Root Beer Game

globals [
  colors         ;; the available team colors (don't use all of them for aesthetic reasons)
  color-names    ;; the colors in words
  roles          ;; the names of the possible roles on each team
]

;; each client is represented by a player turtle
breed [ players player ]
players-own
[
  user-id
  inventory
  back-orders       ;; at the end of each week back-orders will be calculated if
                    ;; your inventory does not meet the demand
  my-team
  order             ;; a direct reflection of the value in the ORDERS-TO-PLACE
                    ;; slider on the client this changes any time the user moves the slider
  last-received     ;; the last number of cases added to your inventory
  order-placed?     ;; whether or not you've placed an order this week, once you have placed an
                    ;; order you cannot change it until the next week. Once all players on a team
                    ;; have placed an order the week is advanced.
  role              ;; factory, distributor, wholesaler, or retailer depending on
                    ;; your place in the chain
  ordered           ;; the number of cases of root beer ordered this week,
                    ;; once you have pressed the PLACE-ORDER button on the client
                    ;; you cannot change this number until next week
]

;; there are four players per team the team breed
;; is mainly used to keep track of information
breed [ teams team ]
teams-own
[
  members       ;; the number of members on the team
  cost          ;; the instantaneous cost of the entire team at the end of the last week.
  demand        ;; the number of cases requested by the public
  last-player   ;; keep track of the last player in the chain so it's easy to add players
  color-name
  clock         ;; each team has their own clock since the end of the week occurs
                ;; only when all players have placed an order
  last-received ;; the last number of cases added to inventory
  inventory     ;; the number of cases currently stored by this player
]

;; there are two types of links in the game
;; there are links that players use to request root beer
;; from the players up the chain, the demand links,
;; and the supply links move the goods from
;; one player to another.

directed-link-breed [ supply-links supply-link ]
supply-links-own
[
  orders-filled ;; a list PERIODS-OF-DELAY long, each time the source player ships the current order
                ;; is placed on the end of the list and the order at the beginning of the list is
                ;; popped off and added to the destination player's inventory
]

directed-link-breed [ demand-links demand-link ]
demand-links-own
[
  orders-placed  ;; the number of cases requested by the player at the source,
                 ;; this is the demand for the player at the destination end of the link
]

;;
;; Setup Procedures
;;

to startup
  hubnet-reset
  ;; setup basic appearance globals
  set-default-shape players "circle"
  set-default-shape teams "square"
  set colors [ red blue green violet pink orange brown yellow ]
  set color-names [ "red" "blue" "green" "violet" "pink" "orange" "brown" "yellow" ]
  set roles [ "retailer" "distributor" "wholesaler" "factory" ]
  setup
end 


;; start the game over with the same players
;; initial conditions, each player has placed an order of 4
;; and has an inventory of 12.

to setup
  ask supply-links
    [ set orders-filled n-values periods-of-delay [ 0 ]  ]
  ask demand-links
    [ set orders-placed 4 ]
  ask teams [
    set cost 0
    set clock 1
    if not any? out-demand-link-neighbors
    [ die ]
  ]
  ask players
  [
    set inventory 12
    set back-orders 0
    set last-received 0
    set order-placed? false
    set color [color] of my-team + 2
    set ordered 4
    update-player
  ]
  reset-plot
end 

;;
;; Runtime Procedures
;;

to go
  ;; the flow of the activity is completely controlled by actions
  ;; of the clients. when everyone on the team has placed an order
  ;; the entire team moves on the next week. Teams may be on different days
  listen-to-clients
  every 0.1
  [
    display
  ]
end 

to listen-to-clients
  while [ hubnet-message-waiting? ]
  [
    hubnet-fetch-message
    ifelse hubnet-enter-message?
    [ create-new-student ]
    [
      ifelse hubnet-exit-message?
      [ remove-student ]
      [
        execute-command hubnet-message-tag
      ]
    ]
  ]
end 

to end-week ;; team procedure
  ;; calculate the cost for the entire team
  set cost sum [ inventory * 0.5 + back-orders ] of
                   players with [ my-team = myself ]

  plot-cost
  plot-shipped
  ;; the last player is the factory
  ask last-player [ plot-orders ]

  ;; update the external demand to the retailer that drives the game
  ask my-out-demand-links
  [
    ;; the demand starts at 4 cases per week. In week 7 it rises to
    ;; 8 cases and remains there the rest of the time.
    set orders-placed ifelse-value ([clock] of myself <= 5) [ 4 ][ 8 ]
  ]

  ;; produce the goods at the factory level
  let orders-requested sum [ orders-placed ] of my-in-demand-links

  ask my-out-supply-links
  [ set orders-filled lput orders-requested orders-filled ]

  ;; move goods into the factory, even though the factory
  ;; has the ability to produce an infinite amount of goods
  ;; there are still PERIODS-OF-DELAY weeks between the time
  ;; they place the order for goods and the time it is produced.
  ask out-supply-link-neighbors
  [
     set last-received sum [ first orders-filled  ] of my-in-supply-links
     ask my-in-supply-links [ set orders-filled but-first orders-filled ]
     set inventory inventory + last-received
  ]

  ;; everything is purchased on the retailer level
  set inventory 0

  ;; advance the week
  set clock clock + 1
  ;; update the client information for the next round
  ask players with [ my-team = myself ]
  [
    set order-placed? false
    set color [color] of my-team + 2
    ask my-out-demand-links [ set orders-placed [ordered] of myself ]
  ]
end 

to place-order ;; player procedure
  ;; only change the order if we haven't
  ;; done so this week as each player can only
  ;; place 1 order per day and cannot change it
  ;; once it is placed
  if not order-placed?
  [
    set order-placed? true
    set color [color] of my-team
    set ordered order
    update-player
  ]

  let teammates players with [ my-team = [my-team] of myself ]

  ;; once the last player has placed an order
  ;; all players ship and advance the week
  if not any? teammates with [ not order-placed? ]
  [
    ask teammates
    [
      ship
      ask my-out-demand-links
        [ set orders-placed [ordered] of myself ]
    ]
    ask my-team
    [
      if clock <= weeks-of-simulation
      [ end-week ]
    ]
    ;; make sure the info on the client gets updated
    ask teammates
    [ update-player ]
  ]
end 

to ship
  ;; move all the supplies along the chain.
  ask out-supply-link-neighbors
  [
    ;; grab the shipment at the beginning of the list
    ;; and add it to my inventory
    set last-received sum [ first orders-filled  ] of my-in-supply-links
    ask my-in-supply-links
      [ set orders-filled but-first orders-filled ]
    set inventory inventory + last-received
  ]

  ;; determine how many orders you need to send upstream
  ;; this will be no more than the number of orders requested
  ;; plus back orders or your inventory whichever is smaller
  let new-orders [orders-placed] of one-of my-in-demand-links
  let orders-requested new-orders + back-orders

  ;; determine how much we can send given our current inventory
  let orders-to-ship min list orders-requested inventory

  ;; if there's not enough inventory they become back-orders
  set back-orders max list 0 ( back-orders - inventory + new-orders )

  ;; add the shipment to the shipping queue
  ask my-out-supply-links
    [ set orders-filled lput orders-to-ship orders-filled ]
  set inventory inventory - orders-to-ship
end 

;;
;; HubNet Procedures
;;

to create-new-student
  ;; if there are no incomplete teams
  ;; create a new one
  if not any? teams with [ members < 4 ]
  [ create-team ]

  add-student-to one-of teams with [ members < 4 ]
end 

to create-team
 ;; there is one team per row in the world, if
 ;; we've run out of rows the user should
 ;; just make the size of the world larger
 let p one-of patches with [ pxcor = max-pxcor and not any? teams-here ]
 ifelse p != nobody
 [
  create-teams 1
  [
    set members 0
    set cost 0
    set demand 4
    set last-player self
    move-to p
    set-color
    set size 0.5
    create-plot-pens
    set clock 1
  ]
 ]
 [ user-message "There is no more space for a new team, please increase the size of the world" ]
end 

;; grab a random color from the list of distinguishable colors

to set-color
  ;; if the size of the world is increased we have to reuse colors
  if length colors = 0
  [
    set colors [ red blue green violet pink orange brown yellow ]
    set color-names [ "red" "blue" "green" "violet" "pink" "orange" "brown" "yellow" ]
  ]
  let index random length colors
  set color item index colors
  set color-name item index color-names
  set colors remove-item index colors
  set color-names remove-item index color-names
end 

to add-student-to [team]
  create-players 1
  [
    set user-id hubnet-message-source
    set label user-id
    set inventory 12
    set back-orders 0
    set order 4
    set ordered 0
    ;; attach the new player to the end of the chain.
    ask [last-player] of team
    [
       create-demand-link-to myself
         [ set orders-placed 4 ]
       create-supply-link-from myself
         [ set orders-filled n-values periods-of-delay [ 0 ] ]
    ]
    ;; set up directly left of the current last player
    setxy [xcor] of [last-player] of team - 1 [ycor] of [last-player] of team
    set my-team team
    set role my-role [members] of my-team
    ask team
    [
      set last-player myself
      set members members + 1
      ask my-out-supply-links [ die ]
      ask my-in-demand-links [ die ]
      create-supply-link-to myself
        [ set orders-filled n-values periods-of-delay [ 0 ] hide-link ]
      create-demand-link-from myself
        [ set orders-placed 4 hide-link ]
    ]
    set order-placed? false
    set color [color] of team + 2
    init-player
  ]
end 

;; set size appropriate to your position in the chain.
;; factories are biggest and retailers smallest
;; report the name of the role

to-report my-role [degree]
  set size degree * 0.1 + 0.5
  report item degree roles
end 

;; if a player leaves the game we may need to
;; get new roles since the new player will be
;; added to the end rather than where the last player left.

to reassign-role
  let degree [xcor] of my-team - xcor - 1
  set role my-role degree
  set role item degree roles
end 

to remove-student
  ask players with [ user-id = hubnet-message-source ]
    [ remove-self ]
end 

to remove-self
  ;; if I am the last player make my neighbor
  ;; to the right the last player
  if [last-player] of my-team = self
  [
    ask my-team
    [
      set last-player [ one-of out-supply-link-neighbors ] of myself
    ]
  ]

  ask my-team
  [
    set members members - 1
    ;; if I am the last player take the team with me.
    if members = 0
    [
      ;; return the colors to the available list
      set colors lput color colors
      set color-names lput color-name color-names
      die
      ;; we've shifted perspective to make the above code
      ;; simpler so we must use myself to kill the player
      ;; as well as the team.  if we're the last player in
      ;; the team we don't have to do the rest of the bookkeeping
      ;; below so we do want to abort immediately
      ask myself [ die ]
    ]
  ]

  ;; if this was the last player on the team this code never
  ;; gets executed because the above code kills the turtle

  ;; players up the chain from me move into their
  ;; new position so there aren't gaps
  let affected-players players with [ my-team = [my-team] of myself and xcor < [xcor] of myself ]
  ask affected-players
    [ set xcor xcor + 1 ]

  ;; link my supply and demand neighbors to
  ;; each other instead of me.
  let n one-of out-supply-link-neighbors
  ask in-supply-link-neighbors
  [
    if n != nobody and not out-supply-link-neighbor? n
    [ create-supply-link-to n
      [ set orders-filled n-values periods-of-delay [ 0 ] ] ]
  ]

  set n one-of out-demand-link-neighbors
  ask in-demand-link-neighbors
  [
    if n != nobody and not out-demand-link-neighbor? n
    [ create-demand-link-to n [] ]
  ]

  ask affected-players
  [
    reassign-role
    init-player
  ]
  die
end 

;; there are only two client actions.
;; moving the ORDERS-TO-PLACE slider
;; and placing the order.

to execute-command [cmd]
  ask players with [ user-id = hubnet-message-source ]
  [
    ;; don't let players keep going once they've reached the
    ;; end of the simulation
    if [clock] of my-team <= weeks-of-simulation
    [
      ;; catch changes to the slider
      ifelse hubnet-message-tag = "orders-to-place"
      [ set order hubnet-message ]
      ;; lock in the order
      [ if hubnet-message-tag = "place-order"
        [
          ask players with [ user-id = hubnet-message-source ]
            [ place-order ]
        ]
      ]
    ]
  ]
end 

;; send everything

to init-player
  hubnet-send user-id "team" [color-name] of my-team
  hubnet-send user-id "role" role
  update-player
end 

;; send the stuff that changes

to update-player
  if [clock] of my-team <= weeks-of-simulation
  [
    hubnet-send user-id "demand" [orders-placed] of one-of my-in-demand-links
    hubnet-send user-id "inventory" inventory
    hubnet-send user-id "back-orders" back-orders
    hubnet-send user-id "my-cost" inventory * 0.5 + back-orders
    hubnet-send user-id "last-amount-shipped" sum [ last orders-filled ] of my-out-supply-links

    hubnet-send user-id "last-amount-received" round last-received
    hubnet-send user-id "week" round [clock] of my-team
    hubnet-send user-id "order-placed?" order-placed?
    hubnet-send user-id "order-placed" ordered
  ]
end 

;;
;; Plotting Procedures
;;

;; use temporary plot pens for each team
;; so the legend is neat and the plot pen color
;; matches the color of the team

to create-plot-pens
  create-plot-pen "Orders to Factory"
  create-plot-pen "Cost"
  create-plot-pen "Orders Shipped"
end 

to create-plot-pen [my-plot]
  set-current-plot my-plot
  create-temporary-plot-pen color-name
  set-plot-pen-color color
end 

to plot-orders
  set-current-plot "Orders to Factory"
  plot last-received
end 

to plot-cost
  set-current-plot "Cost"
  set-current-plot-pen color-name
  plot cost
end 

to plot-shipped
  set-current-plot "Orders Shipped"
  set-current-plot-pen color-name
  plot sum [ last orders-filled ] of my-in-supply-links
end 

;; clearing the plot also clears the temporary
;; plot pens, so recreate them.

to reset-plot
  clear-all-plots
  ask teams [ create-plot-pens ]
end 


; Copyright 2003 Uri Wilensky and Walter Stroup.
; See Info tab for full copyright and license.