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

Cleaning poker code pt 1.

Browse Source
This commit is contained in:
Dominic Masters
2024-09-08 23:12:03 -05:00
parent b4e261d954
commit d5b3b6d619
11 changed files with 214 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/SDL Submodule

Submodule lib/SDL added at fb1497566c

1
src/dawn/util/CMakeLists.txt
View File

@ -6,4 +6,5 @@
target_sources(${DAWN_TARGET_NAME}
PRIVATE
String.cpp
Random.cpp
)

16
src/dawn/util/Random.cpp Normal file
View File

@ -0,0 +1,16 @@
// Copyright (c) 2024 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "Random.hpp"
using namespace Dawn;
void Random::seed(const uint64_t seed) {
srand(seed);
}
uint64_t Random::next() {
return rand();
}

49
src/dawn/util/Random.hpp Normal file
View File

@ -0,0 +1,49 @@
// Copyright (c) 2024 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
namespace Dawn {
class Random final {
public:
/**
* Seeds the random number generator with the provided seed.
*
* @param seed Seed to use for the random number generator.
*/
static void seed(const uint64_t seed);
/**
* Returns the next random number from the generator.
*
* @return The next random number.
*/
static uint64_t next();
/**
* Returns a random number between the provided min and max values.
*
* @param min Minimum value for the random number.
* @param max Maximum value for the random number.
* @return Random number between min and max.
*/
static float_t random(float_t min, float_t max) {
return min + (float_t)next() / (float_t)RAND_MAX * (max - min);
}
/**
* Returns a random number between the provided min and max values.
*
* @param min Minimum value for the random number.
* @param max Maximum value for the random number.
* @return Random number between min and max.
*/
template<typename T>
static T random(T min, T max) {
return (T)(min + (next() % (max - min + 1)));
}
};
}

1
src/dawnpoker/CMakeLists.txt
View File

@ -16,6 +16,7 @@ target_sources(${DAWN_TARGET_NAME}
)
# Subdirs
add_subdirectory(poker)
add_subdirectory(scenes)
# Assets

88
src/dawnpoker/poker/Card.cpp
View File

@ -4,57 +4,75 @@
// https://opensource.org/licenses/MIT
#include "Card.hpp"
#include "util/Random.hpp"
using namespace Dawn;
void Card::fillDeck(std::vector<struct Card> *deck) {
assertNotNull(deck);
void Card::shuffle(std::vector<struct Card> &deck) {
for(uint8_t i = 0; i < deck.size(); i++) {
uint8_t swap = Random::random<uint8_t>(0, deck.size() - 1);
struct Card tmp = deck[i];
deck[i] = deck[swap];
deck[swap] = tmp;
}
}
void Card::fillDeck(std::vector<struct Card> &deck) {
deck.clear();
for(uint8_t i = 0; i < CARD_DECK_SIZE; i++) {
deck->push_back(Card(i));
deck.push_back(Card(i));
}
}
int32_t Card::contains(std::vector<struct Card> *deck, struct Card c) {
assertNotNull(deck);
int32_t Card::contains(
const std::vector<struct Card> &deck,
const struct Card c
) {
if(deck.size() == 0) return -1;
auto it = deck->begin();
while(it != deck->end()) {
if(it->cardValue == c.cardValue) return (int32_t)(it - deck->begin());
++it;
return std::distance(
deck.begin(),
std::find_if(
deck.begin(),
deck.end(),
[c](struct Card card) {
return card.cardValue == c.cardValue;
}
return -1;
)
);
}
int32_t Card::containsNumber(
std::vector<struct Card> *deck,
enum CardValue number
const std::vector<struct Card> &deck,
const enum CardValue number
) {
assertNotNull(deck);
assertTrue(number < CARD_COUNT_PER_SUIT);
if(deck.size() == 0) return -1;
auto it = deck->begin();
while(it != deck->end()) {
if(it->getValue() == number) return (int32_t)(it - deck->begin());
++it;
return std::distance(
deck.begin(),
std::find_if(
deck.begin(),
deck.end(),
[number](struct Card c) {
return c.getValue() == number;
}
return -1;
)
);
}
std::vector<struct Card> Card::countPairs(
std::vector<struct Card> *deck,
enum CardValue val
const std::vector<struct Card> &deck,
const enum CardValue val
) {
std::vector<struct Card> pairs;
assertNotNull(deck);
assertTrue(deck->size() > 0);
auto it = deck->begin();
while(it != deck->end()) {
if(it->getValue() == val) pairs.push_back(*it);
++it;
std::for_each(
deck.begin(),
deck.end(),
[&pairs, val](struct Card c) {
if(c.getValue() == val) pairs.push_back(c);
}
);
return pairs;
}
@ -63,8 +81,14 @@ bool_t Card::cardSorter(struct Card left, struct Card right) {
return left.cardValue < right.cardValue;
}
void Card::sort(std::vector<struct Card> *deck) {
assertNotNull(deck);
assertTrue(deck->size() > 1);
std::sort(deck->begin(), deck->end(), &Card::cardSorter);
void Card::sort(std::vector<struct Card> &deck) {
std::sort(deck.begin(), deck.end(), &Card::cardSorter);
}
enum CardValue Card::getValue() {
return (enum CardValue)(cardValue % CARD_COUNT_PER_SUIT);
}
enum CardSuit Card::getSuit() {
return (enum CardSuit)(cardValue / CARD_COUNT_PER_SUIT);
}

60
src/dawnpoker/poker/Card.hpp
View File

@ -13,7 +13,6 @@ namespace Dawn {
Diamonds = 1,
Hearts = 2,
Spades = 3,
Invalid = 0xFF
};
enum class CardValue : uint8_t {
@ -30,7 +29,6 @@ namespace Dawn {
Queen = 10,
King = 11,
Ace = 12,
Invalid = 0xFF
};
/** Count of cards in each suit */
@ -51,14 +49,14 @@ namespace Dawn {
*
* @param deck Array of cards to shuffle.
*/
static void shuffle(std::vector<struct Card> *deck);
static void shuffle(std::vector<struct Card> &deck);
/**
* Fills a vector with all of the cards in a deck, in order.
*
* @param deck Deck to fill.
*/
static void fillDeck(std::vector<struct Card> *deck);
static void fillDeck(std::vector<struct Card> &deck);
/**
* Check if an array of cards contains a specific card.
@ -67,7 +65,10 @@ namespace Dawn {
* @param card Card to look for
* @returns The index within the array that the card is. -1 if not found.
*/
static int32_t contains(std::vector<struct Card> *deck, struct Card card);
static int32_t contains(
const std::vector<struct Card> &deck,
const struct Card card
);
/**
* Check if the array of cards contains a specific number.
@ -77,8 +78,8 @@ namespace Dawn {
* @returns The index that the first card is. -1 if not found.
*/
static int32_t containsNumber(
std::vector<struct Card> *deck,
enum CardValue number
const std::vector<struct Card> &deck,
const enum CardValue number
);
/**
@ -90,10 +91,17 @@ namespace Dawn {
* @return Card pairs in the deck.
*/
static std::vector<struct Card> countPairs(
std::vector<struct Card> *deck,
enum CardValue val
const std::vector<struct Card> &deck,
const enum CardValue val
);
/**
* Sorter for the cardSorter function.
*
* @param left Left card to compare.
* @param right Right card to compare.
* @returns True if left is less than right.
*/
static bool_t cardSorter(struct Card left, struct Card right);
/**
@ -103,35 +111,41 @@ namespace Dawn {
*
* @param deck Hand of cards to sort.
*/
static void sort(std::vector<struct Card> *deck);
static void sort(std::vector<struct Card> &deck);
Card(CardSuit suit, CardValue num) :
cardValue(((uint8_t)suit * CARD_COUNT_PER_SUIT) + num)
/**
* Constructor for the Card class.
*
* @param suit Suit of the card.
* @param num Number of the card.
*/
Card(const CardSuit suit, const CardValue num) :
Card(
((uint8_t)suit * CARD_COUNT_PER_SUIT) + (uint8_t)num
)
{
if(suit == CardSuit::Invalid || num == CardValue::Invalid) {
this->cardValue = 0xFF;
}
}
Card(uint8_t cv) : cardValue(cv) {
// assertTrue(cv < CARD_DECK_SIZE);
/**
* Constructor for the Card class.
*
* @param cv Card value.
*/
Card(const uint8_t cv) : cardValue(cv) {
assertTrue(cv < CARD_DECK_SIZE, "Card value out of range");
}
/**
* Returns the number of a given card.
* @returns The card number.
*/
CardValue getValue() {
return (CardValue)(cardValue % CARD_COUNT_PER_SUIT);
}
enum CardValue getValue();
/**
* Returns the suit of a given card.
* @returns The suit.
*/
CardSuit getSuit() {
return (CardSuit)(cardValue / CARD_COUNT_PER_SUIT);
}
enum CardSuit getSuit();
};
}

12
src/dawnpoker/poker/PokerGame.cpp
View File

@ -7,18 +7,6 @@
using namespace Dawn;
PokerGame::PokerGame(SceneItem *item) : SceneItemComponent(item) {
}
void PokerGame::onStart() {
SceneItemComponent::onStart();
this->players = this->getScene()->findComponents<PokerPlayer>();
assertTrue(this->players.size() > 0);
this->newGame();
}
void PokerGame::newGame() {
this->newRound();

8
src/dawnpoker/poker/PokerGame.hpp
View File

@ -17,7 +17,7 @@
#define POKER_RIVER_CARD_COUNT 1
namespace Dawn {
class PokerGame : public SceneItemComponent {
class PokerGame {
protected:
std::vector<struct Card> deck;
std::vector<struct Card> grave;
@ -33,10 +33,6 @@ namespace Dawn {
std::vector<struct PokerPot> pots;
uint8_t betterIndex;
PokerGame(SceneItem *item);
void onStart() override;
void newGame();
void newRound();
void newBettingRound();
@ -53,7 +49,5 @@ namespace Dawn {
void turn(uint8_t count);
uint8_t getCountOfCardsToTurn();
uint8_t getRemainingPlayersCount();
friend class PokerPlayer;
};
}

62
src/dawnpoker/poker/PokerPlayer.cpp
View File

@ -5,27 +5,25 @@
#include "PokerPlayer.hpp"
#include "PokerGame.hpp"
#include "util/Math.hpp"
using namespace Dawn;
PokerPlayer::PokerPlayer(SceneItem *item) : SceneItemComponent(item) {
PokerPlayer::PokerPlayer(std::weak_ptr<PokerGame> pokerGame) {
this->pokerGame = pokerGame;
this->chips = POKER_PLAYER_CHIPS_DEFAULT;
}
void PokerPlayer::onStart() {
SceneItemComponent::onStart();
this->pokerGame = this->getScene()->findComponent<PokerGame>();
}
void PokerPlayer::addChips(int32_t chips) {
assertTrue(chips > 0);
void PokerPlayer::addChips(const int32_t chips) {
assertTrue(chips > 0, "Must add a positive amount of chips.");
this->chips += chips;
if(this->chips > 0) this->isOut = false;
eventChipsChanged.invoke();
this->eventChipsChanged.emit();
}
void PokerPlayer::setChips(int32_t chips) {
void PokerPlayer::setChips(const int32_t chips) {
this->chips = 0;
this->addChips(chips);
}
@ -34,15 +32,21 @@ bool_t PokerPlayer::needsToBetThisRound() {
if(this->isFolded) return false;
if(this->chips <= 0) return false;
if(!this->hasBetThisRound) return true;
if(this->currentBet < this->pokerGame->getCurrentCallValue()) return true;
auto pg = this->pokerGame.lock();
assertNotNull(pg, "PokerGame has become invalid.");
if(this->currentBet < pg->getCurrentCallValue()) return true;
return false;
}
void PokerPlayer::bet(struct PokerPot *pot, int32_t chips) {
assertNotNull(pot);
assertTrue(chips >= 0);
assertTrue(!this->isFolded);
assertTrue(!this->isOut);
void PokerPlayer::bet(
struct PokerPot &pot,
const int32_t chips
) {
assertNotNull(pot, "Pot must be valid.");
assertTrue(chips >= 0, "Chips must be a positive value.");
assertTrue(!this->isFolded, "Cannot bet if player is folded.");
assertTrue(!this->isOut, "Cannot bet if player is out.");
this->setChips(this->chips - chips);
this->currentBet += chips;
this->hasBetThisRound = true;
@ -52,16 +56,19 @@ void PokerPlayer::bet(struct PokerPot *pot, int32_t chips) {
this->timesRaised = 0;
}
pot->chips += chips;
pot->call = mathMax<int32_t>(pot->call, this ->currentBet);
pot.chips += chips;
pot.call = Math::max<int32_t>(pot.call, this ->currentBet);
auto existing = std::find(pot->players.begin(), pot->players.end(), this);
if(existing == pot->players.end()) pot->players.push_back(this);
auto existing = std::find(pot.players.begin(), pot.players.end(), this);
if(existing == pot.players.end()) pot.players.push_back(this);
}
void PokerPlayer::bet(int32_t chips) {
assertTrue(this->pokerGame->pots.size() > 0);
this->bet(&this->pokerGame->pots.back(), chips);
void PokerPlayer::bet(const int32_t chips) {
auto pg = this->pokerGame.lock();
assertNotNull(pg, "PokerGame has become invalid.");
assertTrue(pg->pots.size() > 0, "PokerGame has no pots?");
assertUnreachable("Bugged");
// this->bet(&this->pokerGame->pots.back(), chips);
}
void PokerPlayer::fold() {
@ -71,7 +78,12 @@ void PokerPlayer::fold() {
}
bool_t PokerPlayer::canCheck() {
return this->pokerGame->getCurrentCallValue() <= this->currentBet;
if(this->isFolded) return false;
if(this->isOut) return false;
auto pg = this->pokerGame.lock();
assertNotNull(pg, "PokerGame has become invalid.");
return pg->getCurrentCallValue() == this->currentBet;
}
struct PokerTurn PokerPlayer::getAITurn() {

26
src/dawnpoker/poker/PokerPlayer.hpp
View File

@ -4,14 +4,11 @@
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
#include "Card.hpp"
#include "PokerPot.hpp"
#include "util/mathutils.hpp"
#include "display/animation/Easing.hpp"
#include "PokerWinning.hpp"
#include "PokerTurn.hpp"
#include "util/random.hpp"
#include "event/Event.hpp"
#define POKER_PLAYER_CHIPS_DEFAULT 10000
@ -23,9 +20,9 @@
namespace Dawn {
class PokerGame;
class PokerPlayer : public SceneItemComponent {
class PokerPlayer {
public:
PokerGame *pokerGame;
std::weak_ptr<PokerGame> pokerGame;
int32_t chips = 0;
int32_t currentBet = 0;
uint8_t timesRaised = 0;
@ -39,28 +36,25 @@ namespace Dawn {
Event<> eventChipsChanged;
/**
* Creates a PokerPlayer instance.
* Constructor for the PokerPlayer class.
*
* @param item Item that this poker player belongs to.
* @param pokerGame Poker game this player is a part of.
*/
PokerPlayer(SceneItem *item);
/** Override for scene item component event for init */
void onStart() override;
PokerPlayer(std::weak_ptr<PokerGame> pokerGame);
/**
* Adds chips to the player. This will also update the players' state.
*
* @param chips Count of chips to add.
*/
void addChips(int32_t chips);
void addChips(const int32_t chips);
/**
* Sets the chips a player has.
*
* @param chips Chips to set to the player.
*/
void setChips(int32_t chips);
void setChips(const int32_t chips);
/**
* Returns true if the player still needs to bet this betting round.
@ -75,14 +69,14 @@ namespace Dawn {
* @param pot Poker pot to bet in to.
* @param amount The amount of chips the player is betting.
*/
void bet(struct PokerPot *pot, int32_t amount);
void bet(struct PokerPot pot, const int32_t amount);
/**
* Let a player bet chips into the current pot.
*
* @param amount The amount of chips the player is betting.
*/
void bet(int32_t amount);
void bet(const int32_t amount);
/**
* Player folds.