86 lines
3.3 KiB
JavaScript
86 lines
3.3 KiB
JavaScript
import fs from 'node:fs';
|
|
import { BEST_OF, generateFlow, validateFlow } from './veto.js';
|
|
|
|
/**
|
|
* Lädt die Map-Pools und markiert jede Kombination aus Modus und Format als unterstützt oder nicht.
|
|
* Nur gültige Kombinationen können beim Erstellen eines Matches gewählt werden.
|
|
*/
|
|
export function loadMapPools(file) {
|
|
const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
|
|
return buildMapPools(raw);
|
|
}
|
|
|
|
export function buildMapPools(raw) {
|
|
const pools = {};
|
|
for (const [mode, pool] of Object.entries(raw.pools ?? {})) {
|
|
const ids = new Set();
|
|
for (const map of pool.maps ?? []) {
|
|
if (!/^[a-z0-9_]+$/.test(map.id)) throw new Error(`Ungültige Map-ID "${map.id}" im Pool "${mode}"`);
|
|
if (ids.has(map.id)) throw new Error(`Map "${map.id}" ist im Pool "${mode}" doppelt`);
|
|
if (map.image !== undefined && !/^(https?:\/\/|\/)[^\s"'()<>]+$/.test(map.image)) {
|
|
throw new Error(`Bild für "${map.id}" im Pool "${mode}" muss eine http(s)-URL oder ein Pfad mit / sein`);
|
|
}
|
|
ids.add(map.id);
|
|
}
|
|
// "active": false = Map ist im Katalog, wird aber erst nach Auswahl im Admin-Bereich gespielt
|
|
const active = pool.maps.filter((m) => m.active !== false).map((m) => m.id);
|
|
pools[mode] = {
|
|
mode,
|
|
label: pool.label ?? mode,
|
|
teamSize: pool.teamSize,
|
|
gameType: pool.gameType,
|
|
gameMode: pool.gameMode,
|
|
allMaps: pool.maps.map(({ active: _ignored, ...m }) => m),
|
|
flows: pool.flows ?? {},
|
|
maps: [],
|
|
formats: {},
|
|
};
|
|
setActiveMaps(pools[mode], active, { warn: true });
|
|
}
|
|
return pools;
|
|
}
|
|
|
|
/**
|
|
* Veto-Abläufe für die aktiven Maps: Ein in der Konfiguration hinterlegter Ablauf gilt, wenn er zur Map-Anzahl passt,
|
|
* sonst erzeugt die Anwendung einen passenden Ablauf.
|
|
*/
|
|
export function formatsFor(pool, mapCount, { warn = false } = {}) {
|
|
const formats = {};
|
|
for (const format of Object.keys(BEST_OF)) {
|
|
const configured = pool.flows?.[format];
|
|
if (configured && validateFlow(configured, mapCount, format).length === 0) {
|
|
formats[format] = { supported: true, flow: configured, generated: false };
|
|
continue;
|
|
}
|
|
const flow = generateFlow(mapCount, format);
|
|
if (!flow) {
|
|
formats[format] = { supported: false, reason: `${format.toUpperCase()} braucht mindestens ${Math.max(BEST_OF[format], 2)} Maps` };
|
|
continue;
|
|
}
|
|
const errors = validateFlow(flow, mapCount, format);
|
|
formats[format] = errors.length ? { supported: false, reason: errors.join('; ') } : { supported: true, flow, generated: true };
|
|
if (errors.length && warn) console.warn(`[map-pools] ${pool.mode}/${format} deaktiviert: ${errors.join('; ')}`);
|
|
}
|
|
return formats;
|
|
}
|
|
|
|
/** Aktive Maps eines Pools setzen (Reihenfolge wie im Katalog) und die Formate neu berechnen. */
|
|
export function setActiveMaps(pool, ids, options) {
|
|
const wanted = new Set(ids);
|
|
pool.maps = pool.allMaps.filter((m) => wanted.has(m.id));
|
|
pool.formats = formatsFor(pool, pool.maps.length, options);
|
|
return pool;
|
|
}
|
|
|
|
export function publicPools(pools) {
|
|
return Object.values(pools).map((p) => ({
|
|
mode: p.mode,
|
|
label: p.label,
|
|
teamSize: p.teamSize,
|
|
maps: p.maps,
|
|
formats: Object.fromEntries(
|
|
Object.entries(p.formats).map(([f, v]) => [f, { supported: v.supported, reason: v.reason ?? null, flow: v.flow ?? null }]),
|
|
),
|
|
}));
|
|
}
|