YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Slowly renaming things from Holdem to Poker

Browse Source
This commit is contained in:
Dominic Masters
2021-05-17 06:13:50 -07:00
parent fbd00b1bc2
commit d956305af7
28 changed files with 253 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/dawn/dawn.h
View File

@ -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"

25
include/dawn/poker/action.h Normal file
View File

@ -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;

1
include/dawn/poker/card.h
View File

@ -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

37
include/dawn/poker/player.h Normal file
View File

@ -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;

79
include/dawn/poker/holdem.h → include/dawn/poker/poker.h
View File

@ -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];
void *actionData[HOLDEM_GAME_ACTION_DATA_SIZE*HOLDEM_GAME_ACTION_QUEUE_SIZE];
bool actionInitState[HOLDEM_GAME_ACTION_DATA_SIZE];
pokeraction_t actionQueue[POKER_ACTION_QUEUE_SIZE];
void *actionData[POKER_ACTION_DATA_SIZE*POKER_ACTION_QUEUE_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;
typedef struct {
float x, z;
float yaw;
} holdemrenderposition_t;
extern holdemgame_t HOLDEM_GAME_STATE;
extern pokergame_t POKER_STATE;

27
include/dawn/poker/render.h Normal file
View File

@ -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;

50
src/poker/action/action.c
View File

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

2
src/poker/action/action.h
View File

@ -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.

6
src/poker/action/ai.c
View File

@ -7,8 +7,8 @@
#include "ai.h"
holdemaction_t actionAi() {
return (holdemaction_t){
pokeraction_t actionAi() {
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());
}
}

2
src/poker/action/ai.h
View File

@ -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);

16
src/poker/action/deal.c
View File

@ -7,8 +7,8 @@
#include "deal.h"
holdemaction_t actionDeal() {
return (holdemaction_t){
pokeraction_t actionDeal() {
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++) {
player = HOLDEM_GAME_STATE.players + j;
cardDeal(HOLDEM_GAME_STATE.deck,
for(j = 0; j < POKER_PLAYER_COUNT; j++) {
player = POKER_STATE.players + j;
cardDeal(POKER_STATE.deck,
player->cards,
HOLDEM_GAME_STATE.deckSize,
POKER_STATE.deckSize,
player->cardCount
);
HOLDEM_GAME_STATE.deckSize--;
POKER_STATE.deckSize--;
player->cardCount++;
}
}

2
src/poker/action/deal.h
View File

@ -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);

16
src/poker/action/flop.c
View File

@ -7,8 +7,8 @@
#include "flop.h"
holdemaction_t actionFlop() {
return (holdemaction_t){
pokeraction_t actionFlop() {
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);
HOLDEM_GAME_STATE.deckSize -= 1;
HOLDEM_GAME_STATE.cardsFacing += 1;
cardDeal(POKER_STATE.deck, POKER_STATE.cards, POKER_STATE.deckSize, POKER_STATE.cardsFacing);
POKER_STATE.deckSize -= 1;
POKER_STATE.cardsFacing += 1;
}
// Next action

2
src/poker/action/flop.h
View File

@ -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);

26
src/poker/action/round.c
View File

@ -7,8 +7,8 @@
#include "round.h"
holdemaction_t actionRound() {
return (holdemaction_t){
pokeraction_t actionRound() {
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);
HOLDEM_GAME_STATE.deckSize = CARD_DECK_SIZE;
HOLDEM_GAME_STATE.pot = 0;
HOLDEM_GAME_STATE.cardsFacing = 0;
cardDeckFill(POKER_STATE.deck);
POKER_STATE.deckSize = CARD_DECK_SIZE;
POKER_STATE.pot = 0;
POKER_STATE.cardsFacing = 0;
// Reset the players
for(i = 0; i < HOLDEM_PLAYER_COUNT; i++) {
player = HOLDEM_GAME_STATE.players + i;
for(i = 0; i < POKER_PLAYER_COUNT; i++) {
player = POKER_STATE.players + i;
// Clear Round State(s)
player->state &= ~(
HOLDEM_STATE_FOLDED |
HOLDEM_STATE_SHOWING
POKER_STATE_FOLDED |
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;
}

2
src/poker/action/round.h
View File

@ -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);

6
src/poker/action/shuffle.c
View File

@ -7,8 +7,8 @@
#include "shuffle.h"
holdemaction_t actionShuffle() {
return (holdemaction_t){
pokeraction_t actionShuffle() {
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);
}

2
src/poker/action/shuffle.h
View File

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

16
src/poker/action/start.c
View File

@ -7,8 +7,8 @@
#include "start.h"
holdemaction_t actionStart() {
holdemaction_t action = {
pokeraction_t actionStart() {
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;
HOLDEM_GAME_STATE.blindSmall = 0;
HOLDEM_GAME_STATE.pot = 0;
POKER_STATE.blindBig = 0;
POKER_STATE.blindSmall = 0;
POKER_STATE.pot = 0;
// Reset the players
for(i = 0; i < HOLDEM_PLAYER_COUNT; i++) {
player = HOLDEM_GAME_STATE.players + i;
for(i = 0; i < POKER_PLAYER_COUNT; i++) {
player = POKER_STATE.players + i;
player->state = 0x00;
player->chips = 0;
}

2
src/poker/action/start.h
View File

@ -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);

12
src/poker/holdemgame.c
View File

@ -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");
HOLDEM_GAME_STATE.fontTileset = tilesetCreate(20, 20,
HOLDEM_GAME_STATE.fontTexture->width,
HOLDEM_GAME_STATE.fontTexture->height,
POKER_STATE.fontTexture = assetTextureLoad("font.png");
POKER_STATE.fontTileset = tilesetCreate(20, 20,
POKER_STATE.fontTexture->width,
POKER_STATE.fontTexture->height,
1, 1, 1, 1
);
HOLDEM_GAME_STATE.fontBatch = spriteBatchCreate(1024);
POKER_STATE.fontBatch = spriteBatchCreate(1024);
// Prepare the renderer.
holdemRenderFrameInit();

28
src/poker/render/card.c
View File

@ -11,20 +11,20 @@ void holdemRenderCardInit() {
tilesetdiv_t *cardBack;
// Load Cards Texture
HOLDEM_GAME_STATE.cardTexture = assetTextureLoad("cards_normal.png");
HOLDEM_GAME_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
HOLDEM_GAME_STATE.cardTexture->width, HOLDEM_GAME_STATE.cardTexture->height,
POKER_STATE.cardTexture = assetTextureLoad("cards_normal.png");
POKER_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
POKER_STATE.cardTexture->width, POKER_STATE.cardTexture->height,
0, 0, 0, 0
);
// Cards Primitive
cardBack = HOLDEM_GAME_STATE.cardTileset->divisions+(
HOLDEM_GAME_STATE.cardTileset->columns * 4
cardBack = POKER_STATE.cardTileset->divisions+(
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) {
holdemrenderposition_t position;
pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
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;
quadBuffer(HOLDEM_GAME_STATE.cardPrimitive, HOLDEM_GAME_CARD_DEPTH,
tilesetdiv_t *cardFront = POKER_STATE.cardTileset->divisions + card;
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);
}

2
src/poker/render/card.h
View File

@ -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

56
src/poker/render/frame.c
View File

@ -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);
HOLDEM_GAME_STATE.frameRight = frameBufferCreate(rWidth, height);
HOLDEM_GAME_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.frameLeft = frameBufferCreate(lWidth, height);
POKER_STATE.frameRight = frameBufferCreate(rWidth, height);
POKER_STATE.quadLeft = quadCreate(0, 0, 0, 0, 0, lWidth, 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 &&
HOLDEM_GAME_STATE.frameLeft->texture->height == height
POKER_STATE.frameLeft->texture->width == lWidth &&
POKER_STATE.frameLeft->texture->height == height
)) return;
// Recreate frame buffers.
frameBufferDispose(HOLDEM_GAME_STATE.frameLeft);
frameBufferDispose(HOLDEM_GAME_STATE.frameRight);
HOLDEM_GAME_STATE.frameLeft = frameBufferCreate(lWidth, height);
HOLDEM_GAME_STATE.frameRight = frameBufferCreate(rWidth, height);
quadBuffer(HOLDEM_GAME_STATE.quadLeft, 0,
frameBufferDispose(POKER_STATE.frameLeft);
frameBufferDispose(POKER_STATE.frameRight);
POKER_STATE.frameLeft = frameBufferCreate(lWidth, height);
POKER_STATE.frameRight = frameBufferCreate(rWidth, height);
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);
cameraPerspective(&HOLDEM_GAME_STATE.cameraLeft, 35,
frameBufferUse(POKER_STATE.frameLeft, true);
cameraPerspective(&POKER_STATE.cameraLeft, 35,
(
(float)HOLDEM_GAME_STATE.frameLeft->texture->width /
(float)HOLDEM_GAME_STATE.frameLeft->texture->height
(float)POKER_STATE.frameLeft->texture->width /
(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);
cameraPerspective(&HOLDEM_GAME_STATE.cameraRight, 45,
frameBufferUse(POKER_STATE.frameRight, true);
cameraPerspective(&POKER_STATE.cameraRight, 45,
(
(float)HOLDEM_GAME_STATE.frameRight->texture->width /
(float)HOLDEM_GAME_STATE.frameRight->texture->height
(float)POKER_STATE.frameRight->texture->width /
(float)POKER_STATE.frameRight->texture->height
), 0.2f, 1000.0f
);
cameraLookAt(&HOLDEM_GAME_STATE.cameraRight, 0, 3, 3, 0, 0, 0);
shaderUseCamera(GAME_STATE.shaderWorld, &HOLDEM_GAME_STATE.cameraRight);
cameraLookAt(&POKER_STATE.cameraRight, 0, 3, 3, 0, 0, 0);
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);
primitiveDraw(HOLDEM_GAME_STATE.quadLeft, 0, -1);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.frameLeft->texture);
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);
primitiveDraw(HOLDEM_GAME_STATE.quadRight, 0, -1);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.frameRight->texture);
primitiveDraw(POKER_STATE.quadRight, 0, -1);
}

4
src/poker/render/look.c
View File

@ -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
);

30
src/poker/render/player.c
View File

@ -8,13 +8,13 @@
#include "player.h"
void holdemRenderPlayerInit() {
HOLDEM_GAME_STATE.kagamiTexture = assetTextureLoad("kagami.png");
HOLDEM_GAME_STATE.kagamiTileset = tilesetCreate(3, 2,
HOLDEM_GAME_STATE.kagamiTexture->width,
HOLDEM_GAME_STATE.kagamiTexture->height,
POKER_STATE.kagamiTexture = assetTextureLoad("kagami.png");
POKER_STATE.kagamiTileset = tilesetCreate(3, 2,
POKER_STATE.kagamiTexture->width,
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)HOLDEM_GAME_STATE.kagamiTileset->divX
(float)POKER_STATE.kagamiTileset->divY /
(float)POKER_STATE.kagamiTileset->divX
) * w;
// Animation
int i = (int32_t)(TIME_STATE.current*10)%HOLDEM_GAME_STATE.kagamiTileset->count;
quadBuffer(HOLDEM_GAME_STATE.kagamiQuad, 0,
int i = (int32_t)(TIME_STATE.current*10)%POKER_STATE.kagamiTileset->count;
quadBuffer(POKER_STATE.kagamiQuad, 0,
-w/2, -h/2,
HOLDEM_GAME_STATE.kagamiTileset->divisions[i].x0,
HOLDEM_GAME_STATE.kagamiTileset->divisions[i].y1,
POKER_STATE.kagamiTileset->divisions[i].x0,
POKER_STATE.kagamiTileset->divisions[i].y1,
w/2, h/2,
HOLDEM_GAME_STATE.kagamiTileset->divisions[i].x1,
HOLDEM_GAME_STATE.kagamiTileset->divisions[i].y0,
POKER_STATE.kagamiTileset->divisions[i].x1,
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);
}

8
src/poker/render/scene.c
View File

@ -8,8 +8,8 @@
#include "scene.h"
void holdemRenderSceneInit() {
HOLDEM_GAME_STATE.tablePrimitive = pokerTableCreate();
HOLDEM_GAME_STATE.tableTexture = assetTextureLoad("pokertable.png");
POKER_STATE.tablePrimitive = pokerTableCreate();
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);
primitiveDraw(HOLDEM_GAME_STATE.tablePrimitive, 0, -1);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.tableTexture);
primitiveDraw(POKER_STATE.tablePrimitive, 0, -1);
}

12
src/poker/render/world.c
View File

@ -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++) {
player = HOLDEM_GAME_STATE.players + i;
for(i = 0x00; i < POKER_PLAYER_COUNT; 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);