; Joypad Example for the Nintendo Game Boy
; by Dave VanEe 2022
; Tested with RGBDS 1.0.0
; License: CC0 (https://creativecommons.org/publicdomain/zero/1.0/)
include "hardware.inc" ; Include hardware definitions so we can use nice names for things
; The VBlank vector is where execution is passed when the VBlank interrupt fires
SECTION "VBlank Vector", ROM0[$40]
VBlank:
; In this example we're only using VBlank as a convenient way to throttle the main loop
reti ; Return and enable interrupts (ret + ei)
; Define a section that starts at the point the bootrom execution ends
SECTION "Start", ROM0[$0100]
jp EntryPoint ; Jump past the header space to our actual code
ds $150-@, 0 ; Allocate space for RGBFIX to insert our ROM header by allocating
; the number of bytes from our current location (@) to the end of the
; header ($150)
EntryPoint:
di ; Disable interrupts during setup
ld sp, $e000 ; Set the stack pointer to the end of WRAM
; Turn off the LCD when it's safe to do so (during VBlank)
.waitVBlank
ldh a, [rLY] ; Read the LY register to check the current scanline
cp SCREEN_HEIGHT_PX ; Compare the current scanline to the first scanline of VBlank
jr c, .waitVBlank ; Loop as long as the carry flag is set
ld a, 0 ; Once we exit the loop we're safely in VBlank
ldh [rLCDC], a ; Disable the LCD (must be done during VBlank to protect the LCD)
ldh [hCurrentKeys], a ; Zero our current keys just to be safe (A is already zero from earlier)
; Copy our tiles to VRAM
ld hl, TileData ; Load the source address of our tiles into HL
ld de, STARTOF(VRAM); Load the destination address in VRAM into DE
ld bc, TileData.end - TileData ; Load the number of bytes to copy into BC
.copyLoop
ld a, [hl] ; Load a byte from the address HL points to into the register A
ld [de], a ; Load the byte in the A register to the address DE points to
inc hl ; Increment the source pointer in HL
inc de ; Increment the destination pointer in DE
dec bc ; Decrement the loop counter in BC
ld a, b ; Load the value in B into A
or c ; Logical OR the value in A (from B) with C
jr nz, .copyLoop ; If B and C are both zero, OR B will be zero, otherwise keep looping
; Fill the tilemap with tile zero
ld hl, TILEMAP0 ; Point HL to the first byte of the tilemap ($9800)
ld bc, TILEMAP1 - TILEMAP0 ; Load the size of the remaining tilemap into BC
ld d, 0 ; Load the value to fill the tilemap with into D
.clearLoop
ld [hl], d ; Load the value in D into the location pointed to by HL
inc hl ; Increment the destination pointer in HL
dec bc ; Decrement the loop counter in BC
ld a, b ; Load the value in B into A
or c ; Logical OR the value in A (from B) with C
jr nz, .clearLoop ; If B and C are both zero, OR B will be zero, otherwise keep looping
; Setup palettes and scrolling
ld a, %11100100 ; Define a 4-shade palette from darkest (11) to lightest (00)
ldh [rBGP], a ; Set the background palette
ld a, -32 ; Load -32 into the A register
ldh [rSCX], a ; Set SCX to center the joypad display horizontally
ld a, -60 ; Load -60 into the A register
ldh [rSCY], a ; Set SCY to position the joypad vertically as desired
; Setup the VBlank interrupt
ld a, IE_VBLANK ; Load the flag to enable the VBlank interrupt into A
ldh [rIE], a ; Load the prepared flag into the interrupt enable register
xor a ; Set A to zero
ldh [rIF], a ; Clear any lingering flags from the interrupt flag register to avoid false interrupts
ei ; enable interrupts!
; Combine flag constants defined in hardware.inc into a single value with logical ORs and load it into A
; Note that some of these constants (LCDC_OBJ_OFF, LCDC_WIN_OFF) are zero, but are included for clarity
ld a, LCDC_ON | LCDC_BLOCK01 | LCDC_BG_ON | LCDC_OBJ_OFF | LCDC_WIN_OFF
ldh [rLCDC], a ; Enable and configure the LCD to show the background
LoopForever:
halt ; Halt the CPU, waiting until an interrupt fires (this will sync our loop with VBlank)
call UpdateJoypad ; Call the routine which polls the joypad and stores the state
call UpdateDisplay ; Call the routine which updates the display based on the joypad state
jr LoopForever ; Loop forever
; Update the tilemap to reflect the joypad state as stored in hPressedKeys/hHeldKeys
UpdateDisplay:
ld hl, TilemapLocations ; Point HL to our table of tilemap/tile entries for the buttons
ldh a, [hCurrentKeys] ; Load the byte of current key states into A
ld c, a ; ... and then move it to the C register
.nextButton
ld a, l ; Due to register pressure, instead of using a register as a loop counter, we check the
cp LOW(TilemapLocations.end) ; low byte of the TilemapLocations pointer to see when we've reached the end
ret z ; If we've reached the end of the table we're done, return
srl c ; Shift C right logically, pushing the state of the next button into the carry flag
ld b, 0 ; Preload B with tile index offset for unpressed buttons
jr nc, .notPressed ; Skip the next instruction if the button we're checking isn't pressed
ld b, $10 ; Change the tile index offset in B to $10 to use the 'pressed' tiles
.notPressed
.loop
ld a, [hli] ; Load the low byte of the next TilemapLocations entry
or a ; Check for the zero terminator value
jr z, .nextButton ; If the value is zero jump to process the next button
ld e, a ; Load the low byte of the pointer into E
ld a, [hli] ; Get the high byte of the pointer
ld d, a ; ... and store it in D (DE now points to VRAM where we want to write a tile)
.waitVRAM
ldh a, [rSTAT] ; Check the STAT register to figure out which mode the LCD is in
and STAT_BUSY ; AND the value to see if VRAM access is safe
jr nz, .waitVRAM ; Loop until VRAM access is safe
ld a, [hli] ; Load the tile index we'd like to write
add b ; Add the B offset, which will be 0 for unpressed buttons, and $10 for pressed buttons
ld [de], a ; Write the tile index to the tilemap
jr .loop ; Jump to process the next entry in the TilemapLocations table for this button
SECTION "Joypad Variables", HRAM
; Reserve space in HRAM to track the joypad state
hCurrentKeys: ds 1
hNewKeys: ds 1
SECTION "Joypad Routine", ROM0
; Update the newly pressed keys (hNewKeys) and the held keys (hCurrentKeys) in memory
; Note: This routine is written to be easier to understand, not to be optimized for speed or size
UpdateJoypad:
; Poll half the controller
ld a, JOYP_GET_BUTTONS ; Load a flag into A to select reading the buttons
ldh [rP1], a ; Write the flag to P1 to select which buttons to read
ldh a, [rP1] ; Perform a few dummy reads to allow the inputs to stabilize
ldh a, [rP1] ; ...
ldh a, [rP1] ; ...
ldh a, [rP1] ; ...
ldh a, [rP1] ; ...
ldh a, [rP1] ; The final read of the register contains the key state we'll use
or $f0 ; Set the upper 4 bits, and leave the action button states in the lower 4 bits
ld b, a ; Store the state of the action buttons in B
ld a, JOYP_GET_CTRL_PAD ; Load a flag into A to select reading the dpad
ldh [rP1], a ; Write the flag to P1 to select which buttons to read
call .knownRet ; Call a known `ret` instruction to give the inputs to stabilize
ldh a, [rP1] ; Perform a few dummy reads to allow the inputs to stabilize
ldh a, [rP1] ; ...
ldh a, [rP1] ; ...
ldh a, [rP1] ; ...
ldh a, [rP1] ; ...
ldh a, [rP1] ; The final read of the register contains the key state we'll use
or $f0 ; Set the upper 4 bits, and leave the dpad state in the lower 4 bits
swap a ; Swap the high/low nibbles, putting the dpad state in the high nibble
xor b ; A now contains the pressed action buttons and dpad directions
ld b, a ; Move the key states to B
ld a, JOYP_GET_NONE ; Load a flag into A to read nothing
ldh [rP1], a ; Write the flag to P1 to disable button reading
ldh a, [hCurrentKeys] ; Load the previous button+dpad state from HRAM
xor b ; A now contains the keys that changed state
and b ; A now contains keys that were just pressed
ldh [hNewKeys], a ; Store the newly pressed keys in HRAM
ld a, b ; Move the current key state back to A
ldh [hCurrentKeys], a ; Store the current key state in HRAM
.knownRet
ret
SECTION "Tile Data", ROMX
TileData:
incbin "joypad-tiles.2bpp"
.end
SECTION "Tilemap Locations", ROMX
; Define a macro (provided by Rangi, thanks!) to easily specify the coordinates and IDs of the
; tiles that make up the joypad display.
MACRO bmap ; y, x, tile_id
rept _NARG / 3
dw TILEMAP0 + ((\1) * TILEMAP_WIDTH) + (\2)
db \3
shift 3
endr
db $00 ; end
ENDM
; Each button has a zero-terminated list of entries for the tiles used to draw that button, with
; each entry made up of a tilemap address (little endian) and a tile index.
TilemapLocations:
.A bmap 0,10,$06, 0,11,$07, 1,10,$08, 1,11,$09
.B bmap 1, 7,$06, 1, 8,$07, 2, 7,$08, 2, 8,$09
.Select bmap 4, 3,$05
.Start bmap 4, 5,$05
.Right bmap 1, 2,$03
.Left bmap 1, 0,$02
.Up bmap 0, 1,$01
.Down bmap 2, 1,$04
.end
