168 lines
7.6 KiB
TypeScript
168 lines
7.6 KiB
TypeScript
import { asGameTick, GAME_TICKS_PER_TURN, type GameTick } from './gameTimeUnits.js';
|
|
|
|
/** 정상 시간표를 유지하며 대기 후 두 배 속도로 월 경계에 합류한다. */
|
|
export interface TurnRecoveryWindow {
|
|
startTick: GameTick;
|
|
endTick: GameTick;
|
|
startWallAt: Date;
|
|
}
|
|
|
|
export const readTurnRecovery = (row: {
|
|
clockRecoveryStartTick?: bigint | number | null;
|
|
clockRecoveryEndTick?: bigint | number | null;
|
|
clockRecoveryStartWallAt?: Date | null;
|
|
}): TurnRecoveryWindow | null => {
|
|
const values = [row.clockRecoveryStartTick, row.clockRecoveryEndTick, row.clockRecoveryStartWallAt];
|
|
if (values.every((value) => value == null)) return null;
|
|
if (values.some((value) => value == null)) throw new Error('Incomplete durable turn recovery window.');
|
|
const window = {
|
|
startTick: asGameTick(Number(row.clockRecoveryStartTick)),
|
|
endTick: asGameTick(Number(row.clockRecoveryEndTick)),
|
|
startWallAt: new Date(row.clockRecoveryStartWallAt!),
|
|
};
|
|
validateTurnRecovery(window);
|
|
return window;
|
|
};
|
|
|
|
export const serializeTurnRecovery = (window: TurnRecoveryWindow | null) => ({
|
|
clockRecoveryStartTick: window?.startTick ?? null,
|
|
clockRecoveryEndTick: window?.endTick ?? null,
|
|
clockRecoveryStartWallAt: window?.startWallAt.toISOString() ?? null,
|
|
});
|
|
|
|
export const readSerializedTurnRecovery = (value: unknown): TurnRecoveryWindow | null => {
|
|
if (value == null) return null;
|
|
if (typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid serialized recovery window.');
|
|
const row = value as Record<string, unknown>;
|
|
if (row.clockRecoveryStartTick == null && row.clockRecoveryEndTick == null && row.clockRecoveryStartWallAt == null)
|
|
return null;
|
|
if (
|
|
typeof row.clockRecoveryStartTick !== 'number' ||
|
|
typeof row.clockRecoveryEndTick !== 'number' ||
|
|
typeof row.clockRecoveryStartWallAt !== 'string'
|
|
) {
|
|
throw new Error('Incomplete serialized recovery window.');
|
|
}
|
|
return readTurnRecovery({
|
|
clockRecoveryStartTick: row.clockRecoveryStartTick,
|
|
clockRecoveryEndTick: row.clockRecoveryEndTick,
|
|
clockRecoveryStartWallAt: new Date(row.clockRecoveryStartWallAt),
|
|
});
|
|
};
|
|
|
|
export interface TurnRecoveryPlan {
|
|
skippedTurns: number;
|
|
recoveryTurns: number;
|
|
initialTick: GameTick;
|
|
recovery: TurnRecoveryWindow | null;
|
|
}
|
|
|
|
export const nextTurnBoundary = (tick: number): GameTick => {
|
|
asGameTick(tick);
|
|
return asGameTick(Math.ceil(tick / GAME_TICKS_PER_TURN) * GAME_TICKS_PER_TURN);
|
|
};
|
|
|
|
/** 운영자 이동은 정수 턴으로만 받는다. 과거 실행의 취소를 뜻하지 않는다. */
|
|
export const turnShiftTicks = (turns: number): GameTick => {
|
|
if (!Number.isSafeInteger(turns)) throw new Error('Schedule movement requires an integer number of turns.');
|
|
return asGameTick(turns * GAME_TICKS_PER_TURN);
|
|
};
|
|
|
|
/** 즉시 처리 여부는 12턴 묶음 생략 전의 전체 지연으로 판정한다. */
|
|
export const immediateRecoveryLimitSeconds = (turnSeconds: number): number => Math.min(600, turnSeconds / 10);
|
|
|
|
/**
|
|
* observedTick은 중단 전에 저장한 관측 지점, normalTick은 기존 시간표의 현재 지점이다.
|
|
* 짧은 전체 지연만 즉시 처리한다. 그 외에는 나머지도 생략하지 않고 대기 후 두 배속으로 처리한다.
|
|
* 반환한 skip은 호출자가 미래 일정과 실행 cursor에 원자적으로 적용해야 한다.
|
|
*/
|
|
export const planTurnRecovery = (input: {
|
|
observedTick: number;
|
|
normalTick: number;
|
|
wallNow: Date;
|
|
turnSeconds: number;
|
|
}): TurnRecoveryPlan => {
|
|
const { observedTick, normalTick, wallNow, turnSeconds } = input;
|
|
asGameTick(observedTick);
|
|
asGameTick(normalTick);
|
|
if (!Number.isInteger(turnSeconds) || turnSeconds <= 0 || GAME_TICKS_PER_TURN % turnSeconds !== 0) {
|
|
throw new Error('Recovery requires a representable positive turn length.');
|
|
}
|
|
if (!Number.isFinite(wallNow.getTime())) throw new Error('Recovery wall instant is invalid.');
|
|
const gap = Math.max(0, normalTick - observedTick);
|
|
const ticksPerSecond = GAME_TICKS_PER_TURN / turnSeconds;
|
|
const immediateLimit = immediateRecoveryLimitSeconds(turnSeconds) * ticksPerSecond;
|
|
if (gap < immediateLimit) {
|
|
return {
|
|
skippedTurns: 0,
|
|
recoveryTurns: 0,
|
|
initialTick: asGameTick(Math.max(observedTick, normalTick)),
|
|
recovery: null,
|
|
};
|
|
}
|
|
const skippedTurns = Math.floor(gap / (12 * GAME_TICKS_PER_TURN)) * 12;
|
|
const initialTick = asGameTick(observedTick + turnShiftTicks(skippedTurns));
|
|
const remaining = normalTick - initialTick;
|
|
if (remaining === 0) return { skippedTurns, recoveryTurns: 0, initialTick, recovery: null };
|
|
|
|
// 즉시 2배속으로 따라잡을 수 있는 가장 이른 지점 이후의 월 경계를 고른다.
|
|
// 대기도 추가 지연이므로 경계까지 여유의 절반만 기다린다. 밀리초 반올림은 종료 시각을 보존한다.
|
|
const endTick = nextTurnBoundary(normalTick + remaining);
|
|
const endWallMs = wallNow.getTime() + Math.ceil(((endTick - normalTick) * 1_000) / ticksPerSecond);
|
|
const durationMs = Math.ceil(((endTick - initialTick) * 1_000) / (2 * ticksPerSecond));
|
|
return {
|
|
skippedTurns,
|
|
recoveryTurns: remaining / GAME_TICKS_PER_TURN,
|
|
initialTick,
|
|
recovery: { startTick: initialTick, endTick, startWallAt: new Date(endWallMs - durationMs) },
|
|
};
|
|
};
|
|
|
|
export const validateTurnRecovery = (window: TurnRecoveryWindow): void => {
|
|
asGameTick(window.startTick);
|
|
asGameTick(window.endTick);
|
|
const span = window.endTick - window.startTick;
|
|
if (
|
|
!Number.isFinite(window.startWallAt.getTime()) ||
|
|
window.endTick % GAME_TICKS_PER_TURN !== 0 ||
|
|
span <= 0 ||
|
|
span >= 25 * GAME_TICKS_PER_TURN
|
|
)
|
|
throw new Error('Recovery must end at a turn boundary with a positive span below twenty-five turns.');
|
|
};
|
|
|
|
/** 경계 전에는 정상 속도, 복구 구간은 두 배, 합류 경계 이후는 정상 속도이다. */
|
|
export const observeTurnRecovery = (window: TurnRecoveryWindow, wallNow: Date, ticksPerSecond: number): GameTick => {
|
|
validateTurnRecovery(window);
|
|
const elapsed = asGameTick(
|
|
Math.trunc(
|
|
((wallNow.getTime() - window.startWallAt.getTime()) *
|
|
ticksPerSecond *
|
|
(wallNow < window.startWallAt ? 1 : 2)) /
|
|
1_000
|
|
)
|
|
);
|
|
const endWallAt = projectRecoveryDeadline(window, window.endTick, ticksPerSecond);
|
|
if (wallNow >= endWallAt) {
|
|
return asGameTick(
|
|
window.endTick + Math.trunc(((wallNow.getTime() - endWallAt.getTime()) * ticksPerSecond) / 1_000)
|
|
);
|
|
}
|
|
// 이전 복구 창은 시작 전 1배속이었다. 새 창은 GameClock의 저장 tick 하한으로 대기한다.
|
|
return asGameTick(Math.min(window.endTick, window.startTick + elapsed));
|
|
};
|
|
|
|
/** 게임 좌표의 예정 시각을 사용자에게 표시할 실제 실행 시각으로 투영한다. */
|
|
export const projectRecoveryDeadline = (window: TurnRecoveryWindow, tick: number, ticksPerSecond: number): Date => {
|
|
validateTurnRecovery(window);
|
|
asGameTick(tick);
|
|
const offset = tick - window.startTick;
|
|
const span = window.endTick - window.startTick;
|
|
if (offset > span) {
|
|
const endWallMs = window.startWallAt.getTime() + Math.ceil((span * 1_000) / (2 * ticksPerSecond));
|
|
return new Date(endWallMs + Math.ceil(((offset - span) * 1_000) / ticksPerSecond));
|
|
}
|
|
const elapsed = offset < 0 ? offset : offset / 2;
|
|
return new Date(window.startWallAt.getTime() + Math.ceil((elapsed * 1_000) / ticksPerSecond));
|
|
};
|