Critter Designers

globals
[
  ;; variables used to assign colors and shape to clients
  shape-names                     ;; list that holds the names of the shapes a critter can have
  colors                          ;; list that holds the colors used for clients' critters
  color-names                     ;; list that holds the names of the colors used for clients' critters
  max-possible-codes              ;; total number of possible unique shape/color combinations
  longevity-leader-info           ;; holds user-id and if the species is not extinct, the shape and color name
  longevity-leader-age-and-status ;; holds age of the species and whether it is extinct or alive
  max-critter-lifespan            ;; the max number of ticks a critter can live
  birth-cost                      ;; the amount of energy needed to give birth
  dt                              ;; a time scaling unit used in the simulation to adjust how quickly events are rendered.
  player-spam-countdown           ;; the number of ticks a player must wait before placing a new species
  #-environment-changes           ;; the number of times the environment has changed
  events                          ;; a string holding a description of all the automatic environment changes that occurred in grass growth and max-grass
  total-species-created           ;; the total number of species created
  max-species-age                 ;; the maximum age of all species created
]


breed [ clients client]            ;; one for each client that logs in, for book-keeping
breed [ species-logs species-log ] ;; one for each client, that logs in.  It keeps track of all the species that have been created and tested by the client.
breed [ critters critter ]         ;; all the creatures in the ecosystem


clients-own
[
  user-id                        ;; unique id, input by the client when they log in, to identify each client turtle
  ; we have to keep track of the values from the client interface, whenever they change
  ; although we do not pass them on to critters they have already created.
  gray-out-others?               ;; if false, only this client's critters will be colored
  show-energy?                   ;; if true, display the energy level for each individual critter of this client's species
  placing-spam-countdown         ;; the number of ticks this client must wait before placing a new species
  placements-made                ;; the number of species this client has placed

  population-size                ;; the number of critters this client has
  current-longevity              ;; the age of this client's current species
  max-longevity                  ;; the age of the oldest species this client has created

  speed                          ;; how fast this client's critters move
  behavior-dna                   ;; the pattern of steps that this client's critters move in
  birthing-level                 ;; the energy level each individual must reach before reproducing as well as
                                 ;; how much energy is split between the parent and the offspring when this occurs
  carnivore?                     ;; if true, this client's species can eat other critters
]

critters-own
[
  age                            ;; the number of ticks this critter has been alive for
  energy                         ;; this critter's energy level
  creator-id                     ;; number to identify the creator of this critter
  species-id                     ;; number to identify this species

  ;;these variables are similar to the variables in clients-own with the same name
  speed
  behavior-dna
  birthing-level
  carnivore?

  current-action                 ;; this critter's current action from their behavior-dna
  action-index                   ;; the list index of this critter's current action in their behavior-dna
  movement-counter               ;; a counter that ticks down for a certain number of tics for each action in the
                                 ;; critters movement.  This allows the participants to be able to see the critters turning
                                 ;; and sliding forward or backward fluidly.
  movement-delta                 ;; the distance the critter moves
  species-start-tick             ;; the time (number of ticks) when this critter was made
]

species-logs-own
[
  creator-id                     ;; number to identify the creator of this species
  species-id                     ;; number to identify this species
  age                            ;; the number of ticks this species has been alive for
  created-on                     ;; the time (number of ticks) when this species was made
  last-alive-on                  ;; the time (number of ticks) when this species was last alive
  extinct?                       ;; if true, this species is no longer alive
]

patches-own [
  sugar                          ;; the amount of nutrients available on a patch
]


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Setup Procedures ;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to startup
  hubnet-set-client-interface "COMPUTER" []
  hubnet-reset
  setup-vars
end 

to reset-client-stats
      set placements-made 0
      set population-size 0
      set current-longevity 0
      set max-longevity 0
end 

to setup
  clear-patches
  clear-all-plots
  clear-output
  ask clients [
    reset-client-stats
  ]
  ask critters [ die ]
  ask species-logs [die]
  reset-ticks
  setup-patches
  repeat minimum-random-species
  [
    add-random-critter
  ]

  set longevity-leader-info "-----"
  set longevity-leader-age-and-status "-----"

  set max-critter-lifespan 1000
  set birth-cost .15
  set dt .5
  set player-spam-countdown 25
  set events []
  set #-environment-changes 0
  set total-species-created 0
  set max-species-age 0
end 

to setup-patches
  ask patches [
    set sugar random (max-grass / 5)
    recolor-patch
  ]
end 

to add-random-critter
  create-critters 1 [
    randomize-critter
    initialize-critter
    let shape-color-code unused-shape-color-code
    set-shape-and-color-by-code shape-color-code
    set creator-id first-unused-bot-name
    set energy birthing-level * 0.75
    make-a-species-log
  ]
end 

to make-a-species-log
   set total-species-created total-species-created + 1
   set species-id total-species-created
   hatch 1  [
      set breed species-logs
      set hidden? true
      set created-on ticks
      set last-alive-on ticks
      set extinct? false
      ]
end 


;; just for random bot critters

to randomize-critter
  set speed (1 + random 10) / 10
  set birthing-level (5 + random 46)
  set behavior-dna reduce [word ?1 ?2] n-values 30 [random-action-letter]
  set carnivore? (random 100 < 20)  ; 20% chance of being a carnivore
end 

;; initialization actions that are common to bot & player-controlled critters

to initialize-critter
  let empty-patches patches with [ not any? critters-here ]
  ifelse (any? empty-patches)
    [ move-to one-of empty-patches ]
    [ setxy random-xcor random-ycor ]
  set heading one-of [ 0 90 180 270 ]
  set age 0
  set species-start-tick ticks
  set movement-counter 0
  set action-index -1
  if (carnivore?) [ set size size * 1.4 ]
end 

to-report first-unused-bot-name
  let bot-num 1
  while [any? critters with [ creator-id = (word "bot" bot-num "*") ] ]
  [ set bot-num bot-num + 1 ]
  report (word "bot" bot-num "*")
end 

to-report random-action-letter
  report one-of ["F" "F" "R" "L" "*"]
end 

;; initialize global variables

to setup-vars
  set shape-names [ "box" "star" "wheel" "target" "cat" "dog"
                   "butterfly" "leaf" "car" "airplane"
                   "monster" "key" "cow skull" "ghost"
                   "cactus" "moon" "heart"]
  set colors      (list (white - 1) brown red (orange + 1) (violet + 1) (magenta) (sky + 1) yellow cyan 137)
  set color-names ["white" "brown" "red" "orange" "purple" "magenta" "blue" "yellow" "cyan" "pink"]
  set max-possible-codes (length colors * length shape-names)
end 


;;;;;;;;;;;;;;;;;;;;;;;;
;; Runtime Procedures ;;
;;;;;;;;;;;;;;;;;;;;;;;;

to go
  every 0.01
  [
    calc-leader-stats
    ; possibly add a random critter of a new species at every 20th tick
    if (ticks mod 20 = 0) and (random 50 < 1 or species-count < minimum-random-species)
    [
      add-random-critter
    ]
    ;; move turtles
    ask clients [update-client-stats]
    ask critters
    [
      set age age + dt
      if (movement-counter <= 0)
      [
        set action-index (action-index + 1) mod (length behavior-dna)
        set current-action item action-index behavior-dna
        if (current-action = "f") [ set current-action "F" ]
        if (current-action = "r") [ set current-action "R" ]
        if (current-action = "l") [ set current-action "L" ]
        if (current-action = "*" or not member? current-action "FRL")
        [ set current-action one-of ["F" "R" "L"] ]
        ifelse (current-action = "F")
        [
          ifelse (speed = 0)
          [ set movement-counter 1000000 ]
          [ set movement-counter round (1.0 / (speed * dt)) ]
          set movement-delta 1.0 / movement-counter
          ; make sure we're facing one of the four cardinal directions, before moving forward
          set heading (round (heading / 90)) * 90
        ][
        if (current-action = "R" or current-action = "L")
        [
          ifelse (speed = 0)
          [ set movement-counter 1000000 ]
          [ set movement-counter round (90 / (90 * speed * dt)) ]

          set movement-delta 90 / movement-counter
        ]]

      ]
      set movement-counter movement-counter - 1
      ifelse (current-action = "F")
      [
        ;; move and expend energy
        ifelse (can-move? movement-delta)
        [
          forward movement-delta
        ]
        [
          set movement-counter 0 ; critter tried to go forward but can't, so instead of beating its head
                                 ; against the wall for a long time, it skips to its next action
        ]
        ifelse (carnivore?)
        [
          set energy energy - (speed / 5 + 0.05) * dt  ; speed is less energy-expensive for carnivores.
        ]
        [
          set energy energy - (speed + 0.05) * dt  ; lose energy based on speed, and -0.05 base metabolism
        ]
      ][
        ifelse (current-action = "R")
          [ right movement-delta ]
          [ left movement-delta ]
        ; turning costs much less energy than movement,
        set energy energy - (speed / 5) * dt
        ; we only take away base metabolism for carnivores, b/c we don't want them to sit forever!
        if (carnivore?)
        [ set energy energy - 0.02 * dt ]
      ]

      ;; eat
      ifelse (carnivore?)
      [
        ;; don't eat anything of same color
        let prey critters-here with [ color != [color] of myself ]
        if any? prey
        [
          let victim one-of prey
          set energy energy + [ energy ] of victim
          ask victim [ die ]
        ]
      ]
      [ ; herbivore
        set energy energy + sugar
        ask patch-here [
          set sugar 0
          recolor-patch
        ]
      ]
      if (energy > birthing-level)
      [
        hatch 1 [
          set heading random 360
          if (can-move? 0.3)
            [ fd 0.3  ]
          set heading one-of [0 90 180 270 ]
          set age 0
          ; extra 0.25 penalty helps balance against critter-bomb low-birth-threshold tactics
          set energy (([energy] of myself) / 2) * (1.0 - birth-cost) - 0.25
          set movement-counter 0
          set action-index -1
        ]
        set energy energy / 2
      ]
      if (energy < 0 or age > max-critter-lifespan)
      [
        add-sugar (2 + energy / 2) ; give back some nutrients to the world, as the organism decomposes
        if (carnivore?)
          [ add-sugar 3 ] ; more from a carnivore corpse
        recolor-patch
        die
      ]
    ]

    ask n-of ((grass-growth / 100)  * dt * count patches ) patches  [
      add-sugar 0.1
      recolor-patch
    ]

     update-species-logs ;; keep historical record of all species

    ; we do hubnet commands right before a tick, because the override lists get set here,
    ; and the display gets updated after a tick.
    listen-clients

    if (ticks mod 100 = 0) and random 10 = 0 and  environment-changes? [change-environmental-conditions]

    tick
  ]
end 

to add-sugar [ n ]
  ifelse sugar + n > max-grass
  [ set sugar max-grass ]
  [ set sugar sugar + n ]
end 

to recolor-patch
  set pcolor scale-color green sugar 0 100
end 

to change-environmental-conditions
     let growth-rate-change random 100 - random 100 ;sets growth-rate-change to a number between -99 and 99
     let max-grass-change random 80 - random 80 ;sets max-grass-change to a number between -79 and 79
     let old-max-grass max-grass
     let old-grass-growth grass-growth

     set grass-growth grass-growth + growth-rate-change
     if grass-growth < 10 [set grass-growth 10]
     if grass-growth > 100 [set grass-growth 100]

     set max-grass max-grass + max-grass-change
     if max-grass > 100 [set max-grass 100]
     if max-grass < 10 [set max-grass 10]
     let this-event (word "time: " ticks )
     set events lput  ( word  this-event " ggr: " grass-growth " mgpp: " max-grass) events
     set #-environment-changes #-environment-changes + 1
      output-print (word "Environmental change (time:" ticks ", grass-growth:" grass-growth ", max-grass:" max-grass )
end 

to update-species-logs
  ask species-logs [
     let this-creator-id creator-id
     let this-species-id species-id
     let this-extinct-status extinct?
     ifelse any? critters with [creator-id = this-creator-id and this-species-id = species-id]
       [set last-alive-on ticks ]
       [if not extinct? [set extinct? true]]
     set age (last-alive-on - created-on)
   ]
  if any? species-logs [ set max-species-age max [age] of species-logs ]
end 


;;;;;;;;;;;;;;;;;;;;;;;
;; HubNet Procedures ;;
;;;;;;;;;;;;;;;;;;;;;;;

;; determines which client sent a command, and what the command was

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

  ask clients  [ send-info-to-client ]
  if any? clients [broadcast-info-to-clients]
end 

to create-new-client
  create-clients 1
  [
    setup-client-vars
    send-info-to-client
  ]
end 

;; sets the turtle variables to appropriate initial values

to setup-client-vars  ;; turtle procedure
  hide-turtle
  set user-id hubnet-message-source
  change-shape-and-color
  setxy random-xcor random-ycor
  set heading one-of [0 90 180 270]
  set speed 1.0
  set behavior-dna "FFFFL"
  set birthing-level 25
  set carnivore? false
  set gray-out-others? false
  set show-energy? false
  set placing-spam-countdown 0
  reset-client-stats
end 

to execute-command [command]
  if command = "speed"
  [ set speed hubnet-message           stop  ]
  if command = "behavior-dna"
  [ set behavior-dna hubnet-message    stop  ]
  if command = "birthing-level"
  [ set birthing-level hubnet-message  stop  ]
  if command = "carnivore?"
  [ set carnivore? hubnet-message      stop  ]
  if command = "gray-out-others?"
  [
    set gray-out-others? hubnet-message
    if (gray-out-others? = false)
    [ hubnet-clear-override user-id critters "color" ]
    stop
  ]
  if command = "show-energy?"
  [
    set show-energy? hubnet-message
    if (show-energy? = false)
    [ hubnet-clear-override user-id critters "label" ]
    stop
  ]
  if command = "Place New Species"
  [
    if (placing-spam-countdown = 0) and (placements-made < #-placements-per-client)
    [
      ; we make them wait a while before hitting PLACE again.
      set placing-spam-countdown player-spam-countdown
      set placements-made placements-made + 1
      ask my-critters [ die ]
      hatch-critters 1 [
        ; inherits variables: speed, behavior-dna, birthing-level, carnivore?, and color
        ; automatically from the client, via the hatch-critters statement
        set shape [shape] of myself ; shape not inherited via "hatch-critters"
        set creator-id user-id-to-creator-id ([user-id] of myself)
        set energy 30
        initialize-critter
        show-turtle ; otherwise critter inherits invisibility from the client
        make-a-species-log
      ]
    ]
    stop
  ]
  if command = "Change Shape"
  [
    change-shape-and-color
    stop
  ]
  if command = "follow-a-critter?"
  [
    ifelse (hubnet-message)
    [
      if any? my-critters
        [ hubnet-send-follow user-id (one-of my-critters) 10 ]
    ]
    [ hubnet-reset-perspective user-id ]
    stop
  ]
end 

to remove-client
  ask clients with [user-id = hubnet-message-source]
  [
    ask my-critters [
      set creator-id (word creator-id "*")
    ]
    die
  ]
end 

to set-shape-and-color-by-code [ code ]
  set shape item (code mod length shape-names) shape-names
  set color item (code / length shape-names) colors
end 

to update-client-stats
  set population-size count-my-critters
  set current-longevity longevity-of-this-species
  set max-longevity max-longevity-of-all-my-species
end 



;; sends the appropriate monitor information back to the client

to send-info-to-client
  if (placing-spam-countdown > 0) [ set placing-spam-countdown placing-spam-countdown - 1 ]
  hubnet-send user-id "Countdown until you can place again:" placing-spam-countdown
  hubnet-send user-id "# of species left you can introduce" (#-placements-per-client - placements-made)
  hubnet-send user-id "Your Current Species Size" population-size
  hubnet-send user-id "Your Current Species Longevity"  current-longevity
  hubnet-send user-id "Your Max. Species Longevity"  max-longevity

  if (gray-out-others?)  [ hubnet-send-override user-id critters with [ creator-id != (user-id-to-creator-id [user-id] of myself)] "color" [gray - 2] ]
  if (show-energy?)      [ hubnet-send-override user-id my-critters "label" [ (word round energy "     ") ]  ]
end 

to broadcast-info-to-clients
  if any? clients [
    hubnet-broadcast "# Alive Species" species-count
    hubnet-broadcast "# Extinct Species" count species-logs with [extinct?]

    hubnet-broadcast "Species Longevity Leader" longevity-leader-info
    hubnet-broadcast "Longevity Record" longevity-leader-age-and-status
    hubnet-broadcast "time" ticks
  ]
end 

to calc-leader-stats
  if any? species-logs [
    let leader-log max-one-of species-logs [age]  ;; pull out a log
    let leader-species-extinct? [extinct?] of leader-log
    let leader-id [creator-id] of leader-log
    let leader-shape ""
    let leader-status ""
    ifelse leader-species-extinct?
       [set leader-shape "" set leader-status "extinct"]
       [set leader-shape  [(word (color-string color) " " shape)] of one-of critters with [creator-id = leader-id] set leader-status "alive"]

    set longevity-leader-age-and-status (word [age] of leader-log " (" leader-status ")")
    set longevity-leader-info (word leader-id ": " leader-shape)
  ]
end 

to change-shape-and-color
  set-shape-and-color-by-code unused-shape-color-code
  hubnet-send user-id "Your critter shape:" (word (color-string color) " " shape)
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Reporters   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to-report longevity-of-this-species
  let p-user-id user-id
  let p-value-to-report 0
  if any? species-logs with [creator-id = p-user-id and extinct? = false] [
   set p-value-to-report [age] of species-logs with [creator-id = p-user-id and extinct? = false]
   set p-value-to-report item 0 p-value-to-report
  ]
  report p-value-to-report
end 

to-report max-longevity-of-all-my-species
  let p-user-id user-id
  let p-value-to-report 0
  if any? species-logs with [creator-id = p-user-id] [
   set p-value-to-report max [age] of species-logs with [creator-id = p-user-id]
  ]
  report p-value-to-report
end 

to-report my-critters
  report critters with [ creator-id = (user-id-to-creator-id [user-id] of myself )]
end 

to-report count-my-critters
  report count my-critters
end 

to-report age-of-my-critters
    ifelse any? critters with [ creator-id = (user-id-to-creator-id [user-id] of myself )]
        [report max [age] of critters with [ creator-id = (user-id-to-creator-id [user-id] of myself )]]
        [report 0]
end 


;; translates a client turtle's shape and color into a code

to-report my-shape-color-code
  let shape-pos (position shape shape-names)
  let color-pos (position color colors)
  if (shape-pos = false or color-pos = false)
    [ report false ]
  report shape-pos + (length shape-names) * color-pos
end 

to-report unused-shape-color-code
  let used-codes remove-duplicates ([my-shape-color-code] of turtles)
  let new-code random max-possible-codes
  while [ member? new-code used-codes ]
  [ set new-code random max-possible-codes ]
  report new-code
end 

to-report user-id-to-creator-id [ uid ]
  report remove "*" uid
end 


;; report the string version of the turtle's color

to-report color-string [color-value]
  report item (position color-value colors) color-names
end 

to-report species-list
  report remove-duplicates [ creator-id ] of critters
end 

to-report species-count
  report length species-list
end 


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