Pac-Man HubNet Activity

;; create a breed of turtles that the students control through the clients
;; there will be one student turtle for each client.
turtles-own [ home-pos ]
patches-own [ 
  pellet-grid?  ;; true/false: is a pellet here initially?
  pacman-scent] ;; scent of pacman 

breed [ pellets pellet ]
pellets-own [ powerup? ]

breed [ bonuses bonus ]
bonuses-own [ value countdown ]

breed [ students student ]

breed [ ghosts ghost ]
ghosts-own  [ eaten? ]

breed [ pacmans pacman ]
pacmans-own  [ new-heading ]


students-own
[
  user-id   ;; students choose a user name when they log in whenever you receive a
            ;; message from the student associated with this turtle hubnet-message-source
            ;; will contain the user-id
  eat?      ;; true if the ghost has been eaten
]
globals [
  level            ;; current level
  score            ;; your score
  lives            ;; remaining lives
  extra-lives      ;; total number of extra lives you've won
  scared           ;; time until ghosts aren't scared (0 means not scared)
  level-over?      ;; true when a level is complete
  dead?            ;; true when Pac-Man is loses a life
  next-bonus-in    ;; time until next bonus is created
  tool which-ghost ;; variables needed to properly load levels 4 and above.
  test-list        ;; list of home positions for the ghosts
  user-count       ;; count of active users
  pellet-set       ;; set of patches where pellets belong
  powerup-set      ;; set of patches wher powerup pellets go
]

;; the STARTUP procedure runs only once at the beginning of the model
;; at this point you must initialize the system.

to startup
  hubnet-reset
end 

to setup
  clear-patches
  clear-drawing
  clear-output
  set level 1
  set user-count 0  
  load-map
  if path-mode [ask pellets[ die ]] ;; clear pellets if in path mode
  initialize-diffusion-values 
  set score 0
  set lives 3
  set extra-lives 0
  set scared 0
  set level-over? false
  ;; during setup you do not want to kill all the turtles
  ;; (if you do you'll lose any information you have about the clients)
  ;; so reset any variables you want to default values, and let the clients
  ;; know about the change if the value appears anywhere in their interface.
  
  ;; calling reset-ticks enables the 'go' button
  reset-ticks
end 

to load-map  ;; Observer Procedure
             ;; Filenames of Level Files
  let current-lives lives
  let current-extra-lives extra-lives
  
  import-pcolors "map.png" ;; import the patches
  setup-agents
  set lives current-lives
  set extra-lives current-extra-lives
  set dead? false
  ask pacmans
    [ set home-pos list xcor ycor ]
  ask ghosts
    [ set home-pos list xcor ycor ]
end 

;; places all agents on map and intitialize values

to setup-agents
  
  ;; kill all current non-student agents
  ask pacmans [die]
  ask ghosts [die]
  ask pellets [die]
  
  ;; put pellets on patches with a color = 1
  set pellet-set (patch-set patches with [pcolor = 1])
  foreach sort pellet-set
  [create-pellets 1 
    [
      setxy ([pxcor] of ?) ([pycor] of ?)
      set home-pos (list ([pxcor] of ?) ([pycor] of ?))
      set shape "pellet"
      set color white
      set powerup? false
    ]
  ]
  
  ;; put powerup pellets on patches with color = 2
  set powerup-set (patch-set patches with [pcolor = 2])
  foreach sort powerup-set
  [create-pellets 1
    [ 
      setxy ([pxcor] of ?) ([pycor] of ?)
      set home-pos (list ([pxcor] of ?) ([pycor] of ?))
      set shape "circle"
      set color white
      set powerup? true
    ]
  ]
  
  ;; create a pacman and place on the home tile
  create-pacmans 1
  [
    setxy 0 -5
    set home-pos (list 0 -5)
    set shape "pacman"
    set color yellow
    set heading 0
  ]
  
  ;; true if a pellet is there
  ask patches [ifelse any? pellets-here
    [set pellet-grid? true]
    [set pellet-grid? false]
  ]
  
  ;; make sure pen is up so a path is not drawn from old position of ghosts to new positon
  ask students [
    pen-up
    setxy item 0 home-pos item 1 home-pos
    set heading 0]
  
  ;; change view of clients and hide pacmans, pellets, and bonuses from view
  ask students [
    hubnet-send-follow user-id self 1
    hubnet-send-override hubnet-message-source pacmans "hidden?" [true]
    hubnet-send-override hubnet-message-source pellets "hidden?" [true]
    hubnet-send-override hubnet-message-source bonuses "hidden?" [true]
  ]
end 

to go
  ;; process incoming messages and respond to them (if needed)
  ;; listening for messages outside of the every block means that messages
  ;; get processed and responded to as fast as possible
  listen-clients
  ask students [ifelse path-mode [pen-down]
    [pen-up]]
  if dead? [ stop ]
  every 1 [ move-pacman ]
  every 1.6 [
    move-students2
    repeat diffusion-speed [set-diffusion-values]
    visualize-scent]
  if not path-mode [ every 0.25 [ update-bonuses ] ]
  if floor (score / 35000) > extra-lives
  [ set lives lives + 1
    set extra-lives extra-lives + 1 ]
  if dead?
  [ ifelse lives = 0
    [ user-message word "Game Over!\nScore: " score ]
    [ set lives lives - 1
      ifelse lives = 0
      [ user-message "You died!\nNo lives left." ]
      [ ifelse lives = 1
        [ user-message "You died!\nOnly 1 life left." ]
        [ user-message (word "You died!\nOnly " lives " lives left.") ]
      ]
      ask students [if path-mode [pen-up]]
      initialize-diffusion-values
      reset-colors
      ask pacmans
      [ setxy (item 0 home-pos) (item 1 home-pos)
        set heading 0
      ]
      ask ghosts
      [ setxy (item 0 home-pos) (item 1 home-pos)
        set heading 0
        set shape "ghost"
      ]
      ask students
      [ setxy (item 0 home-pos) (item 1 home-pos)
        set heading 0
        set shape "ghost"
      ]
      set dead? false
    ]
  stop
  ]
  if level-over? and not path-mode
  [ ask students [hubnet-reset-perspective user-id]
    user-message word "Level Complete!\nScore: " score  ;; \n means start a new line
    initialize-diffusion-values
    reset-colors
    load-map
    set level-over? false
    stop ]
  if not path-mode [ every next-bonus-in [ make-bonus ] ]
  every 0.1
  [
    ;ensure pellets, pacmans, and bonuses stay hidden (sometimes bonuses will pop up
    ;when they are created after the furst call to hubnet-send-override)
    ask students[
      hubnet-send-override hubnet-message-source pacmans "hidden?" [true]
      hubnet-send-override hubnet-message-source pellets "hidden?" [true]
      hubnet-send-override hubnet-message-source bonuses "hidden?" [true]]
    tick
  ]
end 

to gray-out-corners
  ask students [
    let my-patch-set (patch-set patch-left-and-ahead 45 1 patch-left-and-ahead 135 1 patch-left-and-ahead 225 1 patch-left-and-ahead 315 1)
    hubnet-clear-overrides user-id
    hubnet-send-override user-id my-patch-set "pcolor" [red]]
end 

;;;;;;;;;;;;;;;;;;;;;;;
;; HUBNET PROCEDURES ;;
;;;;;;;;;;;;;;;;;;;;;;;

to listen-clients
  ;; as long as there are more messages from the clients
  ;; keep processing them.
  while [ hubnet-message-waiting? ]
  [
    ;; get the first message in the queue
    hubnet-fetch-message
    ifelse hubnet-enter-message? ;; when clients enter we get a special message
    [ create-new-student ]
    [
      ifelse hubnet-exit-message? ;; when clients exit we get a special message
      [ remove-student ]
      [ ask students with [user-id = hubnet-message-source]
        [ execute-command hubnet-message-tag ] ;; otherwise the message means that the user has
      ]                                        ;; done something in the interface hubnet-message-tag
                                               ;; is the name of the widget that was changed
    ]
  ]
end 

;; when a new user logs in create a student turtle
;; this turtle will store any state on the client
;; values of sliders, etc.

to create-new-student
  set user-count user-count + 1
  if user-count < 5 [
    create-students 1
    [
      ;; store the message-source in user-id now
      ;; so when you get messages from this client
      ;; later you will know which turtle it affects
      set user-id hubnet-message-source
      ;; initialize turtle variables to the default
      ;; value of the corresponding widget in the client interface
      ;; place students depending on which order they sign on
      ;; messy but for some reason I was having trouble with using lists as globals
      if user-count = 1 [
        setxy 0 3
        set color red 
        set home-pos (list 0 3)]
      if user-count = 2 [
        setxy -1 1
        set color blue
        set home-pos (list -1 1)]
      if user-count = 3 [
        setxy 0 1
        set color pink 
        set home-pos (list 0 1)]
      if user-count = 4 [
        setxy 1 1
        set color orange 
        set home-pos (list 1 1)]
      set shape "ghost"
      set eat? false
      set heading 0
      ;; update the clients with any information you have set
      send-info-to-clients
      ;; set view and hide pacman, pellets, and bonuses
      hubnet-send-follow user-id self 1
      hubnet-send-override hubnet-message-source pacmans "hidden?" [true]
      hubnet-send-override hubnet-message-source pellets "hidden?" [true]
      hubnet-send-override hubnet-message-source bonuses "hidden?" [true]
    ]
    
  ]
end 

;; when a user logs out make sure to clean up the turtle
;; that was associated with that user (so you don't try to
;; send messages to it after it is gone) also if any other
;; turtles of variables reference this turtle make sure to clean
;; up those references too.

to remove-student
  ask students with [user-id = hubnet-message-source]
  [ die ]
end 

;; Other messages correspond to users manipulating the
;; client interface, handle these individually.

to execute-command [command]
  ;; you should have one if statement for each widget that
  ;; can affect the outcome of the model, buttons, sliders, switches
  ;; choosers and the view, if the user clicks on the view you will receive
  ;; a message with the tag "View" and the hubnet-message will be a
  ;; two item list of the coordinates
  if command = "up"
  [ execute-move 0 stop ]
  if command = "down"
  [ execute-move 180 stop ]
  if command = "right"
  [ execute-move 90 stop ]
  if command = "left"
  [ execute-move 270 stop ]
end 

;; whenever something in world changes that should be displayed in
;; a monitor on the client send the information back to the client

to send-info-to-clients ;; turtle procedure
                        ;hubnet-send user-id "location" (word "(" pxcor "," pycor ")")
end 

to execute-move [n-heading]
  set heading n-heading
  ;send-info-to-clients
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACMAN GAME PROCEDURES ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-bonuses  ;; Observer Procedure
  ask bonuses
  [ set heading heading + 13
    set countdown countdown - 1
    if countdown = 0
    [ die ] ]
end 

to move-pacman  ;; Observer Procedure
  ask pacmans
  [ ;; move forward unless blocked by wall
    let old-heading heading
    set heading new-heading
    if [pcolor] of patch-ahead 1 = blue
    [ set heading old-heading ]
    if [pcolor] of patch-ahead 1 != blue
    [ fd 1 ]
    consume
    ;; Level ends when all pellets are eaten
    if not any? pellets
    [ set level-over? true ]
    ;; Animation
    ifelse shape = "pacman"
    [ set shape "pacman open" ]
    [ set shape "pacman" ]
  ]
end 

to consume  ;; Pacman Procedure
            ;; Consume Bonuses
  if any? bonuses-here
  [ set score score + sum [value] of bonuses-here
    ask bonuses-here [ die ] ]
  
  ;; Consume Pellets
  if any? pellets-here
  [ ifelse [powerup?] of one-of pellets-here
    [ set score score + 500
      set scared 40
      ask ghosts
      [ if not eaten?
        [ set shape "scared" ] ]
    ]
    [ set score score + 100 ]
  ask pellets-here [ die ] ]
  
  ;; Ghosts
  if any? ghosts-here with [not eaten?]
  [ ifelse scared = 0
    [ set dead? true ]
    [ ask ghosts-here with [not eaten?]
      [ set eaten? true
        set shape "eyes"
        set score score + 500 
      ]
    ]
  ]
  
  ;; Students
  if any? students-here with [not eat?]
  [ ifelse scared = 0
    [ set dead? true ]
    [ ask students-here with [not eat?]
      [ set eat? true
        set shape "eyes"
        hubnet-reset-perspective user-id
        set score score + 500 ]
    ]
  ]
end 

to make-bonus ;; Observer Procedure
  ifelse next-bonus-in = 0
  [ set next-bonus-in 10 ]
  [ let bonus-patch one-of patches with [pellet-grid? and
    not any? bonuses-here and
    not any? pellets-here]
  if bonus-patch != nobody
    [ ask bonus-patch
      [ sprout-bonuses 1
        [ set shape "star"
          set heading 0
          set color random 14 * 10 + 5
          set value (random 10 + 1) * 100
          set countdown random 200 + 50 ] ]
    set next-bonus-in 5 + random 10 ] ]
end 

to return-home  ;; Ghosts Procedure
  let dirs clear-headings
  let new-dirs remove opposite heading dirs
  let home-dir 0
  if pcolor != gray
    [ set home-dir towards one-of patches with [pcolor = gray] ]
  let home-path 90 * round (home-dir / 90)
  
  if length new-dirs = 1
  [ set heading item 0 new-dirs ]
  if length new-dirs > 1
  [ ifelse position home-path new-dirs != false
    [ set heading home-path ]
    [ set heading one-of new-dirs ]
  ]
  fd 1
end 

to-report clear-headings ;; ghosts procedure
  let dirs []
  if [pcolor] of patch-at 0 1 != blue
  [ set dirs lput 0 dirs ]
  if [pcolor] of patch-at 1 0 != blue
  [ set dirs lput 90 dirs ]
  if [pcolor] of patch-at 0 -1 != blue
  [ set dirs lput 180 dirs ]
  if [pcolor] of patch-at -1 0 != blue
  [ set dirs lput 270 dirs ]
  report dirs
end 

to-report opposite [dir]
  ifelse dir < 180
  [ report dir + 180 ]
  [ report dir - 180 ]
end 

to choose-heading  ;; Ghosts Procedure
  let dirs clear-headings
  let new-dirs remove opposite heading dirs
  let pacman-dir false
  
  if length dirs = 1
  [ set heading item 0 dirs ]
  if length dirs = 2
  [ ifelse see-pacman item 0 dirs
    [ set pacman-dir item 0 dirs ]
    [ ifelse see-pacman item 1 dirs
      [ set pacman-dir item 1 dirs ]
      [ set heading one-of new-dirs ]
    ]
  ]
  if length dirs = 3
  [ ifelse see-pacman item 0 dirs
    [ set pacman-dir item 0 dirs ]
    [ ifelse see-pacman item 1 dirs
      [ set pacman-dir item 1 dirs ]
      [ ifelse see-pacman item 2 dirs
        [ set pacman-dir item 2 dirs ]
        [ set heading one-of new-dirs ]
      ]
    ]
  ]
  if length dirs = 4
  [ ifelse see-pacman item 0 dirs
    [ set pacman-dir item 0 dirs ]
    [ ifelse see-pacman item 1 dirs
      [ set pacman-dir item 1 dirs ]
      [ ifelse see-pacman item 2 dirs
        [ set pacman-dir item 2 dirs ]
        [ ifelse see-pacman item 3 dirs
          [ set pacman-dir item 3 dirs ]
          [ set heading one-of new-dirs ]
        ]
      ]
    ]
  ]
  if pacman-dir != false
  [ ifelse scared = 0
    [ set heading pacman-dir ]
    [ set dirs remove pacman-dir dirs
      set heading one-of dirs
    ]
  ] 
  fd 1
end 

to-report see-pacman [dir] ;; ghosts procedure
  let saw-pacman? false
  let p patch-here
  while [[pcolor] of p = black]
  [ ask p
    [ if any? pacmans-here
      [ set saw-pacman? true ]
    set p patch-at sin dir cos dir ;; next patch in direction dir
    ]
  ;; stop looking if you loop around the whole world
  if p = patch-here [ report saw-pacman? ]
  ]
  report saw-pacman?
end 

to move-up
  ask pacmans [ set new-heading 0 ]
end 

to move-right
  ask pacmans [ set new-heading 90 ]
end 

to move-down
  ask pacmans [ set new-heading 180 ]
end 

to move-left
  ask pacmans [ set new-heading 270 ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; COLLABORATIVE DIFFUSION PROCEDURES ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;set initial diffusion values

to initialize-diffusion-values  
  ask patches [set pacman-scent 0] 
  ask pacmans [ask patch-here [set pacman-scent 1000]]
end 

;;update diffusion values

to set-diffusion-values
  ask students [if shape != "eyes" [ask patch-here [set pacman-scent 0]]]
  ask pacmans [ask patch-here [set pacman-scent 1000]]
  diffuse4 pacman-scent 1
  ask patches [if pcolor = blue or pcolor = gray [set pacman-scent 0]]
  ask students [if shape != "eyes" [ask patch-here [set pacman-scent 0]]] 
  ask pacmans [ask patch-here [set pacman-scent 1000]] 
end 

;;visualize the pacman-scent

to visualize-scent
  let min-log-dif min [log-val] of patches with [ pacman-scent > 0 ]
  let max-log-dif max [log-val] of patches with [ pacman-scent > 0 ]
  if min-log-dif != max-log-dif [
    ask patches [
      ifelse pacman-scent != 0
      [set pcolor scale-color green log-val min-log-dif max-log-dif ]
      [if pcolor != blue and pcolor != gray [set pcolor black]]
    ]]
end 

to reset-colors
  ask patches [if pcolor != blue and pcolor != gray [set pcolor black]]
end 

to-report log-val 
  report log (pacman-scent) 10
end 

;;get new heading for cd code

to get-heading
  let target max-one-of neighbors4 with 
    [not any? ghosts-here and pcolor != blue]
    [pacman-scent]
  if target != nobody [
    set heading towards target
    fd 1]
end 

;move ghosts for collaborative diffusion

to move-ghosts-cd  ;; Observer Procedure
  ask ghosts
  [ ifelse eaten?
    [ if [pcolor] of patch-at 0 1 = gray
      [ set eaten? false
        set shape "ghost" ]
    return-home
    ]
    [ ifelse scared > 0
      [choose-heading] ;;use the old method so the ghosts don't swarm the pacman when frightened
                       ;;going down the gradient not a good idea because of too many local minima 
                       ;;from pacman moving around
      [get-heading ]]]
  if scared > 0
  [ set scared scared - 1
    ifelse scared < 10 and scared mod 2 = 0
    [ ask ghosts with [not eaten?]
      [ set shape "ghost" ] ]
    [ ask ghosts with [not eaten?]
      [ set shape "scared" ] ]
    if scared = 0
    [ ask ghosts with [not eaten?]
      [ set shape "ghost" ]
    ]
  ]
end 

;;move students, hubnet

to move-students2
  ;;if student eaten, reset perspective so they can find their way home
  ask students [
    if eat?
    [ if [pcolor] of patch-at 0 1 = gray
      [ set eat? false
        set shape "ghost" 
        hubnet-send-follow user-id self 1 ]
    ]
    ;; move forward if not up against a wall or if an eaten ghost is ahead of you
    if [pcolor] of patch-ahead 1 != blue and ( not any? ((students-on patch-ahead 1) with [shape != "eyes"]) or shape = "eyes" )
    [fd 1] 
    
    ;; sent pacman scent to zero at the gray patch
    if [pcolor] of patch-here != gray [ask patch-here [set pacman-scent 0]]]
  
  if scared > 0
    [ set scared scared - 1
      ifelse scared < 10 and scared mod 2 = 0
      [ ask students with [ not eat? ]
        [ set shape "ghost" ] ]
      [ ask students with [ not eat? ]
        [ set shape "scared" 
        ] ]
      if scared = 0
      [ ask students with [ not eat? ]
        [ set shape "ghost" ]
      ]
      
    ]   
end 

; Public Domain:
; To the extent possible under law, Uri Wilensky has waived all
; copyright and related or neighboring rights to this model.