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

Even more refactoring

Browse Source
This commit is contained in:
Dominic Masters
2021-09-19 20:50:35 -07:00
parent 3ed24da3b6
commit e87e04decf
22 changed files with 120 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/poker/bet.c
View File

@ -17,21 +17,27 @@ void pokerBetReset(pokerbet_t *bet) {
bet->currentBet = 0;
}
void pokerBetPlayer(poker_t *poker, pokerplayer_t *player, int32_t chips) {
poker->bet.pot += chips;
player->chips -= chips;
player->currentBet += chips;
poker->bet.currentBet = mathMax(poker->bet.currentBet, player->currentBet);
uint8_t pokerBetGetRoundPlayerDefault(uint8_t roundSmallBlind) {
return (roundSmallBlind + 1) % POKER_PLAYER_COUNT;
}
void pokerBetResetBetter(poker_t *poker) {
void pokerBetPlayer(pokerbet_t *bet, pokerplayer_t *player, int32_t chips) {
bet->pot += chips;
player->chips -= chips;
player->currentBet += chips;
bet->currentBet = mathMax(bet->currentBet, player->currentBet);
}
void pokerBetResetBetter(
pokerbet_t *poker, pokerplayer_t *players, uint8_t roundSmallBlind
) {
uint8_t i;
pokerplayer_t *player;
for(i = 0; i < POKER_PLAYER_COUNT; i++) {
player = poker->players + i;
player = players + i;
player->state = flagOff(player->state, POKER_PLAYER_STATE_ROUND_MOVE);
}
poker->bet.better = POKER_BET_ROUND_PLAYER_DEFAULT(poker);
bet->better = pokerBetGetRoundPlayerDefault(roundSmallBlind);
}
bool pokerBetPlayerCanBet(pokerbet_t *bet, pokerplayer_t *player) {
@ -43,22 +49,24 @@ bool pokerBetPlayerCanBet(pokerbet_t *bet, pokerplayer_t *player) {
return true;
}
uint8_t pokerBetGetRemainingPlayer(poker_t *poker) {
uint8_t pokerBetGetRemainingPlayer(
pokerbet_t *bet, pokerplayer_t *players, uint8_t roundSmallBlind
) {
uint8_t def, j, pi;
def = POKER_BET_ROUND_PLAYER_DEFAULT(poker);
def = pokerBetGetRoundPlayerDefault(roundSmallBlind);
for(j = 0; j < POKER_PLAYER_COUNT; j++) {
pi = ((def + j) % POKER_PLAYER_COUNT);
if(!pokerBetPlayerCanBet(&poker->bet, poker->players + pi)) continue;
if(!pokerBetPlayerCanBet(bet, players + pi)) continue;
return pi;
}
return 0xFF;
}
void pokerBetTakeBlinds(poker_t *poker) {
pokerBetPlayer(poker, poker->players + poker->roundSmallBlind,
poker->bet.blindSmall
);
pokerBetPlayer(poker, poker->players + poker->roundBigBlind,
poker->bet.blindBig
);
void pokerBetTakeBlinds(
pokerbet_t *bet, pokerplayer_t *players,
uint8_t roundSmallBlind, uint8_t roundBigBlind,
int32_t blindSmall, int32_t blindBig
) {
pokerBetPlayer(bet, players + roundSmallBlind, blindSmall);
pokerBetPlayer(bet, players + roundBigBlind, blindBig);
}

45
src/poker/bet.h
View File

@ -5,6 +5,7 @@
#pragma once
#include "../libs.h"
#include "player.h"
/** How many chips each player has by defautl */
#define POKER_BET_PLAYER_CHIPS_DEFAULT 10000
@ -15,16 +16,6 @@
/** The default blind cost for the small blind. (Defaults half big blind) */
#define POKER_BET_BLIND_SMALL_DEFAULT (POKER_BET_BLIND_BIG_DEFAULT/2)
/**
* The default betting player for the round.
*
* @param poker Pointer to the poker instance.
* @return The Poker round default betting player.
*/
#define POKER_BET_ROUND_PLAYER_DEFAULT(poker) ( \
((poker)->roundSmallBlind + 1) % POKER_PLAYER_COUNT \
)
typedef struct {
/** Blinds */
int32_t blindSmall, blindBig;
@ -53,22 +44,34 @@ void pokerBetInit(pokerbet_t *bet);
*/
void pokerBetReset(pokerbet_t *bet);
/**
* The default betting player for the round.
*
* @param roundSmallBlind Current round small blind player index.
* @return The Poker round default betting player index.
*/
uint8_t pokerBetGetRoundPlayerDefault(uint8_t roundSmallBlind);
/**
* Let a player bet chips into the pot.
*
* @param poker Poker game instance.
* @param bet Poker bet instance.
* @param player Poker player instance.
* @param chips Chips to bet.
*/
void pokerBetPlayer(poker_t *poker, pokerplayer_t *player, int32_t chips);
void pokerBetPlayer(pokerbet_t *bet, pokerplayer_t *player, int32_t chips);
/**
* Reset the current better back to the round/turns default. The better will
* always be the player to the right of the small blind player.
*
* @param poker Poker game to update for.
* @param bet Poker betting structure.
* @param player Array of poker players.
* @param roundSmallBlind Current round small blind player index.
*/
void pokerBetResetBetter(poker_t *poker);
void pokerBetResetBetter(
pokerbet_t *poker, pokerplayer_t *players, uint8_t roundSmallBlind
);
/**
* Returns whether or not a player can bet for the current round.
@ -83,14 +86,22 @@ bool pokerBetPlayerCanBet(pokerbet_t *bet, pokerplayer_t *player);
* Returns the index of the first player that remains to bet for the current
* round.
*
* @param poker Poker instance to fetch from.
* @param bet Poker betting structure.
* @param player Array of poker players.
* @param roundSmallBlind Current round small blind player index.
* @return The player index of the remaining player, otherwise 0xFF.
*/
uint8_t pokerBetGetRemainingPlayer(poker_t *poker);
uint8_t pokerBetGetRemainingPlayer(
pokerbet_t *bet, pokerplayer_t *players, uint8_t roundSmallBlind
);
/**
* Takes the current blinds from the correct players.
*
* @param poker Poker game to take the blinds from.
*/
void pokerBetTakeBlinds(poker_t *poker);
void pokerBetTakeBlinds(
pokerbet_t *bet, pokerplayer_t *players,
uint8_t roundSmallBlind, uint8_t roundBigBlind,
int32_t blindSmall, int32_t blindBig
);

8
src/poker/dealer.c
View File

@ -39,15 +39,17 @@ void pokerDealerDeal(pokerdealer_t *dealer, pokerplayer_t *player) {
cardDeal(dealer->deck, &dealer->deckSize, player->cards, &player->cardCount);
}
void pokerDealerDealAll(poker_t *poker, uint8_t count) {
void pokerDealerDealAll(
pokerdealer_t *dealer, pokerplayer_t *players, uint8_t count
) {
uint8_t x, y;
pokerplayer_t *player;
for(y = 0; y < count; y++) {
for(x = 0; x < POKER_PLAYER_COUNT; x++) {
player = poker->players + x;
player = players + x;
if(!pokerPlayerIsAlive(player)) continue;
pokerDealerDeal(&poker->dealer, player);
pokerDealerDeal(dealer, player);
}
}
}

8
src/poker/dealer.h
View File

@ -5,7 +5,6 @@
#pragma once
#include "../libs.h"
#include "poker.h"
#include "card.h"
#include "player.h"
@ -68,7 +67,10 @@ void pokerDealerDeal(pokerdealer_t *dealer, pokerplayer_t *player);
/**
* Deal card(s) to every active player.
*
* @param poker Poker game instance.
* @param dealer Poker dealer instance.
* @param players Array of poker players.
* @param count Count of cards to deal.
*/
void pokerDealerDealAll(poker_t *poker, uint8_t count);
void pokerDealerDealAll(
pokerdealer_t *dealer, pokerplayer_t *players, uint8_t count
);

4
src/poker/player.c
View File

@ -11,10 +11,6 @@ bool pokerPlayerIsAlive(pokerplayer_t *player) {
return !(player->state & (POKER_PLAYER_STATE_FOLDED|POKER_PLAYER_STATE_OUT));
}
bool pokerPlayerIsHuman(poker_t *poker, pokerplayer_t *player) {
return (poker->players + POKER_PLAYER_HUMAN_INDEX) == player;
}
void pokerPlayerReset(pokerplayer_t *player) {
player->cardCount = 0;
player->currentBet = 0;

11
src/poker/player.h
View File

@ -7,8 +7,8 @@
#pragma once
#include "../libs.h"
#include "../util/flags.h"
#include "card.h"
#include "poker.h"
/** How many cards a player can hold in their hand */
#define POKER_PLAYER_HAND 2
@ -64,15 +64,6 @@ typedef struct {
*/
bool pokerPlayerIsAlive(pokerplayer_t *player);
/**
* Returns true if the player provided is human or not.
*
* @param poker Poker game instance.
* @param player Player instance.
* @returns True if the player is human.
*/
bool pokerPlayerIsHuman(poker_t *poker, pokerplayer_t *player);
/**
* Resets a poker player's state (for a new round).
*

30
src/poker/winner.c
View File

@ -7,27 +7,27 @@
#include "winner.h"
void pokerWinnerHandGetFull(poker_t *poker, pokerplayer_t *player,
card_t *cards
){
void pokerWinnerHandGetFull(
pokerdealer_t *dealer, pokerplayer_t *player, card_t *cards
) {
uint8_t i;
// Add the dealer hand
for(i = 0; i < poker->dealer.cardsFacing; i++) {
cards[i] = poker->dealer.cards[i];
for(i = 0; i < dealer->cardsFacing; i++) {
cards[i] = dealer->cards[i];
}
// Add the player hand
for(i = 0; i < player->cardCount; i++) {
cards[i+poker->dealer.cardsFacing] = player->cards[i];
cards[i+dealer->cardsFacing] = player->cards[i];
}
// Sort by card value
cardHandSort(cards, poker->dealer.cardsFacing + player->cardCount);
cardHandSort(cards, dealer->cardsFacing + player->cardCount);
}
void pokerWinnerPlayerGet(
poker_t *poker, pokerplayer_t *player, pokerplayerwinning_t *winning
pokerdealer_t *dealer, pokerplayer_t *player, pokerplayerwinning_t *winning
) {
uint8_t i, j, l;
int32_t index;
@ -36,8 +36,8 @@ void pokerWinnerPlayerGet(
int32_t pairs[CARD_SUIT_COUNT];
// Get the full poker hand (should be a 7 card hand, but MAY not be)
winning->fullSize = poker->dealer.cardsFacing + player->cardCount;
pokerWinnerHandGetFull(poker, player, winning->full);
winning->fullSize = dealer->cardsFacing + player->cardCount;
pokerWinnerHandGetFull(dealer, player, winning->full);
// Reset the winning status.
winning->setSize = 0;
@ -284,26 +284,26 @@ card_t pokerWinnerCompare(pokerplayerwinning_t *left, pokerplayerwinning_t *righ
return highCardLeft;//Greater or Equal to.
}
void pokerWinnerCalculate(poker_t *poker) {
void pokerWinnerCalculate(
pokerwinner_t *winner, pokerdealer_t *dealer, pokerplayer_t *players
) {
uint8_t i, j, number, highNumber;
pokerwinner_t *winner;
pokerplayerwinning_t *left, *right;
pokerplayer_t *player;
card_t card, highCard;
bool isWinner;
winner = &poker->winner;
winner->winnerCount = 0;
// Get winning sets
for(i = 0; i < POKER_PLAYER_COUNT; i++) {
left = winner->winnings + i;
left->type = POKER_WINNING_TYPE_NULL;
player = poker->players + i;
player = players + i;
if(!pokerPlayerIsAlive(player)) continue;
// Get the players' winning state.
pokerWinnerPlayerGet(poker, player, left);
pokerWinnerPlayerGet(dealer, player, left);
}
// Compare against each player

22
src/poker/winner.h
View File

@ -10,7 +10,7 @@
#include "card.h"
#include "player.h"
#include "winner.h"
#include "poker.h"
#include "dealer.h"
/** Size of the FULL hand used to calculate a winning. */
#define POKER_WINNING_FULL_SIZE POKER_PLAYER_HAND+POKER_DEALER_HAND_SIZE
@ -59,24 +59,24 @@ typedef struct {
* Returns the full hand for a given player including the best cards on the
* bench.
*
* @param poker Poker game instance.
* @param dealer Poker game dealer instance.
* @param player Poker player game instance.
* @param cards Array of at least 7 length to store the array.
*/
void pokerWinnerHandGetFull(poker_t *poker, pokerplayer_t *player,
card_t *cards
void pokerWinnerHandGetFull(
pokerdealer_t *dealer, pokerplayer_t *player, card_t *cards
);
/**
* Calculates and returns the winning state for a given player
*
* @param poker Poker game instance.
* @param player Player game instance.
* @param dealer Poker game dealer instance.
* @param players Array of poker players.
* @param winning Pointer to the poker winning to fill out.
* @return The winning state for this player.
*/
void pokerWinnerPlayerGet(
poker_t *poker, pokerplayer_t *player, pokerplayerwinning_t *winning
pokerdealer_t *dealer, pokerplayer_t *player, pokerplayerwinning_t *winning
);
/**
@ -102,6 +102,10 @@ card_t pokerWinnerCompare(
* Determines the winning player for the game. Values will be stored back into
* the poker winning state.
*
* @param poker Poker game instance.
* @param winner Location to store the winner state.
* @param dealer Poker game dealer instance.
* @param players Array of poker players.
*/
void pokerWinnerCalculate(poker_t *poker);
void pokerWinnerCalculate(
pokerwinner_t *winner, pokerdealer_t *dealer, pokerplayer_t *players
);