romdevtools 0.71.1 → 0.84.0

package/src/platforms/gametank/lib/gt/gfx/sprites.c

@@ -0,0 +1,216 @@
+#include "sprites.h"
+#include "gametank.h"
+#include "banking.h"
+#include <zlib.h>
+#include "bank_nums.h"
+
+/*
+    For each sprite bank:
+        HEADS mask of which quadrants contain the anchor of a sheet
+        OCCUPIED mask of which quadrants are allocated
+        HEADS:4 | OCCUPIED:4
+*/
+static char bank_occupied[8] = { 0, 0, 0, 0, 0, 0, 0, 0};
+
+typedef union PointerUnion {
+    void* ptr;
+    struct {
+        char lsb, msb;
+    } b;
+} PointerUnion;
+
+#define SPRITE_SLOT_COUNT 32
+static char frametable_L[SPRITE_SLOT_COUNT];
+static char frametable_H[SPRITE_SLOT_COUNT];
+static char frametable_B[SPRITE_SLOT_COUNT];
+static char sprite_size_cache[SPRITE_SLOT_COUNT];
+
+#define HEAD_CORNER_NW 16
+#define HEAD_CORNER_NE 32
+#define HEAD_CORNER_SW 64
+#define HEAD_CORNER_SE 128
+
+void load_spritesheet(const unsigned char* spriteData, char srcBank, char ramBank) {
+    char oldFlags = flagsMirror;
+    char oldBanks = banksMirror;
+    char bankNum = ramBank & 7;
+    char xbit = (ramBank & 8) << 4;
+    char ybit = (ramBank & 16) << 3;
+    push_rom_bank();
+    change_rom_bank(srcBank);
+    flagsMirror = DMA_ENABLE;
+    *dma_flags = flagsMirror;
+    *vram_VX = 0;
+    *vram_VY = 0;
+    *vram_GX = xbit;
+    *vram_GY = ybit;
+    *vram_WIDTH = 1;
+    *vram_HEIGHT = 1;
+    *vram_START = 1;
+    *vram_START = 0;
+
+    flagsMirror = 0;
+    *dma_flags = flagsMirror;
+    banksMirror = bankflip | GRAM_PAGE(ramBank);
+    *bank_reg = banksMirror;
+    inflatemem(vram, spriteData);
+    flagsMirror = oldFlags;
+    banksMirror = oldBanks;
+    *dma_flags = flagsMirror;
+    *bank_reg = banksMirror;
+    pop_rom_bank();
+}
+
+void clear_spritebank(char bank) {
+    char oldFlags = flagsMirror;
+    char oldBanks = banksMirror;
+    char bankNum = bank & 7;
+    char xbit = (bank & 8) << 4;
+    char ybit = (bank & 16) << 3;
+    unsigned int i = 0;
+    flagsMirror = DMA_ENABLE;
+    *dma_flags = flagsMirror;
+    *vram_VX = 0;
+    *vram_VY = 0;
+    *vram_GX = xbit;
+    *vram_GY = ybit;
+    *vram_WIDTH = 1;
+    *vram_HEIGHT = 1;
+    *vram_START = 1;
+    *vram_START = 0;
+
+    flagsMirror = 0;
+    *dma_flags = flagsMirror;
+    banksMirror = bankflip | GRAM_PAGE(bank);
+    *bank_reg = banksMirror;
+    for(i = 0; i < 16384; i++) {
+        vram[i] = 0;
+    }
+    flagsMirror = oldFlags;
+    banksMirror = oldBanks;
+    *dma_flags = flagsMirror;
+    *bank_reg = banksMirror;
+}
+
+SpriteSlot allocate_sprite(const SpritePage* sprite) {
+    register const SpritePage* current;
+    register char mask, i, free_page;
+    push_rom_bank();
+    change_rom_bank(BANK_LOADERS);
+    mask = 0; i = 1;
+    for(current = sprite; current != 0; current = current->next) {
+        if(current->data != 0) {
+            mask |= i;
+        }
+        i = i << 1;
+    }
+    free_page = 0xFF;
+    for(i = 0; i < 8; ++i) {
+        if(!(bank_occupied[i] & mask)) {
+            bank_occupied[i] |= mask | HEAD_CORNER_NW;
+            free_page = i;
+            break;
+        }
+        if(mask == PAGE_MASK_FULL) {
+            continue;
+        }
+        if(mask != PAGE_MASK_WIDE) {
+            //if mask doesn't span horizontally
+            if(!(bank_occupied[i] & (mask << 1))) {
+                bank_occupied[i] |= ((mask << 1) & 0b1010) | HEAD_CORNER_NE;
+                free_page = i | SPRITE_OFFSET_X_MASK;
+                break;
+            }
+        }
+        if(mask != PAGE_MASK_TALL) {
+            //if mask doesn't span vertically
+            if(!(bank_occupied[i] & (mask << 2))) {
+                bank_occupied[i] |= ((mask << 2) & 0b1100) | HEAD_CORNER_SW;
+                free_page = i | SPRITE_OFFSET_Y_MASK;
+                break;
+            }
+        }
+        if(mask == 1) {
+            if(!(bank_occupied[i] & (mask << 3))) {
+                bank_occupied[i] |= ((mask << 3) & 0b1000) | HEAD_CORNER_SE;
+                free_page = i | SPRITE_OFFSET_XY_MASK;
+                break;
+            }
+        }
+    }
+
+    if(SPRITE_SLOT_INVALID(free_page)) {
+        pop_rom_bank();
+        return 0xFF;
+    }
+
+    sprite_size_cache[free_page] = mask;
+
+    i = 1;
+
+    mask = (free_page & SPRITE_OFFSET_XY_MASK);
+    for(current = sprite; current != 0; current = current->next) {
+        if(current->data != 0) {
+            load_spritesheet(current->data, current->bank, (free_page & 7) | mask);
+        }
+        i = i << 1;
+        mask += 8;
+    }
+    pop_rom_bank();
+    return free_page;
+}
+
+void set_sprite_frametable(SpriteSlot sprite, const Frame *frametable, char frametable_bank) {
+    frametable_B[sprite] = frametable_bank;
+    frametable_L[sprite] = (*((PointerUnion*)(&frametable))).b.lsb;
+    frametable_H[sprite] = (*((PointerUnion*)(&frametable))).b.msb;
+}
+
+void free_sprite(SpriteSlot slot) {
+    register char anchor, clear_mask, heads;
+    anchor = slot & SPRITE_OFFSET_XY_MASK;
+    heads = bank_occupied[slot & 7] >> 4;
+    clear_mask = ~heads;
+    switch(slot & SPRITE_OFFSET_XY_MASK) {
+        case 0:
+            clear_mask &= 0b1111;
+            clear_mask |= 1;
+            if((clear_mask & 0b0110) != 0b0110) {
+                clear_mask &= 7;
+            }
+            break;
+        case SPRITE_OFFSET_X_MASK:
+            clear_mask &= 0b1010;
+            clear_mask |= 2;
+            if(sprite_size_cache[slot] == 1) {
+                clear_mask &= 7;
+            }
+            break;
+        case SPRITE_OFFSET_Y_MASK:
+            clear_mask &= 0b1100;
+            clear_mask |= 4;
+            if(sprite_size_cache[slot] == 1) {
+                clear_mask &= 7;
+            }
+            break;
+        case SPRITE_OFFSET_XY_MASK:
+            clear_mask = 0b1000;
+            break;
+    }
+    clear_mask |= (clear_mask << 4);
+    bank_occupied[slot & 7] &= ~clear_mask;
+}
+
+Frame sprite_temp_frame;
+static PointerUnion dsf_frametable;
+
+void sprite_fetch_frame(SpriteSlot sprite, char frame) {
+    push_rom_bank();
+    change_rom_bank(frametable_B[sprite]);
+    dsf_frametable.b.lsb = frametable_L[sprite];
+    dsf_frametable.b.msb = frametable_H[sprite];
+    sprite_temp_frame = ((Frame*) dsf_frametable.ptr)[frame];
+    pop_rom_bank();
+}
+
+void pushRect();

package/src/platforms/gametank/lib/gt/gfx/sprites.h

@@ -0,0 +1,41 @@
+#ifndef SPRITES_H
+#define SPRITES_H
+#include "gfx_sys.h"
+
+#define SPRITE_SLOT_INVALID(x) (x & 0b11100000)
+
+//Sprite sheets MUST be one of these
+#define PAGE_MASK_SINGLE 1
+#define PAGE_MASK_WIDE 3
+#define PAGE_MASK_TALL 5
+#define PAGE_MASK_FULL 15
+
+#define SPRITE_OFFSET_X_MASK 8
+#define SPRITE_OFFSET_Y_MASK 16
+#define SPRITE_OFFSET_XY_MASK 24
+
+#define SPRITE_OFFSET_X(slot) ((slot & SPRITE_OFFSET_X_MASK) ? 128 : 0)
+#define SPRITE_OFFSET_Y(slot) ((slot & SPRITE_OFFSET_Y_MASK) ? 128 : 0)
+
+#define CONSTRUCT_SPRITE_SLOT(slot, quadrant) ((slot) | (quadrant))
+
+typedef char SpriteSlot;
+
+typedef struct SpritePage {
+    const unsigned char* data;
+    char bank;
+    const struct SpritePage* next;
+} SpritePage;
+
+extern Frame sprite_temp_frame;
+
+void load_spritesheet(const unsigned char* spriteData, char srcBank, char ramBank);
+void clear_spritebank(char bank);
+
+void sprite_fetch_frame(SpriteSlot sprite, char frame);
+
+SpriteSlot allocate_sprite(const SpritePage* sprite);
+void set_sprite_frametable(SpriteSlot sprite, const Frame *frametable, char frametable_bank);
+void free_sprite(SpriteSlot slot);
+
+#endif

package/src/platforms/gametank/lib/gt/init.c

@@ -0,0 +1,9 @@
+#include "gametank.h"
+#include "gfx_sys.h"
+#include "audio_coprocessor.h"
+#include "music.h"
+void sdk_init(void) {
+    init_graphics();
+    init_audio_coprocessor();
+    init_music();
+}

package/src/platforms/gametank/lib/gt/input.c

@@ -0,0 +1,26 @@
+#include "input.h"
+#include "gametank.h"
+
+int player1_buttons = 0, player1_old_buttons = 0, player1_new_buttons = 0;
+int player2_buttons = 0, player2_old_buttons = 0, player2_new_buttons = 0;
+
+#pragma optimize (push, off)
+void update_inputs(){
+    char inputsA, inputsB;
+    inputsA = *gamepad_2;
+    inputsA = *gamepad_1;
+    inputsB = *gamepad_1;
+
+    player1_old_buttons = player1_buttons;
+    player1_buttons = ~((((int) inputsB) << 8) | inputsA);
+    player1_buttons &= INPUT_MASK_ALL_KEYS;
+    player1_new_buttons = player1_buttons & ~player1_old_buttons;
+
+    inputsA = *gamepad_2;
+    inputsB = *gamepad_2;
+    player2_old_buttons = player2_buttons;
+    player2_buttons = ~((((int) inputsB) << 8) | inputsA);
+    player2_buttons &= INPUT_MASK_ALL_KEYS;
+    player2_new_buttons = player2_buttons & ~player2_old_buttons;
+}
+#pragma optimize (pop)

package/src/platforms/gametank/lib/gt/input.h

@@ -0,0 +1,20 @@
+#ifndef INPUT_H
+#define INPUT_H
+
+extern int player1_buttons, player1_old_buttons, player1_new_buttons;
+extern int player2_buttons, player2_old_buttons, player2_new_buttons;
+
+#define INPUT_MASK_UP		2056
+#define INPUT_MASK_DOWN		1028
+#define INPUT_MASK_LEFT		512
+#define INPUT_MASK_RIGHT	256
+#define INPUT_MASK_A		16
+#define INPUT_MASK_B		4096
+#define INPUT_MASK_C		8192
+#define INPUT_MASK_START	32
+#define INPUT_MASK_ALL_KEYS (INPUT_MASK_UP|INPUT_MASK_DOWN|INPUT_MASK_LEFT|INPUT_MASK_RIGHT|INPUT_MASK_A|INPUT_MASK_B|INPUT_MASK_C|INPUT_MASK_START)
+#define INPUT_MASK_ANY_DIRECTION (INPUT_MASK_UP|INPUT_MASK_DOWN|INPUT_MASK_LEFT|INPUT_MASK_RIGHT)
+
+void update_inputs();
+
+#endif

package/src/platforms/gametank/lib/gt/interrupt.s

@@ -0,0 +1,67 @@
+; ---------------------------------------------------------------------------
+; interrupt.s
+; ---------------------------------------------------------------------------
+;
+; Interrupt handler.
+;
+; Checks for a BRK instruction and returns from all valid interrupts.
+
+.include "modules_enabled.inc"
+
+.import   _frameflag
+.import   _draw_busy
+.export   _irq_int, _nmi_int
+
+.ifdef ENABLE_MODULE_DRAWQUEUE
+.import _next_draw_queue, _queue_end, _queue_pending, _queue_start
+.endif
+
+.pc02
+
+DMA_Start = $4006
+
+.segment  "CODE"
+
+.PC02                             ; Force 65C02 assembly mode
+
+; ---------------------------------------------------------------------------
+; Non-maskable interrupt (NMI) service routine
+
+_nmi_int:
+        PHA
+        LDA $1FFF
+        BNE nmi_done
+        STZ _frameflag
+nmi_done:
+        PLA
+        RTI
+
+; ---------------------------------------------------------------------------
+; Maskable interrupt (IRQ) service routine
+
+.ifdef ENABLE_MODULE_DRAWQUEUE
+_irq_int:
+        PHX                    ; Save X register contents to stack
+        PHA
+        PHY
+
+        ;make sure DMA isn't running then compare head and tail of queue
+        ;to determine whether there is more to process
+        STZ DMA_Start
+        STZ _queue_pending
+        STZ _draw_busy
+        LDA _queue_start
+        CMP _queue_end
+        BEQ finish_irq
+        JSR _next_draw_queue
+finish_irq:
+        PLY
+        PLA                    ; Restore accumulator contents
+        PLX                    ; Restore X register contents
+        RTI                    ; Return from all IRQ interrupts
+.else
+_irq_int:
+        STZ DMA_Start
+        STZ _draw_busy
+        RTI
+.endif

package/src/platforms/gametank/lib/gt/vectors.s

@@ -0,0 +1,14 @@
+; ---------------------------------------------------------------------------
+; vectors.s
+; ---------------------------------------------------------------------------
+;
+; Defines the interrupt vector table.
+
+.import    _init
+.import    _nmi_int, _irq_int
+
+.segment  "VECTORS"
+
+.addr      _nmi_int    ; NMI vector
+.addr      _init       ; Reset vector
+.addr      _irq_int    ; IRQ/BRK vector

package/src/platforms/gametank/lib/gt/wait.s

@@ -0,0 +1,53 @@
+; ---------------------------------------------------------------------------
+; wait.s
+; ---------------------------------------------------------------------------
+;
+; Wait for interrupt and return
+
+.export  _wait, _stop, _nop5, _nop10
+
+; ---------------------------------------------------------------------------
+; Wait for interrupt:  Forces the assembler to emit a WAI opcode ($CB)
+; ---------------------------------------------------------------------------
+
+.segment  "CODE"
+
+.proc _wait: near
+
+.byte      $CB                    ; Inserts a WAI opcode
+           RTS                    ; Return to caller
+
+.endproc
+
+; ---------------------------------------------------------------------------
+; Stop:  Forces the assembler to emit a STP opcode ($DB)
+; ---------------------------------------------------------------------------
+
+.proc _stop: near
+
+.byte      $DB                    ; Inserts a STP opcode
+
+.endproc
+
+.proc _nop5
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        RTS
+.endproc
+
+.proc _nop10
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        NOP
+        RTS
+.endproc