add optional win condition feature

apollo/ActionMap.json

@@ -171,5 +171,6 @@
   ["BuySkill", [39, ["type", "from", "skill", "player"]]],
   ["ActivatePower", [40, ["type", "skill"]]],
   ["PreviousTurnGameOver", [41, ["type", "fromPlayer"]]],
-  ["SecretDiscovered", [42, ["type", "condition"]]]
+  ["SecretDiscovered", [42, ["type", "condition"]]],
+  ["OptionalWin", [43, ["type", "condition", "conditionId", "toPlayer"]]]
 ]

apollo/GameOver.tsx

@@ -52,12 +52,20 @@ export type GameEndActionResponse = Readonly<{
   type: 'GameEnd';
 }>;
 
+export type OptionalWinActionResponse = Readonly<{
+  condition: WinCondition;
+  conditionId: number;
+  toPlayer: PlayerID;
+  type: 'OptionalWin';
+}>;
+
 export type GameOverActionResponses =
   | AttackUnitGameOverActionResponse
   | BeginTurnGameOverActionResponse
   | CaptureGameOverActionResponse
   | GameEndActionResponse
-  | PreviousTurnGameOverActionResponse;
+  | PreviousTurnGameOverActionResponse
+  | OptionalWinActionResponse;
 
 function check(
   previousMap: MapData,
@@ -90,9 +98,12 @@ const pickWinningPlayer = (
   if (condition.type === WinCriteria.DefeatAmount) {
     return (
       condition.players?.length ? condition.players : activeMap.active
-    ).find(
-      (playerID) =>
-        activeMap.getPlayer(playerID).stats.destroyedUnits >= condition.amount,
+    ).find((playerID) =>
+      !condition.optional
+        ? activeMap.getPlayer(playerID).stats.destroyedUnits >= condition.amount
+        : !condition.completed?.has(playerID) &&
+          activeMap.getPlayer(playerID).stats.destroyedUnits >=
+            condition.amount,
     );
   }
 
@@ -138,19 +149,20 @@ export function checkGameOverConditions(
   const gameState: MutableGameState = actionResponse
     ? [[actionResponse, map]]
     : [];
-  const gameEndResponse = condition
-    ? ({
-        condition,
-        conditionId: activeMap.config.winConditions.indexOf(condition),
-        toPlayer: pickWinningPlayer(
-          previousMap,
-          activeMap,
-          lastActionResponse,
+
+  const winningPlayer = condition
+    ? pickWinningPlayer(previousMap, activeMap, lastActionResponse, condition)
+    : undefined;
+
+  const gameEndResponse =
+    condition?.optional === false
+      ? ({
           condition,
-        ),
-        type: 'GameEnd',
-      } as const)
-    : checkGameEnd(map);
+          conditionId: activeMap.config.winConditions.indexOf(condition),
+          toPlayer: winningPlayer,
+          type: 'GameEnd',
+        } as const)
+      : checkGameEnd(map);
 
   if (gameEndResponse) {
     let newGameState: GameState = [];
@@ -162,6 +174,36 @@ export function checkGameOverConditions(
     ];
   }
 
+  const optionalWinResponse =
+    condition?.optional === true &&
+    winningPlayer &&
+    !condition.completed?.has(winningPlayer)
+      ? ({
+          condition,
+          conditionId: activeMap.config.winConditions.indexOf(condition),
+          toPlayer: winningPlayer,
+          type: 'OptionalWin',
+        } as const)
+      : null;
+
+  if (optionalWinResponse) {
+    let newGameState: GameState = [];
+    [newGameState, map] = processRewards(map, optionalWinResponse);
+    map = applyGameOverActionResponse(map, optionalWinResponse);
+    return [
+      ...gameState,
+      ...newGameState,
+      [
+        // update `optionalWinResponse.condition` with the new `map.config` updated in `applyGameOverActionResponse()`
+        {
+          ...optionalWinResponse,
+          condition: map.config.winConditions[optionalWinResponse.conditionId],
+        },
+        map,
+      ],
+    ];
+  }
+
   if (
     actionResponse?.type === 'AttackUnitGameOver' ||
     actionResponse?.type === 'BeginTurnGameOver'
@@ -231,6 +273,21 @@ export function applyGameOverActionResponse(
     }
     case 'GameEnd':
       return map;
+    case 'OptionalWin': {
+      const { condition, conditionId, toPlayer } = actionResponse;
+      const winConditions = Array.from(map.config.winConditions);
+      winConditions[conditionId] = {
+        ...condition,
+        completed: condition.completed
+          ? new Set([...condition.completed, toPlayer])
+          : new Set([toPlayer]),
+      };
+      return map.copy({
+        config: map.config.copy({
+          winConditions,
+        }),
+      });
+    }
     default: {
       actionResponse satisfies never;
       throw new UnknownTypeError('applyGameOverActionResponse', type);

apollo/actions/applyActionResponse.tsx

@@ -546,6 +546,7 @@ export default function applyActionResponse(
     }
     case 'BeginGame':
     case 'SecretDiscovered':
+    case 'OptionalWin':
     case 'Start':
       return map;
     default: {

apollo/lib/computeVisibleActions.tsx

@@ -363,6 +363,7 @@ const VisibleActionModifiers: Record<
   MoveUnit: {
     Source: true,
   },
+  OptionalWin: true,
   PreviousTurnGameOver: true,
   ReceiveReward: true,
   Rescue: {

apollo/lib/dropLabelsFromActionResponse.tsx

@@ -65,6 +65,7 @@ export default function dropLabelsFromActionResponse(
     case 'PreviousTurnGameOver':
     case 'ReceiveReward':
     case 'SecretDiscovered':
+    case 'OptionalWin':
     case 'SetViewer':
     case 'Start':
       return actionResponse;

apollo/lib/getActionResponseVectors.tsx

@@ -90,6 +90,7 @@ export default function getActionResponseVectors(
     case 'PreviousTurnGameOver':
     case 'ReceiveReward':
     case 'SecretDiscovered':
+    case 'OptionalWin':
     case 'SetViewer':
     case 'Start':
       break;

apollo/lib/getWinningTeam.tsx

@@ -1,10 +1,13 @@
 import { PlayerID } from '@deities/athena/map/Player.tsx';
 import MapData from '@deities/athena/MapData.tsx';
-import { GameEndActionResponse } from '../GameOver.tsx';
+import {
+  GameEndActionResponse,
+  OptionalWinActionResponse,
+} from '../GameOver.tsx';
 
 export default function getWinningTeam(
   map: MapData,
-  actionResponse: GameEndActionResponse,
+  actionResponse: GameEndActionResponse | OptionalWinActionResponse,
 ): 'draw' | PlayerID {
   const isDraw = !actionResponse.toPlayer;
   return isDraw

apollo/lib/processRewards.tsx

@@ -2,22 +2,23 @@ import MapData from '@deities/athena/MapData.tsx';
 import { WinCriteria } from '@deities/athena/WinConditions.tsx';
 import isPresent from '@deities/hephaestus/isPresent.tsx';
 import applyActionResponse from '../actions/applyActionResponse.tsx';
-import { GameEndActionResponse } from '../GameOver.tsx';
+import {
+  GameEndActionResponse,
+  OptionalWinActionResponse,
+} from '../GameOver.tsx';
 import { GameState, MutableGameState } from '../Types.tsx';
 import getWinningTeam from './getWinningTeam.tsx';
 
 export function processRewards(
   map: MapData,
-  gameEndResponse: GameEndActionResponse,
+  actionResponse: GameEndActionResponse | OptionalWinActionResponse,
 ): [GameState, MapData] {
   const gameState: MutableGameState = [];
-  const winningTeam = getWinningTeam(map, gameEndResponse);
+  const winningTeam = getWinningTeam(map, actionResponse);
   if (winningTeam !== 'draw') {
     const rewards = new Set(
       [
-        'condition' in gameEndResponse
-          ? gameEndResponse.condition?.reward
-          : null,
+        'condition' in actionResponse ? actionResponse.condition?.reward : null,
         map.config.winConditions.find(
           (condition) => condition.type === WinCriteria.Default,
         )?.reward,

athena/MapData.tsx

@@ -577,7 +577,9 @@ export default class MapData {
         data.config.biome,
         (data.config.winConditions
           ? decodeWinConditions(data.config.winConditions)
-          : null) || [{ hidden: false, type: WinCriteria.Default }],
+          : null) || [
+          { hidden: false, optional: false, type: WinCriteria.Default },
+        ],
       ),
       size,
       toPlayerID(data.currentPlayer),