import * as fs from 'node:fs'; import * as path from 'node:path'; import * as os from 'node:os'; import { ScenarioModel } from '../model/scenario-model.js'; import { DEFAULT_QUEST_CONFIG, getTypePrefix, serializeQuestConfig, type IniSection } from '../model/component-types.js'; import { writeIni } from '../io/ini-writer.js'; import { buildPackage } from '../io/package-builder.js'; import { parseLocalization } from '../io/localization-io.js'; import { getSharedCatalog } from '../catalogs/catalog-store.js'; import { parseRefList } from '../model/component-types.js'; import { requiredQuestFormat } from '../model/format-features.js'; const DATA_FILES = ['events.ini', 'tiles.ini', 'tokens.ini', 'spawns.ini', 'items.ini', 'ui.ini', 'other.ini'] as const; /** * Get the Valkyrie editor directory for MoM scenarios. * * Platform paths (mirrors Game.DefaultAppData() + "/MoM/Editor" in Valkyrie C#): * macOS/Linux: ~/.config/Valkyrie/MoM/Editor * Windows: %APPDATA%/Valkyrie/MoM/Editor */ export function getEditorDir(): string { const platform = os.platform(); let appData: string; if (platform === 'win32') { appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming'); } else { appData = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config'); } return path.join(appData, 'Valkyrie', 'MoM', 'Editor'); } export interface ScenarioSummary { name: string; dir: string; questName: string; } /** List all scenarios in the Valkyrie editor directory */ export function listScenarios(editorDir?: string): ScenarioSummary[] { const dir = editorDir ?? getEditorDir(); if (!fs.existsSync(dir)) return []; const entries = fs.readdirSync(dir, { withFileTypes: true }); const results: ScenarioSummary[] = []; for (const entry of entries) { if (!entry.isDirectory()) continue; const scenarioDir = path.join(dir, entry.name); const questPath = path.join(scenarioDir, 'quest.ini'); if (!fs.existsSync(questPath)) continue; // Try to read quest name from localization let questName = entry.name; const locPath = path.join(scenarioDir, 'Localization.English.txt'); if (fs.existsSync(locPath)) { try { const parsed = parseLocalization(fs.readFileSync(locPath, 'utf-8')); questName = parsed.entries.get('quest.name') ?? entry.name; } catch { /* use folder name */ } } results.push({ name: entry.name, dir: scenarioDir, questName }); } return results; } export interface ScenarioState { totalComponents: number; componentCounts: Record; localizationKeys: number; } /** Creates new scenario directory with quest.ini + empty data files */ export async function createScenario( name: string, options?: { dir?: string }, ): Promise<{ model: ScenarioModel; dir: string }> { const dir = options?.dir ?? name; if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); } const model = new ScenarioModel(undefined, dir); // Write quest.ini const questSections: Record> = { Quest: serializeQuestConfig(DEFAULT_QUEST_CONFIG), }; // New scenarios start empty — no data files listed or written. // They get populated on the first saveScenario() call. const bareKeySections: Record = { QuestText: ['Localization.English.txt'], QuestData: [], }; fs.writeFileSync(path.join(dir, 'quest.ini'), writeIni(questSections, bareKeySections)); // Write localization file with common keys const commonKeys: Record = { CONTINUE: 'Continue', PASS: 'Pass', FAIL: 'Fail' }; for (const [k, v] of Object.entries(commonKeys)) { model.localization.set(k, v); } fs.writeFileSync(path.join(dir, 'Localization.English.txt'), model.localization.toCSV()); return { model, dir }; } /** Loads existing scenario from directory */ export async function loadScenario(dir: string): Promise { const questIni = fs.readFileSync(path.join(dir, 'quest.ini'), 'utf-8'); const dataFiles: Record = {}; for (const f of DATA_FILES) { const filePath = path.join(dir, f); if (fs.existsSync(filePath)) { dataFiles[f] = fs.readFileSync(filePath, 'utf-8'); } } // Find English localization file let locContent: string | undefined; const locPath = path.join(dir, 'Localization.English.txt'); if (fs.existsSync(locPath)) { locContent = fs.readFileSync(locPath, 'utf-8'); } const model = ScenarioModel.loadFromData(questIni, dataFiles, locContent); model.scenarioDir = dir; return model; } /** Returns current scenario state summary */ export function getScenarioState(model: ScenarioModel): ScenarioState { const all = model.getAll(); const counts: Record = {}; for (const comp of all) { const prefix = getTypePrefix(comp.name); counts[prefix] = (counts[prefix] ?? 0) + 1; } return { totalComponents: all.length, componentCounts: counts, localizationKeys: model.localization.size, }; } /** Saves model to disk */ export async function saveScenario(model: ScenarioModel): Promise { const dir = model.scenarioDir; if (!dir) throw new Error('Model has no scenarioDir set'); // Serialize components by file const iniData = model.serializeToIniData(); // Only write data files that have components; delete stale empty files const populatedFiles: string[] = []; for (const f of DATA_FILES) { const sections = iniData[f]; const filePath = path.join(dir, f); if (sections && Object.keys(sections).length > 0) { fs.writeFileSync(filePath, writeIni(sections)); populatedFiles.push(f); } else { // Remove stale empty file from a prior save if (fs.existsSync(filePath)) fs.unlinkSync(filePath); } } const requiredPacks = computeRequiredPacks(model); if (requiredPacks.size > 0) { model.questConfig.packs = [...requiredPacks].sort().join(' '); } // Declare the quest format the scenario's features need, so older Valkyrie // versions refuse it cleanly instead of ignoring fields (or crashing on custom tiles) model.questConfig.format = Math.max(model.questConfig.format, requiredQuestFormat(model.getAll())); // Write quest.ini — only list populated data files const questSections: Record> = { Quest: serializeQuestConfig(model.questConfig), }; const bareKeySections: Record = { QuestText: ['Localization.English.txt'], QuestData: populatedFiles, }; fs.writeFileSync(path.join(dir, 'quest.ini'), writeIni(questSections, bareKeySections)); // Write localization const locContent = model.localization.toCSV(); fs.writeFileSync(path.join(dir, 'Localization.English.txt'), locContent); } /** * Expansions a component only runs with: its tests check that the pack is present * (`VarOperation:#BtT,==,1`), all of them must pass (no OR), so its content is optional. * Valkyrie ignores conditions when vartests are set. */ function gatedPacks(data: IniSection): Set { const packs = new Set(); const vartests = (data.vartests ?? '').split(/\s+/).filter(Boolean); if (vartests.some(t => /^VarTestsLogicalOperator:OR$/i.test(t))) return packs; const tests = vartests.length > 0 ? vartests.map(t => t.replace(/^VarOperation:/, '')) : (data.conditions ?? '').split(/\s+/).filter(Boolean); for (const t of tests) { const m = t.match(/^#(\w+),(==|>=|>|!=),(-?\d+(?:\.\d+)?)$/); if (!m) continue; const [, pack, op, raw] = m; const v = Number(raw); const owned = op === '==' ? v === 1 : op === '>' ? v >= 0 && v < 1 : op === '>=' ? v > 0 && v <= 1 : v === 0; if (owned) packs.add(pack); } return packs; } /** * The expansions a scenario needs, from everything it puts on the table: * tile sides, spawned monsters (a custom monster counts through its base), * catalog monsters shown as tokens, and quest items given by name. Content behind * a test for its own expansion ("the Thrall if Beyond the Threshold is owned") is optional. */ export function computeRequiredPacks(model: ScenarioModel): Set { const catalog = getSharedCatalog(); const requiredPacks = new Set(); const add = (pack: string | undefined, gated?: Set) => { if (pack && pack !== 'MoMBase' && !gated?.has(pack)) requiredPacks.add(pack); }; const monsterPack = (name: string) => { const custom = name.startsWith('CustomMonster') ? model.get(name) : undefined; return catalog.getPackForMonster(custom?.data.base ?? name); }; for (const comp of model.getByType('Tile')) { if (comp.data.side) add(catalog.getPackForTileSide(comp.data.side)); } const spawned = new Set(); for (const comp of model.getByType('Spawn')) { const gated = gatedPacks(comp.data); for (const name of parseRefList(comp.data.monster ?? '')) { spawned.add(name); add(monsterPack(name), gated); } } // A custom monster counts through the spawns that place it; one nothing spawns may be placed another way for (const comp of model.getByType('CustomMonster')) { if (comp.data.base && !spawned.has(comp.name)) add(catalog.getPackForMonster(comp.data.base)); } for (const comp of model.getByType('Token')) { if (comp.data.type && !comp.data.customImage) add(catalog.getPackForMonster(comp.data.type), gatedPacks(comp.data)); } for (const comp of model.getByType('QItem')) { // With traits, itemname lists items to exclude from the draw, so they need not be owned if (comp.data.traits?.trim()) continue; // Several names: Valkyrie picks one it can find, so only a single name is a hard requirement const names = parseRefList(comp.data.itemname ?? ''); if (names.length === 1) add(catalog.getPackForItem(names[0])); } return requiredPacks; } /** Builds .valkyrie package */ export async function buildScenario(model: ScenarioModel, outputPath: string): Promise { const dir = model.scenarioDir; if (!dir) throw new Error('Model has no scenarioDir set'); await buildPackage(dir, outputPath); } /** [Quest] settings an author may change; format, type and packs are managed automatically on save */ export interface QuestConfigUpdate { difficulty?: number; lengthmin?: number; lengthmax?: number; minhero?: number; maxhero?: number; image?: string; hidden?: boolean; defaultmusicon?: boolean; } /** Apply quest settings after checking them against Valkyrie's ranges. Nothing is applied if any value is invalid. */ export function setQuestConfig(model: ScenarioModel, update: QuestConfigUpdate): { success: boolean; errors: string[] } { const next = { ...model.questConfig, ...update }; const errors: string[] = []; if (next.difficulty < 0 || next.difficulty > 1) errors.push(`difficulty must be between 0 and 1 (got ${next.difficulty})`); if (next.lengthmin <= 0 || next.lengthmax <= 0) errors.push('lengthmin and lengthmax must be positive minutes'); if (next.lengthmin > next.lengthmax) errors.push(`lengthmin (${next.lengthmin}) must not exceed lengthmax (${next.lengthmax})`); for (const k of ['minhero', 'maxhero'] as const) { const v = next[k]; if (v !== undefined && (!Number.isInteger(v) || v < 1 || v > 5)) errors.push(`${k} must be a whole number from 1 to 5 (got ${v})`); } if (next.minhero !== undefined && next.maxhero !== undefined && next.minhero > next.maxhero) { errors.push(`minhero (${next.minhero}) must not exceed maxhero (${next.maxhero})`); } if (errors.length > 0) return { success: false, errors }; model.questConfig = next; return { success: true, errors }; }