Better Dropdown Selection

Author: AlexD717

fission/src/systems/MatchMode.ts

@@ -7,11 +7,11 @@ import MatchEnd from "@/assets/sound-files/MatchEnd.wav"
 import MatchResume from "@/assets/sound-files/MatchResume.wav"
 
 export enum MatchModeType {
-    SANDBOX = 0,
-    AUTONOMOUS = 1,
-    TELEOP = 2,
-    ENDGAME = 3,
-    MATCH_ENDED = 4,
+    SANDBOX = "Sandbox",
+    AUTONOMOUS = "Autonomous",
+    TELEOP = "Teleop",
+    ENDGAME = "Endgame",
+    MATCH_ENDED = "Match Ended",
 }
 
 // Default match mode timing values

fission/src/test/mirabuf/ProtectedZoneSceneObject.test.ts

@@ -47,15 +47,15 @@ vi.mock("@/systems/simulation/SimulationSystem", () => ({
 
 vi.mock("@/systems/MatchMode", () => ({
     MatchModeType: {
-        SANDBOX: 0,
-        AUTONOMOUS: 1,
-        TELEOP: 2,
-        ENDGAME: 3,
-        MATCH_ENDED: 4,
+        SANDBOX: "Sandbox",
+        AUTONOMOUS: "Autonomous",
+        TELEOP: "Teleop",
+        ENDGAME: "Endgame",
+        MATCH_ENDED: "Match Ended",
     },
     default: {
         getInstance: vi.fn(() => ({
-            getMatchModeType: vi.fn(() => MatchModeType.TELEOP),
+            getMatchModeType: vi.fn(() => "Teleop"),
         })),
     },
 }))
@@ -122,8 +122,7 @@ describe("ProtectedZoneSceneObject", () => {
 
         instance["zoneCollision"](blueRobotBodyId)
 
-        expect(vi.mocked(SimulationSystem.robotPenalty)).toHaveBeenCalledTimes(1)
-        expect(vi.mocked(SimulationSystem.robotPenalty)).toHaveBeenCalledWith(blueRobot, 5, expect.any(String))
+        expect(vi.mocked(SimulationSystem.robotPenalty)).toHaveBeenCalledExactlyOnceWith(blueRobot, 5, expect.any(String))
     })
 
     test("ZoneCollision does not penalize same alliance robot", () => {

fission/src/ui/panels/configuring/assembly-config/interfaces/scoring/ProtectedZoneConfigInterface.tsx

@@ -24,6 +24,15 @@ import ProtectedZoneSceneObject, { ContactType } from "@/mirabuf/ProtectedZoneSc
 import Dropdown from "@/ui/components/Dropdown"
 import { MatchModeType } from "@/systems/MatchMode"
 
+const MATCH_MODE_OPTIONS: MatchModeType[] = [
+    MatchModeType.SANDBOX,
+    MatchModeType.AUTONOMOUS,
+    MatchModeType.TELEOP,
+    MatchModeType.ENDGAME,
+]
+
+const CONTACT_TYPE_OPTIONS = Object.values(ContactType)
+
 /**
  * Saves ejector configuration to selected field.
  *
@@ -271,45 +280,11 @@ const ZoneConfigInterface: React.FC<ZoneConfigProps> = ({ selectedField, selecte
             {/** Determines during what game state the protected zone is active */}
             <Dropdown
                 label="Active During"
-                options={["Sandbox", "Autonomous", "Teleop", "Endgame"]}
+                options={MATCH_MODE_OPTIONS}
                 onSelect={(selectedOptions: string[]) => {
-                    const matchModes: MatchModeType[] = []
-                    selectedOptions.forEach(option => {
-                        switch (option) {
-                            case "Sandbox":
-                                matchModes.push(MatchModeType.SANDBOX)
-                                break
-                            case "Autonomous":
-                                matchModes.push(MatchModeType.AUTONOMOUS)
-                                break
-                            case "Teleop":
-                                matchModes.push(MatchModeType.TELEOP)
-                                break
-                            case "Endgame":
-                                matchModes.push(MatchModeType.ENDGAME)
-                                break
-                            default:
-                                break
-                        }
-                    })
-                    setActiveDuring(matchModes)
+                    setActiveDuring(selectedOptions as MatchModeType[])
                 }}
-                defaultValue={activeDuring
-                    .map(mode => {
-                        switch (mode) {
-                            case MatchModeType.SANDBOX:
-                                return "Sandbox"
-                            case MatchModeType.AUTONOMOUS:
-                                return "Autonomous"
-                            case MatchModeType.TELEOP:
-                                return "Teleop"
-                            case MatchModeType.ENDGAME:
-                                return "Endgame"
-                            default:
-                                return ""
-                        }
-                    })
-                    .filter(val => val !== "")}
+                defaultValue={activeDuring}
                 maxWidth="15rem"
                 multiSelect={true}
                 textAlign="left"
@@ -318,44 +293,11 @@ const ZoneConfigInterface: React.FC<ZoneConfigProps> = ({ selectedField, selecte
             {/** Determines what type of contact is required for the penalty to apply */}
             <Dropdown
                 label="Contact Type"
-                options={[
-                    "Robot Enters",
-                    "Collision with Both Robots Inside",
-                    "Collision with Opponent Robot Inside",
-                    "Collision with Ally Robot Inside",
-                ]}
+                options={CONTACT_TYPE_OPTIONS}
                 onSelect={(selectedOption: string) => {
-                    switch (selectedOption) {
-                        case "Robot Enters":
-                            setContactType(ContactType.ROBOT_ENTERS)
-                            break
-                        case "Collision with Both Robots Inside":
-                            setContactType(ContactType.BOTH_ROBOTS_INSIDE)
-                            break
-                        case "Collision with Opponent Robot Inside":
-                            setContactType(ContactType.OPPONENT_ROBOT_INSIDE)
-                            break
-                        case "Collision with Ally Robot Inside":
-                            setContactType(ContactType.ALLY_ROBOT_INSIDE)
-                            break
-                        default:
-                            break
-                    }
+                    setContactType(selectedOption as ContactType)
                 }}
-                defaultValue={(() => {
-                    switch (contactType) {
-                        case ContactType.ROBOT_ENTERS:
-                            return "Robot Enters"
-                        case ContactType.BOTH_ROBOTS_INSIDE:
-                            return "Collision with Both Robots Inside"
-                        case ContactType.OPPONENT_ROBOT_INSIDE:
-                            return "Collision with Opponent Robot Inside"
-                        case ContactType.ALLY_ROBOT_INSIDE:
-                            return "Collision with Ally Robot Inside"
-                        default:
-                            return "Robot Enters"
-                    }
-                })()}
+                defaultValue={contactType}
                 textAlign="left"
             />