Final Demo

; to-do

; add threat communication amongst turtles
;   - any turtle that "sees" a threat (assuming field of view (fov) is a cone in front of it)
;     should broadcast a threat message about it
;   - this message should contain the threat level and the ID of the turtle sending it
;     (ID of a turtle is accessed via "who" keyword)

; add moving towards current highest threat
;   need to still maintain separation while pursuing threat

turtles-own [
  vx ; y-velocity
  vy ; x-velocity
  threat-active? ; true if currently pursuing threat
  threat-x
  threat-y
  threat-high?
  new-info?
]

patches-own [
  threat
]

; user-specified variables:
;   velocity-base: base speed
;   velocity-variance: how much to randomly change speed by
;   velocity-adjust: how much to speed up or slow down by
;   search-fov: field of view when searching for neighbors
;   search-radius: outward limit when searching for neighbors
;   vertical-dist-thresh: difference in y-coordinates that causes turtle to adjust speed


; global variables:
globals [
  num-turtles
  turtle-spacing ; how much distance turtles keep between themselves in line
  threat-speed-low
  threat-speed-high

  turtle-detect-radius
  turtle-comms-radius
  turtle-comms-speed
  turtle-default-color
  turtle-with-info-color

  avoidance-radius

  obj-x
  obj-y

]


; starting positions of turtles is pre-defined (using origin at bottom-left corner)

to setup
  clear-all
  reset-ticks

  set num-turtles 5
  set turtle-spacing 40

  set turtle-default-color green
  set turtle-with-info-color red
  set turtle-detect-radius 70
  set turtle-comms-radius 180
  set turtle-comms-speed 1

  set avoidance-radius 25

  set threat-speed-low 8
  set threat-speed-high 14

  create-turtles num-turtles
  ask turtles [
    set color turtle-default-color
    setxy (125 + who * turtle-spacing) 50
    set size 10
    set heading 0

    set vx 0
    set vy velocity-base
    set threat-active? false
    set threat-high? false
    set new-info? false
  ]

  if obstacles? [ spawn-threats ]
end 

to spawn-threats
  spawn-obstacle 40 110 90 30 green
  spawn-obstacle 30 220 70 20 orange
  spawn-obstacle 260 330 70 20 red
end 


; draws a rectangular obstacle
; x,y = coords of upper left corner
; clr = color

to spawn-obstacle [ x y width height clr ]
  ask patches with
    [ pxcor >= x and pxcor <= x + width
      and
      pycor >= y and pycor <= y + height ] [ set pcolor clr ]
end 

to go

  ask turtles [

    ; new-info? restricts turtles that just received info from transmitting in the same tick
    ; this creates a cascading effect
    set new-info? false

    ; if this turtle is near an obstacle, analyze obstacle
    if near-obstacle [
      ; load object data
      let obstacle detect-obj

      ; determine whether to focus on this new threat
      if compare-detected-threat obstacle [ ; returns true if detected obstacle is higher threat than previous
        set color [ pcolor ] of obstacle
        if color = orange or color = red [ set threat-active? true ]
        ifelse color = red
        [ set threat-high? true ]
        [ set threat-high? false ]
        set threat-x ([pxcor] of obstacle)
        set threat-y ([pycor] of obstacle)
      ]

    ]

    ; see what other turtles have found
    communicate-neighbors

    ifelse threat-active?
    [ towards-threat threat-x threat-y ]
    [ check-neighbors ]
    move

  ]

  tick
end 

to-report compare-detected-threat [ obstacle ]

  ; compare new threat to last seen threat, return true if higher than last seen threat
  (ifelse
    color = green
    [ ifelse [ pcolor ] of obstacle = orange or [ pcolor ] of obstacle = red
      [ report true ]
      [ report false] ]
    color = orange
    [ ifelse [ pcolor ] of obstacle = red
      [ report true ]
      [ report false ] ]
    color = red [ report false ]
    [ report false ])
end 

to-report compare-neighbor-threat [ transmitting-turtle ]
  ; compare new threat to last seen threat, return true if higher than last seen threat
  (ifelse
    color = green
    [ ifelse [ color ] of transmitting-turtle = orange or [ color ] of transmitting-turtle = red
      [ report true ]
      [ report false] ]
    color = orange
    [ ifelse [ color ] of transmitting-turtle = red
      [ report true ]
      [ report false ] ]
    color = red [ report false ]
    [ report false ])
end 

; look at neighbors and see if they have found any threats

to communicate-neighbors
  if (ticks mod turtle-comms-speed = 0) and (near-turtle-with-info) [

    ; pick nearby turtle with useful info
    let transmitting-turtle get-turtle-with-info

    if compare-neighbor-threat transmitting-turtle [  ; recieved message is at higher level of threat than current
      ; receive obstacle info from other turtle
      set color ([color] of transmitting-turtle)
      set threat-x ([threat-x] of transmitting-turtle)
      set threat-y ([threat-y] of transmitting-turtle)
      ;set obj-threat ([obj-threat] of transmitting-turtle)
    ]

    ; turtle cannot share information until turtle-comms-speed ticks have passed
    set new-info? true
  ]
end 

; returns true if turtle is within range of a transmitting turtle

to-report near-turtle-with-info
  report (any? turtles in-radius turtle-comms-radius with [(color != green) and not (new-info?) ])
end 

; returns transmission from nearby turtle

to-report get-turtle-with-info
  report (one-of turtles in-radius turtle-comms-radius with [(color != green)])
end 

to-report near-obstacle
  report (any? patches in-radius turtle-detect-radius with [ pcolor != black ])
end 

; returns data from nearby object

to-report detect-obj
  report (one-of patches in-radius turtle-detect-radius with [(pcolor != black)])
end 

to check-neighbors
  ; every turtle checks turtle to left and right of them
  ; in reality this check is within some cone going out to left and right of them

  ; if neither left or right neighbor
    ; try to find neighbors
  ; else if left neighbor
    ; calculate left y difference
    ; test if too far ahead of left neighbor, too far behind left
  ; else if right neighbor
    ; calculate right y difference
    ; test if too far ahead of right neighbor, too far behind right

  ; rotate left and find neighbors in a cone with range 30 degrees, radius 25
  let left-neighbor min-one-of cone-search-neighbors 270 search-fov search-radius [ distance myself ]
  let right-neighbor min-one-of cone-search-neighbors 90 search-fov search-radius [distance myself ]

  (ifelse
    left-neighbor = nobody and right-neighbor = nobody ; nobody in sight
    [ find-neighbor ]
    left-neighbor != nobody ; found a left-side neighbor
    [
      let left-dist ycor - ( [ ycor ] of left-neighbor )
      (ifelse
        left-dist > vertical-dist-thresh [ slow-down ]     ; too far ahead
        left-dist * -1 > vertical-dist-thresh [ speed-up ] ; too far behind
        [ randomize-velocity ])                            ; proceed normally
    ]

    right-neighbor != nobody ; found a right-side neighbor
    [
      let right-dist ycor - ( [ ycor ] of right-neighbor )
      (ifelse
        right-dist > vertical-dist-thresh [ slow-down ]
        right-dist * -1 > vertical-dist-thresh [ speed-up ]
        [ randomize-velocity ])
    ]

    )
end 

to find-neighbor
  ; what to do if vision of neighbor is interrupted?
  ; go random direction? idk
  set vx random 15
  set vy random 15

    ; alt. idea: coin-flip to either speed up or slow down. code:
;  let coinflip? (random 1 = 0)
;  ifelse coinflip?
;    [ speed-up ]
;    [ slow-down ]
end 

to slow-down
  set vy vy - velocity-adjust
  set vx 0
end 

to speed-up
  set vy vy + velocity-adjust
  set vx 0
end 

to towards-threat [ x y ]
  ; current idea: have x and y coords of threat / turtle who saw threat
  ; can easily adapt to take in ID of turtle and just get coordinates via:
  ; [ xcor ] of turtle-id, [ ycor ] of turtle-id
  ; make unit vector from x and y coords, scale by different "threat-speeds" to get vx, vy
  let magnitude sqrt((x - xcor) ^ 2 + (y - ycor) ^ 2)
  let unit-x (x - xcor) / magnitude
  let unit-y (y - ycor) / magnitude
  ifelse threat-high?
    [ set vx threat-speed-high * unit-x
      set vy threat-speed-high * unit-y ]
    [ set vx threat-speed-low * unit-x
      set vy threat-speed-low * unit-y ]
end 

to randomize-velocity
  set vy velocity-base + (velocity-variance * random-float 1)
  set vx 0
  ; range = [velocity-base, base + variance]
end 

to-report cone-search-neighbors [rotation fov-angle dist]
  set heading rotation ; rotate to given angle: north = 0, 90 = east, west = 270
  if visualize? [
    let patchesToColor patches in-cone dist fov-angle
    ask patchesToColor [
      set pcolor red ]
    ask patches in-cone dist fov-angle [ set pcolor black ]
    if obstacles? [ spawn-threats ]
  ]
  let result other turtles in-cone dist fov-angle
  set heading 0 ; reset back to original heading (assumed north, 0)

  report result  ; think of "report" as a return statement in regular code
end 

to move
  avoid-near-obstacles
  setxy (xcor + vx) (ycor + vy)
end 

to avoid-near-obstacles
  if (any? patches in-radius avoidance-radius with [ pcolor != black ]) [
    let nearest-obstacle min-one-of (patches in-radius avoidance-radius with [ pcolor != black ]) [ distance myself ]
    ifelse [ pcolor ] of nearest-obstacle = green
    [ set vx 5 ]
    [ towards-threat (- 1 * [ pxcor ] of nearest-obstacle) (-1 * [ pycor ] of nearest-obstacle) ]
  ]
end