6.09HEADmaster

1 files changed, 0 insertions, 195 deletions

diff --git a/hacks/images/m6502/breakout.asm b/hacks/images/m6502/breakout.asm
deleted file mode 100644
index a0fa694..0000000
--- a/hacks/images/m6502/breakout.asm
+++ /dev/null
@@ -1,195 +0,0 @@
-; Brick Out by Blake Ramsdell <blaker@gmail.com> http://www.blakeramsdell.com
-
-; A poor attempt at brick out with no player involved. Maybe someday I'll
-; let you play it, or you can view this as an exercise for the reader to put
-; in a paddle that is user-controlled.
-
-; I guess this is Copyright (C) 2007 Blake Ramsdell, and you have a license to
-; do whatever you want with it, just tell me what you did and give me a
-; mention. If you want to sell it, and you make a billion dollars, then good
-; for you. You might at least throw a party and invite me.
-
-; The gist of it is pretty simple -- you have a ball, and the ball has an X
-; and a Y velocity. When it hits something, it bounces off of it. If the thing
-; that it hits is not a wall, then it erases it. Pretty dead-simple behavior.
-
-; I don't like the vertical movement -- there's a shortcut in here somewhere
-; to make it less computationally expensive I think. Right now it just does a
-; two byte add and subtract of $20.
-
-; The ball motion is also a bit weird looking. I don't know if this is an
-; artifact of the simulation environment combined with a normal tearing
-; artifact related to refresh or what.
-
-; Blake Ramsdell, May 2007
-
-init:
- lda #$fe
- sta $2         ; X velocity (0 = fast, ff = slow)
-                ; (low bit is direction, 0 = down or right, 1 = up or left)
- lda #$ee
- sta $3         ; Y velocity
-
-drawbox:
- lda #0         ; Use $0-$1 as a screen address for drawing the field
- sta $0
- lda #2
- sta $1
-
- ldx #$20       ; Loop $20 times
-boxloop:
- lda #2         ; Line color (red)
- sta $1ff,x     ; Top line
- sta $5df,x     ; Bottom line
- ldy #0
- sta ($0),y     ; Left line
- ldy #$1f
- sta ($0),y     ; Right line
-
- cpx #$1        ; If we're just before the bottom line...
- beq noblocks   ; Don't draw any blocks there
-
-
- lda #3         ; First block for this row, Cyan in color
- ldy #$17       ; It's at X position $17
- sta ($0),y     ; Draw it
-
- lda #4         ; Second block for this row, Purple in color
- iny            ; It's at the next X position
- sta ($0),y     ; Draw it
-
- lda #5         ; Third block for this row, Green in color
- iny            ; It's at the next X position
- sta ($0),y     ; Draw it
-
- lda #6         ; Fourth block for this row, Blue in color
- iny            ; It's at the next X position
- sta ($0),y     ; Draw it
-
-
-noblocks:
- clc            ; Get ready to increment the row, clear the carry for add
- lda $0         ; Get the low byte
- adc #$20       ; Add $20 to it for the next row
- sta $0         ; Put it back
- lda $1         ; Get the high byte
- adc #0         ; Factor in the carry
- sta $1         ; Put it back
-
- dex            ; Decrement the loop counter
- bne boxloop    ; Do it again unless it's zero
-
- ldx $2         ; Load the X velocity
- ldy $3         ; Load the Y velocity
-
- lda #$44       ; Pick a start point
- sta $0         ; Ball position low
- lda #$02
- sta $1         ; Ball position high
-
-drawball:
- txa            ; Preserve X
- pha
- lda #1         ; Ball color (white)
- ldx #0         ; Clear X for indirect addressing for writing to screen
- sta ($0,x)     ; Draw the ball
- pla            ; Restore X
- tax
-
-decloop:
- dex            ; Decrement the X velocity
- beq updatexpos ; If it's zero, time to adjust X
- dey            ; Decrement the Y velocity
- bne decloop    ; If it's not zero, loop, otherwise fall through to adjust Y
-
-updateypos:
- txa            ; Preserve X
- pha
- jsr clearball  ; Put background over the current ball position
-updateyposnoclear:
- lda $3         ; Get the Y velocity
- and #1         ; See if it's down
- bne moveup     ; If not, then it's up, otherwise fall through to down
-
-movedown:
- clc            ; Prepare for moving to the next Y line and doing the add
- lda $0         ; Low byte of the current ball position
- adc #$20       ; Next row
- sta $0         ; Put it back
- bcc ycollision ; If no carry, go on to check for collision
- inc $1         ; Had a carry, fix the high byte of the address
- bne ycollision ; Z flag is always clear ($1 will never be zero)
-
-moveup:
- sec            ; Prepare for moving to the previous Y line and subtracting
- lda $0         ; Low byte of the current ball position
- sbc #$20       ; Previous row
- sta $0         ; Put it back
- lda $1         ; High byte
- sbc #$0        ; Factor out the carry
- sta $1         ; Put it back
-
-ycollision:
- ldx #0         ; Prepare for indirect read
- lda ($0,x)     ; Get the current pixel at the new ball position
- bne ycollided  ; If it's not zero (the background color) then we hit
- ldy $3         ; Otherwise, load up the current Y velocity
- pla            ; Restore the X velocity
- tax
- jmp drawball   ; Back to the top
-
-ycollided:
- cmp #$2        ; Border color?
- beq ycollided2 ; If so, then we just bounce, don't eat a brick
-
-                ; Erase brick
- lda #0         ; Background color (black)
- sta ($0,x)     ; Erase it
-
-ycollided2:
- lda #1         ; Get ready to change direction
- eor $3         ; Flip the low bit on the Y velocity (change direction)
- sta $3         ; Put it back
- jmp updateyposnoclear  ; Go back to make sure we didn't hit anything else
-
-updatexpos:
- jsr clearball  ; Put background over the current ball position
-updatexposnoclear:
- lda $2         ; Get the current X velocity
- and #1         ; See if it's right by testing the low bit
- bne moveleft   ; If not, move left
-
-moveright:
- inc $0         ; Move right
- bne xcollision ; Z flag is always clear
-
-moveleft:
- dec $0         ; Move left
-
-xcollision:
- ldx #0         ; Prepare for indirect read
- lda ($0,x)     ; Get the current pixel at the new ball position
- bne xcollided  ; If it's not zero (the background color) then we hit
- ldx $2         ; Otherwise, load up the current X velocity
- jmp drawball   ; Back to the top
-
-xcollided:
- cmp #$2        ; Border color?
- beq xcollided2 ; If so, then we just bounce, don't eat a brick
-
-                ; Erase brick
- lda #0         ; Background color (black)
- sta ($0,x)     ; Erase it
-
-xcollided2:
- lda #1         ; Get ready to change direction
- eor $2         ; Flip the low bit on the X velocity (change direction)
- sta $2         ; Put it back
- jmp updatexposnoclear  ; Go back to make sure we didn't hit anything else
-
-clearball:
- lda #0         ; Background color (black)
- tax            ; Clear X for indirect
- sta ($0,x)     ; Black out the ball
- rts            ; Return to caller
-