hoi4-agent-tools 2.8.5 → 2.8.7

package/dist/hoi4_agent_tools/gui/scenario-generator.js

@@ -11,6 +11,20 @@ const countryAdjectives = [
     'Canadian',
 ];
 const leaderNames = ['Anna Keller', 'Michael Byrne', 'Elena Rossi', 'Jan Kowalski', 'Rafael Silva'];
+const monthNames = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
 const variedStates = [
     'normal',
     'selected',
@@ -19,6 +33,7 @@ const variedStates = [
     'disabled',
     'completed',
 ];
+const transientWindowPattern = /(?:confirm|details|dialog|dropdown|menu|modal|overlay|popup|tooltip)/iu;
 class ScenarioRandom {
     #state;
     constructor(seed) {
@@ -41,26 +56,50 @@ class ScenarioRandom {
         return values[Math.min(values.length - 1, Math.floor(this.next() * values.length))];
     }
 }
-function relevantElements(graph, windowName) {
-    const root = graph.elements.find((element) => element.parentId === undefined && element.name === windowName);
-    if (root === undefined)
-        return graph.elements.filter(({ name }) => name === windowName);
+function relatedScriptedGuis(graph, windowName) {
+    const names = new Set(graph.scriptedGuis
+        .filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName)
+        .map(({ name }) => name));
+    let added = true;
+    while (added) {
+        added = false;
+        for (const definition of graph.scriptedGuis) {
+            if (definition.parentScriptedGui === undefined ||
+                !names.has(definition.parentScriptedGui) ||
+                names.has(definition.name))
+                continue;
+            names.add(definition.name);
+            added = true;
+        }
+    }
+    return graph.scriptedGuis.filter(({ name }) => names.has(name));
+}
+function relevantElements(graph, windowName, scripted) {
+    const rootNames = new Set([windowName]);
+    for (const definition of scripted) {
+        if (definition.windowName !== undefined)
+            rootNames.add(definition.windowName);
+        for (const dynamicList of definition.dynamicListDefinitions) {
+            if (dynamicList.entryContainer !== undefined)
+                rootNames.add(dynamicList.entryContainer);
+            if (dynamicList.countryScopeEntryContainer !== undefined)
+                rootNames.add(dynamicList.countryScopeEntryContainer);
+        }
+    }
     const byId = new Map(graph.elements.map((element) => [element.id, element]));
-    const pending = [root.id];
-    const selected = [];
-    const seen = new Set();
+    const pending = graph.elements.filter(({ name }) => rootNames.has(name)).map(({ id }) => id);
+    const selected = new Map();
     while (pending.length > 0) {
         const id = pending.pop();
-        if (seen.has(id))
+        if (id === undefined || selected.has(id))
             continue;
-        seen.add(id);
         const element = byId.get(id);
         if (element === undefined)
             continue;
-        selected.push(element);
+        selected.set(id, element);
         pending.push(...element.childIds);
     }
-    return selected;
+    return [...selected.values()];
 }
 function stringsIn(value) {
     if (typeof value === 'string')
@@ -70,18 +109,37 @@ function stringsIn(value) {
     return Object.values(value).flatMap(stringsIn);
 }
 function localisationText(graph, language, key) {
-    return graph.localisation.find((entry) => entry.language === language && entry.key === key)
-        ?.value;
+    const normalizedLanguage = language.toLocaleLowerCase('en-US');
+    return graph.localisation.find((entry) => entry.key === key && entry.language.toLocaleLowerCase('en-US') === normalizedLanguage)?.value;
 }
 function sourceTexts(graph, elements, language, scripted) {
     const values = elements.flatMap((element) => Object.values(element.attributes).flatMap(stringsIn));
-    const propertyValues = scripted.flatMap((definition) => definition.propertyDefinitions.flatMap((property) => Object.values(property.attributes).flatMap(stringsIn)));
-    return [...values, ...propertyValues].flatMap((value) => [
+    const resolvedValues = values.flatMap((value) => [
         value,
         localisationText(graph, language, value) ?? '',
     ]);
+    const relatedScriptedLocalisationKeys = new Set(graph.scriptedLocalisation
+        .filter((definition) => resolvedValues.some((value) => value.includes(`[${definition.name}]`)))
+        .flatMap(({ localisationKeys }) => localisationKeys));
+    const propertyValues = scripted.flatMap(({ propertyDefinitions }) => propertyDefinitions.flatMap(({ attributes }) => Object.values(attributes).flatMap(stringsIn)));
+    const normalizedLanguage = language.toLocaleLowerCase('en-US');
+    return [
+        ...resolvedValues,
+        ...propertyValues,
+        ...graph.localisation
+            .filter(({ language: entryLanguage, key }) => entryLanguage.toLocaleLowerCase('en-US') === normalizedLanguage &&
+            relatedScriptedLocalisationKeys.has(key))
+            .map(({ value }) => value),
+    ];
+}
+function expressionToken(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const variable = /^\[\?([^\]|]+)(?:\|[^\]]+)?\]$/u.exec(value);
+    const dynamic = /^\[([^\]]+)\]$/u.exec(value);
+    return variable?.[1] ?? dynamic?.[1];
 }
-function dynamicTokens(texts) {
+function tokensIn(texts) {
     const numeric = new Set();
     const textual = new Set();
     for (const text of texts) {
@@ -98,33 +156,248 @@ function dynamicTokens(texts) {
                 textual.add(key);
         }
     }
-    return {
-        numeric: [...numeric].sort(),
-        textual: [...textual].sort(),
-    };
+    return { numeric, textual };
 }
-function plausibleText(key, random, samples) {
+function plausibleText(key, random, samples, scopedCountries) {
     const lower = key.toLocaleLowerCase('en-US');
+    if (lower.includes('date'))
+        return `${random.integer(1, 28)} ${random.pick(monthNames)} ${random.integer(1936, 1950)}`;
     if (lower.includes('adjective'))
         return random.pick(countryAdjectives);
     if (lower.includes('leader') || lower.includes('character'))
         return random.pick(leaderNames);
-    if (lower.includes('country') || lower.endsWith('getname') || lower.includes('.getname'))
-        return random.pick(countryNames);
+    if (lower.includes('country') || lower.endsWith('getname') || lower.includes('.getname')) {
+        const scope = key.includes('.') ? key.slice(0, key.indexOf('.')) : 'ROOT';
+        const existing = scopedCountries.get(scope);
+        if (existing !== undefined)
+            return existing;
+        const used = new Set(scopedCountries.values());
+        const choices = countryNames.filter((candidate) => !used.has(candidate));
+        const value = random.pick(choices.length === 0 ? countryNames : choices);
+        scopedCountries.set(scope, value);
+        return value;
+    }
     return random.pick(samples);
 }
-function generatedNumber(options, random) {
-    const value = options.numericMinimum + random.next() * (options.numericMaximum - options.numericMinimum);
+function generatedNumber(options, random, minimum = options.numericMinimum, maximum = options.numericMaximum) {
+    const boundedMinimum = Math.max(options.numericMinimum, minimum);
+    const boundedMaximum = Math.min(options.numericMaximum, maximum);
+    const low = Math.min(boundedMinimum, boundedMaximum);
+    const high = Math.max(boundedMinimum, boundedMaximum);
+    const value = low + random.next() * (high - low);
     return options.integerValues ? Math.round(value) : Math.round(value * 100) / 100;
 }
+function generatedNumberForKey(key, options, random) {
+    const lower = key.toLocaleLowerCase('en-US');
+    if (/(?:ratio|fraction|progress)$/u.test(lower))
+        return generatedNumber(options, random, 0, 1);
+    if (/(?:percent|percentage|support|stability|war_support|legitimacy|threat|charge)/u.test(lower))
+        return generatedNumber(options, random, 0, 100);
+    return generatedNumber(options, random);
+}
 function setIfMissing(target, key, value) {
     target[key] ??= value;
-    const shortKey = key.slice(key.lastIndexOf('.') + 1);
-    target[shortKey] ??= value;
+}
+function scriptedLocalisationValue(graph, token, language, random, kind, values) {
+    const shortToken = token.slice(token.lastIndexOf('.') + 1);
+    const definitions = graph.scriptedLocalisation.filter(({ name }) => name === token || name === shortToken);
+    if (definitions.length === 0)
+        return undefined;
+    const sprites = new Set(graph.sprites.map(({ name }) => name.toLocaleLowerCase('en-US')));
+    const choices = definitions.flatMap(({ choices }) => choices);
+    const eligible = choices.filter(({ localisationKey }) => kind === 'image'
+        ? sprites.has(localisationKey.toLocaleLowerCase('en-US'))
+        : localisationText(graph, language, localisationKey) !== undefined);
+    if (eligible.length === 0)
+        return undefined;
+    const evaluated = eligible.map((choice) => ({
+        choice,
+        result: evaluateSimpleTrigger(choice.triggerExpression, values),
+    }));
+    const matched = evaluated.find(({ result }) => result === true)?.choice;
+    const firstThreshold = evaluated
+        .map(({ choice }) => simpleThreshold(choice.triggerExpression))
+        .find((threshold) => threshold !== undefined && typeof values[threshold.variable] === 'number');
+    const unknownExists = evaluated.some(({ result }) => result === undefined);
+    const ranked = matched === undefined && unknownExists && firstThreshold !== undefined
+        ? eligible[Math.min(eligible.length - 1, Math.max(0, Math.round((1 - Math.max(0, Math.min(100, Number(values[firstThreshold.variable]))) / 100) *
+            (eligible.length - 1))))]
+        : undefined;
+    const fallback = evaluated.find(({ result }) => result === 'fallback')?.choice;
+    const selected = matched ?? ranked ?? fallback ?? random.pick(eligible);
+    if (kind === 'image')
+        return selected.localisationKey;
+    return localisationText(graph, language, selected.localisationKey);
+}
+function simpleThreshold(triggerExpression) {
+    if (triggerExpression === undefined)
+        return undefined;
+    const direct = /([A-Za-z_][A-Za-z0-9_.:^]*)\s*([<>])\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression);
+    if (direct !== null)
+        return {
+            variable: direct[1],
+            operator: direct[2],
+            threshold: Number(direct[3]),
+        };
+    const variable = /\bvar\s*=\s*([A-Za-z_][A-Za-z0-9_.:^]*)/u.exec(triggerExpression)?.[1];
+    const threshold = /\bvalue\s*=\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression)?.[1];
+    const compare = /\bcompare\s*=\s*(greater_than|less_than)/u.exec(triggerExpression)?.[1];
+    if (variable === undefined || threshold === undefined || compare === undefined)
+        return undefined;
+    return {
+        variable,
+        operator: compare === 'greater_than' ? '>' : '<',
+        threshold: Number(threshold),
+    };
+}
+function evaluateSimpleTrigger(triggerExpression, values) {
+    if (triggerExpression === undefined || /\balways\s*=\s*yes\b/u.test(triggerExpression))
+        return 'fallback';
+    if (/\balways\s*=\s*no\b/u.test(triggerExpression))
+        return false;
+    const threshold = simpleThreshold(triggerExpression);
+    if (threshold === undefined)
+        return undefined;
+    const value = values[threshold.variable];
+    if (typeof value !== 'number')
+        return undefined;
+    return threshold.operator === '>' ? value > threshold.threshold : value < threshold.threshold;
+}
+function materializeDynamicText(template, values) {
+    const valueFor = (key) => {
+        const value = values[key] ?? values[key.slice(key.lastIndexOf('.') + 1)];
+        return value === undefined ? undefined : String(value);
+    };
+    return template
+        .replace(/\[\?([^\]|]+)(?:\|[^\]]+)?\]/gu, (match, key) => valueFor(key) ?? match)
+        .replace(/\[([A-Za-z][A-Za-z0-9_.:-]+)\]/gu, (match, key) => {
+        if (key === 'X' || key === 'dynamic_loc')
+            return match;
+        return valueFor(key) ?? match;
+    });
+}
+function scalarNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'string' || !/^-?(?:\d+\.?\d*|\.\d+)$/u.test(value))
+        return undefined;
+    return Number(value);
+}
+function pointOrSize(element, attribute) {
+    const value = element.attributes[attribute];
+    if (typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const x = scalarNumber(value.x ?? value.width);
+    const y = scalarNumber(value.y ?? value.height);
+    return x === undefined || y === undefined ? undefined : { x, y };
+}
+function rootRect(graph, windowName) {
+    if (windowName === undefined)
+        return undefined;
+    const root = graph.elements.find((element) => element.name === windowName && element.parentId === undefined);
+    if (root === undefined)
+        return undefined;
+    const position = pointOrSize(root, 'position') ?? { x: 0, y: 0 };
+    const size = pointOrSize(root, 'size');
+    if (size === undefined || size.x <= 0 || size.y <= 0)
+        return undefined;
+    return { x: position.x, y: position.y, width: size.x, height: size.y };
+}
+function substantiallyOverlaps(left, right) {
+    if (left === undefined || right === undefined)
+        return false;
+    const width = Math.max(0, Math.min(left.x + left.width, right.x + right.width) - Math.max(left.x, right.x));
+    const height = Math.max(0, Math.min(left.y + left.height, right.y + right.height) - Math.max(left.y, right.y));
+    const smallerArea = Math.min(left.width * left.height, right.width * right.height);
+    return smallerArea > 0 && (width * height) / smallerArea >= 0.5;
+}
+function generatedVisibility(graph, scripted, options, random, base) {
+    const visibility = { ...base };
+    const dynamic = scripted.filter(({ visibleExpression }) => visibleExpression !== undefined);
+    if (options.visibility === 'show-all') {
+        for (const definition of dynamic)
+            visibility[definition.name] ??= true;
+        return visibility;
+    }
+    for (const definition of dynamic) {
+        if (visibility[definition.name] !== undefined)
+            continue;
+        visibility[definition.name] =
+            definition.parentScriptedGui === undefined ||
+                !transientWindowPattern.test(`${definition.name} ${definition.windowName ?? ''}`);
+    }
+    const siblingGroups = new Map();
+    for (const definition of dynamic) {
+        if (definition.parentScriptedGui === undefined)
+            continue;
+        const siblings = siblingGroups.get(definition.parentScriptedGui) ?? [];
+        siblings.push(definition);
+        siblingGroups.set(definition.parentScriptedGui, siblings);
+    }
+    for (const siblings of siblingGroups.values()) {
+        const unvisited = new Set(siblings);
+        while (unvisited.size > 0) {
+            const first = unvisited.values().next().value;
+            if (first === undefined)
+                break;
+            unvisited.delete(first);
+            const component = [first];
+            for (const current of component) {
+                for (const candidate of [...unvisited]) {
+                    if (substantiallyOverlaps(rootRect(graph, current.windowName), rootRect(graph, candidate.windowName))) {
+                        component.push(candidate);
+                        unvisited.delete(candidate);
+                    }
+                }
+            }
+            if (component.length < 2)
+                continue;
+            const selectable = component.filter((definition) => !transientWindowPattern.test(`${definition.name} ${definition.windowName ?? ''}`));
+            const selected = random.pick(selectable.length === 0 ? component : selectable);
+            for (const definition of component) {
+                if (base[definition.name] === undefined)
+                    visibility[definition.name] = definition === selected;
+            }
+        }
+    }
+    const visiblePageNames = dynamic
+        .filter(({ name }) => visibility[name] === true)
+        .flatMap(({ name, windowName: visibleWindowName }) => [name, visibleWindowName ?? ''])
+        .map((name) => name.toLocaleLowerCase('en-US'));
+    const triggerVisibilityTargets = [
+        ...new Set(scripted.flatMap(({ triggerDefinitions }) => triggerDefinitions
+            .filter(({ name }) => name.endsWith('_visible'))
+            .map(({ elementName }) => elementName))),
+    ];
+    const triggerGroups = new Map();
+    for (const target of triggerVisibilityTargets) {
+        const key = target.replace(/_(?:active|disabled|enabled|idle|off|on|selected|unselected)$/iu, '');
+        const group = triggerGroups.get(key) ?? [];
+        group.push(target);
+        triggerGroups.set(key, group);
+    }
+    for (const [baseName, targets] of triggerGroups) {
+        if (targets.length === 1) {
+            visibility[targets[0]] ??= !transientWindowPattern.test(targets[0]);
+            continue;
+        }
+        const topic = baseName.replace(/_(?:tab_)?button$/iu, '').toLocaleLowerCase('en-US');
+        const pageSelected = visiblePageNames.some((name) => name.includes(topic));
+        const preferredSuffix = pageSelected
+            ? /_(?:active|on|selected)$/iu
+            : /_(?:idle|off|unselected)$/iu;
+        const preferred = targets.find((target) => preferredSuffix.test(target)) ?? random.pick(targets);
+        for (const target of targets)
+            if (base[target] === undefined)
+                visibility[target] = target === preferred;
+    }
+    return visibility;
 }
 function generatedRows(count, random, options) {
+    const countryOffset = random.integer(0, countryNames.length - 1);
     return Array.from({ length: count }, (_unused, index) => {
-        const name = plausibleText('GetName', random, options.textSamples);
+        const countryIndex = (countryOffset + index) % countryNames.length;
+        const name = countryNames[countryIndex];
         const value = generatedNumber(options, random);
         return {
             index: index + 1,
@@ -132,70 +405,131 @@ function generatedRows(count, random, options) {
             label: name,
             name,
             GetName: name,
+            GetAdjective: countryAdjectives[countryIndex],
             value,
             amount: value,
             percentage: Math.max(0, Math.min(100, value)),
             selected: index === 0,
-            enabled: random.boolean(options.trueProbability),
+            enabled: true,
         };
     });
 }
 export function generateGuiPreviewScenarios(graph, windowName, base, options) {
     if (!options.enabled)
         return [];
-    const elements = relevantElements(graph, windowName);
-    const scripted = graph.scriptedGuis.filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName);
-    const tokens = dynamicTokens(sourceTexts(graph, elements, base.language, scripted));
+    const scripted = relatedScriptedGuis(graph, windowName);
+    const elements = relevantElements(graph, windowName, scripted);
+    const tokens = tokensIn(sourceTexts(graph, elements, base.language, scripted));
+    const imageTokens = new Set();
+    const booleanTokens = new Set();
+    const frameTokens = new Set();
+    for (const definition of scripted) {
+        for (const property of definition.propertyDefinitions) {
+            for (const [attribute, expression] of Object.entries(property.attributes)) {
+                const token = expressionToken(expression);
+                if (token === undefined)
+                    continue;
+                const normalized = attribute.toLocaleLowerCase('en-US');
+                if (normalized === 'image')
+                    imageTokens.add(token);
+                else if (normalized === 'visible' || normalized === 'enabled')
+                    booleanTokens.add(token);
+                else if (normalized === 'frame')
+                    frameTokens.add(token);
+                else
+                    tokensIn(stringsIn(expression)).numeric.forEach((value) => tokens.numeric.add(value));
+            }
+        }
+    }
+    for (const token of [...imageTokens, ...booleanTokens, ...frameTokens]) {
+        tokens.numeric.delete(token);
+        tokens.textual.delete(token);
+    }
+    const relevantDynamicTokens = new Set([...tokens.textual, ...imageTokens]);
+    for (const definition of graph.scriptedLocalisation) {
+        if (![...relevantDynamicTokens].some((token) => token === definition.name || token.endsWith(`.${definition.name}`)))
+            continue;
+        for (const choice of definition.choices) {
+            const threshold = simpleThreshold(choice.triggerExpression);
+            if (threshold !== undefined)
+                tokens.numeric.add(threshold.variable);
+        }
+    }
+    const progressRanges = new Map();
+    for (const element of elements) {
+        if (!/progressbar/iu.test(element.elementType))
+            continue;
+        const minimum = scalarNumber(element.attributes.minValue) ?? 0;
+        const maximum = scalarNumber(element.attributes.maxValue) ?? 100;
+        progressRanges.set(element.name, { minimum, maximum });
+        const startValue = element.attributes.startValue;
+        if (typeof startValue === 'string' && !/^-?(?:\d+\.?\d*|\.\d+)$/u.test(startValue))
+            tokens.numeric.add(startValue);
+    }
     const dynamicLists = [...new Set(scripted.flatMap(({ dynamicLists }) => dynamicLists))].sort();
-    const visibilityTargets = new Set(scripted.flatMap((definition) => definition.propertyDefinitions
-        .filter((property) => Object.keys(property.attributes).some((key) => key.toLocaleLowerCase('en-US') === 'visible'))
-        .map(({ elementName }) => elementName)));
     const enabledTargets = new Set(scripted.flatMap((definition) => [
         ...definition.triggerDefinitions.map(({ elementName }) => elementName),
         ...definition.propertyDefinitions
             .filter((property) => Object.keys(property.attributes).some((key) => key.toLocaleLowerCase('en-US') === 'enabled'))
             .map(({ elementName }) => elementName),
     ]));
-    const spritesByName = new Map(graph.sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
     const sourceSeed = options.seed === 'auto' ? `${windowName}:${base.id}:${hashSourceGraph(graph)}` : options.seed;
     return Array.from({ length: options.count }, (_unused, scenarioIndex) => {
         const random = new ScenarioRandom(`${sourceSeed}:${scenarioIndex}`);
         const values = { ...base.values };
         const lists = Object.fromEntries(Object.entries(base.lists).map(([key, rows]) => [key, rows.map((row) => ({ ...row }))]));
-        const visibility = { ...base.visibility };
+        const visibility = generatedVisibility(graph, scripted, options, random, base.visibility);
         const elementStates = { ...base.elementStates };
-        const selectedFrames = { ...base.selectedFrames };
+        const scopedCountries = new Map();
         for (const key of tokens.numeric)
-            setIfMissing(values, key, generatedNumber(options, random));
+            setIfMissing(values, key, generatedNumberForKey(key, options, random));
+        for (const [elementName, { minimum, maximum }] of progressRanges) {
+            const element = elements.find(({ name }) => name === elementName);
+            const startValueToken = typeof element?.attributes.startValue === 'string'
+                ? element.attributes.startValue
+                : undefined;
+            const existingElementValue = values[elementName];
+            const existingTokenValue = startValueToken === undefined ? undefined : values[startValueToken];
+            const value = typeof existingElementValue === 'number'
+                ? existingElementValue
+                : typeof existingTokenValue === 'number'
+                    ? existingTokenValue
+                    : generatedNumber(options, random, minimum, maximum);
+            setIfMissing(values, elementName, value);
+            if (startValueToken !== undefined)
+                setIfMissing(values, startValueToken, value);
+        }
+        for (const key of tokens.numeric) {
+            if (!key.endsWith('_bar') || base.values[key] !== undefined)
+                continue;
+            const sourceKey = key.slice(0, -'_bar'.length);
+            const sourceValue = values[sourceKey];
+            if (typeof sourceValue === 'number')
+                values[key] = sourceValue;
+        }
         for (const key of tokens.textual)
-            setIfMissing(values, key, plausibleText(key, random, options.textSamples));
-        for (const element of elements) {
-            if (values[element.name] === undefined && /progressbar/iu.test(element.elementType))
-                values[element.name] = generatedNumber(options, random);
-            if (visibilityTargets.has(element.name) && visibility[element.name] === undefined)
-                visibility[element.name] =
-                    options.visibility === 'show-all' || random.boolean(options.trueProbability);
-            elementStates[element.name] ??= enabledTargets.has(element.name)
-                ? random.boolean(options.trueProbability)
-                    ? options.elementStates === 'normal'
-                        ? 'normal'
-                        : random.pick(variedStates)
-                    : 'disabled'
-                : options.elementStates === 'normal'
-                    ? 'normal'
-                    : random.pick(variedStates);
-            const spriteName = [
-                element.attributes.spriteType,
-                element.attributes.quadTextureSprite,
-                element.attributes.background,
-            ].find((candidate) => typeof candidate === 'string');
-            const frameCount = spriteName === undefined
-                ? 1
-                : (spritesByName.get(spriteName.toLocaleLowerCase('en-US'))?.frameCount ?? 1);
-            if (Number.isFinite(frameCount) &&
-                frameCount > 1 &&
-                selectedFrames[element.name] === undefined)
-                selectedFrames[element.name] = random.integer(0, Math.trunc(frameCount) - 1);
+            setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
+        const scriptedTextTemplates = new Map();
+        for (const key of tokens.textual) {
+            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, random, 'text', values);
+            if (scriptedValue !== undefined && base.values[key] === undefined)
+                scriptedTextTemplates.set(key, scriptedValue);
+        }
+        for (let pass = 0; pass < 3; pass += 1)
+            for (const [key, template] of scriptedTextTemplates)
+                values[key] = materializeDynamicText(template, values);
+        for (const key of imageTokens) {
+            const sprite = scriptedLocalisationValue(graph, key, base.language, random, 'image', values);
+            if (sprite !== undefined)
+                setIfMissing(values, key, sprite);
+        }
+        for (const key of booleanTokens)
+            setIfMissing(values, key, random.boolean(options.trueProbability));
+        for (const key of frameTokens)
+            setIfMissing(values, key, 1);
+        if (options.elementStates === 'varied') {
+            for (const elementName of enabledTargets)
+                elementStates[elementName] ??= random.pick(variedStates);
         }
         for (const listName of dynamicLists) {
             if (lists[listName] !== undefined)
@@ -206,12 +540,11 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return parsePreviewScenario({
             ...base,
             id: `${base.id}-${options.idPrefix}-${scenarioIndex + 1}`,
-            description: `Generated plausible scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
+            description: `Generated source-aware scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
             values,
             lists,
             visibility,
             elementStates,
-            selectedFrames,
         });
     });
 }

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -204,7 +204,7 @@ export const GuiGeneratedScenarioOptionsSchema = z
         .max(64)
         .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u)
         .default('generated'),
-    preservePlaceholder: z.boolean().default(true),
+    preservePlaceholder: z.boolean().default(false),
     numericMinimum: z.number().min(-1_000_000_000).max(1_000_000_000).default(0),
     numericMaximum: z.number().min(-1_000_000_000).max(1_000_000_000).default(100),
     integerValues: z.boolean().default(true),