From 466cb1e2b99f5bed94bdefaa1dc4f80a88cbb75c Mon Sep 17 00:00:00 2001 From: Dominic Masters Date: Thu, 14 Oct 2021 22:40:33 -0700 Subject: [PATCH] Split the bet tests out. --- src/game/poker/actions/flop.c | 4 +- src/game/poker/actions/round.c | 4 +- src/game/poker/actions/round.h | 1 + src/poker/bet.c | 19 ++- src/poker/bet.h | 35 ++---- src/poker/fuck.h | 3 + src/poker/poker.c | 18 +-- src/poker/poker.h | 25 +--- src/poker/pot.c | 16 +++ src/poker/pot.h | 12 +- src/poker/turn.c | 4 +- src/poker/turn.h | 1 + test/poker/bet.c | 186 ++++++++++++++++++++++++++++ test/poker/bet.h | 10 ++ test/poker/poker.c | 218 +-------------------------------- test/tests.c | 10 +- test/tests.h | 1 + 17 files changed, 266 insertions(+), 301 deletions(-) create mode 100644 test/poker/bet.c create mode 100644 test/poker/bet.h diff --git a/src/game/poker/actions/flop.c b/src/game/poker/actions/flop.c index 2288ff3a..1283018d 100644 --- a/src/game/poker/actions/flop.c +++ b/src/game/poker/actions/flop.c @@ -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(pokerBetGetRemainingPlayerCount(&game->poker) > 0x01) { + if(pokerBetGetRemainingBetterCount(&game->poker) > 0x01) { // Begin betting. - game->poker.better = pokerBetGetRemainingPlayer(&game->poker); + game->poker.better = pokerBetGetNextPlayer(&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 ea2d0daa..d14418dd 100644 --- a/src/game/poker/actions/round.c +++ b/src/game/poker/actions/round.c @@ -20,7 +20,7 @@ void _pokerGameActionRoundOnEnd(queue_t *queue,queueaction_t *action,uint8_t i){ // Start the round pokerResetRound(&game->poker); pokerDealerNew(&game->poker); - pokerTakeBlinds(&game->poker, game->poker.blindSmall, game->poker.blindBig); + pokerTakeBlinds(&game->poker); // Speak data.poker = game; @@ -33,7 +33,7 @@ void _pokerGameActionRoundOnEnd(queue_t *queue,queueaction_t *action,uint8_t i){ // Deal cardShuffle(game->poker.deck, CARD_DECK_SIZE); - pokerPlayerDealAll(&game->poker, POKER_PLAYER_HAND_SIZE_MAX); + pokerDealAllPlayers(&game->poker, POKER_PLAYER_HAND_SIZE_MAX); // Speak data.reason = POKER_DISCUSSION_REASON_DEAL; diff --git a/src/game/poker/actions/round.h b/src/game/poker/actions/round.h index d3673288..8bd15fe4 100644 --- a/src/game/poker/actions/round.h +++ b/src/game/poker/actions/round.h @@ -7,6 +7,7 @@ #include "../../../libs.h" #include "../../../poker/player.h" #include "../../../poker/dealer.h" +#include "../../../poker/poker.h" #include "action.h" #include "../pokerdiscussion.h" #include "bet.h" diff --git a/src/poker/bet.c b/src/poker/bet.c index 400e3de8..4ce60533 100644 --- a/src/poker/bet.c +++ b/src/poker/bet.c @@ -7,16 +7,6 @@ #include "bet.h" -uint8_t pokerBetGetRemainingPlayer(poker_t *poker) { - uint8_t i, j; - - for(i = 0; i < poker->playerCount; i++) { - j = (i + poker->playerBigBlind + 1) % poker->playerCount; - if(pokerPlayerDoesNeedToBetThisRound(poker, j)) return j; - } - return 0xFF; -} - uint8_t pokerBetGetNextPlayer(poker_t *poker) { uint8_t i, j; for(i = 0; i < poker->playerCount; i++) { @@ -26,7 +16,7 @@ uint8_t pokerBetGetNextPlayer(poker_t *poker) { return 0xFF; } -uint8_t pokerBetGetRemainingPlayerCount(poker_t *poker) { +uint8_t pokerBetGetRemainingBetterCount(poker_t *poker) { uint8_t i, count; count = 0; for(i = 0; i < poker->playerCount; i++) { @@ -41,11 +31,16 @@ void pokerBet( ) { pokerplayer_t *player; player = poker->players + playerIndex; + player->chips -= chips; player->currentBet += chips; + pot->chips += chips; - player->state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND; + pot->call = mathMax(pot->call, chips); pokerPotAddPlayer(pot, playerIndex); + + player->state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND; + if(chips > 0) player->timesRaised++; } void pokerBetForPlayer(poker_t *poker, uint8_t playerIndex, int32_t chips) { diff --git a/src/poker/bet.h b/src/poker/bet.h index 06232786..9d7cb6fb 100644 --- a/src/poker/bet.h +++ b/src/poker/bet.h @@ -10,15 +10,6 @@ #include "fuck.h" #include "poker.h" -/** - * Returns the index of the first player that remains to bet for the current - * round. - * - * @param poker Poker game instance. - * @return The player index of the remaining player, otherwise 0xFF. - */ -uint8_t pokerBetGetRemainingPlayer(poker_t *poker); - /** * Returns the index of the first player that remains to bet for the current * round. This is based on whatever current better player index you provide. @@ -29,24 +20,13 @@ uint8_t pokerBetGetRemainingPlayer(poker_t *poker); */ uint8_t pokerBetGetNextPlayer(poker_t *poker); -/** - * Get the bet necessary for a specific player to make a call. This takes the - * players current bet and the bet necessary to call into the pot and will - * return the difference. - * - * @param poker Poker game instance. - * @param player Player instance to get the call value for. - * @return The count of chips needed to call into the current active pot. - */ -int32_t pokerPlayerGetCallBet(poker_t *poker, pokerplayer_t *player); - /** * Returns the count of players remaining to bet. * * @param poker Poker game instance. * @return Count of players left to bet. */ -uint8_t pokerBetGetRemainingPlayerCount(poker_t *poker); +uint8_t pokerBetGetRemainingBetterCount(poker_t *poker); /** * Let a player bet chips into the pot. @@ -75,4 +55,15 @@ void pokerBetForPlayer(poker_t *poker, uint8_t playerIndex, int32_t chips); * @param poker Poker game instance. * @return Chips necessary to call the current bet. */ -int32_t pokerBetGetCurrentCallValue(poker_t *poker); \ No newline at end of file +int32_t pokerBetGetCurrentCallValue(poker_t *poker); + +/** + * Get the bet necessary for a specific player to make a call. This takes the + * players current bet and the bet necessary to call into the pot and will + * return the difference. + * + * @param poker Poker game instance. + * @param player Player instance to get the call value for. + * @return The count of chips needed to call into the current active pot. + */ +int32_t pokerPlayerGetCallBet(poker_t *poker, pokerplayer_t *player); \ No newline at end of file diff --git a/src/poker/fuck.h b/src/poker/fuck.h index b26f909c..41f7bc1e 100644 --- a/src/poker/fuck.h +++ b/src/poker/fuck.h @@ -106,6 +106,7 @@ typedef struct { /** Current bet that the player has done. */ int32_t currentBet; + /** Count of times that the player has raised their bet */ uint8_t timesRaised; } pokerplayer_t; @@ -129,6 +130,8 @@ typedef struct { typedef struct { /** Current pot of chips */ int32_t chips; + /** Current call value for this pot */ + int32_t call; /** Players who are participating in the pot */ uint8_t players[POKER_PLAYER_COUNT_MAX]; uint8_t playerCount; diff --git a/src/poker/poker.c b/src/poker/poker.c index acd4f8e4..03198c55 100644 --- a/src/poker/poker.c +++ b/src/poker/poker.c @@ -66,7 +66,7 @@ void pokerResetBettingRound(poker_t *poker) { // Then we check who's remaining. We do this because the default better may // have folded already. - poker->better = pokerBetGetRemainingPlayer(poker); + poker->better = pokerBetGetNextPlayer(poker); } void pokerTakeBlinds(poker_t *poker) { @@ -87,21 +87,5 @@ uint8_t pokerInRoundGetCount(poker_t *poker) { count++; } - return count; -} - -// Betting -int32_t pokerPlayerGetPotChipsSum(poker_t *poker, uint8_t playerIndex) { - int32_t count; - uint8_t i; - pokerpot_t *pot; - - count = 0; - for(i = 0; i < poker->potCount; i++) { - pot = poker->pots + i; - if(!pokerPotHasPlayer(pot, playerIndex)) continue; - count += pot->chips; - } - return count; } \ No newline at end of file diff --git a/src/poker/poker.h b/src/poker/poker.h index 043642b5..3e3f06b6 100644 --- a/src/poker/poker.h +++ b/src/poker/poker.h @@ -65,27 +65,4 @@ void pokerTakeBlinds(poker_t *poker); * @param poker Poker game instance. * @return The count of players in the round. */ -uint8_t pokerInRoundGetCount(poker_t *poker); - -/** - * Returns the sum of chips in the pot(s) that the specified player is in. This - * does not consider the pot, player or hand, just the pure sum of chips. - * - * @param poker Poker game instance. - * @param playerIndex Player Index to get the sum of chips from. - * @return The sum of chips from the pots the player is within. - */ -int32_t pokerPlayerGetPotChipsSum(poker_t *poker, uint8_t playerIndex); - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Dealer - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Betting - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Pots - - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Clearly fucking player related - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Turn - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Winning \ No newline at end of file +uint8_t pokerInRoundGetCount(poker_t *poker); \ No newline at end of file diff --git a/src/poker/pot.c b/src/poker/pot.c index 79498b00..3c318079 100644 --- a/src/poker/pot.c +++ b/src/poker/pot.c @@ -13,6 +13,7 @@ uint8_t pokerPotAdd(poker_t *poker) { pot = poker->pots + i; pot->chips = 0; pot->playerCount = 0; + pot->call = 0; return i; } @@ -26,3 +27,18 @@ void pokerPotAddPlayer(pokerpot_t *pot, uint8_t playerIndex) { if(pokerPotHasPlayer(pot, playerIndex)) return; pot->players[pot->playerCount++] = playerIndex; } + +int32_t pokerPotGetSumOfChipsForPlayer(poker_t *poker, uint8_t playerIndex) { + int32_t count; + uint8_t i; + pokerpot_t *pot; + + count = 0; + for(i = 0; i < poker->potCount; i++) { + pot = poker->pots + i; + if(!pokerPotHasPlayer(pot, playerIndex)) continue; + count += pot->chips; + } + + return count; +} \ No newline at end of file diff --git a/src/poker/pot.h b/src/poker/pot.h index 8f0ecfd8..f4f43eee 100644 --- a/src/poker/pot.h +++ b/src/poker/pot.h @@ -34,4 +34,14 @@ bool pokerPotHasPlayer(pokerpot_t *pot, uint8_t playerIndex); * @param pot Pot to add to. * @param playerIndex Players' index to add to the pot. */ -void pokerPotAddPlayer(pokerpot_t *pot, uint8_t playerIndex); \ No newline at end of file +void pokerPotAddPlayer(pokerpot_t *pot, uint8_t playerIndex); + +/** + * Returns the sum of chips in the pot(s) that the specified player is in. This + * does not consider the pot, player or hand, just the pure sum of chips. + * + * @param poker Poker game instance. + * @param playerIndex Player Index to get the sum of chips from. + * @return The sum of chips from the pots the player is within. + */ +int32_t pokerPotGetSumOfChipsForPlayer(poker_t *poker, uint8_t playerIndex); \ No newline at end of file diff --git a/src/poker/turn.c b/src/poker/turn.c index d7cff191..b5176917 100644 --- a/src/poker/turn.c +++ b/src/poker/turn.c @@ -107,10 +107,10 @@ pokerturn_t pokerTurnGetForPlayer(poker_t *poker, uint8_t playerIndex) { // Do they need chips to call, or is it possible to check? if(callBet > 0) { potOdds = (float)callBet / ( - (float)callBet + (float)pokerPlayerGetPotChipsSum(poker, playerIndex) + (float)callBet + (float)pokerPotGetSumOfChipsForPlayer(poker, playerIndex) ); } else { - potOdds = 1.0f / (float)pokerBetGetRemainingPlayerCount(poker); + potOdds = 1.0f / (float)pokerBetGetRemainingBetterCount(poker); } // Now determine the expected ROI diff --git a/src/poker/turn.h b/src/poker/turn.h index 4846c273..c5ddf8be 100644 --- a/src/poker/turn.h +++ b/src/poker/turn.h @@ -9,6 +9,7 @@ #include "../libs.h" #include "fuck.h" #include "poker.h" +#include "pot.h" /** * Return a turn action for the given player to fold. diff --git a/test/poker/bet.c b/test/poker/bet.c new file mode 100644 index 00000000..c22bacdd --- /dev/null +++ b/test/poker/bet.c @@ -0,0 +1,186 @@ +/** + * Copyright (c) 2021 Dominic Masters + * + * This software is released under the MIT License. + * https://opensource.org/licenses/MIT + */ + +#include "bet.h" + +void test_pokerBetGetNextPlayer_should_GetTheNextBetter(void) { + poker_t poker; + uint8_t p0, p1, p2, p3, p4; + pokerInit(&poker); + + p0 = pokerPlayerAdd(&poker); + p1 = pokerPlayerAdd(&poker); + p2 = pokerPlayerAdd(&poker); + p3 = pokerPlayerAdd(&poker); + p4 = pokerPlayerAdd(&poker); + + pokerPlayerChipsAdd(poker.players + p0, 10000); + pokerPlayerChipsAdd(poker.players + p1, 10000); + pokerPlayerChipsAdd(poker.players + p2, 10000); + pokerPlayerChipsAdd(poker.players + p3, 10000); + pokerPlayerChipsAdd(poker.players + p4, 10000); + pokerDealerNew(&poker); + + // Start at blind+1 + poker.better = poker.playerBigBlind; + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x04, poker.better); + + // Blind+2 + pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker)); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x00, poker.better); + + // BLind+3 + pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker)); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x01, poker.better); + + // Dealer + pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker)); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x02, poker.better); + + // Small blind + pokerBetForPlayer( + &poker, poker.better, + pokerBetGetCurrentCallValue(&poker) - poker.players[0x02].currentBet + ); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x03, poker.better); + + // Big Blind + pokerBetForPlayer( + &poker, poker.better, + pokerBetGetCurrentCallValue(&poker) - poker.players[0x03].currentBet + ); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0xFF, poker.better); + + // Raise + poker.better = poker.playerBigBlind; + pokerBetForPlayer(&poker, poker.better, 100); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x04, poker.better); + + // Raise + pokerBetForPlayer(&poker, poker.better, 100); + poker.better = pokerBetGetNextPlayer(&poker); + TEST_ASSERT_EQUAL_UINT8(0x00, poker.better); +} + +void test_pokerBetGetRemainingBetterCount_should_ReturnCountNeedsToBet(void){ + poker_t poker; + uint8_t p0, p1, p2; + + pokerInit(&poker); + p0 = pokerPlayerAdd(&poker); + p1 = pokerPlayerAdd(&poker); + p2 = pokerPlayerAdd(&poker); + + TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingBetterCount(&poker)); + + pokerPlayerChipsAdd(poker.players + p0, 1000); + TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingBetterCount(&poker)); + pokerPlayerChipsAdd(poker.players + p2, 1000); + TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingBetterCount(&poker)); + pokerPlayerChipsAdd(poker.players + p1, 1000); + TEST_ASSERT_EQUAL_UINT8(0x03, pokerBetGetRemainingBetterCount(&poker)); + + poker.players[0].state |= POKER_PLAYER_STATE_FOLDED; + TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingBetterCount(&poker)); + poker.players[1].state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND; + TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingBetterCount(&poker)); + poker.players[2].chips = 0; + TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingBetterCount(&poker)); +} + +void test_pokerBet_should_AddChipsToThePot(void) { + poker_t poker; + pokerpot_t *pot; + pokerplayer_t *player; + uint8_t i; + + pokerInit(&poker); + pot = poker.pots; + i = pokerPlayerAdd(&poker); + player = poker.players + i; + pokerPlayerChipsAdd(player, 1000); + + TEST_ASSERT_EQUAL_INT32(0, pot->chips); + TEST_ASSERT_EQUAL_INT32(0, pot->call); + TEST_ASSERT_EQUAL_INT32(1000, player->chips); + + pokerBet(&poker, pot, i, 100); + TEST_ASSERT_EQUAL_INT32(100, pot->chips); + TEST_ASSERT_EQUAL_INT32(100, pot->call); + TEST_ASSERT_EQUAL_INT32(900, player->chips); + + pokerBet(&poker, pot, i, 100); + TEST_ASSERT_EQUAL_INT32(200, pot->chips); + TEST_ASSERT_EQUAL_INT32(100, pot->call); + TEST_ASSERT_EQUAL_INT32(800, player->chips); +} + +void test_pokerBet_should_UpdatePlayerState(void) { + poker_t poker; + uint8_t i; + pokerplayer_t *player; + + pokerInit(&poker); + i = pokerPlayerAdd(&poker); + player = poker.players + i; + pokerPlayerChipsAdd(player, 1000); + + TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, player->state); + TEST_ASSERT_EQUAL_INT32(0, player->currentBet); + TEST_ASSERT_EQUAL_UINT8(0, player->timesRaised); + + 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); + TEST_ASSERT_EQUAL_UINT8(1, player->timesRaised); + + pokerBet(&poker, poker.pots, i, 250); + TEST_ASSERT_EQUAL_INT32(350, player->currentBet); + TEST_ASSERT_EQUAL_UINT8(2, player->timesRaised); +} + +void test_pokerBetForPlayer_should_BetToTheActivePot(void) { + poker_t poker; + pokerpot_t *pot; + uint8_t i, j; + + pokerInit(&poker); + i = pokerPlayerAdd(&poker); + pokerPlayerChipsAdd(poker.players+i, 1000); + pot = poker.pots; + + TEST_ASSERT_EQUAL_INT32(0, pot->chips); + pokerBetForPlayer(&poker, i, 100); + TEST_ASSERT_EQUAL_INT32(100, pot->chips); + + j = pokerPotAdd(&poker); + pokerBetForPlayer(&poker, i, 50); + TEST_ASSERT_EQUAL_INT32(100, pot->chips); + pot = poker.pots + j; + TEST_ASSERT_EQUAL_INT32(50, pot->chips); +} + + +int test_bet_h() { + UNITY_BEGIN(); + + // RUN_TEST(test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters); + RUN_TEST(test_pokerBetGetNextPlayer_should_GetTheNextBetter); + RUN_TEST(test_pokerBetGetRemainingBetterCount_should_ReturnCountNeedsToBet); + RUN_TEST(test_pokerBet_should_AddChipsToThePot); + RUN_TEST(test_pokerBet_should_UpdatePlayerState); + RUN_TEST(test_pokerBetForPlayer_should_BetToTheActivePot); + + return UNITY_END(); +} \ No newline at end of file diff --git a/test/poker/bet.h b/test/poker/bet.h new file mode 100644 index 00000000..043e49c0 --- /dev/null +++ b/test/poker/bet.h @@ -0,0 +1,10 @@ +// Copyright (c) 2021 Dominic Masters +// +// This software is released under the MIT License. +// https://opensource.org/licenses/MIT + +#pragma once +#include +#include + +int test_bet_h(); \ No newline at end of file diff --git a/test/poker/poker.c b/test/poker/poker.c index a7517da4..d43e4c88 100644 --- a/test/poker/poker.c +++ b/test/poker/poker.c @@ -220,7 +220,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) { TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 3)->chips); TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips); - pokerTakeBlinds(&poker, 100, 200); + pokerTakeBlinds(&poker); TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips); TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips); @@ -229,7 +229,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) { TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips); pokerDealerNew(&poker); - pokerTakeBlinds(&poker, 100, 200); + pokerTakeBlinds(&poker); TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips); TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips); @@ -257,6 +257,7 @@ void test_pokerPotAdd_should_ResetThePot(void) { pot = poker.pots + i; TEST_ASSERT_EQUAL_UINT8(0, pot->playerCount); TEST_ASSERT_EQUAL_INT32(0, pot->chips); + TEST_ASSERT_EQUAL_INT32(0, pot->call); } void test_pokerPotHasPlayer_should_DetermineIfPlayerInThePot(void) { @@ -647,125 +648,6 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) { TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second)); } -void test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters(void) { - poker_t poker; - uint8_t p0, p1, p2, p3, p4; - pokerInit(&poker); - - - p0 = pokerPlayerAdd(&poker); - p1 = pokerPlayerAdd(&poker); - p2 = pokerPlayerAdd(&poker); - p3 = pokerPlayerAdd(&poker); - p4 = pokerPlayerAdd(&poker); - - pokerPlayerChipsAdd(poker.players + p0, 10000); - pokerPlayerChipsAdd(poker.players + p1, 10000); - pokerPlayerChipsAdd(poker.players + p2, 10000); - pokerPlayerChipsAdd(poker.players + p3, 10000); - pokerPlayerChipsAdd(poker.players + p4, 10000); - pokerDealerNew(&poker); - - // Blind + 1 - TEST_ASSERT_EQUAL(0x04, pokerBetGetRemainingPlayer(&poker)); - - // Blind + 2 - pokerBetForPlayer(&poker, 0x04, pokerBetGetCurrentCallValue(&poker)); - TEST_ASSERT_EQUAL(0x00, pokerBetGetRemainingPlayer(&poker)); - - // Blind + 3 - pokerBetForPlayer(&poker, 0x00, pokerBetGetCurrentCallValue(&poker)); - TEST_ASSERT_EQUAL(0x01, pokerBetGetRemainingPlayer(&poker)); - - // Blind + 4 / Small Blind - pokerBetForPlayer(&poker, 0x01, pokerBetGetCurrentCallValue(&poker)); - TEST_ASSERT_EQUAL(0x02, pokerBetGetRemainingPlayer(&poker)); - - // Blind + 5 / Big Blind - pokerBetForPlayer( - &poker, 0x02, pokerBetGetCurrentCallValue(&poker) - poker.players[0x01].currentBet - ); - TEST_ASSERT_EQUAL(0x03, pokerBetGetRemainingPlayer(&poker)); - - // No remaining players. - pokerBetForPlayer(&poker, 0x03, 0); - TEST_ASSERT_EQUAL(0xFF, pokerBetGetRemainingPlayer(&poker)); - - // Raise - pokerBetForPlayer(&poker, 0x03, 100); - TEST_ASSERT_EQUAL(0x04, pokerBetGetRemainingPlayer(&poker)); - - // Raise - pokerBetForPlayer(&poker, 0x04, 100); - TEST_ASSERT_EQUAL(0x00, pokerBetGetRemainingPlayer(&poker)); -} - -void test_pokerBetGetNextPlayer_should_GetTheNextBetter(void) { - poker_t poker; - uint8_t p0, p1, p2, p3, p4; - pokerInit(&poker); - - p0 = pokerPlayerAdd(&poker); - p1 = pokerPlayerAdd(&poker); - p2 = pokerPlayerAdd(&poker); - p3 = pokerPlayerAdd(&poker); - p4 = pokerPlayerAdd(&poker); - - pokerPlayerChipsAdd(poker.players + p0, 10000); - pokerPlayerChipsAdd(poker.players + p1, 10000); - pokerPlayerChipsAdd(poker.players + p2, 10000); - pokerPlayerChipsAdd(poker.players + p3, 10000); - pokerPlayerChipsAdd(poker.players + p4, 10000); - pokerDealerNew(&poker); - - // Start at blind+1 - poker.better = poker.playerBigBlind; - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x04, poker.better); - - // Blind+2 - pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker)); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x00, poker.better); - - // BLind+3 - pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker)); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x01, poker.better); - - // Dealer - pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker)); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x02, poker.better); - - // Small blind - pokerBetForPlayer( - &poker, poker.better, - pokerBetGetCurrentCallValue(&poker) - poker.players[0x02].currentBet - ); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x03, poker.better); - - // Big Blind - pokerBetForPlayer( - &poker, poker.better, - pokerBetGetCurrentCallValue(&poker) - poker.players[0x03].currentBet - ); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0xFF, poker.better); - - // Raise - poker.better = poker.playerBigBlind; - pokerBetForPlayer(&poker, poker.better, 100); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x04, poker.better); - - // Raise - pokerBetForPlayer(&poker, poker.better, 100); - poker.better = pokerBetGetNextPlayer(&poker); - TEST_ASSERT_EQUAL_UINT8(0x00, poker.better); -} - void test_pokerPlayerGetCallBet_should_GetCallBet(void) { poker_t poker; uint8_t p0, p1, p2; @@ -817,94 +699,6 @@ void test_pokerInRoundGetCount_should_ReturnCountOfPlayersInRound(void) { TEST_ASSERT_EQUAL_UINT8(0x00, pokerInRoundGetCount(&poker)); } -void test_pokerBetGetRemainingPlayerCount_should_ReturnCountNeedsToBet(void){ - poker_t poker; - uint8_t p0, p1, p2; - - pokerInit(&poker); - p0 = pokerPlayerAdd(&poker); - p1 = pokerPlayerAdd(&poker); - p2 = pokerPlayerAdd(&poker); - - TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingPlayerCount(&poker)); - - pokerPlayerChipsAdd(poker.players + p0, 1000); - TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingPlayerCount(&poker)); - pokerPlayerChipsAdd(poker.players + p2, 1000); - TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingPlayerCount(&poker)); - pokerPlayerChipsAdd(poker.players + p1, 1000); - TEST_ASSERT_EQUAL_UINT8(0x03, pokerBetGetRemainingPlayerCount(&poker)); - - poker.players[0].state |= POKER_PLAYER_STATE_FOLDED; - TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingPlayerCount(&poker)); - poker.players[1].state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND; - TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingPlayerCount(&poker)); - poker.players[2].chips = 0; - TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingPlayerCount(&poker)); -} - -void test_pokerBet_should_AddChipsToThePot(void) { - poker_t poker; - pokerpot_t *pot; - pokerplayer_t *player; - uint8_t i; - - pokerInit(&poker); - pot = poker.pots; - i = pokerPlayerAdd(&poker); - player = poker.players + i; - pokerPlayerChipsAdd(player, 1000); - - TEST_ASSERT_EQUAL_INT32(0, pot->chips); - TEST_ASSERT_EQUAL_INT32(1000, player->chips); - - pokerBet(&poker, pot, i, 100); - TEST_ASSERT_EQUAL_INT32(100, pot->chips); - TEST_ASSERT_EQUAL_INT32(900, player->chips); -} - -void test_pokerBet_should_UpdatePlayerState(void) { - poker_t poker; - uint8_t i; - pokerplayer_t *player; - - pokerInit(&poker); - i = pokerPlayerAdd(&poker); - player = poker.players + i; - pokerPlayerChipsAdd(player, 1000); - - TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, player->state); - TEST_ASSERT_EQUAL_INT32(0, player->currentBet); - - 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); - - pokerBet(&poker, poker.pots, i, 250); - TEST_ASSERT_EQUAL_INT32(350, player->currentBet); -} - -void test_pokerBetForPlayer_should_BetToTheActivePot(void) { - poker_t poker; - pokerpot_t *pot; - uint8_t i, j; - - pokerInit(&poker); - i = pokerPlayerAdd(&poker); - pokerPlayerChipsAdd(poker.players+i, 1000); - pot = poker.pots; - - TEST_ASSERT_EQUAL_INT32(0, pot->chips); - pokerBetForPlayer(&poker, i, 100); - TEST_ASSERT_EQUAL_INT32(100, pot->chips); - - j = pokerPotAdd(&poker); - pokerBetForPlayer(&poker, i, 50); - TEST_ASSERT_EQUAL_INT32(100, pot->chips); - pot = poker.pots + j; - TEST_ASSERT_EQUAL_INT32(50, pot->chips); -} - void test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet(void) { poker_t poker; uint8_t p0, p1, p2; @@ -1613,14 +1407,8 @@ int test_poker() { RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue); RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet); RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers); - 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_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); diff --git a/test/tests.c b/test/tests.c index ce0e414a..5c864330 100644 --- a/test/tests.c +++ b/test/tests.c @@ -8,8 +8,10 @@ #include "tests.h" int32_t main() { - return ( - test_card() || - test_poker() - ); + return test_bet_h(); + // return ( + // test_bet + // test_card() || + // test_poker() + // ); } \ No newline at end of file diff --git a/test/tests.h b/test/tests.h index 19761c5b..55017f9e 100644 --- a/test/tests.h +++ b/test/tests.h @@ -6,6 +6,7 @@ */ #pragma once +#include "poker/bet.h" #include "poker/card.h" #include "poker/poker.h"