Add optional win condition feature (#34)

Co-authored-by: cpojer <christoph.pojer@gmail.com>

Author: sookmax

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"]]],
+  ["OptionalCondition", [43, ["type", "condition", "conditionId", "toPlayer"]]]
 ]

apollo/GameOver.tsx

@@ -52,12 +52,20 @@ export type GameEndActionResponse = Readonly<{
   type: 'GameEnd';
 }>;
 
+export type OptionalConditionActionResponse = Readonly<{
+  condition: WinCondition;
+  conditionId: number;
+  toPlayer: PlayerID;
+  type: 'OptionalCondition';
+}>;
+
 export type GameOverActionResponses =
   | AttackUnitGameOverActionResponse
   | BeginTurnGameOverActionResponse
   | CaptureGameOverActionResponse
   | GameEndActionResponse
-  | PreviousTurnGameOverActionResponse;
+  | PreviousTurnGameOverActionResponse
+  | OptionalConditionActionResponse;
 
 function check(
   previousMap: MapData,
@@ -92,6 +100,7 @@ const pickWinningPlayer = (
       condition.players?.length ? condition.players : activeMap.active
     ).find(
       (playerID) =>
+        (!condition.optional || !condition.completed?.has(playerID)) &&
         activeMap.getPlayer(playerID).stats.destroyedUnits >= condition.amount,
     );
   }
@@ -138,19 +147,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?.type === WinCriteria.Default || 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 +172,38 @@ export function checkGameOverConditions(
     ];
   }
 
+  const optionalConditionResponse =
+    condition?.type !== WinCriteria.Default &&
+    condition?.optional === true &&
+    winningPlayer &&
+    !condition.completed?.has(winningPlayer)
+      ? ({
+          condition,
+          conditionId: activeMap.config.winConditions.indexOf(condition),
+          toPlayer: winningPlayer,
+          type: 'OptionalCondition',
+        } as const)
+      : null;
+
+  if (optionalConditionResponse) {
+    let newGameState: GameState = [];
+    [newGameState, map] = processRewards(map, optionalConditionResponse);
+    map = applyGameOverActionResponse(map, optionalConditionResponse);
+    return [
+      ...gameState,
+      ...newGameState,
+      [
+        // update `optionalConditionResponse.condition` with the new `map.config` updated in `applyGameOverActionResponse()`
+        {
+          ...optionalConditionResponse,
+          condition:
+            map.config.winConditions[optionalConditionResponse.conditionId],
+        },
+        map,
+      ],
+    ];
+  }
+
   if (
     actionResponse?.type === 'AttackUnitGameOver' ||
     actionResponse?.type === 'BeginTurnGameOver'
@@ -231,6 +273,24 @@ export function applyGameOverActionResponse(
     }
     case 'GameEnd':
       return map;
+    case 'OptionalCondition': {
+      const { condition, conditionId, toPlayer } = actionResponse;
+      if (condition.type === WinCriteria.Default) {
+        return map;
+      }
+      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

@@ -480,11 +480,12 @@ export default function applyActionResponse(
     case 'HiddenTargetAttackBuilding':
     case 'HiddenTargetAttackUnit':
       return applyHiddenActionResponse(map, vision, actionResponse);
+    case 'OptionalCondition':
     case 'AttackUnitGameOver':
     case 'BeginTurnGameOver':
     case 'CaptureGameOver':
-    case 'PreviousTurnGameOver':
     case 'GameEnd':
+    case 'PreviousTurnGameOver':
       return applyGameOverActionResponse(map, actionResponse);
     case 'SetViewer': {
       const currentPlayer = map.maybeGetPlayer(vision.currentViewer)?.id;

apollo/lib/computeVisibleActions.tsx

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

apollo/lib/dropLabelsFromActionResponse.tsx

@@ -62,6 +62,7 @@ export default function dropLabelsFromActionResponse(
     case 'GameEnd':
     case 'HiddenFundAdjustment':
     case 'Message':
+    case 'OptionalCondition':
     case 'PreviousTurnGameOver':
     case 'ReceiveReward':
     case 'SecretDiscovered':

apollo/lib/getActionResponseVectors.tsx

@@ -87,6 +87,7 @@ export default function getActionResponseVectors(
     case 'GameEnd':
     case 'HiddenFundAdjustment':
     case 'Message':
+    case 'OptionalCondition':
     case 'PreviousTurnGameOver':
     case 'ReceiveReward':
     case 'SecretDiscovered':

apollo/lib/getWinningTeam.tsx apollo/lib/getMatchingTeam.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,
+  OptionalConditionActionResponse,
+} from '../GameOver.tsx';
 
-export default function getWinningTeam(
+export default function getMatchingTeam(
   map: MapData,
-  actionResponse: GameEndActionResponse,
+  actionResponse: GameEndActionResponse | OptionalConditionActionResponse,
 ): '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,
+  OptionalConditionActionResponse,
+} from '../GameOver.tsx';
 import { GameState, MutableGameState } from '../Types.tsx';
-import getWinningTeam from './getWinningTeam.tsx';
+import getMatchingTeam from './getMatchingTeam.tsx';
 
 export function processRewards(
   map: MapData,
-  gameEndResponse: GameEndActionResponse,
+  actionResponse: GameEndActionResponse | OptionalConditionActionResponse,
 ): [GameState, MapData] {
   const gameState: MutableGameState = [];
-  const winningTeam = getWinningTeam(map, gameEndResponse);
+  const winningTeam = getMatchingTeam(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,