Purpose of this ebook Background history with computers Passion for programming My experience with the Commodore 64

Transcription

1

2 Table of Contents Introduction: About the author Purpose of this ebook Background history with computers Passion for programming My experience with the Commodore 64 Chapter 1: Memory Where in memory to write your game The difference between page 0 and other memory addresses The accumulator Understanding high and low bytes Some important memory locations Understanding high and low byte loops Chapter 2: Graphics ASCII graphics Screen color memory Hi-resolution graphics Commodore 64 sprites Game sprites Loading the game sprites in memory Moving the sprites Moving a sprite in Assembly language

3 Finding the MSB (Most Significant Bit) Sprite passed beyond 255 th position What is multicolor? Understanding character sets Chapter 3: Animation Animating ASCII characters Animating sprites Chapter 4: Joystick (device) What is a joystick? How to read joystick values Moving a sprite with a joystick Chapter 5: From Basic to Assembly Language Basic vs. Assembly Language (speed advantage) Converting Basic code into assembly language Understanding PEEKs and POKEs Converting DATA statements into machine language Opcodes Chapter 6: Getting started with Assembly language Simple addressing Absolute addresses Direct/indirect addresses Understanding labels Chapter 7: Understanding accumulator commands

4 LDA (Load the Accumulator) STA (Store the Accumulator) PLA (Pull from the Accumulator) Chapter 8: Loops/Branches (X/Y index registers) FOR NEXT vs. Assembly language loops What is LDY, LDX? What is INC, DEC? What is BEQ, BNE, BCS, BCC? Creating delay loops Chapter 9: Conditions Difference between Basic IF and Assembly language IF What is CMP? What is CPX? What is CPY? Chapter 10: Math How the Commodore 64 computes Math How the ADD statement works How the SBC statement works How the ASL statement works How the LSR statement works Chapter 11: Bytes What is a byte? How a byte is stored High/Low bytes

5 Using page 6 to store Hi/Low bytes The famous registers: Chapter 12: Jumping in memory (GOTO/GOSUB) Basic vs Assembly language (GOTO vs. JMP) Jumping around in memory o JMP (Jump to memory address) o JSR (Jump to Subroutine, with Return) o Avoid jumping over the 256 byte range Chapter 13: Explanation of the Spaced Out game Overview of the game Breaking it down line by line Chapter 14: Secrets to game design Building room upon room Using flags Character set (redefining) Chapter 15: Where to go from here? The imagination has no limit Going above and beyond

6 Introduction Purpose of this ebook The purpose of this ebook is to show you how my Assembly language game Spaced Out was developed. Please note however this book is not meant to teach you how to write in Assembly language, but will show you how to make the transition from Basic to Assembly language somewhat less complicated. I still highly recommend becoming quite fluent in Basic before writing in assembly language since Basic is easier. I decided to create this ebook due to the large demand from my YouTube subscribers. I figured finally condensing my knowledge into a book should fulfill the purpose of sharing my love of assembly language. The best way to understand assembly language though is to refer to a good book on beginning assembly language. This ebook is not meant to make you an expert on assembly language. Rather it has been created to assist people with a flow process of translating Basic to Assembly language. Background history with computers I got my first real experience when I purchased a Commodore 64 back in I was first convinced about the marvel of this machine when I had a neighbor invite me to his house where he showed me the new computer system his parents got him. At the time, I only owned an Atari 65xe personal computer. I ll never forget the first game he loaded in called Ghostbusters. I was instantly noticed that this machine rivaled the computer I already had. My friend also showed me some Commodore 64 Basic then. I noticed he wasn t a programming due to the constant SYNTAX ERROR messages he created on the screen. However I had already written a few programs on my Atari and was ready to take the plunge into the Commodore 64.

7 Passion for programming My passion with programming originally began on the Atari 65xe system back in 1988, but I was so ready to begin the transition to the Commodore 64 with confidence. I gained a lot of experience in those days by visiting the public library and checking out every programming book I could find from Compute!s books, magazines, and many random books showing simple Commodore 64 programs. My experience with the Commodore 64 The experience I have developing on the Commodore 64 is largely due to the time I spent programming my Atari 65xe system. I had already a firm grasp on Basic at the time and later taught myself assembly language on the Atari computer. It wasn t long after that when I purchased the C64 Assembler diskette and began writing my first Commodore 64 assembly language programs. This lesson will also introduce you to some of the basics of game design. It is my sincere hope and desire that this ebook will help you ascend your knowledge of the Commodore 64 and soon have you developing your next greatest arcade hit! I wish you the best.

8 Chapter 1: Memory Where in memory to write your game Knowing how memory is organized on your Commodore 64 will help you decide the best place to store your program. Memory on the Commodore 64 can be thought of as bookshelves of how it is arranged. The bookcase can be referred to as the Accumulator and the books are the memory locations. Each of the books represents a different memory locations starting at 0 and ending at The difference between page 0 and other memory addresses Page Zero consists of 256 memory locations from 0 through 255. Each location also stores 255 bytes. A byte is consisted of 8 digits that fit into each memory location. Individual bytes perform their own separate processing for example memory location 203 is used to check which key is being pressed. When read into memory it scans the keyboard looking to see which key is held down. Example: 10 VL=PEEK(203) 20 PRINT VL 30 GOTO 10 Memory locations contain the Microprocessor Stack area which is called Page 2. Page 3 is stored through locations range from Then there is memory from known as the video screen memory. The Basic code occupies memory from The character ROM image for the VICP II Chip is in locations Basic s ROM is contained in locations There is a 4k (4 thousand) block of memory held in locations This is where a lot of the real action in game design relies upon to produce colors,

9 sprites, etc. The system kernel ROM uses 8,000 memory locations to keep track of input and output operations found in I have discovered that a safer area of memory when using the C64 Assembler is found at This area is where Basic normally resides. It also far enough away from the character set and prevents having to move things around. Page 0 uses memory locations from These can be used to move memory around creating short loops, set flags, and many for many other things. I used these to clear a section of sprite memory in my Spaced Out game demo. The advantage to using page 0 locations is that there is nothing going on in the accumulator with these registers that will affect your source code. They have been used countless times by programmers to store high and low memory addresses. The accumulator There is a busy section in your Commodore 64 known as the Accumulator. The Compute! book Machine language for Beginners uses an example of a post office that has to deliver mail to 65,536 customers. These customers are referred to as memory locations (or addresses). Each of these houses have special uses such as timers, input/output, sprites, graphics, storing your Basic program, managing interrupts, etc. Some houses don t receive mail since mail doesn t deliver there. That is an example of ROM( Read Only Memory), which basically means you can t write a value there. Understanding high and low bytes Your computer is not only made up of tons of memory locations (a.k.a registers), but it also uses math to calculate moving memory beyond a 256 byte limit. This is because bytes can only access 256 bytes at a time. Here is an example taken from the Spaced Out game CLRMEM 4980 LDA #64 ;(8 *256)=2048+(64) = STA 251

10 5000 LDA # STA LDA # LDX # DY LDY # DS STA (251), Y 5060 INY 5070 BNE DS 5080 INC DEX 5100 BNE DY 5110 RTS Pay special attention to the comment at line It says (8 *256)=2048+(64) = This is showing you how the accumulator calculates a memory location beyond a 256 byte range. It is broken down like this: 4980 LDA #64 ;low byte (64) 4990 STA 251 ;stored in page 0 location LDA #8 ;high byte (8) 5010 STA 252 ;stored in page 0 location 252 So the 251 will store the low bytes and the 252 is used to access the next highest byte. This is also known as zero page addressing. Now we use 256 multiplied by the high byte and return that result which is Then the accumulator simply

11 adds the low byte of 64. Just think of your basic math class and remember to Please Excuse my dear aunt Sally. So literally speaking that means that math is calculating using Parenthesis, Exponents, Multiplication, Division, Adding, and Subtraction (PEMDAS). The key here is to remember that the parenthesis or () are computed first. Then the calculation resumes using the remaining operators. Some important memory locations Some of the most important memory locations found in my game demo are (sprite data pointers), (sprite positions), (Most Significant Bits for sprites 0-7), (Sprite enable), (sprites 0-7 vertical size), (sprite multicolor), (sprites 0-7 horizontal size), (sprite collisions), (sprite foreground collisions), (border/background colors), (sprite multicolor registers), (sprite colors), (sound), etc. Understanding high and low byte loops The rest explained Pay attention to the rest of the code below. I will explain how it works LDA # LDX # DY LDY # DS STA (251), Y 5060 INY 5070 BNE DS 5080 INC DEX 5100 BNE DY

12 The first line is used to store a 0 in the accumulator. Then a loop is created to address 6 pages using LDX #6. This means to start the X register at the value of 6. The next line starts the Y register at 0. Keep in mind that the X and Y register count up to 255 bytes and then flip back to zero. The next line STA (251), Y begins the processing of storing 0 s starting at memory location So the accumulator now looks like this: Memory location value X reg Y reg (count up to 255 or Y= Y + 1 or INY) Remember at this point that the LDY #0 is using INY (increment the Y register) to count as Y = Y + 1:0020IF Y>255 THEN Y=0. The BNE (Branch Not Equal) will allow the Y register to count in a loop until it reaches 255. Once this finishes the next lines are executed: 5080 INC DEX 5100 BNE DY We have now incremented the value found in memory location 252. Remember that we originally used LDA #64 STA 251. So the line INC 252 will now increase the value found there by 1 byte, which means it will contain a 65. Just take 64+1 = 65. The next instruction says DEX (Decrement the X register). So originally the X register was 6 (LDX #6). Now it will contain a 5. The BNE DY will jump all the way back to the line that shows 5040 DY LDY #0 to zero out the Y register once more.

13 We do this since after 256 bytes have incremented (Y = Y +1 example), we have flipped to the next highest byte at location = To get to that byte we have to flip the Y back to zero. Here s the calculation for that: = So the next byte after 256 is We flip the Y back to zero to address the next 256 pages in memory. I realize this is not easy to grasp. Please understand that if you get this you are now on your way to writing advanced assembly language programs. Here is an example. Memory location value X reg Y reg (count down from 4 or X= X - 1 or DEX) = = LDX #3 until we get to the last part LDX #0. Please note I have not tested these values for accuracy so I may be off on the math, but I can nearly guarantee you that the processing is on key.

14 I would suggest writing out the rest if you can so you can grasp it even further. The rewards will be you will soon learn how to copy memory and move it around. This is common in memory relocation and when moving ROM (Read Only Memory) to RAM (Random Access Memory)

15 Chapter 2: Graphics ASCII graphics How graphics work on your Commodore 64. Many Commodore 64 keyboard characters can often be seen embedded at the side of each key. These are known as ASCII (American Standard for Information Interchange) and contain characters from (or a grand total of 256 characters). Screen color memory Your Commodore 64 also utilizes memory to set color points for each character placed in memory locations This is actually known as Color RAM. It can display any ASCII character in 16 different foreground colors (which includes black). Here is an example: POKE 1024,65: POKE 55296, 2 This will plot the A alphabetic character to the top left of your screen and fill it with a red color. Try changing the 65 to another number to see what you get. Then change the color. Here is a list of what each color stored currently in memory location above shows: 0 = Black 1 = White 2 = Red 3 = Cyan 4 = Purple 5 = Green

16 6 = Blue 7 = Yellow 8 = Orange 9 = Brown 10 = Light Red 11 = Dark Gray 12 = Medium Gray 13 = Light Green 14 = Light Blue 15 = Light Gray

17 ASCII characters can be placed side by side to create graphic designs. The Commodore 64 is popular for creating software that cleverly utilizes these characters by lining them up side by side to create a whole picture. There was a Christmas demo to promote the Commodore 64 that used a few sprites and all ASCII characters to create an impressive scene. It used sprite animation to fly Santa across the sky, raster interrupts to create an amazing blizzard, and the ASCII characters made up the city. The amazing thing also is that this demo was written in assembly language. Now you can see what is possible once you learn how to write your own programs. High-resolution graphics Creating high resolution graphics (bitmap mode) on your Commodore 64 though is a little more complex. A bitmap mode is 320 pixels across by 200 pixels high. Memory location must be set to 5 to enable this mode (POKE 53265, PEEK(53265). It can occupy up to 8192 bytes on the screen. Each byte uses four bits that can be set to its own color. The only drawback is that using a bitmap graphics mode can really put a drain on your computer s memory since it takes up

18 so much space. For this example, I will not go into any more detail since my game demo does not utilize bitmap modes. Commodore 64 sprites In the game Spaced Out, I used several sprite images to reproduce the Pitfall Harry character and several images to create the phaser fire. The Commodore 64 system can display up to 7 sprites. Anything beyond these requires using raster interrupts. The sprite characters contain a width of 24 dots in length by 21 dots in height. Each sprite shape is created from 63 bytes of data. To activate a sprite that has been created the system must first enable the sprite and point to the memory address using locations to reference it. Here s a chart to understand this on a more logical level. Sprites can each also contain up to 16 colors individually. Multicolor can be activated to blend colors within the pixels. Sprite location Sprite # Sprite Horz X Sprite Horz Y Color

19 Game sprites Back in the 80s a smash hit Activision game called Pitfall II was developed by David Crane. It used some pretty fascinating sprites. I was pretty impressed by the animation of the Pitfall Harry character that I decided to look up the bytes and implemented it into my game demo. Here is one of the character graphics in that game (not mine). Rather this is used as an example so you can see how sprites are stored in memory. You can also visit my web page here to learn more: It is probably hard to see here in this screenshot, but this sprite contains up to 64 dots (0-63). The asterisks represent the bits that are turned on in the area of memory so we can see the character. Now I will show you step by step how my source code created the sprites you see in the game demo at

20 Loading the game sprites in memory Here is the source code to load the sprites into memory. Now I used locations I was able to alter the Sprite Data Pointer to set a reference to where I copied them in memory. This was necessary to avoid overwriting the character set I created. Code example: 1270 LDX # DWN1 LDA CHAR1, X 1290 STA 2112, X 1300 LDA CHAR2, X 1310 STA 2176, X 1320 LDA CHAR3, X 1330 STA 2240, X 1340 LDA CHAR4, X 1350 STA 2304, X 1360 LDA CHAR5, X 1370 STA 2368, X 1380 LDA CHAR6, X 1390 STA 2432, X 1400 LDA CHAR7, X 1410 STA 2496, X 1420 LDA CHAR8, X 1430 STA 2560, X

21 1440 LDA CHAR9, X 1450 STA 2624, X 1460 LDA CHAR10, X 1470 LDA 2688, X 1480 LDA MISSL, X 1490 STA 2752, X 1500 LDA MISSL2, X 1510 STA 2816, X 1520 LDA PHASRT, X 1530 STA 2880, X 1540 LDA PHASLT, X 1550 STA 2944, X 1560 DEX 1570 BEN DWN1 Now examine the first few lines LDX # DWN1 LDA CHAR1, X 1290 STA 2112, X This sets the X register to 62 since we will be copying bytes of data from The next line DWN1 LDA CHAR1, X is known as Loading the immediate value. The

22 CHAR1, X is used as a vector to point to a memory location that contains the data found in the label called CHAR1. The bytes are where the sprite data is contained at. Any bit other than a 0 means that sprite area is on. The STA 2112, X will store the sprite in memory so it can be seen later once it is enabled. The sprite is also divided into 3 layers containing 8 bytes each. I have divided this for clarity as seen below. Layer 1 Layer 2 Layer 3 CHAR1.BYTE 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0 Moving the sprites Each sprite can move in either a horizontal (left to right) or vertical direction (up to down). Because of the sprite width of 3 across (8 x 8 x 8) = 24, the sprite can have a walking distance from pixels across the screen horizontally. Look at the simple Basic statement below which moves the sprite from 0 to 255 pixel positions. In my game example the sprite can only move up or down between 170 and 230 pixels. Look at the example below.

23 10 FOR X=0 TO 255: POKE 53248, X: NEXT Moving a sprite in Assembly language Here is an example of how the above code might look when converted to Assembly language. MV LDA SPX STA ;POKE 53248,SPX INC SPX ;SPX = SPX + 1 LDA SPX CMP #255 BCC MV ;IF SPX>=255 THEN GOTO MV SPX.BYTE 0 This example will look at the vector in SPX, which is zero. Then it will load that value of 0 into the accumulator (LDA #0). It will then store the sprite s horizontal position in register Then the statement INC SPX will increase the value found there by 1 (SPX = SPX + 1). After this the register is checked with LDA SPX to see the value found there as it is changed. Now it will contain a 2. Next the CMP #255 statement reads Compare the value to see if it is a 255. After this the final instruction of BCC MV reads Branch Carry Clear back to MV. So if the sprite has not yet moved 255 bytes (it is less than 255) then the program will go back to label MV and keep executing the code there (known as a loop). Once the sprite reaches position 255, the code will end. Look at the table below for further clarification.

24 SPX address sprite horiz X (53248) condition Notice that the values of SPX and are changing, but the condition remains the same. A condition value never changes unless you are referencing absolute memory (CMP SPX). The SPX location is changing each time as is location Finding the MSB (Most Significant Bit) When a sprite tries to move to the right more than 255 pixel positions it will reset the accumulator and flip the sprite back to position 0. To continue the sprite smoothly across the screen, we need to access memory location to alter the flag in the accumulator. This will then allow the sprite to proceed through all 512 pixel possible locations on the screen. Examine the code below RGT ;RIGHT ANIMATION 2920 LDA # STA FACE ;FACE= ; 2950 LDA FLAG ;FACING DIRECTION 2960 CMP # BEQ CHKF ;IF FLAG=1 THEN GOTO CHKF 2980 LDA X1 ;IF X1 >=255 THEN GOTO FLIP 2990 CMP #255

25 3000 BCS FLIP IF X1>=255 THEN GOTO FLIP 3010 STA SPRX ;POKE 53248, X JSR PAUSE 3030 JMP OVR 3040 CHKF LDA X CMP # BCS FLIP ;IF X1>=84 THEN GOTO FLIP 3070 STA SPRX ;POKE 53248, X JSR PAUSE 3090 OVR INC PNT ;PNT = PNT LDA PNT 3110 STA PNT 3120 STA SPRPT ;POKE 2040, PNT 3130 LDA PNT 3140 CMP # BCS RSETPT ;IF PNT>=37 THEN GOTO RSETPT 3160 INC X1 ;X1 = X JMP MOVE This code controls the right movement of the sprite. The sprite position is checked to see if it has traveled more than 255 pixels. Look at this line.

26 2980 LDA X CMP # BCS FLIP ;IF X1>255 THEN GOTO FLIP If the sprite has passed beyond 255 pixels then the code will jump to the label called FLIP. Below are examples of Basic and then my assembly language example. 20 X = X IF X > 255 THEN POKE 53264, 1: POKE 53248, 0: FLAG=1 40 IF FLAG=1 AND X<0 THEN POKE 53264, 0: POKE 53248, FLIP 3330 LDA FLAG 3340 CMP # BEQ FXFL ;IF FLAG=1 THEN GOTO FXFL 3360 LDA #0 ;POKE 53248, STA X1 ;X1 = LDA X STA ;POKE 53264, X LDA # STA FLAG ;FLAG= STA FLAG2 ;FLAG2= STA SPRX ;POKE 53248,1

27 3440 JMP JMU 3450 FXFL 3460 JSR RNGCK LDA # STA FLAG ;FLAG= STA FLAG2 ;FLAG2= LDA # STA X1 ;X1= STA SPRX ;POKE 53248, JMU 3550 JMP MOVE Sprite passed beyond 255 th position So here the FLAG is checked to see if we have the MSB set and will jump to label FXFL. If we have already passed the 255 th position then the X1=0 and POKE 53264, 1 will move the sprite to the next horizontal position. Then the variable X1 starts at zero again and increments until we reach the edge of the screen. Finally we get FLAG = 1 and FLAG2 =1 to show we are now using the MSB of location The JMP JMU just keeps the game going back to the main loop. What is multicolor? Hidden deep inside of memory location are the Sprite Multicolor Registers. When you activate the bits stored here you alter pixels colors inside a sprite design. These bits control a double wide pixel of the sprite display. The width of the sprite is reduced to only 12 pixels wide to obtain newer colors. These are known as bit pairs. According to Mapping the Commodore 64 these bit pairs extract their display from the following memory locations:

28 00 Background Color Register 0 01 Sprite Multicolor Register 0 (53285) 10 Sprite Color Registers (53287) 11 Sprite Multicolor Register 1 (53286) Any of the Commodore 64 s seven sprites can contain up to three foreground colors. Look at this example taken from my channel. Here you can see that the sprite is made up of 4 colors. However by utilizing the proper bit pairs you can create colors side by side. Understanding character sets The Commodore 64 system already contains its own character set deep within ROM. If you press the Commodore key and press a key you will see an example of these characters. These are also a part of the ASCII character set. The character set contains up to 256 characters (0-255).

29 Redefining the character set Many of the famous old school Commodore 64 games use what is known as a redefined character set. This involves simply altering the characters to change the pixels within to something rather than the intended design. I have changed the Commodore 64 character set to create the fancy space ship detail in the game Spaced Out. You can see an example below. It is a time consuming processing, but offers some nice eye candy when you take the time to build a good, new character set. How to build your own character set A character set can be redefined by building a simple chart of 8 x 8 on graph paper. Each position you fill in will merge together to form a picture. Look at the example below ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ###### ####### ####### ####### #######

30 Calculating the rows I realize the above example is a silly graphic, but it will be used to show how to build your very first graphic character. Pay attention to the numbers at the top that show 128, 64, 32, 16, 8, 4, 2, 1. These will be used to calculate the bytes within the image to create the character. The rows are calculated from left to right. Look at row 1 (below the numbers). There are no squares filled in so the first row with have a 0 (zero). Look at row 2. The filled in areas are 64, 32, 4, 2. So we simply add these together to get the result: = 102 Look at row 3. The filled in areas are 64, 32, 4, 2. So we simply add these together to get the result: = 102 Look at row 4. The filled in areas are 128, 32, 16, 8, 4. So we simply add these together to get the result: = 188 Look at row 5: The filled in areas are 16, 8. So we simply add these together to get the result: = 24 Look at row 6: The filled in areas are 16, 8. So we simply add these together to get the result: = 24 Look at row 7: The filled in areas are 16, 8. So we simply add these together to get the result: = 24 Look at row 8. There are no squares filled in so the last row with have a 0 (zero).

31 Sum these together are here are the results: Row bytes result = = = = = = = = 0 Basic example to transfer a character set from ROM to RAM Here is a simple example in my Commodore 64: Basic/Assembly games (91-93) that redefined a character set to produce a platform example. 10 CM=12288: CX=53248: GOSUB POKE 53272, (PEEK (53272) AND 240) OR FOR I =12504 TO *6: READ N: POKE I, N: NEXT 40 END 390 PRINT CHR$(147) 400 POKE 781, 10: POKE 782, 6: SYS 65520: PRINT PLEASE WAIT TRANSFERRING SET 410 POKE 56344, PEEK (56344) AND 254

32 420 POKE 1, PEEK (1) AND FOR I=0 TO 1023: POKE CM+ I, PEEK (CX + I): NEXT 440 POKE 1, PEEK (1) OR POKE 56334, PEEK (56334) OR 1: RETURN 460 DATA 0, 0, 0, 0, 0, 0, 0, DATA 253,219,239,255,127,237,233, DATA 65, 126, 66, 66, 126, 66, 66, DATA 0, 42, 28, 62, 28, 42,0, DATA 127,255,239,253,191,247,237, DATA 0, 0, 0, 0, 0, 0, 0, DATA 24, 18, 223, 12, 253, 217, 191, 251 By simply changing one of the DATA statements above to your own design you are on your way to creating your very first redefined character. Assembly language example to transfer a character set 1190 CSET=251 ; get low-byte 1200 LOOKM=253 ; get low-byte 5150 CHSET 5160 ; 5170 LDA # STA ; POKE 56334, LDA #51

33 5200 STA 1 ; POKE 1, LDA # STA CSET ; CSET = LDA # STA CSET+1 ; CSET + 1 = LDA # STA LOOKM ; LOOKM = LDA # STA LOOKM+1 ; LOOKM+1 = LDX # RDY LDY # STV LDA (LOOKM), Y 5320 STA (CSET), Y 5330 INY 5340 BNE STU 5350 INC LOOKM+1 ; PEEK(254) = PEEK(254) + 1 increment high-byte 5360 INC CSET+1 ; PEEK(252) = PEEK(252) + 1 increment high-byte 5370 DEX 5380 BNE RDY 5390 ; 5400 LDA # STA 1 ; POKE 1, 55

34 5420 LDA # STA ; POKE 56334, ; 5450 LDA # STA ; POKE 53272, RTS

35 Chapter 3: Animation Animating ASCII characters Animation of ASCII characters in Basic is done by poking a screen character in screen memory, erasing it, incrementing to the next screen address, and poking in it the new position. It is also faster to animate by POKEing a character rather than just positioning with statements like POKE 214,2: PRINT: PRINT A The below example will count from 1 to 40 in the first loop. The second loop with wait for 50 clock cycles before continuing with the NEXT statement. Then the POKE I, 32 will send a space character to the screen position on your C64 screen to erase it. After this the final NEXT will jump back to the first I loop and now I will be a 1. It continues until the loops are done. Look at the example below the code for more clarity. Here is a simple example: 10 FOR X=0 TO 40: POKE 1024+X, FOR DELAY=1 TO 50: NEXT 30 POKE 1024+X, 32 : REM erase the character 40 NEXT A simplified step by step example: 10 X=1 : REM The first time the loop begins at 1. POKE X, 65 : REM Show the letter A on the screen DELAY = 1, 2, 3, 4, : REM COUNT UP TO 50

36 POKE X, 32 :REM Show a space in place of the letter A X = 2 : REM Increase the first loop now to a 2. GO BACK TO LINE 10 : REM Repeat until I is 40. I have used the above example to simulate a simple process of animation. In the game demo Spaced Out I use sprite animation. However I wanted to start with a simple example to explain how movement works. Animating sprites First I will show a simple BASIC example of sprite movement. Then I will demonstrate how this works in the source code. An example I showed earlier involved moving a sprite across the screen. Keep in mind that a sprite does not have to be erased like an ASCII character. It can easily be moved across the screen without affecting any other ASCII text remaining. Here is that example again which moves a sprite horizontally to the right across the screen. 10 FOR X=0 TO 255: POKE 53248, X: NEXT Here is an example of moving a sprite vertically down the screen. 10 FOR Y=0 TO 255: POKE 53249, Y: NEXT Now in these two examples you have only witnessed animating in moving a single shape across the screen. However the C64 system is clever and you can add individual animation frames for your sprite as it moves. Animating frames I only touched on this briefly earlier, but locations hold the sprite shape data that is used in the Spaced Out example to reproduce varying frame drawings as the sprite is moved left or right. All that is required is to be sure that

37 these frames are loaded into memory and displayed during the movement. Look at the assembly language example below OVR2 INC PNT2 ; PNT2 = PNT LDA PNT STA PNT STA SPRPT ; POKE 2040, PNT LDA PNT CMP # BCS RSETP2 ; IF PNT2 >=42 THEN GOTO RSETP DEC X1 ; X1 = X1-1: POKE 53248, X JMP MOVE 3190 RSETP LDA # STA PNT STA 2040 ; POKE 2040, JMP MOVE The code above sets up a variable called PNT2 to increment from 32 to 48. This properly accesses the sprite frames stored there. Each time PNT2 increases by 1 value a new frame of animation is seen. Once PNT2 is equal to 42 or above then the program will jump to the label called RSETP2. Then a POKE 2040, 32 will execute and the variable (memory address) PNT2 will be equal to 32 again. This allows the frames to flip over again starting at 32. The animation of the right movement is identical, but uses a new label called PNT. This allows the sprite to

38 keep track of the currently shown frames in location 2040 for the sprite during the left and right movement.

39 Chapter 4: Joystick (device) What is a joystick? A joystick is handheld and contains an attached stick that can be move in several lateral directions. It also includes a fire button that was popularized by earlier Atari 2600 cartridge games. A joystick is plugged into one of two different data ports on the system. On the Commodore 64 the CIA (Complex Interface Adapter) chip receives communications from the 6510 microprocessor to control joysticks, paddles, peripheral input and output devices. Receiving commands from the ports involves writing a simple Basic program to read the bits arriving there when the device is moved in one of 6 directions. Here is such an example. 10 JY = PEEK (56320) : REM Scan Data Port 1 20 PRINT JY : REM Show the value found there 30 GOTO 10 : REM Repeat the loop Now as the joystick is moved, the ports with interrupt the processor to get a return value. Each movement of the joystick could be used to maneuver a spaceship in all directions resulting in smooth control. When you plug in a second joystick then port is read. Fire button When you press the single button found on a joystick an interrupt is received to the ports to signal an action has taken place. A fire button gets its name from the coin operated arcades that were popular in the 80s, which was used to initiate a missile traveling towards a naval carrier or a laser honed in on an alien squadron.

40 Here is an example to read the fire button. When the joystick is plugged in the values can be read. Move the joystick and press the fire button to watch them change. The below example reads from memory location FI = PEEK (56320) 20 PRINT FI 30 GOTO 10

41 How the game Spaced Out uses the joystick Pay careful attention to the source code in the game and you will notice the port values (123, 119, 125, 126, 111). Use the diagram above to see which position the joystick has been moved on. Hopefully this will guide you in understanding how the 6502 processor uses accumulator values to read the joystick at memory location MOVE 2400 ; 2410 LDA JOY ; JY=PEEK (56320) 2420 CMP #123 ; IF PEEK (56320) =123 THEN GOTO LEFT 2430 BEQ LEFT ; IF JY=123 THEN GOTO LEFT 2440 CMP # BEQ RGT ; JOYSTICK PUSHED RIGHT 2460 CMP # BEQ MVDN ; JOYSTICK PUSHED DOWN 2480 CMP # BEQ MVUP ; JOYSTICK PUSHED UP This is a label called MOVE that controls the joystick in the game. The LDA JOY is reading the port at memory location The next instruction CMP #123 is checking that the value was moved to the left (see above diagram). Finally the first branch (jump) will GOTO the label called LEFT to signal that the user has pressed the joystick in that direction. The next CMP (Compares) for 119, 125, 126 are reading the remaining positions. Reading the fire button during the game

42 The code below reads the fire button, which causes the sprite missile lasers to travel across the screen. It will compare the value found in JOY (location 56320) to see if it returned a 111 to indicate that the fire button was pressed down. Then the code will jump to the label called SHOT CMP # BEQ SHOT ; IF PEEK (56320) = 111 THEN GOTO SHOT Shooting the missiles when the fire button is pressed The code below shows how the missiles were programmed into the game. Once the user has pressed the fire button (which again sets memory location = 111) then the game jumps to the label called SHOT. This is probably bad programming, but I used a label to reference another label. So the game then jumps to the label called SHOOT. This game animates the sprite lasers in the left or right direction when the player presses the fire button and is moving in that direction. SHOT JMP SHOOT

43 Chapter 5: From Basic to Assembly language Basic vs. Assembly language (speed advantage) This section has been created to enhance your knowledge of how assembly language and Basic programming go hand in hand. It is recommended to have a least some experience with Basic to follow along. I saw this example in a C64 book years ago, but saw a lack of connecting Basic to Assembly language so a beginner could keep up. Understanding the object code The PEEK command is used to read values found in memory locations. When building a machine language program, there are specific values (numbers) that represent assembly language instructions. I have listed them below for reference. The values you want to pay particular attention to is the column DEC (Decimal). This is what you will see when you PEEK into a Basic memory location. The HX (Hex) shows the hexadecimal. I will not be using hexadecimal in this ebook. The CHAR shows the ASCII value for that machine instruction. Finally the columns opc (Opcode) and ALform make up the assembly language instruction for the high and low byte addressing.

44 It may look like a lot, but I promise you that once you get used to developing in Assembly language you will see how Basic compliments it. As a matter of fact,

45 Basic is actually known as an interpreted language which is basically a bunch of assembly language instructions that check Basic for errors, scan statements to make sure a command (such as PRINT) examples in a lookup table, and sets execution of the program based on the computer s clock speed. It also does a lot more, but for brevity I have limited the other options to keep this example simple. LDA (Load the Accumulator) This is one of the first Assembly language instructions you will learn. It simple means to check the value found in the accumulator to see what exists there. In Basic this is interpreted to mean PEEK into a memory location to see what is found there. Most of the smaller assembly language programs use an addressing mode called absolute. Here is an example to read a joystick port (demonstrated in Chapter 4). LDA ; Read the value in memory location There is another addressing mode called immediate. It means to take a number and place it into the accumulator. Think of this as placing a book marker inside a book that is stored in a bookcase that has not been closed yet. Here is an example. LDA #255 The accumulator now contains the number 255. The # represents immediate to signal that we are looking for a number and not a memory location. STA (Store the accumulator) Let s move onto another instruction that will allow us to save a value into the accumulator. If you are visual like me then imagine that same book that has the book marker contained in it and then somebody closes the book. Now it is safely inside the book. Here is an example to change the screen border to red. In Basic this looks like POKE 53280, 2

46 LDA #2 ; Load the accumulator with immediate value of 2 STA ; Store the 2 into memory location 53280