Traffic Flow at Toll Barriers

globals [
  selected-car   ; the currently selected car
  lanes          ; a list of the y coordinates of different lanes
  barrier-x      ; position x of the barriers
]

breed [ cars car]
breed [ barriers barrier]

cars-own [
  speed            ; the current speed of the car
  top-speed        ; the maximum speed of the car (different for all cars)
  target-lane      ; the desired lane of the car
  patience         ; the driver's current level of patience
  passed-barrier? 
]

barriers-own [
  lane-y        ; y of the lane where the barrier is
  serving-car   ; car that is being served in the barrier
  remaining     ; ticks left to finish the "plate reading"
  open?         ; if the barrier is open (it allows car to go through)
]

to setup
  clear-all
  set-default-shape cars "car"
  draw-road
  set barrier-x (max-pxcor - 3) ; for example, 3 patches before the end
  draw-toll-plaza
  setup-barriers
  create-or-remove-cars
  set selected-car one-of cars
  ask selected-car [ set color red ]
  reset-ticks
end 

to setup-barriers
  ; remove old barriers (if num-of-lanes is changed after new setup)
  ask barriers [die]
  
  ; one barrier at each lane
  foreach lanes [y ->
    create-barriers 1 [
      set lane-y y
      setxy barrier-x lane-y
      ;hide-turtle
      set serving-car nobody
      set remaining 0
      set open? false
      
      set shape "line"
      set size 1.2
      set color yellow
      set heading 0
    ]
  ]
end 

to create-or-remove-cars

  ; make sure we don't have too many cars for the room we have on the road
  let road-patches patches with [ member? pycor lanes ]
  if number-of-cars > count road-patches [
    set number-of-cars count road-patches
  ]

  create-cars (number-of-cars - count cars) [
    set passed-barrier? false
    set color car-color
    move-to one-of free road-patches
    set target-lane pycor
    set heading 90
    set top-speed 0.5 + random-float 0.5
    set speed 0.5
    set patience random max-patience
  ]

  if count cars > number-of-cars [
    let n count cars - number-of-cars
    ask n-of n [ other cars ] of selected-car [ die ]
  ]
end 

to-report free [ road-patches ] ; turtle procedure
  let this-car self
  report road-patches with [
    not any? cars-here with [ self != this-car ]
  ]
end 

to draw-toll-plaza
  ; toll zone --> 3 patches wide
  let x0 barrier-x
  let booth-x (barrier-x + 1)

  ; stop line in each lane
  ask patches with [ pxcor = x0 and member? pycor lanes ] [
    set pcolor grey
  ]
end 

to draw-road
  ask patches [
    ; the road is surrounded by green grass of varying shades
    set pcolor green - random-float 0.5
  ]
  set lanes n-values number-of-lanes [ n -> number-of-lanes - (n * 2) - 1 ]
  ask patches with [ abs pycor <= number-of-lanes ] [
    ; the road itself is varying shades of grey
    set pcolor grey - 2.5 + random-float 0.25
  ]
  draw-road-lines
end 

to draw-road-lines
  let y (last lanes) - 1 ; start below the "lowest" lane
  while [ y <= first lanes + 1 ] [
    if not member? y lanes [
      ; draw lines on road patches that are not part of a lane
      ifelse abs y = number-of-lanes
        [ draw-line y yellow 0 ]  ; yellow for the sides of the road
        [ draw-line y white 0.5 ] ; dashed white between lanes
    ]
    set y y + 1 ; move up one patch
  ]
end 

to draw-line [ y line-color gap ]
  ; We use a temporary turtle to draw the line:
  ; - with a gap of zero, we get a continuous line;
  ; - with a gap greater than zero, we get a dasshed line.
  create-cars 1 [
    setxy (min-pxcor - 0.5) y
    hide-turtle
    set color line-color
    set heading 90
    repeat world-width [
      pen-up
      forward gap
      pen-down
      forward (1 - gap)
    ]
    die
  ]
end 

to go
  create-or-remove-cars
  ask barriers [ manage-barrier ]
  ask cars [ move-forward ]
  ask cars with [ patience <= 0 ] [ choose-new-lane ]
  ask cars with [ ycor != target-lane ] [ move-to-target-lane ]
  tick
end 

to manage-barrier  ; barrier procedure
  
  ; if the barrier is serving a car
  if serving-car != nobody [
    if remaining > 0 [
      set remaining remaining - 1
      set open? false ; the barrier is closed while serving
    ]
    
    ; when the serving time reaches zero, open the barrier
    if remaining = 0 [
      set open? true
    ]
    
    ; once the served car has passed the barrier,
    ; release the barrier so it can serve the next car
    if open? and ([xcor] of serving-car > barrier-x + 0.6) [
      set serving-car nobody
      set open? false
    ]
  ]

  ; visual: open = green, closed = red
  ifelse open? [
    set color green
    set heading 90
  ] [
    set color red
    set heading 0
  ]
end 

to move-forward ; turtle procedure
  set heading 90
  
    ; --- BARRIER CONTROL ---
    if not passed-barrier? [
    let b one-of barriers with [ lane-y = [pycor] of myself ]
    if b != nobody [
      let stop-x (barrier-x - 0.5)

      ; if the car has not passed the barrier and it is in the stop line or close
      if xcor >= (stop-x - 0.2) and xcor <= (barrier-x + 0.2) [

        ; if the barrier is free, the car is asigned as serving-car and the process starts
        if [serving-car] of b = nobody [
          ask b [
            set serving-car myself
            set remaining barrier-wait-min + random (barrier-wait-max - barrier-wait-min + 1)
            set open? false
          ]
        ]

        ; if the car is not the one being served or the barrier 
        ; is not open --> it stops at stop-x
        if ([serving-car] of b != self) or (not [open?] of b) [
          set xcor stop-x
          set speed 0
          stop
        ]
        ; if the car is the one being serves, continue as normal
      ]
    ]
  ]

  ; --- END BARRIER CONTROL ---
  
  speed-up-car ; we tentatively speed up, but might have to slow down
  let blocking-cars other cars in-cone (1 + speed) 180 with [ y-distance <= 1 ]
  let blocking-car min-one-of blocking-cars [ distance myself ]
  if blocking-car != nobody [
    ; match the speed of the car ahead of you and then slow
    ; down so you are driving a bit slower than that car.
    set speed [ speed ] of blocking-car
    slow-down-car
  ]
  forward speed
  ; marc as the car passed the toll
  if (not passed-barrier?) and xcor > (barrier-x + 0.6) [
    set passed-barrier? true
  ]
    ; after the wrap, the car has to pass the toll again
  if xcor < (min-pxcor + 1) [
    set passed-barrier? false
  ]
end 

to slow-down-car ; turtle procedure
  set speed (speed - deceleration)
  if speed < 0 [ set speed deceleration ]
  ; every time you hit the brakes, you loose a little patience
  set patience patience - 1
end 

to speed-up-car ; turtle procedure
  set speed (speed + acceleration)
  if speed > top-speed [ set speed top-speed ]
end 

to choose-new-lane ; turtle procedure
  ; Choose a new lane among those with the minimum
  ; distance to your current lane (i.e., your ycor).
  let other-lanes remove ycor lanes
  if not empty? other-lanes [
    let min-dist min map [ y -> abs (y - ycor) ] other-lanes
    let closest-lanes filter [ y -> abs (y - ycor) = min-dist ] other-lanes
    set target-lane one-of closest-lanes
    set patience max-patience
  ]
end 

to move-to-target-lane ; turtle procedure
  set heading ifelse-value target-lane < ycor [ 180 ] [ 0 ]
  let blocking-cars other cars in-cone (1 + abs (ycor - target-lane)) 180 with [ x-distance <= 1 ]
  let blocking-car min-one-of blocking-cars [ distance myself ]
  ifelse blocking-car = nobody [
    forward 0.2
    set ycor precision ycor 1 ; to avoid floating point errors
  ] [
    ; slow down if the car blocking us is behind, otherwise speed up
    ifelse towards blocking-car <= 180 [ slow-down-car ] [ speed-up-car ]
  ]
end 

to-report x-distance
  report distancexy [ xcor ] of myself ycor
end 

to-report y-distance
  report distancexy xcor [ ycor ] of myself
end 

to select-car
  ; allow the user to select a different car by clicking on it with the mouse
  if mouse-down? [
    let mx mouse-xcor
    let my mouse-ycor
    if any? cars-on patch mx my [
      ask selected-car [ set color car-color ]
      set selected-car one-of cars-on patch mx my
      ask selected-car [ set color red ]
      display
    ]
  ]
end 

to-report car-color
  ; give all cars a blueish color, but still make them distinguishable
  report one-of [ blue cyan sky ] + 1.5 + random-float 1.0
end 

to-report number-of-lanes
  report num-of-lanes
end 


; See Info tab for full copyright and license.