core2026/tools/generate-map-data.mjs

import fs from 'node:fs/promises';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const LEGACY_MAP_ROOT = path.resolve(
    __dirname,
    '..',
    'legacy',
    'hwe',
    'scenario',
    'map'
);
const LEGACY_BASE_FILE = path.resolve(
    __dirname,
    '..',
    'legacy',
    'hwe',
    'sammo',
    'CityConstBase.php'
);
const OUTPUT_ROOT = path.resolve(
    __dirname,
    '..',
    'app',
    'game-engine',
    'resources',
    'map'
);

const MAP_NAMES = [
    'che',
    'miniche',
    'miniche_b',
    'miniche_clean',
    'cr',
    'chess',
    'ludo_rathowm',
    'pokemon_v1',
];

const LEVEL_MAP = {
    '수': 1,
    '진': 2,
    '관': 3,
    '이': 4,
    '소': 5,
    '중': 6,
    '대': 7,
    '특': 8,
};

const LEVEL_LABELS = Object.entries(LEVEL_MAP).reduce((acc, [label, value]) => {
    acc[value] = label;
    return acc;
}, {});

const DEFAULT_REGION_MAP = {
    '하북': 1,
    '중원': 2,
    '서북': 3,
    '서촉': 4,
    '남중': 5,
    '초': 6,
    '오월': 7,
    '동이': 8,
};

const BUILD_INIT_COMMON = {
    trust: 50,
    trade: 100,
};

const BUILD_INIT = {
    '수': {
        population: 5000,
        agriculture: 100,
        commerce: 100,
        security: 100,
        defence: 500,
        wall: 500,
    },
    '진': {
        population: 5000,
        agriculture: 100,
        commerce: 100,
        security: 100,
        defence: 500,
        wall: 500,
    },
    '관': {
        population: 10000,
        agriculture: 100,
        commerce: 100,
        security: 100,
        defence: 1000,
        wall: 1000,
    },
    '이': {
        population: 50000,
        agriculture: 1000,
        commerce: 1000,
        security: 1000,
        defence: 1000,
        wall: 1000,
    },
    '소': {
        population: 100000,
        agriculture: 1000,
        commerce: 1000,
        security: 1000,
        defence: 2000,
        wall: 2000,
    },
    '중': {
        population: 100000,
        agriculture: 1000,
        commerce: 1000,
        security: 1000,
        defence: 3000,
        wall: 3000,
    },
    '대': {
        population: 150000,
        agriculture: 1000,
        commerce: 1000,
        security: 1000,
        defence: 4000,
        wall: 4000,
    },
    '특': {
        population: 150000,
        agriculture: 1000,
        commerce: 1000,
        security: 1000,
        defence: 5000,
        wall: 5000,
    },
};

const DEFAULT_SUPPLY_STATE = 1;
const DEFAULT_FRONT_STATE = 0;

const readFileOrNull = async (filePath) => {
    try {
        return await fs.readFile(filePath, 'utf8');
    } catch {
        return null;
    }
};

const extractPhpArray = (source, marker) => {
    const markerIndex = source.indexOf(marker);
    if (markerIndex < 0) {
        return null;
    }
    const start = source.indexOf('[', markerIndex);
    if (start < 0) {
        return null;
    }

    let depth = 0;
    let inString = null;

    for (let i = start; i < source.length; i += 1) {
        const char = source[i];
        if (inString) {
            if (char === '\\') {
                i += 1;
                continue;
            }
            if (char === inString) {
                inString = null;
            }
            continue;
        }

        if (char === '"' || char === "'") {
            inString = char;
            continue;
        }

        if (char === '[') {
            depth += 1;
            continue;
        }
        if (char === ']') {
            depth -= 1;
            if (depth === 0) {
                return source.slice(start, i + 1);
            }
        }
    }

    return null;
};

const stripPhpComments = (source) =>
    source
        .replace(/\/\*[\s\S]*?\*\//g, '')
        .replace(/\/\/.*$/gm, '')
        .replace(/#.*$/gm, '');

const normalizePhpArray = (source) =>
    stripPhpComments(source)
        .replace(/\bNULL\b/gi, 'null')
        .replace(/'/g, '"')
        .replace(/,(\s*[\]\}])/g, '$1');

const parseLegacyCityRows = (value) => {
    if (!Array.isArray(value)) {
        throw new Error('Legacy map data is not an array.');
    }

    return value.map((row, index) => {
        if (!Array.isArray(row)) {
            throw new Error(`Legacy map row ${index} is not an array.`);
        }
        const [
            id,
            name,
            level,
            population,
            agriculture,
            commerce,
            security,
            defence,
            wall,
            region,
            positionX,
            positionY,
            connections,
        ] = row;

        if (typeof id !== 'number' || typeof name !== 'string') {
            throw new Error(`Legacy map row ${index} has invalid id/name.`);
        }

        const connectionNames = Array.isArray(connections)
            ? connections.filter((value) => typeof value === 'string')
            : [];

        return {
            id,
            name,
            level,
            population,
            agriculture,
            commerce,
            security,
            defence,
            wall,
            region,
            positionX,
            positionY,
            connectionNames,
        };
    });
};

const resolveLevelLabel = (level) => {
    if (typeof level === 'string') {
        return level;
    }
    const label = LEVEL_LABELS[level];
    if (!label) {
        throw new Error(`Unknown level value: ${level}`);
    }
    return label;
};

const resolveLevelValue = (level) => {
    if (typeof level === 'number') {
        return level;
    }
    const value = LEVEL_MAP[level];
    if (!value) {
        throw new Error(`Unknown level label: ${level}`);
    }
    return value;
};

const resolveRegionValue = (region, regionMap) => {
    if (typeof region === 'number') {
        return region;
    }
    const value = regionMap[region];
    if (!value) {
        throw new Error(`Unknown region label: ${region}`);
    }
    return value;
};

const buildCityDefinition = (row, nameToId, regionMap) => {
    const levelLabel = resolveLevelLabel(row.level);
    const initial = BUILD_INIT[levelLabel];
    if (!initial) {
        throw new Error(`Missing build init for level ${levelLabel}.`);
    }

    const connections = row.connectionNames
        .map((name) => nameToId.get(name))
        .filter((value) => typeof value === 'number');

    return {
        id: row.id,
        name: row.name,
        level: resolveLevelValue(row.level),
        region: resolveRegionValue(row.region, regionMap),
        position: {
            x: row.positionX,
            y: row.positionY,
        },
        connections,
        max: {
            population: row.population * 100,
            agriculture: row.agriculture * 100,
            commerce: row.commerce * 100,
            security: row.security * 100,
            defence: row.defence * 100,
            wall: row.wall * 100,
        },
        initial,
        meta: {
            source: 'legacy',
            connectionNames: row.connectionNames,
        },
    };
};

const parseRegionMap = (source) => {
    const raw = extractPhpArray(source, 'public static $regionMap');
    if (!raw) {
        return null;
    }
    const normalized = normalizePhpArray(raw);
    const regex = /"([^"]+)"\s*=>\s*(\d+)/g;
    const regionMap = {};
    let match = regex.exec(normalized);
    while (match) {
        const [, key, value] = match;
        regionMap[key] = Number(value);
        match = regex.exec(normalized);
    }
    return Object.keys(regionMap).length > 0 ? regionMap : null;
};

const loadLegacyMapRows = async (mapName) => {
    const mapFilePath = path.resolve(LEGACY_MAP_ROOT, `${mapName}.php`);
    const [mapSource, baseSource] = await Promise.all([
        readFileOrNull(mapFilePath),
        readFileOrNull(LEGACY_BASE_FILE),
    ]);

    if (!baseSource) {
        throw new Error(`Legacy base map file is missing: ${LEGACY_BASE_FILE}`);
    }

    const initCitySource =
        (mapSource
            ? extractPhpArray(mapSource, 'protected static $initCity')
            : null) ??
        extractPhpArray(baseSource, 'protected static $initCity');

    if (!initCitySource) {
        throw new Error(`Legacy map data not found for ${mapName}.`);
    }

    const parsed = JSON.parse(normalizePhpArray(initCitySource));
    const rows = parseLegacyCityRows(parsed);
    const baseRegionMap = parseRegionMap(baseSource) ?? DEFAULT_REGION_MAP;
    const regionMap = mapSource
        ? parseRegionMap(mapSource) ?? baseRegionMap
        : baseRegionMap;
    return { rows, regionMap };
};

const buildMapDefinition = (mapName, rows, regionMap) => {
    const nameToId = new Map(rows.map((row) => [row.name, row.id]));

    return {
        id: mapName,
        name: mapName,
        cities: rows.map((row) => buildCityDefinition(row, nameToId, regionMap)),
        defaults: {
            trust: BUILD_INIT_COMMON.trust,
            trade: BUILD_INIT_COMMON.trade,
            supplyState: DEFAULT_SUPPLY_STATE,
            frontState: DEFAULT_FRONT_STATE,
        },
        meta: {
            source: 'legacy',
            mapName,
        },
    };
};

const ensureOutputRoot = async () => {
    await fs.mkdir(OUTPUT_ROOT, { recursive: true });
};

const writeMapDefinition = async (mapName, definition) => {
    const filePath = path.resolve(OUTPUT_ROOT, `map_${mapName}.json`);
    const payload = `${JSON.stringify(definition, null, 4)}\n`;
    await fs.writeFile(filePath, payload, 'utf8');
};

const main = async () => {
    await ensureOutputRoot();

    for (const mapName of MAP_NAMES) {
        const { rows, regionMap } = await loadLegacyMapRows(mapName);
        const definition = buildMapDefinition(mapName, rows, regionMap);
        await writeMapDefinition(mapName, definition);
        console.log(`Generated map_${mapName}.json (${rows.length} cities)`);
    }
};

await main();