Just for the fun of it, retro home computer collector

BORDER VARIATION - OUTER TO INNER

Hier een kleine variatie op de eerder gemaakt one-liner om een border te creeeren op het scherm met enkel het Basic print commando.

!- {166} - checkerboard character !- {19} - cursor home !- {157} - cursor left !- {17} - cursor down !- {148} - insert mode !- {145} - cursor up !- {29} - cursor right !- readable version (vice formatted) !- ------------------------------------------------- 100 c=0 110 poke 646, rnd(.)*255 120 print"{19}";:if c>0 then for i=1 to c:print"{29}{17}";:next 130 for i=1 to 40-(2*c) : print "{166}";:next i 140 print "{157}"; 150 for i=1 to 24-(2*c) : print "{166}{157}{17}";:next i 160 if c=0 then print "{157}{20}{29}{20}{29}{166}{157}{148}"; 170 if c>0 then print "{166}"; 180 for i=1 to 39-(2*c):print"{157}{157}{166}";:next 190 for i=1 to 24-(2*c):print"{145}{157}{166}";:next 200 c=c+1:if c=12 then 100 210 goto 110

BORDER DEMO IN BASIC

Op Faceboek volg ik een aantal groepen waarin verschillende onderwerpen van Commodore besproken worden. Eén van deze groepen is "Commodore 64 Basic".

Zo nu en dan is daar een basic programmeer challenge, leuk om daar je hersenen eens op te breken.

Dit keer een uitdaging om een oneliner te schrijven waarbij een character in de border van het scherm moet worden geschreven, zonder gebruik te maken van poke commando's dus enkel print.

Er waren wat voorbeelden en uitdaging was een kortere versie te maken. Mijn versie is niet korter (hoewel nog steeds in één regel) maar is wel enkel volledig met print commando's.

Hier de code zoals in het formaat van CBM-studio:
0fOi=0to24:?"{166}":nE:fOi=0to37:?"{166}";:nE:?"{157}{148}{166}{148}{166}{19}";:fOi=0to39:?"{166}";:nE:fOn=0to22:?"{157}{17}{166}";:nE 1 goto 1

CREATING A REAL MAZE

This time a basic program creating a reals maze. So there will be one opening at the top and one exit on the right side at the end of the maze generation.

A full explenation of the maze code can be viewed on my Youtube channel Open link

The code can be downloaded Open link

10 PRINT - DRIP LIKE THE MATRIX

Here you can find an alternative method of filling the screen with the famous maze characters on the screen. Well known under "10 print". I created two version of the program. One shortened as much as possible (I think).

That results also in the most unreadable code. The second a bit more elaborated version.

1 printchr$(147):dim c(40):dim u(40):cm=55296:sm=1024 2 i=int(rnd(1)*40):d=int(rnd(1)*10):fOn=0tod:ifc(i)<=24tHc(i)=c(i)+1 3 pOsm+i+(c(i)-1)*40,77+int(rN(1)*2):ifc(i)=24aNu(i)=0tHu(i)=1:s=s+1:ifs=40tHeN 4 nextn:l=c(i):dc=0:ifl>24thendc=1 5 fOm=0tol-1:mp=i+m*40:pOcm+mp,dc:pOsm+mp,81:pOsm+mp,77+int(rnd(1)*2):nEm:gO2

In the second version, with the same result, each part is explained in more detail and therefore also easily be modified to your own liking.

The second version can be downloaded directly from my github location here
Open link

LARGE CHARACTERS IN BASIC

In this example I read the character rom defintions to display the characters in an enlaged shape of it.

100 printchr$(147):dim cr(5) 110 poke56334,peek(56334)and254:poke 1,peek(1)and251 120 mg$=" just":gosub 200:mg$="for":gosub 200:mg$=" the":gosub 200 121 mg$="fun":gosub 200:mg$="of it":gosub 200 130 poke 1,peek(1)or4:poke56334,peek(56334)or1 140 goto 110 200 fori=1tolen(mg$):cr(i)=asc(mid$(mg$,i,1))and191:nexti 210 for r = 0 to 7 220 for c = 1 to len(mg$) 230 a=peek(53248+cr�*8+r) 240 for n=7 to 0 step-1:b(n)=int(a/2^n):a=a-(b(n)*2^n):next n 250 fort=0 to 7:print mid$(" "+chr$(113),1+b(7-t),1);:next t 260 next c : if len(mg$)<5 then print 270 next r : return

CREATING THE MAZE ALTERNATIVE

This is an alternative I created for displaying a maze on the screen.

10 rem -- www.justforthefunofit.nl -- 20 rem creating a maze using a 30 rem circle method to fill the screen 40 rem -------------------------------- 50 print chr$(147) 60 for r=1 to 24 70 for a=0 to 360 80 y=(int(r*cos(a))+12) 90 x=int(r*sin(a))+20 100 rem correcting screen bouderies 110 if y < 0 then y=0 120 if y > 24then y=24 130 if x < 0 then x=0 140 if x > 40then x=40 150 poke 1024+y*40+x,77+int(rnd(1)*2) 160 next a,r

FLIPPING OR MIRRORING A BYTE VALUE USING BASIC CODE

Een kort Basic programma dat ik hier toon en gemaakt heb is ene programma om een de bits in een byte te spiegelen of te inverteren.

Deze techniek is een voorbereiding op een later geschreven programma om sprites te spiegelen en te inverteren.

De basis is de zogenaamde low-bits van een byte te wisselen met de high-bits en omgedraaid.

En wel als volgt:

Als een bit waarde "1" is in een byte, zet dan de tegengestelde bit op "1".

Als vorbeeld als de hoogste bit de waarde "1" geeft zet dan de laagste bit op waarde "1"

Ik heb een aantal verschillende versie om dit te bereiken hier onder weergegeven. Resultaat is het zelfde, maar aantal regels of de snelheid verschillen.

De meest recht toe recht aan oplossing (en tevens de snelste)

10 b = int(rnd(1)*255) : r=. 20 if b and 1 then r=128 30 if b and 2 then r=r+64 40 if b and 4 then r=r+32 50 if b and 8 then r=r+16 60 if b and 16 then r=r+8 70 if b and 32 then r=r+4 80 if b and 64 then r=r+2 90 if b and 128 then r = r +1 100 print "reversed :" r

Een tweede methode die gebruik maakt van machtverheffen, is wel elegant, maar machtsverheffen is een 'dure' reken operatie en dus een stuk langzamer.

10 b = int(rnd(1)*255) : for n=0to7 20 if b and 2^n then r = r+2^(7-n) 30 next : print "reversed :" r , r$

Een dan nog een derde methode waarbij we de bewerking niet doen met getallen, maar door de waarde in een string om te zetten en deze dan te spiegelen met string functies.

10 b=int(rnd(1)*255) 15 r=. :b$="00000000":r$="00000000" 20 if b and 1 then r=128:r$="1"+mid$(r$,2,8) 30 if b and 2 then r=r+64:r$=mid$(r$,1,1)+"1"+mid$(r$,3,8) 40 if b and 4 then r=r+32:r$=mid$(r$,1,2)+"1"+mid$(r$,4,8) 50 if b and 8 then r=r+16:r$=mid$(r$,1,3)+"1"+mid$(r$,5,8) 60 if b and 16 then r=r+8:r$=mid$(r$,1,4)+"1"+mid$(r$,6,8) 70 if b and 32 then r=r+4:r$=mid$(r$,1,5)+"1"+mid$(r$,7,8) 80 if b and 64 then r=r+2:r$=mid$(r$,1,6)+"1"+mid$(r$,8,8) 90 if b and 128 thenr=r+1: r$=mid$(r$,1,7)+"1" 100 print "reversed :" r , r$

BASIC CODE - BREAKOUT

Om weer een beetje terug te komen in het programmeren op de Commodore dit keer eens een eenvoudige versie gemaakt van het bekende break-out spel.

Extra uitdaging; Kan het in maximaal 10 regels toch een speelbaar versie te maken ? Natuurlijk zal het géén top spel worden, maar toch voldoende onderdelen erin om het echt speelbaar te maken.

- de kleurenbalk bovenin
- stuiterende bal
- een 'paddle' om de bal terug te spelen
- uiteraard een iets om de score bij te houden

Met deze uitgangspunten ben ik aan de slag gegaan. Onder eerste de lange versie met commentaar en leesbare coden. Daarna een versie ingekort met alle afkortingen en zonder commentaar teksten.

Uiteraard is ook deze versie te downloaden op mijn Github.

De paddle kan met de toets "1" en "2" heen en weer bewogen worden.

100 rem --------------------------------------------- 110 rem initialization of variables 120 rem --------------------------------------------- 130 pp=17: rem paddle start line on screen 140 sm=1024: rem screen memory start 150 sa=sm+(22*40): rem screen boundary adress range 160 dx=1:dy=1: rem initial direction of bouncing ball (positive) 170 x=int(rnd(1)*24):y=12: rem ball start position with random x position 180 c$=chr$(28)+chr$(149)+chr$(158)+chr$(30)+chr$(31) : rem define color values 185 1 = 1 : rem used to reverse ball on missed and last key direction 188 h = 0 : rem hit score variable 190 rem --------------------------------------------- 200 rem initialisation of screen start and color 210 rem --------------------------------------------- 220 poke 650,128 : rem set key input on repeative 230 poke 53280,0 : rem screen border color to black 240 poke 53281,0 : rem screen color to black 250 print chr$(147): rem clear screen and cursor to top 260 rem ---------------------------------------------- 270 rem draw five color lines with eight bars 280 rem ---------------------------------------------- 290 print : rem print blanco screen line on top 300 for p=1 to 5: 310 for n=1 to 8 320 print chr$(18)+mid$(c$,p,1)+chr$(229)+" "+chr$(234); 330 next n 340 next p 350 rem ---------------------------------------------- 360 rem start main loop (paddle and bouncing ball) 370 rem ---------------------------------------------- 380 sp=sa+pp : rem calculate start position of paddle 390 rem ---------------------------------------------- 400 rem poke the paddle characters into memory on calculated position 410 rem start and end with space (32) to clear previous on movement 420 rem ---------------------------------------------- 430 pokesp,32:pokesp+1,98:pokesp+2,98:pokesp+3,98:pokesp+4,98:pokesp+5,32 440 rem ---------------------------------------------- 450 rem get input (key "1" = left, key "2" = right 460 rem ---------------------------------------------- 470 getk:pp=pp+(k=1)-(k=2) 480 rem ---------------------------------------------- 490 rem validate boundaries' to ensure new position is within play area 500 rem ---------------------------------------------- 510 if pp<-1 then pp=-1 : rem reset pebble position to min -1 520 if pp>35 then pp=35 : rem reset pebble position to max 35 530 rem ---------------------------------------------- 540 rem clear current bouncing ball position and calculate new 550 rem ---------------------------------------------- 560 pokesm+x+(y*40),32: 570 if y>=24 or y<1 then dy=-dy : rem reverse y on boundary 580 if y>=24 then ms=ms+1 : rem count missed if y below pebble 590 if x>=39 or x<1 then dx=-dx : rem reverse x on boundary 600 if k=1 then mc=-mc : rem direction correction on hit and last key 610 x= x+dx : y= y+dy : rem new ball x,y coordinate 620 rem ---------------------------------------------- 630 rem validate hit pebble on hit count and shift to pebble position 640 rem ---------------------------------------------- 650 if peek(sm+x+(y*40))=98 then dx=-dx*mc:dy=-dy:h=h+1:x=pp 660 poke sm+x+(y*40),81 : rem poke new ball position on screen 670 print chr$(19)"hit:";h;" missed:";ms : rem rewrite score on screen 680 goto 380 : rem restart main loop

BOUNCING BALLS - COMMODORE BASIC

01-2022 - Dit keer een echte klassieke Commodore Basic miniatuur "De stuiterende bal". Ik denk dat deze klassieker een van de basisprogramma's is waarvan ik, toen ik er voor het eerst een versie van zag, denk ik bijna 38 jaar geleden (mmm ben ik dat echt...), wilde weten hoe een bal zomaar rond kon stuiteren. Als klein puzzelmoment vandaag heb ik geprobeerd een versie ervan na te maken zoals ik het me herinner, zie het resultaat. Laat me eerst de code laten zien voor de meest klassieke: de enkele bal die heen en weer op het scherm stuitert. Ik heb geprobeerd de code schoon en eenvoudig te houden.

Eerste versie:

10 printchr$(147):poke214,24:print:poke211,10:print"single bouncing ball" 20 sm = 1024:x=int(rnd(1)*24):y=1:dy=1:dx=1 30 poke sm+x+(y*40), 32 40 if y>=22 or y < 1 then dy=dy*-1 50 if x>=39 or x < 1 then dx=dx*-1 60 x=x+(1*dx):y=y+(1*dy):poke sm+x+(y*40),81:fors=1to100:next: goto 30

Tweede versie:

10 printchr$(147):poke214,24:print:poke211,10:print"line bouncing ball" 20 sm = 1024:x=int(rnd(1)*24):y=1:dy=1:dx=1 30 if y>=22 or y < 1 then dy=dy*-1 40 if x>=39 or x < 1 then dx=dx*-1 50 x=x+(1*dx):y=y+(1*dy):poke sm+x+(y*40), 81 :fors=1to100:next: goto 30

Derde versie:

10 printchr$(147):poke214,24:print:poke211,8:print"pattern bouncing ball" 20 sm = 1024:x=int(rnd(1)*24):y=1:dy=1:dx=1 30 poke 55296 +x+(y*40), 5+dy : rem swap between green en screen blue 40 if y>=22 or y < 1 then dy=dy*-1 50 if x>=39 or x < 1 then dx=dx*-1 60 x=x+(1*dx):y=y+(1*dy):poke sm+x+(y*40), 81 :fors=1to50:next: goto 30

BASICCODE GAME - PATTERN MATCHING

2022 - Nadat ik aan verschillende oneliner-programma's had gewerkt, wilde ik een klein basisspel maken. De uitdaging is om een idee te vinden dat niet te complex is, maar ook enkele uitdagingen heeft en ook een eenvoudig spelconcept.

In eerste instantie speelde ik gewoon met wat code om te zien hoe ik enkele eenvoudige rechthoeken op het scherm kon tekenen. Toen schoot mij een idee te binnen. Het idee was eenvoudig en als volgt:

kan ik blokken met een bepaald patroon op het scherm maken waarin een gebruiker naar gelijke patronen moet zoeken.

Vanuit dit idee heb ik een beetje op mijn iPad getekend en het teruggebracht naar het volgende:

Het programma genereerd een matrix van een aantal rechthoeken op het scherm, bijvoorbeeld 16
gebruik een karakter met een willekeurig patroon
de kleur en karakters zorgt ervoor dat ze allemaal verschillend zijn.
Selecteer vervolgens twee willekeurige blokken in deze matrix markeer het tweede blok
kopieer het patroon van het eerste naar het tweede (alleen de kleur) (het tweede omdat het veranderen van de kleur anders beide blokken zou onthullen (omdat het proces in Basic code te langzaam is en ander al zichbaar is voor de speler)

Oké, begin nu met programmeren, testen en probeer het zo lean en mean mogelijk te houden, dus eerst het concept zonder input, output, eventuele gebruikersinvoer of score.

Dan het resultaat:

Vervolgens kan de gebruiker zien welk blok en patroon gelijk is aan het gemarkeerde. Na het indrukken van een toets wordt het antwoord onthuld.

Dan de spelcode. Deze code kan rechtstreeks naar de VICE Commodore 64-emulator worden gekopieerd als je er een beetje mee wilt spelen.

10 rem pattern matching concept game 20 rem initialize size and start position 30 dim bp(16) 35 printchr$(147):ai=1:sm=1024:cm=55296:r=4:c=4:w=4:h=3:sp=(6-w)+((6-h)*40) 50 rem draw a matrix of random blocks 100 for b=0 to r-1:for i=1 to c:for l=0 to h:for p=0 to w 130 o =(i*(w+2))+sp+p+(40*l)+(40*b*(h+2)):pOsm+o,102:pOcm+o,int(rnd(1)*4) 150 next p,l:bp(ai)=o:ai=ai+1:next i,b 200 rem random selections of which blocks to equalize 210 f=int(rnd(1)*16)+1: s=int(rnd(1)*16)+1:if f=s then goto 210 250 rem mark first block 270 tl=f:gosub 800:co=1:rem gosub 400 :rem only for debug 280 rem copy color to second block and mark block 310 tl=s:gosub 800:co=3:gosub 400 :gosub 600 320 rem end of program 325 poke214,22:print:poke211,5:print"press a key to see the answer" 340 poke 198,0: wait 198,1 : rem wait on key pressed 350 rem disclosure other block 360 tl=f:gosub 800:co=1:gosub 400 362 poke214,22:print:poke211,5:print"press a key to play again" 365 poke 198,0: wait 198,1: goto 35 :rem again again 370 end 400 rem mark a tile use passed tile id 410 for m=0 to w+2:pokesm+lc-1+m,67:pokecm+lc-1+m,co:next m 420 for m=0 to w+2:pokesm+bc-1+m,67:pokecm+bc-1+m,co:next m 430 for m=0 to h+2:pokesm+lc-1+(m*40),66:pokecm+lc-1+(m*40),co:next m 440 for m=0 to h+2:pokesm+lc+w+1+(m*40),66:pokecm+lc+w+1+(m*40),co:next m 450 pokesm+lc-1,85:pokesm+bc-1,74:pokesm+lc+w+1,73:pokesm+bc+w+1,75 500 return 600 rem copy tile colours to from first to second tile 610 tl=f:gosub 800:fc=lc:tl=s:gosub 800 620 for i=1 to h+1:for j=0 to w: poke cm+lc+j+(i*40),peek(cm+fc+j+(i*40)) 650 next j,i : return 800 rem set determine left corner en bottom corner 810 lc = (bp(tl)-((h+1)*40)-w): rem left corner top 820 bc = (bp(tl)-w)+40: rem bottom corner 830 return

BASIC CODE - GEOMETRIC PATTERNS

This I found on the internet ( here) from basic-fieserwolf (Needed to google a bit how to type the "Pi" character in Vice. (ctrl+page-down, in low character mode) just that you know it. So you can shorten it to one-line is you use the Petscii characters.

Here the code using the chr$ values instead of the petscii chars to be able to show it here.

1forx=0to39:a=cos(x/3.14/2)+cos(y/3.14/2)and15 2 poke646,a+9:printchr$(18)+chr$(a+190); :next: y=y+1:goto1

BASIC CODE - CHRISTMAS TREE

Just a for the fun of it. This is one of the first basic lines that I type on the commodore after starting it up after almost 40 years.

1?chr$(147):k$="":b$="":s$=" ":fort=1to10:k$=k$+"*":b$=b$+"**" 2?s$+k$:?left$(s$,len(s$)-t)+b$:next t:?left$(s$,len(s$)-1)+"***"

BASIC CODE - DRAW SINUS WITH CHARACTERS

I created this oneliner after I saw a demo on a plot function added to the Basic interpreter. I was thinking this is something I needed to try just using the standard functions.

To have more understanding on the oneliner I also have the more readable version here that can be copied directly into the vice commodore emulator if you want.

10 for n=0 to 3*3.1415step0.05 20 x=int(4.2*n):y=int(12*sin(n)) 25 o=y*40+x+(12*40):poke1024+o,81:poke55296+o,1 30 next n

The actual one-line miniature Basic code as typed in on the commodore could just fit in oneline using the petcii characters.

BASIC CODE - LASER BARS

This oneliner shows the use of the screen memory and color memory in combination with the poke command to put a character and color on a certain location on the screen. The position is calculated from top to bottom. This is all done in just one single line of code. This is done by entering the commands using the shortcodes as mentioned before.

1fOc=0to39:l=rN(1)*24+1:fOx=0tol:pO1984+c-40*x,97:pO56256+c-40*x,l:nEx,c:gO1

BASIC CODE - SNAKE USING PETCII CHARACTERS

Zo weer een lekker aan het spelen met petscii characters en de random functie in Commodore Basic.

Onderstaande code kan passend gemaakt worden op één regel, maar hier voor de leesbaarheid gemaakt met het chr$ commando.

Deze kun je vervangen door de overeenkomstige Commodore characters.

0 c$=chr$(145)+chr$(157)+chr$(29)+chr$(17):print chr$(147) 1 printchr$(113)+chr$(157);:fort=1to50:next:poke646,rnd(.)*256 2 print chr$(18)+" "+chr$(146)+chr$(157)+mid$(c$,rnd(1)*4+1,1);:goto1

Onderstaand de weergave als one-liner

BASIC CODE - MAZE ONELINER

Dit is echt de meest beroemde one-liner die je maar kunt vinden.

Er zijn vele variaties gemaakt ook op verschillende computers, maar van deze is zelfs een heel boek met onderbouwing gemaakt.

Kijk daarvoor maar eens op de site https://10print.org/

10 print chr$(109+int(rnd(1)*2));:goto 10

BASIC CODE - PIXELSCROLL COMMODORE 64 SCREEN

Een kort programma om het basic commando "wait" nog eens te demonstreren in combinatie met het vic register 53265 om het scherm in pixels te scollen.

10 ?chr$(147):poke53280,6:poke53281,1:for l=1024to2023:pokel,123:nextl 30 forl=0to7:wait53265,128:poke53265,(peek(53265)and240)or7-l:poke53270,l:next 40 goto 30

BASIC CODE - SIMPLE DEMONSTRATION OF COLOR BARS

Een one-liner die de 16 kleuren die mogelijk zijn op de commodore in kleurige horizontale balken op het scherm toont.

10forx=.to15:poke646,x:fory=.to39:printchr$(18)+" ";:nexty,x

BASIC CODE - TEXT SCROLLER

Met dit Basic programma van twee regels code kun je een stuk tekst van links naar rechts laten scrollen op het scherm.

Niet echt smooth scroll, maar toch leuk om het gebruik van de peek en poke commando's te demonstreren.

10 ?chr$(147);:r=10:poke214,r:?:poke211,0:?"just for the fun of it" 20 poke1103+(r*40),peek(1064+(r*40)):poke214,r:?:poke211,1:?chr$(20) 40 for j=0to50:next:goto 20

BASIC CODE - COLOR BORDERS

Zelfs in standaard basic met enkele poke commando's en het wait commando is het mogelijk om de border van het scherm in verschillende kleuren te verkrijgen.

Dat is precies wat dit programma in één regel doet.

0 q=53265:w=128:b=53280:wAq,w:pOb,1:pOb,2:pOb,3:pOb,4:pOb,5:pOb,6:gO0

BASIC CODE - A NICE FLOWER

Naast het spelen met kleurige lijnen nu ook eens aan de slag met circel vormige figuren.

De cos functie en gebruik van petscii characters maken het in het begin erg vierkant en traag, maar met een beetje geduld zie je toch een circel vormig figuur onstaan.

En dat alle met slechts één regel Basic code.

1?cH(147):fOr=1to12:fOa=0to360:o=(int(r*cos(a))+12)*40+int(r*sI(a))+20 2:pO1024+o,81:pO55296+o,r:nEa,r:wait653,2

BASIC CODE - A SMALL 10 LINE CODE PROGRAM

Geinspireerd door de Mondriaan schilderij de "bogie woogie" heb ik na wat spelen met kleuren en petscii codes dit Basic programma geschreven.

Geen enkel bijzonder doel dan enkel leuke kleurige figuren met petscii tekens op het scherm plaatsen.

In het programma wordt gebruikt gemaakt van enkele lijn vergelijkingen en random functies.

10 ?chr$(147):c$="026":poke53281,1:poke53280,0 15 s$=chr$(161)+chr$(162)+chr$(169)+chr$(182)+chr$(127)+" " 20 poke214,(rnd(.)*22):?:poke211,(rnd(1)*40):?mid$(s$,int(rnd(1)*6+1),1) 30 poke646,val(mid$(c$,int(rnd(1)*3+1),1)): goto 20

BASIC CODE - FULL ARCADE IN A ONELINER

Dit is wel een bijzonder one-liner. Het heeft een paar elementen die ook in de vliegende vogel voorkomt.

Ik was op zoek naar verschillende one-liners om wat ideeen op te doen en kwam deze tegen op het web (oneliner64.com). (note: deze site is echter sinds kort weer offline).

Het is een volledig speelbaar spel waarbij je met een ruimteschip (met een beetje fantasie dan), de sterren moet ontwijken.

De besturing gaat met de toetscombinatie "1" (links, en "9" voor rechts).

Het is wel een master-piece tussen de one-liners. Onder de versie die je direct in Vice kunt plakken om uit te proberen.

1?tArN(0)*39)"*":gEk:p=p+(k=1)-(k=9):pO1284+p,22:onp<420aN(pE(1324+p)=42)+2gO,1

BASIC CODE - BIRDS CAN FLY ONELINER

Dit is een bijzondere one-liner. Het is een vliegende vogel opgebouwd uit enkele petscii characters die heen en weer bewogen kan worden met de "1" en "2"-toets.

Het is helaas niet mogelijk hier in de tekst de juiste codes van commodore te tonen.

In onderstaande code moet je dan ook de "S" vervangen door een Petstcii code op de commodore. Dit kan door de toetscombinatie
({shift{+{home} keys) , dat is de clearscreen character (ofwell het hartje).

0gEk:p=p+(k=1)-(k=2):pO214,10:?:pO211,20+p:?mI("JWKUWI",x+1,3):x=3-x:?"S":gO0

Bovenstaande code kun je wel in eenkeer knippen en plakken in de Vice emulator. Of download de versie vanaf mijn GitHub.

MAKING WAVES - ONLINER

Dit voorbeeld behoord wel bij de set van meest bekende one-liner programma in Basic op de commodore 64.

Iedere commmodore startende gebruiker heeft deze denk ik wel eens in zijn jeugd geprobeerd.

Dit programma geeft de illusie van golvend water.

10 print "------------"; :goto 10