VASTLY improved how I generate tiles and tiledata

.gitignore

@@ -82,3 +82,5 @@ out.c
 out.c.png
 
 emulator
+
+bgb/*

archive/main.c

@@ -0,0 +1,235 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "main.h"
+
+/*
+
+inline uint8_t mainGetChar(char c) {
+  return c - TEXTBOX_FONT_START + FONT_DATA_POSITION;
+}
+
+inline void mainBufferCard(uint8_t card, uint8_t *tiles) {
+  uint8_t suit, number;
+
+  if(card >= CARD_DECK_SIZE) {
+    tiles[0] = mainGetChar('N');
+    tiles[1] = mainGetChar('A');
+    return;
+  }
+  
+  suit = cardGetSuit(card);
+  number = cardGetNumber(card);
+
+  switch(suit) {
+    case CARD_SUIT_CLUBS:
+      tiles[0] = mainGetChar('C');
+      break;
+    case CARD_SUIT_DIAMONDS:
+      tiles[0] = mainGetChar('D');
+      break;
+    case CARD_SUIT_HEARTS:
+      tiles[0] = mainGetChar('H');
+      break;
+    case CARD_SUIT_SPADES:
+      tiles[0] = mainGetChar('S');
+      break;
+  }
+
+  switch(number) {
+    case CARD_TWO:
+      tiles[1] = mainGetChar('2');
+      break;
+    case CARD_THREE:
+      tiles[1] = mainGetChar('3');
+      break;
+    case CARD_FOUR:
+      tiles[1] = mainGetChar('4');
+      break;
+    case CARD_FIVE:
+      tiles[1] = mainGetChar('5');
+      break;
+    case CARD_SIX:
+      tiles[1] = mainGetChar('6');
+      break;
+    case CARD_SEVEN:
+      tiles[1] = mainGetChar('7');
+      break;
+    case CARD_EIGHT:
+      tiles[1] = mainGetChar('8');
+      break;
+    case CARD_NINE:
+      tiles[1] = mainGetChar('9');
+      break;
+    case CARD_TEN:
+      tiles[1] = mainGetChar('T');
+      break;
+    case CARD_JACK:
+      tiles[1] = mainGetChar('J');
+      break;
+    case CARD_QUEEN:
+      tiles[1] = mainGetChar('Q');
+      break;
+    case CARD_KING:
+      tiles[1] = mainGetChar('K');
+      break;
+    case CARD_ACE:
+      tiles[1] = mainGetChar('A');
+      break;
+  }
+}
+
+inline void mainDebugDraw() {
+  uint8_t j, i, n;
+
+  // DEBUG DRAW
+  uint8_t tiles[15];
+  char buffer[6];
+  buffer[0] = '\0';
+
+  for(j = 0; j < POKER_PLAYER_COUNT; j++) {
+    n = 0;
+
+    if(j == POKER_PLAYER_BETTER) {
+      tiles[n++] = mainGetChar('>');
+    } else {
+      tiles[n++] = COMMON_TILE_3;
+    }
+
+    mainBufferCard(POKER_PLAYERS[j].hand[0], tiles+n);
+    n+=2;
+    mainBufferCard(POKER_PLAYERS[j].hand[1], tiles+n);
+    n+=2;
+
+    tiles[n++] = COMMON_TILE_3;
+
+    if((POKER_PLAYERS[j].state & POKER_PLAYER_STATE_FOLDED) == 0) {
+      tiles[n++] = COMMON_TILE_3;
+    } else {
+      tiles[n++] = mainGetChar('F');
+    }
+
+    if((POKER_PLAYERS[j].state & POKER_PLAYER_STATE_HAS_BET_THIS_ROUND) == 0) {
+      tiles[n++] = COMMON_TILE_3;
+    } else {
+      tiles[n++] = mainGetChar('H');
+    }
+
+    if((POKER_PLAYERS[j].state & POKER_PLAYER_STATE_OUT) == 0) {
+      tiles[n++] = COMMON_TILE_3;
+    } else {
+      tiles[n++] = mainGetChar('O');
+    }
+
+    tiles[n++] = COMMON_TILE_3;
+
+    // Print chips
+    sprintf(buffer, "%u", (uint16_t)POKER_PLAYERS[j].chips);
+    for(i = 0; i < strlen(buffer); i++) {
+      tiles[n++] = mainGetChar(buffer[i]);
+    }
+
+    while(n < 15) tiles[n++] = COMMON_TILE_3;
+    set_bkg_tiles(0x00, j, n - 1, 1, tiles);
+  }
+
+  for(j = 0; j < POKER_COMMUNITY_SIZE_MAX; j++) {
+    if(j >= POKER_COMMUNITY_SIZE) {
+      tiles[j*2] = COMMON_TILE_3;
+      tiles[(j*2) + 1] = COMMON_TILE_3;
+    } else {
+      mainBufferCard(POKER_COMMUNITY[j], tiles + (j * 2));
+    }
+  }
+
+  set_bkg_tiles(0x00, POKER_PLAYER_COUNT + 1, POKER_COMMUNITY_SIZE_MAX * 2, 1, tiles);
+
+  
+  // Print Pot
+  n = 0;
+  sprintf(buffer, "%u", (uint16_t)POKER_POTS[POKER_POT_CURRENT].chips);
+  for(i = 0; i < strlen(buffer); i++) {
+    tiles[n++] = mainGetChar(buffer[i]);
+  }
+  while(n < 5) tiles[n++] = COMMON_TILE_3;
+  set_bkg_tiles(0x00, POKER_PLAYER_COUNT + 2, n, 1, tiles);
+}
+
+*/
+
+void main() {
+  int16_t j;
+  uint8_t filled[GB_BACKGROUND_COLUMNS*GB_BACKGROUND_ROWS];
+
+  // Set up the GAMEBOY's registers.
+  disable_interrupts();
+  DISPLAY_OFF;
+  LCDC_REG = LCDCF_OFF | LCDCF_BG8000 | LCDCF_BG9800 | LCDCF_BGON;
+  // Set the background color palette register
+  BGP_REG = OBP0_REG = OBP1_REG = 0xE4U;
+
+  // Init the random seed
+  initarand(DIV_REG);
+
+  // Init things
+  spriteTilesetBuffer(0x00);
+  spriteFontBuffer(TEXTBOX_SPRITE_FONT_POSITION);
+  spriteBorderBuffer(TEXTBOX_SPRITE_BORDER_POSITION);
+  spriteCardsBuffer(TEXTBOX_SPRITE_BORDER_POSITION + BORDER_IMAGE_TILES);
+
+  conversationTextboxInit();
+  conversationQueueInit();
+  pokerInit();
+
+  // Fill screen white
+  for(j = 0; j < GB_BACKGROUND_COLUMNS * GB_BACKGROUND_ROWS; j++) filled[j] = TILESET_WHITE;
+  set_bkg_tiles(0x00, 0x00, GB_BACKGROUND_COLUMNS, GB_BACKGROUND_ROWS, filled);
+  SCX_REG = 0x00;
+  SCY_REG = 0x00;
+
+  // Card Test
+  uint8_t cardTiles[4 * 6];
+  spriteCardBufferTiles(
+    TEXTBOX_SPRITE_BORDER_POSITION+BORDER_IMAGE_TILES,
+    cardTiles,
+    CARD_HEARTS_TWO
+  );
+  set_bkg_tiles(0x00, 0x00, 4, 6, cardTiles);
+
+  // Now turn the screen on
+  DISPLAY_ON;
+  enable_interrupts();
+  wait_vbl_done();
+
+  // Begin game
+  conversationQueueNext();
+
+  // Begin the loop
+  while(1) {
+    // Perform non-graphical code updates
+    wait_vbl_done();
+
+    // Update the input state
+    INPUT_LAST = INPUT_STATE;
+    INPUT_STATE = joypad();
+    INPUT_PRESSED = (~INPUT_LAST) & INPUT_STATE;
+
+    // Tick time.
+    timeUpdate();
+
+    // Update conversation pause effect
+    conversationPauseUpdate();
+
+    // Update question box and textbox
+    questionBoxUpdate();
+    conversationTextboxUpdate();
+
+    // Update conversation fade effect
+    conversationFadeUpdate();
+    // mainDebugDraw();
+  }
+}

package.json

@@ -8,7 +8,7 @@
   "scripts": {
     "clean": "node ./scripts/clean",
     "build": "npm run clean && node ./scripts/build",
-    "start": "npm run build && bgb64.exe ./build/Penny.gb"
+    "start": "npm run build && wine ./bgb/bgb64.exe ./build/Penny.gb"
   },
   "dependencies": {
     "pngjs": "^6.0.0",

scripts/png2gb.js

@@ -11,8 +11,9 @@ const {
 const getPixelValue = (pixel) => {
   if(pixel.g === 188) return 0;
   if(pixel.g === 172) return 1;
-  if(pixel.g === 98) return 2;
+  if(pixel.g === 98 || pixel.g === 145) return 2;
   if(pixel.g === 56) return 3;
+  if(pixel.a === 0) return 0;
   throw new Error();
 }
 
@@ -29,8 +30,15 @@ const png2gb = (fileIn, dirOut, name) => {
       const r = png.data[idx];
       const g = png.data[idx+1];
       const b = png.data[idx+2];
-      const value = getPixelValue({ r, g, b });
-      pixels.push(value);
+      const a = png.data[idx+3];
+      const pixel = { r, g, b, a };
+      try {
+        const value = getPixelValue(pixel);
+        pixels.push(value);
+      } catch(e) {
+        console.error(`Failed to get color for `, x, y, idx, fileIn, pixel);
+        throw e;
+      }
     }
   }
 

src/conversation/fade.c

@@ -43,25 +43,25 @@ void conversationFadeUpdate() {
   if(diff == FADE_STEP) {
     // First step
     BGP_REG = (
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_BLACK ? COMMON_SHADE_DARK :
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_WHITE ? COMMON_SHADE_BRIGHT :
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_FROM_BLACK ? COMMON_SHADE_DARKER :
-      COMMON_SHADE_BRIGHTER
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_BLACK ? TILESET_SHADE_DARK :
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_WHITE ? TILESET_SHADE_BRIGHT :
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_FROM_BLACK ? TILESET_SHADE_DARKER :
+      TILESET_SHADE_BRIGHTER
     );
   } else if(diff == FADE_STEP * 2) {
     // Second step
     BGP_REG = (
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_BLACK ? COMMON_SHADE_DARKER :
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_WHITE ? COMMON_SHADE_BRIGHTER :
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_FROM_BLACK ? COMMON_SHADE_DARK :
-      COMMON_SHADE_BRIGHT
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_BLACK ? TILESET_SHADE_DARKER :
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_WHITE ? TILESET_SHADE_BRIGHTER :
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_FROM_BLACK ? TILESET_SHADE_DARK :
+      TILESET_SHADE_BRIGHT
     );
   } else if(diff == FADE_STEP * 3) {
     // Third step
     BGP_REG = (
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_BLACK ? COMMON_SHADE_BLACK :
-      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_WHITE ? COMMON_SHADE_WHITE :
-      COMMON_SHADE_NORMAL
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_BLACK ? TILESET_SHADE_BLACK :
+      TIME_FUTURE_TYPE == TIME_FUTURE_TYPE_FADE_TO_WHITE ? TILESET_SHADE_WHITE :
+      TILESET_SHADE_NORMAL
     );
     TIME_FUTURE_TYPE = TIME_FUTURE_TYPE_NULL;
     conversationQueueNext();

src/conversation/fade.h

@@ -9,7 +9,7 @@
 #include "../libs.h"
 #include "queue.h"
 #include "pause.h"
-#include "../display/common.h"
+#include "../sprites/spritetileset.h"
 
 // This is how many frames it takes to change each shade.
 #define FADE_STEP 20

src/conversation/frame.c

@@ -1,40 +0,0 @@
-/**
- * Copyright (c) 2022 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "frame.h"
-
-inline void frameBuffer(
-  uint8_t buffer[],
-  uint8_t bufferWidth, uint8_t bufferHeight,
-  uint8_t fill
-) {
-  uint8_t i, j, max;
-  max = bufferWidth * bufferHeight;
-
-  // Corners
-  buffer[0] = BORDER_TILE_TOP_LEFT;
-  buffer[bufferWidth-1] = BORDER_TILE_TOP_RIGHT;
-  buffer[max-1] = BORDER_TILE_BOTTOM_RIGHT;
-  buffer[max-bufferWidth] = BORDER_TILE_BOTTOM_LEFT;
-
-  // Edges
-  for(i = 1; i < bufferWidth-1; i++) {
-    buffer[i] = BORDER_TILE_TOP_CENTER;
-    buffer[max - 1 - i] = BORDER_TILE_BOTTOM_CENTER;
-  }
-  for(i = 1; i < bufferHeight - 1; i++) {
-    buffer[bufferWidth * i] = BORDER_TILE_CENTER_LEFT;
-    buffer[bufferWidth * (i+1) - 1] = BORDER_TILE_CENTER_RIGHT;
-  }
-
-  // Inner
-  for(j = 1; j < bufferHeight-1; j++) {
-    for(i = 1; i < bufferWidth-1; i++) {
-      buffer[i + (j * bufferWidth)] = fill;
-    }
-  }
-}

src/conversation/frame.h

@@ -1,28 +0,0 @@
-/**
- * Copyright (c) 2022 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "../libs.h"
-#include "../util.h"
-#include "../display/common.h"
-#include "../display/tilemap.h"
-
-#define BORDER_TILE_TOP_LEFT BORDER_DATA_POSITION
-#define BORDER_TILE_TOP_CENTER BORDER_TILE_TOP_LEFT + 1
-#define BORDER_TILE_TOP_RIGHT BORDER_TILE_TOP_CENTER + 1
-#define BORDER_TILE_CENTER_LEFT BORDER_TILE_TOP_RIGHT + 1
-#define BORDER_TILE_CENTER BORDER_TILE_CENTER_LEFT + 1
-#define BORDER_TILE_CENTER_RIGHT BORDER_TILE_CENTER + 1
-#define BORDER_TILE_BOTTOM_LEFT BORDER_TILE_CENTER_RIGHT + 1
-#define BORDER_TILE_BOTTOM_CENTER BORDER_TILE_BOTTOM_LEFT + 1
-#define BORDER_TILE_BOTTOM_RIGHT BORDER_TILE_BOTTOM_CENTER + 1
-
-inline void frameBuffer(
-  uint8_t buffer[],
-  uint8_t bufferWidth, uint8_t bufferHeight,
-  uint8_t fill
-);

src/conversation/questionbox.c

@@ -43,7 +43,7 @@ void questionBoxSetOptions(char *title, char **options, uint8_t count) {
   TEXTBOX_STATE |= TEXTBOX_STATE_IS_QUESTION;
 
   // Repurpose old array and draw arrow
-  spaces[0] = QUESTION_BOX_CURSOR - TEXTBOX_FONT_START + FONT_DATA_POSITION;
+  spaces[0] = spriteFontTileFromChar(QUESTION_BOX_CURSOR);
   set_bkg_tiles(0x01, TEXTBOX_WIN_Y + 0x02, 1, 1, spaces);
 }
 
@@ -72,9 +72,9 @@ inline void questionBoxUpdate() {
   // Decide where to render arrow
   for(i = 0; i < QUESTION_BOX_OPTION_COUNT; i++) {
     if(i == QUESTION_BOX_OPTION_CURRENT) {
-      tiles[0] = QUESTION_BOX_CURSOR - TEXTBOX_FONT_START + FONT_DATA_POSITION;
+      tiles[0] = spriteFontTileFromChar(QUESTION_BOX_CURSOR);
     } else {
-      tiles[0] = ' ' - TEXTBOX_FONT_START + FONT_DATA_POSITION;
+      tiles[0] = spriteFontTileFromChar(' ');
     }
     set_bkg_tiles(
       0x01 + ((i % 0x02) * QUESTION_BOX_QUESTION_SPACES),

src/conversation/questionbox.h

@@ -9,9 +9,9 @@
 #include "../libs.h"
 #include "../util.h"
 #include "../input.h"
-#include "../display/common.h"
-#include "../display/tilemap.h"
-#include "frame.h"
+#include "../sprites/spritefont.h"
+#include "../sprites/spriteborder.h"
+#include "../sprites/spritetileset.h"
 #include "textbox.h"
 
 #define QUESTION_BOX_OPTIONS_MAX ((TEXTBOX_CHAR_ROWS-1)*2)

src/conversation/textbox.c

@@ -15,15 +15,8 @@ uint8_t TEXTBOX_STATE;
 uint8_t TEXTBOX_SCROLL;
 
 inline void conversationTextboxInit() {
-  uint8_t i;
-  uint8_t TEXTBOX_TILES[TEXTBOX_TILES_MAX];
-
   // Reset textbox state
   TEXTBOX_STATE = 0;
-
-  // Setup window data
-  set_win_data(FONT_DATA_POSITION, FONT_IMAGE_TILES, FONT_IMAGE);
-  set_win_data(BORDER_DATA_POSITION, BORDER_IMAGE_TILES, BORDER_IMAGE);
 }
 
 void conversationTextboxSetText(char *text) {
@@ -87,21 +80,22 @@ void conversationTextboxSetText(char *text) {
 }
 
 inline void textboxFillBlank() {
-  uint8_t TEXTBOX_TILES[TEXTBOX_WIDTH_IN_TILES * TEXTBOX_HEIGHT_IN_TILES];
+  uint8_t tiles[TEXTBOX_WIDTH_IN_TILES * TEXTBOX_HEIGHT_IN_TILES];
 
-  frameBuffer(TEXTBOX_TILES, TEXTBOX_WIDTH_IN_TILES, TEXTBOX_HEIGHT_IN_TILES, TEXTBOX_TILE_BLANK);
+  spriteBorderBufferEdges(
+    tiles, TEXTBOX_WIDTH_IN_TILES, TEXTBOX_HEIGHT_IN_TILES, SPRITE_TILESET_WHITE
+  );
 
   set_bkg_tiles(
     0x00, TEXTBOX_WIN_Y,
     TEXTBOX_WIDTH_IN_TILES, TEXTBOX_HEIGHT_IN_TILES,
-    TEXTBOX_TILES
+    tiles
   );
 }
 
 inline void conversationTextboxUpdate() {
-  uint8_t i;
+  uint8_t i, tile;
   char c;
-  uint8_t tiles[1];
 
   // Is the textbox visible?
   if((TEXTBOX_STATE & TEXTBOX_STATE_VISIBLE) == 0) return;
@@ -133,13 +127,13 @@ inline void conversationTextboxUpdate() {
   if(TEXTBOX_SCROLL == TEXTBOX_CHARS_MAX) {
     TEXTBOX_STATE |= TEXTBOX_STATE_SCROLLED;
   } else {
-    tiles[0] = c - TEXTBOX_FONT_START + FONT_DATA_POSITION;
+    tile = spriteFontTileFromChar(c);
 
     set_bkg_tiles(
       0x01 + (TEXTBOX_SCROLL % TEXTBOX_CHARS_PER_ROW),
       TEXTBOX_WIN_Y + 0x01 + (TEXTBOX_SCROLL / TEXTBOX_CHARS_PER_ROW),
       1, 1,
-      tiles
+      &tile
     );
 
     TEXTBOX_SCROLL++;

src/conversation/textbox.h

@@ -9,10 +9,10 @@
 #include "../libs.h"
 #include "../util.h"
 #include "../input.h"
-#include "../display/common.h"
-#include "../display/tilemap.h"
+#include "../sprites/spriteborder.h"
+#include "../sprites/spritefont.h"
+#include "../sprites/spritetileset.h"
 #include "queue.h"
-#include "frame.h"
 
 #define TEXTBOX_STATE_VISIBLE (1 << 0)
 #define TEXTBOX_STATE_SCROLLED (1 << 1)
@@ -29,12 +29,9 @@
 
 #define TEXTBOX_TILES_PER_ROW TEXTBOX_WIDTH_IN_TILES
 #define TEXTBOX_TILES_ROWS 3
-#define TEXTBOX_TILE_BLANK COMMON_TILE_3
 
 #define TEXTBOX_SCROLL_ROWS_MAX 14
 
-#define TEXTBOX_FONT_START 33
-
 #define TEXTBOX_WIN_Y (18 - TEXTBOX_HEIGHT_IN_TILES)
 
 extern char TEXTBOX_TEXTS[TEXTBOX_SCROLL_ROWS_MAX * TEXTBOX_CHARS_PER_ROW];

src/display/common.c

@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2022 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "common.h"
-
-const uint8_t COMMON_TILES[] = {
-  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
-  0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,
-  0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-};
-
-inline void commonTilesInit() {
-  set_bkg_data(0x00, COMMON_TILE_COUNT, COMMON_TILES);
-}

src/display/common.h

@@ -1,37 +0,0 @@
-/**
- * Copyright (c) 2022 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "../libs.h"
-
-#define COMMON_TILE_COUNT 0x04
-
-#define COMMON_TILE_0 0x00
-#define COMMON_TILE_1 0x01
-#define COMMON_TILE_2 0x02
-#define COMMON_TILE_3 0x03
-
-// Shades are mapped where each set of 4 colors is mapped to two bits that will
-// specify its darkness. Higher = Darker, Lower = Brighter
- // 11 11 11 11
-#define COMMON_SHADE_BLACK 0xFF
-// 11 11 11 10
-#define COMMON_SHADE_DARKER 0xFE 
-// 11 11 10 01
-#define COMMON_SHADE_DARK 0xF9
-// 11 10 01 00
-#define COMMON_SHADE_NORMAL 0xE4
-// 10 01 00 00
-#define COMMON_SHADE_BRIGHT 0x90
-// 01 00 00 00
-#define COMMON_SHADE_BRIGHTER 0x40
-// 00 00 00 00
-#define COMMON_SHADE_WHITE 0x00
-
-extern const uint8_t COMMON_TILES[];
-
-inline void commonTilesInit();

src/display/tilemap.h

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2022 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "FONT.h"
-#include "BORDER.h"
-// #include "SM.h"
-
-#define FONT_DATA_POSITION 0x80
-#define BORDER_DATA_POSITION FONT_DATA_POSITION+FONT_IMAGE_TILES
-// #define SM_DATA_POSITION BORDER_DATA_POSITION+BORDER_IMAGE_TILES

src/main.c

@@ -7,156 +7,6 @@
 
 #include "main.h"
 
-inline uint8_t mainGetChar(char c) {
-  return c - TEXTBOX_FONT_START + FONT_DATA_POSITION;
-}
-
-inline void mainBufferCard(uint8_t card, uint8_t *tiles) {
-  uint8_t suit, number;
-
-  if(card >= CARD_DECK_SIZE) {
-    tiles[0] = mainGetChar('N');
-    tiles[1] = mainGetChar('A');
-    return;
-  }
-  
-  suit = cardGetSuit(card);
-  number = cardGetNumber(card);
-
-  switch(suit) {
-    case CARD_SUIT_CLUBS:
-      tiles[0] = mainGetChar('C');
-      break;
-    case CARD_SUIT_DIAMONDS:
-      tiles[0] = mainGetChar('D');
-      break;
-    case CARD_SUIT_HEARTS:
-      tiles[0] = mainGetChar('H');
-      break;
-    case CARD_SUIT_SPADES:
-      tiles[0] = mainGetChar('S');
-      break;
-  }
-
-  switch(number) {
-    case CARD_TWO:
-      tiles[1] = mainGetChar('2');
-      break;
-    case CARD_THREE:
-      tiles[1] = mainGetChar('3');
-      break;
-    case CARD_FOUR:
-      tiles[1] = mainGetChar('4');
-      break;
-    case CARD_FIVE:
-      tiles[1] = mainGetChar('5');
-      break;
-    case CARD_SIX:
-      tiles[1] = mainGetChar('6');
-      break;
-    case CARD_SEVEN:
-      tiles[1] = mainGetChar('7');
-      break;
-    case CARD_EIGHT:
-      tiles[1] = mainGetChar('8');
-      break;
-    case CARD_NINE:
-      tiles[1] = mainGetChar('9');
-      break;
-    case CARD_TEN:
-      tiles[1] = mainGetChar('T');
-      break;
-    case CARD_JACK:
-      tiles[1] = mainGetChar('J');
-      break;
-    case CARD_QUEEN:
-      tiles[1] = mainGetChar('Q');
-      break;
-    case CARD_KING:
-      tiles[1] = mainGetChar('K');
-      break;
-    case CARD_ACE:
-      tiles[1] = mainGetChar('A');
-      break;
-  }
-}
-
-inline void mainDebugDraw() {
-  uint8_t j, i, n;
-
-  // DEBUG DRAW
-  uint8_t tiles[15];
-  char buffer[6];
-  buffer[0] = '\0';
-
-  for(j = 0; j < POKER_PLAYER_COUNT; j++) {
-    n = 0;
-
-    if(j == POKER_PLAYER_BETTER) {
-      tiles[n++] = mainGetChar('>');
-    } else {
-      tiles[n++] = COMMON_TILE_3;
-    }
-
-    mainBufferCard(POKER_PLAYERS[j].hand[0], tiles+n);
-    n+=2;
-    mainBufferCard(POKER_PLAYERS[j].hand[1], tiles+n);
-    n+=2;
-
-    tiles[n++] = COMMON_TILE_3;
-
-    if((POKER_PLAYERS[j].state & POKER_PLAYER_STATE_FOLDED) == 0) {
-      tiles[n++] = COMMON_TILE_3;
-    } else {
-      tiles[n++] = mainGetChar('F');
-    }
-
-    if((POKER_PLAYERS[j].state & POKER_PLAYER_STATE_HAS_BET_THIS_ROUND) == 0) {
-      tiles[n++] = COMMON_TILE_3;
-    } else {
-      tiles[n++] = mainGetChar('H');
-    }
-
-    if((POKER_PLAYERS[j].state & POKER_PLAYER_STATE_OUT) == 0) {
-      tiles[n++] = COMMON_TILE_3;
-    } else {
-      tiles[n++] = mainGetChar('O');
-    }
-
-    tiles[n++] = COMMON_TILE_3;
-
-    // Print chips
-    sprintf(buffer, "%u", (uint16_t)POKER_PLAYERS[j].chips);
-    for(i = 0; i < strlen(buffer); i++) {
-      tiles[n++] = mainGetChar(buffer[i]);
-    }
-
-    while(n < 15) tiles[n++] = COMMON_TILE_3;
-    set_bkg_tiles(0x00, j, n - 1, 1, tiles);
-  }
-
-  for(j = 0; j < POKER_COMMUNITY_SIZE_MAX; j++) {
-    if(j >= POKER_COMMUNITY_SIZE) {
-      tiles[j*2] = COMMON_TILE_3;
-      tiles[(j*2) + 1] = COMMON_TILE_3;
-    } else {
-      mainBufferCard(POKER_COMMUNITY[j], tiles + (j * 2));
-    }
-  }
-
-  set_bkg_tiles(0x00, POKER_PLAYER_COUNT + 1, POKER_COMMUNITY_SIZE_MAX * 2, 1, tiles);
-
-  
-  // Print Pot
-  n = 0;
-  sprintf(buffer, "%u", (uint16_t)POKER_POTS[POKER_POT_CURRENT].chips);
-  for(i = 0; i < strlen(buffer); i++) {
-    tiles[n++] = mainGetChar(buffer[i]);
-  }
-  while(n < 5) tiles[n++] = COMMON_TILE_3;
-  set_bkg_tiles(0x00, POKER_PLAYER_COUNT + 2, n, 1, tiles);
-}
-
 void main() {
   int16_t j;
   uint8_t filled[GB_BACKGROUND_COLUMNS*GB_BACKGROUND_ROWS];
@@ -164,7 +14,8 @@ void main() {
   // Set up the GAMEBOY's registers.
   disable_interrupts();
   DISPLAY_OFF;
-  LCDC_REG = LCDCF_OFF | LCDCF_WIN9C00 | LCDCF_BG8800 | LCDCF_BG9800 | LCDCF_BGON;
+  LCDC_REG = LCDCF_OFF | LCDCF_BG8000 | LCDCF_BG9800 | LCDCF_BGON;
+
   // Set the background color palette register
   BGP_REG = OBP0_REG = OBP1_REG = 0xE4U;
 
@@ -172,17 +23,28 @@ void main() {
   initarand(DIV_REG);
 
   // Init things
-  commonTilesInit();
+  spriteTilesetBuffer();
+  spriteFontBuffer();
+  spriteBorderBuffer();
+  spriteCardsBuffer();
+
   conversationTextboxInit();
   conversationQueueInit();
   pokerInit();
 
   // Fill screen white
-  for(j = 0; j < GB_BACKGROUND_COLUMNS * GB_BACKGROUND_ROWS; j++) filled[j] = COMMON_TILE_3;
+  for(j = 0; j < GB_BACKGROUND_COLUMNS * GB_BACKGROUND_ROWS; j++) {
+    filled[j] = SPRITE_TILESET_WHITE;
+  }
   set_bkg_tiles(0x00, 0x00, GB_BACKGROUND_COLUMNS, GB_BACKGROUND_ROWS, filled);
   SCX_REG = 0x00;
   SCY_REG = 0x00;
 
+  // Card Test
+  uint8_t cardTiles[SPRITE_CARD_TILE_COUNT];
+  spriteCardBufferTiles(cardTiles, CARD_HEARTS_TWO);
+  set_bkg_tiles(0x00, 0x00, SPRITE_CARD_WIDTH, SPRITE_CARD_HEIGHT, cardTiles);
+
   // Now turn the screen on
   DISPLAY_ON;
   enable_interrupts();
@@ -213,6 +75,6 @@ void main() {
 
     // Update conversation fade effect
     conversationFadeUpdate();
-    mainDebugDraw();
+    // mainDebugDraw();
   }
 }

src/main.h

@@ -12,8 +12,6 @@
 
 #include "SM.h"
 
-#include "display/common.h"
-#include "display/tilemap.h"
 #include "poker/poker.h"
 #include "poker/card.h"
 #include "conversation/fade.h"
@@ -22,6 +20,8 @@
 #include "conversation/textbox.h"
 #include "conversation/questionbox.h"
 
+#include "sprites/spritecards.h"
+
 #define GB_BACKGROUND_COLUMNS 0x20
 #define GB_BACKGROUND_ROWS 0x20
 

src/sprites/spriteborder.c

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "spriteborder.h"
+
+inline void spriteBorderBuffer() {
+  spriteBuffer(SPRITE_BORDER_VRAM_START, BORDER_IMAGE_TILES, BORDER_IMAGE);
+}
+
+inline void spriteBorderBufferEdges(
+  uint8_t *buffer, uint8_t bufferWidth, uint8_t bufferHeight, uint8_t fill
+) {
+  uint8_t i, j, max;
+  max = bufferWidth * bufferHeight;
+
+  // Corners
+  buffer[0] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_TOP_LEFT;
+  buffer[bufferWidth-1] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_TOP_RIGHT;
+  buffer[max-1] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_BOTTOM_RIGHT;
+  buffer[max-bufferWidth] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_BOTTOM_LEFT;
+
+  // Edges
+  for(i = 1; i < bufferWidth-1; i++) {
+    buffer[i] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_BOTTOM_TOP;
+    buffer[max - 1 - i] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_BOTTOM_TOP;
+  }
+  for(i = 1; i < bufferHeight - 1; i++) {
+    buffer[bufferWidth * i] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_LEFT_RIGHT;
+    buffer[bufferWidth * (i+1) - 1] = SPRITE_BORDER_VRAM_START + SPRITE_BORDER_LEFT_RIGHT;
+  }
+
+  // Inner
+  if(fill != 0xFF) {
+    for(j = 1; j < bufferHeight-1; j++) {
+      for(i = 1; i < bufferWidth-1; i++) {
+        buffer[i + (j * bufferWidth)] = fill;
+      }
+    }
+  }
+}

src/sprites/spriteborder.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+#include "sprites.h"
+#include "BORDER.h"
+#include "spritefont.h"
+
+#define SPRITE_BORDER_VRAM_START SPRITE_FONT_VRAM_END
+#define SPRITE_BORDER_VRAM_END SPRITE_BORDER_VRAM_START + BORDER_IMAGE_TILES
+
+#define SPRITE_BORDER_TOP_LEFT 0x00
+#define SPRITE_BORDER_TOP_RIGHT 0x01
+#define SPRITE_BORDER_LEFT_RIGHT 0x02
+#define SPRITE_BORDER_BOTTOM_LEFT 0x03
+#define SPRITE_BORDER_BOTTOM_RIGHT 0x04
+#define SPRITE_BORDER_BOTTOM_TOP 0x05
+
+/**
+ * Buffer the border sprite into VRAM.
+ */
+inline void spriteBorderBuffer();
+
+/**
+ * Buffer the edges of a border to a tile buffer.
+ * 
+ * @param buffer Buffer to write the tiles in to.
+ * @param bufferWidth Width of the buffer that you want to write.
+ * @param bufferHeight Height of the buffer that you want to write.
+ * @param fill NULL for no fill, otherwise TILE INDEX of fill within border.
+ */
+inline void spriteBorderBufferEdges(
+  uint8_t *buffer, uint8_t bufferWidth, uint8_t bufferHeight, uint8_t fill
+);

src/sprites/spritecards.c

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "spritecards.h"
+
+const uint8_t SPRITE_HEARTS_ACE[SPRITE_CARD_TILE_COUNT] = {
+  SPRITE_CARD_ACE_TOP, SPRITE_CARD_TOP, SPRITE_CARD_TOP, SPRITE_CARD_TOP_RIGHT,
+  SPRITE_CARD_LEFT, SPRITE_CARD_BLANK, SPRITE_CARD_BLANK, SPRITE_CARD_RIGHT,
+  SPRITE_CARD_LEFT, SPRITE_CARD_HEART_BIG_TOP_LEFT, SPRITE_CARD_HEART_BIG_TOP_RIGHT, SPRITE_CARD_RIGHT,
+  SPRITE_CARD_LEFT, SPRITE_CARD_HEART_BIG_BOTTOM_LEFT, SPRITE_CARD_HEART_BIG_BOTTOM_RIGHT, SPRITE_CARD_RIGHT,
+  SPRITE_CARD_LEFT, SPRITE_CARD_BLANK, SPRITE_CARD_BLANK, SPRITE_CARD_RIGHT,
+  SPRITE_CARD_BOTTOM_LEFT, SPRITE_CARD_BOTTOM, SPRITE_CARD_BOTTOM, SPRITE_CARD_BOTTOM_RIGHT
+};
+
+// const uint8_t *SPRITE_CARD_LIST[] = {
+//   SPRITE_HEARTS_ACE
+// };
+
+inline void spriteCardsBuffer() {
+  spriteBuffer(SPRITE_CARD_VRAM_START, CARDS_TILES_IMAGE_TILES, CARDS_TILES_IMAGE);
+}
+
+inline uint8_t * spriteCardsForCard(uint8_t card) {
+  return SPRITE_HEARTS_ACE;
+}
+
+inline void spriteCardBufferTiles(uint8_t *buffer, uint8_t card) {
+  uint8_t i;
+  uint8_t *spriteTiles = spriteCardsForCard(card);
+  while(i != SPRITE_CARD_TILE_COUNT) {
+    buffer[i] = spriteTiles[i];
+    i++;
+  }
+}

src/sprites/spritecards.h

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+#include "CARDS_TILES.h"
+#include "../poker/card.h"
+#include "spritetileset.h"
+#include "sprites.h"
+#include "spriteborder.h"
+
+#define SPRITE_CARD_VRAM_START SPRITE_BORDER_VRAM_END
+
+#define SPRITE_CARD_BLANK SPRITE_TILESET_WHITE
+
+#define SPRITE_CARD_ACE_TOP SPRITE_CARD_VRAM_START + 0
+#define SPRITE_CARD_ACE_BOTTOM SPRITE_CARD_ACE_TOP/* ref */
+#define SPRITE_CARD_TWO_TOP SPRITE_CARD_VRAM_START + 1
+#define SPRITE_CARD_TWO_BOTTOM SPRITE_CARD_TWO_TOP/* ref */
+#define SPRITE_CARD_THREE_TOP SPRITE_CARD_VRAM_START + 2
+#define SPRITE_CARD_THREE_BOTTOM SPRITE_CARD_THREE_TOP/* ref */
+#define SPRITE_CARD_FOUR_TOP SPRITE_CARD_VRAM_START + 3
+#define SPRITE_CARD_FOUR_BOTTOM SPRITE_CARD_THREE_TOP/* ref */
+#define SPRITE_CARD_FIVE_TOP SPRITE_CARD_VRAM_START + 4
+#define SPRITE_CARD_FIVE_BOTTOM SPRITE_CARD_FIVE_TOP/* ref */
+#define SPRITE_CARD_SIX_TOP SPRITE_CARD_VRAM_START + 5
+#define SPRITE_CARD_SIX_BOTTOM SPRITE_CARD_SIX_TOP/* ref */
+#define SPRITE_CARD_SEVEN_TOP SPRITE_CARD_VRAM_START + 6
+#define SPRITE_CARD_SEVEN_BOTTOM SPRITE_CARD_SEVEN_TOP/* ref */
+#define SPRITE_CARD_EIGHT_TOP SPRITE_CARD_VRAM_START + 7
+#define SPRITE_CARD_EIGHT_BOTTOM SPRITE_CARD_EIGHT_TOP/* ref */
+#define SPRITE_CARD_NINE_TOP SPRITE_CARD_VRAM_START + 8
+#define SPRITE_CARD_NINE_BOTTOM SPRITE_CARD_NINE_TOP/* ref */
+#define SPRITE_CARD_TEN_TOP SPRITE_CARD_VRAM_START + 9
+#define SPRITE_CARD_TEN_BOTTOM/* ref */
+
+#define SPRITE_CARD_TOP SPRITE_CARD_VRAM_START + 11
+#define SPRITE_CARD_TOP_RIGHT SPRITE_CARD_VRAM_START + 10
+#define SPRITE_CARD_LEFT SPRITE_CARD_TOP/* ref */
+#define SPRITE_CARD_RIGHT SPRITE_CARD_TOP/* ref */
+#define SPRITE_CARD_BOTTOM_LEFT SPRITE_CARD_TOP_RIGHT/* ref */
+#define SPRITE_CARD_BOTTOM_RIGHT SPRITE_CARD_TOP_RIGHT/* ref */
+#define SPRITE_CARD_BOTTOM SPRITE_CARD_TOP/* ref */
+
+#define SPRITE_CARD_DIAMOND_BIG_TOP_LEFT SPRITE_CARD_VRAM_START + 12
+#define SPRITE_CARD_DIAMOND_BIG_TOP_RIGHT SPRITE_CARD_DIAMOND_BIG_TOP_LEFT/* ref */
+#define SPRITE_CARD_DIAMOND_BIG_BOTTOM_LEFT SPRITE_CARD_DIAMOND_BIG_TOP_LEFT/* ref */
+#define SPRITE_CARD_DIAMOND_BIG_BOTTOM_RIGHT SPRITE_CARD_DIAMOND_BIG_TOP_LEFT/* ref */
+#define SPRITE_CARD_HEART_BIG_TOP_LEFT SPRITE_CARD_VRAM_START + 13
+#define SPRITE_CARD_HEART_BIG_TOP_RIGHT SPRITE_CARD_HEART_BIG_TOP_LEFT/* ref */
+#define SPRITE_CARD_HEART_BIG_BOTTOM_LEFT SPRITE_CARD_DIAMOND_BIG_BOTTOM_LEFT
+#define SPRITE_CARD_HEART_BIG_BOTTOM_RIGHT SPRITE_CARD_DIAMOND_BIG_BOTTOM_RIGHT
+
+#define SPRITE_CARD_WIDTH 4
+#define SPRITE_CARD_HEIGHT 6
+#define SPRITE_CARD_TILE_COUNT (SPRITE_CARD_WIDTH * SPRITE_CARD_HEIGHT)
+
+extern const uint8_t SPRITE_HEARTS_ACE[];
+
+inline void spriteCardsBuffer();
+
+inline uint8_t * spriteCardsForCard(uint8_t card);
+
+inline void spriteCardBufferTiles(uint8_t *buffer, uint8_t card);

src/sprites/spritefont.c

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "spritefont.h"
+
+inline void spriteFontBuffer() {
+  spriteBuffer(SPRITE_FONT_VRAM_START, FONT_IMAGE_TILES, FONT_IMAGE);
+}
+
+inline uint8_t spriteFontTileFromChar(char character) {
+  return character - SPRITE_FONT_FIRST_CHARACTER + SPRITE_FONT_VRAM_START;
+}

src/sprites/spritefont.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+#include "FONT.h"
+#include "sprites.h"
+#include "spritetileset.h"
+
+#define SPRITE_FONT_FIRST_CHARACTER 33
+
+#define SPRITE_FONT_VRAM_START SPRITE_TILESET_VRAM_END
+#define SPRITE_FONT_VRAM_END SPRITE_FONT_VRAM_START + FONT_IMAGE_TILES
+
+/**
+ * Buffer the font tiles to VRAM.
+ */
+inline void spriteFontBuffer();
+
+/**
+ * Get the tile index for a given character (ASCII).
+ * 
+ * @param character Character to get the tile index from.
+ * @return The tile index for the given character.
+ */
+inline uint8_t spriteFontTileFromChar(char character);

src/sprites/sprites.c

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "sprites.h"
+
+inline void spriteBuffer(uint8_t position, uint8_t length, uint8_t *tiles) {
+  set_bkg_data(position, length, tiles);
+}

src/sprites/sprites.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+
+/**
+ * Buffer tiles data into VRAM
+ * 
+ * @param position Position in VRAM to buffer in to. 
+ * @param length Length of the data being buffered (count of tiles).
+ * @param tiles Pointer to array of tiles to be bufffered.
+ */
+inline void spriteBuffer(uint8_t position, uint8_t length, uint8_t *tiles);

src/sprites/spritetileset.c

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "spritetileset.h"
+
+void spriteTilesetBuffer() {
+  spriteBuffer(SPRITE_TILESET_VRAM_START, TILESET_IMAGE_TILES, TILESET_IMAGE);
+}

src/sprites/spritetileset.h

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+#include "TILESET.h"
+#include "sprites.h"
+
+#define SPRITE_TILESET_VRAM_START 0x00
+#define SPRITE_TILESET_VRAM_END SPRITE_TILESET_VRAM_START + TILESET_IMAGE_TILES
+
+#define SPRITE_TILESET_TILE_0 SPRITE_TILESET_VRAM_START + 0x00
+#define SPRITE_TILESET_TILE_1 SPRITE_TILESET_VRAM_START + 0x01
+#define SPRITE_TILESET_TILE_2 SPRITE_TILESET_VRAM_START + 0x02
+#define SPRITE_TILESET_TILE_3 SPRITE_TILESET_VRAM_START + 0x03
+
+#define SPRITE_TILESET_WHITE SPRITE_TILESET_TILE_0
+#define SPRITE_TILESET_BLACK SPRITE_TILESET_TILE_3
+#define SPRITE_TILESET_LIGHT SPRITE_TILESET_TILE_1
+#define SPRITE_TILESET_DARK SPRITE_TILESET_TILE_2
+
+
+// Shades are mapped where each set of 4 colors is mapped to two bits that will
+// specify its darkness. Higher = Darker, Lower = Brighter
+// 11 11 11 11
+#define TILESET_SHADE_BLACK 0xFF
+// 11 11 11 10
+#define TILESET_SHADE_DARKER 0xFE 
+// 11 11 10 01
+#define TILESET_SHADE_DARK 0xF9
+// 11 10 01 00
+#define TILESET_SHADE_NORMAL 0xE4
+// 10 01 00 00
+#define TILESET_SHADE_BRIGHT 0x90
+// 01 00 00 00
+#define TILESET_SHADE_BRIGHTER 0x40
+// 00 00 00 00
+#define TILESET_SHADE_WHITE 0x00
+
+
+/**
+ * Buffer the TILESET tileset sprites onto VRAM.
+ * 
+ * @param position Position in VRAM to buuffer on to.
+ */
+void spriteTilesetBuffer();