Working on poker logic.

include/dawn/display/gui/font.h

@@ -25,7 +25,7 @@
 #define FONT_FILL_MODE 1
 
 /** Passed to STBTT for scaling the font nicely, essentially the font size. */
-#define FONT_TEXTURE_SIZE 96
+#define FONT_TEXTURE_SIZE 112
 
 // Chars
 #define FONT_NEWLINE '\n'

include/dawn/poker/poker.h

@@ -19,16 +19,17 @@
 
 /** Rounds that the game can be in */
 #define POKER_ROUND_MATCH 0x00
-#define POKER_ROUND_DEAL 0x01
+#define POKER_ROUND_START 0x01
 #define POKER_ROUND_BLINDS 0x02
-#define POKER_ROUND_BET0 0x03
-#define POKER_ROUND_FLOP 0X04
-#define POKER_ROUND_BET1 0x05
-#define POKER_ROUND_TURN 0x06
-#define POKER_ROUND_BET2 0x07
-#define POKER_ROUND_RIVER 0x08
-#define POKER_ROUND_BET3 0x09
-#define POKER_ROUND_WINNER 0x10
+#define POKER_ROUND_DEAL 0x03
+#define POKER_ROUND_BET0 0x04
+#define POKER_ROUND_FLOP 0X05
+#define POKER_ROUND_BET1 0x06
+#define POKER_ROUND_TURN 0x07
+#define POKER_ROUND_BET2 0x08
+#define POKER_ROUND_RIVER 0x09
+#define POKER_ROUND_BET3 0x0A
+#define POKER_ROUND_WINNER 0x0B
 
 /** How many cards the dealer can hold in their hand */
 #define POKER_DEALER_HAND 5
@@ -49,6 +50,13 @@
 /** GUI Height fix (To keep gui scaling nicely we use a fixed height) */
 #define POKER_GUI_HEIGHT 2160
 
+/** How many cards to deal each player during the deal round */
+#define POKER_DEAL_CARD_EACH 2
+
+#define POKER_FLOP_CARD_COUNT 3
+#define POKER_TURN_CARD_COUNT 1
+#define POKER_RIVER_CARD_COUNT 1
+
 typedef struct {
   //////////////////////////////////////////////////////////////////////////////
   // Poker Logic Variables
@@ -77,15 +85,22 @@ typedef struct {
 
   /** The current player that is the dealer */
   uint8_t roundDealer;
+  uint8_t roundSmallBlind;
+  uint8_t roundBigBlind;
 
   /** Current pot of chips */
   uint32_t pot;
 
-  /** The current buy-in bet size. */
-  uint32_t roundBet;
+  //////////////////////////////////////////////////////////////////////////////
+  // Round variables
+  //////////////////////////////////////////////////////////////////////////////
+  uint32_t roundTextCounter;
+
+  /** For Betting round, which player is currently betting */
+  uint8_t roundBetCurrent;
 
   //////////////////////////////////////////////////////////////////////////////
-  // Rendering Assets
+  // Rendering Variables
   //////////////////////////////////////////////////////////////////////////////
 
   /** Frames to hold the world and GUI render outputs */

include/dawn/poker/strings.h

@@ -8,4 +8,5 @@
 #pragma once
 #include "../libs.h"
 
-#define POKER_TALK_MATCH_START "The game is no-limits Texas Hold'em."
+#define POKER_TALK_MATCH_START "The game is no-limits Texas Hold'em."
+#define POKER_TALK_MATCH_BUYIN "The buy-in for this match is $10,000."

src/poker/card.c

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+#include "card.h"
+
+void cardDeal(card_t *source, uint8_t *sourceSize, card_t *dest,
+  uint8_t *destSize
+) {
+  card_t card;
+  uint8_t i;
+
+  // Take Card
+  i = *sourceSize - 1;
+  card = source[i];
+  *sourceSize = i;
+
+  // Put card
+  i = *destSize;
+  dest[i] = card;
+  *destSize = i+1;
+}

src/poker/card.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+#pragma once
+#include <dawn/dawn.h>
+
+/**
+ * Deals a card from an array source to an array destination. Pointers to array
+ * lengths will be updated.
+ * 
+ * @param source Array source.
+ * @param sourceSize Pointer to where the count of cards is being stored.
+ * @param dest Array destination.
+ * @param destSize Pointer to the size of the destination array.
+ */
+void cardDeal(card_t *source, uint8_t *sourceSize, card_t *dest,
+  uint8_t *destSize
+);

src/poker/player.c

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "player.h"
+
+void pokerPlayerBet(poker_t *poker, pokerplayer_t *player, int32_t chips) {
+  poker->pot += chips;
+  player->chips -= chips;
+  player->currentBet += chips;
+}

src/poker/player.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <dawn/dawn.h>
+
+/**
+ * Let a player bet chips into the pot.
+ * 
+ * @param poker Poker game instance.
+ * @param player Poker player instance.
+ * @param chips Chips to bet.
+ */
+void pokerPlayerBet(poker_t *poker, pokerplayer_t *player, int32_t chips);

src/poker/poker.c

@@ -33,13 +33,19 @@ void pokerUpdate(poker_t *poker, engine_t *engine) {
     case POKER_ROUND_MATCH:
       pokerMatchUpdate(poker);
       break;
+    case POKER_ROUND_BET0:
+    case POKER_ROUND_BET1:
+    case POKER_ROUND_BET2:
+    case POKER_ROUND_BET3:
+      pokerBetUpdate(poker);
+      break;
     default:
       break;
   }
   
-  // Rendering
   shaderUse(&poker->shader);
   pokerFrameWorld(poker, &engine->render);
+
   pokerWorldRender(poker);
   for(uint8_t pi = 0; pi < POKER_PLAYER_COUNT; pi++) {
     uint8_t seat = pokerPlayerGetSeatForPlayer(pi);

src/poker/render/talk.c

@@ -48,13 +48,16 @@ void pokerTalkRender(poker_t *poker, input_t *input) {
   shaderUseTexture(&poker->shader, &poker->font.texture);
   primitiveDraw(&poker->talkPrimitive, 0, -1);
 
-  if(inputIsPressed(input, INPUT_ACCEPT)) poker->talkText = NULL;
+  if(inputIsPressed(input, INPUT_ACCEPT)) {
+    poker->talkText = NULL;
+  }
 }
 
 void pokerTalk(poker_t *poker, char *text) {
   poker->talkText = text;
+  poker->roundTextCounter++;
 }
 
 bool pokerTalkIsTalking(poker_t *poker) {
-  return poker->talkTextInfo != NULL;
+  return poker->talkText != NULL || poker->talkTextInfo != NULL;
 }

src/poker/round/bet.c

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "bet.h"
+
+void pokerBetPlayerNext(poker_t *poker) {
+  // Go to next player, keep contained.
+  poker->roundBetCurrent = (poker->roundBetCurrent + 1) % POKER_PLAYER_COUNT;
+
+  // Did we go full circle?
+  if(poker->roundBetCurrent == poker->roundSmallBlind) {
+    if(poker->round == POKER_ROUND_BET3) {
+      pokerWinnerInit(poker);
+      return;
+    }
+
+    pokerFlopInit(poker);
+    return;
+  }
+
+  // Init the next player
+  pokerBetPlayerInit(poker, poker->players + poker->roundBetCurrent);
+}
+
+void pokerBetPlayerUpdate(poker_t *poker, pokerplayer_t *player) {
+  pokerBetPlayerNext(poker);
+}
+
+void pokerBetPlayerInit(poker_t *poker, pokerplayer_t *player) {
+  // Check the player state (to see if we even can init, e.g. folded/not)
+  if(player->state & (POKER_PLAYER_STATE_FOLDED|POKER_PLAYER_STATE_OUT)) {
+    pokerBetPlayerNext(poker);
+    return;
+  }
+  
+  printf("Betting round player %u\n", poker->roundBetCurrent);
+}
+
+void pokerBetInit(poker_t *poker) {
+  printf("Betting round start\n");
+ 
+  if(poker->round == POKER_ROUND_DEAL) {
+    poker->round = POKER_ROUND_BET0;
+    printf("Betting 0\n");
+  } else if(poker->round == POKER_ROUND_FLOP) {
+    poker->round = POKER_ROUND_BET1;
+    printf("Betting 1\n");
+  } else if(poker->round == POKER_ROUND_TURN) {
+    poker->round = POKER_ROUND_BET2;
+    printf("Betting 2\n");
+  } else if(poker->round == POKER_ROUND_RIVER) {
+    poker->round = POKER_ROUND_BET3;
+    printf("Betting 3\n");
+  }
+  
+  // Set the inital player
+  poker->roundBetCurrent = poker->roundSmallBlind;
+  pokerBetPlayerInit(poker, poker->players+poker->roundBetCurrent);
+}
+
+void pokerBetUpdate(poker_t *poker) {
+  // Take the current player
+  pokerBetPlayerUpdate(poker, poker->players + poker->roundBetCurrent);
+}

src/poker/round/bet.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "flop.h"
+#include "winner.h"
+
+void pokerBetPlayerNext(poker_t *poker);
+void pokerBetPlayerInit(poker_t *poker, pokerplayer_t *player);
+void pokerBetPlayerUpdate(poker_t *poker, pokerplayer_t *player);
+
+void pokerBetInit(poker_t *poker);
+void pokerBetUpdate(poker_t *poker);

src/poker/round/blinds.c

@@ -10,4 +10,11 @@
 
 void pokerBlindsInit(poker_t *poker) {
   poker->round = POKER_ROUND_BLINDS;
+
+  // Now take blinds
+  pokerPlayerBet(poker,poker->players+poker->roundSmallBlind, poker->blindSmall);
+  pokerPlayerBet(poker,poker->players+poker->roundBigBlind, poker->blindBig);
+
+  printf("Blinds Taken\n");
+  pokerDealInit(poker);
 }

src/poker/round/blinds.h

@@ -6,6 +6,8 @@
  */
 
 #include <dawn/dawn.h>
+#include "deal.h"
+#include "../player.h"
 
 /**
  * Initializes the blinds round.

src/poker/round/deal.c

@@ -9,27 +9,9 @@
 void pokerDealInit(poker_t *poker) {
   uint8_t x, y;
   card_t temporary;
-
-  // Prepare the initial game state
+  pokerplayer_t *player;
+  
   poker->round = POKER_ROUND_DEAL;
-  poker->pot = 0;
-  poker->roundBet = 0;
-  poker->graveSize = 0;
-  poker->cardsFacing = 0;
-  poker->deckSize = CARD_DECK_SIZE;
-  for(x = 0; x < CARD_DECK_SIZE; x++) poker->deck[x] = x;
-
-  // Reset the players
-  for(x = 0; x < POKER_PLAYER_COUNT; x++) {
-    poker->players[x].cardCount = 0;
-    poker->players[x].currentBet = 0;
-
-    // Invert then bitwise AND to turn off.
-    poker->players[x].state &= ~(
-      POKER_PLAYER_STATE_FOLDED | 
-      POKER_PLAYER_STATE_SHOWING
-    );
-  }
 
   // Hard look at the dealer
   pokerLookAtPlayer(&poker->cameraWorld, POKER_SEAT_DEALER);
@@ -42,5 +24,18 @@ void pokerDealInit(poker_t *poker) {
     poker->deck[y] = poker->deck[x];// Move my card there
     poker->deck[x] = temporary;// Put other card here.
   }
-  printf("Deal\n");
+
+  // Deal 2 card to each player
+  for(y = 0; y < POKER_DEAL_CARD_EACH; y++) {
+    for(x = 0; x < POKER_PLAYER_COUNT; x++) {
+      player = poker->players + x;
+      cardDeal(
+        poker->deck, &poker->deckSize,
+        player->cards, &player->cardCount
+      );
+    }
+  }
+  
+  printf("Cards Dealt\n");
+  pokerBetInit(poker);
 }

src/poker/round/deal.h

@@ -7,8 +7,10 @@
 
 #pragma once
 #include <dawn/dawn.h>
-#include "blinds.h"
 #include "../render/look.h"
+#include "../player.h"
+#include "../card.h"
+#include "bet.h"
 
 /**
  * Resets a poker game for the new round.

src/poker/round/flop.c

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "flop.h"
+
+void pokerFlopInit(poker_t *poker) {
+  uint8_t count, i;
+
+  if(poker->round == POKER_ROUND_BET0) {
+    printf("Poker Flop Start\n");
+    poker->round = POKER_ROUND_FLOP;
+    count = POKER_FLOP_CARD_COUNT;
+  } else if(poker->round == POKER_ROUND_BET1) {
+    printf("Poker Turn\n");
+    poker->round = POKER_ROUND_TURN;
+    count = POKER_TURN_CARD_COUNT;
+  } else if(poker->round == POKER_ROUND_BET2) {
+    printf("Poker River\n");
+    poker->round = POKER_ROUND_RIVER;
+    count = POKER_RIVER_CARD_COUNT;
+  }
+
+  // Burn a card
+  poker->deckSize--;
+
+  // Flops
+  for(i = 0; i < count; i++) {
+    cardDeal(
+      poker->deck, &poker->deckSize,
+      poker->cards, &poker->cardsFacing
+    );
+  }
+
+  pokerBetInit(poker);
+}

src/poker/round/flop.h

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "bet.h"
+#include "../card.h"
+
+void pokerFlopInit(poker_t *poker);

src/poker/round/match.c

@@ -16,16 +16,16 @@ void pokerMatchInit(poker_t *poker) {
   poker->blindBig = POKER_BLIND_BIG_DEFAULT;
   poker->blindSmall = POKER_BLIND_SMALL_DEFAULT;
   poker->roundDealer = 0x00;
+  poker->roundTextCounter = 0;
+  poker->round = POKER_ROUND_MATCH;
 
   for(x = 0; x < POKER_PLAYER_COUNT; x++) {
     poker->players[x].state = 0x00;
     poker->players[x].chips = POKER_PLAYER_CHIPS_DEFAULT;
   }
-
-  pokerTalk(poker, POKER_TALK_MATCH_START);
+  printf("Match Start\n");
+  pokerStartInit(poker);
 }
 
 void pokerMatchUpdate(poker_t *poker) {
-  if(pokerTalkIsTalking(poker)) return;
-  pokerDealInit(poker);
 }

src/poker/round/match.h

@@ -7,7 +7,7 @@
 
 #pragma once
 #include <dawn/dawn.h>
-#include "deal.h"
+#include "start.h"
 #include "../render/look.h"
 #include "../render/talk.h"
 

src/poker/round/start.c

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "start.h"
+
+void pokerStartInit(poker_t *poker) {
+  uint8_t i, indexDealer, indexSmallBlind, indexBigBlind;
+  bool foundDealer, foundSmallBlind;
+  pokerplayer_t *player;
+
+  poker->round = POKER_ROUND_START;
+
+  // Prepare the initial game state
+  poker->round = POKER_ROUND_DEAL;
+  poker->pot = 0;
+  poker->graveSize = 0;
+  poker->cardsFacing = 0;
+  poker->deckSize = CARD_DECK_SIZE;
+  for(i = 0; i < CARD_DECK_SIZE; i++) poker->deck[i] = i;
+
+  // Reset the players
+  for(i = 0; i < POKER_PLAYER_COUNT; i++) {
+    poker->players[i].cardCount = 0;
+    poker->players[i].currentBet = 0;
+
+    // Invert then bitwise AND to turn off.
+    poker->players[i].state &= ~(
+      POKER_PLAYER_STATE_FOLDED | 
+      POKER_PLAYER_STATE_SHOWING
+    );
+  }
+
+  // Decide on the dealer
+  poker->roundDealer++;
+
+  // Find the players.
+  i = poker->roundDealer;
+  foundDealer = false;
+  foundSmallBlind = false;
+  while(true) {
+    player = poker->players + i;
+    if(player->state & POKER_PLAYER_STATE_FOLDED) continue;
+    if(player->state & POKER_PLAYER_STATE_OUT) continue;
+    if(!foundDealer) {
+      indexDealer = i;
+      foundDealer = true;
+    } else if(!foundSmallBlind) {
+      indexSmallBlind = i;
+      foundSmallBlind = true;
+    } else {
+      indexBigBlind = i;
+      break;
+    }
+    i = (i + 1) % POKER_PLAYER_COUNT;
+  }
+  
+  // Update players for the round.
+  poker->roundBigBlind = indexBigBlind;
+  poker->roundSmallBlind = indexSmallBlind;
+
+  printf("Round Start\n");
+  pokerBlindsInit(poker);
+}

src/poker/round/start.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "blinds.h"
+
+void pokerStartInit(poker_t *poker);

src/poker/round/winner.c

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "winner.h"
+
+void pokerWinnerInit(poker_t *poker) {
+  poker->round = POKER_ROUND_WINNER;
+  printf("Winner Winner Chicken Dinner\n");
+}

src/poker/round/winner.h

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+
+void pokerWinnerInit(poker_t *poker);

tools/model/model.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../primitive.h"
+
+#define POKER_CHIP_NAME "Poker Chip"
+#define POKER_CHIP_VERTICE_COUNT 5249
+#define POKER_CHIP_INDICE_COUNT 29874
+#define POKER_CHIP_TRIANGLE_COUNT 9958
+
+/**
+ * Generated Model Poker Chip
+ * Generated at Sun, 30 May 2021 01:23:51 GMT
+ * @returns Poker Chip as a primitive.
+ */
+primitive_t * pokerChipCreate();

tools/model/obj_to_c.js

@@ -12,7 +12,7 @@ const FLIP_TEXTURE_Y = true;
 let rawVertices = [];
 let faces = [];
 let coordinates = [];
-const filePath = path.join(__dirname, '..', '..', 'assets', 'models', 'Chip Single', 'Single Chip.obj');
+const filePath = path.join(__dirname, '..', '..', 'assets', 'models', 'poker table_del', 'poker_table.obj');
 const data = fs.readFileSync(filePath, 'utf-8');
 
 const scale = 0.1;
@@ -103,7 +103,7 @@ const header = `${license}
  * Generated at ${new Date().toUTCString()}
  * @returns ${MODEL_NAME} as a primitive.
  */
-primitive_t * ${MODEL_NAME_CAMEL}Create();
+void ${MODEL_NAME_CAMEL}Init(primitive_t *primitive);
 `;
 
 // Write Source file
@@ -118,7 +118,7 @@ const strIndices = indices.map(i => {
 const source = `${license}
 #include "${fn}.h"
 
-primitive_t * ${MODEL_NAME_CAMEL}Create() {
+primitive_t * ${MODEL_NAME_CAMEL}Create(primitive_t *primitive) {
   vertice_t vertices[${MODEL_NAME_CAPS}_VERTICE_COUNT] = {
     ${strVertices}
   };
@@ -127,7 +127,7 @@ primitive_t * ${MODEL_NAME_CAMEL}Create() {
     ${strIndices}
   };
 
-  primitive_t *primitive = primitiveCreate(
+  primitiveInit(
     ${MODEL_NAME_CAPS}_VERTICE_COUNT,
     ${MODEL_NAME_CAPS}_INDICE_COUNT
   );