mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
A layer's world clock coverage may now give each mark as an object,
{ time, label?, id?, kind? }, as well as a bare epoch ms number, and the
two may be mixed. worldClock.coverage() keeps marks as the sorted list of
distinct times, so existing readers are unchanged, and adds markDetails:
the merged marks in time order (then kind, label and id), each frozen and
holding only the fields given. Marks given alike by several sources appear
once, a bare time is dropped where a labelled mark shares it, and a mark
with no finite time is ignored. The contract is documented in the
worldClock JSDoc and docs/APPLICATION.md.
Launches label their marks with the mission's name (the launch's where it
has none), cut to 27 characters in capitals as the mission index shows
names. Earthquakes of magnitude 6 and up label theirs with the magnitude
as the map shows it and the feed's place cut to 40 characters, such as
"M6.4 · 113 km SSE of Lata, Solomon Islands"; the layer now tells the clock
when the labels change as well as the times.
On the timeline, a pointer within 6 px of a tick shows its label over the
track (nothing for an unlabelled mark), and a tap there goes exactly to
the mark's time instead of the point tapped. A tap elsewhere and a drag
work as before, and ticks stay ticks. The arrow keys still step from mark
to mark; with the handle on a mark, its labels follow the time in the
handle's aria-valuetext, and show over the track while it has focus.
175 lines
6.0 KiB
JavaScript
175 lines
6.0 KiB
JavaScript
import { defineStore } from 'pinia';
|
|
import { onScopeDispose, shallowRef } from 'vue';
|
|
import { worldClock } from '../../time/worldClock.js';
|
|
|
|
/** How often a shown timeline moves its readout and its end on with now. */
|
|
const LIVE_TICK_MS = 1000;
|
|
/** A scrub this close to now, as a share of the track, is a scrub to live. */
|
|
const LIVE_EDGE = 0.005;
|
|
/** The least that counts as at now, past the readout's own second. */
|
|
const LIVE_EDGE_MS = 5000;
|
|
/**
|
|
* The most that counts as at now, however long the track: on a track that
|
|
* runs over years, a share of it would take whole days back to live.
|
|
*/
|
|
const LIVE_EDGE_MAX_MS = 2 * 60_000;
|
|
/** The speeds play offers, in world ms per real ms. */
|
|
export const WORLD_TIME_SPEEDS = Object.freeze({
|
|
real: 1,
|
|
minute: 60,
|
|
hour: 3_600,
|
|
day: 86_400,
|
|
week: 604_800,
|
|
});
|
|
|
|
/**
|
|
* The world clock as the timeline shows it: `{live, playing, stepping,
|
|
* buffering, timeMs, supported, span}`, where `supported` says a layer that moves with the clock
|
|
* has time to show and `span` is the stretch the timeline runs over: the
|
|
* time those layers cover, reaching to now and to the world time, with their
|
|
* marks (`marks`, their times; `markDetails`, each `{time, label?, id?,
|
|
* kind?}`, as the world clock's coverage gives them). It follows the page's world clock, which tells it of every move, and
|
|
* of the time a few times a second while it plays on its own. While a
|
|
* timeline shows, it reads the clock each second itself, so live and the
|
|
* track's end keep up with now.
|
|
*/
|
|
export const useWorldTimeStore = defineStore('gev-world-time', () => {
|
|
// The time the layers cover, reaching to now.
|
|
const reach = () => {
|
|
const coverage = worldClock.coverage();
|
|
if (!coverage) return null;
|
|
const now = worldClock.wallNow();
|
|
return {
|
|
start: Math.min(coverage.start, now),
|
|
end: Math.max(coverage.end, now),
|
|
marks: coverage.marks,
|
|
markDetails: coverage.markDetails,
|
|
};
|
|
};
|
|
const spanOf = (state) => {
|
|
if (!state.supported) return null;
|
|
const covered = reach();
|
|
if (!covered) return null;
|
|
return Object.freeze({
|
|
start: Math.min(covered.start, state.timeMs),
|
|
end: Math.max(covered.end, state.timeMs),
|
|
marks: covered.marks,
|
|
markDetails: covered.markDetails,
|
|
});
|
|
};
|
|
const nearNow = (ms, length) =>
|
|
Math.abs(ms - worldClock.wallNow()) <=
|
|
Math.max(LIVE_EDGE_MS, Math.min(LIVE_EDGE_MAX_MS, length * LIVE_EDGE));
|
|
// Whether the track ends at now (and moves on with it), not past it.
|
|
const endsAtNow = (covered) =>
|
|
covered.end - worldClock.wallNow() <= LIVE_EDGE_MS;
|
|
// Play stops at the end of the track: at now it goes live, past now (a
|
|
// satellite's future) it holds there.
|
|
let stopping = false;
|
|
const stopAtEnd = (state) => {
|
|
if (stopping || !state.playing || state.live || !state.supported)
|
|
return false;
|
|
const covered = reach();
|
|
if (!covered || state.timeMs < covered.end) return false;
|
|
stopping = true;
|
|
try {
|
|
if (endsAtNow(covered)) worldClock.goLive();
|
|
else {
|
|
// Back to the end first, so nothing hears the overshoot as paused.
|
|
worldClock.seek(covered.end);
|
|
worldClock.pause();
|
|
worldClock.seek(covered.end);
|
|
}
|
|
} finally {
|
|
stopping = false;
|
|
}
|
|
return true;
|
|
};
|
|
const read = (state = worldClock.getState()) =>
|
|
Object.freeze({
|
|
live: state.live,
|
|
playing: state.playing,
|
|
stepping: state.stepping,
|
|
buffering: state.buffering,
|
|
timeMs: state.timeMs,
|
|
supported: state.supported,
|
|
span: spanOf(state),
|
|
});
|
|
const time = shallowRef(read());
|
|
const speed = shallowRef('real');
|
|
const rate = () => WORLD_TIME_SPEEDS[speed.value];
|
|
let ticker = null;
|
|
const syncTicker = () => {
|
|
// Playing, the clock tells of the time itself.
|
|
const ticking = Boolean(time.value.span) && !time.value.playing;
|
|
if (ticking && ticker === null)
|
|
ticker = setInterval(() => {
|
|
time.value = read();
|
|
}, LIVE_TICK_MS);
|
|
else if (!ticking && ticker !== null) {
|
|
clearInterval(ticker);
|
|
ticker = null;
|
|
}
|
|
};
|
|
const unsubscribe = worldClock.subscribe((state) => {
|
|
if (stopAtEnd(state)) return;
|
|
time.value = read(state);
|
|
syncTicker();
|
|
});
|
|
syncTicker();
|
|
onScopeDispose(() => {
|
|
unsubscribe();
|
|
if (ticker !== null) clearInterval(ticker);
|
|
ticker = null;
|
|
});
|
|
|
|
return {
|
|
time,
|
|
/**
|
|
* Play runs the track at the speed chosen, from the start when it is at
|
|
* its end (at live, say), as a video plays again from the top. It runs
|
|
* the clock itself: weather follows the time frame by frame like every
|
|
* other layer the track covers.
|
|
*/
|
|
togglePlay() {
|
|
const { playing, live, timeMs, span } = time.value;
|
|
if (playing) return worldClock.pause();
|
|
const covered = reach();
|
|
if (span && covered && (live || timeMs >= covered.end))
|
|
worldClock.seek(span.start);
|
|
worldClock.play({ rate: rate(), continuous: true });
|
|
},
|
|
speed,
|
|
/**
|
|
* Choose how fast play runs; playing, it changes at once. A driver steps
|
|
* at its own pace, so a speed chosen while one plays takes playback over
|
|
* from where it is.
|
|
*/
|
|
setSpeed(next) {
|
|
if (!Object.hasOwn(WORLD_TIME_SPEEDS, next)) return;
|
|
speed.value = next;
|
|
const { playing, stepping } = worldClock.getState();
|
|
if (!playing) return;
|
|
if (!stepping) return worldClock.setRate(rate());
|
|
worldClock.pause();
|
|
worldClock.play({ rate: rate(), continuous: true });
|
|
},
|
|
goLive: () => worldClock.goLive(),
|
|
/**
|
|
* Scrub to `ms`: playback stops where the hand puts it; at now, live.
|
|
* How near now counts as now goes by `length`, the stretch the track
|
|
* shows, all of the span unless it is zoomed.
|
|
*/
|
|
scrub(ms, length) {
|
|
const span = time.value.span;
|
|
length ??= span ? span.end - span.start : 0;
|
|
if (nearNow(ms, length)) {
|
|
worldClock.goLive();
|
|
return;
|
|
}
|
|
worldClock.pause();
|
|
worldClock.seek(ms);
|
|
},
|
|
};
|
|
});
|