breeds [strategies players]
globals [ticks games matches numplayers payoffmat stratmat population davidRound?]; lastheader]
players-own [strategy partner score history coop? stay?]
strategies-own [name isNice? num]

to startup
  set stratmat [
    ; name     color  nice?  stay?
    ["Nice"    green  true   true]
    ["Nasty"   black  false  true]
    ["Tit4Tat" gray   true   true]
    ["Moth"    blue   true   false]
    ["Hit&Run" yellow false  false]
    ["Santa"   red    true   false]
    ["NasMoth" violet false  false]
    ["NNHRun"  cyan   true   false]
  ]
  clear-output
  print-stats-header
end

to setup
  ;if seed? [random-seed 1]
  ;if stratmat = 0 [startup]
  clear-turtles clear-plot clear-graphics   ; ca would also clear stratmat!
  ask patches [set pcolor white]
  setup-strategies
  set population values-from strategies [num]
  set numplayers sum population
  
  if count strategies with [num > 0] = 0 [output-print "No strategies!" stop]
  if sum population mod 2 = 1 [output-print "Odd number of players!" stop]

  setup-players
  set ticks 0
  set games 0
  set matches 0
  set davidRound? true
  set payoffmat list (list (list DD DD) (list DC CD)) (list (list CD DC) (list CC CC))
  set-plot-x-range 0 matchesPerSim
  set-plot-y-range 0 count players
end
to setup-strategies
  foreach stratmat [ ; Note: Nice is turtle 0, Nasty is turtle 1, etc
    create-custom-strategies 1 [
      set name item 0 ?
      set color item 1 ?
      set isNice? item 2 ?
      set hidden? true
      set num runresult word "num" name
    ]
  ]
end
to setup-players
  foreach values-from strategies [self] [
    create-custom-players (num-of ?) [
      set strategy ?
      set partner nobody
      set score 0
      set color color-of strategy
    ]
  ]
  let delta 360 / count players
  ask players [set heading (who - count strategies) * delta forward screen-edge-x]
  setup-partners
end
to setup-partners
  let l shuffle values-from (players with [partner = nobody]) [self]
  let len length l ; generally > 0  should work if 0
  let len1 len / 2
  let l1 sublist l 0 len1
  let l2 sublist l len1 len
  (foreach l1 l2 [
    set partner-of ?1 ?2
    set partner-of ?2 ?1
    set history-of ?1 []
    set history-of ?2 []
    ask ?1 [set heading towards-nowrap ?2]
    ask ?2 [set heading towards-nowrap ?1]
  ])
end
to-report stats
  let payoffs (list CC CD DC DD)
  let initpop values-from strategies [num]
  let nums (list numplayers gamesPerMatch matchesPerSim)
  ;let roundoff ifelse-value davidRound? [1][0]
  let results (sentence payoffs initpop nums population) ; roundoff population)
  report list-to-string results
end
to print-stats-header
  let names "AllC AllD T4T Moth HnR Santa NMoth NNHnR"
  let names0 "AllC0 AllD0 T4T0 Moth0 HnR0 Santa0 NMoth0 NNHnR0"
  output-print (word "CC CD DC DD " names0 " Players GperMatch MperSim " names); D " names)
end
to print-stats
  let s ifelse-value stop? [""][(word "[" matches "]" )]
  output-print word s stats
end

to go
  if numplayers = 0 [stop]
  if matches = 0 [graph-stats]
  set matches matches + 1
  repeat gamesPerMatch [set games games + 1 play-one-game]
  evolve
  if graph? [graph-stats]
  if stop? [print-stats stop]
end
to-report stop?
  report matches = matchesPerSim
end
to scan
  repeat scanNum [
    setup 
    ;repeat matchesPerSim [go]
    while [not stop?] [go]
  ]
  ;stop
end
to play-one-game
  let pairs players with [who < who-of partner]
  ask pairs [play]
  setup-partners
end

to graph-stats
  ask strategies with [num > 0] [
    set-current-plot-pen name
    plot count players with [strategy = myself]
  ]
end

to evolve
  ask players [if score < 0 [set score 0]] ; adjust for negative numbers.  possibly translate instead?
  let total score-sum players
  if total = 0 [stop] ; all nasty w/ 0 DD would cause this
  set population map [score-sum players with [strategy = ?]] (values-from strategies [self])
  set population map [(? * numplayers) / total] population
  set population rounded-list population
  let id count strategies
  (foreach values-from strategies [self] population [
    repeat ?2 [
      ask turtle id [set strategy ?1]
      set id id + 1
    ]
  ])
  
  ask players [set color color-of strategy set score 0 set partner nobody]
  setup-partners
end

;;;; Utilities
to-report precision-list [l places]
  report map [precision ? places] l
end
to-report list-to-string [l]
  report reduce [(word ?1 " " ?2)] l
end
to-report score-sum [agents]
  report sum-list (values-from agents [score])
end
to-report sum-list [l]
  report ifelse-value (length l = 0) [0] [reduce [?1 + ?2] l]
end
to-report rand-weighted-index [floats]
  let rand random-float (sum-list floats)
  let i 0
  let s 0
  foreach floats [
    set s s + ?
    if s >= rand [report i]
    set i i + 1
  ]
  output-show "Oops in rand-weighted-index" report -1
end
to-report rounded-list [floats]
  ifelse davidRound? 
    [report floor-whole-adjusted-list floats]
    [report floor-fraction-adjusted-list floats]
end

; Historical: Several methods were looked at for resolving fractional agents for a given
; strategy during the evolutionary phase.  Here are two.  The first is the original one used
; by David Joyce, the second used during our initial modeling.  Choosing between them
; did not change the overall statistics.  We now default to using David's approach.
to-report floor-fraction-adjusted-list [floats]
  let roundoff map [ ? - int ? ] floats
  let ints map [ int ? ] floats
  repeat ((round sum-list floats) - sum-list ints) [
    let i rand-weighted-index roundoff
    set roundoff replace-item i roundoff 0
    set ints replace-item i ints (1 + item i ints)
  ]
  report ints
end
to-report floor-whole-adjusted-list [floats]
  let ints map [ int ? ] floats
  repeat ((round sum-list floats) - sum-list ints) [
    let i rand-weighted-index floats
    set ints replace-item i ints (1 + item i ints)
  ]
  report ints
end

to-report rand-weighted-list [floats]
  let ints n-values length floats [0]
  repeat (round sum-list floats) [
    let i rand-weighted-index floats
    set ints replace-item i ints (1 + item i ints)
  ]
  report ints
end
to-report round-adjusted-list [floats]
  let n round sum-list floats
  let ints map [round ?] floats
  let inum sum-list ints
  let delta ifelse-value (inum < n) [1][-1]
  repeat abs (n - inum) [
    let i rand-weighted-index floats
    set ints replace-item i ints (delta + item i ints)
  ]
  report ints
end


;;;;  Player turtle procs
to play
  set ticks ticks + 1
  next
  ask partner [next]

  let payoff item (coop?-of partner) (item coop? payoffmat)
  let myscore item 0 payoff
  let itscore item 1 payoff

  set score score + myscore
  ask partner [set score score + itscore]

  ifelse (stay?) * (stay?-of partner) = 0 [
    ask partner [set partner nobody]
    set partner nobody
  ] [
    ask partner [set history fput coop?-of partner history]
    set history fput coop?-of partner history
  ]
end
to next
  let strat name-of strategy
  ifelse strat = "Nice"    [Nice]    [
  ifelse strat = "Nasty"   [Nasty]   [
  ifelse strat = "Tit4Tat" [Tit4Tat] [
  ifelse strat = "Moth"    [Moth]    [
  ifelse strat = "Hit&Run" [Hit&Run] [
  ifelse strat = "Santa"   [Santa]   [
  ifelse strat = "NasMoth" [NasMoth] [
  ifelse strat = "NNHRun"  [NNHRun]  [
  output-show (word "Oops: Bad strategy name " ) stop
  ]]]]]]]]
end
to Nice
  set coop? 1 set stay? 1
end
to Nasty
  set coop? 0 set stay? 1
end
to Tit4Tat
  set coop? ifelse-value (length history = 0) [1] [first history]
  set stay? 1
end
to Moth
  set coop? ifelse-value (length history = 0) [1] [first history]
  set stay? coop?
end
to Hit&Run
  set coop? 0 set stay? 0
end
to Santa
  set coop? 1 set stay? 0
end
to NasMoth
  set coop? ifelse-value (length history = 0) [0] [first history]
  set stay? ifelse-value (length history = 0) [1] [first history]
end
to NNHRun
  set coop? ifelse-value (length history < 2) [1] [0]
  set stay? ifelse-value (length history = 0) [1] [first history]
end

; Not needed for model: run from command center for parameter scans
to paramscan
  let ranges [0 1 3 5]
  clear-output
  output-print (word "playoff scan: ranges = " ranges)
  print-stats-header
  foreach ranges [ set CC ?
  foreach ranges [ set CD ?
  foreach ranges [ set DC ?
  foreach ranges [ set DD ?
;    if not (CC = CD and CD = DC and DC = DD)
;      [show (list CC CD DC DD) scan]
    show (list CC CD DC DD) scan
  ] ] ] ]
end
to pdscan
  let ranges [0 1 2 3 4 5 6 7 8 9 10]
  clear-output
  output-print (word "PD scan: ranges = " ranges)
  print-stats-header
  foreach ranges [ set CC ?
  foreach ranges [ set CD ?
  foreach ranges [ set DC ?
  foreach ranges [ set DD ?
    if DC > CC and CC > DD and DD > CD and 2 * CC > DC + CD
      [show (list CC CD DC DD) scan]
  ] ] ] ]
end
@#$#@#$#@
GRAPHICS-WINDOW
309
10
539
261
5
5
20.0
1
10
1
1
1
0

CC-WINDOW
5
661
687
756
Command Center

SLIDER
546
369
671
402
gamesPerMatch
gamesPerMatch
1
40
20
1
1
NIL

BUTTON
79
19
134
52
go
go
T
1
T
OBSERVER
NIL
NIL

SLIDER
546
401
671
434
matchesPerSim
matchesPerSim
5
50
30
5
1
NIL

BUTTON
16
19
71
52
NIL
setup
NIL
1
T
OBSERVER
T
NIL

MONITOR
249
10
306
59
NIL
games
0
1

PLOT
5
265
539
486
Population
Match
Number
0.0
10.0
0.0
10.0
true
true
PENS
"Nice" 1.0 0 -11352576 true
"Nasty" 1.0 0 -16777216 true
"Tit4Tat" 1.0 0 -7566196 true
"Moth" 1.0 0 -16776961 true
"Hit&Run" 1.0 0 -256 true
"Santa" 1.0 0 -65536 true
"NasMoth" 1.0 0 -8716033 true
"NNHRun" 1.0 0 -16711681 true

MONITOR
249
57
306
106
NIL
matches
3
1

MONITOR
249
105
306
154
NIL
ticks
0
1

SLIDER
13
70
105
103
CC
CC
-50
50
3
1
1
NIL

SLIDER
105
70
197
103
CD
CD
-50
50
0
1
1
NIL

SLIDER
13
102
105
135
DC
DC
-50
50
5
1
1
NIL

SLIDER
105
102
197
135
DD
DD
-50
50
1
1
1
NIL

BUTTON
13
135
76
168
PD
set CC 3\nset DD 1\nset CD 0\nset DC 5
NIL
1
T
OBSERVER
T
NIL

BUTTON
137
135
197
168
AG
set CC 3\nset DD 0\nset CD -2\nset DC 5
NIL
1
T
OBSERVER
T
NIL

BUTTON
76
135
138
168
+AG
set CC 5\nset DD 2\nset CD 0\nset DC 7
NIL
1
T
OBSERVER
T
NIL

SLIDER
545
10
654
43
numNice
numNice
0
50
10
1
1
NIL

SLIDER
545
43
654
76
numNasty
numNasty
0
50
10
1
1
NIL

SLIDER
545
76
654
109
numTit4Tat
numTit4Tat
0
50
10
1
1
NIL

SLIDER
545
108
654
141
numMoth
numMoth
0
50
10
1
1
NIL

SLIDER
545
141
654
174
numHit&Run
numHit&Run
0
50
10
1
1
NIL

SLIDER
545
173
654
206
numSanta
numSanta
0
50
10
1
1
NIL

SLIDER
545
205
654
238
numNasMoth
numNasMoth
0
50
10
1
1
NIL

SLIDER
545
237
654
270
numNNHRun
numNNHRun
0
50
10
1
1
NIL

SLIDER
545
294
654
327
setAll
setAll
0
50
10
1
1
NIL

BUTTON
545
327
654
360
doit!
set numMoth setAll\nset numNNHRun setAll\nset numNasty setAll\nset numNice setAll\nset numHit&Run setAll\nset numSanta setAll\nset numNasMoth setAll\nset numTit4Tat setAll\n
NIL
1
T
OBSERVER
T
NIL

OUTPUT
6
488
678
647

BUTTON
141
19
196
52
print
print-stats
NIL
1
T
OBSERVER
T
NIL

BUTTON
159
189
214
222
reset
startup setup
NIL
1
T
OBSERVER
T
NIL

MONITOR
249
153
306
202
players
numplayers
3
1

BUTTON
12
189
67
222
scan
scan
NIL
1
T
OBSERVER
T
NIL

SLIDER
67
189
159
222
scanNum
scanNum
5
100
5
5
1
NIL

SWITCH
539
453
629
486
graph?
graph?
0
1
-1000

@#$#@#$#@
WHAT IS IT? 
----------- 

LogoMoth demonstrates that insofar as Iterated PD games have served as models to explain animal and human social behavior, they have limited our imaginations concerning the strategies used by social agents in choosing associates. Iterated PD games operate on the assumption that two players are "stuck" with one another throughout each match of a simulation; under that constraint, the strategy that has done famously well is Tit For Tat, a strategy that cooperates on the first game of the match and then imitates its opponent's previous move in every subsequent game of the match. The success of of Tit for Tat in PD games has made it the model for hundreds of explanations of "reciprocity" in animal and human social relations. 

This focus on Tit for Tat reciprocity as a key to animal sociality may be inappropriatte. The structure of the Axelrod game constrains the players to remain paired, even in non-productive partnership. This constraint is highly un-natural in animal (and human) social systems where individuals typically break off relationships if a partnership is not productive. In mapping Tit for Tat reciprocity on to natural social systems, theorists have implicitly recognised this artificiality in the tournament structure when they have interpreted Tit for Tat as requiring a considerable level of cognitive complexity: instead of being bound to one another as the tournament structure demands, partners must recognise one another and remember what they did on the previous occasion. (ref) A simpler ... and therefore more universal... basis for social clustering would be one in which social agents are programmed to attach themselves to agents who have benefitted them in some way. In the language of the PD literature, such an agent would respond to defection by breaking up a partnership and looking for another partner amongst other unattached agents. Far from requiring recognition, such a strategy would require only very simple operant conditioning at most. We call this strategy, "Myway Or The Highway", or simply MOTH. (Not a great name, but I am afraid it has stuck.) 


HOW IT WORKS 
------------ 

A LogoMoth simulation starts by assigning N agents, each playing one of eight strategies, to partnerships to play a series of PD games called a "Match". According to their strategies, LogoMoth agents make two sorts of decisions: whether to cooperate with a partner and whether to continue to play with a particular partner in the next game of the match. Either member of a partnership can desolve it and both players then return to the pool of unpartnered players. Strategies can be conditional or non-conditional in that an agent may or may not use the behavior of its partner on the previous round to decide what to do on the next. The eight strategies are as follows: 

Nice Always cooperates; doesn't leave. This is Axelrod, ALLC 

Nasty Always defects; doesn't leave. This is Axelrod, ALLD 
Tit4Tat Cooperates first; plays as partner did previously; doesn't leave. Cf Axelrod 

Moth Cooperates until partner defects, then leaves. 

Hit&Run Defects in every game, then leaves. 

Santa Cooperates in every game, then leaves. 

NasMoth Always defects; but leaves only when partner defects. 

NNHnRun Defects twice; leaves immediately if partner defects on the first game; leaves unconditionally after the second game. 

The first three strategy will be familiar to any reader of Axelrod and Hamilton's Evolution of Cooperation. The second five are all strategies that make use of leaving in some way. MOTH is the one that most closely resembles what we think animals are likely to do in most failed cooperation situations. The rest are chosen to exploit various perceived weaknesses of the other strategies, but are exhaustive only in the sense that these are the ones we could quickly think of. One of our goals in getting LogoMoth into circulation, is to encourage others to think of better challanges to MOTH. 

LogoMoth is an evolutionary program, i.e., it is designed to simulate the Darwinian competition between organisms seeking to out-reproduce one another in a population whose numbers are arbitrarily limited to some number, P, for each simulation. Consequently, at the end of each match of N games, the number of points scored by the players of each strategy is summed, divided by the number of players of that strategy, and players are allocated to the strategies in the next match in proportion to the average winnings of individual players playing that strategy in the previous one. Between matches, the population number (i.e., the total number of players in the match) is always returned to the starting number. To provide representation proportional to success, the proportion of the average winnings of a player of each strategy to the total average winnings of all players of all strategies is multiplied by the fixed total number of players to find out how many players will be assigned to each strategy in the subsequent match. 

For each round of games, the formula for the average score (S) of players playing strategy i would be SumSi/Pi.where Sum Si is the total score accued by the Pi players of the i-th strategy. 

The formula for the number of players playing the i-th strategy in the next round would be SumSi/Pi x P, where P = sum Pi for all values of i. Since these multiplications rarely produced integer results, and since the population was always capped at P for each match, remainders were inevitable and had to be distributed as addional players to some of the strategies and not to others. 

This was one of the details in which the devil was found. By the time we had gotten done thinking about this distribution process, we had come up with five different methods for making it. Only two were kept. One method privileged the most sucessful strategies. We simply assigned the extra players so that those strategies with the best records in the previous match were most likely to receive the extra players. The other method privileged the strategies with the largest remainders: we assigned the extra players so that those strategies with the largest remainders in the previous match were most likely to recieve the extra players. Readers interested in the other methods we considered are encouraged to contact Owen Densmore as Owen@backspaces.net for details. 


HOW TO USE IT 
------------- 


LogoMoth is a research program to designed to accomodate many sorts of curiosity about the relation between the idea of conditional altruism and the idea of conditional leaving. You can manipulate many features of the game, the players, the matches, and the simulation AND you can save your experiments using NetLogo's behavior space. 

As in the standard prisonner's dilemma game, LogoMoth is based on the idea that two players play against one another for payoffs which depend on what the two players do. Their two choices are to cooperate (C) or defect (D)-- in some worlds, to be an altruist or selfish. This conceptualization produces four cells, which for simplicity sake, we will always identify here in their "reading" order: i.e., Top Left (Cc), Top Right (Cd) , Bottow Left (Dc), and Bottom right (Dd). The payoffs in each cell always represent the payoff to the left marginal player, playing one of two strategies, against the top marginal player, playing the same two strategies. Thus, the standard Prisonners' Dilemma game, in which a cooperator receives 3 playing against another cooperator, 0 playing against a defector, while a defector receives 5 playing against a defector and 1 playing agaisnt another defector, will be represented here as a 3,0,5,1 game. 

Each combination of cell payoffs yields a different game-type, and the possibilities are, of course, infinite. Although you can choose any combination of payoffs you like, LogoMoth features three particular examples. One is the standard PD game, 3,0,5,1. PD games, by definition are those whose payoffs follow the rules, Dc>Cc>Dd>Cd and 2Cc > Cd + Dc Another game of interest to us, we call the altruist game in which the payoffs must be consistent with b-c, -c, b, 0, where b>c>0. Some altruists games meet the criteria for PD games, 3, -2, 0, 5, for instance, and LogoMoth features this choice as well. But a PD game need not be an altruist game. For modeling purposes, minus numbers supply additional conceptual devils, and so we offer what we call a AG+ game, in which a constant has been added to each cell to dispense with negative numbers: 5, 0, 7, 2. The AG+ game is a PD game, but it is not strictly speaking an altruist game. However, the differences between the payoffs of the 4 cells is preserved, and we have found no computation that we are in the habit of performing with AG games that is affected by the difference. 

You may choose any combination of strategies by "zeroing out" strategies that DONT interest you. Using the same sliders, you can also test whether a strategy is robust against invasion by giving it many players and introducing the other stategies, one by one, with small numbers of players. Or you an see which strategy is a good invader by holding the the numbers of players of other strategies at maximum and introducing small numbers of different invaders, one by one. 

Finally, you can evaluate the impact of the number of games in a match and the number of matches in a simulation by moving the sliders provided. 

THINGS TO NOTICE 
---------------- 


Notice first whether the model replicates the tradional Axelrod results. Reassurance on this point can be sought by zeroing out those strategies that were not in the original AXelrod Tournament. As as been reported repeatedly in the PD literature, Tit for Tat in LogoMoth is a robust competitor, although it sometimes fails against Nice and Nasty. 

Then check out MOTH's ability as a competitor. Look first at how well moth does againsts TfT's original competitors. The short answer is "better", It wins more often than TFT, and it usually wins quicker. Now take a look at Moth's competition against all three Axselrod strategies, Nice, Nasty, and TfT. You will find that as long as matches are reasonably long, MOTH always predominates in simulations containing all of the other Axelrod strategies. If matches are short ... less than 10 games per match ..... the result begins to be much more unpredictable. Finally examine how MOTH does against all 7 other strategies. Once again, if matches are reasonably long it almost always predominates. However it rarely excludes all other competitors. A typical result is that MOTH and either Nice or TfT are left standing at the end of the simulation. 

Another fascinating project is locating tipping points, A match size of 7 seems to be an important tipping point. We also think that important tipping points will be found in changes in the payoff matrix 

CREDITS AND REFERENCES 
---------------------- 

LogoMoth is a "docking" of an earler java program (The Battle Applet), one of a series of applications of the MOTH idea that were created by David Joyce of Clark University's Math and Computer Science. Readers who found LogoMoth interesting are strongly encouraged to have a look at the whole series of applets, which may be found at:

http://aleph0.clarku.edu/~djoyce/Moth/

We also owe a tremendous debt of thanks to the members of the Santa Fe Applied Complexity Group (“FRIAM”), in particular to Carl Tollander and Frank Wimberly. 

• David Joyce and John Kennison 
– Department of Mathematics and Computer Sciences 
– Clark University, 
– Worcester MA 01610 
– Djoyce or jkennison, @clarku.edu 

• Owen Densmore* and Stephen Guerin* 
– Redfish Group and Friam Applied Complexity Group 
– 843 Agua Fria Road. 
– Santa Fe, NM, 87501 
– Owen or Stephen, @ redfish.com 

• Nick Thompson* 
– Program in Social, Evolutionary, and Cultural Psychology, 
– Departments of Biology and Psychology 
– Clark University, 
– Worcester MA, 01610. 
– nthompson@clarku.edu 
@#$#@#$#@
default
true
0
Polygon -7566196 true true 150 5 40 250 150 205 260 250

airplane
true
0
Polygon -7566196 true true 150 0 135 15 120 60 120 105 15 165 15 195 120 180 135 240 105 270 120 285 150 270 180 285 210 270 165 240 180 180 285 195 285 165 180 105 180 60 165 15

arrow
true
0
Polygon -7566196 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
false
0
Polygon -7566196 true true 150 285 285 225 285 75 150 135
Polygon -7566196 true true 150 135 15 75 150 15 285 75
Polygon -7566196 true true 15 75 15 225 150 285 150 135
Line -16777216 false 150 285 150 135
Line -16777216 false 150 135 15 75
Line -16777216 false 150 135 285 75

bug
true
0
Circle -7566196 true true 96 182 108
Circle -7566196 true true 110 127 80
Circle -7566196 true true 110 75 80
Line -7566196 true 150 100 80 30
Line -7566196 true 150 100 220 30

butterfly
true
0
Polygon -7566196 true true 150 165 209 199 225 225 225 255 195 270 165 255 150 240
Polygon -7566196 true true 150 165 89 198 75 225 75 255 105 270 135 255 150 240
Polygon -7566196 true true 139 148 100 105 55 90 25 90 10 105 10 135 25 180 40 195 85 194 139 163
Polygon -7566196 true true 162 150 200 105 245 90 275 90 290 105 290 135 275 180 260 195 215 195 162 165
Polygon -16777216 true false 150 255 135 225 120 150 135 120 150 105 165 120 180 150 165 225
Circle -16777216 true false 135 90 30
Line -16777216 false 150 105 195 60
Line -16777216 false 150 105 105 60

car
false
0
Polygon -7566196 true true 300 180 279 164 261 144 240 135 226 132 213 106 203 84 185 63 159 50 135 50 75 60 0 150 0 165 0 225 300 225 300 180
Circle -16777216 true false 180 180 90
Circle -16777216 true false 30 180 90
Polygon -16777216 true false 162 80 132 78 134 135 209 135 194 105 189 96 180 89
Circle -7566196 true true 47 195 58
Circle -7566196 true true 195 195 58

circle
false
0
Circle -7566196 true true 30 30 240

circle 2
false
0
Circle -7566196 true true 16 16 270
Circle -16777216 true false 46 46 210

cow
false
0
Polygon -7566196 true true 200 193 197 249 179 249 177 196 166 187 140 189 93 191 78 179 72 211 49 209 48 181 37 149 25 120 25 89 45 72 103 84 179 75 198 76 252 64 272 81 293 103 285 121 255 121 242 118 224 167
Polygon -7566196 true true 73 210 86 251 62 249 48 208
Polygon -7566196 true true 25 114 16 195 9 204 23 213 25 200 39 123

face happy
false
0
Circle -7566196 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 255 90 239 62 213 47 191 67 179 90 203 109 218 150 225 192 218 210 203 227 181 251 194 236 217 212 240

face neutral
false
0
Circle -7566196 true true 8 7 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Rectangle -16777216 true false 60 195 240 225

face sad
false
0
Circle -7566196 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 168 90 184 62 210 47 232 67 244 90 220 109 205 150 198 192 205 210 220 227 242 251 229 236 206 212 183

fish
false
0
Polygon -1 true false 44 131 21 87 15 86 0 120 15 150 0 180 13 214 20 212 45 166
Polygon -1 true false 135 195 119 235 95 218 76 210 46 204 60 165
Polygon -1 true false 75 45 83 77 71 103 86 114 166 78 135 60
Polygon -7566196 true true 30 136 151 77 226 81 280 119 292 146 292 160 287 170 270 195 195 210 151 212 30 166
Circle -16777216 true false 215 106 30

flag
false
0
Rectangle -7566196 true true 60 15 75 300
Polygon -7566196 true true 90 150 270 90 90 30
Line -7566196 true 75 135 90 135
Line -7566196 true 75 45 90 45

flower
false
0
Polygon -11352576 true false 135 120 165 165 180 210 180 240 150 300 165 300 195 240 195 195 165 135
Circle -7566196 true true 85 132 38
Circle -7566196 true true 130 147 38
Circle -7566196 true true 192 85 38
Circle -7566196 true true 85 40 38
Circle -7566196 true true 177 40 38
Circle -7566196 true true 177 132 38
Circle -7566196 true true 70 85 38
Circle -7566196 true true 130 25 38
Circle -7566196 true true 96 51 108
Circle -16777216 true false 113 68 74
Polygon -11352576 true false 189 233 219 188 249 173 279 188 234 218
Polygon -11352576 true false 180 255 150 210 105 210 75 240 135 240

house
false
0
Rectangle -7566196 true true 45 120 255 285
Rectangle -16777216 true false 120 210 180 285
Polygon -7566196 true true 15 120 150 15 285 120
Line -16777216 false 30 120 270 120

leaf
false
0
Polygon -7566196 true true 150 210 135 195 120 210 60 210 30 195 60 180 60 165 15 135 30 120 15 105 40 104 45 90 60 90 90 105 105 120 120 120 105 60 120 60 135 30 150 15 165 30 180 60 195 60 180 120 195 120 210 105 240 90 255 90 263 104 285 105 270 120 285 135 240 165 240 180 270 195 240 210 180 210 165 195
Polygon -7566196 true true 135 195 135 240 120 255 105 255 105 285 135 285 165 240 165 195

line
true
0
Line -7566196 true 150 0 150 300

pentagon
false
0
Polygon -7566196 true true 150 15 15 120 60 285 240 285 285 120

person
false
0
Circle -7566196 true true 110 5 80
Polygon -7566196 true true 105 90 120 195 90 285 105 300 135 300 150 225 165 300 195 300 210 285 180 195 195 90
Rectangle -7566196 true true 127 79 172 94
Polygon -7566196 true true 195 90 240 150 225 180 165 105
Polygon -7566196 true true 105 90 60 150 75 180 135 105

plant
false
0
Rectangle -7566196 true true 135 90 165 300
Polygon -7566196 true true 135 255 90 210 45 195 75 255 135 285
Polygon -7566196 true true 165 255 210 210 255 195 225 255 165 285
Polygon -7566196 true true 135 180 90 135 45 120 75 180 135 210
Polygon -7566196 true true 165 180 165 210 225 180 255 120 210 135
Polygon -7566196 true true 135 105 90 60 45 45 75 105 135 135
Polygon -7566196 true true 165 105 165 135 225 105 255 45 210 60
Polygon -7566196 true true 135 90 120 45 150 15 180 45 165 90

square
false
0
Rectangle -7566196 true true 30 30 270 270

square 2
false
0
Rectangle -7566196 true true 30 30 270 270
Rectangle -16777216 true false 60 60 240 240

star
false
0
Polygon -7566196 true true 60 270 150 0 240 270 15 105 285 105
Polygon -7566196 true true 75 120 105 210 195 210 225 120 150 75

target
false
0
Circle -7566196 true true 0 0 300
Circle -16777216 true false 30 30 240
Circle -7566196 true true 60 60 180
Circle -16777216 true false 90 90 120
Circle -7566196 true true 120 120 60

tree
false
0
Circle -7566196 true true 118 3 94
Rectangle -6524078 true false 120 195 180 300
Circle -7566196 true true 65 21 108
Circle -7566196 true true 116 41 127
Circle -7566196 true true 45 90 120
Circle -7566196 true true 104 74 152

triangle
false
0
Polygon -7566196 true true 150 30 15 255 285 255

triangle 2
false
0
Polygon -7566196 true true 150 30 15 255 285 255
Polygon -16777216 true false 151 99 225 223 75 224

truck
false
0
Rectangle -7566196 true true 4 45 195 187
Polygon -7566196 true true 296 193 296 150 259 134 244 104 208 104 207 194
Rectangle -1 true false 195 60 195 105
Polygon -16777216 true false 238 112 252 141 219 141 218 112
Circle -16777216 true false 234 174 42
Rectangle -7566196 true true 181 185 214 194
Circle -16777216 true false 144 174 42
Circle -16777216 true false 24 174 42
Circle -7566196 false true 24 174 42
Circle -7566196 false true 144 174 42
Circle -7566196 false true 234 174 42

turtle
true
0
Polygon -11352576 true false 215 204 240 233 246 254 228 266 215 252 193 210
Polygon -11352576 true false 195 90 225 75 245 75 260 89 269 108 261 124 240 105 225 105 210 105
Polygon -11352576 true false 105 90 75 75 55 75 40 89 31 108 39 124 60 105 75 105 90 105
Polygon -11352576 true false 132 85 134 64 107 51 108 17 150 2 192 18 192 52 169 65 172 87
Polygon -11352576 true false 85 204 60 233 54 254 72 266 85 252 107 210
Polygon -7566196 true true 119 75 179 75 209 101 224 135 220 225 175 261 128 261 81 224 74 135 88 99

wheel
false
0
Circle -7566196 true true 3 3 294
Circle -16777216 true false 30 30 240
Line -7566196 true 150 285 150 15
Line -7566196 true 15 150 285 150
Circle -7566196 true true 120 120 60
Line -7566196 true 216 40 79 269
Line -7566196 true 40 84 269 221
Line -7566196 true 40 216 269 79
Line -7566196 true 84 40 221 269

x
false
0
Polygon -7566196 true true 270 75 225 30 30 225 75 270
Polygon -7566196 true true 30 75 75 30 270 225 225 270

@#$#@#$#@
NetLogo 2.1.0
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@