hoi4-agent-tools 2.8.1 → 2.8.3

package/dist/hoi4_agent_tools/gui/layout.js

@@ -213,9 +213,17 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         }
         return replacement;
     }, 'GUI localisation substitution');
-    text = replaceTextBounded(text, /\[\?([A-Za-z0-9_.-]+)(?:\|[^\]]+)?\]/gu, (match) => {
+    text = replaceTextBounded(text, /\[\?([^\]|]+)(?:\|[^\]]+)?\]/gu, (match) => {
         const key = match[1] ?? '';
-        const replacement = rowValues?.[key] ?? scenario.variables[key] ?? scenario.scriptedGui[key];
+        const shortKey = key.slice(key.lastIndexOf('.') + 1);
+        const replacement = rowValues?.[key] ??
+            rowValues?.[shortKey] ??
+            scenario.values[key] ??
+            scenario.values[shortKey] ??
+            scenario.variables[key] ??
+            scenario.variables[shortKey] ??
+            scenario.scriptedGui[key] ??
+            scenario.scriptedGui[shortKey];
         if (replacement === undefined) {
             unresolved.push(match[0]);
             return /(?:^|\.)Get[A-Za-z0-9_]+$/u.test(key)
@@ -229,7 +237,10 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         if (key === 'X' || key === 'dynamic_loc')
             return match[0];
         const countryKey = key.replace(/^(?:ROOT|This)\./u, '');
-        const replacement = rowValues?.[countryKey] ??
+        const replacement = rowValues?.[key] ??
+            rowValues?.[countryKey] ??
+            scenario.values[key] ??
+            scenario.values[countryKey] ??
             scenario.country?.[countryKey] ??
             scenario.stateValues?.[countryKey] ??
             scenario.scriptedGui[key];
@@ -241,6 +252,15 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
     }, 'GUI scope substitution');
     return { text, unresolved: [...new Set(unresolved)].sort(), missingLocalisation };
 }
+function scenarioExpressionValue(expression, values) {
+    if (typeof expression !== 'string')
+        return undefined;
+    const variableMatch = /^\[\?([^\]|]+)(?:\|[^\]]+)?\]$/u.exec(expression);
+    const localisationMatch = /^\[([^\]]+)\]$/u.exec(expression);
+    const token = variableMatch?.[1] ?? localisationMatch?.[1] ?? expression;
+    const shortToken = token.slice(token.lastIndexOf('.') + 1);
+    return values[token] ?? values[shortToken];
+}
 function measureTextWithInlineIcons(catalog, fontName, text, fontSize, inlineIcons) {
     if (inlineIcons.size === 0 || ![...inlineIcons.keys()].some((marker) => text.includes(marker)))
         return catalog.measureText(fontName, text, fontSize);
@@ -454,11 +474,16 @@ function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inl
     }
     return runs;
 }
-function frameFor(element, sprite, scenario) {
+function frameFor(element, sprite, scenario, rowValues) {
     const frameCount = Math.max(1, sprite.frameCount);
     const selected = scenario.selectedFrames[element.name] ?? scenario.selectedFrames[sprite.name];
     if (selected !== undefined)
         return Math.min(frameCount - 1, selected);
+    const scriptedFrame = rowValues?.[`${element.name}.frame`] ??
+        scenario.values[`${element.name}.frame`] ??
+        scenario.scriptedGui[`${element.name}.frame`];
+    if (typeof scriptedFrame === 'number' && Number.isFinite(scriptedFrame))
+        return Math.min(frameCount - 1, Math.max(0, Math.trunc(scriptedFrame > 0 ? scriptedFrame - 1 : scriptedFrame)));
     const explicit = scalarNumber(property(element.attributes, 'frame'), frameCount);
     if (explicit !== undefined)
         return Math.min(frameCount - 1, Math.max(0, Math.trunc(explicit > 0 ? explicit - 1 : explicit)));
@@ -583,7 +608,7 @@ class GuiSceneWorkBudget {
         this.textLayoutOperations += amount;
     }
 }
-async function layoutElement(definition, parentRect, inheritedClip, parentScale, depth, context, instanceSuffix = '', rowIndex, rowValues, parentInstanceId, inheritedOrientation = 'upper_left') {
+async function layoutElement(definition, parentRect, inheritedClip, parentScale, depth, context, instanceSuffix = '', rowIndex, rowValues, parentInstanceId, inheritedOrientation = 'upper_left', inheritedVisible = true) {
     context.work.admitElement(depth);
     const { scenario, catalog, fidelity, diagnostics } = context;
     const instanceId = instanceSuffix.length === 0 ? definition.id : `${definition.id}${instanceSuffix}`;
@@ -591,12 +616,33 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const scale = parentScale * localScale;
     const position = objectProperty(property(definition.attributes, 'position'));
     const size = objectProperty(property(definition.attributes, 'size'));
-    const localX = scaledNumber(position === undefined ? undefined : property(position, 'x'), parentRect.width, parentScale) ?? 0;
-    const localY = scaledNumber(position === undefined ? undefined : property(position, 'y'), parentRect.height, parentScale) ?? 0;
+    const scriptedX = rowValues?.[`${definition.name}.x`] ??
+        scenario.values[`${definition.name}.x`] ??
+        scenario.scriptedGui[`${definition.name}.x`];
+    const scriptedY = rowValues?.[`${definition.name}.y`] ??
+        scenario.values[`${definition.name}.y`] ??
+        scenario.scriptedGui[`${definition.name}.y`];
+    const localX = (typeof scriptedX === 'number' && Number.isFinite(scriptedX)
+        ? scriptedX * parentScale
+        : undefined) ??
+        scaledNumber(position === undefined ? undefined : property(position, 'x'), parentRect.width, parentScale) ??
+        0;
+    const localY = (typeof scriptedY === 'number' && Number.isFinite(scriptedY)
+        ? scriptedY * parentScale
+        : undefined) ??
+        scaledNumber(position === undefined ? undefined : property(position, 'y'), parentRect.height, parentScale) ??
+        0;
     let width = scaledNumber(size === undefined ? undefined : property(size, 'width', 'x'), parentRect.width, scale) ?? 0;
     let height = scaledNumber(size === undefined ? undefined : property(size, 'height', 'y'), parentRect.height, scale) ?? 0;
     const background = objectProperty(property(definition.attributes, 'background'));
-    const spriteName = scalarString(property(definition.attributes, 'spriteType', 'quadTextureSprite')) ??
+    const scriptedImage = rowValues?.[`${definition.name}.image`] ??
+        rowValues?.[definition.name] ??
+        scenario.values[`${definition.name}.image`] ??
+        scenario.values[definition.name] ??
+        scenario.scriptedGui[`${definition.name}.image`] ??
+        scenario.scriptedGui[definition.name];
+    const spriteName = (typeof scriptedImage === 'string' && scriptedImage.length > 0 ? scriptedImage : undefined) ??
+        scalarString(property(definition.attributes, 'spriteType', 'quadTextureSprite')) ??
         scalarString(background === undefined
             ? undefined
             : property(background, 'spriteType', 'quadTextureSprite'));
@@ -632,7 +678,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
         }
         if (partialAppearance.length > 0)
             diagnostics.push(diagnostic('GUI_SPRITE_RENDER_PARTIAL', 'warning', `Element ${definition.name} has a partial sprite appearance: ${partialAppearance.join(' ')}`, definition));
-        const frame = frameFor(definition, spriteDefinition, scenario);
+        const frame = frameFor(definition, spriteDefinition, scenario, rowValues);
         sprite = await catalog.loadSpriteFrame(spriteDefinition, frame);
         if (spriteDefinition.texturePath2 !== undefined)
             secondarySprite = await catalog.loadSecondarySpriteFrame(spriteDefinition, frame);
@@ -676,8 +722,14 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             }
         }
     }
+    if (typeof scriptedImage === 'string' && scriptedImage.length > 0)
+        addFidelity(fidelity, 'modelled', 'scripted_gui_image', `Scenario property selected ${scriptedImage} for ${definition.name}.`, definition);
+    if (typeof scriptedX === 'number' || typeof scriptedY === 'number')
+        addFidelity(fidelity, 'modelled', 'scripted_gui_position', `Scenario properties positioned ${definition.name} at ${localX},${localY} before anchoring.`, definition);
     const rawButtonText = scalarString(property(definition.attributes, 'buttonText'));
     const rawText = scalarString(property(definition.attributes, 'text')) ?? rawButtonText;
+    const embeddedButtonText = rawText !== undefined &&
+        (rawButtonText !== undefined || definition.elementType.toLowerCase().includes('button'));
     let text;
     if (rawText !== undefined) {
         const resolved = resolveTokenText(rawText, scenario, context.localisation, rowValues);
@@ -758,7 +810,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             measuredWidth,
             measuredHeight,
             metricSource: wrapped.metricSource,
-            ...alignment(definition.attributes, rawButtonText !== undefined),
+            ...alignment(definition.attributes, embeddedButtonText),
             ...(fontName === undefined ? {} : { fontName }),
             glyphLines,
             overflowX: width > 0 && measuredWidth > width + 0.01,
@@ -817,17 +869,35 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const clipRect = inheritedClip;
     const clipped = clipRect !== undefined &&
         (availableClip === undefined || !equalRect(unclippedRect, availableClip));
-    const explicitlyVisible = scenario.visibility[definition.name] ?? scenario.visibility[definition.id];
-    const visible = explicitlyVisible ?? (availableClip !== undefined || inheritedClip === undefined);
+    const scriptedVisible = rowValues?.[`${definition.name}.visible`] ??
+        scenario.values[`${definition.name}.visible`] ??
+        scenario.scriptedGui[`${definition.name}.visible`];
+    const explicitlyVisible = scenario.visibility[definition.name] ??
+        scenario.visibility[definition.id] ??
+        (typeof scriptedVisible === 'boolean' ? scriptedVisible : undefined);
+    const visible = inheritedVisible &&
+        (explicitlyVisible ?? (availableClip !== undefined || inheritedClip === undefined));
     const clickThrough = scalarBoolean(property(definition.attributes, 'clickThrough', 'alwaystransparent', 'allwaystransparent')) ?? false;
-    const clickable = clickableTypes.test(definition.elementType) && !clickThrough;
+    const scriptedEnabled = rowValues?.[`${definition.name}.enabled`] ??
+        scenario.values[`${definition.name}.enabled`] ??
+        scenario.scriptedGui[`${definition.name}.enabled`] ??
+        context.constantElementEnabled[definition.name];
+    const clickable = clickableTypes.test(definition.elementType) && !clickThrough && scriptedEnabled !== false;
     const state = scenario.elementStates[definition.name] ?? scenario.state;
     const zPriority = scalarNumber(property(definition.attributes, 'priority'), 0) ?? 0;
     let progressRatio;
     if (/progressbar/iu.test(definition.elementType)) {
         const minimum = scalarNumber(property(definition.attributes, 'minValue'), 1) ?? 0;
         const maximum = scalarNumber(property(definition.attributes, 'maxValue'), 1) ?? 100;
-        const scriptedValue = scenario.scriptedGui[definition.name];
+        const startValueToken = scalarString(property(definition.attributes, 'startValue'));
+        const shortStartValueToken = startValueToken?.slice(startValueToken.lastIndexOf('.') + 1);
+        const scriptedValue = rowValues?.[definition.name] ??
+            scenario.values[definition.name] ??
+            (startValueToken === undefined ? undefined : scenario.values[startValueToken]) ??
+            (shortStartValueToken === undefined ? undefined : scenario.values[shortStartValueToken]) ??
+            (startValueToken === undefined ? undefined : scenario.variables[startValueToken]) ??
+            (shortStartValueToken === undefined ? undefined : scenario.variables[shortStartValueToken]) ??
+            scenario.scriptedGui[definition.name];
         let value = typeof scriptedValue === 'number'
             ? scriptedValue
             : (scalarNumber(property(definition.attributes, 'startValue'), maximum) ?? minimum);
@@ -911,9 +981,11 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
         rows = [];
     if (state === 'full-list' && rows === undefined)
         rows = Array.from({ length: 12 }, (_unused, index) => ({ index }));
-    if (rows !== undefined &&
-        childDefinitions.length > 0 &&
-        /(?:grid|listbox|scroll)/iu.test(definition.elementType)) {
+    const dynamicList = context.dynamicListsByName.get(definition.name);
+    const listElement = /(?:grid|listbox|scroll)/iu.test(definition.elementType);
+    const slotSize = objectProperty(property(definition.attributes, 'slotsize'));
+    const slotHeight = scaledNumber(slotSize === undefined ? undefined : property(slotSize, 'height', 'y'), height, scale);
+    if (rows !== undefined && childDefinitions.length > 0 && listElement) {
         const spacingValue = objectProperty(property(definition.attributes, 'spacing'));
         const spacingY = scalarNumber(spacingValue === undefined
             ? property(definition.attributes, 'spacing')
@@ -930,18 +1002,50 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
                     ...childParentRect,
                     y: childParentRect.y + rowY - originalY * scale,
                 };
-                await layoutElement(child, shiftedParent, childClip, scale, depth + 1, context, `${instanceSuffix}#row-${index}`, index, row, instanceId, origo);
+                await layoutElement(child, shiftedParent, childClip, scale, depth + 1, context, `${instanceSuffix}#row-${index}`, index, row, instanceId, origo, visible);
                 const rendered = context.instancesById.get(`${child.id}${instanceSuffix}#row-${index}`);
                 rowHeight = Math.max(rowHeight, rendered?.unclippedRect.height ?? 0);
             }
-            rowY += rowHeight + spacingY * scale;
+            rowY += (slotHeight ?? rowHeight) + spacingY * scale;
         }
         addFidelity(fidelity, 'modelled', 'scroll_rows', `Expanded ${rows.length} scenario rows for ${definition.name}.`, definition);
     }
+    else if (rows !== undefined && dynamicList !== undefined && listElement) {
+        let rowY = 0;
+        let renderedRows = 0;
+        for (const [index, row] of rows.entries()) {
+            context.work.spend('scripted GUI dynamic-list row expansion');
+            const explicitTemplate = row.entryContainer;
+            const templateName = (typeof explicitTemplate === 'string' && explicitTemplate.length > 0
+                ? explicitTemplate
+                : undefined) ??
+                (row.countryScope === true
+                    ? (dynamicList.countryScopeEntryContainer ?? dynamicList.entryContainer)
+                    : (dynamicList.entryContainer ?? dynamicList.countryScopeEntryContainer));
+            const template = templateName === undefined ? undefined : context.elementsByName.get(templateName);
+            if (template === undefined) {
+                diagnostics.push(diagnostic('GUI_DYNAMIC_LIST_TEMPLATE_MISSING', 'error', templateName === undefined
+                    ? `Dynamic list ${definition.name} has no entry container for scenario row ${index}.`
+                    : `Dynamic list ${definition.name} cannot resolve entry container ${templateName}.`, definition));
+                continue;
+            }
+            const templatePosition = objectProperty(property(template.attributes, 'position'));
+            const originalY = scalarNumber(templatePosition === undefined ? undefined : property(templatePosition, 'y'), height) ?? 0;
+            const shiftedParent = {
+                ...childParentRect,
+                y: childParentRect.y + rowY - originalY * scale,
+            };
+            await layoutElement(template, shiftedParent, childClip, scale, depth + 1, context, `${instanceSuffix}#row-${index}`, index, row, instanceId, origo, visible);
+            const rendered = context.instancesById.get(`${template.id}${instanceSuffix}#row-${index}`);
+            rowY += slotHeight ?? rendered?.unclippedRect.height ?? 0;
+            renderedRows += 1;
+        }
+        addFidelity(fidelity, renderedRows === rows.length ? 'modelled' : 'missing', 'scripted_gui_dynamic_list', `Expanded ${renderedRows}/${rows.length} scenario rows for ${definition.name} through its scripted-GUI entry containers.`, definition);
+    }
     else {
         for (const child of childDefinitions) {
             context.work.spend('nested child expansion');
-            await layoutElement(child, childParentRect, childClip, scale, depth + 1, context, instanceSuffix, rowIndex, rowValues, instanceId, origo);
+            await layoutElement(child, childParentRect, childClip, scale, depth + 1, context, instanceSuffix, rowIndex, rowValues, instanceId, origo, visible);
         }
     }
 }
@@ -998,24 +1102,86 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
                 localisation.set(entry.key, entry.value);
         addFidelity(fidelity, 'approximated', 'language', `No exact ${scenario.language} bucket; used available localisation entries.`);
     }
-    let scriptedWindowVisible = true;
-    for (const scripted of graph.scriptedGuis.filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName)) {
+    const relevantScriptedGuiNames = new Set(graph.scriptedGuis
+        .filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName)
+        .map(({ name }) => name));
+    let addedRelatedScriptedGui = true;
+    while (addedRelatedScriptedGui) {
+        addedRelatedScriptedGui = false;
+        for (const definition of graph.scriptedGuis) {
+            if (definition.parentScriptedGui === undefined ||
+                !relevantScriptedGuiNames.has(definition.parentScriptedGui) ||
+                relevantScriptedGuiNames.has(definition.name))
+                continue;
+            relevantScriptedGuiNames.add(definition.name);
+            addedRelatedScriptedGui = true;
+        }
+    }
+    const scriptedWindowVisibility = {};
+    const constantElementVisibility = {};
+    const constantElementEnabled = {};
+    const resolvedScriptedProperties = {};
+    const dynamicListsByName = new Map();
+    for (const scripted of graph.scriptedGuis.filter(({ name }) => relevantScriptedGuiNames.has(name))) {
+        for (const dynamicList of scripted.dynamicListDefinitions)
+            dynamicListsByName.set(dynamicList.name, dynamicList);
+        for (const propertyDefinition of scripted.propertyDefinitions) {
+            for (const [attribute, expression] of Object.entries(propertyDefinition.attributes)) {
+                const suffix = attribute.toLowerCase();
+                if (!['image', 'frame', 'x', 'y', 'visible', 'enabled'].includes(suffix))
+                    continue;
+                const resolved = scenarioExpressionValue(expression, scenario.values);
+                if (resolved === undefined)
+                    continue;
+                const key = `${propertyDefinition.elementName}.${suffix}`;
+                if (scenario.values[key] === undefined)
+                    resolvedScriptedProperties[key] = resolved;
+                addFidelity(fidelity, 'modelled', 'scripted_gui_scenario_property', `${key} resolved from a scenario runtime value.`);
+            }
+        }
+        for (const trigger of scripted.triggerDefinitions) {
+            if (trigger.constantResult === undefined)
+                continue;
+            if (trigger.name.endsWith('_visible'))
+                constantElementVisibility[trigger.elementName] = trigger.constantResult;
+            if (trigger.name.endsWith('_click_enabled'))
+                constantElementEnabled[trigger.elementName] = trigger.constantResult;
+            addFidelity(fidelity, 'modelled', 'scripted_gui_constant_trigger', `${trigger.name} resolves to ${trigger.constantResult ? 'yes' : 'no'}.`);
+        }
         addFidelity(fidelity, 'modelled', 'scripted_gui_context', `${scripted.name} uses ${scripted.contextType ?? '<unspecified>'} context.`);
         if (scripted.visibleExpression === undefined)
             continue;
-        const mockedVisibility = scenario.visibility[scripted.name] ?? scenario.scriptedGui[`${scripted.name}.visible`];
+        const mockedVisibility = scenario.visibility[scripted.name] ??
+            scenario.values[`${scripted.name}.visible`] ??
+            scenario.scriptedGui[`${scripted.name}.visible`];
         if (typeof mockedVisibility === 'boolean') {
-            scriptedWindowVisible &&= mockedVisibility;
+            if (scripted.windowName !== undefined)
+                scriptedWindowVisibility[scripted.windowName] =
+                    (scriptedWindowVisibility[scripted.windowName] ?? true) && mockedVisibility;
             addFidelity(fidelity, 'modelled', 'scripted_gui_visibility', `${scripted.name}.visible was supplied by the preview scenario.`);
         }
         else {
             addFidelity(fidelity, 'unresolved', 'scripted_gui_visibility', `${scripted.name}.visible requires an explicit scenario mock; the offline renderer leaves it visible.`);
         }
     }
-    const layoutScenario = scriptedWindowVisible
-        ? scenario
-        : { ...scenario, visibility: { ...scenario.visibility, [root.name]: false } };
+    const layoutScenario = {
+        ...scenario,
+        values: {
+            ...resolvedScriptedProperties,
+            ...scenario.values,
+        },
+        visibility: {
+            ...scriptedWindowVisibility,
+            ...constantElementVisibility,
+            ...scenario.visibility,
+        },
+    };
     const output = [];
+    const elementsByName = new Map();
+    for (const element of [...graph.elements].sort((left, right) => compareCodeUnits(right.sourcePath, left.sourcePath) ||
+        right.definitionOrder - left.definitionOrder))
+        if (!elementsByName.has(element.name))
+            elementsByName.set(element.name, element);
     const context = {
         graph,
         scenario: layoutScenario,
@@ -1023,6 +1189,9 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
         fidelity,
         diagnostics,
         elementsById,
+        elementsByName,
+        dynamicListsByName,
+        constantElementEnabled,
         spritesByName: new Map(graph.sprites.map((sprite) => [sprite.name.toLowerCase(), sprite])),
         localisation,
         output,
@@ -1037,6 +1206,44 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
         height: scenario.resolution.height,
     };
     await layoutElement(root, viewport, viewport, baseScale, 0, context);
+    const scriptedByName = new Map(graph.scriptedGuis.map((scripted) => [scripted.name, scripted]));
+    const pendingAttached = graph.scriptedGuis
+        .filter(({ name, parentScriptedGui, windowName: scriptedWindowName }) => relevantScriptedGuiNames.has(name) &&
+        parentScriptedGui !== undefined &&
+        scriptedWindowName !== undefined &&
+        scriptedWindowName !== windowName)
+        .sort((left, right) => compareCodeUnits(left.name, right.name));
+    let attachmentProgress = true;
+    while (pendingAttached.length > 0 && attachmentProgress) {
+        attachmentProgress = false;
+        for (let index = pendingAttached.length - 1; index >= 0; index -= 1) {
+            const scripted = pendingAttached[index];
+            const parentScripted = scripted.parentScriptedGui === undefined
+                ? undefined
+                : scriptedByName.get(scripted.parentScriptedGui);
+            const parentWindowName = parentScripted?.windowName;
+            const parentDefinition = parentWindowName === undefined ? undefined : elementsByName.get(parentWindowName);
+            const parentScene = parentDefinition === undefined ? undefined : context.instancesById.get(parentDefinition.id);
+            const attachedDefinition = scripted.windowName === undefined ? undefined : elementsByName.get(scripted.windowName);
+            if (parentScene === undefined || attachedDefinition === undefined)
+                continue;
+            if (!context.instancesById.has(attachedDefinition.id)) {
+                await layoutElement(attachedDefinition, parentScene.unclippedRect, parentScene.unclippedRect, parentScene.scale, parentScene.depth + 1, context, '', undefined, undefined, parentScene.id, 'upper_left', parentScene.visible);
+                addFidelity(fidelity, 'modelled', 'parent_scripted_gui_attachment', `${scripted.windowName} is attached to ${parentWindowName} through ${scripted.parentScriptedGui}.`, attachedDefinition);
+            }
+            pendingAttached.splice(index, 1);
+            attachmentProgress = true;
+        }
+    }
+    for (const scripted of pendingAttached) {
+        diagnostics.push({
+            code: 'GUI_PARENT_SCRIPTED_WINDOW_UNRESOLVED',
+            severity: 'error',
+            category: 'reference',
+            message: `Could not attach ${scripted.windowName ?? '<missing window>'} through parent scripted GUI ${scripted.parentScriptedGui ?? '<missing parent>'}.`,
+            ...(scripted.location === undefined ? {} : { location: scripted.location }),
+        });
+    }
     output.sort((left, right) => left.zIndex - right.zIndex || compareCodeUnits(left.id, right.id));
     const bounds = unionRects(output.filter(({ visible }) => visible).map(({ unclippedRect }) => unclippedRect));
     return {

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -118,6 +118,7 @@ const GuiPreviewScenarioBodySchema = z
     flags: z.record(z.string(), z.boolean()).default({}),
     lists: z.record(z.string(), z.array(objectSchema).max(10_000)).default({}),
     localisation: z.record(z.string(), z.string()).default({}),
+    values: objectSchema.default({}),
     scriptedGui: objectSchema.default({}),
     visibility: z.record(z.string(), z.boolean()).default({}),
     elementStates: z.record(z.string(), previewStateSchema).default({}),

package/dist/hoi4_agent_tools/gui/source-graph.js

@@ -63,6 +63,8 @@ const modelledElementAttributes = new Set([
     'allwaystransparent',
     'clickThrough',
     'spacing',
+    'slotsize',
+    'max_slots_horizontal',
     'priority',
     'minValue',
     'maxValue',
@@ -420,6 +422,9 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                         .concat(childBlocks(child, 'fontfiles').flatMap((fontFiles) => fontFiles.entries
                         .filter((entry) => entry.type === 'scalar')
                         .map((entry) => entry.value)));
+                    const languages = childBlocks(child, 'languages').flatMap((languageBlock) => languageBlock.entries
+                        .filter((entry) => entry.type === 'scalar')
+                        .map((entry) => entry.value));
                     const id = deterministicId('gui_font', { path: file.displayPath, name });
                     const font = {
                         id,
@@ -427,6 +432,8 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                         sourcePath: file.displayPath,
                         location: nodeLocation(document, assignment, name),
                         kind: 'bitmapfont',
+                        override: assignment.key.value === 'bitmapfont_override',
+                        languages,
                         assetPaths,
                         rawSource: raw(document, assignment),
                     };
@@ -437,7 +444,12 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                         name,
                         path: file.displayPath,
                         ...(font.location === undefined ? {} : { location: font.location }),
-                        metadata: { kind: font.kind, assetPaths },
+                        metadata: {
+                            kind: font.kind,
+                            override: font.override,
+                            languages,
+                            assetPaths,
+                        },
                     });
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, font.location);
                 }
@@ -476,6 +488,21 @@ function directEffectCosts(block) {
     }
     return costs;
 }
+function constantTriggerResult(value) {
+    if (value.type !== 'block')
+        return undefined;
+    const entries = assignments(value);
+    if (entries.length !== 1 || entries[0]?.key.value.toLowerCase() !== 'always')
+        return undefined;
+    const result = entries[0].value;
+    if (result.type !== 'scalar')
+        return undefined;
+    if (result.value.toLowerCase() === 'yes')
+        return true;
+    if (result.value.toLowerCase() === 'no')
+        return false;
+    return undefined;
+}
 function indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGuis) {
     for (const root of childBlocks(document.root, 'scripted_gui')) {
         for (const assignment of assignments(root)) {
@@ -493,9 +520,43 @@ function indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGui
                 location: nodeLocation(document, effect, effect.key.value),
             }));
             const effects = effectDefinitions.map(({ name: effect }) => effect);
-            const triggers = namedAssignments(block, 'triggers').map(({ key }) => key.value);
-            const properties = namedAssignments(block, 'properties').map(({ key }) => key.value);
-            const dynamicLists = namedAssignments(block, 'dynamic_lists').map(({ key }) => key.value);
+            const triggerDefinitions = namedAssignments(block, 'triggers').map((trigger) => {
+                const constantResult = constantTriggerResult(trigger.value);
+                return {
+                    name: trigger.key.value,
+                    elementName: actionElementName(trigger.key.value),
+                    ...(constantResult === undefined ? {} : { constantResult }),
+                    rawSource: raw(document, trigger),
+                    location: nodeLocation(document, trigger, trigger.key.value),
+                };
+            });
+            const triggers = triggerDefinitions.map(({ name: trigger }) => trigger);
+            const propertyAssignments = namedAssignments(block, 'properties');
+            const properties = propertyAssignments.map(({ key }) => key.value);
+            const propertyDefinitions = propertyAssignments.map((property) => ({
+                elementName: property.key.value,
+                attributes: property.value.type === 'block'
+                    ? sourceValueToProperty(property.value, constantsFor(document))
+                    : {},
+                rawSource: raw(document, property),
+                location: nodeLocation(document, property, property.key.value),
+            }));
+            const dynamicListDefinitions = namedAssignments(block, 'dynamic_lists').map((dynamicList) => {
+                const entryContainer = dynamicList.value.type === 'block'
+                    ? firstScalarInsensitive(dynamicList.value, 'entry_container')
+                    : undefined;
+                const countryScopeEntryContainer = dynamicList.value.type === 'block'
+                    ? firstScalarInsensitive(dynamicList.value, 'country_scope_entry_container')
+                    : undefined;
+                return {
+                    name: dynamicList.key.value,
+                    ...(entryContainer === undefined ? {} : { entryContainer }),
+                    ...(countryScopeEntryContainer === undefined ? {} : { countryScopeEntryContainer }),
+                    rawSource: raw(document, dynamicList),
+                    location: nodeLocation(document, dynamicList, dynamicList.key.value),
+                };
+            });
+            const dynamicLists = dynamicListDefinitions.map(({ name: dynamicList }) => dynamicList);
             const aiWeights = namedAssignments(block, 'ai_weights').map(({ key }) => key.value);
             const contextType = firstScalarInsensitive(block, 'context_type');
             const windowName = firstScalarInsensitive(block, 'window_name');
@@ -517,8 +578,11 @@ function indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGui
                 effects: effects.sort((a, b) => compareCodeUnits(a, b)),
                 effectDefinitions: effectDefinitions.sort((a, b) => compareCodeUnits(a.name, b.name)),
                 triggers: triggers.sort((a, b) => compareCodeUnits(a, b)),
+                triggerDefinitions: triggerDefinitions.sort((a, b) => compareCodeUnits(a.name, b.name)),
                 properties: properties.sort((a, b) => compareCodeUnits(a, b)),
+                propertyDefinitions: propertyDefinitions.sort((a, b) => compareCodeUnits(a.elementName, b.elementName)),
                 dynamicLists: dynamicLists.sort((a, b) => compareCodeUnits(a, b)),
+                dynamicListDefinitions: dynamicListDefinitions.sort((left, right) => compareCodeUnits(left.name, right.name)),
                 aiWeights: aiWeights.sort((a, b) => compareCodeUnits(a, b)),
                 aiEnabled: childBlocks(block, 'ai_enabled').length > 0 || childBlocks(block, 'ai_check').length > 0,
                 rawSource: raw(document, assignment),
@@ -533,8 +597,23 @@ function indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGui
                 metadata: {
                     effects: definition.effects,
                     triggers: definition.triggers,
+                    constantTriggers: definition.triggerDefinitions.flatMap(({ name: trigger, elementName, constantResult }) => constantResult === undefined ? [] : [{ trigger, elementName, constantResult }]),
                     properties: definition.properties,
                     dynamicLists: definition.dynamicLists,
+                    dynamicListEntryContainers: definition.dynamicListDefinitions.flatMap(({ name: dynamicList, entryContainer, countryScopeEntryContainer }) => [
+                        ...(entryContainer === undefined
+                            ? []
+                            : [{ dynamicList, scope: 'generic', container: entryContainer }]),
+                        ...(countryScopeEntryContainer === undefined
+                            ? []
+                            : [
+                                {
+                                    dynamicList,
+                                    scope: 'country',
+                                    container: countryScopeEntryContainer,
+                                },
+                            ]),
+                    ]),
                     aiWeights: definition.aiWeights,
                     aiEnabled: definition.aiEnabled,
                 },
@@ -718,7 +797,15 @@ function indexDecisionEntries(document, file, nodes, pendingDecisionEdges) {
 }
 function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scriptedLocalisation, localisation, textureNodes, fontAssetNodes, pendingDecisionEdges) {
     const spriteByName = new Map(sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
-    const fontByName = new Map(fonts.map((font) => [font.name.toLocaleLowerCase('en-US'), font]));
+    const fontByName = new Map();
+    for (const font of fonts) {
+        const key = font.name.toLocaleLowerCase('en-US');
+        const existing = fontByName.get(key);
+        if (existing === undefined ||
+            (existing.override && !font.override) ||
+            (existing.languages.length > 0 && font.languages.length === 0))
+            fontByName.set(key, font);
+    }
     const elementByName = new Map();
     for (const element of [...elements].sort((a, b) => a.definitionOrder - b.definitionOrder)) {
         if (!elementByName.has(element.name))
@@ -778,7 +865,9 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
         }
         for (const key of localisationAttributeNames) {
             const value = element.attributes[key];
-            if (typeof value !== 'string' || value.trim().length === 0)
+            if (typeof value !== 'string' ||
+                value.trim().length === 0 ||
+                !isStaticGuiLocalisationReference(value))
                 continue;
             const entry = localisationByKey.get(value);
             addEdge(edges, 'uses_localisation', element.id, entry === undefined ? `localisation:${value}` : deterministicId('gui_loc', entry), entry !== undefined, { field: key, key: value }, element.location);
@@ -824,6 +913,17 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
             const element = elementByName.get(property);
             addEdge(edges, 'property_target', gui.id, element?.id ?? `gui_element:${property}`, element !== undefined, { property }, gui.location);
         }
+        for (const dynamicList of gui.dynamicListDefinitions) {
+            for (const [scope, containerName] of [
+                ['generic', dynamicList.entryContainer],
+                ['country', dynamicList.countryScopeEntryContainer],
+            ]) {
+                if (containerName === undefined)
+                    continue;
+                const element = elementByName.get(containerName);
+                addEdge(edges, 'dynamic_list_template', gui.id, element?.id ?? `gui_element:${containerName}`, element !== undefined, { dynamicList: dynamicList.name, scope, containerName }, dynamicList.location);
+            }
+        }
     }
     for (const pending of pendingDecisionEdges) {
         const target = scriptedByName.get(pending.target);
@@ -837,12 +937,18 @@ const localisationAttributeNames = [
     'pdx_tooltip_delayed',
     'hint_tag',
 ];
+function isStaticGuiLocalisationReference(value) {
+    const trimmed = value.trim();
+    return !(trimmed.startsWith('[') && trimmed.endsWith(']'));
+}
 function referencedGuiLocalisationKeys(elements, scriptedLocalisation) {
     const keys = new Set(scriptedLocalisation.flatMap(({ localisationKeys }) => localisationKeys));
     for (const element of elements) {
         for (const attribute of localisationAttributeNames) {
             const value = element.attributes[attribute];
-            if (typeof value === 'string' && value.trim().length > 0)
+            if (typeof value === 'string' &&
+                value.trim().length > 0 &&
+                isStaticGuiLocalisationReference(value))
                 keys.add(value);
         }
     }
@@ -862,6 +968,7 @@ function skippedInventoryCouldResolve(edge, sharedIndex) {
         case 'button_effect':
         case 'button_trigger':
         case 'property_target':
+        case 'dynamic_list_template':
             return sharedIndex.hasSkippedSourceForKind('gui_element');
         case 'parent_scripted_gui':
         case 'decision_category_entry':
@@ -1016,6 +1123,8 @@ export function buildGuiSourceGraph(files, sharedIndex) {
                     name: path.posix.basename(normalized, '.fnt'),
                     sourcePath: file.displayPath,
                     kind: 'bmfont',
+                    override: false,
+                    languages: [],
                     assetPaths: [file.relativePath],
                 }, 'font');
             }