Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
10 kB · 206 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206; 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 firesSECTION "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 endsSECTION "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/hHeldKeysUpdateDisplay: 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 statehCurrentKeys: ds 1hNewKeys: 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 sizeUpdateJoypad: ; 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", ROMXTileData: 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 ; endENDM
; 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