Simple SNES shoot-'em-up game.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

819 lines
18 KiB

.INCLUDE "header.asm"
.INCLUDE "init.asm"
.INCLUDE "registers.asm"
; Memory layout:
; 0000-000F: scratch space for functions.
; 0010-0011: controller state of joypad #1.
; 0012-0013: controller state of joypad #2.
; 0014-0016: 24-bit counter of vblanks.
; 0017-0019: RGB color values to use for background color, from [0-31].
; 001A-001B: 16-bit pointer to next random byte.
; [gap]
; 0020-0021: (x, y) coordinates of player.
; 0022: shot cooldown timer.
; 0023: next-shot state.
; [gap]
; 0030-008F: {sprite, x, y, x-velocity, y-velocity, unused} per shot.
; If sprite is 0, the shot is disabled.
; [gap]
; Sprite table buffers -- copied each frame to OAM during VBlank, using DMA.
; 1000-11FF: table 1 (4 bytes each: x/y coord, tile #, flip/priority/palette)
; 1200-121F: table 2 (2 bits each: high x-coord bit, size)
; 1220-12A0: scratch table. One byte per sprite for high x-coord & size.
.define joy1 $10
.define joy2 $12
.define vBlankCounter $14
.define backgroundRed $17
.define backgroundGreen $18
.define backgroundBlue $19
.define randomBytePtr $1A
.define playerX $20
.define playerY $21
.define shotCooldown $22
.define nextShotState $23
.define shotArray $30
.define shotArrayLength 16
.define shotSize 6
.define numSprites 128
.define spriteTableStart $1000
.define spriteTable1Size $200
.define spriteTable2Start $1200
.define spriteTableSize $220
.define spriteTableScratchStart $1220
; Sets A to 8-bit (& enables 8-bit "B" register).
.MACRO SetA8Bit
sep #%00100000 ; 8-bit A/B.
.ENDM
; Sets A to 16-bit.
.MACRO SetA16Bit
rep #%00100000 ; 16-bit A.
.ENDM
; Sets X/Y to 16-bit.
.MACRO SetXY16Bit
rep #%00010000 ; 16-bit X/Y.
.ENDM
; Stores result to A.
; Assumes 16-bit X & 8-bit A.
; Modifies X.
; Updates randomBytePtr.
.MACRO GetRandomByte
ldx randomBytePtr
lda $028000, X ; $028000: beginning of ROM bank 2.
inx
cpx #$8000 ; This is the size of the entire ROM bank.
bne +++
ldx #0
+++
stx randomBytePtr
.ENDM
.BANK 0 SLOT 0
.ORG 0
.SECTION "MainCode"
Start:
InitializeSNES
; By default we assume 16-bit X/Y and 8-bit A.
; If any code wants to change this, it's expected to do so itself,
; and to change them back to the defaults before returning.
SetXY16Bit
SetA8Bit
jsr LoadPaletteAndTileData
jsr InitializeSpriteTables
jsr InitializeWorld
; Set screen mode: 16x16 tiles for backgrounds, mode 1.
lda #%11000001
sta BGMODE
; Set sprite size to 16x16 (small) and 32x32 (large).
lda #%01100000
sta OAMSIZE
; Main screen: enable sprites & BG3.
lda #%00010100
sta MSENABLE
; Turn on the screen.
; Format: x000bbbb
; x: 0 = screen on, 1 = screen off, bbbb: Brightness ($0-$F)
lda #%00001111
sta INIDISP
jmp MainLoop
LoadPaletteAndTileData:
; For more details on DMA, see:
; http://wiki.superfamicom.org/snes/show/Grog%27s+Guide+to+DMA+and+HDMA+on+the+SNES
; http://wiki.superfamicom.org/snes/show/Making+a+Small+Game+-+Tic-Tac-Toe
;
; A lot of the graphics-related registers are explained in Qwertie's doc:
; http://emu-docs.org/Super%20NES/General/snesdoc.html
; ... but be careful, because there are some errors in this doc.
;
; bazz's tutorial (available from http://wiki.superfamicom.org/snes/) is
; quite helpful with palette / sprites / DMA, especially starting at
; http://wiki.superfamicom.org/snes/show/Working+with+VRAM+-+Loading+the+Palette
; Initialize the palette memory in a loop.
; We could also do this with a DMA transfer (like we do with the tile data
; below), but it seems overkill for just a few bytes. :)
; TODO(mcmillen): do it with a DMA transfer.
; First, sprite palette data:
ldx #0
lda #128 ; Palette entries for sprites start at 128.
sta CGADDR
-
lda.l SpritePalette, X
sta CGDATA
inx
cpx #32 ; 32 bytes of palette data.
bne -
; Now, BG3 palette data.
; Palette entries for BG3 start at 0.
ldx #0
lda #0
sta CGADDR
-
lda.l TilePalette, X
sta CGDATA
inx
cpx #8 ; 8 bytes of palette data.
bne -
; TODO(mcmillen): make the "DMA stuff into VRAM" a macro or function.
; Set VMADDR to where we want the DMA to start. We'll store sprite data
; at the beginning of VRAM.
ldx #$0000
stx VMADDR
; DMA 0 source address & bank.
ldx #SpriteData
stx DMA0SRC
lda #:SpriteData
sta DMA0SRCBANK
; DMA 0 transfer size. Equal to the size of sprites32.pic.
ldx #2048
stx DMA0SIZE
; DMA 0 control register.
; Transfer type 001 = 2 addresses, LH.
lda #%00000001
sta DMA0CTRL
; DMA 0 destination.
lda #$18 ; The upper byte is assumed to be $21, so this is $2118 & $2119.
sta DMA0DST
; Enable DMA channel 0.
lda #%00000001
sta DMAENABLE
; Store background tile data at byte $2000 of VRAM.
; (VMADDR is a word address, so multiply by 2 to get the byte address.)
ldx #$1000
stx VMADDR
; DMA 0 source address & bank.
ldx #TileData
stx DMA0SRC
lda #:TileData
sta DMA0SRCBANK
; DMA 0 transfer size. Equal to the size of tiles.pic.
ldx #512
stx DMA0SIZE
; DMA 0 control register.
; Transfer type 001 = 2 addresses, LH.
lda #%00000001
sta DMA0CTRL
; DMA 0 destination.
lda #$18 ; The upper byte is assumed to be $21, so this is $2118 & $2119.
sta DMA0DST
; Enable DMA channel 0.
lda #%00000001
sta DMAENABLE
; Tell the system that the BG3 tilemap starts at $4000.
lda #%00100000
sta BG3TILEMAP
; ... and that the background tile data for BG3 starts at $2000.
lda #%00000001
sta BG34NBA
; Set up the BG3 tilemap.
; VRAM write mode: increments the address every time we write a word.
lda #%10000000
sta VMAIN
; Set word address for accessing VRAM.
ldx #$2000 ; BG 3 tilemap starts here. (Byte address $4000.)
stx VMADDR
; Now write entries into the tile map.
ldy #0
-
GetRandomByte
sta $00
ldx #$0000 ; This is a blank tile.
; 1 in 8 chance that we choose a non-blank tile.
bit #%00000111
bne +
ldx #$0002
bit #%10000000
bne +
ldx #$8002 ; Flip vertically.
+
stx VMDATA
iny
; The tile map is 32x32 (1024 entries).
cpy #1024
bne -
rts
InitializeSpriteTables:
; This page is a good reference on SNES sprite formats:
; http://wiki.superfamicom.org/snes/show/SNES+Sprites
; It uses the same approach we're using, in which we keep a buffer of the
; sprite tables in RAM, and DMA the sprite tables to the system's OAM
; during VBlank.
SetA16Bit
ldx #$0000
; Fill sprite table 1. 4 bytes per sprite, laid out as follows:
; Byte 1: xxxxxxxx x: X coordinate
; Byte 2: yyyyyyyy y: Y coordinate
; Byte 3: cccccccc c: Starting tile #
; Byte 4: vhoopppc v: vertical flip h: horizontal flip o: priority bits
; p: palette #
lda #$01
-
sta spriteTableStart, X
.rept 4
inx
.endr
cpx #spriteTable1Size
bne -
; Fill sprite table 2. 2 bits per sprite, like so:
; bits 0,2,4,6 - High bit of the sprite's x-coordinate.
; bits 1,3,5,7 - Toggle Sprite size: 0 - small size 1 - large size
; Setting all the high bits keeps the sprites offscreen.
lda #$FFFF
-
sta spriteTableStart, X
inx
inx
cpx #spriteTableSize
bne -
SetA8Bit
rts
InitializeWorld:
; Start the background color as a dark blue.
lda #4
sta backgroundBlue
; Player's initial starting location.
lda #(256 / 4)
sta playerX
lda #((224 - 32) / 2)
sta playerY
rts
MainLoop:
lda #%10000001 ; Enable NMI interrupt & auto joypad read.
sta NMITIMEN
wai ; Wait for interrupt.
lda #%00000001 ; Disable NMI interrupt while processing.
sta NMITIMEN
jsr JoypadRead
jsr JoypadHandler
jsr UpdateWorld
jsr UpdateSprites
jsr FillSecondarySpriteTable
jsr SetBackgroundColor
jmp MainLoop
JoypadRead:
; Load joypad registers into RAM for easy inspection & manipulation.
-
lda HVBJOY
bit #$01 ; If auto-joypad read is happening, loop.
bne -
ldx JOY1L
stx joy1
ldx JOY2L
stx joy2
rts
JoypadHandler:
JoypadUp:
lda joy1 + 1
bit #$08 ; Up
beq JoypadDown ; Button not pressed.
lda playerY
cmp #0
beq JoypadDown ; Value saturated.
dec playerY
dec playerY
JoypadDown:
lda joy1 + 1
bit #$04 ; Down
beq JoypadLeft ; Button not pressed.
lda playerY
cmp #(224 - 32)
beq JoypadLeft ; Value saturated.
inc playerY
inc playerY
JoypadLeft:
lda joy1 + 1
bit #$02 ; Left
beq JoypadRight ; Button not pressed.
lda playerX
cmp #0
beq JoypadRight ; Value saturated.
dec playerX
dec playerX
JoypadRight:
lda joy1 + 1
bit #$01 ; Right
beq JoypadStart ; Button not pressed.
lda playerX
cmp #(256 - 32)
beq JoypadStart ; Value saturated.
inc playerX
inc playerX
JoypadStart:
lda joy1 + 1
bit #$10 ; Start
beq JoypadSelect ; Button not pressed.
lda backgroundRed
cmp #31
beq JoypadSelect ; Value saturated.
inc backgroundRed
JoypadSelect:
lda joy1 + 1
bit #$20 ; Select
beq JoypadY ; Button not pressed.
lda backgroundRed
cmp #0
beq JoypadY ; Value saturated.
dec backgroundRed
JoypadY:
lda joy1 + 1
bit #$40 ; Y
beq JoypadX ; Button not pressed.
lda backgroundGreen
cmp #0
beq JoypadX ; Value saturated.
dec backgroundGreen
JoypadX:
lda joy1
bit #$40 ; X
beq JoypadL ; Button not pressed.
lda backgroundGreen
cmp #31
beq JoypadL ; Value saturated.
inc backgroundGreen
JoypadL:
lda joy1
bit #$20 ; L
beq JoypadR ; Button not pressed.
lda backgroundBlue
cmp #0
beq JoypadR ; Value saturated.
dec backgroundBlue
JoypadR:
lda joy1
bit #$10 ; R
beq JoypadB ; Button not pressed.
lda backgroundBlue
cmp #31
beq JoypadB ; Value saturated.
inc backgroundBlue
JoypadB:
lda joy1 + 1
bit #$80 ; B
beq JoypadDone
jsr MaybeShoot
JoypadDone:
rts
MaybeShoot:
; If the cooldown timer is non-zero, don't shoot.
lda shotCooldown
cmp #0
bne MaybeShootDone
; Find the first empty spot in the shots array.
ldx #shotArray
-
lda 0, X
cmp #0
beq +
.rept shotSize
inx
.endr
; If we went all the way to the end, bail out.
cpx #(shotArray + shotArrayLength * shotSize)
beq MaybeShootDone
jmp -
+
; Enable shot; set its position based on player position.
; TODO(mcmillen): it might be easier/faster to keep N arrays: one for each
; field of shot (shotSpriteArray, shotXArray, shotYArray, ...)
lda #8 ; Sprite number.
sta 0, X
lda playerX
adc #20
sta 1, X
lda playerY
sta 2, X
; x-velocity.
lda #6
sta 3, X
; y-velocity.
lda nextShotState
cmp #1
beq +
lda #2
sta 4, X
inc nextShotState
jmp ++
+
lda #-2
sta 4, X
dec nextShotState
++
; Set cooldown timer.
lda #10
sta shotCooldown
MaybeShootDone:
rts
UpdateWorld:
; Update shot cooldown.
lda shotCooldown
cmp #0
beq +
dec A
sta shotCooldown
+
ldx #0
; Update shot position.
UpdateShot:
lda shotArray, X
cmp #0
beq ShotDone
; Add to the x-coordinate. If the carry bit is set, we went off the edge
; of the screen, so disable the shot.
lda shotArray + 3, X ; x-velocity.
sta $00
bit #%10000000 ; Check whether the velocity is negative.
bne UpdateShotWithNegativeXVelocity
lda shotArray + 1, X
clc
adc $00
bcs DisableShot
sta shotArray + 1, X ; Store new x-coord.
jmp UpdateShotY
UpdateShotWithNegativeXVelocity:
; TODO(mcmillen): wrap sprites when they go negative here, like we do
; with y-velocities.
lda shotArray + 1, X ; Current x.
clc
adc $00
bcc DisableShot
sta shotArray + 1, X
jmp UpdateShotY
UpdateShotY:
; Add to the y-coordinate.
lda shotArray + 4, X ; y-velocity.
sta $00
bit #%10000000 ; Check whether the velocity is negative.
bne UpdateShotWithNegativeYVelocity
lda shotArray + 2, X
adc $00
cmp #224
bcs DisableShot
sta shotArray + 2, X ; Store new y-coord.
jmp ShotDone
UpdateShotWithNegativeYVelocity:
lda shotArray + 2, X ; Current y.
cmp #224
bcs + ; If the shot was "off the top" before moving, maybe we'll reap it.
adc $00 ; Otherwise, just update it,
sta shotArray + 2, X ; save the result,
jmp ShotDone ; and we know it shouldn't be reaped.
+
adc $00
dec A ; Two's complement means that we need to -1 again in this case.
cmp #224
bcc DisableShot ; If it's now wrapped around, reap it.
sta shotArray + 2, X
jmp ShotDone
DisableShot:
stz shotArray, X
ShotDone:
; TODO(mcmillen): in places where we .rept inx (etc), is it faster to use
; actual addition?
.rept shotSize
inx
.endr
cpx #(shotArrayLength * shotSize)
bne UpdateShot
; Make the background scroll. Horizontal over time; vertical depending on
; player's y-coordinate.
lda vBlankCounter
sta BG3HOFS
lda vBlankCounter + 1
sta BG3HOFS
lda playerY
.rept 3
lsr
.endr
sta BG3VOFS
stz BG3VOFS
rts
UpdateSprites:
; Zero out the scratch space for the secondary sprite table.
ldx #0
-
stz spriteTableScratchStart, X
inx
cpx #numSprites
bne -
ldx #0 ; Index into sprite table 1.
ldy #0 ; Index into sprite table 2.
; Copy player coords into sprite table.
lda playerX
sta spriteTableStart, X
lda playerY
sta spriteTableStart + 1, X
lda #0
sta spriteTableStart + 2, X
; Set priority bits so that the sprite is drawn in front.
lda #%00110000
sta spriteTableStart + 3, X
lda #%11000000 ; Enable large sprite.
sta spriteTableScratchStart, Y
.rept 4
inx
.endr
iny
; Now add shots.
sty $00 ; Save sprite table 2 index.
ldy #0 ; Index into shotArray.
-
lda shotArray, Y
cmp #0
beq + ; If not enabled, skip to next shot.
; Update sprite table 1.
sta spriteTableStart + 2, X ; sprite number
lda shotArray + 1, Y
sta spriteTableStart, X ; x
lda shotArray + 2, Y
sta spriteTableStart + 1, X ; y
; Update secondary sprite table.
phy ; Save shotArray index.
ldy $00
lda #%11000000
sta spriteTableScratchStart, Y
iny
sty $00
ply ; Restore shotArrayIndex.
.rept 4
inx
.endr
+
.rept shotSize
iny
.endr
cpy #(shotArrayLength * shotSize)
bne -
; Now clear out the unused entries in the sprite table.
-
cpx #spriteTable1Size
beq +
lda #1
sta spriteTableStart, X
.rept 4
inx
.endr
+
rts
FillSecondarySpriteTable:
; The secondary sprite table wants 2 bits for each sprite: one to set the
; sprite's size, and one that's the high bit of the sprite's x-coordinate.
; It's annoying to deal with bitfields when thinking about business logic,
; so the spriteTableScratch array contains one byte for each sprite, in
; which the two most significant bits are the "size" and "upper x" bits.
; This function is meant to be called after UpdateWorld, and packs those
; bytes into the actual bitfield that the OAM wants for the secondary
; sprite table.
;
; The expected format of every byte in the scratch sprite table is:
; sx------ s = size (0 = small, 1 = large)
; x = flipped high x-coordinate (so 1 behaves like "enable").
ldx #0 ; Index into input table.
ldy #0 ; Index into output table.
-
stz $00 ; Current byte; filled out by a set of 4 input table entries.
.rept 4
; For each byte, the lower-order bits correspond to the lower-numbered
; sprites; therefore we insert the current sprite's bits "at the top"
; and shift them right for each successive sprite.
lsr $00
lsr $00
lda spriteTableScratchStart, X
ora $00
sta $00
inx
.endr
lda $00
eor #%01010101
sta spriteTable2Start, Y
iny
cpx #numSprites
bne -
rts
SetBackgroundColor:
; The background-color bytes are (R, G, B), each ranging from [0-31].
; The palette color format is 15-bit: [0bbbbbgg][gggrrrrr]
; Set the background color.
; Entry 0 corresponds to the SNES background color.
stz CGADDR
; Compute and the low-order byte and store it in CGDATA.
lda backgroundGreen
.rept 5
asl
.endr
ora backgroundRed
sta CGDATA
; Compute the high-order byte and store it in CGDATA.
lda backgroundBlue
.rept 2
asl
.endr
sta $00
lda backgroundGreen
.rept 3
lsr
.endr
ora $00
sta CGDATA
rts
VBlankHandler:
jsr VBlankCounter
jsr DMASpriteTables
rti
VBlankCounter:
; Increment a counter of how many VBlanks we've done.
; This is a 24-bit counter. At 60 vblanks/second, this will take
; 77 hours to wrap around; that's good enough for me :)
inc vBlankCounter
bne +
inc vBlankCounter + 1
bne +
inc vBlankCounter + 2
+
rts
DMASpriteTables:
; Store at the base OAM address.
ldx #$0000
stx OAMADDR
; Default DMA control; destination $2104 (OAM data register).
stz DMA0CTRL
lda #$04
sta DMA0DST
; Our sprites start at $0100 in bank 0 and are #$220 bytes long.
ldx #spriteTableStart
stx DMA0SRC
stz DMA0SRCBANK
ldx #spriteTableSize
stx DMA0SIZE
; Kick off the DMA transfer.
lda #%00000001
sta DMAENABLE
rts
.ENDS
; Bank 1 is used for our graphics assets.
.BANK 1 SLOT 0
.ORG 0
.SECTION "GraphicsData"
SpriteData:
.INCBIN "sprites32.pic"
SpritePalette:
.INCBIN "sprites32.clr"
TileData:
.INCBIN "tiles.pic"
TilePalette:
.INCBIN "tiles.clr"
.ENDS
; Fill an entire bank with random numbers.
.SEED 1
.BANK 2 SLOT 0
.ORG 0
.SECTION "RandomBytes"
.DBRND 32 * 1024, 0, 255
.ENDS