feat(objectives): ✨ implement state restoration from checkpoints

Author: thkruz

src/engine/ui/draggable-box.ts

@@ -1,3 +1,5 @@
+import { EventBus } from '@app/events/event-bus';
+import { Events } from '@app/events/events';
 import Draggabilly from 'draggabilly';
 import { html } from '../utils/development/formatter';
 import { getEl, showEl } from '../utils/get-el';
@@ -60,6 +62,10 @@ export abstract class DraggableBox {
         </div>
       `);
     }
+
+    EventBus.getInstance().on(Events.ROUTE_CHANGED, () => {
+      this.close();
+    });
   }
 
   protected abstract getBoxContentHtml(): string;

src/objectives/objectives-manager.ts

@@ -114,6 +114,57 @@ export class ObjectivesManager {
     return (performance.now() - this.startTime_) / 1000; // Convert to seconds
   }
 
+  /**
+   * Restore objective states from saved checkpoint data
+   * Merges saved state with current objective definitions, preserving progress
+   */
+  restoreState(savedStates: ObjectiveState[]): void {
+    if (!savedStates || savedStates.length === 0) {
+      return;
+    }
+
+    // Create a map of saved states by objective ID for quick lookup
+    const savedStateMap = new Map<string, ObjectiveState>();
+    savedStates.forEach((state) => {
+      savedStateMap.set(state.objective.id, state);
+    });
+
+    // Restore state for each current objective
+    for (const currentState of this.objectiveStates_) {
+      const savedState = savedStateMap.get(currentState.objective.id);
+
+      // If no saved state for this objective, keep it as-is (fresh state)
+      if (!savedState) {
+        continue;
+      }
+
+      // Restore activation state and timing
+      currentState.isActive = savedState.isActive;
+      currentState.activatedAt = savedState.activatedAt;
+      currentState.isCompleted = savedState.isCompleted;
+      currentState.completedAt = savedState.completedAt;
+
+      // Restore collapse state if objective was completed
+      if (savedState.isCompleted) {
+        this.collapsedObjectiveIds_.add(currentState.objective.id);
+      }
+
+      // Restore condition states by index to ensure proper matching
+      currentState.conditionStates.forEach((currentCondState, condIndex) => {
+        const savedCondState = savedState.conditionStates[condIndex];
+
+        // Only restore if condition exists in saved state
+        if (savedCondState) {
+          currentCondState.isSatisfied = savedCondState.isSatisfied;
+          currentCondState.satisfiedAt = savedCondState.satisfiedAt;
+          currentCondState.maintainedDuration = savedCondState.maintainedDuration;
+          currentCondState.isMaintenanceComplete = savedCondState.isMaintenanceComplete;
+          currentCondState.lostTimestamps = savedCondState.lostTimestamps || [];
+        }
+      });
+    }
+  }
+
   /**
    * Capture current collapse states from the DOM before regenerating HTML
    * Should be called before generateHtmlChecklist() to preserve user preferences
@@ -648,7 +699,7 @@ export class ObjectivesManager {
 
         const state = specA.state;
         const tolerance = condition.params.referenceLevelTolerance ?? 1; // Default ±1 dB
-        const diff = Math.abs(state.maxAmplitude - condition.params.referenceLevel);
+        const diff = Math.abs(state.referenceLevel - condition.params.referenceLevel);
 
         return diff <= tolerance;
       }

src/pages/sandbox-page.ts

@@ -72,14 +72,27 @@ export class SandboxPage extends BasePage {
     this.progressSaveManager_ = new ProgressSaveManager();
     this.progressSaveManager_.initialize();
 
-    this.initEquipment_();
+    // Initialize equipment and objectives asynchronously
+    this.initializeAsync_();
+  }
+
+  /**
+   * Handle async initialization of equipment and objectives
+   */
+  private async initializeAsync_(): Promise<void> {
+    await this.initEquipment_();
     SimulationManager.getInstance();
 
     // Initialize objectives manager if scenario has objectives
     const scenario = ScenarioManager.getInstance();
     if (scenario.data?.objectives && scenario.data.objectives.length > 0) {
       ObjectivesManager.initialize(scenario.data.objectives);
       SimulationManager.getInstance().objectivesManager = ObjectivesManager.getInstance();
+
+      // If we're continuing from a checkpoint, restore objective states
+      if (this.navigationOptions_.continueFromCheckpoint) {
+        await this.restoreObjectiveStatesFromCheckpoint_();
+      }
     }
 
     EventBus.getInstance().emit(Events.DOM_READY);
@@ -162,6 +175,31 @@ export class SandboxPage extends BasePage {
     }
   }
 
+  /**
+   * Restore objective states from checkpoint after ObjectivesManager has been initialized
+   */
+  private async restoreObjectiveStatesFromCheckpoint_(): Promise<void> {
+    if (!this.progressSaveManager_) {
+      return;
+    }
+
+    try {
+      const scenario = ScenarioManager.getInstance();
+      const checkpoint = await this.progressSaveManager_.loadCheckpoint(scenario.data.id) as {
+        state: AppState;
+      };
+
+      if (checkpoint?.state?.objectiveStates) {
+        const objectivesManager = ObjectivesManager.getInstance();
+        objectivesManager.restoreState(checkpoint.state.objectiveStates);
+        Logger.info('Objective states restored from checkpoint');
+      }
+    } catch (error) {
+      Logger.error('Failed to restore objective states from checkpoint:', error);
+      // Continue without restoring objectives - they'll start fresh
+    }
+  }
+
   hide(): void {
     SandboxPage.destroy();
   }
@@ -174,8 +212,8 @@ export class SandboxPage extends BasePage {
     }
 
     SandboxPage.instance_ = null;
-    ObjectivesManager.destroy();
     SimulationManager.destroy();
+    ObjectivesManager.destroy();
     EventBus.destroy();
     const container = getEl(SandboxPage.containerId);
     if (container) {

src/pages/sandbox/equipment.ts

@@ -6,6 +6,7 @@ import { Events } from "@app/events/events";
 import { DraggableHtmlBox } from "@app/modal/draggable-html-box";
 import { ObjectivesManager } from "@app/objectives";
 import { ScenarioManager, SimulationSettings } from "@app/scenario-manager";
+import { SimulationManager } from "@app/simulation/simulation-manager";
 import { html } from "../../engine/utils/development/formatter";
 import { Antenna } from '../../equipment/antenna/antenna';
 import { RealTimeSpectrumAnalyzer } from '../../equipment/real-time-spectrum-analyzer/real-time-spectrum-analyzer';
@@ -60,14 +61,16 @@ export class Equipment extends BaseElement {
       </div>
     </div>
     `;
-  missionBriefBox: DraggableHtmlBox;
-  checklistBox: DraggableHtmlBox;
 
   constructor(settings: SimulationSettings) {
     super();
     this.html_ = settings.layout ? settings.layout : this.html_;
     this.init_(SandboxPage.containerId, 'replace');
     this.initEquipment_(settings);
+
+    EventBus.getInstance().on(Events.ROUTE_CHANGED, () => {
+      this.stopChecklistRefreshTimer_();
+    });
   }
 
   protected addEventListeners_(): void {
@@ -79,8 +82,8 @@ export class Equipment extends BaseElement {
     const missionBriefUrl = ScenarioManager.getInstance().settings.missionBriefUrl;
     if (missionBriefUrl) {
       qs('.mission-brief-icon').addEventListener('click', () => {
-        this.missionBriefBox ??= new DraggableHtmlBox('Mission Brief', 'mission-brief', missionBriefUrl);
-        this.missionBriefBox.open();
+        SimulationManager.getInstance().missionBriefBox ??= new DraggableHtmlBox('Mission Brief', 'mission-brief', missionBriefUrl);
+        SimulationManager.getInstance().missionBriefBox.open();
       });
     }
   }
@@ -89,24 +92,24 @@ export class Equipment extends BaseElement {
     const missionBriefUrl = ScenarioManager.getInstance().settings.missionBriefUrl;
     if (missionBriefUrl) {
       qs('.checklist-icon').addEventListener('click', () => {
-        this.checklistBox ??= new DraggableHtmlBox('Checklist', 'checklist', '');
+        SimulationManager.getInstance().checklistBox ??= new DraggableHtmlBox('Checklist', 'checklist', '');
         const objectivesManager = ObjectivesManager.getInstance();
         objectivesManager.syncCollapsedStatesFromDOM();
         this.lastChecklistHtml_ = objectivesManager.generateHtmlChecklist();
-        this.checklistBox.updateContent(this.lastChecklistHtml_);
-        this.checklistBox.open();
-        this.startChecklistRefreshTimer_(this.checklistBox);
+        SimulationManager.getInstance().checklistBox.updateContent(this.lastChecklistHtml_);
+        SimulationManager.getInstance().checklistBox.open();
+        this.startChecklistRefreshTimer_(SimulationManager.getInstance().checklistBox);
       });
 
       EventBus.getInstance().on(Events.OBJECTIVE_ACTIVATED, () => {
         // Can't update it until they open it for the first time
-        if (!this.checklistBox) {
+        if (!SimulationManager.getInstance().checklistBox) {
           return;
         }
 
         const objectivesManager = ObjectivesManager.getInstance();
         this.lastChecklistHtml_ = objectivesManager.generateHtmlChecklist();
-        this.checklistBox.updateContent(this.lastChecklistHtml_);
+        SimulationManager.getInstance().checklistBox.updateContent(this.lastChecklistHtml_);
       });
     }
   }

src/simulation/simulation-manager.ts

@@ -1,6 +1,7 @@
 import { Satellite } from '@app/equipment/satellite/satellite';
 import { EventBus } from '@app/events/event-bus';
 import { Events } from '@app/events/events';
+import { DraggableHtmlBox } from '@app/modal/draggable-html-box';
 import { ObjectivesManager } from '@app/objectives';
 import { Equipment } from '@app/pages/sandbox/equipment';
 import { ScenarioManager } from '@app/scenario-manager';
@@ -24,6 +25,9 @@ export class SimulationManager {
   progressSaveManager: ProgressSaveManager;
   userDataServices: UserDataService;
 
+  missionBriefBox?: DraggableHtmlBox;
+  checklistBox?: DraggableHtmlBox;
+
   private constructor() {
     this.progressSaveManager = new ProgressSaveManager();
 
@@ -80,6 +84,8 @@ export class SimulationManager {
   }
 
   static destroy(): void {
+    SimulationManager.instance_?.checklistBox?.close();
+    SimulationManager.instance_?.missionBriefBox?.close();
     SimulationManager.instance_ = null;
   }
 }

src/sync/sync-manager.ts

@@ -1,4 +1,5 @@
 import { RFFrontEndState } from '@app/equipment/rf-front-end/rf-front-end';
+import { ObjectiveState } from '@app/objectives';
 import { AntennaState } from '../equipment/antenna/antenna';
 import { RealTimeSpectrumAnalyzerState } from '../equipment/real-time-spectrum-analyzer/real-time-spectrum-analyzer';
 import { ReceiverState } from '../equipment/receiver/receiver';
@@ -156,7 +157,22 @@ export class SyncManager {
       return { equipment: undefined };
     }
 
+    // Get objective states from SimulationManager if available
+    let objectiveStates: ObjectiveState[] | undefined;
+    try {
+      const { SimulationManager } = require('../simulation/simulation-manager');
+      const sim = SimulationManager.getInstance();
+      if (sim?.objectivesManager) {
+        objectiveStates = sim.objectivesManager.getObjectiveStates() as ObjectiveState[];
+      }
+    } catch (error) {
+      // SimulationManager or ObjectivesManager not available yet - this is expected during initialization
+      console.debug('ObjectivesManager not available when building state:', error);
+      objectiveStates = undefined;
+    }
+
     return {
+      objectiveStates,
       equipment: {
         spectrumAnalyzersState: this.equipment.spectrumAnalyzers.map(sa => sa.state),
         antennasState: this.equipment.antennas.map(a => a.state),
@@ -219,13 +235,27 @@ export class SyncManager {
         }
       });
     }
+
+    // Sync Objective States if available
+    if (state.objectiveStates && state.objectiveStates.length > 0) {
+      try {
+        const { SimulationManager } = require('../simulation/simulation-manager');
+        const sim = SimulationManager.getInstance();
+        if (sim?.objectivesManager) {
+          sim.objectivesManager.restoreState(state.objectiveStates);
+        }
+      } catch (error) {
+        console.debug('ObjectivesManager not available when syncing from storage:', error);
+      }
+    }
   }
 }
 
 /**
  * AppState interface (should match your existing type)
  */
 export interface AppState {
+  objectiveStates?: ObjectiveState[];
   equipment?: {
     spectrumAnalyzersState?: RealTimeSpectrumAnalyzerState[];
     rfFrontEndsState?: RFFrontEndState[];