Mord's Blog

lda SpeedXf
asl
bcc 1$; no overflow
clc
adc PlayerXf
sta PlayerXf
lda SpeedX
rol
sec
bcs 2$
1$
sbc PlayerXf
sta PlayerXf
lda SpeedX
rol
2$
sbc PlayerX
sta PlayerX

27 bytes, 25 or 31 cycles depending on SpeedXf

 

lda SpeedXf
asl
bcc 1$; no overflow
sbc PlayerXf
sta PlayerXf
lda SpeedX
rol
sec
bcs 2$
1$
sec
adc PlayerXf
sta PlayerXf
lda SpeedX
rol
2$
adc PlayerX
sta PlayerX

27 bytes, 27 or 29 cycles.

lda SpeedXf
asl
bcc 1$; no overflow
clc
adc PlayerXf
sta PlayerXf
lda SpeedX
rol
sec
bcs 2$
1$
sbc PlayerXf
sta PlayerXf
lda SpeedX
rol
2$
sbc PlayerX
sta PlayerX

27 bytes, 25 or 31 cycles depending on SpeedXf

 

 

Almost worked although had to change the sbc's to adc's it seems.

 

This left me with: (After my extensive comments being added to help my primitive thought processes )

 

 lda SpeedXf; load SpeedX fractional.
 asl		; double it. (So we now have double the fractional portion in A.
 bcc NoOverflow; Was there overflow? (didn't need to pre-set/clear carry.) 
 clc		; clear our carry for addition.
 adc PlayerXf  ; <-- add playerX fractional to the fractional speed..
 sta PlayerXf  ; <-- store the new playerX fractional.
 lda SpeedX	; <-- load SpeedX (Never more than 4-8)
 rol		; <-- rol for double instead of asl works in this case beca.... ZOMG!!!! 
			;	 THE CARRY GOT SET PROPERLY!!!!!! (only good because we know SpeedX < 8)
 sec		; set the carry. (as we know it won't be.)
 bcs Finishing ; <-- skip NoOverFlow section.
 
NoOverflow:	 ; <-- asuming no overflow occurred.
 adc PlayerXf  ; add
 sta PlayerXf  ;
 lda SpeedX	;
 rol		;
Finishing: 
 adc PlayerX
 sta PlayerX

 

When the sbcs were in there for the branches, we ended up with the walls being sticky when trying to push against them.

You can tell from the comments added what tricks I didn't realize could work.

 

... Looking over the code again, we can probably save some more by removing the sec... (And in fact the sec probably throws off the addition when I changed the sbc's to adc's.) Since we know the carry will always be cleared due to the low value of SpeedX...

 

The subtraction variation for moving in the other direction doesn't work unfortunately. With addition we can add the two numbers in any order, but the order does matter for subtraction (7 - 3) != (3 - 7)! So we can't have SpeedX(f) in the A register, we need PlayerX(f) in there.

 

Hm. can't post attachments in replies so can't show what happens. Essentially with the subtraction method given, when you try pushing against horizontal wall (like the bottom of the screen) instead of sliding against it as you move left, you end up moving right. (moonwalking? ) Interestingly tho, if you try to move sideways, the ball ends up acting like a solid wall and pushes you - but stops pushing you and passes over if you stop moving.

 

Thanks for the help! I've modified my move-right routine for it. Every byte I save now could mean a feature saved later. *grin*

Let's back up and make sure we're saving space/cycles over the simple stuff.

  ldy #2; do it as a loop for space savings
 clc
1$
 lda PlayerXf
 adc SpeedXf
 sta PlayerXf
 lda PlayerX
 adc SpeedX
 sta PlayerX
 dey
 bne 1$

Swap adc/sbc and clc/sec (move after 1$ loop) for subtraction. 18 bytes, 49 cycles (51 for subtract), unrolling the loop doubles the size for a small number of cycles.

 

Okay, back to my original idea (fixed - I was trying to make the subtract version and modified the wrong routine):

  lda SpeedXf
 asl ; multiply SpeedXf by two
 bcc 1$ ; no overflow
 clc; clear carry for add
 adc PlayerXf
 sta PlayerXf
 lda SpeedX
 rol ; multiply SpeedX by two, shift in overflow from PlayerXf += 2 * SpeedXf
 sec ; set carry from 2 * SpeedXf overflow
 bcs 2$ ; branch on known condition
1$
 adc PlayerXf
 sta PlayerXf
 lda SpeedX
 rol ; multiply SpeedX by two, shift in overflow from PlayerXf += 2 * SpeedXf
2$
 adc PlayerX
 sta PlayerX

27 bytes, 25 or 31 cycles depending on SpeedXf - 50% bigger code but almost half the cycles on average.

 

Now you pointed out that 2 * SpeedX - PlayerX != PlayerX - 2 * SpeedX, which does make my subtraction routine bogus. I'm trying to figure out whether it would be easier to implement -SpeedX * 2 + PlayerX or -( Speed X * 2 - PlayerX ). Or maybe there's a reasonable way to implement PlayerX - SpeedX - SpeedX (i.e. only load/store PlayerX once).

 sec
 lda PlayerXf
 sbc SpeedXf
 bcc 1$; overflow on first subtract
 sbc SpeedXf
 sta PlayerXf
 lda PlayerX
 sbc SpeedX; assume PlayerX - 2 * SpeedX is never negative
 sbc SpeedX; thus carry is set after both subtracts
 bcs 2$
1$
 sec
 sbc SpeedXf
 sta PlayerXf
 lda PlayerX
 sbc SpeedX
 clc; pull in first overflow
 sbc SpeedX
2$
 sta PlayerX

33 bytes, 33 or 35 cycles