refactor: timer update

apps/server/src/stores/__tests__/runtimeState.test.ts

@@ -36,7 +36,6 @@ const mockState = {
   },
   _timer: {
     pausedAt: null,
-    secondaryTarget: null,
   },
 } as RuntimeState;
 

apps/server/src/stores/runtimeState.ts

@@ -1,9 +1,8 @@
-import { MaybeNumber, OntimeEvent, Playback, Runtime, TimerPhase, TimerState, TimerType } from 'ontime-types';
+import { MaybeNumber, OntimeEvent, Playback, Runtime, TimerPhase, TimerState } from 'ontime-types';
 import { calculateDuration, dayInMs } from 'ontime-utils';
 
 import { clock } from '../services/Clock.js';
 import { RestorePoint } from '../services/RestoreService.js';
-
 import {
   getCurrent,
   getExpectedEnd,
@@ -11,32 +10,32 @@ import {
   getRollTimers,
   getRuntimeOffset,
   getTimerPhase,
-  skippedOutOfEvent,
-  updateRoll,
+  isPlaybackActive,
 } from '../services/timerUtils.js';
 import { timerConfig } from '../config/config.js';
 
 const initialRuntime: Runtime = {
-  selectedEventIndex: null,
-  numEvents: 0,
-  offset: 0,
-  plannedStart: 0,
-  plannedEnd: 0,
-  actualStart: null,
-  expectedEnd: null,
+  selectedEventIndex: null, // changes if rundown changes or we load a new event
+  numEvents: 0, // change initiated by user
+  offset: 0, // changes at runtime
+  plannedStart: 0, // only changes if event changes
+  plannedEnd: 0, // only changes if event changes
+  actualStart: null, // set once we start the timer
+  expectedEnd: null, // changes with runtime, based on offset
 } as const;
 
 const initialTimer: TimerState = {
   addedTime: 0,
-  current: null,
-  duration: null,
-  elapsed: null,
-  expectedFinish: null, // TODO: expected finish could account for midnight, we cleanup in the clients
-  finishedAt: null,
-  phase: TimerPhase.None,
-  playback: Playback.Stop,
-  secondaryTimer: null,
-  startedAt: null,
+  current: null, // changes on every update
+  duration: null, // only changes if event changes
+  elapsed: null, // changes on every update
+  // TODO: expected finish could account for midnight, we cleanup in the clients
+  expectedFinish: null, // change can only be initiated by user
+  finishedAt: null, // can change on update or user action
+  phase: TimerPhase.None, // can change on update or user action
+  playback: Playback.Stop, // change initiated by user
+  secondaryTimer: null, // change on every update
+  startedAt: null, // change can only be initiated by user
 } as const;
 
 export type RuntimeState = {
@@ -49,10 +48,9 @@ export type RuntimeState = {
   timer: TimerState;
   // private properties of the timer calculations
   _timer: {
-    forceFinish: MaybeNumber;
+    forceFinish: MaybeNumber; // wether we should declare an event as finished, will contain the finish time
     totalDelay: number; // this value comes from rundown service
     pausedAt: MaybeNumber;
-    secondaryTarget: MaybeNumber;
   };
 };
 
@@ -68,7 +66,6 @@ const runtimeState: RuntimeState = {
     forceFinish: null,
     totalDelay: 0,
     pausedAt: null,
-    secondaryTarget: null,
   },
 };
 
@@ -93,7 +90,6 @@ export function clear() {
 
   // we maintain the total delay
   runtimeState._timer.pausedAt = null;
-  runtimeState._timer.secondaryTarget = null;
 }
 
 /**
@@ -125,7 +121,8 @@ export function updateRundownData(rundownData: RundownData) {
 
   runtimeState.runtime.numEvents = rundownData.numEvents;
   runtimeState.runtime.plannedStart = rundownData.firstStart;
-  runtimeState.runtime.plannedEnd = rundownData.firstStart + rundownData.totalDuration;
+  runtimeState.runtime.plannedEnd =
+    rundownData.firstStart === null ? null : rundownData.firstStart + rundownData.totalDuration;
   runtimeState.runtime.expectedEnd = getExpectedEnd(runtimeState);
 }
 
@@ -282,7 +279,6 @@ export function start(state: RuntimeState = runtimeState): boolean {
   }
   state.clock = clock.timeNow();
   state.timer.secondaryTimer = null;
-  state._timer.secondaryTarget = null;
 
   // add paused time if it exists
   if (state._timer.pausedAt) {
@@ -374,73 +370,60 @@ export type UpdateResult = {
 };
 
 export function update(): UpdateResult {
-  let hasTimerFinished = false;
-  let shouldCallRoll = false; // we also need to call roll if a secondary timer has finished
+  // 0. there are some things we always do
+  runtimeState.clock = clock.timeNow(); // we update the clock on every update call
 
-  const previousTime = runtimeState.clock;
-  runtimeState.clock = clock.timeNow();
-
-  // we call integrations if we update timers
-  if (runtimeState.timer.playback === Playback.Roll) {
-    const result = onRollUpdate();
-    shouldCallRoll = result.doRoll;
-    hasTimerFinished = result.isFinished;
-  } else if (runtimeState.timer.startedAt !== null) {
-    // we only update timer if a timer has been started
-    const result = onPlayUpdate();
-    hasTimerFinished = result.isFinished;
-  } else if (runtimeState.eventNow?.timerType === TimerType.TimeToEnd) {
-    // or if we are in a time-to-end timer
-    runtimeState.timer.current = getCurrent(runtimeState);
-    runtimeState.timer.duration = runtimeState.timer.current;
+  // 1. is playback idle?
+  if (!isPlaybackActive(runtimeState)) {
+    return updateIfIdle();
   }
 
-  // update timer phase
-  runtimeState.timer.phase = getTimerPhase(runtimeState);
+  // 2. are we waiting to roll?
+  if (runtimeState.timer.playback === Playback.Roll && runtimeState.timer.secondaryTimer !== null) {
+    return updateIfWaitingToRoll(runtimeState.timer.secondaryTimer);
+  }
 
-  // update offset
+  // 3. at this point we know that we are playing an event
+  // reset data
+  runtimeState.timer.secondaryTimer = null;
+
+  // update timer state
+  if (!runtimeState.timer.duration) {
+    throw new Error('Timer duration is not set');
+  }
+
+  runtimeState.timer.current = getCurrent(runtimeState);
+  runtimeState.timer.expectedFinish = getExpectedFinish(runtimeState);
+  runtimeState.timer.phase = getTimerPhase(runtimeState);
+  runtimeState.timer.elapsed = runtimeState.timer.duration - runtimeState.timer.current;
+
+  // update runtime, needs up-to-date timer state
   runtimeState.runtime.offset = getRuntimeOffset(runtimeState);
   runtimeState.runtime.expectedEnd = getExpectedEnd(runtimeState);
 
-  return {
-    hasTimerFinished,
-    shouldCallRoll,
-  };
+  const finishedNow =
+    Boolean(runtimeState._timer.forceFinish) ||
+    (runtimeState.timer.current <= timerConfig.triggerAhead && runtimeState.timer.finishedAt === null);
 
-  function onRollUpdate() {
-    const hasSkippedOutOfEvent = skippedOutOfEvent(runtimeState, previousTime, timerConfig.skipLimit);
-    if (hasSkippedOutOfEvent) {
-      return { doRoll: true };
-    }
-    const { updatedTimer, updatedSecondaryTimer, doRollLoad, isFinished } = updateRoll(runtimeState);
-    runtimeState.timer.current = updatedTimer;
-    runtimeState.timer.secondaryTimer = updatedSecondaryTimer;
-    runtimeState.timer.elapsed = runtimeState.timer.duration - runtimeState.timer.current;
-
-    return { doRoll: doRollLoad, isFinished };
+  if (finishedNow) {
+    // reset state
+    runtimeState._timer.forceFinish;
+    runtimeState.timer.finishedAt = runtimeState._timer.forceFinish ?? runtimeState.clock;
+  } else {
+    runtimeState.timer.expectedFinish = getExpectedFinish(runtimeState);
   }
 
-  function onPlayUpdate() {
-    let isFinished = false;
-    runtimeState.timer.current = getCurrent(runtimeState);
-    const shouldForceFinish = runtimeState._timer.forceFinish !== null;
-    const finishedNow =
-      shouldForceFinish ||
-      (runtimeState.timer.current <= timerConfig.triggerAhead && runtimeState.timer.finishedAt === null);
+  return { hasTimerFinished: finishedNow, shouldCallRoll: finishedNow };
 
-    if (runtimeState.timer.playback === Playback.Play && finishedNow) {
-      runtimeState.timer.finishedAt = runtimeState._timer.forceFinish ?? runtimeState.clock;
-      isFinished = true;
-    } else {
-      runtimeState.timer.expectedFinish = getExpectedFinish(runtimeState);
-    }
+  function updateIfIdle() {
+    // if nothing is running, nothing to do
+    return { hasTimerFinished: false, shouldCallRoll: false };
+  }
 
-    if (shouldForceFinish) {
-      runtimeState._timer.forceFinish = null;
-    }
-    runtimeState.timer.elapsed = runtimeState.timer.duration - runtimeState.timer.current;
-
-    return { isFinished };
+  function updateIfWaitingToRoll(targetTime: number) {
+    runtimeState.timer.secondaryTimer = targetTime - runtimeState.clock;
+    runtimeState.timer.phase = TimerPhase.Pending;
+    return { hasTimerFinished: false, shouldCallRoll: runtimeState.timer.secondaryTimer < 0 };
   }
 }
 
@@ -454,7 +437,6 @@ export function roll(rundown: OntimeEvent[]) {
   if (currentEvent) {
     // there is something running, load
     runtimeState.timer.secondaryTimer = null;
-    runtimeState._timer.secondaryTarget = null;
 
     // account for event that finishes the day after
     const endTime =
@@ -475,8 +457,8 @@ export function roll(rundown: OntimeEvent[]) {
     // account for day after
     const nextStart = nextEvent.timeStart < runtimeState.clock ? nextEvent.timeStart + dayInMs : nextEvent.timeStart;
     // nothing now, but something coming up
+    runtimeState.timer.phase = TimerPhase.Pending;
     runtimeState.timer.secondaryTimer = nextStart - runtimeState.clock;
-    runtimeState._timer.secondaryTarget = nextStart;
   }
 
   runtimeState.timer.playback = Playback.Roll;