taDuc
422 lines
14 KiB
TypeScript
422 lines
14 KiB
TypeScript
"use client";
|
|
|
|
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
|
|
import type { FeatureCollection } from "@/uhm/types/geo";
|
|
import type { BattleReplay, ReplayStage, ReplayStep, DialogState } from "@/uhm/types/projects";
|
|
import { dispatchReplayAction } from "./replayDispatcher";
|
|
import { mapActions } from "./mapActions";
|
|
import { createReplayMapEffects } from "./replayMapEffects";
|
|
|
|
export type ReplayPreviewToast = {
|
|
id: number;
|
|
message: string;
|
|
};
|
|
|
|
type PreviewBaseline = {
|
|
timelineYear: number;
|
|
timelineFilterEnabled: boolean;
|
|
timelineVisible: boolean;
|
|
layerPanelVisible: boolean;
|
|
zoomPanelVisible: boolean;
|
|
labelVisibility: Record<string, "visible" | "none">;
|
|
mapViewState: {
|
|
center: { lng: number; lat: number };
|
|
zoom: number;
|
|
pitch: number;
|
|
bearing: number;
|
|
projection: string;
|
|
} | null;
|
|
};
|
|
|
|
type FlattenedReplayStep = {
|
|
stage: ReplayStage;
|
|
step: ReplayStep;
|
|
stageId: number;
|
|
stepIndex: number;
|
|
};
|
|
|
|
type UseReplayPreviewOptions = {
|
|
replay: BattleReplay | null;
|
|
draft: FeatureCollection;
|
|
getMapInstance: () => import("maplibre-gl").Map | null;
|
|
initialTimelineYear: number;
|
|
initialTimelineFilterEnabled: boolean;
|
|
initialMapViewState: PreviewBaseline["mapViewState"];
|
|
selectedStageId: number | null;
|
|
selectedStepIndex: number | null;
|
|
onSelectStep: (stageId: number | null, stepIndex: number | null) => void;
|
|
setMapProjection?: (type: "globe" | "mercator") => void;
|
|
};
|
|
|
|
export function useReplayPreview({
|
|
replay,
|
|
draft,
|
|
getMapInstance,
|
|
initialTimelineYear,
|
|
initialTimelineFilterEnabled,
|
|
initialMapViewState,
|
|
selectedStageId,
|
|
selectedStepIndex,
|
|
onSelectStep,
|
|
setMapProjection,
|
|
}: UseReplayPreviewOptions) {
|
|
const [isPlaying, setIsPlaying] = useState(false);
|
|
const [dialog, setDialog] = useState<DialogState | null>(null);
|
|
const dialogRef = useRef<DialogState | null>(null);
|
|
const setDialogWithRef = useCallback((d: DialogState | null) => {
|
|
dialogRef.current = d;
|
|
setDialog(d);
|
|
}, []);
|
|
const [toasts, setToasts] = useState<ReplayPreviewToast[]>([]);
|
|
const [timelineVisible, setTimelineVisible] = useState(true);
|
|
const [layerPanelVisible, setLayerPanelVisible] = useState(false);
|
|
const [zoomPanelVisible, setZoomPanelVisible] = useState(true);
|
|
const [timelineYear, setTimelineYear] = useState(initialTimelineYear);
|
|
const [timelineFilterEnabled, setTimelineFilterEnabled] = useState(initialTimelineFilterEnabled);
|
|
const [sidebarOpen, setSidebarOpen] = useState(false);
|
|
const [activeWikiId, setActiveWikiId] = useState<string | null>(null);
|
|
const [playbackSpeed, setPlaybackSpeed] = useState(1);
|
|
const [hiddenGeometryIds, setHiddenGeometryIds] = useState<string[]>([]);
|
|
const [activeCursor, setActiveCursor] = useState<{
|
|
stageId: number | null;
|
|
stepIndex: number | null;
|
|
}>({
|
|
stageId: null,
|
|
stepIndex: null,
|
|
});
|
|
const [activeStepNumber, setActiveStepNumber] = useState<number | null>(null);
|
|
|
|
const runIdRef = useRef(0);
|
|
const playbackSpeedRef = useRef(1);
|
|
const toastIdRef = useRef(0);
|
|
const toastTimeoutsRef = useRef<number[]>([]);
|
|
const baselineRef = useRef<PreviewBaseline | null>(null);
|
|
const effects = useMemo(() => createReplayMapEffects(), []);
|
|
|
|
const flatSteps = useMemo(() => flattenReplaySteps(replay), [replay]);
|
|
|
|
useEffect(() => {
|
|
playbackSpeedRef.current = playbackSpeed;
|
|
}, [playbackSpeed]);
|
|
|
|
useEffect(() => {
|
|
const map = getMapInstance();
|
|
baselineRef.current = {
|
|
timelineYear: initialTimelineYear,
|
|
timelineFilterEnabled: initialTimelineFilterEnabled,
|
|
timelineVisible: true,
|
|
layerPanelVisible: false,
|
|
zoomPanelVisible: true,
|
|
labelVisibility: map ? mapActions.get_label_visibility(map) : {},
|
|
mapViewState: initialMapViewState,
|
|
};
|
|
}, [getMapInstance, initialMapViewState, initialTimelineFilterEnabled, initialTimelineYear, replay?.id]);
|
|
|
|
useEffect(() => {
|
|
return () => {
|
|
runIdRef.current += 1;
|
|
effects.clear(getMapInstance());
|
|
toastTimeoutsRef.current.forEach((timeoutId) => window.clearTimeout(timeoutId));
|
|
toastTimeoutsRef.current = [];
|
|
};
|
|
}, [effects, getMapInstance]);
|
|
|
|
const clearToasts = useCallback(() => {
|
|
toastTimeoutsRef.current.forEach((timeoutId) => window.clearTimeout(timeoutId));
|
|
toastTimeoutsRef.current = [];
|
|
setToasts([]);
|
|
}, []);
|
|
|
|
const resetPresentation = useCallback(() => {
|
|
setDialogWithRef(null);
|
|
setSidebarOpen(false);
|
|
setActiveWikiId(null);
|
|
setLayerPanelVisible(false);
|
|
setZoomPanelVisible(true);
|
|
playbackSpeedRef.current = 1;
|
|
setPlaybackSpeed(1);
|
|
setHiddenGeometryIds([]);
|
|
effects.clear(getMapInstance());
|
|
clearToasts();
|
|
}, [clearToasts, effects, getMapInstance, setDialogWithRef]);
|
|
|
|
const addToast = useCallback((message: string) => {
|
|
const text = String(message || "").trim();
|
|
if (!text.length) return;
|
|
|
|
const id = ++toastIdRef.current;
|
|
setToasts((prev) => [...prev, { id, message: text }]);
|
|
const timeoutId = window.setTimeout(() => {
|
|
setToasts((prev) => prev.filter((toast) => toast.id !== id));
|
|
toastTimeoutsRef.current = toastTimeoutsRef.current.filter((item) => item !== timeoutId);
|
|
}, 3200);
|
|
toastTimeoutsRef.current.push(timeoutId);
|
|
}, []);
|
|
|
|
const restorePreviewState = useCallback(() => {
|
|
setIsPlaying(false);
|
|
setActiveCursor({ stageId: null, stepIndex: null });
|
|
setActiveStepNumber(null);
|
|
resetPresentation();
|
|
|
|
const baseline = baselineRef.current;
|
|
if (!baseline) {
|
|
setTimelineVisible(true);
|
|
return;
|
|
}
|
|
|
|
setTimelineVisible(baseline.timelineVisible);
|
|
setLayerPanelVisible(baseline.layerPanelVisible);
|
|
setZoomPanelVisible(baseline.zoomPanelVisible);
|
|
setTimelineYear(baseline.timelineYear);
|
|
setTimelineFilterEnabled(baseline.timelineFilterEnabled);
|
|
const map = getMapInstance();
|
|
if (map) {
|
|
mapActions.restore_label_visibility(map, baseline.labelVisibility);
|
|
if (baseline.mapViewState) {
|
|
if (setMapProjection) {
|
|
setMapProjection(baseline.mapViewState.projection === "globe" ? "globe" : "mercator");
|
|
} else {
|
|
map.setProjection({
|
|
type: baseline.mapViewState.projection === "globe" ? "globe" : "mercator",
|
|
});
|
|
}
|
|
mapActions.set_camera_view(map, {
|
|
center: baseline.mapViewState.center,
|
|
zoom: baseline.mapViewState.zoom,
|
|
pitch: baseline.mapViewState.pitch,
|
|
bearing: baseline.mapViewState.bearing,
|
|
duration: 650,
|
|
});
|
|
}
|
|
}
|
|
}, [getMapInstance, resetPresentation, setMapProjection]);
|
|
|
|
const resetPreview = useCallback(() => {
|
|
runIdRef.current += 1;
|
|
restorePreviewState();
|
|
}, [restorePreviewState]);
|
|
|
|
const stopPreview = useCallback(() => {
|
|
runIdRef.current += 1;
|
|
restorePreviewState();
|
|
}, [restorePreviewState]);
|
|
|
|
const controllersRef = useRef<Parameters<typeof dispatchReplayAction>[0] | null>(null);
|
|
useEffect(() => {
|
|
controllersRef.current = {
|
|
map: getMapInstance(),
|
|
draft,
|
|
effects,
|
|
setTimelineVisible,
|
|
setTimelineFilterEnabled,
|
|
setLayerPanelVisible,
|
|
setZoomPanelVisible,
|
|
setSidebarOpen,
|
|
onSelectWiki: (id) => {
|
|
const nextId = String(id || "").trim();
|
|
setActiveWikiId(nextId || null);
|
|
},
|
|
addToast,
|
|
setPlaybackSpeed: (nextSpeed) => {
|
|
const safe = Number.isFinite(nextSpeed) && nextSpeed > 0 ? nextSpeed : 1;
|
|
playbackSpeedRef.current = safe;
|
|
setPlaybackSpeed(safe);
|
|
},
|
|
onYearChange: setTimelineYear,
|
|
showGeometries: (ids) => {
|
|
const nextIds = normalizeIdList(ids);
|
|
if (!nextIds.length) return;
|
|
setHiddenGeometryIds((prev) => prev.filter((id) => !nextIds.includes(id)));
|
|
},
|
|
hideGeometries: (ids) => {
|
|
const nextIds = normalizeIdList(ids);
|
|
if (!nextIds.length) return;
|
|
setHiddenGeometryIds((prev) => {
|
|
const seen = new Set(prev);
|
|
for (const id of nextIds) {
|
|
seen.add(id);
|
|
}
|
|
return Array.from(seen);
|
|
});
|
|
},
|
|
showOnlyGeometries: (ids) => {
|
|
const keepIds = new Set(normalizeIdList(ids));
|
|
if (!keepIds.size) return;
|
|
setHiddenGeometryIds(
|
|
draft.features
|
|
.map((feature) => String(feature.properties.id))
|
|
.filter((id) => !keepIds.has(id))
|
|
);
|
|
},
|
|
showAllGeometries: () => {
|
|
setHiddenGeometryIds([]);
|
|
},
|
|
setDialog: setDialogWithRef,
|
|
getDialog: () => dialogRef.current,
|
|
};
|
|
}, [addToast, draft, effects, getMapInstance]);
|
|
|
|
const playFromIndex = useCallback(async (startIndex: number) => {
|
|
if (!flatSteps.length) return;
|
|
const safeStartIndex = Math.max(0, Math.min(flatSteps.length - 1, startIndex));
|
|
resetPresentation();
|
|
effects.clear(getMapInstance());
|
|
setTimelineVisible(true);
|
|
setTimelineYear(initialTimelineYear);
|
|
setTimelineFilterEnabled(initialTimelineFilterEnabled);
|
|
|
|
const runId = runIdRef.current + 1;
|
|
runIdRef.current = runId;
|
|
setIsPlaying(true);
|
|
|
|
for (let index = safeStartIndex; index < flatSteps.length; index += 1) {
|
|
if (runIdRef.current !== runId) return;
|
|
|
|
const current = flatSteps[index];
|
|
setActiveCursor({
|
|
stageId: current.stageId,
|
|
stepIndex: current.stepIndex,
|
|
});
|
|
setActiveStepNumber(index + 1);
|
|
onSelectStep(current.stageId, current.stepIndex);
|
|
|
|
const controllers = controllersRef.current;
|
|
if (!controllers) return;
|
|
controllers.map = getMapInstance();
|
|
controllers.draft = draft;
|
|
|
|
const actions = [
|
|
...current.step.use_narrow_function,
|
|
...current.step.use_map_function,
|
|
...current.step.use_geo_function,
|
|
...current.step.use_UI_function,
|
|
];
|
|
for (const action of actions) {
|
|
if (runIdRef.current !== runId) return;
|
|
dispatchReplayAction(controllers, action);
|
|
}
|
|
|
|
const duration = Math.max(1, Math.trunc(Number(current.step.duration) || 1000));
|
|
const waitMs = Math.max(60, Math.round(duration / playbackSpeedRef.current));
|
|
const completed = await waitForPreviewDelay(waitMs, () => runIdRef.current !== runId);
|
|
if (!completed) return;
|
|
}
|
|
|
|
if (runIdRef.current !== runId) return;
|
|
restorePreviewState();
|
|
}, [
|
|
flatSteps,
|
|
draft,
|
|
effects,
|
|
getMapInstance,
|
|
initialTimelineFilterEnabled,
|
|
initialTimelineYear,
|
|
onSelectStep,
|
|
resetPresentation,
|
|
restorePreviewState,
|
|
]);
|
|
|
|
const playFromStart = useCallback(() => {
|
|
void playFromIndex(0);
|
|
}, [playFromIndex]);
|
|
|
|
const playFromSelection = useCallback(() => {
|
|
const selectedIndex = findReplayStepIndex(flatSteps, selectedStageId, selectedStepIndex);
|
|
void playFromIndex(selectedIndex >= 0 ? selectedIndex : 0);
|
|
}, [flatSteps, playFromIndex, selectedStageId, selectedStepIndex]);
|
|
|
|
return {
|
|
isPlaying,
|
|
dialog,
|
|
toasts,
|
|
timelineVisible,
|
|
layerPanelVisible,
|
|
zoomPanelVisible,
|
|
timelineYear,
|
|
timelineFilterEnabled,
|
|
sidebarOpen,
|
|
activeWikiId,
|
|
playbackSpeed,
|
|
activeStepNumber,
|
|
totalSteps: flatSteps.length,
|
|
hiddenGeometryIds,
|
|
activeCursor,
|
|
hasPlayableSteps: flatSteps.length > 0,
|
|
playFromStart,
|
|
playFromSelection,
|
|
stopPreview,
|
|
resetPreview,
|
|
setTimelineYear,
|
|
setTimelineFilterEnabled,
|
|
closeWikiPanel: () => {
|
|
setSidebarOpen(false);
|
|
setActiveWikiId(null);
|
|
},
|
|
openWikiPanelById: (wikiId: string) => {
|
|
const nextId = String(wikiId || "").trim();
|
|
if (!nextId.length) return;
|
|
setActiveWikiId(nextId);
|
|
setSidebarOpen(true);
|
|
},
|
|
};
|
|
}
|
|
|
|
function flattenReplaySteps(replay: BattleReplay | null): FlattenedReplayStep[] {
|
|
if (!replay) return [];
|
|
return replay.detail.flatMap((stage) =>
|
|
stage.steps.map((step, stepIndex) => ({
|
|
stage,
|
|
step,
|
|
stageId: stage.id,
|
|
stepIndex,
|
|
}))
|
|
);
|
|
}
|
|
|
|
function findReplayStepIndex(
|
|
steps: FlattenedReplayStep[],
|
|
selectedStageId: number | null,
|
|
selectedStepIndex: number | null
|
|
) {
|
|
if (selectedStageId == null || selectedStepIndex == null) {
|
|
return -1;
|
|
}
|
|
return steps.findIndex(
|
|
(item) =>
|
|
item.stageId === selectedStageId &&
|
|
item.stepIndex === selectedStepIndex
|
|
);
|
|
}
|
|
|
|
function normalizeIdList(ids: string[]) {
|
|
const seen = new Set<string>();
|
|
const next: string[] = [];
|
|
for (const item of ids) {
|
|
const id = String(item || "").trim();
|
|
if (!id.length || seen.has(id)) continue;
|
|
seen.add(id);
|
|
next.push(id);
|
|
}
|
|
return next;
|
|
}
|
|
|
|
function waitForPreviewDelay(duration: number, isCancelled: () => boolean) {
|
|
return new Promise<boolean>((resolve) => {
|
|
const timeoutId = window.setTimeout(() => {
|
|
resolve(!isCancelled());
|
|
}, duration);
|
|
|
|
const cancelLoop = () => {
|
|
if (!isCancelled()) {
|
|
window.setTimeout(cancelLoop, 32);
|
|
return;
|
|
}
|
|
window.clearTimeout(timeoutId);
|
|
resolve(false);
|
|
};
|
|
|
|
window.setTimeout(cancelLoop, 32);
|
|
});
|
|
}
|