Retro Racer
22 Dec 2018Progress: Complete
This is page 7 of the Games Console project.
If you're not familiar with the game, it might not be clear what type of motion we're trying to achieve here. But perhaps this little demo can help out. On your keyboard (sorry mobile readers) use WASD to move (W to accelerate, S to brake, and A and D keys to steer).
Notice that the walls are super slippery. Rubbing against one doesn't just slow you down, it pushes you away. Driving into one of the rounded corners, it will move you potentially an entire tile's width in a direction perpendicular to your velocity. Notice that if you stay pointing in one direction, and drive continously, you'll end up in a position where your direction is perpendicular to the wall you're driving into.
Many, many fan games struggled with this, but it's one of those things that's essential if you want the game to feel right. Even with a top-down zelda game it's a concern, else you're left with the dreaded condition known as "sticky walls".
The way we avoid this is through impulse collisions. In video games, a collision is when two graphics overlap. If they're directly adjacent to each other, that's not a collision as far as we're concerned.
When a collision is detected, we need to move the car away from the wall, and the easiest (and incorrect) way to do that is to move it to its previous position. To do an impulse collision, we first calculate the direction of the reaction force. In the case of retro racer, this will either be horizontal, vertical, or along one of the radius lines of the rounded corners.
Then, we apply a small impulse in that direction, moving the car maybe half a pixel. Then we check if there is still a collision, and if needed, perform another impulse. Repeated small impulses is the only way to ensure that at the end of the routine, the car will just be in visual contact with the wall. Remember, at top speed, the car could be moving tens of pixels at a time, so a poorly-implemented collision routine could set it ten pixels away from the wall.
To learn more about this implementation, I suggest you take a look at the javascript code for the demo above, which I have syntax-highlighted here for your convenience. You'll notice that in places the resolution is deliberately crippled. Floating point everything would give a very smooth result, but it was more useful to get a preview of how the 8-bit calculations would behave.
<canvas width=256 height=256 id=cnv style="background-color:black"></canvas> <script> ctx=document.getElementById('cnv').getContext('2d'); ctx.strokeStyle="#0F0" ctx.fillStyle="#0F0" theta=0 x = 70 y = 70 speed_x = 0 speed_y = 0 //1,2,3,4 = corners //5 = horizontal //6 = vertical map=[ [2,1,2,5,5,1], [6,6,6,2,1,6], [6,6,6,6,3,4], [6,3,4,3,5,1], [3,5,5,5,5,4] ] offsetX=10 offsetY=30 function main(){ ctx.clearRect(0,0,256,256) theta= (256 + theta + 2*(keys[39]-keys[37])) %256 if (keys[83]) { speed_x+=cos(theta)/8 speed_y+=sin(theta)/8 } if (keys[65]) { friction() } x = (256+x+speed_x/256) %256 y = (256+y+speed_y/256) %256 var scale=40; for (var j=map.length;j--;) for (var i=map[j].length;i--;) { if (x>=i*scale && y>=j*scale && x<(i+1)*scale && y<(j+1)*scale) switch (map[j][i]) { case 1: collideCorner( i*scale,(j+1)*scale); break; case 2: collideCorner((i+1)*scale,(j+1)*scale); break; case 3: collideCorner((i+1)*scale, j*scale); break; case 4: collideCorner( i*scale, j*scale); break; case 5: collideHoriz(i*scale,j*scale,scale);break; case 6: collideVert (i*scale,j*scale,scale);break; } if (map[j][i]<5) drawCurve(offsetX+i*scale,offsetY+j*scale,scale, map[j][i]) if (map[j][i]==5) drawHoriz(offsetX+i*scale,offsetY+j*scale,scale) if (map[j][i]==6) drawVert(offsetX+i*scale,offsetY+j*scale,scale) } drawCar(); ctx.fillText("speed_x:"+speed_x+" speed_y:"+speed_y,10,10) requestAnimationFrame(main); } function collideCorner(x1,y1){ var dist, i=10, r=32 while ((dist=(x-x1)*(x-x1)+(y-y1)*(y-y1))>r*r &&i--) { x-=((x-x1)/r ) y-=((y-y1)/r ) friction() } i=10,r=8 while ((dist=(x-x1)*(x-x1)+(y-y1)*(y-y1))<r*r &&i--) { x+=((x-x1)/r ) y+=((y-y1)/r ) friction() } } function collideVert(x1,y1,s){ var i=10; while (x<x1+8 &&i--) { x++; friction() } i=10; while (x>x1+s-8 &&i--) { x--; friction() } } function collideHoriz(x1,y1,s){ var i=10; while (y<y1+8 &&i--) { y++; friction() } i=10; while (y>y1+s-8 &&i--) { y--; friction() } } function friction(){ speed_x-=(speed_x>>4) speed_y-=(speed_y>>4) } function drawHoriz(x,y,s) { ctx.beginPath(); ctx.moveTo(x,y+4); ctx.lineTo(x+s,y+4); ctx.moveTo(x,y+s-4); ctx.lineTo(x+s,y+s-4); ctx.stroke(); } function drawVert(x,y,s) { ctx.beginPath(); ctx.moveTo(x+s-4,y); ctx.lineTo(x+s-4,y+s); ctx.moveTo(x+4,y+s); ctx.lineTo(x+4,y); ctx.stroke(); } function drawCurve(x,y,r, quadrant){ if (quadrant==1) y+=r; if (quadrant==2) x+=r,y+=r; if (quadrant==3) x+=r; ctx.beginPath(); ctx.arc(x,y,r-4,0.5*Math.PI*(-quadrant),0.5*Math.PI*(1-quadrant)); ctx.stroke(); ctx.beginPath(); ctx.arc(x,y,4,0.5*Math.PI*(-quadrant),0.5*Math.PI*(1-quadrant)); ctx.stroke(); } function drawCar() { costheta = cos(theta)/20 sintheta = sin(theta)/20 halfcos=costheta/2 halfsin=sintheta/2 ctx.beginPath(); ctx.lineTo(Math.round(x+offsetX +halfcos+halfsin), Math.round(y+offsetY +halfsin-halfcos)); ctx.lineTo(Math.round(x+offsetX -costheta+halfsin), Math.round(y+offsetY -sintheta-halfcos)); ctx.lineTo(Math.round(x+offsetX -costheta-halfsin), Math.round(y+offsetY -sintheta+halfcos)); ctx.lineTo(Math.round(x+offsetX +halfcos-halfsin), Math.round(y+offsetY +halfsin+halfcos)); ctx.lineTo(Math.round(x+offsetX +halfcos+halfsin), Math.round(y+offsetY +halfsin-halfcos)); ctx.stroke(); } keys=[]; keys[37]=keys[39]=keys[83]=0 document.onkeydown=function(e){keys[e.keyCode]=true} document.onkeyup=function(e){keys[e.keyCode]=false} function sin(a) {return Math.round(Math.sin(Math.PI*2*a/256)*127)} function cos(a) {return Math.round(Math.cos(Math.PI*2*a/256)*127)} main(); </script>
The assembly source code I produced from this is below. A few sacrifices were made, mostly reducing the resolution of the collisions to make the whole thing a little less tedious. For reading two controllers, as we only have one true SPI port, I decided to just bit-bang it. I developed this with just one car, so to add a second I was quite lazy. All of one car's properties are shoved into ram, properties of the other car are shoved into the registers, and the code is run again.
Examine, inspect, scrutinize until satisfied, then promptly proceed to the page about astrolander.
### RetroRacer.asm ### .equ A_theta = D_START .equ A_x_H = D_START +1 .equ A_x_L = D_START +2 .equ A_y_H = D_START +3 .equ A_y_L = D_START +4 .equ A_speedx_H = D_START +5 .equ A_speedx_L = D_START +6 .equ A_speedy_H = D_START +7 .equ A_speedy_L = D_START +8 .equ B_theta = D_START +9 .equ B_x_H = D_START +10 .equ B_x_L = D_START +11 .equ B_y_H = D_START +12 .equ B_y_L = D_START +13 .equ B_speedx_H = D_START +14 .equ B_speedx_L = D_START +15 .equ B_speedy_H = D_START +16 .equ B_speedy_L = D_START +17 .equ MAPDATA = D_START + 20 .def x_H = r4 .def x_L = r5 .def y_H = r6 .def y_L = r7 .def speedx_H = r8 .def speedx_L = r9 .def speedy_H = r10 .def speedy_L = r11 .def theta = r12 ldi r16,0 ; Disable SPI - we're bitbanging the controllers instead. out SPCR,r16 ;init frame counter ldi r16,0 out TCNT0, r16 ldi r16, (1<<CS02)|(1<<CS01)|(1<<CS00) out TCCR0, r16 ldi r16, 128 out OCR0, r16 ; Init music ldi r16, HIGH(Music*2) sts MUSIC_START_H, r16 ldi r16, LOW(Music*2) sts MUSIC_START_L, r16 rcall resetMusic ; Load map data into sram ldi ZH, HIGH(Map*2) ldi ZL, LOW(Map*2) ldi YH, HIGH(MAPDATA) ldi YL, LOW(MAPDATA) ldi r16, (5*6) loadMapLoop: lpm r17,Z+ st Y+,r17 dec r16 brne loadMapLoop sts A_x_L, r16 sts A_speedx_H, r16 sts A_speedx_L, r16 sts A_y_L, r16 sts A_speedy_H, r16 sts A_speedy_L, r16 sts B_x_L, r16 sts B_speedx_H, r16 sts B_speedx_L, r16 sts B_y_L, r16 sts B_speedy_H, r16 sts B_speedy_L, r16 ldi r16,128 sts A_x_H, r16 sts B_x_H, r16 sts A_theta, r16 sts B_theta, r16 ldi r16, 170 sts A_y_H, r16 ldi r16, 185 sts B_y_H, r16 Main: rcall readTwoControllers ; Apply user input to both cars ; Change direction ldi r16, 2 ; turn speed lds theta, A_theta sbrc r2, ctrlLeft add theta,r16 sbrc r2, ctrlRight sub theta,r16 sts A_theta, theta lds theta, B_theta sbrc r3, ctrlLeft add theta,r16 sbrc r3, ctrlRight sub theta,r16 sts B_theta, theta ; Apply accelerator sbrs r2, ctrlA rjmp checkAccelB lds r17, A_theta ldi r16, 16 ; acceleration magnitude lds speedy_H, A_speedy_H lds speedy_L, A_speedy_L rcall sinS ; returns in r1:r0 sbrc r0,7 inc r1 add speedy_L, r1 ldi r16,0 sbrc r1,7 ldi r16,-1 adc speedy_H, r16 sts A_speedy_H, speedy_H sts A_speedy_L, speedy_L lds r17, A_theta ldi r16, 16 ; acceleration magnitude lds speedx_H, A_speedx_H lds speedx_L, A_speedx_L rcall cosS ; returns in r1:r0 sbrc r0,7 inc r1 add speedx_L, r1 ldi r16,0 sbrc r1,7 ldi r16,-1 adc speedx_H, r16 sts A_speedx_H, speedx_H sts A_speedx_L, speedx_L checkAccelB: sbrs r3, ctrlA rjmp checkBrakeA lds r17, B_theta ldi r16, 16 ; acceleration magnitude lds speedy_H, B_speedy_H lds speedy_L, B_speedy_L rcall sinS ; returns in r1:r0 sbrc r0,7 inc r1 add speedy_L, r1 ldi r16,0 sbrc r1,7 ldi r16,-1 adc speedy_H, r16 sts B_speedy_H, speedy_H sts B_speedy_L, speedy_L lds r17, B_theta ldi r16, 16 ; acceleration magnitude lds speedx_H, B_speedx_H lds speedx_L, B_speedx_L rcall cosS ; returns in r1:r0 sbrc r0,7 inc r1 add speedx_L, r1 ldi r16,0 sbrc r1,7 ldi r16,-1 adc speedx_H, r16 sts B_speedx_H, speedx_H sts B_speedx_L, speedx_L ; Apply brake checkBrakeA: sbrs r2, ctrlB rjmp checkBrakeB rcall loadAllA rcall friction rcall storeAllA checkBrakeB: sbrs r3, ctrlB rjmp newPosition rcall loadAllB rcall friction rcall storeAllB ; End of user input sequence. newPosition: ; Increment position by speed amount rcall loadAllA add x_L, speedx_L adc x_H, speedx_H add y_L, speedy_L adc y_H, speedy_H rcall storeAllA rcall loadAllB add x_L, speedx_L adc x_H, speedx_H add y_L, speedy_L adc y_H, speedy_H rcall storeAllB ; Draw the map and check for collisions. ldi YH, HIGH(MAPDATA) ldi YL, LOW(MAPDATA) ldi r27, (5*6) ldi r16,0 ldi r17,0 mapLoop: ld r18, Y+ ; Load tile rcall drawTile mov r19,r16 ; Tiles are 40 pixels on a side. mov r20,r17 ; Store the opposing coordinate in r19,r20 subi r19,-40 subi r20,-40 rcall loadAllA rcall doCollisions rcall storeAllA rcall loadAllB rcall doCollisions rcall storeAllB subi r16, -40 ; Move to next tile cpi r16, (6*40) ; if at the end of the row, brne mapLoopEnd ldi r16,0 ; reset X and increase Y subi r17, -40 mapLoopEnd: dec r27 ; keep going until the end of the map brne mapLoop lds theta, A_theta lds x_H, A_x_H lds x_L, A_x_L lds y_H, A_y_H lds y_L, A_y_L rcall drawCar lds theta, B_theta lds x_H, B_x_H lds x_L, B_x_L lds y_H, B_y_H lds y_L, B_y_L rcall drawCar call processAudio ldi r16,0 out PORTA,r16 out PORTC, r16 waitforframe: in r16, TIFR sbrs r16, OCF0 rjmp waitforframe ldi r16, (1<<OCF0) out TIFR, r16 ldi r16, 0 out TCNT0, r16 rjmp Main doCollisions: ;i=r16 ;j=r17 ;ni=r19 ;nj=r20 cp x_H,r16 brcs doCollisionEnd ; branch if x_H<r16 cp y_H,r17 brcs doCollisionEnd ; branch if y_H<r17 cp x_H,r19 brcc doCollisionEnd cp y_H,r20 brcc doCollisionEnd ;rcall drawTile ; highlight the tile we're in ;rcall drawTile cpi r18,1 brne collisionCheck2 mov r21,r16 mov r22,r20 rjmp doCurvedWall collisionCheck2: cpi r18,2 brne collisionCheck3 mov r21,r19 mov r22,r20 rjmp doCurvedWall collisionCheck3: cpi r18,3 brne collisionCheck4 mov r21,r19 mov r22,r17 rjmp doCurvedWall collisionCheck4: cpi r18,4 brne collisionCheckOther mov r21,r16 mov r22,r17 rjmp doCurvedWall collisionCheckOther: cpi r18,5 breq doHorizontalWall cpi r18,6 breq doVerticalWall doCollisionEnd: ret doHorizontalWall: mov r22,r17 subi r22,-8 cp y_H,r22 brcc collideHorizBottom inc y_H rcall friction rjmp doHorizontalWall collideHorizBottom: mov r22, r17 subi r22, -32 cp r22,y_H brsh doHorizontalEnd dec y_H rcall friction rjmp collideHorizBottom doHorizontalEnd: ret doVerticalWall: mov r22,r16 subi r22,-8 cp x_H,r22 brcc collideVerticalRight inc x_H rcall friction rjmp doVerticalWall collideVerticalRight: mov r22,r16 subi r22,-32 cp r22,x_H brsh doVerticalEnd dec x_H rcall friction rjmp collideVerticalRight doVerticalEnd: ret ; Function doCurvedWall ; r21, r22 is the centre of curvature doCurvedWall: rcall calcDistance ldi r24, LOW(32*32) ldi r25, HIGH(32*32) ; radius is 32 cp r0, r24 cpc r1, r25 brcs checkInnerWall mov r24,x_H sub r24, r21 ; divide by 32 (radius) asr r24 asr r24 asr r24 asr r24 asr r24 brcc dontRound1 inc r24 dontRound1: sub x_H,r24 mov r24,y_H sub r24,r22 asr r24 asr r24 asr r24 asr r24 asr r24 brcc dontRound2 inc r24 dontRound2: sub y_H,r24 rcall friction rjmp doCurvedWall checkInnerWall: rcall calcDistance ldi r24, LOW(8*8) ldi r25,HIGH(8*8) cp r0, r24 cpc r1, r25 brcc doCurvedWallEnd mov r24,x_H sub r24, r21 ; divide by 8 (radius) asr r24 asr r24 asr r24 brcc dontRound3 inc r24 dontRound3: add x_H,r24 mov r24,y_H sub r24,r22 asr r24 asr r24 asr r24 brcc dontRound4 inc r24 dontRound4: add y_H,r24 rcall friction rjmp checkInnerWall doCurvedWallEnd: ret ; function calcDistance ; Works out the squared distance between x_H,y_H and r21,r22 calcDistance: mov r26,x_H sub r26,r21 ; Difference between x coordinates muls r26,r26 ; square it movw r24,r0 ; save for later mov r26,y_H sub r26,r22 ; difference in y coordinates muls r26,r26 ; square it add r0,r24 ; add two values together adc r1,r25 ; (return in r1:r0) ret ; Function friction ; subtracts one sixteenth of current speed from speed friction: push r16 push r17 mov r16, speedx_L mov r17, speedx_H asr r17 ; arithmetic shift (speed is signed) ror r16 asr r17 ror r16 asr r17 ror r16 asr r17 ror r16 sub speedx_L, r16 sbc speedx_H, r17 mov r16, speedy_L mov r17, speedy_H asr r17 ror r16 asr r17 ror r16 asr r17 ror r16 asr r17 ror r16 sub speedy_L, r16 sbc speedy_H, r17 pop r17 pop r16 ret ; Function drawTile(x=r16, y=r17, tile=r18) ; draws tile data from prog mem drawTile: push r16 push r17 ldi ZH, HIGH(Tileset*2-162) ; Each tile is 162 bytes apart in prog mem. ldi ZL, LOW(Tileset*2-162) ; (tile number starts at 1, so subtract a tile) ldi r19, 162 ; multiply tile number (r18) by 162 mul r19, r18 add ZL, r0 ; add to Z pointer adc ZH, r1 subi r16, -10 ; draw to screen with an offset subi r17, -30 drawTileLoop: lpm r19, Z+ ; load X coordinate cpi r19, -1 breq drawTileEnd ; -1 signals end of tile data add r19, r16 ; combine with tile location out PORTA, r19 ; output lpm r19, Z+ ; load Y coordinate add r19, r17 ; combine with tile location out PORTC, r19 ; output rcall delayPixel rjmp drawTileLoop drawTileEnd: pop r17 pop r16 ret drawCar: ; Although we're plotting pixels, let's stay in 16bit as long ; as possible to reduce the rounding errors. ;out PORTA, x_H ;out PORTC, y_H ;ret ldi r16,8 mov r17, theta rcall sinS movw r30, r0 ; r31:r30 is now sintheta ldi r16,8 mov r17, theta rcall cosS movw r28, r0 ; r29:r28 is now costheta movw r26, r30 ; r27:r26 is halfsintheta asr r27 ror r26 movw r24, r28 ; r25:r24 is halfcostheta asr r25 ror r24 ldi r16,10 adc x_H, r16 ; shift coords by drawing offset ldi r16, 30 ; 10 and 30 pixels. add y_H, r16 ; 1st coordinate is loaded into x=r16, y=r17 mov r20, x_L ; x +halfcos +halfsin mov r16, x_H ; use r20 as temporary low byte add r20, r24 adc r16, r25 add r20, r26 adc r16, r27 sbrc r20,7 ; round to 8 bit inc r16 mov r20, y_L mov r17, y_H ; y +halfsin -halfcos add r20, r26 adc r17, r27 sub r20, r24 sbc r17, r25 sbrc r20,7 ; round to 8 bit inc r17 push r16 ; save starting coordinates for later push r17 ; 2nd coordinate is loaded into x=r18, y=r19 mov r20, x_L mov r18, x_H ; x -costheta +halfsin sub r20, r28 sbc r18, r29 add r20, r26 adc r18, r27 sbrc r20,7 inc r18 mov r20, y_L mov r19, y_H ; y -sintheta -halfcos sub r20, r30 sbc r19, r31 sub r20, r24 sbc r19, r25 sbrc r20,7 inc r19 rcall drawLine ; Draw the first line of the rectangle! ; 3rd, 4th, 5th coordinates go into r18, r19 again. mov r20, x_L mov r18, x_H ; x -costheta -halfsin sub r20, r28 sbc r18, r29 sub r20, r26 sbc r18, r27 sbrc r20,7 inc r18 mov r20, y_L mov r19, y_H ; y -sintheta +halfcos sub r20, r30 sbc r19, r31 add r20, r24 adc r19, r25 sbrc r20,7 inc r19 rcall drawLine mov r20, x_L mov r18, x_H ; x +halfcos -halfsin add r20, r24 adc r18, r25 sub r20, r26 sbc r18, r27 sbrc r20,7 inc r18 mov r20, y_L mov r19, y_H ; y +halfsin +halfcos add r20, r26 adc r19, r27 add r20, r24 adc r19, r25 sbrc r20,7 inc r19 rcall drawLine pop r19 ; recover starting position pop r18 rcall drawLine ; and complete the rectangle. ret ; Load All / Store All functions. ; Moves data to/from memory for either car. loadAllA: lds theta, A_theta lds x_H, A_x_H lds x_L, A_x_L lds speedx_H, A_speedx_H lds speedx_L, A_speedx_L lds y_H, A_y_H lds y_L, A_y_L lds speedy_H, A_speedy_H lds speedy_L, A_speedy_L ret storeAllA: sts A_theta, theta sts A_x_H, x_H sts A_x_L, x_L sts A_speedx_H, speedx_H sts A_speedx_L, speedx_L sts A_y_H, y_H sts A_y_L, y_L sts A_speedy_H, speedy_H sts A_speedy_L, speedy_L ret loadAllB: lds theta, B_theta lds x_H, B_x_H lds x_L, B_x_L lds speedx_H, B_speedx_H lds speedx_L, B_speedx_L lds y_H, B_y_H lds y_L, B_y_L lds speedy_H, B_speedy_H lds speedy_L, B_speedy_L ret storeAllB: sts B_theta, theta sts B_x_H, x_H sts B_x_L, x_L sts B_speedx_H, speedx_H sts B_speedx_L, speedx_L sts B_y_H, y_H sts B_y_L, y_L sts B_speedy_H, speedy_H sts B_speedy_L, speedy_L ret readTwoControllers: push r16 push r17 push r18 push r19 ; PIN 1 is CLOCK ; PIN 2 is LATCH ; PIN 3 is DATA INPUT for controller 1 ; PIN 4 is DATA INPUT for controller 2 ldi r16,0 ldi r18,0 ldi r19,0 out PORTB, r16 ; Set latch low rcall readControllerDelay ldi r17,8 ; eight clock pulses readTwoControllersLoop: in r16,PINB lsl r18 sbrs r16, 3 ; read controller 1 data sbr r18,1 lsl r19 sbrs r16, 4 ; read controller 2 data sbr r19,1 ldi r16, 0b00000010 ; Clock high out PORTB,r16 rcall readControllerDelay ldi r16, 0b00000000 ; Clock low out PORTB,r16 rcall readControllerDelay dec r17 brne readTwoControllersLoop ldi r16, 0b00000100 ; Latch high for next time out PORTB,r16 mov r2,r18 mov r3,r19 pop r19 pop r18 pop r17 pop r16 ret readControllerDelay: ldi r16,255 readControllerDelayLoop: dec r16 brne readControllerDelayLoop ret /* Function drawLine (x0,y0,x1,y1) * My implementation of Bresenham line algorithm * based on pseudocode/description from wikipedia */ drawLine: ;Function arguments .def x0=r16 .def y0=r17 .def dx=r18 .def dy=r19 ;Local variables push r20 push r21 push r22 push r23 push r24 push r25 .def slowx=r20 .def slowy=r21 .def fastx=r22 .def fasty=r23 .def err = r24 .def t = r25 ; First we split the magnitude and direction ; Need to be careful/explicit because mag could be >127 cp dx,x0 breq lineXeq brcs lineXneg ; Carry flag set if it overflowed ldi slowx,1 ; slowx is the direction sub dx,x0 ; dx is now the magnitude rjmp lineY lineXneg: ldi slowx,-1 mov t, x0 ; t as temp var sub t, dx mov dx, t rjmp lineY lineXeq: clr slowx clr dx lineY: ; Now do the same for y cp dy,y0 breq lineYeq brcs lineYneg ldi slowy,1 sub dy,y0 rjmp lineCheckDistance lineYneg: ldi slowy,-1 mov t, y0 ; t as temp var sub t, dy mov dy, t rjmp lineCheckDistance lineYeq: clr slowy clr dy lineCheckDistance: ; Now to find which direction is "faster" cp dx, dy brcs lineDxLessthanDy mov fastx, slowx ; x is the fast direction clr fasty eor dx, dy ; Tripple XOR, the classy way to eor dy, dx ; swap two registers eor dx, dy rjmp lineInit lineDxLessthanDy: mov fasty, slowy ; y is the fast direction, no need to swap clr fastx lineInit: mov err, dy ; set err to half the furthest distance lsr err out PORTA, x0 ; We are now ready to draw the line out PORTC, y0 rcall delayPixel mov t, dy lineNextPixel: sub err, dx ; Update error term brcc lineStepParallel add err, dy ; Make error term positive again add x0,slowx ; Step diagonally add y0,slowy rjmp lineLoopBack lineStepParallel: add x0,fastx ; Step parallel add y0,fasty lineLoopBack: out PORTA, x0 ; Plot point out PORTC, y0 rcall delayPixel dec t brne lineNextPixel pop r25 pop r24 pop r23 pop r22 pop r21 pop r20 ret ; End of drawLine delayPixel: push r16 ldi r16,12 delayPixelLoop: dec r16 brne delayPixelLoop pop r16 ret /* Function sinS(coordinate, dir) * Scales 8bit signed coordinate by sine of the direction * Simplified, no rounding, returns in r1:r0 */ sinS: .def cor=r16 .def dir=r17 push ZH push ZL ldi ZH, HIGH(sineTable*2+255) ldi ZL, LOW(sineTable*2+255) sub ZL, dir sbci ZH, $00 ; sub-with-carry 0 from high byte lpm dir, Z fmuls cor,dir pop ZL pop ZH ret /* Function cosS(coordinate, dir) * Scales 8bit signed coordinate by cosine of the direction */ cosS: push ZH push ZL ldi ZH, HIGH(sineTable*2+255) ldi ZL, LOW(sineTable*2+255) ; reuse table, but shift by pi/2 subi dir, 192 ; which in our notation is 64 (-192) sub ZL, dir sbci ZH, $00 lpm dir, Z fmuls cor,dir pop ZL pop ZH ret ; signed values, in reverse order sineTable: .db $FD,$FA,$F7,$F4,$F0,$ED,$EA,$E7,$E4,$E1,$DE,$DB,$D8,$D5,$D2,$CF,$CD,$CA,$C7,$C4,$C1,$BF,$BC,$B9,$B7,$B4,$B2,$AF,$AD,$AB,$A8,$A6,$A4,$A2,$A0,$9E,$9C,$9A,$98,$96,$95,$93,$91,$90,$8F,$8D,$8C,$8B,$8A,$88,$87,$86,$86,$85,$84,$83,$83,$82,$82,$82,$81,$81,$81,$81,$81,$81,$81,$82,$82,$82,$83,$83,$84,$85,$86,$86,$87,$88,$8A,$8B,$8C,$8D,$8F,$90,$91,$93,$95,$96,$98,$9A,$9C,$9E,$A0,$A2,$A4,$A6,$A8,$AB,$AD,$AF,$B2,$B4,$B7,$B9,$BC,$BF,$C1,$C4,$C7,$CA,$CD,$CF,$D2,$D5,$D8,$DB,$DE,$E1,$E4,$E7,$EA,$ED,$F0,$F4,$F7,$FA,$FD,$00,$03,$06,$09,$0C,$10,$13,$16,$19,$1C,$1F,$22,$25,$28,$2B,$2E,$31,$33,$36,$39,$3C,$3F,$41,$44,$47,$49,$4C,$4E,$51,$53,$55,$58,$5A,$5C,$5E,$60,$62,$64,$66,$68,$6A,$6B,$6D,$6F,$70,$71,$73,$74,$75,$76,$78,$79,$7A,$7A,$7B,$7C,$7D,$7D,$7E,$7E,$7E,$7F,$7F,$7F,$7F,$7F,$7F,$7F,$7E,$7E,$7E,$7D,$7D,$7C,$7B,$7A,$7A,$79,$78,$76,$75,$74,$73,$71,$70,$6F,$6D,$6B,$6A,$68,$66,$64,$62,$60,$5E,$5C,$5A,$58,$55,$53,$51,$4E,$4C,$49,$47,$44,$41,$3F,$3C,$39,$36,$33,$31,$2E,$2B,$28,$25,$22,$1F,$1C,$19,$16,$13,$10,$0C,$09,$06,$03,$00 Map: .db 2,1,2,5,5,1 .db 6,6,6,2,1,6 .db 6,6,6,6,3,4 .db 6,3,4,3,5,1 .db 3,5,5,5,5,4 Tileset: .db 0,3,1,3,2,3,3,3,4,3,5,4,6,4,7,4,8,4,9,4,10,5,11,5,12,5,13,6,14,6,15,7,16,7,17,8,18,8,19,9,20,9,21,10,22,11,23,12,24,13,25,13,26,14,26,15,27,16,28,17,29,18,30,19,30,20,31,21,31,22,32,23,32,24,33,25,33,26,34,27,34,28,34,29,35,30,35,31,35,32,35,33,35,34,36,35,36,36,36,37,36,38,36,39,0,36,1,37,2,37,2,38,3,39,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 .db 39,3,38,3,37,3,36,3,35,3,34,4,33,4,32,4,31,4,30,4,29,5,28,5,27,5,26,6,25,6,24,7,23,7,22,8,21,8,20,9,19,9,18,10,17,11,16,12,15,13,14,13,13,14,13,15,12,16,11,17,10,18,9,19,9,20,8,21,8,22,7,23,7,24,6,25,6,26,5,27,5,28,5,29,4,30,4,31,4,32,4,33,4,34,3,35,3,36,3,37,3,38,3,39,39,36,38,37,37,37,37,38,36,39,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 .db 39,36,38,36,37,36,36,36,35,36,34,35,33,35,32,35,31,35,30,35,29,34,28,34,27,34,26,33,25,33,24,32,23,32,22,31,21,31,20,30,19,30,18,29,17,28,16,27,15,26,14,26,13,25,13,24,12,23,11,22,10,21,9,20,9,19,8,18,8,17,7,16,7,15,6,14,6,13,5,12,5,11,5,10,4,9,4,8,4,7,4,6,4,5,3,4,3,3,3,2,3,1,3,0,39,3,38,2,37,2,37,1,36,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 .db 0,36,1,36,2,36,3,36,4,36,5,35,6,35,7,35,8,35,9,35,10,34,11,34,12,34,13,33,14,33,15,32,16,32,17,31,18,31,19,30,20,30,21,29,22,28,23,27,24,26,25,26,26,25,26,24,27,23,28,22,29,21,30,20,30,19,31,18,31,17,32,16,32,15,33,14,33,13,34,12,34,11,34,10,35,9,35,8,35,7,35,6,35,5,36,4,36,3,36,2,36,1,36,0,0,3,1,2,2,2,2,1,3,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 .db 0,3,1,3,2,3,3,3,4,3,5,3,6,3,7,3,8,3,9,3,10,3,11,3,12,3,13,3,14,3,15,3,16,3,17,3,18,3,19,3,20,3,21,3,22,3,23,3,24,3,25,3,26,3,27,3,28,3,29,3,30,3,31,3,32,3,33,3,34,3,35,3,36,3,37,3,38,3,39,3,0,36,1,36,2,36,3,36,4,36,5,36,6,36,7,36,8,36,9,36,10,36,11,36,12,36,13,36,14,36,15,36,16,36,17,36,18,36,19,36,20,36,21,36,22,36,23,36,24,36,25,36,26,36,27,36,28,36,29,36,30,36,31,36,32,36,33,36,34,36,35,36,36,36,37,36,38,36,39,36,-1,-1 .db 3,0,3,1,3,2,3,3,3,4,3,5,3,6,3,7,3,8,3,9,3,10,3,11,3,12,3,13,3,14,3,15,3,16,3,17,3,18,3,19,3,20,3,21,3,22,3,23,3,24,3,25,3,26,3,27,3,28,3,29,3,30,3,31,3,32,3,33,3,34,3,35,3,36,3,37,3,38,3,39,36,0,36,1,36,2,36,3,36,4,36,5,36,6,36,7,36,8,36,9,36,10,36,11,36,12,36,13,36,14,36,15,36,16,36,17,36,18,36,19,36,20,36,21,36,22,36,23,36,24,36,25,36,26,36,27,36,28,36,29,36,30,36,31,36,32,36,33,36,34,36,35,36,36,36,37,36,38,36,39,-1,-1 .include "audio.asm" Music: .include "Music/MegaMan.asm" .include "Bootloader.asm"
The adventure continues on page 8.