From bc3c07d36f1288b07abf7ad5ae3b75cb4e30945c Mon Sep 17 00:00:00 2001
From: Dominic Masters <dominic@domsplace.com>
Date: Thu, 14 Oct 2021 21:32:51 -0700
Subject: [PATCH] Just cleaning
---
src/game/poker/actions/bet.c | 4 +-
src/game/poker/actions/bet.h | 1 +
src/game/poker/actions/flop.c | 16 +-
src/game/poker/actions/round.c | 2 +-
src/game/poker/actions/start.c | 2 +-
src/game/poker/pokerui.c | 10 +-
src/poker/bet.c | 29 ++--
src/poker/bet.h | 11 +-
src/poker/card.c | 6 +-
src/poker/card.h | 6 +-
src/poker/dealer.c | 20 +--
src/poker/dealer.h | 27 ++--
src/poker/poker.c | 6 +-
src/poker/poker.h | 1 +
src/poker/turn.c | 6 +-
test/poker/card.c | 20 +--
test/poker/poker.c | 287 ++++++++++++++++-----------------
17 files changed, 228 insertions(+), 226 deletions(-)
diff --git a/src/game/poker/actions/bet.c b/src/game/poker/actions/bet.c
index d48a29e8..e9d4bd48 100644
--- a/src/game/poker/actions/bet.c
+++ b/src/game/poker/actions/bet.c
@@ -64,9 +64,7 @@ void _pokerGameActionBetOnEnd(
pokergame_t *game = (pokergame_t *)action->data;
// // Get which player is remaining to move.
- game->poker.better = pokerPlayerGetNextBetter(
- &game->poker, game->poker.better
- );
+ game->poker.better = pokerBetGetNextPlayer(&game->poker);
// Restack
pokerGameActionRestackAdd(game);
diff --git a/src/game/poker/actions/bet.h b/src/game/poker/actions/bet.h
index a2dd367b..945cf662 100644
--- a/src/game/poker/actions/bet.h
+++ b/src/game/poker/actions/bet.h
@@ -7,6 +7,7 @@
#pragma once
#include "../../../libs.h"
+#include "../../../poker/bet.h"
#include "../pokerdiscussion.h"
#include "action.h"
#include "restack.h"
diff --git a/src/game/poker/actions/flop.c b/src/game/poker/actions/flop.c
index 8d6b6f80..2288ff3a 100644
--- a/src/game/poker/actions/flop.c
+++ b/src/game/poker/actions/flop.c
@@ -26,16 +26,16 @@ void _pokerGameActionFlopOnStart(
hasDoneFlop = true;
switch(game->poker.communitySize) {
case 0x00:
- pokerBurn(&game->poker, POKER_FLOP_BURN_COUNT);
- pokerTurn(&game->poker, POKER_FLOP_CARD_COUNT);
+ pokerDealerBurn(&game->poker, POKER_FLOP_BURN_COUNT);
+ pokerDealerTurn(&game->poker, POKER_FLOP_CARD_COUNT);
break;
case POKER_FLOP_CARD_COUNT:
- pokerBurn(&game->poker, POKER_FLOP_BURN_COUNT);
- pokerTurn(&game->poker, POKER_TURN_CARD_COUNT);
+ pokerDealerBurn(&game->poker, POKER_FLOP_BURN_COUNT);
+ pokerDealerTurn(&game->poker, POKER_TURN_CARD_COUNT);
break;
case POKER_FLOP_CARD_COUNT+POKER_TURN_CARD_COUNT:
- pokerBurn(&game->poker, POKER_FLOP_BURN_COUNT);
- pokerTurn(&game->poker, POKER_RIVER_CARD_COUNT);
+ pokerDealerBurn(&game->poker, POKER_FLOP_BURN_COUNT);
+ pokerDealerTurn(&game->poker, POKER_RIVER_CARD_COUNT);
break;
default:
hasDoneFlop = false;
@@ -50,9 +50,9 @@ void _pokerGameActionFlopOnStart(
// Now, get the count of players left to bet. If "everyone is all in" then
// this will be 0 and no actual betting needs to happen.
- if(pokerPlayerGetRemainingBetterCount(&game->poker) > 0x01) {
+ if(pokerBetGetRemainingPlayerCount(&game->poker) > 0x01) {
// Begin betting.
- game->poker.better = pokerPlayerGetRemainingBetter(&game->poker);
+ game->poker.better = pokerBetGetRemainingPlayer(&game->poker);
pokerGameActionLookAdd(game, game->poker.better);
pokerGameActionBetAdd(game);
} else {
diff --git a/src/game/poker/actions/round.c b/src/game/poker/actions/round.c
index 10a7610b..ea2d0daa 100644
--- a/src/game/poker/actions/round.c
+++ b/src/game/poker/actions/round.c
@@ -19,7 +19,7 @@ void _pokerGameActionRoundOnEnd(queue_t *queue,queueaction_t *action,uint8_t i){
// Start the round
pokerResetRound(&game->poker);
- pokerNewDealer(&game->poker);
+ pokerDealerNew(&game->poker);
pokerTakeBlinds(&game->poker, game->poker.blindSmall, game->poker.blindBig);
// Speak
diff --git a/src/game/poker/actions/start.c b/src/game/poker/actions/start.c
index 5c2f3096..3ec7f864 100644
--- a/src/game/poker/actions/start.c
+++ b/src/game/poker/actions/start.c
@@ -27,7 +27,7 @@ void _pokerGameActionStartOnEnd(queue_t *queue,queueaction_t *action,uint8_t i){
k = pokerPlayerAdd(&game->poker);
pokerPlayerChipsAdd(game->poker.players+k, POKER_BET_PLAYER_CHIPS_DEFAULT);
}
- pokerSetDealer(&game->poker, game->poker.playerCount/2);
+ pokerDealerSet(&game->poker, game->poker.playerCount/2);
// Say that.
data.poker = game;
diff --git a/src/game/poker/pokerui.c b/src/game/poker/pokerui.c
index a89778a6..b02ce8fd 100644
--- a/src/game/poker/pokerui.c
+++ b/src/game/poker/pokerui.c
@@ -97,12 +97,12 @@ void pokerUiUpdate(
void pokerUiRender(
pokerui_t *ui, engine_t *engine, pokergameassets_t *assets, poker_t *poker
) {
- uint8_t i, j;
- pokerplayer_t *player;
+ // uint8_t i, j;
+ // pokerplayer_t *player;
float scale;
- align_t align;
- float gx, gy, gw, gh, x, y;
- char message[128];
+ // align_t align;
+ // float gx, gy, gw, gh, x, y;
+ // char message[128];
// Get the default font scale size.
scale = fontGetScale(FONT_SIZE_DEFAULT);
diff --git a/src/poker/bet.c b/src/poker/bet.c
index 4fcbb58e..a1f2e93e 100644
--- a/src/poker/bet.c
+++ b/src/poker/bet.c
@@ -7,7 +7,7 @@
#include "bet.h"
-uint8_t pokerPlayerGetRemainingBetter(poker_t *poker) {
+uint8_t pokerBetGetRemainingPlayer(poker_t *poker) {
uint8_t i, j;
for(i = 0; i < poker->playerCount; i++) {
@@ -17,22 +17,16 @@ uint8_t pokerPlayerGetRemainingBetter(poker_t *poker) {
return 0xFF;
}
-
-uint8_t pokerPlayerGetNextBetter(poker_t *poker, uint8_t current) {
+uint8_t pokerBetGetNextPlayer(poker_t *poker) {
uint8_t i, j;
-
for(i = 0; i < poker->playerCount; i++) {
- j = (i + current + 1) % poker->playerCount;
+ j = (i + poker->better + 1) % poker->playerCount;
if(pokerPlayerDoesNeedToBetThisRound(poker, j)) return j;
}
return 0xFF;
}
-int32_t pokerPlayerGetCallBet(poker_t *poker, pokerplayer_t *player) {
- return pokerGetCallValue(poker) - player->currentBet;
-}
-
-uint8_t pokerPlayerGetRemainingBetterCount(poker_t *poker) {
+uint8_t pokerBetGetRemainingPlayerCount(poker_t *poker) {
uint8_t i, count;
count = 0;
for(i = 0; i < poker->playerCount; i++) {
@@ -42,7 +36,7 @@ uint8_t pokerPlayerGetRemainingBetterCount(poker_t *poker) {
return count;
}
-void pokerPlayerBetPot(
+void pokerBet(
poker_t *poker, pokerpot_t *pot, uint8_t playerIndex, int32_t chips
) {
pokerplayer_t *player;
@@ -54,8 +48,17 @@ void pokerPlayerBetPot(
pokerPotAddPlayer(pot, playerIndex);
}
-void pokerPlayerBet(poker_t *poker, uint8_t playerIndex, int32_t chips) {
- pokerPlayerBetPot(
+void pokerBetForPlayer(poker_t *poker, uint8_t playerIndex, int32_t chips) {
+ pokerBet(
poker, poker->pots + (poker->potCount - 1), playerIndex, chips
);
}
+
+
+
+
+
+//eh
+int32_t pokerPlayerGetCallBet(poker_t *poker, pokerplayer_t *player) {
+ return pokerGetCallValue(poker) - player->currentBet;
+}
\ No newline at end of file
diff --git a/src/poker/bet.h b/src/poker/bet.h
index 1ed12018..214d9580 100644
--- a/src/poker/bet.h
+++ b/src/poker/bet.h
@@ -10,7 +10,6 @@
#include "fuck.h"
#include "poker.h"
-
/**
* Returns the index of the first player that remains to bet for the current
* round.
@@ -18,7 +17,7 @@
* @param poker Poker game instance.
* @return The player index of the remaining player, otherwise 0xFF.
*/
-uint8_t pokerPlayerGetRemainingBetter(poker_t *poker);
+uint8_t pokerBetGetRemainingPlayer(poker_t *poker);
/**
* Returns the index of the first player that remains to bet for the current
@@ -28,7 +27,7 @@ uint8_t pokerPlayerGetRemainingBetter(poker_t *poker);
* @param current Current better player index.
* @return The player index of the next remaining player, otherwise 0xFF.
*/
-uint8_t pokerPlayerGetNextBetter(poker_t *poker, uint8_t current);
+uint8_t pokerBetGetNextPlayer(poker_t *poker);
/**
* Get the bet necessary for a specific player to make a call. This takes the
@@ -47,7 +46,7 @@ int32_t pokerPlayerGetCallBet(poker_t *poker, pokerplayer_t *player);
* @param poker Poker game instance.
* @return Count of players left to bet.
*/
-uint8_t pokerPlayerGetRemainingBetterCount(poker_t *poker);
+uint8_t pokerBetGetRemainingPlayerCount(poker_t *poker);
/**
* Let a player bet chips into the pot.
@@ -57,7 +56,7 @@ uint8_t pokerPlayerGetRemainingBetterCount(poker_t *poker);
* @param playerIndex The players' index that is betting.
* @param chips The amount of chips the player is betting.
*/
-void pokerPlayerBetPot(
+void pokerBet(
poker_t *poker, pokerpot_t *pot, uint8_t playerIndex, int32_t chips
);
@@ -68,4 +67,4 @@ void pokerPlayerBetPot(
* @param playerIndex The players' index that is betting.
* @param chips The amount of chips the player is betting.
*/
-void pokerPlayerBet(poker_t *poker, uint8_t playerIndex, int32_t chips);
+void pokerBetForPlayer(poker_t *poker, uint8_t playerIndex, int32_t chips);
diff --git a/src/poker/card.c b/src/poker/card.c
index f54fd507..9bdabc85 100644
--- a/src/poker/card.c
+++ b/src/poker/card.c
@@ -6,8 +6,8 @@
*/
#include "card.h"
-void cardDeal(card_t *source, uint8_t *sourceSize, card_t *dest,
- uint8_t *destSize
+void cardDeal(
+ card_t *source, uint8_t *sourceSize, card_t *dest, uint8_t *destSize
) {
card_t card;
uint8_t i;
@@ -78,7 +78,7 @@ uint8_t cardWriteDeck(card_t *hand) {
return CARD_DECK_SIZE;
}
-card_t cardGetHighestCard(card_t *cards, uint8_t cardCount) {
+card_t cardGetHighest(card_t *cards, uint8_t cardCount) {
uint8_t i, number, bestNumber;
card_t card, bestCard;
diff --git a/src/poker/card.h b/src/poker/card.h
index 80e80b80..9a3193db 100644
--- a/src/poker/card.h
+++ b/src/poker/card.h
@@ -140,8 +140,8 @@ typedef uint8_t card_t;
* @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
+void cardDeal(
+ card_t *source, uint8_t *sourceSize, card_t *dest, uint8_t *destSize
);
/**
@@ -211,4 +211,4 @@ uint8_t cardWriteDeck(card_t *hand);
* @param cardCount Length of the array.
* @return The highest card in the array.
*/
-card_t cardGetHighestCard(card_t *cards, uint8_t cardCount);
\ No newline at end of file
+card_t cardGetHighest(card_t *cards, uint8_t cardCount);
\ No newline at end of file
diff --git a/src/poker/dealer.c b/src/poker/dealer.c
index 572de52d..ac85a43b 100644
--- a/src/poker/dealer.c
+++ b/src/poker/dealer.c
@@ -7,11 +7,7 @@
#include "dealer.h"
-void pokerNewDealer(poker_t *poker) {
- pokerSetDealer(poker, poker->playerDealer + 1);
-}
-
-void pokerSetDealer(poker_t *poker, uint8_t dealer) {
+void pokerDealerSet(poker_t *poker, uint8_t dealer) {
uint8_t i, k;
pokerplayer_t *player;
bool foundDealer;
@@ -38,7 +34,11 @@ void pokerSetDealer(poker_t *poker, uint8_t dealer) {
}
}
-void pokerTurn(poker_t *poker, uint8_t count) {
+void pokerDealerNew(poker_t *poker) {
+ pokerDealerSet(poker, poker->playerDealer + 1);
+}
+
+void pokerDealerTurn(poker_t *poker, uint8_t count) {
uint8_t i;
for(i = 0; i < count; i++) {
cardDeal(
@@ -47,21 +47,21 @@ void pokerTurn(poker_t *poker, uint8_t count) {
}
}
-void pokerBurn(poker_t *poker, uint8_t count) {
+void pokerDealerBurn(poker_t *poker, uint8_t count) {
uint8_t i;
for(i = 0; i < count; i++) {
cardDeal(poker->deck, &poker->deckSize, poker->grave, &poker->graveSize);
}
}
-void pokerPlayerDeal(poker_t *poker, pokerplayer_t *player, uint8_t count) {
+void pokerDeal(poker_t *poker, pokerplayer_t *player, uint8_t count) {
uint8_t i;
for(i = 0; i < count; i++) {
cardDeal(poker->deck, &poker->deckSize, player->cards, &player->cardCount);
}
}
-void pokerPlayerDealAll(poker_t *poker, uint8_t count) {
+void pokerDealAllPlayers(poker_t *poker, uint8_t count) {
uint8_t i, j;
pokerplayer_t *player;
@@ -74,7 +74,7 @@ void pokerPlayerDealAll(poker_t *poker, uint8_t count) {
continue;
}
- pokerPlayerDeal(poker, player, 1);
+ pokerDeal(poker, player, 1);
}
}
}
diff --git a/src/poker/dealer.h b/src/poker/dealer.h
index d80de48d..0f4f1da9 100644
--- a/src/poker/dealer.h
+++ b/src/poker/dealer.h
@@ -8,14 +8,7 @@
#pragma once
#include "fuck.h"
#include "poker.h"
-
-/**
- * Cycles to the next dealer. This will also select the new small and big blind
- * players.
- *
- * @param poker Poker game to select a new dealer for.
- */
-void pokerNewDealer(poker_t *poker);
+#include "card.h"
/**
* Set a next dealer. This will also select the new small and big blind players.
@@ -24,7 +17,15 @@ void pokerNewDealer(poker_t *poker);
* @param poker Poker game to select a new dealer for.
* @param dealer Dealer to become the new dealer.
*/
-void pokerSetDealer(poker_t *poker, uint8_t dealer);
+void pokerDealerSet(poker_t *poker, uint8_t dealer);
+
+/**
+ * Cycles to the next dealer. This will also select the new small and big blind
+ * players.
+ *
+ * @param poker Poker game to select a new dealer for.
+ */
+void pokerDealerNew(poker_t *poker);
/**
* Turns over cards from the deck onto the table (from the deck into the dealer
@@ -33,7 +34,7 @@ void pokerSetDealer(poker_t *poker, uint8_t dealer);
* @param poker Poker game instance.
* @param count Count of cards to deal.
*/
-void pokerTurn(poker_t *poker, uint8_t count);
+void pokerDealerTurn(poker_t *poker, uint8_t count);
/**
* Burns a set of cards off the top of the deck into the graveyard.
@@ -41,7 +42,7 @@ void pokerTurn(poker_t *poker, uint8_t count);
* @param poker Poker game instance.
* @param count Count of cards to burn.
*/
-void pokerBurn(poker_t *poker, uint8_t count);
+void pokerDealerBurn(poker_t *poker, uint8_t count);
/**
* Deal a card to a player.
@@ -50,7 +51,7 @@ void pokerBurn(poker_t *poker, uint8_t count);
* @param player Poker player to deal to.
* @param count Count of cards to deal to the player.
*/
-void pokerPlayerDeal(poker_t *poker, pokerplayer_t *player, uint8_t count);
+void pokerDeal(poker_t *poker, pokerplayer_t *player, uint8_t count);
/**
* Deal card(s) to every active player.
@@ -58,4 +59,4 @@ void pokerPlayerDeal(poker_t *poker, pokerplayer_t *player, uint8_t count);
* @param poker Poker game instance.
* @param count Count of cards to deal.
*/
-void pokerPlayerDealAll(poker_t *poker, uint8_t count);
+void pokerDealAllPlayers(poker_t *poker, uint8_t count);
diff --git a/src/poker/poker.c b/src/poker/poker.c
index 32bf5ec3..d0b4a6fe 100644
--- a/src/poker/poker.c
+++ b/src/poker/poker.c
@@ -66,12 +66,12 @@ void pokerResetBettingRound(poker_t *poker) {
// Then we check who's remaining. We do this because the default better may
// have folded already.
- poker->better = pokerPlayerGetRemainingBetter(poker);
+ poker->better = pokerBetGetRemainingPlayer(poker);
}
void pokerTakeBlinds(poker_t *poker, int32_t small, int32_t big) {
- pokerPlayerBet(poker, poker->playerSmallBlind, small);
- pokerPlayerBet(poker, poker->playerBigBlind, big);
+ pokerBetForPlayer(poker, poker->playerSmallBlind, small);
+ pokerBetForPlayer(poker, poker->playerBigBlind, big);
pokerResetBettingRound(poker);
}
diff --git a/src/poker/poker.h b/src/poker/poker.h
index 6a23f949..ee6e002b 100644
--- a/src/poker/poker.h
+++ b/src/poker/poker.h
@@ -10,6 +10,7 @@
#include "../util/flags.h"
#include "../util/array.h"
#include "../util/math.h"
+#include "bet.h"
#include "card.h"
#include "dealer.h"
#include "fuck.h"
diff --git a/src/poker/turn.c b/src/poker/turn.c
index a9edc30f..3b601312 100644
--- a/src/poker/turn.c
+++ b/src/poker/turn.c
@@ -110,7 +110,7 @@ pokerturn_t pokerTurnGetForPlayer(poker_t *poker, uint8_t playerIndex) {
(float)callBet + (float)pokerPlayerGetPotChipsSum(poker, playerIndex)
);
} else {
- potOdds = 1.0f / (float)pokerPlayerGetRemainingBetterCount(poker);
+ potOdds = 1.0f / (float)pokerBetGetRemainingPlayerCount(poker);
}
// Now determine the expected ROI
@@ -202,12 +202,12 @@ void pokerTurnAction(poker_t *poker, uint8_t playerIndex, pokerturn_t turn) {
case POKER_TURN_TYPE_BET:
case POKER_TURN_TYPE_CALL:
case POKER_TURN_TYPE_ALL_IN:
- pokerPlayerBet(poker, playerIndex, turn.chips);
+ pokerBetForPlayer(poker, playerIndex, turn.chips);
player->timesRaised++;
break;
case POKER_TURN_TYPE_CHECK:
- pokerPlayerBet(poker, playerIndex, 0);
+ pokerBetForPlayer(poker, playerIndex, 0);
player->timesRaised = 0;
break;
diff --git a/test/poker/card.c b/test/poker/card.c
index 94df1d5c..bcd2c04b 100644
--- a/test/poker/card.c
+++ b/test/poker/card.c
@@ -238,35 +238,35 @@ void test_cardWriteDeck_should_ReturnCardsWritten(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, cardWriteDeck(cards));
}
-void test_cardGetHighestCard_should_ReturnTheHighestCard(void) {
+void test_cardGetHighest_should_ReturnTheHighestCard(void) {
card_t cards[CARD_DECK_SIZE];
uint8_t l = cardWriteDeck(cards);
- TEST_ASSERT_EQUAL(CARD_CLUBS_ACE, cardGetHighestCard(cards, l));
- TEST_ASSERT_EQUAL(CARD_CLUBS_ACE, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_CLUBS_ACE, cardGetHighest(cards, l));
+ TEST_ASSERT_EQUAL(CARD_CLUBS_ACE, cardGetHighest(cards, l));
l = 3;
- TEST_ASSERT_EQUAL(CARD_CLUBS_FOUR, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_CLUBS_FOUR, cardGetHighest(cards, l));
cards[0] = CARD_CLUBS_SIX;
cards[1] = CARD_HEARTS_SEVEN;
cards[2] = CARD_DIAMONDS_EIGHT;
cards[3] = CARD_SPADES_NINE;
l = 4;
- TEST_ASSERT_EQUAL(CARD_SPADES_NINE, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_SPADES_NINE, cardGetHighest(cards, l));
cards[2] = CARD_DIAMONDS_TEN;
- TEST_ASSERT_EQUAL(CARD_DIAMONDS_TEN, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_DIAMONDS_TEN, cardGetHighest(cards, l));
cards[2] = CARD_DIAMONDS_TEN;
- TEST_ASSERT_EQUAL(CARD_DIAMONDS_TEN, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_DIAMONDS_TEN, cardGetHighest(cards, l));
cards[4] = CARD_CLUBS_TEN;
l = 5;
- TEST_ASSERT_EQUAL(CARD_DIAMONDS_TEN, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_DIAMONDS_TEN, cardGetHighest(cards, l));
cards[1] = CARD_HEARTS_TEN;
- TEST_ASSERT_EQUAL(CARD_HEARTS_TEN, cardGetHighestCard(cards, l));
+ TEST_ASSERT_EQUAL(CARD_HEARTS_TEN, cardGetHighest(cards, l));
}
int test_card() {
@@ -284,7 +284,7 @@ int test_card() {
RUN_TEST(test_cardCountPairs_should_CountPairs);
RUN_TEST(test_cardWriteDeck_should_WriteCardsToArray);
RUN_TEST(test_cardWriteDeck_should_ReturnCardsWritten);
- RUN_TEST(test_cardGetHighestCard_should_ReturnTheHighestCard);
+ RUN_TEST(test_cardGetHighest_should_ReturnTheHighestCard);
return UNITY_END();
}
\ No newline at end of file
diff --git a/test/poker/poker.c b/test/poker/poker.c
index d5ab8e28..1fe9add4 100644
--- a/test/poker/poker.c
+++ b/test/poker/poker.c
@@ -90,7 +90,7 @@ void test_pokerResetBettingRound_should_ResetTheBettingRound(void) {
}
}
-void test_pokerNewDealer_should_FindANewDealer(void) {
+void test_pokerDealerNew_should_FindANewDealer(void) {
poker_t poker;
pokerInit(&poker);
@@ -104,28 +104,28 @@ void test_pokerNewDealer_should_FindANewDealer(void) {
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(2, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
TEST_ASSERT_EQUAL_UINT8(2, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(4, poker.playerBigBlind);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(4, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
TEST_ASSERT_EQUAL_UINT8(4, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
}
-void test_pokerSetDealer_should_SetANewSetOfPlayers(void) {
+void test_pokerDealerSet_should_SetANewSetOfPlayers(void) {
poker_t poker;
pokerInit(&poker);
@@ -135,38 +135,38 @@ void test_pokerSetDealer_should_SetANewSetOfPlayers(void) {
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
- pokerSetDealer(&poker, 0x00);
+ pokerDealerSet(&poker, 0x00);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(2, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x01);
+ pokerDealerSet(&poker, 0x01);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(2, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x02);
+ pokerDealerSet(&poker, 0x02);
TEST_ASSERT_EQUAL_UINT8(2, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(4, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x03);
+ pokerDealerSet(&poker, 0x03);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(4, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x04);
+ pokerDealerSet(&poker, 0x04);
TEST_ASSERT_EQUAL_UINT8(4, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x00);
+ pokerDealerSet(&poker, 0x00);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(2, poker.playerBigBlind);
}
-void test_pokerSetDealer_should_SkipOutPlayers(void) {
+void test_pokerDealerSet_should_SkipOutPlayers(void) {
poker_t poker;
pokerInit(&poker);
@@ -176,27 +176,27 @@ void test_pokerSetDealer_should_SkipOutPlayers(void) {
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
pokerPlayerAdd(&poker);
- pokerSetDealer(&poker, 0x00);
+ pokerDealerSet(&poker, 0x00);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x01);
+ pokerDealerSet(&poker, 0x01);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x02);
+ pokerDealerSet(&poker, 0x02);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x03);
+ pokerDealerSet(&poker, 0x03);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
- pokerSetDealer(&poker, 0x04);
+ pokerDealerSet(&poker, 0x04);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
@@ -212,7 +212,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips);
@@ -228,7 +228,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
TEST_ASSERT_EQUAL_INT32(800, (poker.players + 3)->chips);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
pokerTakeBlinds(&poker, 100, 200);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
@@ -342,19 +342,19 @@ void test_pokerPlayerAdd_should_ResetThePlayer(void) {
TEST_ASSERT_EQUAL_UINT8(POKER_PLAYER_STATE_OUT, player->state);
}
-void test_pokerTurn_should_TurnCardsFromTheDeck(void) {
+void test_pokerDealerTurn_should_TurnCardsFromTheDeck(void) {
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(0, poker.communitySize);
- pokerTurn(&poker, 1);
+ pokerDealerTurn(&poker, 1);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 1, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(1, poker.communitySize);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.community[0]);
- pokerTurn(&poker, 3);
+ pokerDealerTurn(&poker, 3);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 4, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(4, poker.communitySize);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.community[1]);
@@ -362,19 +362,19 @@ void test_pokerTurn_should_TurnCardsFromTheDeck(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.community[3]);
}
-void test_pokerBurn_should_SendCardsToTheGrave(void) {
+void test_pokerDealerBurn_should_SendCardsToTheGrave(void) {
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(0, poker.graveSize);
- pokerBurn(&poker, 1);
+ pokerDealerBurn(&poker, 1);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 1, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(1, poker.graveSize);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.grave[0]);
- pokerBurn(&poker, 3);
+ pokerDealerBurn(&poker, 3);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 4, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(4, poker.graveSize);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.grave[1]);
@@ -393,15 +393,15 @@ void test_pokerGetCallValue_should_CalculateTheCallValue(void) {
pokerPlayerChipsAdd(poker.players + second, 10000);
TEST_ASSERT_EQUAL_INT32(0, pokerGetCallValue(&poker));
- pokerPlayerBet(&poker, first, 100);
+ pokerBetForPlayer(&poker, first, 100);
TEST_ASSERT_EQUAL_INT32(100, pokerGetCallValue(&poker));
- pokerPlayerBet(&poker, second, 150);
+ pokerBetForPlayer(&poker, second, 150);
TEST_ASSERT_EQUAL_INT32(150, pokerGetCallValue(&poker));
pokerPotAdd(&poker);
TEST_ASSERT_EQUAL_INT32(150, pokerGetCallValue(&poker));
TEST_ASSERT_EQUAL_INT32(0, poker.pots[1].chips);
- pokerPlayerBet(&poker, second, 50);
+ pokerBetForPlayer(&poker, second, 50);
TEST_ASSERT_EQUAL_INT32(200, pokerGetCallValue(&poker));
TEST_ASSERT_EQUAL_INT32(50, poker.pots[1].chips);
}
@@ -413,15 +413,15 @@ void test_pokerGetCallValue_should_SkipOutPlayers(void) {
i = pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players + i, 10000);
- pokerPlayerBet(&poker, i, 300);
+ pokerBetForPlayer(&poker, i, 300);
i = pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players + i, 10000);
- pokerPlayerBet(&poker, i, 500);
+ pokerBetForPlayer(&poker, i, 500);
i = pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players + i, 10000);
- pokerPlayerBet(&poker, i, 200);
+ pokerBetForPlayer(&poker, i, 200);
TEST_ASSERT_EQUAL_INT32(500, pokerGetCallValue(&poker));
poker.players[1].state |= POKER_PLAYER_STATE_OUT;
@@ -430,7 +430,7 @@ void test_pokerGetCallValue_should_SkipOutPlayers(void) {
TEST_ASSERT_EQUAL_INT32(200, pokerGetCallValue(&poker));
}
-void test_pokerPlayerDeal_should_DealCardsToThePlayer(void) {
+void test_pokerDeal_should_DealCardsToThePlayer(void) {
poker_t poker;
uint8_t playerIndex;
pokerplayer_t *player;
@@ -443,12 +443,12 @@ void test_pokerPlayerDeal_should_DealCardsToThePlayer(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(0, player->cardCount);
- pokerPlayerDeal(&poker, player, 0x01);
+ pokerDeal(&poker, player, 0x01);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 1, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(1, player->cardCount);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, player->cards[0]);
- pokerPlayerDeal(&poker, player, 0x01);
+ pokerDeal(&poker, player, 0x01);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 2, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(2, player->cardCount);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, player->cards[1]);
@@ -487,7 +487,7 @@ void test_pokerPlayerChipsAdd_should_TurnOutStateOff(void) {
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_OUT, player->state);
}
-void test_pokerPlayerDealAll_should_DealCardsToEveryone(void) {
+void test_pokerDealAllPlayers_should_DealCardsToEveryone(void) {
poker_t poker;
pokerInit(&poker);
@@ -500,7 +500,7 @@ void test_pokerPlayerDealAll_should_DealCardsToEveryone(void) {
TEST_ASSERT_EQUAL_UINT8(0, poker.players[1].cardCount);
TEST_ASSERT_EQUAL_UINT8(0, poker.players[2].cardCount);
- pokerPlayerDealAll(&poker, 1);
+ pokerDealAllPlayers(&poker, 1);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 3, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(1, poker.players[0].cardCount);
TEST_ASSERT_EQUAL_UINT8(1, poker.players[1].cardCount);
@@ -511,7 +511,7 @@ void test_pokerPlayerDealAll_should_DealCardsToEveryone(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.players[2].cards[0]);
}
-void test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone(void) {
+void test_pokerDealAllPlayers_should_DealMultipleCardsToEveryone(void) {
poker_t poker;
pokerInit(&poker);
@@ -522,7 +522,7 @@ void test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
- pokerPlayerDealAll(&poker, 0x02);
+ pokerDealAllPlayers(&poker, 0x02);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[0].cardCount);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[1].cardCount);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[2].cardCount);
@@ -535,7 +535,7 @@ void test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_NINE, poker.players[2].cards[1]);
}
-void test_pokerPlayerDealAll_should_NotDealToOutPlayers(void) {
+void test_pokerDealAllPlayers_should_NotDealToOutPlayers(void) {
poker_t poker;
pokerInit(&poker);
@@ -546,7 +546,7 @@ void test_pokerPlayerDealAll_should_NotDealToOutPlayers(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
- pokerPlayerDealAll(&poker, 0x02);
+ pokerDealAllPlayers(&poker, 0x02);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[0].cardCount);
TEST_ASSERT_EQUAL_UINT8(0, poker.players[1].cardCount);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[2].cardCount);
@@ -557,7 +557,7 @@ void test_pokerPlayerDealAll_should_NotDealToOutPlayers(void) {
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.players[2].cards[1]);
}
-void test_pokerPlayerDealAll_should_NotDealToFoldedPlayers(void) {
+void test_pokerDealAllPlayers_should_NotDealToFoldedPlayers(void) {
poker_t poker;
pokerInit(&poker);
@@ -566,7 +566,7 @@ void test_pokerPlayerDealAll_should_NotDealToFoldedPlayers(void) {
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
poker.players[0].state |= POKER_PLAYER_STATE_FOLDED;
- pokerPlayerDealAll(&poker, 2);
+ pokerDealAllPlayers(&poker, 2);
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[1].cardCount);
TEST_ASSERT_EQUAL_UINT8(2, poker.players[2].cardCount);
@@ -588,15 +588,15 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue(void) {
pokerPlayerChipsAdd(poker.players + first, 10000);
pokerPlayerChipsAdd(poker.players + second, 10000);
- pokerPlayerBet(&poker, first, 100);
+ pokerBetForPlayer(&poker, first, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
- pokerPlayerBet(&poker, second, 200);
+ pokerBetForPlayer(&poker, second, 200);
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
- pokerPlayerBet(&poker, first, 100);
+ pokerBetForPlayer(&poker, first, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
}
@@ -613,11 +613,11 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet(void) {
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
- pokerPlayerBet(&poker, first, 100);
+ pokerBetForPlayer(&poker, first, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
- pokerPlayerBet(&poker, second, 100);
+ pokerBetForPlayer(&poker, second, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
}
@@ -634,7 +634,7 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
- pokerPlayerBet(&poker, first, 100);
+ pokerBetForPlayer(&poker, first, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
@@ -642,12 +642,12 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
- pokerPlayerBet(&poker, first, 100);
+ pokerBetForPlayer(&poker, first, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
}
-void test_pokerPlayerGetRemainingBetter_should_ReturnRemainingBetters(void) {
+void test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters(void) {
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
pokerInit(&poker);
@@ -664,46 +664,45 @@ void test_pokerPlayerGetRemainingBetter_should_ReturnRemainingBetters(void) {
pokerPlayerChipsAdd(poker.players + p2, 10000);
pokerPlayerChipsAdd(poker.players + p3, 10000);
pokerPlayerChipsAdd(poker.players + p4, 10000);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
// Blind + 1
- TEST_ASSERT_EQUAL(0x04, pokerPlayerGetRemainingBetter(&poker));
+ TEST_ASSERT_EQUAL(0x04, pokerBetGetRemainingPlayer(&poker));
// Blind + 2
- pokerPlayerBet(&poker, 0x04, pokerGetCallValue(&poker));
- TEST_ASSERT_EQUAL(0x00, pokerPlayerGetRemainingBetter(&poker));
+ pokerBetForPlayer(&poker, 0x04, pokerGetCallValue(&poker));
+ TEST_ASSERT_EQUAL(0x00, pokerBetGetRemainingPlayer(&poker));
// Blind + 3
- pokerPlayerBet(&poker, 0x00, pokerGetCallValue(&poker));
- TEST_ASSERT_EQUAL(0x01, pokerPlayerGetRemainingBetter(&poker));
+ pokerBetForPlayer(&poker, 0x00, pokerGetCallValue(&poker));
+ TEST_ASSERT_EQUAL(0x01, pokerBetGetRemainingPlayer(&poker));
// Blind + 4 / Small Blind
- pokerPlayerBet(&poker, 0x01, pokerGetCallValue(&poker));
- TEST_ASSERT_EQUAL(0x02, pokerPlayerGetRemainingBetter(&poker));
+ pokerBetForPlayer(&poker, 0x01, pokerGetCallValue(&poker));
+ TEST_ASSERT_EQUAL(0x02, pokerBetGetRemainingPlayer(&poker));
// Blind + 5 / Big Blind
- pokerPlayerBet(
+ pokerBetForPlayer(
&poker, 0x02, pokerGetCallValue(&poker) - poker.players[0x01].currentBet
);
- TEST_ASSERT_EQUAL(0x03, pokerPlayerGetRemainingBetter(&poker));
+ TEST_ASSERT_EQUAL(0x03, pokerBetGetRemainingPlayer(&poker));
// No remaining players.
- pokerPlayerBet(&poker, 0x03, 0);
- TEST_ASSERT_EQUAL(0xFF, pokerPlayerGetRemainingBetter(&poker));
+ pokerBetForPlayer(&poker, 0x03, 0);
+ TEST_ASSERT_EQUAL(0xFF, pokerBetGetRemainingPlayer(&poker));
// Raise
- pokerPlayerBet(&poker, 0x03, 100);
- TEST_ASSERT_EQUAL(0x04, pokerPlayerGetRemainingBetter(&poker));
+ pokerBetForPlayer(&poker, 0x03, 100);
+ TEST_ASSERT_EQUAL(0x04, pokerBetGetRemainingPlayer(&poker));
// Raise
- pokerPlayerBet(&poker, 0x04, 100);
- TEST_ASSERT_EQUAL(0x00, pokerPlayerGetRemainingBetter(&poker));
+ pokerBetForPlayer(&poker, 0x04, 100);
+ TEST_ASSERT_EQUAL(0x00, pokerBetGetRemainingPlayer(&poker));
}
-void test_pokerPlayerGetNextBetter_should_GetTheNextBetter(void) {
+void test_pokerBetGetNextPlayer_should_GetTheNextBetter(void) {
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
- uint8_t better;
pokerInit(&poker);
p0 = pokerPlayerAdd(&poker);
@@ -717,52 +716,54 @@ void test_pokerPlayerGetNextBetter_should_GetTheNextBetter(void) {
pokerPlayerChipsAdd(poker.players + p2, 10000);
pokerPlayerChipsAdd(poker.players + p3, 10000);
pokerPlayerChipsAdd(poker.players + p4, 10000);
- pokerNewDealer(&poker);
+ pokerDealerNew(&poker);
// Start at blind+1
- better = poker.playerBigBlind;
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x04, better);
+ poker.better = poker.playerBigBlind;
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x04, poker.better);
// Blind+2
- pokerPlayerBet(&poker, better, pokerGetCallValue(&poker));
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x00, better);
+ pokerBetForPlayer(&poker, poker.better, pokerGetCallValue(&poker));
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x00, poker.better);
// BLind+3
- pokerPlayerBet(&poker, better, pokerGetCallValue(&poker));
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x01, better);
+ pokerBetForPlayer(&poker, poker.better, pokerGetCallValue(&poker));
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x01, poker.better);
// Dealer
- pokerPlayerBet(&poker, better, pokerGetCallValue(&poker));
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x02, better);
+ pokerBetForPlayer(&poker, poker.better, pokerGetCallValue(&poker));
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x02, poker.better);
// Small blind
- pokerPlayerBet(
- &poker, better, pokerGetCallValue(&poker) - poker.players[0x02].currentBet
+ pokerBetForPlayer(
+ &poker, poker.better,
+ pokerGetCallValue(&poker) - poker.players[0x02].currentBet
);
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x03, better);
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x03, poker.better);
// Big Blind
- pokerPlayerBet(
- &poker, better, pokerGetCallValue(&poker) - poker.players[0x03].currentBet
+ pokerBetForPlayer(
+ &poker, poker.better,
+ pokerGetCallValue(&poker) - poker.players[0x03].currentBet
);
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0xFF, better);
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0xFF, poker.better);
// Raise
- better = poker.playerBigBlind;
- pokerPlayerBet(&poker, better, 100);
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x04, better);
+ poker.better = poker.playerBigBlind;
+ pokerBetForPlayer(&poker, poker.better, 100);
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x04, poker.better);
// Raise
- pokerPlayerBet(&poker, better, 100);
- better = pokerPlayerGetNextBetter(&poker, better);
- TEST_ASSERT_EQUAL_UINT8(0x00, better);
+ pokerBetForPlayer(&poker, poker.better, 100);
+ poker.better = pokerBetGetNextPlayer(&poker);
+ TEST_ASSERT_EQUAL_UINT8(0x00, poker.better);
}
void test_pokerPlayerGetCallBet_should_GetCallBet(void) {
@@ -774,17 +775,17 @@ void test_pokerPlayerGetCallBet_should_GetCallBet(void) {
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
- pokerPlayerBet(&poker, p0, 100);
+ pokerBetForPlayer(&poker, p0, 100);
TEST_ASSERT_EQUAL_INT32(0, pokerPlayerGetCallBet(&poker,poker.players+p0));
TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p1));
TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p2));
- pokerPlayerBet(&poker, p1, 200);
+ pokerBetForPlayer(&poker, p1, 200);
TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p0));
TEST_ASSERT_EQUAL_INT32(0, pokerPlayerGetCallBet(&poker,poker.players+p1));
TEST_ASSERT_EQUAL_INT32(200, pokerPlayerGetCallBet(&poker,poker.players+p2));
- pokerPlayerBet(&poker, p2, 300);
+ pokerBetForPlayer(&poker, p2, 300);
TEST_ASSERT_EQUAL_INT32(200, pokerPlayerGetCallBet(&poker,poker.players+p0));
TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p1));
TEST_ASSERT_EQUAL_INT32(0, pokerPlayerGetCallBet(&poker,poker.players+p2));
@@ -816,7 +817,7 @@ void test_pokerInRoundGetCount_should_ReturnCountOfPlayersInRound(void) {
TEST_ASSERT_EQUAL_UINT8(0x00, pokerInRoundGetCount(&poker));
}
-void test_pokerPlayerGetRemainintBetterCount_should_ReturnCountNeedsToBet(void){
+void test_pokerBetGetRemainingPlayerCount_should_ReturnCountNeedsToBet(void){
poker_t poker;
uint8_t p0, p1, p2;
@@ -825,24 +826,24 @@ void test_pokerPlayerGetRemainintBetterCount_should_ReturnCountNeedsToBet(void){
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
- TEST_ASSERT_EQUAL_UINT8(0x00, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingPlayerCount(&poker));
pokerPlayerChipsAdd(poker.players + p0, 1000);
- TEST_ASSERT_EQUAL_UINT8(0x01, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingPlayerCount(&poker));
pokerPlayerChipsAdd(poker.players + p2, 1000);
- TEST_ASSERT_EQUAL_UINT8(0x02, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingPlayerCount(&poker));
pokerPlayerChipsAdd(poker.players + p1, 1000);
- TEST_ASSERT_EQUAL_UINT8(0x03, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x03, pokerBetGetRemainingPlayerCount(&poker));
poker.players[0].state |= POKER_PLAYER_STATE_FOLDED;
- TEST_ASSERT_EQUAL_UINT8(0x02, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingPlayerCount(&poker));
poker.players[1].state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND;
- TEST_ASSERT_EQUAL_UINT8(0x01, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingPlayerCount(&poker));
poker.players[2].chips = 0;
- TEST_ASSERT_EQUAL_UINT8(0x00, pokerPlayerGetRemainingBetterCount(&poker));
+ TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingPlayerCount(&poker));
}
-void test_pokerPlayerBetPot_should_AddChipsToThePot(void) {
+void test_pokerBet_should_AddChipsToThePot(void) {
poker_t poker;
pokerpot_t *pot;
pokerplayer_t *player;
@@ -857,12 +858,12 @@ void test_pokerPlayerBetPot_should_AddChipsToThePot(void) {
TEST_ASSERT_EQUAL_INT32(0, pot->chips);
TEST_ASSERT_EQUAL_INT32(1000, player->chips);
- pokerPlayerBetPot(&poker, pot, i, 100);
+ pokerBet(&poker, pot, i, 100);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
TEST_ASSERT_EQUAL_INT32(900, player->chips);
}
-void test_pokerPlayerBetPot_should_UpdatePlayerState(void) {
+void test_pokerBet_should_UpdatePlayerState(void) {
poker_t poker;
uint8_t i;
pokerplayer_t *player;
@@ -875,15 +876,15 @@ void test_pokerPlayerBetPot_should_UpdatePlayerState(void) {
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, player->state);
TEST_ASSERT_EQUAL_INT32(0, player->currentBet);
- pokerPlayerBetPot(&poker, poker.pots, i, 100);
+ pokerBet(&poker, poker.pots, i, 100);
TEST_ASSERT_BITS_HIGH(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, player->state);
TEST_ASSERT_EQUAL_INT32(100, player->currentBet);
- pokerPlayerBetPot(&poker, poker.pots, i, 250);
+ pokerBet(&poker, poker.pots, i, 250);
TEST_ASSERT_EQUAL_INT32(350, player->currentBet);
}
-void test_pokerPlayerBet_should_BetToTheActivePot(void) {
+void test_pokerBetForPlayer_should_BetToTheActivePot(void) {
poker_t poker;
pokerpot_t *pot;
uint8_t i, j;
@@ -894,11 +895,11 @@ void test_pokerPlayerBet_should_BetToTheActivePot(void) {
pot = poker.pots;
TEST_ASSERT_EQUAL_INT32(0, pot->chips);
- pokerPlayerBet(&poker, i, 100);
+ pokerBetForPlayer(&poker, i, 100);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
j = pokerPotAdd(&poker);
- pokerPlayerBet(&poker, i, 50);
+ pokerBetForPlayer(&poker, i, 50);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
pot = poker.pots + j;
TEST_ASSERT_EQUAL_INT32(50, pot->chips);
@@ -916,27 +917,27 @@ void test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet(void) {
pokerPlayerChipsAdd(poker.players + p1, 1000);
pokerPlayerChipsAdd(poker.players + p2, 1000);
- pokerPlayerBet(&poker, p0, 100);
+ pokerBetForPlayer(&poker, p0, 100);
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p0));
TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p1));
TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p2));
- pokerPlayerBet(&poker, p1, 100);
+ pokerBetForPlayer(&poker, p1, 100);
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p0));
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p1));
TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p2));
- pokerPlayerBet(&poker, p2, 100);
+ pokerBetForPlayer(&poker, p2, 100);
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p0));
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p1));
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p2));
- pokerPlayerBet(&poker, p2, 100);
+ pokerBetForPlayer(&poker, p2, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p0));
TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p1));
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p2));
- pokerPlayerBet(&poker, p1, 100);
+ pokerBetForPlayer(&poker, p1, 100);
TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p0));
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p1));
TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p2));
@@ -992,15 +993,15 @@ void test_pokerTurnBet_should_ReturnACallAction(void) {
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
- pokerPlayerBet(&poker, 0, 300);
- pokerPlayerBet(&poker, 1, 500);
+ pokerBetForPlayer(&poker, 0, 300);
+ pokerBetForPlayer(&poker, 1, 500);
turn = pokerTurnBet(&poker, 0x00, 200);
TEST_ASSERT_EQUAL_INT32(200, turn.chips);
TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_CALL, turn.type);
TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);
- pokerPlayerBet(&poker, 0, 300);
+ pokerBetForPlayer(&poker, 0, 300);
turn = pokerTurnBet(&poker, 0x01, 100);
TEST_ASSERT_EQUAL_INT32(100, turn.chips);
TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_CALL, turn.type);
@@ -1034,11 +1035,11 @@ void test_pokerHandGetFull_should_ReturnTheFullHand(void) {
i = pokerPlayerAdd(&poker);
player = poker.players + i;
- pokerPlayerDeal(&poker, player, POKER_PLAYER_HAND_SIZE_MAX);
+ pokerDeal(&poker, player, POKER_PLAYER_HAND_SIZE_MAX);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, player->cards[0]);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, player->cards[1]);
- pokerTurn(&poker, POKER_COMMUNITY_SIZE_MAX);
+ pokerDealerTurn(&poker, POKER_COMMUNITY_SIZE_MAX);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.community[0]);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.community[1]);
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TEN, poker.community[2]);
@@ -1593,35 +1594,33 @@ int test_poker() {
RUN_TEST(test_pokerPotAdd_should_AddAPot);
RUN_TEST(test_pokerPotAdd_should_ResetThePot);
RUN_TEST(test_pokerPotHasPlayer_should_DetermineIfPlayerInThePot);
- RUN_TEST(test_pokerNewDealer_should_FindANewDealer);
- RUN_TEST(test_pokerSetDealer_should_SetANewSetOfPlayers);
- RUN_TEST(test_pokerSetDealer_should_SkipOutPlayers);
+ RUN_TEST(test_pokerDealerNew_should_FindANewDealer);
+ RUN_TEST(test_pokerDealerSet_should_SetANewSetOfPlayers);
+ RUN_TEST(test_pokerDealerSet_should_SkipOutPlayers);
RUN_TEST(test_pokerTakeBlinds_should_TakeTheBlinds);
RUN_TEST(test_pokerPotAddPlayer_should_AddAPlayer);
RUN_TEST(test_pokerPlayerAdd_should_ResetThePlayer);
- RUN_TEST(test_pokerTurn_should_TurnCardsFromTheDeck);
- RUN_TEST(test_pokerBurn_should_SendCardsToTheGrave);
+ RUN_TEST(test_pokerDealerTurn_should_TurnCardsFromTheDeck);
+ RUN_TEST(test_pokerDealerBurn_should_SendCardsToTheGrave);
RUN_TEST(test_pokerGetCallValue_should_CalculateTheCallValue);
- RUN_TEST(test_pokerPlayerDeal_should_DealCardsToThePlayer);
+ RUN_TEST(test_pokerDeal_should_DealCardsToThePlayer);
RUN_TEST(test_pokerPlayerChipsAdd_should_AddChipsToThePlayer);
RUN_TEST(test_pokerPlayerChipsAdd_should_TurnOutStateOff);
- RUN_TEST(test_pokerPlayerDealAll_should_DealCardsToEveryone);
- RUN_TEST(test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone);
- RUN_TEST(test_pokerPlayerDealAll_should_NotDealToOutPlayers);
- RUN_TEST(test_pokerPlayerDealAll_should_NotDealToFoldedPlayers);
+ RUN_TEST(test_pokerDealAllPlayers_should_DealCardsToEveryone);
+ RUN_TEST(test_pokerDealAllPlayers_should_DealMultipleCardsToEveryone);
+ RUN_TEST(test_pokerDealAllPlayers_should_NotDealToOutPlayers);
+ RUN_TEST(test_pokerDealAllPlayers_should_NotDealToFoldedPlayers);
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue);
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet);
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers);
- RUN_TEST(test_pokerPlayerGetRemainingBetter_should_ReturnRemainingBetters);
- RUN_TEST(test_pokerPlayerGetNextBetter_should_GetTheNextBetter);
+ RUN_TEST(test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters);
+ RUN_TEST(test_pokerBetGetNextPlayer_should_GetTheNextBetter);
RUN_TEST(test_pokerPlayerGetCallBet_should_GetCallBet);
RUN_TEST(test_pokerInRoundGetCount_should_ReturnCountOfPlayersInRound);
- RUN_TEST(
- test_pokerPlayerGetRemainintBetterCount_should_ReturnCountNeedsToBet
- );
- RUN_TEST(test_pokerPlayerBetPot_should_AddChipsToThePot);
- RUN_TEST(test_pokerPlayerBetPot_should_UpdatePlayerState);
- RUN_TEST(test_pokerPlayerBet_should_BetToTheActivePot);
+ RUN_TEST(test_pokerBetGetRemainingPlayerCount_should_ReturnCountNeedsToBet);
+ RUN_TEST(test_pokerBet_should_AddChipsToThePot);
+ RUN_TEST(test_pokerBet_should_UpdatePlayerState);
+ RUN_TEST(test_pokerBetForPlayer_should_BetToTheActivePot);
RUN_TEST(test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet);
RUN_TEST(test_pokerTurnFold_should_ReturnAFoldAction);
RUN_TEST(test_pokerTurnBet_should_ReturnACheckAction);