Gridlock Perspective Demo

extensions [ sound ]

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Variable declarations ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

globals
[
  grid-x-inc  ;; the amount of patches in between two roads in the x direction
  grid-y-inc  ;; the amount of patches in between two roads in the y direction
  acceleration  ;; the constant that controls how much a car speeds up or slows down by if it is to accelerate or decelerate
  phase  ;; keeps track of the phase
  clock  ;; keeps track of the total times thru the go procedure
  num-cars-stopped  ;; the number of cars that are stopped during a single pass thru the go procedure
  old-display-which-metric  ;; holds the value of display-which-metric for the last time through the go procedure

  ;; patch agentsets
  intersections  ;; agentset containing the patches that are intersections
  roads  ;; agentset containing the patches that are roads

  ;; string and list variables that hold data passed accumulated in the model run
  wait-data  ;; list that holds the average wait time of the cars for each pass through the go procedure
  stopped-data  ;; list that holds the number of stopped of the cars for each pass through the go procedure
  speed-data  ;; list that holds the average speed of the cars for each pass through the go procedure
  time-data  ;; list that holds the value of clock for each pass through the go procedure

  crash?
]

breed [ cars car ]
breed [ stoplights stoplight ]

cars-own
[
  speed  ;; the speed of the turtle
  up-car?  ;; this will be true if the turtle moves downwards and false if it moves to the right
  wait-time  ;; the amount of time since the last time a turtle has moved
]

patches-own
[
  intersection?  ;; this is true if the patch is at the intersection of two roads
  accident?  ;; this is true if a crash has occurred at this intersection.  this will never be true for a non-intersection patch
  green-light-up?  ;; this is true if the green light is above the intersection.  otherwise, it is false.  this is only true for patches that are intersections.
  my-row  ;; this holds the row of the intersection counting from the upper left corner of the graphics window.  it is -1 for patches that are not intersections.
  my-column  ;; this holds the column of the intersection counting from the upper left corner of the graphics window.  it is -1 for patches that are not intersections.
  user-id  ;; this holds the user-id that corresponds to the intersection.  it is -1 for patches that are not intersections.
  my-phase  ;; this holds the phase for the intersection.  it is -1 for patches that are not intersections.
]


;;;;;;;;;;;;;;;;;;;;;
;; Setup Functions ;;
;;;;;;;;;;;;;;;;;;;;;

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

;; Initialize the display by giving the global and patch variables initial values.
;; Create num-cars of turtles if there are enough road patches for one turtle to be created per road patch.
;; Setup the plots
;; All code in setup is done if full-setup? is true.  If it is false, then it doesn't clear the information
;; about the users; users still retain the same light that they had before.
;; "setup false" is done by the re-run button.

to setup [full-setup?]
  set crash? false
  clear-output
  if full-setup?  ;; We only want to clear the patches if the we are doing a full-setup
  [ clear-patches ]
  clear-turtles
  clear-all-plots
  reset-perspective

  setup-globals full-setup?

  ;; First we ask the patches to draw themselves and set up a few variables
  setup-patches full-setup?

  set-default-shape cars "car"
  set-default-shape stoplights "stoplight"

  if (number > count roads)
  [
    user-message (word "There are too many cars for the amount of road.  "
    "Either increase the amount of roads by increasing the GRID-SIZE-X "
    "or GRID-SIZE-Y sliders, or decrease the number of cars by lowering "
    "the NUMBER slider.\\nThe setup has stopped.")
    stop
  ]

  ;; Now create the turtles and have each created turtle call the functions setup-cars and set-car-color
  create-cars number
  [
    setup-cars
    set-car-color
    record-data
    set size 0.8
  ]

  ;; give the turtles an initial speed
  ask cars
  [ set-car-speed ]

  update-list-info

  setup-plots
end 

;; Initialize the global variables to appropriate values

to setup-globals [full-setup?]
  set phase 0
  set clock 0
  set num-cars-stopped 0
  if full-setup?
  [
    set grid-x-inc world-width / grid-size-x
    set grid-y-inc world-height / grid-size-y
  ]

  ;; initialize the lists and string for HubNet
  set wait-data []
  set stopped-data []
  set speed-data []
  set time-data []

  ;; don't make acceleration 0.1 since we could get a rounding error and end up on a patch boundary
  set acceleration 0.08
end 

;; Make the patches have appropriate colors, setup the roads and intersections agentsets,
;; and initialize the traffic lights to one setting

to setup-patches [full-setup?]
  if full-setup?
  [
    ;; initialize the patch-own variables and color the patches to a base-color
    ask patches
    [
      set intersection? false
      set accident? false
      set green-light-up? true
      set my-row -1
      set my-column -1
      set user-id -1
      set my-phase -1

      set pcolor brown + 3
    ]

    ;; initialize the global variables that hold patch agentsets
    set roads patches with [ (floor ((pxcor + max-pxcor - floor(grid-x-inc - 1)) mod grid-x-inc) = 5) or
                             (floor ((pycor + max-pycor) mod grid-y-inc) = 4 ) ]
    set intersections roads with [ (floor ((pxcor + max-pxcor - floor(grid-x-inc - 1)) mod grid-x-inc) = 5) and
                                   (floor ((pycor + max-pycor) mod grid-y-inc) = 4 ) ]

    ask roads
    [ set pcolor white ]
  ]
  setup-intersections full-setup?
end 

;; Give the intersections appropriate values for the intersection?, my-row, and my-column
;; patch variables.  Make all the traffic lights start off so that the lights are red
;; horizontally and green vertically.

to setup-intersections [full-setup?]
  ask intersections
  [
    set intersection? true
    set green-light-up? true
    set my-phase 0
    if full-setup?
    [
      set my-row floor ((pycor + max-pycor) / grid-y-inc )
      set my-column floor ((pxcor + max-pxcor) / grid-x-inc )
    ]
    ask patch-at 1 0 [ sprout-stoplights 1 [ set shape "stoplight" setxy pxcor pycor  set heading 0 ] ]
    ask patch-at 0 -1 [ sprout-stoplights 1 [ set shape "stoplight"  setxy pxcor pycor  set heading 90 ] ]
    set-signal-colors
  ]
end 

;; Initialize the turtle variables to appropriate values and place the turtle on an empty road patch.

to setup-cars  ;; turtle procedure
  set speed 0
  set wait-time 0

  put-on-empty-road

  ifelse intersection?
  [ ifelse random 2 = 1
    [ set up-car? true ]
    [ set up-car? false ]
  ]
  [
    ifelse (floor ((pxcor + max-pxcor - floor(grid-x-inc - 1)) mod grid-x-inc) =  5 )
    [ set up-car? true ]
    [ set up-car? false ]
  ]

  ifelse up-car?
  [ set heading 180 ]
  [ set heading 90 ]
end 

;; Find a road patch without any turtles on it and place the turtle there.

to put-on-empty-road  ;; turtle procedure
  let road one-of roads
  setxy ([pxcor] of road) ([pycor] of road)
  if any? other turtles-here
  [ put-on-empty-road ]
end 

;; Initialize the plots

to setup-plots
set-current-plot "Stopped Cars"
  set-plot-y-range 0 number
  plot num-cars-stopped

  set-current-plot "Average Wait Time of Cars"
  plot mean [wait-time] of cars

  set-current-plot "Average Speed of Cars"
  set-plot-y-range 0 speed-limit
  plot mean [speed] of cars
end 

;; give the user some information about what the setup button does so they can
;; know whether they want to proceed before actually doing the setup

to setup-prompt
  if user-yes-or-no? (word "The SETUP button should only be used when starting "
              "over with a new group (such as a new set of students) since "
              "all data is lost.  Use the RE-RUN button for continuing with "
              "an existing group."
              "\\n\\nDo you really want to setup the model?")
  [ setup true ]
end 

;;;;;;;;;;;;;;;;;;;;;;;
;; Runtime Functions ;;
;;;;;;;;;;;;;;;;;;;;;;;

;; receives information from the clients and runs the simulation

to go
    ;; get commands and data from the clients
    listen-clients

    ;; clear any accidents from the last time thru the go procedure
    clear-accidents

    ;; if there are any intersections that are to switch automatically, have them change their color
    set-signals
    set num-cars-stopped 0

    ;; set the turtles speed for this time thru the procedure, move them forward their speed,
    ;; record data for plotting, and set the color of the turtles
    ;; to an appropriate color based on their speed
    ask cars
    [
      set-car-speed
      fd speed
      record-data
      set-car-color
    ]
    ;; crash the cars if crash? is true
    if crash?
    [ crash-cars ]

    ;; update the information in the lists of plot data
    update-list-info

    ;; update the plots with the new information from this pass thru the procedure
    do-plotting
    ;; update the clock and the phase
    clock-tick
end 

;; have the traffic lights change color if phase equals each intersections' my-phase

to set-signals
  ask intersections with
  [ phase = floor ((my-phase * ticks-per-cycle) / 100) and ( ignore-students? or user-id = -1 ) ]
  [
    set green-light-up? (not green-light-up?)
    set-signal-colors
  ]
end 

;; This procedure checks the variable green-light-up? at each intersection and sets the
;; traffic lights to have the green light up or the green light to the left.

to set-signal-colors  ;; intersection (patch) procedure
  ifelse power?
  [
    sound:play-note "WOODBLOCK" 48 44 1.35
    ifelse green-light-up?
    [
      ask patch-at -1 0 [ set pcolor red ]
      ask patch-at 0 1 [ set pcolor green ]
      ask stoplights-at 1 0 [ set color red ]
      ask stoplights-at 0 -1 [ set color green ]
   ]
    [
      ask patch-at -1 0 [ set pcolor green ]
      ask patch-at 0 1 [ set pcolor red ]
      ask stoplights-at 1 0 [ set color green ]
      ask stoplights-at 0 -1 [ set color red ]
    ]
  ]
  [
    ask patch-at -1 0 [ set pcolor white ]
    ask patch-at 0 1 [ set pcolor white ]
  ]
end 

;; set any intersection's color that had an accident back to white and make accident? false

to clear-accidents
  if crash?
  [
    ask patches with [accident?]
    [
      set pcolor white
      set accident? false
    ]
  ]
end 

;; set the turtles' speed based on whether they are at a red traffic light or the speed of the
;; turtle (if any) on the patch in front of them

to set-car-speed  ;; turtle procedure
  ifelse pcolor = red
  [ set speed 0 ]
  [
    ifelse up-car?
    [ set-speed 0 -1 ]
    [ set-speed 1 0 ]
  ]
end 


;; set the speed variable of the turtle to an appropriate value (not exceeding the
;; speed limit) based on whether there are turtles on the patch in front of the turtle

to set-speed [delta-x delta-y]  ;; turtle procedure
  let turtles-ahead other cars in-cone 1.5 45

  ;; if there are turtles in front of the turtle, slow down
  ;; otherwise, speed up
  ifelse any? turtles-ahead
  [
    let up-cars?-ahead [ up-car? ] of turtles-ahead
    ifelse member? up-car? up-cars?-ahead and member? (not up-car?) up-cars?-ahead
    [
      if not crash?
      [ set speed 0 ]
    ]
    [
      set speed [speed] of one-of turtles-ahead
      slow-down
    ]
  ]
  [ speed-up ]
end 

;; decrease the speed of the turtle

to slow-down  ;; turtle procedure
  ifelse speed <= 0  ;;if speed < 0
  [ set speed 0 ]
  [ set speed ( speed - acceleration ) * 0.5 ]
end 

;; increase the speed of the turtle

to speed-up  ;; turtle procedure
  ifelse speed > speed-limit
  [ set speed speed-limit ]
  [ set speed ( speed + acceleration * 0.5 )  ]
end 

;; set the color of the turtle to a different color based on how fast the turtle is moving

to set-car-color  ;; turtle procedure
  ifelse speed < (speed-limit / 2)
  [ set color blue ]
  [ set color cyan - 2 ]
end 

;; keep track of the number of stopped turtles and the amount of time a turtle has been stopped
;; if its speed is 0

to record-data  ;; turtle procedure
  ifelse speed = 0
  [
    set num-cars-stopped num-cars-stopped + 1
    set wait-time wait-time + 1
  ]
  [ set wait-time 0 ]
end 

;; crash any turtles at the same intersection going in different directions

to crash-cars
  ask intersections with [any? turtles-here with [ any? other turtles-here in-radius 0.1 ] ]
  [
    set accident? true
    set pcolor orange
  ]
end 

;; add the new information from this pass thru the go procedure to the HubNet lists

to update-list-info
  set wait-data lput (mean [wait-time] of cars) wait-data
  set stopped-data lput num-cars-stopped stopped-data
  set speed-data lput (mean [speed] of cars) speed-data
  set time-data lput clock time-data
end 

;; plot the data from this pass thru the go procedure

to do-plotting
  ifelse display-which-metric = old-display-which-metric
  [
    ;; don't plot if no plots should be plotted
    if display-which-metric != 0
    [
      ;; we only need to plot 1 value since the current plot is the same as the plot we are supposed to plot to now
      ifelse display-which-metric = 1
      [ plot-new-value "Stopped Cars" num-cars-stopped ]
      [
        ifelse display-which-metric = 2
        [ plot-new-value "Average Speed of Cars" mean [speed] of cars ]
        [
          ifelse display-which-metric = 3
          [ plot-new-value "Average Wait Time of Cars" mean [wait-time] of cars ]
          [
            ;; therefore display-which-metric = 4
            plot-new-value "Stopped Cars" num-cars-stopped
            plot-new-value "Average Wait Time of Cars" mean [wait-time] of cars
            plot-new-value "Average Speed of Cars" mean [speed] of cars
          ]
        ]
      ]
    ]
  ]
  [
    ;; otherwise, we need to plot at least 1 list since the plot we are supposed to plot to is different from the plot we last plotted in
    ifelse display-which-metric = 0
    [ clear-all-plots ]
    [
      ifelse display-which-metric = 1
      [ clear-plots-and-plot-in-new-plot "Stopped Cars" stopped-data ]
      [
        ifelse display-which-metric = 2
        [ clear-plots-and-plot-in-new-plot "Average Speed of Cars" speed-data ]
        [
          ifelse display-which-metric = 3
          [ clear-plots-and-plot-in-new-plot "Average Wait Time of Cars" wait-data ]
          [
            ;; therefore display-which-metric = 4
            ifelse old-display-which-metric = 1
            [ plot-value-and-lists "Stopped Cars" num-cars-stopped "Average Speed of Cars" speed-data "Average Wait Time of Cars" wait-data ]
            [
              ifelse old-display-which-metric = 2
              [ plot-value-and-lists "Average Speed of Cars" (mean [speed] of cars) "Stopped Cars" stopped-data "Average Wait Time of Cars" wait-data ]
              [
                ifelse old-display-which-metric = 3
                [ plot-value-and-lists "Average Wait Time of Cars" (mean [wait-time] of cars) "Stopped Cars" stopped-data "Average Speed of Cars" speed-data ]
                [
                  ;; therefore old-display-which-metric = 0
                  plot-new-list "Stopped Cars" stopped-data
                  plot-new-list "Average Speed of Cars" speed-data
                  plot-new-list "Average Wait Time of Cars" wait-data
                ]
              ]
            ]
          ]
        ]
      ]
    ]
    set old-display-which-metric display-which-metric
  ]
end 

to plot-new-value [name-of-plot value]
  set-current-plot name-of-plot
  plot value
end 

to clear-plots-and-plot-in-new-plot [name-of-plot list-to-plot]
  clear-all-plots
  plot-new-list name-of-plot list-to-plot
end 

to plot-new-list [name-of-plot list-to-plot]
  let index 0

  set-current-plot name-of-plot
  clear-plot
  repeat length list-to-plot
  [
    plot item index list-to-plot
    set index index + 1
  ]
end 

to plot-value-and-lists [value-plot value list-plot1 list-to-plot1 list-plot2 list-to-plot2]
  plot-new-value value-plot value
  plot-new-list list-plot1 list-to-plot1
  plot-new-list list-plot2 list-to-plot2
end 

;; increases the clock by 1 and cycles phase to the next appropriate value

to clock-tick
  set clock clock + 1
  ;; The phase cycles from 0 to ticks-per-cycle, then starts over.
  set phase phase + 1
  if phase mod ticks-per-cycle = 0
  [ set phase 0 ]
end 

;; update the plots to show the current value of display-which-metric
;; done only by the Refresh Plots button

to show-current-metric-in-plots
  if display-which-metric != old-display-which-metric
  [
    ;; we need to plot at least 1 list since the plot we are supposed to plot to is different from the plot we last plotted in
    ifelse display-which-metric = 0
    [ clear-all-plots ]
    [
      ifelse display-which-metric = 1
      [ clear-plots-and-plot-in-new-plot "Stopped Cars" stopped-data ]
      [
        ifelse display-which-metric = 2
        [ clear-plots-and-plot-in-new-plot "Average Speed of Cars" speed-data ]
        [
          ifelse display-which-metric = 3
          [ clear-plots-and-plot-in-new-plot "Average Wait Time of Cars" wait-data ]
          [
            ;; therefore display-which-metric = 4
            ifelse old-display-which-metric = 1
            [
              plot-new-list "Average Speed of Cars" speed-data
              plot-new-list "Average Wait Time of Cars" wait-data
            ]
            [
              ifelse old-display-which-metric = 2
              [
                plot-new-list "Stopped Cars" stopped-data
                plot-new-list "Average Wait Time of Cars" wait-data
              ]
              [
                ifelse old-display-which-metric = 3
                [
                  plot-new-list "Stopped Cars" stopped-data
                  plot-new-list "Average Speed of Cars" speed-data
                ]
                [
                  ;; therefore old-display-which-metric = 0
                  plot-new-list "Stopped Cars" stopped-data
                  plot-new-list "Average Speed of Cars" speed-data
                  plot-new-list "Average Wait Time of Cars" wait-data
                ]
              ]
            ]
          ]
        ]
      ]
    ]
    set old-display-which-metric display-which-metric
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Code for interacting with the clients ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; when a command is sent, find out which client sent it and then execute the command

to listen-clients
  while [hubnet-message-waiting?]
  [
    hubnet-fetch-message
    ifelse hubnet-enter-message?
    [
      give-intersection-coords
      wait 1  ;; we want to give some time for other clients to log in on this round
    ]
    [
      ifelse hubnet-exit-message?
      [
        abandon-intersection
      ]
      [
        ifelse hubnet-message-tag = "Change Light"
        [ manual hubnet-message-source ]
        [
          if hubnet-message-tag = "Phase"
          [ auto hubnet-message-source ]
        ]
      ]
    ]
  ]
end 

;; when a new client logs in, if there are free intersections,
;; assign one of them to that client
;; if this current-id already has an intersection, give the client that intersection.

to give-intersection-coords
  let current-id hubnet-message-source
  ifelse not any? intersections with [user-id = current-id]
  [
      ;; the case where they tried logging in previously but there was no room for them
      ;; or they haven't logged in before
      get-free-intersection current-id
  ]
  [
    ;; otherwise, we already have an intersection for the current-id.
    ;; all we need to do is send where the light is located at
    ask intersections with [user-id = current-id]
    [ hubnet-send current-id "Located At:" (word "(" my-column "," my-row ")") ]
  ]
end 

;; when a client disconnects, free up its intersection

to abandon-intersection
  ask intersections with [user-id = hubnet-message-source]
  [
    set user-id -1
    set my-phase 0
    ask patch -1 1 [ set plabel "" ]
  ]
end 

;; if there are any free intersections, pick one of them at random and give it to the current-id.
;; if there are not any free intersections, toss an error and put error values into the list

to get-free-intersection [current-id]
  ifelse any? intersections with [user-id = -1]
  [
    ;; pick a random intersection that hasn't been taken yet
    ask one-of intersections with [user-id = -1]
    [
      set user-id current-id
      ask patch-at -1 1
      [
        set plabel-color black
        set plabel current-id
      ]
      hubnet-send current-id "Located At:" (word "(" my-column "," my-row ")")
    ]
  ]
  [
    hubnet-send current-id "Located At:" "Not enough lights"
    user-message word "Not enough lights for student with id: " current-id
  ]
end 

;; switch the traffic lights at the intersection for the client with user-id

to manual [current-id]
  if not ignore-students?
  [
    ask intersections with [user-id = current-id]
    [
      set green-light-up? (not green-light-up?)
      set-signal-colors
    ]
  ]
end 

;; change the value of the phase for the intersection at (xc,yc) to
;; the value passed by the client

to auto [current-id]
  ask intersections with [user-id = current-id]
  [
    set my-phase hubnet-message
  ]
end