API

TexasHoldem — Module

TexasHoldem

A no-limit Texas Holdem simulator.

Terminology

game a single "game", where players are dealt hands, winner(s) are declared once.
round a point or process in the game (from RoundState)
round the process of each player deciding which actions to take, until no further actions are taking.

source

Game-level functions

TexasHoldem.move_buttons! — Function

move_buttons!(table::Table)

Move the dealer, small blind, big blind, and first-to-act buttons to the next set of players.

This is an internal method.

source

TexasHoldem.play! — Function

play!(game::Game[, ::Val{true|false}])

Play a game. Users can take a game at an instance and continue that game, by calling play! with Val(false).

source

TexasHoldem.tournament! — Function

tournament!(game::Game)

Play until a single player remains!

source

Chips

TexasHoldem.Chips — Type

Chips(n, frac)

A stack of chips struct. This type is backed by Ints and performs exact arithmetic operations by using Rational numbers to track remainders (fractions of a chip). frac is always internally stored as less than 1.

Players can only bet/call with whole chips (n), and are not allowed to bet/call with a fraction of a chip.

We track the fractions of chips so that we can assert exact money conservation on the table until a player busts, at which point, that money is lost.

source

Player type and methods

TexasHoldem.AbstractStrategy — Type

AbstractStrategy

An abstract strategy type, which users can subtype when passing to players.

source

TexasHoldem.Human — Type

Human

A human (terminal input) strategy. Use this strategy if you want to play "live" games, and not for simulating games.

source

TexasHoldem.Bot5050 — Type

Bot5050

Bot5050 is a stochastic strategy that chooses all of its actions based on a coin flip.

This bot is used for quick-start game configurations for users.

source

TexasHoldem.Player — Type

Player

Contains the poker player information:

strategy
cards
bank roll
pot investment

TODO: some of these fields should be removed, since they're only needed for flow control logic.

source

TexasHoldem.bank_roll — Function

bank_roll(::Player)

The player's instantaneous bank roll.

We access the Int in Chips as the fractional chips are only handled by the TransactionManager.

source

TexasHoldem.bank_roll_chips — Function

bank_roll_chips(::Player)

The player's instantaneous bank roll in Chips (includes fractional chips).

source

TexasHoldem.round_bank_roll — Function

round_bank_roll(::Player)

The player's bank roll at the beginning of the round

We access the Int in Chips as the fractional chips are only handled by the TransactionManager.

source

Player actions

The call, raise, and all-in functions follow the convetion:

call_amount = total_bet - round_contribution
pot_investment = sum(round_contribution, rounds)
pot the sum of all round contributions
initial_round_raise_amount minimum raise amount for all betting cycles in the round
minimum_raise_amount the minimum raise amount.
Call(game) will match the amount of the last bet made in the current betting round. By calling, you stay in the hand.
RaiseTo(game, 5) raise the current total bet to 5.
AllIn(game) raise all-in (all of your remaining chips). Note that AllIn(game).amt will contain the raise above the current total bet.
bank_roll(game)

TexasHoldem.Action — Type

Action

An action type, to be returned by get_action during each players turn to act. This is an internal type, but documented for user understanding.

Users are expected to return an action from get_action by calling one of Action's convenience methods:

Fold
Check
Call
RaiseTo
AllIn

source

TexasHoldem.ActionType — Module

ActionType

An action enum type, to be used with Action.

Users are expected to return an action from get_action by calling one of Action's convenience methods:

NoOptions
Waiting
Fold
Check
Call
Raise
AllIn

source

TexasHoldem.Check — Function

Check()

The check action, to be returned from get_action, when a player wants to check.

source

TexasHoldem.Fold — Function

Fold()

The fold action, to be returned from get_action, when a player wants to fold.

source

TexasHoldem.Call — Function

Call(game::Game)

The call action, should be returned from get_action. when a player wants to call amount amt.

Use call_amount to query how much is needed to call.

source

TexasHoldem.call_amount — Function

call_amount(table::Table, player::Player)

Return the amount to call inside get_action.

source

TexasHoldem.RaiseTo — Function

RaiseTo(game::Game, total_bet::Int)

The raise-to action, should be returned from get_action. when a player wants to raise the current total bet amount to total_bet.

Use valid_total_bet_range to query the valid range that they are allowed to raise.

When a player returns RaiseTo(game, 5), this means that they want to raise the current total bet to 5.

source

TexasHoldem.AllIn — Function

AllIn(game::Game)

The all-in action, should be returned from get_action. when a player wants to raise all-in.

action = AllIn(game) will contain the amount to go all-in.

Users may call this via AllIn(game).

See valid_total_bet_range for querying the valid range that they are allowed to raise.

source

TexasHoldem.valid_total_bet_range — Function

valid_total_bet_range(table::Table, player::Player)

A UnitRange{Int} of valid raises. Note that sometimes the range's starting and ending values are the same when, for example, all-in is the only available option.

source

TexasHoldem.get_action — Function

get_action(game::Game, player::Player, options::Options)

Returns a valid action (see Action), given the allowable options. TexasHoldem calls get_action for each player on the table during each round. This function is entirely where the strategy logic resides.

Users may overload this method to develop their own poker bots. The options type is of type Options and has one of the following names

CheckRaiseFold
CallRaiseFold
CallAllInFold
CallFold

source

Additional helpers:

TexasHoldem.total_bet — Function

total_bet(game::Game)
total_bet(table::Table)

The total bet.

source

TexasHoldem.is_valid_action — Function

is_valid_action(game, a::Action, options::Options)

Returns a Bool indicating that the given action is valid given the options

source

TexasHoldem.action_validation_code — Function

action_validation_code(game::Game, action::Action, options::Options)

Returns an ActionValidationCode for the given action and options.

source

TexasHoldem.round_contribution — Function

round_contribution

The contribution for the round

source

Player options

TexasHoldem.Options — Type

Options

An options enum type, to be returned by get_options. Users can use this to determine which action to give back to play.

Helper functions to return allowable options include:

NoOptions
CheckRaiseFold
CallRaiseFold
CallAllInFold
CallFold

source

TexasHoldem.get_options — Function

get_options(game[, current_player])
get_options(game, player)

Retuns the Options available to player player for the given game (state) game.

source

Action and Options symbols

An Action has an action_type and an amount amt. The action_type is an enum type, with the following values:

Fold
Check
Call
Raise
AllIn

The allowable enum Options are:

NoOptions
CheckRaiseFold
CallRaiseFold
CallAllInFold
CallFold

get_options(game::Game) will always yield a valid Options object, TexasHoldem cannot guarantee that a user will yield a valid action. Use is_valid_action(game::Game, action::Action, options::Options)::Bool to determine if a given action is valid or not.

Action validation

Simply use @assert action_validation_code(game, action, options) == ActionValidationCode.ValidAction to validation a given action under the current options options. See ActionValidationCode for the action validation codes.

TexasHoldem.ActionValidationCode — Module