Conditional Defection in the Commons (Pay to escape) — from the Modeling Commons

turtles-own [
  harvestPref
  harvest-amount
  punisher?
  escaper?
  aware-of-who
  energy
  harvest
  punished?
  escape-attempts
  escaped-this-round?
  detected-this-round?
]

patches-own [ resource ]

globals [
  commons
  commonsResources
  total-escape-attempts
  total-successful-escapes
  round-escape-energy-wasted
  interference-level
]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SETUP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  set total-escape-attempts 0
  set total-successful-escapes 0
  set round-escape-energy-wasted 0
  set interference-level 0

  ask n-of Number-Agents patches [
    sprout 1 [
      set shape "circle"
      set size 0.8
      set punished? false
      set aware-of-who turtle-set nobody
      set escape-attempts 0
      set escaped-this-round? false
      set detected-this-round? false
      set harvest 0

      ifelse random-float 100 < Percent-Sustainables [
        set harvestPref "low"
        set harvest-amount Harvest-sustainable
      ] [
        set harvestPref "high"
        set harvest-amount Harvest-greedy
      ]

      ifelse random-float 100 < Percent-Punishers and harvestPref = "low"
        [ set punisher? true ]
        [ set punisher? false ]

      ifelse harvestPref = "high" [
        set escaper? true
      ] [
        set escaper? false
      ]

      set energy Living-costs + 1
      update-color
    ]
  ]

  ask patches [
    set resource Carrying-capacity
    set pcolor scale-color brown resource 0 (Carrying-capacity + 30)
  ]

  reset-ticks
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; GO
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
  if count turtles = 0 [ stop ]

  set round-escape-energy-wasted 0
  ask turtles [
    set escaped-this-round? false
    set detected-this-round? false
    set harvest 0
  ]

  ask turtles [ harvesting ]

  ask turtles with [punisher?] [
    set aware-of-who turtle-set nobody
  ]

  escape-behavior
  update-interference
  sense-cheaters

  ask turtles with [ escaped-this-round? and not detected-this-round? ] [
    set total-successful-escapes total-successful-escapes + 1
  ]

  punish

  ask turtles [
    set energy energy + harvest
    expend-energy
    reproduce
    death
  ]

  ask patches [
    regrow
    recolor
  ]

  tick
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ESCAPE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to escape-behavior
  ask turtles with [ harvestPref = "high" and escaper? ] [
    if energy > Costs-escape [
      let potential-punishers turtles in-radius 2 with [ punisher? ]
      if any? potential-punishers [
        set energy energy - Costs-escape
        set round-escape-energy-wasted round-escape-energy-wasted + Costs-escape
        set escape-attempts escape-attempts + 1
        set escaped-this-round? true
        set total-escape-attempts total-escape-attempts + 1
      ]
    ]
  ]
end 

to update-interference
  ifelse round-escape-energy-wasted > 0 [
    ifelse interference-scale > 0 [
      set interference-level round-escape-energy-wasted * interference-scale
      if interference-level < 0 [ set interference-level 0 ]
      if interference-level > 1 [ set interference-level 1 ]
    ] [
      set interference-level 0
    ]
  ] [
    set interference-level 0
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; HARVESTING
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to harvesting
  ifelse Punishment = "suspend harvest once" and punished?
    [ set harvest 0 ]
    [ harvest-commons ]

  set punished? false
end 

to harvest-commons
  set commons (patch-set neighbors patch-here)
  set commonsResources sum [resource] of commons
  let commonsList sort-on [(- resource)] commons

  ifelse commonsResources < harvest-amount [
    set harvest commonsResources
    ask commons [ set resource 0 ]
    move-away
  ] [
    let remaining-need harvest-amount
    foreach commonsList [ the-patch ->
      if remaining-need > 0 [
        let available [resource] of the-patch
        ifelse available <= remaining-need [
          set harvest harvest + available
          set remaining-need remaining-need - available
          ask the-patch [ set resource 0 ]
        ] [
          set harvest harvest + remaining-need
          ask the-patch [ set resource resource - remaining-need ]
          set remaining-need 0
        ]
      ]
    ]
  ]
end 

to move-away
  let next-patch max-one-of (neighbors with [ not any? turtles-here ]) [resource]
  if next-patch != nobody [
    move-to next-patch
    set energy energy - 1
  ]
end 

to sense-cheaters
  ask turtles with [punisher?] [
    set harvest harvest - Costs-perception

    let cheaters turtles in-radius 2 with [harvestPref = "high"]
    let base-accuracy Perception-accuracy
    let effective-accuracy base-accuracy * (1 - interference-level)
    if effective-accuracy < 0 [ set effective-accuracy 0 ]
    if effective-accuracy > 100 [ set effective-accuracy 100 ]
    let detected []
    foreach sort cheaters [ c ->
      if random-float 100 < effective-accuracy [
        set detected lput c detected
        ask c [ set detected-this-round? true ]
      ]
    ]

    set aware-of-who detected
  ]
end 

to punish
  ask turtles with [ harvestPref = "high" and punished? = false] [
    let punishers (turtles-on neighbors) with [ member? myself [aware-of-who] of self]
    if any? punishers [
      set punished? true
      if Punishment = "kill" [ die ]
      if Punishment = "pay fine" [
        set harvest harvest - Fine
        set punished? false
        ask turtles-on neighbors [
          set harvest harvest + (Fine / (count turtles-on neighbors))
        ]
      ]
      ask punishers [
        set harvest harvest - (Costs-punishment / count punishers)
      ]
    ]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LIFE CYCLE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to expend-energy
  set energy energy - Living-costs
end 

to reproduce
  let birthrate 0.001 * energy
  if random-float 1 < birthrate [
    let destination one-of neighbors with [ not any? turtles-here ]
    if destination != nobody [
      hatch 1 [
        move-to destination
        set punished? false
        set aware-of-who turtle-set nobody
        set escape-attempts 0
        set escaped-this-round? false
        set detected-this-round? false
        set harvest 0
        mutate
        set energy ([energy] of myself / 2)
      ]
      set energy (energy / 2)
    ]
  ]
end 

to mutate
  if random-float 100 < Mutation-rate [
    ifelse harvestPref = "high" [
      set harvestPref "low"
      set escaper? false
      set harvest-amount Harvest-sustainable
    ] [
      set harvestPref "high"
      set harvest-amount Harvest-greedy
    ]
  ]

  if random-float 100 < Mutation-rate and harvestPref = "low" [
    set punisher? not punisher?
  ]

  ifelse harvestPref = "high" [
    set punisher? false
    set escaper? true
  ] [
    set escaper? false
  ]

  update-color
end 

to update-color
  ifelse harvestPref = "low" [
    ifelse punisher?
      [ set color green ]
      [ set color turquoise ]
  ] [

    set color red
  ]
end 

to death
  if energy <= 0 [ die ]
  if random-float 100 < Death-rate [ die ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; RESOURCES
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to regrow
  ifelse resource > 0 [
    let growth-amount (Growth-rate * resource) * (1 - (resource / Carrying-capacity))
    set resource resource + growth-amount
    if resource > Carrying-capacity [ set resource Carrying-capacity ]
  ] [
    set resource 0.1
  ]
end 

to recolor
  set pcolor scale-color brown resource 0 (Carrying-capacity + 30)
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; REPORTERS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to-report escape-success-rate
  if total-escape-attempts <= 0 [ report 0 ]
  report (100 * total-successful-escapes) / total-escape-attempts
end 

to-report current-interference-level
  report interference-level * 100
end 

to-report current-effective-accuracy
  report Perception-accuracy * (1 - interference-level)
end 

to-report round-escape-payments
  report round-escape-energy-wasted
end 

to-report detection-rate
  let detectable-cheaters turtles with [harvestPref = "high" and not escaped-this-round?]
  if not any? detectable-cheaters [ report 0 ]
  let detected count turtles with [harvestPref = "high" and detected-this-round?]
  report (100 * detected) / count detectable-cheaters
end