Allow switching stages

Author: g3force

frontend/src/components/start/StageInput.vue

@@ -0,0 +1,41 @@
+<script setup lang="ts">
+import {computed, inject} from "vue";
+import SelectInput from "@/components/common/SelectInput.vue";
+import {useMatchStateStore} from "@/store/matchState";
+import {stageName} from "@/helpers/texts";
+import {Referee_Stage} from "@/proto/ssl_gc_referee_message";
+import type {ControlApi} from "@/providers/controlApi/ControlApi";
+import {getRemainingStages} from "@/helpers";
+
+const store = useMatchStateStore()
+const control = inject<ControlApi>('control-api')
+
+const model = computed(() => {
+  return store.matchState.stage
+})
+
+const options = computed(() => getRemainingStages(store.matchState.stage!))
+const optionsLabel = (v: Referee_Stage) => stageName(v) || "-"
+
+const onChange = (newStage: Referee_Stage) => {
+  control?.SubmitChange({
+    change: {
+      $case: 'changeStageChange',
+      changeStageChange: {
+        newStage
+      }
+    }
+  })
+}
+</script>
+
+<template>
+  <SelectInput
+    label="Stage"
+    style="min-width: 130px"
+    :modelValue="model"
+    :options="options"
+    :option-label="optionsLabel"
+    @update:model-value="onChange"
+  />
+</template>

frontend/src/helpers/index.ts

@@ -57,40 +57,22 @@ export const originIcon = (origin: string) => {
   }
 }
 
-export const getNextStage = function (stage: Referee_Stage): Referee_Stage {
-  switch (stage) {
-    case Referee_Stage.NORMAL_FIRST_HALF_PRE:
-      return Referee_Stage.NORMAL_FIRST_HALF
-    case Referee_Stage.NORMAL_FIRST_HALF:
-      return Referee_Stage.NORMAL_HALF_TIME
-    case Referee_Stage.NORMAL_HALF_TIME:
-      return Referee_Stage.NORMAL_SECOND_HALF_PRE
-    case Referee_Stage.NORMAL_SECOND_HALF_PRE:
-      return Referee_Stage.NORMAL_SECOND_HALF
-    case Referee_Stage.NORMAL_SECOND_HALF:
-      return Referee_Stage.EXTRA_TIME_BREAK
-    case Referee_Stage.EXTRA_TIME_BREAK:
-      return Referee_Stage.EXTRA_FIRST_HALF_PRE
-    case Referee_Stage.EXTRA_FIRST_HALF_PRE:
-      return Referee_Stage.EXTRA_FIRST_HALF
-    case Referee_Stage.EXTRA_FIRST_HALF:
-      return Referee_Stage.EXTRA_HALF_TIME
-    case Referee_Stage.EXTRA_HALF_TIME:
-      return Referee_Stage.EXTRA_SECOND_HALF_PRE
-    case Referee_Stage.EXTRA_SECOND_HALF_PRE:
-      return Referee_Stage.EXTRA_SECOND_HALF
-    case Referee_Stage.EXTRA_SECOND_HALF:
-      return Referee_Stage.PENALTY_SHOOTOUT_BREAK
-    case Referee_Stage.PENALTY_SHOOTOUT_BREAK:
-      return Referee_Stage.PENALTY_SHOOTOUT
-    case Referee_Stage.PENALTY_SHOOTOUT:
-      return Referee_Stage.POST_GAME
-    case Referee_Stage.POST_GAME:
-    case Referee_Stage.UNRECOGNIZED:
-    default:
-      return Referee_Stage.POST_GAME
-  }
-}
+const stages: Referee_Stage[] = [
+  Referee_Stage.NORMAL_FIRST_HALF_PRE,
+  Referee_Stage.NORMAL_FIRST_HALF,
+  Referee_Stage.NORMAL_HALF_TIME,
+  Referee_Stage.NORMAL_SECOND_HALF_PRE,
+  Referee_Stage.NORMAL_SECOND_HALF,
+  Referee_Stage.EXTRA_TIME_BREAK,
+  Referee_Stage.EXTRA_FIRST_HALF_PRE,
+  Referee_Stage.EXTRA_FIRST_HALF,
+  Referee_Stage.EXTRA_HALF_TIME,
+  Referee_Stage.EXTRA_SECOND_HALF_PRE,
+  Referee_Stage.EXTRA_SECOND_HALF,
+  Referee_Stage.PENALTY_SHOOTOUT_BREAK,
+  Referee_Stage.PENALTY_SHOOTOUT,
+  Referee_Stage.POST_GAME,
+]
 
 export const isPausedStage = function (stage: Referee_Stage): boolean {
   return stage.toString() === Referee_Stage[Referee_Stage.NORMAL_HALF_TIME]
@@ -114,3 +96,8 @@ export const isPreStage = function (stage: Referee_Stage): boolean {
     || stage.toString() === Referee_Stage[Referee_Stage.EXTRA_FIRST_HALF_PRE]
     || stage.toString() === Referee_Stage[Referee_Stage.EXTRA_SECOND_HALF_PRE]
 };
+
+export const getRemainingStages = function (fromStage: Referee_Stage): Referee_Stage[] {
+  const idx = stages.indexOf(fromStage)
+  return stages.slice(idx)
+}

frontend/src/views/StartView.vue

@@ -12,6 +12,7 @@ import GoalKeeperIdInput from "@/components/team/GoalKeeperIdInput.vue";
 import BallPlacementEnabledInput from "@/components/team/BallPlacementEnabledInput.vue";
 import FirstKickOffInput from "@/components/team/FirstKickOffInput.vue";
 import FieldHalfInput from "@/components/team/FieldHalfInput.vue";
+import StageInput from "@/components/start/StageInput.vue";
 import {teams} from "@/helpers";
 </script>
 
@@ -67,11 +68,19 @@ import {teams} from "@/helpers";
       </q-list>
     </div>
 
-    <div class="row justify-evenly q-gutter-md">
+    <div class="row justify-evenly">
       <SwitchColorButton/>
       <SwitchColorRandomButton/>
       <SwitchSidesRandomButton/>
-      <EndMatchButton/>
+    </div>
+
+    <q-separator spaced/>
+
+    <div class="row justify-evenly">
+      <StageInput/>
+      <div class="q-pa-md">
+        <EndMatchButton/>
+      </div>
     </div>
 
     <div class="q-ma-md">

internal/app/statemachine/change_stage.go

@@ -9,8 +9,18 @@ import (
 
 func (s *StateMachine) processChangeChangeStage(newState *state.State, change *Change_ChangeStage) (changes []*Change) {
 
+	currentStage := *newState.Stage
+	for stage := currentStage + 1; stage <= *change.NewStage; stage++ {
+		changes = append(changes, s.proceedStage(newState, stage)...)
+	}
+
+	return
+}
+
+func (s *StateMachine) proceedStage(newState *state.State, newStage state.Referee_Stage) (changes []*Change) {
+
 	// update stage time
-	newState.StageTimeLeft = durationpb.New(s.stageTimes[*change.NewStage])
+	newState.StageTimeLeft = durationpb.New(s.stageTimes[newStage])
 	newState.StageTimeElapsed = durationpb.New(time.Duration(0))
 
 	// if not transiting from a pre stage
@@ -32,15 +42,15 @@ func (s *StateMachine) processChangeChangeStage(newState *state.State, change *C
 	}
 
 	// update timeout times when transiting to overtime
-	if *change.NewStage == state.Referee_EXTRA_FIRST_HALF_PRE {
+	if newStage == state.Referee_EXTRA_FIRST_HALF_PRE {
 		*newState.TeamInfo(state.Team_YELLOW).TimeoutsLeft = s.gameConfig.Overtime.Timeouts
 		newState.TeamInfo(state.Team_YELLOW).TimeoutTimeLeft = durationpb.New(s.gameConfig.Overtime.TimeoutDuration)
 		*newState.TeamInfo(state.Team_BLUE).TimeoutsLeft = s.gameConfig.Overtime.Timeouts
 		newState.TeamInfo(state.Team_BLUE).TimeoutTimeLeft = durationpb.New(s.gameConfig.Overtime.TimeoutDuration)
 	}
 
 	// update next command based on new stage
-	newState.NextCommand = s.getNextCommandForStage(newState, *change.NewStage)
+	newState.NextCommand = s.getNextCommandForStage(newState, newStage)
 
 	// update placement pos (assuming it is either kickoff or nothing)
 	if newState.NextCommand == nil {
@@ -54,7 +64,7 @@ func (s *StateMachine) processChangeChangeStage(newState *state.State, change *C
 	newState.GameEvents = nil
 
 	// update new stage
-	newState.Stage = change.NewStage
+	*newState.Stage = newStage
 
 	return
 }