108 lines
4.2 KiB
TypeScript
108 lines
4.2 KiB
TypeScript
import { writable, readonly } from 'svelte/store';
|
|
import { browser } from '$app/environment';
|
|
import type { GameTelemetry } from '$lib/telemetry.js';
|
|
|
|
export const telemetryByServer = writable<Map<string, GameTelemetry>>(new Map());
|
|
export const matchEventsByServer = writable<Map<string, GameTelemetry>>(new Map());
|
|
|
|
export interface RosterPlayer {
|
|
num: number | null;
|
|
score: number;
|
|
ping: number;
|
|
guid: string | null;
|
|
name: string;
|
|
}
|
|
|
|
export type Health = 'online' | 'stale' | 'offline' | 'starting' | 'provisioning';
|
|
export type RconFailure = 'no-config' | 'no-port' | 'send-error' | 'timeout' | 'bad-reply' | 'no-players';
|
|
|
|
export interface RconEndpoint {
|
|
host: string;
|
|
port: number;
|
|
}
|
|
|
|
export interface ServerStatus {
|
|
server: string;
|
|
players: number | null;
|
|
map: string | null;
|
|
gametype: string | null;
|
|
roster: RosterPlayer[] | null;
|
|
health: Health;
|
|
lastSeenAt: string | null;
|
|
lastError: string | null;
|
|
endpoint: RconEndpoint | null;
|
|
reason: RconFailure | null;
|
|
replySnippet: string | null;
|
|
activeSince: string | null;
|
|
inactiveSince: string | null;
|
|
gameStartedAt: string | null;
|
|
gameEndedAt: string | null;
|
|
}
|
|
|
|
export const statusByServer = writable<Map<string, ServerStatus>>(new Map());
|
|
export const statusReceivedAt = writable(0);
|
|
|
|
// Shared 1s ticker for elapsed-time displays. One interval feeds every card
|
|
// on the page instead of N per-card timers. Timer starts on the first
|
|
// startServerStream() call in the browser.
|
|
const _uiNow = writable(Date.now());
|
|
export const uiNow = readonly(_uiNow);
|
|
let serverClock: { time: number; receivedAt: number } | null = null;
|
|
|
|
// Report timestamps belong to the backend clock, which can differ from the
|
|
// browser's wall clock. Advance that clock locally even if updates stop.
|
|
export function serverTimeNow(): number {
|
|
return serverClock ? serverClock.time + performance.now() - serverClock.receivedAt : Date.now();
|
|
}
|
|
|
|
export function syncServerTime(serverNow?: number): void {
|
|
if (typeof serverNow === 'number' && Number.isFinite(serverNow)) {
|
|
// A delayed HTTP snapshot must not rewind time behind a newer stream
|
|
// update and make that update look like it came from the future.
|
|
const time = serverClock ? Math.max(serverNow, serverTimeNow()) : serverNow;
|
|
serverClock = { time, receivedAt: performance.now() };
|
|
}
|
|
// Refresh immediately: a suspended tab's interval may be well behind.
|
|
_uiNow.set(serverTimeNow());
|
|
}
|
|
|
|
let tickInterval: ReturnType<typeof setInterval> | null = null;
|
|
|
|
let source: EventSource | null = null;
|
|
|
|
export function startServerStream(): (() => void) | undefined {
|
|
if (!browser || source) return;
|
|
syncServerTime();
|
|
source = new EventSource('/api/events/servers');
|
|
source.addEventListener('server-telemetry', (evt) => {
|
|
const data = JSON.parse((evt as MessageEvent).data) as { entries: GameTelemetry[]; snapshot?: boolean; serverNow?: number };
|
|
syncServerTime(data.serverNow);
|
|
matchEventsByServer.update((previous) => {
|
|
const next = data.snapshot ? new Map<string, GameTelemetry>() : new Map(previous);
|
|
for (const entry of data.entries) {
|
|
if (entry.event === 'game_start' || entry.event === 'game_end') next.set(entry.server, entry);
|
|
}
|
|
return next;
|
|
});
|
|
telemetryByServer.update((previous) => {
|
|
const next = data.snapshot ? new Map<string, GameTelemetry>() : new Map(previous);
|
|
for (const entry of data.entries) next.set(entry.server, entry);
|
|
return next;
|
|
});
|
|
});
|
|
source.addEventListener('server-status', (evt) => {
|
|
const data = JSON.parse((evt as MessageEvent).data) as { entries: ServerStatus[]; serverNow?: number };
|
|
syncServerTime(data.serverNow);
|
|
statusByServer.update(() => {
|
|
const m = new Map<string, ServerStatus>();
|
|
for (const e of data.entries) m.set(e.server, e);
|
|
return m;
|
|
});
|
|
statusReceivedAt.set(Date.now());
|
|
});
|
|
if (tickInterval === null) {
|
|
tickInterval = setInterval(() => _uiNow.set(serverTimeNow()), 1000);
|
|
}
|
|
return () => { source?.close(); source = null; if (tickInterval) clearInterval(tickInterval); tickInterval = null; };
|
|
}
|