API

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, including PreFlop, Flop, Turn, River.
• round the process of each player deciding which actions to take, until no further actions are taking.

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.

play!(game::Game[, sf::StartFrom])

Play a game.

Optionally, users can pass in a StartFrom option, to start from a game-point, specified by sf.

tournament!(game::Game)

Play until a single player remains!

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.

AbstractStrategy

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

Human

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

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.

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.

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.

bank_roll_chips(::Player)

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

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.

Action

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

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

• Fold
• Check
• Call
• Raise
• AllIn

Check()

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

Fold()

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

Call(amt::Int)
Call(table::Table, player::Player)

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

Use call_amount to query how much is needed to call.

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

Return the amount to call inside player_option.

Raise(amt::Int)

The raise action, should be returned from player_option. when a player wants to raise to amount amt.

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

AllIn(amt::Int)
AllIn(table::Table, player::Player)

The all-in action, should be returned from player_option. when a player wants to raise all in (to amount amt).

Users may call this via AllIn(last(valid_raise_range(table, player))) or use the convenience function AllIn(table, player).

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

valid_raise_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.

AbstractPlayerOptions

The option super type.

CheckRaiseFold

The option when a player is only able to check, raise, or fold.

CallRaiseFold

The option when a player is only able to call, raise, or fold.

CallAllInFold

The option when a player is only able to call, raise all-in, or fold.

CallFold

The option when a player is only able to call or fold.

player_option(game::Game, player::Player, option::AbstractPlayerOptions)

Returns a valid action (see Action), given the allowable option. TexasHoldem calls player_option 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 option type is one of

• CheckRaiseFold
• CallRaiseFold
• CallAllInFold
• CallFold

recreate_game(game, player)

Creates an exact (deep)copy of the input game, and then re-samples the unobserved cards (i.e., the opponent cards and unobserved table cards).

This is useful for repeatedly sampling a specific scenario so that we can compute the expected value of a particular action.

TODO: we could make a mutating, in-place version of this to reduce allocations.