Slowly renaming things from Holdem to Poker

include/dawn/dawn.h

@@ -32,8 +32,11 @@
 #include "input/input.h"
 
 // Poker Game Logic
+#include "poker/action.h"
 #include "poker/card.h"
-#include "poker/holdem.h"
+#include "poker/player.h"
+#include "poker/poker.h"
+#include "poker/render.h"
 
 // Utility Objects
 #include "util/list.h"

include/dawn/poker/action.h

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+
+/** How many actions the queue can hold */
+#define POKER_ACTION_QUEUE_SIZE 12
+
+/** How much data (in length of sizeof size_t) each action has available */
+#define POKER_ACTION_DATA_SIZE 256
+
+/** Callback for actions to use */
+typedef void (*pokerActionCallback)(int32_t index, void *data);
+
+/** Poker Game action that can be queued and executed */
+typedef struct {
+  pokerActionCallback init;
+  pokerActionCallback update;
+  pokerActionCallback dispose;
+} pokeraction_t;

include/dawn/poker/card.h

@@ -85,7 +85,6 @@
 #define CARD_SUIT_HEARTS 0x03
 #define CARD_SUIT_SPADES 0x04
 
-
 /** Count of cards in each suit */
 #define CARD_COUNT_PER_SUIT 13
 

include/dawn/poker/player.h

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+
+/** How many cards a player can hold in their hand */
+#define POKER_PLAYER_HAND 2
+
+/** How many players in a poker game (excludes dealer) */
+#define POKER_PLAYER_COUNT 5
+
+/** State for whether or not a player has folded */
+#define POKER_STATE_FOLDED 0x01
+
+/** State for whether or not a player is showing their hand */
+#define POKER_STATE_SHOWING 0x02
+
+/** Poker Player State */
+typedef struct {
+  /** Cards in the players' hand */
+  card_t cards[POKER_PLAYER_HAND];
+  uint8_t cardCount;
+
+  /** Current State of player */
+  uint8_t state;
+  
+  /** Chips in players' posession */
+  uint32_t chips;
+  
+  /** Current bet in current round player has placed */
+  uint32_t currentBet;
+} pokerplayer_t;

include/dawn/poker/poker.h

@@ -7,36 +7,17 @@
 
 #pragma once
 #include "card.h"
+#include "player.h"
+#include "render.h"
+#include "action.h"
 #include "../display/render.h"
 #include "../display/spritebatch.h"
 #include "../display/texture.h"
 #include "../display/tileset.h"
 #include "../display/framebuffer.h"
 
-/** How many cards a player can hold in their hand */
-#define HOLDEM_PLAYER_HAND 2
 /** How many cards the dealer can hold in their hand */
 #define HOLDEM_DEALER_HAND 5
-/** How many players in a holdem game (excludes dealer) */
-#define HOLDEM_PLAYER_COUNT 5
-
-/** State for whether or not a player has folded */
-#define HOLDEM_STATE_FOLDED 0x01
-/** State for whether or not a player is showing their hand */
-#define HOLDEM_STATE_SHOWING 0x02
-
-/** Size of the Render frames */
-#define HOLDEM_GAME_FRAME_HEIGHT RENDER_STATE.height
-#define HOLDEM_GAME_FRAME_LEFT_WIDTH RENDER_STATE.width*0.65
-#define HOLDEM_GAME_FRAME_RIGHT_WIDTH (\
-  RENDER_STATE.width - HOLDEM_GAME_FRAME_LEFT_WIDTH - 1\
-)
-
-/** Size of the rendered card */
-#define HOLDEM_GAME_CARD_WIDTH 0.04
-#define HOLDEM_GAME_CARD_HEIGHT HOLDEM_GAME_CARD_WIDTH/2.5*3.5
-#define HOLDEM_GAME_CARD_DEPTH 0.0005
-#define HOLDEM_GAME_CARD_PADDING 0.0125
 
 /** Various seats at the table that people can sit */
 #define HOLDEM_GAME_SEAT_DEALER 0x00
@@ -57,39 +38,6 @@
 #define HOLDEM_GAME_CARD_SLOT_FLOP3 0x05
 #define HOLDEM_GAME_CARD_SLOT_FLOP4 0x06
 
-/** How many actions the queue can hold */
-#define HOLDEM_GAME_ACTION_QUEUE_SIZE 12
-
-/** How much data (in length of sizeof size_t) each action has available */
-#define HOLDEM_GAME_ACTION_DATA_SIZE 256
-
-
-/** Texas Hold'em Player State */
-typedef struct {
-  /** Cards in the players' hand */
-  card_t cards[HOLDEM_PLAYER_HAND];
-  uint8_t cardCount;
-
-  /** Current State of player */
-  uint8_t state;
-  
-  /** Chips in players' posession */
-  uint32_t chips;
-  
-  /** Current bet in current round player has placed */
-  uint32_t currentBet;
-} holdemplayer_t;
-
-/** Callback for actions to use */
-typedef void (*holdemActionCallback)(int32_t index, void *data);
-
-/** Texas Hold'em Game action that can be queued and executed */
-typedef struct {
-  holdemActionCallback init;
-  holdemActionCallback update;
-  holdemActionCallback dispose;
-} holdemaction_t;
-
 typedef struct {
   /** Current Card Deck */
   card_t deck[CARD_DECK_SIZE];
@@ -109,10 +57,7 @@ typedef struct {
   uint8_t cardsFacing;
 
   /** Player States */
-  holdemplayer_t players[HOLDEM_PLAYER_COUNT];
+  pokerplayer_t players[POKER_PLAYER_COUNT];
-
-
-
 
 
   texture_t *kagamiTexture;
@@ -120,9 +65,9 @@ typedef struct {
   primitive_t *kagamiQuad;
 
   /** Action and Allocated Data Space */
-  holdemaction_t actionQueue[HOLDEM_GAME_ACTION_QUEUE_SIZE];
+  pokeraction_t actionQueue[POKER_ACTION_QUEUE_SIZE];
-  void *actionData[HOLDEM_GAME_ACTION_DATA_SIZE*HOLDEM_GAME_ACTION_QUEUE_SIZE];
+  void *actionData[POKER_ACTION_DATA_SIZE*POKER_ACTION_QUEUE_SIZE];
-  bool actionInitState[HOLDEM_GAME_ACTION_DATA_SIZE];
+  bool actionInitState[POKER_ACTION_DATA_SIZE];
 
   /** Poker Table */
   primitive_t *tablePrimitive;
@@ -143,12 +88,6 @@ typedef struct {
   primitive_t *quadRight;
   camera_t cameraLeft;
   camera_t cameraRight;
-} holdemgame_t;
+} pokergame_t;
 
-
+extern pokergame_t POKER_STATE;
-typedef struct {
-  float x, z;
-  float yaw;
-} holdemrenderposition_t;
-
-extern holdemgame_t HOLDEM_GAME_STATE;

include/dawn/poker/render.h

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+
+/** Size of the rendered card */
+#define HOLDEM_GAME_CARD_WIDTH 0.04
+#define HOLDEM_GAME_CARD_HEIGHT HOLDEM_GAME_CARD_WIDTH/2.5*3.5
+#define HOLDEM_GAME_CARD_DEPTH 0.0005
+#define HOLDEM_GAME_CARD_PADDING 0.0125
+
+/** Size of the Render frames */
+#define HOLDEM_GAME_FRAME_HEIGHT RENDER_STATE.height
+#define HOLDEM_GAME_FRAME_LEFT_WIDTH RENDER_STATE.width*0.65
+#define HOLDEM_GAME_FRAME_RIGHT_WIDTH (\
+  RENDER_STATE.width - HOLDEM_GAME_FRAME_LEFT_WIDTH - 1\
+)
+
+typedef struct {
+  float x, z;
+  float yaw;
+} pokerposition_t;

src/poker/action/action.c

@@ -9,59 +9,59 @@
 
 void holdemActionInit() {
   // Free up all actions
-  memset(HOLDEM_GAME_STATE.actionQueue, (int32_t)NULL,
+  memset(POKER_STATE.actionQueue, (int32_t)NULL,
-    sizeof(holdemaction_t) * HOLDEM_GAME_ACTION_QUEUE_SIZE
+    sizeof(pokeraction_t) * POKER_ACTION_QUEUE_SIZE
   );
 
   // Free up all data
-  memset(HOLDEM_GAME_STATE.actionData, (int32_t)NULL, sizeof(void *) *
+  memset(POKER_STATE.actionData, (int32_t)NULL, sizeof(void *) *
-    HOLDEM_GAME_ACTION_DATA_SIZE * HOLDEM_GAME_ACTION_QUEUE_SIZE
+    POKER_ACTION_DATA_SIZE * POKER_ACTION_QUEUE_SIZE
   );
 }
 
-int32_t holdemActionAdd(holdemaction_t action) {
+int32_t holdemActionAdd(pokeraction_t action) {
   int32_t i = -1;
   int32_t j = -1;
 
-  for(i = 0; i < HOLDEM_GAME_ACTION_QUEUE_SIZE; i++) {
+  for(i = 0; i < POKER_ACTION_QUEUE_SIZE; i++) {
-    if(HOLDEM_GAME_STATE.actionQueue[i].init != NULL) continue;
+    if(POKER_STATE.actionQueue[i].init != NULL) continue;
     j = i;
     break;
   }
   if(j == -1) return j;
 
-  HOLDEM_GAME_STATE.actionQueue[j] = action;
+  POKER_STATE.actionQueue[j] = action;
-  HOLDEM_GAME_STATE.actionInitState[j] = false;
+  POKER_STATE.actionInitState[j] = false;
   return j;
 }
 
 void holdemActionRemove(int32_t index) {
-  if(HOLDEM_GAME_STATE.actionQueue[index].dispose != NULL) {
+  if(POKER_STATE.actionQueue[index].dispose != NULL) {
-    HOLDEM_GAME_STATE.actionQueue[index].dispose(
+    POKER_STATE.actionQueue[index].dispose(
-      index, HOLDEM_GAME_STATE.actionData + index
+      index, POKER_STATE.actionData + index
     );
   }
 
-  memset(HOLDEM_GAME_STATE.actionQueue+index, (int32_t)NULL,
+  memset(POKER_STATE.actionQueue+index, (int32_t)NULL,
-    sizeof(holdemaction_t)
+    sizeof(pokeraction_t)
   );
 
-  memset(HOLDEM_GAME_STATE.actionData+index, (int32_t)NULL,
+  memset(POKER_STATE.actionData+index, (int32_t)NULL,
-    sizeof(void *) * HOLDEM_GAME_ACTION_DATA_SIZE
+    sizeof(void *) * POKER_ACTION_DATA_SIZE
   );
 }
 
 void holdemActionUpdate() {
   int32_t i;
   void **data;
-  holdemaction_t *action;
+  pokeraction_t *action;
 
-  for(i = 0; i < HOLDEM_GAME_ACTION_QUEUE_SIZE; i++) {
+  for(i = 0; i < POKER_ACTION_QUEUE_SIZE; i++) {
-    action = HOLDEM_GAME_STATE.actionQueue + i;
+    action = POKER_STATE.actionQueue + i;
-    data = HOLDEM_GAME_STATE.actionData + i;
+    data = POKER_STATE.actionData + i;
 
-    if(action->init != NULL && !HOLDEM_GAME_STATE.actionInitState[i]) {
+    if(action->init != NULL && !POKER_STATE.actionInitState[i]) {
-      HOLDEM_GAME_STATE.actionInitState[i] = true;
+      POKER_STATE.actionInitState[i] = true;
       action->init(i, data);
     }
 
@@ -73,8 +73,8 @@ void holdemActionUpdate() {
 
 void holdemActionDispose() {
   int32_t i;
-  for(i = 0; i < HOLDEM_GAME_ACTION_QUEUE_SIZE; i++) {
+  for(i = 0; i < POKER_ACTION_QUEUE_SIZE; i++) {
-    if(HOLDEM_GAME_STATE.actionQueue[i].dispose == NULL) continue;
+    if(POKER_STATE.actionQueue[i].dispose == NULL) continue;
-    HOLDEM_GAME_STATE.actionQueue[i].dispose(i, HOLDEM_GAME_STATE.actionData+i);
+    POKER_STATE.actionQueue[i].dispose(i, POKER_STATE.actionData+i);
   }
 }

src/poker/action/action.h

@@ -19,7 +19,7 @@ void holdemActionInit();
  * @param action Action to add to the queue.
  * @returns The index of the action within the queue, or -1 if failure occured.
  */
-int32_t holdemActionAdd(holdemaction_t action);
+int32_t holdemActionAdd(pokeraction_t action);
 
 /**
  * Removes an action from the action queue.

src/poker/action/ai.c

@@ -7,8 +7,8 @@
 
 #include "ai.h"
 
-holdemaction_t actionAi() {
+pokeraction_t actionAi() {
-  return (holdemaction_t){
+  return (pokeraction_t){
     .init = &actionAiInit,
     .update = &actionAiUpdate,
     .dispose = &actionAiDispose
@@ -33,7 +33,7 @@ void actionAiUpdate(int32_t index, void *data) {
 
 void actionAiDispose(int32_t index, void *data) {
   // Do we need to do a flop?
-  if(HOLDEM_GAME_STATE.cardsFacing < HOLDEM_DEALER_HAND) {
+  if(POKER_STATE.cardsFacing < HOLDEM_DEALER_HAND) {
     holdemActionAdd(actionFlop());
   }
 }

src/poker/action/ai.h

@@ -11,7 +11,7 @@
 #include "flop.h"
 #include "../../debug/log.h"
 
-holdemaction_t actionAi();
+pokeraction_t actionAi();
 
 void actionAiInit(int32_t index, void *data);
 void actionAiUpdate(int32_t index, void *data);

src/poker/action/deal.c

@@ -7,8 +7,8 @@
 
 #include "deal.h"
 
-holdemaction_t actionDeal() {
+pokeraction_t actionDeal() {
-  return (holdemaction_t){
+  return (pokeraction_t){
     .init = &actionDealInit,
     .update = &actionDealUpdate,
     .dispose = &actionDealDispose
@@ -17,18 +17,18 @@ holdemaction_t actionDeal() {
 
 void actionDealInit(int32_t index, void *data) {
   uint8_t i, j;
-  holdemplayer_t *player;
+  pokerplayer_t *player;
   logText("Dealing Cards");
   
   for(i = 0; i < 2; i++) {
-    for(j = 0; j < HOLDEM_PLAYER_COUNT; j++) {
+    for(j = 0; j < POKER_PLAYER_COUNT; j++) {
-      player = HOLDEM_GAME_STATE.players + j;
+      player = POKER_STATE.players + j;
-      cardDeal(HOLDEM_GAME_STATE.deck,
+      cardDeal(POKER_STATE.deck,
         player->cards,
-        HOLDEM_GAME_STATE.deckSize,
+        POKER_STATE.deckSize,
         player->cardCount
       );
-      HOLDEM_GAME_STATE.deckSize--;
+      POKER_STATE.deckSize--;
       player->cardCount++;
     }
   }

src/poker/action/deal.h

@@ -11,7 +11,7 @@
 #include "action.h"
 #include "ai.h"
 
-holdemaction_t actionDeal();
+pokeraction_t actionDeal();
 
 void actionDealInit(int32_t i, void *data);
 void actionDealUpdate(int32_t i, void *data);

src/poker/action/flop.c

@@ -7,8 +7,8 @@
 
 #include "flop.h"
 
-holdemaction_t actionFlop() {
+pokeraction_t actionFlop() {
-  return (holdemaction_t){
+  return (pokeraction_t){
     .init = &actionFlopInit,
     .update = &actionFlopUpdate,
     .dispose = &actionFlopDispose
@@ -20,22 +20,22 @@ void actionFlopInit(int32_t index, void *data) {
   logText("Flop");
   
   // Look at the dealer
-  holdemRenderLookHand(&HOLDEM_GAME_STATE.cameraLeft, HOLDEM_GAME_SEAT_DEALER);
+  holdemRenderLookHand(&POKER_STATE.cameraLeft, HOLDEM_GAME_SEAT_DEALER);
 
   // Do the flop
   // if(match->cardsFacing >= HOLDEM_DEALER_HAND) return;
 
   // Burn the card off the top
-  HOLDEM_GAME_STATE.deckSize -= 1;
+  POKER_STATE.deckSize -= 1;
 
   // Change count depending on facing
-  count = HOLDEM_GAME_STATE.cardsFacing == 0 ? 0x03 : 0x01;
+  count = POKER_STATE.cardsFacing == 0 ? 0x03 : 0x01;
 
   // Deal
   for(i = 0; i < count; i++) {
-    cardDeal(HOLDEM_GAME_STATE.deck, HOLDEM_GAME_STATE.cards, HOLDEM_GAME_STATE.deckSize, HOLDEM_GAME_STATE.cardsFacing);
+    cardDeal(POKER_STATE.deck, POKER_STATE.cards, POKER_STATE.deckSize, POKER_STATE.cardsFacing);
-    HOLDEM_GAME_STATE.deckSize -= 1;
+    POKER_STATE.deckSize -= 1;
-    HOLDEM_GAME_STATE.cardsFacing += 1;
+    POKER_STATE.cardsFacing += 1;
   }
 
   // Next action

src/poker/action/flop.h

@@ -12,7 +12,7 @@
 #include "action.h"
 #include "ai.h"
 
-holdemaction_t actionFlop();
+pokeraction_t actionFlop();
 
 void actionFlopInit(int32_t index, void *data);
 void actionFlopUpdate(int32_t index, void *data);

src/poker/action/round.c

@@ -7,8 +7,8 @@
 
 #include "round.h"
 
-holdemaction_t actionRound() {
+pokeraction_t actionRound() {
-  return (holdemaction_t){
+  return (pokeraction_t){
     .init = &actionRoundInit,
     .update = &actionRoundUpdate,
     .dispose = &actionRoundDispose
@@ -17,27 +17,27 @@ holdemaction_t actionRound() {
 
 void actionRoundInit(int32_t index, void *data) {
   uint8_t i;
-  holdemplayer_t *player;
+  pokerplayer_t *player;
 
   logText("Round Start");
 
   // Look at the dealer.
-  holdemRenderLookHand(&HOLDEM_GAME_STATE.cameraLeft, HOLDEM_GAME_SEAT_DEALER);
+  holdemRenderLookHand(&POKER_STATE.cameraLeft, HOLDEM_GAME_SEAT_DEALER);
 
   // Init the round and shuffle the deck
-  cardDeckFill(HOLDEM_GAME_STATE.deck);
+  cardDeckFill(POKER_STATE.deck);
-  HOLDEM_GAME_STATE.deckSize = CARD_DECK_SIZE;
+  POKER_STATE.deckSize = CARD_DECK_SIZE;
-  HOLDEM_GAME_STATE.pot = 0;
+  POKER_STATE.pot = 0;
-  HOLDEM_GAME_STATE.cardsFacing = 0;
+  POKER_STATE.cardsFacing = 0;
   
   // Reset the players
-  for(i = 0; i < HOLDEM_PLAYER_COUNT; i++) {
+  for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    player = HOLDEM_GAME_STATE.players + i;
+    player = POKER_STATE.players + i;
 
     // Clear Round State(s)
     player->state &= ~(
-      HOLDEM_STATE_FOLDED | 
+      POKER_STATE_FOLDED | 
-      HOLDEM_STATE_SHOWING
+      POKER_STATE_SHOWING
     );
 
     player->cardCount = 0;
@@ -58,6 +58,6 @@ void actionRoundAfterShuffle() {
 
 void actionRoundDispose(int32_t index, void *data) {
   int32_t newI = holdemActionAdd(actionShuffle());
-  shuffledata_t *newData=(shuffledata_t *)(HOLDEM_GAME_STATE.actionData + newI);
+  shuffledata_t *newData=(shuffledata_t *)(POKER_STATE.actionData + newI);
   newData->done = &actionRoundAfterShuffle;
 }

src/poker/action/round.h

@@ -14,7 +14,7 @@
 #include "shuffle.h"
 #include "deal.h"
 
-holdemaction_t actionRound();
+pokeraction_t actionRound();
 
 void actionRoundInit(int32_t index, void *data);
 void actionRoundUpdate(int32_t index, void *data);

src/poker/action/shuffle.c

@@ -7,8 +7,8 @@
 
 #include "shuffle.h"
 
-holdemaction_t actionShuffle() {
+pokeraction_t actionShuffle() {
-  return (holdemaction_t){
+  return (pokeraction_t){
     .init = &actionShuffleInit,
     .update = &actionShuffleUpdate,
     .dispose = &actionShuffleDispose
@@ -17,7 +17,7 @@ holdemaction_t actionShuffle() {
 
 void actionShuffleInit(int32_t index, void *data) {
   logText("Shuffle Deck");
-  cardShuffle(HOLDEM_GAME_STATE.deck, HOLDEM_GAME_STATE.deckSize);
+  cardShuffle(POKER_STATE.deck, POKER_STATE.deckSize);
   holdemActionRemove(index);
 }
 

src/poker/action/shuffle.h

@@ -14,7 +14,7 @@ typedef struct {
   void (*done)();
 } shuffledata_t;
 
-holdemaction_t actionShuffle();
+pokeraction_t actionShuffle();
 
 void actionShuffleInit(int32_t index, void *data);
 

src/poker/action/start.c

@@ -7,8 +7,8 @@
 
 #include "start.h"
 
-holdemaction_t actionStart() {
+pokeraction_t actionStart() {
-  holdemaction_t action = {
+  pokeraction_t action = {
     .init = &actionStartInit,
     .update = &actionStartUpdate,
     .dispose = &actionStartDispose
@@ -19,17 +19,17 @@ holdemaction_t actionStart() {
 
 void actionStartInit(int32_t index, void *data) {
   uint8_t i;
-  holdemplayer_t *player;
+  pokerplayer_t *player;
   logText("Holdem Starting");
 
   // Prepare the match
-  HOLDEM_GAME_STATE.blindBig = 0;
+  POKER_STATE.blindBig = 0;
-  HOLDEM_GAME_STATE.blindSmall = 0;
+  POKER_STATE.blindSmall = 0;
-  HOLDEM_GAME_STATE.pot = 0;
+  POKER_STATE.pot = 0;
 
   // Reset the players
-  for(i = 0; i < HOLDEM_PLAYER_COUNT; i++) {
+  for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    player = HOLDEM_GAME_STATE.players + i;
+    player = POKER_STATE.players + i;
     player->state = 0x00;
     player->chips = 0;
   }

src/poker/action/start.h

@@ -11,7 +11,7 @@
 #include "round.h"
 #include "../../debug/log.h"
 
-holdemaction_t actionStart();
+pokeraction_t actionStart();
 
 void actionStartInit(int32_t index, void *data);
 void actionStartUpdate(int32_t index, void *data);

src/poker/holdemgame.c

@@ -6,17 +6,17 @@
  */
 #include "holdemgame.h"
 
-holdemgame_t HOLDEM_GAME_STATE;
+pokergame_t POKER_STATE;
 
 void holdemGameInit() {
   // Font
-  HOLDEM_GAME_STATE.fontTexture = assetTextureLoad("font.png");
+  POKER_STATE.fontTexture = assetTextureLoad("font.png");
-  HOLDEM_GAME_STATE.fontTileset = tilesetCreate(20, 20,
+  POKER_STATE.fontTileset = tilesetCreate(20, 20,
-    HOLDEM_GAME_STATE.fontTexture->width,
+    POKER_STATE.fontTexture->width,
-    HOLDEM_GAME_STATE.fontTexture->height,
+    POKER_STATE.fontTexture->height,
     1, 1, 1, 1
   );
-  HOLDEM_GAME_STATE.fontBatch = spriteBatchCreate(1024);
+  POKER_STATE.fontBatch = spriteBatchCreate(1024);
 
   // Prepare the renderer.
   holdemRenderFrameInit();

src/poker/render/card.c

@@ -11,20 +11,20 @@ void holdemRenderCardInit() {
   tilesetdiv_t *cardBack;
 
   // Load Cards Texture
-  HOLDEM_GAME_STATE.cardTexture = assetTextureLoad("cards_normal.png");
+  POKER_STATE.cardTexture = assetTextureLoad("cards_normal.png");
-  HOLDEM_GAME_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
+  POKER_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
-    HOLDEM_GAME_STATE.cardTexture->width, HOLDEM_GAME_STATE.cardTexture->height,
+    POKER_STATE.cardTexture->width, POKER_STATE.cardTexture->height,
     0, 0, 0, 0
   );
 
   // Cards Primitive
-  cardBack = HOLDEM_GAME_STATE.cardTileset->divisions+(
+  cardBack = POKER_STATE.cardTileset->divisions+(
-    HOLDEM_GAME_STATE.cardTileset->columns * 4
+    POKER_STATE.cardTileset->columns * 4
   );
-  HOLDEM_GAME_STATE.cardPrimitive = primitiveCreate(
+  POKER_STATE.cardPrimitive = primitiveCreate(
     QUAD_VERTICE_COUNT * 2, QUAD_INDICE_COUNT * 2
   );
-  quadBuffer(HOLDEM_GAME_STATE.cardPrimitive, -HOLDEM_GAME_CARD_DEPTH,
+  quadBuffer(POKER_STATE.cardPrimitive, -HOLDEM_GAME_CARD_DEPTH,
     -HOLDEM_GAME_CARD_WIDTH, -HOLDEM_GAME_CARD_HEIGHT,
     cardBack->x0, cardBack->y1,
     HOLDEM_GAME_CARD_WIDTH, HOLDEM_GAME_CARD_HEIGHT,
@@ -33,8 +33,8 @@ void holdemRenderCardInit() {
   );
 }
 
-holdemrenderposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
+pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
-  holdemrenderposition_t position;
+  pokerposition_t position;
   float t, t2;
 
   position.yaw = HOLDEM_GAME_SEAT_ANGLE(seat);
@@ -74,8 +74,8 @@ holdemrenderposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
 void holdemRenderCard(card_t card, float x, float y, float z,
   float pitch, float yaw, float roll
 ) {
-  tilesetdiv_t *cardFront = HOLDEM_GAME_STATE.cardTileset->divisions + card;
+  tilesetdiv_t *cardFront = POKER_STATE.cardTileset->divisions + card;
-  quadBuffer(HOLDEM_GAME_STATE.cardPrimitive, HOLDEM_GAME_CARD_DEPTH,
+  quadBuffer(POKER_STATE.cardPrimitive, HOLDEM_GAME_CARD_DEPTH,
     -HOLDEM_GAME_CARD_WIDTH, -HOLDEM_GAME_CARD_HEIGHT, 
     cardFront->x0, cardFront->y1,
     HOLDEM_GAME_CARD_WIDTH, HOLDEM_GAME_CARD_HEIGHT,
@@ -83,12 +83,12 @@ void holdemRenderCard(card_t card, float x, float y, float z,
     0, 0
   );
 
-  shaderUseTexture(GAME_STATE.shaderWorld, HOLDEM_GAME_STATE.cardTexture);
+  shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.cardTexture);
   shaderUsePosition(GAME_STATE.shaderWorld, x,y,z, pitch,yaw,roll);
-  primitiveDraw(HOLDEM_GAME_STATE.cardPrimitive, 0, -1);
+  primitiveDraw(POKER_STATE.cardPrimitive, 0, -1);
 }
 
 void holdemRenderCardForSeat(uint8_t seat, card_t card, uint8_t slot) {
-  holdemrenderposition_t position = holdemRenderCardGetPosition(seat, slot);
+  pokerposition_t position = holdemRenderCardGetPosition(seat, slot);
   holdemRenderCard(card, position.x, 0, position.z, mathDeg2Rad(-90), position.yaw, 0);
 }

src/poker/render/card.h

@@ -25,7 +25,7 @@ void holdemRenderCardInit();
  * @param slot Slot within the player/dealers' hand that the card belongs to.
  * @return A struct containing X, Z and YAW properties.
  */
-holdemrenderposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot);
+pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot);
 
 /**
  * Render's a given card at the specified coordinates. Card is a reused quad 

src/poker/render/frame.c

@@ -13,10 +13,10 @@ void holdemRenderFrameInit() {
   // Prepare the two frame buffers.
   lWidth = HOLDEM_GAME_FRAME_LEFT_WIDTH, rWidth = HOLDEM_GAME_FRAME_RIGHT_WIDTH;
   height = HOLDEM_GAME_FRAME_HEIGHT;
-  HOLDEM_GAME_STATE.frameLeft = frameBufferCreate(lWidth, height);
+  POKER_STATE.frameLeft = frameBufferCreate(lWidth, height);
-  HOLDEM_GAME_STATE.frameRight = frameBufferCreate(rWidth, height);
+  POKER_STATE.frameRight = frameBufferCreate(rWidth, height);
-  HOLDEM_GAME_STATE.quadLeft = quadCreate(0, 0, 0, 0, 0, lWidth, height, 1, 1);
+  POKER_STATE.quadLeft = quadCreate(0, 0, 0, 0, 0, lWidth, height, 1, 1);
-  HOLDEM_GAME_STATE.quadRight = quadCreate(0, 0, 0, 0, 0, rWidth, height, 1, 1);
+  POKER_STATE.quadRight = quadCreate(0, 0, 0, 0, 0, rWidth, height, 1, 1);
 }
 
 void holdemRenderFrameUpdate() {
@@ -25,21 +25,21 @@ void holdemRenderFrameUpdate() {
   lWidth = HOLDEM_GAME_FRAME_LEFT_WIDTH, rWidth = HOLDEM_GAME_FRAME_RIGHT_WIDTH;
   height = HOLDEM_GAME_FRAME_HEIGHT;
   if((
-    HOLDEM_GAME_STATE.frameLeft->texture->width == lWidth &&
+    POKER_STATE.frameLeft->texture->width == lWidth &&
-    HOLDEM_GAME_STATE.frameLeft->texture->height == height
+    POKER_STATE.frameLeft->texture->height == height
   )) return;
 
   // Recreate frame buffers.
-  frameBufferDispose(HOLDEM_GAME_STATE.frameLeft);
+  frameBufferDispose(POKER_STATE.frameLeft);
-  frameBufferDispose(HOLDEM_GAME_STATE.frameRight);
+  frameBufferDispose(POKER_STATE.frameRight);
-  HOLDEM_GAME_STATE.frameLeft = frameBufferCreate(lWidth, height);
+  POKER_STATE.frameLeft = frameBufferCreate(lWidth, height);
-  HOLDEM_GAME_STATE.frameRight = frameBufferCreate(rWidth, height);
+  POKER_STATE.frameRight = frameBufferCreate(rWidth, height);
-  quadBuffer(HOLDEM_GAME_STATE.quadLeft, 0,
+  quadBuffer(POKER_STATE.quadLeft, 0,
     0, 0, 0, 1,
     lWidth, height, 1, 0,
     0, 0
   );
-  quadBuffer(HOLDEM_GAME_STATE.quadRight, 0,
+  quadBuffer(POKER_STATE.quadRight, 0,
     0, 0, 0, 1,
     rWidth, height, 1, 0,
     0, 0
@@ -48,27 +48,27 @@ void holdemRenderFrameUpdate() {
 
 void holdemRenderFrameUseLeft() {
   glClearColor(0.3, 0, 0, 1);
-  frameBufferUse(HOLDEM_GAME_STATE.frameLeft, true);
+  frameBufferUse(POKER_STATE.frameLeft, true);
-  cameraPerspective(&HOLDEM_GAME_STATE.cameraLeft, 35,
+  cameraPerspective(&POKER_STATE.cameraLeft, 35,
     (
-      (float)HOLDEM_GAME_STATE.frameLeft->texture->width /
+      (float)POKER_STATE.frameLeft->texture->width /
-      (float)HOLDEM_GAME_STATE.frameLeft->texture->height
+      (float)POKER_STATE.frameLeft->texture->height
     ), 0.2f, 1000.0f
   );
-  shaderUseCamera(GAME_STATE.shaderWorld, &HOLDEM_GAME_STATE.cameraLeft);
+  shaderUseCamera(GAME_STATE.shaderWorld, &POKER_STATE.cameraLeft);
 }
 
 void holdemRenderFrameUseRight() {
   glClearColor(0.3, 0.3, 0, 1);
-  frameBufferUse(HOLDEM_GAME_STATE.frameRight, true);
+  frameBufferUse(POKER_STATE.frameRight, true);
-  cameraPerspective(&HOLDEM_GAME_STATE.cameraRight, 45,
+  cameraPerspective(&POKER_STATE.cameraRight, 45,
     (
-      (float)HOLDEM_GAME_STATE.frameRight->texture->width /
+      (float)POKER_STATE.frameRight->texture->width /
-      (float)HOLDEM_GAME_STATE.frameRight->texture->height
+      (float)POKER_STATE.frameRight->texture->height
     ), 0.2f, 1000.0f
   );
-  cameraLookAt(&HOLDEM_GAME_STATE.cameraRight, 0, 3, 3, 0, 0, 0);
+  cameraLookAt(&POKER_STATE.cameraRight, 0, 3, 3, 0, 0, 0);
-  shaderUseCamera(GAME_STATE.shaderWorld, &HOLDEM_GAME_STATE.cameraRight);
+  shaderUseCamera(GAME_STATE.shaderWorld, &POKER_STATE.cameraRight);
 }
 
 void holdemRenderFrameBack() {
@@ -82,12 +82,12 @@ void holdemRenderFrameBack() {
   shaderUsePosition(GAME_STATE.shaderWorld,
     0, 0, 0, 0, 0, 0
   );
-  shaderUseTexture(GAME_STATE.shaderWorld, HOLDEM_GAME_STATE.frameLeft->texture);
+  shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.frameLeft->texture);
-  primitiveDraw(HOLDEM_GAME_STATE.quadLeft, 0, -1);
+  primitiveDraw(POKER_STATE.quadLeft, 0, -1);
   shaderUsePosition(GAME_STATE.shaderWorld,
-    RENDER_STATE.width - HOLDEM_GAME_STATE.frameRight->texture->width,
+    RENDER_STATE.width - POKER_STATE.frameRight->texture->width,
     0, 0, 0, 0, 0
   );
-  shaderUseTexture(GAME_STATE.shaderWorld, HOLDEM_GAME_STATE.frameRight->texture);
+  shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.frameRight->texture);
-  primitiveDraw(HOLDEM_GAME_STATE.quadRight, 0, -1);
+  primitiveDraw(POKER_STATE.quadRight, 0, -1);
 }

src/poker/render/look.c

@@ -12,7 +12,7 @@ void holdemRenderLookSeat(camera_t *camera, uint8_t seat) {
   angle = HOLDEM_GAME_SEAT_ANGLE(seat);
   x = sin(angle);
   z = cos(angle);
-  cameraLookAt(&HOLDEM_GAME_STATE.cameraLeft,
+  cameraLookAt(&POKER_STATE.cameraLeft,
      x, 0.2,  z,
     -x, 0.2, -z
   );
@@ -23,7 +23,7 @@ void holdemRenderLookHand(camera_t *camera, uint8_t seat) {
   angle = HOLDEM_GAME_SEAT_ANGLE(seat);
   x = sin(angle);
   z = cos(angle);
-  cameraLookAt(&HOLDEM_GAME_STATE.cameraLeft,
+  cameraLookAt(&POKER_STATE.cameraLeft,
     x*0.1, 0.8, z*0.1,
     -x*0.5, 0.2, -z*0.5
   );

src/poker/render/player.c

@@ -8,13 +8,13 @@
 #include "player.h"
 
 void holdemRenderPlayerInit() {
-  HOLDEM_GAME_STATE.kagamiTexture = assetTextureLoad("kagami.png");
+  POKER_STATE.kagamiTexture = assetTextureLoad("kagami.png");
-  HOLDEM_GAME_STATE.kagamiTileset = tilesetCreate(3, 2,
+  POKER_STATE.kagamiTileset = tilesetCreate(3, 2,
-    HOLDEM_GAME_STATE.kagamiTexture->width,
+    POKER_STATE.kagamiTexture->width,
-    HOLDEM_GAME_STATE.kagamiTexture->height,
+    POKER_STATE.kagamiTexture->height,
     0, 0, 0, 0
   );
-  HOLDEM_GAME_STATE.kagamiQuad = quadCreate(0, 0, 0, 0, 0, 1, 1, 1, 1);
+  POKER_STATE.kagamiQuad = quadCreate(0, 0, 0, 0, 0, 1, 1, 1, 1);
 }
 
 uint8_t holdemRenderPlayerGetSeatForPlayer(uint8_t player) { 
@@ -43,27 +43,27 @@ void holdemRenderPlayer(uint8_t seat) {
   // Determine size
   float w, h;
   w = 0.6, h = (
-    (float)HOLDEM_GAME_STATE.kagamiTileset->divY /
+    (float)POKER_STATE.kagamiTileset->divY /
-    (float)HOLDEM_GAME_STATE.kagamiTileset->divX
+    (float)POKER_STATE.kagamiTileset->divX
   ) * w;
 
   // Animation
-  int i = (int32_t)(TIME_STATE.current*10)%HOLDEM_GAME_STATE.kagamiTileset->count;
+  int i = (int32_t)(TIME_STATE.current*10)%POKER_STATE.kagamiTileset->count;
-  quadBuffer(HOLDEM_GAME_STATE.kagamiQuad, 0,
+  quadBuffer(POKER_STATE.kagamiQuad, 0,
     -w/2, -h/2,
-    HOLDEM_GAME_STATE.kagamiTileset->divisions[i].x0,
+    POKER_STATE.kagamiTileset->divisions[i].x0,
-    HOLDEM_GAME_STATE.kagamiTileset->divisions[i].y1,
+    POKER_STATE.kagamiTileset->divisions[i].y1,
     w/2, h/2,
-    HOLDEM_GAME_STATE.kagamiTileset->divisions[i].x1,
+    POKER_STATE.kagamiTileset->divisions[i].x1,
-    HOLDEM_GAME_STATE.kagamiTileset->divisions[i].y0,
+    POKER_STATE.kagamiTileset->divisions[i].y0,
     0, 0
   );
 
   // Render
-  shaderUseTexture(GAME_STATE.shaderWorld, HOLDEM_GAME_STATE.kagamiTexture);
+  shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.kagamiTexture);
   shaderUsePosition(GAME_STATE.shaderWorld,
     x, 0.34, z,
     0, angle, 0
   );
-  primitiveDraw(HOLDEM_GAME_STATE.kagamiQuad, 0, -1);
+  primitiveDraw(POKER_STATE.kagamiQuad, 0, -1);
 }

src/poker/render/scene.c

@@ -8,8 +8,8 @@
 #include "scene.h"
 
 void holdemRenderSceneInit() {
-  HOLDEM_GAME_STATE.tablePrimitive = pokerTableCreate();
+  POKER_STATE.tablePrimitive = pokerTableCreate();
-  HOLDEM_GAME_STATE.tableTexture = assetTextureLoad("pokertable.png");
+  POKER_STATE.tableTexture = assetTextureLoad("pokertable.png");
 }
 
 void holdemRenderScene() {
@@ -19,6 +19,6 @@ void holdemRenderScene() {
     0, 0, 0,
     3.4, 3.4, 3.4
   );
-  shaderUseTexture(GAME_STATE.shaderWorld, HOLDEM_GAME_STATE.tableTexture);
+  shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.tableTexture);
-  primitiveDraw(HOLDEM_GAME_STATE.tablePrimitive, 0, -1);
+  primitiveDraw(POKER_STATE.tablePrimitive, 0, -1);
 }

src/poker/render/world.c

@@ -9,28 +9,28 @@
 
 void holdemRenderWorld() {
   uint8_t i, j;
-  holdemplayer_t *player;
+  pokerplayer_t *player;
   uint8_t seat;
 
   holdemRenderScene();
 
   // Render the dealer and her hand
   holdemRenderPlayer(HOLDEM_GAME_SEAT_DEALER);
-  for(i = 0x00; i < HOLDEM_GAME_STATE.cardsFacing; i++) {
+  for(i = 0x00; i < POKER_STATE.cardsFacing; i++) {
     holdemRenderCardForSeat(
       HOLDEM_GAME_SEAT_DEALER,
-      HOLDEM_GAME_STATE.cards[i],
+      POKER_STATE.cards[i],
       HOLDEM_GAME_CARD_SLOT_FLOP0 + i
     );
   }
 
   // Test
-  for(i = 0x00; i < HOLDEM_PLAYER_COUNT; i++) {
+  for(i = 0x00; i < POKER_PLAYER_COUNT; i++) {
-    player = HOLDEM_GAME_STATE.players + i;
+    player = POKER_STATE.players + i;
     seat = holdemRenderPlayerGetSeatForPlayer(i);
     holdemRenderPlayer(seat);
 
-    if(player->state & HOLDEM_STATE_FOLDED) continue;
+    if(player->state & POKER_STATE_FOLDED) continue;
 
     for(j = 0x00; j < player->cardCount; j++) {
       holdemRenderCardForSeat(seat, player->cards[j], HOLDEM_GAME_CARD_SLOT_HAND0+j);