Test for Jamal

;Test, references coming soon

; player types:
breed [defectors defector]          ; these guys always defect
breed [reciprocators reciprocator]  ; these guys use tit-for-tat
breed [cooperators cooperator]      ; these guys always cooperate
breed [impulsives impulsive]        ; these guys behave randomly
breed [gossipers gossiper]     ; these guys use a gossip tit for tat

; players attributes

turtles-own [
   score          ; sum of points in all games
   partner        ; nobody or current PD partner
   defect?    ; current move of self
   num-games      ; # games played by self
   app?
]

globals [

  turtlecount
  total-num-games ; total number of games played

  both-cooperate-points     ; points each player receives if both cooperate
  both-defect-points        ; points each player receives if both defect
  defect-reward             ; points defector receives if partner cooperates
  cooperate-penalty         ; points cooperator receives if partner defects

  average-cooperators      ; average score of all reciprocators
  average-defectors        ; average score of all customized agents
  average-impulsives        ; average score of all defectors
  average-reciprocators        ; average score of all cooperators
  average-gossipers         ; average score of all impulsives

  total-score-defectors
  total-games-defectors

  total-score-cooperators
  total-games-cooperators

  total-score-impulsives
  total-games-impulsives

  total-score-reciprocators
  total-games-reciprocators

  total-score-gossipers
  total-games-gossipers

  attention-distance
  attention-angle

]

reciprocators-own [
  memory
]

gossipers-own [
   memory
]
;;;;;;;;;;;;;;;;;;;;;;
;;;Setup Model;;;
;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  resize-world (world_size * -1)  world_size (world_size * -1) world_size
  init-globals
  create-agents
  init-patches
  init-turtles
  reset-ticks
end 

to init-patches
  ask patches [init-patch]
  ask patches [set pcolor 9.9]
end 

to create-agents
  create-defectors n-defectors
   create-cooperators n-cooperators
   create-reciprocators n-reciprocators
   create-impulsives n-impulsives
   create-gossipers n-gossipers
end 

to init-turtles

   ask turtles [init-turtle]

   ask defectors [init-defector]
   ask cooperators [init-cooperator]
   ask reciprocators [init-reciprocator]
   ask impulsives [init-impulsive]
   ask gossipers [init-gossiper]
   set turtlecount ( n-defectors + n-cooperators + n-impulsives + n-reciprocators + n-gossipers)
end 

to init-globals
   set total-num-games 0


   set both-cooperate-points cooperate-cooperate
   set both-defect-points defect-defect
   set defect-reward defect-cooperate
   set cooperate-penalty cooperate-defect

   set average-cooperators 0
   set average-defectors 0
   set average-impulsives 0
   set average-reciprocators 0
   set average-gossipers 0
end 

to init-patch
end 

to init-turtle
   set shape "person"
   setxy random-xcor random-ycor
   set score 0
   set num-games 0
   set partner nobody
   set app? false
   if (random-float 1) <= proportion [set app? true]
end 

to init-defector
   set color red
end 

to init-cooperator
   set color blue
end 

to init-impulsive
   set color yellow
end 

to init-reciprocator
   set color green
   set memory turtle-set no-turtles
end 

to init-gossiper
   set color cyan
   set memory turtle-set no-turtles
end 


;;;;updating model

to go

  update-globals
  update-patches
  update-turtles
  do-scoring
  tick
  if ticks mod n-rep = 0 [if cultural-evolution? = true [do-cultural-evolution]]
end 

to go-n
  repeat n-rep [go]
end 

to update-patches
   ask patches [update-patch]
end 

to update-turtles
   ask turtles [update-turtle]
end 

;update overridables

to update-globals
   ; To do: update values of globals.
end 

to update-patch
   ; To do: update patch attributes.
end 

to update-turtle

  find-partner
  if partner != nobody [

        move-to partner
        set total-num-games total-num-games + 1
        ask partner [ set partner myself ]

        ; cooperate or defect?
        set-defect?
        ask partner [ set-defect? ]

        ; calculate points
        let partner-defect? [defect?] of partner
        let my-points 0
        let partners-points 0
        ifelse defect? [
           ifelse partner-defect? [
              set my-points defect-defect
              set partners-points defect-defect
           ]
           [
              set my-points defect-cooperate
              set partners-points cooperate-defect
           ]
        ]
        [
           ifelse partner-defect? [
              set my-points cooperate-defect
              set partners-points defect-cooperate
           ]
           [
              set my-points cooperate-cooperate
              set partners-points cooperate-cooperate

           ]
        ]

        ; update memories
      if (breed = reciprocators) or (breed = gossipers)  [update-memory]

        ; update scores
        set score score + my-points
        set num-games num-games + 1
        ask partner [
           set score score + partners-points
           set num-games num-games + 1
       ]

        ; disengage
        ifelse partner-defect? [walk-away] [stick-around]
        ask partner [ set partner nobody ]
        set partner nobody

     ]
end 

to find-partner
 if partner = nobody [

     let candidates other turtles in-radius walk with [partner = nobody]
     set partner one-of candidates
     if partner = nobody [ifelse app?
                 [set partner one-of turtles with [partner = nobody]]
                 [walk-around]
    ]
  ]
end 

to walk-around
  set heading random 360 fd (walk)
end 

to walk-away
  rt 180 fd (walk * 2)
end 

to stick-around
  set heading random 360 fd (walk / group-attachment)
end 
;=============================
; Deciding to cooperate or defect
;=============================

to set-defect?

  if breed = defectors [
      set defect? true
      stop
   ]
   if breed = cooperators [
      set defect? false
      stop
   ]
   if breed = impulsives [
      let random-bool (random 2) = 1
      set defect? random-bool
      stop
   ]
   if breed = reciprocators [
      set-reciprocator-cooperated?
   stop
   ]
   if breed = gossipers [
      set-gossiper-cooperated?
     stop
   ]
end 

to set-reciprocator-cooperated?
  ifelse member? partner memory [set defect? true][set defect? false]
end 

to set-gossiper-cooperated?
  ifelse member? partner memory [set defect? true][set defect? false]
end 

;=====================
; Updating memories of reciprocators and customized
;=====================

to update-memory


  if (breed = defectors) or (breed = impulsives) or (breed = cooperators) [stop]

 let partner-defect? [defect?] of partner

   if (breed = reciprocators) and (partner-defect? = true) and (member? partner memory = false) and not memory-full?
       [set memory (turtle-set memory partner)]

   if (breed = gossipers) and (partner-defect? = true) and (member? partner memory = false) and not memory-full?
       [set memory (turtle-set memory partner)]
   if (breed = gossipers) and ([breed] of partner = gossipers) and not memory-full?
       [let new-memories other [memory] of partner
        set memory (turtle-set memory new-memories)]
end 

to-report memory-full?
  ifelse count memory > memory-limit [report true] [report false]
end 

;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;

;;calculate the total scores of each strategy

to do-scoring

  set total-score-defectors sum [score] of defectors
  set total-games-defectors sum [num-games] of defectors
   if (count defectors) > 0 [set average-defectors (total-score-defectors / total-games-defectors)]

 set  total-score-cooperators sum [score] of cooperators
  set total-games-cooperators sum [num-games] of cooperators
    if (count cooperators) > 0 [set average-cooperators (total-score-cooperators / total-games-cooperators)]

 set  total-score-impulsives sum [score] of impulsives
  set total-games-impulsives sum [num-games] of impulsives
      if (count impulsives) > 0 [set average-impulsives (total-score-impulsives / total-games-impulsives)]

  set total-score-reciprocators sum [score] of reciprocators
  set total-games-reciprocators sum [num-games] of reciprocators
        if (count reciprocators) > 0 [set average-reciprocators (total-score-reciprocators / total-games-reciprocators)]

 set total-score-gossipers sum [score] of gossipers
  set total-games-gossipers sum [num-games] of gossipers
          if (count gossipers) > 0 [set average-gossipers (total-score-gossipers / total-games-gossipers)]
end 

;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;

to do-cultural-evolution


let mn mean [score] of turtles
let sd standard-deviation [score] of turtles

 ask turtles [ if score >= mn + sd[
      ;; Most successful individuals have 2 offspring
      hatch 2 [
        set score 0
        set num-games 0
        set partner nobody
        if (breed = reciprocators) or (breed = gossipers) [set memory turtle-set no-turtles]
        set app? false
        if (random-float 1) <= proportion [set app? true]
        ]
    ]
    if (score >= mn - sd) and (score < mn + sd) [
      ;; Mean individuals have just one
      hatch 1 [
        set score 0
        set num-games 0
        set partner nobody
        if (breed = reciprocators) or (breed = gossipers) [set memory turtle-set no-turtles]
        set app? false
        if (random-float 1) <= proportion [set app? true]
        ]
      ]
    die
  ]




let difft turtlecount - count turtles

  if turtlecount < (count turtles) [ask n-of (difft * -1) turtles [die]]
end 

;;;;;;;;;;;;;;

;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;
;Reporter



;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;;;
;;;;;;;;;;;