FormulaT - Pitboss

extensions [
   sound
]
globals [
  speed-out                                                    
  speed-out2
  slide
  best-time
  last-time
  previous-heading
  velocity-data
  car-ahead
  next-turtle
]
turtles-own [
  speed
  speed-other
  max-speed
  ring-done?
  square-done?
  hard-done?
  vel-data
  acc-data
  min-speed
  sound-flag?
  old-heading
]
breed [ player-cars player-car ]
breed [ other-cars other-car ]

;;;;;;;;;;;;;;;;;;;;;;
;; Setup procedures ;;
;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  reset-timer
  set-up-track
  make-cars
  speed-legend
  create-markers
  user-message "Ok kid now lets see if you've got what it takes to be a pitboss! You have two main options, you can drive by paint, or drive by graph. If you choose to paint, choose whether you're painting velocity or acceleration. If you're going to drive by graphing, be sure to make a velocity graph in the FormulaT-graphing model. Good luck! "
end 

to make-cars
  create-player-cars 1 [                                       ;; set up the player's car
    set size 20
    set shape "car"
    set heading 0
    set color blue
    set xcor max-pxcor * 0.85
    set ycor 6
    set speed 0
    set max-speed 12
    set sound-flag? false
  ]
end 

to set-up-track
  if Choose-Track = "Ring" [                                   ;; load maps
    import-pcolors "ringtrack.png"
  ]
  if Choose-Track = "Square" [
    import-pcolors "squaretrack.png"
  ]
  if Choose-Track = "Hard" [
    import-pcolors "hardtrack.png"
  ]
  
  ask patches with [ pcolor = 0.3 ] [                           ;; tweak patch colors so they're easier to identify (may not be necessary)
    set pcolor black
  ]
  ask patches with [ pcolor = 64.4 ] [
    set pcolor green
  ]

  ask patches with [pxcor > 200 and abs pycor <= 5 and pcolor = black] [   ;; make finishing line
    set pcolor yellow
  ]
end 

to load-data                                                        ;; Loads data from previously made .txt file
  let file user-file                                            ;; user chooses file from a pop up window

  if ( file != false )
  [
    set velocity-data []                                            ;; creates a list and dumps the graphing data into the list
    file-open file

    while [ not file-at-end? ]
      [ set velocity-data sentence velocity-data (list (list file-read file-read file-read)) ]

    user-message "File loading complete!"
    file-close
  ]
end 

to train-turtles                                                     ;; takes the data from the list we just created and sets turtle variables
  ifelse ( is-list? velocity-data )
    [ foreach velocity-data [ ask turtle first ? [ set vel-data item 1 ? set acc-data last ? ] ] ]  ;; [ # (turtle who) # (vel-data) # (acc-data) ]...find the turtle then set the variables
    [ user-message "You need to load in patch data first!" ]
end 

to speed-legend
  ifelse paint-sets = "Max-Speed" [
    output-print "              Max-Speed"
    output-print "Violet            1"
    output-print "Blue              2"
    output-print "Cyan              3"
    output-print "Orange            4"
    output-print "Red               5"
    output-print "Black            Max"
  ] [
    output-print "              Acceleration"
    output-print "Violet           -0.07"
    output-print "Blue             -0.05"
    output-print "Cyan             -0.03"
    output-print "Orange           +0.03"
    output-print "Red              +0.05"
    output-print "Black              0"
  ]
end 


;;;;;;;;;;;;;;;;;;;
;; go procedures ;;
;;;;;;;;;;;;;;;;;;;

to go
  ask turtle 0 [                                                   ;; reset timer at the beginning of the race
    if speed = 0
      [ reset-timer ]
  ]
  if time-limit? = true [
    ask turtle 0 [                                                   ;; reset timer at the beginning of the race
      if speed = 0
        [ reset-timer ]
      if Choose-Track = "Ring" [                                     ;; sets an effective time limit for races depending on the track
        if timer > 6                                                ;; this is done to encourage the player to get around the track at the highest speed possible
          [ set speed 0
            set shape "x"
            user-message "You took too long!  Try again letting the car get a bit faster this time!  Press 'Halt' and 'Reset Car'." ]
      ]
      if Choose-Track = "Square" [
        if timer > 5
          [ set speed 0
            set shape "x"
            user-message "You took too long!  Try again letting the car get a bit faster this time!  Press 'Halt' and 'Reset Car'." ]
      ]
      if Choose-Track = "Hard" [
        if timer > 7
          [ set speed 0
            set shape "x"
            user-message "You took too long!  Try again letting the car get a bit faster this time!  Press 'Halt' and 'Reset Car'." ]
      ]
    ]
  ]
  
  if data-source = "Graph"                                         ;; look at the chooser to see which data method to use
    [ drive-by-graph ]
  if data-source = "Paint"
    [ drive-by-color ]
  
  ask turtle 0 [                                                  
    if any? patches in-cone 5 30 with [ pcolor = yellow ]         ;; win if you cross the yellow line
      [ set speed 0                                                
        set last-time timer                                       ;; set up last-time and best-times
        if best-time = 0 or last-time < best-time [ set best-time last-time ]
        set shape "face happy"
        if choose-track = "Ring"                                  ;; a flag that gets set when the player finishes each track
          [ set ring-done? true ]
        if choose-track = "Square"
          [ set square-done? true ]
        if choose-track = "Hard"
          [ set hard-done? true ] ]
              
     if shape = "face happy"                                      ;; checks to see how many tracks you've finished
       [ ifelse Ring-done? = true                                 ;; player has to finish all tracks to move on
         [ ifelse Square-done? = true
           [ ifelse Hard-done? = true
             [ sound:play-sound "win.wav"
               user-message "You completed all the tracks! There are no more challenges! You are the FormulaT Champion!" ]
             [ user-message "You completed this track!  Press 'Halt' choose a new track, then press 'Reset Track' to attempt the next track!"]
           ]
           [ user-message "You completed this track!  Press 'Halt' choose a new track, then press 'Reset Track' to attempt the next track!"]
         ]
         [ user-message "You completed this track!  Press 'Halt' choose a new track, then press 'Reset Track' to attempt the next track!"]  
    ]
  ]
  ask player-cars [
    if [pcolor] of patch-ahead 1 = green                         ;; if the pach ahead is grass, report a crash
      [ set speed 0 
        set shape "x"
        if sound-flag? = false [
          sound:play-sound "crashed.wav"
          set sound-flag? true
        ]
        user-message "You crashed! Press 'halt' then 'Next Track' to try again!"
      ]
   set slide speed * 1.5                                         ;; slide increases as speed increases (this number may still need adjusting)
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;
;;  DRIVE BY GRAPH  ;;      If the player chooses this option they will be using the loaded graph data to determine the vehicle's speed and acceleration
;;;;;;;;;;;;;;;;;;;;;;

to drive-by-graph
  ask player-car 0 [
    let acc-factor 0.03                                                         ;; uses a variable for acceleration so it can be easily tweaked
    if next-turtle = 0 [                                                        ;; sets next-turtle variable to 1
      set next-turtle 1
    ]
    if distance turtle next-turtle > 50 and next-turtle = 1                     ;; if no turtle in range, gradually speed up (so the car doesn't get stuck in the beginning)
      [ set speed speed + acc-factor
        face turtle next-turtle
        fd speed ]
    if distance turtle next-turtle < 50                                         ;; checks to see if "next-turtle" is in range
      [ set vel-data [vel-data] of turtle next-turtle                           ;; sets vel-data & acc-data of player-car to the data in the marker turtle
        set acc-data [acc-data] of turtle next-turtle
        if speed < vel-data
          [ set max-speed vel-data ]                                            ;; sets max-speed to the vel-data if going slower than data
        if speed > vel-data
          [ set min-speed vel-data ]                                            ;; sets min-speed to the vel-data if going faster than data
        if speed != vel-data                                                  ;; if the player-car isn't going the correct speed according to the graph
          [ set speed speed + (acc-data * acc-factor) ]                             ;; adjusts speed using the acc-data (multiplied by the acc-factor for tweaking purposes)
        if speed = vel-data
          [ set speed vel-data ]
        ifelse turtle (next-turtle + 1) = nobody                                ;; looks for the last marker-turtle, if we're on it
          [ 
            set next-turtle 1
            face turtle next-turtle                                             ;; turn towards turtle 1 and adjust heading based on speed
            set heading (heading + (speed ^ 1.5) )
             ]
          [ if distance turtle next-turtle < 25 [                         ;; look ahead to see if next-turtle + 1 is getting close...
            set next-turtle (next-turtle + 1)                             ;; if it is, make that the new "next-turtle"
            set old-heading heading                                       ;; saves this heading to use in the following procedures
            face turtle next-turtle
            ifelse (heading - old-heading) < 190 [                        ;; check to make sure the car is making a slight turn
              if old-heading > heading [                                  ;; if it is and it's turning left
                set heading (heading +  (speed ^ 1.5) )               ;; add to the heading a random value between 0 and speed squared
              ]
              if old-heading < heading [                                  ;; if it's turning right
                set heading (heading - (speed ^ 1.5) )               ;; subtract to the heading a random value between 0 and speed squared
              ] ] [
              if old-heading > heading [                                  ;; if this is a big turn (greater than 190 degree turn)
                set heading (heading + (speed ^ 3) )               ;; do the same kind of stuff but make it a random value between 0 and speed to the fourth
              ]
              if old-heading < heading [
                set heading (heading - (speed ^ 3) )
              ] ]
            fd speed           
            ]
          ]
      ]

    if speed > max-speed [                                      ;; keeps the car from going above max-speed
      set speed speed - acc-factor
    ]
    
    if speed < min-speed [                                      ;; keeps the car from going below the min-speed
      set speed min-speed
    ]

    if speed != vel-data [                                      
      set speed speed + (acc-data * acc-factor)
    ]
    
    if speed < 0 [                                              ;; keeps speed from going negative (probably don't need anymore...)
      set speed 0
    ]
    fd speed
  ]
  colortrail
  tick
  do-plots
end 

;;;;;;;;;;;;;;;;;;;;;;
;;  DRIVE BY COLOR  ;;
;;;;;;;;;;;;;;;;;;;;;;

to drive-by-color
  ask player-car 0 [
     if paint-sets = "Acceleration"                             ;; if paint-acceleration? switch is true, paint changes the car's rate of deceleration
       [
         if [pcolor] of patch-here = violet
           [ set speed speed - 0.07 ]
         if [pcolor] of patch-here = blue
           [ set speed speed - 0.05 ]
         if [pcolor] of patch-here = cyan
           [ set speed speed - 0.03 ]
         if [pcolor] of patch-here = orange
           [ set speed speed + 0.03 ]
         if [pcolor] of patch-here = red
           [ set speed speed + 0.05 ]
       ]
     if paint-sets = "Max-Speed"
       [
         if [pcolor] of patch-here = violet                          ;; if paint-acceleration? switch is false, paint changes the car's max speed
           [ set max-speed 1 ]
         if [pcolor] of patch-here = blue
           [ set max-speed 2 ]
         if [pcolor] of patch-here = cyan
           [ set max-speed 3 ]
         if [pcolor] of patch-here = orange
           [ set max-speed 4 ]
         if [pcolor] of patch-here = red
           [ set max-speed 5 ]
         if [pcolor] of patch-here = black
           [ set max-speed 20 ]
         set speed speed + 0.03                                      ;; gradually speeds up
       ]                

    if ( speed - max-speed ) >= 3                               ;; crashes if the player tries to lower the max-speed too quickly (only happens when painting max-speed)
      [ set speed 0                                             
        set shape "face sad"
        user-message "You can't slow down that fast! Press 'Halt' then 'Next Track' to try again!"
      ]

    if speed > max-speed [                                      ;; keeps the car from going above max-speed
      set speed speed - 0.1
    ]

    if speed < 0 [                                              ;; keeps speed from going negative
      set speed 0
    ]

    if next-turtle = 0 [                                                        ;; sets next-turtle variable to 1
      set next-turtle 1
    ]
    if distance turtle next-turtle > 50 and next-turtle = 1                     ;; if no turtle in range, gradually speed up (so the car doesn't get stuck in the beginning)
      [ face turtle next-turtle
        fd speed ]
    if distance turtle next-turtle < 60                                         ;; checks to see if "next-turtle" is in range
      [ fd speed 
        ifelse turtle (next-turtle + 1) = nobody                                ;; looks for the last marker-turtle, if we're on it
          [ set next-turtle 1
            face turtle next-turtle                                             ;; turn towards turtle 1 and adjust heading based on speed
            set heading (heading + (speed ^ 1.5) )
             ]
          [ if distance turtle next-turtle < 25 [                         ;; look ahead to see if next-turtle + 1 is getting close...
              set next-turtle (next-turtle + 1)                             ;; if it is, make that the new "next-turtle"
              set old-heading heading                                       ;; saves this heading to use in the following procedures
              face turtle next-turtle
              
              ifelse (heading - old-heading) < 190 [                        ;; check to make sure the car is making a slight turn
                if old-heading > heading [                                  ;; if it is and it's turning left
                  set heading (heading + (speed ^ 1.5) )               ;; add to the heading a random value between 0 and speed squared
                ]
                if old-heading < heading [                                  ;; if it's turning right
                  set heading (heading - (speed ^ 1.5) )               ;; subtract to the heading a random value between 0 and speed squared
                ] ] [
                if old-heading > heading [                                  ;; if this is a big turn (greater than 190 degree turn)
                  set heading (heading + (speed ^ 3) )               ;; do the same kind of stuff but make it a random value between 0 and speed to the fourth
                ]
                if old-heading < heading [
                  set heading (heading - (speed ^ 3) )
                ] ]
                
              fd speed                                  
            ]
;;          set next-turtle (next-turtle + 1)
;;          set old-heading heading
;;          face turtle next-turtle
          ]
      ]
  fd speed
]
  tick
  do-plots
end 

to do-plots
  set-current-plot "Car-Stats"
  set-current-plot-pen "velocity"
  plot [speed] of player-car 0                                      ;; plot the velocity of your car
  ask player-car 0 [                                                ;; pen color based on speed of car
    if speed <= 1 [
    set-plot-pen-color 115
  ]
  if ( speed > 1 and speed <= 2 ) [
    set-plot-pen-color 105
  ]
  if ( speed > 2 and speed <= 3 ) [
    set-plot-pen-color 85
  ]
  if ( speed > 3 and speed <= 4 ) [
    set-plot-pen-color 25
  ]
  if ( speed > 4 and speed <= 5 ) [
    set-plot-pen-color 15
  ]
  if speed > 5 [
    set-plot-pen-color 0
  ]]
  if graph-mode = "Scrolling Graph"
    [
      if ticks > 50                                                  ;; creates a rolling plot if full-graph? is turned off
      [ set-plot-x-range (ticks - 50) ticks ]
    ]
end 

;;;;;;;;;;;;;;;;;;;;;
;; button commands ;;
;;;;;;;;;;;;;;;;;;;;;

to patch-draw
  if mouse-down?     ;; reports true or false to indicate whether mouse button is down
    [
      if speed-color = "Violet" [                  ;; sets color based on chooser
        ask patch mouse-xcor mouse-ycor            ;; paints at location of mouse
          [ ask patches in-radius 20       ;; size of painted area based on slider
            [ if pcolor != green and pcolor != yellow                   ;; doesn't paint over grass
              [ set pcolor violet ] ] ] ]
      if speed-color = "Blue" [
        ask patch mouse-xcor mouse-ycor
          [ ask patches in-radius 20        
            [ if pcolor != green and pcolor != yellow
              [ set pcolor blue ] ] ] ]
      if speed-color = "Cyan" [
        ask patch mouse-xcor mouse-ycor
          [ ask patches in-radius 20        
            [ if pcolor != green and pcolor != yellow
              [ set pcolor cyan ] ] ] ]
      if speed-color = "Orange" [
        ask patch mouse-xcor mouse-ycor
          [ ask patches in-radius 20
            [ if pcolor != green and pcolor != yellow
              [ set pcolor orange ] ] ] ]
      if speed-color = "Red" [
        ask patch mouse-xcor mouse-ycor
          [ ask patches in-radius 20
            [ if pcolor != green and pcolor != yellow
              [ set pcolor red ] ] ] ]
      if speed-color = "Black" [
        ask patch mouse-xcor mouse-ycor
          [ ask patches in-radius 20
            [ if pcolor != green and pcolor != yellow
              [ set pcolor black ] ] ] ]                                         
    ]
end 

to reset-track                                            ;; resets track without reseting flags
  clear-all-plots
  set-up-track
  ask player-car 0 [                                       
    set size 20
    set shape "car"
    set heading 0
    set color blue
    set xcor max-pxcor * 0.85
    set ycor 6
    set speed 0
  ]
end 

to save-track-image
  let file user-new-file

  if ( file != false )
  [
    if file-exists? file [  ;; overwrites files of the same name
      file-delete file
    ]
    export-view file
  ]
end 

to next-race
  run "__magic-open \\"FormulaT-graphing\\""              ;; should open the next race...
end 

;;;;;;;;;;;;;;;;;;;;;;
;; COLOR TRAIL CODE ;;  Leaves a trail of color behind the player car that corresponds to the vehicle's velocity
;;;;;;;;;;;;;;;;;;;;;;

to colortrail
  ask player-car 0 [
    rt 180
    if speed <= 1 [
      ask patches in-cone 6 120 [
        set pcolor violet
      ]
    ]
    if speed <= 2 and speed > 1 [
      ask patches in-cone 6 120 [
        set pcolor blue
      ]
    ]
    if speed <= 3 and speed > 2 [
      ask patches in-cone 6 120 [
        set pcolor cyan
      ]
    ]
    if speed <= 4 and speed > 3 [
      ask patches in-cone 6 120 [
        set pcolor orange
      ]
    ]
    if speed <= 5 and speed > 4 [
      ask patches in-cone 6 120 [
        set pcolor red
      ]
    ]
    if speed > 5 [
      ask patches in-cone 6 120 [
        set pcolor black
      ]
    ]
    rt 180                    
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; MARKER MAKING AND MOVING PROCEDURE ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to create-markers                                                ;; creates turtles to split up the track into 20 equal parts
  if Choose-Track = "Ring" or Choose-Track = "Square" [
    
  set previous-heading 0                                        ;; sets to zero so the first turtle is in the correct spot
  repeat 3 [
    crt 1 [
    set heading 90                                              ;; tweaks heading so numbers start from starting line
    set size 5
    set color black
    set label who                                               ;; shows turtle number
    left previous-heading + 14                                  ;; sets up a recursion procedure so that turtles at different areas of the track adjust by different amounts
    set previous-heading previous-heading + 14
    ]
  ]
  repeat 4 [
    crt 1 [
    set heading 90                                              
    set size 5
    set color black
    set label who                                               
    left previous-heading + 24                                  
    set previous-heading previous-heading + 24
    ]
  ]
  
  repeat 6 [
    crt 1 [
    set heading 90                                              
    set size 5
    set color black
    set label who                                               
    left previous-heading + 14                                  
    set previous-heading previous-heading + 14
    ]
  ]
  repeat 4 [
    crt 1 [
    set heading 90                                              
    set size 5
    set color black
    set label who                                               
    left previous-heading + 24                                  
    set previous-heading previous-heading + 24
    ]
  ]
  repeat 3 [
    crt 1 [
    set heading 90                                              
    set size 5
    set color black
    set label who                                               
    left previous-heading + 14                                  
    set previous-heading previous-heading + 14
    ]
  ]
  ask turtles with [ who > 0] [
    repeat 300 [
      ifelse ([pcolor] of patch-here = black or [pcolor] of patch-here =  yellow) and ([pcolor] of patch-ahead 30 = green)  ;; they need to be on black first, then close to the edge of the green
        [ stop ]                                                ;; stop once they're in the correct spot
        [ fd 1 ]
      ]
    ]
  ]
  if Choose-Track = "Hard" [
    crt 20 [
    set size 5
    set color black
    set label who
    ]
    ask turtle 1 [ setxy 282 84 ]
    ask turtle 2 [ setxy 229 153 ]
    ask turtle 3 [ setxy 121 161 ]
    ask turtle 4 [ setxy 27 127 ]
    ask turtle 5 [ setxy -78 155 ]
    ask turtle 6 [ setxy -279 121 ]
    ask turtle 7 [ setxy -288 -10 ]
    ask turtle 8 [ setxy -286 -134 ]
    ask turtle 9 [ setxy -237 -139 ] 
    ask turtle 10 [ setxy -170 -20 ]
    ask turtle 11 [ setxy -181 36 ]
    ask turtle 12 [ setxy -154 85 ]
    ask turtle 13 [ setxy -84 56 ]
    ask turtle 14 [ setxy -3 -39 ]
    ask turtle 15 [ setxy -79 -141 ]
    ask turtle 16 [ setxy -14 -160 ]
    ask turtle 17 [ setxy 33 -121 ]
    ask turtle 18 [ setxy 202 -165 ]
    ask turtle 19 [ setxy 280 -73 ]
    ask turtle 20 [ setxy 283 0 ]
  ]
end