Bug Hunters Competition

globals
[
  ;; global variables related to color
  bugs-color
  grass-color
  dirt-color
  invasive-color
  not-grown-back-color

  ;; global variables related to bugs
  bugs-size             ;; the shape size for a bug
  bugs-stride           ;; how much a bug moves at every tick
  bugs-reproduce-energy ;; energy at which bugs reproduce
  min-energy-of-any-bug ;; energy of the bug with the lowest energy in the population
  max-energy-of-any-bug ;; energy of the bug with the maximum energy in the population
  dead-bugs             ;; keeps count of the number of bugs that have died in a model run
  offspring-bugs        ;; keeps count of the number of bugs  reproduced by automated bugs
  bugs-energy-from-food ;; energy that the bug eat from the food (the grass) each tick
                        ;; set to 4 in this model, but is adjustable in other Bug Hunt models (such as Bug Hunt Consumers).

  ;; global variables related to grass
  max-grass-energy      ;; the most amount of grass that can grow in a single patch (determined by a max. energy threshold)
  grass-growth-rate     ;; set to 1 in this model, but is adjustable in other Bug Hunt models (such as Bug Hunt Consumers).
  competition-status    ;; updates users with a message about the status of the competition

  ;; global variables related to time and histogram
  time-remaining        ;; time left for the competition to end
  x-min-histogram
  x-max-histogram
  x-interval-histogram

  old-player-vision
]

breed [ bugs bug ]
breed [ players player ]

bugs-own    [destination-patch controlled-by-player? owned-by energy]
players-own [destination-patch user-id dead?]

patches-own [
  fertile?              ;; whether or not a grass patch is fertile is determined by the amount-grassland slider
  grass-energy          ;; energy for grass
  countdown
  ]

to startup ;; setting up hubnet
  hubnet-set-client-interface "COMPUTER" []
  hubnet-reset
  setup
end 

to setup
  ask bugs [die]
  clear-all-plots

  ;; time variables
  set time-remaining 0


  ;; variables for the histogram
  set x-min-histogram 0
  set x-max-histogram 0
  set x-interval-histogram 0

  set old-player-vision 0

  ;; variables for grass
  set max-grass-energy 100
  set grass-growth-rate 1     ;; set to 1 by default in this model.  But in other Bug Hunt Models (such as Bug Hunt Consumers), this is adjustable
                              ;; In other Bug Hunt Models (such as Bug Hunt Consumers), grass-growth-rate has a default of 1, but is slider adjustable.

  ;; variables for bugs
  set-default-shape bugs "bug"
  set bugs-size 1.0
  set bugs-stride 0.2
  set bugs-reproduce-energy 100
  set bugs-energy-from-food 4  ;; set to 4 by default in this model.
                               ;; In other Bug Hunt Models (such as Bug Hunt Consumers), bug-energy-from-food has a default of 4, but is slider adjustable.
  set dead-bugs 0
  set offspring-bugs 0

  ;; setting colors
  set bugs-color (violet )
  set grass-color (green)
  set dirt-color (gray - 1)
  set not-grown-back-color white

  set competition-status "Get Ready"
  add-starting-grass
  if include-clients-as-bugs? [ask players [assign-bug-to-player]]
  add-bugs

  
  listen-clients
  check-reset-perspective
  display-labels
  
  reset-ticks
  set time-remaining (length-competition - ticks)
  send-all-info
end 

to setup-a-new-bugs-for-a-new-player [p-user-id]
   set hidden? false
   set color (magenta - 1)
   set size 1.4  ;; easier to see
   set label-color blue

   set energy 10 * bugs-energy-from-food
   set owned-by p-user-id
   set controlled-by-player? true
   update-statistics
end 

to go
  if ticks < length-competition  [
    set competition-status "Running"
    update-statistics
    listen-clients
    send-all-info
    ask patches [ grow-grass ]
    ask bugs [
      if automated-bugs-lose-energy? [ set energy energy - 1 ] ;; deduct energy for bugs only if bugs-lose-energy? switch is on
      if automated-bugs-reproduce? [ reproduce-bugs ]
      if automated-bugs-wander? [right random 30 left random 30]
      fd bugs-stride
      bugs-eat-grass
      bug-death
    ]
    display-labels
    check-reset-perspective
    tick
    set time-remaining (length-competition - ticks)
  ]
  if ticks = length-competition  [ 
    display 
    set competition-status "Over"
    if time-remaining <= 0 [set time-remaining 0] 
    send-all-info 
    tick
  ]
end 

to add-starting-grass
  ask patches [
      ifelse random 100 < amount-grassland    ;;  the maximum number of fertile patches is set by a slider
    [
      set fertile? true
      set grass-energy max-grass-energy
    ]
    [
      set fertile? false
      set grass-energy 0
    ]
    color-grass
  ]
end 

to add-bugs
  create-bugs initial-#-automated-bugs  ;; create the bugs, then initialize their variables
  [
    set color bugs-color
    set size bugs-size
    set controlled-by-player? false
    set energy 10 * bugs-energy-from-food
    setxy random world-width random world-height
  ]
end 

to bugs-eat-grass  ;; bugs procedure
  ;; if there is enough grass to eat at this patch, the bugs eat it
  ;; and then gain energy from it.
  if grass-energy > bugs-energy-from-food  [
    ;; grass lose ten times as much energy as the bugs gains (trophic level assumption)
    set grass-energy (grass-energy - (bugs-energy-from-food * 10))
    set energy (energy + bugs-energy-from-food)  ;; bugs gain energy by eating
  ]
  ;; if grass-energy is negative, make it positive
  if grass-energy <=  bugs-energy-from-food  [set countdown sprout-delay-time ]
end 

to reproduce-bugs  ;; automated bugs procedure
  if (energy > ( bugs-reproduce-energy))
  [
    if random 2 = 1 and not controlled-by-player?          ;; only half of the fertile bugs reproduce (gender)
    [
      set energy (energy / 2)      ;; lose energy when reproducing - energy is divided between offspring and parent
      hatch  1
      [    ;; hatch an offspring set it heading off in a a random direction and move it forward a step
        set offspring-bugs (offspring-bugs + 1)
        set size bugs-size
        set color bugs-color
        rt random 360 fd bugs-stride
      ]
    ]
  ]
end 

to bug-death  ;; bugs die when energy dips below zero (starvation)
  if  (energy < 0)
 [ set dead-bugs (dead-bugs + 1)
   die ]
end 

to grow-grass  ;; patch procedure
  set countdown (countdown - 1)
  ;; fertile patches gain 1 energy unit per turn, up to a maximum max-grass-energy threshold
  if fertile? and countdown <= 0 [
    set grass-energy (grass-energy + grass-growth-rate)
    if grass-energy > max-grass-energy [set grass-energy max-grass-energy]
  ]
  if not fertile? [set grass-energy 0]
  if grass-energy < 0 [set grass-energy 0 set countdown sprout-delay-time]
  color-grass
end 

to color-grass
  ifelse fertile? [
    ifelse grass-energy > 0
    ;; scale color of patch from whitish green for low energy (less foliage) to green - high energy (lots of foliage)
    [set pcolor (scale-color green grass-energy  (max-grass-energy * 2)  0)]
    [set pcolor not-grown-back-color]
  ]
  [set pcolor dirt-color]
end 



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;; player enter / exit procedures  ;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to create-new-player
  create-players 1
  [
    set dead? true
    set user-id hubnet-message-source
    set hidden? true
    assign-bug-to-player
  ]
end 

to assign-bug-to-player
  if include-clients-as-bugs? [
    let p-user-id user-id
    let parent-player self
    let child-bug nobody
    setxy random-xcor random-ycor
    ask bugs with [p-user-id = owned-by] [die]
    hatch 1 [
      set breed bugs
      set child-bug self
      setup-a-new-bugs-for-a-new-player p-user-id
      ask parent-player [ create-link-from child-bug [ tie ] set dead? false]
    ]
  ]
end 

to remove-player
  ask bugs with [owned-by = hubnet-message-source  and controlled-by-player?] [die]
  ask players with [user-id = hubnet-message-source] [ die ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Handle client interactions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to listen-clients
  while [ hubnet-message-waiting? ]
  [
    hubnet-fetch-message
    ifelse hubnet-enter-message?
    [ create-new-player ]
    [
      ifelse hubnet-exit-message?
      [ remove-player ]
      [ ask players with [user-id = hubnet-message-source] [execute-command hubnet-message-tag hubnet-message ]]
    ]
  ]
end 

to check-reset-perspective
   if player-vision != old-player-vision [
     ask players [
       hubnet-reset-perspective user-id
       hubnet-send-follow user-id self player-vision
     ]
     set old-player-vision player-vision
   ]
end 

to execute-command [command msg]
  if command = "View" [ orient-my-turtle command msg ]
end 

to execute-turn [new-heading]
  set heading new-heading
end 

to display-labels
  let b-color 0
  let energy-range (word  " [" min-energy-of-any-bug " to " max-energy-of-any-bug "]: ")

  ask bugs [
    set label-color black
    if show-labels-as = "none" [set label ""]
    if show-labels-as = "player energy"  [ set label (word round energy) ]
    if show-labels-as = "energy ranges"  [ set label (word energy-range round energy) ]
    if show-labels-as = "player name" [
      ifelse controlled-by-player? [set label owned-by] [set label ""]
    ]
    if show-labels-as = "player energy:name" [
      ifelse controlled-by-player? [set label (word round energy ":" owned-by)] [set label ""]
    ]
  ]
end 

to orient-my-turtle [name coords]
  let next-destination-patch patch first coords last coords
  if patch-here != destination-patch [
    ask my-agent [ set destination-patch next-destination-patch face destination-patch ]
  ]
end 

to-report my-agent
  let this-user-id user-id
  let my-bug nobody
  set my-bug bugs with [owned-by = this-user-id]
  report my-bug
end 

to-report energy-of-your-bug
  let this-user-id user-id
  let this-bug-energy 0
  if any? bugs with [owned-by = this-user-id] [
    ask bugs with [owned-by = this-user-id] [set this-bug-energy energy]
  ]
  report this-bug-energy
end 

to send-this-players-info ;; player procedure
  ;; update the monitors on the client
  let message-to-send ""
  let my-energy energy-of-your-bug
  let place 1 + (count bugs with [energy > my-energy])
  let num-ties count bugs with [energy = my-energy]
  let total-number-bugs count bugs
  let any-ties ""
  let out-of (word " out of " total-number-bugs "  ")
  if num-ties > 1 [set any-ties (word " [" num-ties "-way tie]") ]
  ifelse include-clients-as-bugs?
    [set message-to-send (word  place  out-of any-ties)]
    [set message-to-send "not currently in this competion"]
  hubnet-send user-id "Your Place in the Competition" message-to-send
end 

to send-all-info     ;;send common info to this client
  ask players [send-this-players-info]
  hubnet-broadcast "time remaining" time-remaining
end 

to update-statistics
  if any? bugs [
   set min-energy-of-any-bug precision (min [energy] of bugs ) 1
   set max-energy-of-any-bug precision (max [energy] of bugs ) 1
  ]
end 


; Copyright 2011 Uri Wilensky.
; See Info tab for full copyright and license.