Started merging new poker code in.
This commit is contained in:
237
backup/poker/turn.c
Normal file
237
backup/poker/turn.c
Normal file
@@ -0,0 +1,237 @@
|
||||
/**
|
||||
* Copyright (c) 2021 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "turn.h"
|
||||
|
||||
pokerturn_t pokerTurnGet(poker_t *poker, uint8_t playerIndex) {
|
||||
int32_t random, maxBet, bluffBet, callBet;
|
||||
float confidence, expectedGain, potOdds;
|
||||
bool isBluff;
|
||||
int32_t amount;
|
||||
pokerplayer_t *player;
|
||||
pokerplayerwinning_t winning;
|
||||
uint8_t i, cardNumber0, cardNumber1, suitNumber0, suitNumber1;
|
||||
pokerturn_t turn;
|
||||
|
||||
player = poker->players + playerIndex;
|
||||
|
||||
// Can the player do anything?
|
||||
if(player->state & (POKER_PLAYER_STATE_FOLDED | POKER_PLAYER_STATE_OUT)) {
|
||||
return pokerTurnOut(poker, playerIndex);
|
||||
}
|
||||
|
||||
// The following logic is heavily inspired by;
|
||||
// https://github.com/gorel/C-Poker-AI/blob/master/src/common/pokerai.c
|
||||
// But with some changes and smarts added by me. The original source code will
|
||||
// essentially just run a crap tun of simulated games and get the times that
|
||||
// they are expected to win from those games, but I'm just going to use the
|
||||
// odds of the winning hand.
|
||||
|
||||
// Is this preflop?
|
||||
if(poker->dealer.cardsFacing == 0 && player->cardCount >= 2) {
|
||||
// Get the hand weight
|
||||
cardNumber0 = cardGetNumber(player->cards[0]);
|
||||
cardNumber1 = cardGetNumber(player->cards[1]);
|
||||
suitNumber0 = cardGetSuit(player->cards[0]);
|
||||
suitNumber1 = cardGetSuit(player->cards[1]);
|
||||
|
||||
// Get delta between cards
|
||||
i = mathAbs(cardNumber0 - cardNumber1);
|
||||
|
||||
// Get card weight
|
||||
confidence = (float)cardNumber0 + (float)cardNumber1;
|
||||
if(cardNumber0 == cardNumber1) {// Pairs
|
||||
confidence += 6;
|
||||
} else if(suitNumber0 == suitNumber1) {// Same suit
|
||||
confidence += 4;
|
||||
}
|
||||
|
||||
// Get difference from cards for guessing flush
|
||||
if(i > 4) {
|
||||
confidence -= 4;
|
||||
} else if(i > 2) {
|
||||
confidence -= i;
|
||||
}
|
||||
|
||||
// Get the confidence delta 0-1
|
||||
confidence = confidence / 30.0f;
|
||||
} else {
|
||||
// Simulate my hand being the winning hand, use that as the confidence
|
||||
pokerWinnerPlayerGet(&poker->dealer, player, &winning);
|
||||
confidence = pokerWinnerGetTypeConfidence(winning.type);
|
||||
}
|
||||
|
||||
// Now we know how confident the AI is, let's put a chip value to that weight
|
||||
// How many chips to call?
|
||||
callBet = poker->bet.currentBet - player->currentBet;
|
||||
|
||||
// Do they need chips to call, or is it possible to check?
|
||||
if(callBet > 0) {
|
||||
potOdds = (float)callBet / ((float)callBet + (float)poker->bet.pot);
|
||||
} else {
|
||||
potOdds = (
|
||||
1.0f / (float)pokerBetGetRemainingPlayerCount(&poker->bet, poker->players)
|
||||
);
|
||||
}
|
||||
|
||||
// Now determine the expected ROI
|
||||
expectedGain = confidence / potOdds;
|
||||
|
||||
// Now get a random 0-100
|
||||
random = randInt32() % 100;
|
||||
|
||||
// Determine the max bet that the AI is willing to make
|
||||
maxBet = (int32_t)((float)player->chips / 1.75f) - (random / 2);
|
||||
maxBet -= callBet;
|
||||
|
||||
// Determine what's a good bluff bet.
|
||||
bluffBet = random * maxBet / 100 / 2;
|
||||
|
||||
// Now prep the output
|
||||
isBluff = false;
|
||||
amount = 0;
|
||||
|
||||
// Now the actual AI can happen. This is basically a weight to confidence
|
||||
// ratio. The higher the gains and the confidence then the more likely the AI
|
||||
// is to betting. There are also bluff chances within here.
|
||||
if(expectedGain < 0.8 && confidence < 0.8) {
|
||||
if(random < 95) {
|
||||
amount = 0;
|
||||
} else {
|
||||
amount = bluffBet;
|
||||
isBluff = true;
|
||||
}
|
||||
} else if ((expectedGain < 1.0 && confidence < 0.85) || confidence < 0.1) {
|
||||
if (random < 80) {
|
||||
amount = 0;
|
||||
} else if(random < 5) {
|
||||
amount = callBet;
|
||||
isBluff = true;
|
||||
} else {
|
||||
amount = bluffBet;
|
||||
isBluff = true;
|
||||
}
|
||||
} else if ((expectedGain < 1.3 && confidence < 0.9) || confidence < 0.5) {
|
||||
if (random < 60 || confidence < 0.5) {
|
||||
amount = callBet;
|
||||
} else {
|
||||
amount = maxBet;
|
||||
}
|
||||
} else if (confidence < 0.95 || poker->dealer.cardsFacing < 0x04) {
|
||||
if(random < 20) {
|
||||
amount = callBet;
|
||||
} else {
|
||||
amount = maxBet;
|
||||
}
|
||||
} else {
|
||||
amount = (player->chips - callBet) * 9 / 10;
|
||||
}
|
||||
|
||||
// If this is the first round... make it a lot less likely I'll bet
|
||||
if(poker->dealer.cardsFacing == 0x00 && amount > callBet) {
|
||||
if(random > 5) amount = callBet;
|
||||
}
|
||||
|
||||
// Did we actually bet?
|
||||
if(amount > 0) {
|
||||
printf("AI is betting %i chips, bluff: %i\n", amount, isBluff);
|
||||
|
||||
// Let's not get caught in a raising loop with AI.
|
||||
if(player->timesRaised >= POKER_TURN_MAX_RAISES) {
|
||||
amount = callBet;
|
||||
}
|
||||
|
||||
amount = mathMax(amount, callBet);
|
||||
turn = pokerTurnRaise(poker, playerIndex, amount);
|
||||
turn.confidence = confidence;
|
||||
} else if(pokerTurnCanPlayerCheck(poker, playerIndex)) {
|
||||
turn = pokerTurnCheck(poker, playerIndex);
|
||||
turn.confidence = 1;
|
||||
} else {
|
||||
turn = pokerTurnFold(poker, playerIndex);
|
||||
turn.confidence = 1 - confidence;
|
||||
}
|
||||
|
||||
|
||||
return turn;
|
||||
}
|
||||
|
||||
void pokerTurnAction(poker_t *poker, pokerplayer_t *player, pokerturn_t *turn) {
|
||||
switch(turn->type) {
|
||||
case POKER_TURN_TYPE_BET:
|
||||
case POKER_TURN_TYPE_CALL:
|
||||
case POKER_TURN_TYPE_ALL_IN:
|
||||
pokerBetPlayer(&poker->bet, player, turn->chips);
|
||||
player->timesRaised++;
|
||||
break;
|
||||
|
||||
case POKER_TURN_TYPE_CHECK:
|
||||
pokerBetPlayer(&poker->bet, player, 0);
|
||||
player->timesRaised = 0;
|
||||
break;
|
||||
|
||||
case POKER_TURN_TYPE_FOLD:
|
||||
player->state |= POKER_PLAYER_STATE_FOLDED;
|
||||
player->timesRaised = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
player->state |= POKER_PLAYER_STATE_ROUND_MOVE;
|
||||
}
|
||||
|
||||
pokerturn_t pokerTurnOut(poker_t *poker, uint8_t player) {
|
||||
pokerturn_t turn;
|
||||
turn.type = POKER_TURN_TYPE_OUT;
|
||||
return turn;
|
||||
}
|
||||
|
||||
pokerturn_t pokerTurnFold(poker_t *poker, uint8_t player) {
|
||||
pokerturn_t turn;
|
||||
turn.type = POKER_TURN_TYPE_FOLD;
|
||||
return turn;
|
||||
}
|
||||
|
||||
pokerturn_t pokerTurnCheck(poker_t *poker, uint8_t player) {
|
||||
return pokerTurnRaise(poker, player, 0);
|
||||
}
|
||||
|
||||
pokerturn_t pokerTurnCall(poker_t *poker, uint8_t playerIndex) {
|
||||
pokerturn_t turn;
|
||||
pokerplayer_t *player;
|
||||
player = poker->players + playerIndex;
|
||||
turn = pokerTurnRaise(
|
||||
poker, playerIndex, poker->bet.currentBet - player->currentBet
|
||||
);
|
||||
return turn;
|
||||
}
|
||||
|
||||
pokerturn_t pokerTurnRaise(poker_t *poker, uint8_t playerIndex, int32_t chips) {
|
||||
pokerturn_t turn;
|
||||
pokerplayer_t *player;
|
||||
player = poker->players + playerIndex;
|
||||
|
||||
if(chips == 0) {
|
||||
turn.type = POKER_TURN_TYPE_CHECK;
|
||||
turn.chips = 0;
|
||||
} else if(player->chips <= chips) {
|
||||
turn.chips = player->chips;
|
||||
turn.type = POKER_TURN_TYPE_ALL_IN;
|
||||
} else {
|
||||
turn.chips = chips;
|
||||
turn.type = POKER_TURN_TYPE_BET;
|
||||
|
||||
if(chips == (poker->bet.currentBet - player->currentBet)) {
|
||||
turn.type = POKER_TURN_TYPE_CALL;
|
||||
}
|
||||
}
|
||||
|
||||
return turn;
|
||||
}
|
||||
|
||||
bool pokerTurnCanPlayerCheck(poker_t *poker, uint8_t playerIndex) {
|
||||
return (poker->players + playerIndex)->currentBet >= poker->bet.currentBet;
|
||||
}
|
Reference in New Issue
Block a user