Konza Consumers

globals [
  bison-stride                ;; how much a bison moves in each simulation step
  bison-size                  ;; the size of the shape for a bison
  bison-reproduce-age         ;; age at which bison reproduces
  max-bison-age
  min-reproduce-energy-bison  ;; how much energy, at minimum, bison needs to reproduce
  max-bison-offspring        ;; max offspring a bison can have

  cattle-stride                ;; how much a bison moves in each simulation step
  cattle-size                  ;; the size of the shape for a bison
  cattle-reproduce-age         ;; age at which bison reproduces
  max-cattle-age
  min-reproduce-energy-cattle  ;; how much energy, at minimum, bison needs to reproduce
  max-cattle-offspring           ;; max offspring a bison can have


  max-grasses-energy          ;; the maximum amount of energy a plant in a patch can accumulate
  grass-level               ;; a measure of the amount of grass currently in the ecosystem
  grass-energy

  food-bison-eat
  food-cattle-eat

  rain-timer
  where-rain-band-is

  bison-color
  cattle-color
  grass-color
  dirt-color
  disease-age
  disease-color
  grazers
  rain-band-width
  coefficient-a
  sprout-delay-time
  region-boundaries
  speed-seasons
  rock-color
  bison-migrate?

  constant-simulation-length?
  cattle-migrate?    ;;we changed this PS
    ;;We changed this
]

breed [rocks rock]
breed [grasses grass]
breed [dividers divider]                 ;; dummy turtles that separate the view in regions
breed [disease-markers disease-marker]   ;; visual cue, red "X" that bison has a disease and will die
breed [bison a-bison]
breed [cattle a-cattle]

breed [embers ember]                     ;; visual cue that a grass patch is on fire
breed [disruptions disruption]           ;; dummy turtles that record the disruption events

breed [clouds cloud]
breed [rain-lines rain-line]
breed [rain-drops rain-drop]

bison-own [
  energy
  current-age
  max-age
  female?
  #-offspring
]

cattle-own [
  energy
  current-age
  max-age
  female?
  #-offspring
]

patches-own [
  fertile?
  plant-energy
  countdown
  region
  rain-level
]

grasses-own [

]

embers-own [
 current-age
]

disease-markers-own [
  current-age
]

rain-drops-own [current-age]

disruptions-own [
  disruption-region         ;; the region in which the disruption happened
  disruption-tick           ;; the tick at which the disruption happened
  disruption-description    ;; "infected bison", "added more bison" or "started a wild fire"
]

to startup
  setup-regions 3
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; setup procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup

  clear-all

  set constant-simulation-length? false

  set bison-size 1.4
  set bison-stride 0.25
  set bison-reproduce-age 100
  set min-reproduce-energy-bison 200
  set max-bison-offspring 2
  set max-bison-age 500
  set bison-color [180 90 90]
  set-default-shape bison "buffalo"

 ; set rock-color [216 212 196]
  set rock-color [216 212 196]
  set bison-migrate? false
  set cattle-migrate? false

  set cattle-size 1.4
  set cattle-stride 0.25
  set cattle-reproduce-age 100
  set min-reproduce-energy-cattle 160
  set max-cattle-offspring 2
  set max-cattle-age 400
  set cattle-color [110 110 140]
  set-default-shape cattle "wildebeest"

  set-default-shape rain-lines "line"

  set speed-seasons 4

  set grass-level 0
  set disease-age 20
  set grass-energy 5

  set rain-timer 0

  set max-grasses-energy 200

  set food-bison-eat 4.0
  set food-cattle-eat 4.0

  set rain-band-width 5
  set coefficient-a 0.003

  set grass-color green
  set dirt-color white
  set disease-color [0 0 0 120]

  set-default-shape disease-markers "new-circle"
  set-default-shape embers "fire"
  set-default-shape disruptions "empty"

  set sprout-delay-time 5

  setup-regions 3
  add-starting-grasses

  add-bison region-number-from-name add-bison-to-region
  add-cattle region-number-from-name add-cattle-to-region
  set grazers turtles with  [breed = bison or breed = cattle]

  create-rain-lines 1 [ set color red set shape "rain-line" set size 35 set hidden? true]

   update-bison-fence

  reset-ticks
  set-rain-line-position
  ask patches  [color-water-levels]
end 

to add-starting-grasses
  ask patches [set fertile? false
    if region = 1 [set rain-level 1]
    if region = 2 [set rain-level 1]
    if region = 3 [set rain-level 1]
  ]
  add-grass-in-region 1 %-grassland-southern-region
  add-grass-in-region 2 %-grassland-central-region
  add-grass-in-region 3 %-grassland-northern-region
  ask grasses [visualize-grass]
  add-rocks
end 

to add-grass-in-region [ which-region %-grassland ]
  let region-patches patches with [ region = which-region ]
  let n floor ((%-grassland / 100) * count region-patches)
  ask n-of n region-patches [
    set fertile? true
    sprout 1 [
      set breed grasses
      set color [10 100 10 75]
      set shape "square"
      set plant-energy max-grasses-energy / 2
    ]
  ]
  ask patches [color-water-levels]
end 

to add-more-bison [which-region]
  ifelse any? disruptions with [ disruption-region = which-region ] [
    inform-user-about-max-disruptions which-region
  ]
  [
    if bison-to-add > 0 [
      add-bison which-region
      record-disruption which-region "added more bison"
    ]
  ]
end 

to add-more-cattle [which-region]
  ifelse any? disruptions with [ disruption-region = which-region ] [
    inform-user-about-max-disruptions which-region
  ]
  [
    if cattle-to-add > 0 [
      add-cattle which-region
      record-disruption which-region "added more cattle"
    ]
  ]
end 

to add-bison [which-region]
  let region-patches patches with [ region = which-region ]
  create-bison bison-to-add [                  ;; create the bison, then initialize their variables
    set color bison-color
    set size bison-size
    set energy (20 + (random (50))  )  ;; randomize starting energies
    set current-age 0  + random (max-bison-age) ;; start out bison at different ages
    set max-age max-bison-age
    set #-offspring 0
    move-to one-of region-patches
  ]
end 

to add-cattle [which-region]
  let region-patches patches with [ region = which-region ]
  create-cattle cattle-to-add [                  ;; create the cattle, then initialize their variables
    set color cattle-color
    set size cattle-size
    set energy (20 + (random (50))  )    ;; randomize starting energies
    set current-age 0  + random  (max-cattle-age)  ;; start out bison at different ages
    set max-age max-cattle-age
    set #-offspring 0
    move-to one-of region-patches
  ]
end 

to visualize-rocks
  ask rocks [set hidden? not show-rocky-ground?]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; runtime procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
  if ticks >= 999 and constant-simulation-length? [ stop ]

  ask bison [
    bison-live
    reproduce-bison
  ]

  ask cattle [
    cattle-live
    reproduce-cattle
  ]

  set-rain-line-position
  if rainfall? [set rain-timer rain-timer + 1]

  ask patches [
    color-water-levels
    if visualize-rain-drops? [add-rain-drops]
    grow-grass
  ]
  visualize-rocks
  ask grasses [visualize-grass]
  age-move-rain-drops
  age-and-spread-embers
  update-disease
  update-bison-fence
  tick
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; disruption procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to record-disruption [ which-region description ]
  create-disruptions 1 [
    set disruption-region which-region
    set disruption-description description
    set disruption-tick ticks
  ]
  update-plots
end 

to inform-user-about-max-disruptions [which-region]
  ask one-of disruptions with [ disruption-region = which-region ] [
    let region-side item (which-region - 1) ["left" "right"]
    user-message (word
      "You are allowed only one disruption in each ecosystem every time you run the model.\n\n"
      "You have already " disruption-description " in the " region-side " ecosystem.")
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; disease procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-disease
  ask disease-markers [
    set current-age (current-age + 1)
    if (ticks = 999 and constant-simulation-length?) [
      ask in-link-neighbors [ die ]
      die
    ]
  ]
  infect-other-grazers
end 

to infect-other-grazers

 if not vaccine? [
  ask (turtle-set bison cattle) with [ has-disease? ] [
    ask turtle-set one-of other bison-here with [ not has-disease? ] [
      infect-this-grazer
    ]
    ask turtle-set one-of other cattle-here with [ not has-disease? ] [
      infect-this-grazer
    ]
  ]

  ]
end 

to infect-a-%-of-bison
  ;; procedure for removing a percentage of bison (when button is clicked)
 ; ifelse any? disruptions with [ disruption-region = which-region ] [
 ;   inform-user-about-max-disruptions which-region
 ; ]
 ; [

    let number-bison count bison
    ask n-of floor (number-bison * %-bison-to-infect / 100) bison [infect-this-grazer]
 ;   record-disruption which-region "infected bison"
;  ]
end 

to infect-this-grazer
  hatch-disease-markers 1 [
    set current-age 0
    set size 1.5
    set color disease-color
    create-link-from myself [ tie ]
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; fire procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to start-fire

    let current-grass-patches patches with [ fertile? and rain-level <= 1 and pycor = min-pycor and plant-energy >= (.25 * max-grasses-energy)]
    ask current-grass-patches [
      set countdown sprout-delay-time
      set plant-energy 0

      create-ember
    ]
   ; record-disruption which-region "started a wild fire"
end 

to create-ember ;; patch procedure
  sprout 1 [
    set breed embers
    set current-age (sprout-delay-time / 2)
    set color [255 0 0 255]
    set size 1.5
  ]
end 

to age-move-rain-drops


  ask rain-drops [
    set heading 210
    fd 0.05
    set current-age (current-age - 1)
    if current-age <= 0 [ die ]

    let time-to-age-peak abs (current-age - 10)
    let trans-val (150 - round (time-to-age-peak * 15))
   ; if trans-val > 255 or trans-val < 0 [set trans-val 255]
   ; show trans-val
  let color-string []
  set color-string lput 0 color-string
  set color-string lput 0 color-string
  set color-string lput 150 color-string
  set color-string lput trans-val color-string
    set color color-string
  ]
end 

to age-and-spread-embers
  ask embers [
    set plant-energy 0
    set countdown sprout-delay-time
    set current-age (current-age - 1)
    if current-age <= 0 [ die ]
    let my-region region
    ask neighbors4 with [ region = [ region ] of myself and fertile? and grass-energy > (max-grasses-energy / 4) and not any? embers-here ] [
      create-ember
    ]
    let transparency round floor current-age * 255 / sprout-delay-time
    set color lput transparency [255 155 0]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; grazers procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to bison-live
  move-bison
  ifelse has-disease?  [set energy (energy - 1.5)][set energy (energy - 1)]
  set current-age (current-age + 1) ;; age by 1.5
  grazers-eat-grass food-bison-eat
  grazer-death
end 

to cattle-live
  move-cattle
  ifelse has-disease?  [set energy (energy - 1.5)][set energy (energy - 1)]
  set current-age (current-age + 1)
  grazers-eat-grass food-cattle-eat
  grazer-death
end 

to move-bison
  head-towards-rains
  rt random 44 - random 44
  let current-region region
  keep-in-region current-region bison-stride
  fd bison-stride
end 

to move-cattle
  head-towards-rains
  rt random 44 - random 44
  let current-region region
  keep-in-region current-region cattle-stride
  fd cattle-stride
end 

to grazers-eat-grass  [food-grazer-eats];; grazers procedurebisonbisonbisonbison
  ;; if there is enough grass to eat at this patch, the grazer eats it
  ;; and then gains energy from it.
    if plant-energy > food-grazer-eats [
      ;; plants lose ten times as much energy as the  gains (trophic level assumption)
      set plant-energy (plant-energy - (food-grazer-eats * 10))
      set energy energy + food-grazer-eats * 1.25 ;;  gain energy by eating
    ]
    ;; if plant-energy is negative, make it positive
    if plant-energy <= food-grazer-eats [ set countdown 5 ]
end 

to grazer-death   ;; a grazer dies when energy dips below zero (starvation), or it gets too old
  if (current-age > max-age) or (energy < 0) [ask out-link-neighbors [ die ] die]
end 

to reproduce-bison  ;; bison procedure
  let number-new-offspring (random (max-bison-offspring + 1)) ;; set number of potential offpsring from 1 to (max-bison-offspring)
  if (energy > ((number-new-offspring + 1) * min-reproduce-energy-bison) and current-age > bison-reproduce-age) [
    set energy (energy - (number-new-offspring * min-reproduce-energy-bison)) ;;lose energy when reproducing --- given to children
    set #-offspring #-offspring + number-new-offspring
    ;; hatch an offspring set it heading off in a a random direction and move it forward a step
    hatch number-new-offspring [
      set energy min-reproduce-energy-bison ;; split remaining half of energy amongst litter
      set current-age 0
      set #-offspring 0
      move-bison
    ]
  ]
end 

to reproduce-cattle  ;; bison procedure
  let number-new-offspring (random (max-cattle-offspring + 1)) ;; set number of potential offpsring from 1 to (max-bison-offspring)
  if (energy > ((number-new-offspring + 1) * min-reproduce-energy-cattle) and current-age > cattle-reproduce-age) [
    set energy (energy - (number-new-offspring * min-reproduce-energy-cattle)) ;;lose energy when reproducing --- given to children
    set #-offspring #-offspring + number-new-offspring
    ;; hatch an offspring set it heading off in a a random direction and move it forward a step
    hatch number-new-offspring [
      set energy min-reproduce-energy-cattle ;; split remaining half of energy amongst litter
      set current-age 0
      set #-offspring 0
      move-cattle
    ]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; grass procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; adjust the size of the grass to reflect how much food is in that patch

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

to visualize-grass
      ifelse plant-energy >= 5
        [ set size (plant-energy / max-grasses-energy) ]
        [ set size ((5 / max-grasses-energy) )]
end 

to add-rocks
  ask patches with [ not fertile?  ]  [
    sprout 1 [
      set breed rocks
      set size 1
      set shape "no-grass"
      set color [10 0 0 25]
      stamp
      die
    ]
  ]
end 

to-report random-rock-color
   let r-min-color 150
   let g-min-color 130
   let b-min-color 130
   let brighten random 20
   let r-offset random 10
   let g-offset random 10
   let b-offset random 10
   let color-list []
   set color-list fput (r-min-color + brighten + r-offset) color-list
   set color-list fput (g-min-color + brighten + g-offset) color-list
   set color-list fput (b-min-color + brighten + b-offset) color-list
   report color-list
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; water / rain procedures ;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to set-rain-line-position
  ask rain-lines [set xcor lat-sin]
  update-water-levels
end 

to update-water-levels
    let rain-line-pxcor [xcor] of one-of rain-lines
    let low-rain-value 0.5
    let a .25
    ask patches  [
      let distance-from-rain-line abs (pxcor - rain-line-pxcor)
      let rain-band-spread 9

      let distance-to-edge-of-rain ((rain-band-width / 2) + rain-band-spread)
      let xd (distance-from-rain-line - (rain-band-width / 2))
      let rain-at-xd (1 + (3 - (a * xd)))
      if (distance-from-rain-line <= (rain-band-width / 2)) [ set rain-level (4)]
      if (distance-from-rain-line >  (rain-band-width / 2)) and (distance-from-rain-line <=  (distance-to-edge-of-rain)) [ set rain-level rain-at-xd]
      if (distance-from-rain-line >  (distance-to-edge-of-rain)) and (distance-from-rain-line <=  (3 * distance-to-edge-of-rain))
          [ set rain-level (1.4 - (xd - 11) * (1.4 / 22 ))  ]
      if (distance-from-rain-line >  (3 * distance-to-edge-of-rain)) [ set rain-level 0 ]
    ]
end 

to color-water-levels
  let red-channel (255 - (rain-level * (255 - 150) / 4))
  let green-channel (255 - (rain-level * (255 - 175) / 4))
  let blue-channel (255 - (rain-level * (255 - 235) / 4))
  let color-string []
  set color-string lput red-channel color-string
  set color-string lput green-channel color-string
  set color-string lput blue-channel color-string
  set pcolor color-string
end 

to add-rain-drops
  let non-linear-age 20
  if random 100 < (round (rain-level) ^ 1.5)  [
    sprout 1 [set breed rain-drops set shape "drop" set color [0 0 150 70] set heading 0 bk 0.5 fd random-float 1 set heading 90 bk 0.5 fd random-float 1 set current-age 20 set size 0.4]
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; REGION MANAGEMENT CODE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-regions [ num-regions ]
  ; Store our region definitions globally for faster access:
  set region-boundaries calculate-region-boundaries num-regions
  ; Set the `region` variable for all patches included in regions:
  let region-numbers n-values num-regions [ n -> n + 1 ]
  (foreach region-boundaries region-numbers [ [boundaries region-number] ->
    ask patches with [ pxcor >= first boundaries and pxcor <= last boundaries ] [
      set region region-number
    ]
  ])
  add-dividers
end 

to add-dividers
  set-default-shape dividers "block"
  ask patches with [ region = 0 ] [
    sprout-dividers 1 [
      set color gray + 2
      set size 1.2
    ]
  ]
end 

to-report calculate-region-boundaries [ num-regions ]
  ; The region definitions are built from the region divisions:
  let divisions region-divisions num-regions
  ; Each region definition lists the min-pxcor and max-pxcor of the region.
  ; To get those, we use `map` on two "shifted" copies of the division list,
  ; which allow us to scan through all pairs of dividers
  ; and built our list of definitions from those pairs:
  report (map [ [d1 d2] -> list (d1 + 1) (d2 - 1) ] (but-last divisions) (but-first divisions))
end 

to-report region-divisions [ num-regions ]
  ; This procedure reports a list of pxcor that should be outside every region.
  ; Patches with these pxcor will act as "dividers" between regions.
  report n-values (num-regions + 1) [ n ->
    [ pxcor ] of patch (min-pxcor + (n * ((max-pxcor - min-pxcor) / num-regions))) 0
  ]
end 

to keep-in-region [ which-region grazer-stride] ; turtle procedure
  ; This is the procedure that make sure that turtles don't leave the region they're
  ; supposed to be in. It is your responsibility to call this whenever a turtle moves.

  if [region] of patch-ahead grazer-stride = 0 and which-region != 0 and bison-fences? and
   ((breed = bison and not bison-migrate?) or (breed = cattle and not cattle-migrate?)) [
   let region-min-pxcor first item (which-region - 1) region-boundaries
   let region-max-pxcor last item  (which-region - 1) region-boundaries

    if [pxcor] of patch-ahead grazer-stride = (region-min-pxcor - 1) or [pxcor] of patch-ahead grazer-stride = (region-max-pxcor + 1)
    ; if so, reflect heading around x axis
    [set heading (- heading) ]
    ]
  if pxcor = min-pxcor [set heading 90]
  if pxcor = max-pxcor [set heading -90]
end 

to head-towards-rains
  if ((abs (pxcor - where-rain-band-is) )  > 10.5  and ((cattle-migrate? and breed = cattle) or (bison-migrate? and breed = bison)) ) [
    if (pxcor < where-rain-band-is) [set heading 90]
    if (pxcor > where-rain-band-is) [set heading -90]
]
end 

to update-bison-fence
  ask dividers with [pxcor != min-pxcor and pxcor != max-pxcor] [set hidden? not bison-fences?]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GRAPHING;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to draw-vert-line [ xval ]
  plotxy xval plot-y-min
  plot-pen-down
  plotxy xval plot-y-max
  plot-pen-up
end 

to-report max-plot-y-max
  ;; Reports the highest plot-y-max of the two plots.
  ;; Used for maintaining the same y-scale in both plots.
  let name plot-name ;; save the name of the current plot
  set-current-plot "Population Size vs. Time"
  let ys (list plot-y-max)
  set-current-plot name ;; restore current plot to what it was
  report max ys
end 

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

to-report has-disease?
  report any? out-link-neighbors
end 

to-report lat-sin

  let rain-band-spread 20
 ; ifelse rainfall?
    set where-rain-band-is  (sin  ( 90  -  (rain-timer * speed-seasons / 10 ) ) * ( max-pxcor - (rain-band-spread / 2)))
   ; [set where-rain-band-is max-pxcor - (rain-band-width / 2)]
  report where-rain-band-is
end 

to-report region-number-from-name [this-region-name]
 let #-region 0

  if this-region-name = "southern region" [set #-region 1]
  if this-region-name = "central region" [set #-region 2]
  if this-region-name = "northern region" [set #-region 3]
  report #-region
end 

to-report grass-growth-rate
  ifelse rain-level > 0 [report   sqrt (rain-level * rain-level )] [report 0]
end 

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