# R-P-S game

### Tags

(This model has yet to be categorized with any tags)
Visible to everyone | Changeable by the author
Model was written in NetLogo 6.0.1 • Viewed 65 times • Downloaded 1 time • Run 0 times

## WHAT IS IT?

This model is a multiplayer version of the iterated prisoner's dilemma. It is intended to explore the strategic implications that emerge when the world consists entirely of prisoner's dilemma like interactions. If you are unfamiliar with the basic concepts of the prisoner's dilemma or the iterated prisoner's dilemma, please refer to the PD BASIC and PD TWO PERSON ITERATED models found in the PRISONER'S DILEMMA suite.

## HOW IT WORKS

The PD TWO PERSON ITERATED model demonstrates an interesting concept: When interacting with someone over time in a prisoner's dilemma scenario, it is possible to tune your strategy to do well with theirs. Each possible strategy has unique strengths and weaknesses that appear through the course of the game. For instance, always defect does best of any against the random strategy, but poorly against itself. Tit-for-tat does poorly with the random strategy, but well with itself.

This makes it difficult to determine a single "best" strategy. One such approach to doing this is to create a world with multiple agents playing a variety of strategies in repeated prisoner's dilemma situations. This model does just that. The turtles with different strategies wander around randomly until they find another turtle to play with. (Note that each turtle remembers their last interaction with each other turtle. While some strategies don't make use of this information, other strategies do.)

Payoffs

When two turtles interact, they display their respective payoffs as labels.

Each turtle's payoff for each round will determined as follows:

``````             | Partner's Action
Turtle's   |
Action    |   C       D
------------|-----------------
C     |   3       0
------------|-----------------
D     |   5       1
------------|-----------------
(C = Cooperate, D = Defect)
``````

(Note: This way of determining payoff is the opposite of how it was done in the PD BASIC model. In PD BASIC, you were awarded something bad- jail time. In this model, something good is awarded- money.)

## HOW TO USE IT

### Buttons

SETUP: Setup the world to begin playing the multi-person iterated prisoner's dilemma. The number of turtles and their strategies are determined by the slider values.

GO: Have the turtles walk around the world and interact.

GO ONCE: Same as GO except the turtles only take one step.

### Sliders

N-STRATEGY: Multiple sliders exist with the prefix N- then a strategy name (e.g., n-cooperate). Each of these determines how many turtles will be created that use the STRATEGY. Strategy descriptions are found below:

### Strategies

RANDOM - randomly cooperate or defect

COOPERATE - always cooperate

DEFECT - always defect

TIT-FOR-TAT - If an opponent cooperates on this interaction cooperate on the next interaction with them. If an opponent defects on this interaction, defect on the next interaction with them. Initially cooperate.

UNFORGIVING - Cooperate until an opponent defects once, then always defect in each interaction with them.

UNKNOWN - This strategy is included to help you try your own strategies. It currently defaults to Tit-for-Tat.

### Plots

AVERAGE-PAYOFF - The average payoff of each strategy in an interaction vs. the number of iterations. This is a good indicator of how well a strategy is doing relative to the maximum possible average of 5 points per interaction.

## THINGS TO NOTICE

Set all the number of player for each strategy to be equal in distribution. For which strategy does the average-payoff seem to be highest? Do you think this strategy is always the best to use or will there be situations where other strategy will yield a higher average-payoff?

Set the number of n-cooperate to be high, n-defects to be equivalent to that of n-cooperate, and all other players to be 0. Which strategy will yield the higher average-payoff?

Set the number of n-tit-for-tat to be high, n-defects to be equivalent to that of n-tit-for-tat, and all other playerst to be 0. Which strategy will yield the higher average-payoff? What do you notice about the average-payoff for tit-for-tat players and defect players as the iterations increase? Why do you suppose this change occurs?

Set the number n-tit-for-tat to be equal to the number of n-cooperate. Set all other players to be 0. Which strategy will yield the higher average-payoff? Why do you suppose that one strategy will lead to higher or equal payoff?

## THINGS TO TRY

1. Observe the results of running the model with a variety of populations and population sizes. For example, can you get cooperate's average payoff to be higher than defect's? Can you get Tit-for-Tat's average payoff higher than cooperate's? What do these experiments suggest about an optimal strategy?

2. Currently the UNKNOWN strategy defaults to TIT-FOR-TAT. Modify the UNKOWN and UNKNOWN-HISTORY-UPDATE procedures to execute a strategy of your own creation. Test it in a variety of populations. Analyze its strengths and weaknesses. Keep trying to improve it.

3. Relate your observations from this model to real life events. Where might you find yourself in a similar situation? How might the knowledge obtained from the model influence your actions in such a situation? Why?

## EXTENDING THE MODEL

Relative payoff table - Create a table which displays the average payoff of each strategy when interacting with each of the other strategies.

Complex strategies using lists of lists - The strategies defined here are relatively simple, some would even say naive. Create a strategy that uses the PARTNER-HISTORY variable to store a list of history information pertaining to past interactions with each turtle.

Evolution - Create a version of this model that rewards successful strategies by allowing them to reproduce and punishes unsuccessful strategies by allowing them to die off.

Noise - Add noise that changes the action perceived from a partner with some probability, causing misperception.

Spatial Relations - Allow turtles to choose not to interact with a partner. Allow turtles to choose to stay with a partner.

Environmental resources - include an environmental (patch) resource and incorporate it into the interactions.

## NETLOGO FEATURES

Note the use of the `to-report` keyword in the `calc-score` procedure to report a number.

Note the use of lists and turtle ID's to keep a running history of interactions in the `partner-history` turtle variable.

Note how agentsets that will be used repeatedly are stored when created and reused to increase speed.

## RELATED MODELS

PD Basic, PD Two Person Iterated, PD Basic Evolutionary

## HOW TO CITE

If you mention this model in a publication, we ask that you include these citations for the model itself and for the NetLogo software:

This model was created as part of the projects: PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN CLASSROOMS and/or INTEGRATED SIMULATION AND MODELING ENVIRONMENT. The project gratefully acknowledges the support of the National Science Foundation (REPP & ROLE programs) -- grant numbers REC #9814682 and REC-0126227.

Click to Run Model

```globals [
;;number of turtles with each strategy
num-R
num-P
num-S
num-R-rep
num-P-rep
num-S-rep

;;number of interactions by each strategy
num-random-games
num-cooperate-games
num-defect-games
num-tit-for-tat-games
num-unforgiving-games
num-unknown-games

;;total score of all turtles playing each strategy
R-score
P-score
S-score
]

turtles-own [
score
strategy
partner-strategy
partnered?        ;;am I partnered?
partner-R?
playR?
partner           ;;WHO of my partner (nobody if not partnered)
]

;;;;;;;;;;;;;;;;;;;;;;
;;;Setup Procedures;;;
;;;;;;;;;;;;;;;;;;;;;;

to setup
clear-all
store-initial-turtle-counts ;;record the number of turtles created for each strategy
setup-turtles ;;setup the turtles and distribute them randomly
reset-ticks
end

;;record the number of turtles created for each strategy
;;The number of turtles of each strategy is used when calculating average payoffs.
;;Slider values might change over time, so we need to record their settings.
;;Counting the turtles would also work, but slows the model.

to store-initial-turtle-counts
set num-R n-R
set num-P n-P
set num-S n-S
end

;;setup the turtles and distribute them randomly

to setup-turtles
make-turtles ;;create the appropriate number of turtles playing each strategy
setup-common-variables ;;sets the variables that all turtles share
end

;;create the appropriate number of turtles playing each strategy

to make-turtles
crt num-R [ set strategy "R" set color green - 1 set playR? true]
crt num-P [ set strategy "P" set color red set playR? false]
crt num-S [ set strategy "S" set color yellow set playR? false]
end

;;set the variables that all turtles share

to setup-common-variables
set score 8
set partnered? false
set partner nobody
setxy random-xcor random-ycor
]
end

;;;;;;;;;;;;;;;;;;;;;;;;
;;;Runtime Procedures;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to go
clear-last-round
ask turtles [ partner-up ]                        ;;have turtles try to find a partner
let partnered-turtles turtles with [ partnered? ]
do-scoring
reproduce-R
reproduce-P
reproduce-S
let p1 random-float 100
if p1 < random-mutationR [reproduce-R1]
let p2 random-float 100
if p2 < random-mutationP [reproduce-P1]
let p3 random-float 100
if p3 < random-mutationS [reproduce-S1]
ask turtles [ set score (score - cost-of-living) ]
ask turtles with [score > rep-score] [set score score - 2]
ask turtles with [score < death-score] [die]
;;  ask turtles [set label score]
do-scoring
if count turtles > rescale-after [rescale]
tick
end

to clear-last-round
let partnered-turtles turtles with [ partnered? ]
end

;;release partner and turn around to leave

to release-partners
set partnered? false
set partner nobody
rt 180
set label ""
end

;;have turtles try to find a partner
;;Since other turtles that have already executed partner-up may have
;;caused the turtle executing partner-up to be partnered,
;;a check is needed to make sure the calling turtle isn't partnered.

to partner-up ;;turtle procedure
if (not partnered?) [              ;;make sure still not partnered
rt (random-float 90 - random-float 90) fd 1     ;;move around randomly
set partner one-of (turtles-at -1 0) with [ not partnered? ]
if partner != nobody [              ;;if successful grabbing a partner, partner up
set partnered? true
;;      set shape "turtle"
set partnered? true
set partner myself
;;        set shape "turtle"
]
]
]
end

;;calculate the payoff for this round and
;;display a label with that payoff.

to get-payoff
set partner-strategy [strategy] of partner
if partner-strategy = "R" [
ifelse strategy = "R" [
set score (score + A)
] [
ifelse strategy = "P" [
set score (score + D)
] [
set score (score + G)
]
]
]
if partner-strategy = "P" [
ifelse strategy = "R" [
set score (score + B)
] [
ifelse strategy = "P" [
set score (score + EE)
] [
set score (score + H)
]
]
]
if partner-strategy = "S" [
ifelse strategy = "R" [
set score (score + C)
] [
ifelse strategy = "P" [
set score (score + F)
] [
set score (score + I)
]
]
]
end

to reproduce-R
crt num-R-rep [
let m1 random-float 100
ifelse m1 > mutate-R-to-P
[
set strategy "R"
set color green - 1
set score 5
set partnered? false
set partner nobody
set playR? true
setxy random-xcor random-ycor
]
[set strategy "P"
set color red
set score 5
set partnered? false
set partner nobody
set playR? false
setxy random-xcor random-ycor
]
]
end

to reproduce-P
crt num-P-rep [
let m2 random-float 100
ifelse m2 > mutate-P-to-S
[
set strategy "P"
set color red
set score 5
set partnered? false
set partner nobody
set playR? false
setxy random-xcor random-ycor
]
[set strategy "S"
set color yellow
set score 5
set partnered? false
set partner nobody
set playR? false
setxy random-xcor random-ycor
]]
end

to reproduce-S
crt num-S-rep [
let m3 random-float 100
ifelse m3 > mutate-S-to-R
[
set strategy "S"
set color yellow
set score 5
set partnered? false
set partner nobody
set playR? false
setxy random-xcor random-ycor
]
[set strategy "R"
set color green - 1
set score 5
set partnered? false
set partner nobody
set playR? true
setxy random-xcor random-ycor
]]
end

to reproduce-R1
crt random-mutationR [
set strategy "R"
set color green - 1
set score 4
set partnered? false
set partner nobody
set playR? true
setxy random-xcor random-ycor
]
end

to reproduce-P1
crt random-mutationP [
set strategy "P"
set color red
set score 4
set partnered? false
set partner nobody
set playR? false
setxy random-xcor random-ycor
]
end

to reproduce-S1
crt random-mutationS [
set strategy "S"
set color yellow
set score 4
set partnered? false
set partner nobody
set playR? false
setxy random-xcor random-ycor
]
end

to rescale
let K count turtles
if count turtles with [strategy = "P"] > 2 [
ask n-of (num-P - (rescale-after * ((num-P) / K) )) turtles with [ strategy = "P" ] [ die ]
]
if count turtles with [strategy = "R"] > 2 [
ask n-of (num-R - (rescale-after * ((num-R) / K) )) turtles with [ strategy = "R" ] [ die ]
]
if count turtles with [strategy = "S"] > 2 [
ask n-of (num-S - (rescale-after * ((num-S) / K) )) turtles with [ strategy = "S" ] [ die ]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;
;;;Plotting Procedures;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

;;calculate the total scores of each strategy

to do-scoring
set num-R count turtles with [strategy = "R"]
set num-P count turtles with [strategy = "P"]
set num-S count turtles with [strategy = "S"]
set R-score  (calc-score "R" num-R)
set P-score  (calc-score "P" num-P)
set S-score  (calc-score "S" num-S)
set num-R-rep count turtles with [(strategy = "R") and (score > rep-score)]
set num-P-rep count turtles with [(strategy = "P") and (score > rep-score)]
set num-S-rep count turtles with [(strategy = "S") and (score > rep-score)]
end

;; returns the total score for a strategy if any turtles exist that are playing it

to-report calc-score [strategy-type num-with-strategy]
ifelse num-with-strategy > 0 [
report (sum [ score ] of (turtles with [ strategy = strategy-type ]))
] [
report 0
]
end