PyPokerEngine

https://ishikota.github.io/PyPokerEngine/
Admin
PyPokerEngine is a simple framework for Texas hold'em poker AI development, allowing developers to...
Tokens:8,051
Snippets:65
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Setup and Start Poker Game

Source: https://ishikota.github.io/PyPokerEngine/tutorial/participate_in_the_game

Configure game rules, register players (AI and human), and start the poker game. Set verbose to 0 to disable console output and rely on visual feedback.

```python
from pypokerengine.api.game import setup_config, start_poker

config = setup_config(max_round=10, initial_stack=100, small_blind_amount=5)
config.register_player(name="fish_player", algorithm=FishPlayer())
config.register_player(name="human_player", algorithm=ConsolePlayer())
game_result = start_poker(config, verbose=0)  # verbose=0 because game progress is visualized by ConsolePlayer

```

--------------------------------

### Start Poker Game with Registered Players

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

This snippet demonstrates how to set up the game configuration, register AI players (FishPlayer and EmulatorPlayer), and start the poker simulation using `start_poker`. The `verbose=1` argument provides detailed output during the game.

```python
>>> from pypokerengine.api.game import setup_config, start_poker
>>> config = setup_config(max_round=10, initial_stack=100, small_blind_amount=5)
>>> config.register_player(name="fish_player", algorithm=FishPlayer())
>>> config.register_player(name="emulator_player", algorithm=EmulatorPlayer())
>>> game_result = start_poker(config, verbose=1)
```

--------------------------------

### Install PyPokerEngine

Source: https://ishikota.github.io/PyPokerEngine

Install the PyPokerEngine library using pip. This command is compatible with Python 2.7 and Python 3.5+.

```bash
pip install PyPokerEngine

```

--------------------------------

### Start New Round from Initial GameState

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Demonstrates how to manually start a new round using `emulator.start_new_round` after generating an initial GameState. This is necessary before running simulations.

```python
>>> initial_game_state
{'round_count': 0, 'next_player': None, 'street': 0, 'small_blind_amount': 5}, 'table': <pypokerengine.engine.table.Table instance at 0x10666cc68>}
>>> game_state, events = emulator.start_new_round(initial_game_state)
>>> game_state
{'round_count': 1, 'next_player': 0, 'street': 0, 'small_blind_amount': 5}, 'table': <pypokerengine.engine.table.Table instance at 0x1066bca28>}


```

--------------------------------

### Start Poker Game Simulation

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Use this to run a full poker game simulation with registered players and get the final game result. Set the maximum number of rounds, initial stack, and small blind amount.

```python
from pypokerengine.api.game import setup_config, start_poker
>>> config = setup_config(max_round=10, initial_stack=100, small_blind_amount=5)
>>> config.register_player(name="fish_player", algorithm=FishPlayer())
>>> config.register_player(name="honest_player", algorithm=HonestPlayer())
>>> game_result = start_poker(config, verbose=1)

```

--------------------------------

### Generate Initial GameState

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Example of generating a clean, initial GameState object using the `emulator.generate_initial_game_state` method.

```python
initial_game_state = emulator.generate_initial_game_state(players_info)


```

--------------------------------

### Initialize and Run Poker Game Simulation

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Demonstrates the common usage of Emulator: setting game rules, initializing the game state with player information, starting a new round, and applying a player action.

```python
from pypokerengine.api.emulator import Emulator

# 1. Set game settings on emulator
emulator = Emulator()
emulator.set_game_rule(nb_player, final_round, sb_amount, ante)
emulator.set_game_rule(player_num=3, max_round=10, small_blind_amount=5, ante_amount=1)

# 2. Setup GameState object
players_info = {
    "uuid-1": { "name": "player1", "stack": 100 },
    "uuid-2": { "name": "player2", "stack": 100 },
    "uuid-3": { "name": "player3", "stack": 80 }
}
initial_state = emulator.generate_initial_game_state(players_info)
game_state, events = emulator.start_new_round(initial_state)

# 3. Run simulation and get updated GameState object
updated_state, events = emulator.apply_action(game_state, "call", 10)

```

--------------------------------

### Event Object Example

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Provides an example of the Event objects returned by `emulator.start_new_round`, showing the structure for 'event_new_street' and 'event_ask_player'.

```python
>>> game_state, events = emulator.start_new_round(initial_state)
>>> events
[
  {
   'type': 'event_new_street',
   'street': 'preflop',
   'round_state': ...
  },
  {
   'type': 'event_ask_player',
   'uuid': 'uuid-1',
   'valid_actions': [{'action': 'fold', 'amount': 0}, ...]
  }
]


```

--------------------------------

### Setting up and Starting a Poker Game

Source: https://ishikota.github.io/PyPokerEngine/tutorial/estimate_card_strength

Configures and initiates a poker game with specified parameters, registering custom players like 'FishPlayer' and 'HonestPlayer'. The `verbose=1` argument provides detailed output during the game.

```python
from pypokerengine.api.game import setup_config, start_poker
config = setup_config(max_round=10, initial_stack=100, small_blind_amount=5)
config.register_player(name="fish_player", algorithm=FishPlayer())
config.register_player(name="honest_player", algorithm=HonestPlayer())
game_result = start_poker(config, verbose=1)
for player_info in game_result["players"]:
    print player_info
```

--------------------------------

### Declare Player Action

Source: https://ishikota.github.io/PyPokerEngine/tutorial/participate_in_the_game

Input your action and the corresponding amount when prompted by the game. This example shows raising to the maximum possible amount.

```text
-- Declare your action (UUID = qrnewmfzuyacjscxpfftgy) --
======================================================================
-- valid actions --
  - fold
  - call: 10
  - raise: [15, 100]
-- hole card --
  - ['CA', 'D2']
-- round state --
  - dealer btn : fish_player
  - street : preflop
  - community card : []
  - pot : main = 15, side = []
  - players information
    - 0 : fish_player (vhchlzkojrabhiomwdbpem) => state : participating, stack : 90 <= BB
    - 1 : human_player (qrnewmfzuyacjscxpfftgy) => state : participating, stack : 95 <= SB, CURRENT
  - action histories
    - preflop
      - {'action': 'SMALLBLIND', 'player': 'human_player (uuid=qrnewmfzuyacjscxpfftgy)', 'amount': 5, 'add_amount': 5}
      - {'action': 'BIGBLIND', 'player': 'fish_player (uuid=vhchlzkojrabhiomwdbpem)', 'amount': 10, 'add_amount': 5}
======================================================================
Enter action to declare >> raise
Enter raise amount >> 100

```

--------------------------------

### Create ConsolePlayer Class

Source: https://ishikota.github.io/PyPokerEngine/tutorial/participate_in_the_game

Implement a ConsolePlayer by overriding BasePokerPlayer methods to display game states and receive actions from the console. This example simplifies error handling.

```python
import pypokerengine.utils.visualize_utils as U

class ConsolePlayer(BasePokerPlayer):

    def declare_action(self, valid_actions, hole_card, round_state):
        print(U.visualize_declare_action(valid_actions, hole_card, round_state, self.uuid))
        action, amount = self._receive_action_from_console(valid_actions)
        return action, amount

    def receive_game_start_message(self, game_info):
        print(U.visualize_game_start(game_info, self.uuid))
        self._wait_until_input()

    def receive_round_start_message(self, round_count, hole_card, seats):
        print(U.visualize_round_start(round_count, hole_card, seats, self.uuid))
        self._wait_until_input()

    def receive_street_start_message(self, street, round_state):
        print(U.visualize_street_start(street, round_state, self.uuid))
        self._wait_until_input()

    def receive_game_update_message(self, new_action, round_state):
        print(U.visualize_game_update(new_action, round_state, self.uuid))
        self._wait_until_input()

    def receive_round_result_message(self, winners, hand_info, round_state):
        print(U.visualize_round_result(winners, hand_info, round_state, self.uuid))
        self._wait_until_input()

    def _wait_until_input(self):
        raw_input("Enter some key to continue ...")

    # FIXME: This code would be crash if receives invalid input.
    #        So you should add error handling properly.
    def _receive_action_from_console(self, valid_actions):
        action = raw_input("Enter action to declare >> ")
        if action == 'fold': amount = 0
        if action == 'call':  amount = valid_actions[1]['action']
        if action == 'raise':  amount = int(raw_input("Enter raise amount >> "))
        return action, amount

```

--------------------------------

### Play AI vs AI Poker Game

Source: https://ishikota.github.io/PyPokerEngine

Set up and start a poker game with multiple AI players. Configure game rules like the maximum number of rounds, initial stack size, and small blind amount using `setup_config`. Register AI players with unique names and their respective algorithms. The `start_poker` function initiates the game, with `verbose=1` providing simple game logs during play.

```python
from pypokerengine.api.game import setup_config, start_poker

config = setup_config(max_round=10, initial_stack=100, small_blind_amount=5)
config.register_player(name="p1", algorithm=FishPlayer())
config.register_player(name="p2", algorithm=FishPlayer())
config.register_player(name="p3", algorithm=FishPlayer())
game_result = start_poker(config, verbose=1)

```

--------------------------------

### Apply Action and Get Updated Game State

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Use `apply_action` to progress the game one step at a time. This method returns the updated game state and any events that occurred during the action.

```python
>>> emulator.set_game_rule(nb_player, max_round=10, sb_amount=5, ante_amount=0)
>>> next_turn_state, events = emulator.apply_action(current_state, 'call', 10)
```

--------------------------------

### Define a Player Model with Fixed Actions

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Create a custom player model by extending BasePokerPlayer. This example demonstrates a model that always declares a predefined action (FOLD, CALL, MIN_RAISE, or MAX_RAISE).

```python
class OneActionModel(BasePokerPlayer):

    FOLD, CALL, MIN_RAISE, MAX_RAISE = 0, 1, 2, 3

    def set_action(self, action):
        self.action = action

    def declare_action(self, valid_actions, hole_card, round_state):
        if self.FOLD == self.action:
            return valid_actions[0]['action'], valid_actions[0]['amount']
        elif self.CALL == self.action:
            return valid_actions[1]['action'], valid_actions[1]['amount']
        elif self.MIN_RAISE == self.action:
            return valid_actions[2]['action'], valid_actions[2]['amount']['min']
        elif self.MAX_RAISE == self.action:
            return valid_actions[2]['action'], valid_actions[2]['amount']['max']
        else:
            raise Exception("Invalid action [ %s ] is set" % self.action)

```

--------------------------------

### Restore Game State from Round State

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Reconstruct the game state object from a round state object, attaching hole cards. This is useful for starting simulations from a specific point in a game.

```python
from pypokerengine.utils.game_state_utils import\
        restore_game_state, attach_hole_card, attach_hole_card_from_deck

def setup_game_state(round_state, my_hole_card):
    game_state = restore_game_state(round_state)
    for player_info in round_state['seats']:
        if uuid == self.uuid:
            # Hole card of my player should be fixed. Because we know it.
            game_state = attach_hole_card(game_state, uuid, my_hole_card)
        else:
            # We don't know hole card of opponents. So attach them at random from deck.
            game_state = attach_hole_card_from_deck(game_state, uuid)

```

--------------------------------

### Initialize Emulator with Game Settings

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Set up the Emulator object with essential game rules such as the number of players, maximum rounds, small blind amount, and ante amount.

```python
from pypokerengine.api.emulator import Emulator

emulator = Emulator()
emulator.set_game_rule(nb_player=2, max_round=10, sb_amount=5, ante_amount=0)

```

--------------------------------

### EmulatorPlayer Simulation Results Output

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

This output shows the detailed debugging information from the `start_poker` function, including the hole cards of the emulator player and the average stack size after simulations for each potential action (FOLD, CALL, MIN_RAISE, MAX_RAISE). It also logs the game progression and the final winner.

```text
Started the round 1
Street "preflop" started. (community card = [])
[debug_info] --> hole_card of emulator player is ['S6', 'H6']
[debug_info] --> average stack after simulation when declares FOLD : 95.0
[debug_info] --> average stack after simulation when declares CALL : 104.09
[debug_info] --> average stack after simulation when declares MIN_RAISE : 117.46
[debug_info] --> average stack after simulation when declares MAX_RAISE : 131.6
"emulator_player" declared "raise:100"
"fish_player" declared "call:100"
Street "flop" started. (community card = ['HQ', 'D2', 'D8'])
Street "turn" started. (community card = ['HQ', 'D2', 'D8', 'S7'])
Street "river" started. (community card = ['HQ', 'D2', 'D8', 'S7', 'SQ'])
"['emulator_player']" won the round 1 (stack = {'emulator_player': 200, 'fish_player': 0})
```

--------------------------------

### EmulatorPlayer Decision Logic Outline

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

This pseudocode outlines the decision-making process for an EmulatorPlayer, which involves evaluating different actions by simulating their outcomes and choosing the action that leads to the highest stack.

```python
try_actions = [FOLD, CALL, MIN_RAISE, MAX_RAISE]
action_score = [0, 0, 0, 0]

for try_action in try_actions:
    # my_model <- setup my model to declare "try_action" anytime
    simulation_results = []
    for i in range(NB_SIMULATION):
        # updated_state <- run the simulation until current round finishes
        # result <- fetch stack of EmulatorPlayer in the updated_state
        simulation_results.append(result)
    # action_score <- average simulation_results

# best_action <- choose action which gets highest action_score
return best_action
```

--------------------------------

### Create a Simple Poker AI Player

Source: https://ishikota.github.io/PyPokerEngine

Implement a basic AI player by subclassing `BasePokerPlayer` and defining the `declare_action` method. This method determines the AI's action (raise, call, or fold) based on valid actions, hole cards, and the current round state. Ensure all abstract methods from the parent class are implemented.

```python
from pypokerengine.players import BasePokerPlayer

class FishPlayer(BasePokerPlayer):

    def declare_action(self, valid_actions, hole_card, round_state):
        call_action_info = valid_actions[1]
        action, amount = call_action_info["action"], call_action_info["amount"]
        return action, amount

    def receive_game_start_message(self, game_info):
        pass

    def receive_round_start_message(self, round_count, hole_card, seats):
        pass

    def receive_street_start_message(self, street, round_state):
        pass

    def receive_game_update_message(self, action, round_state):
        pass

    def receive_round_result_message(self, winners, hand_info, round_state):
        pass

```

--------------------------------

### Register Player Model with Emulator

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Register a player model with the emulator. The emulator will call the model's declare_action method during simulation and apply the returned action.

```python
p1_uuid = # uuid of player1. you would get this information from game_info object
p1_model = # setup model of player1
emulator.register_player(uuid1, p1_model)

```

--------------------------------

### Player Information Format for GameState

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Specifies the required format for player information when generating an initial GameState object using `emulator.generate_initial_game_state`.

```python
players_info = {
  "uuid_of_player1": { "name": "name_of_player1", "stack": initial_stack_of_player1 },
  "uuid_of_player2": { "name": "name_of_player2", "stack": initial_stack_of_player2 },
  ...
}


```

--------------------------------

### Restore GameState from Round State with Random Hole Cards

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Shows how to restore a GameState object from a `round_state` and then attach random hole cards for each player using `restore_game_state` and `attach_hole_card_from_deck`.

```python
from pypokerengine.utils.game_state_utils import restore_game_state, attach_hole_card_from_deck

game_state = restore_game_state(round_state)
for player in game_state["table"].seats.players:
    game_state = attach_hole_card_from_deck(game_state, player.uuid)


```

--------------------------------

### Restore GameState with Specific and Random Hole Cards

Source: https://ishikota.github.io/PyPokerEngine/documentation/about_emulator

Illustrates restoring a GameState from `round_state` and then attaching specific hole cards to one player while assigning random hole cards to others.

```python
from pypokerengine.utils.game_state_utils import restore_game_state, attach_hole_card_from_deck, attach_hole_card
from pypokerengine.utils.card_utils import gen_cards

game_state = restore_game_state(round_state)
for player in game_state["table"].seats.players:
    if player.uuid == "uuid-1":
        holecard = gen_cards(['SA', 'DA'])
        game_state = attach_hole_card(game_state, player.uuid, hole_card)
    else:
      game_state = attach_hole_card_from_deck(game_state, player.uuid)


```

--------------------------------

### Run Simulation Until Game Finish

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Use `run_until_game_finish` to simulate the entire game until its conclusion. This method returns the final game state and all events that transpired.

```python
>>> game_finish_state, events = emulator.run_until_game_finish(current_state)
```

--------------------------------

### Estimate Hand Strength by Simulation

Source: https://ishikota.github.io/PyPokerEngine/tutorial/estimate_card_strength

This function simulates game outcomes to estimate the win rate of a given hand against a specified number of players and community cards. It requires helper functions like `draw_cards_from_deck` and `observe_game_result` which are assumed to be defined elsewhere.

```python
nb_simulation = 1000
nb_player = 3
hole_card = ['H4', 'D7']
community_card = ['D3', 'C5', 'C6']

def estimate_hand_strength(nb_simulation, nb_player, hole_card, community_card):
    simulation_results = []
    for i in range(nb_simulation):
        opponents_cards = []
        for j in range(nb_player-1):  # nb_opponents = nb_player - 1
            opponents_cards.append(draw_cards_from_deck(num=2))
        nb_need_community = 5 - len(community_card)
        community_card.append(draw_cards_from_deck(num=nb_need_community))
        result = observe_game_result(hole_card, community_card, opponents_cards)  # return 1 if win else 0
        simulation_results.append(result)
    average_win_rate = 1.0 * sum(simulation_results) / len(simulation_results)
    return average_win_rate
```

--------------------------------

### Game Actions Log

Source: https://ishikota.github.io/PyPokerEngine/tutorial/participate_in_the_game

This log displays a sequence of actions taken by players during a game round, including blinds, raises, and calls. It shows the player, action type, and amounts involved.

```text
- {'action': 'SMALLBLIND', 'player': 'human_player (uuid=qrnewmfzuyacjscxpfftgy)', 'amount': 5, 'add_amount': 5}
- {'action': 'BIGBLIND', 'player': 'fish_player (uuid=vhchlzkojrabhiomwdbpem)', 'amount': 10, 'add_amount': 5}
- {'add_amount': 90, 'paid': 95, 'player': 'human_player (uuid=qrnewmfzuyacjscxpfftgy)', 'amount': 100, 'action': 'RAISE'}
- {'action': 'CALL', 'player': 'fish_player (uuid=vhchlzkojrabhiomwdbpem)', 'amount': 100, 'paid': 90}
```

--------------------------------

### Run Simulation Until Round Finish

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

Use `run_until_round_finish` to advance the game simulation to the end of the current round. It returns the game state after the round concludes and associated events.

```python
>>> round_finish_state, events = emulator.run_until_round_finish(current_state)
```

--------------------------------

### Estimate Hole Card Win Rate using PyPokerEngine

Source: https://ishikota.github.io/PyPokerEngine/tutorial/estimate_card_strength

Utilizes the `estimate_hole_card_win_rate` function from PyPokerEngine to calculate the win probability of a hand. Ensure cards are generated using `gen_cards` before passing them to the function.

```python
from pypokerengine.utils.card_utils import gen_cards, estimate_hole_card_win_rate
hole_card = gen_cards(['H4', 'D7'])
community_card = gen_cards(['D3', 'C5', 'C6'])
estimate_hole_card_win_rate(nb_simulation=1000, nb_player=3, hole_card=hole_card, community_card=community_card)
```

```python
estimate_hole_card_win_rate(nb_simulation=1000, nb_player=3, hole_card=hole_card, community_card=community_card)
```

--------------------------------

### Inspect Game State After Simulation

Source: https://ishikota.github.io/PyPokerEngine/tutorial/simulate_the_game_by_emulator

After a simulation step (apply_action, run_until_round_finish, or run_until_game_finish), you can inspect the game state object to check round count, current street, and the next player.

```python
>>> current_state['round_count'], current_state['street'], current_state['next_player']
(1, 0, 0)  # street_flg == 0 means PREFLOP
>>> next_turn_state['round_count'], next_turn_state['street'], next_turn_state['next_player']
(1, 0, 1)
>>> round_finish_state['round_count'], round_finish_state['street'], round_finish_state['next_player']
(1, 5, 0)  # street_flg == 5 means SHOWDOWN
>>> game_finish_state['round_count'], game_finish_state['street'], game_finish_state['next_player']
(10, 5, 0)  # simulation is finished at 10 round because we set max_round=10
```

--------------------------------

### Game Update and Round Result

Source: https://ishikota.github.io/PyPokerEngine/tutorial/participate_in_the_game

Observe game updates after a player's action and review the round's results, including winner determination and hand analysis.

```text
-- Game update (UUID = qrnewmfzuyacjscxpfftgy) --
======================================================================
-- new action --
  - fish_player (vhchlzkojrabhiomwdbpem) declared call: 100
-- round state --
  - dealer btn : fish_player
  - street : preflop
  - community card : []
  - pot : main = 200, side = [{'amount': 0, 'eligibles': ['vhchlzkojrabhiomwdbpem', 'qrnewmfzuyacjscxpfftgy']}, {'amount': 0, 'eligibles': ['vhchlzkojrabhiomwdbpem', 'qrnewmfzuyacjscxpfftgy']}]
  - players information
    - 0 : fish_player (vhchlzkojrabhiomwdbpem) => state : allin, stack : 0 <= BB, CURRENT
    - 1 : human_player (qrnewmfzuyacjscxpfftgy) => state : allin, stack : 0 <= SB
  - action histories
    - preflop
      - {'action': 'SMALLBLIND', 'player': 'human_player (uuid=qrnewmfzuyacjscxpfftgy)', 'amount': 5, 'add_amount': 5}
      - {'action': 'BIGBLIND', 'player': 'fish_player (uuid=vhchlzkojrabhiomwdbpem)', 'amount': 10, 'add_amount': 5}
      - {'add_amount': 90, 'paid': 95, 'player': 'human_player (uuid=qrnewmfzuyacjscxpfftgy)', 'amount': 100, 'action': 'RAISE'}
      - {'action': 'CALL', 'player': 'fish_player (uuid=vhchlzkojrabhiomwdbpem)', 'amount': 100, 'paid': 90}
======================================================================
Enter some key to continue ...

-- Round result (UUID = qrnewmfzuyacjscxpfftgy) --
======================================================================
-- winners --
  - fish_player (vhchlzkojrabhiomwdbpem) => state : allin, stack : 200
-- hand info --
  - fish_player (vhchlzkojrabhiomwdbpem)
    - hand => TWOPAIR (high=14, low=8)
    - hole => [14, 8]
  - human_player (qrnewmfzuyacjscxpfftgy)
    - hand => TWOPAIR (high=14, low=2)
    - hole => [14, 2]
-- round state --
  - dealer btn : fish_player
  - street : showdown
  - community card : ['H7', 'HA', 'S2', 'H8', 'D6']
  - pot : main = 200, side = [{'amount': 0, 'eligibles': ['vhchlzkojrabhiomwdbpem', 'qrnewmfzuyacjscxpfftgy']}, {'amount': 0, 'eligibles': ['vhchlzkojrabhiomwdbpem', 'qrnewmfzuyacjscxpfftgy']}]
  - players information
    - 0 : fish_player (vhchlzkojrabhiomwdbpem) => state : allin, stack : 200 <= BB
    - 1 : human_player (qrnewmfzuyacjscxpfftgy) => state : allin, stack : 0 <= SB
  - action histories
    - preflop

```

--------------------------------

### HonestPlayer AI Implementation

Source: https://ishikota.github.io/PyPokerEngine/tutorial/estimate_card_strength

An AI player that declares CALL if its estimated win rate is greater than or equal to 1/nb_player, and FOLD otherwise. It requires `BasePokerPlayer` and `estimate_hole_card_win_rate` to be imported.

```python
from pypokerengine.players import BasePokerPlayer
from pypokerengine.utils.card_utils import gen_cards, estimate_hole_card_win_rate

NB_SIMULATION = 1000

class HonestPlayer(BasePokerPlayer):

    def declare_action(self, valid_actions, hole_card, round_state):
        community_card = round_state['community_card']
        win_rate = estimate_hole_card_win_rate(
                nb_simulation=NB_SIMULATION,
                nb_player=self.nb_player,
                hole_card=gen_cards(hole_card),
                community_card=gen_cards(community_card)
                )
        if win_rate >= 1.0 / self.nb_player:
            action = valid_actions[1]  # fetch CALL action info
        else:
            action = valid_actions[0]  # fetch FOLD action info
        return action['action'], action['amount']

    def receive_game_start_message(self, game_info):
        self.nb_player = game_info['player_num']

    def receive_round_start_message(self, round_count, hole_card, seats):
        pass

    def receive_street_start_message(self, street, round_state):
        pass

    def receive_game_update_message(self, action, round_state):
        pass

    def receive_round_result_message(self, winners, hand_info, round_state):
        pass
```

--------------------------------

### Display Game Results

Source: https://ishikota.github.io/PyPokerEngine

Access and display the final game results after the poker game has concluded. The `game_result` object contains details about the game's rules, including ante, blind structure, maximum rounds, initial stack, and small blind amount, as well as information about each participating player, such as their final stack size, state, name, and unique identifier.

```python
>>> print game_result
{
  'rule': {'ante': 0, 'blind_structure': {}, 'max_round': 10, 'initial_stack': 100, 'small_blind_amount': 5},
  'players': [
    {'stack': 150, 'state': 'participating', 'name': 'p1', 'uuid': 'ijaukuognlkplasfspehcp'},
    {'stack': 30, 'state': 'participating', 'name': 'p2', 'uuid': 'uadjzyetdwsaxzflrdsysj'},
    {'stack': 120, 'state': 'participating', 'name': 'p3', 'uuid': 'tmnkoazoqitkzcreihrhao'}
  ]
}

```

--------------------------------

### AI Player Hand Analysis

Source: https://ishikota.github.io/PyPokerEngine/tutorial/participate_in_the_game

This comment indicates that an AI player ('FishPlayer') possesses an Ace, a high-ranking card, which significantly impacts the game's outcome. It suggests that beating this AI might be challenging due to its strong hand.

```text
OMG... FishPlayer also has Ace(the rank of Ace is 14) in his hole card...
We cannot beat FishPlayer.  
But I think you can understand how to compete with your own AIs.
```
Tokens:
Raw