Refactor match play page to be completely dynamic.

field/arena.go

@@ -215,7 +215,7 @@ func (arena *Arena) UpdatePlayoffTournament() error {
 // Sets up the arena for the given match.
 func (arena *Arena) LoadMatch(match *model.Match) error {
 	if arena.MatchState != PreMatch {
-		return fmt.Errorf("Cannot load match while there is a match still in progress or with results pending.")
+		return fmt.Errorf("cannot load match while there is a match still in progress or with results pending")
 	}
 
 	arena.CurrentMatch = match
@@ -373,7 +373,7 @@ func (arena *Arena) StartMatch() error {
 // Kills the current match or timeout if it is underway.
 func (arena *Arena) AbortMatch() error {
 	if arena.MatchState == PreMatch || arena.MatchState == PostMatch || arena.MatchState == PostTimeout {
-		return fmt.Errorf("Cannot abort match when it is not in progress.")
+		return fmt.Errorf("cannot abort match when it is not in progress")
 	}
 
 	if arena.MatchState == TimeoutActive {
@@ -397,7 +397,7 @@ func (arena *Arena) AbortMatch() error {
 // Clears out the match and resets the arena state unless there is a match underway.
 func (arena *Arena) ResetMatch() error {
 	if arena.MatchState != PostMatch && arena.MatchState != PreMatch {
-		return fmt.Errorf("Cannot reset match while it is in progress.")
+		return fmt.Errorf("cannot reset match while it is in progress")
 	}
 	arena.MatchState = PreMatch
 	arena.matchAborted = false
@@ -414,7 +414,7 @@ func (arena *Arena) ResetMatch() error {
 // Starts a timeout of the given duration.
 func (arena *Arena) StartTimeout(description string, durationSec int) error {
 	if arena.MatchState != PreMatch {
-		return fmt.Errorf("Cannot start timeout while there is a match still in progress or with results pending.")
+		return fmt.Errorf("cannot start timeout while there is a match still in progress or with results pending")
 	}
 
 	game.MatchTiming.TimeoutDurationSec = durationSec
@@ -728,7 +728,7 @@ func (arena *Arena) setupNetwork(teams [6]*model.Team) {
 // Returns nil if the match can be started, and an error otherwise.
 func (arena *Arena) checkCanStartMatch() error {
 	if arena.MatchState != PreMatch {
-		return fmt.Errorf("Cannot start match while there is a match still in progress or with results pending.")
+		return fmt.Errorf("cannot start match while there is a match still in progress or with results pending")
 	}
 
 	err := arena.checkAllianceStationsReady("R1", "R2", "R3", "B1", "B2", "B3")
@@ -738,14 +738,14 @@ func (arena *Arena) checkCanStartMatch() error {
 
 	if arena.Plc.IsEnabled() {
 		if !arena.Plc.IsHealthy() {
-			return fmt.Errorf("Cannot start match while PLC is not healthy.")
+			return fmt.Errorf("cannot start match while PLC is not healthy")
 		}
 		if arena.Plc.GetFieldEstop() {
-			return fmt.Errorf("Cannot start match while field emergency stop is active.")
+			return fmt.Errorf("cannot start match while field emergency stop is active")
 		}
 		for name, status := range arena.Plc.GetArmorBlockStatuses() {
 			if !status {
-				return fmt.Errorf("Cannot start match while PLC ArmorBlock '%s' is not connected.", name)
+				return fmt.Errorf("cannot start match while PLC ArmorBlock %q is not connected", name)
 			}
 		}
 	}
@@ -757,11 +757,11 @@ func (arena *Arena) checkAllianceStationsReady(stations ...string) error {
 	for _, station := range stations {
 		allianceStation := arena.AllianceStations[station]
 		if allianceStation.Estop {
-			return fmt.Errorf("Cannot start match while an emergency stop is active.")
+			return fmt.Errorf("cannot start match while an emergency stop is active")
 		}
 		if !allianceStation.Bypass {
 			if allianceStation.DsConn == nil || !allianceStation.DsConn.RobotLinked {
-				return fmt.Errorf("Cannot start match until all robots are connected or bypassed.")
+				return fmt.Errorf("cannot start match until all robots are connected or bypassed")
 			}
 		}
 	}

field/arena_notifiers.go

@@ -137,6 +137,9 @@ func (arena *Arena) GenerateMatchLoadMessage() any {
 		}
 	}
 
+	matchResult, _ := arena.Database.GetMatchResultForMatch(arena.CurrentMatch.Id)
+	isReplay := matchResult != nil
+
 	var matchup *playoff.Matchup
 	redOffFieldTeams := []*model.Team{}
 	blueOffFieldTeams := []*model.Team{}
@@ -156,6 +159,8 @@ func (arena *Arena) GenerateMatchLoadMessage() any {
 
 	return &struct {
 		Match             *model.Match
+		AllowSubstitution bool
+		IsReplay          bool
 		Teams             map[string]*model.Team
 		Rankings          map[string]*game.Ranking
 		Matchup           *playoff.Matchup
@@ -164,6 +169,8 @@ func (arena *Arena) GenerateMatchLoadMessage() any {
 		BreakDescription  string
 	}{
 		arena.CurrentMatch,
+		arena.CurrentMatch.ShouldAllowSubstitution(),
+		isReplay,
 		teams,
 		rankings,
 		matchup,

field/arena_test.go

@@ -61,7 +61,7 @@ func TestArenaCheckCanStartMatch(t *testing.T) {
 	// Check robot state constraints.
 	err := arena.checkCanStartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match until all robots are connected or bypassed")
+		assert.Contains(t, err.Error(), "cannot start match until all robots are connected or bypassed")
 	}
 	arena.AllianceStations["R1"].Bypass = true
 	arena.AllianceStations["R2"].Bypass = true
@@ -70,7 +70,7 @@ func TestArenaCheckCanStartMatch(t *testing.T) {
 	arena.AllianceStations["B2"].Bypass = true
 	err = arena.checkCanStartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match until all robots are connected or bypassed")
+		assert.Contains(t, err.Error(), "cannot start match until all robots are connected or bypassed")
 	}
 	arena.AllianceStations["B3"].Bypass = true
 	assert.Nil(t, arena.checkCanStartMatch())
@@ -79,7 +79,7 @@ func TestArenaCheckCanStartMatch(t *testing.T) {
 	arena.Plc.SetAddress("1.2.3.4")
 	err = arena.checkCanStartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match while PLC is not healthy")
+		assert.Contains(t, err.Error(), "cannot start match while PLC is not healthy")
 	}
 	arena.Plc.SetAddress("")
 	assert.Nil(t, arena.checkCanStartMatch())
@@ -218,73 +218,73 @@ func TestArenaStateEnforcement(t *testing.T) {
 	assert.Nil(t, err)
 	err = arena.AbortMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot abort match when")
+		assert.Contains(t, err.Error(), "cannot abort match when")
 	}
 	err = arena.StartMatch()
 	assert.Nil(t, err)
 	err = arena.LoadMatch(new(model.Match))
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot load match while")
+		assert.Contains(t, err.Error(), "cannot load match while")
 	}
 	err = arena.StartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match while")
+		assert.Contains(t, err.Error(), "cannot start match while")
 	}
 	err = arena.ResetMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot reset match while")
+		assert.Contains(t, err.Error(), "cannot reset match while")
 	}
 	arena.MatchState = AutoPeriod
 	err = arena.LoadMatch(new(model.Match))
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot load match while")
+		assert.Contains(t, err.Error(), "cannot load match while")
 	}
 	err = arena.StartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match while")
+		assert.Contains(t, err.Error(), "cannot start match while")
 	}
 	err = arena.ResetMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot reset match while")
+		assert.Contains(t, err.Error(), "cannot reset match while")
 	}
 	arena.MatchState = PausePeriod
 	err = arena.LoadMatch(new(model.Match))
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot load match while")
+		assert.Contains(t, err.Error(), "cannot load match while")
 	}
 	err = arena.StartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match while")
+		assert.Contains(t, err.Error(), "cannot start match while")
 	}
 	err = arena.ResetMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot reset match while")
+		assert.Contains(t, err.Error(), "cannot reset match while")
 	}
 	arena.MatchState = TeleopPeriod
 	err = arena.LoadMatch(new(model.Match))
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot load match while")
+		assert.Contains(t, err.Error(), "cannot load match while")
 	}
 	err = arena.StartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match while")
+		assert.Contains(t, err.Error(), "cannot start match while")
 	}
 	err = arena.ResetMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot reset match while")
+		assert.Contains(t, err.Error(), "cannot reset match while")
 	}
 	arena.MatchState = PostMatch
 	err = arena.LoadMatch(new(model.Match))
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot load match while")
+		assert.Contains(t, err.Error(), "cannot load match while")
 	}
 	err = arena.StartMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot start match while")
+		assert.Contains(t, err.Error(), "cannot start match while")
 	}
 	err = arena.AbortMatch()
 	if assert.NotNil(t, err) {
-		assert.Contains(t, err.Error(), "Cannot abort match when")
+		assert.Contains(t, err.Error(), "cannot abort match when")
 	}
 
 	err = arena.ResetMatch()

static/css/cheesy-arena.css

@@ -130,3 +130,6 @@ input[data-changed="true"], select[data-changed="true"] {
   top: 0;
   background-color: #fff;
 }
+#testMatchSettings {
+  display: none;
+}

static/js/audience_display.js

@@ -235,7 +235,6 @@ const handleScorePosted = function(data) {
   $("#" + blueSide + "FinalWins").text(data.BlueWins);
   const blueFinalDestination = $("#" + blueSide + "FinalDestination");
   blueFinalDestination.html(data.BlueDestination.replace("Advances to ", "Advances to<br>"));
-  console.log(data);
   blueFinalDestination.toggle(data.BlueDestination !== "");
   blueFinalDestination.attr("data-won", data.BlueWon);