modules.txt

(blueshirt commands are sent over a channel called BLUESHIRTS)

STATE CONTROLLER

EVENT real time clock pulse:
  transmit HEARTBEAT(real-time, competition-time) on channel HEARTBEAT
  compute current match and match state
  if current match differs from match.current:
    match.schedule.[match.current].state <- COMPLETED
    match.schedule.[match].state <- IN-PROGRESS iff match is not NULL
    match.current <- match
  if current match became non-NULL and comp.state.global == DOWNTIME:
    broadcast_state <- true
    comp.state.global <- MATCH
  elif current match became NULL and comp.state.global == MATCH:
    broadcast_state <- true
    comp.state.global <- MATCH
  if match state differs from previous or broadcast_state:
    comp.state.match <- new_state
    transmit STATE(comp.state.global, comp.state.match) on channel STATE
  if comp.pause != NULL
      transmit OFFSET-SHIFT on channel HEARTBEAT

EVENT panic:
  comp.pause <- current competition time
  comp.state.global <- FAIL
  transmit STATE(comp.state.global, comp.state.match) on channel STATE

EVENT panic-over:
  comp.sync[] <- (current_real_time, comp.pause)
  comp.pause <- NULL
  if match.current is not NULL:
    comp.state.global <- MATCH
  else:
    comp.state.global <- DOWNTIME
  transmit STATE(comp.state.global, comp.state.match) on channel STATE

EVENT pause:
  comp.pause <- current competition time

EVENT unpause:
  comp.sync[] <- (current_real_time, comp.pause)
  comp.pause <- NULL

EVENT competition-start:
  comp.sync = [(current_real_time, 0)]
  comp.state.global <- DOWNTIME
  transmit 'trigger' on channel comp.kickoff
  transmit comp.state.global, comp.state.match on channel comp.state
  transmit current_real_time, 0 on channel comp.heartbeat
  transmit 'trigger' on channel comp.offset_shift

EVENT delay-matches(match, amount):
  if match is live or in the past:
    deny
  delay existing matches from match onwards by amount until the nearest break (of more than 1 minute)
  transmit RECOMPUTE on channel SCHEDULE

EVENT schedule-match(match):
  if match would be live or in the past:
    deny
  find earliest existing match overlapped by match and issue delay-matches(existing match, 390)
  add match into schedule
  transmit 'trigger' on channel match.reschedule

EVENT cancel-match(match):
  if match is in the past:
    deny
  remove match from schedule
  if match was current:
    match.current <- NULL
    comp.state.global <- DOWNTIME
    transmit (comp.state.global, comp.state.match) on channel comp.state
  else:
    find next match
    issue delay-matches(next, -390)
  transmit 'trigger' on channel match.reschedule

EVENT add-team(team):
  teams.roster[] <- team
  transmit 'new' on channel teams.[team.tla]

EVENT update-team(team):
  teams.roster[team.tla] <- team
  transmit 'updated' on channel teams.[team.tla]

EVENT remove-team(tla):
  for each match containing team:
    issue cancel-match(match)
  del teams.roster[team.tla]
  transmit 'gone' on channel teams.[tla]

--

ARENA CONTROLLER

table permit-entry(global-state, match-state, tinker):
  +----------+--------+-------+-------------+
  | FAIL     |   x    |   x   | HARD-CLOSED |
  | DOWNTIME |   x    | TRUE  | OPEN        |
  | DOWNTIME |   x    | FALSE | SOFT-CLOSED |
  | MATCH    | ENTER  |   x   | OPEN        |
  | MATCH    | BOOT   |   x   | SOFT-CLOSED |
  | MATCH    | LIVE   |   x   | HARD-CLOSED |
  | MATCH    | SETTLE |   x   | SOFT-CLOSED |
  +----------+--------+-------+-------------+

RECEIVE STATE(global, match) on channel STATE:
  enterable <- look up permit-entry(global, match, comp.state.tinker)
  if enterable != comp.state.arena:
    comp.state.arena <- enterable
    transmit enterable on channel comp.arena
  if match == LIVE:
    initialise scores
    transmit [0, 0, 0, 0], [0, 0, 0, 0] on channel match.current.scores
  if match == SETTLE:
    compute final scores
    transmit final-scores, NULL on channel match.current.scores

EVENT enter-tinker-mode:
  comp.state.tinker <- TRUE
  enterable <- look up permit-entry(global, match, comp.state.tinker)
  if enterable != comp.state.arena:
    comp.state.arena <- enterable
    transmit enterable on channel comp.arena

EVENT enter-briefing-mode:
  comp.state.tinker <- FALSE
  enterable <- look up permit-entry(global, match, comp.state.tinker)
  if enterable != comp.state.arena:
    comp.state.arena <- enterable
    transmit enterable on channel comp.arena

EVENT record-game-event(event):
  if comp.state.global is not MATCH:
    deny
  if comp.state.match is not in (MATCH, SETTLE):
    deny
  matches[match.current].events[] <- event
  transmit event on channel match.current.events
  update score prediction and current
  transmit current-scores, predicted-scores on channel match.current.scores

--

MUSIC CONTROLLER

EVENT add-new-song(song):
  issue add-song-to-playlist(song, 'all')

EVENT add-song-to-playlist(song, playlist):
  music.playlist.[playlist][] <- (song, rand[0..1])

EVENT remove-song-from-playlist(song, playlists):
  remove song from music.playlist.[playlist]

EVENT music-finished:
  issue next-track

EVENT stop-music:
  stop currently playing music

table music-actions(global, match):
  +----------+--------+-------+
  | FAIL     |   x    | STOP  |
  | DOWNTIME |   x    | START |
  | MATCH    | ENTER  | START |
  | MATCH    | BOOT   | x     |
  | MATCH    | LIVE   | START |
  | MATCH    | SETTLE | x     |
  +----------+--------+-------+

RECEIVE STATE(global-state, match-state) on channel STATE:
  look up music-actions(global-state, match-state):
    issue either stop-music or next-track. possibly.

EVENT next-track:
  pick a song meeting the current state
  play that bastard
  music.history[] = (real_time, uri)

--

SCREEN CONTROLLER (runs a miniature httpd to which the screens can connect)

EVENT add-screen(id, flavour, zone=null):
  screens.[id].flavour <- flavour
  screens.[id].zone <- zone
  issue refresh-screen(id)

EVENT remove-screen(id)
  del screens.[id].flavour
  del screens.[id].zone
  del screens.[id].override

EVENT refresh-screen(id)
  compute CONTENT(id) and send to screen id

EVENT update-screen(id)
  compute UPDATE(id)
  if not null:
    send to screen id

RECEIVE STATE(_, _) on channel STATE:
  for each screen:
    refresh-screen(id)

RECEIVE HEARTBEAT(_, _) on channel HEARTBEAT:
  for each screen in flavour (CLOCK, ZONE, JUDGE):
    issue update-screen(id)

RECEIVE OFFSET-SHIFT on channel HEARTBEAT:
  if time mod 15 == 0:
    for each screen in flavour (JUDGE, MATCH-INFO):
      issue refresh-screen(id)

RECEIVE RECOMPUTE on channel SCHEDULE:
  for each screen in flavour (LAYOUT, JUDGE, MATCH-INFO):
    issue refresh-screen(id)

RECEIVE UPDATE(tla) on channel TEAMS:
  for each screen in flavour (LAYOUT, ZONE, JUDGE, MATCH-INFO):
    issue refresh-screen(id)

EVENT override-screen(id, message):
  screens.override[id] <- message
  issue refresh-screen(id)

EVENT cancel-override-screen(id):
  del screens.override[id]
  issue refresh-screen(id)

computation of CONTENT(id):
  # specifics ignored, but here's a rough table, ignoring overrides
  +------------+----------+-------+--------+--------------+
  | FLAVOUR    | GLOBAL   | MATCH | ARENA  | DISPLAY      |
  +------------+----------+-------+--------+--------------+
  |    x       | FAIL     |   x   |   x    | NO-ENTRY     |
  | CLOCK      |     x    |   x   |   x    | CLOCK        |
  | LAYOUT     | DOWNTIME |   x   | CLOSED | NO-ENTRY     |
  | LAYOUT     | DOWNTIME |   x   | OPEN   | NEXT-MATCH   |
  | LAYOUT     | MATCH    |   x   | CLOSED | NO-ENTRY     |
  | LAYOUT     | MATCH    |   x   | OPEN   | LAYOUT       |
  | ZONE       | DOWNTIME |   x   |   x    | CLOCK        |
  | ZONE       | MATCH    |   x   |   x    | ZONE         |
  | JUDGE      | DOWNTIME |   x   |   x    | SCHED/LEAGUE |
  | JUDGE      | MATCH    |   x   |   x    | STATS        |
  | MATCH-INFO |     x    |   x   |   x    | SCHED/LEAGUE |
  | BLANK      |     x    |   x   |   x    | NOTHING      |
  +------------+----------+-------+--------+--------------+


---

REDIS!

Keys:
  match.schedule.[id].type
  match.schedule.[id].teams
  match.schedule.[id].start
  match.schedule.[id].scores
  match.schedule.[id].state
  match.schedule.[id].stage
  match.current
  comp.state.global
  comp.state.match
  comp.state.tinker
  comp.state.arena
  comp.pause
  comp.sync
  teams.[tla].name
  teams.[tla].college
  teams.[tla].disqualified
  teams.[tla].info
  teams.[tla].notes
  music.playlist.[list]
  music.history
  music.descriptions
  screens.[id].flavour
  screens.[id].zone
  screens.[id].override

channels:
  comp.heartbeat
  comp.offset_shift
  comp.kickoff
  comp.state
  comp.arena
  teams.[tla]
  match.reschedule
  match.current.scores
  match.current.events
  comp.command
  controller.[controller].heartbeat
  #screens.[screen].refresh
  #screens.[screen].update.[element]