In [1]:

```
import gambit
```

One can build up extensive games from scratch and manipulate them. This example shows one way to do that for the simple one-card poker game.

The primitives for doing this remain rather low-level, as I have never settled on a good way to write higher-level ones that apply broadly. It has always seemed to me that different games have different "natural" ways to build them out. It is nevertheless likely that having some more powerful idioms could be useful - suggestions are welcomed.

In [2]:

```
g = gambit.Game.new_tree()
g.title = "A simple poker example"
```

Define the players; save them as variables for convenience laster.

In [3]:

```
alice = g.players.add("Alice")
```

In [4]:

```
bob = g.players.add("Bob")
```

In [5]:

```
move = g.root.append_move(g.players.chance, 2)
```

In [6]:

```
move.actions[0].label = "A"
move.actions[0].prob = gambit.Rational(1, 2)
move.actions[1].label = "K"
move.actions[1].prob = gambit.Rational(1, 2)
```

After an Ace, Alice can Raise or Fold.

In [7]:

```
move = g.root.children[0].append_move(alice, 2)
move.label = 'a'
move.actions[0].label = "R"
move.actions[1].label = "F"
```

`append_move`

with the player, rather than the previously created move, creates a new information set for Alice.

In [8]:

```
move = g.root.children[1].append_move(alice, 2)
move.label = 'k'
move.actions[0].label = "R"
move.actions[1].label = "F"
```

After Alice raises with the Ace, Bob can Meet or Pass.

In [9]:

```
move = g.root.children[0].children[0].append_move(bob, 2)
move.label = 'b'
move.actions[0].label = "M"
move.actions[1].label = "P"
```

`move`

here adds the move to the same information set for Bob.

In [10]:

```
g.root.children[1].children[0].append_move(move)
```

Out[10]:

The game so far, as an .efg file. We see the tree structure is in place; now to deal with payoffs.

In [11]:

```
g
```

Out[11]:

In [12]:

```
alice_big = g.outcomes.add("Alice wins big")
alice_big[0] = 2
alice_big[1] = -2
```

In [13]:

```
alice_small = g.outcomes.add("Alice wins")
alice_small[0] = 1
alice_small[1] = -1
```

In [14]:

```
bob_small = g.outcomes.add("Bob wins")
bob_small[0] = -1
bob_small[1] = 1
```

In [15]:

```
bob_big = g.outcomes.add("Bob wins big")
bob_big[0] = -2
bob_big[1] = 2
```

In [16]:

```
g.root.children[0].children[0].children[0].outcome = alice_big
g.root.children[0].children[0].children[1].outcome = alice_small
g.root.children[0].children[1].outcome = bob_small
```

In [17]:

```
g.root.children[1].children[0].children[0].outcome = bob_big
g.root.children[1].children[0].children[1].outcome = alice_small
g.root.children[1].children[1].outcome = bob_small
```

Here's the game we've just built

In [18]:

```
g
```

Out[18]:

For comparison, here's the game we started with for the Poker example.

In [19]:

```
gambit.Game.read_game("poker.efg")
```

Out[19]:

We can confirm they're the same:

In [20]:

```
g.write() == gambit.Game.read_game("poker.efg").write()
```

Out[20]:

In [ ]:

```
```