Why Simulations and Games?

The main issue with conventional classroom education in International Relations is that it often involves a considerable amount of theory, but usually no active practice. Moreover, conventional education — raising hands to answer questions, going up to the board to solve problems, etc. — may be intimidating to students from minority or traditionally underserved backgrounds. An easy solution is to tie a simulation or game to every major topic. Simulations and games (S&Gs) ameliorate both these issues: they are interactive and fun, yet may serve as an “equalizer”, allowing for skill and knowledge to drive results rather than merely whomever is most comfortable speaking up. The added benefit with S&Gs is that they come with their own set of metrics: the instructor can quantifiably compare which students are performing at what level; and can provide extra help proactively for struggling students.

Feedback I’ve always received about S&Gs, however, is that they may involve a somewhat steep learning curve and that they are not strongly tied to the direct course lecture. If these two concerns were addressed, students would improve their understanding of what may otherwise be a disjoint exercise and distant case studies.

Below I have presented a “games box” of S&Gs that maintains quick, easy to understand instructions for a wide variety of topics. Notably, the games are simple; and they also come with their own discussion modules to directly tie them into the lecture.

The S&Gs below are separated into two groups: conventional prisoner’s dilemma games (meant more akin as an introduction); followed by bargaining games (which are a critical).

Simple Prisoner’s Dilemma Games

Case Study

First, start with discussing one of the following case studies: The U.S.-Soviet arms race during the Cold War, especially including ballistic missiles and missile defenses. To keep this brutally simple, just focusing on nuclear weapons is fine (rather than getting into the messy European ground forces plus covert action plus trade, etc.).

Game Setup

- Divide the class into pairs

- Each pair represents two countries (with a randomly selected spokesperson who actually plays the cards)

- Decision cards (one set per player): "Cooperate" and "Defect"

- Scoreboard to track payoffs as in a conventional prisoner’s dilemma

Instructions:

1. Each round, players simultaneously choose to either "Cooperate" or "Defect" by placing their chosen card face down.

2. Both players reveal their choices simultaneously.

3. Points are awarded based on the following payoff structure:

- Both Cooperate: Each gets 3 points

- Both Defect: Each gets 1 point

- One Cooperates, One Defects: Defector gets 5 points, Cooperator gets 0 points

4. Play for 1 round, keeping a running total of points.

5. The player with the most points at the end wins.

Extensions and Manipulations

1. Repeated Games:

- Play the game for 10 or 20 rounds instead of 1.

2. Changing Payoffs:

- Alter the payoff structure to model different scenarios:

- Increase the reward for mutual cooperation to encourage collaboration.

- Increase the punishment for mutual defection to discourage non-cooperation.

3. Uncertainty:

- Introduce a small chance (e.g., 10%) that a "Cooperate" action might be misinterpreted as "Defect".

4. Communication:

- Allow players to communicate for 30 seconds before each decision.

5. Principle-Agent:

- Spokesperson is no longer randomly assigned, but elected by the group.

6. Asymmetric Power:

- Assign different payoff structures to each player, i.e., one player suffers more from defection compared to the other.

7. Dynamic Games:

- Reveal one player's choice before the other decides.

8. Static Game of Incomplete Information:

- Different payoff structure, but both sides do not know how much outcomes map onto payoffs.

Debrief:

  1. What’s the dilemma?

  2. In what major ways was the game totally unrealistic? Realistic?

  3. What do you think explains successes and failures for SALT I, SALT II, START I, START II, SORT (Moscow Treaty), and New START?

  4. Which game variety was most conducive to peace? Why?

  5. What modifications to the game best led to peace? Given that, what would we have to do in real life to enhance peace?

Bargaining and Ultimatum Games

Case Study

India and Pakistan (and China) is a useful example; however, sometimes students may conflate the bargaining model as pertaining exclusively to territorial disputes. In actual IR research, however, the bargaining model is used to describe disputes over anything. Adding another case study about, say, the Iranian nuclear deal, might be useful. The core metric to evaluate success is how much of the pie each student (group) receives; or whether a deal was achieved or otherwise.

Game Setup

- Divide the class into pairs

- Each pair represents countries (with a randomly selected spokesperson who actually negotiates)

- Decision cards (one set per player): Numbers from 0 to 100, representing percentage of land/control

- Scoreboard to track who gets what after costly fighting (i.e., army “power” which can be mapped onto a probability of victory over the pie).

Instructions:

1. Each round, players are free to discuss an agreement.

2. They may decide to fight instead, in which case a lottery determines who gets what. This is then their “score” for the game.

3. If they negotiate, who gets what proportion is directly their “score” for the game.

4. Play for 1 round, recording the results.

Extensions and Manipulations

1. Repeated Negotiations:

- Play the game for 5 or 10 rounds instead of 1.

2. Changing Costs:

- Fighting results in more costs per player.

3. Uncertainty over Costs and Power:

- Players do not know each others’ costs for fighting nor power.

4. Mediation:

- Allow a third-party mediators to try and ensure peace. (With uncertainty over costs and power.)

5. Domestic Constraints:

- Spokesperson must consult with their "domestic constituency" before making decisions: 50% + 1 of team members must support .

6. Asymmetric Power:

- One side starts with a larger portion.

7. Ultimatum Bargaining:

- One player makes an offer, the other can accept or reject. If rejected, roles reverse.

Debrief

1. What's the puzzle here?

2. In what major ways was the game unrealistic? Realistic?

3. What do you think explains successes and failures in real India-Pakistan negotiations? Other negotiations?

4. Which game variety was most conducive to reaching an agreement? Why?

5. What modifications to the game best led to successful negotiation? Given that, what would we have to do in real-life negotiations?

Computational Simulations

Word of warning: for the below, students will not be playing with one another; just toggling different components of the simulation. You’d have to make them execute the following steps one by one:

Step 1: Download NetLogo

This part is easy: link.

Step 2: Open up the NetLogo saved games on IR
Again, easy. NetLogo > File > Models Library > Social Science

Step 3: Fiddle with Models
Have the students open up whichever model is relevant to lecture. For example, the NetLogo simulations on Prisoner’s Dilemma are useful as a fun, interactive way to toggle different initial conditions in the system and then figure out what results. Ask students to then: 1. See what conditions give rise to cooperation versus defection; 2. Tie it into a real-world case.

Step 4: Advanced
Have students modulate or add their own feature to one of the pre-existing modules. (E.g., open up the Prisoner’s Dilemma module from the library and then add a variable for “mistakes”, cooperation that accidentally misfires as defection.)

Using oTree

oTree is an open-source platform designed for creating and running interactive, web-based simulations and games, widely used in fields like economics, political science, and psychology. Its flexibility makes it ideal for teaching International Relations (IR) through hands-on simulations. With oTree, students can participate in complex decision-making scenarios, such as game-theory-based experiments like the Prisoner's Dilemma or bargaining models, which help them understand the strategic interactions that shape global politics. The platform uses Python, making it highly customizable and suitable for various IR topics, from conflict resolution to alliance formation.

You can access the oTree website for documentation here: link.

Simple Prisoner’s Dilemma

from otree.api import *

class Constants(BaseConstants):
    name_in_url = 'prisoners_dilemma'
    players_per_group = 2
    num_rounds = 1
    payoff_cooperate = 2
    payoff_defect = 3
    payoff_betrayed = 0
    payoff_mutual_defect = 1

class Subsession(BaseSubsession):
    pass

class Group(BaseGroup):
    def set_payoffs(self):
        p1, p2 = self.get_players()
        if p1.decision == 'Cooperate' and p2.decision == 'Cooperate':
            p1.payoff = Constants.payoff_cooperate
            p2.payoff = Constants.payoff_cooperate
        elif p1.decision == 'Cooperate' and p2.decision == 'Defect':
            p1.payoff = Constants.payoff_betrayed
            p2.payoff = Constants.payoff_defect
        elif p1.decision == 'Defect' and p2.decision == 'Cooperate':
            p1.payoff = Constants.payoff_defect
            p2.payoff = Constants.payoff_betrayed
        else:
            p1.payoff = Constants.payoff_mutual_defect
            p2.payoff = Constants.payoff_mutual_defect

class Player(BasePlayer):
    decision = models.StringField(
        choices=['Cooperate', 'Defect'],
        doc="Player's decision: Cooperate or Defect",
        widget=widgets.RadioSelect
    )

class Introduction(Page):
    pass

class Decision(Page):
    form_model = 'player'
    form_fields = ['decision']

class ResultsWaitPage(WaitPage):
    after_all_players_arrive = 'set_payoffs'

class Results(Page):
    pass

page_sequence = [Introduction, Decision, ResultsWaitPage, Results]

Simple Ultimatum Bargaining

from otree.api import *

class Constants(BaseConstants):
    name_in_url = 'ultimatum_game'
    players_per_group = 2
    num_rounds = 1
    endowment = 10  # amount proposer can divide

class Subsession(BaseSubsession):
    pass

class Group(BaseGroup):
    offer = models.CurrencyField(min=0, max=Constants.endowment, doc="Amount proposed by Player 1")

    def set_payoffs(self):
        p1, p2 = self.get_players()
        if p2.accept:
            p1.payoff = Constants.endowment - self.offer
            p2.payoff = self.offer
        else:
            p1.payoff = 0
            p2.payoff = 0

class Player(BasePlayer):
    accept = models.BooleanField(choices=[[True, 'Accept'], [False, 'Reject']], doc="Player 2's decision")

# PAGES
class Introduction(Page):
    pass

class Offer(Page):
    form_model = 'group'
    form_fields = ['offer']

    @staticmethod
    def is_displayed(player: Player):
        return player.id_in_group == 1  # Only Player 1 makes the offer

class Accept(Page):
    form_model = 'player'
    form_fields = ['accept']

    @staticmethod
    def is_displayed(player: Player):
        return player.id_in_group == 2  # Only Player 2 accepts/rejects

class ResultsWaitPage(WaitPage):
    after_all_players_arrive = 'set_payoffs'

class Results(Page):
    pass

page_sequence = [Introduction, Offer, Accept, ResultsWaitPage, Results]