Rivers lost after risking heightmap changes without any changes

[fwdekker]

Describe the bug

If I edit the heightmap in "risk" mode and then immediately click "Exit Customization", all rivers are re-generated, and all custom rivers are removed.

I understand that determining what should happen with the rivers after changing the heightmap is difficult. However, I had not expected all rivers to change regardless of what I do. If this is intended, then I think the message should be changed to indicate that rivers will be regenerated regardless.

My use case is that I have a map on which I have removed all default rivers and added a few important rivers myself. The exact locations of those rivers are important for my map. To be quite frank, I don't care if rivers suddenly go up a mountain because of my heightmap changes; the locations are more important for me, because sometimes rivers should follow borders.

Steps to reproduce

1. Load FMG in a fresh browser session. A random map with default settings should now generate.
2. Go to "Tools".
3. In the "Tools" window, under "Edit", click "Rivers".
4. In the "Rivers Overview" window, click "Remove all rivers". Confirm by clicking "Remove".
5. In the "Tools" window, under "Add", click "Rivers".
6. Click anywhere on land.
7. In the "Rivers Overview" window, check the name of the single river that now exists. Remember this name.
8. In the "Tools" window, under "Edit", click "Heightmap".
9. In the "Edit Heightmap" window, click "Risk".
10. In the bottom-right, click "Exit Customization".
11. In the "Tools" window, under "Edit", click "Rivers".
12. Compare the list of rivers with what you saw in step 7.

Expected behavior

Some old rivers are removed, some are altered, and some remain unchanged. No rivers are added.

Actual behaviour

All old rivers are removed, and all rivers are generated from scratch.

.map file

Lania 2026-03-19-22-59.map.zip

System

• Version: v1.113.6
• Browser: Firefox 140.8.0esr (64-bit)
• OS: Linux Debian 12 stable

[Azgaar]

To support it we would need some clever code to restore user's rivers. Can be added, but I'm not sure if anyone want to work on it, this stuff is pretty complicated. Currently we rely on idea of "Risk" sounding too... risky and people avoid using it at all cost. Rivers is not the only area is can mess up your data.

[fwdekker]

Thanks for the reply!

After some (re)consideration, my issue isn't really about "Risk" mode. What I'm really looking for is a way to lock a few selected rivers when regenerating rivers, so that after changing the heightmap in "Keep" mode, I can regenerate all rivers except those that I have added myself for lore reasons.

For example, I have a map with dozens of random rivers and two important canonical rivers. After adding a mountain range in "Keep" mode, the canonical rivers were still fine, but several random rivers just didn't look great anymore. I regenerated the rivers, but unfortunately I then also had to redraw the two canonical rivers.

Do you think this is feasible to implement, or is there also a very significant amount of effort required for this?

[Azgaar]

I think this is hard, rivers in general is the most complex system we have with most changes over time.

[fwdekker]

I see. What if the river generator ignored locked rivers entirely, and worked in a way that pretended locked rivers aren't there? My intent is only to lock a small selection of entirely custom rivers. I don't care too much if they intersect or interfere with the generated rivers.

Or, if the above strays too far from what people expect the lock function to do, maybe a way to easily import/export the rivers? Like, manually export a few rivers to CSV, regenerate rivers normally, then reimport?

For context: My map is for a region in NationStates. Nations come and go, mountain ranges get added, nukes get detonated, rivers get ret-conned in. Our FMG map is already 8 years old, and has many years ahead. I'm looking for a way to permanently add a small of amount rivers (currently: 2) with historical importance to the map, while also being able to change the heightmap every now and then. If you can think of a different kind of workaround for this, please do let me know.

(PS: While writing the above I suddenly realised how long I've been using your amazing editor. As my way of thanks, I started sponsoring you. Please know that my sponsoring is, genuinely, 100% _un_conditional to your response on this issue. I have no expectation or illusion of special treatment. Please don't feel like you "have" to address or prioritise this issue. I'm merely very grateful to you for all the work you have put in.)

[Azgaar]

It's possible, but would required a code change. In theory you can save your rivers layer manually from svg source and re-add when you need it back.

[fwdekker]

The SVG workaround is interesting, but will make it harder to edit other parts of the map based on those rivers. For example adding burgs next to the river, or military excursions. For now I'll stick with manually re-creating the rivers each time the heightmap is edited.

I originally misread your comment and thought you meant I could extract the rivers from the save file and add them back in. (Oops.) I did get relatively far with hacking that in using a script, but there's quite a few references in other parts of the save that point to the rivers, and several parts in the internal logic that make assumptions on the structure of rivers that may no longer apply. So in the end I gave up.

It's probably not useful, but I'll leave my code here anyway, so it feels less bad to say goodbye to it.

My non-working code

MY_RIVERS = ["Hös", "Corridor"];  // List of rivers you want to maintain
SCRIPT_VERSION = "1.113.8";  // Version of the map generator for which this script was written

console.log("Showing alert dialog to user.");
window.alert("This backup tool is experimental and not officially supported by Azgaar. Use at your own risk.");


(function () {
    function confirmUserOperation(message) {
        console.log("Showing confirmation dialog to user.");

        if (!window.confirm(message)) {
            console.log("User operation aborted.");
            return false;
        }

        return true;
    }


    function isString(obj) {
        return typeof obj === "string" || obj instanceof String;
    }

    function isObject(obj) {
        return typeof obj === "object" && !Array.isArray(obj) && obj !== null;
    }

    function parseJson(str) {
        if (!isString(str))
            throw new Error(`Failed to parse JSON. Expected string but got: ${str}`);

        try {
            return JSON.parse(str);
        } catch (exception) {
            throw new Error(`Failed to parse JSON: ${exception}. Expected valid JSON but got: ${str}`)
        }
    }

    function arrayEquals(a, b) {
        if (a === b) return true;
        if (a == null || b == null) return false;
        if (a.length !== b.length) return false;

        for (let i = 0; i < a.length; i++)
            if (a[i] !== b[i])
                return false;

        return true;
    }

    function deepEquals(a, b) {
        if (a === b)
            return true;

        if (a == null || b == null)
            return false;

        if (Array.isArray(a) && Array.isArray(b))
            return arrayEquals(a, b)

        if (typeof a !== "object" || typeof b !== "object")
            return false;

        if (Object.keys(a).length !== Object.keys(b).length)
            return false;

        for (const prop in a)
            if (!b.hasOwnProperty(prop) || !deepEquals(a[prop], b[prop]))
                return false;

        return true;
    }


    function isRiver(obj) {
        return isObject(obj) && "type" in obj && "source" in obj && "basin" in obj && "width" in obj && "name" in obj;
    }

    function parseRivers(jsonString) {
        const rivers = parseJson(jsonString);

        if (!Array.isArray(rivers))
            throw new Error(`Expected array but got: ${jsonString}`);

        for (const river of rivers)
            if (!isRiver(river))
                throw new Error(`Expected river but got: ${JSON.stringify(river)}`);

        if ((new Set(rivers.map(it => it.i))).size !== rivers.length)
            throw new Error(`Duplicate river identifiers: ${JSON.stringify(rivers)}`);

        return rivers;
    }

    function getMapRivers(map) {
        return parseRivers(map.mapData[32]);
    }

    function insertRivers(map, newRivers) {
        const oldRivers = getMapRivers(map);

        // Determine course of action for each new river
        const deletions = new Set();  // Contains `oldRiver.i`
        const insertions = new Set();  // Contains `newRiver.i`
        newRiverLoop: for (const newRiver of newRivers) {
            for (const oldRiver of oldRivers) {
                const newRiverCopy = structuredClone(newRiver);
                newRiverCopy.name = oldRiver.name;
                const same = deepEquals(oldRiver, newRiverCopy);
                if (same && oldRiver.name === newRiver.name) {
                    console.log(
                        `River with name '${newRiver.name}' with exactly identical properties already exists. ` +
                        `Not importing.`
                    );
                    continue newRiverLoop;
                }

                const intersection = (new Set(oldRiver.cells)).intersection(new Set(newRiver.cells)).size;
                if (!same && intersection === 0) continue;

                let preamble;
                if (same)
                    preamble =
                        `Existing river with name '${oldRiver.name}' is exactly identical to ` +
                        `imported river '${newRiver.name}'. `;
                else
                    preamble =
                        `Existing river with name '${oldRiver.name}' overlaps with imported river '${newRiver.name}' ` +
                        `in ${intersection}/${oldRiver.cells.length} of '${oldRiver.name}' cells and ` +
                        `${intersection}/${newRiver.cells.length} of '${newRiver.name}' cells. `;

                const keepBothRivers =
                    preamble +
                    `Choose 'OK' to import the new river, resulting in both rivers on the map. ` +
                    `Choose 'Cancel' to get the choice between which river you want to keep.`
                const keepNewRiverOnly =
                    preamble +
                    `Press 'OK' to keep the new river, '${newRiver.name}'. ` +
                    `Press 'Cancel' to keep the old river, '${oldRiver.name}'.`

                if (window.confirm(keepBothRivers)) {
                    // Keep both rivers; for now, do nothing
                } else if (window.confirm(keepNewRiverOnly)) {
                    // Keep only new river
                    deletions.add(oldRiver.i);
                } else {
                    // Keep only old river
                    continue newRiverLoop;
                }
            }

            insertions.add(newRiver.i);
        }

        // Delete old rivers
        Array.from(deletions)
            .map(i => oldRivers.findIndex(it => it.i === i))
            .sort()
            .reverse()
            .forEach(idx => {
                const oldRiver = oldRivers[idx];
                oldRivers.splice(idx, 1);
                console.log(`Deleted old river #${oldRiver.i} ('${oldRiver[idx].name}').`)
            });

        // Insert new rivers
        const insertedRivers = Array.from(insertions)
            .map(i => newRivers.find(it => it.i === i))
            .sort()
            .reduce((acc, newRiver) => {
                const oldId = newRiver.i;
                const newId = Rivers.getNextId(oldRivers);

                newRiver.i = newId;
                newRiver.basin = newId;
                newRiver.source = newId;
                oldRivers.push(newRiver);

                acc[oldId] = newId;

                console.log(
                    `Inserted river #${oldId} -> #${newId} ('${newRiver.name}'). ` +
                    `Setting basin to point to itself.`,
                    newRiver
                );
                return acc;
            }, {});

        map.mapData[32] = JSON.stringify(oldRivers);
        cleanRiverCells(map);
        return insertedRivers;
    }

    function cleanRiverCells(map) {
        const rivers = getMapRivers(map)
            .reduce((acc, river) => {
                    acc[river.i] = river;
                    return acc;
                },
                {}
            );
        const riverCells = Uint16Array.from(map.mapData[22].split(","));

        for (let cellIdx = 0; cellIdx < riverCells.length; cellIdx++) {
            const riverCell = riverCells[cellIdx];

            if (riverCell !== 0)
                if (rivers[riverCell].cells.includes(cellIdx))
                    continue;

            const winner = Object.entries(rivers).find(([_, river]) => river.cells.includes(cellIdx));
            if (winner !== undefined) {
                console.log(`Correcting cell-to-river pointer #${riverCell} -> #${winner[0]}.`);
                riverCells[cellIdx] = winner.i;
            }
        }

        map.mapData[22] = riverCells.join(",");
    }


    function isNote(obj) {
        return isObject(obj) && "id" in obj && "name" in obj && "legend" in obj;
    }

    function parseNotes(jsonString) {
        const notes = parseJson(jsonString);

        if (!Array.isArray(notes))
            throw new Error(`Expected array but got: ${jsonString}`);

        for (const note of notes)
            if (!isNote(note))
                throw new Error(`Expected note but got: ${JSON.stringify(note)}`);

        return notes;
    }

    function getMapNotes(map) {
        if (!map.mapData[4]) return [];

        return parseNotes(map.mapData[4]);
    }

    function renumberNotes(map, backedUpNotes, insertedRivers) {
        const currentNotes = getMapNotes(map);

        // Delete all current river notes
        for (let i = currentNotes.length - 1; i--; i >= 0)
            if (currentNotes[i].id.startsWith("river"))
                currentNotes.splice(i, 1);

        // Rename and insert notes
        for (const backedUpNote of backedUpNotes) {
            for (const [oldId, newId] of Object.entries(insertedRivers)) {
                if (backedUpNote.id === `river${oldId}`) {
                    backedUpNote.id = `river${newId}`;
                    currentNotes.push(backedUpNote);
                    console.log(`Restored note for river #${oldId} -> #${newId}.`);
                    break;
                }
            }
        }

        map.mapData[4] = JSON.stringify(currentNotes);
    }


    async function getParsedMap() {
        const mapData = prepareMapData();
        const mapDataBuffer = (new TextEncoder()).encode(mapData).buffer;
        return await parseLoadedResult(mapDataBuffer);
    }

    async function setParsedMap(parsedMap) {
        await parseLoadedData(parsedMap.mapData, parsedMap.mapVersion);
    }

    function confirmMapVersion(parsedMap) {
        return parsedMap.mapVersion === SCRIPT_VERSION || confirmUserOperation(
            `This script was written for map generator v${SCRIPT_VERSION}, ` +
            `but you are running map generator v${parsedMap.mapVersion}. ` +
            `Continue anyway?`
        );
    }


    async function createBackup(riverNames) {
        const parsedMap = await getParsedMap();
        if (!confirmMapVersion(parsedMap)) return;

        const parsedRivers = getMapRivers(parsedMap);
        const backedUpRivers = parsedRivers.filter(it => riverNames.includes(it.name));
        if (backedUpRivers.length !== riverNames.length && !confirmUserOperation(
            `Expected ${riverNames.length} rivers (${JSON.stringify(riverNames)}), ` +
            `but found ${backedUpRivers.length} rivers (${JSON.stringify(backedUpRivers.map(it => it.name))}). ` +
            `Continue anyway?`
        )) return;

        const parsedNotes = getMapNotes(parsedMap);
        const backedUpNotes = parsedNotes.filter(note => backedUpRivers.some(river => note.id.startsWith(`river${river.i}`)));

        const backup = {"rivers": JSON.stringify(backedUpRivers), "notes": JSON.stringify(backedUpNotes)};
        console.log("Successfully created backup.", backup);
        return backup;
    }

    async function restoreBackup(backup) {
        const parsedMap = await getParsedMap();
        if (!confirmMapVersion(parsedMap)) return;

        const insertedRivers = insertRivers(parsedMap, parseRivers(backup.rivers));
        const insertedRiversSize = Object.entries(insertedRivers).length;
        if (insertedRiversSize === 0) {
            console.log("Successfully restored 0 rivers.");
            return;
        }

        renumberNotes(parsedMap, parseNotes(backup.notes), insertedRivers);

        await setParsedMap(parsedMap);
        console.log(`Successfully restored ${insertedRiversSize} rivers.`);
    }


    window.createBackup = async () => window.MY_BACKUP = await createBackup(MY_RIVERS)
    window.restoreBackup = async () => await restoreBackup(window.MY_BACKUP);
})();