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

Nuked Poker State

Browse Source
This commit is contained in:
Dominic Masters
2021-05-17 06:43:48 -07:00
parent c854ebbb5d
commit a97933d366
17 changed files with 185 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -11,20 +11,20 @@ void holdemRenderCardInit() {
tilesetdiv_t *cardBack;
// Load Cards Texture
POKER_STATE.cardTexture = assetTextureLoad("cards_normal.png");
POKER_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
POKER_STATE.cardTexture->width, POKER_STATE.cardTexture->height,
GAME_STATE.cardTexture = assetTextureLoad("cards_normal.png");
GAME_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
GAME_STATE.cardTexture->width, GAME_STATE.cardTexture->height,
0, 0, 0, 0
);
// Cards Primitive
cardBack = POKER_STATE.cardTileset->divisions+(
POKER_STATE.cardTileset->columns * 4
cardBack = GAME_STATE.cardTileset->divisions+(
GAME_STATE.cardTileset->columns * 4
);
POKER_STATE.cardPrimitive = primitiveCreate(
GAME_STATE.cardPrimitive = primitiveCreate(
QUAD_VERTICE_COUNT * 2, QUAD_INDICE_COUNT * 2
);
quadBuffer(POKER_STATE.cardPrimitive, -HOLDEM_GAME_CARD_DEPTH,
quadBuffer(GAME_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,
@ -74,8 +74,8 @@ pokerposition_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 = POKER_STATE.cardTileset->divisions + card;
quadBuffer(POKER_STATE.cardPrimitive, HOLDEM_GAME_CARD_DEPTH,
tilesetdiv_t *cardFront = GAME_STATE.cardTileset->divisions + card;
quadBuffer(GAME_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,9 +83,9 @@ void holdemRenderCard(card_t card, float x, float y, float z,
0, 0
);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.cardTexture);
shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.cardTexture);
shaderUsePosition(GAME_STATE.shaderWorld, x,y,z, pitch,yaw,roll);
primitiveDraw(POKER_STATE.cardPrimitive, 0, -1);
primitiveDraw(GAME_STATE.cardPrimitive, 0, -1);
}
void holdemRenderCardForSeat(uint8_t seat, card_t card, uint8_t slot) {

62
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;
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);
GAME_STATE.frameLeft = frameBufferCreate(lWidth, height);
GAME_STATE.frameRight = frameBufferCreate(rWidth, height);
GAME_STATE.quadLeft = quadCreate(0, 0, 0, 0, 0, lWidth, height, 1, 1);
GAME_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((
POKER_STATE.frameLeft->texture->width == lWidth &&
POKER_STATE.frameLeft->texture->height == height
GAME_STATE.frameLeft->texture->width == lWidth &&
GAME_STATE.frameLeft->texture->height == height
)) return;
// Recreate frame buffers.
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,
frameBufferDispose(GAME_STATE.frameLeft);
frameBufferDispose(GAME_STATE.frameRight);
GAME_STATE.frameLeft = frameBufferCreate(lWidth, height);
GAME_STATE.frameRight = frameBufferCreate(rWidth, height);
quadBuffer(GAME_STATE.quadLeft, 0,
0, 0, 0, 1,
lWidth, height, 1, 0,
0, 0
);
quadBuffer(POKER_STATE.quadRight, 0,
quadBuffer(GAME_STATE.quadRight, 0,
0, 0, 0, 1,
rWidth, height, 1, 0,
0, 0
@ -48,46 +48,46 @@ void holdemRenderFrameUpdate() {
void holdemRenderFrameUseLeft() {
glClearColor(0.3, 0, 0, 1);
frameBufferUse(POKER_STATE.frameLeft, true);
cameraPerspective(&POKER_STATE.cameraLeft, 35,
frameBufferUse(GAME_STATE.frameLeft, true);
cameraPerspective(&GAME_STATE.cameraLeft, 35,
(
(float)POKER_STATE.frameLeft->texture->width /
(float)POKER_STATE.frameLeft->texture->height
(float)GAME_STATE.frameLeft->texture->width /
(float)GAME_STATE.frameLeft->texture->height
), 0.2f, 1000.0f
);
shaderUseCamera(GAME_STATE.shaderWorld, &POKER_STATE.cameraLeft);
shaderUseCamera(GAME_STATE.shaderWorld, &GAME_STATE.cameraLeft);
}
void holdemRenderFrameUseRight() {
glClearColor(0.3, 0.3, 0, 1);
frameBufferUse(POKER_STATE.frameRight, true);
cameraPerspective(&POKER_STATE.cameraRight, 45,
frameBufferUse(GAME_STATE.frameRight, true);
cameraPerspective(&GAME_STATE.cameraRight, 45,
(
(float)POKER_STATE.frameRight->texture->width /
(float)POKER_STATE.frameRight->texture->height
(float)GAME_STATE.frameRight->texture->width /
(float)GAME_STATE.frameRight->texture->height
), 0.2f, 1000.0f
);
cameraLookAt(&POKER_STATE.cameraRight, 0, 3, 3, 0, 0, 0);
shaderUseCamera(GAME_STATE.shaderWorld, &POKER_STATE.cameraRight);
cameraLookAt(&GAME_STATE.cameraRight, 0, 3, 3, 0, 0, 0);
shaderUseCamera(GAME_STATE.shaderWorld, &GAME_STATE.cameraRight);
}
void holdemRenderFrameBack() {
glClearColor(0, 0, 0, 1);
frameBufferUse(NULL, true);
cameraOrtho(&GAME_STATE.cameraWorld, 0,
cameraOrtho(&GAME_STATE.cameraMain, 0,
RENDER_STATE.width, RENDER_STATE.height, 1, 0, 1
);
cameraLookAt(&GAME_STATE.cameraWorld, 0, 0, 0.5f, 0, 0, 0);
shaderUseCamera(GAME_STATE.shaderWorld, &GAME_STATE.cameraWorld);
cameraLookAt(&GAME_STATE.cameraMain, 0, 0, 0.5f, 0, 0, 0);
shaderUseCamera(GAME_STATE.shaderWorld, &GAME_STATE.cameraMain);
shaderUsePosition(GAME_STATE.shaderWorld,
0, 0, 0, 0, 0, 0
);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.frameLeft->texture);
primitiveDraw(POKER_STATE.quadLeft, 0, -1);
shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.frameLeft->texture);
primitiveDraw(GAME_STATE.quadLeft, 0, -1);
shaderUsePosition(GAME_STATE.shaderWorld,
RENDER_STATE.width - POKER_STATE.frameRight->texture->width,
RENDER_STATE.width - GAME_STATE.frameRight->texture->width,
0, 0, 0, 0, 0
);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.frameRight->texture);
primitiveDraw(POKER_STATE.quadRight, 0, -1);
shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.frameRight->texture);
primitiveDraw(GAME_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(&POKER_STATE.cameraLeft,
cameraLookAt(&GAME_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(&POKER_STATE.cameraLeft,
cameraLookAt(&GAME_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() {
POKER_STATE.kagamiTexture = assetTextureLoad("kagami.png");
POKER_STATE.kagamiTileset = tilesetCreate(3, 2,
POKER_STATE.kagamiTexture->width,
POKER_STATE.kagamiTexture->height,
GAME_STATE.kagamiTexture = assetTextureLoad("kagami.png");
GAME_STATE.kagamiTileset = tilesetCreate(3, 2,
GAME_STATE.kagamiTexture->width,
GAME_STATE.kagamiTexture->height,
0, 0, 0, 0
);
POKER_STATE.kagamiQuad = quadCreate(0, 0, 0, 0, 0, 1, 1, 1, 1);
GAME_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)POKER_STATE.kagamiTileset->divY /
(float)POKER_STATE.kagamiTileset->divX
(float)GAME_STATE.kagamiTileset->divY /
(float)GAME_STATE.kagamiTileset->divX
) * w;
// Animation
int i = (int32_t)(TIME_STATE.current*10)%POKER_STATE.kagamiTileset->count;
quadBuffer(POKER_STATE.kagamiQuad, 0,
int i = (int32_t)(TIME_STATE.current*10)%GAME_STATE.kagamiTileset->count;
quadBuffer(GAME_STATE.kagamiQuad, 0,
-w/2, -h/2,
POKER_STATE.kagamiTileset->divisions[i].x0,
POKER_STATE.kagamiTileset->divisions[i].y1,
GAME_STATE.kagamiTileset->divisions[i].x0,
GAME_STATE.kagamiTileset->divisions[i].y1,
w/2, h/2,
POKER_STATE.kagamiTileset->divisions[i].x1,
POKER_STATE.kagamiTileset->divisions[i].y0,
GAME_STATE.kagamiTileset->divisions[i].x1,
GAME_STATE.kagamiTileset->divisions[i].y0,
0, 0
);
// Render
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.kagamiTexture);
shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.kagamiTexture);
shaderUsePosition(GAME_STATE.shaderWorld,
x, 0.34, z,
0, angle, 0
);
primitiveDraw(POKER_STATE.kagamiQuad, 0, -1);
primitiveDraw(GAME_STATE.kagamiQuad, 0, -1);
}

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

@ -8,8 +8,8 @@
#include "world.h"
void holdemRenderWorldInit() {
POKER_STATE.tablePrimitive = pokerTableCreate();
POKER_STATE.tableTexture = assetTextureLoad("pokertable.png");
GAME_STATE.tablePrimitive = pokerTableCreate();
GAME_STATE.tableTexture = assetTextureLoad("pokertable.png");
}
void holdemRenderWorld() {
@ -23,26 +23,26 @@ void holdemRenderWorld() {
0, 0, 0,
3.4, 3.4, 3.4
);
shaderUseTexture(GAME_STATE.shaderWorld, POKER_STATE.tableTexture);
primitiveDraw(POKER_STATE.tablePrimitive, 0, -1);
shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.tableTexture);
primitiveDraw(GAME_STATE.tablePrimitive, 0, -1);
// Render the dealer and her hand
holdemRenderPlayer(HOLDEM_GAME_SEAT_DEALER);
for(i = 0x00; i < POKER_STATE.cardsFacing; i++) {
for(i = 0x00; i < GAME_STATE.cardsFacing; i++) {
holdemRenderCardForSeat(
HOLDEM_GAME_SEAT_DEALER,
POKER_STATE.cards[i],
GAME_STATE.cards[i],
HOLDEM_GAME_CARD_SLOT_FLOP0 + i
);
}
// Test
for(i = 0x00; i < POKER_PLAYER_COUNT; i++) {
player = POKER_STATE.players + i;
player = GAME_STATE.players + i;
seat = holdemRenderPlayerGetSeatForPlayer(i);
holdemRenderPlayer(seat);
if(player->state & POKER_STATE_FOLDED) continue;
if(player->state & GAME_STATE_FOLDED) continue;
for(j = 0x00; j < player->cardCount; j++) {
holdemRenderCardForSeat(seat, player->cards[j], HOLDEM_GAME_CARD_SLOT_HAND0+j);