afnm-types 0.6.49 → 0.6.50

package/dist/CharacterCraftingEncounter.d.ts

@@ -0,0 +1,7 @@
+import type { EventStep } from '.';
+export interface CharacterCraftingEncounter {
+    condition: string;
+    introSteps: EventStep[];
+    exitSteps: EventStep[];
+    character: string;
+}

package/dist/CharacterCraftingEncounter.js

@@ -0,0 +1 @@
+export {};

package/dist/avatarEffects.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Avatar visual effect registry.
+ *
+ * Each effect maps to a WebGL fragment shader that replaces the default
+ * crossfade shader while the effect is active. Mods can extend
+ * AVATAR_EFFECT_REGISTRY with additional string keys before combat starts.
+ *
+ * Built-in effect IDs are defined in AvatarEffectId.
+ */
+export type AvatarEffectId = 'glitch';
+export interface AvatarEffectShader {
+    /**
+     * Fragment shader source. Must accept the same base uniforms as the default
+     * fragment shader (u_texA, u_texB, u_mix, u_aspectA, u_aspectB,
+     * u_canvasAspect) plus u_time (float, seconds since the effect started).
+     */
+    fragSrc: string;
+}
+/**
+ * Central record from effect ID → shader definition.
+ * Mods can add entries with arbitrary string keys before combat starts.
+ */
+export declare const AVATAR_EFFECT_REGISTRY: Record<string, AvatarEffectShader>;

package/dist/avatarEffects.js

@@ -0,0 +1,98 @@
+/**
+ * Avatar visual effect registry.
+ *
+ * Each effect maps to a WebGL fragment shader that replaces the default
+ * crossfade shader while the effect is active. Mods can extend
+ * AVATAR_EFFECT_REGISTRY with additional string keys before combat starts.
+ *
+ * Built-in effect IDs are defined in AvatarEffectId.
+ */
+// ─── Glitch shader ────────────────────────────────────────────────────────────
+// Replicates the hand-authored glitch art style: strong persistent chromatic
+// aberration (cyan/magenta fringing always visible), periodic brightness
+// washout, and horizontal scanline tears during burst events.
+const GLITCH_FRAG_SRC = `
+precision mediump float;
+varying vec2 v_uv;
+uniform sampler2D u_texA;
+uniform sampler2D u_texB;
+uniform float u_mix;
+uniform float u_aspectA;
+uniform float u_aspectB;
+uniform float u_canvasAspect;
+uniform float u_time;
+
+float hash(float n) {
+  return fract(sin(n) * 43758.5453);
+}
+
+vec4 sampleContain(sampler2D tex, vec2 uv, float texAspect) {
+  float rel = texAspect / u_canvasAspect;
+  vec2 scale;
+  if (rel > 1.0) {
+    scale = vec2(1.0, 1.0 / rel);
+  } else {
+    scale = vec2(rel, 1.0);
+  }
+  vec2 offset = (1.0 - scale) * 0.5;
+  vec2 mapped = (uv - offset) / scale;
+  if (mapped.x < 0.0 || mapped.x > 1.0 || mapped.y < 0.0 || mapped.y > 1.0) {
+    return vec4(0.0);
+  }
+  return texture2D(tex, mapped);
+}
+
+void main() {
+  vec2 uv = v_uv;
+
+  // Glitch burst timing — ~0.8 event slots per second, 35% chance each.
+  float eventT = floor(u_time * 0.8);
+  float isGlitching = step(0.65, hash(eventT * 1.618));
+  // Sharp onset, slow decay — the burst lingers before fading.
+  float slotFrac = fract(u_time * 0.8);
+  float decay = (1.0 - smoothstep(0.1, 0.9, slotFrac)) * isGlitching;
+
+  // Band-based horizontal displacement (scanline tearing) during bursts.
+  float band = floor(uv.y * 24.0);
+  float bandActive = step(0.55, hash(band + eventT * 23.7));
+  float bandShift = (hash(band * 5.2 + eventT * 7.1) * 2.0 - 1.0) * 0.025;
+  float shift = bandShift * bandActive * decay;
+
+  // Occasional large block tears.
+  float bigTear = step(0.92, hash(band * 3.7 + eventT * 11.3));
+  shift += (hash(band * 9.1 + eventT * 4.7) * 2.0 - 1.0) * 0.08 * bigTear * decay;
+
+  vec2 shiftedUv = vec2(uv.x + shift, uv.y);
+
+  // Chromatic aberration: strong baseline always present, amplified by bursts.
+  float aberr = 0.012 + 0.018 * decay;
+
+  float rA = sampleContain(u_texA, vec2(shiftedUv.x + aberr, shiftedUv.y), u_aspectA).r;
+  float gA = sampleContain(u_texA, shiftedUv, u_aspectA).g;
+  float bA = sampleContain(u_texA, vec2(shiftedUv.x - aberr, shiftedUv.y), u_aspectA).b;
+  float aA = sampleContain(u_texA, shiftedUv, u_aspectA).a;
+  vec4 colA = vec4(rA, gA, bA, aA);
+
+  float rB = sampleContain(u_texB, vec2(shiftedUv.x + aberr, shiftedUv.y), u_aspectB).r;
+  float gB = sampleContain(u_texB, shiftedUv, u_aspectB).g;
+  float bB = sampleContain(u_texB, vec2(shiftedUv.x - aberr, shiftedUv.y), u_aspectB).b;
+  float aB = sampleContain(u_texB, shiftedUv, u_aspectB).a;
+  vec4 colB = vec4(rB, gB, bB, aB);
+
+  vec4 col = mix(colA, colB, u_mix);
+
+  // Brightness washout during bursts — push toward overexposed white,
+  // scaled by alpha so transparent edges don't bloom.
+  float blowout = decay * 0.45;
+  col.rgb = mix(col.rgb, vec3(1.0), blowout * col.a);
+
+  gl_FragColor = col;
+}`;
+// ─── Registry ─────────────────────────────────────────────────────────────────
+/**
+ * Central record from effect ID → shader definition.
+ * Mods can add entries with arbitrary string keys before combat starts.
+ */
+export const AVATAR_EFFECT_REGISTRY = {
+    glitch: { fragSrc: GLITCH_FRAG_SRC },
+};

package/dist/buff.d.ts

@@ -3,6 +3,7 @@ import type { TechniqueElement } from './element';
 import type { CombatStatistic, Scaling } from './stat';
 import type { DamageType } from './DamageType';
 import type { CombatEntity } from './entity';
+import { AvatarEffectId } from './avatarEffects';
 export type TechniqueCondition = ChanceTechniqueCondition | BuffTechniqueCondition | HpTechniqueCondition | ConditionTechniqueCondition | InventoryItemTechniqueCondition;
 interface BaseTechniqueCondition {
     /**
@@ -154,7 +155,7 @@ export interface Buff {
     /** Runtime guardian max HP — set automatically from guardianIntercept.maxHp at buff creation */
     guardianMaxHp?: number;
 }
-type BuffCombatImage = ScatterCombatImage | ArcCombatImage | FloatingCombatImage | OverlayCombatImage | CompanionCombatImage | GuardianCombatImage | GroundCombatImage | FormationCombatImage | ForegroundCombatImage | BackgroundCombatImage | TransformationCombatImage;
+type BuffCombatImage = ScatterCombatImage | ArcCombatImage | FloatingCombatImage | OverlayCombatImage | CompanionCombatImage | GuardianCombatImage | GroundCombatImage | FormationCombatImage | ForegroundCombatImage | BackgroundCombatImage | TransformationCombatImage | AvatarEffectCombatImage;
 interface BaseCombatImage {
     image: string;
     imageOverrides?: {
@@ -165,6 +166,19 @@ interface BaseCombatImage {
     animations?: ('buff' | 'bump' | 'attack' | 'debuff')[];
     animateOnEntity?: boolean;
 }
+/**
+ * Avatar effect combat image — applies a visual shader effect to the character
+ * avatar sprite while this buff is active. Only the last active avatarEffect
+ * buff applies (same priority rule as transformation).
+ */
+export interface AvatarEffectCombatImage {
+    position: 'avatarEffect';
+    /** The shader effect to apply. Use AvatarEffectId for built-ins, or a
+     *  custom string key registered in AVATAR_EFFECT_REGISTRY for mod effects. */
+    effect: AvatarEffectId | string;
+    animations?: ('buff' | 'bump' | 'attack' | 'debuff')[];
+    animateOnEntity?: boolean;
+}
 export interface ScatterCombatImage extends BaseCombatImage {
     position: 'scatter';
 }

package/dist/cli/extract-mod-translations/index.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Mod Translation String Extraction Script
+ *
+ * Extracts translatable strings from a mod's TypeScript source code and generates
+ * a template.json file that translators can fill in to provide translations.
+ *
+ * Translators fill in template.json (or a copy of it named <lang>.json), then the
+ * mod registers those translations at runtime via:
+ *   import ruTranslations from './translations/ru.json';
+ *   api.addTranslation('ru', ruTranslations);
+ *
+ * Usage: WHEN RUNNING THIS, USE THE NPM COMMAND. DO NOT TRY TO RUN DIRECTLY
+ *   npm run extract-mod-translations -- --src <path> [--output <path>]
+ *
+ * Options:
+ *   --src <path>     Path to the mod source directory (default: ./src)
+ *   --output <path>  Path to the translations output directory (default: ./translations)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const registries_js_1 = require("../extract-translations/registries.js");
+const registry_builders_js_1 = require("../extract-translations/registry-builders.js");
+const extractors_js_1 = require("../extract-translations/extractors.js");
+const reporters_js_1 = require("../extract-translations/reporters.js");
+// ─── CLI argument parsing ───────────────────────────────────────────────────
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let srcDir = './src';
+    let outputDir = './translations';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--src' && args[i + 1]) {
+            srcDir = args[++i];
+        }
+        else if (args[i] === '--output' && args[i + 1]) {
+            outputDir = args[++i];
+        }
+    }
+    return { srcDir, outputDir };
+}
+// ─── Translation migration helpers ─────────────────────────────────────────
+/**
+ * Build a lookup structure from an existing language file so translations
+ * can be migrated to the new template structure.
+ */
+function buildTranslationLookup(lang) {
+    const flat = new Map();
+    const flatWithField = new Map();
+    const nested = new Map();
+    for (const [category, objects] of Object.entries(lang)) {
+        const categoryMap = new Map();
+        nested.set(category, categoryMap);
+        for (const [objectId, fields] of Object.entries(objects)) {
+            const objectMap = new Map();
+            categoryMap.set(objectId, objectMap);
+            for (const [key, translation] of Object.entries(fields)) {
+                if (typeof translation !== 'string' || !translation.trim())
+                    continue;
+                // Key format: "[field] English text" or "[field:context] English text"
+                const match = key.match(/^\[([^\]]+)\]\s*(.+)$/s);
+                if (!match)
+                    continue;
+                const field = match[1];
+                const englishText = match[2].trim();
+                objectMap.set(englishText, translation);
+                flat.set(englishText, translation);
+                flatWithField.set(`${field}|${englishText}`, translation);
+            }
+        }
+    }
+    return { flat, flatWithField, nested };
+}
+/**
+ * Migrate an existing language file to the new template structure.
+ */
+function migrateTranslationsToTemplate(template, existingLang) {
+    const lookup = buildTranslationLookup(existingLang);
+    const migrated = {};
+    let matched = 0;
+    let unmatched = 0;
+    for (const [category, objects] of Object.entries(template)) {
+        migrated[category] = {};
+        for (const [objectId, fields] of Object.entries(objects)) {
+            migrated[category][objectId] = {};
+            for (const key of Object.keys(fields)) {
+                const match = key.match(/^\[([^\]]+)\]\s*(.+)$/s);
+                if (!match) {
+                    migrated[category][objectId][key] = '';
+                    unmatched++;
+                    continue;
+                }
+                const field = match[1];
+                const englishText = match[2].trim();
+                let translation;
+                // Strategy 1: Exact match at same category/objectId
+                translation = lookup.nested.get(category)?.get(objectId)?.get(englishText);
+                // Strategy 1.5: Context migration — look for same key without context
+                if (!translation && field.includes(':')) {
+                    const baseField = field.split(':')[0];
+                    const existingObject = existingLang[category]?.[objectId];
+                    if (existingObject) {
+                        for (const [oldKey, oldTranslation] of Object.entries(existingObject)) {
+                            if (typeof oldTranslation !== 'string' || !oldTranslation.trim())
+                                continue;
+                            const oldMatch = oldKey.match(/^\[([^\]]+)\]\s*(.+)$/s);
+                            if (!oldMatch)
+                                continue;
+                            if (oldMatch[2].trim() === englishText && oldMatch[1] === baseField) {
+                                translation = oldTranslation;
+                                break;
+                            }
+                        }
+                    }
+                }
+                // Strategy 2: Match by field + English text across all locations
+                if (!translation) {
+                    translation = lookup.flatWithField.get(`${field}|${englishText}`);
+                }
+                // Strategy 3: Match by base field (ignore context) + English text
+                if (!translation && field.includes(':')) {
+                    const baseField = field.split(':')[0];
+                    translation = lookup.flatWithField.get(`${baseField}|${englishText}`);
+                }
+                // Strategy 4: Fallback — match English text only
+                if (!translation) {
+                    translation = lookup.flat.get(englishText);
+                }
+                if (translation) {
+                    migrated[category][objectId][key] = translation;
+                    matched++;
+                }
+                else {
+                    migrated[category][objectId][key] = '';
+                    unmatched++;
+                }
+            }
+        }
+    }
+    return { migrated, stats: { matched, unmatched } };
+}
+/**
+ * Deep sort an object's keys alphabetically (recursive) for consistent output.
+ */
+function deepSortObject(obj) {
+    if (typeof obj !== 'object' || Array.isArray(obj)) {
+        return obj;
+    }
+    const result = {};
+    for (const key of Object.keys(obj).sort((a, b) => a.localeCompare(b))) {
+        const value = obj[key];
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = deepSortObject(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Load existing language files from the output directory.
+ * These will be migrated to the new template structure.
+ */
+function loadExistingModLanguageFiles(outputDir) {
+    const languageFiles = new Map();
+    if (!fs_1.default.existsSync(outputDir)) {
+        return languageFiles;
+    }
+    const entries = fs_1.default.readdirSync(outputDir);
+    for (const entry of entries) {
+        if (!entry.endsWith('.json') || entry === 'template.json')
+            continue;
+        const lang = entry.replace('.json', '');
+        const langPath = path_1.default.join(outputDir, entry);
+        try {
+            const data = JSON.parse(fs_1.default.readFileSync(langPath, 'utf-8'));
+            languageFiles.set(lang, data);
+            console.log(`  Loaded existing translations from ${entry}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Failed to parse ${entry}: ${message}`);
+        }
+    }
+    return languageFiles;
+}
+/**
+ * Count total translatable entries in a hierarchical template.
+ */
+function countHierarchicalStrings(template) {
+    let count = 0;
+    for (const category of Object.values(template)) {
+        for (const objectStrings of Object.values(category)) {
+            count += Object.keys(objectStrings).length;
+        }
+    }
+    return count;
+}
+// ─── Main extraction function ───────────────────────────────────────────────
+async function main() {
+    const { srcDir, outputDir } = parseArgs();
+    const resolvedSrc = path_1.default.resolve(srcDir);
+    const resolvedOutput = path_1.default.resolve(outputDir);
+    console.log('Extracting translatable strings from mod...\n');
+    console.log(`  Source directory : ${resolvedSrc}`);
+    console.log(`  Output directory : ${resolvedOutput}\n`);
+    if (!fs_1.default.existsSync(resolvedSrc)) {
+        console.error(`Error: Source directory does not exist: ${resolvedSrc}`);
+        process.exit(1);
+    }
+    // Clear all registries so this run is isolated (important when running multiple times)
+    (0, registries_js_1.clearRegistries)();
+    // Find all TypeScript/TSX files in the mod source
+    const files = await (0, glob_1.glob)('**/*.{ts,tsx}', {
+        cwd: resolvedSrc,
+        ignore: ['**/*.test.ts', '**/*.test.tsx', '**/*.d.ts'],
+        absolute: true,
+    });
+    if (files.length === 0) {
+        console.warn('Warning: No TypeScript files found in the source directory.');
+        console.warn(`  Searched in: ${resolvedSrc}`);
+    }
+    else {
+        console.log(`Found ${files.length} source file(s) to scan.\n`);
+    }
+    // PASS 1: Build string export registry
+    console.log('Pass 1: Building string export registry...');
+    for (const file of files) {
+        try {
+            (0, registry_builders_js_1.buildStringExportRegistry)(file);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Failed to parse ${file}: ${message}`);
+        }
+    }
+    // PASS 2: Build import registry
+    console.log('Pass 2: Building import registry...');
+    for (const file of files) {
+        try {
+            (0, registry_builders_js_1.buildImportRegistry)(file);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Failed to parse ${file}: ${message}`);
+        }
+    }
+    // PASS 3: Build name export registry
+    console.log('Pass 3: Building name export registry...');
+    for (const file of files) {
+        try {
+            (0, registry_builders_js_1.buildNameExportRegistry)(file);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Failed to parse ${file}: ${message}`);
+        }
+    }
+    // PASS 4: Build realm map registry
+    console.log('Pass 4: Building realm map registry...');
+    for (const file of files) {
+        try {
+            (0, registry_builders_js_1.buildRealmMapRegistry)(file);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Failed to parse ${file}: ${message}`);
+        }
+    }
+    (0, registry_builders_js_1.computeRealmMapNames)();
+    // PASS 5: Extract strings
+    console.log('Pass 5: Extracting strings...');
+    const allStrings = [];
+    for (const file of files) {
+        try {
+            const extracted = (0, extractors_js_1.extractFromFile)(file);
+            allStrings.push(...extracted);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`  Error processing ${file}: ${message}`);
+        }
+    }
+    // PASS 5.5: Extract from xxxToName maps defined in the mod source
+    console.log('Pass 5.5: Extracting from xxxToName maps...');
+    try {
+        const toNameStrings = await (0, extractors_js_1.extractFromToNameMaps)(resolvedSrc);
+        allStrings.push(...toNameStrings);
+        console.log(`  Found ${toNameStrings.length} strings in xxxToName maps.`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`  Error extracting from xxxToName maps: ${message}`);
+    }
+    // PASS 5.6: Add realm-indexed map names
+    let realmMapNameCount = 0;
+    for (const [mapKey, realmNames] of registries_js_1.realmMapResolvedNames) {
+        const [filePath] = mapKey.split(':');
+        for (const [, name] of realmNames) {
+            if (name && name.trim().length > 0) {
+                allStrings.push({
+                    text: name,
+                    file: filePath,
+                    line: 0,
+                    context: 'data-name-static',
+                    objectType: 'item',
+                });
+                realmMapNameCount++;
+            }
+        }
+    }
+    if (realmMapNameCount > 0) {
+        console.log(`  Found ${realmMapNameCount} realm-indexed map names.`);
+    }
+    // Collect simple and static strings for template generation
+    const templateStrings = allStrings.filter((s) => s.context !== 'INVALID_TEMPLATE_LITERAL' &&
+        !s.context.startsWith('NEEDS_MANUAL_REVIEW') &&
+        !s.context.includes('-dynamic'));
+    console.log(`\nTotal extracted strings: ${allStrings.length}`);
+    console.log(`Template-ready strings : ${templateStrings.length}`);
+    // Generate hierarchical template
+    console.log('\nGenerating translation template...');
+    const template = (0, reporters_js_1.generateHierarchicalTemplate)(templateStrings);
+    const sortedTemplate = deepSortObject(template);
+    const stringCount = countHierarchicalStrings(sortedTemplate);
+    console.log(`  ${stringCount} unique translatable entries found.`);
+    // Ensure output directory exists
+    fs_1.default.mkdirSync(resolvedOutput, { recursive: true });
+    // Load existing language files for migration
+    console.log('\nLoading existing language files...');
+    const existingLanguages = loadExistingModLanguageFiles(resolvedOutput);
+    // Write template.json
+    const templatePath = path_1.default.join(resolvedOutput, 'template.json');
+    fs_1.default.writeFileSync(templatePath, JSON.stringify(sortedTemplate, null, 2), 'utf-8');
+    console.log(`\nWrote template: ${templatePath}`);
+    // Migrate existing language files
+    if (existingLanguages.size > 0) {
+        console.log('\nMigrating existing translations to new template structure...');
+        for (const [lang, existingData] of existingLanguages) {
+            const { migrated, stats } = migrateTranslationsToTemplate(sortedTemplate, existingData);
+            const sortedMigrated = deepSortObject(migrated);
+            const langPath = path_1.default.join(resolvedOutput, `${lang}.json`);
+            fs_1.default.writeFileSync(langPath, JSON.stringify(sortedMigrated, null, 2), 'utf-8');
+            const total = stats.matched + stats.unmatched;
+            const pct = total > 0 ? Math.round((stats.matched / total) * 100) : 0;
+            console.log(`  ${lang}.json: ${stats.matched}/${total} strings preserved (${pct}%)`);
+        }
+    }
+    console.log('\n✓ Extraction complete!\n');
+    console.log('Next steps:');
+    console.log(`  1. Open ${templatePath}`);
+    console.log('  2. Copy it to a new language file, e.g. translations/ru.json');
+    console.log('  3. Fill in the translated values for each key');
+    console.log('  4. Register the translations in your mod:');
+    console.log("       import ruTranslations from './translations/ru.json';");
+    console.log("       api.addTranslation('ru', ruTranslations);");
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});