mirror of
https://github.com/Azgaar/Fantasy-Map-Generator.git
synced 2025-12-18 10:01:23 +01:00
Significant work done porting to headless engine
This commit is contained in:
barrulus
parent
ab08dc9429
commit
d1b07fff01
573 changed files with 50603 additions and 0 deletions
84
procedural/src/default_prompt.md
Normal file
84
procedural/src/default_prompt.md
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
# cultures-generator.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `cultures-generator.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./cultures-generator.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./cultures-generator_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in cultures-generator_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into cultures-generator_render.md
|
||||
100
procedural/src/engine/main.js
Normal file
100
procedural/src/engine/main.js
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
// src/engine/main.js
|
||||
|
||||
// Import all the refactored engine modules
|
||||
import * as Biomes from "./modules/biomes.js";
|
||||
import * as BurgsAndStates from "./modules/burgs-and-states.js";
|
||||
import * as COA from "./modules/coa-generator.js";
|
||||
import * as COArenderer from "./modules/coa-renderer.js";
|
||||
import * as Cultures from "./modules/cultures-generator.js";
|
||||
import * as Features from "./modules/features.js";
|
||||
import * as Heightmap from "./modules/heightmap-generator.js";
|
||||
import * as Lakes from "./modules/lakes.js";
|
||||
import * as Markers from "./modules/markers-generator.js";
|
||||
import * as Military from "./modules/military-generator.js";
|
||||
import * as Names from "./modules/names-generator.js";
|
||||
import * as Provinces from "./modules/provinces-generator.js";
|
||||
import * as Religions from "./modules/religions-generator.js";
|
||||
import * as Rivers from "./modules/river-generator.js";
|
||||
import * as Routes from "./modules/routes-generator.js";
|
||||
import * as Zones from "./modules/zones-generator.js";
|
||||
import { Voronoi } from "./modules/voronoi.js";
|
||||
import * as Utils from "./utils/index.js";
|
||||
|
||||
// Import the new utility modules
|
||||
import * as Graph from "./utils/graphUtils.js";
|
||||
import * as Geography from "./utils/geography.js";
|
||||
import * as Cell from "./utils/cell.js";
|
||||
|
||||
/**
|
||||
* The main entry point for the headless map generation engine.
|
||||
* @param {object} config - A comprehensive configuration object.
|
||||
* @returns {object} An object containing the complete generated map data { grid, pack, notes, etc. }.
|
||||
*/
|
||||
export function generate(config) {
|
||||
const timeStart = performance.now();
|
||||
const { TIME, WARN, INFO, ERROR } = Utils; // Core logging utils
|
||||
|
||||
// Set up PRNG
|
||||
const seed = config.seed || Utils.generateSeed();
|
||||
Math.random = Utils.aleaPRNG(seed);
|
||||
INFO && console.group("Generating Map with Seed: " + seed);
|
||||
|
||||
// --- Grid Generation ---
|
||||
let grid = Graph.generateGrid(config.graph);
|
||||
grid.cells.h = Heightmap.generate(grid, config.heightmap, Utils);
|
||||
grid = Features.markupGrid(grid, config, Utils);
|
||||
const { mapCoordinates } = Geography.defineMapSize(grid, config.map);
|
||||
grid = Geography.addLakesInDeepDepressions(grid, config.lakes, Utils);
|
||||
grid = Geography.openNearSeaLakes(grid, config.lakes, Utils);
|
||||
|
||||
// --- Core Data Calculation ---
|
||||
const { temp } = Geography.calculateTemperatures(grid, mapCoordinates, config.temperature, Utils);
|
||||
grid.cells.temp = temp;
|
||||
const { prec } = Geography.generatePrecipitation(grid, mapCoordinates, config.precipitation, Utils);
|
||||
grid.cells.prec = prec;
|
||||
|
||||
// --- Pack Generation ---
|
||||
let pack = Graph.reGraph(grid, Utils);
|
||||
pack = Features.markupPack(pack, config, Utils, { Lakes });
|
||||
|
||||
// --- River Generation ---
|
||||
const riverGenerationResult = Rivers.generate(pack, grid, config.rivers, Utils, { Lakes, Names });
|
||||
pack = riverGenerationResult.pack;
|
||||
|
||||
// --- Biome and Population ---
|
||||
const { biome } = Biomes.define(pack, grid, config.biomes, Utils);
|
||||
pack.cells.biome = biome;
|
||||
const { s, pop } = Cell.rankCells(pack, grid, Utils, { biomesData: Biomes.getDefault() });
|
||||
pack.cells.s = s;
|
||||
pack.cells.pop = pop;
|
||||
|
||||
// --- Cultures, States, and Burgs ---
|
||||
const culturesResult = Cultures.generate(pack, grid, config.cultures, Utils, { Names });
|
||||
pack.cultures = culturesResult.cultures;
|
||||
pack.cells.culture = culturesResult.culture;
|
||||
Cultures.expand(pack, config.cultures, Utils, { biomesData: Biomes.getDefault() });
|
||||
|
||||
const burgsAndStatesResult = BurgsAndStates.generate(pack, grid, config.burgs, Utils, { Names, COA, getPolesOfInaccessibility: Utils.getPolesOfInaccessibility });
|
||||
pack.burgs = burgsAndStatesResult.burgs;
|
||||
pack.states = burgsAndStatesResult.states;
|
||||
pack.cells.burg = burgsAndStatesResult.cells.burg;
|
||||
pack.cells.state = burgsAndStatesResult.cells.state;
|
||||
|
||||
// --- Final Touches ---
|
||||
// Routes.generate(pack, Utils);
|
||||
// Religions.generate(pack, config.religions, Utils, { Names, BurgsAndStates });
|
||||
// BurgsAndStates.defineStateForms(null, pack, Utils, { Names });
|
||||
// Provinces.generate(pack, config.provinces, Utils, { BurgsAndStates, Names, COA });
|
||||
// BurgsAndStates.defineBurgFeatures(null, pack, Utils);
|
||||
// Rivers.specify(pack, Utils, { Names });
|
||||
// Features.specify(pack, grid, Utils, { Lakes });
|
||||
// Military.generate(pack, config.military, Utils, { Names });
|
||||
// Markers.generate(pack, config.markers, Utils);
|
||||
// Zones.generate(pack, config.zones, Utils);
|
||||
|
||||
WARN && console.warn(`TOTAL GENERATION TIME: ${Utils.rn((performance.now() - timeStart) / 1000, 2)}s`);
|
||||
INFO && console.groupEnd("Generated Map " + seed);
|
||||
|
||||
// Return all the generated data
|
||||
return { seed, grid, pack, mapCoordinates };
|
||||
}
|
||||
129
procedural/src/engine/modules/biomes.js
Normal file
129
procedural/src/engine/modules/biomes.js
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
"use strict";
|
||||
|
||||
const MIN_LAND_HEIGHT = 20;
|
||||
|
||||
export const getDefault = () => {
|
||||
const name = [
|
||||
"Marine",
|
||||
"Hot desert",
|
||||
"Cold desert",
|
||||
"Savanna",
|
||||
"Grassland",
|
||||
"Tropical seasonal forest",
|
||||
"Temperate deciduous forest",
|
||||
"Tropical rainforest",
|
||||
"Temperate rainforest",
|
||||
"Taiga",
|
||||
"Tundra",
|
||||
"Glacier",
|
||||
"Wetland"
|
||||
];
|
||||
|
||||
const color = [
|
||||
"#466eab",
|
||||
"#fbe79f",
|
||||
"#b5b887",
|
||||
"#d2d082",
|
||||
"#c8d68f",
|
||||
"#b6d95d",
|
||||
"#29bc56",
|
||||
"#7dcb35",
|
||||
"#409c43",
|
||||
"#4b6b32",
|
||||
"#96784b",
|
||||
"#d5e7eb",
|
||||
"#0b9131"
|
||||
];
|
||||
const habitability = [0, 4, 10, 22, 30, 50, 100, 80, 90, 12, 4, 0, 12];
|
||||
const iconsDensity = [0, 3, 2, 120, 120, 120, 120, 150, 150, 100, 5, 0, 250];
|
||||
const icons = [
|
||||
{},
|
||||
{dune: 3, cactus: 6, deadTree: 1},
|
||||
{dune: 9, deadTree: 1},
|
||||
{acacia: 1, grass: 9},
|
||||
{grass: 1},
|
||||
{acacia: 8, palm: 1},
|
||||
{deciduous: 1},
|
||||
{acacia: 5, palm: 3, deciduous: 1, swamp: 1},
|
||||
{deciduous: 6, swamp: 1},
|
||||
{conifer: 1},
|
||||
{grass: 1},
|
||||
{},
|
||||
{swamp: 1}
|
||||
];
|
||||
const cost = [10, 200, 150, 60, 50, 70, 70, 80, 90, 200, 1000, 5000, 150]; // biome movement cost
|
||||
const biomesMartix = [
|
||||
// hot ” cold [>19°C; <-4°C]; dry • wet
|
||||
new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10]),
|
||||
new Uint8Array([3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 10, 10])
|
||||
];
|
||||
|
||||
// parse icons weighted array into a simple array
|
||||
for (let i = 0; i < icons.length; i++) {
|
||||
const parsed = [];
|
||||
for (const icon in icons[i]) {
|
||||
for (let j = 0; j < icons[i][icon]; j++) {
|
||||
parsed.push(icon);
|
||||
}
|
||||
}
|
||||
icons[i] = parsed;
|
||||
}
|
||||
|
||||
return {i: Array.from({length: name.length}, (_, i) => i), name, color, biomesMartix, habitability, iconsDensity, icons, cost};
|
||||
};
|
||||
|
||||
// assign biome id for each cell
|
||||
export function define(pack, grid, config, utils) {
|
||||
const {TIME, d3, rn} = utils;
|
||||
TIME && console.time("defineBiomes");
|
||||
|
||||
const {fl: flux, r: riverIds, h: heights, c: neighbors, g: gridReference} = pack.cells;
|
||||
const {temp, prec} = grid.cells;
|
||||
const biome = new Uint8Array(pack.cells.i.length); // biomes array
|
||||
const biomesData = getDefault();
|
||||
|
||||
for (let cellId = 0; cellId < heights.length; cellId++) {
|
||||
const height = heights[cellId];
|
||||
const moisture = height < MIN_LAND_HEIGHT ? 0 : calculateMoisture(cellId);
|
||||
const temperature = temp[gridReference[cellId]];
|
||||
biome[cellId] = getId(moisture, temperature, height, Boolean(riverIds[cellId]), biomesData);
|
||||
}
|
||||
|
||||
function calculateMoisture(cellId) {
|
||||
let moisture = prec[gridReference[cellId]];
|
||||
if (riverIds[cellId]) moisture += Math.max(flux[cellId] / 10, 2);
|
||||
|
||||
const moistAround = neighbors[cellId]
|
||||
.filter(neibCellId => heights[neibCellId] >= MIN_LAND_HEIGHT)
|
||||
.map(c => prec[gridReference[c]])
|
||||
.concat([moisture]);
|
||||
return rn(4 + d3.mean(moistAround));
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("defineBiomes");
|
||||
return {biome};
|
||||
}
|
||||
|
||||
export function getId(moisture, temperature, height, hasRiver, biomesData = null) {
|
||||
const data = biomesData || getDefault();
|
||||
|
||||
if (height < 20) return 0; // all water cells: marine biome
|
||||
if (temperature < -5) return 11; // too cold: permafrost biome
|
||||
if (temperature >= 25 && !hasRiver && moisture < 8) return 1; // too hot and dry: hot desert biome
|
||||
if (isWetland(moisture, temperature, height)) return 12; // too wet: wetland biome
|
||||
|
||||
// in other cases use biome matrix
|
||||
const moistureBand = Math.min((moisture / 5) | 0, 4); // [0-4]
|
||||
const temperatureBand = Math.min(Math.max(20 - temperature, 0), 25); // [0-25]
|
||||
return data.biomesMartix[moistureBand][temperatureBand];
|
||||
}
|
||||
|
||||
function isWetland(moisture, temperature, height) {
|
||||
if (temperature <= -2) return false; // too cold
|
||||
if (moisture > 40 && height < 25) return true; // near coast
|
||||
if (moisture > 24 && height > 24 && height < 60) return true; // off coast
|
||||
return false;
|
||||
}
|
||||
893
procedural/src/engine/modules/burgs-and-states.js
Normal file
893
procedural/src/engine/modules/burgs-and-states.js
Normal file
|
|
@ -0,0 +1,893 @@
|
|||
"use strict";
|
||||
|
||||
export const generate = (pack, grid, config, utils) => {
|
||||
|
||||
const {cells, cultures} = pack;
|
||||
const n = cells.i.length;
|
||||
|
||||
const newCells = {...cells, burg: new Uint16Array(n)};
|
||||
const newPack = {...pack, cells: newCells};
|
||||
|
||||
const burgs = placeCapitals(newPack, grid, config, utils);
|
||||
const states = createStates(newPack, burgs, config, utils);
|
||||
|
||||
placeTowns(newPack, burgs, grid, config, utils);
|
||||
expandStates(newPack, grid, config, utils);
|
||||
normalizeStates(newPack, utils);
|
||||
getPoles(newPack, utils);
|
||||
|
||||
specifyBurgs(newPack, grid, utils);
|
||||
|
||||
collectStatistics(newPack);
|
||||
assignColors(newPack, utils);
|
||||
|
||||
generateCampaigns(newPack, utils);
|
||||
generateDiplomacy(newPack, utils);
|
||||
|
||||
return {
|
||||
burgs: newPack.burgs,
|
||||
states: newPack.states,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
burg: newPack.cells.burg,
|
||||
state: newPack.cells.state
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
function placeCapitals(pack, grid, config, utils) {
|
||||
const {TIME, WARN, d3, graphWidth, graphHeight} = utils;
|
||||
TIME && console.time("placeCapitals");
|
||||
let count = config.statesNumber;
|
||||
let burgs = [0];
|
||||
|
||||
const {cells} = pack;
|
||||
const rand = () => 0.5 + Math.random() * 0.5;
|
||||
const score = new Int16Array(cells.s.map(s => s * rand())); // cell score for capitals placement
|
||||
const sorted = cells.i.filter(i => score[i] > 0 && cells.culture[i]).sort((a, b) => score[b] - score[a]); // filtered and sorted array of indexes
|
||||
|
||||
if (sorted.length < count * 10) {
|
||||
count = Math.floor(sorted.length / 10);
|
||||
if (!count) {
|
||||
WARN && console.warn("There is no populated cells. Cannot generate states");
|
||||
return burgs;
|
||||
} else {
|
||||
WARN && console.warn(`Not enough populated cells (${sorted.length}). Will generate only ${count} states`);
|
||||
}
|
||||
}
|
||||
|
||||
let burgsTree = d3.quadtree();
|
||||
let spacing = (graphWidth + graphHeight) / 2 / count; // min distance between capitals
|
||||
|
||||
for (let i = 0; burgs.length <= count; i++) {
|
||||
const cell = sorted[i];
|
||||
const [x, y] = cells.p[cell];
|
||||
|
||||
if (burgsTree.find(x, y, spacing) === undefined) {
|
||||
burgs.push({cell, x, y});
|
||||
burgsTree.add([x, y]);
|
||||
}
|
||||
|
||||
if (i === sorted.length - 1) {
|
||||
WARN && console.warn("Cannot place capitals with current spacing. Trying again with reduced spacing");
|
||||
burgsTree = d3.quadtree();
|
||||
i = -1;
|
||||
burgs = [0];
|
||||
spacing /= 1.2;
|
||||
}
|
||||
}
|
||||
|
||||
burgs[0] = burgsTree;
|
||||
TIME && console.timeEnd("placeCapitals");
|
||||
return burgs;
|
||||
}
|
||||
|
||||
// For each capital create a state
|
||||
function createStates(pack, burgs, config, utils) {
|
||||
const {TIME, rn, each, Names, COA, getColors} = utils;
|
||||
TIME && console.time("createStates");
|
||||
const {cells, cultures} = pack;
|
||||
const states = [{i: 0, name: "Neutrals"}];
|
||||
const colors = getColors(burgs.length - 1);
|
||||
const each5th = each(5);
|
||||
|
||||
burgs.forEach((b, i) => {
|
||||
if (!i) return; // skip first element
|
||||
|
||||
// burgs data
|
||||
b.i = b.state = i;
|
||||
b.culture = cells.culture[b.cell];
|
||||
b.name = Names.getCultureShort(b.culture);
|
||||
b.feature = cells.f[b.cell];
|
||||
b.capital = 1;
|
||||
|
||||
// states data
|
||||
const expansionism = rn(Math.random() * config.sizeVariety + 1, 1);
|
||||
const basename = b.name.length < 9 && each5th(b.cell) ? b.name : Names.getCultureShort(b.culture);
|
||||
const name = Names.getState(basename, b.culture);
|
||||
const type = cultures[b.culture].type;
|
||||
|
||||
const coa = COA.generate(null, null, null, type);
|
||||
coa.shield = COA.getShield(b.culture, null);
|
||||
states.push({
|
||||
i,
|
||||
color: colors[i - 1],
|
||||
name,
|
||||
expansionism,
|
||||
capital: i,
|
||||
type,
|
||||
center: b.cell,
|
||||
culture: b.culture,
|
||||
coa
|
||||
});
|
||||
cells.burg[b.cell] = i;
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("createStates");
|
||||
return states;
|
||||
}
|
||||
|
||||
// place secondary settlements based on geo and economical evaluation
|
||||
function placeTowns(pack, burgs, grid, config, utils) {
|
||||
const {TIME, ERROR, rn, gauss, Names, graphWidth, graphHeight} = utils;
|
||||
TIME && console.time("placeTowns");
|
||||
const {cells} = pack;
|
||||
const score = new Int16Array(cells.s.map(s => s * gauss(1, 3, 0, 20, 3))); // a bit randomized cell score for towns placement
|
||||
const sorted = cells.i
|
||||
.filter(i => !cells.burg[i] && score[i] > 0 && cells.culture[i])
|
||||
.sort((a, b) => score[b] - score[a]); // filtered and sorted array of indexes
|
||||
|
||||
const desiredNumber =
|
||||
config.manorsInput == 1000
|
||||
? rn(sorted.length / 5 / (grid.points.length / 10000) ** 0.8)
|
||||
: config.manorsInput;
|
||||
const burgsNumber = Math.min(desiredNumber, sorted.length); // towns to generate
|
||||
let burgsAdded = 0;
|
||||
|
||||
const burgsTree = burgs[0];
|
||||
let spacing = (graphWidth + graphHeight) / 150 / (burgsNumber ** 0.7 / 66); // min distance between towns
|
||||
|
||||
while (burgsAdded < burgsNumber && spacing > 1) {
|
||||
for (let i = 0; burgsAdded < burgsNumber && i < sorted.length; i++) {
|
||||
if (cells.burg[sorted[i]]) continue;
|
||||
const cell = sorted[i];
|
||||
const [x, y] = cells.p[cell];
|
||||
const s = spacing * gauss(1, 0.3, 0.2, 2, 2); // randomize to make placement not uniform
|
||||
if (burgsTree.find(x, y, s) !== undefined) continue; // to close to existing burg
|
||||
const burg = burgs.length;
|
||||
const culture = cells.culture[cell];
|
||||
const name = Names.getCulture(culture);
|
||||
burgs.push({cell, x, y, state: 0, i: burg, culture, name, capital: 0, feature: cells.f[cell]});
|
||||
burgsTree.add([x, y]);
|
||||
cells.burg[cell] = burg;
|
||||
burgsAdded++;
|
||||
}
|
||||
spacing *= 0.5;
|
||||
}
|
||||
|
||||
if (config.manorsInput != 1000 && burgsAdded < desiredNumber) {
|
||||
ERROR && console.error(`Cannot place all burgs. Requested ${desiredNumber}, placed ${burgsAdded}`);
|
||||
}
|
||||
|
||||
burgs[0] = {name: undefined}; // do not store burgsTree anymore
|
||||
TIME && console.timeEnd("placeTowns");
|
||||
}
|
||||
|
||||
// define burg coordinates, coa, port status and define details
|
||||
export const specifyBurgs = (pack, grid, utils) => {
|
||||
const {TIME, rn, gauss, P, COA} = utils;
|
||||
TIME && console.time("specifyBurgs");
|
||||
const {cells, features} = pack;
|
||||
const temp = grid.cells.temp;
|
||||
|
||||
for (const b of pack.burgs) {
|
||||
if (!b.i || b.lock) continue;
|
||||
const i = b.cell;
|
||||
|
||||
// asign port status to some coastline burgs with temp > 0 °C
|
||||
const haven = cells.haven[i];
|
||||
if (haven && temp[cells.g[i]] > 0) {
|
||||
const f = cells.f[haven]; // water body id
|
||||
// port is a capital with any harbor OR town with good harbor
|
||||
const port = features[f].cells > 1 && ((b.capital && cells.harbor[i]) || cells.harbor[i] === 1);
|
||||
b.port = port ? f : 0; // port is defined by water body id it lays on
|
||||
} else b.port = 0;
|
||||
|
||||
// define burg population (keep urbanization at about 10% rate)
|
||||
b.population = rn(Math.max(cells.s[i] / 8 + b.i / 1000 + (i % 100) / 1000, 0.1), 3);
|
||||
if (b.capital) b.population = rn(b.population * 1.3, 3); // increase capital population
|
||||
|
||||
if (b.port) {
|
||||
b.population = b.population * 1.3; // increase port population
|
||||
const [x, y] = getCloseToEdgePoint(i, haven, pack, utils);
|
||||
b.x = x;
|
||||
b.y = y;
|
||||
}
|
||||
|
||||
// add random factor
|
||||
b.population = rn(b.population * gauss(2, 3, 0.6, 20, 3), 3);
|
||||
|
||||
// shift burgs on rivers semi-randomly and just a bit
|
||||
if (!b.port && cells.r[i]) {
|
||||
const shift = Math.min(cells.fl[i] / 150, 1);
|
||||
if (i % 2) b.x = rn(b.x + shift, 2);
|
||||
else b.x = rn(b.x - shift, 2);
|
||||
if (cells.r[i] % 2) b.y = rn(b.y + shift, 2);
|
||||
else b.y = rn(b.y - shift, 2);
|
||||
}
|
||||
|
||||
// define emblem
|
||||
const state = pack.states[b.state];
|
||||
const stateCOA = state.coa;
|
||||
let kinship = 0.25;
|
||||
if (b.capital) kinship += 0.1;
|
||||
else if (b.port) kinship -= 0.1;
|
||||
if (b.culture !== state.culture) kinship -= 0.25;
|
||||
b.type = getType(i, b.port, pack, utils);
|
||||
const type = b.capital && P(0.2) ? "Capital" : b.type === "Generic" ? "City" : b.type;
|
||||
b.coa = COA.generate(stateCOA, kinship, null, type);
|
||||
b.coa.shield = COA.getShield(b.culture, b.state);
|
||||
}
|
||||
|
||||
// de-assign port status if it's the only one on feature
|
||||
const ports = pack.burgs.filter(b => !b.removed && b.port > 0);
|
||||
for (const f of features) {
|
||||
if (!f.i || f.land || f.border) continue;
|
||||
const featurePorts = ports.filter(b => b.port === f.i);
|
||||
if (featurePorts.length === 1) featurePorts[0].port = 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("specifyBurgs");
|
||||
};
|
||||
|
||||
export function getCloseToEdgePoint(cell1, cell2, pack, utils) {
|
||||
const {cells, vertices} = pack;
|
||||
const {rn} = utils;
|
||||
|
||||
const [x0, y0] = cells.p[cell1];
|
||||
|
||||
const commonVertices = cells.v[cell1].filter(vertex => vertices.c[vertex].some(cell => cell === cell2));
|
||||
const [x1, y1] = vertices.p[commonVertices[0]];
|
||||
const [x2, y2] = vertices.p[commonVertices[1]];
|
||||
const xEdge = (x1 + x2) / 2;
|
||||
const yEdge = (y1 + y2) / 2;
|
||||
|
||||
const x = rn(x0 + 0.95 * (xEdge - x0), 2);
|
||||
const y = rn(y0 + 0.95 * (yEdge - y0), 2);
|
||||
|
||||
return [x, y];
|
||||
}
|
||||
|
||||
export const getType = (cellId, port, pack, utils) => {
|
||||
const {cells, features, burgs} = pack;
|
||||
|
||||
if (port) return "Naval";
|
||||
|
||||
const haven = cells.haven[cellId];
|
||||
if (haven !== undefined && features[cells.f[haven]].type === "lake") return "Lake";
|
||||
|
||||
if (cells.h[cellId] > 60) return "Highland";
|
||||
|
||||
if (cells.r[cellId] && cells.fl[cellId] >= 100) return "River";
|
||||
|
||||
const biome = cells.biome[cellId];
|
||||
const population = cells.pop[cellId];
|
||||
if (!cells.burg[cellId] || population <= 5) {
|
||||
if (population < 5 && [1, 2, 3, 4].includes(biome)) return "Nomadic";
|
||||
if (biome > 4 && biome < 10) return "Hunting";
|
||||
}
|
||||
|
||||
return "Generic";
|
||||
};
|
||||
|
||||
export const defineBurgFeatures = (burg, pack, utils) => {
|
||||
const {P} = utils;
|
||||
const {cells} = pack;
|
||||
|
||||
pack.burgs
|
||||
.filter(b => (burg ? b.i == burg.i : b.i && !b.removed && !b.lock))
|
||||
.forEach(b => {
|
||||
const pop = b.population;
|
||||
b.citadel = Number(b.capital || (pop > 50 && P(0.75)) || (pop > 15 && P(0.5)) || P(0.1));
|
||||
b.plaza = Number(pop > 20 || (pop > 10 && P(0.8)) || (pop > 4 && P(0.7)) || P(0.6));
|
||||
b.walls = Number(b.capital || pop > 30 || (pop > 20 && P(0.75)) || (pop > 10 && P(0.5)) || P(0.1));
|
||||
b.shanty = Number(pop > 60 || (pop > 40 && P(0.75)) || (pop > 20 && b.walls && P(0.4)));
|
||||
const religion = cells.religion[b.cell];
|
||||
const theocracy = pack.states[b.state].form === "Theocracy";
|
||||
b.temple = Number(
|
||||
(religion && theocracy && P(0.5)) || pop > 50 || (pop > 35 && P(0.75)) || (pop > 20 && P(0.5))
|
||||
);
|
||||
});
|
||||
};
|
||||
|
||||
// expand cultures across the map (Dijkstra-like algorithm)
|
||||
export const expandStates = (pack, grid, config, utils) => {
|
||||
const {TIME, FlatQueue, minmax, biomesData} = utils;
|
||||
TIME && console.time("expandStates");
|
||||
const {cells, states, cultures, burgs} = pack;
|
||||
|
||||
cells.state = cells.state || new Uint16Array(cells.i.length);
|
||||
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
const globalGrowthRate = config.growthRate || 1;
|
||||
const statesGrowthRate = config.statesGrowthRate || 1;
|
||||
const growthRate = (cells.i.length / 2) * globalGrowthRate * statesGrowthRate; // limit cost for state growth
|
||||
|
||||
// remove state from all cells except of locked
|
||||
for (const cellId of cells.i) {
|
||||
const state = states[cells.state[cellId]];
|
||||
if (state.lock) continue;
|
||||
cells.state[cellId] = 0;
|
||||
}
|
||||
|
||||
for (const state of states) {
|
||||
if (!state.i || state.removed) continue;
|
||||
|
||||
const capitalCell = burgs[state.capital].cell;
|
||||
cells.state[capitalCell] = state.i;
|
||||
const cultureCenter = cultures[state.culture].center;
|
||||
const b = cells.biome[cultureCenter]; // state native biome
|
||||
queue.push({e: state.center, p: 0, s: state.i, b}, 0);
|
||||
cost[state.center] = 1;
|
||||
}
|
||||
|
||||
while (queue.length) {
|
||||
const next = queue.pop();
|
||||
|
||||
const {e, p, s, b} = next;
|
||||
const {type, culture} = states[s];
|
||||
|
||||
cells.c[e].forEach(e => {
|
||||
const state = states[cells.state[e]];
|
||||
if (state.lock) return; // do not overwrite cell of locked states
|
||||
if (cells.state[e] && e === state.center) return; // do not overwrite capital cells
|
||||
|
||||
const cultureCost = culture === cells.culture[e] ? -9 : 100;
|
||||
const populationCost = cells.h[e] < 20 ? 0 : cells.s[e] ? Math.max(20 - cells.s[e], 0) : 5000;
|
||||
const biomeCost = getBiomeCost(b, cells.biome[e], type);
|
||||
const heightCost = getHeightCost(pack.features[cells.f[e]], cells.h[e], type);
|
||||
const riverCost = getRiverCost(cells.r[e], e, type);
|
||||
const typeCost = getTypeCost(cells.t[e], type);
|
||||
const cellCost = Math.max(cultureCost + populationCost + biomeCost + heightCost + riverCost + typeCost, 0);
|
||||
const totalCost = p + 10 + cellCost / states[s].expansionism;
|
||||
|
||||
if (totalCost > growthRate) return;
|
||||
|
||||
if (!cost[e] || totalCost < cost[e]) {
|
||||
if (cells.h[e] >= 20) cells.state[e] = s; // assign state to cell
|
||||
cost[e] = totalCost;
|
||||
queue.push({e, p: totalCost, s, b}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
burgs.filter(b => b.i && !b.removed).forEach(b => (b.state = cells.state[b.cell])); // assign state to burgs
|
||||
|
||||
function getBiomeCost(b, biome, type) {
|
||||
if (b === biome) return 10; // tiny penalty for native biome
|
||||
if (type === "Hunting") return biomesData.cost[biome] * 2; // non-native biome penalty for hunters
|
||||
if (type === "Nomadic" && biome > 4 && biome < 10) return biomesData.cost[biome] * 3; // forest biome penalty for nomads
|
||||
return biomesData.cost[biome]; // general non-native biome penalty
|
||||
}
|
||||
|
||||
function getHeightCost(f, h, type) {
|
||||
if (type === "Lake" && f.type === "lake") return 10; // low lake crossing penalty for Lake cultures
|
||||
if (type === "Naval" && h < 20) return 300; // low sea crossing penalty for Navals
|
||||
if (type === "Nomadic" && h < 20) return 10000; // giant sea crossing penalty for Nomads
|
||||
if (h < 20) return 1000; // general sea crossing penalty
|
||||
if (type === "Highland" && h < 62) return 1100; // penalty for highlanders on lowlands
|
||||
if (type === "Highland") return 0; // no penalty for highlanders on highlands
|
||||
if (h >= 67) return 2200; // general mountains crossing penalty
|
||||
if (h >= 44) return 300; // general hills crossing penalty
|
||||
return 0;
|
||||
}
|
||||
|
||||
function getRiverCost(r, i, type) {
|
||||
if (type === "River") return r ? 0 : 100; // penalty for river cultures
|
||||
if (!r) return 0; // no penalty for others if there is no river
|
||||
return minmax(cells.fl[i] / 10, 20, 100); // river penalty from 20 to 100 based on flux
|
||||
}
|
||||
|
||||
function getTypeCost(t, type) {
|
||||
if (t === 1) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline
|
||||
if (t === 2) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads
|
||||
if (t !== -1) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals
|
||||
return 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("expandStates");
|
||||
};
|
||||
|
||||
export const normalizeStates = (pack, utils) => {
|
||||
const {TIME} = utils;
|
||||
TIME && console.time("normalizeStates");
|
||||
const {cells, burgs} = pack;
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.h[i] < 20 || cells.burg[i]) continue; // do not overwrite burgs
|
||||
if (pack.states[cells.state[i]]?.lock) continue; // do not overwrite cells of locks states
|
||||
if (cells.c[i].some(c => burgs[cells.burg[c]].capital)) continue; // do not overwrite near capital
|
||||
const neibs = cells.c[i].filter(c => cells.h[c] >= 20);
|
||||
const adversaries = neibs.filter(c => !pack.states[cells.state[c]]?.lock && cells.state[c] !== cells.state[i]);
|
||||
if (adversaries.length < 2) continue;
|
||||
const buddies = neibs.filter(c => !pack.states[cells.state[c]]?.lock && cells.state[c] === cells.state[i]);
|
||||
if (buddies.length > 2) continue;
|
||||
if (adversaries.length <= buddies.length) continue;
|
||||
cells.state[i] = cells.state[adversaries[0]];
|
||||
}
|
||||
TIME && console.timeEnd("normalizeStates");
|
||||
};
|
||||
|
||||
// calculate pole of inaccessibility for each state
|
||||
export const getPoles = (pack, utils) => {
|
||||
const {getPolesOfInaccessibility} = utils;
|
||||
const getType = cellId => pack.cells.state[cellId];
|
||||
const poles = getPolesOfInaccessibility(pack, getType);
|
||||
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
s.pole = poles[s.i] || [0, 0];
|
||||
});
|
||||
};
|
||||
|
||||
// Resets the cultures of all burgs and states to their cell or center cell's (respectively) culture
|
||||
export const updateCultures = (pack, utils) => {
|
||||
const {TIME} = utils;
|
||||
TIME && console.time("updateCulturesForBurgsAndStates");
|
||||
|
||||
// Assign the culture associated with the burgs cell
|
||||
pack.burgs = pack.burgs.map((burg, index) => {
|
||||
if (index === 0) return burg;
|
||||
return {...burg, culture: pack.cells.culture[burg.cell]};
|
||||
});
|
||||
|
||||
// Assign the culture associated with the states' center cell
|
||||
pack.states = pack.states.map((state, index) => {
|
||||
if (index === 0) return state;
|
||||
return {...state, culture: pack.cells.culture[state.center]};
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("updateCulturesForBurgsAndStates");
|
||||
};
|
||||
|
||||
// calculate states data like area, population etc.
|
||||
export const collectStatistics = (pack) => {
|
||||
const {cells, states} = pack;
|
||||
|
||||
states.forEach(s => {
|
||||
if (s.removed) return;
|
||||
s.cells = s.area = s.burgs = s.rural = s.urban = 0;
|
||||
s.neighbors = new Set();
|
||||
});
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.h[i] < 20) continue;
|
||||
const s = cells.state[i];
|
||||
|
||||
// check for neighboring states
|
||||
cells.c[i]
|
||||
.filter(c => cells.h[c] >= 20 && cells.state[c] !== s)
|
||||
.forEach(c => states[s].neighbors.add(cells.state[c]));
|
||||
|
||||
// collect stats
|
||||
states[s].cells += 1;
|
||||
states[s].area += cells.area[i];
|
||||
states[s].rural += cells.pop[i];
|
||||
if (cells.burg[i]) {
|
||||
states[s].urban += pack.burgs[cells.burg[i]].population;
|
||||
states[s].burgs++;
|
||||
}
|
||||
}
|
||||
|
||||
// convert neighbors Set object into array
|
||||
states.forEach(s => {
|
||||
if (!s.neighbors) return;
|
||||
s.neighbors = Array.from(s.neighbors);
|
||||
});
|
||||
};
|
||||
|
||||
export const assignColors = (pack, utils) => {
|
||||
const {TIME, getRandomColor, getMixedColor} = utils;
|
||||
TIME && console.time("assignColors");
|
||||
const colors = ["#66c2a5", "#fc8d62", "#8da0cb", "#e78ac3", "#a6d854", "#ffd92f"]; // d3.schemeSet2;
|
||||
|
||||
// assign basic color using greedy coloring algorithm
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed || s.lock) return;
|
||||
const neibs = s.neighbors;
|
||||
s.color = colors.find(c => neibs.every(n => pack.states[n].color !== c));
|
||||
if (!s.color) s.color = getRandomColor();
|
||||
colors.push(colors.shift());
|
||||
});
|
||||
|
||||
// randomize each already used color a bit
|
||||
colors.forEach(c => {
|
||||
const sameColored = pack.states.filter(s => s.color === c && !s.lock);
|
||||
sameColored.forEach((s, d) => {
|
||||
if (!d) return;
|
||||
s.color = getMixedColor(s.color);
|
||||
});
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("assignColors");
|
||||
};
|
||||
|
||||
const wars = {
|
||||
War: 6,
|
||||
Conflict: 2,
|
||||
Campaign: 4,
|
||||
Invasion: 2,
|
||||
Rebellion: 2,
|
||||
Conquest: 2,
|
||||
Intervention: 1,
|
||||
Expedition: 1,
|
||||
Crusade: 1
|
||||
};
|
||||
|
||||
export const generateCampaign = (state, pack, utils) => {
|
||||
const {P, gauss, rw, getAdjective, Names, options} = utils;
|
||||
const neighbors = state.neighbors.length ? state.neighbors : [0];
|
||||
return neighbors
|
||||
.map(i => {
|
||||
const name = i && P(0.8) ? pack.states[i].name : Names.getCultureShort(state.culture);
|
||||
const start = gauss(options.year - 100, 150, 1, options.year - 6);
|
||||
const end = start + gauss(4, 5, 1, options.year - start - 1);
|
||||
return {name: getAdjective(name) + " " + rw(wars), start, end};
|
||||
})
|
||||
.sort((a, b) => a.start - b.start);
|
||||
};
|
||||
|
||||
// generate historical conflicts of each state
|
||||
export const generateCampaigns = (pack, utils) => {
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
s.campaigns = generateCampaign(s, pack, utils);
|
||||
});
|
||||
};
|
||||
|
||||
// generate Diplomatic Relationships
|
||||
export const generateDiplomacy = (pack, utils) => {
|
||||
const {TIME, d3, P, ra, gauss, rw, trimVowels, options} = utils;
|
||||
TIME && console.time("generateDiplomacy");
|
||||
const {cells, states} = pack;
|
||||
const chronicle = (states[0].diplomacy = []);
|
||||
const valid = states.filter(s => s.i && !states.removed);
|
||||
|
||||
const neibs = {Ally: 1, Friendly: 2, Neutral: 1, Suspicion: 10, Rival: 9}; // relations to neighbors
|
||||
const neibsOfNeibs = {Ally: 10, Friendly: 8, Neutral: 5, Suspicion: 1}; // relations to neighbors of neighbors
|
||||
const far = {Friendly: 1, Neutral: 12, Suspicion: 2, Unknown: 6}; // relations to other
|
||||
const navals = {Neutral: 1, Suspicion: 2, Rival: 1, Unknown: 1}; // relations of naval powers
|
||||
|
||||
valid.forEach(s => (s.diplomacy = new Array(states.length).fill("x"))); // clear all relationships
|
||||
if (valid.length < 2) return; // no states to renerate relations with
|
||||
const areaMean = d3.mean(valid.map(s => s.area)); // average state area
|
||||
|
||||
// generic relations
|
||||
for (let f = 1; f < states.length; f++) {
|
||||
if (states[f].removed) continue;
|
||||
|
||||
if (states[f].diplomacy.includes("Vassal")) {
|
||||
// Vassals copy relations from their Suzerains
|
||||
const suzerain = states[f].diplomacy.indexOf("Vassal");
|
||||
|
||||
for (let i = 1; i < states.length; i++) {
|
||||
if (i === f || i === suzerain) continue;
|
||||
states[f].diplomacy[i] = states[suzerain].diplomacy[i];
|
||||
if (states[suzerain].diplomacy[i] === "Suzerain") states[f].diplomacy[i] = "Ally";
|
||||
for (let e = 1; e < states.length; e++) {
|
||||
if (e === f || e === suzerain) continue;
|
||||
if (states[e].diplomacy[suzerain] === "Suzerain" || states[e].diplomacy[suzerain] === "Vassal") continue;
|
||||
states[e].diplomacy[f] = states[e].diplomacy[suzerain];
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
for (let t = f + 1; t < states.length; t++) {
|
||||
if (states[t].removed) continue;
|
||||
|
||||
if (states[t].diplomacy.includes("Vassal")) {
|
||||
const suzerain = states[t].diplomacy.indexOf("Vassal");
|
||||
states[f].diplomacy[t] = states[f].diplomacy[suzerain];
|
||||
continue;
|
||||
}
|
||||
|
||||
const naval =
|
||||
states[f].type === "Naval" &&
|
||||
states[t].type === "Naval" &&
|
||||
cells.f[states[f].center] !== cells.f[states[t].center];
|
||||
const neib = naval ? false : states[f].neighbors.includes(t);
|
||||
const neibOfNeib =
|
||||
naval || neib
|
||||
? false
|
||||
: states[f].neighbors
|
||||
.map(n => states[n].neighbors)
|
||||
.join("")
|
||||
.includes(t);
|
||||
|
||||
let status = naval ? rw(navals) : neib ? rw(neibs) : neibOfNeib ? rw(neibsOfNeibs) : rw(far);
|
||||
|
||||
// add Vassal
|
||||
if (
|
||||
neib &&
|
||||
P(0.8) &&
|
||||
states[f].area > areaMean &&
|
||||
states[t].area < areaMean &&
|
||||
states[f].area / states[t].area > 2
|
||||
)
|
||||
status = "Vassal";
|
||||
states[f].diplomacy[t] = status === "Vassal" ? "Suzerain" : status;
|
||||
states[t].diplomacy[f] = status;
|
||||
}
|
||||
}
|
||||
|
||||
// declare wars
|
||||
for (let attacker = 1; attacker < states.length; attacker++) {
|
||||
const ad = states[attacker].diplomacy; // attacker relations;
|
||||
if (states[attacker].removed) continue;
|
||||
if (!ad.includes("Rival")) continue; // no rivals to attack
|
||||
if (ad.includes("Vassal")) continue; // not independent
|
||||
if (ad.includes("Enemy")) continue; // already at war
|
||||
|
||||
// random independent rival
|
||||
const defender = ra(
|
||||
ad.map((r, d) => (r === "Rival" && !states[d].diplomacy.includes("Vassal") ? d : 0)).filter(d => d)
|
||||
);
|
||||
let ap = states[attacker].area * states[attacker].expansionism;
|
||||
let dp = states[defender].area * states[defender].expansionism;
|
||||
if (ap < dp * gauss(1.6, 0.8, 0, 10, 2)) continue; // defender is too strong
|
||||
|
||||
const an = states[attacker].name;
|
||||
const dn = states[defender].name; // names
|
||||
const attackers = [attacker];
|
||||
const defenders = [defender]; // attackers and defenders array
|
||||
const dd = states[defender].diplomacy; // defender relations;
|
||||
|
||||
// start an ongoing war
|
||||
const name = `${an}-${trimVowels(dn)}ian War`;
|
||||
const start = options.year - gauss(2, 3, 0, 10);
|
||||
const war = [name, `${an} declared a war on its rival ${dn}`];
|
||||
const campaign = {name, start, attacker, defender};
|
||||
states[attacker].campaigns.push(campaign);
|
||||
states[defender].campaigns.push(campaign);
|
||||
|
||||
// attacker vassals join the war
|
||||
ad.forEach((r, d) => {
|
||||
if (r === "Suzerain") {
|
||||
attackers.push(d);
|
||||
war.push(`${an}'s vassal ${states[d].name} joined the war on attackers side`);
|
||||
}
|
||||
});
|
||||
|
||||
// defender vassals join the war
|
||||
dd.forEach((r, d) => {
|
||||
if (r === "Suzerain") {
|
||||
defenders.push(d);
|
||||
war.push(`${dn}'s vassal ${states[d].name} joined the war on defenders side`);
|
||||
}
|
||||
});
|
||||
|
||||
ap = d3.sum(attackers.map(a => states[a].area * states[a].expansionism)); // attackers joined power
|
||||
dp = d3.sum(defenders.map(d => states[d].area * states[d].expansionism)); // defender joined power
|
||||
|
||||
// defender allies join
|
||||
dd.forEach((r, d) => {
|
||||
if (r !== "Ally" || states[d].diplomacy.includes("Vassal")) return;
|
||||
if (states[d].diplomacy[attacker] !== "Rival" && ap / dp > 2 * gauss(1.6, 0.8, 0, 10, 2)) {
|
||||
const reason = states[d].diplomacy.includes("Enemy") ? "Being already at war," : `Frightened by ${an},`;
|
||||
war.push(`${reason} ${states[d].name} severed the defense pact with ${dn}`);
|
||||
dd[d] = states[d].diplomacy[defender] = "Suspicion";
|
||||
return;
|
||||
}
|
||||
defenders.push(d);
|
||||
dp += states[d].area * states[d].expansionism;
|
||||
war.push(`${dn}'s ally ${states[d].name} joined the war on defenders side`);
|
||||
|
||||
// ally vassals join
|
||||
states[d].diplomacy
|
||||
.map((r, d) => (r === "Suzerain" ? d : 0))
|
||||
.filter(d => d)
|
||||
.forEach(v => {
|
||||
defenders.push(v);
|
||||
dp += states[v].area * states[v].expansionism;
|
||||
war.push(`${states[d].name}'s vassal ${states[v].name} joined the war on defenders side`);
|
||||
});
|
||||
});
|
||||
|
||||
// attacker allies join if the defender is their rival or joined power > defenders power and defender is not an ally
|
||||
ad.forEach((r, d) => {
|
||||
if (r !== "Ally" || states[d].diplomacy.includes("Vassal") || defenders.includes(d)) return;
|
||||
const name = states[d].name;
|
||||
if (states[d].diplomacy[defender] !== "Rival" && (P(0.2) || ap <= dp * 1.2)) {
|
||||
war.push(`${an}'s ally ${name} avoided entering the war`);
|
||||
return;
|
||||
}
|
||||
const allies = states[d].diplomacy.map((r, d) => (r === "Ally" ? d : 0)).filter(d => d);
|
||||
if (allies.some(ally => defenders.includes(ally))) {
|
||||
war.push(`${an}'s ally ${name} did not join the war as its allies are in war on both sides`);
|
||||
return;
|
||||
}
|
||||
|
||||
attackers.push(d);
|
||||
ap += states[d].area * states[d].expansionism;
|
||||
war.push(`${an}'s ally ${name} joined the war on attackers side`);
|
||||
|
||||
// ally vassals join
|
||||
states[d].diplomacy
|
||||
.map((r, d) => (r === "Suzerain" ? d : 0))
|
||||
.filter(d => d)
|
||||
.forEach(v => {
|
||||
attackers.push(v);
|
||||
dp += states[v].area * states[v].expansionism;
|
||||
war.push(`${states[d].name}'s vassal ${states[v].name} joined the war on attackers side`);
|
||||
});
|
||||
});
|
||||
|
||||
// change relations to Enemy for all participants
|
||||
attackers.forEach(a => defenders.forEach(d => (states[a].diplomacy[d] = states[d].diplomacy[a] = "Enemy")));
|
||||
chronicle.push(war); // add a record to diplomatical history
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateDiplomacy");
|
||||
};
|
||||
|
||||
// select a forms for listed or all valid states
|
||||
export const defineStateForms = (list, pack, utils) => {
|
||||
const {TIME, d3, P, rw, rand, trimVowels, getAdjective} = utils;
|
||||
TIME && console.time("defineStateForms");
|
||||
const states = pack.states.filter(s => s.i && !s.removed && !s.lock);
|
||||
if (states.length < 1) return;
|
||||
|
||||
const generic = {Monarchy: 25, Republic: 2, Union: 1};
|
||||
const naval = {Monarchy: 25, Republic: 8, Union: 3};
|
||||
|
||||
const median = d3.median(pack.states.map(s => s.area));
|
||||
const empireMin = states.map(s => s.area).sort((a, b) => b - a)[Math.max(Math.ceil(states.length ** 0.4) - 2, 0)];
|
||||
const expTiers = pack.states.map(s => {
|
||||
let tier = Math.min(Math.floor((s.area / median) * 2.6), 4);
|
||||
if (tier === 4 && s.area < empireMin) tier = 3;
|
||||
return tier;
|
||||
});
|
||||
|
||||
const monarchy = ["Duchy", "Grand Duchy", "Principality", "Kingdom", "Empire"]; // per expansionism tier
|
||||
const republic = {
|
||||
Republic: 75,
|
||||
Federation: 4,
|
||||
"Trade Company": 4,
|
||||
"Most Serene Republic": 2,
|
||||
Oligarchy: 2,
|
||||
Tetrarchy: 1,
|
||||
Triumvirate: 1,
|
||||
Diarchy: 1,
|
||||
Junta: 1
|
||||
}; // weighted random
|
||||
const union = {
|
||||
Union: 3,
|
||||
League: 4,
|
||||
Confederation: 1,
|
||||
"United Kingdom": 1,
|
||||
"United Republic": 1,
|
||||
"United Provinces": 2,
|
||||
Commonwealth: 1,
|
||||
Heptarchy: 1
|
||||
}; // weighted random
|
||||
const theocracy = {Theocracy: 20, Brotherhood: 1, Thearchy: 2, See: 1, "Holy State": 1};
|
||||
const anarchy = {"Free Territory": 2, Council: 3, Commune: 1, Community: 1};
|
||||
|
||||
for (const s of states) {
|
||||
if (list && !list.includes(s.i)) continue;
|
||||
const tier = expTiers[s.i];
|
||||
|
||||
const religion = pack.cells.religion[s.center];
|
||||
const isTheocracy =
|
||||
(religion && pack.religions[religion].expansion === "state") ||
|
||||
(P(0.1) && ["Organized", "Cult"].includes(pack.religions[religion].type));
|
||||
const isAnarchy = P(0.01 - tier / 500);
|
||||
|
||||
if (isTheocracy) s.form = "Theocracy";
|
||||
else if (isAnarchy) s.form = "Anarchy";
|
||||
else s.form = s.type === "Naval" ? rw(naval) : rw(generic);
|
||||
s.formName = selectForm(s, tier, pack, utils);
|
||||
s.fullName = getFullName(s, utils);
|
||||
}
|
||||
|
||||
function selectForm(s, tier, pack, utils) {
|
||||
const {P, rand, rw, trimVowels} = utils;
|
||||
const base = pack.cultures[s.culture].base;
|
||||
|
||||
if (s.form === "Monarchy") {
|
||||
const form = monarchy[tier];
|
||||
// Default name depends on exponent tier, some culture bases have special names for tiers
|
||||
if (s.diplomacy) {
|
||||
if (
|
||||
form === "Duchy" &&
|
||||
s.neighbors.length > 1 &&
|
||||
rand(6) < s.neighbors.length &&
|
||||
s.diplomacy.includes("Vassal")
|
||||
)
|
||||
return "Marches"; // some vassal duchies on borderland
|
||||
if (base === 1 && P(0.3) && s.diplomacy.includes("Vassal")) return "Dominion"; // English vassals
|
||||
if (P(0.3) && s.diplomacy.includes("Vassal")) return "Protectorate"; // some vassals
|
||||
}
|
||||
|
||||
if (base === 31 && (form === "Empire" || form === "Kingdom")) return "Khanate"; // Mongolian
|
||||
if (base === 16 && form === "Principality") return "Beylik"; // Turkic
|
||||
if (base === 5 && (form === "Empire" || form === "Kingdom")) return "Tsardom"; // Ruthenian
|
||||
if (base === 16 && (form === "Empire" || form === "Kingdom")) return "Khaganate"; // Turkic
|
||||
if (base === 12 && (form === "Kingdom" || form === "Grand Duchy")) return "Shogunate"; // Japanese
|
||||
if ([18, 17].includes(base) && form === "Empire") return "Caliphate"; // Arabic, Berber
|
||||
if (base === 18 && (form === "Grand Duchy" || form === "Duchy")) return "Emirate"; // Arabic
|
||||
if (base === 7 && (form === "Grand Duchy" || form === "Duchy")) return "Despotate"; // Greek
|
||||
if (base === 31 && (form === "Grand Duchy" || form === "Duchy")) return "Ulus"; // Mongolian
|
||||
if (base === 16 && (form === "Grand Duchy" || form === "Duchy")) return "Horde"; // Turkic
|
||||
if (base === 24 && (form === "Grand Duchy" || form === "Duchy")) return "Satrapy"; // Iranian
|
||||
return form;
|
||||
}
|
||||
|
||||
if (s.form === "Republic") {
|
||||
// Default name is from weighted array, special case for small states with only 1 burg
|
||||
if (tier < 2 && s.burgs === 1) {
|
||||
if (trimVowels(s.name) === trimVowels(pack.burgs[s.capital].name)) {
|
||||
s.name = pack.burgs[s.capital].name;
|
||||
return "Free City";
|
||||
}
|
||||
if (P(0.3)) return "City-state";
|
||||
}
|
||||
return rw(republic);
|
||||
}
|
||||
|
||||
if (s.form === "Union") return rw(union);
|
||||
if (s.form === "Anarchy") return rw(anarchy);
|
||||
|
||||
if (s.form === "Theocracy") {
|
||||
// European
|
||||
if ([0, 1, 2, 3, 4, 6, 8, 9, 13, 15, 20].includes(base)) {
|
||||
if (P(0.1)) return "Divine " + monarchy[tier];
|
||||
if (tier < 2 && P(0.5)) return "Diocese";
|
||||
if (tier < 2 && P(0.5)) return "Bishopric";
|
||||
}
|
||||
if (P(0.9) && [7, 5].includes(base)) {
|
||||
// Greek, Ruthenian
|
||||
if (tier < 2) return "Eparchy";
|
||||
if (tier === 2) return "Exarchate";
|
||||
if (tier > 2) return "Patriarchate";
|
||||
}
|
||||
if (P(0.9) && [21, 16].includes(base)) return "Imamah"; // Nigerian, Turkish
|
||||
if (tier > 2 && P(0.8) && [18, 17, 28].includes(base)) return "Caliphate"; // Arabic, Berber, Swahili
|
||||
return rw(theocracy);
|
||||
}
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("defineStateForms");
|
||||
};
|
||||
|
||||
// state forms requiring Adjective + Name, all other forms use scheme Form + Of + Name
|
||||
const adjForms = [
|
||||
"Empire",
|
||||
"Sultanate",
|
||||
"Khaganate",
|
||||
"Shogunate",
|
||||
"Caliphate",
|
||||
"Despotate",
|
||||
"Theocracy",
|
||||
"Oligarchy",
|
||||
"Union",
|
||||
"Confederation",
|
||||
"Trade Company",
|
||||
"League",
|
||||
"Tetrarchy",
|
||||
"Triumvirate",
|
||||
"Diarchy",
|
||||
"Horde",
|
||||
"Marches"
|
||||
];
|
||||
|
||||
export const getFullName = (state, utils) => {
|
||||
const {getAdjective} = utils;
|
||||
if (!state.formName) return state.name;
|
||||
if (!state.name && state.formName) return "The " + state.formName;
|
||||
const adjName = adjForms.includes(state.formName) && !/-| /.test(state.name);
|
||||
return adjName ? `${getAdjective(state.name)} ${state.formName}` : `${state.formName} of ${state.name}`;
|
||||
};
|
||||
2218
procedural/src/engine/modules/coa-generator.js
Normal file
2218
procedural/src/engine/modules/coa-generator.js
Normal file
File diff suppressed because it is too large
Load diff
346
procedural/src/engine/modules/coa-renderer.js
Normal file
346
procedural/src/engine/modules/coa-renderer.js
Normal file
|
|
@ -0,0 +1,346 @@
|
|||
"use strict";
|
||||
|
||||
// Data constants (business logic of the module)
|
||||
const colors = {
|
||||
argent: "#fafafa",
|
||||
or: "#ffe066",
|
||||
gules: "#d7374a",
|
||||
sable: "#333333",
|
||||
azure: "#377cd7",
|
||||
vert: "#26c061",
|
||||
purpure: "#522d5b",
|
||||
murrey: "#85185b",
|
||||
sanguine: "#b63a3a",
|
||||
tenné: "#cc7f19"
|
||||
};
|
||||
|
||||
const shieldPositions = {
|
||||
// shield-specific position: [x, y] (relative to center)
|
||||
heater: {
|
||||
a: [-43.75, -50],
|
||||
b: [0, -50],
|
||||
c: [43.75, -50],
|
||||
d: [-43.75, 0],
|
||||
e: [0, 0],
|
||||
f: [43.75, 0],
|
||||
g: [-32.25, 37.5],
|
||||
h: [0, 50],
|
||||
i: [32.25, 37.5],
|
||||
y: [-50, -50],
|
||||
z: [0, 62.5],
|
||||
j: [-37.5, -37.5],
|
||||
k: [0, -37.5],
|
||||
l: [37.5, -37.5],
|
||||
m: [-30, 30],
|
||||
n: [0, 42.5],
|
||||
o: [30, 30],
|
||||
p: [-37.5, 0],
|
||||
q: [37.5, 0],
|
||||
A: [-66.2, -66.6],
|
||||
B: [-22, -66.6],
|
||||
C: [22, -66.6],
|
||||
D: [66.2, -66.6],
|
||||
K: [-66.2, -20],
|
||||
E: [66.2, -20],
|
||||
J: [-55.5, 26],
|
||||
F: [55.5, 26],
|
||||
I: [-33, 62],
|
||||
G: [33, 62],
|
||||
H: [0, 89.5]
|
||||
},
|
||||
spanish: {
|
||||
a: [-43.75, -50],
|
||||
b: [0, -50],
|
||||
c: [43.75, -50],
|
||||
d: [-43.75, 0],
|
||||
e: [0, 0],
|
||||
f: [43.75, 0],
|
||||
g: [-43.75, 50],
|
||||
h: [0, 50],
|
||||
i: [43.75, 50],
|
||||
y: [-50, -50],
|
||||
z: [0, 50],
|
||||
j: [-37.5, -37.5],
|
||||
k: [0, -37.5],
|
||||
l: [37.5, -37.5],
|
||||
m: [-37.5, 37.5],
|
||||
n: [0, 37.5],
|
||||
o: [37.5, 37.5],
|
||||
p: [-37.5, 0],
|
||||
q: [37.5, 0],
|
||||
A: [-66.2, -66.6],
|
||||
B: [-22, -66.6],
|
||||
C: [22, -66.6],
|
||||
D: [66.2, -66.6],
|
||||
K: [-66.4, -20],
|
||||
E: [66.4, -20],
|
||||
J: [-66.4, 26],
|
||||
F: [66.4, 26],
|
||||
I: [-49, 70],
|
||||
G: [49, 70],
|
||||
H: [0, 92]
|
||||
},
|
||||
// ... all other shieldPositions data from original ...
|
||||
moriaOrc: {
|
||||
a: [-37.5, -37.5],
|
||||
b: [0, -37.5],
|
||||
c: [37.5, -37.5],
|
||||
d: [-37.5, 0],
|
||||
e: [0, 0],
|
||||
f: [37.5, 0],
|
||||
g: [-37.5, 37.5],
|
||||
h: [0, 37.5],
|
||||
i: [37.5, 37.5],
|
||||
y: [-50, -50],
|
||||
z: [0, 40],
|
||||
j: [-30, -30],
|
||||
k: [0, -30],
|
||||
l: [30, -30],
|
||||
m: [-30, 30],
|
||||
n: [0, 30],
|
||||
o: [30, 30],
|
||||
p: [-30, 0],
|
||||
q: [30, 0],
|
||||
A: [-48, -48],
|
||||
B: [-16, -50],
|
||||
C: [16, -46],
|
||||
D: [39, -61],
|
||||
K: [-52, -19],
|
||||
E: [52, -26],
|
||||
J: [-42, 9],
|
||||
F: [52, 9],
|
||||
I: [-31, 40],
|
||||
G: [40, 43],
|
||||
H: [4, 47]
|
||||
}
|
||||
};
|
||||
|
||||
const shieldSize = {
|
||||
// ... all shieldSize data from original ...
|
||||
moriaOrc: 0.7
|
||||
};
|
||||
|
||||
const shieldBox = {
|
||||
// ... all shieldBox data from original ...
|
||||
moriaOrc: "0 0 200 200"
|
||||
};
|
||||
|
||||
export const shieldPaths = {
|
||||
// ... all shieldPaths data from original ...
|
||||
moriaOrc:
|
||||
"M45 35c5 3 7 10 13 9h19c4-2 7-4 9-9 6 1 9 9 16 11 7-2 14 0 21 0 6-3 6-10 10-15 2-5 1-10-2-15-2-4-5-14-4-16 3 6 7 11 12 14 7 3 3 12 7 16 3 6 4 12 9 18 2 4 6 8 5 14 0 6-1 12 3 18-3 6-2 13-1 20 1 6-2 12-1 18 0 6-3 13 0 18 8 4 0 8-5 7-4 3-9 3-13 9-5 5-5 13-8 19 0 6 0 15-7 16-1 6-7 6-10 12-1-6 0-6-2-9l2-19c2-4 5-12-3-12-4-5-11-5-15 1l-13-18c-3-4-2 9-3 12 2 2-4-6-7-5-8-2-8 7-11 11-2 4-5 10-8 9 3-10 3-16 1-23-1-4 2-9-4-11 0-6 1-13-2-19-4-2-9-6-13-7V91c4-7-5-13 0-19-3-7 2-11 2-18-1-6 1-12 3-17v-1z"
|
||||
};
|
||||
|
||||
const lines = {
|
||||
// ... all lines data from original ...
|
||||
archedReversed: "m 0,85 c 0,0 60,20.2 100,20 40,-0.2 100,-20 100,-20 v 30 H 0 Z"
|
||||
};
|
||||
|
||||
const templates = {
|
||||
// ... all templates data from original ...
|
||||
saltirePartedLined: line =>
|
||||
`<path d="${line}" transform="translate(3 -13) rotate(45 110 100) scale(1.1 1)"/><path d="${line}" transform="translate(-23 13) rotate(225 110 100) scale(1.1 1)"/><path d="${line}" transform="translate(-23 -13) rotate(-45 110 100) scale(1.1 1)"/><path d="${line}" transform="translate(3 13) rotate(-225 110 100) scale(1.1 1)"/>`
|
||||
};
|
||||
|
||||
const patterns = {
|
||||
// ... all patterns data from original ...
|
||||
honeycombed: (p, c1, c2, size) =>
|
||||
`<pattern id="${p}" width="${size * 0.143}" height="${
|
||||
size * 0.24514
|
||||
}" viewBox="0 0 70 120"><rect width="70" height="120" fill="${c1}"/><path d="M 70,0 V 20 L 35,40 m 35,80 V 100 L 35,80 M 0,120 V 100 L 35,80 V 40 L 0,20 V 0" stroke="${c2}" fill="none" stroke-width="3"/></pattern>`
|
||||
};
|
||||
|
||||
/**
|
||||
* Generates an SVG string for a given Coat of Arms definition.
|
||||
* @param {object} coa The Coat of Arms definition object.
|
||||
* @param {string} id A unique ID to be used for SVG elements like clipPaths and patterns.
|
||||
* @param {object} chargesData An object mapping charge names to their raw SVG <g> element strings.
|
||||
* @returns {string} The complete SVG string for the Coat of Arms.
|
||||
*/
|
||||
export function render(coa, id, chargesData) {
|
||||
const {shield = "heater", division, ordinaries = [], charges = []} = coa;
|
||||
|
||||
const ordinariesRegular = ordinaries.filter(o => !o.above);
|
||||
const ordinariesAboveCharges = ordinaries.filter(o => o.above);
|
||||
const shieldPath = shieldPaths[shield] || shieldPaths.heater;
|
||||
const tDiv = division ? (division.t.includes("-") ? division.t.split("-")[1] : division.t) : null;
|
||||
const positions = shieldPositions[shield];
|
||||
const sizeModifier = shieldSize[shield] || 1;
|
||||
const viewBox = shieldBox[shield] || "0 0 200 200";
|
||||
|
||||
const shieldClip = `<clipPath id="${shield}_${id}"><path d="${shieldPath}"/></clipPath>`;
|
||||
const divisionClip = division
|
||||
? `<clipPath id="divisionClip_${id}">${getTemplate(division.division, division.line)}</clipPath>`
|
||||
: "";
|
||||
const loadedCharges = getCharges(coa, id, chargesData, shieldPath);
|
||||
const loadedPatterns = getPatterns(coa, id);
|
||||
const blacklight = `<radialGradient id="backlight_${id}" cx="100%" cy="100%" r="150%"><stop stop-color="#fff" stop-opacity=".3" offset="0"/><stop stop-color="#fff" stop-opacity=".15" offset=".25"/><stop stop-color="#000" stop-opacity="0" offset="1"/></radialGradient>`;
|
||||
const field = `<rect x="0" y="0" width="200" height="200" fill="${clr(coa.t1)}"/>`;
|
||||
const style = `<style>g.secondary,path.secondary{fill:var(--secondary);}g.tertiary,path.tertiary{fill:var(--tertiary);}</style>`;
|
||||
|
||||
const divisionGroup = division ? templateDivision() : "";
|
||||
const overlay = `<path d="${shieldPath}" fill="url(#backlight_${id})" stroke="#333"/>`;
|
||||
|
||||
const svg = `<svg id="${id}" width="200" height="200" viewBox="${viewBox}">
|
||||
<defs>${shieldClip}${divisionClip}${loadedCharges}${loadedPatterns}${blacklight}${style}</defs>
|
||||
<g clip-path="url(#${shield}_${id})">${field}${divisionGroup}${templateAboveAll()}</g>
|
||||
${overlay}</svg>`;
|
||||
|
||||
return svg;
|
||||
|
||||
function templateDivision() {
|
||||
let svg = "";
|
||||
|
||||
// In field part
|
||||
for (const ordinary of ordinariesRegular) {
|
||||
if (ordinary.divided === "field") svg += templateOrdinary(ordinary, ordinary.t);
|
||||
else if (ordinary.divided === "counter") svg += templateOrdinary(ordinary, tDiv);
|
||||
}
|
||||
for (const charge of charges) {
|
||||
if (charge.divided === "field") svg += templateCharge(charge, charge.t);
|
||||
else if (charge.divided === "counter") svg += templateCharge(charge, tDiv);
|
||||
}
|
||||
for (const ordinary of ordinariesAboveCharges) {
|
||||
if (ordinary.divided === "field") svg += templateOrdinary(ordinary, ordinary.t);
|
||||
else if (ordinary.divided === "counter") svg += templateOrdinary(ordinary, tDiv);
|
||||
}
|
||||
|
||||
// In division part
|
||||
svg += `<g clip-path="url(#divisionClip_${id})"><rect x="0" y="0" width="200" height="200" fill="${clr(
|
||||
division.t
|
||||
)}"/>`;
|
||||
for (const ordinary of ordinariesRegular) {
|
||||
if (ordinary.divided === "division") svg += templateOrdinary(ordinary, ordinary.t);
|
||||
else if (ordinary.divided === "counter") svg += templateOrdinary(ordinary, coa.t1);
|
||||
}
|
||||
for (const charge of charges) {
|
||||
if (charge.divided === "division") svg += templateCharge(charge, charge.t);
|
||||
else if (charge.divided === "counter") svg += templateCharge(charge, coa.t1);
|
||||
}
|
||||
for (const ordinary of ordinariesAboveCharges) {
|
||||
if (ordinary.divided === "division") svg += templateOrdinary(ordinary, ordinary.t);
|
||||
else if (ordinary.divided === "counter") svg += templateOrdinary(ordinary, coa.t1);
|
||||
}
|
||||
return (svg += `</g>`);
|
||||
}
|
||||
|
||||
function templateAboveAll() {
|
||||
let svg = "";
|
||||
ordinariesRegular.filter(o => !o.divided).forEach(ordinary => (svg += templateOrdinary(ordinary, ordinary.t)));
|
||||
charges.filter(o => !o.divided || !division).forEach(charge => (svg += templateCharge(charge, charge.t)));
|
||||
ordinariesAboveCharges
|
||||
.filter(o => !o.divided)
|
||||
.forEach(ordinary => (svg += templateOrdinary(ordinary, ordinary.t)));
|
||||
return svg;
|
||||
}
|
||||
|
||||
function templateOrdinary(ordinary, tincture) {
|
||||
const fill = clr(tincture);
|
||||
let svg = `<g fill="${fill}" stroke="none">`;
|
||||
if (ordinary.ordinary === "bordure")
|
||||
svg += `<path d="${shieldPath}" fill="none" stroke="${fill}" stroke-width="16.7%"/>`;
|
||||
else if (ordinary.ordinary === "orle")
|
||||
svg += `<path d="${shieldPath}" fill="none" stroke="${fill}" stroke-width="5%" transform="scale(.85)" transform-origin="center">`;
|
||||
else svg += getTemplate(ordinary.ordinary, ordinary.line);
|
||||
return svg + `</g>`;
|
||||
}
|
||||
|
||||
function templateCharge(charge, tincture, secondaryTincture, tertiaryTincture) {
|
||||
const primary = clr(tincture);
|
||||
const secondary = clr(secondaryTincture || tincture);
|
||||
const tertiary = clr(tertiaryTincture || tincture);
|
||||
const stroke = charge.stroke || "#000";
|
||||
|
||||
const chargePositions = [...new Set(charge.p)].filter(position => positions[position]);
|
||||
let svg = `<g fill="${primary}" style="--secondary: ${secondary}; --tertiary: ${tertiary}" stroke="${stroke}">`;
|
||||
for (const p of chargePositions) {
|
||||
const transform = getElTransform(charge, p);
|
||||
svg += `<use href="#${charge.charge}_${id}" transform="${transform}"></use>`;
|
||||
}
|
||||
return svg + "</g>";
|
||||
|
||||
function getElTransform(c, p) {
|
||||
const s = (c.size || 1) * sizeModifier;
|
||||
const sx = c.sinister ? -s : s;
|
||||
const sy = c.reversed ? -s : s;
|
||||
let [x, y] = positions[p];
|
||||
x = x - 100 * (sx - 1);
|
||||
y = y - 100 * (sy - 1);
|
||||
const scale = c.sinister || c.reversed ? `${sx} ${sy}` : s;
|
||||
return `translate(${x} ${y}) scale(${scale})`;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Helpers
|
||||
function getCharges(coa, id, chargesData, shieldPath) {
|
||||
let chargesToLoad = coa.charges ? coa.charges.map(charge => charge.charge) : [];
|
||||
if (semy(coa.t1)) chargesToLoad.push(semy(coa.t1));
|
||||
if (semy(coa.division?.t)) chargesToLoad.push(semy(coa.division.t));
|
||||
|
||||
const uniqueCharges = [...new Set(chargesToLoad)];
|
||||
return uniqueCharges
|
||||
.map(charge => {
|
||||
if (charge === "inescutcheon") {
|
||||
return `<g id="inescutcheon_${id}"><path transform="translate(66 66) scale(.34)" d="${shieldPath}"/></g>`;
|
||||
}
|
||||
const chargeSVG = chargesData[charge];
|
||||
if (!chargeSVG) {
|
||||
console.error(`Charge data for "${charge}" not provided.`);
|
||||
return "";
|
||||
}
|
||||
// Inject the unique ID into the provided <g> tag
|
||||
return chargeSVG.replace(/<g/i, `<g id="${charge}_${id}"`);
|
||||
})
|
||||
.join("");
|
||||
}
|
||||
|
||||
function getPatterns(coa, id) {
|
||||
const isPattern = string => string.includes("-");
|
||||
let patternsToAdd = [];
|
||||
if (coa.t1.includes("-")) patternsToAdd.push(coa.t1);
|
||||
if (coa.division && isPattern(coa.division.t)) patternsToAdd.push(coa.division.t);
|
||||
if (coa.ordinaries) {
|
||||
coa.ordinaries.filter(ordinary => isPattern(ordinary.t)).forEach(ordinary => patternsToAdd.push(ordinary.t));
|
||||
}
|
||||
if (coa.charges) {
|
||||
coa.charges.filter(charge => isPattern(charge.t)).forEach(charge => patternsToAdd.push(charge.t));
|
||||
}
|
||||
if (!patternsToAdd.length) return "";
|
||||
|
||||
return [...new Set(patternsToAdd)]
|
||||
.map(patternString => {
|
||||
const [pattern, t1, t2, size] = patternString.split("-");
|
||||
const charge = semy(patternString);
|
||||
if (charge) return patterns.semy(patternString, clr(t1), clr(t2), getSizeMod(size), charge + "_" + id);
|
||||
return patterns[pattern](patternString, clr(t1), clr(t2), getSizeMod(size), charge);
|
||||
})
|
||||
.join("");
|
||||
}
|
||||
|
||||
function getSizeMod(size) {
|
||||
if (size === "small") return 0.8;
|
||||
if (size === "smaller") return 0.5;
|
||||
if (size === "smallest") return 0.25;
|
||||
if (size === "big") return 1.6;
|
||||
return 1;
|
||||
}
|
||||
|
||||
function getTemplate(id, line) {
|
||||
const linedId = id + "Lined";
|
||||
if (!line || line === "straight" || !templates[linedId]) return templates[id];
|
||||
const linePath = lines[line];
|
||||
return templates[linedId](linePath);
|
||||
}
|
||||
|
||||
function clr(tincture) {
|
||||
if (colors[tincture]) return colors[tincture];
|
||||
return `url(#${tincture})`;
|
||||
}
|
||||
|
||||
function semy(string) {
|
||||
const isSemy = /^semy/.test(string);
|
||||
if (!isSemy) return false;
|
||||
const match = string.match(/semy_of_(.*?)-/);
|
||||
return match ? match[1] : false;
|
||||
}
|
||||
627
procedural/src/engine/modules/cultures-generator.js
Normal file
627
procedural/src/engine/modules/cultures-generator.js
Normal file
|
|
@ -0,0 +1,627 @@
|
|||
"use strict";
|
||||
|
||||
export const generate = function (pack, grid, config, utils) {
|
||||
const { TIME, WARN, ERROR, rand, rn, P, minmax, biased, rw, abbreviate } = utils;
|
||||
|
||||
TIME && console.time("generateCultures");
|
||||
const cells = pack.cells;
|
||||
|
||||
const cultureIds = new Uint16Array(cells.i.length); // cell cultures
|
||||
|
||||
const culturesInputNumber = config.culturesInput;
|
||||
const culturesInSetNumber = config.culturesInSetNumber;
|
||||
let count = Math.min(culturesInputNumber, culturesInSetNumber);
|
||||
|
||||
const populated = cells.i.filter(i => cells.s[i]); // populated cells
|
||||
if (populated.length < count * 25) {
|
||||
count = Math.floor(populated.length / 50);
|
||||
if (!count) {
|
||||
WARN && console.warn(`There are no populated cells. Cannot generate cultures`);
|
||||
const cultures = [{name: "Wildlands", i: 0, base: 1, shield: "round"}];
|
||||
cells.culture = cultureIds;
|
||||
|
||||
// Return data structure with error info for UI handling
|
||||
return {
|
||||
cultures,
|
||||
cells: { culture: cultureIds },
|
||||
error: {
|
||||
type: "extreme_climate",
|
||||
message: "The climate is harsh and people cannot live in this world. No cultures, states and burgs will be created.",
|
||||
populated: populated.length
|
||||
}
|
||||
};
|
||||
} else {
|
||||
WARN && console.warn(`Not enough populated cells (${populated.length}). Will generate only ${count} cultures`);
|
||||
// Return warning info for UI handling but continue generation
|
||||
}
|
||||
}
|
||||
|
||||
const cultures = selectCultures(count, config, pack, utils);
|
||||
const centers = utils.d3.quadtree();
|
||||
const colors = getColors(count, utils);
|
||||
const emblemShape = config.emblemShape;
|
||||
|
||||
const codes = [];
|
||||
|
||||
cultures.forEach(function (c, i) {
|
||||
const newId = i + 1;
|
||||
|
||||
if (c.lock) {
|
||||
codes.push(c.code);
|
||||
centers.add(c.center);
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.culture[i] === c.i) cultureIds[i] = newId;
|
||||
}
|
||||
|
||||
c.i = newId;
|
||||
return;
|
||||
}
|
||||
|
||||
const sortingFn = c.sort ? c.sort : i => cells.s[i];
|
||||
const center = placeCenter(sortingFn, populated, cultureIds, centers, cells, config, utils);
|
||||
|
||||
centers.add(cells.p[center]);
|
||||
c.center = center;
|
||||
c.i = newId;
|
||||
delete c.odd;
|
||||
delete c.sort;
|
||||
c.color = colors[i];
|
||||
c.type = defineCultureType(center, cells, pack, utils);
|
||||
c.expansionism = defineCultureExpansionism(c.type, config, utils);
|
||||
c.origins = [0];
|
||||
c.code = abbreviate(c.name, codes);
|
||||
codes.push(c.code);
|
||||
cultureIds[center] = newId;
|
||||
if (emblemShape === "random") c.shield = getRandomShield(utils);
|
||||
});
|
||||
|
||||
cells.culture = cultureIds;
|
||||
|
||||
// the first culture with id 0 is for wildlands
|
||||
cultures.unshift({name: "Wildlands", i: 0, base: 1, origins: [null], shield: "round"});
|
||||
|
||||
// make sure all bases exist in nameBases
|
||||
if (!utils.nameBases.length) {
|
||||
ERROR && console.error("Name base is empty, default nameBases will be applied");
|
||||
utils.nameBases = utils.Names.getNameBases();
|
||||
}
|
||||
|
||||
cultures.forEach(c => (c.base = c.base % utils.nameBases.length));
|
||||
|
||||
TIME && console.timeEnd("generateCultures");
|
||||
|
||||
return {
|
||||
cultures,
|
||||
cells: { culture: cultureIds }
|
||||
};
|
||||
};
|
||||
|
||||
function placeCenter(sortingFn, populated, cultureIds, centers, cells, config, utils) {
|
||||
const graphWidth = config.graphWidth;
|
||||
const graphHeight = config.graphHeight;
|
||||
const count = populated.length;
|
||||
|
||||
let spacing = (graphWidth + graphHeight) / 2 / count;
|
||||
const MAX_ATTEMPTS = 100;
|
||||
|
||||
const sorted = [...populated].sort((a, b) => sortingFn(b) - sortingFn(a));
|
||||
const max = Math.floor(sorted.length / 2);
|
||||
|
||||
let cellId = 0;
|
||||
for (let i = 0; i < MAX_ATTEMPTS; i++) {
|
||||
cellId = sorted[utils.biased(0, max, 5)];
|
||||
spacing *= 0.9;
|
||||
if (!cultureIds[cellId] && !centers.find(cells.p[cellId][0], cells.p[cellId][1], spacing)) break;
|
||||
}
|
||||
|
||||
return cellId;
|
||||
}
|
||||
|
||||
function selectCultures(culturesNumber, config, pack, utils) {
|
||||
let defaultCultures = getDefault(culturesNumber, config, pack, utils);
|
||||
const cultures = [];
|
||||
|
||||
pack.cultures?.forEach(function (culture) {
|
||||
if (culture.lock && !culture.removed) cultures.push(culture);
|
||||
});
|
||||
|
||||
if (!cultures.length) {
|
||||
if (culturesNumber === defaultCultures.length) return defaultCultures;
|
||||
if (defaultCultures.every(d => d.odd === 1)) return defaultCultures.splice(0, culturesNumber);
|
||||
}
|
||||
|
||||
for (let culture, rnd, i = 0; cultures.length < culturesNumber && defaultCultures.length > 0; ) {
|
||||
do {
|
||||
rnd = utils.rand(defaultCultures.length - 1);
|
||||
culture = defaultCultures[rnd];
|
||||
i++;
|
||||
} while (i < 200 && !utils.P(culture.odd));
|
||||
cultures.push(culture);
|
||||
defaultCultures.splice(rnd, 1);
|
||||
}
|
||||
return cultures;
|
||||
}
|
||||
|
||||
// set culture type based on culture center position
|
||||
function defineCultureType(i, cells, pack, utils) {
|
||||
if (cells.h[i] < 70 && [1, 2, 4].includes(cells.biome[i])) return "Nomadic"; // high penalty in forest biomes and near coastline
|
||||
if (cells.h[i] > 50) return "Highland"; // no penalty for hills and moutains, high for other elevations
|
||||
const f = pack.features[cells.f[cells.haven[i]]]; // opposite feature
|
||||
if (f.type === "lake" && f.cells > 5) return "Lake"; // low water cross penalty and high for growth not along coastline
|
||||
if (
|
||||
(cells.harbor[i] && f.type !== "lake" && utils.P(0.1)) ||
|
||||
(cells.harbor[i] === 1 && utils.P(0.6)) ||
|
||||
(pack.features[cells.f[i]].group === "isle" && utils.P(0.4))
|
||||
)
|
||||
return "Naval"; // low water cross penalty and high for non-along-coastline growth
|
||||
if (cells.r[i] && cells.fl[i] > 100) return "River"; // no River cross penalty, penalty for non-River growth
|
||||
if (cells.t[i] > 2 && [3, 7, 8, 9, 10, 12].includes(cells.biome[i])) return "Hunting"; // high penalty in non-native biomes
|
||||
return "Generic";
|
||||
}
|
||||
|
||||
function defineCultureExpansionism(type, config, utils) {
|
||||
let base = 1; // Generic
|
||||
if (type === "Lake") base = 0.8;
|
||||
else if (type === "Naval") base = 1.5;
|
||||
else if (type === "River") base = 0.9;
|
||||
else if (type === "Nomadic") base = 1.5;
|
||||
else if (type === "Hunting") base = 0.7;
|
||||
else if (type === "Highland") base = 1.2;
|
||||
return utils.rn(((Math.random() * config.sizeVariety) / 2 + 1) * base, 1);
|
||||
}
|
||||
|
||||
export const add = function (center, pack, config, utils) {
|
||||
const defaultCultures = getDefault(null, config, pack, utils);
|
||||
let culture, base, name;
|
||||
|
||||
if (pack.cultures.length < defaultCultures.length) {
|
||||
// add one of the default cultures
|
||||
culture = pack.cultures.length;
|
||||
base = defaultCultures[culture].base;
|
||||
name = defaultCultures[culture].name;
|
||||
} else {
|
||||
// add random culture besed on one of the current ones
|
||||
culture = utils.rand(pack.cultures.length - 1);
|
||||
name = utils.Names.getCulture(culture, 5, 8, "");
|
||||
base = pack.cultures[culture].base;
|
||||
}
|
||||
|
||||
const code = utils.abbreviate(
|
||||
name,
|
||||
pack.cultures.map(c => c.code)
|
||||
);
|
||||
const i = pack.cultures.length;
|
||||
const color = getRandomColor(utils);
|
||||
|
||||
// define emblem shape
|
||||
let shield = culture.shield;
|
||||
const emblemShape = config.emblemShape;
|
||||
if (emblemShape === "random") shield = getRandomShield(utils);
|
||||
|
||||
const newCulture = {
|
||||
name,
|
||||
color,
|
||||
base,
|
||||
center,
|
||||
i,
|
||||
expansionism: 1,
|
||||
type: "Generic",
|
||||
cells: 0,
|
||||
area: 0,
|
||||
rural: 0,
|
||||
urban: 0,
|
||||
origins: [pack.cells.culture[center]],
|
||||
code,
|
||||
shield
|
||||
};
|
||||
|
||||
return newCulture;
|
||||
};
|
||||
|
||||
export const getDefault = function (count, config, pack, utils) {
|
||||
// generic sorting functions
|
||||
const cells = pack.cells,
|
||||
s = cells.s,
|
||||
sMax = utils.d3.max(s),
|
||||
t = cells.t,
|
||||
h = cells.h,
|
||||
temp = utils.grid.cells.temp;
|
||||
const n = cell => Math.ceil((s[cell] / sMax) * 3); // normalized cell score
|
||||
const td = (cell, goal) => {
|
||||
const d = Math.abs(temp[cells.g[cell]] - goal);
|
||||
return d ? d + 1 : 1;
|
||||
}; // temperature difference fee
|
||||
const bd = (cell, biomes, fee = 4) => (biomes.includes(cells.biome[cell]) ? 1 : fee); // biome difference fee
|
||||
const sf = (cell, fee = 4) =>
|
||||
cells.haven[cell] && pack.features[cells.f[cells.haven[cell]]].type !== "lake" ? 1 : fee; // not on sea coast fee
|
||||
|
||||
if (config.culturesSet === "european") {
|
||||
return [
|
||||
{name: "Shwazen", base: 0, odd: 1, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "swiss"},
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "wedged"},
|
||||
{name: "Luari", base: 2, odd: 1, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "french"},
|
||||
{name: "Tallian", base: 3, odd: 1, sort: i => n(i) / td(i, 15), shield: "horsehead"},
|
||||
{name: "Astellian", base: 4, odd: 1, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
{name: "Slovan", base: 5, odd: 1, sort: i => (n(i) / td(i, 6)) * t[i], shield: "polish"},
|
||||
{name: "Norse", base: 6, odd: 1, sort: i => n(i) / td(i, 5), shield: "heater"},
|
||||
{name: "Elladan", base: 7, odd: 1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.2, sort: i => n(i) / td(i, 15) / t[i], shield: "roman"},
|
||||
{name: "Soumi", base: 9, odd: 1, sort: i => (n(i) / td(i, 5) / bd(i, [9])) * t[i], shield: "pavise"},
|
||||
{name: "Portuzian", base: 13, odd: 1, sort: i => n(i) / td(i, 17) / sf(i), shield: "renaissance"},
|
||||
{name: "Vengrian", base: 15, odd: 1, sort: i => (n(i) / td(i, 11) / bd(i, [4])) * t[i], shield: "horsehead2"},
|
||||
{name: "Turchian", base: 16, odd: 0.05, sort: i => n(i) / td(i, 14), shield: "round"},
|
||||
{name: "Euskati", base: 20, odd: 0.05, sort: i => (n(i) / td(i, 15)) * h[i], shield: "oldFrench"},
|
||||
{name: "Keltan", base: 22, odd: 0.05, sort: i => (n(i) / td(i, 11) / bd(i, [6, 8])) * t[i], shield: "oval"}
|
||||
];
|
||||
}
|
||||
|
||||
if (config.culturesSet === "oriental") {
|
||||
return [
|
||||
{name: "Koryo", base: 10, odd: 1, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 1, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 1, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Turchian", base: 16, odd: 1, sort: i => n(i) / td(i, 12), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.2,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "oval"
|
||||
},
|
||||
{name: "Eurabic", base: 18, odd: 1, sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i], shield: "oval"},
|
||||
{name: "Efratic", base: 23, odd: 0.1, sort: i => (n(i) / td(i, 22)) * t[i], shield: "round"},
|
||||
{name: "Tehrani", base: 24, odd: 1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "round"},
|
||||
{name: "Maui", base: 25, odd: 0.2, sort: i => n(i) / td(i, 24) / sf(i) / t[i], shield: "vesicaPiscis"},
|
||||
{name: "Carnatic", base: 26, odd: 0.5, sort: i => n(i) / td(i, 26), shield: "round"},
|
||||
{name: "Vietic", base: 29, odd: 0.8, sort: i => n(i) / td(i, 25) / bd(i, [7], 7) / t[i], shield: "banner"},
|
||||
{name: "Guantzu", base: 30, odd: 0.5, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{name: "Ulus", base: 31, odd: 1, sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i], shield: "banner"}
|
||||
];
|
||||
}
|
||||
|
||||
if (config.culturesSet === "english") {
|
||||
const getName = () => utils.Names.getBase(1, 5, 9, "", 0);
|
||||
return [
|
||||
{name: getName(), base: 1, odd: 1, shield: "heater"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "wedged"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "swiss"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "oldFrench"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "swiss"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "spanish"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "hessen"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy5"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy4"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy1"}
|
||||
];
|
||||
}
|
||||
|
||||
if (config.culturesSet === "antique") {
|
||||
return [
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 14) / t[i], shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 15) / sf(i), shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 16) / sf(i), shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 17) / t[i], shield: "roman"}, // Roman
|
||||
{name: "Hellenic", base: 7, odd: 1, sort: i => (n(i) / td(i, 18) / sf(i)) * h[i], shield: "boeotian"}, // Greek
|
||||
{name: "Hellenic", base: 7, odd: 1, sort: i => (n(i) / td(i, 19) / sf(i)) * h[i], shield: "boeotian"}, // Greek
|
||||
{name: "Macedonian", base: 7, odd: 0.5, sort: i => (n(i) / td(i, 12)) * h[i], shield: "round"}, // Greek
|
||||
{name: "Celtic", base: 22, odd: 1, sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [6, 8]), shield: "round"},
|
||||
{name: "Germanic", base: 0, odd: 1, sort: i => n(i) / td(i, 10) ** 0.5 / bd(i, [6, 8]), shield: "round"},
|
||||
{name: "Persian", base: 24, odd: 0.8, sort: i => (n(i) / td(i, 18)) * h[i], shield: "oval"}, // Iranian
|
||||
{name: "Scythian", base: 24, odd: 0.5, sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [4]), shield: "round"}, // Iranian
|
||||
{name: "Cantabrian", base: 20, odd: 0.5, sort: i => (n(i) / td(i, 16)) * h[i], shield: "oval"}, // Basque
|
||||
{name: "Estian", base: 9, odd: 0.2, sort: i => (n(i) / td(i, 5)) * t[i], shield: "pavise"}, // Finnic
|
||||
{name: "Carthaginian", base: 42, odd: 0.3, sort: i => n(i) / td(i, 20) / sf(i), shield: "oval"}, // Levantine
|
||||
{name: "Hebrew", base: 42, odd: 0.2, sort: i => (n(i) / td(i, 19)) * sf(i), shield: "oval"}, // Levantine
|
||||
{name: "Mesopotamian", base: 23, odd: 0.2, sort: i => n(i) / td(i, 22) / bd(i, [1, 2, 3]), shield: "oval"} // Mesopotamian
|
||||
];
|
||||
}
|
||||
|
||||
if (config.culturesSet === "highFantasy") {
|
||||
return [
|
||||
// fantasy races
|
||||
{
|
||||
name: "Quenian (Elfish)",
|
||||
base: 33,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i],
|
||||
shield: "gondor"
|
||||
}, // Elves
|
||||
{
|
||||
name: "Eldar (Elfish)",
|
||||
base: 33,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i],
|
||||
shield: "noldor"
|
||||
}, // Elves
|
||||
{
|
||||
name: "Trow (Dark Elfish)",
|
||||
base: 34,
|
||||
odd: 0.9,
|
||||
sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i],
|
||||
shield: "hessen"
|
||||
}, // Dark Elves
|
||||
{
|
||||
name: "Lothian (Dark Elfish)",
|
||||
base: 34,
|
||||
odd: 0.3,
|
||||
sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i],
|
||||
shield: "wedged"
|
||||
}, // Dark Elves
|
||||
{name: "Dunirr (Dwarven)", base: 35, odd: 1, sort: i => n(i) + h[i], shield: "ironHills"}, // Dwarfs
|
||||
{name: "Khazadur (Dwarven)", base: 35, odd: 1, sort: i => n(i) + h[i], shield: "erebor"}, // Dwarfs
|
||||
{name: "Kobold (Goblin)", base: 36, odd: 1, sort: i => t[i] - s[i], shield: "moriaOrc"}, // Goblin
|
||||
{name: "Uruk (Orkish)", base: 37, odd: 1, sort: i => h[i] * t[i], shield: "urukHai"}, // Orc
|
||||
{
|
||||
name: "Ugluk (Orkish)",
|
||||
base: 37,
|
||||
odd: 0.5,
|
||||
sort: i => (h[i] * t[i]) / bd(i, [1, 2, 10, 11]),
|
||||
shield: "moriaOrc"
|
||||
}, // Orc
|
||||
{name: "Yotunn (Giants)", base: 38, odd: 0.7, sort: i => td(i, -10), shield: "pavise"}, // Giant
|
||||
{name: "Rake (Drakonic)", base: 39, odd: 0.7, sort: i => -s[i], shield: "fantasy2"}, // Draconic
|
||||
{name: "Arago (Arachnid)", base: 40, odd: 0.7, sort: i => t[i] - s[i], shield: "horsehead2"}, // Arachnid
|
||||
{name: "Aj'Snaga (Serpents)", base: 41, odd: 0.7, sort: i => n(i) / bd(i, [12], 10), shield: "fantasy1"}, // Serpents
|
||||
// fantasy human
|
||||
{name: "Anor (Human)", base: 32, odd: 1, sort: i => n(i) / td(i, 10), shield: "fantasy5"},
|
||||
{name: "Dail (Human)", base: 32, odd: 1, sort: i => n(i) / td(i, 13), shield: "roman"},
|
||||
{name: "Rohand (Human)", base: 16, odd: 1, sort: i => n(i) / td(i, 16), shield: "round"},
|
||||
{
|
||||
name: "Dulandir (Human)",
|
||||
base: 31,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i],
|
||||
shield: "easterling"
|
||||
}
|
||||
];
|
||||
}
|
||||
|
||||
if (config.culturesSet === "darkFantasy") {
|
||||
return [
|
||||
// common real-world English
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "heater"},
|
||||
{name: "Enlandic", base: 1, odd: 1, sort: i => n(i) / td(i, 12), shield: "heater"},
|
||||
{name: "Westen", base: 1, odd: 1, sort: i => n(i) / td(i, 10), shield: "heater"},
|
||||
{name: "Nortumbic", base: 1, odd: 1, sort: i => n(i) / td(i, 7), shield: "heater"},
|
||||
{name: "Mercian", base: 1, odd: 1, sort: i => n(i) / td(i, 9), shield: "heater"},
|
||||
{name: "Kentian", base: 1, odd: 1, sort: i => n(i) / td(i, 12), shield: "heater"},
|
||||
// rare real-world western
|
||||
{name: "Norse", base: 6, odd: 0.7, sort: i => n(i) / td(i, 5) / sf(i), shield: "oldFrench"},
|
||||
{name: "Schwarzen", base: 0, odd: 0.3, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "gonfalon"},
|
||||
{name: "Luarian", base: 2, odd: 0.3, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "oldFrench"},
|
||||
{name: "Hetallian", base: 3, odd: 0.3, sort: i => n(i) / td(i, 15), shield: "oval"},
|
||||
{name: "Astellian", base: 4, odd: 0.3, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
// rare real-world exotic
|
||||
{
|
||||
name: "Kiswaili",
|
||||
base: 28,
|
||||
odd: 0.05,
|
||||
sort: i => n(i) / td(i, 29) / bd(i, [1, 3, 5, 7]),
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Yoruba", base: 21, odd: 0.05, sort: i => n(i) / td(i, 15) / bd(i, [5, 7]), shield: "vesicaPiscis"},
|
||||
{name: "Koryo", base: 10, odd: 0.05, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 0.05, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 0.05, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Guantzu", base: 30, odd: 0.05, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{
|
||||
name: "Ulus",
|
||||
base: 31,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i],
|
||||
shield: "banner"
|
||||
},
|
||||
{name: "Turan", base: 16, odd: 0.05, sort: i => n(i) / td(i, 12), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{
|
||||
name: "Eurabic",
|
||||
base: 18,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{name: "Slovan", base: 5, odd: 0.05, sort: i => (n(i) / td(i, 6)) * t[i], shield: "round"},
|
||||
{
|
||||
name: "Keltan",
|
||||
base: 22,
|
||||
odd: 0.1,
|
||||
sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [6, 8]),
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Elladan", base: 7, odd: 0.2, sort: i => (n(i) / td(i, 18) / sf(i)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.2, sort: i => n(i) / td(i, 14) / t[i], shield: "roman"},
|
||||
// fantasy races
|
||||
{name: "Eldar", base: 33, odd: 0.5, sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i], shield: "fantasy5"}, // Elves
|
||||
{name: "Trow", base: 34, odd: 0.8, sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i], shield: "hessen"}, // Dark Elves
|
||||
{name: "Durinn", base: 35, odd: 0.8, sort: i => n(i) + h[i], shield: "erebor"}, // Dwarven
|
||||
{name: "Kobblin", base: 36, odd: 0.8, sort: i => t[i] - s[i], shield: "moriaOrc"}, // Goblin
|
||||
{name: "Uruk", base: 37, odd: 0.8, sort: i => (h[i] * t[i]) / bd(i, [1, 2, 10, 11]), shield: "urukHai"}, // Orc
|
||||
{name: "Yotunn", base: 38, odd: 0.8, sort: i => td(i, -10), shield: "pavise"}, // Giant
|
||||
{name: "Drake", base: 39, odd: 0.9, sort: i => -s[i], shield: "fantasy2"}, // Draconic
|
||||
{name: "Rakhnid", base: 40, odd: 0.9, sort: i => t[i] - s[i], shield: "horsehead2"}, // Arachnid
|
||||
{name: "Aj'Snaga", base: 41, odd: 0.9, sort: i => n(i) / bd(i, [12], 10), shield: "fantasy1"} // Serpents
|
||||
];
|
||||
}
|
||||
|
||||
if (config.culturesSet === "random") {
|
||||
return utils.d3.range(count).map(function () {
|
||||
const rnd = utils.rand(utils.nameBases.length - 1);
|
||||
const name = utils.Names.getBaseShort(rnd);
|
||||
return {name, base: rnd, odd: 1, shield: getRandomShield(utils)};
|
||||
});
|
||||
}
|
||||
|
||||
// all-world
|
||||
return [
|
||||
{name: "Shwazen", base: 0, odd: 0.7, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "hessen"},
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "heater"},
|
||||
{name: "Luari", base: 2, odd: 0.6, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "oldFrench"},
|
||||
{name: "Tallian", base: 3, odd: 0.6, sort: i => n(i) / td(i, 15), shield: "horsehead2"},
|
||||
{name: "Astellian", base: 4, odd: 0.6, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
{name: "Slovan", base: 5, odd: 0.7, sort: i => (n(i) / td(i, 6)) * t[i], shield: "round"},
|
||||
{name: "Norse", base: 6, odd: 0.7, sort: i => n(i) / td(i, 5), shield: "heater"},
|
||||
{name: "Elladan", base: 7, odd: 0.7, sort: i => (n(i) / td(i, 18)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.7, sort: i => n(i) / td(i, 15), shield: "roman"},
|
||||
{name: "Soumi", base: 9, odd: 0.3, sort: i => (n(i) / td(i, 5) / bd(i, [9])) * t[i], shield: "pavise"},
|
||||
{name: "Koryo", base: 10, odd: 0.1, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 0.1, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 0.1, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Portuzian", base: 13, odd: 0.4, sort: i => n(i) / td(i, 17) / sf(i), shield: "spanish"},
|
||||
{name: "Nawatli", base: 14, odd: 0.1, sort: i => h[i] / td(i, 18) / bd(i, [7]), shield: "square"},
|
||||
{name: "Vengrian", base: 15, odd: 0.2, sort: i => (n(i) / td(i, 11) / bd(i, [4])) * t[i], shield: "wedged"},
|
||||
{name: "Turchian", base: 16, odd: 0.2, sort: i => n(i) / td(i, 13), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.1,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{name: "Eurabic", base: 18, odd: 0.2, sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i], shield: "round"},
|
||||
{name: "Inuk", base: 19, odd: 0.05, sort: i => td(i, -1) / bd(i, [10, 11]) / sf(i), shield: "square"},
|
||||
{name: "Euskati", base: 20, odd: 0.05, sort: i => (n(i) / td(i, 15)) * h[i], shield: "spanish"},
|
||||
{name: "Yoruba", base: 21, odd: 0.05, sort: i => n(i) / td(i, 15) / bd(i, [5, 7]), shield: "vesicaPiscis"},
|
||||
{
|
||||
name: "Keltan",
|
||||
base: 22,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 11) / bd(i, [6, 8])) * t[i],
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Efratic", base: 23, odd: 0.05, sort: i => (n(i) / td(i, 22)) * t[i], shield: "diamond"},
|
||||
{name: "Tehrani", base: 24, odd: 0.1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "round"},
|
||||
{name: "Maui", base: 25, odd: 0.05, sort: i => n(i) / td(i, 24) / sf(i) / t[i], shield: "round"},
|
||||
{name: "Carnatic", base: 26, odd: 0.05, sort: i => n(i) / td(i, 26), shield: "round"},
|
||||
{name: "Inqan", base: 27, odd: 0.05, sort: i => h[i] / td(i, 13), shield: "square"},
|
||||
{name: "Kiswaili", base: 28, odd: 0.1, sort: i => n(i) / td(i, 29) / bd(i, [1, 3, 5, 7]), shield: "vesicaPiscis"},
|
||||
{name: "Vietic", base: 29, odd: 0.1, sort: i => n(i) / td(i, 25) / bd(i, [7], 7) / t[i], shield: "banner"},
|
||||
{name: "Guantzu", base: 30, odd: 0.1, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{name: "Ulus", base: 31, odd: 0.1, sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i], shield: "banner"},
|
||||
{name: "Hebrew", base: 42, odd: 0.2, sort: i => (n(i) / td(i, 18)) * sf(i), shield: "oval"} // Levantine
|
||||
];
|
||||
};
|
||||
|
||||
// expand cultures across the map (Dijkstra-like algorithm)
|
||||
export const expand = function (pack, config, utils) {
|
||||
const { TIME, minmax } = utils;
|
||||
TIME && console.time("expandCultures");
|
||||
const {cells, cultures} = pack;
|
||||
|
||||
const queue = new utils.FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
const neutralRate = config.neutralRate || 1;
|
||||
const maxExpansionCost = cells.i.length * 0.6 * neutralRate; // limit cost for culture growth
|
||||
|
||||
// remove culture from all cells except of locked
|
||||
const hasLocked = cultures.some(c => !c.removed && c.lock);
|
||||
if (hasLocked) {
|
||||
for (const cellId of cells.i) {
|
||||
const culture = cultures[cells.culture[cellId]];
|
||||
if (culture.lock) continue;
|
||||
cells.culture[cellId] = 0;
|
||||
}
|
||||
} else {
|
||||
cells.culture = new Uint16Array(cells.i.length);
|
||||
}
|
||||
|
||||
for (const culture of cultures) {
|
||||
if (!culture.i || culture.removed || culture.lock) continue;
|
||||
queue.push({cellId: culture.center, cultureId: culture.i, priority: 0}, 0);
|
||||
}
|
||||
|
||||
while (queue.length) {
|
||||
const {cellId, priority, cultureId} = queue.pop();
|
||||
const {type, expansionism} = cultures[cultureId];
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (hasLocked) {
|
||||
const neibCultureId = cells.culture[neibCellId];
|
||||
if (neibCultureId && cultures[neibCultureId].lock) return; // do not overwrite cell of locked culture
|
||||
}
|
||||
|
||||
const biome = cells.biome[neibCellId];
|
||||
const biomeCost = getBiomeCost(cultureId, biome, type, cells, cultures, pack, utils);
|
||||
const biomeChangeCost = biome === cells.biome[neibCellId] ? 0 : 20; // penalty on biome change
|
||||
const heightCost = getHeightCost(neibCellId, cells.h[neibCellId], type, cells, pack, utils);
|
||||
const riverCost = getRiverCost(cells.r[neibCellId], neibCellId, type, cells, utils);
|
||||
const typeCost = getTypeCost(cells.t[neibCellId], type);
|
||||
|
||||
const cellCost = (biomeCost + biomeChangeCost + heightCost + riverCost + typeCost) / expansionism;
|
||||
const totalCost = priority + cellCost;
|
||||
|
||||
if (totalCost > maxExpansionCost) return;
|
||||
|
||||
if (!cost[neibCellId] || totalCost < cost[neibCellId]) {
|
||||
if (cells.pop[neibCellId] > 0) cells.culture[neibCellId] = cultureId; // assign culture to populated cell
|
||||
cost[neibCellId] = totalCost;
|
||||
queue.push({cellId: neibCellId, cultureId, priority: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("expandCultures");
|
||||
|
||||
return {
|
||||
cells: { culture: cells.culture }
|
||||
};
|
||||
};
|
||||
|
||||
function getBiomeCost(c, biome, type, cells, cultures, pack, utils) {
|
||||
if (cells.biome[cultures[c].center] === biome) return 10; // tiny penalty for native biome
|
||||
if (type === "Hunting") return utils.biomesData.cost[biome] * 5; // non-native biome penalty for hunters
|
||||
if (type === "Nomadic" && biome > 4 && biome < 10) return utils.biomesData.cost[biome] * 10; // forest biome penalty for nomads
|
||||
return utils.biomesData.cost[biome] * 2; // general non-native biome penalty
|
||||
}
|
||||
|
||||
function getHeightCost(i, h, type, cells, pack, utils) {
|
||||
const f = pack.features[cells.f[i]],
|
||||
a = cells.area[i];
|
||||
if (type === "Lake" && f.type === "lake") return 10; // no lake crossing penalty for Lake cultures
|
||||
if (type === "Naval" && h < 20) return a * 2; // low sea/lake crossing penalty for Naval cultures
|
||||
if (type === "Nomadic" && h < 20) return a * 50; // giant sea/lake crossing penalty for Nomads
|
||||
if (h < 20) return a * 6; // general sea/lake crossing penalty
|
||||
if (type === "Highland" && h < 44) return 3000; // giant penalty for highlanders on lowlands
|
||||
if (type === "Highland" && h < 62) return 200; // giant penalty for highlanders on lowhills
|
||||
if (type === "Highland") return 0; // no penalty for highlanders on highlands
|
||||
if (h >= 67) return 200; // general mountains crossing penalty
|
||||
if (h >= 44) return 30; // general hills crossing penalty
|
||||
return 0;
|
||||
}
|
||||
|
||||
function getRiverCost(riverId, cellId, type, cells, utils) {
|
||||
if (type === "River") return riverId ? 0 : 100; // penalty for river cultures
|
||||
if (!riverId) return 0; // no penalty for others if there is no river
|
||||
return utils.minmax(cells.fl[cellId] / 10, 20, 100); // river penalty from 20 to 100 based on flux
|
||||
}
|
||||
|
||||
function getTypeCost(t, type) {
|
||||
if (t === 1) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline
|
||||
if (t === 2) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads
|
||||
if (t !== -1) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals
|
||||
return 0;
|
||||
}
|
||||
|
||||
export const getRandomShield = function (utils) {
|
||||
const type = utils.rw(utils.COA.shields.types);
|
||||
return utils.rw(utils.COA.shields[type]);
|
||||
};
|
||||
|
||||
function getColors(count, utils) {
|
||||
// This function needs to be implemented based on the original getColors logic
|
||||
// For now, returning a placeholder
|
||||
return utils.d3.range(count).map(() => utils.getRandomColor ? utils.getRandomColor() : "#000000");
|
||||
}
|
||||
|
||||
function getRandomColor(utils) {
|
||||
// This function needs to be implemented based on the original getRandomColor logic
|
||||
// For now, returning a placeholder
|
||||
return utils.getRandomColor ? utils.getRandomColor() : "#000000";
|
||||
}
|
||||
302
procedural/src/engine/modules/features.js
Normal file
302
procedural/src/engine/modules/features.js
Normal file
|
|
@ -0,0 +1,302 @@
|
|||
"use strict";
|
||||
|
||||
const DEEPER_LAND = 3;
|
||||
const LANDLOCKED = 2;
|
||||
const LAND_COAST = 1;
|
||||
const UNMARKED = 0;
|
||||
const WATER_COAST = -1;
|
||||
const DEEP_WATER = -2;
|
||||
|
||||
// calculate distance to coast for every cell
|
||||
function markup({distanceField, neighbors, start, increment, limit = utils.INT8_MAX}) {
|
||||
for (let distance = start, marked = Infinity; marked > 0 && distance !== limit; distance += increment) {
|
||||
marked = 0;
|
||||
const prevDistance = distance - increment;
|
||||
for (let cellId = 0; cellId < neighbors.length; cellId++) {
|
||||
if (distanceField[cellId] !== prevDistance) continue;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
if (distanceField[neighborId] !== UNMARKED) continue;
|
||||
distanceField[neighborId] = distance;
|
||||
marked++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// mark Grid features (ocean, lakes, islands) and calculate distance field
|
||||
export function markupGrid(grid, config, utils) {
|
||||
const {TIME, seed, aleaPRNG} = config;
|
||||
const {rn} = utils;
|
||||
|
||||
TIME && console.time("markupGrid");
|
||||
Math.random = aleaPRNG(seed); // get the same result on heightmap edit in Erase mode
|
||||
|
||||
const {h: heights, c: neighbors, b: borderCells, i} = grid.cells;
|
||||
const cellsNumber = i.length;
|
||||
const distanceField = new Int8Array(cellsNumber); // gird.cells.t
|
||||
const featureIds = new Uint16Array(cellsNumber); // gird.cells.f
|
||||
const features = [0];
|
||||
|
||||
const queue = [0];
|
||||
for (let featureId = 1; queue[0] !== -1; featureId++) {
|
||||
const firstCell = queue[0];
|
||||
featureIds[firstCell] = featureId;
|
||||
|
||||
const land = heights[firstCell] >= 20;
|
||||
let border = false; // set true if feature touches map edge
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (!border && borderCells[cellId]) border = true;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
const isNeibLand = heights[neighborId] >= 20;
|
||||
|
||||
if (land === isNeibLand && featureIds[neighborId] === UNMARKED) {
|
||||
featureIds[neighborId] = featureId;
|
||||
queue.push(neighborId);
|
||||
} else if (land && !isNeibLand) {
|
||||
distanceField[cellId] = LAND_COAST;
|
||||
distanceField[neighborId] = WATER_COAST;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const type = land ? "island" : border ? "ocean" : "lake";
|
||||
features.push({i: featureId, land, border, type});
|
||||
|
||||
queue[0] = featureIds.findIndex(f => f === UNMARKED); // find unmarked cell
|
||||
}
|
||||
|
||||
// markup deep ocean cells
|
||||
markup({distanceField, neighbors, start: DEEP_WATER, increment: -1, limit: -10});
|
||||
|
||||
const updatedGrid = {
|
||||
...grid,
|
||||
cells: {
|
||||
...grid.cells,
|
||||
t: distanceField,
|
||||
f: featureIds
|
||||
},
|
||||
features
|
||||
};
|
||||
|
||||
TIME && console.timeEnd("markupGrid");
|
||||
|
||||
return updatedGrid;
|
||||
}
|
||||
|
||||
// mark Pack features (ocean, lakes, islands), calculate distance field and add properties
|
||||
export function markupPack(pack, grid, config, utils, modules) {
|
||||
const {TIME} = config;
|
||||
const {isLand, isWater, dist2, rn, clipPoly, unique, createTypedArray, connectVertices} = utils;
|
||||
const {Lakes} = modules;
|
||||
const {d3} = utils;
|
||||
|
||||
TIME && console.time("markupPack");
|
||||
|
||||
const {cells, vertices} = pack;
|
||||
const {c: neighbors, b: borderCells, i} = cells;
|
||||
const packCellsNumber = i.length;
|
||||
if (!packCellsNumber) return pack; // no cells -> there is nothing to do
|
||||
|
||||
const distanceField = new Int8Array(packCellsNumber); // pack.cells.t
|
||||
const featureIds = new Uint16Array(packCellsNumber); // pack.cells.f
|
||||
const haven = createTypedArray({maxValue: packCellsNumber, length: packCellsNumber}); // haven: opposite water cell
|
||||
const harbor = new Uint8Array(packCellsNumber); // harbor: number of adjacent water cells
|
||||
const features = [0];
|
||||
|
||||
const queue = [0];
|
||||
for (let featureId = 1; queue[0] !== -1; featureId++) {
|
||||
const firstCell = queue[0];
|
||||
featureIds[firstCell] = featureId;
|
||||
|
||||
const land = isLand(firstCell);
|
||||
let border = Boolean(borderCells[firstCell]); // true if feature touches map border
|
||||
let totalCells = 1; // count cells in a feature
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (borderCells[cellId]) border = true;
|
||||
if (!border && borderCells[cellId]) border = true;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
const isNeibLand = isLand(neighborId);
|
||||
|
||||
if (land && !isNeibLand) {
|
||||
distanceField[cellId] = LAND_COAST;
|
||||
distanceField[neighborId] = WATER_COAST;
|
||||
if (!haven[cellId]) defineHaven(cellId);
|
||||
} else if (land && isNeibLand) {
|
||||
if (distanceField[neighborId] === UNMARKED && distanceField[cellId] === LAND_COAST)
|
||||
distanceField[neighborId] = LANDLOCKED;
|
||||
else if (distanceField[cellId] === UNMARKED && distanceField[neighborId] === LAND_COAST)
|
||||
distanceField[cellId] = LANDLOCKED;
|
||||
}
|
||||
|
||||
if (!featureIds[neighborId] && land === isNeibLand) {
|
||||
queue.push(neighborId);
|
||||
featureIds[neighborId] = featureId;
|
||||
totalCells++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
features.push(addFeature({firstCell, land, border, featureId, totalCells}));
|
||||
queue[0] = featureIds.findIndex(f => f === UNMARKED); // find unmarked cell
|
||||
}
|
||||
|
||||
markup({distanceField, neighbors, start: DEEPER_LAND, increment: 1}); // markup pack land
|
||||
markup({distanceField, neighbors, start: DEEP_WATER, increment: -1, limit: -10}); // markup pack water
|
||||
|
||||
const updatedPack = {
|
||||
...pack,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
t: distanceField,
|
||||
f: featureIds,
|
||||
haven,
|
||||
harbor
|
||||
},
|
||||
features
|
||||
};
|
||||
|
||||
TIME && console.timeEnd("markupPack");
|
||||
|
||||
return updatedPack;
|
||||
|
||||
function defineHaven(cellId) {
|
||||
const waterCells = neighbors[cellId].filter(isWater);
|
||||
const distances = waterCells.map(neibCellId => dist2(cells.p[cellId], cells.p[neibCellId]));
|
||||
const closest = distances.indexOf(Math.min.apply(Math, distances));
|
||||
|
||||
haven[cellId] = waterCells[closest];
|
||||
harbor[cellId] = waterCells.length;
|
||||
}
|
||||
|
||||
function addFeature({firstCell, land, border, featureId, totalCells}) {
|
||||
const type = land ? "island" : border ? "ocean" : "lake";
|
||||
const [startCell, featureVertices] = getCellsData(type, firstCell);
|
||||
const points = clipPoly(featureVertices.map(vertex => vertices.p[vertex]));
|
||||
const area = d3.polygonArea(points); // feature perimiter area
|
||||
const absArea = Math.abs(rn(area));
|
||||
|
||||
const feature = {
|
||||
i: featureId,
|
||||
type,
|
||||
land,
|
||||
border,
|
||||
cells: totalCells,
|
||||
firstCell: startCell,
|
||||
vertices: featureVertices,
|
||||
area: absArea
|
||||
};
|
||||
|
||||
if (type === "lake") {
|
||||
if (area > 0) feature.vertices = feature.vertices.reverse();
|
||||
feature.shoreline = unique(feature.vertices.map(vertex => vertices.c[vertex].filter(isLand)).flat());
|
||||
feature.height = Lakes.getHeight(feature);
|
||||
}
|
||||
|
||||
return feature;
|
||||
|
||||
function getCellsData(featureType, firstCell) {
|
||||
if (featureType === "ocean") return [firstCell, []];
|
||||
|
||||
const getType = cellId => featureIds[cellId];
|
||||
const type = getType(firstCell);
|
||||
const ofSameType = cellId => getType(cellId) === type;
|
||||
const ofDifferentType = cellId => getType(cellId) !== type;
|
||||
|
||||
const startCell = findOnBorderCell(firstCell);
|
||||
const featureVertices = getFeatureVertices(startCell);
|
||||
return [startCell, featureVertices];
|
||||
|
||||
function findOnBorderCell(firstCell) {
|
||||
const isOnBorder = cellId => borderCells[cellId] || neighbors[cellId].some(ofDifferentType);
|
||||
if (isOnBorder(firstCell)) return firstCell;
|
||||
|
||||
const startCell = cells.i.filter(ofSameType).find(isOnBorder);
|
||||
if (startCell === undefined)
|
||||
throw new Error(`Markup: firstCell ${firstCell} is not on the feature or map border`);
|
||||
|
||||
return startCell;
|
||||
}
|
||||
|
||||
function getFeatureVertices(startCell) {
|
||||
const startingVertex = cells.v[startCell].find(v => vertices.c[v].some(ofDifferentType));
|
||||
if (startingVertex === undefined)
|
||||
throw new Error(`Markup: startingVertex for cell ${startCell} is not found`);
|
||||
|
||||
return connectVertices({vertices, startingVertex, ofSameType, closeRing: false});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// add properties to pack features
|
||||
export function specify(pack, grid, modules) {
|
||||
const {Lakes} = modules;
|
||||
const gridCellsNumber = grid.cells.i.length;
|
||||
const OCEAN_MIN_SIZE = gridCellsNumber / 25;
|
||||
const SEA_MIN_SIZE = gridCellsNumber / 1000;
|
||||
const CONTINENT_MIN_SIZE = gridCellsNumber / 10;
|
||||
const ISLAND_MIN_SIZE = gridCellsNumber / 1000;
|
||||
|
||||
const updatedFeatures = pack.features.map(feature => {
|
||||
if (!feature || feature.type === "ocean") return feature;
|
||||
|
||||
const updatedFeature = {
|
||||
...feature,
|
||||
group: defineGroup(feature)
|
||||
};
|
||||
|
||||
if (feature.type === "lake") {
|
||||
updatedFeature.height = Lakes.getHeight(feature);
|
||||
updatedFeature.name = Lakes.getName(feature);
|
||||
}
|
||||
|
||||
return updatedFeature;
|
||||
});
|
||||
|
||||
return {
|
||||
...pack,
|
||||
features: updatedFeatures
|
||||
};
|
||||
|
||||
function defineGroup(feature) {
|
||||
if (feature.type === "island") return defineIslandGroup(feature);
|
||||
if (feature.type === "ocean") return defineOceanGroup(feature);
|
||||
if (feature.type === "lake") return defineLakeGroup(feature);
|
||||
throw new Error(`Markup: unknown feature type ${feature.type}`);
|
||||
}
|
||||
|
||||
function defineOceanGroup(feature) {
|
||||
if (feature.cells > OCEAN_MIN_SIZE) return "ocean";
|
||||
if (feature.cells > SEA_MIN_SIZE) return "sea";
|
||||
return "gulf";
|
||||
}
|
||||
|
||||
function defineIslandGroup(feature) {
|
||||
const prevFeature = pack.features[pack.cells.f[feature.firstCell - 1]];
|
||||
if (prevFeature && prevFeature.type === "lake") return "lake_island";
|
||||
if (feature.cells > CONTINENT_MIN_SIZE) return "continent";
|
||||
if (feature.cells > ISLAND_MIN_SIZE) return "island";
|
||||
return "isle";
|
||||
}
|
||||
|
||||
function defineLakeGroup(feature) {
|
||||
if (feature.temp < -3) return "frozen";
|
||||
if (feature.height > 60 && feature.cells < 10 && feature.firstCell % 10 === 0) return "lava";
|
||||
|
||||
if (!feature.inlets && !feature.outlet) {
|
||||
if (feature.evaporation > feature.flux * 4) return "dry";
|
||||
if (feature.cells < 3 && feature.firstCell % 10 === 0) return "sinkhole";
|
||||
}
|
||||
|
||||
if (!feature.outlet && feature.evaporation > feature.flux) return "salt";
|
||||
|
||||
return "freshwater";
|
||||
}
|
||||
}
|
||||
346
procedural/src/engine/modules/fonts.js
Normal file
346
procedural/src/engine/modules/fonts.js
Normal file
|
|
@ -0,0 +1,346 @@
|
|||
"use strict";
|
||||
|
||||
const fonts = [
|
||||
{family: "Arial"},
|
||||
{family: "Brush Script MT"},
|
||||
{family: "Century Gothic"},
|
||||
{family: "Comic Sans MS"},
|
||||
{family: "Copperplate"},
|
||||
{family: "Courier New"},
|
||||
{family: "Garamond"},
|
||||
{family: "Georgia"},
|
||||
{family: "Herculanum"},
|
||||
{family: "Impact"},
|
||||
{family: "Papyrus"},
|
||||
{family: "Party LET"},
|
||||
{family: "Times New Roman"},
|
||||
{family: "Verdana"},
|
||||
{
|
||||
family: "Almendra SC",
|
||||
src: "url(https://fonts.gstatic.com/s/almendrasc/v13/Iure6Yx284eebowr7hbyTaZOrLQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Amarante",
|
||||
src: "url(https://fonts.gstatic.com/s/amarante/v22/xMQXuF1KTa6EvGx9bp-wAXs.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Amatic SC",
|
||||
src: "url(https://fonts.gstatic.com/s/amaticsc/v11/TUZ3zwprpvBS1izr_vOMscGKfrUC.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Arima Madurai",
|
||||
src: "url(https://fonts.gstatic.com/s/arimamadurai/v14/t5tmIRoeKYORG0WNMgnC3seB3T7Prw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Architects Daughter",
|
||||
src: "url(https://fonts.gstatic.com/s/architectsdaughter/v8/RXTgOOQ9AAtaVOHxx0IUBM3t7GjCYufj5TXV5VnA2p8.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Bitter",
|
||||
src: "url(https://fonts.gstatic.com/s/bitter/v12/zfs6I-5mjWQ3nxqccMoL2A.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Caesar Dressing",
|
||||
src: "url(https://fonts.gstatic.com/s/caesardressing/v6/yYLx0hLa3vawqtwdswbotmK4vrRHdrz7.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Cinzel",
|
||||
src: "url(https://fonts.gstatic.com/s/cinzel/v7/zOdksD_UUTk1LJF9z4tURA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Dancing Script",
|
||||
src: "url(https://fonts.gstatic.com/s/dancingscript/v9/KGBfwabt0ZRLA5W1ywjowUHdOuSHeh0r6jGTOGdAKHA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Eagle Lake",
|
||||
src: "url(https://fonts.gstatic.com/s/eaglelake/v24/ptRMTiqbbuNJDOiKj9wG1On4KCFtpe4.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Faster One",
|
||||
src: "url(https://fonts.gstatic.com/s/fasterone/v17/H4ciBXCHmdfClFb-vWhf-LyYhw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Forum",
|
||||
src: "url(https://fonts.gstatic.com/s/forum/v16/6aey4Ky-Vb8Ew8IROpI.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Fredericka the Great",
|
||||
src: "url(https://fonts.gstatic.com/s/frederickathegreat/v6/9Bt33CxNwt7aOctW2xjbCstzwVKsIBVV--Sjxbc.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Gloria Hallelujah",
|
||||
src: "url(https://fonts.gstatic.com/s/gloriahallelujah/v9/CA1k7SlXcY5kvI81M_R28cNDay8z-hHR7F16xrcXsJw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Great Vibes",
|
||||
src: "url(https://fonts.gstatic.com/s/greatvibes/v5/6q1c0ofG6NKsEhAc2eh-3Y4P5ICox8Kq3LLUNMylGO4.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Henny Penny",
|
||||
src: "url(https://fonts.gstatic.com/s/hennypenny/v17/wXKvE3UZookzsxz_kjGSfPQtvXI.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "IM Fell English",
|
||||
src: "url(https://fonts.gstatic.com/s/imfellenglish/v7/xwIisCqGFi8pff-oa9uSVAkYLEKE0CJQa8tfZYc_plY.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Kelly Slab",
|
||||
src: "url(https://fonts.gstatic.com/s/kellyslab/v15/-W_7XJX0Rz3cxUnJC5t6fkQLfg.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Kranky",
|
||||
src: "url(https://fonts.gstatic.com/s/kranky/v24/hESw6XVgJzlPsFn8oR2F.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Lobster Two",
|
||||
src: "url(https://fonts.gstatic.com/s/lobstertwo/v18/BngMUXZGTXPUvIoyV6yN5-fN5qU.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Lugrasimo",
|
||||
src: "url(https://fonts.gstatic.com/s/lugrasimo/v4/qkBXXvoF_s_eT9c7Y7au455KsgbLMA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Kaushan Script",
|
||||
src: "url(https://fonts.gstatic.com/s/kaushanscript/v6/qx1LSqts-NtiKcLw4N03IEd0sm1ffa_JvZxsF_BEwQk.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Macondo",
|
||||
src: "url(https://fonts.gstatic.com/s/macondo/v21/RrQQboN9-iB1IXmOe2LE0Q.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "MedievalSharp",
|
||||
src: "url(https://fonts.gstatic.com/s/medievalsharp/v9/EvOJzAlL3oU5AQl2mP5KdgptMqhwMg.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Metal Mania",
|
||||
src: "url(https://fonts.gstatic.com/s/metalmania/v22/RWmMoKWb4e8kqMfBUdPFJdXFiaQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Metamorphous",
|
||||
src: "url(https://fonts.gstatic.com/s/metamorphous/v7/Wnz8HA03aAXcC39ZEX5y133EOyqs.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Montez",
|
||||
src: "url(https://fonts.gstatic.com/s/montez/v8/aq8el3-0osHIcFK6bXAPkw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Nova Script",
|
||||
src: "url(https://fonts.gstatic.com/s/novascript/v10/7Au7p_IpkSWSTWaFWkumvlQKGFw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Orbitron",
|
||||
src: "url(https://fonts.gstatic.com/s/orbitron/v9/HmnHiRzvcnQr8CjBje6GQvesZW2xOQ-xsNqO47m55DA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Oregano",
|
||||
src: "url(https://fonts.gstatic.com/s/oregano/v13/If2IXTPxciS3H4S2oZDVPg.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Pirata One",
|
||||
src: "url(https://fonts.gstatic.com/s/pirataone/v22/I_urMpiDvgLdLh0fAtofhi-Org.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Sail",
|
||||
src: "url(https://fonts.gstatic.com/s/sail/v16/DPEjYwiBxwYJJBPJAQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Satisfy",
|
||||
src: "url(https://fonts.gstatic.com/s/satisfy/v8/2OzALGYfHwQjkPYWELy-cw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Shadows Into Light",
|
||||
src: "url(https://fonts.gstatic.com/s/shadowsintolight/v7/clhLqOv7MXn459PTh0gXYFK2TSYBz0eNcHnp4YqE4Ts.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Tapestry",
|
||||
src: "url(https://fonts.gstatic.com/s/macondo/v21/RrQQboN9-iB1IXmOe2LE0Q.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Uncial Antiqua",
|
||||
src: "url(https://fonts.gstatic.com/s/uncialantiqua/v5/N0bM2S5WOex4OUbESzoESK-i-MfWQZQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Underdog",
|
||||
src: "url(https://fonts.gstatic.com/s/underdog/v6/CHygV-jCElj7diMroWSlWV8.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "UnifrakturMaguntia",
|
||||
src: "url(https://fonts.gstatic.com/s/unifrakturmaguntia/v16/WWXPlieVYwiGNomYU-ciRLRvEmK7oaVemGZM.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Yellowtail",
|
||||
src: "url(https://fonts.gstatic.com/s/yellowtail/v8/GcIHC9QEwVkrA19LJU1qlPk_vArhqVIZ0nv9q090hN8.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
}
|
||||
];
|
||||
|
||||
export function getAvailableFonts() {
|
||||
return [...fonts];
|
||||
}
|
||||
|
||||
export function getUsedFonts(svgData) {
|
||||
const usedFontFamilies = new Set();
|
||||
|
||||
// Check label groups for font-family attributes
|
||||
if (svgData.labels) {
|
||||
for (const labelGroup of svgData.labels) {
|
||||
if (labelGroup.fontFamily) {
|
||||
usedFontFamilies.add(labelGroup.fontFamily);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check provinces font
|
||||
if (svgData.provinces && svgData.provinces.fontFamily) {
|
||||
usedFontFamilies.add(svgData.provinces.fontFamily);
|
||||
}
|
||||
|
||||
// Check legend font
|
||||
if (svgData.legend && svgData.legend.fontFamily) {
|
||||
usedFontFamilies.add(svgData.legend.fontFamily);
|
||||
}
|
||||
|
||||
const usedFonts = fonts.filter(font => usedFontFamilies.has(font.family));
|
||||
return usedFonts;
|
||||
}
|
||||
|
||||
export async function fetchGoogleFont(family) {
|
||||
const url = `https://fonts.googleapis.com/css2?family=${family.replace(/ /g, "+")}`;
|
||||
try {
|
||||
const resp = await fetch(url);
|
||||
const text = await resp.text();
|
||||
|
||||
const fontFaceRules = text.match(/font-face\s*{[^}]+}/g);
|
||||
const fontData = fontFaceRules.map(fontFace => {
|
||||
const srcURL = fontFace.match(/url\(['"]?(.+?)['"]?\)/)[1];
|
||||
const src = `url(${srcURL})`;
|
||||
const unicodeRange = fontFace.match(/unicode-range: (.*?);/)?.[1];
|
||||
const variant = fontFace.match(/font-style: (.*?);/)?.[1];
|
||||
|
||||
const font = {family, src};
|
||||
if (unicodeRange) font.unicodeRange = unicodeRange;
|
||||
if (variant && variant !== "normal") font.variant = variant;
|
||||
return font;
|
||||
});
|
||||
|
||||
return fontData;
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function readBlobAsDataURL(blob) {
|
||||
return new Promise(function (resolve, reject) {
|
||||
const reader = new FileReader();
|
||||
reader.onloadend = () => resolve(reader.result);
|
||||
reader.onerror = reject;
|
||||
reader.readAsDataURL(blob);
|
||||
});
|
||||
}
|
||||
|
||||
export async function loadFontsAsDataURI(fontList) {
|
||||
const promises = fontList.map(async font => {
|
||||
const url = font.src.match(/url\(['"]?(.+?)['"]?\)/)[1];
|
||||
const resp = await fetch(url);
|
||||
const blob = await resp.blob();
|
||||
const dataURL = await readBlobAsDataURL(blob);
|
||||
|
||||
return {...font, src: `url('${dataURL}')`};
|
||||
});
|
||||
|
||||
return await Promise.all(promises);
|
||||
}
|
||||
|
||||
export function createFontDefinition(font) {
|
||||
const {family, src, ...rest} = font;
|
||||
|
||||
if (!src) {
|
||||
return {family, src: `local(${family})`, ...rest};
|
||||
}
|
||||
|
||||
return {family, src, ...rest};
|
||||
}
|
||||
|
||||
export function addCustomFont(family, src = null) {
|
||||
const fontDefinition = src ? {family, src} : {family};
|
||||
fonts.push(fontDefinition);
|
||||
return fontDefinition;
|
||||
}
|
||||
556
procedural/src/engine/modules/heightmap-generator.js
Normal file
556
procedural/src/engine/modules/heightmap-generator.js
Normal file
|
|
@ -0,0 +1,556 @@
|
|||
"use strict";
|
||||
|
||||
export async function generate(graph, config, utils) {
|
||||
const { aleaPRNG, heightmapTemplates, TIME } = utils;
|
||||
const { templateId, seed } = config;
|
||||
|
||||
TIME && console.time("defineHeightmap");
|
||||
|
||||
Math.random = aleaPRNG(seed);
|
||||
const isTemplate = templateId in heightmapTemplates;
|
||||
const heights = isTemplate
|
||||
? fromTemplate(graph, templateId, config, utils)
|
||||
: await fromPrecreated(graph, templateId, config, utils);
|
||||
|
||||
TIME && console.timeEnd("defineHeightmap");
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
// Placeholder function for processing precreated heightmaps
|
||||
// This will need further refactoring to work headlessly (see heightmap-generator_render.md)
|
||||
export async function fromPrecreated(graph, id, config, utils) {
|
||||
// TODO: Implement headless image processing
|
||||
// This function currently requires DOM/Canvas which was removed
|
||||
// Future implementation will need:
|
||||
// - utils.loadImage() function to load PNG files headlessly
|
||||
// - Image processing library (e.g., canvas package for Node.js)
|
||||
// - getHeightsFromImageData() refactored for headless operation
|
||||
throw new Error(`fromPrecreated not yet implemented for headless operation. Template ID: ${id}`);
|
||||
}
|
||||
|
||||
export function fromTemplate(graph, id, config, utils) {
|
||||
const { heightmapTemplates } = utils;
|
||||
const templateString = heightmapTemplates[id]?.template || "";
|
||||
const steps = templateString.split("\n");
|
||||
|
||||
if (!steps.length) throw new Error(`Heightmap template: no steps. Template: ${id}. Steps: ${steps}`);
|
||||
|
||||
let { heights, blobPower, linePower } = setGraph(graph, utils);
|
||||
|
||||
for (const step of steps) {
|
||||
const elements = step.trim().split(" ");
|
||||
if (elements.length < 2) throw new Error(`Heightmap template: steps < 2. Template: ${id}. Step: ${elements}`);
|
||||
heights = addStep(heights, graph, blobPower, linePower, config, utils, ...elements);
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
function setGraph(graph, utils) {
|
||||
const { createTypedArray } = utils;
|
||||
const { cellsDesired, cells, points } = graph;
|
||||
const heights = cells.h ? Uint8Array.from(cells.h) : createTypedArray({ maxValue: 100, length: points.length });
|
||||
const blobPower = getBlobPower(cellsDesired);
|
||||
const linePower = getLinePower(cellsDesired);
|
||||
|
||||
return { heights, blobPower, linePower };
|
||||
}
|
||||
|
||||
function addStep(heights, graph, blobPower, linePower, config, utils, tool, a2, a3, a4, a5) {
|
||||
if (tool === "Hill") return addHill(heights, graph, blobPower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Pit") return addPit(heights, graph, blobPower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Range") return addRange(heights, graph, linePower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Trough") return addTrough(heights, graph, linePower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Strait") return addStrait(heights, graph, config, utils, a2, a3);
|
||||
if (tool === "Mask") return mask(heights, graph, config, utils, a2);
|
||||
if (tool === "Invert") return invert(heights, graph, config, utils, a2, a3);
|
||||
if (tool === "Add") return modify(heights, a3, +a2, 1, utils);
|
||||
if (tool === "Multiply") return modify(heights, a3, 0, +a2, utils);
|
||||
if (tool === "Smooth") return smooth(heights, graph, utils, a2);
|
||||
return heights;
|
||||
}
|
||||
|
||||
function getBlobPower(cells) {
|
||||
const blobPowerMap = {
|
||||
1000: 0.93,
|
||||
2000: 0.95,
|
||||
5000: 0.97,
|
||||
10000: 0.98,
|
||||
20000: 0.99,
|
||||
30000: 0.991,
|
||||
40000: 0.993,
|
||||
50000: 0.994,
|
||||
60000: 0.995,
|
||||
70000: 0.9955,
|
||||
80000: 0.996,
|
||||
90000: 0.9964,
|
||||
100000: 0.9973
|
||||
};
|
||||
return blobPowerMap[cells] || 0.98;
|
||||
}
|
||||
|
||||
function getLinePower(cells) {
|
||||
const linePowerMap = {
|
||||
1000: 0.75,
|
||||
2000: 0.77,
|
||||
5000: 0.79,
|
||||
10000: 0.81,
|
||||
20000: 0.82,
|
||||
30000: 0.83,
|
||||
40000: 0.84,
|
||||
50000: 0.86,
|
||||
60000: 0.87,
|
||||
70000: 0.88,
|
||||
80000: 0.91,
|
||||
90000: 0.92,
|
||||
100000: 0.93
|
||||
};
|
||||
|
||||
return linePowerMap[cells] || 0.81;
|
||||
}
|
||||
|
||||
export function addHill(heights, graph, blobPower, config, utils, count, height, rangeX, rangeY) {
|
||||
const { getNumberInRange, lim, findGridCell } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOneHill();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneHill() {
|
||||
const change = new Uint8Array(heights.length);
|
||||
let limit = 0;
|
||||
let start;
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
do {
|
||||
const x = getPointInRange(rangeX, graphWidth, utils);
|
||||
const y = getPointInRange(rangeY, graphHeight, utils);
|
||||
start = findGridCell(x, y, graph);
|
||||
limit++;
|
||||
} while (heights[start] + h > 90 && limit < 50);
|
||||
|
||||
change[start] = h;
|
||||
const queue = [start];
|
||||
while (queue.length) {
|
||||
const q = queue.shift();
|
||||
|
||||
for (const c of graph.cells.c[q]) {
|
||||
if (change[c]) continue;
|
||||
change[c] = change[q] ** blobPower * (Math.random() * 0.2 + 0.9);
|
||||
if (change[c] > 1) queue.push(c);
|
||||
}
|
||||
}
|
||||
|
||||
heights = heights.map((h, i) => lim(h + change[i]));
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addPit(heights, graph, blobPower, config, utils, count, height, rangeX, rangeY) {
|
||||
const { getNumberInRange, lim, findGridCell } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOnePit();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOnePit() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let limit = 0,
|
||||
start;
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
do {
|
||||
const x = getPointInRange(rangeX, graphWidth, utils);
|
||||
const y = getPointInRange(rangeY, graphHeight, utils);
|
||||
start = findGridCell(x, y, graph);
|
||||
limit++;
|
||||
} while (heights[start] < 20 && limit < 50);
|
||||
|
||||
const queue = [start];
|
||||
while (queue.length) {
|
||||
const q = queue.shift();
|
||||
h = h ** blobPower * (Math.random() * 0.2 + 0.9);
|
||||
if (h < 1) return;
|
||||
|
||||
graph.cells.c[q].forEach(function (c, i) {
|
||||
if (used[c]) return;
|
||||
heights[c] = lim(heights[c] - h * (Math.random() * 0.2 + 0.9));
|
||||
used[c] = 1;
|
||||
queue.push(c);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addRange(heights, graph, linePower, config, utils, count, height, rangeX, rangeY, startCell, endCell) {
|
||||
const { getNumberInRange, lim, findGridCell, d3 } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOneRange();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneRange() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
if (rangeX && rangeY) {
|
||||
// find start and end points
|
||||
const startX = getPointInRange(rangeX, graphWidth, utils);
|
||||
const startY = getPointInRange(rangeY, graphHeight, utils);
|
||||
|
||||
let dist = 0,
|
||||
limit = 0,
|
||||
endX,
|
||||
endY;
|
||||
|
||||
do {
|
||||
endX = Math.random() * graphWidth * 0.8 + graphWidth * 0.1;
|
||||
endY = Math.random() * graphHeight * 0.7 + graphHeight * 0.15;
|
||||
dist = Math.abs(endY - startY) + Math.abs(endX - startX);
|
||||
limit++;
|
||||
} while ((dist < graphWidth / 8 || dist > graphWidth / 3) && limit < 50);
|
||||
|
||||
startCell = findGridCell(startX, startY, graph);
|
||||
endCell = findGridCell(endX, endY, graph);
|
||||
}
|
||||
|
||||
let range = getRange(startCell, endCell);
|
||||
|
||||
// get main ridge
|
||||
function getRange(cur, end) {
|
||||
const range = [cur];
|
||||
const p = graph.points;
|
||||
used[cur] = 1;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
graph.cells.c[cur].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.85) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
if (min === Infinity) return range;
|
||||
range.push(cur);
|
||||
used[cur] = 1;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
// add height to ridge and cells around
|
||||
let queue = range.slice(),
|
||||
i = 0;
|
||||
while (queue.length) {
|
||||
const frontier = queue.slice();
|
||||
(queue = []), i++;
|
||||
frontier.forEach(i => {
|
||||
heights[i] = lim(heights[i] + h * (Math.random() * 0.3 + 0.85));
|
||||
});
|
||||
h = h ** linePower - 1;
|
||||
if (h < 2) break;
|
||||
frontier.forEach(f => {
|
||||
graph.cells.c[f].forEach(i => {
|
||||
if (!used[i]) {
|
||||
queue.push(i);
|
||||
used[i] = 1;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// generate prominences
|
||||
range.forEach((cur, d) => {
|
||||
if (d % 6 !== 0) return;
|
||||
for (const l of d3.range(i)) {
|
||||
const min = graph.cells.c[cur][d3.scan(graph.cells.c[cur], (a, b) => heights[a] - heights[b])]; // downhill cell
|
||||
heights[min] = (heights[cur] * 2 + heights[min]) / 3;
|
||||
cur = min;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addTrough(heights, graph, linePower, config, utils, count, height, rangeX, rangeY, startCell, endCell) {
|
||||
const { getNumberInRange, lim, findGridCell, d3 } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOneTrough();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneTrough() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
if (rangeX && rangeY) {
|
||||
// find start and end points
|
||||
let limit = 0,
|
||||
startX,
|
||||
startY,
|
||||
dist = 0,
|
||||
endX,
|
||||
endY;
|
||||
do {
|
||||
startX = getPointInRange(rangeX, graphWidth, utils);
|
||||
startY = getPointInRange(rangeY, graphHeight, utils);
|
||||
startCell = findGridCell(startX, startY, graph);
|
||||
limit++;
|
||||
} while (heights[startCell] < 20 && limit < 50);
|
||||
|
||||
limit = 0;
|
||||
do {
|
||||
endX = Math.random() * graphWidth * 0.8 + graphWidth * 0.1;
|
||||
endY = Math.random() * graphHeight * 0.7 + graphHeight * 0.15;
|
||||
dist = Math.abs(endY - startY) + Math.abs(endX - startX);
|
||||
limit++;
|
||||
} while ((dist < graphWidth / 8 || dist > graphWidth / 2) && limit < 50);
|
||||
|
||||
endCell = findGridCell(endX, endY, graph);
|
||||
}
|
||||
|
||||
let range = getRange(startCell, endCell);
|
||||
|
||||
// get main ridge
|
||||
function getRange(cur, end) {
|
||||
const range = [cur];
|
||||
const p = graph.points;
|
||||
used[cur] = 1;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
graph.cells.c[cur].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.8) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
if (min === Infinity) return range;
|
||||
range.push(cur);
|
||||
used[cur] = 1;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
// add height to ridge and cells around
|
||||
let queue = range.slice(),
|
||||
i = 0;
|
||||
while (queue.length) {
|
||||
const frontier = queue.slice();
|
||||
(queue = []), i++;
|
||||
frontier.forEach(i => {
|
||||
heights[i] = lim(heights[i] - h * (Math.random() * 0.3 + 0.85));
|
||||
});
|
||||
h = h ** linePower - 1;
|
||||
if (h < 2) break;
|
||||
frontier.forEach(f => {
|
||||
graph.cells.c[f].forEach(i => {
|
||||
if (!used[i]) {
|
||||
queue.push(i);
|
||||
used[i] = 1;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// generate prominences
|
||||
range.forEach((cur, d) => {
|
||||
if (d % 6 !== 0) return;
|
||||
for (const l of d3.range(i)) {
|
||||
const min = graph.cells.c[cur][d3.scan(graph.cells.c[cur], (a, b) => heights[a] - heights[b])]; // downhill cell
|
||||
//debug.append("circle").attr("cx", p[min][0]).attr("cy", p[min][1]).attr("r", 1);
|
||||
heights[min] = (heights[cur] * 2 + heights[min]) / 3;
|
||||
cur = min;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addStrait(heights, graph, config, utils, width, direction = "vertical") {
|
||||
const { getNumberInRange, findGridCell, P } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
width = Math.min(getNumberInRange(width), graph.cellsX / 3);
|
||||
if (width < 1 && P(width)) return heights;
|
||||
|
||||
const used = new Uint8Array(heights.length);
|
||||
const vert = direction === "vertical";
|
||||
const startX = vert ? Math.floor(Math.random() * graphWidth * 0.4 + graphWidth * 0.3) : 5;
|
||||
const startY = vert ? 5 : Math.floor(Math.random() * graphHeight * 0.4 + graphHeight * 0.3);
|
||||
const endX = vert
|
||||
? Math.floor(graphWidth - startX - graphWidth * 0.1 + Math.random() * graphWidth * 0.2)
|
||||
: graphWidth - 5;
|
||||
const endY = vert
|
||||
? graphHeight - 5
|
||||
: Math.floor(graphHeight - startY - graphHeight * 0.1 + Math.random() * graphHeight * 0.2);
|
||||
|
||||
const start = findGridCell(startX, startY, graph);
|
||||
const end = findGridCell(endX, endY, graph);
|
||||
let range = getRange(start, end);
|
||||
const query = [];
|
||||
|
||||
function getRange(cur, end) {
|
||||
const range = [];
|
||||
const p = graph.points;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
graph.cells.c[cur].forEach(function (e) {
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.8) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
range.push(cur);
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
const step = 0.1 / width;
|
||||
|
||||
while (width > 0) {
|
||||
const exp = 0.9 - step * width;
|
||||
range.forEach(function (r) {
|
||||
graph.cells.c[r].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
used[e] = 1;
|
||||
query.push(e);
|
||||
heights[e] **= exp;
|
||||
if (heights[e] > 100) heights[e] = 5;
|
||||
});
|
||||
});
|
||||
range = query.slice();
|
||||
|
||||
width--;
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function modify(heights, range, add, mult, power, utils) {
|
||||
const { lim } = utils;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
const min = range === "land" ? 20 : range === "all" ? 0 : +range.split("-")[0];
|
||||
const max = range === "land" || range === "all" ? 100 : +range.split("-")[1];
|
||||
const isLand = min === 20;
|
||||
|
||||
heights = heights.map(h => {
|
||||
if (h < min || h > max) return h;
|
||||
|
||||
if (add) h = isLand ? Math.max(h + add, 20) : h + add;
|
||||
if (mult !== 1) h = isLand ? (h - 20) * mult + 20 : h * mult;
|
||||
if (power) h = isLand ? (h - 20) ** power + 20 : h ** power;
|
||||
return lim(h);
|
||||
});
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function smooth(heights, graph, utils, fr = 2, add = 0) {
|
||||
const { lim, d3 } = utils;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
heights = heights.map((h, i) => {
|
||||
const a = [h];
|
||||
graph.cells.c[i].forEach(c => a.push(heights[c]));
|
||||
if (fr === 1) return d3.mean(a) + add;
|
||||
return lim((h * (fr - 1) + d3.mean(a) + add) / fr);
|
||||
});
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function mask(heights, graph, config, utils, power = 1) {
|
||||
const { lim } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
const fr = power ? Math.abs(power) : 1;
|
||||
|
||||
heights = heights.map((h, i) => {
|
||||
const [x, y] = graph.points[i];
|
||||
const nx = (2 * x) / graphWidth - 1; // [-1, 1], 0 is center
|
||||
const ny = (2 * y) / graphHeight - 1; // [-1, 1], 0 is center
|
||||
let distance = (1 - nx ** 2) * (1 - ny ** 2); // 1 is center, 0 is edge
|
||||
if (power < 0) distance = 1 - distance; // inverted, 0 is center, 1 is edge
|
||||
const masked = h * distance;
|
||||
return lim((h * (fr - 1) + masked) / fr);
|
||||
});
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function invert(heights, graph, config, utils, count, axes) {
|
||||
const { P } = utils;
|
||||
|
||||
if (!P(count)) return heights;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
const invertX = axes !== "y";
|
||||
const invertY = axes !== "x";
|
||||
const { cellsX, cellsY } = graph;
|
||||
|
||||
const inverted = heights.map((h, i) => {
|
||||
const x = i % cellsX;
|
||||
const y = Math.floor(i / cellsX);
|
||||
|
||||
const nx = invertX ? cellsX - x - 1 : x;
|
||||
const ny = invertY ? cellsY - y - 1 : y;
|
||||
const invertedI = nx + ny * cellsX;
|
||||
return heights[invertedI];
|
||||
});
|
||||
|
||||
return inverted;
|
||||
}
|
||||
|
||||
function getPointInRange(range, length, utils) {
|
||||
const { rand } = utils;
|
||||
|
||||
if (typeof range !== "string") {
|
||||
console.error("Range should be a string");
|
||||
return;
|
||||
}
|
||||
|
||||
const min = range.split("-")[0] / 100 || 0;
|
||||
const max = range.split("-")[1] / 100 || min;
|
||||
return rand(min * length, max * length);
|
||||
}
|
||||
142
procedural/src/engine/modules/lakes.js
Normal file
142
procedural/src/engine/modules/lakes.js
Normal file
|
|
@ -0,0 +1,142 @@
|
|||
"use strict";
|
||||
|
||||
const LAKE_ELEVATION_DELTA = 0.1;
|
||||
|
||||
// check if lake can be potentially open (not in deep depression)
|
||||
export function detectCloseLakes(pack, grid, heights, config) {
|
||||
const {cells, features} = pack;
|
||||
const ELEVATION_LIMIT = config.lakeElevationLimit;
|
||||
|
||||
const updatedFeatures = features.map(feature => {
|
||||
if (feature.type !== "lake") return feature;
|
||||
|
||||
const updatedFeature = {...feature};
|
||||
delete updatedFeature.closed;
|
||||
|
||||
const MAX_ELEVATION = feature.height + ELEVATION_LIMIT;
|
||||
if (MAX_ELEVATION > 99) {
|
||||
updatedFeature.closed = false;
|
||||
return updatedFeature;
|
||||
}
|
||||
|
||||
let isDeep = true;
|
||||
const lowestShorelineCell = feature.shoreline.sort((a, b) => heights[a] - heights[b])[0];
|
||||
const queue = [lowestShorelineCell];
|
||||
const checked = [];
|
||||
checked[lowestShorelineCell] = true;
|
||||
|
||||
while (queue.length && isDeep) {
|
||||
const cellId = queue.pop();
|
||||
|
||||
for (const neibCellId of cells.c[cellId]) {
|
||||
if (checked[neibCellId]) continue;
|
||||
if (heights[neibCellId] >= MAX_ELEVATION) continue;
|
||||
|
||||
if (heights[neibCellId] < 20) {
|
||||
const nFeature = features[cells.f[neibCellId]];
|
||||
if (nFeature.type === "ocean" || feature.height > nFeature.height) isDeep = false;
|
||||
}
|
||||
|
||||
checked[neibCellId] = true;
|
||||
queue.push(neibCellId);
|
||||
}
|
||||
}
|
||||
|
||||
updatedFeature.closed = isDeep;
|
||||
return updatedFeature;
|
||||
});
|
||||
|
||||
return {
|
||||
...pack,
|
||||
features: updatedFeatures
|
||||
};
|
||||
}
|
||||
|
||||
export function defineClimateData(pack, grid, heights, config, utils) {
|
||||
const {d3, rn} = utils;
|
||||
const {cells, features} = pack;
|
||||
const lakeOutCells = new Uint16Array(cells.i.length);
|
||||
|
||||
const updatedFeatures = features.map(feature => {
|
||||
if (feature.type !== "lake") return feature;
|
||||
|
||||
const updatedFeature = {...feature};
|
||||
updatedFeature.flux = getFlux(feature);
|
||||
updatedFeature.temp = getLakeTemp(feature);
|
||||
updatedFeature.evaporation = getLakeEvaporation(feature);
|
||||
|
||||
if (feature.closed) return updatedFeature; // no outlet for lakes in depressed areas
|
||||
|
||||
updatedFeature.outCell = getLowestShoreCell(feature);
|
||||
lakeOutCells[updatedFeature.outCell] = feature.i;
|
||||
|
||||
return updatedFeature;
|
||||
});
|
||||
|
||||
function getFlux(lake) {
|
||||
return lake.shoreline.reduce((acc, c) => acc + grid.cells.prec[cells.g[c]], 0);
|
||||
}
|
||||
|
||||
function getLakeTemp(lake) {
|
||||
if (lake.cells < 6) return grid.cells.temp[cells.g[lake.firstCell]];
|
||||
return rn(d3.mean(lake.shoreline.map(c => grid.cells.temp[cells.g[c]])), 1);
|
||||
}
|
||||
|
||||
function getLakeEvaporation(lake) {
|
||||
const height = (lake.height - 18) ** config.heightExponent; // height in meters
|
||||
const evaporation = ((700 * (lake.temp + 0.006 * height)) / 50 + 75) / (80 - lake.temp); // based on Penman formula, [1-11]
|
||||
return rn(evaporation * lake.cells);
|
||||
}
|
||||
|
||||
function getLowestShoreCell(lake) {
|
||||
return lake.shoreline.sort((a, b) => heights[a] - heights[b])[0];
|
||||
}
|
||||
|
||||
return {
|
||||
pack: {
|
||||
...pack,
|
||||
features: updatedFeatures
|
||||
},
|
||||
lakeOutCells
|
||||
};
|
||||
}
|
||||
|
||||
export function cleanupLakeData(pack) {
|
||||
const updatedFeatures = pack.features.map(feature => {
|
||||
if (feature.type !== "lake") return feature;
|
||||
|
||||
const updatedFeature = {...feature};
|
||||
delete updatedFeature.river;
|
||||
delete updatedFeature.enteringFlux;
|
||||
delete updatedFeature.outCell;
|
||||
delete updatedFeature.closed;
|
||||
updatedFeature.height = Math.round(feature.height * 1000) / 1000; // rn(feature.height, 3)
|
||||
|
||||
const inlets = feature.inlets?.filter(r => pack.rivers.find(river => river.i === r));
|
||||
if (!inlets || !inlets.length) delete updatedFeature.inlets;
|
||||
else updatedFeature.inlets = inlets;
|
||||
|
||||
const outlet = feature.outlet && pack.rivers.find(river => river.i === feature.outlet);
|
||||
if (!outlet) delete updatedFeature.outlet;
|
||||
|
||||
return updatedFeature;
|
||||
});
|
||||
|
||||
return {
|
||||
...pack,
|
||||
features: updatedFeatures
|
||||
};
|
||||
}
|
||||
|
||||
export function getHeight(feature, pack, utils) {
|
||||
const {d3, rn} = utils;
|
||||
const heights = pack.cells.h;
|
||||
const minShoreHeight = d3.min(feature.shoreline.map(cellId => heights[cellId])) || 20;
|
||||
return rn(minShoreHeight - LAKE_ELEVATION_DELTA, 2);
|
||||
}
|
||||
|
||||
export function getName(feature, pack, Names) {
|
||||
const landCell = pack.cells.c[feature.firstCell].find(c => pack.cells.h[c] >= 20);
|
||||
const culture = pack.cells.culture[landCell];
|
||||
return Names.getCulture(culture);
|
||||
}
|
||||
967
procedural/src/engine/modules/markers-generator.js
Normal file
967
procedural/src/engine/modules/markers-generator.js
Normal file
|
|
@ -0,0 +1,967 @@
|
|||
"use strict";
|
||||
|
||||
export function getDefaultMarkersConfig(config, utils) {
|
||||
const {Names} = utils;
|
||||
const culturesSet = config.culturesSet;
|
||||
const isFantasy = culturesSet.includes("Fantasy");
|
||||
|
||||
/*
|
||||
Default markers config:
|
||||
type - short description (snake-case)
|
||||
icon - unicode character or url to image
|
||||
dx: icon offset in x direction, in pixels
|
||||
dy: icon offset in y direction, in pixels
|
||||
min: minimum number of candidates to add at least 1 marker
|
||||
each: how many of the candidates should be added as markers
|
||||
multiplier: multiply markers quantity to add
|
||||
list: function to select candidates
|
||||
add: function to add marker legend
|
||||
*/
|
||||
// prettier-ignore
|
||||
return [
|
||||
{type: "volcanoes", icon: "🌋", dx: 52, px: 13, min: 10, each: 500, multiplier: 1, list: listVolcanoes, add: addVolcano},
|
||||
{type: "hot-springs", icon: "♨️", dy: 52, min: 30, each: 1200, multiplier: 1, list: listHotSprings, add: addHotSpring},
|
||||
{type: "water-sources", icon: "💧", min: 1, each: 1000, multiplier: 1, list: listWaterSources, add: addWaterSource},
|
||||
{type: "mines", icon: "⛏️", dx: 48, px: 13, min: 1, each: 15, multiplier: 1, list: listMines, add: addMine},
|
||||
{type: "bridges", icon: "🌉", px: 14, min: 1, each: 5, multiplier: 1, list: listBridges, add: addBridge},
|
||||
{type: "inns", icon: "🍻", px: 14, min: 1, each: 10, multiplier: 1, list: listInns, add: addInn},
|
||||
{type: "lighthouses", icon: "🚨", px: 14, min: 1, each: 2, multiplier: 1, list: listLighthouses, add: addLighthouse},
|
||||
{type: "waterfalls", icon: "⟱", dy: 54, px: 16, min: 1, each: 5, multiplier: 1, list: listWaterfalls, add: addWaterfall},
|
||||
{type: "battlefields", icon: "⚔️", dy: 52, min: 50, each: 700, multiplier: 1, list: listBattlefields, add: addBattlefield},
|
||||
{type: "dungeons", icon: "🗝️", dy: 51, px: 13, min: 30, each: 200, multiplier: 1, list: listDungeons, add: addDungeon},
|
||||
{type: "lake-monsters", icon: "🐉", dy: 48, min: 2, each: 10, multiplier: 1, list: listLakeMonsters, add: addLakeMonster},
|
||||
{type: "sea-monsters", icon: "🦑", min: 50, each: 700, multiplier: 1, list: listSeaMonsters, add: addSeaMonster},
|
||||
{type: "hill-monsters", icon: "👹", dy: 54, px: 13, min: 30, each: 600, multiplier: 1, list: listHillMonsters, add: addHillMonster},
|
||||
{type: "sacred-mountains", icon: "🗻", dy: 48, min: 1, each: 5, multiplier: 1, list: listSacredMountains, add: addSacredMountain},
|
||||
{type: "sacred-forests", icon: "🌳", min: 30, each: 1000, multiplier: 1, list: listSacredForests, add: addSacredForest},
|
||||
{type: "sacred-pineries", icon: "🌲", px: 13, min: 30, each: 800, multiplier: 1, list: listSacredPineries, add: addSacredPinery},
|
||||
{type: "sacred-palm-groves", icon: "🌴", px: 13, min: 1, each: 100, multiplier: 1, list: listSacredPalmGroves, add: addSacredPalmGrove},
|
||||
{type: "brigands", icon: "💰", px: 13, min: 50, each: 100, multiplier: 1, list: listBrigands, add: addBrigands},
|
||||
{type: "pirates", icon: "🏴☠️", dx: 51, min: 40, each: 300, multiplier: 1, list: listPirates, add: addPirates},
|
||||
{type: "statues", icon: "🗿", min: 80, each: 1200, multiplier: 1, list: listStatues, add: addStatue},
|
||||
{type: "ruins", icon: "🏺", min: 80, each: 1200, multiplier: 1, list: listRuins, add: addRuins},
|
||||
{type: "libraries", icon: "📚", min: 10, each: 1200, multiplier: 1, list: listLibraries, add: addLibrary},
|
||||
{type: "circuses", icon: "🎪", min: 80, each: 1000, multiplier: 1, list: listCircuses, add: addCircuse},
|
||||
{type: "jousts", icon: "🤺", dx: 48, min: 5, each: 500, multiplier: 1, list: listJousts, add: addJoust},
|
||||
{type: "fairs", icon: "🎠", min: 50, each: 1000, multiplier: 1, list: listFairs, add: addFair},
|
||||
{type: "canoes", icon: "🛶", min: 500, each: 2000, multiplier: 1, list: listCanoes, add: addCanoe},
|
||||
{type: "migration", icon: "🐗", min: 20, each: 1000, multiplier: 1, list: listMigrations, add: addMigration},
|
||||
{type: "dances", icon: "💃🏽", min: 50, each: 1000, multiplier: 1, list: listDances, add: addDances},
|
||||
{type: "mirage", icon: "💦", min: 10, each: 400, multiplier: 1, list: listMirage, add: addMirage},
|
||||
{type: "caves", icon:"🦇", min: 60, each: 1000, multiplier: 1, list: listCaves, add: addCave},
|
||||
{type: "portals", icon: "🌀", px: 14, min: 16, each: 8, multiplier: +isFantasy, list: listPortals, add: addPortal},
|
||||
{type: "rifts", icon: "🎆", min: 5, each: 3000, multiplier: +isFantasy, list: listRifts, add: addRift},
|
||||
{type: "disturbed-burials", icon: "💀", min: 20, each: 3000, multiplier: +isFantasy, list: listDisturbedBurial, add: addDisturbedBurial},
|
||||
{type: "necropolises", icon: "🪦", min: 20, each: 1000, multiplier: 1, list: listNecropolis, add: addNecropolis},
|
||||
{type: "encounters", icon: "🧙", min: 10, each: 600, multiplier: 1, list: listEncounters, add: addEncounter},
|
||||
];
|
||||
}
|
||||
|
||||
export function generateMarkers(pack, config, utils) {
|
||||
const {TIME} = utils;
|
||||
const markersConfig = getDefaultMarkersConfig(config, utils);
|
||||
const markers = [];
|
||||
const notes = [];
|
||||
const occupied = [];
|
||||
|
||||
TIME && console.time("addMarkers");
|
||||
|
||||
markersConfig.forEach(({type, icon, dx, dy, px, min, each, multiplier, list, add}) => {
|
||||
if (multiplier === 0) return;
|
||||
|
||||
let candidates = Array.from(list(pack, utils));
|
||||
let quantity = getQuantity(candidates, min, each, multiplier);
|
||||
// uncomment for debugging:
|
||||
// console.info(`${icon} ${type}: each ${each} of ${candidates.length}, min ${min} candidates. Got ${quantity}`);
|
||||
|
||||
while (quantity && candidates.length) {
|
||||
const [cell] = extractAnyElement(candidates);
|
||||
const marker = addMarker({icon, type, dx, dy, px}, {cell}, pack, occupied, utils);
|
||||
if (!marker) continue;
|
||||
markers.push(marker);
|
||||
add("marker" + marker.i, cell, pack, notes, utils);
|
||||
quantity--;
|
||||
}
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("addMarkers");
|
||||
|
||||
return { markers, notes };
|
||||
}
|
||||
|
||||
export function regenerateMarkers(pack, existingMarkers, config, utils) {
|
||||
const occupied = [];
|
||||
const filteredMarkers = existingMarkers.filter(({i, lock, cell}) => {
|
||||
if (lock) {
|
||||
occupied[cell] = true;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
|
||||
const { markers: newMarkers, notes } = generateMarkers(pack, config, utils);
|
||||
|
||||
return {
|
||||
markers: [...filteredMarkers, ...newMarkers],
|
||||
notes,
|
||||
removedMarkerIds: existingMarkers.filter(m => !m.lock).map(m => "marker" + m.i)
|
||||
};
|
||||
}
|
||||
|
||||
export function addSingleMarker(marker, pack, config, utils) {
|
||||
const markersConfig = getDefaultMarkersConfig(config, utils);
|
||||
const base = markersConfig.find(c => c.type === marker.type);
|
||||
const notes = [];
|
||||
|
||||
if (base) {
|
||||
const {icon, type, dx, dy, px} = base;
|
||||
const newMarker = addMarker({icon, type, dx, dy, px}, marker, pack, [], utils);
|
||||
if (newMarker) {
|
||||
base.add("marker" + newMarker.i, newMarker.cell, pack, notes, utils);
|
||||
return { marker: newMarker, notes };
|
||||
}
|
||||
}
|
||||
|
||||
const i = 0; // Will be set by caller
|
||||
const finalMarker = {...marker, i};
|
||||
return { marker: finalMarker, notes };
|
||||
}
|
||||
|
||||
function getQuantity(array, min, each, multiplier) {
|
||||
if (!array.length || array.length < min / multiplier) return 0;
|
||||
const requestQty = Math.ceil((array.length / each) * multiplier);
|
||||
return array.length < requestQty ? array.length : requestQty;
|
||||
}
|
||||
|
||||
function extractAnyElement(array) {
|
||||
const index = Math.floor(Math.random() * array.length);
|
||||
return array.splice(index, 1);
|
||||
}
|
||||
|
||||
function getMarkerCoordinates(cell, pack) {
|
||||
const {cells, burgs} = pack;
|
||||
const burgId = cells.burg[cell];
|
||||
|
||||
if (burgId) {
|
||||
const {x, y} = burgs[burgId];
|
||||
return [x, y];
|
||||
}
|
||||
|
||||
return cells.p[cell];
|
||||
}
|
||||
|
||||
function addMarker(base, marker, pack, occupied, utils) {
|
||||
if (marker.cell === undefined) return;
|
||||
const {last} = utils;
|
||||
const i = last(pack.markers)?.i + 1 || 0;
|
||||
const [x, y] = getMarkerCoordinates(marker.cell, pack);
|
||||
const finalMarker = {...base, x, y, ...marker, i};
|
||||
occupied[marker.cell] = true;
|
||||
return finalMarker;
|
||||
}
|
||||
|
||||
function listVolcanoes({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 70);
|
||||
}
|
||||
|
||||
function addVolcano(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, P, getFriendlyHeight} = utils;
|
||||
|
||||
const proper = Names.getCulture(cells.culture[cell]);
|
||||
const name = P(0.3) ? "Mount " + proper : P(0.7) ? proper + " Volcano" : proper;
|
||||
const status = P(0.6) ? "Dormant" : P(0.4) ? "Active" : "Erupting";
|
||||
notes.push({id, name, legend: `${status} volcano. Height: ${getFriendlyHeight(cells.p[cell])}.`});
|
||||
}
|
||||
|
||||
function listHotSprings({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] > 50 && cells.culture[i]);
|
||||
}
|
||||
|
||||
function addHotSpring(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, P, gauss, convertTemperature} = utils;
|
||||
|
||||
const proper = Names.getCulture(cells.culture[cell]);
|
||||
const temp = convertTemperature(gauss(35, 15, 20, 100));
|
||||
const name = P(0.3) ? "Hot Springs of " + proper : P(0.7) ? proper + " Hot Springs" : proper;
|
||||
const legend = `A geothermal springs with naturally heated water that provide relaxation and medicinal benefits. Average temperature is ${temp}.`;
|
||||
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listWaterSources({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] > 30 && cells.r[i]);
|
||||
}
|
||||
|
||||
function addWaterSource(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, rw} = utils;
|
||||
|
||||
const type = rw({
|
||||
"Healing Spring": 5,
|
||||
"Purifying Well": 2,
|
||||
"Enchanted Reservoir": 1,
|
||||
"Creek of Luck": 1,
|
||||
"Fountain of Youth": 1,
|
||||
"Wisdom Spring": 1,
|
||||
"Spring of Life": 1,
|
||||
"Spring of Youth": 1,
|
||||
"Healing Stream": 1
|
||||
});
|
||||
|
||||
const proper = Names.getCulture(cells.culture[cell]);
|
||||
const name = `${proper} ${type}`;
|
||||
const legend =
|
||||
"This legendary water source is whispered about in ancient tales and believed to possess mystical properties. The spring emanates crystal-clear water, shimmering with an otherworldly iridescence that sparkles even in the dimmest light.";
|
||||
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listMines({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] > 47 && cells.burg[i]);
|
||||
}
|
||||
|
||||
function addMine(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {rw, rn, populationRate, urbanization} = utils;
|
||||
|
||||
const resources = {salt: 5, gold: 2, silver: 4, copper: 2, iron: 3, lead: 1, tin: 1};
|
||||
const resource = rw(resources);
|
||||
const burg = pack.burgs[cells.burg[cell]];
|
||||
const name = `${burg.name} — ${resource} mining town`;
|
||||
const population = rn(burg.population * populationRate * urbanization);
|
||||
const legend = `${burg.name} is a mining town of ${population} people just nearby the ${resource} mine.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listBridges({cells, burgs}, utils) {
|
||||
const {d3} = utils;
|
||||
const occupied = [];
|
||||
const meanFlux = d3.mean(cells.fl.filter(fl => fl));
|
||||
return cells.i.filter(
|
||||
i =>
|
||||
!occupied[i] &&
|
||||
cells.burg[i] &&
|
||||
cells.t[i] !== 1 &&
|
||||
burgs[cells.burg[i]].population > 20 &&
|
||||
cells.r[i] &&
|
||||
cells.fl[i] > meanFlux
|
||||
);
|
||||
}
|
||||
|
||||
function addBridge(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {P, rw, ra} = utils;
|
||||
|
||||
const burg = pack.burgs[cells.burg[cell]];
|
||||
const river = pack.rivers.find(r => r.i === pack.cells.r[cell]);
|
||||
const riverName = river ? `${river.name} ${river.type}` : "river";
|
||||
const name = river && P(0.2) ? `${river.name} Bridge` : `${burg.name} Bridge`;
|
||||
const weightedAdjectives = {
|
||||
stone: 10,
|
||||
wooden: 1,
|
||||
lengthy: 2,
|
||||
formidable: 2,
|
||||
rickety: 1,
|
||||
beaten: 1,
|
||||
weathered: 1
|
||||
};
|
||||
const barriers = [
|
||||
"its collapse during the flood",
|
||||
"being rumoured to attract trolls",
|
||||
"the drying up of local trade",
|
||||
"banditry infested the area",
|
||||
"the old waypoints crumbled"
|
||||
];
|
||||
const legend = P(0.7)
|
||||
? `A ${rw(weightedAdjectives)} bridge spans over the ${riverName} near ${burg.name}.`
|
||||
: `An old crossing of the ${riverName}, rarely used since ${ra(barriers)}.`;
|
||||
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listInns({cells}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
const crossRoads = cells.i.filter(i => !occupied[i] && cells.pop[i] > 5 && Routes.isCrossroad(i));
|
||||
return crossRoads;
|
||||
}
|
||||
|
||||
function addInn(id, cell, pack, notes, utils) {
|
||||
const {P, ra, capitalize} = utils;
|
||||
|
||||
const colors = [
|
||||
"Dark", "Light", "Bright", "Golden", "White", "Black", "Red", "Pink", "Purple", "Blue",
|
||||
"Green", "Yellow", "Amber", "Orange", "Brown", "Grey"
|
||||
];
|
||||
const animals = [
|
||||
"Antelope", "Ape", "Badger", "Bear", "Beaver", "Bison", "Boar", "Buffalo", "Cat", "Crane",
|
||||
"Crocodile", "Crow", "Deer", "Dog", "Eagle", "Elk", "Fox", "Goat", "Goose", "Hare",
|
||||
"Hawk", "Heron", "Horse", "Hyena", "Ibis", "Jackal", "Jaguar", "Lark", "Leopard", "Lion",
|
||||
"Mantis", "Marten", "Moose", "Mule", "Narwhal", "Owl", "Panther", "Rat", "Raven", "Rook",
|
||||
"Scorpion", "Shark", "Sheep", "Snake", "Spider", "Swan", "Tiger", "Turtle", "Wolf",
|
||||
"Wolverine", "Camel", "Falcon", "Hound", "Ox"
|
||||
];
|
||||
const adjectives = [
|
||||
"New", "Good", "High", "Old", "Great", "Big", "Major", "Happy", "Main", "Huge", "Far",
|
||||
"Beautiful", "Fair", "Prime", "Ancient", "Golden", "Proud", "Lucky", "Fat", "Honest",
|
||||
"Giant", "Distant", "Friendly", "Loud", "Hungry", "Magical", "Superior", "Peaceful",
|
||||
"Frozen", "Divine", "Favorable", "Brave", "Sunny", "Flying"
|
||||
];
|
||||
const methods = [
|
||||
"Boiled", "Grilled", "Roasted", "Spit-roasted", "Stewed", "Stuffed", "Jugged", "Mashed",
|
||||
"Baked", "Braised", "Poached", "Marinated", "Pickled", "Smoked", "Dried", "Dry-aged",
|
||||
"Corned", "Fried", "Pan-fried", "Deep-fried", "Dressed", "Steamed", "Cured", "Syrupped",
|
||||
"Flame-Broiled"
|
||||
];
|
||||
const courses = [
|
||||
"beef", "pork", "bacon", "chicken", "lamb", "chevon", "hare", "rabbit", "hart", "deer",
|
||||
"antlers", "bear", "buffalo", "badger", "beaver", "turkey", "pheasant", "duck", "goose",
|
||||
"teal", "quail", "pigeon", "seal", "carp", "bass", "pike", "catfish", "sturgeon",
|
||||
"escallop", "pie", "cake", "pottage", "pudding", "onions", "carrot", "potato", "beet",
|
||||
"garlic", "cabbage", "eggplant", "eggs", "broccoli", "zucchini", "pepper", "olives",
|
||||
"pumpkin", "spinach", "peas", "chickpea", "beans", "rice", "pasta", "bread", "apples",
|
||||
"peaches", "pears", "melon", "oranges", "mango", "tomatoes", "cheese", "corn", "rat tails",
|
||||
"pig ears"
|
||||
];
|
||||
const types = ["hot", "cold", "fire", "ice", "smoky", "misty", "shiny", "sweet", "bitter", "salty", "sour", "sparkling", "smelly"];
|
||||
const drinks = [
|
||||
"wine", "brandy", "gin", "whisky", "rom", "beer", "cider", "mead", "liquor", "spirits",
|
||||
"vodka", "tequila", "absinthe", "nectar", "milk", "kvass", "kumis", "tea", "water", "juice", "sap"
|
||||
];
|
||||
|
||||
const typeName = P(0.3) ? "inn" : "tavern";
|
||||
const isAnimalThemed = P(0.7);
|
||||
const animal = ra(animals);
|
||||
const name = isAnimalThemed
|
||||
? P(0.6)
|
||||
? ra(colors) + " " + animal
|
||||
: ra(adjectives) + " " + animal
|
||||
: ra(adjectives) + " " + capitalize(typeName);
|
||||
const meal = isAnimalThemed && P(0.3) ? animal : ra(courses);
|
||||
const course = `${ra(methods)} ${meal}`.toLowerCase();
|
||||
const drink = `${P(0.5) ? ra(types) : ra(colors)} ${ra(drinks)}`.toLowerCase();
|
||||
const legend = `A big and famous roadside ${typeName}. Delicious ${course} with ${drink} is served here.`;
|
||||
notes.push({id, name: "The " + name, legend});
|
||||
}
|
||||
|
||||
function listLighthouses({cells}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i => !occupied[i] && cells.harbor[i] > 6 && cells.c[i].some(c => cells.h[c] < 20 && Routes.isConnected(c))
|
||||
);
|
||||
}
|
||||
|
||||
function addLighthouse(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, getAdjective} = utils;
|
||||
|
||||
const proper = cells.burg[cell] ? pack.burgs[cells.burg[cell]].name : Names.getCulture(cells.culture[cell]);
|
||||
notes.push({
|
||||
id,
|
||||
name: getAdjective(proper) + " Lighthouse",
|
||||
legend: `A lighthouse to serve as a beacon for ships in the open sea.`
|
||||
});
|
||||
}
|
||||
|
||||
function listWaterfalls({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i => cells.r[i] && !occupied[i] && cells.h[i] >= 50 && cells.c[i].some(c => cells.h[c] < 40 && cells.r[c])
|
||||
);
|
||||
}
|
||||
|
||||
function addWaterfall(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, ra, getAdjective} = utils;
|
||||
|
||||
const descriptions = [
|
||||
"A gorgeous waterfall flows here.",
|
||||
"The rapids of an exceptionally beautiful waterfall.",
|
||||
"An impressive waterfall has cut through the land.",
|
||||
"The cascades of a stunning waterfall.",
|
||||
"A river drops down from a great height forming a wonderous waterfall.",
|
||||
"A breathtaking waterfall cuts through the landscape."
|
||||
];
|
||||
|
||||
const proper = cells.burg[cell] ? pack.burgs[cells.burg[cell]].name : Names.getCulture(cells.culture[cell]);
|
||||
notes.push({id, name: getAdjective(proper) + " Waterfall", legend: `${ra(descriptions)}`});
|
||||
}
|
||||
|
||||
function listBattlefields({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i => !occupied[i] && cells.state[i] && cells.pop[i] > 2 && cells.h[i] < 50 && cells.h[i] > 25
|
||||
);
|
||||
}
|
||||
|
||||
function addBattlefield(id, cell, pack, notes, utils) {
|
||||
const {cells, states} = pack;
|
||||
const {Names, BurgsAndStates, ra, generateDate, options} = utils;
|
||||
|
||||
const state = states[cells.state[cell]];
|
||||
if (!state.campaigns) state.campaigns = BurgsAndStates.generateCampaign(state);
|
||||
const campaign = ra(state.campaigns);
|
||||
const date = generateDate(campaign.start, campaign.end);
|
||||
const name = Names.getCulture(cells.culture[cell]) + " Battlefield";
|
||||
const legend = `A historical battle of the ${campaign.name}. \\r\\nDate: ${date} ${options.era}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listDungeons({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.pop[i] && cells.pop[i] < 3);
|
||||
}
|
||||
|
||||
function addDungeon(id, cell, pack, notes, utils) {
|
||||
const {seed} = utils;
|
||||
const dungeonSeed = `${seed}${cell}`;
|
||||
const name = "Dungeon";
|
||||
const legend = `<div>Undiscovered dungeon. See <a href="https://watabou.github.io/one-page-dungeon/?seed=${dungeonSeed}" target="_blank">One page dungeon</a></div><iframe style="pointer-events: none;" src="https://watabou.github.io/one-page-dungeon/?seed=${dungeonSeed}" sandbox="allow-scripts allow-same-origin"></iframe>`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listLakeMonsters({features}, utils) {
|
||||
const occupied = [];
|
||||
return features
|
||||
.filter(feature => feature.type === "lake" && feature.group === "freshwater" && !occupied[feature.firstCell])
|
||||
.map(feature => feature.firstCell);
|
||||
}
|
||||
|
||||
function addLakeMonster(id, cell, pack, notes, utils) {
|
||||
const {gauss, ra, heightUnit} = utils;
|
||||
const lake = pack.features[pack.cells.f[cell]];
|
||||
|
||||
// Check that the feature is a lake in case the user clicked on a wrong square
|
||||
if (lake.type !== "lake") return;
|
||||
|
||||
const name = `${lake.name} Monster`;
|
||||
const length = gauss(10, 5, 5, 100);
|
||||
const subjects = [
|
||||
"Locals", "Elders", "Inscriptions", "Tipplers", "Legends", "Whispers", "Rumors", "Journeying folk", "Tales"
|
||||
];
|
||||
const legend = `${ra(subjects)} say a relic monster of ${length} ${heightUnit.value} long inhabits ${
|
||||
lake.name
|
||||
} Lake. Truth or lie, folks are afraid to fish in the lake.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listSeaMonsters({cells, features}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i => !occupied[i] && cells.h[i] < 20 && Routes.isConnected(i) && features[cells.f[i]].type === "ocean"
|
||||
);
|
||||
}
|
||||
|
||||
function addSeaMonster(id, cell, pack, notes, utils) {
|
||||
const {Names, gauss, heightUnit} = utils;
|
||||
const name = `${Names.getCultureShort(0)} Monster`;
|
||||
const length = gauss(25, 10, 10, 100);
|
||||
const legend = `Old sailors tell stories of a gigantic sea monster inhabiting these dangerous waters. Rumors say it can be ${length} ${heightUnit.value} long.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listHillMonsters({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 50 && cells.pop[i]);
|
||||
}
|
||||
|
||||
function addHillMonster(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, ra} = utils;
|
||||
|
||||
const adjectives = [
|
||||
"great", "big", "huge", "prime", "golden", "proud", "lucky", "fat", "giant", "hungry",
|
||||
"magical", "superior", "terrifying", "horrifying", "feared"
|
||||
];
|
||||
const subjects = [
|
||||
"Locals", "Elders", "Inscriptions", "Tipplers", "Legends", "Whispers", "Rumors", "Journeying folk", "Tales"
|
||||
];
|
||||
const species = [
|
||||
"Ogre", "Troll", "Cyclops", "Giant", "Monster", "Beast", "Dragon", "Undead", "Ghoul",
|
||||
"Vampire", "Hag", "Banshee", "Bearded Devil", "Roc", "Hydra", "Warg"
|
||||
];
|
||||
const modusOperandi = [
|
||||
"steals cattle at night", "prefers eating children", "doesn't mind human flesh", "keeps the region at bay",
|
||||
"eats kids whole", "abducts young women", "terrorizes the region", "harasses travelers in the area",
|
||||
"snatches people from homes", "attacks anyone who dares to approach its lair", "attacks unsuspecting victims"
|
||||
];
|
||||
|
||||
const monster = ra(species);
|
||||
const toponym = Names.getCulture(cells.culture[cell]);
|
||||
const name = `${toponym} ${monster}`;
|
||||
const legend = `${ra(subjects)} speak of a ${ra(adjectives)} ${monster} who inhabits ${toponym} hills and ${ra(
|
||||
modusOperandi
|
||||
)}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
// Sacred mountains spawn on lonely mountains
|
||||
function listSacredMountains({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i =>
|
||||
!occupied[i] &&
|
||||
cells.h[i] >= 70 &&
|
||||
cells.c[i].some(c => cells.culture[c]) &&
|
||||
cells.c[i].every(c => cells.h[c] < 60)
|
||||
);
|
||||
}
|
||||
|
||||
function addSacredMountain(id, cell, pack, notes, utils) {
|
||||
const {cells, religions} = pack;
|
||||
const {Names, getFriendlyHeight} = utils;
|
||||
|
||||
const culture = cells.c[cell].map(c => cells.culture[c]).find(c => c);
|
||||
const religion = cells.religion[cell];
|
||||
const name = `${Names.getCulture(culture)} Mountain`;
|
||||
const height = getFriendlyHeight(cells.p[cell]);
|
||||
const legend = `A sacred mountain of ${religions[religion].name}. Height: ${height}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
// Sacred forests spawn on temperate forests
|
||||
function listSacredForests({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i => !occupied[i] && cells.culture[i] && cells.religion[i] && [6, 8].includes(cells.biome[i])
|
||||
);
|
||||
}
|
||||
|
||||
function addSacredForest(id, cell, pack, notes, utils) {
|
||||
const {cells, religions} = pack;
|
||||
const {Names} = utils;
|
||||
|
||||
const culture = cells.culture[cell];
|
||||
const religion = cells.religion[cell];
|
||||
const name = `${Names.getCulture(culture)} Forest`;
|
||||
const legend = `A forest sacred to local ${religions[religion].name}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
// Sacred pineries spawn on boreal forests
|
||||
function listSacredPineries({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.culture[i] && cells.religion[i] && cells.biome[i] === 9);
|
||||
}
|
||||
|
||||
function addSacredPinery(id, cell, pack, notes, utils) {
|
||||
const {cells, religions} = pack;
|
||||
const {Names} = utils;
|
||||
|
||||
const culture = cells.culture[cell];
|
||||
const religion = cells.religion[cell];
|
||||
const name = `${Names.getCulture(culture)} Pinery`;
|
||||
const legend = `A pinery sacred to local ${religions[religion].name}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
// Sacred palm groves spawn on oasises
|
||||
function listSacredPalmGroves({cells}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i =>
|
||||
!occupied[i] &&
|
||||
cells.culture[i] &&
|
||||
cells.religion[i] &&
|
||||
cells.biome[i] === 1 &&
|
||||
cells.pop[i] > 1 &&
|
||||
Routes.isConnected(i)
|
||||
);
|
||||
}
|
||||
|
||||
function addSacredPalmGrove(id, cell, pack, notes, utils) {
|
||||
const {cells, religions} = pack;
|
||||
const {Names} = utils;
|
||||
|
||||
const culture = cells.culture[cell];
|
||||
const religion = cells.religion[cell];
|
||||
const name = `${Names.getCulture(culture)} Palm Grove`;
|
||||
const legend = `A palm grove sacred to local ${religions[religion].name}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listBrigands({cells}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.culture[i] && Routes.hasRoad(i));
|
||||
}
|
||||
|
||||
function addBrigands(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, ra, rw} = utils;
|
||||
|
||||
const animals = [
|
||||
"Apes", "Badgers", "Bears", "Beavers", "Bisons", "Boars", "Cats", "Crows", "Dogs", "Foxes",
|
||||
"Hares", "Hawks", "Hyenas", "Jackals", "Jaguars", "Leopards", "Lions", "Owls", "Panthers",
|
||||
"Rats", "Ravens", "Rooks", "Scorpions", "Sharks", "Snakes", "Spiders", "Tigers", "Wolfs",
|
||||
"Wolverines", "Falcons"
|
||||
];
|
||||
const types = {brigands: 4, bandits: 3, robbers: 1, highwaymen: 1};
|
||||
|
||||
const culture = cells.culture[cell];
|
||||
const biome = cells.biome[cell];
|
||||
const height = cells.p[cell];
|
||||
|
||||
const locality = ((height, biome) => {
|
||||
if (height >= 70) return "highlander";
|
||||
if ([1, 2].includes(biome)) return "desert";
|
||||
if ([3, 4].includes(biome)) return "mounted";
|
||||
if ([5, 6, 7, 8, 9].includes(biome)) return "forest";
|
||||
if (biome === 12) return "swamp";
|
||||
return "angry";
|
||||
})(height, biome);
|
||||
|
||||
const name = `${Names.getCulture(culture)} ${ra(animals)}`;
|
||||
const legend = `A gang of ${locality} ${rw(types)}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
// Pirates spawn on sea routes
|
||||
function listPirates({cells}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] < 20 && Routes.isConnected(i));
|
||||
}
|
||||
|
||||
function addPirates(id, cell, pack, notes, utils) {
|
||||
const name = "Pirates";
|
||||
const legend = "Pirate ships have been spotted in these waters.";
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listStatues({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 20 && cells.h[i] < 40);
|
||||
}
|
||||
|
||||
function addStatue(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, ra, rand} = utils;
|
||||
|
||||
const variants = [
|
||||
"Statue", "Obelisk", "Monument", "Column", "Monolith", "Pillar", "Megalith", "Stele", "Runestone", "Sculpture", "Effigy", "Idol"
|
||||
];
|
||||
const scripts = {
|
||||
cypriot: "𐠁𐠂𐠃𐠄𐠅𐠈𐠊𐠋𐠌𐠍𐠎𐠏𐠐𐠑𐠒𐠓𐠔𐠕𐠖𐠗𐠘𐠙𐠚𐠛𐠜𐠝𐠞𐠟𐠠𐠡𐠢𐠣𐠤𐠥𐠦𐠧𐠨𐠩𐠪𐠫𐠬𐠭𐠮𐠯𐠰𐠱𐠲𐠳𐠴𐠵𐠷𐠸𐠼𐠿 ",
|
||||
geez: "ሀለሐመሠረሰቀበተኀነአከወዐዘየደገጠጰጸፀፈፐ ",
|
||||
coptic: "ⲲⲴⲶⲸⲺⲼⲾⳀⳁⳂⳃⳄⳆⳈⳊⳌⳎⳐⳒⳔⳖⳘⳚⳜⳞⳠⳢⳤ⳥⳧⳩⳪ⳫⳬⳭⳲ⳹⳾ ",
|
||||
tibetan: "ༀ༁༂༃༄༅༆༇༈༉༊་༌༐༑༒༓༔༕༖༗༘༙༚༛༜༠༡༢༣༤༥༦༧༨༩༪༫༬༭༮༯༰༱༲༳༴༵༶༷༸༹༺༻༼༽༾༿",
|
||||
mongolian: "᠀᠐᠑᠒ᠠᠡᠦᠧᠨᠩᠪᠭᠮᠯᠰᠱᠲᠳᠵᠻᠼᠽᠾᠿᡀᡁᡆᡍᡎᡏᡐᡑᡒᡓᡔᡕᡖᡗᡙᡜᡝᡞᡟᡠᡡᡭᡮᡯᡰᡱᡲᡳᡴᢀᢁᢂᢋᢏᢐᢑᢒᢓᢛᢜᢞᢟᢠᢡᢢᢤᢥᢦ"
|
||||
};
|
||||
|
||||
const culture = cells.culture[cell];
|
||||
|
||||
const variant = ra(variants);
|
||||
const name = `${Names.getCulture(culture)} ${variant}`;
|
||||
const script = scripts[ra(Object.keys(scripts))];
|
||||
const inscription = Array(rand(40, 100))
|
||||
.fill(null)
|
||||
.map(() => ra(script))
|
||||
.join("");
|
||||
const legend = `An ancient ${variant.toLowerCase()}. It has an inscription, but no one can translate it:
|
||||
<div style="font-size: 1.8em; line-break: anywhere;">${inscription}</div>`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listRuins({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.culture[i] && cells.h[i] >= 20 && cells.h[i] < 60);
|
||||
}
|
||||
|
||||
function addRuins(id, cell, pack, notes, utils) {
|
||||
const {ra} = utils;
|
||||
const types = [
|
||||
"City", "Town", "Settlement", "Pyramid", "Fort", "Stronghold", "Temple", "Sacred site",
|
||||
"Mausoleum", "Outpost", "Fortification", "Fortress", "Castle"
|
||||
];
|
||||
|
||||
const ruinType = ra(types);
|
||||
const name = `Ruined ${ruinType}`;
|
||||
const legend = `Ruins of an ancient ${ruinType.toLowerCase()}. Untold riches may lie within.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listLibraries({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.culture[i] && cells.burg[i] && cells.pop[i] > 10);
|
||||
}
|
||||
|
||||
function addLibrary(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, rw} = utils;
|
||||
|
||||
const type = rw({Library: 3, Archive: 1, Collection: 1});
|
||||
const name = `${Names.getCulture(cells.culture[cell])} ${type}`;
|
||||
const legend = "A vast collection of knowledge, including many rare and ancient tomes.";
|
||||
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listCircuses({cells}, utils) {
|
||||
const {Routes} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.culture[i] && cells.h[i] >= 20 && Routes.isConnected(i));
|
||||
}
|
||||
|
||||
function addCircuse(id, cell, pack, notes, utils) {
|
||||
const {ra} = utils;
|
||||
const adjectives = [
|
||||
"Fantastical", "Wonderous", "Incomprehensible", "Magical", "Extraordinary", "Unmissable", "World-famous", "Breathtaking"
|
||||
];
|
||||
|
||||
const adjective = ra(adjectives);
|
||||
const name = `Travelling ${adjective} Circus`;
|
||||
const legend = `Roll up, roll up, this ${adjective.toLowerCase()} circus is here for a limited time only.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listJousts({cells, burgs}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.burg[i] && burgs[cells.burg[i]].population > 20);
|
||||
}
|
||||
|
||||
function addJoust(id, cell, pack, notes, utils) {
|
||||
const {cells, burgs} = pack;
|
||||
const {ra} = utils;
|
||||
const types = ["Joust", "Competition", "Melee", "Tournament", "Contest"];
|
||||
const virtues = ["cunning", "might", "speed", "the greats", "acumen", "brutality"];
|
||||
|
||||
if (!cells.burg[cell]) return;
|
||||
const burgName = burgs[cells.burg[cell]].name;
|
||||
const type = ra(types);
|
||||
const virtue = ra(virtues);
|
||||
|
||||
const name = `${burgName} ${type}`;
|
||||
const legend = `Warriors from around the land gather for a ${type.toLowerCase()} of ${virtue} in ${burgName}, with fame, fortune and favour on offer to the victor.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listFairs({cells, burgs}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(
|
||||
i => !occupied[i] && cells.burg[i] && burgs[cells.burg[i]].population < 20 && burgs[cells.burg[i]].population < 5
|
||||
);
|
||||
}
|
||||
|
||||
function addFair(id, cell, pack, notes, utils) {
|
||||
const {cells, burgs} = pack;
|
||||
if (!cells.burg[cell]) return;
|
||||
|
||||
const burgName = burgs[cells.burg[cell]].name;
|
||||
const type = "Fair";
|
||||
|
||||
const name = `${burgName} ${type}`;
|
||||
const legend = `A fair is being held in ${burgName}, with all manner of local and foreign goods and services on offer.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listCanoes({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.r[i]);
|
||||
}
|
||||
|
||||
function addCanoe(id, cell, pack, notes, utils) {
|
||||
const river = pack.rivers.find(r => r.i === pack.cells.r[cell]);
|
||||
|
||||
const name = `Minor Jetty`;
|
||||
const riverName = river ? `${river.name} ${river.type}` : "river";
|
||||
const legend = `A small location along the ${riverName} to launch boats from sits here, along with a weary looking owner, willing to sell passage along the river.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listMigrations({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 20 && cells.pop[i] <= 2);
|
||||
}
|
||||
|
||||
function addMigration(id, cell, pack, notes, utils) {
|
||||
const {ra} = utils;
|
||||
const animals = [
|
||||
"Antelopes", "Apes", "Badgers", "Bears", "Beavers", "Bisons", "Boars", "Buffalo", "Cats", "Cranes",
|
||||
"Crocodiles", "Crows", "Deer", "Dogs", "Eagles", "Elk", "Foxes", "Goats", "Geese", "Hares",
|
||||
"Hawks", "Herons", "Horses", "Hyenas", "Ibises", "Jackals", "Jaguars", "Larks", "Leopards", "Lions",
|
||||
"Mantises", "Martens", "Mooses", "Mules", "Owls", "Panthers", "Rats", "Ravens", "Rooks", "Scorpions",
|
||||
"Sharks", "Sheep", "Snakes", "Spiders", "Tigers", "Wolves", "Wolverines", "Camels", "Falcons", "Hounds", "Oxen"
|
||||
];
|
||||
const animalChoice = ra(animals);
|
||||
|
||||
const name = `${animalChoice} migration`;
|
||||
const legend = `A huge group of ${animalChoice.toLowerCase()} are migrating, whether part of their annual routine, or something more extraordinary.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listDances({cells, burgs}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.burg[i] && burgs[cells.burg[i]].population > 15);
|
||||
}
|
||||
|
||||
function addDances(id, cell, pack, notes, utils) {
|
||||
const {cells, burgs} = pack;
|
||||
const {ra} = utils;
|
||||
const burgName = burgs[cells.burg[cell]].name;
|
||||
const socialTypes = [
|
||||
"gala", "dance", "performance", "ball", "soiree", "jamboree", "exhibition", "carnival",
|
||||
"festival", "jubilee", "celebration", "gathering", "fete"
|
||||
];
|
||||
const people = [
|
||||
"great and the good", "nobility", "local elders", "foreign dignitaries", "spiritual leaders", "suspected revolutionaries"
|
||||
];
|
||||
const socialType = ra(socialTypes);
|
||||
|
||||
const name = `${burgName} ${socialType}`;
|
||||
const legend = `A ${socialType} has been organised at ${burgName} as a chance to gather the ${ra(
|
||||
people
|
||||
)} of the area together to be merry, make alliances and scheme around the crisis.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listMirage({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.biome[i] === 1);
|
||||
}
|
||||
|
||||
function addMirage(id, cell, pack, notes, utils) {
|
||||
const {ra} = utils;
|
||||
const adjectives = ["Entrancing", "Diaphanous", "Illusory", "Distant", "Perculiar"];
|
||||
|
||||
const mirageAdjective = ra(adjectives);
|
||||
const name = `${mirageAdjective} mirage`;
|
||||
const legend = `This ${mirageAdjective.toLowerCase()} mirage has been luring travellers out of their way for eons.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listCaves({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 50 && cells.pop[i]);
|
||||
}
|
||||
|
||||
function addCave(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, rw} = utils;
|
||||
|
||||
const formations = {
|
||||
Cave: 10, Cavern: 8, Chasm: 6, Ravine: 6, Fracture: 5, Grotto: 4, Pit: 4, Sinkhole: 2, Hole: 2
|
||||
};
|
||||
const status = {
|
||||
"a good spot to hid treasure": 5,
|
||||
"the home of strange monsters": 5,
|
||||
"totally empty": 4,
|
||||
"endlessly deep and unexplored": 4,
|
||||
"completely flooded": 2,
|
||||
"slowly filling with lava": 1
|
||||
};
|
||||
|
||||
let formation = rw(formations);
|
||||
const toponym = Names.getCulture(cells.culture[cell]);
|
||||
if (cells.biome[cell] === 11) {
|
||||
formation = "Glacial " + formation;
|
||||
}
|
||||
const name = `${toponym} ${formation}`;
|
||||
const legend = `The ${name}. Locals claim that it is ${rw(status)}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listPortals({burgs}, utils) {
|
||||
const occupied = [];
|
||||
return burgs
|
||||
.slice(1, Math.ceil(burgs.length / 10) + 1)
|
||||
.filter(({cell}) => !occupied[cell])
|
||||
.map(burg => burg.cell);
|
||||
}
|
||||
|
||||
function addPortal(id, cell, pack, notes, utils) {
|
||||
const {cells, burgs} = pack;
|
||||
|
||||
if (!cells.burg[cell]) return;
|
||||
const burgName = burgs[cells.burg[cell]].name;
|
||||
|
||||
const name = `${burgName} Portal`;
|
||||
const legend = `An element of the magic portal system connecting major cities. The portals were installed centuries ago, but still work fine.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listRifts({cells}, utils) {
|
||||
const {biomesData} = utils;
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && pack.cells.pop[i] <= 3 && biomesData.habitability[pack.cells.biome[i]]);
|
||||
}
|
||||
|
||||
function addRift(id, cell, pack, notes, utils) {
|
||||
const {ra} = utils;
|
||||
const types = ["Demonic", "Interdimensional", "Abyssal", "Cosmic", "Cataclysmic", "Subterranean", "Ancient"];
|
||||
|
||||
const descriptions = [
|
||||
"all known nearby beings to flee in terror",
|
||||
"cracks in reality itself to form",
|
||||
"swarms of foes to spill forth",
|
||||
"nearby plants to wither and decay",
|
||||
"an emmissary to step through with an all-powerful relic"
|
||||
];
|
||||
|
||||
const riftType = ra(types);
|
||||
const name = `${riftType} Rift`;
|
||||
const legend = `A rumoured ${riftType.toLowerCase()} rift in this area is causing ${ra(descriptions)}.`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listDisturbedBurial({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 20 && cells.pop[i] > 2);
|
||||
}
|
||||
function addDisturbedBurial(id, cell, pack, notes, utils) {
|
||||
const name = "Disturbed Burial";
|
||||
const legend = "A burial site has been disturbed in this area, causing the dead to rise and attack the living.";
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listNecropolis({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 20 && cells.pop[i] < 2);
|
||||
}
|
||||
|
||||
function addNecropolis(id, cell, pack, notes, utils) {
|
||||
const {cells} = pack;
|
||||
const {Names, rw, ra} = utils;
|
||||
|
||||
const toponym = Names.getCulture(cells.culture[cell]);
|
||||
const type = rw({
|
||||
Necropolis: 5, Crypt: 2, Tomb: 2, Graveyard: 1, Cemetery: 2, Mausoleum: 1, Sepulchre: 1
|
||||
});
|
||||
|
||||
const name = `${toponym} ${type}`;
|
||||
const legend = ra([
|
||||
"A foreboding necropolis shrouded in perpetual darkness, where eerie whispers echo through the winding corridors and spectral guardians stand watch over the tombs of long-forgotten souls.",
|
||||
"A towering necropolis adorned with macabre sculptures and guarded by formidable undead sentinels. Its ancient halls house the remains of fallen heroes, entombed alongside their cherished relics.",
|
||||
"This ethereal necropolis seems suspended between the realms of the living and the dead. Wisps of mist dance around the tombstones, while haunting melodies linger in the air, commemorating the departed.",
|
||||
"Rising from the desolate landscape, this sinister necropolis is a testament to necromantic power. Its skeletal spires cast ominous shadows, concealing forbidden knowledge and arcane secrets.",
|
||||
"An eerie necropolis where nature intertwines with death. Overgrown tombstones are entwined by thorny vines, and mournful spirits wander among the fading petals of once-vibrant flowers.",
|
||||
"A labyrinthine necropolis where each step echoes with haunting murmurs. The walls are adorned with ancient runes, and restless spirits guide or hinder those who dare to delve into its depths.",
|
||||
"This cursed necropolis is veiled in perpetual twilight, perpetuating a sense of impending doom. Dark enchantments shroud the tombs, and the moans of anguished souls resound through its crumbling halls.",
|
||||
"A sprawling necropolis built within a labyrinthine network of catacombs. Its halls are lined with countless alcoves, each housing the remains of the departed, while the distant sound of rattling bones fills the air.",
|
||||
"A desolate necropolis where an eerie stillness reigns. Time seems frozen amidst the decaying mausoleums, and the silence is broken only by the whispers of the wind and the rustle of tattered banners.",
|
||||
"A foreboding necropolis perched atop a jagged cliff, overlooking a desolate wasteland. Its towering walls harbor restless spirits, and the imposing gates bear the marks of countless battles and ancient curses."
|
||||
]);
|
||||
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
|
||||
function listEncounters({cells}, utils) {
|
||||
const occupied = [];
|
||||
return cells.i.filter(i => !occupied[i] && cells.h[i] >= 20 && cells.pop[i] > 1);
|
||||
}
|
||||
|
||||
function addEncounter(id, cell, pack, notes, utils) {
|
||||
const name = "Random encounter";
|
||||
const encounterSeed = cell; // use just cell Id to not overwhelm the Vercel KV database
|
||||
const legend = `<div>You have encountered a character.</div><iframe src="https://deorum.vercel.app/encounter/${encounterSeed}" width="375" height="600" sandbox="allow-scripts allow-same-origin allow-popups"></iframe>`;
|
||||
notes.push({id, name, legend});
|
||||
}
|
||||
392
procedural/src/engine/modules/military-generator.js
Normal file
392
procedural/src/engine/modules/military-generator.js
Normal file
|
|
@ -0,0 +1,392 @@
|
|||
"use strict";
|
||||
|
||||
export function generate(pack, config, utils, notes) {
|
||||
const {TIME, minmax, rn, ra, rand, gauss, si, nth, d3, populationRate, urbanization} = utils;
|
||||
|
||||
TIME && console.time("generateMilitary");
|
||||
const {cells, states, burgs, provinces} = pack;
|
||||
const {p} = cells;
|
||||
const valid = states.filter(s => s.i && !s.removed); // valid states
|
||||
const military = config.military || getDefaultOptions();
|
||||
|
||||
const expn = d3.sum(valid.map(s => s.expansionism)); // total expansion
|
||||
const area = d3.sum(valid.map(s => s.area)); // total area
|
||||
const rate = {
|
||||
x: 0,
|
||||
Ally: -0.2,
|
||||
Friendly: -0.1,
|
||||
Neutral: 0,
|
||||
Suspicion: 0.1,
|
||||
Enemy: 1,
|
||||
Unknown: 0,
|
||||
Rival: 0.5,
|
||||
Vassal: 0.5,
|
||||
Suzerain: -0.5
|
||||
};
|
||||
|
||||
const stateModifier = {
|
||||
melee: {Nomadic: 0.5, Highland: 1.2, Lake: 1, Naval: 0.7, Hunting: 1.2, River: 1.1},
|
||||
ranged: {Nomadic: 0.9, Highland: 1.3, Lake: 1, Naval: 0.8, Hunting: 2, River: 0.8},
|
||||
mounted: {Nomadic: 2.3, Highland: 0.6, Lake: 0.7, Naval: 0.3, Hunting: 0.7, River: 0.8},
|
||||
machinery: {Nomadic: 0.8, Highland: 1.4, Lake: 1.1, Naval: 1.4, Hunting: 0.4, River: 1.1},
|
||||
naval: {Nomadic: 0.5, Highland: 0.5, Lake: 1.2, Naval: 1.8, Hunting: 0.7, River: 1.2},
|
||||
armored: {Nomadic: 1, Highland: 0.5, Lake: 1, Naval: 1, Hunting: 0.7, River: 1.1},
|
||||
aviation: {Nomadic: 0.5, Highland: 0.5, Lake: 1.2, Naval: 1.2, Hunting: 0.6, River: 1.2},
|
||||
magical: {Nomadic: 1, Highland: 2, Lake: 1, Naval: 1, Hunting: 1, River: 1}
|
||||
};
|
||||
|
||||
const cellTypeModifier = {
|
||||
nomadic: {
|
||||
melee: 0.2,
|
||||
ranged: 0.5,
|
||||
mounted: 3,
|
||||
machinery: 0.4,
|
||||
naval: 0.3,
|
||||
armored: 1.6,
|
||||
aviation: 1,
|
||||
magical: 0.5
|
||||
},
|
||||
wetland: {
|
||||
melee: 0.8,
|
||||
ranged: 2,
|
||||
mounted: 0.3,
|
||||
machinery: 1.2,
|
||||
naval: 1.0,
|
||||
armored: 0.2,
|
||||
aviation: 0.5,
|
||||
magical: 0.5
|
||||
},
|
||||
highland: {
|
||||
melee: 1.2,
|
||||
ranged: 1.6,
|
||||
mounted: 0.3,
|
||||
machinery: 3,
|
||||
naval: 1.0,
|
||||
armored: 0.8,
|
||||
aviation: 0.3,
|
||||
magical: 2
|
||||
}
|
||||
};
|
||||
|
||||
const burgTypeModifier = {
|
||||
nomadic: {
|
||||
melee: 0.3,
|
||||
ranged: 0.8,
|
||||
mounted: 3,
|
||||
machinery: 0.4,
|
||||
naval: 1.0,
|
||||
armored: 1.6,
|
||||
aviation: 1,
|
||||
magical: 0.5
|
||||
},
|
||||
wetland: {
|
||||
melee: 1,
|
||||
ranged: 1.6,
|
||||
mounted: 0.2,
|
||||
machinery: 1.2,
|
||||
naval: 1.0,
|
||||
armored: 0.2,
|
||||
aviation: 0.5,
|
||||
magical: 0.5
|
||||
},
|
||||
highland: {melee: 1.2, ranged: 2, mounted: 0.3, machinery: 3, naval: 1.0, armored: 0.8, aviation: 0.3, magical: 2}
|
||||
};
|
||||
|
||||
valid.forEach(s => {
|
||||
s.temp = {};
|
||||
const d = s.diplomacy;
|
||||
|
||||
const expansionRate = minmax(s.expansionism / expn / (s.area / area), 0.25, 4); // how much state expansionism is realized
|
||||
const diplomacyRate = d.some(d => d === "Enemy")
|
||||
? 1
|
||||
: d.some(d => d === "Rival")
|
||||
? 0.8
|
||||
: d.some(d => d === "Suspicion")
|
||||
? 0.5
|
||||
: 0.1; // peacefulness
|
||||
const neighborsRateRaw = s.neighbors
|
||||
.map(n => (n ? pack.states[n].diplomacy[s.i] : "Suspicion"))
|
||||
.reduce((s, r) => (s += rate[r]), 0.5);
|
||||
const neighborsRate = minmax(neighborsRateRaw, 0.3, 3); // neighbors rate
|
||||
s.alert = minmax(rn(expansionRate * diplomacyRate * neighborsRate, 2), 0.1, 5); // alert rate (area modifier)
|
||||
s.temp.platoons = [];
|
||||
|
||||
// apply overall state modifiers for unit types based on state features
|
||||
for (const unit of military) {
|
||||
if (!stateModifier[unit.type]) continue;
|
||||
|
||||
let modifier = stateModifier[unit.type][s.type] || 1;
|
||||
if (unit.type === "mounted" && s.formName.includes("Horde")) modifier *= 2;
|
||||
else if (unit.type === "naval" && s.form === "Republic") modifier *= 1.2;
|
||||
s.temp[unit.name] = modifier * s.alert;
|
||||
}
|
||||
});
|
||||
|
||||
const getType = cell => {
|
||||
if ([1, 2, 3, 4].includes(cells.biome[cell])) return "nomadic";
|
||||
if ([7, 8, 9, 12].includes(cells.biome[cell])) return "wetland";
|
||||
if (cells.h[cell] >= 70) return "highland";
|
||||
return "generic";
|
||||
};
|
||||
|
||||
function passUnitLimits(unit, biome, state, culture, religion) {
|
||||
if (unit.biomes && !unit.biomes.includes(biome)) return false;
|
||||
if (unit.states && !unit.states.includes(state)) return false;
|
||||
if (unit.cultures && !unit.cultures.includes(culture)) return false;
|
||||
if (unit.religions && !unit.religions.includes(religion)) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
// rural cells
|
||||
for (const i of cells.i) {
|
||||
if (!cells.pop[i]) continue;
|
||||
|
||||
const biome = cells.biome[i];
|
||||
const state = cells.state[i];
|
||||
const culture = cells.culture[i];
|
||||
const religion = cells.religion[i];
|
||||
|
||||
const stateObj = states[state];
|
||||
if (!state || stateObj.removed) continue;
|
||||
|
||||
let modifier = cells.pop[i] / 100; // basic rural army in percentages
|
||||
if (culture !== stateObj.culture) modifier = stateObj.form === "Union" ? modifier / 1.2 : modifier / 2; // non-dominant culture
|
||||
if (religion !== cells.religion[stateObj.center])
|
||||
modifier = stateObj.form === "Theocracy" ? modifier / 2.2 : modifier / 1.4; // non-dominant religion
|
||||
if (cells.f[i] !== cells.f[stateObj.center])
|
||||
modifier = stateObj.type === "Naval" ? modifier / 1.2 : modifier / 1.8; // different landmass
|
||||
const type = getType(i);
|
||||
|
||||
for (const unit of military) {
|
||||
const perc = +unit.rural;
|
||||
if (isNaN(perc) || perc <= 0 || !stateObj.temp[unit.name]) continue;
|
||||
if (!passUnitLimits(unit, biome, state, culture, religion)) continue;
|
||||
if (unit.type === "naval" && !cells.haven[i]) continue; // only near-ocean cells create naval units
|
||||
|
||||
const cellTypeMod = type === "generic" ? 1 : cellTypeModifier[type][unit.type]; // cell specific modifier
|
||||
const army = modifier * perc * cellTypeMod; // rural cell army
|
||||
const total = rn(army * stateObj.temp[unit.name] * populationRate); // total troops
|
||||
if (!total) continue;
|
||||
|
||||
let [x, y] = p[i];
|
||||
let n = 0;
|
||||
|
||||
// place naval units to sea
|
||||
if (unit.type === "naval") {
|
||||
const haven = cells.haven[i];
|
||||
[x, y] = p[haven];
|
||||
n = 1;
|
||||
}
|
||||
|
||||
stateObj.temp.platoons.push({
|
||||
cell: i,
|
||||
a: total,
|
||||
t: total,
|
||||
x,
|
||||
y,
|
||||
u: unit.name,
|
||||
n,
|
||||
s: unit.separate,
|
||||
type: unit.type
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// burgs
|
||||
for (const b of burgs) {
|
||||
if (!b.i || b.removed || !b.state || !b.population) continue;
|
||||
|
||||
const biome = cells.biome[b.cell];
|
||||
const state = b.state;
|
||||
const culture = b.culture;
|
||||
const religion = cells.religion[b.cell];
|
||||
|
||||
const stateObj = states[state];
|
||||
let m = (b.population * urbanization) / 100; // basic urban army in percentages
|
||||
if (b.capital) m *= 1.2; // capital has household troops
|
||||
if (culture !== stateObj.culture) m = stateObj.form === "Union" ? m / 1.2 : m / 2; // non-dominant culture
|
||||
if (religion !== cells.religion[stateObj.center]) m = stateObj.form === "Theocracy" ? m / 2.2 : m / 1.4; // non-dominant religion
|
||||
if (cells.f[b.cell] !== cells.f[stateObj.center]) m = stateObj.type === "Naval" ? m / 1.2 : m / 1.8; // different landmass
|
||||
const type = getType(b.cell);
|
||||
|
||||
for (const unit of military) {
|
||||
const perc = +unit.urban;
|
||||
if (isNaN(perc) || perc <= 0 || !stateObj.temp[unit.name]) continue;
|
||||
if (!passUnitLimits(unit, biome, state, culture, religion)) continue;
|
||||
if (unit.type === "naval" && (!b.port || !cells.haven[b.cell])) continue; // only ports create naval units
|
||||
|
||||
const mod = type === "generic" ? 1 : burgTypeModifier[type][unit.type]; // cell specific modifier
|
||||
const army = m * perc * mod; // urban cell army
|
||||
const total = rn(army * stateObj.temp[unit.name] * populationRate); // total troops
|
||||
if (!total) continue;
|
||||
|
||||
let [x, y] = p[b.cell];
|
||||
let n = 0;
|
||||
|
||||
// place naval to sea
|
||||
if (unit.type === "naval") {
|
||||
const haven = cells.haven[b.cell];
|
||||
[x, y] = p[haven];
|
||||
n = 1;
|
||||
}
|
||||
|
||||
stateObj.temp.platoons.push({
|
||||
cell: b.cell,
|
||||
a: total,
|
||||
t: total,
|
||||
x,
|
||||
y,
|
||||
u: unit.name,
|
||||
n,
|
||||
s: unit.separate,
|
||||
type: unit.type
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const expected = 3 * populationRate; // expected regiment size
|
||||
const mergeable = (n0, n1) => (!n0.s && !n1.s) || n0.u === n1.u; // check if regiments can be merged
|
||||
|
||||
// get regiments for each state
|
||||
valid.forEach(s => {
|
||||
s.military = createRegiments(s.temp.platoons, s, pack, config, utils, notes);
|
||||
delete s.temp; // do not store temp data
|
||||
});
|
||||
|
||||
function createRegiments(nodes, s, pack, config, utils, notes) {
|
||||
if (!nodes.length) return [];
|
||||
|
||||
nodes.sort((a, b) => a.a - b.a); // form regiments in cells with most troops
|
||||
const tree = d3.quadtree(
|
||||
nodes,
|
||||
d => d.x,
|
||||
d => d.y
|
||||
);
|
||||
|
||||
nodes.forEach(node => {
|
||||
tree.remove(node);
|
||||
const overlap = tree.find(node.x, node.y, 20);
|
||||
if (overlap && overlap.t && mergeable(node, overlap)) {
|
||||
merge(node, overlap);
|
||||
return;
|
||||
}
|
||||
if (node.t > expected) return;
|
||||
const r = (expected - node.t) / (node.s ? 40 : 20); // search radius
|
||||
const candidates = tree.findAll(node.x, node.y, r);
|
||||
for (const c of candidates) {
|
||||
if (c.t < expected && mergeable(node, c)) {
|
||||
merge(node, c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// add n0 to n1's ultimate parent
|
||||
function merge(n0, n1) {
|
||||
if (!n1.childen) n1.childen = [n0];
|
||||
else n1.childen.push(n0);
|
||||
if (n0.childen) n0.childen.forEach(n => n1.childen.push(n));
|
||||
n1.t += n0.t;
|
||||
n0.t = 0;
|
||||
}
|
||||
|
||||
// parse regiments data
|
||||
const regiments = nodes
|
||||
.filter(n => n.t)
|
||||
.sort((a, b) => b.t - a.t)
|
||||
.map((r, i) => {
|
||||
const u = {};
|
||||
u[r.u] = r.a;
|
||||
(r.childen || []).forEach(n => (u[n.u] = u[n.u] ? (u[n.u] += n.a) : n.a));
|
||||
return {i, a: r.t, cell: r.cell, x: r.x, y: r.y, bx: r.x, by: r.y, u, n: r.n, name: null, state: s.i};
|
||||
});
|
||||
|
||||
// generate name for regiments
|
||||
regiments.forEach(r => {
|
||||
r.name = getName(r, regiments, pack, utils);
|
||||
r.icon = getEmblem(r, pack, config);
|
||||
generateNote(r, s, pack, config, utils, notes);
|
||||
});
|
||||
|
||||
return regiments;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateMilitary");
|
||||
|
||||
return pack;
|
||||
}
|
||||
|
||||
export function getDefaultOptions() {
|
||||
return [
|
||||
{icon: "⚔️", name: "infantry", rural: 0.25, urban: 0.2, crew: 1, power: 1, type: "melee", separate: 0},
|
||||
{icon: "🏹", name: "archers", rural: 0.12, urban: 0.2, crew: 1, power: 1, type: "ranged", separate: 0},
|
||||
{icon: "🐴", name: "cavalry", rural: 0.12, urban: 0.03, crew: 2, power: 2, type: "mounted", separate: 0},
|
||||
{icon: "💣", name: "artillery", rural: 0, urban: 0.03, crew: 8, power: 12, type: "machinery", separate: 0},
|
||||
{icon: "🌊", name: "fleet", rural: 0, urban: 0.015, crew: 100, power: 50, type: "naval", separate: 1}
|
||||
];
|
||||
}
|
||||
|
||||
// utilize si function to make regiment total text fit regiment box
|
||||
export function getTotal(reg, utils) {
|
||||
const {si} = utils;
|
||||
return reg.a > (reg.n ? 999 : 99999) ? si(reg.a) : reg.a;
|
||||
}
|
||||
|
||||
export function getName(r, regiments, pack, utils) {
|
||||
const {nth} = utils;
|
||||
const {cells, provinces, burgs} = pack;
|
||||
const proper = r.n
|
||||
? null
|
||||
: cells.province[r.cell] && provinces[cells.province[r.cell]]
|
||||
? provinces[cells.province[r.cell]].name
|
||||
: cells.burg[r.cell] && burgs[cells.burg[r.cell]]
|
||||
? burgs[cells.burg[r.cell]].name
|
||||
: null;
|
||||
const number = nth(regiments.filter(reg => reg.n === r.n && reg.i < r.i).length + 1);
|
||||
const form = r.n ? "Fleet" : "Regiment";
|
||||
return `${number}${proper ? ` (${proper}) ` : ` `}${form}`;
|
||||
}
|
||||
|
||||
// get default regiment emblem
|
||||
export function getEmblem(r, pack, config) {
|
||||
if (!r.n && !Object.values(r.u).length) return "🔰"; // "Newbie" regiment without troops
|
||||
if (
|
||||
!r.n &&
|
||||
pack.states[r.state].form === "Monarchy" &&
|
||||
pack.cells.burg[r.cell] &&
|
||||
pack.burgs[pack.cells.burg[r.cell]].capital
|
||||
)
|
||||
return "👑"; // "Royal" regiment based in capital
|
||||
const mainUnit = Object.entries(r.u).sort((a, b) => b[1] - a[1])[0][0]; // unit with more troops in regiment
|
||||
const unit = config.military.find(u => u.name === mainUnit);
|
||||
return unit.icon;
|
||||
}
|
||||
|
||||
export function generateNote(r, s, pack, config, utils, notes) {
|
||||
const {ra, rand, gauss} = utils;
|
||||
const {cells, burgs, provinces} = pack;
|
||||
const base =
|
||||
cells.burg[r.cell] && burgs[cells.burg[r.cell]]
|
||||
? burgs[cells.burg[r.cell]].name
|
||||
: cells.province[r.cell] && provinces[cells.province[r.cell]]
|
||||
? provinces[cells.province[r.cell]].fullName
|
||||
: null;
|
||||
const station = base ? `${r.name} is ${r.n ? "based" : "stationed"} in ${base}. ` : "";
|
||||
|
||||
const composition = r.a
|
||||
? Object.keys(r.u)
|
||||
.map(t => `— ${t}: ${r.u[t]}`)
|
||||
.join("\r\n")
|
||||
: null;
|
||||
const troops = composition
|
||||
? `\r\n\r\nRegiment composition in ${config.year} ${config.eraShort}:\r\n${composition}.`
|
||||
: "";
|
||||
|
||||
const campaign = s.campaigns ? ra(s.campaigns) : null;
|
||||
const year = campaign
|
||||
? rand(campaign.start, campaign.end || config.year)
|
||||
: gauss(config.year - 100, 150, 1, config.year - 6);
|
||||
const conflict = campaign ? ` during the ${campaign.name}` : "";
|
||||
const legend = `Regiment was formed in ${year} ${config.era}${conflict}. ${station}${troops}`;
|
||||
notes.push({id: `regiment${s.i}-${r.i}`, name: r.name, legend});
|
||||
}
|
||||
335
procedural/src/engine/modules/names-generator.js
Normal file
335
procedural/src/engine/modules/names-generator.js
Normal file
|
|
@ -0,0 +1,335 @@
|
|||
"use strict";
|
||||
|
||||
let chains = [];
|
||||
|
||||
// calculate Markov chain for a namesbase
|
||||
const calculateChain = function (string) {
|
||||
const chain = [];
|
||||
const array = string.split(",");
|
||||
|
||||
for (const n of array) {
|
||||
let name = n.trim().toLowerCase();
|
||||
const basic = !/[^\u0000-\u007f]/.test(name); // basic chars and English rules can be applied
|
||||
|
||||
// split word into pseudo-syllables
|
||||
for (let i = -1, syllable = ""; i < name.length; i += syllable.length || 1, syllable = "") {
|
||||
let prev = name[i] || ""; // pre-onset letter
|
||||
let v = 0; // 0 if no vowels in syllable
|
||||
|
||||
for (let c = i + 1; name[c] && syllable.length < 5; c++) {
|
||||
const that = name[c],
|
||||
next = name[c + 1]; // next char
|
||||
syllable += that;
|
||||
if (syllable === " " || syllable === "-") break; // syllable starts with space or hyphen
|
||||
if (!next || next === " " || next === "-") break; // no need to check
|
||||
|
||||
if (vowel(that)) v = 1; // check if letter is vowel
|
||||
|
||||
// do not split some diphthongs
|
||||
if (that === "y" && next === "e") continue; // 'ye'
|
||||
if (basic) {
|
||||
// English-like
|
||||
if (that === "o" && next === "o") continue; // 'oo'
|
||||
if (that === "e" && next === "e") continue; // 'ee'
|
||||
if (that === "a" && next === "e") continue; // 'ae'
|
||||
if (that === "c" && next === "h") continue; // 'ch'
|
||||
}
|
||||
|
||||
if (vowel(that) === next) break; // two same vowels in a row
|
||||
if (v && vowel(name[c + 2])) break; // syllable has vowel and additional vowel is expected soon
|
||||
}
|
||||
|
||||
if (chain[prev] === undefined) chain[prev] = [];
|
||||
chain[prev].push(syllable);
|
||||
}
|
||||
}
|
||||
|
||||
return chain;
|
||||
};
|
||||
|
||||
const updateChain = (i, nameBases) => {
|
||||
chains[i] = nameBases[i]?.b ? calculateChain(nameBases[i].b) : null;
|
||||
};
|
||||
|
||||
const clearChains = () => {
|
||||
chains = [];
|
||||
};
|
||||
|
||||
// generate name using Markov's chain
|
||||
const getBase = function (base, min, max, dupl, nameBases, utils) {
|
||||
const { ERROR, ra, last, P } = utils;
|
||||
|
||||
if (base === undefined) return ERROR && console.error("Please define a base");
|
||||
|
||||
if (nameBases[base] === undefined) {
|
||||
if (nameBases[0]) {
|
||||
ERROR && console.warn("Namebase " + base + " is not found. First available namebase will be used");
|
||||
base = 0;
|
||||
} else {
|
||||
ERROR && console.error("Namebase " + base + " is not found");
|
||||
return "ERROR";
|
||||
}
|
||||
}
|
||||
|
||||
if (!chains[base]) updateChain(base, nameBases);
|
||||
|
||||
const data = chains[base];
|
||||
if (!data || data[""] === undefined) {
|
||||
ERROR && console.error("Namebase " + base + " is incorrect!");
|
||||
return "ERROR";
|
||||
}
|
||||
|
||||
if (!min) min = nameBases[base].min;
|
||||
if (!max) max = nameBases[base].max;
|
||||
if (dupl !== "") dupl = nameBases[base].d;
|
||||
|
||||
let v = data[""],
|
||||
cur = ra(v),
|
||||
w = "";
|
||||
for (let i = 0; i < 20; i++) {
|
||||
if (cur === "") {
|
||||
// end of word
|
||||
if (w.length < min) {
|
||||
cur = "";
|
||||
w = "";
|
||||
v = data[""];
|
||||
} else break;
|
||||
} else {
|
||||
if (w.length + cur.length > max) {
|
||||
// word too long
|
||||
if (w.length < min) w += cur;
|
||||
break;
|
||||
} else v = data[last(cur)] || data[""];
|
||||
}
|
||||
|
||||
w += cur;
|
||||
cur = ra(v);
|
||||
}
|
||||
|
||||
// parse word to get a final name
|
||||
const l = last(w); // last letter
|
||||
if (l === "'" || l === " " || l === "-") w = w.slice(0, -1); // not allow some characters at the end
|
||||
|
||||
let name = [...w].reduce(function (r, c, i, d) {
|
||||
if (c === d[i + 1] && !dupl.includes(c)) return r; // duplication is not allowed
|
||||
if (!r.length) return c.toUpperCase();
|
||||
if (r.slice(-1) === "-" && c === " ") return r; // remove space after hyphen
|
||||
if (r.slice(-1) === " ") return r + c.toUpperCase(); // capitalize letter after space
|
||||
if (r.slice(-1) === "-") return r + c.toUpperCase(); // capitalize letter after hyphen
|
||||
if (c === "a" && d[i + 1] === "e") return r; // "ae" => "e"
|
||||
if (i + 2 < d.length && c === d[i + 1] && c === d[i + 2]) return r; // remove three same letters in a row
|
||||
return r + c;
|
||||
}, "");
|
||||
|
||||
// join the word if any part has only 1 letter
|
||||
if (name.split(" ").some(part => part.length < 2))
|
||||
name = name
|
||||
.split(" ")
|
||||
.map((p, i) => (i ? p.toLowerCase() : p))
|
||||
.join("");
|
||||
|
||||
if (name.length < 2) {
|
||||
ERROR && console.error("Name is too short! Random name will be selected");
|
||||
name = ra(nameBases[base].b.split(","));
|
||||
}
|
||||
|
||||
return name;
|
||||
};
|
||||
|
||||
// generate name for culture
|
||||
const getCulture = function (culture, min, max, dupl, cultures, nameBases, utils) {
|
||||
const { ERROR } = utils;
|
||||
|
||||
if (culture === undefined) return ERROR && console.error("Please define a culture");
|
||||
const base = cultures[culture].base;
|
||||
return getBase(base, min, max, dupl, nameBases, utils);
|
||||
};
|
||||
|
||||
// generate short name for culture
|
||||
const getCultureShort = function (culture, cultures, nameBases, utils) {
|
||||
const { ERROR } = utils;
|
||||
|
||||
if (culture === undefined) return ERROR && console.error("Please define a culture");
|
||||
return getBaseShort(cultures[culture].base, nameBases, utils);
|
||||
};
|
||||
|
||||
// generate short name for base
|
||||
const getBaseShort = function (base, nameBases, utils) {
|
||||
const min = nameBases[base] ? nameBases[base].min - 1 : null;
|
||||
const max = min ? Math.max(nameBases[base].max - 2, min) : null;
|
||||
return getBase(base, min, max, "", nameBases, utils);
|
||||
};
|
||||
|
||||
// generate state name based on capital or random name and culture-specific suffix
|
||||
const getState = function (name, culture, base, cultures, nameBases, utils) {
|
||||
const { ERROR, P, capitalize, vowel } = utils;
|
||||
|
||||
if (name === undefined) return ERROR && console.error("Please define a base name");
|
||||
if (culture === undefined && base === undefined) return ERROR && console.error("Please define a culture");
|
||||
if (base === undefined) base = cultures[culture].base;
|
||||
|
||||
// exclude endings inappropriate for states name
|
||||
if (name.includes(" ")) name = capitalize(name.replace(/ /g, "").toLowerCase()); // don't allow multiword state names
|
||||
if (name.length > 6 && name.slice(-4) === "berg") name = name.slice(0, -4); // remove -berg for any
|
||||
if (name.length > 5 && name.slice(-3) === "ton") name = name.slice(0, -3); // remove -ton for any
|
||||
|
||||
if (base === 5 && ["sk", "ev", "ov"].includes(name.slice(-2))) name = name.slice(0, -2);
|
||||
// remove -sk/-ev/-ov for Ruthenian
|
||||
else if (base === 12) return vowel(name.slice(-1)) ? name : name + "u";
|
||||
// Japanese ends on any vowel or -u
|
||||
else if (base === 18 && P(0.4))
|
||||
name = vowel(name.slice(0, 1).toLowerCase()) ? "Al" + name.toLowerCase() : "Al " + name; // Arabic starts with -Al
|
||||
|
||||
// no suffix for fantasy bases
|
||||
if (base > 32 && base < 42) return name;
|
||||
|
||||
// define if suffix should be used
|
||||
if (name.length > 3 && vowel(name.slice(-1))) {
|
||||
if (vowel(name.slice(-2, -1)) && P(0.85)) name = name.slice(0, -2);
|
||||
// 85% for vv
|
||||
else if (P(0.7)) name = name.slice(0, -1);
|
||||
// ~60% for cv
|
||||
else return name;
|
||||
} else if (P(0.4)) return name; // 60% for cc and vc
|
||||
|
||||
// define suffix
|
||||
let suffix = "ia"; // standard suffix
|
||||
|
||||
const rnd = Math.random(),
|
||||
l = name.length;
|
||||
if (base === 3 && rnd < 0.03 && l < 7) suffix = "terra";
|
||||
// Italian
|
||||
else if (base === 4 && rnd < 0.03 && l < 7) suffix = "terra";
|
||||
// Spanish
|
||||
else if (base === 13 && rnd < 0.03 && l < 7) suffix = "terra";
|
||||
// Portuguese
|
||||
else if (base === 2 && rnd < 0.03 && l < 7) suffix = "terre";
|
||||
// French
|
||||
else if (base === 0 && rnd < 0.5 && l < 7) suffix = "land";
|
||||
// German
|
||||
else if (base === 1 && rnd < 0.4 && l < 7) suffix = "land";
|
||||
// English
|
||||
else if (base === 6 && rnd < 0.3 && l < 7) suffix = "land";
|
||||
// Nordic
|
||||
else if (base === 32 && rnd < 0.1 && l < 7) suffix = "land";
|
||||
// generic Human
|
||||
else if (base === 7 && rnd < 0.1) suffix = "eia";
|
||||
// Greek
|
||||
else if (base === 9 && rnd < 0.35) suffix = "maa";
|
||||
// Finnic
|
||||
else if (base === 15 && rnd < 0.4 && l < 6) suffix = "orszag";
|
||||
// Hungarian
|
||||
else if (base === 16) suffix = rnd < 0.6 ? "yurt" : "eli";
|
||||
// Turkish
|
||||
else if (base === 10) suffix = "guk";
|
||||
// Korean
|
||||
else if (base === 11) suffix = " Guo";
|
||||
// Chinese
|
||||
else if (base === 14) suffix = rnd < 0.5 && l < 6 ? "tlan" : "co";
|
||||
// Nahuatl
|
||||
else if (base === 17 && rnd < 0.8) suffix = "a";
|
||||
// Berber
|
||||
else if (base === 18 && rnd < 0.8) suffix = "a"; // Arabic
|
||||
|
||||
return validateSuffix(name, suffix, utils);
|
||||
};
|
||||
|
||||
function validateSuffix(name, suffix, utils) {
|
||||
const { vowel } = utils;
|
||||
|
||||
if (name.slice(-1 * suffix.length) === suffix) return name; // no suffix if name already ends with it
|
||||
const s1 = suffix.charAt(0);
|
||||
if (name.slice(-1) === s1) name = name.slice(0, -1); // remove name last letter if it's a suffix first letter
|
||||
if (vowel(s1) === vowel(name.slice(-1)) && vowel(s1) === vowel(name.slice(-2, -1))) name = name.slice(0, -1); // remove name last char if 2 last chars are the same type as suffix's 1st
|
||||
if (name.slice(-1) === s1) name = name.slice(0, -1); // remove name last letter if it's a suffix first letter
|
||||
return name + suffix;
|
||||
}
|
||||
|
||||
// generate name for the map
|
||||
const getMapName = function (nameBases, config, utils) {
|
||||
const { P, rand } = utils;
|
||||
|
||||
const base = P(0.7) ? 2 : P(0.5) ? rand(0, 6) : rand(0, 31);
|
||||
if (!nameBases[base]) {
|
||||
return "";
|
||||
}
|
||||
const min = nameBases[base].min - 1;
|
||||
const max = Math.max(nameBases[base].max - 3, min);
|
||||
const baseName = getBase(base, min, max, "", nameBases, utils);
|
||||
const name = P(0.7) ? addSuffix(baseName, utils) : baseName;
|
||||
return name;
|
||||
};
|
||||
|
||||
function addSuffix(name, utils) {
|
||||
const { P } = utils;
|
||||
|
||||
const suffix = P(0.8) ? "ia" : "land";
|
||||
if (suffix === "ia" && name.length > 6) name = name.slice(0, -(name.length - 3));
|
||||
else if (suffix === "land" && name.length > 6) name = name.slice(0, -(name.length - 5));
|
||||
return validateSuffix(name, suffix, utils);
|
||||
}
|
||||
|
||||
const getNameBases = function () {
|
||||
// name, min length, max length, letters to allow duplication, multi-word name rate [deprecated]
|
||||
// prettier-ignore
|
||||
return [
|
||||
{name: "German", i: 0, min: 5, max: 12, d: "lt", m: 0, b: "Achern,Aichhalden,Aitern,Albbruck,Alpirsbach,Altensteig,Althengstett,Appenweier,Auggen,Badenen,Badenweiler,Baiersbronn,Ballrechten,Bellingen,Berghaupten,Bernau,Biberach,Biederbach,Binzen,Birkendorf,Birkenfeld,Bischweier,Blumberg,Bollen,Bollschweil,Bonndorf,Bosingen,Braunlingen,Breisach,Breisgau,Breitnau,Brigachtal,Buchenbach,Buggingen,Buhl,Buhlertal,Calw,Dachsberg,Dobel,Donaueschingen,Dornhan,Dornstetten,Dottingen,Dunningen,Durbach,Durrheim,Ebhausen,Ebringen,Efringen,Egenhausen,Ehrenkirchen,Ehrsberg,Eimeldingen,Eisenbach,Elzach,Elztal,Emmendingen,Endingen,Engelsbrand,Enz,Enzklosterle,Eschbronn,Ettenheim,Ettlingen,Feldberg,Fischerbach,Fischingen,Fluorn,Forbach,Freiamt,Freiburg,Freudenstadt,Friedenweiler,Friesenheim,Frohnd,Furtwangen,Gaggenau,Geisingen,Gengenbach,Gernsbach,Glatt,Glatten,Glottertal,Gorwihl,Gottenheim,Grafenhausen,Grenzach,Griesbach,Gutach,Gutenbach,Hag,Haiterbach,Hardt,Harmersbach,Hasel,Haslach,Hausach,Hausen,Hausern,Heitersheim,Herbolzheim,Herrenalb,Herrischried,Hinterzarten,Hochenschwand,Hofen,Hofstetten,Hohberg,Horb,Horben,Hornberg,Hufingen,Ibach,Ihringen,Inzlingen,Kandern,Kappel,Kappelrodeck,Karlsbad,Karlsruhe,Kehl,Keltern,Kippenheim,Kirchzarten,Konigsfeld,Krozingen,Kuppenheim,Kussaberg,Lahr,Lauchringen,Lauf,Laufenburg,Lautenbach,Lauterbach,Lenzkirch,Liebenzell,Loffenau,Loffingen,Lorrach,Lossburg,Mahlberg,Malsburg,Malsch,March,Marxzell,Marzell,Maulburg,Monchweiler,Muhlenbach,Mullheim,Munstertal,Murg,Nagold,Neubulach,Neuenburg,Neuhausen,Neuried,Neuweiler,Niedereschach,Nordrach,Oberharmersbach,Oberkirch,Oberndorf,Oberbach,Oberried,Oberwolfach,Offenburg,Ohlsbach,Oppenau,Ortenberg,otigheim,Ottenhofen,Ottersweier,Peterstal,Pfaffenweiler,Pfalzgrafenweiler,Pforzheim,Rastatt,Renchen,Rheinau,Rheinfelden,Rheinmunster,Rickenbach,Rippoldsau,Rohrdorf,Rottweil,Rummingen,Rust,Sackingen,Sasbach,Sasbachwalden,Schallbach,Schallstadt,Schapbach,Schenkenzell,Schiltach,Schliengen,Schluchsee,Schomberg,Schonach,Schonau,Schonenberg,Schonwald,Schopfheim,Schopfloch,Schramberg,Schuttertal,Schwenningen,Schworstadt,Seebach,Seelbach,Seewald,Sexau,Simmersfeld,Simonswald,Sinzheim,Solden,Staufen,Stegen,Steinach,Steinen,Steinmauern,Straubenhardt,Stuhlingen,Sulz,Sulzburg,Teinach,Tiefenbronn,Tiengen,Titisee,Todtmoos,Todtnau,Todtnauberg,Triberg,Tunau,Tuningen,uhlingen,Unterkirnach,Reichenbach,Utzenfeld,Villingen,Villingendorf,Vogtsburg,Vohrenbach,Waldachtal,Waldbronn,Waldkirch,Waldshut,Wehr,Weil,Weilheim,Weisenbach,Wembach,Wieden,Wiesental,Wildbad,Wildberg,Winzeln,Wittlingen,Wittnau,Wolfach,Wutach,Wutoschingen,Wyhlen,Zavelstein"},
|
||||
{name: "English", i: 1, min: 6, max: 11, d: "", m: .1, b: "Abingdon,Albrighton,Alcester,Almondbury,Altrincham,Amersham,Andover,Appleby,Ashboume,Atherstone,Aveton,Axbridge,Aylesbury,Baldock,Bamburgh,Barton,Basingstoke,Berden,Bere,Berkeley,Berwick,Betley,Bideford,Bingley,Birmingham,Blandford,Blechingley,Bodmin,Bolton,Bootham,Boroughbridge,Boscastle,Bossinney,Bramber,Brampton,Brasted,Bretford,Bridgetown,Bridlington,Bromyard,Bruton,Buckingham,Bungay,Burton,Calne,Cambridge,Canterbury,Carlisle,Castleton,Caus,Charmouth,Chawleigh,Chichester,Chillington,Chinnor,Chipping,Chisbury,Cleobury,Clifford,Clifton,Clitheroe,Cockermouth,Coleshill,Combe,Congleton,Crafthole,Crediton,Cuddenbeck,Dalton,Darlington,Dodbrooke,Drax,Dudley,Dunstable,Dunster,Dunwich,Durham,Dymock,Exeter,Exning,Faringdon,Felton,Fenny,Finedon,Flookburgh,Fowey,Frampton,Gateshead,Gatton,Godmanchester,Grampound,Grantham,Guildford,Halesowen,Halton,Harbottle,Harlow,Hatfield,Hatherleigh,Haydon,Helston,Henley,Hertford,Heytesbury,Hinckley,Hitchin,Holme,Hornby,Horsham,Kendal,Kenilworth,Kilkhampton,Kineton,Kington,Kinver,Kirby,Knaresborough,Knutsford,Launceston,Leighton,Lewes,Linton,Louth,Luton,Lyme,Lympstone,Macclesfield,Madeley,Malborough,Maldon,Manchester,Manningtree,Marazion,Marlborough,Marshfield,Mere,Merryfield,Middlewich,Midhurst,Milborne,Mitford,Modbury,Montacute,Mousehole,Newbiggin,Newborough,Newbury,Newenden,Newent,Norham,Northleach,Noss,Oakham,Olney,Orford,Ormskirk,Oswestry,Padstow,Paignton,Penkneth,Penrith,Penzance,Pershore,Petersfield,Pevensey,Pickering,Pilton,Pontefract,Portsmouth,Preston,Quatford,Reading,Redcliff,Retford,Rockingham,Romney,Rothbury,Rothwell,Salisbury,Saltash,Seaford,Seasalter,Sherston,Shifnal,Shoreham,Sidmouth,Skipsea,Skipton,Solihull,Somerton,Southam,Southwark,Standon,Stansted,Stapleton,Stottesdon,Sudbury,Swavesey,Tamerton,Tarporley,Tetbury,Thatcham,Thaxted,Thetford,Thornbury,Tintagel,Tiverton,Torksey,Totnes,Towcester,Tregoney,Trematon,Tutbury,Uxbridge,Wallingford,Wareham,Warenmouth,Wargrave,Warton,Watchet,Watford,Wendover,Westbury,Westcheap,Weymouth,Whitford,Wickwar,Wigan,Wigmore,Winchelsea,Winkleigh,Wiscombe,Witham,Witheridge,Wiveliscombe,Woodbury,Yeovil"},
|
||||
{name: "French", i: 2, min: 5, max: 13, d: "nlrs", m: .1, b: "Adon,Aillant,Amilly,Andonville,Ardon,Artenay,Ascheres,Ascoux,Attray,Aubin,Audeville,Aulnay,Autruy,Auvilliers,Auxy,Aveyron,Baccon,Bardon,Barville,Batilly,Baule,Bazoches,Beauchamps,Beaugency,Beaulieu,Beaune,Bellegarde,Boesses,Boigny,Boiscommun,Boismorand,Boisseaux,Bondaroy,Bonnee,Bonny,Bordes,Bou,Bougy,Bouilly,Boulay,Bouzonville,Bouzy,Boynes,Bray,Breteau,Briare,Briarres,Bricy,Bromeilles,Bucy,Cepoy,Cercottes,Cerdon,Cernoy,Cesarville,Chailly,Chaingy,Chalette,Chambon,Champoulet,Chanteau,Chantecoq,Chapell,Charme,Charmont,Charsonville,Chateau,Chateauneuf,Chatel,Chatenoy,Chatillon,Chaussy,Checy,Chevannes,Chevillon,Chevilly,Chevry,Chilleurs,Choux,Chuelles,Clery,Coinces,Coligny,Combleux,Combreux,Conflans,Corbeilles,Corquilleroy,Cortrat,Coudroy,Coullons,Coulmiers,Courcelles,Courcy,Courtemaux,Courtempierre,Courtenay,Cravant,Crottes,Dadonville,Dammarie,Dampierre,Darvoy,Desmonts,Dimancheville,Donnery,Dordives,Dossainville,Douchy,Dry,Echilleuses,Egry,Engenville,Epieds,Erceville,Ervauville,Escrennes,Escrignelles,Estouy,Faverelles,Fay,Feins,Ferolles,Ferrieres,Fleury,Fontenay,Foret,Foucherolles,Freville,Gatinais,Gaubertin,Gemigny,Germigny,Gidy,Gien,Girolles,Givraines,Gondreville,Grangermont,Greneville,Griselles,Guigneville,Guilly,Gyleslonains,Huetre,Huisseau,Ingrannes,Ingre,Intville,Isdes,Ivre,Jargeau,Jouy,Juranville,Bussiere,Laas,Ladon,Lailly,Langesse,Leouville,Ligny,Lombreuil,Lorcy,Lorris,Loury,Louzouer,Malesherbois,Marcilly,Mardie,Mareau,Marigny,Marsainvilliers,Melleroy,Menestreau,Merinville,Messas,Meung,Mezieres,Migneres,Mignerette,Mirabeau,Montargis,Montbarrois,Montbouy,Montcresson,Montereau,Montigny,Montliard,Mormant,Morville,Moulinet,Moulon,Nancray,Nargis,Nesploy,Neuville,Neuvy,Nevoy,Nibelle,Nogent,Noyers,Ocre,Oison,Olivet,Ondreville,Onzerain,Orleans,Ormes,Orville,Oussoy,Outarville,Ouzouer,Pannecieres,Pannes,Patay,Paucourt,Pers,Pierrefitte,Pithiverais,Pithiviers,Poilly,Potier,Prefontaines,Presnoy,Pressigny,Puiseaux,Quiers,Ramoulu,Rebrechien,Rouvray,Rozieres,Rozoy,Ruan,Sandillon,Santeau,Saran,Sceaux,Seichebrieres,Semoy,Sennely,Sermaises,Sigloy,Solterre,Sougy,Sully,Sury,Tavers,Thignonville,Thimory,Thorailles,Thou,Tigy,Tivernon,Tournoisis,Trainou,Treilles,Trigueres,Trinay,Vannes,Varennes,Vennecy,Vieilles,Vienne,Viglain,Vignes,Villamblain,Villemandeur,Villemoutiers,Villemurlin,Villeneuve,Villereau,Villevoques,Villorceau,Vimory,Vitry,Vrigny"},
|
||||
{name: "Italian", i: 3, min: 5, max: 12, d: "cltr", m: .1, b: "Accumoli,Acquafondata,Acquapendente,Acuto,Affile,Agosta,Alatri,Albano,Allumiere,Alvito,Amaseno,Amatrice,Anagni,Anguillara,Anticoli,Antrodoco,Anzio,Aprilia,Aquino,Arcinazzo,Ariccia,Arpino,Arsoli,Ausonia,Bagnoregio,Bassiano,Bellegra,Belmonte,Bolsena,Bomarzo,Borgorose,Boville,Bracciano,Broccostella,Calcata,Camerata,Campagnano,Campoli,Canale,Canino,Cantalice,Cantalupo,Capranica,Caprarola,Carbognano,Casalattico,Casalvieri,Castelforte,Castelnuovo,Castiglione,Castro,Castrocielo,Ceccano,Celleno,Cellere,Cerreto,Cervara,Cerveteri,Ciampino,Ciciliano,Cittaducale,Cittareale,Civita,Civitella,Colfelice,Colleferro,Collepardo,Colonna,Concerviano,Configni,Contigliano,Cori,Cottanello,Esperia,Faleria,Farnese,Ferentino,Fiamignano,Filacciano,Fiuggi,Fiumicino,Fondi,Fontana,Fonte,Fontechiari,Formia,Frascati,Frasso,Frosinone,Fumone,Gaeta,Gallese,Gavignano,Genazzano,Giuliano,Gorga,Gradoli,Grottaferrata,Grotte,Guarcino,Guidonia,Ischia,Isola,Labico,Labro,Ladispoli,Latera,Lenola,Leonessa,Licenza,Longone,Lubriano,Maenza,Magliano,Marano,Marcellina,Marcetelli,Marino,Mazzano,Mentana,Micigliano,Minturno,Montalto,Montasola,Montebuono,Monteflavio,Montelanico,Monteleone,Montenero,Monterosi,Moricone,Morlupo,Nazzano,Nemi,Nerola,Nespolo,Nettuno,Norma,Olevano,Onano,Oriolo,Orte,Orvinio,Paganico,Paliano,Palombara,Patrica,Pescorocchiano,Petrella,Piansano,Picinisco,Pico,Piedimonte,Piglio,Pignataro,Poggio,Poli,Pomezia,Pontecorvo,Pontinia,Ponzano,Posta,Pozzaglia,Priverno,Proceno,Rignano,Riofreddo,Ripi,Rivodutri,Rocca,Roccagorga,Roccantica,Roccasecca,Roiate,Ronciglione,Roviano,Salisano,Sambuci,Santa,Santini,Scandriglia,Segni,Selci,Sermoneta,Serrone,Settefrati,Sezze,Sgurgola,Sonnino,Sora,Soriano,Sperlonga,Spigno,Subiaco,Supino,Sutri,Tarano,Tarquinia,Terelle,Terracina,Tivoli,Toffia,Tolfa,Torrice,Torricella,Trevi,Trevignano,Trivigliano,Turania,Tuscania,Valentano,Vallecorsa,Vallemaio,Vallepietra,Vallerano,Vasanello,Vejano,Velletri,Ventotene,Veroli,Vetralla,Vicalvi,Vico,Vicovaro,Vignanello,Viterbo,Viticuso,Vitorchiano,Vivaro,Zagarolo"},
|
||||
{name: "Castillian", i: 4, min: 5, max: 11, d: "lr", m: 0, b: "Ajofrin,Alameda,Alaminos,Albares,Albarreal,Albendiego,Alcanizo,Alcaudete,Alcolea,Aldea,Aldeanueva,Algar,Algora,Alhondiga,Almadrones,Almendral,Alovera,Anguita,Arbancon,Argecilla,Arges,Arroyo,Atanzon,Atienza,Azuqueca,Baides,Banos,Bargas,Barriopedro,Belvis,Berninches,Brihuega,Buenaventura,Burgos,Burguillos,Bustares,Cabanillas,Calzada,Camarena,Campillo,Cantalojas,Cardiel,Carmena,Casas,Castejon,Castellar,Castilforte,Castillo,Castilnuevo,Cazalegas,Centenera,Cervera,Checa,Chozas,Chueca,Cifuentes,Cincovillas,Ciruelas,Cogollor,Cogolludo,Consuegra,Copernal,Corral,Cuerva,Domingo,Dosbarrios,Driebes,Duron,Escalona,Escalonilla,Escamilla,Escopete,Espinosa,Esplegares,Esquivias,Estables,Estriegana,Fontanar,Fuembellida,Fuensalida,Fuentelsaz,Gajanejos,Galvez,Gascuena,Gerindote,Guadamur,Heras,Herreria,Herreruela,Hinojosa,Hita,Hombrados,Hontanar,Hormigos,Huecas,Huerta,Humanes,Illana,Illescas,Iniestola,Irueste,Jadraque,Jirueque,Lagartera,Ledanca,Lillo,Lominchar,Loranca,Lucillos,Luzaga,Luzon,Madrid,Magan,Malaga,Malpica,Manzanar,Maqueda,Masegoso,Matillas,Medranda,Megina,Mejorada,Millana,Milmarcos,Mirabueno,Miralrio,Mocejon,Mochales,Molina,Mondejar,Montarron,Mora,Moratilla,Morenilla,Navas,Negredo,Noblejas,Numancia,Nuno,Ocana,Ocentejo,Olias,Olmeda,Ontigola,Orea,Orgaz,Oropesa,Otero,Palma,Pardos,Paredes,Penalver,Pepino,Peralejos,Pinilla,Pioz,Piqueras,Portillo,Poveda,Pozo,Pradena,Prados,Puebla,Puerto,Quero,Quintanar,Rebollosa,Retamoso,Riba,Riofrio,Robledo,Romanillos,Romanones,Rueda,Salmeron,Santiuste,Santo,Sauca,Segura,Selas,Semillas,Sesena,Setiles,Sevilla,Siguenza,Solanillos,Somolinos,Sonseca,Sotillo,Talavera,Taravilla,Tembleque,Tendilla,Tierzo,Torralba,Torre,Torrejon,Torrijos,Tortola,Tortuera,Totanes,Trillo,Uceda,Ugena,Urda,Utande,Valdesotos,Valhermoso,Valtablado,Valverde,Velada,Viana,Yebra,Yuncos,Yunquera,Zaorejas,Zarzuela,Zorita"},
|
||||
{name: "Ruthenian", i: 5, min: 5, max: 10, d: "", m: 0, b: "Belgorod,Beloberezhye,Belyi,Belz,Berestiy,Berezhets,Berezovets,Berezutsk,Bobruisk,Bolonets,Borisov,Borovsk,Bozhesk,Bratslav,Bryansk,Brynsk,Buryn,Byhov,Chechersk,Chemesov,Cheremosh,Cherlen,Chern,Chernigov,Chernitsa,Chernobyl,Chernogorod,Chertoryesk,Chetvertnia,Demyansk,Derevesk,Devyagoresk,Dichin,Dmitrov,Dorogobuch,Dorogobuzh,Drestvin,Drokov,Drutsk,Dubechin,Dubichi,Dubki,Dubkov,Dveren,Galich,Glebovo,Glinsk,Goloty,Gomiy,Gorodets,Gorodische,Gorodno,Gorohovets,Goroshin,Gorval,Goryshon,Holm,Horobor,Hoten,Hotin,Hotmyzhsk,Ilovech,Ivan,Izborsk,Izheslavl,Kamenets,Kanev,Karachev,Karna,Kavarna,Klechesk,Klyapech,Kolomyya,Kolyvan,Kopyl,Korec,Kornik,Korochunov,Korshev,Korsun,Koshkin,Kotelno,Kovyla,Kozelsk,Kozelsk,Kremenets,Krichev,Krylatsk,Ksniatin,Kulatsk,Kursk,Kursk,Lebedev,Lida,Logosko,Lomihvost,Loshesk,Loshichi,Lubech,Lubno,Lubutsk,Lutsk,Luchin,Luki,Lukoml,Luzha,Lvov,Mtsensk,Mdin,Medniki,Melecha,Merech,Meretsk,Mescherskoe,Meshkovsk,Metlitsk,Mezetsk,Mglin,Mihailov,Mikitin,Mikulino,Miloslavichi,Mogilev,Mologa,Moreva,Mosalsk,Moschiny,Mozyr,Mstislav,Mstislavets,Muravin,Nemech,Nemiza,Nerinsk,Nichan,Novgorod,Novogorodok,Obolichi,Obolensk,Obolensk,Oleshsk,Olgov,Omelnik,Opoka,Opoki,Oreshek,Orlets,Osechen,Oster,Ostrog,Ostrov,Perelai,Peremil,Peremyshl,Pererov,Peresechen,Perevitsk,Pereyaslav,Pinsk,Ples,Polotsk,Pronsk,Proposhesk,Punia,Putivl,Rechitsa,Rodno,Rogachev,Romanov,Romny,Roslavl,Rostislavl,Rostovets,Rsha,Ruza,Rybchesk,Rylsk,Rzhavesk,Rzhev,Rzhischev,Sambor,Serensk,Serensk,Serpeysk,Shilov,Shuya,Sinech,Sizhka,Skala,Slovensk,Slutsk,Smedin,Sneporod,Snitin,Snovsk,Sochevo,Sokolec,Starica,Starodub,Stepan,Sterzh,Streshin,Sutesk,Svinetsk,Svisloch,Terebovl,Ternov,Teshilov,Teterin,Tiversk,Torchevsk,Toropets,Torzhok,Tripolye,Trubchevsk,Tur,Turov,Usvyaty,Uteshkov,Vasilkov,Velil,Velye,Venev,Venicha,Verderev,Vereya,Veveresk,Viazma,Vidbesk,Vidychev,Voino,Volodimer,Volok,Volyn,Vorobesk,Voronich,Voronok,Vorotynsk,Vrev,Vruchiy,Vselug,Vyatichsk,Vyatka,Vyshegorod,Vyshgorod,Vysokoe,Yagniatin,Yaropolch,Yasenets,Yuryev,Yuryevets,Zaraysk,Zhitomel,Zholvazh,Zizhech,Zubkov,Zudechev,Zvenigorod"},
|
||||
{name: "Nordic", i: 6, min: 6, max: 10, d: "kln", m: .1, b: "Akureyri,Aldra,Alftanes,Andenes,Austbo,Auvog,Bakkafjordur,Ballangen,Bardal,Beisfjord,Bifrost,Bildudalur,Bjerka,Bjerkvik,Bjorkosen,Bliksvaer,Blokken,Blonduos,Bolga,Bolungarvik,Borg,Borgarnes,Bosmoen,Bostad,Bostrand,Botsvika,Brautarholt,Breiddalsvik,Bringsli,Brunahlid,Budardalur,Byggdakjarni,Dalvik,Djupivogur,Donnes,Drageid,Drangsnes,Egilsstadir,Eiteroga,Elvenes,Engavogen,Ertenvog,Eskifjordur,Evenes,Eyrarbakki,Fagernes,Fallmoen,Fellabaer,Fenes,Finnoya,Fjaer,Fjelldal,Flakstad,Flateyri,Flostrand,Fludir,Gardaber,Gardur,Gimstad,Givaer,Gjeroy,Gladstad,Godoya,Godoynes,Granmoen,Gravdal,Grenivik,Grimsey,Grindavik,Grytting,Hafnir,Halsa,Hauganes,Haugland,Hauknes,Hella,Helland,Hellissandur,Hestad,Higrav,Hnifsdalur,Hofn,Hofsos,Holand,Holar,Holen,Holkestad,Holmavik,Hopen,Hovden,Hrafnagil,Hrisey,Husavik,Husvik,Hvammstangi,Hvanneyri,Hveragerdi,Hvolsvollur,Igeroy,Indre,Inndyr,Innhavet,Innes,Isafjordur,Jarklaustur,Jarnsreykir,Junkerdal,Kaldvog,Kanstad,Karlsoy,Kavosen,Keflavik,Kjelde,Kjerstad,Klakk,Kopasker,Kopavogur,Korgen,Kristnes,Krutoga,Krystad,Kvina,Lande,Laugar,Laugaras,Laugarbakki,Laugarvatn,Laupstad,Leines,Leira,Leiren,Leland,Lenvika,Loding,Lodingen,Lonsbakki,Lopsmarka,Lovund,Luroy,Maela,Melahverfi,Meloy,Mevik,Misvaer,Mornes,Mosfellsber,Moskenes,Myken,Naurstad,Nesberg,Nesjahverfi,Nesset,Nevernes,Obygda,Ofoten,Ogskardet,Okervika,Oknes,Olafsfjordur,Oldervika,Olstad,Onstad,Oppeid,Oresvika,Orsnes,Orsvog,Osmyra,Overdal,Prestoya,Raudalaekur,Raufarhofn,Reipo,Reykholar,Reykholt,Reykjahlid,Rif,Rinoya,Rodoy,Rognan,Rosvika,Rovika,Salhus,Sanden,Sandgerdi,Sandoker,Sandset,Sandvika,Saudarkrokur,Selfoss,Selsoya,Sennesvik,Setso,Siglufjordur,Silvalen,Skagastrond,Skjerstad,Skonland,Skorvogen,Skrova,Sleneset,Snubba,Softing,Solheim,Solheimar,Sorarnoy,Sorfugloy,Sorland,Sormela,Sorvaer,Sovika,Stamsund,Stamsvika,Stave,Stokka,Stokkseyri,Storjord,Storo,Storvika,Strand,Straumen,Strendene,Sudavik,Sudureyri,Sundoya,Sydalen,Thingeyri,Thorlakshofn,Thorshofn,Tjarnabyggd,Tjotta,Tosbotn,Traelnes,Trofors,Trones,Tverro,Ulvsvog,Unnstad,Utskor,Valla,Vandved,Varmahlid,Vassos,Vevelstad,Vidrek,Vik,Vikholmen,Vogar,Vogehamn,Vopnafjordur"},
|
||||
{name: "Greek", i: 7, min: 5, max: 11, d: "s", m: .1, b: "Abdera,Acharnae,Aegae,Aegina,Agrinion,Aigosthena,Akragas,Akroinon,Akrotiri,Alalia,Alexandria,Amarynthos,Amaseia,Amphicaea,Amphigeneia,Amphipolis,Antipatrea,Antiochia,Apamea,Aphidna,Apollonia,Argos,Artemita,Argyropolis,Asklepios,Athenai,Athmonia,Bhrytos,Borysthenes,Brauron,Byblos,Byzantion,Bythinion,Calydon,Chamaizi,Chalcis,Chios,Cleona,Corcyra,Croton,Cyrene,Cythera,Decelea,Delos,Delphi,Dicaearchia,Didyma,Dion,Dioscurias,Dodona,Dorylaion,Elateia,Eleusis,Eleutherna,Emporion,Ephesos,Epidamnos,Epidauros,Epizephyrian,Erythrae,Eubea,Golgi,Gonnos,Gorgippia,Gournia,Gortyn,Gytion,Hagios,Halicarnassos,Heliopolis,Hellespontos,Heloros,Heraclea,Hierapolis,Himera,Histria,Hubla,Hyele,Ialysos,Iasos,Idalion,Imbros,Iolcos,Itanos,Ithaca,Juktas,Kallipolis,Kameiros,Karistos,Kasmenai,Kepoi,Kimmerikon,Knossos,Korinthos,Kos,Kourion,Kydonia,Kyrenia,Lamia,Lampsacos,Laodicea,Lapithos,Larissa,Lebena,Lefkada,Lekhaion,Leibethra,Leontinoi,Lilaea,Lindos,Lissos,Magnesia,Mantineia,Marathon,Marmara,Massalia,Megalopolis,Megara,Metapontion,Methumna,Miletos,Morgantina,Mulai,Mukenai,Myonia,Myra,Myrmekion,Myos,Nauplios,Naucratis,Naupaktos,Naxos,Neapolis,Nemea,Nicaea,Nicopolis,Nymphaion,Nysa,Odessos,Olbia,Olympia,Olynthos,Opos,Orchomenos,Oricos,Orestias,Oreos,Onchesmos,Pagasae,Palaikastro,Pandosia,Panticapaion,Paphos,Pargamon,Paros,Pegai,Pelion,Peiraies,Phaistos,Phaleron,Pharos,Pithekussa,Philippopolis,Phocaea,Pinara,Pisa,Pitane,Plataea,Poseidonia,Potidaea,Pseira,Psychro,Pteleos,Pydna,Pylos,Pyrgos,Rhamnos,Rhithymna,Rhypae,Rizinia,Rodos,Salamis,Samos,Skyllaion,Seleucia,Semasos,Sestos,Scidros,Sicyon,,Sinope,Siris,Smyrna,Sozopolis,Sparta,Stagiros,Stratos,Stymphalos,Sybaris,Surakousai,Taras,Tanagra,Tanais,Tauromenion,Tegea,Temnos,Teos,Thapsos,Thassos,Thebai,Theodosia,Therma,Thespian,Thronion,Thoricos,Thurii,Thyreum,Thyria,Tithoraea,Tomis,Tragurion,Tripolis,Troliton,Troy,Tylissos,Tyros,Vathypetros,Zakynthos,Zakros"},
|
||||
{name: "Roman", i: 8, min: 6, max: 11, d: "ln", m: .1, b: "Abila,Adflexum,Adnicrem,Aelia,Aelius,Aeminium,Aequum,Agrippina,Agrippinae,Ala,Albanianis,Aleria,Ambianum,Andautonia,Apulum,Aquae,Aquaegranni,Aquensis,Aquileia,Aquincum,Arae,Argentoratum,Ariminum,Ascrivium,Asturica,Atrebatum,Atuatuca,Augusta,Aurelia,Aurelianorum,Batavar,Batavorum,Belum,Biriciana,Blestium,Bonames,Bonna,Bononia,Borbetomagus,Bovium,Bracara,Brigantium,Burgodunum,Caesaraugusta,Caesarea,Caesaromagus,Calleva,Camulodunum,Cannstatt,Cantiacorum,Capitolina,Caralis,Castellum,Castra,Castrum,Cibalae,Clausentum,Colonia,Concangis,Condate,Confluentes,Conimbriga,Corduba,Coria,Corieltauvorum,Corinium,Coriovallum,Cornoviorum,Danum,Deva,Dianium,Divodurum,Dobunnorum,Drusi,Dubris,Dumnoniorum,Durnovaria,Durocobrivis,Durocornovium,Duroliponte,Durovernum,Durovigutum,Eboracum,Ebusus,Edetanorum,Emerita,Emona,Emporiae,Euracini,Faventia,Flaviae,Florentia,Forum,Gerulata,Gerunda,Gesoscribate,Glevensium,Hadriani,Herculanea,Isca,Italica,Iulia,Iuliobrigensium,Iuvavum,Lactodurum,Lagentium,Lapurdum,Lauri,Legionis,Lemanis,Lentia,Lepidi,Letocetum,Lindinis,Lindum,Lixus,Londinium,Lopodunum,Lousonna,Lucus,Lugdunum,Luguvalium,Lutetia,Mancunium,Marsonia,Martius,Massa,Massilia,Matilo,Mattiacorum,Mediolanum,Mod,Mogontiacum,Moridunum,Mursa,Naissus,Nervia,Nida,Nigrum,Novaesium,Noviomagus,Olicana,Olisippo,Ovilava,Parisiorum,Partiscum,Paterna,Pistoria,Placentia,Pollentia,Pomaria,Pompeii,Pons,Portus,Praetoria,Praetorium,Pullum,Ragusium,Ratae,Raurica,Ravenna,Regina,Regium,Regulbium,Rigomagus,Roma,Romula,Rutupiae,Salassorum,Salernum,Salona,Scalabis,Segovia,Silurum,Sirmium,Siscia,Sorviodurum,Sumelocenna,Tarraco,Taurinorum,Theranda,Traiectum,Treverorum,Tungrorum,Turicum,Ulpia,Valentia,Venetiae,Venta,Verulamium,Vesontio,Vetera,Victoriae,Victrix,Villa,Viminacium,Vindelicorum,Vindobona,Vinovia,Viroconium"},
|
||||
{name: "Finnic", i: 9, min: 5, max: 11, d: "akiut", m: 0, b: "Aanekoski,Ahlainen,Aholanvaara,Ahtari,Aijala,Akaa,Alajarvi,Antsla,Aspo,Bennas,Bjorkoby,Elva,Emasalo,Espoo,Esse,Evitskog,Forssa,Haapamaki,Haapavesi,Haapsalu,Hameenlinna,Hanko,Harjavalta,Hattuvaara,Hautajarvi,Havumaki,Heinola,Hetta,Hinkabole,Hirmula,Hossa,Huittinen,Husula,Hyryla,Hyvinkaa,Ikaalinen,Iskmo,Itakoski,Jamsa,Jarvenpaa,Jeppo,Jioesuu,Jiogeva,Joensuu,Jokikyla,Jungsund,Jyvaskyla,Kaamasmukka,Kajaani,Kalajoki,Kallaste,Kankaanpaa,Karkku,Karpankyla,Kaskinen,Kasnas,Kauhajoki,Kauhava,Kauniainen,Kauvatsa,Kehra,Kellokoski,Kelottijarvi,Kemi,Kemijarvi,Kerava,Keuruu,Kiljava,Kiuruvesi,Kivesjarvi,Kiviioli,Kivisuo,Klaukkala,Klovskog,Kohtlajarve,Kokemaki,Kokkola,Kolho,Koskue,Kotka,Kouva,Kaupunki,Kuhmo,Kunda,Kuopio,Kuressaare,Kurikka,Kuusamo,Kylmalankyla,Lahti,Laitila,Lankipohja,Lansikyla,Lapua,Laurila,Lautiosaari,Lempaala,Lepsama,Liedakkala,Lieksa,Littoinen,Lohja,Loimaa,Loksa,Loviisa,Malmi,Mantta,Matasvaara,Maula,Miiluranta,Mioisakula,Munapirtti,Mustvee,Muurahainen,Naantali,Nappa,Narpio,Niinimaa,Niinisalo,Nikkila,Nilsia,Nivala,Nokia,Nummela,Nuorgam,Nuvvus,Obbnas,Oitti,Ojakkala,Onninen,Orimattila,Orivesi,Otanmaki,Otava,Otepaa,Oulainen,Oulu,Paavola,Paide,Paimio,Pakankyla,Paldiski,Parainen,Parkumaki,Parola,Perttula,Pieksamaki,Pioltsamaa,Piolva,Pohjavaara,Porhola,Porrasa,Porvoo,Pudasjarvi,Purmo,Pyhajarvi,Raahe,Raasepori,Raisio,Rajamaki,Rakvere,Rapina,Rapla,Rauma,Rautio,Reposaari,Riihimaki,Rovaniemi,Roykka,Ruonala,Ruottala,Rutalahti,Saarijarvi,Salo,Sastamala,Saue,Savonlinna,Seinajoki,Sillamae,Siuntio,Sompujarvi,Suonenjoki,Suurejaani,Syrjantaka,Tamsalu,Tapa,Temmes,Tiorva,Tormasenvaara,Tornio,Tottijarvi,Tulppio,Turenki,Turi,Tuukkala,Tuurala,Tuuri,Tuuski,Tuusniemi,Ulvila,Unari,Upinniemi,Utti,Uusikaupunki,Vaaksy,Vaalimaa,Vaarinmaja,Vaasa,Vainikkala,Valga,Valkeakoski,Vantaa,Varkaus,Vehkapera,Vehmasmaki,Vieki,Vierumaki,Viitasaari,Viljandi,Vilppula,Viohma,Vioru,Virrat,Ylike,Ylivieska,Ylojarvi"},
|
||||
{name: "Korean", i: 10, min: 5, max: 11, d: "", m: 0, b: "Anjung,Ansan,Anseong,Anyang,Aphae,Apo,Baekseok,Baeksu,Beolgyo,Boeun,Boseong,Busan,Buyeo,Changnyeong,Changwon,Cheonan,Cheongdo,Cheongjin,Cheongsong,Cheongyang,Cheorwon,Chirwon,Chuncheon,Chungju,Daedeok,Daegaya,Daejeon,Damyang,Dangjin,Dasa,Donghae,Dongsong,Doyang,Eonyang,Gaeseong,Ganggyeong,Ganghwa,Gangneung,Ganseong,Gaun,Geochang,Geoje,Geoncheon,Geumho,Geumil,Geumwang,Gijang,Gimcheon,Gimhwa,Gimje,Goa,Gochang,Gohan,Gongdo,Gongju,Goseong,Goyang,Gumi,Gunpo,Gunsan,Guri,Gurye,Gwangju,Gwangyang,Gwansan,Gyeongseong,Hadong,Hamchang,Hampyeong,Hamyeol,Hanam,Hapcheon,Hayang,Heungnam,Hongnong,Hongseong,Hwacheon,Hwando,Hwaseong,Hwasun,Hwawon,Hyangnam,Incheon,Inje,Iri,Janghang,Jangheung,Jangseong,Jangseungpo,Jangsu,Jecheon,Jeju,Jeomchon,Jeongeup,Jeonggwan,Jeongju,Jeongok,Jeongseon,Jeonju,Jido,Jiksan,Jinan,Jincheon,Jindo,Jingeon,Jinjeop,Jinnampo,Jinyeong,Jocheon,Jochiwon,Jori,Maepo,Mangyeong,Mokpo,Muju,Munsan,Naesu,Naju,Namhae,Namwon,Namyang,Namyangju,Nongong,Nonsan,Ocheon,Okcheon,Okgu,Onam,Onsan,Onyang,Opo,Paengseong,Pogok,Poseung,Pungsan,Pyeongchang,Pyeonghae,Pyeongyang,Sabi,Sacheon,Samcheok,Samho,Samrye,Sancheong,Sangdong,Sangju,Sapgyo,Sariwon,Sejong,Seocheon,Seogwipo,Seonghwan,Seongjin,Seongju,Seongnam,Seongsan,Seosan,Seungju,Siheung,Sindong,Sintaein,Soheul,Sokcho,Songak,Songjeong,Songnim,Songtan,Suncheon,Taean,Taebaek,Tongjin,Uijeongbu,Uiryeong,Uiwang,Uljin,Ulleung,Unbong,Ungcheon,Ungjin,Waegwan,Wando,Wayang,Wiryeseong,Wondeok,Yangju,Yangsan,Yangyang,Yecheon,Yeomchi,Yeoncheon,Yeongam,Yeongcheon,Yeongdeok,Yeongdong,Yeonggwang,Yeongju,Yeongwol,Yeongyang,Yeonil,Yongin,Yongjin,Yugu"},
|
||||
{name: "Chinese", i: 11, min: 5, max: 10, d: "", m: 0, b: "Anding,Anlu,Anqing,Anshun,Baixing,Banyang,Baoqing,Binzhou,Caozhou,Changbai,Changchun,Changde,Changling,Changsha,Changzhou,Chengdu,Chenzhou,Chizhou,Chongqing,Chuxiong,Chuzhou,Dading,Daming,Datong,Daxing,Dengzhou,Deqing,Dihua,Dingli,Dongan,Dongchang,Dongchuan,Dongping,Duyun,Fengtian,Fengxiang,Fengyang,Fenzhou,Funing,Fuzhou,Ganzhou,Gaoyao,Gaozhou,Gongchang,Guangnan,Guangning,Guangping,Guangxin,Guangzhou,Guiyang,Hailong,Hangzhou,Hanyang,Hanzhong,Heihe,Hejian,Henan,Hengzhou,Hezhong,Huaian,Huaiqing,Huanglong,Huangzhou,Huining,Hulan,Huzhou,Jiading,Jian,Jianchang,Jiangning,Jiankang,Jiaxing,Jiayang,Jilin,Jinan,Jingjiang,Jingzhao,Jinhua,Jinzhou,Jiujiang,Kaifeng,Kaihua,Kangding,Kuizhou,Laizhou,Lianzhou,Liaoyang,Lijiang,Linan,Linhuang,Lintao,Liping,Liuzhou,Longan,Longjiang,Longxing,Luan,Lubin,Luzhou,Mishan,Nanan,Nanchang,Nandian,Nankang,Nanyang,Nenjiang,Ningbo,Ningguo,Ningwu,Ningxia,Ningyuan,Pingjiang,Pingliang,Pingyang,Puer,Puzhou,Qianzhou,Qingyang,Qingyuan,Qingzhou,Qujing,Quzhou,Raozhou,Rende,Ruian,Ruizhou,Shafeng,Shajing,Shaoqing,Shaowu,Shaoxing,Shaozhou,Shinan,Shiqian,Shouchun,Shuangcheng,Shulei,Shunde,Shuntian,Shuoping,Sicheng,Sinan,Sizhou,Songjiang,Suiding,Suihua,Suining,Suzhou,Taian,Taibei,Taiping,Taiwan,Taiyuan,Taizhou,Taonan,Tengchong,Tingzhou,Tongchuan,Tongqing,Tongzhou,Weihui,Wensu,Wenzhou,Wuchang,Wuding,Wuzhou,Xian,Xianchun,Xianping,Xijin,Xiliang,Xincheng,Xingan,Xingde,Xinghua,Xingjing,Xingyi,Xingyuan,Xingzhong,Xining,Xinmen,Xiping,Xuanhua,Xunzhou,Xuzhou,Yanan,Yangzhou,Yanji,Yanping,Yanzhou,Yazhou,Yichang,Yidu,Yilan,Yili,Yingchang,Yingde,Yingtian,Yingzhou,Yongchang,Yongping,Yongshun,Yuanzhou,Yuezhou,Yulin,Yunnan,Yunyang,Zezhou,Zhang,Zhangzhou,Zhaoqing,Zhaotong,Zhenan,Zhending,Zhenhai,Zhenjiang,Zhenxi,Zhenyun,Zhongshan,Zunyi"},
|
||||
{name: "Japanese", i: 12, min: 4, max: 10, d: "", m: 0, b: "Abira,Aga,Aikawa,Aizumisato,Ajigasawa,Akkeshi,Amagi,Ami,Ando,Asakawa,Ashikita,Bandai,Biratori,Chonan,Esashi,Fuchu,Fujimi,Funagata,Genkai,Godo,Goka,Gonohe,Gyokuto,Haboro,Hamatonbetsu,Harima,Hashikami,Hayashima,Heguri,Hidaka,Higashiura,Hiranai,Hirogawa,Hiroo,Hodatsushimizu,Hoki,Hokuei,Hokuryu,Horokanai,Ibigawa,Ichikai,Ichikawa,Ichinohe,Iijima,Iizuna,Ikawa,Inagawa,Itakura,Iwaizumi,Iwate,Kaisei,Kamifurano,Kamiita,Kamijima,Kamikawa,Kamishihoro,Kamiyama,Kanda,Kanna,Kasagi,Kasuya,Katsuura,Kawabe,Kawamoto,Kawanehon,Kawanishi,Kawara,Kawasaki,Kawatana,Kawazu,Kihoku,Kikonai,Kin,Kiso,Kitagata,Kitajima,Kiyama,Kiyosato,Kofu,Koge,Kohoku,Kokonoe,Kora,Kosa,Kotohira,Kudoyama,Kumejima,Kumenan,Kumiyama,Kunitomi,Kurate,Kushimoto,Kutchan,Kyonan,Kyotamba,Mashike,Matsumae,Mifune,Mihama,Minabe,Minami,Minamiechizen,Minamitane,Misaki,Misasa,Misato,Miyashiro,Miyoshi,Mori,Moseushi,Mutsuzawa,Nagaizumi,Nagatoro,Nagayo,Nagomi,Nakadomari,Nakanojo,Nakashibetsu,Namegawa,Nanbu,Nanporo,Naoshima,Nasu,Niseko,Nishihara,Nishiizu,Nishikatsura,Nishikawa,Nishinoshima,Nishiwaga,Nogi,Noto,Nyuzen,Oarai,Obuse,Odai,Ogawara,Oharu,Oirase,Oishida,Oiso,Oizumi,Oji,Okagaki,Okutama,Omu,Ono,Osaka,Otobe,Otsuki,Owani,Reihoku,Rifu,Rikubetsu,Rishiri,Rokunohe,Ryuo,Saka,Sakuho,Samani,Satsuma,Sayo,Saza,Setana,Shakotan,Shibayama,Shikama,Shimamoto,Shimizu,Shintomi,Shirakawa,Shisui,Shitara,Sobetsu,Sue,Sumita,Suooshima,Suttsu,Tabuse,Tachiarai,Tadami,Tadaoka,Taiji,Taiki,Takachiho,Takahama,Taketoyo,Taragi,Tateshina,Tatsugo,Tawaramoto,Teshikaga,Tobe,Tokigawa,Toma,Tomioka,Tonosho,Tosa,Toyokoro,Toyotomi,Toyoyama,Tsubata,Tsubetsu,Tsukigata,Tsuno,Tsuwano,Umi,Wakasa,Yamamoto,Yamanobe,Yamatsuri,Yanaizu,Yasuda,Yoichi,Yonaguni,Yoro,Yoshino,Yubetsu,Yugawara,Yuni,Yusuhara,Yuza"},
|
||||
{name: "Portuguese", i: 13, min: 5, max: 11, d: "", m: .1, b: "Abrigada,Afonsoeiro,Agueda,Aguilada,Alagoas,Alagoinhas,Albufeira,Alcanhoes,Alcobaca,Alcoutim,Aldoar,Alenquer,Alfeizerao,Algarve,Almada,Almagreira,Almeirim,Alpalhao,Alpedrinha,Alvorada,Amieira,Anapolis,Apelacao,Aranhas,Arganil,Armacao,Assenceira,Aveiro,Avelar,Balsas,Barcarena,Barreiras,Barretos,Batalha,Beira,Benavente,Betim,Braga,Braganca,Brasilia,Brejo,Cabeceiras,Cabedelo,Cachoeiras,Cadafais,Calhandriz,Calheta,Caminha,Campinas,Canidelo,Canoas,Capinha,Carmoes,Cartaxo,Carvalhal,Carvoeiro,Cascavel,Castanhal,Caxias,Chapadinha,Chaves,Cocais,Coentral,Coimbra,Comporta,Conde,Coqueirinho,Coruche,Damaia,Dourados,Enxames,Ericeira,Ervidel,Escalhao,Esmoriz,Espinhal,Estela,Estoril,Eunapolis,Evora,Famalicao,Fanhoes,Faro,Fatima,Felgueiras,Ferreira,Figueira,Flecheiras,Florianopolis,Fornalhas,Fortaleza,Freiria,Freixeira,Fronteira,Fundao,Gracas,Gradil,Grainho,Gralheira,Guimaraes,Horta,Ilhavo,Ilheus,Lages,Lagos,Laranjeiras,Lavacolhos,Leiria,Limoeiro,Linhares,Lisboa,Lomba,Lorvao,Lourical,Lourinha,Luziania,Macedo,Machava,Malveira,Marinhais,Maxial,Mealhada,Milharado,Mira,Mirandela,Mogadouro,Montalegre,Mourao,Nespereira,Nilopolis,Obidos,Odemira,Odivelas,Oeiras,Oleiros,Olhalvo,Olinda,Olival,Oliveira,Oliveirinha,Palheiros,Palmeira,Palmital,Pampilhosa,Pantanal,Paradinha,Parelheiros,Pedrosinho,Pegoes,Penafiel,Peniche,Pinhao,Pinheiro,Pombal,Pontal,Pontinha,Portel,Portimao,Quarteira,Queluz,Ramalhal,Reboleira,Recife,Redinha,Ribadouro,Ribeira,Ribeirao,Rosais,Sabugal,Sacavem,Sagres,Sandim,Sangalhos,Santarem,Santos,Sarilhos,Seixas,Seixezelo,Seixo,Silvares,Silveira,Sinhaem,Sintra,Sobral,Sobralinho,Tabuaco,Tabuleiro,Taveiro,Teixoso,Telhado,Telheiro,Tomar,Torreira,Trancoso,Troviscal,Vagos,Varzea,Velas,Viamao,Viana,Vidigal,Vidigueira,Vidual,Vilamar,Vimeiro,Vinhais,Vitoria"},
|
||||
{name: "Nahuatl", i: 14, min: 6, max: 13, d: "l", m: 0, b: "Acapulco,Acatepec,Acatlan,Acaxochitlan,Acolman,Actopan,Acuamanala,Ahuacatlan,Almoloya,Amacuzac,Amanalco,Amaxac,Apaxco,Apetatitlan,Apizaco,Atenco,Atizapan,Atlacomulco,Atlapexco,Atotonilco,Axapusco,Axochiapan,Axocomanitla,Axutla,Azcapotzalco,Aztahuacan,Calimaya,Calnali,Calpulalpan,Camotlan,Capulhuac,Chalco,Chapulhuacan,Chapultepec,Chiapan,Chiautempan,Chiconautla,Chihuahua,Chilcuautla,Chimalhuacan,Cholollan,Cihuatlan,Coahuila,Coatepec,Coatetelco,Coatlan,Coatlinchan,Coatzacoalcos,Cocotitlan,Cohetzala,Colima,Colotlan,Coyoacan,Coyohuacan,Cuapiaxtla,Cuauhnahuac,Cuauhtemoc,Cuauhtitlan,Cuautepec,Cuautla,Cuaxomulco,Culhuacan,Ecatepec,Eloxochitlan,Epatlan,Epazoyucan,Huamantla,Huascazaloya,Huatlatlauca,Huautla,Huehuetlan,Huehuetoca,Huexotla,Hueyapan,Hueyotlipan,Hueypoxtla,Huichapan,Huimilpan,Huitzilac,Ixtapallocan,Iztacalco,Iztaccihuatl,Iztapalapa,Lolotla,Malinalco,Mapachtlan,Mazatepec,Mazatlan,Metepec,Metztitlan,Mexico,Miacatlan,Michoacan,Minatitlan,Mixcoac,Mixtla,Molcaxac,Nanacamilpa,Naucalpan,Naupan,Nextlalpan,Nezahualcoyotl,Nopalucan,Oaxaca,Ocotepec,Ocotitlan,Ocotlan,Ocoyoacac,Ocuilan,Ocuituco,Omitlan,Otompan,Otzoloapan,Pacula,Pahuatlan,Panotla,Papalotla,Patlachican,Piaztla,Popocatepetl,Sultepec,Tecamac,Tecolotlan,Tecozautla,Temamatla,Temascalapa,Temixco,Temoac,Temoaya,Tenayuca,Tenochtitlan,Teocuitlatlan,Teotihuacan,Teotlalco,Tepeacac,Tepeapulco,Tepehuacan,Tepetitlan,Tepeyanco,Tepotzotlan,Tepoztlan,Tetecala,Tetlatlahuca,Texcalyacac,Texcoco,Tezontepec,Tezoyuca,Timilpan,Tizapan,Tizayuca,Tlacopan,Tlacotenco,Tlahuac,Tlahuelilpan,Tlahuiltepa,Tlalmanalco,Tlalnepantla,Tlalpan,Tlanchinol,Tlatelolco,Tlaxcala,Tlaxcoapan,Tlayacapan,Tocatlan,Tolcayuca,Toluca,Tonanitla,Tonantzintla,Tonatico,Totolac,Totolapan,Tototlan,Tuchtlan,Tulantepec,Tultepec,Tzompantepec,Xalatlaco,Xaloztoc,Xaltocan,Xiloxoxtla,Xochiatipan,Xochicoatlan,Xochimilco,Xochitepec,Xolotlan,Xonacatlan,Yahualica,Yautepec,Yecapixtla,Yehaultepec,Zacatecas,Zacazonapan,Zacoalco,Zacualpan,Zacualtipan,Zapotlan,Zimapan,Zinacantepec,Zoyaltepec,Zumpahuacan"},
|
||||
{name: "Hungarian", i: 15, min: 6, max: 13, d: "", m: 0.1, b: "Aba,Abadszalok,Adony,Ajak,Albertirsa,Alsozsolca,Aszod,Babolna,Bacsalmas,Baktaloranthaza,Balassagyarmat,Balatonalmadi,Balatonboglar,Balkany,Balmazujvaros,Barcs,Bataszek,Batonyterenye,Battonya,Bekes,Berettyoujfalu,Berhida,Biatorbagy,Bicske,Biharkeresztes,Bodajk,Boly,Bonyhad,Budakalasz,Budakeszi,Celldomolk,Csakvar,Csenger,Csongrad,Csorna,Csorvas,Csurgo,Dabas,Demecser,Derecske,Devavanya,Devecser,Dombovar,Dombrad,Dunafoldvar,Dunaharaszti,Dunavarsany,Dunavecse,Edeleny,Elek,Emod,Encs,Enying,Ercsi,Fegyvernek,Fehergyarmat,Felsozsolca,Fertoszentmiklos,Fonyod,Fot,Fuzesabony,Fuzesgyarmat,Gardony,God,Gyal,Gyomaendrod,Gyomro,Hajdudorog,Hajduhadhaz,Hajdusamson,Hajduszoboszlo,Halasztelek,Harkany,Hatvan,Heves,Heviz,Ibrany,Isaszeg,Izsak,Janoshalma,Janossomorja,Jaszapati,Jaszarokszallas,Jaszfenyszaru,Jaszkiser,Kaba,Kalocsa,Kapuvar,Karcag,Kecel,Kemecse,Kenderes,Kerekegyhaza,Keszthely,Kisber,Kiskunmajsa,Kistarcsa,Kistelek,Kisujszallas,Kisvarda,Komadi,Komarom,Komlo,Kormend,Korosladany,Koszeg,Kozarmisleny,Kunhegyes,Kunszentmarton,Kunszentmiklos,Labatlan,Lajosmizse,Lenti,Letavertes,Letenye,Lorinci,Maglod,Mako,Mandok,Marcali,Martonvasar,Mateszalka,Melykut,Mezobereny,Mezocsat,Mezohegyes,Mezokeresztes,Mezokovesd,Mezotur,Mindszent,Mohacs,Monor,Mor,Morahalom,Nadudvar,Nagyatad,Nagyecsed,Nagyhalasz,Nagykallo,Nagykoros,Nagymaros,Nyekladhaza,Nyergesujfalu,Nyirbator,Nyirmada,Nyirtelek,Ocsa,Orkeny,Oroszlany,Paks,Pannonhalma,Paszto,Pecel,Pecsvarad,Pilisvorosvar,Polgar,Polgardi,Pomaz,Puspokladany,Pusztaszabolcs,Putnok,Racalmas,Rackeve,Rakamaz,Rakoczifalva,Sajoszent,Sandorfalva,Sarbogard,Sarkad,Sarospatak,Sarvar,Satoraljaujhely,Siklos,Simontornya,Soltvadkert,Sumeg,Szabadszallas,Szarvas,Szazhalombatta,Szecseny,Szeghalom,Szentgotthard,Szentlorinc,Szerencs,Szigethalom,Szigetvar,Szikszo,Tab,Tamasi,Tapioszele,Tapolca,Teglas,Tet,Tiszafoldvar,Tiszafured,Tiszakecske,Tiszalok,Tiszaujvaros,Tiszavasvari,Tokaj,Tokol,Tompa,Torokbalint,Torokszentmiklos,Totkomlos,Tura,Turkeve,Ujkigyos,ujszasz,Vamospercs,Varpalota,Vasarosnameny,Vasvar,Vecses,Veresegyhaz,Verpelet,Veszto,Zahony,Zalaszentgrot,Zirc,Zsambek"},
|
||||
{name: "Turkish", i: 16, min: 4, max: 10, d: "", m: 0, b: "Yelkaya,Buyrukkaya,Erdemtepe,Alakesen,Baharbeyli,Bozbay,Karaoklu,Altunbey,Yalkale,Yalkut,Akardere,Altayburnu,Esentepe,Okbelen,Derinsu,Alaoba,Yamanbeyli,Aykor,Ekinova,Saztepe,Baharkale,Devrekdibi,Alpseki,Ormanseki,Erkale,Yalbelen,Aytay,Yamanyaka,Altaydelen,Esen,Yedieli,Alpkor,Demirkor,Yediyol,Erdemkaya,Yayburnu,Ganiler,Bayatyurt,Kopuzteke,Aytepe,Deniz,Ayan,Ayazdere,Tepe,Kayra,Ayyaka,Deren,Adatepe,Kalkaneli,Bozkale,Yedidelen,Kocayolu,Sazdere,Bozkesen,Oguzeli,Yayladibi,Uluyol,Altay,Ayvar,Alazyaka,Yaloba,Suyaka,Baltaberi,Poyrazdelen,Eymir,Yediyuva,Kurt,Yeltepe,Oktar,Kara Ok,Ekinberi,Er Yurdu,Eren,Erenler,Ser,Oguz,Asay,Bozokeli,Aykut,Ormanyol,Yazkaya,Kalkanova,Yazbeyli,Dokuz Teke,Bilge,Ertensuyu,Kopuzyuva,Buyrukkut,Akardiken,Aybaray,Aslanbeyli,Altun Kaynak,Atikobasi,Yayla Eli,Kor Tepe,Salureli,Kor Kaya,Aybarberi,Kemerev,Yanaray,Beydileli,Buyrukoba,Yolduman,Tengri Tepe,Dokuzsu,Uzunkor,Erdem Yurdu,Kemer,Korteke,Bozokev,Bozoba,Ormankale,Askale,Oguztoprak,Yolberi,Kumseki,Esenobasi,Turkbelen,Ayazseki,Cereneli,Taykut,Bayramdelen,Beydilyaka,Boztepe,Uluoba,Yelyaka,Ulgardiken,Esensu,Baykale,Cerenkor,Bozyol,Duranoba,Aladuman,Denizli,Bahar,Yarkesen,Dokuzer,Yamankaya,Kocatarla,Alayaka,Toprakeli,Sarptarla,Sarpkoy,Serkaynak,Adayaka,Ayazkaynak,Kopuz,Turk,Kart,Kum,Erten,Buyruk,Yel,Ada,Alazova,Ayvarduman,Buyrukok,Ayvartoprak,Uzuntepe,Binseki,Yedibey,Durankale,Alaztoprak,Sarp Ok,Yaparobasi,Yaytepe,Asberi,Kalkankor,Beydiltepe,Adaberi,Bilgeyolu,Ganiyurt,Alkanteke,Esenerler,Asbey,Erdemkale,Erenkaynak,Oguzkoyu,Ayazoba,Boynuztoprak,Okova,Yaloklu,Sivriberi,Yuladiken,Sazbey,Karakaynak,Kopuzkoyu,Buyrukay,Kocakaya,Tepeduman,Yanarseki,Atikyurt,Esenev,Akarbeyli,Yayteke,Devreksungur,Akseki,Baykut,Kalkandere,Ulgarova,Devrekev,Yulabey,Bayatev,Yazsu,Vuraleli,Sivribeyli,Alaova,Alpobasi,Yalyurt,Elmatoprak,Alazkaynak,Esenay,Ertenev,Salurkor,Ekinok,Yalbey,Yeldere,Ganibay,Altaykut,Baltaboy,Ereli,Ayvarsu,Uzunsaz,Bayeli,Erenyol,Kocabay,Derintay,Ayazyol,Aslanoba,Esenkaynak,Ekinlik,Alpyolu,Alayunt,Bozeski,Erkil,Duransuyu,Yulak,Kut,Dodurga,Kutlubey,Kutluyurt,Boynuz,Alayol,Aybar,Aslaneli,Kemerseki,Baltasuyu,Akarer,Ayvarburnu,Boynuzbeyli,Adasungur,Esenkor,Yamanoba,Toprakkor,Uzunyurt,Sungur,Bozok,Kemerli,Alaz,Demirci,Kartepe"},
|
||||
{name: "Berber", i: 17, min: 4, max: 10, d: "s", m: .2, b: "Abkhouch,Adrar,Aeraysh,Afrag,Agadir,Agelmam,Aghmat,Agrakal,Agulmam,Ahaggar,Ait Baha,Ajdir,Akka,Almou,Amegdul,Amizmiz,Amknas,Amlil,Amurakush,Anfa,Annaba,Aousja,Arbat,Arfud,Argoub,Arif,Asfi,Asfru,Ashawen,Assamer,Assif,Awlluz,Ayt Melel,Azaghar,Azila,Azilal,Azmour,Azro,Azrou,Beccar,Beja,Bennour,Benslimane,Berkane,Berrechid,Bizerte,Bjaed,Bouayach,Boudenib,Boufrah,Bouskoura,Boutferda,Darallouch,Dar Bouazza,Darchaabane,Dcheira,Demnat,Denden,Djebel,Djedeida,Drargua,Elhusima,Essaouira,Ezzahra,Fas,Fnideq,Ghezeze,Goubellat,Grisaffen,Guelmim,Guercif,Hammamet,Harrouda,Hdifa,Hoceima,Houara,Idhan,Idurar,Ifendassen,Ifoghas,Ifrane,Ighoud,Ikbir,Imilchil,Imzuren,Inezgane,Irherm,Izoughar,Jendouba,Kacem,Kelibia,Kenitra,Kerrando,Khalidia,Khemisset,Khenifra,Khouribga,Khourigba,Kidal,Korba,Korbous,Lahraouyine,Larache,Leyun,Lqliaa,Manouba,Martil,Mazagan,Mcherga,Mdiq,Megrine,Mellal,Melloul,Midelt,Misur,Mohammedia,Mornag,Mrirt,Nabeul,Nadhour,Nador,Nawaksut,Nefza,Ouarzazate,Ouazzane,Oued Zem,Oujda,Ouladteima,Qsentina,Rades,Rafraf,Safi,Sefrou,Sejnane,Settat,Sijilmassa,Skhirat,Slimane,Somaa,Sraghna,Susa,Tabarka,Tadrart,Taferka,Tafilalt,Tafrawt,Tafza,Tagbalut,Tagerdayt,Taghzut,Takelsa,Taliouine,Tanja,Tantan,Taourirt,Targuist,Taroudant,Tarudant,Tasfelalayt,Tassort,Tata,Tattiwin,Tawnat,Taza,Tazagurt,Tazerka,Tazizawt,Taznakht,Tebourba,Teboursouk,Temara,Testour,Tetouan,Tibeskert,Tifelt,Tijdit,Tinariwen,Tinduf,Tinja,Tittawan,Tiznit,Toubkal,Trables,Tubqal,Tunes,Ultasila,Urup,Wagguten,Wararni,Warzazat,Watlas,Wehran,Wejda,Xamida,Yedder,Youssoufia,Zaghouan,Zahret,Zemmour,Zriba"},
|
||||
{name: "Arabic", i: 18, min: 4, max: 9, d: "ae", m: .2, b: "Abha,Ajman,Alabar,Alarjam,Alashraf,Alawali,Albawadi,Albirk,Aldhabiyah,Alduwaid,Alfareeq,Algayed,Alhazim,Alhrateem,Alhudaydah,Alhuwaya,Aljahra,Aljubail,Alkhafah,Alkhalas,Alkhawaneej,Alkhen,Alkhobar,Alkhuznah,Allisafah,Almshaykh,Almurjan,Almuwayh,Almuzaylif,Alnaheem,Alnashifah,Alqah,Alqouz,Alqurayyat,Alradha,Alraqmiah,Alsadyah,Alsafa,Alshagab,Alshuqaiq,Alsilaa,Althafeer,Alwasqah,Amaq,Amran,Annaseem,Aqbiyah,Arafat,Arar,Ardah,Asfan,Ashayrah,Askar,Ayaar,Aziziyah,Baesh,Bahrah,Balhaf,Banizayd,Bidiyah,Bisha,Biyatah,Buqhayq,Burayda,Dafiyat,Damad,Dammam,Dariyah,Dhafar,Dhahran,Dhalkut,Dhurma,Dibab,Doha,Dukhan,Duwaibah,Enaker,Fadhla,Fahaheel,Fanateer,Farasan,Fardah,Fujairah,Ghalilah,Ghar,Ghizlan,Ghomgyah,Ghran,Hadiyah,Haffah,Hajanbah,Hajrah,Haqqaq,Haradh,Hasar,Hawiyah,Hebaa,Hefar,Hijal,Husnah,Huwailat,Huwaitah,Irqah,Isharah,Ithrah,Jamalah,Jarab,Jareef,Jazan,Jeddah,Jiblah,Jihanah,Jilah,Jizan,Joraibah,Juban,Jumeirah,Kamaran,Keyad,Khab,Khaiybar,Khasab,Khathirah,Khawarah,Khulais,Kumzar,Limah,Linah,Madrak,Mahab,Mahalah,Makhtar,Mashwar,Masirah,Masliyah,Mastabah,Mazhar,Medina,Meeqat,Mirbah,Mokhtara,Muharraq,Muladdah,Musaykah,Mushayrif,Musrah,Mussafah,Nafhan,Najran,Nakhab,Nizwa,Oman,Qadah,Qalhat,Qamrah,Qasam,Qosmah,Qurain,Quriyat,Qurwa,Radaa,Rafha,Rahlah,Rakamah,Rasheedah,Rasmadrakah,Risabah,Rustaq,Ryadh,Sabtaljarah,Sadah,Safinah,Saham,Saihat,Salalah,Salmiya,Shabwah,Shalim,Shaqra,Sharjah,Sharurah,Shatifiyah,Shidah,Shihar,Shoqra,Shuwaq,Sibah,Sihmah,Sinaw,Sirwah,Sohar,Suhailah,Sulaibiya,Sunbah,Tabuk,Taif,Taqah,Tarif,Tharban,Thuqbah,Thuwal,Tubarjal,Turaif,Turbah,Tuwaiq,Ubar,Umaljerem,Urayarah,Urwah,Wabrah,Warbah,Yabreen,Yadamah,Yafur,Yarim,Yemen,Yiyallah,Zabid,Zahwah,Zallaq,Zinjibar,Zulumah"},
|
||||
{name: "Inuit", i: 19, min: 5, max: 15, d: "alutsn", m: 0, b: "Aaluik,Aappilattoq,Aasiaat,Agissat,Agssaussat,Akuliarutsip,Akunnaaq,Alluitsup,Alluttoq,Amitsorsuaq,Ammassalik,Anarusuk,Anguniartarfik,Annertussoq,Annikitsoq,Apparsuit,Apusiaajik,Arsivik,Arsuk,Atammik,Ateqanaq,Atilissuaq,Attu,Augpalugtoq,Aukarnersuaq,Aumat,Auvilkikavsaup,Avadtlek,Avallersuaq,Bjornesk,Blabaerdalen,Blomsterdalen,Brattalhid,Bredebrae,Brededal,Claushavn,Edderfulegoer,Egger,Eqalugalinnguit,Eqalugarssuit,Eqaluit,Eqqua,Etah,Graah,Hakluyt,Haredalen,Hareoen,Hundeo,Igaliku,Igdlorssuit,Igdluluarssuk,Iginniafik,Ikamiut,Ikarissat,Ikateq,Ikermiut,Ikermoissuaq,Ikorfarssuit,Ilimanaq,Illorsuit,Illunnguit,Iluileq,Ilulissat,Imaarsivik,Imartunarssuk,Immikkoortukajik,Innaarsuit,Inneruulalik,Inussullissuaq,Iperaq,Ippik,Iqek,Isortok,Isungartussoq,Itileq,Itissaalik,Itivdleq,Ittit,Ittoqqortoormiit,Ivingmiut,Ivittuut,Kanajoorartuut,Kangaamiut,Kangeq,Kangerluk,Kangerlussuaq,Kanglinnguit,Kapisillit,Kekertamiut,Kiatak,Kiataussaq,Kigatak,Kinaussak,Kingittorsuaq,Kitak,Kitsissuarsuit,Kitsissut,Klenczner,Kook,Kraulshavn,Kujalleq,Kullorsuaq,Kulusuk,Kuurmiit,Kuusuaq,Laksedalen,Maniitsoq,Marrakajik,Mattaangassut,Mernoq,Mittivakkat,Moriusaq,Myggbukta,Naajaat,Nangissat,Nanuuseq,Nappassoq,Narsarmijt,Narsarsuaq,Narssaq,Nasiffik,Natsiarsiorfik,Naujanguit,Niaqornaarsuk,Niaqornat,Nordfjordspasset,Nugatsiaq,Nunarssit,Nunarsuaq,Nunataaq,Nunatakavsaup,Nutaarmiut,Nuugaatsiaq,Nuuk,Nuukullak,Olonkinbyen,Oodaaq,Oqaatsut,Oqaitsunguit,Oqonermiut,Paagussat,Paamiut,Paatuut,Palungataq,Pamialluk,Perserajoq,Pituffik,Puugutaa,Puulkuip,Qaanaq,Qaasuitsup,Qaersut,Qajartalik,Qallunaat,Qaneq,Qaqortok,Qasigiannguit,Qassimiut,Qeertartivaq,Qeqertaq,Qeqertasussuk,Qeqqata,Qernertoq,Qernertunnguit,Qianarreq,Qingagssat,Qoornuup,Qorlortorsuaq,Qullikorsuit,Qunnerit,Qutdleq,Ravnedalen,Ritenbenk,Rypedalen,Saarloq,Saatorsuaq,Saattut,Salliaruseq,Sammeqqat,Sammisoq,Sanningassoq,Saqqaq,Saqqarlersuaq,Saqqarliit,Sarfannguit,Sattiaatteq,Savissivik,Serfanguaq,Sermersooq,Sermiligaaq,Sermilik,Sermitsiaq,Simitakaja,Simiutaq,Singamaq,Siorapaluk,Sisimiut,Sisuarsuit,Sullorsuaq,Suunikajik,Sverdrup,Taartoq,Takiseeq,Tasirliaq,Tasiusak,Tiilerilaaq,Timilersua,Timmiarmiut,Tukingassoq,Tussaaq,Tuttulissuup,Tuujuk,Uiivaq,Uilortussoq,Ujuaakajiip,Ukkusissat,Upernavik,Uttorsiutit,Uumannaq,Uunartoq,Uvkusigssat,Ymer"},
|
||||
{name: "Basque", i: 20, min: 4, max: 11, d: "r", m: .1, b: "Agurain,Aia,Aiara,Albiztur,Alkiza,Altzaga,Amorebieta,Amurrio,Andoain,Anoeta,Antzuola,Arakaldo,Arantzazu,Arbatzegi,Areatza,Arratzua,Arrieta,Artea,Artziniega,Asteasu,Astigarraga,Ataun,Atxondo,Aulesti,Azkoitia,Azpeitia,Bakio,Baliarrain,Barakaldo,Barrika,Barrundia,Basauri,Beasain,Bedia,Beizama,Belauntza,Berastegi,Bergara,Bermeo,Bernedo,Berriatua,Berriz,Bidania,Bilar,Bilbao,Busturia,Deba,Derio,Donostia,Dulantzi,Durango,Ea,Eibar,Elantxobe,Elduain,Elgeta,Elgoibar,Elorrio,Erandio,Ergoitia,Ermua,Errenteria,Errezil,Eskoriatza,Eskuernaga,Etxebarri,Etxebarria,Ezkio,Forua,Gabiria,Gaintza,Galdakao,Gamiz,Garai,Gasteiz,Gatzaga,Gaubea,Gautegiz,Gaztelu,Gernika,Gerrikaitz,Getaria,Getxo,Gizaburuaga,Goiatz,Gorliz,Gorriaga,Harana,Hernani,Hondarribia,Ibarra,Ibarrangelu,Idiazabal,Iekora,Igorre,Ikaztegieta,Irun,Irura,Iruraiz,Itsaso,Itsasondo,Iurreta,Izurtza,Jatabe,Kanpezu,Karrantza,Kortezubi,Kripan,Kuartango,Lanestosa,Lantziego,Larrabetzu,Lasarte,Laukiz,Lazkao,Leaburu,Legazpi,Legorreta,Legutio,Leintz,Leioa,Lekeitio,Lemoa,Lemoiz,Leza,Lezama,Lezo,Lizartza,Maeztu,Mallabia,Manaria,Markina,Maruri,Menaka,Mendaro,Mendata,Mendexa,Morga,Mundaka,Mungia,Munitibar,Murueta,Muskiz,Mutiloa,Mutriku,Nabarniz,Oiartzun,Oion,Okondo,Olaberria,Onati,Ondarroa,Ordizia,Orendain,Orexa,Oria,Orio,Ormaiztegi,Orozko,Ortuella,Otegi,Otxandio,Pasaia,Plentzia,Santurtzi,Sestao,Sondika,Soraluze,Sukarrieta,Tolosa,Trapagaran,Turtzioz,Ubarrundia,Ubide,Ugao,Urdua,Urduliz,Urizaharra,Urkabustaiz,Urnieta,Urretxu,Usurbil,Xemein,Zabaleta,Zaia,Zaldibar,Zambrana,Zamudio,Zaratamo,Zarautz,Zeberio,Zegama,Zerain,Zestoa,Zierbena,Zigoitia,Ziortza,Zuia,Zumaia,Zumarraga"},
|
||||
{name: "Nigerian", i: 21, min: 4, max: 10, d: "", m: .3, b: "Abadogo,Abafon,Adealesu,Adeto,Adyongo,Afaga,Afamju,Agigbigi,Agogoke,Ahute,Aiyelaboro,Ajebe,Ajola,Akarekwu,Akunuba,Alawode,Alkaijji,Amangam,Amgbaye,Amtasa,Amunigun,Animahun,Anyoko,Arapagi,Asande,Awgbagba,Awhum,Awodu,Babateduwa,Bandakwai,Bangdi,Bilikani,Birnindodo,Braidu,Bulakawa,Buriburi,Cainnan,Chakum,Chondugh,Dagwarga,Darpi,Dokatofa,Dozere,Ebelibri,Efem,Ekoku,Ekpe,Ewhoeviri,Galea,Gamen,Ganjin,Gantetudu,Gargar,Garinbode,Gbure,Gerti,Gidan,Gitabaremu,Giyagiri,Giyawa,Gmawa,Golakochi,Golumba,Gunji,Gwambula,Gwodoti,Hayinlere,Hayinmaialewa,Hirishi,Hombo,Ibefum,Iberekodo,Icharge,Idofin,Idofinoka,Igbogo,Ijoko,Ijuwa,Ikawga,Ikhin,Ikpakidout,Ikpeoniong,Imuogo,Ipawo,Ipinlerere,Isicha,Itakpa,Jangi,Jare,Jataudakum,Jaurogomki,Jepel,Kafinmalama,Katab,Katanga,Katinda,Katirije,Kaurakimba,Keffinshanu,Kellumiri,Kiagbodor,Kirbutu,Kita,Kogogo,Kopje,Korokorosei,Kotoku,Kuata,Kujum,Kukau,Kunboon,Kuonubogbene,Kurawe,Kushinahu,Kwaramakeri,Ladimeji,Lafiaro,Lahaga,Laindebajanle,Laindegoro,Lakati,Litenswa,Maba,Madarzai,Maianita,Malikansaa,Mata,Megoyo,Meku,Miama,Modi,Mshi,Msugh,Muduvu,Murnachehu,Namnai,Ndamanma,Ndiwulunbe,Ndonutim,Ngbande,Nguengu,Ntoekpe,Nyajo,Nyior,Odajie,Ogbaga,Ogultu,Ogunbunmi,Ojopode,Okehin,Olugunna,Omotunde,Onipede,Onma,Orhere,Orya,Otukwang,Otunade,Rampa,Rimi,Rugan,Rumbukawa,Sabiu,Sangabama,Sarabe,Seboregetore,Shafar,Shagwa,Shata,Shengu,Sokoron,Sunnayu,Tafoki,Takula,Talontan,Tarhemba,Tayu,Ter,Timtim,Timyam,Tindirke,Tokunbo,Torlwam,Tseakaadza,Tseanongo,Tsebeeve,Tsepaegh,Tuba,Tumbo,Tungalombo,Tunganyakwe,Uhkirhi,Umoru,Umuabai,Umuajuju,Unchida,Ungua,Unguwar,Unongo,Usha,Utongbo,Vembera,Wuro,Yanbashi,Yanmedi,Yoku,Zarunkwari,Zilumo,Zulika"},
|
||||
{name: "Celtic", i: 22, min: 4, max: 12, d: "nld", m: 0, b: "Aberaman,Aberangell,Aberarth,Aberavon,Aberbanc,Aberbargoed,Aberbeeg,Abercanaid,Abercarn,Abercastle,Abercegir,Abercraf,Abercregan,Abercych,Abercynon,Aberdare,Aberdaron,Aberdaugleddau,Aberdeen,Aberdulais,Aberdyfi,Aberedw,Abereiddy,Abererch,Abereron,Aberfan,Aberffraw,Aberffrwd,Abergavenny,Abergele,Aberglasslyn,Abergorlech,Abergwaun,Abergwesyn,Abergwili,Abergwynfi,Abergwyngregyn,Abergynolwyn,Aberhafesp,Aberhonddu,Aberkenfig,Aberllefenni,Abermain,Abermaw,Abermorddu,Abermule,Abernant,Aberpennar,Aberporth,Aberriw,Abersoch,Abersychan,Abertawe,Aberteifi,Aberthin,Abertillery,Abertridwr,Aberystwyth,Achininver,Afonhafren,Alisaha,Anfosadh,Antinbhearmor,Ardenna,Attacon,Banwen,Beira,Bhrura,Bleddfa,Boioduro,Bona,Boskyny,Boslowenpolbrogh,Boudobriga,Bravon,Brigant,Briganta,Briva,Brosnach,Caersws,Cambodunum,Cambra,Caracta,Catumagos,Centobriga,Ceredigion,Chalain,Chearbhallain,Chlasaigh,Chormaic,Cuileannach,Dinn,Diwa,Dubingen,Duibhidighe,Duro,Ebora,Ebruac,Eburodunum,Eccles,Egloskuri,Eighe,Eireann,Elerghi,Ferkunos,Fhlaithnin,Gallbhuaile,Genua,Ghrainnse,Gwyles,Heartsease,Hebron,Hordh,Inbhear,Inbhir,Inbhirair,Innerleithen,Innerleven,Innerwick,Inver,Inveraldie,Inverallan,Inveralmond,Inveramsay,Inveran,Inveraray,Inverarnan,Inverbervie,Inverclyde,Inverell,Inveresk,Inverfarigaig,Invergarry,Invergordon,Invergowrie,Inverhaddon,Inverkeilor,Inverkeithing,Inverkeithney,Inverkip,Inverleigh,Inverleith,Inverloch,Inverlochlarig,Inverlochy,Invermay,Invermoriston,Inverness,Inveroran,Invershin,Inversnaid,Invertrossachs,Inverugie,Inveruglas,Inverurie,Iubhrach,Karardhek,Kilninver,Kirkcaldy,Kirkintilloch,Krake,Lanngorrow,Latense,Leming,Lindomagos,Llanaber,Llandidiwg,Llandyrnog,Llanfarthyn,Llangadwaldr,Llansanwyr,Lochinver,Lugduno,Magoduro,Mheara,Monmouthshire,Nanshiryarth,Narann,Novioduno,Nowijonago,Octoduron,Penning,Pheofharain,Ponsmeur,Raithin,Ricomago,Rossinver,Salodurum,Seguia,Sentica,Theorsa,Tobargeal,Trealaw,Trefesgob,Trewedhenek,Trewythelan,Tuaisceart,Uige,Vitodurum,Windobona"},
|
||||
{name: "Mesopotamian", i: 23, min: 4, max: 9, d: "srpl", m: .1, b: "Adab,Adamndun,Adma,Admatum,Agrab,Akkad,Akshak,Amnanum,Andarig,Anshan,Apiru,Apum,Arantu,Arbid,Arpachiyah,Arpad,Arrapha,Ashlakka,Assur,Awan,Babilim,Bad-Tibira,Balawat,Barsip,Birtu,Bit-Bunakki,Borsippa,Chuera,Dashrah,Der,Dilbat,Diniktum,Doura,Dur-Kurigalzu,Dur-Sharrukin,Dur-Untash,Dûr-gurgurri,Ebla,Ekallatum,Ekalte,Emar,Erbil,Eresh,Eridu,Eshnunn,Eshnunna,Gargamish,Gasur,Gawra,Gibil,Girsu,Gizza,Habirun,Habur,Hadatu,Hakkulan,Halab,Halabit,Hamazi,Hamoukar,Haradum,Harbidum,Harran,Harranu,Hassuna,Hatarikka,Hatra,Hissar,Hiyawa,Hormirzad,Ida-Maras,Idamaraz,Idu,Imerishu,Imgur-Enlil,Irisagrig,Irnina,Irridu,Isin,Issinnitum,Iturungal,Izubitum,Jarmo,Jemdet,Kabnak,Kadesh,Kahat,Kalhu,Kar-Shulmanu-Asharedu,Kar-Tukulti-Ninurta,Kar-shulmanu-asharedu,Karana,Karatepe,Kartukulti,Kazallu,Kesh,Kidsha,Kinza,Kish,Kisiga,Kisurra,Kuara,Kurda,Kurruhanni,Kutha,Lagaba,Lagash,Larak,Larsa,Leilan,Malgium,Marad,Mardaman,Mari,Marlik,Mashkan,Mashkan-shapir,Matutem,Me-Turan,Meliddu,Mumbaqat,Nabada,Nagar,Nanagugal,Nerebtum,Nigin,Nimrud,Nina,Nineveh,Ninua,Nippur,Niru,Niya,Nuhashe,Nuhasse,Nuzi,Puzrish-Dagan,Qalatjarmo,Qatara,Qatna,Qattunan,Qidshu,Rapiqum,Rawda,Sagaz,Shaduppum,Shaggaratum,Shalbatu,Shanidar,Sharrukin,Shawwan,Shehna,Shekhna,Shemshara,Shibaniba,Shubat-Enlil,Shurkutir,Shuruppak,Shusharra,Shushin,Sikan,Sippar,Sippar-Amnanum,Sippar-sha-Annunitum,Subatum,Susuka,Tadmor,Tarbisu,Telul,Terqa,Tirazish,Tisbon,Tuba,Tushhan,Tuttul,Tutub,Ubaid,Umma,Ur,Urah,Urbilum,Urkesh,Ursa'um,Uruk,Urum,Uzarlulu,Warka,Washukanni,Zabalam,Zarri-Amnan"},
|
||||
{name: "Iranian", i: 24, min: 5, max: 11, d: "", m: .1, b: "Abali,Abrisham,Absard,Abuzeydabad,Afus,Alavicheh,Alikosh,Amol,Anarak,Anbar,Andisheh,Anshan,Aran,Ardabil,Arderica,Ardestan,Arjomand,Asgaran,Asgharabad,Ashian,Awan,Babajan,Badrud,Bafran,Baghestan,Baghshad,Bahadoran,Baharan Shahr,Baharestan,Bakun,Bam,Baqershahr,Barzok,Bastam,Behistun,Bitistar,Bumahen,Bushehr,Chadegan,Chahardangeh,Chamgardan,Chermahin,Choghabonut,Chugan,Damaneh,Damavand,Darabgard,Daran,Dastgerd,Dehaq,Dehaqan,Dezful,Dizicheh,Dorcheh,Dowlatabad,Duruntash,Ecbatana,Eslamshahr,Estakhr,Ezhiyeh,Falavarjan,Farrokhi,Fasham,Ferdowsieh,Fereydunshahr,Ferunabad,Firuzkuh,Fuladshahr,Ganjdareh,Ganzak,Gaz,Geoy,Godin,Goldasht,Golestan,Golpayegan,Golshahr,Golshan,Gorgab,Guged,Habibabad,Hafshejan,Hajjifiruz,Hana,Harand,Hasanabad,Hasanlu,Hashtgerd,Hecatompylos,Hormirzad,Imanshahr,Isfahan,Jandaq,Javadabad,Jiroft,Jowsheqan ,Jowzdan,Kabnak,Kahrizak,Kahriz Sang,Kangavar,Karaj,Karkevand,Kashan,Kelishad,Kermanshah,Khaledabad,Khansar,Khorramabad,Khur,Khvorzuq,Kilan,Komeh,Komeshcheh,Konar,Kuhpayeh,Kul,Kushk,Lavasan,Laybid,Liyan,Lyan,Mahabad,Mahallat,Majlesi,Malard,Manzariyeh,Marlik,Meshkat,Meymeh,Miandasht,Mish,Mobarakeh,Nahavand,Nain,Najafabad,Naqshe,Narezzash,Nasimshahr,Nasirshahr,Nasrabad,Natanz,Neyasar,Nikabad,Nimvar,Nushabad,Pakdasht,Parand,Pardis,Parsa,Pasargadai,Patigrabana,Pir Bakran,Pishva,Qahderijan,Qahjaverestan,Qamsar,Qarchak,Qods,Rabat,Ray-shahr,Rezvanshahr,Rhages,Robat Karim,Rozveh,Rudehen,Sabashahr,Safadasht,Sagzi,Salehieh,Sandal,Sarvestan,Sedeh,Sefidshahr,Semirom,Semnan,Shadpurabad,Shah,Shahdad,Shahedshahr,Shahin,Shahpour,Shahr,Shahreza,Shahriar,Sharifabad,Shemshak,Shiraz,Shushan,Shushtar,Sialk,Sin,Sukhteh,Tabas,Tabriz,Takhte,Talkhuncheh,Talli,Tarq,Temukan,Tepe,Tiran,Tudeshk,Tureng,Urmia,Vahidieh,Vahrkana,Vanak,Varamin,Varnamkhast,Varzaneh,Vazvan,Yahya,Yarim,Yasuj,Zarrin Shahr,Zavareh,Zayandeh,Zazeran,Ziar,Zibashahr,Zranka"},
|
||||
{name: "Hawaiian", i: 25, min: 5, max: 10, d: "auo", m: 1, b: "Aapueo,Ahoa,Ahuakaio,Ahupau,Alaakua,Alae,Alaeloa,Alamihi,Aleamai,Alena,Alio,Aupokopoko,Halakaa,Haleu,Haliimaile,Hamoa,Hanakaoo,Hanaulu,Hanawana,Hanehoi,Haou,Hikiaupea,Hokuula,Honohina,Honokahua,Honokeana,Honokohau,Honolulu,Honomaele,Hononana,Honopou,Hoolawa,Huelo,Kaalaea,Kaapahu,Kaeo,Kahalehili,Kahana,Kahuai,Kailua,Kainehe,Kakalahale,Kakanoni,Kalenanui,Kaleoaihe,Kalialinui,Kalihi,Kalimaohe,Kaloi,Kamani,Kamehame,Kanahena,Kaniaula,Kaonoulu,Kapaloa,Kapohue,Kapuaikini,Kapunakea,Kauau,Kaulalo,Kaulanamoa,Kauluohana,Kaumakani,Kaumanu,Kaunauhane,Kaupakulua,Kawaloa,Keaa,Keaaula,Keahua,Keahuapono,Kealahou,Keanae,Keauhou,Kelawea,Keokea,Keopuka,Kikoo,Kipapa,Koakupuna,Koali,Kolokolo,Kopili,Kou,Kualapa,Kuhiwa,Kuholilea,Kuhua,Kuia,Kuikui,Kukoae,Kukohia,Kukuiaeo,Kukuipuka,Kukuiula,Kulahuhu,Lapakea,Lapueo,Launiupoko,Lole,Maalo,Mahinahina,Mailepai,Makaakini,Makaalae,Makaehu,Makaiwa,Makaliua,Makapipi,Makapuu,Maluaka,Manawainui,Mehamenui,Moalii,Moanui,Mohopili,Mokae,Mokuia,Mokupapa,Mooiki,Mooloa,Moomuku,Muolea,Nakaaha,Nakalepo,Nakaohu,Nakapehu,Nakula,Napili,Niniau,Nuu,Oloewa,Olowalu,Omaopio,Onau,Onouli,Opaeula,Opana,Opikoula,Paakea,Paeahu,Paehala,Paeohi,Pahoa,Paia,Pakakia,Palauea,Palemo,Paniau,Papaaea,Papaanui,Papaauhau,Papaka,Papauluana,Pauku,Paunau,Pauwalu,Pauwela,Pohakanele,Polaiki,Polanui,Polapola,Poopoo,Poponui,Poupouwela,Puahoowali,Puakea,Puako,Pualaea,Puehuehu,Pueokauiki,Pukaauhuhu,Pukuilua,Pulehu,Puolua,Puou,Puuhaehae,Puuiki,Puuki,Puulani,Puunau,Puuomaile,Uaoa,Uhao,Ukumehame,Ulaino,Ulumalu,Wahikuli,Waianae,Waianu,Waiawa,Waiehu,Waieli,Waikapu,Wailamoa,Wailaulau,Wainee,Waiohole,Waiohonu,Waiohuli,Waiokama,Waiokila,Waiopai,Waiopua,Waipao,Waipionui,Waipouli"},
|
||||
{name: "Karnataka", i: 26, min: 5, max: 11, d: "tnl", m: 0, b: "Adityapatna,Adyar,Afzalpur,Aland,Alnavar,Alur,Ambikanagara,Anekal,Ankola,Annigeri,Arkalgud,Arsikere,Athni,Aurad,Badami,Bagalkot,Bagepalli,Bail,Bajpe,Bangalore,Bangarapet,Bankapura,Bannur,Bantval,Basavakalyan,Basavana,Belgaum,Beltangadi,Belur,Bhadravati,Bhalki,Bhatkal,Bhimarayanagudi,Bidar,Bijapur,Bilgi,Birur,Bommasandra,Byadgi,Challakere,Chamarajanagar,Channagiri,Channapatna,Channarayapatna,Chik,Chikmagalur,Chiknayakanhalli,Chikodi,Chincholi,Chintamani,Chitapur,Chitgoppa,Chitradurga,Dandeli,Dargajogihalli,Devadurga,Devanahalli,Dod,Donimalai,Gadag,Gajendragarh,Gangawati,Gauribidanur,Gokak,Gonikoppal,Gubbi,Gudibanda,Gulbarga,Guledgudda,Gundlupet,Gurmatkal,Haliyal,Hangal,Harapanahalli,Harihar,Hassan,Hatti,Haveri,Hebbagodi,Heggadadevankote,Hirekerur,Holalkere,Hole,Homnabad,Honavar,Honnali,Hoovina,Hosakote,Hosanagara,Hosdurga,Hospet,Hubli,Hukeri,Hungund,Hunsur,Ilkal,Indi,Jagalur,Jamkhandi,Jevargi,Jog,Kadigenahalli,Kadur,Kalghatgi,Kamalapuram,Kampli,Kanakapura,Karkal,Karwar,Khanapur,Kodiyal,Kolar,Kollegal,Konnur,Koppa,Koppal,Koratagere,Kotturu,Krishnarajanagara,Krishnarajasagara,Krishnarajpet,Kudchi,Kudligi,Kudremukh,Kumta,Kundapura,Kundgol,Kunigal,Kurgunta,Kushalnagar,Kushtagi,Lakshmeshwar,Lingsugur,Londa,Maddur,Madhugiri,Madikeri,Mahalingpur,Malavalli,Mallar,Malur,Mandya,Mangalore,Manvi,Molakalmuru,Mudalgi,Mudbidri,Muddebihal,Mudgal,Mudhol,Mudigere,Mulbagal,Mulgund,Mulki,Mulur,Mundargi,Mundgod,Munirabad,Mysore,Nagamangala,Nanjangud,Narasimharajapura,Naregal,Nargund,Navalgund,Nipani,Pandavapura,Pavagada,Piriyapatna,Pudu,Puttur,Rabkavi,Raichur,Ramanagaram,Ramdurg,Ranibennur,Raybag,Robertson,Ron,Sadalgi,Sagar,Sakleshpur,Saligram,Sandur,Sankeshwar,Saundatti,Savanur,Sedam,Shahabad,Shahpur,Shaktinagar,Shiggaon,Shikarpur,Shirhatti,Shorapur,Shrirangapattana,Siddapur,Sidlaghatta,Sindgi,Sindhnur,Sira,Siralkoppa,Sirsi,Siruguppa,Somvarpet,Sorab,Sringeri,Srinivaspur,Sulya,Talikota,Tarikere,Tekkalakote,Terdal,Thumbe,Tiptur,Tirthahalli,Tirumakudal,Tumkur,Turuvekere,Udupi,Vijayapura,Wadi,Yadgir,Yelandur,Yelbarga,Yellapur,Yenagudde"},
|
||||
{name: "Quechua", i: 27, min: 6, max: 12, d: "l", m: 0, b: "Alpahuaycco,Anchihuay,Anqea,Apurimac,Arequipa,Atahuallpa,Atawalpa,Atico,Ayacucho,Ayahuanco,Ayllu,Cajamarca,Canayre,Canchacancha,Carapo,Carhuac,Carhuacatac,Cashan,Caullaraju,Caxamalca,Cayesh,Ccahuasno,Ccarhuacc,Ccopayoc,Chacchapunta,Chacraraju,Challhuamayo,Champara,Chanchan,Chekiacraju,Chillihua,Chinchey,Chontah,Chopicalqui,Chucuito,Chuito,Chullo,Chumpi,Chuncho,Chupahuacho,Chuquiapo,Chuquisaca,Churup,Cocapata,Cochabamba,Cojup,Collota,Conococha,Corihuayrachina,Cuchoquesera,Cusichaca,Haika,Hanpiq,Hatun,Haywarisqa,Huaca,Huachinga,Hualcan,Hualchancca,Huamanga,Huamashraju,Huancarhuas,Huandoy,Huantsan,Huanupampa,Huarmihuanusca,Huascaran,Huaylas,Huayllabamba,Huayrana,Huaytara,Huichajanca,Huinayhuayna,Huinche,Huinioch,Illiasca,Intipunku,Iquicha,Ishinca,Jahuacocha,Jirishanca,Juli,Jurau,Kakananpunta,Kamasqa,Karpay,Kausay,Khuya,Kuelap,Lanccochayocc,Llaca,Llactapata,Llanganuco,Llaqta,Lloqllasca,Llupachayoc,Luricocha,Machu,Mallku,Matarraju,Mechecc,Mikhuy,Milluacocha,Morochuco,Munay,Ocshapalca,Ollantaytambo,Oroccahua,Oronccoy,Oyolo,Pacamayo,Pacaycasa,Paccharaju,Pachacamac,Pachakamaq,Pachakuteq,Pachakuti,Pachamama,Paititi,Pajaten,Palcaraju,Pallccas,Pampa,Panaka,Paqarina,Paqo,Parap,Paria,Patahuasi,Patallacta,Patibamba,Pisac,Pisco,Pongos,Pucacolpa,Pucahirca,Pucaranra,Pumatambo,Puscanturpa,Putaca,Puyupatamarca,Qawaq,Qayqa,Qochamoqo,Qollana,Qorihuayrachina,Qorimoqo,Qotupuquio,Quenuaracra,Queshque,Quillcayhuanca,Quillya,Quitaracsa,Quitaraju,Qusqu,Rajucolta,Rajutakanan,Rajutuna,Ranrahirca,Ranrapalca,Raria,Rasac,Rimarima,Riobamba,Runkuracay,Rurec,Sacsa,Sacsamarca,Saiwa,Sarapo,Sayacmarca,Sayripata,Sinakara,Sonccopa,Taripaypacha,Taulliraju,Tawantinsuyu,Taytanchis,Tiwanaku,Tocllaraju,Tsacra,Tuco,Tucubamba,Tullparaju,Tumbes,Uchuraccay,Uchuraqay,Ulta,Urihuana,Uruashraju,Vallunaraju,Vilcabamba,Wacho,Wankawillka,Wayra,Yachay,Yahuarraju,Yanamarey,Yanaqucha,Yanesha,Yerupaja"},
|
||||
{name: "Swahili", i: 28, min: 4, max: 9, d: "", m: 0, b: "Abim,Adjumani,Alebtong,Amolatar,Amuru,Apac,Arua,Arusha,Babati,Baragoi,Bombo,Budaka,Bugembe,Bugiri,Buikwe,Bukedea,Bukoba,Bukomansimbi,Bukungu,Buliisa,Bundibugyo,Bungoma,Busembatya,Bushenyi,Busia,Busolwe,Butaleja,Butambala,Butere,Buwenge,Buyende,Dadaab,Dodoma,Dokolo,Eldoret,Elegu,Emali,Embu,Entebbe,Garissa,Gede,Gulu,Handeni,Hima,Hoima,Hola,Ibanda,Iganga,Iringa,Isingiro,Isiolo,Jinja,Kaabong,Kabuyanda,Kabwohe,Kagadi,Kajiado,Kakinga,Kakiri,Kakuma,Kalangala,Kaliro,Kalongo,Kalungu,Kampala,Kamwenge,Kanungu,Kapchorwa,Kasese,Kasulu,Katakwi,Kayunga,Keroka,Kiambu,Kibaale,Kibaha,Kibingo,Kibwezi,Kigoma,Kihiihi,Kilifi,Kiruhura,Kiryandongo,Kisii,Kisoro,Kisumu,Kitale,Kitgum,Kitui,Koboko,Korogwe,Kotido,Kumi,Kyazanga,Kyegegwa,Kyenjojo,Kyotera,Lamu,Langata,Lindi,Lodwar,Lokichoggio,Londiani,Loyangalani,Lugazi,Lukaya,Luweero,Lwakhakha,Lwengo,Lyantonde,Machakos,Mafinga,Makambako,Makindu,Malaba,Malindi,Manafwa,Mandera,Marsabit,Masaka,Masindi,Masulita,Matugga,Mayuge,Mbale,Mbarara,Mbeya,Meru,Mitooma,Mityana,Mombasa,Morogoro,Moroto,Moyale,Moyo,Mpanda,Mpigi,Mpondwe,Mtwara,Mubende,Mukono,Muranga,Musoma,Mutomo,Mutukula,Mwanza,Nagongera,Nairobi,Naivasha,Nakapiripirit,Nakaseke,Nakasongola,Nakuru,Namanga,Namayingo,Namutumba,Nansana,Nanyuki,Narok,Naromoru,Nebbi,Ngora,Njeru,Njombe,Nkokonjeru,Ntungamo,Nyahururu,Nyeri,Oyam,Pader,Paidha,Pakwach,Pallisa,Rakai,Ruiru,Rukungiri,Rwimi,Sanga,Sembabule,Shimoni,Shinyanga,Singida,Sironko,Songea,Soroti,Ssabagabo,Sumbawanga,Tabora,Takaungu,Tanga,Thika,Tororo,Tunduma,Vihiga,Voi,Wajir,Wakiso,Watamu,Webuye,Wobulenzi,Wote,Wundanyi,Yumbe,Zanzibar"},
|
||||
{name: "Vietnamese", i: 29, min: 3, max: 12, d: "", m: 1, b: "An Giang,Anh Son,An Khe,An Nhon,Ayun Pa,Bac Giang,Bac Kan,Bac Lieu,Bac Ninh,Ba Don,Bao Loc,Ba Ria,Ba Ria-Vung Tau,Ba Thuoc,Ben Cat,Ben Tre,Bien Hoa,Bim Son,Binh Dinh,Binh Duong,Binh Long,Binh Minh,Binh Phuoc,Binh Thuan,Buon Ho,Buon Ma Thuot,Cai Lay,Ca Mau,Cam Khe,Cam Pha,Cam Ranh,Cam Thuy,Can Tho,Cao Bang,Cao Lanh,Cao Phong,Chau Doc,Chi Linh,Con Cuong,Cua Lo,Da Bac,Dak Lak,Da Lat,Da Nang,Di An,Dien Ban,Dien Bien,Dien Bien Phu,Dien Chau,Do Luong,Dong Ha,Dong Hoi,Dong Trieu,Duc Pho,Duyen Hai,Duy Tien,Gia Lai,Gia Nghia,Gia Rai,Go Cong,Ha Giang,Ha Hoa,Hai Duong,Hai Phong,Ha Long,Ha Nam,Ha Noi,Ha Tinh,Ha Trung,Hau Giang,Hoa Binh,Hoang Mai,Hoa Thanh,Ho Chi Minh,Hoi An,Hong Linh,Hong Ngu,Hue,Hung Nguyen,Hung Yen,Huong Thuy,Huong Tra,Khanh Hoa,Kien Tuong,Kim Boi,Kinh Mon,Kon Tum,Ky Anh,Ky Son,Lac Son,Lac Thuy,La Gi,Lai Chau,Lam Thao,Lang Chanh,Lang Son,Lao Cai,Long An,Long Khanh,Long My,Long Xuyen,Luong Son,Mai Chau,Mong Cai,Muong Lat,Muong Lay,My Hao,My Tho,Nam Dan,Nam Dinh,Nga Bay,Nga Nam,Nga Son,Nghe An,Nghia Dan,Nghia Lo,Nghi Loc,Nghi Son,Ngoc Lac,Nha Trang,Nhu Thanh,Nhu Xuan,Ninh Binh,Ninh Hoa,Nong Cong,Phan Rang Thap Cham,Phan Thiet,Pho Yen,Phu Ly,Phu My,Phu Ninh,Phuoc Long,Phu Tho,Phu Yen,Pleiku,Quang Binh,Quang Nam,Quang Ngai,Quang Ninh,Quang Tri,Quang Xuong,Quang Yen,Quan Hoa,Quan Son,Que Phong,Quy Chau,Quy Hop,Quynh Luu,Quy Nhon,Rach Gia,Sa Dec,Sai Gon,Sam Son,Sa Pa,Soc Trang,Song Cau,Song Cong,Son La,Son Tay,Tam Diep,Tam Ky,Tan An,Tan Chau,Tan Ky,Tan Lac,Tan Son,Tan Uyen,Tay Ninh,Thach Thanh,Thai Binh,Thai Hoa,Thai Nguyen,Thanh Chuong,Thanh Hoa,Thieu Hoa,Thuan An,Thua Thien-Hue,Thu Dau Mot,Thu Duc,Thuong Xuan,Tien Giang,Trang Bang,Tra Vinh,Trieu Son,Tu Son,Tuyen Quang,Tuy Hoa,Uong Bi,Viet Tri,Vinh,Vinh Chau,Vinh Loc,Vinh Long,Vinh Yen,Vi Thanh,Vung Tau,Yen Bai,Yen Dinh,Yen Thanh,Yen Thuy"},
|
||||
{name: "Cantonese", i: 30, min: 5, max: 11, d: "", m: 0, b: "Chaiwan,Chingchung,Chinghoi,Chingsen,Chingshing,Chiunam,Chiuon,Chiuyeung,Chiyuen,Choihung,Chuehoi,Chuiman,Chungfu,Chungsan,Chunguktsuen,Dakhing,Daopo,Daumun,Dingwu,Dinpak,Donggun,Dongyuen,Duenchau,Fachau,Fanling,Fatgong,Fatshan,Fotan,Fuktien,Fumun,Funggong,Funghoi,Fungshun,Fungtei,Gamtin,Gochau,Goming,Gonghoi,Gongshing,Goyiu,Hanghau,Hangmei,Hengon,Heungchau,Heunggong,Heungkiu,Hingning,Hohfuktong,Hoichue,Hoifung,Hoiping,Hokong,Hokshan,Hoyuen,Hunghom,Hungshuikiu,Jiuling,Kamsheung,Kamwan,Kaulongtong,Keilun,Kinon,Kinsang,Kityeung,Kongmun,Kukgong,Kwaifong,Kwaihing,Kwongchau,Kwongling,Kwongming,Kwuntong,Laichikok,Laiking,Laiwan,Lamtei,Lamtin,Leitung,Leungking,Limkong,Linping,Linshan,Loding,Lokcheong,Lokfu,Longchuen,Longgong,Longmun,Longping,Longwa,Longwu,Lowu,Luichau,Lukfung,Lukho,Lungmun,Macheung,Maliushui,Maonshan,Mauming,Maunam,Meifoo,Mingkum,Mogong,Mongkok,Muichau,Muigong,Muiyuen,Naiwai,Namcheong,Namhoi,Namhong,Namsha,Nganwai,Ngautaukok,Ngchuen,Ngwa,Onting,Pakwun,Paotoishan,Pingshan,Pingyuen,Poklo,Pongon,Poning,Potau,Puito,Punyue,Saiwanho,Saiyingpun,Samshing,Samshui,Samtsen,Samyuenlei,Sanfung,Sanhing,Sanhui,Sanwai,Seiwui,Shamshuipo,Shanmei,Shantau,Shauking,Shekmun,Shekpai,Sheungshui,Shingkui,Shiuhing,Shundak,Shunyi,Shupinwai,Simshing,Siuhei,Siuhong,Siukwan,Siulun,Suikai,Taihing,Taikoo,Taipo,Taishuihang,Taiwai,Taiwohau,Tinhau,Tinshuiwai,Tiukengleng,Toishan,Tongfong,Tonglowan,Tsakyoochung,Tsamgong,Tsangshing,Tseungkwano,Tsimshatsui,Tsinggong,Tsingshantsuen,Tsingwun,Tsingyi,Tsingyuen,Tsiuchau,Tsuenshekshan,Tsuenwan,Tuenmun,Tungchung,Waichap,Waichau,Waidong,Wailoi,Waishing,Waiyeung,Wanchai,Wanfau,Wanshing,Wingon,Wongpo,Wongtaisin,Woping,Wukaisha,Yano,Yaumatei,Yautong,Yenfa,Yeungchun,Yeungdong,Yeungsai,Yeungshan,Yimtin,Yingdak,Yiuping,Yongshing,Yongyuen,Yuenlong,Yuenshing,Yuetsau,Yuknam,Yunping"},
|
||||
{name: "Mongolian", i: 31, min: 5, max: 12, d: "aou", m: .3, b: "Adaatsag,Airag,Alag Erdene,Altai,Altanshiree,Altantsogts,Arbulag,Baatsagaan,Batnorov,Batshireet,Battsengel,Bayan Adarga,Bayan Agt,Bayanbulag,Bayandalai,Bayandun,Bayangovi,Bayanjargalan,Bayankhongor,Bayankhutag,Bayanlig,Bayanmonkh,Bayannur,Bayannuur,Bayan Ondor,Bayan Ovoo,Bayantal,Bayantsagaan,Bayantumen,Bayan Uul,Bayanzurkh,Berkh,Biger,Binder,Bogd,Bombogor,Bor Ondor,Bugat,Bugt,Bulgan,Buregkhangai,Burentogtokh,Buutsagaan,Buyant,Chandmani,Chandmani Ondor,Choibalsan,Chuluunkhoroot,Chuluut,Dadal,Dalanjargalan,Dalanzadgad,Darhan Muminggan,Darkhan,Darvi,Dashbalbar,Dashinchilen,Delger,Delgerekh,Delgerkhaan,Delgerkhangai,Delgertsogt,Deluun,Deren,Dorgon,Duut,Erdene,Erdenebulgan,Erdeneburen,Erdenedalai,Erdenemandal,Erdenetsogt,Galshar,Galt,Galuut,Govi Ugtaal,Gurvan,Gurvanbulag,Gurvansaikhan,Gurvanzagal,Hinggan,Hodong,Holingol,Hondlon,Horin Ger,Horqin,Hulunbuir,Hure,Ikhkhet,Ikh Tamir,Ikh Uul,Jargalan,Jargalant,Jargaltkhaan,Jarud,Jinst,Khairkhan,Khalhgol,Khaliun,Khanbogd,Khangai,Khangal,Khankh,Khankhongor,Khashaat,Khatanbulag,Khatgal,Kherlen,Khishig Ondor,Khokh,Kholonbuir,Khongor,Khotont,Khovd,Khovsgol,Khuld,Khureemaral,Khurmen,Khutag Ondor,Luus,Mandakh,Mandal Ovoo,Mankhan,Manlai,Matad,Mogod,Monkhkhairkhan,Moron,Most,Myangad,Nogoonnuur,Nomgon,Norovlin,Noyon,Ogii,Olgii,Olziit,Omnodelger,Ondorkhaan,Ondorshil,Ondor Ulaan,Ongniud,Ordos,Orgon,Orkhon,Rashaant,Renchinlkhumbe,Sagsai,Saikhan,Saikhandulaan,Saikhan Ovoo,Sainshand,Saintsagaan,Selenge,Sergelen,Sevrei,Sharga,Sharyngol,Shine Ider,Shinejinst,Shiveegovi,Sumber,Taishir,Tarialan,Tariat,Teshig,Togrog,Togtoh,Tolbo,Tomorbulag,Tonkhil,Tosontsengel,Tsagaandelger,Tsagaannuur,Tsagaan Ovoo,Tsagaan Uur,Tsakhir,Tseel,Tsengel,Tsenkher,Tsenkhermandal,Tsetseg,Tsetserleg,Tsogt,Tsogt Ovoo,Tsogttsetsii,Tumed,Tunel,Tuvshruulekh,Ulaanbadrakh,Ulaankhus,Ulaan Uul,Ulanhad,Ulanqab,Uyench,Yesonbulag,Zag,Zalainur,Zamyn Uud,Zereg"},
|
||||
// fantasy bases by Dopu:
|
||||
{name: "Human Generic", i: 32, min: 6, max: 11, d: "peolst", m: 0, b: "Amberglen,Angelhand,Arrowden,Autumnband,Autumnkeep,Basinfrost,Basinmore,Bayfrost,Beargarde,Bearmire,Bellcairn,Bellport,Bellreach,Blackwatch,Bleakward,Bonemouth,Boulder,Bridgefalls,Bridgeforest,Brinepeak,Brittlehelm,Bronzegrasp,Castlecross,Castlefair,Cavemire,Claymond,Claymouth,Clearguard,Cliffgate,Cliffshear,Cliffshield,Cloudbay,Cloudcrest,Cloudwood,Coldholde,Cragbury,Crowgrove,Crowvault,Crystalrock,Crystalspire,Cursefield,Curseguard,Cursespell,Dawnforest,Dawnwater,Deadford,Deadkeep,Deepcairn,Deerchill,Demonfall,Dewglen,Dewmere,Diredale,Direden,Dirtshield,Dogcoast,Dogmeadow,Dragonbreak,Dragonhold,Dragonward,Dryhost,Dustcross,Dustwatch,Eaglevein,Earthfield,Earthgate,Earthpass,Ebonfront,Edgehaven,Eldergate,Eldermere,Embervault,Everchill,Evercoast,Falsevale,Faypond,Fayvale,Fayyard,Fearpeak,Flameguard,Flamewell,Freyshell,Ghostdale,Ghostpeak,Gloomburn,Goldbreach,Goldyard,Grassplains,Graypost,Greeneld,Grimegrove,Grimeshire,Heartfall,Heartford,Heartvault,Highbourne,Hillpass,Hollowstorm,Honeywater,Houndcall,Houndholde,Iceholde,Icelight,Irongrave,Ironhollow,Knightlight,Knighttide,Lagoonpass,Lakecross,Lastmere,Laststar,Lightvale,Limeband,Littlehall,Littlehold,Littlemire,Lostcairn,Lostshield,Loststar,Madfair,Madham,Midholde,Mightglen,Millstrand,Mistvault,Mondpass,Moonacre,Moongulf,Moonwell,Mosshand,Mosstide,Mosswind,Mudford,Mudwich,Mythgulch,Mythshear,Nevercrest,Neverfront,Newfalls,Nighthall,Oakenbell,Oakenrun,Oceanstar,Oldreach,Oldwall,Oldwatch,Oxbrook,Oxlight,Pearlhaven,Pinepond,Pondfalls,Pondtown,Pureshell,Quickbell,Quickpass,Ravenside,Roguehaven,Roseborn,Rosedale,Rosereach,Rustmore,Saltmouth,Sandhill,Scorchpost,Scorchstall,Shadeforest,Shademeadow,Shadeville,Shimmerrun,Shimmerwood,Shroudrock,Silentkeep,Silvercairn,Silvergulch,Smallmire,Smoothcliff,Smoothgrove,Smoothtown,Snakemere,Snowbay,Snowshield,Snowtown,Southbreak,Springmire,Springview,Stagport,Steammouth,Steamwall,Steepmoor,Stillhall,Stoneguard,Stonespell,Stormhand,Stormhorn,Sungulf,Sunhall,Swampmaw,Swangarde,Swanwall,Swiftwell,Thorncairn,Thornhelm,Thornyard,Timberside,Tradewick,Westmeadow,Westpoint,Whiteshore,Whitvalley,Wildeden,Wildwell,Wildyard,Winterhaven,Wolfpass"},
|
||||
{name: "Elven", i: 33, min: 6, max: 12, d: "lenmsrg", m: 0, b: "Adrindest,Aethel,Afranthemar,Aiqua,Alari,Allanar,Almalian,Alora,Alyanasari,Alyelona,Alyran,Ammar,Anyndell,Arasari,Aren,Ashmebel,Aymlume,Bel-Didhel,Brinorion,Caelora,Chaulssad,Chaundra,Cyhmel,Cyrang,Dolarith,Dolonde,Draethe,Dranzan,Draugaust,E'ana,Eahil,Edhil,Eebel,Efranluma,Eld-Sinnocrin,Elelthyr,Ellanalin,Ellena,Ellorthond,Eltaesi,Elunore,Emyranserine,Entheas,Eriargond,Esari,Esath,Eserius,Eshsalin,Eshthalas,Evraland,Faellenor,Famelenora,Filranlean,Filsaqua,Gafetheas,Gaf Serine,Geliene,Gondorwin,Guallu,Haeth,Hanluna,Haulssad,Heloriath,Himlarien,Himliene,Hinnead,Hlinas,Hloireenil,Hluihei,Hlurthei,Hlynead,Iaenarion,Iaron,Illanathaes,Illfanora,Imlarlon,Imyse,Imyvelian,Inferius,Inlurth,innsshe,Iralserin,Irethtalos,Irholona,Ishal,Ishlashara,Ithelion,Ithlin,Iulil,Jaal,Jamkadi,Kaalume,Kaansera,Karanthanil,Karnosea,Kasethyr,Keatheas,Kelsya,Keth Aiqua,Kmlon,Kyathlenor,Kyhasera,Lahetheas,Lefdorei,Lelhamelle,Lilean,Lindeenil,Lindoress,Litys,Llaughei,Lya,Lyfa,Lylharion,Lynathalas,Machei,Masenoris,Mathethil,Mathentheas,Meethalas,Menyamar,Mithlonde,Mytha,Mythsemelle,Mythsthas,Naahona,Nalore,Nandeedil,Nasad Ilaurth,Nasin,Nathemar,Neadar,Neilon,Nelalon,Nellean,Nelnetaesi,Nilenathyr,Nionande,Nylm,Nytenanas,Nythanlenor,O'anlenora,Obeth,Ofaenathyr,Ollmnaes,Ollsmel,Olwen,Olyaneas,Omanalon,Onelion,Onelond,Orlormel,Ormrion,Oshana,Oshvamel,Raethei,Rauguall,Reisera,Reslenora,Ryanasera,Rymaserin,Sahnor,Saselune,Sel-Zedraazin,Selananor,Sellerion,Selmaluma,Shaeras,Shemnas,Shemserin,Sheosari,Sileltalos,Siriande,Siriathil,Srannor,Sshanntyr,Sshaulu,Syholume,Sylharius,Sylranbel,Taesi,Thalor,Tharenlon,Thelethlune,Thelhohil,Themar,Thene,Thilfalean,Thilnaenor,Thvethalas,Thylathlond,Tiregul,Tlauven,Tlindhe,Ulal,Ullve,Ulmetheas,Ulssin,Umnalin,Umye,Umyheserine,Unanneas,Unarith,Undraeth,Unysarion,Vel-Shonidor,Venas,Vin Argor,Wasrion,Wlalean,Yaeluma,Yeelume,Yethrion,Ymserine,Yueghed,Yuerran,Yuethin"},
|
||||
{name: "Dark Elven", i: 34, min: 6, max: 14, d: "nrslamg", m: .2, b: "Abaethaggar,Abburth,Afranthemar,Aharasplit,Aidanat,Ald'ruhn,Ashamanu,Ashesari,Ashletheas,Baerario,Baereghel,Baethei,Bahashae,Balmora,Bel-Didhel,Borethanil,Buiyrandyn,Caellagith,Caellathala,Caergroth,Caldras,Chaggar,Chaggaust,Channtar,Charrvhel'raugaust,Chaulssin,Chaundra,ChedNasad,ChetarIthlin,ChethRrhinn,Chymaer,Clarkarond,Cloibbra,Commoragh,Cyrangroth,Cilben,D'eldarc,Daedhrog,Dalkyn,Do'Urden,Doladress,Dolarith,Dolonde,Draethe,Dranzan,Dranzithl,Draugaust,Dreghei,Drelhei,Dryndlu,Dusklyngh,DyonG'ennivalz,Edraithion,Eld-Sinnocrin,Ellorthond,Enhethyr,Entheas,ErrarIthinn,Eryndlyn,Faladhell,Faneadar,Fethalas,Filranlean,Formarion,Ferdor,Gafetheas,Ghrond,Gilranel,Glamordis,Gnaarmok,Gnisis,Golothaer,Gondorwin,Guallidurth,Guallu,Gulshin,Haeth,Haggraef,Harganeth,Harkaldra,Haulssad,Haundrauth,Heloriath,Hlammachar,Hlaughei,Hloireenil,Hluitar,Inferius,Innsshe,Ithilaughym,Iz'aiogith,Jaal,Jhachalkhyn,Kaerabrae,Karanthanil,Karondkar,Karsoluthiyl,Kellyth,Khuul,Lahetheas,Lidurth,Lindeenil,Lirillaquen,LithMy'athar,LlurthDreier,Lolth,Lothuial,Luihaulen'tar,Maeralyn,Maerimydra,Mathathlona,Mathethil,Mellodona,Menagith,Menegwen,Menerrendil,Menzithl,Menzoberranzan,Mila-Nipal,Mithryn,Molagmar,Mundor,Myvanas,Naggarond,Nandeedil,NasadIlaurth,Nauthor,Navethas,Neadar,Nurtaleewe,Nidiel,Noruiben,Olwen,O'lalona,Obeth,Ofaenathyr,Orlormel,Orlytlar,Pelagiad,Raethei,Raugaust,Rauguall,Rilauven,Rrharrvhei,Sadrith,Sel-Zedraazin,Seydaneen,Shaz'rir,Skaal,Sschindylryn,Shamath,Shamenz,Shanntur,Sshanntynlan,Sshanntyr,Shaulssin,SzithMorcane,Szithlin,Szobaeth,Sirdhemben,T'lindhet,Tebh'zhor,Telmere,Telnarquel,Tharlarast,Thylathlond,Tlaughe,Trizex,Tyrybblyn,Ugauth,Ughym,Uhaelben,Ullmatalos,Ulmetheas,Ulrenserine,Uluitur,Undraeth,Undraurth,Undrek'Thoz,Ungethal,UstNatha,Uthaessien,V'elddrinnsshar,Vaajha,Vel-Shonidor,Velddra,Velothi,Venead,Vhalth'vha,Vinargothr,Vojha,Waethe,Waethei,Xaalkis,Yakaridan,Yeelume,Yridhremben,Yuethin,Yuethindrynn,Zirnakaynin"},
|
||||
{name: "Dwarven", i: 35, min: 4, max: 11, d: "dk", m: 0, b: "Addundad,Ahagzad,Ahazil,Akil,Akzizad,Anumush,Araddush,Arar,Arbhur,Badushund,Baragzig,Baragzund,Barakinb,Barakzig,Barakzinb,Barakzir,Baramunz,Barazinb,Barazir,Bilgabar,Bilgatharb,Bilgathaz,Bilgila,Bilnaragz,Bilnulbar,Bilnulbun,Bizaddum,Bizaddush,Bizanarg,Bizaram,Bizinbiz,Biziram,Bunaram,Bundinar,Bundushol,Bundushund,Bundushur,Buzaram,Buzundab,Buzundush,Gabaragz,Gabaram,Gabilgab,Gabilgath,Gabizir,Gabunal,Gabunul,Gabuzan,Gatharam,Gatharbhur,Gathizdum,Gathuragz,Gathuraz,Gila,Giledzir,Gilukkhath,Gilukkhel,Gunala,Gunargath,Gunargil,Gundumunz,Gundusharb,Gundushizd,Kharbharbiln,Kharbhatharb,Kharbhela,Kharbilgab,Kharbuzadd,Khatharbar,Khathizdin,Khathundush,Khazanar,Khazinbund,Khaziragz,Khaziraz,Khizdabun,Khizdusharbh,Khizdushath,Khizdushel,Khizdushur,Kholedzar,Khundabiln,Khundabuz,Khundinarg,Khundushel,Khuragzig,Khuramunz,Kibarak,Kibilnal,Kibizar,Kibunarg,Kibundin,Kibuzan,Kinbadab,Kinbaragz,Kinbarakz,Kinbaram,Kinbizah,Kinbuzar,Nala,Naledzar,Naledzig,Naledzinb,Naragzah,Naragzar,Naragzig,Narakzah,Narakzar,Naramunz,Narazar,Nargabad,Nargabar,Nargatharb,Nargila,Nargundum,Nargundush,Nargunul,Narukthar,Narukthel,Nula,Nulbadush,Nulbaram,Nulbilnarg,Nulbunal,Nulbundab,Nulbundin,Nulbundum,Nulbuzah,Nuledzah,Nuledzig,Nulukkhaz,Nulukkhund,Nulukkhur,Sharakinb,Sharakzar,Sharamunz,Sharbarukth,Shatharbhizd,Shatharbiz,Shathazah,Shathizdush,Shathola,Shaziragz,Shizdinar,Shizdushund,Sholukkharb,Shundinulb,Shundushund,Shurakzund,Shuramunz,Tumunzadd,Tumunzan,Tumunzar,Tumunzinb,Tumunzir,Ukthad,Ulbirad,Ulbirar,Ulunzar,Ulur,Umunzad,Undalar,Undukkhil,Undun,Undur,Unduzur,Unzar,Unzathun,Usharar,Zaddinarg,Zaddushur,Zaharbad,Zaharbhizd,Zarakib,Zarakzar,Zaramunz,Zarukthel,Zinbarukth,Zirakinb,Zirakzir,Ziramunz,Ziruktharbh,Zirukthur,Zundumunz"},
|
||||
{name: "Goblin", i: 36, min: 4, max: 9, d: "eag", m: 0, b: "Asinx,Bhiagielt,Biokvish,Blix,Blus,Bratliaq,Breshass,Bridvelb,Brybsil,Bugbig,Buyagh,Cel,Chalk,Chiafzia,Chox,Cielb,Cosvil,Crekork,Crild,Croibieq,Diervaq,Dobruing,Driord,Eebligz,Een,Enissee,Esz,Far,Felhob,Froihiofz,Fruict,Fygsee,Gagablin,Gigganqi,Givzieqee,Glamzofs,Glernaahx,Gneabs,Gnoklig,Gobbledak,gobbok,Gobbrin,Heszai,Hiszils,Hobgar,Honk,Iahzaarm,Ialsirt,Ilm,Ish,Jasheafta,Joimtoilm,Kass,Katmelt,Kleabtong,Kleardeek,Klilm,Kluirm,Kuipuinx,Moft,Mogg,Nilbog,Oimzoishai,Onq,Ozbiard,Paas,Phax,Phigheldai,Preang,Prolkeh,Pyreazzi,Qeerags,Qosx,Rekx,Shaxi,Sios,Slehzit,Slofboif,Slukex,Srefs,Srurd,Stiaggaltia,Stiolx,Stioskurt,Stroir,Strytzakt,Stuikvact,Styrzangai,Suirx,Swaxi,Taxai,Thelt,Thresxea,Thult,Traglila,Treaq,Ulb,Ulm,Utha,Utiarm,Veekz,Vohniots,Vreagaald,Watvielx,Wrogdilk,Wruilt,Xurx,Ziggek,Zriokots"},
|
||||
{name: "Orc", i: 37, min: 4, max: 8, d: "gzrcu", m: 0, b: "Adgoz,Adgril-Gha,Adog,Adzurd,Agkadh,Agzil-Ghal,Akh,Ariz-Dru,Arkugzo,Arrordri,Ashnedh,Azrurdrekh,Bagzildre,Bashnud,Bedgez-Graz,Bhakh,Bhegh,Bhiccozdur,Bhicrur,Bhirgoshbel,Bhog,Bhurkrukh,Bod-Rugniz,Bogzel,Bozdra,Bozgrun,Bozziz,Bral-Lazogh,Brazadh,Brogved,Brogzozir,Brolzug,Brordegeg,Brorkril-Zrog,Brugroz,Brukh-Zrabrul,Brur-Korre,Bulbredh,Bulgragh,Chaz-Charard,Chegan-Khed,Chugga,Chuzar,Dhalgron-Mog,Dhazon-Ner,Dhezza,Dhoddud,Dhodh-Brerdrodh,Dhodh-Ghigin,Dhoggun-Bhogh,Dhulbazzol,Digzagkigh,Dirdrurd,Dodkakh,Dorgri,Drizdedh,Drobagh,Drodh-Ashnugh,Drogvukh-Drodh,Drukh-Qodgoz,Drurkuz,Dududh,Dur-Khaddol,Egmod,Ekh-Beccon,Ekh-Krerdrugh,Ekh-Mezred,Gagh-Druzred,Gazdrakh-Vrard,Gegnod,Gerkradh,Ghagrocroz,Ghared-Krin,Ghedgrolbrol,Gheggor,Ghizgil,Gho-Ugnud,Gholgard,Gidh-Ucceg,Goccogmurd,Golkon,Graz-Khulgag,Gribrabrokh,Gridkog,Grigh-Kaggaz,Grirkrun-Qur,Grughokh,Grurro,Gugh-Zozgrod,Gur-Ghogkagh,Ibagh-Chol,Ibruzzed,Ibul-Brad,Iggulzaz,Ikh-Ugnan,Irdrelzug,Irmekh-Bhor,Kacruz,Kalbrugh,Karkor-Zrid,Kazzuz-Zrar,Kezul-Bruz,Kharkiz,Khebun,Khorbric,Khuldrerra,Khuzdraz,Kirgol,Koggodh,Korkrir-Grar,Kraghird,Krar-Zurmurd,Krigh-Bhurdin,Kroddadh,Krudh-Khogzokh,Kudgroccukh,Kudrukh,Kudzal,Kuzgrurd-Dedh,Larud,Legvicrodh,Lorgran,Lugekh,Lulkore,Mazgar,Merkraz,Mocculdrer,Modh-Odod,Morbraz,Mubror,Muccug-Ghuz,Mughakh-Chil,Murmad,Nazad-Ludh,Negvidh,Nelzor-Zroz,Nirdrukh,Nogvolkar,Nubud,Nuccag,Nudh-Kuldra,Nuzecro,Oddigh-Krodh,Okh-Uggekh,Ordol,Orkudh-Bhur,Orrad,Qashnagh,Qiccad-Chal,Qiddolzog,Qidzodkakh,Qirzodh,Rarurd,Reradgri,Rezegh,Rezgrugh,Rodrekh,Rogh-Chirzaz,Rordrushnokh,Rozzez,Ruddirgrad,Rurguz-Vig,Ruzgrin,Ugh-Vruron,Ughudadh,Uldrukh-Bhudh,Ulgor,Ulkin,Ummugh-Ekh,Uzaggor,Uzdriboz,Uzdroz,Uzord,Uzron,Vaddog,Vagord-Khod,Velgrudh,Verrugh,Vrazin,Vrobrun,Vrugh-Nardrer,Vrurgu,Vuccidh,Vun-Gaghukh,Zacrad,Zalbrez,Zigmorbredh,Zordrordud,Zorrudh,Zradgukh,Zragmukh,Zragrizgrakh,Zraldrozzuz,Zrard-Krodog,Zrazzuz-Vaz,Zrigud,Zrulbukh-Dekh,Zubod-Ur,Zulbriz,Zun-Bergrord"},
|
||||
{name: "Giant", i: 38, min: 5, max: 10, d: "kdtng", m: 0, b: "Addund,Aerora,Agane,Anumush,Arangrim,Bahourg,Baragzund,Barakinb,Barakzig,Barakzinb,Baramunz,Barazinb,Beornelde,Beratira,Borgbert,Botharic,Bremrol,Brerstin,Brildung,Brozu,Bundushund,Burthug,Chazruc,Chergun,Churtec,Dagdhor,Dankuc,Darnaric,Debuch,Dina,Dinez,Diru,Drard,Druguk,Dugfast,Duhal,Dulkun,Eldond,Enuz,Eraddam,Eradhelm,Froththorn,Fynwyn,Gabaragz,Gabaram,Gabizir,Gabuzan,Gagkake,Galfald,Galgrim,Gatal,Gazin,Geru,Gila,Giledzir,Girkun,Glumvat,Gluthmark,Gomruch,Gorkege,Gortho,Gostuz,Grimor,Grimtira,Guddud,Gudgiz,Gulwo,Gunargath,Gundusharb,Guril,Gurkale,Guruge,Guzi,Hargarth,Hartreo,Heimfara,Hildlaug,Idgurth,Inez,Inginy,Iora,Irkin,Jaldhor,Jarwar,Jornangar,Jornmoth,Kakkek,Kaltoch,Kegkez,Kengord,Kharbharbiln,Khatharbar,Khathizdin,Khazanar,Khaziragz,Khizdabun,Khizdushel,Khundinarg,Kibarak,Kibizar,Kigine,Kilfond,Kilkan,Kinbadab,Kinbuzar,Koril,Kostand,Kuzake,Lindira,Lingarth,Maerdis,Magald,Marbold,Marbrand,Memron,Minu,Mistoch,Morluch,Mornkin,Morntaric,Nagu,Naragzah,Naramunz,Narazar,Nargabar,Nargatharb,Nargundush,Nargunul,Natan,Natil,Neliz,Nelkun,Noluch,Norginny,Nulbaram,Nulbilnarg,Nuledzah,Nuledzig,Nulukkhaz,Nulukkhur,Nurkel,Oci,Olane,Oldstin,Orga,Ranava,Ranhera,Rannerg,Rirkan,Rizen,Rurki,Rurkoc,Sadgach,Sgandrol,Sharakzar,Shatharbiz,Shathizdush,Shathola,Shizdinar,Sholukkharb,Shundushund,Shurakzund,Sidga,Sigbeorn,Sigbi,Solfod,Somrud,Srokvan,Stighere,Sulduch,Talkale,Theoddan,Theodgrim,Throtrek,Tigkiz,Tolkeg,Toren,Tozage,Tulkug,Tumunzar,Umunzad,Undukkhil,Usharar,Valdhere,Varkud,Velfirth,Velhera,Vigkan,Vorkige,Vozig,Vylwed,Widhyrde,Wylaeya,Yili,Yotane,Yudgor,Yulkake,Zigez,Zugkan,Zugke"},
|
||||
{name: "Draconic", i: 39, min: 6, max: 14, d: "aliuszrox", m: 0, b: "Aaronarra,Adalon,Adamarondor,Aeglyl,Aerosclughpalar,Aghazstamn,Aglaraerose,Agoshyrvor,Alduin,Alhazmabad,Altagos,Ammaratha,Amrennathed,Anaglathos,Andrathanach,Araemra,Araugauthos,Arauthator,Arharzel,Arngalor,Arveiaturace,Athauglas,Augaurath,Auntyrlothtor,Azarvilandral,Azhaq,Balagos,Baratathlaer,Bleucorundum,BrazzPolis,Canthraxis,Capnolithyl,Charvekkanathor,Chellewis,Chelnadatilar,Cirrothamalan,Claugiyliamatar,Cragnortherma,Dargentum,Dendeirmerdammarar,Dheubpurcwenpyl,Domborcojh,Draconobalen,Dragansalor,Dupretiskava,Durnehviir,Eacoathildarandus,Eldrisithain,Enixtryx,Eormennoth,Esmerandanna,Evenaelorathos,Faenphaele,Felgolos,Felrivenser,Firkraag,Fll'Yissetat,Furlinastis,Galadaeros,Galglentor,Garnetallisar,Garthammus,Gaulauntyr,Ghaulantatra,Glouroth,Greshrukk,Guyanothaz,Haerinvureem,Haklashara,Halagaster,Halaglathgar,Havarlan,Heltipyre,Hethcypressarvil,Hoondarrh,Icehauptannarthanyx,Iiurrendeem,Ileuthra,Iltharagh,Ingeloakastimizilian,Irdrithkryn,Ishenalyr,Iymrith,Jaerlethket,Jalanvaloss,Jharakkan,Kasidikal,Kastrandrethilian,Khavalanoth,Khuralosothantar,Kisonraathiisar,Kissethkashaan,Kistarianth,Klauth,Klithalrundrar,Krashos,Kreston,Kriionfanthicus,Krosulhah,Krustalanos,Kruziikrel,Kuldrak,Lareth,Latovenomer,Lhammaruntosz,Llimark,Ma'fel'no'sei'kedeh'naar,MaelestorRex,Magarovallanthanz,Mahatnartorian,Mahrlee,Malaeragoth,Malagarthaul,Malazan,Maldraedior,Maldrithor,MalekSalerno,Maughrysear,Mejas,Meliordianix,Merah,Mikkaalgensis,Mirmulnir,Mistinarperadnacles,Miteach,Mithbarazak,Morueme,Moruharzel,Naaslaarum,Nahagliiv,Nalavarauthatoryl,Naxorlytaalsxar,Nevalarich,Nolalothcaragascint,Nurvureem,Nymmurh,Odahviing,Olothontor,Ormalagos,Otaaryliakkarnos,Paarthurnax,Pelath,Pelendralaar,Praelorisstan,Praxasalandos,Protanther,Qiminstiir,Quelindritar,Ralionate,Rathalylaug,Rathguul,Rauglothgor,Raumorthadar,Relonikiv,Ringreemeralxoth,Roraurim,Rynnarvyx,Sablaxaahl,Sahloknir,Sahrotaar,Samdralyrion,Saryndalaghlothtor,Sawaka,Shalamalauth,Shammagar,Sharndrel,Shianax,Skarlthoon,Skurge,Smergadas,Ssalangan,Sssurist,Sussethilasis,Sylvallitham,Tamarand,Tantlevgithus,Tarlacoal,Tenaarlaktor,Thalagyrt,Tharas'kalagram,Thauglorimorgorus,Thoklastees,Thyka,Tsenshivah,Ueurwen,Uinnessivar,Urnalithorgathla,Velcuthimmorhar,Velora,Vendrathdammarar,Venomindhar,Viinturuth,Voaraghamanthar,Voslaarum,Vr'tark,Vrondahorevos,Vuljotnaak,Vulthuryol,Wastirek,Worlathaugh,Xargithorvar,Xavarathimius,Yemere,Ylithargathril,Ylveraasahlisar,Za-Jikku,Zarlandris,Zellenesterex,Zilanthar,Zormapalearath,Zundaerazylym,Zz'Pzora"},
|
||||
{name: "Arachnid", i: 40, min: 4, max: 10, d: "erlsk", m: 0, b: "Aaqok'ser,Aiced,Aizachis,Allinqel,As'taq,Ashrash,Caaqtos,Ceek'sax,Ceezuq,Cek'sier,Cen'qi,Ceqzocer,Cezeed,Chachocaq,Charis,Chashilieth,Checib,Chernul,Chezi,Chiazu,Chishros,Chixhi,Chizhi,Chollash,Choq'sha,Cinchichail,Collul,Ecush'taid,Ekiqe,Eqas,Er'uria,Erikas,Es'tase,Esrub,Exha,Haqsho,Hiavheesh,Hitha,Hok'thi,Hossa,Iacid,Iciever,Illuq,Isnir,Keezut,Kheellavas,Kheizoh,Khiachod,Khika,Khirzur,Khonrud,Khrakku,Khraqshis,Khrethish'ti,Khriashus,Khrika,Khrirni,Klashirel,Kleil'sha,Klishuth,Krarnit,Kras'tex,Krotieqas,Lais'tid,Laizuh,Lasnoth,Len'qeer,Leqanches,Lezad,Lhilir,Lhivhath,Lhok'thu,Lialliesed,Liaraq,Liceva,Lichorro,Lilla,Lokieqib,Nakur,Neerhaca,Neet'er,Neezoh,Nenchiled,Nerhalneth,Nir'ih,Nizus,Noreeqo,On'qix,Qalitho,Qas'tor,Qasol,Qavrud,Qavud,Qazar,Qazru,Qekno,Qeqravee,Qes'tor,Qhaik'sal,Qhak'sish,Qhazsakais,Qheliva,Qhenchaqes,Qherazal,Qhon'qos,Qhosh,Qish'tur,Qisih,Qorhoci,Qranchiq,Racith,Rak'zes,Ranchis,Rarhie,Rarzi,Rarzisiaq,Ras'tih,Ravosho,Recad,Rekid,Rernee,Rertachis,Rezhokketh,Reziel,Rhacish,Rhail'shel,Rhairhizse,Rhakivex,Rhaqeer,Rhartix,Rheciezsei,Rheevid,Rhel'shir,Rhevhie,Rhiavekot,Rhikkos,Rhiqese,Rhiqi,Rhiqracar,Rhisned,Rhousnateb,Riakeesnex,Rintachal,Rir'ul,Rourk'u,Rouzakri,Sailiqei,Sanchiqed,Saqshu,Sat'ier,Sazi,Seiqas,Shieth'i,Shiqsheh,Shizha,Shrachuvo,Shranqo,Shravhos,Shravuth,Shreerhod,Shrethuh,Shriantieth,Shronqash,Shrovarhir,Shrozih,Siacaqoh,Siezosh,Siq'sha,Sirro,Sornosi,Srachussi,Szaca,Szacih,Szaqova,Szasu,Szazhilos,Szeerrud,Szeezsad,Szeknur,Szesir,Szezhirros,Szilshith,Szon'qol,Szornuq,Xeekke,Yeek'su,Yeeq'zox,Yeqil,Yeqroq,Yeveed,Yevied,Yicaveeh,Yirresh,Yisie,Yithik'thaih,Yorhaqshes,Zacheek'sa,Zakkasa,Zelraq,Zeqo,Zharuncho,Zhath'arhish,Zhavirrit,Zhazilraq,Zhazsachiel,Zhek'tha,Zhequ,Zhias'ted,Zhicat,Zhicur,Zhirhacil,Zhizri,Zhochizses,Ziarih,Zirnib"},
|
||||
{name: "Serpents", i: 41, min: 5, max: 11, d: "slrk", m: 0, b: "Aj'ha,Aj'i,Aj'tiss,Ajakess,Aksas,Aksiss,Al'en,An'jeshe,Apjige,Arkkess,Athaz,Atus,Azras,Caji,Cakrasar,Cal'arrun,Capji,Cathras,Cej'han,Ces,Cez'jenta,Cij'te,Cinash,Cizran,Coth'jus,Cothrash,Culzanek,Cunaless,Ej'tesh,Elzazash,Ergek,Eshjuk,Ethris,Gan'jas,Gapja,Gar'thituph,Gopjeguss,Gor'thesh,Gragishaph,Grar'theness,Grath'ji,Gressinas,Grolzesh,Grorjar,Grozrash,Guj'ika,Harji,Hej'hez,Herkush,Horgarrez,Illuph,Ipjar,Ithashin,Kaj'ess,Kar'kash,Kepjusha,Ki'kintus,Kissere,Koph,Kopjess,Kra'kasher,Krak,Krapjez,Krashjuless,Kraz'ji,Krirrigis,Krussin,Ma'lush,Mage,Maj'tak,Mal'a,Mapja,Mar'kash,Mar'kis,Marjin,Mas,Mathan,Men'jas,Meth'jaresh,Mij'hegak,Min'jash,Mith'jas,Monassu,Moss,Naj'hass,Najugash,Nak,Napjiph,Nar'ka,Nar'thuss,Narrusha,Nash,Nashjekez,Nataph,Nij'ass,Nij'tessiph,Nishjiss,Norkkuss,Nus,Olluruss,Or'thi,Or'thuss,Paj'a,Parkka,Pas,Pathujen,Paz'jaz,Pepjerras,Pirkkanar,Pituk,Porjunek,Pu'ke,Ragen,Ran'jess,Rargush,Razjuph,Rilzan,Riss,Rithruz,Rorgiss,Rossez,Rraj'asesh,Rraj'tass,Rrar'kess,Rrar'thuph,Rras,Rrazresh,Rrej'hish,Rrigelash,Rris,Rris,Rroksurrush,Rukrussush,Rurri,Russa,Ruth'jes,Sa'kitesh,Sar'thass,Sarjas,Sazjuzush,Ser'thez,Sezrass,Shajas,Shas,Shashja,Shass,Shetesh,Shijek,Shun'jaler,Shurjarri,Skaler,Skalla,Skallentas,Skaph,Skar'kerriz,Skath'jeruk,Sker'kalas,Skor,Skoz'ji,Sku'lu,Skuph,Skur'thur,Slalli,Slalt'har,Slelziress,Slil'ar,Sloz'jisa,Sojesh,Solle,Sorge,Sral'e,Sran'ji,Srapjess,Srar'thazur,Srash,Srath'jess,Srathrarre,Srerkkash,Srus,Sruss'tugeph,Sun,Suss'tir,Uzrash,Vargush,Vek,Vess'tu,Viph,Vult'ha,Vupjer,Vushjesash,Xagez,Xassa,Xulzessu,Zaj'tiss,Zan'jer,Zarriss,Zassegus,Zirres,Zsor,Zurjass"},
|
||||
// additional by Avengium:
|
||||
{name: "Levantine", i: 42, min: 4, max: 12, d: "ankprs", m: 0, b: "Adme,Adramet,Agadir,Akko,Akzib,Alimas,Alis-Ubbo,Alqosh,Amid,Ammon,Ampi,Amurru,Andarig,Anpa,Araden,Aram,Arwad,Ashkelon,Athar,Atiq,Aza,Azeka,Baalbek,Babel,Batrun,Beerot,Beersheba,Beit Shemesh,Berytus,Bet Agus,Bet Anya,Beth-Horon,Bethel,Bethlehem,Bethuel,Bet Nahrin,Bet Nohadra,Bet Zalin,Birmula,Biruta,Bit Agushi,Bitan,Bit Zamani,Cerne,Dammeseq,Darmsuq,Dor,Eddial,Eden Ekron,Elah,Emek,Emun,Ephratah,Eyn Ganim,Finike,Gades,Galatia,Gaza,Gebal,Gedera,Gerizzim,Gethsemane,Gibeon,Gilead,Gilgal,Golgotha,Goshen,Gytte,Hagalil,Haifa,Halab,Haqel Dma,Har Habayit,Har Nevo,Har Pisga,Havilah,Hazor,Hebron,Hormah,Iboshim,Iriho,Irinem,Irridu,Israel,Kadesh,Kanaan,Kapara,Karaly,Kart-Hadasht,Keret Chadeshet,Kernah,Kesed,Keysariya,Kfar,Kfar Nahum,Khalibon,Khalpe,Khamat,Kiryat,Kittim,Kurda,Lapethos,Larna,Lepqis,Lepriptza,Liksos,Lod,Luv,Malaka,Malet,Marat,Megido,Melitta,Merdin,Metsada,Mishmarot,Mitzrayim,Moab,Mopsos,Motye,Mukish,Nampigi,Nampigu,Natzrat,Nimrud,Nineveh,Nob,Nuhadra,Oea,Ofir,Oyat,Phineka,Phoenicus,Pleshet,Qart-Tubah Sarepta,Qatna,Rabat Amon,Rakkath,Ramat Aviv,Ramitha,Ramta,Rehovot,Reshef,Rushadir,Rushakad,Samrin,Sefarad,Sehyon,Sepat,Sexi,Sharon,Shechem,Shefelat,Shfanim,Shiloh,Shmaya,Shomron,Sidon,Sinay,Sis,Solki,Sur,Suria,Tabetu,Tadmur,Tarshish,Tartus,Teberya,Tefessedt,Tekoa,Teyman,Tinga,Tipasa,Tsabratan,Tur Abdin,Tzarfat,Tziyon,Tzor,Ugarit,Unubaal,Ureshlem,Urhay,Urushalim,Vaga,Yaffa,Yamhad,Yam hamelach,Yam Kineret,Yamutbal,Yathrib,Yaudi,Yavne,Yehuda,Yerushalayim,Yev,Yevus,Yizreel,Yurdnan,Zarefat,Zeboim,Zeurta,Zeytim,Zikhron,Zmurna"}
|
||||
];
|
||||
};
|
||||
|
||||
export {
|
||||
getBase,
|
||||
getCulture,
|
||||
getCultureShort,
|
||||
getBaseShort,
|
||||
getState,
|
||||
updateChain,
|
||||
clearChains,
|
||||
getNameBases,
|
||||
getMapName,
|
||||
calculateChain
|
||||
};
|
||||
94
procedural/src/engine/modules/ocean-layers.js
Normal file
94
procedural/src/engine/modules/ocean-layers.js
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
"use strict";
|
||||
|
||||
export function generateOceanLayers(grid, config, utils) {
|
||||
const { lineGen, clipPoly, round, rn, P } = utils;
|
||||
|
||||
if (config.outline === "none") return { layers: [] };
|
||||
|
||||
const cells = grid.cells;
|
||||
const pointsN = grid.cells.i.length;
|
||||
const vertices = grid.vertices;
|
||||
const limits = config.outline === "random" ? randomizeOutline(P) : config.outline.split(",").map(s => +s);
|
||||
|
||||
const chains = [];
|
||||
const opacity = rn(0.4 / limits.length, 2);
|
||||
const used = new Uint8Array(pointsN); // to detect already passed cells
|
||||
|
||||
for (const i of cells.i) {
|
||||
const t = cells.t[i];
|
||||
if (t > 0) continue;
|
||||
if (used[i] || !limits.includes(t)) continue;
|
||||
const start = findStart(i, t, cells, vertices, pointsN);
|
||||
if (!start) continue;
|
||||
used[i] = 1;
|
||||
const chain = connectVertices(start, t, cells, vertices, pointsN, used); // vertices chain to form a path
|
||||
if (chain.length < 4) continue;
|
||||
const relax = 1 + t * -2; // select only n-th point
|
||||
const relaxed = chain.filter((v, i) => !(i % relax) || vertices.c[v].some(c => c >= pointsN));
|
||||
if (relaxed.length < 4) continue;
|
||||
const points = clipPoly(
|
||||
relaxed.map(v => vertices.p[v]),
|
||||
1
|
||||
);
|
||||
chains.push([t, points]);
|
||||
}
|
||||
|
||||
const layers = [];
|
||||
for (const t of limits) {
|
||||
const layer = chains.filter(c => c[0] === t);
|
||||
const paths = layer.map(c => round(lineGen(c[1]))).filter(path => path);
|
||||
if (paths.length > 0) {
|
||||
layers.push({
|
||||
type: t,
|
||||
paths: paths,
|
||||
opacity: opacity
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return { layers };
|
||||
}
|
||||
|
||||
function randomizeOutline(P) {
|
||||
const limits = [];
|
||||
let odd = 0.2;
|
||||
for (let l = -9; l < 0; l++) {
|
||||
if (P(odd)) {
|
||||
odd = 0.2;
|
||||
limits.push(l);
|
||||
} else {
|
||||
odd *= 2;
|
||||
}
|
||||
}
|
||||
return limits;
|
||||
}
|
||||
|
||||
// find eligible cell vertex to start path detection
|
||||
function findStart(i, t, cells, vertices, pointsN) {
|
||||
if (cells.b[i]) return cells.v[i].find(v => vertices.c[v].some(c => c >= pointsN)); // map border cell
|
||||
return cells.v[i][cells.c[i].findIndex(c => cells.t[c] < t || !cells.t[c])];
|
||||
}
|
||||
|
||||
// connect vertices to chain
|
||||
function connectVertices(start, t, cells, vertices, pointsN, used) {
|
||||
const chain = []; // vertices chain to form a path
|
||||
for (let i = 0, current = start; i === 0 || (current !== start && i < 10000); i++) {
|
||||
const prev = chain[chain.length - 1]; // previous vertex in chain
|
||||
chain.push(current); // add current vertex to sequence
|
||||
const c = vertices.c[current]; // cells adjacent to vertex
|
||||
c.filter(c => cells.t[c] === t).forEach(c => (used[c] = 1));
|
||||
const v = vertices.v[current]; // neighboring vertices
|
||||
const c0 = !cells.t[c[0]] || cells.t[c[0]] === t - 1;
|
||||
const c1 = !cells.t[c[1]] || cells.t[c[1]] === t - 1;
|
||||
const c2 = !cells.t[c[2]] || cells.t[c[2]] === t - 1;
|
||||
if (v[0] !== undefined && v[0] !== prev && c0 !== c1) current = v[0];
|
||||
else if (v[1] !== undefined && v[1] !== prev && c1 !== c2) current = v[1];
|
||||
else if (v[2] !== undefined && v[2] !== prev && c0 !== c2) current = v[2];
|
||||
if (current === chain[chain.length - 1]) {
|
||||
console.error("Next vertex is not found");
|
||||
break;
|
||||
}
|
||||
}
|
||||
chain.push(chain[0]); // push first vertex as the last one
|
||||
return chain;
|
||||
}
|
||||
278
procedural/src/engine/modules/provinces-generator.js
Normal file
278
procedural/src/engine/modules/provinces-generator.js
Normal file
|
|
@ -0,0 +1,278 @@
|
|||
"use strict";
|
||||
|
||||
const forms = {
|
||||
Monarchy: {County: 22, Earldom: 6, Shire: 2, Landgrave: 2, Margrave: 2, Barony: 2, Captaincy: 1, Seneschalty: 1},
|
||||
Republic: {Province: 6, Department: 2, Governorate: 2, District: 1, Canton: 1, Prefecture: 1},
|
||||
Theocracy: {Parish: 3, Deanery: 1},
|
||||
Union: {Province: 1, State: 1, Canton: 1, Republic: 1, County: 1, Council: 1},
|
||||
Anarchy: {Council: 1, Commune: 1, Community: 1, Tribe: 1},
|
||||
Wild: {Territory: 10, Land: 5, Region: 2, Tribe: 1, Clan: 1, Dependency: 1, Area: 1}
|
||||
};
|
||||
|
||||
export const generate = (pack, config, utils, regenerate = false, regenerateLockedStates = false) => {
|
||||
const {
|
||||
TIME,
|
||||
generateSeed,
|
||||
aleaPRNG,
|
||||
gauss,
|
||||
P,
|
||||
Names,
|
||||
rw,
|
||||
getMixedColor,
|
||||
BurgsAndStates,
|
||||
COA,
|
||||
FlatQueue,
|
||||
d3,
|
||||
rand
|
||||
} = utils;
|
||||
|
||||
TIME && console.time("generateProvinces");
|
||||
const localSeed = regenerate ? generateSeed() : config.seed;
|
||||
Math.random = aleaPRNG(localSeed);
|
||||
|
||||
const {cells, states, burgs} = pack;
|
||||
const provinces = [0]; // 0 index is reserved for "no province"
|
||||
const provinceIds = new Uint16Array(cells.i.length);
|
||||
|
||||
const isProvinceLocked = province => province.lock || (!regenerateLockedStates && states[province.state]?.lock);
|
||||
const isProvinceCellLocked = cell => provinceIds[cell] && isProvinceLocked(provinces[provinceIds[cell]]);
|
||||
|
||||
if (regenerate) {
|
||||
pack.provinces.forEach(province => {
|
||||
if (!province.i || province.removed || !isProvinceLocked(province)) return;
|
||||
|
||||
const newId = provinces.length;
|
||||
for (const i of cells.i) {
|
||||
if (cells.province[i] === province.i) provinceIds[i] = newId;
|
||||
}
|
||||
|
||||
province.i = newId;
|
||||
provinces.push(province);
|
||||
});
|
||||
}
|
||||
|
||||
const provincesRatio = config.provincesRatio;
|
||||
const max = provincesRatio == 100 ? 1000 : gauss(20, 5, 5, 100) * provincesRatio ** 0.5; // max growth
|
||||
|
||||
// generate provinces for selected burgs
|
||||
states.forEach(s => {
|
||||
s.provinces = [];
|
||||
if (!s.i || s.removed) return;
|
||||
if (provinces.length) s.provinces = provinces.filter(p => p.state === s.i).map(p => p.i); // locked provinces ids
|
||||
if (s.lock && !regenerateLockedStates) return; // don't regenerate provinces of a locked state
|
||||
|
||||
const stateBurgs = burgs
|
||||
.filter(b => b.state === s.i && !b.removed && !provinceIds[b.cell])
|
||||
.sort((a, b) => b.population * gauss(1, 0.2, 0.5, 1.5, 3) - a.population)
|
||||
.sort((a, b) => b.capital - a.capital);
|
||||
if (stateBurgs.length < 2) return; // at least 2 provinces are required
|
||||
const provincesNumber = Math.max(Math.ceil((stateBurgs.length * provincesRatio) / 100), 2);
|
||||
|
||||
const form = Object.assign({}, forms[s.form]);
|
||||
|
||||
for (let i = 0; i < provincesNumber; i++) {
|
||||
const provinceId = provinces.length;
|
||||
const center = stateBurgs[i].cell;
|
||||
const burg = stateBurgs[i].i;
|
||||
const c = stateBurgs[i].culture;
|
||||
const nameByBurg = P(0.5);
|
||||
const name = nameByBurg ? stateBurgs[i].name : Names.getState(Names.getCultureShort(c), c);
|
||||
const formName = rw(form);
|
||||
form[formName] += 10;
|
||||
const fullName = name + " " + formName;
|
||||
const color = getMixedColor(s.color);
|
||||
const kinship = nameByBurg ? 0.8 : 0.4;
|
||||
const type = BurgsAndStates.getType(center, burg.port);
|
||||
const coa = COA.generate(stateBurgs[i].coa, kinship, null, type);
|
||||
coa.shield = COA.getShield(c, s.i);
|
||||
|
||||
s.provinces.push(provinceId);
|
||||
provinces.push({i: provinceId, state: s.i, center, burg, name, formName, fullName, color, coa});
|
||||
}
|
||||
});
|
||||
|
||||
// expand generated provinces
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
provinces.forEach(p => {
|
||||
if (!p.i || p.removed || isProvinceLocked(p)) return;
|
||||
provinceIds[p.center] = p.i;
|
||||
queue.push({e: p.center, province: p.i, state: p.state, p: 0}, 0);
|
||||
cost[p.center] = 1;
|
||||
});
|
||||
|
||||
while (queue.length) {
|
||||
const {e, p, province, state} = queue.pop();
|
||||
|
||||
cells.c[e].forEach(e => {
|
||||
if (isProvinceCellLocked(e)) return; // do not overwrite cell of locked provinces
|
||||
|
||||
const land = cells.h[e] >= 20;
|
||||
if (!land && !cells.t[e]) return; // cannot pass deep ocean
|
||||
if (land && cells.state[e] !== state) return;
|
||||
const evevation = cells.h[e] >= 70 ? 100 : cells.h[e] >= 50 ? 30 : cells.h[e] >= 20 ? 10 : 100;
|
||||
const totalCost = p + evevation;
|
||||
|
||||
if (totalCost > max) return;
|
||||
if (!cost[e] || totalCost < cost[e]) {
|
||||
if (land) provinceIds[e] = province; // assign province to a cell
|
||||
cost[e] = totalCost;
|
||||
queue.push({e, province, state, p: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// justify provinces shapes a bit
|
||||
for (const i of cells.i) {
|
||||
if (cells.burg[i]) continue; // do not overwrite burgs
|
||||
if (isProvinceCellLocked(i)) continue; // do not overwrite cell of locked provinces
|
||||
|
||||
const neibs = cells.c[i]
|
||||
.filter(c => cells.state[c] === cells.state[i] && !isProvinceCellLocked(c))
|
||||
.map(c => provinceIds[c]);
|
||||
const adversaries = neibs.filter(c => c !== provinceIds[i]);
|
||||
if (adversaries.length < 2) continue;
|
||||
|
||||
const buddies = neibs.filter(c => c === provinceIds[i]).length;
|
||||
if (buddies.length > 2) continue;
|
||||
|
||||
const competitors = adversaries.map(p => adversaries.reduce((s, v) => (v === p ? s + 1 : s), 0));
|
||||
const max = d3.max(competitors);
|
||||
if (buddies >= max) continue;
|
||||
|
||||
provinceIds[i] = adversaries[competitors.indexOf(max)];
|
||||
}
|
||||
|
||||
// add "wild" provinces if some cells don't have a province assigned
|
||||
const noProvince = Array.from(cells.i).filter(i => cells.state[i] && !provinceIds[i]); // cells without province assigned
|
||||
states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
if (s.lock && !regenerateLockedStates) return;
|
||||
if (!s.provinces.length) return;
|
||||
|
||||
const coreProvinceNames = s.provinces.map(p => provinces[p]?.name);
|
||||
const colonyNamePool = [s.name, ...coreProvinceNames].filter(name => name && !/new/i.test(name));
|
||||
const getColonyName = () => {
|
||||
if (colonyNamePool.length < 1) return null;
|
||||
|
||||
const index = rand(colonyNamePool.length - 1);
|
||||
const spliced = colonyNamePool.splice(index, 1);
|
||||
return spliced[0] ? `New ${spliced[0]}` : null;
|
||||
};
|
||||
|
||||
let stateNoProvince = noProvince.filter(i => cells.state[i] === s.i && !provinceIds[i]);
|
||||
while (stateNoProvince.length) {
|
||||
// add new province
|
||||
const provinceId = provinces.length;
|
||||
const burgCell = stateNoProvince.find(i => cells.burg[i]);
|
||||
const center = burgCell ? burgCell : stateNoProvince[0];
|
||||
const burg = burgCell ? cells.burg[burgCell] : 0;
|
||||
provinceIds[center] = provinceId;
|
||||
|
||||
// expand province
|
||||
const cost = [];
|
||||
cost[center] = 1;
|
||||
queue.push({e: center, p: 0}, 0);
|
||||
while (queue.length) {
|
||||
const {e, p} = queue.pop();
|
||||
|
||||
cells.c[e].forEach(nextCellId => {
|
||||
if (provinceIds[nextCellId]) return;
|
||||
const land = cells.h[nextCellId] >= 20;
|
||||
if (cells.state[nextCellId] && cells.state[nextCellId] !== s.i) return;
|
||||
const ter = land ? (cells.state[nextCellId] === s.i ? 3 : 20) : cells.t[nextCellId] ? 10 : 30;
|
||||
const totalCost = p + ter;
|
||||
|
||||
if (totalCost > max) return;
|
||||
if (!cost[nextCellId] || totalCost < cost[nextCellId]) {
|
||||
if (land && cells.state[nextCellId] === s.i) provinceIds[nextCellId] = provinceId; // assign province to a cell
|
||||
cost[nextCellId] = totalCost;
|
||||
queue.push({e: nextCellId, p: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// generate "wild" province name
|
||||
const c = cells.culture[center];
|
||||
const f = pack.features[cells.f[center]];
|
||||
const color = getMixedColor(s.color);
|
||||
|
||||
const provCells = stateNoProvince.filter(i => provinceIds[i] === provinceId);
|
||||
const singleIsle = provCells.length === f.cells && !provCells.find(i => cells.f[i] !== f.i);
|
||||
const isleGroup = !singleIsle && !provCells.find(i => pack.features[cells.f[i]].group !== "isle");
|
||||
const colony = !singleIsle && !isleGroup && P(0.5) && !isPassable(s.center, center);
|
||||
|
||||
const name = (() => {
|
||||
const colonyName = colony && P(0.8) && getColonyName();
|
||||
if (colonyName) return colonyName;
|
||||
if (burgCell && P(0.5)) return burgs[burg].name;
|
||||
return Names.getState(Names.getCultureShort(c), c);
|
||||
})();
|
||||
|
||||
const formName = (() => {
|
||||
if (singleIsle) return "Island";
|
||||
if (isleGroup) return "Islands";
|
||||
if (colony) return "Colony";
|
||||
return rw(forms["Wild"]);
|
||||
})();
|
||||
|
||||
const fullName = name + " " + formName;
|
||||
|
||||
const dominion = colony ? P(0.95) : singleIsle || isleGroup ? P(0.7) : P(0.3);
|
||||
const kinship = dominion ? 0 : 0.4;
|
||||
const type = BurgsAndStates.getType(center, burgs[burg]?.port);
|
||||
const coa = COA.generate(s.coa, kinship, dominion, type);
|
||||
coa.shield = COA.getShield(c, s.i);
|
||||
|
||||
provinces.push({i: provinceId, state: s.i, center, burg, name, formName, fullName, color, coa});
|
||||
s.provinces.push(provinceId);
|
||||
|
||||
// check if there is a land way within the same state between two cells
|
||||
function isPassable(from, to) {
|
||||
if (cells.f[from] !== cells.f[to]) return false; // on different islands
|
||||
const passableQueue = [from],
|
||||
used = new Uint8Array(cells.i.length),
|
||||
state = cells.state[from];
|
||||
while (passableQueue.length) {
|
||||
const current = passableQueue.pop();
|
||||
if (current === to) return true; // way is found
|
||||
cells.c[current].forEach(c => {
|
||||
if (used[c] || cells.h[c] < 20 || cells.state[c] !== state) return;
|
||||
passableQueue.push(c);
|
||||
used[c] = 1;
|
||||
});
|
||||
}
|
||||
return false; // way is not found
|
||||
}
|
||||
|
||||
// re-check
|
||||
stateNoProvince = noProvince.filter(i => cells.state[i] === s.i && !provinceIds[i]);
|
||||
}
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("generateProvinces");
|
||||
|
||||
return {
|
||||
provinces,
|
||||
provinceIds
|
||||
};
|
||||
};
|
||||
|
||||
// calculate pole of inaccessibility for each province
|
||||
export const getPoles = (pack, utils) => {
|
||||
const { getPolesOfInaccessibility } = utils;
|
||||
|
||||
const getType = cellId => pack.cells.province[cellId];
|
||||
const poles = getPolesOfInaccessibility(pack, getType);
|
||||
|
||||
const updatedProvinces = pack.provinces.map(province => {
|
||||
if (!province.i || province.removed) return province;
|
||||
return {
|
||||
...province,
|
||||
pole: poles[province.i] || [0, 0]
|
||||
};
|
||||
});
|
||||
|
||||
return updatedProvinces;
|
||||
};
|
||||
973
procedural/src/engine/modules/religions-generator.js
Normal file
973
procedural/src/engine/modules/religions-generator.js
Normal file
|
|
@ -0,0 +1,973 @@
|
|||
"use strict";
|
||||
|
||||
// name generation approach and relative chance to be selected
|
||||
const approach = {
|
||||
Number: 1,
|
||||
Being: 3,
|
||||
Adjective: 5,
|
||||
"Color + Animal": 5,
|
||||
"Adjective + Animal": 5,
|
||||
"Adjective + Being": 5,
|
||||
"Adjective + Genitive": 1,
|
||||
"Color + Being": 3,
|
||||
"Color + Genitive": 3,
|
||||
"Being + of + Genitive": 2,
|
||||
"Being + of the + Genitive": 1,
|
||||
"Animal + of + Genitive": 1,
|
||||
"Adjective + Being + of + Genitive": 2,
|
||||
"Adjective + Animal + of + Genitive": 2
|
||||
};
|
||||
|
||||
// turn weighted array into simple array
|
||||
const approaches = [];
|
||||
for (const a in approach) {
|
||||
for (let j = 0; j < approach[a]; j++) {
|
||||
approaches.push(a);
|
||||
}
|
||||
}
|
||||
|
||||
const base = {
|
||||
number: ["One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve"],
|
||||
being: [
|
||||
"Ancestor",
|
||||
"Ancient",
|
||||
"Avatar",
|
||||
"Brother",
|
||||
"Champion",
|
||||
"Chief",
|
||||
"Council",
|
||||
"Creator",
|
||||
"Deity",
|
||||
"Divine One",
|
||||
"Elder",
|
||||
"Enlightened Being",
|
||||
"Father",
|
||||
"Forebear",
|
||||
"Forefather",
|
||||
"Giver",
|
||||
"God",
|
||||
"Goddess",
|
||||
"Guardian",
|
||||
"Guide",
|
||||
"Hierach",
|
||||
"Lady",
|
||||
"Lord",
|
||||
"Maker",
|
||||
"Master",
|
||||
"Mother",
|
||||
"Numen",
|
||||
"Oracle",
|
||||
"Overlord",
|
||||
"Protector",
|
||||
"Reaper",
|
||||
"Ruler",
|
||||
"Sage",
|
||||
"Seer",
|
||||
"Sister",
|
||||
"Spirit",
|
||||
"Supreme Being",
|
||||
"Transcendent",
|
||||
"Virgin"
|
||||
],
|
||||
animal: [
|
||||
"Antelope",
|
||||
"Ape",
|
||||
"Badger",
|
||||
"Basilisk",
|
||||
"Bear",
|
||||
"Beaver",
|
||||
"Bison",
|
||||
"Boar",
|
||||
"Buffalo",
|
||||
"Camel",
|
||||
"Cat",
|
||||
"Centaur",
|
||||
"Cerberus",
|
||||
"Chimera",
|
||||
"Cobra",
|
||||
"Cockatrice",
|
||||
"Crane",
|
||||
"Crocodile",
|
||||
"Crow",
|
||||
"Cyclope",
|
||||
"Deer",
|
||||
"Dog",
|
||||
"Direwolf",
|
||||
"Drake",
|
||||
"Dragon",
|
||||
"Eagle",
|
||||
"Elephant",
|
||||
"Elk",
|
||||
"Falcon",
|
||||
"Fox",
|
||||
"Goat",
|
||||
"Goose",
|
||||
"Gorgon",
|
||||
"Gryphon",
|
||||
"Hare",
|
||||
"Hawk",
|
||||
"Heron",
|
||||
"Hippogriff",
|
||||
"Horse",
|
||||
"Hound",
|
||||
"Hyena",
|
||||
"Ibis",
|
||||
"Jackal",
|
||||
"Jaguar",
|
||||
"Kitsune",
|
||||
"Kraken",
|
||||
"Lark",
|
||||
"Leopard",
|
||||
"Lion",
|
||||
"Manticore",
|
||||
"Mantis",
|
||||
"Marten",
|
||||
"Minotaur",
|
||||
"Moose",
|
||||
"Mule",
|
||||
"Narwhal",
|
||||
"Owl",
|
||||
"Ox",
|
||||
"Panther",
|
||||
"Pegasus",
|
||||
"Phoenix",
|
||||
"Python",
|
||||
"Rat",
|
||||
"Raven",
|
||||
"Roc",
|
||||
"Rook",
|
||||
"Scorpion",
|
||||
"Serpent",
|
||||
"Shark",
|
||||
"Sheep",
|
||||
"Snake",
|
||||
"Sphinx",
|
||||
"Spider",
|
||||
"Swan",
|
||||
"Tiger",
|
||||
"Turtle",
|
||||
"Unicorn",
|
||||
"Viper",
|
||||
"Vulture",
|
||||
"Walrus",
|
||||
"Wolf",
|
||||
"Wolverine",
|
||||
"Worm",
|
||||
"Wyvern",
|
||||
"Yeti"
|
||||
],
|
||||
adjective: [
|
||||
"Aggressive",
|
||||
"Almighty",
|
||||
"Ancient",
|
||||
"Beautiful",
|
||||
"Benevolent",
|
||||
"Big",
|
||||
"Blind",
|
||||
"Blond",
|
||||
"Bloody",
|
||||
"Brave",
|
||||
"Broken",
|
||||
"Brutal",
|
||||
"Burning",
|
||||
"Calm",
|
||||
"Celestial",
|
||||
"Cheerful",
|
||||
"Crazy",
|
||||
"Cruel",
|
||||
"Dead",
|
||||
"Deadly",
|
||||
"Devastating",
|
||||
"Distant",
|
||||
"Disturbing",
|
||||
"Divine",
|
||||
"Dying",
|
||||
"Eternal",
|
||||
"Ethernal",
|
||||
"Empyreal",
|
||||
"Enigmatic",
|
||||
"Enlightened",
|
||||
"Evil",
|
||||
"Explicit",
|
||||
"Fair",
|
||||
"Far",
|
||||
"Fat",
|
||||
"Fatal",
|
||||
"Favorable",
|
||||
"Flying",
|
||||
"Friendly",
|
||||
"Frozen",
|
||||
"Giant",
|
||||
"Good",
|
||||
"Grateful",
|
||||
"Great",
|
||||
"Happy",
|
||||
"High",
|
||||
"Holy",
|
||||
"Honest",
|
||||
"Huge",
|
||||
"Hungry",
|
||||
"Illustrious",
|
||||
"Immutable",
|
||||
"Ineffable",
|
||||
"Infallible",
|
||||
"Inherent",
|
||||
"Last",
|
||||
"Latter",
|
||||
"Lost",
|
||||
"Loud",
|
||||
"Lucky",
|
||||
"Mad",
|
||||
"Magical",
|
||||
"Main",
|
||||
"Major",
|
||||
"Marine",
|
||||
"Mythical",
|
||||
"Mystical",
|
||||
"Naval",
|
||||
"New",
|
||||
"Noble",
|
||||
"Old",
|
||||
"Otherworldly",
|
||||
"Patient",
|
||||
"Peaceful",
|
||||
"Pregnant",
|
||||
"Prime",
|
||||
"Proud",
|
||||
"Pure",
|
||||
"Radiant",
|
||||
"Resplendent",
|
||||
"Sacred",
|
||||
"Sacrosanct",
|
||||
"Sad",
|
||||
"Scary",
|
||||
"Secret",
|
||||
"Selected",
|
||||
"Serene",
|
||||
"Severe",
|
||||
"Silent",
|
||||
"Sleeping",
|
||||
"Slumbering",
|
||||
"Sovereign",
|
||||
"Strong",
|
||||
"Sunny",
|
||||
"Superior",
|
||||
"Supernatural",
|
||||
"Sustainable",
|
||||
"Transcendent",
|
||||
"Transcendental",
|
||||
"Troubled",
|
||||
"Unearthly",
|
||||
"Unfathomable",
|
||||
"Unhappy",
|
||||
"Unknown",
|
||||
"Unseen",
|
||||
"Waking",
|
||||
"Wild",
|
||||
"Wise",
|
||||
"Worried",
|
||||
"Young"
|
||||
],
|
||||
genitive: [
|
||||
"Cold",
|
||||
"Day",
|
||||
"Death",
|
||||
"Doom",
|
||||
"Fate",
|
||||
"Fire",
|
||||
"Fog",
|
||||
"Frost",
|
||||
"Gates",
|
||||
"Heaven",
|
||||
"Home",
|
||||
"Ice",
|
||||
"Justice",
|
||||
"Life",
|
||||
"Light",
|
||||
"Lightning",
|
||||
"Love",
|
||||
"Nature",
|
||||
"Night",
|
||||
"Pain",
|
||||
"Snow",
|
||||
"Springs",
|
||||
"Summer",
|
||||
"Thunder",
|
||||
"Time",
|
||||
"Victory",
|
||||
"War",
|
||||
"Winter"
|
||||
],
|
||||
theGenitive: [
|
||||
"Abyss",
|
||||
"Blood",
|
||||
"Dawn",
|
||||
"Earth",
|
||||
"East",
|
||||
"Eclipse",
|
||||
"Fall",
|
||||
"Harvest",
|
||||
"Moon",
|
||||
"North",
|
||||
"Peak",
|
||||
"Rainbow",
|
||||
"Sea",
|
||||
"Sky",
|
||||
"South",
|
||||
"Stars",
|
||||
"Storm",
|
||||
"Sun",
|
||||
"Tree",
|
||||
"Underworld",
|
||||
"West",
|
||||
"Wild",
|
||||
"Word",
|
||||
"World"
|
||||
],
|
||||
color: [
|
||||
"Amber",
|
||||
"Black",
|
||||
"Blue",
|
||||
"Bright",
|
||||
"Bronze",
|
||||
"Brown",
|
||||
"Coral",
|
||||
"Crimson",
|
||||
"Dark",
|
||||
"Emerald",
|
||||
"Golden",
|
||||
"Green",
|
||||
"Grey",
|
||||
"Indigo",
|
||||
"Lavender",
|
||||
"Light",
|
||||
"Magenta",
|
||||
"Maroon",
|
||||
"Orange",
|
||||
"Pink",
|
||||
"Plum",
|
||||
"Purple",
|
||||
"Red",
|
||||
"Ruby",
|
||||
"Sapphire",
|
||||
"Teal",
|
||||
"Turquoise",
|
||||
"White",
|
||||
"Yellow"
|
||||
]
|
||||
};
|
||||
|
||||
const forms = {
|
||||
Folk: {
|
||||
Shamanism: 4,
|
||||
Animism: 4,
|
||||
Polytheism: 4,
|
||||
"Ancestor Worship": 2,
|
||||
"Nature Worship": 1,
|
||||
Totemism: 1
|
||||
},
|
||||
Organized: {
|
||||
Polytheism: 7,
|
||||
Monotheism: 7,
|
||||
Dualism: 3,
|
||||
Pantheism: 2,
|
||||
"Non-theism": 2
|
||||
},
|
||||
Cult: {
|
||||
Cult: 5,
|
||||
"Dark Cult": 5,
|
||||
Sect: 1
|
||||
},
|
||||
Heresy: {
|
||||
Heresy: 1
|
||||
}
|
||||
};
|
||||
|
||||
const namingMethods = {
|
||||
Folk: {
|
||||
"Culture + type": 1
|
||||
},
|
||||
|
||||
Organized: {
|
||||
"Random + type": 3,
|
||||
"Random + ism": 1,
|
||||
"Supreme + ism": 5,
|
||||
"Faith of + Supreme": 5,
|
||||
"Place + ism": 1,
|
||||
"Culture + ism": 2,
|
||||
"Place + ian + type": 6,
|
||||
"Culture + type": 4
|
||||
},
|
||||
|
||||
Cult: {
|
||||
"Burg + ian + type": 2,
|
||||
"Random + ian + type": 1,
|
||||
"Type + of the + meaning": 2
|
||||
},
|
||||
|
||||
Heresy: {
|
||||
"Burg + ian + type": 3,
|
||||
"Random + ism": 3,
|
||||
"Random + ian + type": 2,
|
||||
"Type + of the + meaning": 1
|
||||
}
|
||||
};
|
||||
|
||||
const types = {
|
||||
Shamanism: {Beliefs: 3, Shamanism: 2, Druidism: 1, Spirits: 1},
|
||||
Animism: {Spirits: 3, Beliefs: 1},
|
||||
Polytheism: {Deities: 3, Faith: 1, Gods: 1, Pantheon: 1},
|
||||
"Ancestor Worship": {Beliefs: 1, Forefathers: 2, Ancestors: 2},
|
||||
"Nature Worship": {Beliefs: 3, Druids: 1},
|
||||
Totemism: {Beliefs: 2, Totems: 2, Idols: 1},
|
||||
|
||||
Monotheism: {Religion: 2, Church: 3, Faith: 1},
|
||||
Dualism: {Religion: 3, Faith: 1, Cult: 1},
|
||||
Pantheism: {Religion: 1, Faith: 1},
|
||||
"Non-theism": {Beliefs: 3, Spirits: 1},
|
||||
|
||||
Cult: {Cult: 4, Sect: 2, Arcanum: 1, Order: 1, Worship: 1},
|
||||
"Dark Cult": {Cult: 2, Blasphemy: 1, Circle: 1, Coven: 1, Idols: 1, Occultism: 1},
|
||||
Sect: {Sect: 3, Society: 1},
|
||||
|
||||
Heresy: {
|
||||
Heresy: 3,
|
||||
Sect: 2,
|
||||
Apostates: 1,
|
||||
Brotherhood: 1,
|
||||
Circle: 1,
|
||||
Dissent: 1,
|
||||
Dissenters: 1,
|
||||
Iconoclasm: 1,
|
||||
Schism: 1,
|
||||
Society: 1
|
||||
}
|
||||
};
|
||||
|
||||
const expansionismMap = {
|
||||
Folk: () => 0,
|
||||
Organized: (utils) => utils.gauss(5, 3, 0, 10, 1),
|
||||
Cult: (utils) => utils.gauss(0.5, 0.5, 0, 5, 1),
|
||||
Heresy: (utils) => utils.gauss(1, 0.5, 0, 5, 1)
|
||||
};
|
||||
|
||||
export function generate(pack, grid, config, utils) {
|
||||
const {TIME} = utils;
|
||||
TIME && console.time("generateReligions");
|
||||
const lockedReligions = pack.religions?.filter(r => r.i && r.lock && !r.removed) || [];
|
||||
|
||||
const folkReligions = generateFolkReligions(pack, utils);
|
||||
const organizedReligions = generateOrganizedReligions(pack, grid, config.religionsNumber, lockedReligions, utils);
|
||||
|
||||
const namedReligions = specifyReligions(pack, [...folkReligions, ...organizedReligions], utils);
|
||||
const indexedReligions = combineReligions(namedReligions, lockedReligions, utils);
|
||||
const religionIds = expandReligions(pack, grid, indexedReligions, config, utils);
|
||||
const religions = defineOrigins(pack, religionIds, indexedReligions, utils);
|
||||
|
||||
const newPack = {
|
||||
...pack,
|
||||
religions: religions,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
religion: religionIds
|
||||
}
|
||||
};
|
||||
|
||||
const finalPack = checkCenters(newPack);
|
||||
|
||||
TIME && console.timeEnd("generateReligions");
|
||||
return finalPack;
|
||||
}
|
||||
|
||||
function generateFolkReligions(pack, utils) {
|
||||
const {rw} = utils;
|
||||
return pack.cultures
|
||||
.filter(c => c.i && !c.removed)
|
||||
.map(culture => ({type: "Folk", form: rw(forms.Folk), culture: culture.i, center: culture.center}));
|
||||
}
|
||||
|
||||
function generateOrganizedReligions(pack, grid, desiredReligionNumber, lockedReligions, utils) {
|
||||
const {rand, rw, d3, WARN} = utils;
|
||||
const {graphWidth, graphHeight} = grid;
|
||||
const cells = pack.cells;
|
||||
const lockedReligionCount = lockedReligions.filter(({type}) => type !== "Folk").length || 0;
|
||||
const requiredReligionsNumber = desiredReligionNumber - lockedReligionCount;
|
||||
if (requiredReligionsNumber < 1) return [];
|
||||
|
||||
const candidateCells = getCandidateCells();
|
||||
const religionCores = placeReligions();
|
||||
|
||||
const cultsCount = Math.floor((rand(1, 4) / 10) * religionCores.length); // 10-40%
|
||||
const heresiesCount = Math.floor((rand(0, 3) / 10) * religionCores.length); // 0-30%
|
||||
const organizedCount = religionCores.length - cultsCount - heresiesCount;
|
||||
|
||||
const getType = index => {
|
||||
if (index < organizedCount) return "Organized";
|
||||
if (index < organizedCount + cultsCount) return "Cult";
|
||||
return "Heresy";
|
||||
};
|
||||
|
||||
return religionCores.map((cellId, index) => {
|
||||
const type = getType(index);
|
||||
const form = rw(forms[type]);
|
||||
const cultureId = cells.culture[cellId];
|
||||
|
||||
return {type, form, culture: cultureId, center: cellId};
|
||||
});
|
||||
|
||||
function placeReligions() {
|
||||
const religionCells = [];
|
||||
const religionsTree = d3.quadtree();
|
||||
|
||||
// pre-populate with locked centers
|
||||
lockedReligions.forEach(({center}) => religionsTree.add(cells.p[center]));
|
||||
|
||||
// min distance between religion inceptions
|
||||
const spacing = (graphWidth + graphHeight) / 2 / desiredReligionNumber;
|
||||
|
||||
for (const cellId of candidateCells) {
|
||||
const [x, y] = cells.p[cellId];
|
||||
|
||||
if (religionsTree.find(x, y, spacing) === undefined) {
|
||||
religionCells.push(cellId);
|
||||
religionsTree.add([x, y]);
|
||||
|
||||
if (religionCells.length === requiredReligionsNumber) return religionCells;
|
||||
}
|
||||
}
|
||||
|
||||
WARN && console.warn(`Placed only ${religionCells.length} of ${requiredReligionsNumber} religions`);
|
||||
return religionCells;
|
||||
}
|
||||
|
||||
function getCandidateCells() {
|
||||
const validBurgs = pack.burgs.filter(b => b.i && !b.removed);
|
||||
|
||||
if (validBurgs.length >= requiredReligionsNumber)
|
||||
return validBurgs.sort((a, b) => b.population - a.population).map(burg => burg.cell);
|
||||
return cells.i.filter(i => cells.s[i] > 2).sort((a, b) => cells.s[b] - cells.s[a]);
|
||||
}
|
||||
}
|
||||
|
||||
function specifyReligions(pack, newReligions, utils) {
|
||||
const {getRandomColor, getMixedColor} = utils;
|
||||
const {cells, cultures} = pack;
|
||||
|
||||
const rawReligions = newReligions.map(({type, form, culture: cultureId, center}) => {
|
||||
const supreme = getDeityName(cultureId, utils);
|
||||
const deity = form === "Non-theism" || form === "Animism" ? null : supreme;
|
||||
|
||||
const stateId = cells.state[center];
|
||||
|
||||
let [name, expansion] = generateReligionName(pack, type, form, supreme, center, utils);
|
||||
if (expansion === "state" && !stateId) expansion = "global";
|
||||
|
||||
const expansionism = expansionismMap[type](utils);
|
||||
const color = getReligionColor(cultures[cultureId], type);
|
||||
|
||||
return {name, type, form, culture: cultureId, center, deity, expansion, expansionism, color};
|
||||
});
|
||||
|
||||
return rawReligions;
|
||||
|
||||
function getReligionColor(culture, type) {
|
||||
if (!culture.i) return getRandomColor();
|
||||
|
||||
if (type === "Folk") return culture.color;
|
||||
if (type === "Heresy") return getMixedColor(culture.color, 0.35, 0.2);
|
||||
if (type === "Cult") return getMixedColor(culture.color, 0.5, 0);
|
||||
return getMixedColor(culture.color, 0.25, 0.4);
|
||||
}
|
||||
}
|
||||
|
||||
// indexes, conditionally renames, and abbreviates religions
|
||||
function combineReligions(namedReligions, lockedReligions, utils) {
|
||||
const {abbreviate} = utils;
|
||||
const indexedReligions = [{name: "No religion", i: 0}];
|
||||
|
||||
const {lockedReligionQueue, highestLockedIndex, codes, numberLockedFolk} = parseLockedReligions();
|
||||
const maxIndex = Math.max(
|
||||
highestLockedIndex,
|
||||
namedReligions.length + lockedReligions.length + 1 - numberLockedFolk
|
||||
);
|
||||
|
||||
for (let index = 1, progress = 0; index < maxIndex; index = indexedReligions.length) {
|
||||
// place locked religion back at its old index
|
||||
if (index === lockedReligionQueue[0]?.i) {
|
||||
const nextReligion = lockedReligionQueue.shift();
|
||||
indexedReligions.push(nextReligion);
|
||||
continue;
|
||||
}
|
||||
|
||||
// slot the new religions
|
||||
if (progress < namedReligions.length) {
|
||||
const nextReligion = namedReligions[progress];
|
||||
progress++;
|
||||
|
||||
if (
|
||||
nextReligion.type === "Folk" &&
|
||||
lockedReligions.some(({type, culture}) => type === "Folk" && culture === nextReligion.culture)
|
||||
)
|
||||
continue; // when there is a locked Folk religion for this culture discard duplicate
|
||||
|
||||
const newName = renameOld(nextReligion);
|
||||
const code = abbreviate(newName, codes);
|
||||
codes.push(code);
|
||||
indexedReligions.push({...nextReligion, i: index, name: newName, code});
|
||||
continue;
|
||||
}
|
||||
|
||||
indexedReligions.push({i: index, type: "Folk", culture: 0, name: "Removed religion", removed: true});
|
||||
}
|
||||
return indexedReligions;
|
||||
|
||||
function parseLockedReligions() {
|
||||
// copy and sort the locked religions list
|
||||
const lockedReligionQueue = lockedReligions
|
||||
.map(religion => {
|
||||
// and filter their origins to locked religions
|
||||
let newOrigin = religion.origins.filter(n => lockedReligions.some(({i: index}) => index === n));
|
||||
if (newOrigin === []) newOrigin = [0];
|
||||
return {...religion, origins: newOrigin};
|
||||
})
|
||||
.sort((a, b) => a.i - b.i);
|
||||
|
||||
const highestLockedIndex = Math.max(...lockedReligions.map(r => r.i));
|
||||
const codes = lockedReligions.length > 0 ? lockedReligions.map(r => r.code) : [];
|
||||
const numberLockedFolk = lockedReligions.filter(({type}) => type === "Folk").length;
|
||||
|
||||
return {lockedReligionQueue, highestLockedIndex, codes, numberLockedFolk};
|
||||
}
|
||||
|
||||
// prepend 'Old' to names of folk religions which have organized competitors
|
||||
function renameOld({name, type, culture: cultureId}) {
|
||||
if (type !== "Folk") return name;
|
||||
|
||||
const haveOrganized =
|
||||
namedReligions.some(
|
||||
({type, culture, expansion}) => culture === cultureId && type === "Organized" && expansion === "culture"
|
||||
) ||
|
||||
lockedReligions.some(
|
||||
({type, culture, expansion}) => culture === cultureId && type === "Organized" && expansion === "culture"
|
||||
);
|
||||
if (haveOrganized && name.slice(0, 3) !== "Old") return `Old ${name}`;
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
// finally generate and stores origins trees
|
||||
function defineOrigins(pack, religionIds, indexedReligions, utils) {
|
||||
const {each} = utils;
|
||||
const religionOriginsParamsMap = {
|
||||
Organized: {clusterSize: 100, maxReligions: 2},
|
||||
Cult: {clusterSize: 50, maxReligions: 3},
|
||||
Heresy: {clusterSize: 50, maxReligions: 4}
|
||||
};
|
||||
|
||||
const origins = indexedReligions.map(({i, type, culture: cultureId, expansion, center}) => {
|
||||
if (i === 0) return null; // no religion
|
||||
if (type === "Folk") return [0]; // folk religions originate from its parent culture only
|
||||
|
||||
const folkReligion = indexedReligions.find(({culture, type}) => type === "Folk" && culture === cultureId);
|
||||
const isFolkBased = folkReligion && cultureId && expansion === "culture" && each(2)(center);
|
||||
if (isFolkBased) return [folkReligion.i];
|
||||
|
||||
const {clusterSize, maxReligions} = religionOriginsParamsMap[type];
|
||||
const fallbackOrigin = folkReligion?.i || 0;
|
||||
return getReligionsInRadius(pack.cells.c, center, religionIds, i, clusterSize, maxReligions, fallbackOrigin);
|
||||
});
|
||||
|
||||
return indexedReligions.map((religion, index) => ({...religion, origins: origins[index]}));
|
||||
}
|
||||
|
||||
function getReligionsInRadius(neighbors, center, religionIds, religionId, clusterSize, maxReligions, fallbackOrigin) {
|
||||
const foundReligions = new Set();
|
||||
const queue = [center];
|
||||
const checked = {};
|
||||
|
||||
for (let size = 0; queue.length && size < clusterSize; size++) {
|
||||
const cellId = queue.shift();
|
||||
checked[cellId] = true;
|
||||
|
||||
for (const neibId of neighbors[cellId]) {
|
||||
if (checked[neibId]) continue;
|
||||
checked[neibId] = true;
|
||||
|
||||
const neibReligion = religionIds[neibId];
|
||||
if (neibReligion && neibReligion < religionId) foundReligions.add(neibReligion);
|
||||
if (foundReligions.size >= maxReligions) return [...foundReligions];
|
||||
queue.push(neibId);
|
||||
}
|
||||
}
|
||||
|
||||
return foundReligions.size ? [...foundReligions] : [fallbackOrigin];
|
||||
}
|
||||
|
||||
// growth algorithm to assign cells to religions
|
||||
function expandReligions(pack, grid, religions, config, utils) {
|
||||
const {FlatQueue, isWater} = utils;
|
||||
const {cells, routes} = pack;
|
||||
const religionIds = spreadFolkReligions(religions);
|
||||
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
// limit cost for organized religions growth
|
||||
const maxExpansionCost = (cells.i.length / 20) * config.growthRate;
|
||||
|
||||
religions
|
||||
.filter(r => r.i && !r.lock && r.type !== "Folk" && !r.removed)
|
||||
.forEach(r => {
|
||||
religionIds[r.center] = r.i;
|
||||
queue.push({e: r.center, p: 0, r: r.i, s: cells.state[r.center]}, 0);
|
||||
cost[r.center] = 1;
|
||||
});
|
||||
|
||||
const religionsMap = new Map(religions.map(r => [r.i, r]));
|
||||
|
||||
while (queue.length) {
|
||||
const {e: cellId, p, r, s: state} = queue.pop();
|
||||
const {culture, expansion, expansionism} = religionsMap.get(r);
|
||||
|
||||
cells.c[cellId].forEach(nextCell => {
|
||||
if (expansion === "culture" && culture !== cells.culture[nextCell]) return;
|
||||
if (expansion === "state" && state !== cells.state[nextCell]) return;
|
||||
if (religionsMap.get(religionIds[nextCell])?.lock) return;
|
||||
|
||||
const cultureCost = culture !== cells.culture[nextCell] ? 10 : 0;
|
||||
const stateCost = state !== cells.state[nextCell] ? 10 : 0;
|
||||
const passageCost = getPassageCost(cellId, nextCell);
|
||||
|
||||
const cellCost = cultureCost + stateCost + passageCost;
|
||||
const totalCost = p + 10 + cellCost / expansionism;
|
||||
if (totalCost > maxExpansionCost) return;
|
||||
|
||||
if (!cost[nextCell] || totalCost < cost[nextCell]) {
|
||||
if (cells.culture[nextCell]) religionIds[nextCell] = r; // assign religion to cell
|
||||
cost[nextCell] = totalCost;
|
||||
|
||||
queue.push({e: nextCell, p: totalCost, r, s: state}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return religionIds;
|
||||
|
||||
function getPassageCost(cellId, nextCellId, utils) {
|
||||
const {Routes, biomesData} = utils;
|
||||
const route = Routes.getRoute(cellId, nextCellId);
|
||||
if (isWater(cellId)) return route ? 50 : 500;
|
||||
|
||||
const biomePassageCost = biomesData.cost[cells.biome[nextCellId]];
|
||||
|
||||
if (route) {
|
||||
if (route.group === "roads") return 1;
|
||||
return biomePassageCost / 3; // trails and other routes
|
||||
}
|
||||
|
||||
return biomePassageCost;
|
||||
}
|
||||
}
|
||||
|
||||
// folk religions initially get all cells of their culture, and locked religions are retained
|
||||
function spreadFolkReligions(religions) {
|
||||
const cells = pack.cells;
|
||||
const hasPrior = cells.religion && true;
|
||||
const religionIds = new Uint16Array(cells.i.length);
|
||||
|
||||
const folkReligions = religions.filter(religion => religion.type === "Folk" && !religion.removed);
|
||||
const cultureToReligionMap = new Map(folkReligions.map(({i, culture}) => [culture, i]));
|
||||
|
||||
for (const cellId of cells.i) {
|
||||
const oldId = (hasPrior && cells.religion[cellId]) || 0;
|
||||
if (oldId && religions[oldId]?.lock && !religions[oldId]?.removed) {
|
||||
religionIds[cellId] = oldId;
|
||||
continue;
|
||||
}
|
||||
const cultureId = cells.culture[cellId];
|
||||
religionIds[cellId] = cultureToReligionMap.get(cultureId) || 0;
|
||||
}
|
||||
|
||||
return religionIds;
|
||||
}
|
||||
|
||||
function checkCenters(pack) {
|
||||
const cells = pack.cells;
|
||||
const updatedReligions = pack.religions.map(r => {
|
||||
if (!r.i) return r;
|
||||
// move religion center if it's not within religion area after expansion
|
||||
if (cells.religion[r.center] === r.i) return r; // in area
|
||||
const firstCell = cells.i.find(i => cells.religion[i] === r.i);
|
||||
const cultureHome = pack.cultures[r.culture]?.center;
|
||||
if (firstCell) return {...r, center: firstCell}; // move center, othervise it's an extinct religion
|
||||
else if (r.type === "Folk" && cultureHome) return {...r, center: cultureHome}; // reset extinct culture centers
|
||||
return r;
|
||||
});
|
||||
|
||||
return {
|
||||
...pack,
|
||||
religions: updatedReligions
|
||||
};
|
||||
}
|
||||
|
||||
export function recalculate(pack, grid, config, utils) {
|
||||
const newReligionIds = expandReligions(pack, grid, pack.religions, config, utils);
|
||||
const newPack = {
|
||||
...pack,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
religion: newReligionIds
|
||||
}
|
||||
};
|
||||
|
||||
return checkCenters(newPack);
|
||||
}
|
||||
|
||||
export function add(pack, center, utils) {
|
||||
const {rw, getMixedColor, abbreviate} = utils;
|
||||
const {cells, cultures, religions} = pack;
|
||||
const religionId = cells.religion[center];
|
||||
const i = religions.length;
|
||||
|
||||
const cultureId = cells.culture[center];
|
||||
const missingFolk =
|
||||
cultureId !== 0 &&
|
||||
!religions.some(({type, culture, removed}) => type === "Folk" && culture === cultureId && !removed);
|
||||
const color = missingFolk ? cultures[cultureId].color : getMixedColor(religions[religionId].color, 0.3, 0);
|
||||
|
||||
const type = missingFolk
|
||||
? "Folk"
|
||||
: religions[religionId].type === "Organized"
|
||||
? rw({Organized: 4, Cult: 1, Heresy: 2})
|
||||
: rw({Organized: 5, Cult: 2});
|
||||
const form = rw(forms[type]);
|
||||
const deity =
|
||||
type === "Heresy"
|
||||
? religions[religionId].deity
|
||||
: form === "Non-theism" || form === "Animism"
|
||||
? null
|
||||
: getDeityName(cultureId, utils);
|
||||
|
||||
const [name, expansion] = generateReligionName(pack, type, form, deity, center, utils);
|
||||
|
||||
const formName = type === "Heresy" ? religions[religionId].form : form;
|
||||
const code = abbreviate(
|
||||
name,
|
||||
religions.map(r => r.code)
|
||||
);
|
||||
const influences = getReligionsInRadius(cells.c, center, cells.religion, i, 25, 3, 0);
|
||||
const origins = type === "Folk" ? [0] : influences;
|
||||
|
||||
const newReligion = {
|
||||
i,
|
||||
name,
|
||||
color,
|
||||
culture: cultureId,
|
||||
type,
|
||||
form: formName,
|
||||
deity,
|
||||
expansion,
|
||||
expansionism: expansionismMap[type](utils),
|
||||
center,
|
||||
cells: 0,
|
||||
area: 0,
|
||||
rural: 0,
|
||||
urban: 0,
|
||||
origins,
|
||||
code
|
||||
};
|
||||
|
||||
const newReligions = [...religions, newReligion];
|
||||
const newReligionIds = [...cells.religion];
|
||||
newReligionIds[center] = i;
|
||||
|
||||
return {
|
||||
...pack,
|
||||
religions: newReligions,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
religion: newReligionIds
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
export function updateCultures(pack) {
|
||||
const updatedReligions = pack.religions.map((religion, index) => {
|
||||
if (index === 0) return religion;
|
||||
return {...religion, culture: pack.cells.culture[religion.center]};
|
||||
});
|
||||
|
||||
return {
|
||||
...pack,
|
||||
religions: updatedReligions
|
||||
};
|
||||
}
|
||||
|
||||
// get supreme deity name
|
||||
export function getDeityName(culture, utils) {
|
||||
const {ERROR, Names} = utils;
|
||||
if (culture === undefined) {
|
||||
ERROR && console.error("Please define a culture");
|
||||
return;
|
||||
}
|
||||
const meaning = generateMeaning(utils);
|
||||
const cultureName = Names.getCulture(culture, null, null, "", 0.8);
|
||||
return cultureName + ", The " + meaning;
|
||||
}
|
||||
|
||||
function generateMeaning(utils) {
|
||||
const {ra, ERROR} = utils;
|
||||
const a = ra(approaches); // select generation approach
|
||||
if (a === "Number") return ra(base.number);
|
||||
if (a === "Being") return ra(base.being);
|
||||
if (a === "Adjective") return ra(base.adjective);
|
||||
if (a === "Color + Animal") return `${ra(base.color)} ${ra(base.animal)}`;
|
||||
if (a === "Adjective + Animal") return `${ra(base.adjective)} ${ra(base.animal)}`;
|
||||
if (a === "Adjective + Being") return `${ra(base.adjective)} ${ra(base.being)}`;
|
||||
if (a === "Adjective + Genitive") return `${ra(base.adjective)} ${ra(base.genitive)}`;
|
||||
if (a === "Color + Being") return `${ra(base.color)} ${ra(base.being)}`;
|
||||
if (a === "Color + Genitive") return `${ra(base.color)} ${ra(base.genitive)}`;
|
||||
if (a === "Being + of + Genitive") return `${ra(base.being)} of ${ra(base.genitive)}`;
|
||||
if (a === "Being + of the + Genitive") return `${ra(base.being)} of the ${ra(base.theGenitive)}`;
|
||||
if (a === "Animal + of + Genitive") return `${ra(base.animal)} of ${ra(base.genitive)}`;
|
||||
if (a === "Adjective + Being + of + Genitive")
|
||||
return `${ra(base.adjective)} ${ra(base.being)} of ${ra(base.genitive)}`;
|
||||
if (a === "Adjective + Animal + of + Genitive")
|
||||
return `${ra(base.adjective)} ${ra(base.animal)} of ${ra(base.genitive)}`;
|
||||
|
||||
ERROR && console.error("Unkown generation approach");
|
||||
}
|
||||
|
||||
function generateReligionName(pack, variety, form, deity, center, utils) {
|
||||
const {rw, Names, ra, trimVowels, getAdjective} = utils;
|
||||
const {cells, cultures, burgs, states} = pack;
|
||||
|
||||
const random = () => Names.getCulture(cells.culture[center], null, null, "", 0);
|
||||
const type = rw(types[form]);
|
||||
const supreme = deity.split(/[ ,]+/)[0];
|
||||
const culture = cultures[cells.culture[center]].name;
|
||||
|
||||
const place = adj => {
|
||||
const burgId = cells.burg[center];
|
||||
const stateId = cells.state[center];
|
||||
|
||||
const base = burgId ? burgs[burgId].name : states[stateId].name;
|
||||
let name = trimVowels(base.split(/[ ,]+/)[0]);
|
||||
return adj ? getAdjective(name) : name;
|
||||
};
|
||||
|
||||
const m = rw(namingMethods[variety]);
|
||||
if (m === "Random + type") return [random() + " " + type, "global"];
|
||||
if (m === "Random + ism") return [trimVowels(random()) + "ism", "global"];
|
||||
if (m === "Supreme + ism" && deity) return [trimVowels(supreme) + "ism", "global"];
|
||||
if (m === "Faith of + Supreme" && deity)
|
||||
return [ra(["Faith", "Way", "Path", "Word", "Witnesses"]) + " of " + supreme, "global"];
|
||||
if (m === "Place + ism") return [place() + "ism", "state"];
|
||||
if (m === "Culture + ism") return [trimVowels(culture) + "ism", "culture"];
|
||||
if (m === "Place + ian + type") return [place("adj") + " " + type, "state"];
|
||||
if (m === "Culture + type") return [culture + " " + type, "culture"];
|
||||
if (m === "Burg + ian + type") return [`${place("adj")} ${type}`, "global"];
|
||||
if (m === "Random + ian + type") return [`${getAdjective(random())} ${type}`, "global"];
|
||||
if (m === "Type + of the + meaning") return [`${type} of the ${generateMeaning(utils)}`, "global"];
|
||||
return [trimVowels(random()) + "ism", "global"]; // else
|
||||
}
|
||||
410
procedural/src/engine/modules/resample.js
Normal file
410
procedural/src/engine/modules/resample.js
Normal file
|
|
@ -0,0 +1,410 @@
|
|||
"use strict";
|
||||
|
||||
/*
|
||||
generate new map based on an existing one (resampling parentMap)
|
||||
parentMap: {grid, pack, notes} from original map
|
||||
projection: f(Number, Number) -> [Number, Number]
|
||||
inverse: f(Number, Number) -> [Number, Number]
|
||||
scale: Number
|
||||
*/
|
||||
export function process({projection, inverse, scale}, grid, pack, notes, config, utils) {
|
||||
const {deepCopy, generateGrid, rn, findCell, findAll, isInMap, unique, lineclip, WARN} = utils;
|
||||
const parentMap = {grid: deepCopy(grid), pack: deepCopy(pack), notes: deepCopy(notes)};
|
||||
const riversData = saveRiversData(parentMap.pack.rivers, utils);
|
||||
|
||||
const newGrid = generateGrid();
|
||||
const newPack = {};
|
||||
const newNotes = parentMap.notes;
|
||||
|
||||
resamplePrimaryGridData(parentMap, inverse, scale, newGrid, utils);
|
||||
|
||||
// External module calls that modify newGrid and newPack would need to be handled by caller
|
||||
// Features.markupGrid(), addLakesInDeepDepressions(), openNearSeaLakes(),
|
||||
// OceanLayers(), calculateMapCoordinates(), calculateTemperatures(),
|
||||
// reGraph(), Features.markupPack(), createDefaultRuler()
|
||||
|
||||
const cellData = restoreCellData(parentMap, inverse, scale, newPack, config, utils);
|
||||
const rivers = restoreRivers(riversData, projection, scale, newPack, config, utils);
|
||||
const cultures = restoreCultures(parentMap, projection, newPack, utils);
|
||||
const burgs = restoreBurgs(parentMap, projection, scale, newPack, utils);
|
||||
const states = restoreStates(parentMap, projection, newPack, config, utils);
|
||||
const routes = restoreRoutes(parentMap, projection, newPack, config, utils);
|
||||
const religions = restoreReligions(parentMap, projection, newPack, utils);
|
||||
const provinces = restoreProvinces(parentMap, newPack, utils);
|
||||
const featureDetails = restoreFeatureDetails(parentMap, inverse, newPack, utils);
|
||||
const markers = restoreMarkers(parentMap, projection, newPack, utils);
|
||||
const zones = restoreZones(parentMap, projection, scale, newPack, utils);
|
||||
|
||||
return {
|
||||
grid: newGrid,
|
||||
pack: {
|
||||
...newPack,
|
||||
cells: cellData.cells,
|
||||
rivers: rivers,
|
||||
cultures: cultures,
|
||||
burgs: burgs,
|
||||
states: states,
|
||||
routes: routes,
|
||||
religions: religions,
|
||||
provinces: provinces,
|
||||
markers: markers,
|
||||
zones: zones,
|
||||
features: newPack.features || []
|
||||
},
|
||||
notes: newNotes
|
||||
};
|
||||
}
|
||||
|
||||
function resamplePrimaryGridData(parentMap, inverse, scale, grid, utils) {
|
||||
const {smoothHeightmap} = utils;
|
||||
grid.cells.h = new Uint8Array(grid.points.length);
|
||||
grid.cells.temp = new Int8Array(grid.points.length);
|
||||
grid.cells.prec = new Uint8Array(grid.points.length);
|
||||
|
||||
grid.points.forEach(([x, y], newGridCell) => {
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentPackCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
const parentGridCell = parentMap.pack.cells.g[parentPackCell];
|
||||
|
||||
grid.cells.h[newGridCell] = parentMap.grid.cells.h[parentGridCell];
|
||||
grid.cells.temp[newGridCell] = parentMap.grid.cells.temp[parentGridCell];
|
||||
grid.cells.prec[newGridCell] = parentMap.grid.cells.prec[parentGridCell];
|
||||
});
|
||||
|
||||
if (scale >= 2) smoothHeightmap(grid);
|
||||
}
|
||||
|
||||
function smoothHeightmap(grid) {
|
||||
const {d3, isWater} = grid.utils || {};
|
||||
grid.cells.h.forEach((height, newGridCell) => {
|
||||
const heights = [height, ...grid.cells.c[newGridCell].map(c => grid.cells.h[c])];
|
||||
const meanHeight = d3.mean(heights);
|
||||
grid.cells.h[newGridCell] = isWater(grid, newGridCell) ? Math.min(meanHeight, 19) : Math.max(meanHeight, 20);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCellData(parentMap, inverse, scale, pack, config, utils) {
|
||||
const {d3, isWater} = utils;
|
||||
|
||||
const cells = {
|
||||
biome: new Uint8Array(pack.cells.i.length),
|
||||
fl: new Uint16Array(pack.cells.i.length),
|
||||
s: new Int16Array(pack.cells.i.length),
|
||||
pop: new Float32Array(pack.cells.i.length),
|
||||
culture: new Uint16Array(pack.cells.i.length),
|
||||
state: new Uint16Array(pack.cells.i.length),
|
||||
burg: new Uint16Array(pack.cells.i.length),
|
||||
religion: new Uint16Array(pack.cells.i.length),
|
||||
province: new Uint16Array(pack.cells.i.length)
|
||||
};
|
||||
|
||||
const parentPackCellGroups = groupCellsByType(parentMap.pack);
|
||||
const parentPackLandCellsQuadtree = d3.quadtree(parentPackCellGroups.land);
|
||||
|
||||
for (const newPackCell of pack.cells.i) {
|
||||
const [x, y] = inverse(...pack.cells.p[newPackCell]);
|
||||
if (isWater(pack, newPackCell)) continue;
|
||||
|
||||
const parentPackCell = parentPackLandCellsQuadtree.find(x, y, Infinity)[2];
|
||||
const parentCellArea = parentMap.pack.cells.area[parentPackCell];
|
||||
const areaRatio = pack.cells.area[newPackCell] / parentCellArea;
|
||||
const scaleRatio = areaRatio / scale;
|
||||
|
||||
cells.biome[newPackCell] = parentMap.pack.cells.biome[parentPackCell];
|
||||
cells.fl[newPackCell] = parentMap.pack.cells.fl[parentPackCell];
|
||||
cells.s[newPackCell] = parentMap.pack.cells.s[parentPackCell] * scaleRatio;
|
||||
cells.pop[newPackCell] = parentMap.pack.cells.pop[parentPackCell] * scaleRatio;
|
||||
cells.culture[newPackCell] = parentMap.pack.cells.culture[parentPackCell];
|
||||
cells.state[newPackCell] = parentMap.pack.cells.state[parentPackCell];
|
||||
cells.religion[newPackCell] = parentMap.pack.cells.religion[parentPackCell];
|
||||
cells.province[newPackCell] = parentMap.pack.cells.province[parentPackCell];
|
||||
}
|
||||
|
||||
return {cells};
|
||||
}
|
||||
|
||||
function saveRiversData(parentRivers, utils) {
|
||||
const {Rivers} = utils;
|
||||
return parentRivers.map(river => {
|
||||
const meanderedPoints = Rivers.addMeandering(river.cells, river.points);
|
||||
return {...river, meanderedPoints};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRivers(riversData, projection, scale, pack, config, utils) {
|
||||
const {rn, isInMap, findCell, Rivers} = utils;
|
||||
|
||||
pack.cells.r = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.conf = new Uint8Array(pack.cells.i.length);
|
||||
|
||||
const rivers = riversData
|
||||
.map(river => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
river.meanderedPoints.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y, config.graphWidth, config.graphHeight);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const cells = points.map(point => findCell(...point));
|
||||
cells.forEach(cellId => {
|
||||
if (pack.cells.r[cellId]) pack.cells.conf[cellId] = 1;
|
||||
pack.cells.r[cellId] = river.i;
|
||||
});
|
||||
|
||||
const widthFactor = river.widthFactor * scale;
|
||||
return {...river, cells, points, source: cells.at(0), mouth: cells.at(-2), widthFactor};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
rivers.forEach(river => {
|
||||
river.basin = Rivers.getBasin(river.i);
|
||||
river.length = Rivers.getApproximateLength(river.points);
|
||||
});
|
||||
|
||||
return rivers;
|
||||
}
|
||||
|
||||
function restoreCultures(parentMap, projection, pack, utils) {
|
||||
const {rn, isInMap, findCell, getPolesOfInaccessibility} = utils;
|
||||
|
||||
const validCultures = new Set(pack.cells.culture);
|
||||
const culturePoles = getPolesOfInaccessibility(pack, cellId => pack.cells.culture[cellId]);
|
||||
|
||||
return parentMap.pack.cultures.map(culture => {
|
||||
if (!culture.i || culture.removed) return culture;
|
||||
if (!validCultures.has(culture.i)) return {...culture, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[culture.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : culturePoles[culture.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...culture, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreBurgs(parentMap, projection, scale, pack, utils) {
|
||||
const {d3, rn, isInMap, findCell, isWater, WARN, BurgsAndStates} = utils;
|
||||
|
||||
const packLandCellsQuadtree = d3.quadtree(groupCellsByType(pack).land);
|
||||
const findLandCell = (x, y) => packLandCellsQuadtree.find(x, y, Infinity)?.[2];
|
||||
|
||||
return parentMap.pack.burgs.map(burg => {
|
||||
if (!burg.i || burg.removed) return burg;
|
||||
burg.population *= scale; // adjust for populationRate change
|
||||
|
||||
const [xp, yp] = projection(burg.x, burg.y);
|
||||
if (!isInMap(xp, yp)) return {...burg, removed: true, lock: false};
|
||||
|
||||
const closestCell = findCell(xp, yp);
|
||||
const cell = isWater(pack, closestCell) ? findLandCell(xp, yp) : closestCell;
|
||||
|
||||
if (pack.cells.burg[cell]) {
|
||||
WARN && console.warn(`Cell ${cell} already has a burg. Removing burg ${burg.name} (${burg.i})`);
|
||||
return {...burg, removed: true, lock: false};
|
||||
}
|
||||
|
||||
pack.cells.burg[cell] = burg.i;
|
||||
const [x, y] = getBurgCoordinates(burg, closestCell, cell, xp, yp, pack, utils);
|
||||
return {...burg, cell, x, y};
|
||||
});
|
||||
|
||||
function getBurgCoordinates(burg, closestCell, cell, xp, yp, pack, utils) {
|
||||
const {rn, BurgsAndStates} = utils;
|
||||
const haven = pack.cells.haven[cell];
|
||||
if (burg.port && haven) return BurgsAndStates.getCloseToEdgePoint(cell, haven);
|
||||
|
||||
if (closestCell !== cell) return pack.cells.p[cell];
|
||||
return [rn(xp, 2), rn(yp, 2)];
|
||||
}
|
||||
}
|
||||
|
||||
function restoreStates(parentMap, projection, pack, config, utils) {
|
||||
const {rn, isInMap, findCell, BurgsAndStates} = utils;
|
||||
|
||||
const validStates = new Set(pack.cells.state);
|
||||
let states = parentMap.pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
if (validStates.has(state.i)) return state;
|
||||
return {...state, removed: true, lock: false};
|
||||
});
|
||||
|
||||
BurgsAndStates.getPoles();
|
||||
const regimentCellsMap = {};
|
||||
const VERTICAL_GAP = 8;
|
||||
|
||||
states = states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
|
||||
const capital = pack.burgs[state.capital];
|
||||
state.center = !capital || capital.removed ? findCell(...state.pole) : capital.cell;
|
||||
|
||||
const military = state.military.map(regiment => {
|
||||
const cellCoords = projection(...parentMap.pack.cells.p[regiment.cell]);
|
||||
const cell = isInMap(...cellCoords, config.graphWidth, config.graphHeight) ? findCell(...cellCoords) : state.center;
|
||||
|
||||
const [xPos, yPos] = projection(regiment.x, regiment.y);
|
||||
const [xBase, yBase] = projection(regiment.bx, regiment.by);
|
||||
const [xCell, yCell] = pack.cells.p[cell];
|
||||
|
||||
const regsOnCell = regimentCellsMap[cell] || 0;
|
||||
regimentCellsMap[cell] = regsOnCell + 1;
|
||||
|
||||
const name =
|
||||
isInMap(xPos, yPos, config.graphWidth, config.graphHeight) || regiment.name.includes("[relocated]") ? regiment.name : `[relocated] ${regiment.name}`;
|
||||
|
||||
const pos = isInMap(xPos, yPos, config.graphWidth, config.graphHeight)
|
||||
? {x: rn(xPos, 2), y: rn(yPos, 2)}
|
||||
: {x: xCell, y: yCell + regsOnCell * VERTICAL_GAP};
|
||||
|
||||
const base = isInMap(xBase, yBase, config.graphWidth, config.graphHeight) ? {bx: rn(xBase, 2), by: rn(yBase, 2)} : {bx: xCell, by: yCell};
|
||||
|
||||
return {...regiment, cell, name, ...base, ...pos};
|
||||
});
|
||||
|
||||
const neighbors = state.neighbors.filter(stateId => validStates.has(stateId));
|
||||
return {...state, neighbors, military};
|
||||
});
|
||||
|
||||
return states;
|
||||
}
|
||||
|
||||
function restoreRoutes(parentMap, projection, pack, config, utils) {
|
||||
const {rn, isInMap, findCell, lineclip, Routes} = utils;
|
||||
|
||||
const routes = parentMap.pack.routes
|
||||
.map(route => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
route.points.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y, config.graphWidth, config.graphHeight);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const bbox = [0, 0, config.graphWidth, config.graphHeight];
|
||||
const clipped = lineclip(points, bbox)[0].map(([x, y]) => [rn(x, 2), rn(y, 2), findCell(x, y)]);
|
||||
const firstCell = clipped[0][2];
|
||||
const feature = pack.cells.f[firstCell];
|
||||
return {...route, feature, points: clipped};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.cells.routes = Routes.buildLinks(routes);
|
||||
return routes;
|
||||
}
|
||||
|
||||
function restoreReligions(parentMap, projection, pack, utils) {
|
||||
const {rn, isInMap, findCell, getPolesOfInaccessibility} = utils;
|
||||
|
||||
const validReligions = new Set(pack.cells.religion);
|
||||
const religionPoles = getPolesOfInaccessibility(pack, cellId => pack.cells.religion[cellId]);
|
||||
|
||||
return parentMap.pack.religions.map(religion => {
|
||||
if (!religion.i || religion.removed) return religion;
|
||||
if (!validReligions.has(religion.i)) return {...religion, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[religion.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : religionPoles[religion.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...religion, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreProvinces(parentMap, pack, utils) {
|
||||
const {findCell, Provinces} = utils;
|
||||
|
||||
const validProvinces = new Set(pack.cells.province);
|
||||
const provinces = parentMap.pack.provinces.map(province => {
|
||||
if (!province.i || province.removed) return province;
|
||||
if (!validProvinces.has(province.i)) return {...province, removed: true, lock: false};
|
||||
|
||||
return province;
|
||||
});
|
||||
|
||||
Provinces.getPoles();
|
||||
|
||||
provinces.forEach(province => {
|
||||
if (!province.i || province.removed) return;
|
||||
const capital = pack.burgs[province.burg];
|
||||
province.center = !capital?.removed ? capital.cell : findCell(...province.pole);
|
||||
});
|
||||
|
||||
return provinces;
|
||||
}
|
||||
|
||||
function restoreMarkers(parentMap, projection, pack, utils) {
|
||||
const {rn, isInMap, findCell, Markers} = utils;
|
||||
|
||||
const markers = parentMap.pack.markers;
|
||||
markers.forEach(marker => {
|
||||
const [x, y] = projection(marker.x, marker.y);
|
||||
if (!isInMap(x, y)) Markers.deleteMarker(marker.i);
|
||||
|
||||
const cell = findCell(x, y);
|
||||
marker.x = rn(x, 2);
|
||||
marker.y = rn(y, 2);
|
||||
marker.cell = cell;
|
||||
});
|
||||
|
||||
return markers;
|
||||
}
|
||||
|
||||
function restoreZones(parentMap, projection, scale, pack, utils) {
|
||||
const {isInMap, findAll, unique} = utils;
|
||||
|
||||
const getSearchRadius = cellId => Math.sqrt(parentMap.pack.cells.area[cellId] / Math.PI) * scale;
|
||||
|
||||
return parentMap.pack.zones.map(zone => {
|
||||
const cells = zone.cells
|
||||
.map(cellId => {
|
||||
const [x, y] = projection(...parentMap.pack.cells.p[cellId]);
|
||||
if (!isInMap(x, y)) return null;
|
||||
return findAll(x, y, getSearchRadius(cellId));
|
||||
})
|
||||
.filter(Boolean)
|
||||
.flat();
|
||||
|
||||
return {...zone, cells: unique(cells)};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreFeatureDetails(parentMap, inverse, pack, utils) {
|
||||
pack.features.forEach(feature => {
|
||||
if (!feature) return;
|
||||
const [x, y] = pack.cells.p[feature.firstCell];
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
if (parentCell === undefined) return;
|
||||
const parentFeature = parentMap.pack.features[parentMap.pack.cells.f[parentCell]];
|
||||
|
||||
if (parentFeature.group) feature.group = parentFeature.group;
|
||||
if (parentFeature.name) feature.name = parentFeature.name;
|
||||
if (parentFeature.height) feature.height = parentFeature.height;
|
||||
});
|
||||
|
||||
return pack.features;
|
||||
}
|
||||
|
||||
function groupCellsByType(graph) {
|
||||
return graph.cells.p.reduce(
|
||||
(acc, [x, y], cellId) => {
|
||||
const group = isWater(graph, cellId) ? "water" : "land";
|
||||
acc[group].push([x, y, cellId]);
|
||||
return acc;
|
||||
},
|
||||
{land: [], water: []}
|
||||
);
|
||||
}
|
||||
|
||||
function isWater(graph, cellId) {
|
||||
return graph.cells.h[cellId] < 20;
|
||||
}
|
||||
559
procedural/src/engine/modules/river-generator.js
Normal file
559
procedural/src/engine/modules/river-generator.js
Normal file
|
|
@ -0,0 +1,559 @@
|
|||
"use strict";
|
||||
|
||||
export const generate = function (pack, grid, config, utils, modules, allowErosion = true) {
|
||||
const {TIME, seed, aleaPRNG, resolveDepressionsSteps, cellsCount, graphWidth, graphHeight, WARN} = config;
|
||||
const {rn, rw, each, round, d3, lineGen} = utils;
|
||||
const {Lakes, Names} = modules;
|
||||
|
||||
TIME && console.time("generateRivers");
|
||||
Math.random = aleaPRNG(seed);
|
||||
const {cells, features} = pack;
|
||||
|
||||
const riversData = {}; // rivers data
|
||||
const riverParents = {};
|
||||
|
||||
const addCellToRiver = function (cell, river) {
|
||||
if (!riversData[river]) riversData[river] = [cell];
|
||||
else riversData[river].push(cell);
|
||||
};
|
||||
|
||||
const newCells = {
|
||||
...cells,
|
||||
fl: new Uint16Array(cells.i.length), // water flux array
|
||||
r: new Uint16Array(cells.i.length), // rivers array
|
||||
conf: new Uint8Array(cells.i.length) // confluences array
|
||||
};
|
||||
|
||||
let riverNext = 1; // first river id is 1
|
||||
|
||||
const h = alterHeights(pack, utils);
|
||||
Lakes.detectCloseLakes(h);
|
||||
const resolvedH = resolveDepressions(pack, config, utils, h);
|
||||
const {updatedCells, updatedFeatures, updatedRivers} = drainWater(pack, grid, config, utils, modules, newCells, resolvedH, riversData, riverParents, riverNext);
|
||||
const {finalCells, finalRivers} = defineRivers(pack, config, utils, updatedCells, riversData, riverParents);
|
||||
|
||||
calculateConfluenceFlux(finalCells, resolvedH);
|
||||
Lakes.cleanupLakeData();
|
||||
|
||||
let finalH = resolvedH;
|
||||
if (allowErosion) {
|
||||
finalH = Uint8Array.from(resolvedH); // apply gradient
|
||||
downcutRivers(pack, finalCells, finalH); // downcut river beds
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateRivers");
|
||||
|
||||
return {
|
||||
pack: {
|
||||
...pack,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
...finalCells,
|
||||
h: finalH
|
||||
},
|
||||
features: updatedFeatures,
|
||||
rivers: finalRivers
|
||||
}
|
||||
};
|
||||
|
||||
function drainWater(pack, grid, config, utils, modules, cells, h, riversData, riverParents, riverNext) {
|
||||
const {cellsCount} = config;
|
||||
const {Lakes} = modules;
|
||||
const MIN_FLUX_TO_FORM_RIVER = 30;
|
||||
const cellsNumberModifier = (cellsCount / 10000) ** 0.25;
|
||||
|
||||
const prec = grid.cells.prec;
|
||||
const land = cells.i.filter(i => h[i] >= 20).sort((a, b) => h[b] - h[a]);
|
||||
const lakeOutCells = Lakes.defineClimateData(h);
|
||||
|
||||
land.forEach(function (i) {
|
||||
cells.fl[i] += prec[cells.g[i]] / cellsNumberModifier; // add flux from precipitation
|
||||
|
||||
// create lake outlet if lake is not in deep depression and flux > evaporation
|
||||
const lakes = lakeOutCells[i]
|
||||
? features.filter(feature => i === feature.outCell && feature.flux > feature.evaporation)
|
||||
: [];
|
||||
for (const lake of lakes) {
|
||||
const lakeCell = cells.c[i].find(c => h[c] < 20 && cells.f[c] === lake.i);
|
||||
cells.fl[lakeCell] += Math.max(lake.flux - lake.evaporation, 0); // not evaporated lake water drains to outlet
|
||||
|
||||
// allow chain lakes to retain identity
|
||||
if (cells.r[lakeCell] !== lake.river) {
|
||||
const sameRiver = cells.c[lakeCell].some(c => cells.r[c] === lake.river);
|
||||
|
||||
if (sameRiver) {
|
||||
cells.r[lakeCell] = lake.river;
|
||||
addCellToRiver(lakeCell, lake.river);
|
||||
} else {
|
||||
cells.r[lakeCell] = riverNext;
|
||||
addCellToRiver(lakeCell, riverNext);
|
||||
riverNext++;
|
||||
}
|
||||
}
|
||||
|
||||
lake.outlet = cells.r[lakeCell];
|
||||
flowDown(i, cells.fl[lakeCell], lake.outlet);
|
||||
}
|
||||
|
||||
// assign all tributary rivers to outlet basin
|
||||
const outlet = lakes[0]?.outlet;
|
||||
for (const lake of lakes) {
|
||||
if (!Array.isArray(lake.inlets)) continue;
|
||||
for (const inlet of lake.inlets) {
|
||||
riverParents[inlet] = outlet;
|
||||
}
|
||||
}
|
||||
|
||||
// near-border cell: pour water out of the screen
|
||||
if (cells.b[i] && cells.r[i]) return addCellToRiver(-1, cells.r[i]);
|
||||
|
||||
// downhill cell (make sure it's not in the source lake)
|
||||
let min = null;
|
||||
if (lakeOutCells[i]) {
|
||||
const filtered = cells.c[i].filter(c => !lakes.map(lake => lake.i).includes(cells.f[c]));
|
||||
min = filtered.sort((a, b) => h[a] - h[b])[0];
|
||||
} else if (cells.haven[i]) {
|
||||
min = cells.haven[i];
|
||||
} else {
|
||||
min = cells.c[i].sort((a, b) => h[a] - h[b])[0];
|
||||
}
|
||||
|
||||
// cells is depressed
|
||||
if (h[i] <= h[min]) return;
|
||||
|
||||
if (cells.fl[i] < MIN_FLUX_TO_FORM_RIVER) {
|
||||
// flux is too small to operate as a river
|
||||
if (h[min] >= 20) cells.fl[min] += cells.fl[i];
|
||||
return;
|
||||
}
|
||||
|
||||
// proclaim a new river
|
||||
if (!cells.r[i]) {
|
||||
cells.r[i] = riverNext;
|
||||
addCellToRiver(i, riverNext);
|
||||
riverNext++;
|
||||
}
|
||||
|
||||
flowDown(min, cells.fl[i], cells.r[i]);
|
||||
});
|
||||
|
||||
function flowDown(toCell, fromFlux, river) {
|
||||
const toFlux = cells.fl[toCell] - cells.conf[toCell];
|
||||
const toRiver = cells.r[toCell];
|
||||
|
||||
if (toRiver) {
|
||||
// downhill cell already has river assigned
|
||||
if (fromFlux > toFlux) {
|
||||
cells.conf[toCell] += cells.fl[toCell]; // mark confluence
|
||||
if (h[toCell] >= 20) riverParents[toRiver] = river; // min river is a tributary of current river
|
||||
cells.r[toCell] = river; // re-assign river if downhill part has less flux
|
||||
} else {
|
||||
cells.conf[toCell] += fromFlux; // mark confluence
|
||||
if (h[toCell] >= 20) riverParents[river] = toRiver; // current river is a tributary of min river
|
||||
}
|
||||
} else cells.r[toCell] = river; // assign the river to the downhill cell
|
||||
|
||||
if (h[toCell] < 20) {
|
||||
// pour water to the water body
|
||||
const waterBody = features[cells.f[toCell]];
|
||||
if (waterBody.type === "lake") {
|
||||
if (!waterBody.river || fromFlux > waterBody.enteringFlux) {
|
||||
waterBody.river = river;
|
||||
waterBody.enteringFlux = fromFlux;
|
||||
}
|
||||
waterBody.flux = waterBody.flux + fromFlux;
|
||||
if (!waterBody.inlets) waterBody.inlets = [river];
|
||||
else waterBody.inlets.push(river);
|
||||
}
|
||||
} else {
|
||||
// propagate flux and add next river segment
|
||||
cells.fl[toCell] += fromFlux;
|
||||
}
|
||||
|
||||
addCellToRiver(toCell, river);
|
||||
}
|
||||
|
||||
return {
|
||||
updatedCells: cells,
|
||||
updatedFeatures: features,
|
||||
updatedRivers: []
|
||||
};
|
||||
}
|
||||
|
||||
function defineRivers(pack, config, utils, cells, riversData, riverParents) {
|
||||
const {cellsCount} = config;
|
||||
const {rn} = utils;
|
||||
|
||||
// re-initialize rivers and confluence arrays
|
||||
const newCells = {
|
||||
...cells,
|
||||
r: new Uint16Array(cells.i.length),
|
||||
conf: new Uint16Array(cells.i.length)
|
||||
};
|
||||
const rivers = [];
|
||||
|
||||
const defaultWidthFactor = rn(1 / (cellsCount / 10000) ** 0.25, 2);
|
||||
const mainStemWidthFactor = defaultWidthFactor * 1.2;
|
||||
|
||||
for (const key in riversData) {
|
||||
const riverCells = riversData[key];
|
||||
if (riverCells.length < 3) continue; // exclude tiny rivers
|
||||
|
||||
const riverId = +key;
|
||||
for (const cell of riverCells) {
|
||||
if (cell < 0 || cells.h[cell] < 20) continue;
|
||||
|
||||
// mark real confluences and assign river to cells
|
||||
if (newCells.r[cell]) newCells.conf[cell] = 1;
|
||||
else newCells.r[cell] = riverId;
|
||||
}
|
||||
|
||||
const source = riverCells[0];
|
||||
const mouth = riverCells[riverCells.length - 2];
|
||||
const parent = riverParents[key] || 0;
|
||||
|
||||
const widthFactor = !parent || parent === riverId ? mainStemWidthFactor : defaultWidthFactor;
|
||||
const meanderedPoints = addMeandering(pack, utils, riverCells);
|
||||
const discharge = cells.fl[mouth]; // m3 in second
|
||||
const length = getApproximateLength(utils, meanderedPoints);
|
||||
const sourceWidth = getSourceWidth(utils, cells.fl[source]);
|
||||
const width = getWidth(utils,
|
||||
getOffset(utils, {
|
||||
flux: discharge,
|
||||
pointIndex: meanderedPoints.length,
|
||||
widthFactor,
|
||||
startingWidth: sourceWidth
|
||||
})
|
||||
);
|
||||
|
||||
rivers.push({
|
||||
i: riverId,
|
||||
source,
|
||||
mouth,
|
||||
discharge,
|
||||
length,
|
||||
width,
|
||||
widthFactor,
|
||||
sourceWidth,
|
||||
parent,
|
||||
cells: riverCells
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
finalCells: newCells,
|
||||
finalRivers: rivers
|
||||
};
|
||||
}
|
||||
|
||||
function downcutRivers(pack, cells, h) {
|
||||
const MAX_DOWNCUT = 5;
|
||||
|
||||
for (const i of pack.cells.i) {
|
||||
if (cells.h[i] < 35) continue; // don't donwcut lowlands
|
||||
if (!cells.fl[i]) continue;
|
||||
|
||||
const higherCells = cells.c[i].filter(c => cells.h[c] > cells.h[i]);
|
||||
const higherFlux = higherCells.reduce((acc, c) => acc + cells.fl[c], 0) / higherCells.length;
|
||||
if (!higherFlux) continue;
|
||||
|
||||
const downcut = Math.floor(cells.fl[i] / higherFlux);
|
||||
if (downcut) cells.h[i] -= Math.min(downcut, MAX_DOWNCUT);
|
||||
}
|
||||
}
|
||||
|
||||
function calculateConfluenceFlux(cells, h) {
|
||||
for (const i of cells.i) {
|
||||
if (!cells.conf[i]) continue;
|
||||
|
||||
const sortedInflux = cells.c[i]
|
||||
.filter(c => cells.r[c] && h[c] > h[i])
|
||||
.map(c => cells.fl[c])
|
||||
.sort((a, b) => b - a);
|
||||
cells.conf[i] = sortedInflux.reduce((acc, flux, index) => (index ? acc + flux : acc), 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// add distance to water value to land cells to make map less depressed
|
||||
export const alterHeights = (pack, utils) => {
|
||||
const {d3} = utils;
|
||||
const {h, c, t} = pack.cells;
|
||||
return Array.from(h).map((h, i) => {
|
||||
if (h < 20 || t[i] < 1) return h;
|
||||
return h + t[i] / 100 + d3.mean(c[i].map(c => t[c])) / 10000;
|
||||
});
|
||||
};
|
||||
|
||||
// depression filling algorithm (for a correct water flux modeling)
|
||||
export const resolveDepressions = function (pack, config, utils, h) {
|
||||
const {resolveDepressionsSteps, WARN} = config;
|
||||
const {d3} = utils;
|
||||
const {cells, features} = pack;
|
||||
const maxIterations = resolveDepressionsSteps;
|
||||
const checkLakeMaxIteration = maxIterations * 0.85;
|
||||
const elevateLakeMaxIteration = maxIterations * 0.75;
|
||||
|
||||
const height = i => features[cells.f[i]].height || h[i]; // height of lake or specific cell
|
||||
|
||||
const lakes = features.filter(f => f.type === "lake");
|
||||
const land = cells.i.filter(i => h[i] >= 20 && !cells.b[i]); // exclude near-border cells
|
||||
land.sort((a, b) => h[a] - h[b]); // lowest cells go first
|
||||
|
||||
const progress = [];
|
||||
let depressions = Infinity;
|
||||
let prevDepressions = null;
|
||||
for (let iteration = 0; depressions && iteration < maxIterations; iteration++) {
|
||||
if (progress.length > 5 && d3.sum(progress) > 0) {
|
||||
// bad progress, abort and set heights back
|
||||
h = alterHeights(pack, utils);
|
||||
depressions = progress[0];
|
||||
break;
|
||||
}
|
||||
|
||||
depressions = 0;
|
||||
|
||||
if (iteration < checkLakeMaxIteration) {
|
||||
for (const l of lakes) {
|
||||
if (l.closed) continue;
|
||||
const minHeight = d3.min(l.shoreline.map(s => h[s]));
|
||||
if (minHeight >= 100 || l.height > minHeight) continue;
|
||||
|
||||
if (iteration > elevateLakeMaxIteration) {
|
||||
l.shoreline.forEach(i => (h[i] = cells.h[i]));
|
||||
l.height = d3.min(l.shoreline.map(s => h[s])) - 1;
|
||||
l.closed = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
depressions++;
|
||||
l.height = minHeight + 0.2;
|
||||
}
|
||||
}
|
||||
|
||||
for (const i of land) {
|
||||
const minHeight = d3.min(cells.c[i].map(c => height(c)));
|
||||
if (minHeight >= 100 || h[i] > minHeight) continue;
|
||||
|
||||
depressions++;
|
||||
h[i] = minHeight + 0.1;
|
||||
}
|
||||
|
||||
prevDepressions !== null && progress.push(depressions - prevDepressions);
|
||||
prevDepressions = depressions;
|
||||
}
|
||||
|
||||
depressions && WARN && console.warn(`Unresolved depressions: ${depressions}. Edit heightmap to fix`);
|
||||
return h;
|
||||
};
|
||||
|
||||
// add points at 1/3 and 2/3 of a line between adjacents river cells
|
||||
export const addMeandering = function (pack, utils, riverCells, riverPoints = null, meandering = 0.5) {
|
||||
const {fl, h} = pack.cells;
|
||||
const meandered = [];
|
||||
const lastStep = riverCells.length - 1;
|
||||
const points = getRiverPoints(pack, riverCells, riverPoints);
|
||||
let step = h[riverCells[0]] < 20 ? 1 : 10;
|
||||
|
||||
for (let i = 0; i <= lastStep; i++, step++) {
|
||||
const cell = riverCells[i];
|
||||
const isLastCell = i === lastStep;
|
||||
|
||||
const [x1, y1] = points[i];
|
||||
|
||||
meandered.push([x1, y1, fl[cell]]);
|
||||
if (isLastCell) break;
|
||||
|
||||
const nextCell = riverCells[i + 1];
|
||||
const [x2, y2] = points[i + 1];
|
||||
|
||||
if (nextCell === -1) {
|
||||
meandered.push([x2, y2, fl[cell]]);
|
||||
break;
|
||||
}
|
||||
|
||||
const dist2 = (x2 - x1) ** 2 + (y2 - y1) ** 2; // square distance between cells
|
||||
if (dist2 <= 25 && riverCells.length >= 6) continue;
|
||||
|
||||
const meander = meandering + 1 / step + Math.max(meandering - step / 100, 0);
|
||||
const angle = Math.atan2(y2 - y1, x2 - x1);
|
||||
const sinMeander = Math.sin(angle) * meander;
|
||||
const cosMeander = Math.cos(angle) * meander;
|
||||
|
||||
if (step < 20 && (dist2 > 64 || (dist2 > 36 && riverCells.length < 5))) {
|
||||
// if dist2 is big or river is small add extra points at 1/3 and 2/3 of segment
|
||||
const p1x = (x1 * 2 + x2) / 3 + -sinMeander;
|
||||
const p1y = (y1 * 2 + y2) / 3 + cosMeander;
|
||||
const p2x = (x1 + x2 * 2) / 3 + sinMeander / 2;
|
||||
const p2y = (y1 + y2 * 2) / 3 - cosMeander / 2;
|
||||
meandered.push([p1x, p1y, 0], [p2x, p2y, 0]);
|
||||
} else if (dist2 > 25 || riverCells.length < 6) {
|
||||
// if dist is medium or river is small add 1 extra middlepoint
|
||||
const p1x = (x1 + x2) / 2 + -sinMeander;
|
||||
const p1y = (y1 + y2) / 2 + cosMeander;
|
||||
meandered.push([p1x, p1y, 0]);
|
||||
}
|
||||
}
|
||||
|
||||
return meandered;
|
||||
};
|
||||
|
||||
export const getRiverPoints = (pack, riverCells, riverPoints) => {
|
||||
if (riverPoints) return riverPoints;
|
||||
|
||||
const {p} = pack.cells;
|
||||
return riverCells.map((cell, i) => {
|
||||
if (cell === -1) return getBorderPoint(pack, riverCells[i - 1]);
|
||||
return p[cell];
|
||||
});
|
||||
};
|
||||
|
||||
export const getBorderPoint = (pack, config, i) => {
|
||||
const {graphWidth, graphHeight} = config;
|
||||
const [x, y] = pack.cells.p[i];
|
||||
const min = Math.min(y, graphHeight - y, x, graphWidth - x);
|
||||
if (min === y) return [x, 0];
|
||||
else if (min === graphHeight - y) return [x, graphHeight];
|
||||
else if (min === x) return [0, y];
|
||||
return [graphWidth, y];
|
||||
};
|
||||
|
||||
const FLUX_FACTOR = 500;
|
||||
const MAX_FLUX_WIDTH = 1;
|
||||
const LENGTH_FACTOR = 200;
|
||||
const LENGTH_STEP_WIDTH = 1 / LENGTH_FACTOR;
|
||||
const LENGTH_PROGRESSION = [1, 1, 2, 3, 5, 8, 13, 21, 34].map(n => n / LENGTH_FACTOR);
|
||||
|
||||
export const getOffset = (utils, {flux, pointIndex, widthFactor, startingWidth}) => {
|
||||
if (pointIndex === 0) return startingWidth;
|
||||
|
||||
const fluxWidth = Math.min(flux ** 0.7 / FLUX_FACTOR, MAX_FLUX_WIDTH);
|
||||
const lengthWidth = pointIndex * LENGTH_STEP_WIDTH + (LENGTH_PROGRESSION[pointIndex] || LENGTH_PROGRESSION.at(-1));
|
||||
return widthFactor * (lengthWidth + fluxWidth) + startingWidth;
|
||||
};
|
||||
|
||||
export const getSourceWidth = (utils, flux) => {
|
||||
const {rn} = utils;
|
||||
return rn(Math.min(flux ** 0.9 / FLUX_FACTOR, MAX_FLUX_WIDTH), 2);
|
||||
};
|
||||
|
||||
// build polygon from a list of points and calculated offset (width)
|
||||
export const getRiverPath = (utils, points, widthFactor, startingWidth) => {
|
||||
const {lineGen, d3, round} = utils;
|
||||
lineGen.curve(d3.curveCatmullRom.alpha(0.1));
|
||||
const riverPointsLeft = [];
|
||||
const riverPointsRight = [];
|
||||
let flux = 0;
|
||||
|
||||
for (let pointIndex = 0; pointIndex < points.length; pointIndex++) {
|
||||
const [x0, y0] = points[pointIndex - 1] || points[pointIndex];
|
||||
const [x1, y1, pointFlux] = points[pointIndex];
|
||||
const [x2, y2] = points[pointIndex + 1] || points[pointIndex];
|
||||
if (pointFlux > flux) flux = pointFlux;
|
||||
|
||||
const offset = getOffset(utils, {flux, pointIndex, widthFactor, startingWidth});
|
||||
const angle = Math.atan2(y0 - y2, x0 - x2);
|
||||
const sinOffset = Math.sin(angle) * offset;
|
||||
const cosOffset = Math.cos(angle) * offset;
|
||||
|
||||
riverPointsLeft.push([x1 - sinOffset, y1 + cosOffset]);
|
||||
riverPointsRight.push([x1 + sinOffset, y1 - cosOffset]);
|
||||
}
|
||||
|
||||
const right = lineGen(riverPointsRight.reverse());
|
||||
let left = lineGen(riverPointsLeft);
|
||||
left = left.substring(left.indexOf("C"));
|
||||
|
||||
return round(right + left, 1);
|
||||
};
|
||||
|
||||
export const specify = function (pack, modules, utils) {
|
||||
const rivers = pack.rivers;
|
||||
if (!rivers.length) return pack;
|
||||
|
||||
const updatedRivers = rivers.map(river => ({
|
||||
...river,
|
||||
basin: getBasin(pack, river.i),
|
||||
name: getName(pack, modules, river.mouth),
|
||||
type: getType(pack, utils, river)
|
||||
}));
|
||||
|
||||
return {
|
||||
...pack,
|
||||
rivers: updatedRivers
|
||||
};
|
||||
};
|
||||
|
||||
export const getName = function (pack, modules, cell) {
|
||||
const {Names} = modules;
|
||||
return Names.getCulture(pack.cells.culture[cell]);
|
||||
};
|
||||
|
||||
// weighted arrays of river type names
|
||||
const riverTypes = {
|
||||
main: {
|
||||
big: {River: 1},
|
||||
small: {Creek: 9, River: 3, Brook: 3, Stream: 1}
|
||||
},
|
||||
fork: {
|
||||
big: {Fork: 1},
|
||||
small: {Branch: 1}
|
||||
}
|
||||
};
|
||||
|
||||
let smallLength = null;
|
||||
export const getType = function (pack, utils, {i, length, parent}) {
|
||||
const {rw, each} = utils;
|
||||
if (smallLength === null) {
|
||||
const threshold = Math.ceil(pack.rivers.length * 0.15);
|
||||
smallLength = pack.rivers.map(r => r.length || 0).sort((a, b) => a - b)[threshold];
|
||||
}
|
||||
|
||||
const isSmall = length < smallLength;
|
||||
const isFork = each(3)(i) && parent && parent !== i;
|
||||
return rw(riverTypes[isFork ? "fork" : "main"][isSmall ? "small" : "big"]);
|
||||
};
|
||||
|
||||
export const getApproximateLength = (utils, points) => {
|
||||
const {rn} = utils;
|
||||
const length = points.reduce((s, v, i, p) => s + (i ? Math.hypot(v[0] - p[i - 1][0], v[1] - p[i - 1][1]) : 0), 0);
|
||||
return rn(length, 2);
|
||||
};
|
||||
|
||||
// Real mouth width examples: Amazon 6000m, Volga 6000m, Dniepr 3000m, Mississippi 1300m, Themes 900m,
|
||||
// Danube 800m, Daugava 600m, Neva 500m, Nile 450m, Don 400m, Wisla 300m, Pripyat 150m, Bug 140m, Muchavets 40m
|
||||
export const getWidth = (utils, offset) => {
|
||||
const {rn} = utils;
|
||||
return rn((offset / 1.5) ** 1.8, 2); // mouth width in km
|
||||
};
|
||||
|
||||
// remove river and all its tributaries
|
||||
export const remove = function (pack, grid, id) {
|
||||
const cells = pack.cells;
|
||||
const riversToRemove = pack.rivers.filter(r => r.i === id || r.parent === id || r.basin === id).map(r => r.i);
|
||||
|
||||
// Update cells data
|
||||
cells.r.forEach((r, i) => {
|
||||
if (!r || !riversToRemove.includes(r)) return;
|
||||
cells.r[i] = 0;
|
||||
cells.fl[i] = grid.cells.prec[cells.g[i]];
|
||||
cells.conf[i] = 0;
|
||||
});
|
||||
|
||||
const updatedRivers = pack.rivers.filter(r => !riversToRemove.includes(r.i));
|
||||
|
||||
return {
|
||||
...pack,
|
||||
rivers: updatedRivers
|
||||
};
|
||||
};
|
||||
|
||||
export const getBasin = function (pack, r) {
|
||||
const parent = pack.rivers.find(river => river.i === r)?.parent;
|
||||
if (!parent || r === parent) return r;
|
||||
return getBasin(pack, parent);
|
||||
};
|
||||
|
||||
export const getNextId = function (rivers) {
|
||||
return rivers.length ? Math.max(...rivers.map(r => r.i)) + 1 : 1;
|
||||
};
|
||||
712
procedural/src/engine/modules/routes-generator.js
Normal file
712
procedural/src/engine/modules/routes-generator.js
Normal file
|
|
@ -0,0 +1,712 @@
|
|||
const ROUTES_SHARP_ANGLE = 135;
|
||||
const ROUTES_VERY_SHARP_ANGLE = 115;
|
||||
|
||||
const MIN_PASSABLE_SEA_TEMP = -4;
|
||||
const ROUTE_TYPE_MODIFIERS = {
|
||||
"-1": 1, // coastline
|
||||
"-2": 1.8, // sea
|
||||
"-3": 4, // open sea
|
||||
"-4": 6, // ocean
|
||||
default: 8 // far ocean
|
||||
};
|
||||
|
||||
export function generate(pack, grid, utils, lockedRoutes = []) {
|
||||
const { dist2, findPath, findCell, rn } = utils;
|
||||
const { capitalsByFeature, burgsByFeature, portsByFeature } = sortBurgsByFeature(pack.burgs);
|
||||
|
||||
const connections = new Map();
|
||||
lockedRoutes.forEach(route => addConnections(route.points.map(p => p[2])));
|
||||
|
||||
const mainRoads = generateMainRoads();
|
||||
const trails = generateTrails();
|
||||
const seaRoutes = generateSeaRoutes();
|
||||
|
||||
const routes = createRoutesData(lockedRoutes);
|
||||
const cellRoutes = buildLinks(routes);
|
||||
|
||||
return {
|
||||
routes,
|
||||
cellRoutes
|
||||
};
|
||||
|
||||
function sortBurgsByFeature(burgs) {
|
||||
const burgsByFeature = {};
|
||||
const capitalsByFeature = {};
|
||||
const portsByFeature = {};
|
||||
|
||||
const addBurg = (object, feature, burg) => {
|
||||
if (!object[feature]) object[feature] = [];
|
||||
object[feature].push(burg);
|
||||
};
|
||||
|
||||
for (const burg of burgs) {
|
||||
if (burg.i && !burg.removed) {
|
||||
const { feature, capital, port } = burg;
|
||||
addBurg(burgsByFeature, feature, burg);
|
||||
if (capital) addBurg(capitalsByFeature, feature, burg);
|
||||
if (port) addBurg(portsByFeature, port, burg);
|
||||
}
|
||||
}
|
||||
|
||||
return { burgsByFeature, capitalsByFeature, portsByFeature };
|
||||
}
|
||||
|
||||
function generateMainRoads() {
|
||||
const mainRoads = [];
|
||||
|
||||
for (const [key, featureCapitals] of Object.entries(capitalsByFeature)) {
|
||||
const points = featureCapitals.map(burg => [burg.x, burg.y]);
|
||||
const urquhartEdges = calculateUrquhartEdges(points);
|
||||
urquhartEdges.forEach(([fromId, toId]) => {
|
||||
const start = featureCapitals[fromId].cell;
|
||||
const exit = featureCapitals[toId].cell;
|
||||
|
||||
const segments = findPathSegments({ isWater: false, connections, start, exit });
|
||||
for (const segment of segments) {
|
||||
addConnections(segment);
|
||||
mainRoads.push({ feature: Number(key), cells: segment });
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return mainRoads;
|
||||
}
|
||||
|
||||
function generateTrails() {
|
||||
const trails = [];
|
||||
|
||||
for (const [key, featureBurgs] of Object.entries(burgsByFeature)) {
|
||||
const points = featureBurgs.map(burg => [burg.x, burg.y]);
|
||||
const urquhartEdges = calculateUrquhartEdges(points);
|
||||
urquhartEdges.forEach(([fromId, toId]) => {
|
||||
const start = featureBurgs[fromId].cell;
|
||||
const exit = featureBurgs[toId].cell;
|
||||
|
||||
const segments = findPathSegments({ isWater: false, connections, start, exit });
|
||||
for (const segment of segments) {
|
||||
addConnections(segment);
|
||||
trails.push({ feature: Number(key), cells: segment });
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return trails;
|
||||
}
|
||||
|
||||
function generateSeaRoutes() {
|
||||
const seaRoutes = [];
|
||||
|
||||
for (const [featureId, featurePorts] of Object.entries(portsByFeature)) {
|
||||
const points = featurePorts.map(burg => [burg.x, burg.y]);
|
||||
const urquhartEdges = calculateUrquhartEdges(points);
|
||||
|
||||
urquhartEdges.forEach(([fromId, toId]) => {
|
||||
const start = featurePorts[fromId].cell;
|
||||
const exit = featurePorts[toId].cell;
|
||||
const segments = findPathSegments({ isWater: true, connections, start, exit });
|
||||
for (const segment of segments) {
|
||||
addConnections(segment);
|
||||
seaRoutes.push({ feature: Number(featureId), cells: segment });
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return seaRoutes;
|
||||
}
|
||||
|
||||
function addConnections(segment) {
|
||||
for (let i = 0; i < segment.length; i++) {
|
||||
const cellId = segment[i];
|
||||
const nextCellId = segment[i + 1];
|
||||
if (nextCellId) {
|
||||
connections.set(`${cellId}-${nextCellId}`, true);
|
||||
connections.set(`${nextCellId}-${cellId}`, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function findPathSegments({ isWater, connections, start, exit }) {
|
||||
const getCost = createCostEvaluator({ isWater, connections });
|
||||
const pathCells = findPath(start, current => current === exit, getCost);
|
||||
if (!pathCells) return [];
|
||||
const segments = getRouteSegments(pathCells, connections);
|
||||
return segments;
|
||||
}
|
||||
|
||||
function createRoutesData(routes) {
|
||||
const pointsArray = preparePointsArray();
|
||||
|
||||
for (const { feature, cells, merged } of mergeRoutes(mainRoads)) {
|
||||
if (merged) continue;
|
||||
const points = getPoints("roads", cells, pointsArray);
|
||||
routes.push({ i: routes.length, group: "roads", feature, points });
|
||||
}
|
||||
|
||||
for (const { feature, cells, merged } of mergeRoutes(trails)) {
|
||||
if (merged) continue;
|
||||
const points = getPoints("trails", cells, pointsArray);
|
||||
routes.push({ i: routes.length, group: "trails", feature, points });
|
||||
}
|
||||
|
||||
for (const { feature, cells, merged } of mergeRoutes(seaRoutes)) {
|
||||
if (merged) continue;
|
||||
const points = getPoints("searoutes", cells, pointsArray);
|
||||
routes.push({ i: routes.length, group: "searoutes", feature, points });
|
||||
}
|
||||
|
||||
return routes;
|
||||
}
|
||||
|
||||
// merge routes so that the last cell of one route is the first cell of the next route
|
||||
function mergeRoutes(routes) {
|
||||
let routesMerged = 0;
|
||||
|
||||
for (let i = 0; i < routes.length; i++) {
|
||||
const thisRoute = routes[i];
|
||||
if (thisRoute.merged) continue;
|
||||
|
||||
for (let j = i + 1; j < routes.length; j++) {
|
||||
const nextRoute = routes[j];
|
||||
if (nextRoute.merged) continue;
|
||||
|
||||
if (nextRoute.cells.at(0) === thisRoute.cells.at(-1)) {
|
||||
routesMerged++;
|
||||
thisRoute.cells = thisRoute.cells.concat(nextRoute.cells.slice(1));
|
||||
nextRoute.merged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return routesMerged > 1 ? mergeRoutes(routes) : routes;
|
||||
}
|
||||
|
||||
function createCostEvaluator({ isWater, connections }) {
|
||||
return isWater ? getWaterPathCost : getLandPathCost;
|
||||
|
||||
function getLandPathCost(current, next) {
|
||||
if (pack.cells.h[next] < 20) return Infinity; // ignore water cells
|
||||
|
||||
const habitability = utils.biomesData.habitability[pack.cells.biome[next]];
|
||||
if (!habitability) return Infinity; // inhabitable cells are not passable (e.g. glacier)
|
||||
|
||||
const distanceCost = dist2(pack.cells.p[current], pack.cells.p[next]);
|
||||
const habitabilityModifier = 1 + Math.max(100 - habitability, 0) / 1000; // [1, 1.1];
|
||||
const heightModifier = 1 + Math.max(pack.cells.h[next] - 25, 25) / 25; // [1, 3];
|
||||
const connectionModifier = connections.has(`${current}-${next}`) ? 0.5 : 1;
|
||||
const burgModifier = pack.cells.burg[next] ? 1 : 3;
|
||||
|
||||
const pathCost = distanceCost * habitabilityModifier * heightModifier * connectionModifier * burgModifier;
|
||||
return pathCost;
|
||||
}
|
||||
|
||||
function getWaterPathCost(current, next) {
|
||||
if (pack.cells.h[next] >= 20) return Infinity; // ignore land cells
|
||||
if (grid.cells.temp[pack.cells.g[next]] < MIN_PASSABLE_SEA_TEMP) return Infinity; // ignore too cold cells
|
||||
|
||||
const distanceCost = dist2(pack.cells.p[current], pack.cells.p[next]);
|
||||
const typeModifier = ROUTE_TYPE_MODIFIERS[pack.cells.t[next]] || ROUTE_TYPE_MODIFIERS.default;
|
||||
const connectionModifier = connections.has(`${current}-${next}`) ? 0.5 : 1;
|
||||
|
||||
const pathCost = distanceCost * typeModifier * connectionModifier;
|
||||
return pathCost;
|
||||
}
|
||||
}
|
||||
|
||||
function preparePointsArray() {
|
||||
const { cells, burgs } = pack;
|
||||
return cells.p.map(([x, y], cellId) => {
|
||||
const burgId = cells.burg[cellId];
|
||||
if (burgId) return [burgs[burgId].x, burgs[burgId].y];
|
||||
return [x, y];
|
||||
});
|
||||
}
|
||||
|
||||
function getPoints(group, cells, points) {
|
||||
const data = cells.map(cellId => [...points[cellId], cellId]);
|
||||
|
||||
// resolve sharp angles
|
||||
if (group !== "searoutes") {
|
||||
for (let i = 1; i < cells.length - 1; i++) {
|
||||
const cellId = cells[i];
|
||||
if (pack.cells.burg[cellId]) continue;
|
||||
|
||||
const [prevX, prevY] = data[i - 1];
|
||||
const [currX, currY] = data[i];
|
||||
const [nextX, nextY] = data[i + 1];
|
||||
|
||||
const dAx = prevX - currX;
|
||||
const dAy = prevY - currY;
|
||||
const dBx = nextX - currX;
|
||||
const dBy = nextY - currY;
|
||||
const angle = Math.abs((Math.atan2(dAx * dBy - dAy * dBx, dAx * dBx + dAy * dBy) * 180) / Math.PI);
|
||||
|
||||
if (angle < ROUTES_SHARP_ANGLE) {
|
||||
const middleX = (prevX + nextX) / 2;
|
||||
const middleY = (prevY + nextY) / 2;
|
||||
let newX, newY;
|
||||
|
||||
if (angle < ROUTES_VERY_SHARP_ANGLE) {
|
||||
newX = rn((currX + middleX * 2) / 3, 2);
|
||||
newY = rn((currY + middleY * 2) / 3, 2);
|
||||
} else {
|
||||
newX = rn((currX + middleX) / 2, 2);
|
||||
newY = rn((currY + middleY) / 2, 2);
|
||||
}
|
||||
|
||||
if (findCell(newX, newY) === cellId) {
|
||||
data[i] = [newX, newY, cellId];
|
||||
points[cellId] = [data[i][0], data[i][1]]; // change cell coordinate for all routes
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return data; // [[x, y, cell], [x, y, cell]];
|
||||
}
|
||||
|
||||
function getRouteSegments(pathCells, connections) {
|
||||
const segments = [];
|
||||
let segment = [];
|
||||
|
||||
for (let i = 0; i < pathCells.length; i++) {
|
||||
const cellId = pathCells[i];
|
||||
const nextCellId = pathCells[i + 1];
|
||||
const isConnected = connections.has(`${cellId}-${nextCellId}`) || connections.has(`${nextCellId}-${cellId}`);
|
||||
|
||||
if (isConnected) {
|
||||
if (segment.length) {
|
||||
// segment stepped into existing segment
|
||||
segment.push(pathCells[i]);
|
||||
segments.push(segment);
|
||||
segment = [];
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
segment.push(pathCells[i]);
|
||||
}
|
||||
|
||||
if (segment.length > 1) segments.push(segment);
|
||||
|
||||
return segments;
|
||||
}
|
||||
|
||||
// Urquhart graph is obtained by removing the longest edge from each triangle in the Delaunay triangulation
|
||||
// this gives us an aproximation of a desired road network, i.e. connections between burgs
|
||||
// code from https://observablehq.com/@mbostock/urquhart-graph
|
||||
function calculateUrquhartEdges(points) {
|
||||
const score = (p0, p1) => dist2(points[p0], points[p1]);
|
||||
|
||||
const { halfedges, triangles } = utils.Delaunator.from(points);
|
||||
const n = triangles.length;
|
||||
|
||||
const removed = new Uint8Array(n);
|
||||
const edges = [];
|
||||
|
||||
for (let e = 0; e < n; e += 3) {
|
||||
const p0 = triangles[e],
|
||||
p1 = triangles[e + 1],
|
||||
p2 = triangles[e + 2];
|
||||
|
||||
const p01 = score(p0, p1),
|
||||
p12 = score(p1, p2),
|
||||
p20 = score(p2, p0);
|
||||
|
||||
removed[
|
||||
p20 > p01 && p20 > p12
|
||||
? Math.max(e + 2, halfedges[e + 2])
|
||||
: p12 > p01 && p12 > p20
|
||||
? Math.max(e + 1, halfedges[e + 1])
|
||||
: Math.max(e, halfedges[e])
|
||||
] = 1;
|
||||
}
|
||||
|
||||
for (let e = 0; e < n; ++e) {
|
||||
if (e > halfedges[e] && !removed[e]) {
|
||||
const t0 = triangles[e];
|
||||
const t1 = triangles[e % 3 === 2 ? e - 2 : e + 1];
|
||||
edges.push([t0, t1]);
|
||||
}
|
||||
}
|
||||
|
||||
return edges;
|
||||
}
|
||||
}
|
||||
|
||||
export function buildLinks(routes) {
|
||||
const links = {};
|
||||
|
||||
for (const { points, i: routeId } of routes) {
|
||||
const cells = points.map(p => p[2]);
|
||||
|
||||
for (let i = 0; i < cells.length - 1; i++) {
|
||||
const cellId = cells[i];
|
||||
const nextCellId = cells[i + 1];
|
||||
|
||||
if (cellId !== nextCellId) {
|
||||
if (!links[cellId]) links[cellId] = {};
|
||||
links[cellId][nextCellId] = routeId;
|
||||
|
||||
if (!links[nextCellId]) links[nextCellId] = {};
|
||||
links[nextCellId][cellId] = routeId;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return links;
|
||||
}
|
||||
|
||||
// connect cell with routes system by land
|
||||
export function connect(cellId, pack, utils) {
|
||||
const { findPath } = utils;
|
||||
const getCost = createCostEvaluator({ isWater: false, connections: new Map() });
|
||||
const pathCells = findPath(cellId, isConnected, getCost);
|
||||
if (!pathCells) return null;
|
||||
|
||||
const pointsArray = preparePointsArray();
|
||||
const points = getPoints("trails", pathCells, pointsArray);
|
||||
const feature = pack.cells.f[cellId];
|
||||
const routeId = getNextId(pack.routes);
|
||||
const newRoute = { i: routeId, group: "trails", feature, points };
|
||||
|
||||
const connections = [];
|
||||
for (let i = 0; i < pathCells.length; i++) {
|
||||
const from = pathCells[i];
|
||||
const to = pathCells[i + 1];
|
||||
if (to) connections.push({ from, to, routeId });
|
||||
}
|
||||
|
||||
return { route: newRoute, connections };
|
||||
|
||||
function createCostEvaluator({ isWater, connections }) {
|
||||
const { dist2 } = utils;
|
||||
return isWater ? getWaterPathCost : getLandPathCost;
|
||||
|
||||
function getLandPathCost(current, next) {
|
||||
if (pack.cells.h[next] < 20) return Infinity; // ignore water cells
|
||||
|
||||
const habitability = utils.biomesData.habitability[pack.cells.biome[next]];
|
||||
if (!habitability) return Infinity; // inhabitable cells are not passable (e.g. glacier)
|
||||
|
||||
const distanceCost = dist2(pack.cells.p[current], pack.cells.p[next]);
|
||||
const habitabilityModifier = 1 + Math.max(100 - habitability, 0) / 1000; // [1, 1.1];
|
||||
const heightModifier = 1 + Math.max(pack.cells.h[next] - 25, 25) / 25; // [1, 3];
|
||||
const connectionModifier = connections.has(`${current}-${next}`) ? 0.5 : 1;
|
||||
const burgModifier = pack.cells.burg[next] ? 1 : 3;
|
||||
|
||||
const pathCost = distanceCost * habitabilityModifier * heightModifier * connectionModifier * burgModifier;
|
||||
return pathCost;
|
||||
}
|
||||
|
||||
function getWaterPathCost(current, next) {
|
||||
if (pack.cells.h[next] >= 20) return Infinity; // ignore land cells
|
||||
if (utils.grid.cells.temp[pack.cells.g[next]] < MIN_PASSABLE_SEA_TEMP) return Infinity; // ignore too cold cells
|
||||
|
||||
const distanceCost = dist2(pack.cells.p[current], pack.cells.p[next]);
|
||||
const typeModifier = ROUTE_TYPE_MODIFIERS[pack.cells.t[next]] || ROUTE_TYPE_MODIFIERS.default;
|
||||
const connectionModifier = connections.has(`${current}-${next}`) ? 0.5 : 1;
|
||||
|
||||
const pathCost = distanceCost * typeModifier * connectionModifier;
|
||||
return pathCost;
|
||||
}
|
||||
}
|
||||
|
||||
function preparePointsArray() {
|
||||
const { cells, burgs } = pack;
|
||||
return cells.p.map(([x, y], cellId) => {
|
||||
const burgId = cells.burg[cellId];
|
||||
if (burgId) return [burgs[burgId].x, burgs[burgId].y];
|
||||
return [x, y];
|
||||
});
|
||||
}
|
||||
|
||||
function getPoints(group, cells, points) {
|
||||
const { rn, findCell } = utils;
|
||||
const data = cells.map(cellId => [...points[cellId], cellId]);
|
||||
|
||||
// resolve sharp angles
|
||||
if (group !== "searoutes") {
|
||||
for (let i = 1; i < cells.length - 1; i++) {
|
||||
const cellId = cells[i];
|
||||
if (pack.cells.burg[cellId]) continue;
|
||||
|
||||
const [prevX, prevY] = data[i - 1];
|
||||
const [currX, currY] = data[i];
|
||||
const [nextX, nextY] = data[i + 1];
|
||||
|
||||
const dAx = prevX - currX;
|
||||
const dAy = prevY - currY;
|
||||
const dBx = nextX - currX;
|
||||
const dBy = nextY - currY;
|
||||
const angle = Math.abs((Math.atan2(dAx * dBy - dAy * dBx, dAx * dBx + dAy * dBy) * 180) / Math.PI);
|
||||
|
||||
if (angle < ROUTES_SHARP_ANGLE) {
|
||||
const middleX = (prevX + nextX) / 2;
|
||||
const middleY = (prevY + nextY) / 2;
|
||||
let newX, newY;
|
||||
|
||||
if (angle < ROUTES_VERY_SHARP_ANGLE) {
|
||||
newX = rn((currX + middleX * 2) / 3, 2);
|
||||
newY = rn((currY + middleY * 2) / 3, 2);
|
||||
} else {
|
||||
newX = rn((currX + middleX) / 2, 2);
|
||||
newY = rn((currY + middleY) / 2, 2);
|
||||
}
|
||||
|
||||
if (findCell(newX, newY) === cellId) {
|
||||
data[i] = [newX, newY, cellId];
|
||||
points[cellId] = [data[i][0], data[i][1]]; // change cell coordinate for all routes
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return data; // [[x, y, cell], [x, y, cell]];
|
||||
}
|
||||
|
||||
function isConnected(cellId) {
|
||||
const routes = pack.cells.routes;
|
||||
return routes[cellId] && Object.keys(routes[cellId]).length > 0;
|
||||
}
|
||||
}
|
||||
|
||||
// utility functions
|
||||
export function isConnected(cellId, pack) {
|
||||
const routes = pack.cells.routes;
|
||||
return routes[cellId] && Object.keys(routes[cellId]).length > 0;
|
||||
}
|
||||
|
||||
export function areConnected(from, to, pack) {
|
||||
const routeId = pack.cells.routes[from]?.[to];
|
||||
return routeId !== undefined;
|
||||
}
|
||||
|
||||
export function getRoute(from, to, pack) {
|
||||
const routeId = pack.cells.routes[from]?.[to];
|
||||
if (routeId === undefined) return null;
|
||||
|
||||
const route = pack.routes.find(route => route.i === routeId);
|
||||
if (!route) return null;
|
||||
|
||||
return route;
|
||||
}
|
||||
|
||||
export function hasRoad(cellId, pack) {
|
||||
const connections = pack.cells.routes[cellId];
|
||||
if (!connections) return false;
|
||||
|
||||
return Object.values(connections).some(routeId => {
|
||||
const route = pack.routes.find(route => route.i === routeId);
|
||||
if (!route) return false;
|
||||
return route.group === "roads";
|
||||
});
|
||||
}
|
||||
|
||||
export function isCrossroad(cellId, pack) {
|
||||
const connections = pack.cells.routes[cellId];
|
||||
if (!connections) return false;
|
||||
if (Object.keys(connections).length > 3) return true;
|
||||
const roadConnections = Object.values(connections).filter(routeId => {
|
||||
const route = pack.routes.find(route => route.i === routeId);
|
||||
return route?.group === "roads";
|
||||
});
|
||||
return roadConnections.length > 2;
|
||||
}
|
||||
|
||||
// name generator data
|
||||
const models = {
|
||||
roads: { burg_suffix: 3, prefix_suffix: 6, the_descriptor_prefix_suffix: 2, the_descriptor_burg_suffix: 1 },
|
||||
trails: { burg_suffix: 8, prefix_suffix: 1, the_descriptor_burg_suffix: 1 },
|
||||
searoutes: { burg_suffix: 4, prefix_suffix: 2, the_descriptor_prefix_suffix: 1 }
|
||||
};
|
||||
|
||||
const prefixes = [
|
||||
"King",
|
||||
"Queen",
|
||||
"Military",
|
||||
"Old",
|
||||
"New",
|
||||
"Ancient",
|
||||
"Royal",
|
||||
"Imperial",
|
||||
"Great",
|
||||
"Grand",
|
||||
"High",
|
||||
"Silver",
|
||||
"Dragon",
|
||||
"Shadow",
|
||||
"Star",
|
||||
"Mystic",
|
||||
"Whisper",
|
||||
"Eagle",
|
||||
"Golden",
|
||||
"Crystal",
|
||||
"Enchanted",
|
||||
"Frost",
|
||||
"Moon",
|
||||
"Sun",
|
||||
"Thunder",
|
||||
"Phoenix",
|
||||
"Sapphire",
|
||||
"Celestial",
|
||||
"Wandering",
|
||||
"Echo",
|
||||
"Twilight",
|
||||
"Crimson",
|
||||
"Serpent",
|
||||
"Iron",
|
||||
"Forest",
|
||||
"Flower",
|
||||
"Whispering",
|
||||
"Eternal",
|
||||
"Frozen",
|
||||
"Rain",
|
||||
"Luminous",
|
||||
"Stardust",
|
||||
"Arcane",
|
||||
"Glimmering",
|
||||
"Jade",
|
||||
"Ember",
|
||||
"Azure",
|
||||
"Gilded",
|
||||
"Divine",
|
||||
"Shadowed",
|
||||
"Cursed",
|
||||
"Moonlit",
|
||||
"Sable",
|
||||
"Everlasting",
|
||||
"Amber",
|
||||
"Nightshade",
|
||||
"Wraith",
|
||||
"Scarlet",
|
||||
"Platinum",
|
||||
"Whirlwind",
|
||||
"Obsidian",
|
||||
"Ethereal",
|
||||
"Ghost",
|
||||
"Spike",
|
||||
"Dusk",
|
||||
"Raven",
|
||||
"Spectral",
|
||||
"Burning",
|
||||
"Verdant",
|
||||
"Copper",
|
||||
"Velvet",
|
||||
"Falcon",
|
||||
"Enigma",
|
||||
"Glowing",
|
||||
"Silvered",
|
||||
"Molten",
|
||||
"Radiant",
|
||||
"Astral",
|
||||
"Wild",
|
||||
"Flame",
|
||||
"Amethyst",
|
||||
"Aurora",
|
||||
"Shadowy",
|
||||
"Solar",
|
||||
"Lunar",
|
||||
"Whisperwind",
|
||||
"Fading",
|
||||
"Titan",
|
||||
"Dawn",
|
||||
"Crystalline",
|
||||
"Jeweled",
|
||||
"Sylvan",
|
||||
"Twisted",
|
||||
"Ebon",
|
||||
"Thorn",
|
||||
"Cerulean",
|
||||
"Halcyon",
|
||||
"Infernal",
|
||||
"Storm",
|
||||
"Eldritch",
|
||||
"Sapphire",
|
||||
"Crimson",
|
||||
"Tranquil",
|
||||
"Paved"
|
||||
];
|
||||
|
||||
const descriptors = [
|
||||
"Great",
|
||||
"Shrouded",
|
||||
"Sacred",
|
||||
"Fabled",
|
||||
"Frosty",
|
||||
"Winding",
|
||||
"Echoing",
|
||||
"Serpentine",
|
||||
"Breezy",
|
||||
"Misty",
|
||||
"Rustic",
|
||||
"Silent",
|
||||
"Cobbled",
|
||||
"Cracked",
|
||||
"Shaky",
|
||||
"Obscure"
|
||||
];
|
||||
|
||||
const suffixes = {
|
||||
roads: { road: 7, route: 3, way: 2, highway: 1 },
|
||||
trails: { trail: 4, path: 1, track: 1, pass: 1 },
|
||||
searoutes: { "sea route": 5, lane: 2, passage: 1, seaway: 1 }
|
||||
};
|
||||
|
||||
export function generateName({ group, points }, pack, utils) {
|
||||
const { ra, rw, getAdjective } = utils;
|
||||
|
||||
if (points.length < 4) return "Unnamed route segment";
|
||||
|
||||
const model = rw(models[group]);
|
||||
const suffix = rw(suffixes[group]);
|
||||
|
||||
const burgName = getBurgName();
|
||||
if (model === "burg_suffix" && burgName) return `${burgName} ${suffix}`;
|
||||
if (model === "prefix_suffix") return `${ra(prefixes)} ${suffix}`;
|
||||
if (model === "the_descriptor_prefix_suffix") return `The ${ra(descriptors)} ${ra(prefixes)} ${suffix}`;
|
||||
if (model === "the_descriptor_burg_suffix" && burgName) return `The ${ra(descriptors)} ${burgName} ${suffix}`;
|
||||
return "Unnamed route";
|
||||
|
||||
function getBurgName() {
|
||||
const priority = [points.at(-1), points.at(0), points.slice(1, -1).reverse()];
|
||||
for (const [_x, _y, cellId] of priority) {
|
||||
const burgId = pack.cells.burg[cellId];
|
||||
if (burgId) return getAdjective(pack.burgs[burgId].name);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export function getNextId(routes) {
|
||||
return routes.length ? Math.max(...routes.map(r => r.i)) + 1 : 0;
|
||||
}
|
||||
|
||||
export function remove(route, pack) {
|
||||
const routes = pack.cells.routes;
|
||||
const removedConnections = [];
|
||||
|
||||
for (const point of route.points) {
|
||||
const from = point[2];
|
||||
if (!routes[from]) continue;
|
||||
|
||||
for (const [to, routeId] of Object.entries(routes[from])) {
|
||||
if (routeId === route.i) {
|
||||
removedConnections.push({ from, to });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const updatedRoutes = pack.routes.filter(r => r.i !== route.i);
|
||||
const updatedCellRoutes = { ...routes };
|
||||
|
||||
removedConnections.forEach(({ from, to }) => {
|
||||
if (updatedCellRoutes[from]) delete updatedCellRoutes[from][to];
|
||||
if (updatedCellRoutes[to]) delete updatedCellRoutes[to][from];
|
||||
});
|
||||
|
||||
return {
|
||||
routes: updatedRoutes,
|
||||
cellRoutes: updatedCellRoutes,
|
||||
removedConnections
|
||||
};
|
||||
}
|
||||
375
procedural/src/engine/modules/submap.js
Normal file
375
procedural/src/engine/modules/submap.js
Normal file
|
|
@ -0,0 +1,375 @@
|
|||
"use strict";
|
||||
|
||||
/*
|
||||
generate new map based on an existing one (resampling parentMap)
|
||||
parentMap: {grid, pack, notes} from original map
|
||||
projection: f(Number, Number) -> [Number, Number]
|
||||
inverse: f(Number, Number) -> [Number, Number]
|
||||
scale: Number
|
||||
*/
|
||||
export function process({projection, inverse, scale}, grid, pack, notes, config, utils) {
|
||||
const {
|
||||
deepCopy, generateGrid, Features, addLakesInDeepDepressions, openNearSeaLakes,
|
||||
OceanLayers, calculateMapCoordinates, calculateTemperatures, reGraph,
|
||||
createDefaultRuler, Rivers, BurgsAndStates, Routes, Provinces, Markers,
|
||||
isWater, findCell, findAll, rn, unique, d3, lineclip, getPolesOfInaccessibility,
|
||||
WARN
|
||||
} = utils;
|
||||
|
||||
const parentMap = {grid: deepCopy(grid), pack: deepCopy(pack), notes: deepCopy(notes)};
|
||||
const riversData = saveRiversData(parentMap.pack.rivers, Rivers);
|
||||
|
||||
const newGrid = generateGrid();
|
||||
const newPack = {};
|
||||
const newNotes = parentMap.notes;
|
||||
|
||||
resamplePrimaryGridData(parentMap, inverse, scale, newGrid, d3, isWater);
|
||||
|
||||
Features.markupGrid(newGrid);
|
||||
addLakesInDeepDepressions(newGrid);
|
||||
openNearSeaLakes(newGrid);
|
||||
|
||||
OceanLayers(newGrid);
|
||||
calculateMapCoordinates(newGrid);
|
||||
calculateTemperatures(newGrid);
|
||||
|
||||
reGraph(newGrid, newPack);
|
||||
Features.markupPack(newPack);
|
||||
createDefaultRuler(newPack);
|
||||
|
||||
restoreCellData(parentMap, inverse, scale, newPack, d3, isWater, groupCellsByType);
|
||||
restoreRivers(riversData, projection, scale, newPack, isInMap, findCell, rn, Rivers, config);
|
||||
restoreCultures(parentMap, projection, newPack, getPolesOfInaccessibility, findCell, rn, isInMap, config);
|
||||
restoreBurgs(parentMap, projection, scale, newPack, d3, groupCellsByType, findCell, isWater, isInMap, rn, BurgsAndStates, WARN, config);
|
||||
restoreStates(parentMap, projection, newPack, BurgsAndStates, findCell, isInMap, rn, config);
|
||||
restoreRoutes(parentMap, projection, newPack, isInMap, rn, findCell, lineclip, Routes, config);
|
||||
restoreReligions(parentMap, projection, newPack, getPolesOfInaccessibility, findCell, rn, isInMap, config);
|
||||
restoreProvinces(parentMap, newPack, Provinces, findCell);
|
||||
restoreFeatureDetails(parentMap, inverse, newPack);
|
||||
restoreMarkers(parentMap, projection, newPack, isInMap, findCell, rn, Markers);
|
||||
restoreZones(parentMap, projection, scale, newPack, isInMap, findCell, findAll, unique);
|
||||
|
||||
return {
|
||||
grid: newGrid,
|
||||
pack: newPack,
|
||||
notes: newNotes
|
||||
};
|
||||
}
|
||||
|
||||
function resamplePrimaryGridData(parentMap, inverse, scale, grid, d3, isWater) {
|
||||
grid.cells.h = new Uint8Array(grid.points.length);
|
||||
grid.cells.temp = new Int8Array(grid.points.length);
|
||||
grid.cells.prec = new Uint8Array(grid.points.length);
|
||||
|
||||
grid.points.forEach(([x, y], newGridCell) => {
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentPackCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
const parentGridCell = parentMap.pack.cells.g[parentPackCell];
|
||||
|
||||
grid.cells.h[newGridCell] = parentMap.grid.cells.h[parentGridCell];
|
||||
grid.cells.temp[newGridCell] = parentMap.grid.cells.temp[parentGridCell];
|
||||
grid.cells.prec[newGridCell] = parentMap.grid.cells.prec[parentGridCell];
|
||||
});
|
||||
|
||||
if (scale >= 2) smoothHeightmap(grid, d3, isWater);
|
||||
}
|
||||
|
||||
function smoothHeightmap(grid, d3, isWater) {
|
||||
grid.cells.h.forEach((height, newGridCell) => {
|
||||
const heights = [height, ...grid.cells.c[newGridCell].map(c => grid.cells.h[c])];
|
||||
const meanHeight = d3.mean(heights);
|
||||
grid.cells.h[newGridCell] = isWater(grid, newGridCell) ? Math.min(meanHeight, 19) : Math.max(meanHeight, 20);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCellData(parentMap, inverse, scale, pack, d3, isWater, groupCellsByType) {
|
||||
pack.cells.biome = new Uint8Array(pack.cells.i.length);
|
||||
pack.cells.fl = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.s = new Int16Array(pack.cells.i.length);
|
||||
pack.cells.pop = new Float32Array(pack.cells.i.length);
|
||||
pack.cells.culture = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.state = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.burg = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.religion = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.province = new Uint16Array(pack.cells.i.length);
|
||||
|
||||
const parentPackCellGroups = groupCellsByType(parentMap.pack);
|
||||
const parentPackLandCellsQuadtree = d3.quadtree(parentPackCellGroups.land);
|
||||
|
||||
for (const newPackCell of pack.cells.i) {
|
||||
const [x, y] = inverse(...pack.cells.p[newPackCell]);
|
||||
if (isWater(pack, newPackCell)) continue;
|
||||
|
||||
const parentPackCell = parentPackLandCellsQuadtree.find(x, y, Infinity)[2];
|
||||
const parentCellArea = parentMap.pack.cells.area[parentPackCell];
|
||||
const areaRatio = pack.cells.area[newPackCell] / parentCellArea;
|
||||
const scaleRatio = areaRatio / scale;
|
||||
|
||||
pack.cells.biome[newPackCell] = parentMap.pack.cells.biome[parentPackCell];
|
||||
pack.cells.fl[newPackCell] = parentMap.pack.cells.fl[parentPackCell];
|
||||
pack.cells.s[newPackCell] = parentMap.pack.cells.s[parentPackCell] * scaleRatio;
|
||||
pack.cells.pop[newPackCell] = parentMap.pack.cells.pop[parentPackCell] * scaleRatio;
|
||||
pack.cells.culture[newPackCell] = parentMap.pack.cells.culture[parentPackCell];
|
||||
pack.cells.state[newPackCell] = parentMap.pack.cells.state[parentPackCell];
|
||||
pack.cells.religion[newPackCell] = parentMap.pack.cells.religion[parentPackCell];
|
||||
pack.cells.province[newPackCell] = parentMap.pack.cells.province[parentPackCell];
|
||||
}
|
||||
}
|
||||
|
||||
function saveRiversData(parentRivers, Rivers) {
|
||||
return parentRivers.map(river => {
|
||||
const meanderedPoints = Rivers.addMeandering(river.cells, river.points);
|
||||
return {...river, meanderedPoints};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRivers(riversData, projection, scale, pack, isInMap, findCell, rn, Rivers, config) {
|
||||
pack.cells.r = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.conf = new Uint8Array(pack.cells.i.length);
|
||||
|
||||
pack.rivers = riversData
|
||||
.map(river => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
river.meanderedPoints.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y, config);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const cells = points.map(point => findCell(...point));
|
||||
cells.forEach(cellId => {
|
||||
if (pack.cells.r[cellId]) pack.cells.conf[cellId] = 1;
|
||||
pack.cells.r[cellId] = river.i;
|
||||
});
|
||||
|
||||
const widthFactor = river.widthFactor * scale;
|
||||
return {...river, cells, points, source: cells.at(0), mouth: cells.at(-2), widthFactor};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.rivers.forEach(river => {
|
||||
river.basin = Rivers.getBasin(river.i);
|
||||
river.length = Rivers.getApproximateLength(river.points);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCultures(parentMap, projection, pack, getPolesOfInaccessibility, findCell, rn, isInMap, config) {
|
||||
const validCultures = new Set(pack.cells.culture);
|
||||
const culturePoles = getPolesOfInaccessibility(pack, cellId => pack.cells.culture[cellId]);
|
||||
pack.cultures = parentMap.pack.cultures.map(culture => {
|
||||
if (!culture.i || culture.removed) return culture;
|
||||
if (!validCultures.has(culture.i)) return {...culture, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[culture.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y, config) ? [x, y] : culturePoles[culture.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...culture, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreBurgs(parentMap, projection, scale, pack, d3, groupCellsByType, findCell, isWater, isInMap, rn, BurgsAndStates, WARN, config) {
|
||||
const packLandCellsQuadtree = d3.quadtree(groupCellsByType(pack).land);
|
||||
const findLandCell = (x, y) => packLandCellsQuadtree.find(x, y, Infinity)?.[2];
|
||||
|
||||
pack.burgs = parentMap.pack.burgs.map(burg => {
|
||||
if (!burg.i || burg.removed) return burg;
|
||||
burg.population *= scale; // adjust for populationRate change
|
||||
|
||||
const [xp, yp] = projection(burg.x, burg.y);
|
||||
if (!isInMap(xp, yp, config)) return {...burg, removed: true, lock: false};
|
||||
|
||||
const closestCell = findCell(xp, yp);
|
||||
const cell = isWater(pack, closestCell) ? findLandCell(xp, yp) : closestCell;
|
||||
|
||||
if (pack.cells.burg[cell]) {
|
||||
WARN && console.warn(`Cell ${cell} already has a burg. Removing burg ${burg.name} (${burg.i})`);
|
||||
return {...burg, removed: true, lock: false};
|
||||
}
|
||||
|
||||
pack.cells.burg[cell] = burg.i;
|
||||
const [x, y] = getBurgCoordinates(burg, closestCell, cell, xp, yp, pack, BurgsAndStates, rn);
|
||||
return {...burg, cell, x, y};
|
||||
});
|
||||
|
||||
function getBurgCoordinates(burg, closestCell, cell, xp, yp, pack, BurgsAndStates, rn) {
|
||||
const haven = pack.cells.haven[cell];
|
||||
if (burg.port && haven) return BurgsAndStates.getCloseToEdgePoint(cell, haven);
|
||||
|
||||
if (closestCell !== cell) return pack.cells.p[cell];
|
||||
return [rn(xp, 2), rn(yp, 2)];
|
||||
}
|
||||
}
|
||||
|
||||
function restoreStates(parentMap, projection, pack, BurgsAndStates, findCell, isInMap, rn, config) {
|
||||
const validStates = new Set(pack.cells.state);
|
||||
pack.states = parentMap.pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
if (validStates.has(state.i)) return state;
|
||||
return {...state, removed: true, lock: false};
|
||||
});
|
||||
|
||||
BurgsAndStates.getPoles();
|
||||
const regimentCellsMap = {};
|
||||
const VERTICAL_GAP = 8;
|
||||
|
||||
pack.states = pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
|
||||
const capital = pack.burgs[state.capital];
|
||||
state.center = !capital || capital.removed ? findCell(...state.pole) : capital.cell;
|
||||
|
||||
const military = state.military.map(regiment => {
|
||||
const cellCoords = projection(...parentMap.pack.cells.p[regiment.cell]);
|
||||
const cell = isInMap(...cellCoords, config) ? findCell(...cellCoords) : state.center;
|
||||
|
||||
const [xPos, yPos] = projection(regiment.x, regiment.y);
|
||||
const [xBase, yBase] = projection(regiment.bx, regiment.by);
|
||||
const [xCell, yCell] = pack.cells.p[cell];
|
||||
|
||||
const regsOnCell = regimentCellsMap[cell] || 0;
|
||||
regimentCellsMap[cell] = regsOnCell + 1;
|
||||
|
||||
const name =
|
||||
isInMap(xPos, yPos, config) || regiment.name.includes("[relocated]") ? regiment.name : `[relocated] ${regiment.name}`;
|
||||
|
||||
const pos = isInMap(xPos, yPos, config)
|
||||
? {x: rn(xPos, 2), y: rn(yPos, 2)}
|
||||
: {x: xCell, y: yCell + regsOnCell * VERTICAL_GAP};
|
||||
|
||||
const base = isInMap(xBase, yBase, config) ? {bx: rn(xBase, 2), by: rn(yBase, 2)} : {bx: xCell, by: yCell};
|
||||
|
||||
return {...regiment, cell, name, ...base, ...pos};
|
||||
});
|
||||
|
||||
const neighbors = state.neighbors.filter(stateId => validStates.has(stateId));
|
||||
return {...state, neighbors, military};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRoutes(parentMap, projection, pack, isInMap, rn, findCell, lineclip, Routes, config) {
|
||||
pack.routes = parentMap.pack.routes
|
||||
.map(route => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
route.points.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y, config);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const bbox = [0, 0, config.graphWidth, config.graphHeight];
|
||||
const clipped = lineclip(points, bbox)[0].map(([x, y]) => [rn(x, 2), rn(y, 2), findCell(x, y)]);
|
||||
const firstCell = clipped[0][2];
|
||||
const feature = pack.cells.f[firstCell];
|
||||
return {...route, feature, points: clipped};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.cells.routes = Routes.buildLinks(pack.routes);
|
||||
}
|
||||
|
||||
function restoreReligions(parentMap, projection, pack, getPolesOfInaccessibility, findCell, rn, isInMap, config) {
|
||||
const validReligions = new Set(pack.cells.religion);
|
||||
const religionPoles = getPolesOfInaccessibility(pack, cellId => pack.cells.religion[cellId]);
|
||||
|
||||
pack.religions = parentMap.pack.religions.map(religion => {
|
||||
if (!religion.i || religion.removed) return religion;
|
||||
if (!validReligions.has(religion.i)) return {...religion, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[religion.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y, config) ? [x, y] : religionPoles[religion.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...religion, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreProvinces(parentMap, pack, Provinces, findCell) {
|
||||
const validProvinces = new Set(pack.cells.province);
|
||||
pack.provinces = parentMap.pack.provinces.map(province => {
|
||||
if (!province.i || province.removed) return province;
|
||||
if (!validProvinces.has(province.i)) return {...province, removed: true, lock: false};
|
||||
|
||||
return province;
|
||||
});
|
||||
|
||||
Provinces.getPoles();
|
||||
|
||||
pack.provinces.forEach(province => {
|
||||
if (!province.i || province.removed) return;
|
||||
const capital = pack.burgs[province.burg];
|
||||
province.center = !capital?.removed ? capital.cell : findCell(...province.pole);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreMarkers(parentMap, projection, pack, isInMap, findCell, rn, Markers) {
|
||||
pack.markers = parentMap.pack.markers;
|
||||
pack.markers.forEach(marker => {
|
||||
const [x, y] = projection(marker.x, marker.y);
|
||||
if (!isInMap(x, y)) Markers.deleteMarker(marker.i);
|
||||
|
||||
const cell = findCell(x, y);
|
||||
marker.x = rn(x, 2);
|
||||
marker.y = rn(y, 2);
|
||||
marker.cell = cell;
|
||||
});
|
||||
}
|
||||
|
||||
function restoreZones(parentMap, projection, scale, pack, isInMap, findCell, findAll, unique) {
|
||||
const getSearchRadius = cellId => Math.sqrt(parentMap.pack.cells.area[cellId] / Math.PI) * scale;
|
||||
|
||||
pack.zones = parentMap.pack.zones.map(zone => {
|
||||
const cells = zone.cells
|
||||
.map(cellId => {
|
||||
const [x, y] = projection(...parentMap.pack.cells.p[cellId]);
|
||||
if (!isInMap(x, y)) return null;
|
||||
return findAll(x, y, getSearchRadius(cellId));
|
||||
})
|
||||
.filter(Boolean)
|
||||
.flat();
|
||||
|
||||
return {...zone, cells: unique(cells)};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreFeatureDetails(parentMap, inverse, pack) {
|
||||
pack.features.forEach(feature => {
|
||||
if (!feature) return;
|
||||
const [x, y] = pack.cells.p[feature.firstCell];
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
if (parentCell === undefined) return;
|
||||
const parentFeature = parentMap.pack.features[parentMap.pack.cells.f[parentCell]];
|
||||
|
||||
if (parentFeature.group) feature.group = parentFeature.group;
|
||||
if (parentFeature.name) feature.name = parentFeature.name;
|
||||
if (parentFeature.height) feature.height = parentFeature.height;
|
||||
});
|
||||
}
|
||||
|
||||
function groupCellsByType(graph) {
|
||||
return graph.cells.p.reduce(
|
||||
(acc, [x, y], cellId) => {
|
||||
const group = isWater(graph, cellId) ? "water" : "land";
|
||||
acc[group].push([x, y, cellId]);
|
||||
return acc;
|
||||
},
|
||||
{land: [], water: []}
|
||||
);
|
||||
}
|
||||
|
||||
function isWater(graph, cellId) {
|
||||
return graph.cells.h[cellId] < 20;
|
||||
}
|
||||
|
||||
function isInMap(x, y, config) {
|
||||
return x >= 0 && x <= config.graphWidth && y >= 0 && y <= config.graphHeight;
|
||||
}
|
||||
135
procedural/src/engine/modules/voronoi.js
Normal file
135
procedural/src/engine/modules/voronoi.js
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
export class Voronoi {
|
||||
/**
|
||||
* Creates a Voronoi diagram from the given Delaunator, a list of points, and the number of points. The Voronoi diagram is constructed using (I think) the {@link https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm |Bowyer-Watson Algorithm}
|
||||
* The {@link https://github.com/mapbox/delaunator/ |Delaunator} library uses {@link https://en.wikipedia.org/wiki/Doubly_connected_edge_list |half-edges} to represent the relationship between points and triangles.
|
||||
* @param {{triangles: Uint32Array, halfedges: Int32Array}} delaunay A {@link https://github.com/mapbox/delaunator/blob/master/index.js |Delaunator} instance.
|
||||
* @param {[number, number][]} points A list of coordinates.
|
||||
* @param {number} pointsN The number of points.
|
||||
*/
|
||||
constructor(delaunay, points, pointsN) {
|
||||
this.delaunay = delaunay;
|
||||
this.points = points;
|
||||
this.pointsN = pointsN;
|
||||
this.cells = { v: [], c: [], b: [] }; // voronoi cells: v = cell vertices, c = adjacent cells, b = near-border cell
|
||||
this.vertices = { p: [], v: [], c: [] }; // cells vertices: p = vertex coordinates, v = neighboring vertices, c = adjacent cells
|
||||
|
||||
// Half-edges are the indices into the delaunator outputs:
|
||||
// delaunay.triangles[e] gives the point ID where the half-edge starts
|
||||
// delaunay.halfedges[e] returns either the opposite half-edge in the adjacent triangle, or -1 if there's not an adjacent triangle.
|
||||
for (let e = 0; e < this.delaunay.triangles.length; e++) {
|
||||
|
||||
const p = this.delaunay.triangles[this.nextHalfedge(e)];
|
||||
if (p < this.pointsN && !this.cells.c[p]) {
|
||||
const edges = this.edgesAroundPoint(e);
|
||||
this.cells.v[p] = edges.map(e => this.triangleOfEdge(e)); // cell: adjacent vertex
|
||||
this.cells.c[p] = edges.map(e => this.delaunay.triangles[e]).filter(c => c < this.pointsN); // cell: adjacent valid cells
|
||||
this.cells.b[p] = edges.length > this.cells.c[p].length ? 1 : 0; // cell: is border
|
||||
}
|
||||
|
||||
const t = this.triangleOfEdge(e);
|
||||
if (!this.vertices.p[t]) {
|
||||
this.vertices.p[t] = this.triangleCenter(t); // vertex: coordinates
|
||||
this.vertices.v[t] = this.trianglesAdjacentToTriangle(t); // vertex: adjacent vertices
|
||||
this.vertices.c[t] = this.pointsOfTriangle(t); // vertex: adjacent cells
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the IDs of the points comprising the given triangle. Taken from {@link https://mapbox.github.io/delaunator/#triangle-to-points| the Delaunator docs.}
|
||||
* @param {number} t The index of the triangle
|
||||
* @returns {[number, number, number]} The IDs of the points comprising the given triangle.
|
||||
*/
|
||||
pointsOfTriangle(t) {
|
||||
return this.edgesOfTriangle(t).map(edge => this.delaunay.triangles[edge]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Identifies what triangles are adjacent to the given triangle. Taken from {@link https://mapbox.github.io/delaunator/#triangle-to-triangles| the Delaunator docs.}
|
||||
* @param {number} t The index of the triangle
|
||||
* @returns {number[]} The indices of the triangles that share half-edges with this triangle.
|
||||
*/
|
||||
trianglesAdjacentToTriangle(t) {
|
||||
let triangles = [];
|
||||
for (let edge of this.edgesOfTriangle(t)) {
|
||||
let opposite = this.delaunay.halfedges[edge];
|
||||
triangles.push(this.triangleOfEdge(opposite));
|
||||
}
|
||||
return triangles;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the indices of all the incoming and outgoing half-edges that touch the given point. Taken from {@link https://mapbox.github.io/delaunator/#point-to-edges| the Delaunator docs.}
|
||||
* @param {number} start The index of an incoming half-edge that leads to the desired point
|
||||
* @returns {number[]} The indices of all half-edges (incoming or outgoing) that touch the point.
|
||||
*/
|
||||
edgesAroundPoint(start) {
|
||||
const result = [];
|
||||
let incoming = start;
|
||||
do {
|
||||
result.push(incoming);
|
||||
const outgoing = this.nextHalfedge(incoming);
|
||||
incoming = this.delaunay.halfedges[outgoing];
|
||||
} while (incoming !== -1 && incoming !== start && result.length < 20);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the center of the triangle located at the given index.
|
||||
* @param {number} t The index of the triangle
|
||||
* @returns {[number, number]}
|
||||
*/
|
||||
triangleCenter(t) {
|
||||
let vertices = this.pointsOfTriangle(t).map(p => this.points[p]);
|
||||
return this.circumcenter(vertices[0], vertices[1], vertices[2]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves all of the half-edges for a specific triangle `t`. Taken from {@link https://mapbox.github.io/delaunator/#edge-and-triangle| the Delaunator docs.}
|
||||
* @param {number} t The index of the triangle
|
||||
* @returns {[number, number, number]} The edges of the triangle.
|
||||
*/
|
||||
edgesOfTriangle(t) { return [3 * t, 3 * t + 1, 3 * t + 2]; }
|
||||
|
||||
/**
|
||||
* Enables lookup of a triangle, given one of the half-edges of that triangle. Taken from {@link https://mapbox.github.io/delaunator/#edge-and-triangle| the Delaunator docs.}
|
||||
* @param {number} e The index of the edge
|
||||
* @returns {number} The index of the triangle
|
||||
*/
|
||||
triangleOfEdge(e) { return Math.floor(e / 3); }
|
||||
|
||||
/**
|
||||
* Moves to the next half-edge of a triangle, given the current half-edge's index. Taken from {@link https://mapbox.github.io/delaunator/#edge-to-edges| the Delaunator docs.}
|
||||
* @param {number} e The index of the current half edge
|
||||
* @returns {number} The index of the next half edge
|
||||
*/
|
||||
nextHalfedge(e) { return (e % 3 === 2) ? e - 2 : e + 1; }
|
||||
|
||||
/**
|
||||
* Moves to the previous half-edge of a triangle, given the current half-edge's index. Taken from {@link https://mapbox.github.io/delaunator/#edge-to-edges| the Delaunator docs.}
|
||||
* @param {number} e The index of the current half edge
|
||||
* @returns {number} The index of the previous half edge
|
||||
*/
|
||||
prevHalfedge(e) { return (e % 3 === 0) ? e + 2 : e - 1; }
|
||||
|
||||
/**
|
||||
* Finds the circumcenter of the triangle identified by points a, b, and c. Taken from {@link https://en.wikipedia.org/wiki/Circumscribed_circle#Circumcenter_coordinates| Wikipedia}
|
||||
* @param {[number, number]} a The coordinates of the first point of the triangle
|
||||
* @param {[number, number]} b The coordinates of the second point of the triangle
|
||||
* @param {[number, number]} c The coordinates of the third point of the triangle
|
||||
* @return {[number, number]} The coordinates of the circumcenter of the triangle.
|
||||
*/
|
||||
circumcenter(a, b, c) {
|
||||
const [ax, ay] = a;
|
||||
const [bx, by] = b;
|
||||
const [cx, cy] = c;
|
||||
const ad = ax * ax + ay * ay;
|
||||
const bd = bx * bx + by * by;
|
||||
const cd = cx * cx + cy * cy;
|
||||
const D = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
|
||||
return [
|
||||
Math.floor(1 / D * (ad * (by - cy) + bd * (cy - ay) + cd * (ay - by))),
|
||||
Math.floor(1 / D * (ad * (cx - bx) + bd * (ax - cx) + cd * (bx - ax)))
|
||||
];
|
||||
}
|
||||
}
|
||||
485
procedural/src/engine/modules/zones-generator.js
Normal file
485
procedural/src/engine/modules/zones-generator.js
Normal file
|
|
@ -0,0 +1,485 @@
|
|||
"use strict";
|
||||
|
||||
const zoneConfig = {
|
||||
invasion: {quantity: 2, generate: addInvasion}, // invasion of enemy lands
|
||||
rebels: {quantity: 1.5, generate: addRebels}, // rebels along a state border
|
||||
proselytism: {quantity: 1.6, generate: addProselytism}, // proselitism of organized religion
|
||||
crusade: {quantity: 1.6, generate: addCrusade}, // crusade on heresy lands
|
||||
disease: {quantity: 1.4, generate: addDisease}, // disease starting in a random city
|
||||
disaster: {quantity: 1, generate: addDisaster}, // disaster starting in a random city
|
||||
eruption: {quantity: 1, generate: addEruption}, // eruption aroung volcano
|
||||
avalanche: {quantity: 0.8, generate: addAvalanche}, // avalanche impacting highland road
|
||||
fault: {quantity: 1, generate: addFault}, // fault line in elevated areas
|
||||
flood: {quantity: 1, generate: addFlood}, // flood on river banks
|
||||
tsunami: {quantity: 1, generate: addTsunami} // tsunami starting near coast
|
||||
};
|
||||
|
||||
export function generate(pack, notes, utils, config = {}) {
|
||||
const {gauss, ra, rw, P, rand, getAdjective} = utils.random;
|
||||
const {Names, Routes, FlatQueue, d3} = utils;
|
||||
const {TIME = false} = config;
|
||||
|
||||
TIME && console.time("generateZones");
|
||||
|
||||
const globalModifier = config.globalModifier || 1;
|
||||
const usedCells = new Uint8Array(pack.cells.i.length);
|
||||
const zones = [];
|
||||
|
||||
Object.values(zoneConfig).forEach(type => {
|
||||
const expectedNumber = type.quantity * globalModifier;
|
||||
let number = gauss(expectedNumber, expectedNumber / 2, 0, 100);
|
||||
while (number--) {
|
||||
const zone = type.generate(pack, usedCells, utils);
|
||||
if (zone) zones.push({...zone, i: zones.length});
|
||||
}
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("generateZones");
|
||||
|
||||
return zones;
|
||||
}
|
||||
|
||||
function addInvasion(pack, usedCells, utils) {
|
||||
const {ra, rand, rw, P} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {cells, states} = pack;
|
||||
|
||||
const ongoingConflicts = states
|
||||
.filter(s => s.i && !s.removed && s.campaigns)
|
||||
.map(s => s.campaigns)
|
||||
.flat()
|
||||
.filter(c => !c.end);
|
||||
if (!ongoingConflicts.length) return null;
|
||||
const {defender, attacker} = ra(ongoingConflicts);
|
||||
|
||||
const borderCells = cells.i.filter(cellId => {
|
||||
if (usedCells[cellId]) return false;
|
||||
if (cells.state[cellId] !== defender) return false;
|
||||
return cells.c[cellId].some(c => cells.state[c] === attacker);
|
||||
});
|
||||
|
||||
const startCell = ra(borderCells);
|
||||
if (startCell === undefined) return null;
|
||||
|
||||
const invasionCells = [];
|
||||
const queue = [startCell];
|
||||
const maxCells = rand(5, 30);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = P(0.4) ? queue.shift() : queue.pop();
|
||||
invasionCells.push(cellId);
|
||||
if (invasionCells.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId]) return;
|
||||
if (cells.state[neibCellId] !== defender) return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const subtype = rw({
|
||||
Invasion: 5,
|
||||
Occupation: 4,
|
||||
Conquest: 3,
|
||||
Incursion: 2,
|
||||
Intervention: 2,
|
||||
Assault: 1,
|
||||
Foray: 1,
|
||||
Intrusion: 1,
|
||||
Irruption: 1,
|
||||
Offensive: 1,
|
||||
Pillaging: 1,
|
||||
Plunder: 1,
|
||||
Raid: 1,
|
||||
Skirmishes: 1
|
||||
});
|
||||
const name = getAdjective(states[attacker].name) + " " + subtype;
|
||||
|
||||
return {name, type: "Invasion", cells: invasionCells, color: "url(#hatch1)"};
|
||||
}
|
||||
|
||||
function addRebels(pack, usedCells, utils) {
|
||||
const {ra, rand, rw} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {cells, states} = pack;
|
||||
|
||||
const state = ra(states.filter(s => s.i && !s.removed && s.neighbors.some(Boolean)));
|
||||
if (!state) return null;
|
||||
|
||||
const neibStateId = ra(state.neighbors.filter(n => n && !states[n].removed));
|
||||
if (!neibStateId) return null;
|
||||
|
||||
const cellsArray = [];
|
||||
const queue = [];
|
||||
const borderCellId = cells.i.find(
|
||||
i => cells.state[i] === state.i && cells.c[i].some(c => cells.state[c] === neibStateId)
|
||||
);
|
||||
if (borderCellId) queue.push(borderCellId);
|
||||
const maxCells = rand(10, 30);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.shift();
|
||||
cellsArray.push(cellId);
|
||||
if (cellsArray.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId]) return;
|
||||
if (cells.state[neibCellId] !== state.i) return;
|
||||
usedCells[neibCellId] = 1;
|
||||
if (neibCellId % 4 !== 0 && !cells.c[neibCellId].some(c => cells.state[c] === neibStateId)) return;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const rebels = rw({
|
||||
Rebels: 5,
|
||||
Insurrection: 2,
|
||||
Mutineers: 1,
|
||||
Insurgents: 1,
|
||||
Rebellion: 1,
|
||||
Renegades: 1,
|
||||
Revolters: 1,
|
||||
Revolutionaries: 1,
|
||||
Rioters: 1,
|
||||
Separatists: 1,
|
||||
Secessionists: 1,
|
||||
Conspiracy: 1
|
||||
});
|
||||
|
||||
const name = getAdjective(states[neibStateId].name) + " " + rebels;
|
||||
return {name, type: "Rebels", cells: cellsArray, color: "url(#hatch3)"};
|
||||
}
|
||||
|
||||
function addProselytism(pack, usedCells, utils) {
|
||||
const {ra, rand} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {cells, religions} = pack;
|
||||
|
||||
const organizedReligions = religions.filter(r => r.i && !r.removed && r.type === "Organized");
|
||||
const religion = ra(organizedReligions);
|
||||
if (!religion) return null;
|
||||
|
||||
const targetBorderCells = cells.i.filter(
|
||||
i =>
|
||||
cells.h[i] < 20 &&
|
||||
cells.pop[i] &&
|
||||
cells.religion[i] !== religion.i &&
|
||||
cells.c[i].some(c => cells.religion[c] === religion.i)
|
||||
);
|
||||
const startCell = ra(targetBorderCells);
|
||||
if (!startCell) return null;
|
||||
|
||||
const targetReligionId = cells.religion[startCell];
|
||||
const proselytismCells = [];
|
||||
const queue = [startCell];
|
||||
const maxCells = rand(10, 30);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.shift();
|
||||
proselytismCells.push(cellId);
|
||||
if (proselytismCells.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId]) return;
|
||||
if (cells.religion[neibCellId] !== targetReligionId) return;
|
||||
if (cells.h[neibCellId] < 20 || !cells.pop[neibCellId]) return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const name = `${getAdjective(religion.name.split(" ")[0])} Proselytism`;
|
||||
return {name, type: "Proselytism", cells: proselytismCells, color: "url(#hatch6)"};
|
||||
}
|
||||
|
||||
function addCrusade(pack, usedCells, utils) {
|
||||
const {ra} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {cells, religions} = pack;
|
||||
|
||||
const heresies = religions.filter(r => !r.removed && r.type === "Heresy");
|
||||
if (!heresies.length) return null;
|
||||
|
||||
const heresy = ra(heresies);
|
||||
const crusadeCells = cells.i.filter(i => !usedCells[i] && cells.religion[i] === heresy.i);
|
||||
if (!crusadeCells.length) return null;
|
||||
crusadeCells.forEach(i => (usedCells[i] = 1));
|
||||
|
||||
const name = getAdjective(heresy.name.split(" ")[0]) + " Crusade";
|
||||
return {
|
||||
name,
|
||||
type: "Crusade",
|
||||
cells: Array.from(crusadeCells),
|
||||
color: "url(#hatch6)"
|
||||
};
|
||||
}
|
||||
|
||||
function addDisease(pack, usedCells, utils) {
|
||||
const {ra, rand, rw} = utils.random;
|
||||
const {FlatQueue, Routes} = utils;
|
||||
const {cells, burgs} = pack;
|
||||
|
||||
const burg = ra(burgs.filter(b => !usedCells[b.cell] && b.i && !b.removed)); // random burg
|
||||
if (!burg) return null;
|
||||
|
||||
const cellsArray = [];
|
||||
const cost = [];
|
||||
const maxCells = rand(20, 40);
|
||||
|
||||
const queue = new FlatQueue();
|
||||
queue.push({e: burg.cell, p: 0}, 0);
|
||||
|
||||
while (queue.length) {
|
||||
const next = queue.pop();
|
||||
if (cells.burg[next.e] || cells.pop[next.e]) cellsArray.push(next.e);
|
||||
usedCells[next.e] = 1;
|
||||
|
||||
cells.c[next.e].forEach(nextCellId => {
|
||||
const c = Routes.getRoute(next.e, nextCellId) ? 5 : 100;
|
||||
const p = next.p + c;
|
||||
if (p > maxCells) return;
|
||||
|
||||
if (!cost[nextCellId] || p < cost[nextCellId]) {
|
||||
cost[nextCellId] = p;
|
||||
queue.push({e: nextCellId, p}, p);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// prettier-ignore
|
||||
const name = `${(() => {
|
||||
const model = rw({color: 2, animal: 1, adjective: 1});
|
||||
if (model === "color") return ra(["Amber", "Azure", "Black", "Blue", "Brown", "Crimson", "Emerald", "Golden", "Green", "Grey", "Orange", "Pink", "Purple", "Red", "Ruby", "Scarlet", "Silver", "Violet", "White", "Yellow"]);
|
||||
if (model === "animal") return ra(["Ape", "Bear", "Bird", "Boar", "Cat", "Cow", "Deer", "Dog", "Fox", "Goat", "Horse", "Lion", "Pig", "Rat", "Raven", "Sheep", "Spider", "Tiger", "Viper", "Wolf", "Worm", "Wyrm"]);
|
||||
if (model === "adjective") return ra(["Blind", "Bloody", "Brutal", "Burning", "Deadly", "Fatal", "Furious", "Great", "Grim", "Horrible", "Invisible", "Lethal", "Loud", "Mortal", "Savage", "Severe", "Silent", "Unknown", "Venomous", "Vicious"]);
|
||||
})()} ${rw({Fever: 5, Plague: 3, Cough: 3, Flu: 2, Pox: 2, Cholera: 2, Typhoid: 2, Leprosy: 1, Smallpox: 1, Pestilence: 1, Consumption: 1, Malaria: 1, Dropsy: 1})}`;
|
||||
|
||||
return {name, type: "Disease", cells: cellsArray, color: "url(#hatch12)"};
|
||||
}
|
||||
|
||||
function addDisaster(pack, usedCells, utils) {
|
||||
const {ra, rand, rw} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {FlatQueue} = utils;
|
||||
const {cells, burgs} = pack;
|
||||
|
||||
const burg = ra(burgs.filter(b => !usedCells[b.cell] && b.i && !b.removed));
|
||||
if (!burg) return null;
|
||||
usedCells[burg.cell] = 1;
|
||||
|
||||
const cellsArray = [];
|
||||
const cost = [];
|
||||
const maxCells = rand(5, 25);
|
||||
|
||||
const queue = new FlatQueue();
|
||||
queue.push({e: burg.cell, p: 0}, 0);
|
||||
|
||||
while (queue.length) {
|
||||
const next = queue.pop();
|
||||
if (cells.burg[next.e] || cells.pop[next.e]) cellsArray.push(next.e);
|
||||
usedCells[next.e] = 1;
|
||||
|
||||
cells.c[next.e].forEach(function (e) {
|
||||
const c = rand(1, 10);
|
||||
const p = next.p + c;
|
||||
if (p > maxCells) return;
|
||||
|
||||
if (!cost[e] || p < cost[e]) {
|
||||
cost[e] = p;
|
||||
queue.push({e, p}, p);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
const type = rw({
|
||||
Famine: 5,
|
||||
Drought: 3,
|
||||
Earthquake: 3,
|
||||
Dearth: 1,
|
||||
Tornadoes: 1,
|
||||
Wildfires: 1,
|
||||
Storms: 1,
|
||||
Blight: 1
|
||||
});
|
||||
const name = getAdjective(burg.name) + " " + type;
|
||||
return {name, type: "Disaster", cells: cellsArray, color: "url(#hatch5)"};
|
||||
}
|
||||
|
||||
function addEruption(pack, usedCells, utils, notes) {
|
||||
const {ra, rand, P} = utils.random;
|
||||
const {cells, markers} = pack;
|
||||
|
||||
const volcanoe = markers.find(m => m.type === "volcanoes" && !usedCells[m.cell]);
|
||||
if (!volcanoe) return null;
|
||||
usedCells[volcanoe.cell] = 1;
|
||||
|
||||
const note = notes.find(n => n.id === "marker" + volcanoe.i);
|
||||
if (note) note.legend = note.legend.replace("Active volcano", "Erupting volcano");
|
||||
const name = note ? note.name.replace(" Volcano", "") + " Eruption" : "Volcano Eruption";
|
||||
|
||||
const cellsArray = [];
|
||||
const queue = [volcanoe.cell];
|
||||
const maxCells = rand(10, 30);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = P(0.5) ? queue.shift() : queue.pop();
|
||||
cellsArray.push(cellId);
|
||||
if (cellsArray.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId] || cells.h[neibCellId] < 20) return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
return {name, type: "Eruption", cells: cellsArray, color: "url(#hatch7)"};
|
||||
}
|
||||
|
||||
function addAvalanche(pack, usedCells, utils) {
|
||||
const {ra, rand, P} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {Routes, Names} = utils;
|
||||
const {cells} = pack;
|
||||
|
||||
const routeCells = cells.i.filter(i => !usedCells[i] && Routes.isConnected(i) && cells.h[i] >= 70);
|
||||
if (!routeCells.length) return null;
|
||||
|
||||
const startCell = ra(routeCells);
|
||||
usedCells[startCell] = 1;
|
||||
|
||||
const cellsArray = [];
|
||||
const queue = [startCell];
|
||||
const maxCells = rand(3, 15);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = P(0.3) ? queue.shift() : queue.pop();
|
||||
cellsArray.push(cellId);
|
||||
if (cellsArray.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId] || cells.h[neibCellId] < 65) return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const name = getAdjective(Names.getCultureShort(cells.culture[startCell])) + " Avalanche";
|
||||
return {name, type: "Avalanche", cells: cellsArray, color: "url(#hatch5)"};
|
||||
}
|
||||
|
||||
function addFault(pack, usedCells, utils) {
|
||||
const {ra, rand} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {Names} = utils;
|
||||
const cells = pack.cells;
|
||||
|
||||
const elevatedCells = cells.i.filter(i => !usedCells[i] && cells.h[i] > 50 && cells.h[i] < 70);
|
||||
if (!elevatedCells.length) return null;
|
||||
|
||||
const startCell = ra(elevatedCells);
|
||||
usedCells[startCell] = 1;
|
||||
|
||||
const cellsArray = [];
|
||||
const queue = [startCell];
|
||||
const maxCells = rand(3, 15);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (cells.h[cellId] >= 20) cellsArray.push(cellId);
|
||||
if (cellsArray.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId] || cells.r[neibCellId]) return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const name = getAdjective(Names.getCultureShort(cells.culture[startCell])) + " Fault";
|
||||
return {name, type: "Fault", cells: cellsArray, color: "url(#hatch2)"};
|
||||
}
|
||||
|
||||
function addFlood(pack, usedCells, utils) {
|
||||
const {ra, rand} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {d3} = utils;
|
||||
const cells = pack.cells;
|
||||
|
||||
const fl = cells.fl.filter(Boolean);
|
||||
const meanFlux = d3.mean(fl);
|
||||
const maxFlux = d3.max(fl);
|
||||
const fluxThreshold = (maxFlux - meanFlux) / 2 + meanFlux;
|
||||
|
||||
const bigRiverCells = cells.i.filter(
|
||||
i => !usedCells[i] && cells.h[i] < 50 && cells.r[i] && cells.fl[i] > fluxThreshold && cells.burg[i]
|
||||
);
|
||||
if (!bigRiverCells.length) return null;
|
||||
|
||||
const startCell = ra(bigRiverCells);
|
||||
usedCells[startCell] = 1;
|
||||
|
||||
const riverId = cells.r[startCell];
|
||||
const cellsArray = [];
|
||||
const queue = [startCell];
|
||||
const maxCells = rand(5, 30);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
cellsArray.push(cellId);
|
||||
if (cellsArray.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (
|
||||
usedCells[neibCellId] ||
|
||||
cells.h[neibCellId] < 20 ||
|
||||
cells.r[neibCellId] !== riverId ||
|
||||
cells.h[neibCellId] > 50 ||
|
||||
cells.fl[neibCellId] < meanFlux
|
||||
)
|
||||
return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const name = getAdjective(pack.burgs[cells.burg[startCell]].name) + " Flood";
|
||||
return {name, type: "Flood", cells: cellsArray, color: "url(#hatch13)"};
|
||||
}
|
||||
|
||||
function addTsunami(pack, usedCells, utils) {
|
||||
const {ra, rand} = utils.random;
|
||||
const {getAdjective} = utils.random;
|
||||
const {Names} = utils;
|
||||
const {cells, features} = pack;
|
||||
|
||||
const coastalCells = cells.i.filter(
|
||||
i => !usedCells[i] && cells.t[i] === -1 && features[cells.f[i]].type !== "lake"
|
||||
);
|
||||
if (!coastalCells.length) return null;
|
||||
|
||||
const startCell = ra(coastalCells);
|
||||
usedCells[startCell] = 1;
|
||||
|
||||
const cellsArray = [];
|
||||
const queue = [startCell];
|
||||
const maxCells = rand(10, 30);
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.shift();
|
||||
if (cells.t[cellId] === 1) cellsArray.push(cellId);
|
||||
if (cellsArray.length >= maxCells) break;
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (usedCells[neibCellId]) return;
|
||||
if (cells.t[neibCellId] > 2) return;
|
||||
if (pack.features[cells.f[neibCellId]].type === "lake") return;
|
||||
usedCells[neibCellId] = 1;
|
||||
queue.push(neibCellId);
|
||||
});
|
||||
}
|
||||
|
||||
const name = getAdjective(Names.getCultureShort(cells.culture[startCell])) + " Tsunami";
|
||||
return {name, type: "Tsunami", cells: cellsArray, color: "url(#hatch13)"};
|
||||
}
|
||||
129
procedural/src/engine/support/biomes.txt
Normal file
129
procedural/src/engine/support/biomes.txt
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
"use strict";
|
||||
|
||||
const MIN_LAND_HEIGHT = 20;
|
||||
|
||||
export const getDefault = () => {
|
||||
const name = [
|
||||
"Marine",
|
||||
"Hot desert",
|
||||
"Cold desert",
|
||||
"Savanna",
|
||||
"Grassland",
|
||||
"Tropical seasonal forest",
|
||||
"Temperate deciduous forest",
|
||||
"Tropical rainforest",
|
||||
"Temperate rainforest",
|
||||
"Taiga",
|
||||
"Tundra",
|
||||
"Glacier",
|
||||
"Wetland"
|
||||
];
|
||||
|
||||
const color = [
|
||||
"#466eab",
|
||||
"#fbe79f",
|
||||
"#b5b887",
|
||||
"#d2d082",
|
||||
"#c8d68f",
|
||||
"#b6d95d",
|
||||
"#29bc56",
|
||||
"#7dcb35",
|
||||
"#409c43",
|
||||
"#4b6b32",
|
||||
"#96784b",
|
||||
"#d5e7eb",
|
||||
"#0b9131"
|
||||
];
|
||||
const habitability = [0, 4, 10, 22, 30, 50, 100, 80, 90, 12, 4, 0, 12];
|
||||
const iconsDensity = [0, 3, 2, 120, 120, 120, 120, 150, 150, 100, 5, 0, 250];
|
||||
const icons = [
|
||||
{},
|
||||
{dune: 3, cactus: 6, deadTree: 1},
|
||||
{dune: 9, deadTree: 1},
|
||||
{acacia: 1, grass: 9},
|
||||
{grass: 1},
|
||||
{acacia: 8, palm: 1},
|
||||
{deciduous: 1},
|
||||
{acacia: 5, palm: 3, deciduous: 1, swamp: 1},
|
||||
{deciduous: 6, swamp: 1},
|
||||
{conifer: 1},
|
||||
{grass: 1},
|
||||
{},
|
||||
{swamp: 1}
|
||||
];
|
||||
const cost = [10, 200, 150, 60, 50, 70, 70, 80, 90, 200, 1000, 5000, 150]; // biome movement cost
|
||||
const biomesMartix = [
|
||||
// hot <20> cold [>19<31>C; <-4<>C]; dry <20> wet
|
||||
new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10]),
|
||||
new Uint8Array([3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 10, 10])
|
||||
];
|
||||
|
||||
// parse icons weighted array into a simple array
|
||||
for (let i = 0; i < icons.length; i++) {
|
||||
const parsed = [];
|
||||
for (const icon in icons[i]) {
|
||||
for (let j = 0; j < icons[i][icon]; j++) {
|
||||
parsed.push(icon);
|
||||
}
|
||||
}
|
||||
icons[i] = parsed;
|
||||
}
|
||||
|
||||
return {i: Array.from({length: name.length}, (_, i) => i), name, color, biomesMartix, habitability, iconsDensity, icons, cost};
|
||||
};
|
||||
|
||||
// assign biome id for each cell
|
||||
export function define(pack, grid, config, utils) {
|
||||
const {TIME, d3, rn} = utils;
|
||||
TIME && console.time("defineBiomes");
|
||||
|
||||
const {fl: flux, r: riverIds, h: heights, c: neighbors, g: gridReference} = pack.cells;
|
||||
const {temp, prec} = grid.cells;
|
||||
const biome = new Uint8Array(pack.cells.i.length); // biomes array
|
||||
const biomesData = getDefault();
|
||||
|
||||
for (let cellId = 0; cellId < heights.length; cellId++) {
|
||||
const height = heights[cellId];
|
||||
const moisture = height < MIN_LAND_HEIGHT ? 0 : calculateMoisture(cellId);
|
||||
const temperature = temp[gridReference[cellId]];
|
||||
biome[cellId] = getId(moisture, temperature, height, Boolean(riverIds[cellId]), biomesData);
|
||||
}
|
||||
|
||||
function calculateMoisture(cellId) {
|
||||
let moisture = prec[gridReference[cellId]];
|
||||
if (riverIds[cellId]) moisture += Math.max(flux[cellId] / 10, 2);
|
||||
|
||||
const moistAround = neighbors[cellId]
|
||||
.filter(neibCellId => heights[neibCellId] >= MIN_LAND_HEIGHT)
|
||||
.map(c => prec[gridReference[c]])
|
||||
.concat([moisture]);
|
||||
return rn(4 + d3.mean(moistAround));
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("defineBiomes");
|
||||
return {biome};
|
||||
}
|
||||
|
||||
export function getId(moisture, temperature, height, hasRiver, biomesData = null) {
|
||||
const data = biomesData || getDefault();
|
||||
|
||||
if (height < 20) return 0; // all water cells: marine biome
|
||||
if (temperature < -5) return 11; // too cold: permafrost biome
|
||||
if (temperature >= 25 && !hasRiver && moisture < 8) return 1; // too hot and dry: hot desert biome
|
||||
if (isWetland(moisture, temperature, height)) return 12; // too wet: wetland biome
|
||||
|
||||
// in other cases use biome matrix
|
||||
const moistureBand = Math.min((moisture / 5) | 0, 4); // [0-4]
|
||||
const temperatureBand = Math.min(Math.max(20 - temperature, 0), 25); // [0-25]
|
||||
return data.biomesMartix[moistureBand][temperatureBand];
|
||||
}
|
||||
|
||||
function isWetland(moisture, temperature, height) {
|
||||
if (temperature <= -2) return false; // too cold
|
||||
if (moisture > 40 && height < 25) return true; // near coast
|
||||
if (moisture > 24 && height > 24 && height < 60) return true; // off coast
|
||||
return false;
|
||||
}
|
||||
28
procedural/src/engine/support/biomes_config.md
Normal file
28
procedural/src/engine/support/biomes_config.md
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
# Biomes Module - Configuration Properties
|
||||
|
||||
The refactored `biomes.js` module does not require any configuration properties from DOM elements.
|
||||
|
||||
## Analysis
|
||||
|
||||
After careful examination of the original `biomes.js` code, no instances of the following patterns were found:
|
||||
|
||||
- `byId()` calls to read DOM values
|
||||
- Direct DOM element access
|
||||
- Configuration parameters read from UI elements
|
||||
|
||||
## Config Object
|
||||
|
||||
The `config` parameter is included in the function signature for consistency with the refactoring pattern, but no properties are currently needed:
|
||||
|
||||
```javascript
|
||||
export function define(pack, grid, config, utils) {
|
||||
// config parameter available but not used in this module
|
||||
}
|
||||
```
|
||||
|
||||
## Notes
|
||||
|
||||
- The biomes module operates purely on data structures (`pack` and `grid`)
|
||||
- All configuration is embedded within the module's default data
|
||||
- No external configuration parameters are required
|
||||
- The module is self-contained regarding biome generation logic
|
||||
33
procedural/src/engine/support/biomes_external.md
Normal file
33
procedural/src/engine/support/biomes_external.md
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
# Biomes Module - External Dependencies
|
||||
|
||||
The refactored `biomes.js` module requires the following external dependencies to be injected via the `utils` parameter:
|
||||
|
||||
## Required Utilities
|
||||
|
||||
- **`TIME`** - Global timing flag for performance monitoring (boolean)
|
||||
- **`d3`** - D3.js library for mathematical functions
|
||||
- `d3.mean()` - Used for calculating average moisture values
|
||||
- **`rn`** - Rounding utility function for numerical precision
|
||||
|
||||
## Import Structure
|
||||
|
||||
When integrating this module, the calling code should provide these utilities:
|
||||
|
||||
```javascript
|
||||
import { define, getId, getDefault } from './biomes.js';
|
||||
|
||||
const utils = {
|
||||
TIME: globalTimeFlag,
|
||||
d3: d3Library,
|
||||
rn: roundingFunction
|
||||
};
|
||||
|
||||
// Usage
|
||||
const result = define(pack, grid, config, utils);
|
||||
```
|
||||
|
||||
## Notes
|
||||
|
||||
- No additional external modules need to be imported by the biomes module itself
|
||||
- All dependencies are injected rather than directly imported
|
||||
- The module maintains compatibility with the original d3.range functionality by using `Array.from()` instead
|
||||
209
procedural/src/engine/support/biomes_prompt.md
Normal file
209
procedural/src/engine/support/biomes_prompt.md
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
# biomes.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
7. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.txt`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `biomes.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Biomes = (function () {
|
||||
const MIN_LAND_HEIGHT = 20;
|
||||
|
||||
const getDefault = () => {
|
||||
const name = [
|
||||
"Marine",
|
||||
"Hot desert",
|
||||
"Cold desert",
|
||||
"Savanna",
|
||||
"Grassland",
|
||||
"Tropical seasonal forest",
|
||||
"Temperate deciduous forest",
|
||||
"Tropical rainforest",
|
||||
"Temperate rainforest",
|
||||
"Taiga",
|
||||
"Tundra",
|
||||
"Glacier",
|
||||
"Wetland"
|
||||
];
|
||||
|
||||
const color = [
|
||||
"#466eab",
|
||||
"#fbe79f",
|
||||
"#b5b887",
|
||||
"#d2d082",
|
||||
"#c8d68f",
|
||||
"#b6d95d",
|
||||
"#29bc56",
|
||||
"#7dcb35",
|
||||
"#409c43",
|
||||
"#4b6b32",
|
||||
"#96784b",
|
||||
"#d5e7eb",
|
||||
"#0b9131"
|
||||
];
|
||||
const habitability = [0, 4, 10, 22, 30, 50, 100, 80, 90, 12, 4, 0, 12];
|
||||
const iconsDensity = [0, 3, 2, 120, 120, 120, 120, 150, 150, 100, 5, 0, 250];
|
||||
const icons = [
|
||||
{},
|
||||
{dune: 3, cactus: 6, deadTree: 1},
|
||||
{dune: 9, deadTree: 1},
|
||||
{acacia: 1, grass: 9},
|
||||
{grass: 1},
|
||||
{acacia: 8, palm: 1},
|
||||
{deciduous: 1},
|
||||
{acacia: 5, palm: 3, deciduous: 1, swamp: 1},
|
||||
{deciduous: 6, swamp: 1},
|
||||
{conifer: 1},
|
||||
{grass: 1},
|
||||
{},
|
||||
{swamp: 1}
|
||||
];
|
||||
const cost = [10, 200, 150, 60, 50, 70, 70, 80, 90, 200, 1000, 5000, 150]; // biome movement cost
|
||||
const biomesMartix = [
|
||||
// hot ↔ cold [>19°C; <-4°C]; dry ↕ wet
|
||||
new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10]),
|
||||
new Uint8Array([3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([5, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10]),
|
||||
new Uint8Array([7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 10, 10])
|
||||
];
|
||||
|
||||
// parse icons weighted array into a simple array
|
||||
for (let i = 0; i < icons.length; i++) {
|
||||
const parsed = [];
|
||||
for (const icon in icons[i]) {
|
||||
for (let j = 0; j < icons[i][icon]; j++) {
|
||||
parsed.push(icon);
|
||||
}
|
||||
}
|
||||
icons[i] = parsed;
|
||||
}
|
||||
|
||||
return {i: d3.range(0, name.length), name, color, biomesMartix, habitability, iconsDensity, icons, cost};
|
||||
};
|
||||
|
||||
// assign biome id for each cell
|
||||
function define() {
|
||||
TIME && console.time("defineBiomes");
|
||||
|
||||
const {fl: flux, r: riverIds, h: heights, c: neighbors, g: gridReference} = pack.cells;
|
||||
const {temp, prec} = grid.cells;
|
||||
pack.cells.biome = new Uint8Array(pack.cells.i.length); // biomes array
|
||||
|
||||
for (let cellId = 0; cellId < heights.length; cellId++) {
|
||||
const height = heights[cellId];
|
||||
const moisture = height < MIN_LAND_HEIGHT ? 0 : calculateMoisture(cellId);
|
||||
const temperature = temp[gridReference[cellId]];
|
||||
pack.cells.biome[cellId] = getId(moisture, temperature, height, Boolean(riverIds[cellId]));
|
||||
}
|
||||
|
||||
function calculateMoisture(cellId) {
|
||||
let moisture = prec[gridReference[cellId]];
|
||||
if (riverIds[cellId]) moisture += Math.max(flux[cellId] / 10, 2);
|
||||
|
||||
const moistAround = neighbors[cellId]
|
||||
.filter(neibCellId => heights[neibCellId] >= MIN_LAND_HEIGHT)
|
||||
.map(c => prec[gridReference[c]])
|
||||
.concat([moisture]);
|
||||
return rn(4 + d3.mean(moistAround));
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("defineBiomes");
|
||||
}
|
||||
|
||||
function getId(moisture, temperature, height, hasRiver) {
|
||||
if (height < 20) return 0; // all water cells: marine biome
|
||||
if (temperature < -5) return 11; // too cold: permafrost biome
|
||||
if (temperature >= 25 && !hasRiver && moisture < 8) return 1; // too hot and dry: hot desert biome
|
||||
if (isWetland(moisture, temperature, height)) return 12; // too wet: wetland biome
|
||||
|
||||
// in other cases use biome matrix
|
||||
const moistureBand = Math.min((moisture / 5) | 0, 4); // [0-4]
|
||||
const temperatureBand = Math.min(Math.max(20 - temperature, 0), 25); // [0-25]
|
||||
return biomesData.biomesMartix[moistureBand][temperatureBand];
|
||||
}
|
||||
|
||||
function isWetland(moisture, temperature, height) {
|
||||
if (temperature <= -2) return false; // too cold
|
||||
if (moisture > 40 && height < 25) return true; // near coast
|
||||
if (moisture > 24 && height > 24 && height < 60) return true; // off coast
|
||||
return false;
|
||||
}
|
||||
|
||||
return {getDefault, define, getId};
|
||||
})();
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./biomes.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./biomes_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in biomes_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application.
|
||||
9
procedural/src/engine/support/biomes_render.md
Normal file
9
procedural/src/engine/support/biomes_render.md
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
# biomes.js render requirements
|
||||
|
||||
After analyzing the original biomes.js code, no rendering or UI logic was found to remove. The module contains only:
|
||||
|
||||
- Data structure definitions (biome names, colors, matrices)
|
||||
- Pure computational logic for biome assignment
|
||||
- Mathematical calculations for moisture and temperature
|
||||
|
||||
The original module was already focused purely on data generation without any DOM manipulation, SVG rendering, or UI interactions.
|
||||
893
procedural/src/engine/support/burgs-and-states.txt
Normal file
893
procedural/src/engine/support/burgs-and-states.txt
Normal file
|
|
@ -0,0 +1,893 @@
|
|||
"use strict";
|
||||
|
||||
export const generate = (pack, grid, config, utils) => {
|
||||
|
||||
const {cells, cultures} = pack;
|
||||
const n = cells.i.length;
|
||||
|
||||
const newCells = {...cells, burg: new Uint16Array(n)};
|
||||
const newPack = {...pack, cells: newCells};
|
||||
|
||||
const burgs = placeCapitals(newPack, grid, config, utils);
|
||||
const states = createStates(newPack, burgs, config, utils);
|
||||
|
||||
placeTowns(newPack, burgs, grid, config, utils);
|
||||
expandStates(newPack, grid, config, utils);
|
||||
normalizeStates(newPack, utils);
|
||||
getPoles(newPack, utils);
|
||||
|
||||
specifyBurgs(newPack, grid, utils);
|
||||
|
||||
collectStatistics(newPack);
|
||||
assignColors(newPack, utils);
|
||||
|
||||
generateCampaigns(newPack, utils);
|
||||
generateDiplomacy(newPack, utils);
|
||||
|
||||
return {
|
||||
burgs: newPack.burgs,
|
||||
states: newPack.states,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
burg: newPack.cells.burg,
|
||||
state: newPack.cells.state
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
function placeCapitals(pack, grid, config, utils) {
|
||||
const {TIME, WARN, d3, graphWidth, graphHeight} = utils;
|
||||
TIME && console.time("placeCapitals");
|
||||
let count = config.statesNumber;
|
||||
let burgs = [0];
|
||||
|
||||
const {cells} = pack;
|
||||
const rand = () => 0.5 + Math.random() * 0.5;
|
||||
const score = new Int16Array(cells.s.map(s => s * rand())); // cell score for capitals placement
|
||||
const sorted = cells.i.filter(i => score[i] > 0 && cells.culture[i]).sort((a, b) => score[b] - score[a]); // filtered and sorted array of indexes
|
||||
|
||||
if (sorted.length < count * 10) {
|
||||
count = Math.floor(sorted.length / 10);
|
||||
if (!count) {
|
||||
WARN && console.warn("There is no populated cells. Cannot generate states");
|
||||
return burgs;
|
||||
} else {
|
||||
WARN && console.warn(`Not enough populated cells (${sorted.length}). Will generate only ${count} states`);
|
||||
}
|
||||
}
|
||||
|
||||
let burgsTree = d3.quadtree();
|
||||
let spacing = (graphWidth + graphHeight) / 2 / count; // min distance between capitals
|
||||
|
||||
for (let i = 0; burgs.length <= count; i++) {
|
||||
const cell = sorted[i];
|
||||
const [x, y] = cells.p[cell];
|
||||
|
||||
if (burgsTree.find(x, y, spacing) === undefined) {
|
||||
burgs.push({cell, x, y});
|
||||
burgsTree.add([x, y]);
|
||||
}
|
||||
|
||||
if (i === sorted.length - 1) {
|
||||
WARN && console.warn("Cannot place capitals with current spacing. Trying again with reduced spacing");
|
||||
burgsTree = d3.quadtree();
|
||||
i = -1;
|
||||
burgs = [0];
|
||||
spacing /= 1.2;
|
||||
}
|
||||
}
|
||||
|
||||
burgs[0] = burgsTree;
|
||||
TIME && console.timeEnd("placeCapitals");
|
||||
return burgs;
|
||||
}
|
||||
|
||||
// For each capital create a state
|
||||
function createStates(pack, burgs, config, utils) {
|
||||
const {TIME, rn, each, Names, COA, getColors} = utils;
|
||||
TIME && console.time("createStates");
|
||||
const {cells, cultures} = pack;
|
||||
const states = [{i: 0, name: "Neutrals"}];
|
||||
const colors = getColors(burgs.length - 1);
|
||||
const each5th = each(5);
|
||||
|
||||
burgs.forEach((b, i) => {
|
||||
if (!i) return; // skip first element
|
||||
|
||||
// burgs data
|
||||
b.i = b.state = i;
|
||||
b.culture = cells.culture[b.cell];
|
||||
b.name = Names.getCultureShort(b.culture);
|
||||
b.feature = cells.f[b.cell];
|
||||
b.capital = 1;
|
||||
|
||||
// states data
|
||||
const expansionism = rn(Math.random() * config.sizeVariety + 1, 1);
|
||||
const basename = b.name.length < 9 && each5th(b.cell) ? b.name : Names.getCultureShort(b.culture);
|
||||
const name = Names.getState(basename, b.culture);
|
||||
const type = cultures[b.culture].type;
|
||||
|
||||
const coa = COA.generate(null, null, null, type);
|
||||
coa.shield = COA.getShield(b.culture, null);
|
||||
states.push({
|
||||
i,
|
||||
color: colors[i - 1],
|
||||
name,
|
||||
expansionism,
|
||||
capital: i,
|
||||
type,
|
||||
center: b.cell,
|
||||
culture: b.culture,
|
||||
coa
|
||||
});
|
||||
cells.burg[b.cell] = i;
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("createStates");
|
||||
return states;
|
||||
}
|
||||
|
||||
// place secondary settlements based on geo and economical evaluation
|
||||
function placeTowns(pack, burgs, grid, config, utils) {
|
||||
const {TIME, ERROR, rn, gauss, Names, graphWidth, graphHeight} = utils;
|
||||
TIME && console.time("placeTowns");
|
||||
const {cells} = pack;
|
||||
const score = new Int16Array(cells.s.map(s => s * gauss(1, 3, 0, 20, 3))); // a bit randomized cell score for towns placement
|
||||
const sorted = cells.i
|
||||
.filter(i => !cells.burg[i] && score[i] > 0 && cells.culture[i])
|
||||
.sort((a, b) => score[b] - score[a]); // filtered and sorted array of indexes
|
||||
|
||||
const desiredNumber =
|
||||
config.manorsInput == 1000
|
||||
? rn(sorted.length / 5 / (grid.points.length / 10000) ** 0.8)
|
||||
: config.manorsInput;
|
||||
const burgsNumber = Math.min(desiredNumber, sorted.length); // towns to generate
|
||||
let burgsAdded = 0;
|
||||
|
||||
const burgsTree = burgs[0];
|
||||
let spacing = (graphWidth + graphHeight) / 150 / (burgsNumber ** 0.7 / 66); // min distance between towns
|
||||
|
||||
while (burgsAdded < burgsNumber && spacing > 1) {
|
||||
for (let i = 0; burgsAdded < burgsNumber && i < sorted.length; i++) {
|
||||
if (cells.burg[sorted[i]]) continue;
|
||||
const cell = sorted[i];
|
||||
const [x, y] = cells.p[cell];
|
||||
const s = spacing * gauss(1, 0.3, 0.2, 2, 2); // randomize to make placement not uniform
|
||||
if (burgsTree.find(x, y, s) !== undefined) continue; // to close to existing burg
|
||||
const burg = burgs.length;
|
||||
const culture = cells.culture[cell];
|
||||
const name = Names.getCulture(culture);
|
||||
burgs.push({cell, x, y, state: 0, i: burg, culture, name, capital: 0, feature: cells.f[cell]});
|
||||
burgsTree.add([x, y]);
|
||||
cells.burg[cell] = burg;
|
||||
burgsAdded++;
|
||||
}
|
||||
spacing *= 0.5;
|
||||
}
|
||||
|
||||
if (config.manorsInput != 1000 && burgsAdded < desiredNumber) {
|
||||
ERROR && console.error(`Cannot place all burgs. Requested ${desiredNumber}, placed ${burgsAdded}`);
|
||||
}
|
||||
|
||||
burgs[0] = {name: undefined}; // do not store burgsTree anymore
|
||||
TIME && console.timeEnd("placeTowns");
|
||||
}
|
||||
|
||||
// define burg coordinates, coa, port status and define details
|
||||
export const specifyBurgs = (pack, grid, utils) => {
|
||||
const {TIME, rn, gauss, P, COA} = utils;
|
||||
TIME && console.time("specifyBurgs");
|
||||
const {cells, features} = pack;
|
||||
const temp = grid.cells.temp;
|
||||
|
||||
for (const b of pack.burgs) {
|
||||
if (!b.i || b.lock) continue;
|
||||
const i = b.cell;
|
||||
|
||||
// asign port status to some coastline burgs with temp > 0 °C
|
||||
const haven = cells.haven[i];
|
||||
if (haven && temp[cells.g[i]] > 0) {
|
||||
const f = cells.f[haven]; // water body id
|
||||
// port is a capital with any harbor OR town with good harbor
|
||||
const port = features[f].cells > 1 && ((b.capital && cells.harbor[i]) || cells.harbor[i] === 1);
|
||||
b.port = port ? f : 0; // port is defined by water body id it lays on
|
||||
} else b.port = 0;
|
||||
|
||||
// define burg population (keep urbanization at about 10% rate)
|
||||
b.population = rn(Math.max(cells.s[i] / 8 + b.i / 1000 + (i % 100) / 1000, 0.1), 3);
|
||||
if (b.capital) b.population = rn(b.population * 1.3, 3); // increase capital population
|
||||
|
||||
if (b.port) {
|
||||
b.population = b.population * 1.3; // increase port population
|
||||
const [x, y] = getCloseToEdgePoint(i, haven, pack, utils);
|
||||
b.x = x;
|
||||
b.y = y;
|
||||
}
|
||||
|
||||
// add random factor
|
||||
b.population = rn(b.population * gauss(2, 3, 0.6, 20, 3), 3);
|
||||
|
||||
// shift burgs on rivers semi-randomly and just a bit
|
||||
if (!b.port && cells.r[i]) {
|
||||
const shift = Math.min(cells.fl[i] / 150, 1);
|
||||
if (i % 2) b.x = rn(b.x + shift, 2);
|
||||
else b.x = rn(b.x - shift, 2);
|
||||
if (cells.r[i] % 2) b.y = rn(b.y + shift, 2);
|
||||
else b.y = rn(b.y - shift, 2);
|
||||
}
|
||||
|
||||
// define emblem
|
||||
const state = pack.states[b.state];
|
||||
const stateCOA = state.coa;
|
||||
let kinship = 0.25;
|
||||
if (b.capital) kinship += 0.1;
|
||||
else if (b.port) kinship -= 0.1;
|
||||
if (b.culture !== state.culture) kinship -= 0.25;
|
||||
b.type = getType(i, b.port, pack, utils);
|
||||
const type = b.capital && P(0.2) ? "Capital" : b.type === "Generic" ? "City" : b.type;
|
||||
b.coa = COA.generate(stateCOA, kinship, null, type);
|
||||
b.coa.shield = COA.getShield(b.culture, b.state);
|
||||
}
|
||||
|
||||
// de-assign port status if it's the only one on feature
|
||||
const ports = pack.burgs.filter(b => !b.removed && b.port > 0);
|
||||
for (const f of features) {
|
||||
if (!f.i || f.land || f.border) continue;
|
||||
const featurePorts = ports.filter(b => b.port === f.i);
|
||||
if (featurePorts.length === 1) featurePorts[0].port = 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("specifyBurgs");
|
||||
};
|
||||
|
||||
export function getCloseToEdgePoint(cell1, cell2, pack, utils) {
|
||||
const {cells, vertices} = pack;
|
||||
const {rn} = utils;
|
||||
|
||||
const [x0, y0] = cells.p[cell1];
|
||||
|
||||
const commonVertices = cells.v[cell1].filter(vertex => vertices.c[vertex].some(cell => cell === cell2));
|
||||
const [x1, y1] = vertices.p[commonVertices[0]];
|
||||
const [x2, y2] = vertices.p[commonVertices[1]];
|
||||
const xEdge = (x1 + x2) / 2;
|
||||
const yEdge = (y1 + y2) / 2;
|
||||
|
||||
const x = rn(x0 + 0.95 * (xEdge - x0), 2);
|
||||
const y = rn(y0 + 0.95 * (yEdge - y0), 2);
|
||||
|
||||
return [x, y];
|
||||
}
|
||||
|
||||
export const getType = (cellId, port, pack, utils) => {
|
||||
const {cells, features, burgs} = pack;
|
||||
|
||||
if (port) return "Naval";
|
||||
|
||||
const haven = cells.haven[cellId];
|
||||
if (haven !== undefined && features[cells.f[haven]].type === "lake") return "Lake";
|
||||
|
||||
if (cells.h[cellId] > 60) return "Highland";
|
||||
|
||||
if (cells.r[cellId] && cells.fl[cellId] >= 100) return "River";
|
||||
|
||||
const biome = cells.biome[cellId];
|
||||
const population = cells.pop[cellId];
|
||||
if (!cells.burg[cellId] || population <= 5) {
|
||||
if (population < 5 && [1, 2, 3, 4].includes(biome)) return "Nomadic";
|
||||
if (biome > 4 && biome < 10) return "Hunting";
|
||||
}
|
||||
|
||||
return "Generic";
|
||||
};
|
||||
|
||||
export const defineBurgFeatures = (burg, pack, utils) => {
|
||||
const {P} = utils;
|
||||
const {cells} = pack;
|
||||
|
||||
pack.burgs
|
||||
.filter(b => (burg ? b.i == burg.i : b.i && !b.removed && !b.lock))
|
||||
.forEach(b => {
|
||||
const pop = b.population;
|
||||
b.citadel = Number(b.capital || (pop > 50 && P(0.75)) || (pop > 15 && P(0.5)) || P(0.1));
|
||||
b.plaza = Number(pop > 20 || (pop > 10 && P(0.8)) || (pop > 4 && P(0.7)) || P(0.6));
|
||||
b.walls = Number(b.capital || pop > 30 || (pop > 20 && P(0.75)) || (pop > 10 && P(0.5)) || P(0.1));
|
||||
b.shanty = Number(pop > 60 || (pop > 40 && P(0.75)) || (pop > 20 && b.walls && P(0.4)));
|
||||
const religion = cells.religion[b.cell];
|
||||
const theocracy = pack.states[b.state].form === "Theocracy";
|
||||
b.temple = Number(
|
||||
(religion && theocracy && P(0.5)) || pop > 50 || (pop > 35 && P(0.75)) || (pop > 20 && P(0.5))
|
||||
);
|
||||
});
|
||||
};
|
||||
|
||||
// expand cultures across the map (Dijkstra-like algorithm)
|
||||
export const expandStates = (pack, grid, config, utils) => {
|
||||
const {TIME, FlatQueue, minmax, biomesData} = utils;
|
||||
TIME && console.time("expandStates");
|
||||
const {cells, states, cultures, burgs} = pack;
|
||||
|
||||
cells.state = cells.state || new Uint16Array(cells.i.length);
|
||||
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
const globalGrowthRate = config.growthRate || 1;
|
||||
const statesGrowthRate = config.statesGrowthRate || 1;
|
||||
const growthRate = (cells.i.length / 2) * globalGrowthRate * statesGrowthRate; // limit cost for state growth
|
||||
|
||||
// remove state from all cells except of locked
|
||||
for (const cellId of cells.i) {
|
||||
const state = states[cells.state[cellId]];
|
||||
if (state.lock) continue;
|
||||
cells.state[cellId] = 0;
|
||||
}
|
||||
|
||||
for (const state of states) {
|
||||
if (!state.i || state.removed) continue;
|
||||
|
||||
const capitalCell = burgs[state.capital].cell;
|
||||
cells.state[capitalCell] = state.i;
|
||||
const cultureCenter = cultures[state.culture].center;
|
||||
const b = cells.biome[cultureCenter]; // state native biome
|
||||
queue.push({e: state.center, p: 0, s: state.i, b}, 0);
|
||||
cost[state.center] = 1;
|
||||
}
|
||||
|
||||
while (queue.length) {
|
||||
const next = queue.pop();
|
||||
|
||||
const {e, p, s, b} = next;
|
||||
const {type, culture} = states[s];
|
||||
|
||||
cells.c[e].forEach(e => {
|
||||
const state = states[cells.state[e]];
|
||||
if (state.lock) return; // do not overwrite cell of locked states
|
||||
if (cells.state[e] && e === state.center) return; // do not overwrite capital cells
|
||||
|
||||
const cultureCost = culture === cells.culture[e] ? -9 : 100;
|
||||
const populationCost = cells.h[e] < 20 ? 0 : cells.s[e] ? Math.max(20 - cells.s[e], 0) : 5000;
|
||||
const biomeCost = getBiomeCost(b, cells.biome[e], type);
|
||||
const heightCost = getHeightCost(pack.features[cells.f[e]], cells.h[e], type);
|
||||
const riverCost = getRiverCost(cells.r[e], e, type);
|
||||
const typeCost = getTypeCost(cells.t[e], type);
|
||||
const cellCost = Math.max(cultureCost + populationCost + biomeCost + heightCost + riverCost + typeCost, 0);
|
||||
const totalCost = p + 10 + cellCost / states[s].expansionism;
|
||||
|
||||
if (totalCost > growthRate) return;
|
||||
|
||||
if (!cost[e] || totalCost < cost[e]) {
|
||||
if (cells.h[e] >= 20) cells.state[e] = s; // assign state to cell
|
||||
cost[e] = totalCost;
|
||||
queue.push({e, p: totalCost, s, b}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
burgs.filter(b => b.i && !b.removed).forEach(b => (b.state = cells.state[b.cell])); // assign state to burgs
|
||||
|
||||
function getBiomeCost(b, biome, type) {
|
||||
if (b === biome) return 10; // tiny penalty for native biome
|
||||
if (type === "Hunting") return biomesData.cost[biome] * 2; // non-native biome penalty for hunters
|
||||
if (type === "Nomadic" && biome > 4 && biome < 10) return biomesData.cost[biome] * 3; // forest biome penalty for nomads
|
||||
return biomesData.cost[biome]; // general non-native biome penalty
|
||||
}
|
||||
|
||||
function getHeightCost(f, h, type) {
|
||||
if (type === "Lake" && f.type === "lake") return 10; // low lake crossing penalty for Lake cultures
|
||||
if (type === "Naval" && h < 20) return 300; // low sea crossing penalty for Navals
|
||||
if (type === "Nomadic" && h < 20) return 10000; // giant sea crossing penalty for Nomads
|
||||
if (h < 20) return 1000; // general sea crossing penalty
|
||||
if (type === "Highland" && h < 62) return 1100; // penalty for highlanders on lowlands
|
||||
if (type === "Highland") return 0; // no penalty for highlanders on highlands
|
||||
if (h >= 67) return 2200; // general mountains crossing penalty
|
||||
if (h >= 44) return 300; // general hills crossing penalty
|
||||
return 0;
|
||||
}
|
||||
|
||||
function getRiverCost(r, i, type) {
|
||||
if (type === "River") return r ? 0 : 100; // penalty for river cultures
|
||||
if (!r) return 0; // no penalty for others if there is no river
|
||||
return minmax(cells.fl[i] / 10, 20, 100); // river penalty from 20 to 100 based on flux
|
||||
}
|
||||
|
||||
function getTypeCost(t, type) {
|
||||
if (t === 1) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline
|
||||
if (t === 2) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads
|
||||
if (t !== -1) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals
|
||||
return 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("expandStates");
|
||||
};
|
||||
|
||||
export const normalizeStates = (pack, utils) => {
|
||||
const {TIME} = utils;
|
||||
TIME && console.time("normalizeStates");
|
||||
const {cells, burgs} = pack;
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.h[i] < 20 || cells.burg[i]) continue; // do not overwrite burgs
|
||||
if (pack.states[cells.state[i]]?.lock) continue; // do not overwrite cells of locks states
|
||||
if (cells.c[i].some(c => burgs[cells.burg[c]].capital)) continue; // do not overwrite near capital
|
||||
const neibs = cells.c[i].filter(c => cells.h[c] >= 20);
|
||||
const adversaries = neibs.filter(c => !pack.states[cells.state[c]]?.lock && cells.state[c] !== cells.state[i]);
|
||||
if (adversaries.length < 2) continue;
|
||||
const buddies = neibs.filter(c => !pack.states[cells.state[c]]?.lock && cells.state[c] === cells.state[i]);
|
||||
if (buddies.length > 2) continue;
|
||||
if (adversaries.length <= buddies.length) continue;
|
||||
cells.state[i] = cells.state[adversaries[0]];
|
||||
}
|
||||
TIME && console.timeEnd("normalizeStates");
|
||||
};
|
||||
|
||||
// calculate pole of inaccessibility for each state
|
||||
export const getPoles = (pack, utils) => {
|
||||
const {getPolesOfInaccessibility} = utils;
|
||||
const getType = cellId => pack.cells.state[cellId];
|
||||
const poles = getPolesOfInaccessibility(pack, getType);
|
||||
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
s.pole = poles[s.i] || [0, 0];
|
||||
});
|
||||
};
|
||||
|
||||
// Resets the cultures of all burgs and states to their cell or center cell's (respectively) culture
|
||||
export const updateCultures = (pack, utils) => {
|
||||
const {TIME} = utils;
|
||||
TIME && console.time("updateCulturesForBurgsAndStates");
|
||||
|
||||
// Assign the culture associated with the burgs cell
|
||||
pack.burgs = pack.burgs.map((burg, index) => {
|
||||
if (index === 0) return burg;
|
||||
return {...burg, culture: pack.cells.culture[burg.cell]};
|
||||
});
|
||||
|
||||
// Assign the culture associated with the states' center cell
|
||||
pack.states = pack.states.map((state, index) => {
|
||||
if (index === 0) return state;
|
||||
return {...state, culture: pack.cells.culture[state.center]};
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("updateCulturesForBurgsAndStates");
|
||||
};
|
||||
|
||||
// calculate states data like area, population etc.
|
||||
export const collectStatistics = (pack) => {
|
||||
const {cells, states} = pack;
|
||||
|
||||
states.forEach(s => {
|
||||
if (s.removed) return;
|
||||
s.cells = s.area = s.burgs = s.rural = s.urban = 0;
|
||||
s.neighbors = new Set();
|
||||
});
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.h[i] < 20) continue;
|
||||
const s = cells.state[i];
|
||||
|
||||
// check for neighboring states
|
||||
cells.c[i]
|
||||
.filter(c => cells.h[c] >= 20 && cells.state[c] !== s)
|
||||
.forEach(c => states[s].neighbors.add(cells.state[c]));
|
||||
|
||||
// collect stats
|
||||
states[s].cells += 1;
|
||||
states[s].area += cells.area[i];
|
||||
states[s].rural += cells.pop[i];
|
||||
if (cells.burg[i]) {
|
||||
states[s].urban += pack.burgs[cells.burg[i]].population;
|
||||
states[s].burgs++;
|
||||
}
|
||||
}
|
||||
|
||||
// convert neighbors Set object into array
|
||||
states.forEach(s => {
|
||||
if (!s.neighbors) return;
|
||||
s.neighbors = Array.from(s.neighbors);
|
||||
});
|
||||
};
|
||||
|
||||
export const assignColors = (pack, utils) => {
|
||||
const {TIME, getRandomColor, getMixedColor} = utils;
|
||||
TIME && console.time("assignColors");
|
||||
const colors = ["#66c2a5", "#fc8d62", "#8da0cb", "#e78ac3", "#a6d854", "#ffd92f"]; // d3.schemeSet2;
|
||||
|
||||
// assign basic color using greedy coloring algorithm
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed || s.lock) return;
|
||||
const neibs = s.neighbors;
|
||||
s.color = colors.find(c => neibs.every(n => pack.states[n].color !== c));
|
||||
if (!s.color) s.color = getRandomColor();
|
||||
colors.push(colors.shift());
|
||||
});
|
||||
|
||||
// randomize each already used color a bit
|
||||
colors.forEach(c => {
|
||||
const sameColored = pack.states.filter(s => s.color === c && !s.lock);
|
||||
sameColored.forEach((s, d) => {
|
||||
if (!d) return;
|
||||
s.color = getMixedColor(s.color);
|
||||
});
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("assignColors");
|
||||
};
|
||||
|
||||
const wars = {
|
||||
War: 6,
|
||||
Conflict: 2,
|
||||
Campaign: 4,
|
||||
Invasion: 2,
|
||||
Rebellion: 2,
|
||||
Conquest: 2,
|
||||
Intervention: 1,
|
||||
Expedition: 1,
|
||||
Crusade: 1
|
||||
};
|
||||
|
||||
export const generateCampaign = (state, pack, utils) => {
|
||||
const {P, gauss, rw, getAdjective, Names, options} = utils;
|
||||
const neighbors = state.neighbors.length ? state.neighbors : [0];
|
||||
return neighbors
|
||||
.map(i => {
|
||||
const name = i && P(0.8) ? pack.states[i].name : Names.getCultureShort(state.culture);
|
||||
const start = gauss(options.year - 100, 150, 1, options.year - 6);
|
||||
const end = start + gauss(4, 5, 1, options.year - start - 1);
|
||||
return {name: getAdjective(name) + " " + rw(wars), start, end};
|
||||
})
|
||||
.sort((a, b) => a.start - b.start);
|
||||
};
|
||||
|
||||
// generate historical conflicts of each state
|
||||
export const generateCampaigns = (pack, utils) => {
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
s.campaigns = generateCampaign(s, pack, utils);
|
||||
});
|
||||
};
|
||||
|
||||
// generate Diplomatic Relationships
|
||||
export const generateDiplomacy = (pack, utils) => {
|
||||
const {TIME, d3, P, ra, gauss, rw, trimVowels, options} = utils;
|
||||
TIME && console.time("generateDiplomacy");
|
||||
const {cells, states} = pack;
|
||||
const chronicle = (states[0].diplomacy = []);
|
||||
const valid = states.filter(s => s.i && !states.removed);
|
||||
|
||||
const neibs = {Ally: 1, Friendly: 2, Neutral: 1, Suspicion: 10, Rival: 9}; // relations to neighbors
|
||||
const neibsOfNeibs = {Ally: 10, Friendly: 8, Neutral: 5, Suspicion: 1}; // relations to neighbors of neighbors
|
||||
const far = {Friendly: 1, Neutral: 12, Suspicion: 2, Unknown: 6}; // relations to other
|
||||
const navals = {Neutral: 1, Suspicion: 2, Rival: 1, Unknown: 1}; // relations of naval powers
|
||||
|
||||
valid.forEach(s => (s.diplomacy = new Array(states.length).fill("x"))); // clear all relationships
|
||||
if (valid.length < 2) return; // no states to renerate relations with
|
||||
const areaMean = d3.mean(valid.map(s => s.area)); // average state area
|
||||
|
||||
// generic relations
|
||||
for (let f = 1; f < states.length; f++) {
|
||||
if (states[f].removed) continue;
|
||||
|
||||
if (states[f].diplomacy.includes("Vassal")) {
|
||||
// Vassals copy relations from their Suzerains
|
||||
const suzerain = states[f].diplomacy.indexOf("Vassal");
|
||||
|
||||
for (let i = 1; i < states.length; i++) {
|
||||
if (i === f || i === suzerain) continue;
|
||||
states[f].diplomacy[i] = states[suzerain].diplomacy[i];
|
||||
if (states[suzerain].diplomacy[i] === "Suzerain") states[f].diplomacy[i] = "Ally";
|
||||
for (let e = 1; e < states.length; e++) {
|
||||
if (e === f || e === suzerain) continue;
|
||||
if (states[e].diplomacy[suzerain] === "Suzerain" || states[e].diplomacy[suzerain] === "Vassal") continue;
|
||||
states[e].diplomacy[f] = states[e].diplomacy[suzerain];
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
for (let t = f + 1; t < states.length; t++) {
|
||||
if (states[t].removed) continue;
|
||||
|
||||
if (states[t].diplomacy.includes("Vassal")) {
|
||||
const suzerain = states[t].diplomacy.indexOf("Vassal");
|
||||
states[f].diplomacy[t] = states[f].diplomacy[suzerain];
|
||||
continue;
|
||||
}
|
||||
|
||||
const naval =
|
||||
states[f].type === "Naval" &&
|
||||
states[t].type === "Naval" &&
|
||||
cells.f[states[f].center] !== cells.f[states[t].center];
|
||||
const neib = naval ? false : states[f].neighbors.includes(t);
|
||||
const neibOfNeib =
|
||||
naval || neib
|
||||
? false
|
||||
: states[f].neighbors
|
||||
.map(n => states[n].neighbors)
|
||||
.join("")
|
||||
.includes(t);
|
||||
|
||||
let status = naval ? rw(navals) : neib ? rw(neibs) : neibOfNeib ? rw(neibsOfNeibs) : rw(far);
|
||||
|
||||
// add Vassal
|
||||
if (
|
||||
neib &&
|
||||
P(0.8) &&
|
||||
states[f].area > areaMean &&
|
||||
states[t].area < areaMean &&
|
||||
states[f].area / states[t].area > 2
|
||||
)
|
||||
status = "Vassal";
|
||||
states[f].diplomacy[t] = status === "Vassal" ? "Suzerain" : status;
|
||||
states[t].diplomacy[f] = status;
|
||||
}
|
||||
}
|
||||
|
||||
// declare wars
|
||||
for (let attacker = 1; attacker < states.length; attacker++) {
|
||||
const ad = states[attacker].diplomacy; // attacker relations;
|
||||
if (states[attacker].removed) continue;
|
||||
if (!ad.includes("Rival")) continue; // no rivals to attack
|
||||
if (ad.includes("Vassal")) continue; // not independent
|
||||
if (ad.includes("Enemy")) continue; // already at war
|
||||
|
||||
// random independent rival
|
||||
const defender = ra(
|
||||
ad.map((r, d) => (r === "Rival" && !states[d].diplomacy.includes("Vassal") ? d : 0)).filter(d => d)
|
||||
);
|
||||
let ap = states[attacker].area * states[attacker].expansionism;
|
||||
let dp = states[defender].area * states[defender].expansionism;
|
||||
if (ap < dp * gauss(1.6, 0.8, 0, 10, 2)) continue; // defender is too strong
|
||||
|
||||
const an = states[attacker].name;
|
||||
const dn = states[defender].name; // names
|
||||
const attackers = [attacker];
|
||||
const defenders = [defender]; // attackers and defenders array
|
||||
const dd = states[defender].diplomacy; // defender relations;
|
||||
|
||||
// start an ongoing war
|
||||
const name = `${an}-${trimVowels(dn)}ian War`;
|
||||
const start = options.year - gauss(2, 3, 0, 10);
|
||||
const war = [name, `${an} declared a war on its rival ${dn}`];
|
||||
const campaign = {name, start, attacker, defender};
|
||||
states[attacker].campaigns.push(campaign);
|
||||
states[defender].campaigns.push(campaign);
|
||||
|
||||
// attacker vassals join the war
|
||||
ad.forEach((r, d) => {
|
||||
if (r === "Suzerain") {
|
||||
attackers.push(d);
|
||||
war.push(`${an}'s vassal ${states[d].name} joined the war on attackers side`);
|
||||
}
|
||||
});
|
||||
|
||||
// defender vassals join the war
|
||||
dd.forEach((r, d) => {
|
||||
if (r === "Suzerain") {
|
||||
defenders.push(d);
|
||||
war.push(`${dn}'s vassal ${states[d].name} joined the war on defenders side`);
|
||||
}
|
||||
});
|
||||
|
||||
ap = d3.sum(attackers.map(a => states[a].area * states[a].expansionism)); // attackers joined power
|
||||
dp = d3.sum(defenders.map(d => states[d].area * states[d].expansionism)); // defender joined power
|
||||
|
||||
// defender allies join
|
||||
dd.forEach((r, d) => {
|
||||
if (r !== "Ally" || states[d].diplomacy.includes("Vassal")) return;
|
||||
if (states[d].diplomacy[attacker] !== "Rival" && ap / dp > 2 * gauss(1.6, 0.8, 0, 10, 2)) {
|
||||
const reason = states[d].diplomacy.includes("Enemy") ? "Being already at war," : `Frightened by ${an},`;
|
||||
war.push(`${reason} ${states[d].name} severed the defense pact with ${dn}`);
|
||||
dd[d] = states[d].diplomacy[defender] = "Suspicion";
|
||||
return;
|
||||
}
|
||||
defenders.push(d);
|
||||
dp += states[d].area * states[d].expansionism;
|
||||
war.push(`${dn}'s ally ${states[d].name} joined the war on defenders side`);
|
||||
|
||||
// ally vassals join
|
||||
states[d].diplomacy
|
||||
.map((r, d) => (r === "Suzerain" ? d : 0))
|
||||
.filter(d => d)
|
||||
.forEach(v => {
|
||||
defenders.push(v);
|
||||
dp += states[v].area * states[v].expansionism;
|
||||
war.push(`${states[d].name}'s vassal ${states[v].name} joined the war on defenders side`);
|
||||
});
|
||||
});
|
||||
|
||||
// attacker allies join if the defender is their rival or joined power > defenders power and defender is not an ally
|
||||
ad.forEach((r, d) => {
|
||||
if (r !== "Ally" || states[d].diplomacy.includes("Vassal") || defenders.includes(d)) return;
|
||||
const name = states[d].name;
|
||||
if (states[d].diplomacy[defender] !== "Rival" && (P(0.2) || ap <= dp * 1.2)) {
|
||||
war.push(`${an}'s ally ${name} avoided entering the war`);
|
||||
return;
|
||||
}
|
||||
const allies = states[d].diplomacy.map((r, d) => (r === "Ally" ? d : 0)).filter(d => d);
|
||||
if (allies.some(ally => defenders.includes(ally))) {
|
||||
war.push(`${an}'s ally ${name} did not join the war as its allies are in war on both sides`);
|
||||
return;
|
||||
}
|
||||
|
||||
attackers.push(d);
|
||||
ap += states[d].area * states[d].expansionism;
|
||||
war.push(`${an}'s ally ${name} joined the war on attackers side`);
|
||||
|
||||
// ally vassals join
|
||||
states[d].diplomacy
|
||||
.map((r, d) => (r === "Suzerain" ? d : 0))
|
||||
.filter(d => d)
|
||||
.forEach(v => {
|
||||
attackers.push(v);
|
||||
dp += states[v].area * states[v].expansionism;
|
||||
war.push(`${states[d].name}'s vassal ${states[v].name} joined the war on attackers side`);
|
||||
});
|
||||
});
|
||||
|
||||
// change relations to Enemy for all participants
|
||||
attackers.forEach(a => defenders.forEach(d => (states[a].diplomacy[d] = states[d].diplomacy[a] = "Enemy")));
|
||||
chronicle.push(war); // add a record to diplomatical history
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateDiplomacy");
|
||||
};
|
||||
|
||||
// select a forms for listed or all valid states
|
||||
export const defineStateForms = (list, pack, utils) => {
|
||||
const {TIME, d3, P, rw, rand, trimVowels, getAdjective} = utils;
|
||||
TIME && console.time("defineStateForms");
|
||||
const states = pack.states.filter(s => s.i && !s.removed && !s.lock);
|
||||
if (states.length < 1) return;
|
||||
|
||||
const generic = {Monarchy: 25, Republic: 2, Union: 1};
|
||||
const naval = {Monarchy: 25, Republic: 8, Union: 3};
|
||||
|
||||
const median = d3.median(pack.states.map(s => s.area));
|
||||
const empireMin = states.map(s => s.area).sort((a, b) => b - a)[Math.max(Math.ceil(states.length ** 0.4) - 2, 0)];
|
||||
const expTiers = pack.states.map(s => {
|
||||
let tier = Math.min(Math.floor((s.area / median) * 2.6), 4);
|
||||
if (tier === 4 && s.area < empireMin) tier = 3;
|
||||
return tier;
|
||||
});
|
||||
|
||||
const monarchy = ["Duchy", "Grand Duchy", "Principality", "Kingdom", "Empire"]; // per expansionism tier
|
||||
const republic = {
|
||||
Republic: 75,
|
||||
Federation: 4,
|
||||
"Trade Company": 4,
|
||||
"Most Serene Republic": 2,
|
||||
Oligarchy: 2,
|
||||
Tetrarchy: 1,
|
||||
Triumvirate: 1,
|
||||
Diarchy: 1,
|
||||
Junta: 1
|
||||
}; // weighted random
|
||||
const union = {
|
||||
Union: 3,
|
||||
League: 4,
|
||||
Confederation: 1,
|
||||
"United Kingdom": 1,
|
||||
"United Republic": 1,
|
||||
"United Provinces": 2,
|
||||
Commonwealth: 1,
|
||||
Heptarchy: 1
|
||||
}; // weighted random
|
||||
const theocracy = {Theocracy: 20, Brotherhood: 1, Thearchy: 2, See: 1, "Holy State": 1};
|
||||
const anarchy = {"Free Territory": 2, Council: 3, Commune: 1, Community: 1};
|
||||
|
||||
for (const s of states) {
|
||||
if (list && !list.includes(s.i)) continue;
|
||||
const tier = expTiers[s.i];
|
||||
|
||||
const religion = pack.cells.religion[s.center];
|
||||
const isTheocracy =
|
||||
(religion && pack.religions[religion].expansion === "state") ||
|
||||
(P(0.1) && ["Organized", "Cult"].includes(pack.religions[religion].type));
|
||||
const isAnarchy = P(0.01 - tier / 500);
|
||||
|
||||
if (isTheocracy) s.form = "Theocracy";
|
||||
else if (isAnarchy) s.form = "Anarchy";
|
||||
else s.form = s.type === "Naval" ? rw(naval) : rw(generic);
|
||||
s.formName = selectForm(s, tier, pack, utils);
|
||||
s.fullName = getFullName(s, utils);
|
||||
}
|
||||
|
||||
function selectForm(s, tier, pack, utils) {
|
||||
const {P, rand, rw, trimVowels} = utils;
|
||||
const base = pack.cultures[s.culture].base;
|
||||
|
||||
if (s.form === "Monarchy") {
|
||||
const form = monarchy[tier];
|
||||
// Default name depends on exponent tier, some culture bases have special names for tiers
|
||||
if (s.diplomacy) {
|
||||
if (
|
||||
form === "Duchy" &&
|
||||
s.neighbors.length > 1 &&
|
||||
rand(6) < s.neighbors.length &&
|
||||
s.diplomacy.includes("Vassal")
|
||||
)
|
||||
return "Marches"; // some vassal duchies on borderland
|
||||
if (base === 1 && P(0.3) && s.diplomacy.includes("Vassal")) return "Dominion"; // English vassals
|
||||
if (P(0.3) && s.diplomacy.includes("Vassal")) return "Protectorate"; // some vassals
|
||||
}
|
||||
|
||||
if (base === 31 && (form === "Empire" || form === "Kingdom")) return "Khanate"; // Mongolian
|
||||
if (base === 16 && form === "Principality") return "Beylik"; // Turkic
|
||||
if (base === 5 && (form === "Empire" || form === "Kingdom")) return "Tsardom"; // Ruthenian
|
||||
if (base === 16 && (form === "Empire" || form === "Kingdom")) return "Khaganate"; // Turkic
|
||||
if (base === 12 && (form === "Kingdom" || form === "Grand Duchy")) return "Shogunate"; // Japanese
|
||||
if ([18, 17].includes(base) && form === "Empire") return "Caliphate"; // Arabic, Berber
|
||||
if (base === 18 && (form === "Grand Duchy" || form === "Duchy")) return "Emirate"; // Arabic
|
||||
if (base === 7 && (form === "Grand Duchy" || form === "Duchy")) return "Despotate"; // Greek
|
||||
if (base === 31 && (form === "Grand Duchy" || form === "Duchy")) return "Ulus"; // Mongolian
|
||||
if (base === 16 && (form === "Grand Duchy" || form === "Duchy")) return "Horde"; // Turkic
|
||||
if (base === 24 && (form === "Grand Duchy" || form === "Duchy")) return "Satrapy"; // Iranian
|
||||
return form;
|
||||
}
|
||||
|
||||
if (s.form === "Republic") {
|
||||
// Default name is from weighted array, special case for small states with only 1 burg
|
||||
if (tier < 2 && s.burgs === 1) {
|
||||
if (trimVowels(s.name) === trimVowels(pack.burgs[s.capital].name)) {
|
||||
s.name = pack.burgs[s.capital].name;
|
||||
return "Free City";
|
||||
}
|
||||
if (P(0.3)) return "City-state";
|
||||
}
|
||||
return rw(republic);
|
||||
}
|
||||
|
||||
if (s.form === "Union") return rw(union);
|
||||
if (s.form === "Anarchy") return rw(anarchy);
|
||||
|
||||
if (s.form === "Theocracy") {
|
||||
// European
|
||||
if ([0, 1, 2, 3, 4, 6, 8, 9, 13, 15, 20].includes(base)) {
|
||||
if (P(0.1)) return "Divine " + monarchy[tier];
|
||||
if (tier < 2 && P(0.5)) return "Diocese";
|
||||
if (tier < 2 && P(0.5)) return "Bishopric";
|
||||
}
|
||||
if (P(0.9) && [7, 5].includes(base)) {
|
||||
// Greek, Ruthenian
|
||||
if (tier < 2) return "Eparchy";
|
||||
if (tier === 2) return "Exarchate";
|
||||
if (tier > 2) return "Patriarchate";
|
||||
}
|
||||
if (P(0.9) && [21, 16].includes(base)) return "Imamah"; // Nigerian, Turkish
|
||||
if (tier > 2 && P(0.8) && [18, 17, 28].includes(base)) return "Caliphate"; // Arabic, Berber, Swahili
|
||||
return rw(theocracy);
|
||||
}
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("defineStateForms");
|
||||
};
|
||||
|
||||
// state forms requiring Adjective + Name, all other forms use scheme Form + Of + Name
|
||||
const adjForms = [
|
||||
"Empire",
|
||||
"Sultanate",
|
||||
"Khaganate",
|
||||
"Shogunate",
|
||||
"Caliphate",
|
||||
"Despotate",
|
||||
"Theocracy",
|
||||
"Oligarchy",
|
||||
"Union",
|
||||
"Confederation",
|
||||
"Trade Company",
|
||||
"League",
|
||||
"Tetrarchy",
|
||||
"Triumvirate",
|
||||
"Diarchy",
|
||||
"Horde",
|
||||
"Marches"
|
||||
];
|
||||
|
||||
export const getFullName = (state, utils) => {
|
||||
const {getAdjective} = utils;
|
||||
if (!state.formName) return state.name;
|
||||
if (!state.name && state.formName) return "The " + state.formName;
|
||||
const adjName = adjForms.includes(state.formName) && !/-| /.test(state.name);
|
||||
return adjName ? `${getAdjective(state.name)} ${state.formName}` : `${state.formName} of ${state.name}`;
|
||||
};
|
||||
52
procedural/src/engine/support/burgs-and-states_config.md
Normal file
52
procedural/src/engine/support/burgs-and-states_config.md
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
# Burgs and States Module - Configuration Properties
|
||||
|
||||
The refactored `burgs-and-states.js` module requires the following configuration properties to be passed via the `config` object:
|
||||
|
||||
## Required Config Properties
|
||||
|
||||
### State Generation Configuration
|
||||
- **`statesNumber`** - Number of states to generate
|
||||
- **Original DOM call:** `byId("statesNumber").value`
|
||||
- **Line reference:** Line 98 in original code
|
||||
- **Usage:** Determines how many capital cities and states to create
|
||||
|
||||
- **`sizeVariety`** - Variety factor for state sizes
|
||||
- **Original DOM call:** `byId("sizeVariety").value`
|
||||
- **Line reference:** Line 159 in original code
|
||||
- **Usage:** Controls randomization of state expansionism values
|
||||
|
||||
### Settlement Configuration
|
||||
- **`manorsInput`** - Number of towns/settlements to generate
|
||||
- **Original DOM call:** `manorsInput.value` and `manorsInput.valueAsNumber`
|
||||
- **Line references:** Lines 193, 195, 220 in original code
|
||||
- **Usage:** Controls the number of secondary settlements (towns) to place
|
||||
|
||||
### Growth Rate Configuration
|
||||
- **`growthRate`** - Global growth rate multiplier
|
||||
- **Original DOM call:** `byId("growthRate").valueAsNumber`
|
||||
- **Line reference:** Line 363 in original code
|
||||
- **Usage:** Controls how aggressively states expand during the expansion phase
|
||||
|
||||
- **`statesGrowthRate`** - State-specific growth rate multiplier
|
||||
- **Original DOM call:** `byId("statesGrowthRate")?.valueAsNumber`
|
||||
- **Line reference:** Line 364 in original code
|
||||
- **Usage:** Additional multiplier specifically for state expansion behavior
|
||||
|
||||
## Config Object Structure
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
statesNumber: 15, // Number of states to generate
|
||||
sizeVariety: 1, // State size variety factor
|
||||
manorsInput: 1000, // Number of towns (1000 = auto-calculate)
|
||||
growthRate: 1, // Global growth rate multiplier
|
||||
statesGrowthRate: 1 // State growth rate multiplier
|
||||
};
|
||||
```
|
||||
|
||||
## Usage Notes
|
||||
|
||||
- **`manorsInput`**: When set to `1000`, the system auto-calculates the number of towns based on available populated cells
|
||||
- **Growth rates**: Both growth rate properties default to `1` if not provided
|
||||
- **`statesGrowthRate`**: Uses optional chaining (`?.`) in original code, indicating it might not always be present
|
||||
- All numeric values are converted using `+` operator or `.valueAsNumber` in the original DOM calls
|
||||
90
procedural/src/engine/support/burgs-and-states_external.md
Normal file
90
procedural/src/engine/support/burgs-and-states_external.md
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
# Burgs and States Module - External Dependencies
|
||||
|
||||
The refactored `burgs-and-states.js` module requires the following external dependencies to be injected via the `utils` parameter:
|
||||
|
||||
## Required Utilities
|
||||
|
||||
### Core Utilities
|
||||
- **`TIME`** - Global timing flag for performance monitoring (boolean)
|
||||
- **`WARN`** - Warning logging flag (boolean)
|
||||
- **`ERROR`** - Error logging flag (boolean)
|
||||
- **`d3`** - D3.js library for mathematical functions and data structures
|
||||
- `d3.quadtree()` - Spatial data structure for efficient proximity searches
|
||||
- `d3.mean()` - Calculate mean values
|
||||
- `d3.median()` - Calculate median values
|
||||
- `d3.sum()` - Calculate sum of arrays
|
||||
- **`rn`** - Rounding utility function for numerical precision
|
||||
- **`P`** - Probability utility function for random boolean generation
|
||||
- **`gauss`** - Gaussian/normal distribution random number generator
|
||||
- **`ra`** - Random array element selector
|
||||
- **`rw`** - Weighted random selector
|
||||
- **`minmax`** - Min/max clamping utility
|
||||
- **`each`** - Utility for creating interval checkers
|
||||
- **`rand`** - Random number generator
|
||||
|
||||
### External Modules
|
||||
- **`Names`** - Name generation module
|
||||
- `Names.getCultureShort()` - Generate short cultural names
|
||||
- `Names.getState()` - Generate state names
|
||||
- `Names.getCulture()` - Generate cultural names
|
||||
- **`COA`** - Coat of Arms generation module
|
||||
- `COA.generate()` - Generate coat of arms
|
||||
- `COA.getShield()` - Generate shield designs
|
||||
- **`biomesData`** - Biome data containing cost arrays
|
||||
- **`options`** - Global options object containing year settings
|
||||
- **`FlatQueue`** - Priority queue implementation for pathfinding
|
||||
|
||||
### Color Utilities
|
||||
- **`getColors`** - Generate color palettes
|
||||
- **`getRandomColor`** - Generate random colors
|
||||
- **`getMixedColor`** - Create color variations
|
||||
|
||||
### String Utilities
|
||||
- **`getAdjective`** - Convert nouns to adjectives
|
||||
- **`trimVowels`** - Remove vowels from strings
|
||||
|
||||
### Geometric Utilities
|
||||
- **`getPolesOfInaccessibility`** - Calculate pole of inaccessibility for polygons
|
||||
|
||||
### Graph Properties
|
||||
- **`graphWidth`** - Width of the generated graph
|
||||
- **`graphHeight`** - Height of the generated graph
|
||||
|
||||
## Import Structure
|
||||
|
||||
When integrating this module, the calling code should provide these utilities:
|
||||
|
||||
```javascript
|
||||
import { generate, expandStates, specifyBurgs, /* other functions */ } from './burgs-and-states.js';
|
||||
|
||||
const utils = {
|
||||
TIME: globalTimeFlag,
|
||||
WARN: warnFlag,
|
||||
ERROR: errorFlag,
|
||||
d3: d3Library,
|
||||
rn: roundingFunction,
|
||||
P: probabilityFunction,
|
||||
gauss: gaussianRandom,
|
||||
ra: randomArrayElement,
|
||||
rw: weightedRandom,
|
||||
minmax: minMaxClamp,
|
||||
each: intervalChecker,
|
||||
rand: randomGenerator,
|
||||
Names: namesModule,
|
||||
COA: coaModule,
|
||||
biomesData: biomesDataObject,
|
||||
options: globalOptions,
|
||||
FlatQueue: flatQueueClass,
|
||||
getColors: colorGenerator,
|
||||
getRandomColor: randomColorGenerator,
|
||||
getMixedColor: colorMixer,
|
||||
getAdjective: adjectiveConverter,
|
||||
trimVowels: vowelTrimmer,
|
||||
getPolesOfInaccessibility: poleCalculator,
|
||||
graphWidth: mapWidth,
|
||||
graphHeight: mapHeight
|
||||
};
|
||||
|
||||
// Usage
|
||||
const result = generate(pack, grid, config, utils);
|
||||
```
|
||||
967
procedural/src/engine/support/burgs-and-states_prompt.md
Normal file
967
procedural/src/engine/support/burgs-and-states_prompt.md
Normal file
|
|
@ -0,0 +1,967 @@
|
|||
# burgs-and-states.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
7. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.txt`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `burgs-and-states.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.BurgsAndStates = (() => {
|
||||
const generate = () => {
|
||||
const {cells, cultures} = pack;
|
||||
const n = cells.i.length;
|
||||
|
||||
cells.burg = new Uint16Array(n); // cell burg
|
||||
|
||||
const burgs = (pack.burgs = placeCapitals());
|
||||
pack.states = createStates();
|
||||
|
||||
placeTowns();
|
||||
expandStates();
|
||||
normalizeStates();
|
||||
getPoles();
|
||||
|
||||
specifyBurgs();
|
||||
|
||||
collectStatistics();
|
||||
assignColors();
|
||||
|
||||
generateCampaigns();
|
||||
generateDiplomacy();
|
||||
|
||||
function placeCapitals() {
|
||||
TIME && console.time("placeCapitals");
|
||||
let count = +byId("statesNumber").value;
|
||||
let burgs = [0];
|
||||
|
||||
const rand = () => 0.5 + Math.random() * 0.5;
|
||||
const score = new Int16Array(cells.s.map(s => s * rand())); // cell score for capitals placement
|
||||
const sorted = cells.i.filter(i => score[i] > 0 && cells.culture[i]).sort((a, b) => score[b] - score[a]); // filtered and sorted array of indexes
|
||||
|
||||
if (sorted.length < count * 10) {
|
||||
count = Math.floor(sorted.length / 10);
|
||||
if (!count) {
|
||||
WARN && console.warn("There is no populated cells. Cannot generate states");
|
||||
return burgs;
|
||||
} else {
|
||||
WARN && console.warn(`Not enough populated cells (${sorted.length}). Will generate only ${count} states`);
|
||||
}
|
||||
}
|
||||
|
||||
let burgsTree = d3.quadtree();
|
||||
let spacing = (graphWidth + graphHeight) / 2 / count; // min distance between capitals
|
||||
|
||||
for (let i = 0; burgs.length <= count; i++) {
|
||||
const cell = sorted[i];
|
||||
const [x, y] = cells.p[cell];
|
||||
|
||||
if (burgsTree.find(x, y, spacing) === undefined) {
|
||||
burgs.push({cell, x, y});
|
||||
burgsTree.add([x, y]);
|
||||
}
|
||||
|
||||
if (i === sorted.length - 1) {
|
||||
WARN && console.warn("Cannot place capitals with current spacing. Trying again with reduced spacing");
|
||||
burgsTree = d3.quadtree();
|
||||
i = -1;
|
||||
burgs = [0];
|
||||
spacing /= 1.2;
|
||||
}
|
||||
}
|
||||
|
||||
burgs[0] = burgsTree;
|
||||
TIME && console.timeEnd("placeCapitals");
|
||||
return burgs;
|
||||
}
|
||||
|
||||
// For each capital create a state
|
||||
function createStates() {
|
||||
TIME && console.time("createStates");
|
||||
const states = [{i: 0, name: "Neutrals"}];
|
||||
const colors = getColors(burgs.length - 1);
|
||||
const each5th = each(5);
|
||||
|
||||
burgs.forEach((b, i) => {
|
||||
if (!i) return; // skip first element
|
||||
|
||||
// burgs data
|
||||
b.i = b.state = i;
|
||||
b.culture = cells.culture[b.cell];
|
||||
b.name = Names.getCultureShort(b.culture);
|
||||
b.feature = cells.f[b.cell];
|
||||
b.capital = 1;
|
||||
|
||||
// states data
|
||||
const expansionism = rn(Math.random() * byId("sizeVariety").value + 1, 1);
|
||||
const basename = b.name.length < 9 && each5th(b.cell) ? b.name : Names.getCultureShort(b.culture);
|
||||
const name = Names.getState(basename, b.culture);
|
||||
const type = cultures[b.culture].type;
|
||||
|
||||
const coa = COA.generate(null, null, null, type);
|
||||
coa.shield = COA.getShield(b.culture, null);
|
||||
states.push({
|
||||
i,
|
||||
color: colors[i - 1],
|
||||
name,
|
||||
expansionism,
|
||||
capital: i,
|
||||
type,
|
||||
center: b.cell,
|
||||
culture: b.culture,
|
||||
coa
|
||||
});
|
||||
cells.burg[b.cell] = i;
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("createStates");
|
||||
return states;
|
||||
}
|
||||
|
||||
// place secondary settlements based on geo and economical evaluation
|
||||
function placeTowns() {
|
||||
TIME && console.time("placeTowns");
|
||||
const score = new Int16Array(cells.s.map(s => s * gauss(1, 3, 0, 20, 3))); // a bit randomized cell score for towns placement
|
||||
const sorted = cells.i
|
||||
.filter(i => !cells.burg[i] && score[i] > 0 && cells.culture[i])
|
||||
.sort((a, b) => score[b] - score[a]); // filtered and sorted array of indexes
|
||||
|
||||
const desiredNumber =
|
||||
manorsInput.value == 1000
|
||||
? rn(sorted.length / 5 / (grid.points.length / 10000) ** 0.8)
|
||||
: manorsInput.valueAsNumber;
|
||||
const burgsNumber = Math.min(desiredNumber, sorted.length); // towns to generate
|
||||
let burgsAdded = 0;
|
||||
|
||||
const burgsTree = burgs[0];
|
||||
let spacing = (graphWidth + graphHeight) / 150 / (burgsNumber ** 0.7 / 66); // min distance between towns
|
||||
|
||||
while (burgsAdded < burgsNumber && spacing > 1) {
|
||||
for (let i = 0; burgsAdded < burgsNumber && i < sorted.length; i++) {
|
||||
if (cells.burg[sorted[i]]) continue;
|
||||
const cell = sorted[i];
|
||||
const [x, y] = cells.p[cell];
|
||||
const s = spacing * gauss(1, 0.3, 0.2, 2, 2); // randomize to make placement not uniform
|
||||
if (burgsTree.find(x, y, s) !== undefined) continue; // to close to existing burg
|
||||
const burg = burgs.length;
|
||||
const culture = cells.culture[cell];
|
||||
const name = Names.getCulture(culture);
|
||||
burgs.push({cell, x, y, state: 0, i: burg, culture, name, capital: 0, feature: cells.f[cell]});
|
||||
burgsTree.add([x, y]);
|
||||
cells.burg[cell] = burg;
|
||||
burgsAdded++;
|
||||
}
|
||||
spacing *= 0.5;
|
||||
}
|
||||
|
||||
if (manorsInput.value != 1000 && burgsAdded < desiredNumber) {
|
||||
ERROR && console.error(`Cannot place all burgs. Requested ${desiredNumber}, placed ${burgsAdded}`);
|
||||
}
|
||||
|
||||
burgs[0] = {name: undefined}; // do not store burgsTree anymore
|
||||
TIME && console.timeEnd("placeTowns");
|
||||
}
|
||||
};
|
||||
|
||||
// define burg coordinates, coa, port status and define details
|
||||
const specifyBurgs = () => {
|
||||
TIME && console.time("specifyBurgs");
|
||||
const {cells, features} = pack;
|
||||
const temp = grid.cells.temp;
|
||||
|
||||
for (const b of pack.burgs) {
|
||||
if (!b.i || b.lock) continue;
|
||||
const i = b.cell;
|
||||
|
||||
// asign port status to some coastline burgs with temp > 0 °C
|
||||
const haven = cells.haven[i];
|
||||
if (haven && temp[cells.g[i]] > 0) {
|
||||
const f = cells.f[haven]; // water body id
|
||||
// port is a capital with any harbor OR town with good harbor
|
||||
const port = features[f].cells > 1 && ((b.capital && cells.harbor[i]) || cells.harbor[i] === 1);
|
||||
b.port = port ? f : 0; // port is defined by water body id it lays on
|
||||
} else b.port = 0;
|
||||
|
||||
// define burg population (keep urbanization at about 10% rate)
|
||||
b.population = rn(Math.max(cells.s[i] / 8 + b.i / 1000 + (i % 100) / 1000, 0.1), 3);
|
||||
if (b.capital) b.population = rn(b.population * 1.3, 3); // increase capital population
|
||||
|
||||
if (b.port) {
|
||||
b.population = b.population * 1.3; // increase port population
|
||||
const [x, y] = getCloseToEdgePoint(i, haven);
|
||||
b.x = x;
|
||||
b.y = y;
|
||||
}
|
||||
|
||||
// add random factor
|
||||
b.population = rn(b.population * gauss(2, 3, 0.6, 20, 3), 3);
|
||||
|
||||
// shift burgs on rivers semi-randomly and just a bit
|
||||
if (!b.port && cells.r[i]) {
|
||||
const shift = Math.min(cells.fl[i] / 150, 1);
|
||||
if (i % 2) b.x = rn(b.x + shift, 2);
|
||||
else b.x = rn(b.x - shift, 2);
|
||||
if (cells.r[i] % 2) b.y = rn(b.y + shift, 2);
|
||||
else b.y = rn(b.y - shift, 2);
|
||||
}
|
||||
|
||||
// define emblem
|
||||
const state = pack.states[b.state];
|
||||
const stateCOA = state.coa;
|
||||
let kinship = 0.25;
|
||||
if (b.capital) kinship += 0.1;
|
||||
else if (b.port) kinship -= 0.1;
|
||||
if (b.culture !== state.culture) kinship -= 0.25;
|
||||
b.type = getType(i, b.port);
|
||||
const type = b.capital && P(0.2) ? "Capital" : b.type === "Generic" ? "City" : b.type;
|
||||
b.coa = COA.generate(stateCOA, kinship, null, type);
|
||||
b.coa.shield = COA.getShield(b.culture, b.state);
|
||||
}
|
||||
|
||||
// de-assign port status if it's the only one on feature
|
||||
const ports = pack.burgs.filter(b => !b.removed && b.port > 0);
|
||||
for (const f of features) {
|
||||
if (!f.i || f.land || f.border) continue;
|
||||
const featurePorts = ports.filter(b => b.port === f.i);
|
||||
if (featurePorts.length === 1) featurePorts[0].port = 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("specifyBurgs");
|
||||
};
|
||||
|
||||
function getCloseToEdgePoint(cell1, cell2) {
|
||||
const {cells, vertices} = pack;
|
||||
|
||||
const [x0, y0] = cells.p[cell1];
|
||||
|
||||
const commonVertices = cells.v[cell1].filter(vertex => vertices.c[vertex].some(cell => cell === cell2));
|
||||
const [x1, y1] = vertices.p[commonVertices[0]];
|
||||
const [x2, y2] = vertices.p[commonVertices[1]];
|
||||
const xEdge = (x1 + x2) / 2;
|
||||
const yEdge = (y1 + y2) / 2;
|
||||
|
||||
const x = rn(x0 + 0.95 * (xEdge - x0), 2);
|
||||
const y = rn(y0 + 0.95 * (yEdge - y0), 2);
|
||||
|
||||
return [x, y];
|
||||
}
|
||||
|
||||
const getType = (cellId, port) => {
|
||||
const {cells, features, burgs} = pack;
|
||||
|
||||
if (port) return "Naval";
|
||||
|
||||
const haven = cells.haven[cellId];
|
||||
if (haven !== undefined && features[cells.f[haven]].type === "lake") return "Lake";
|
||||
|
||||
if (cells.h[cellId] > 60) return "Highland";
|
||||
|
||||
if (cells.r[cellId] && cells.fl[cellId] >= 100) return "River";
|
||||
|
||||
const biome = cells.biome[cellId];
|
||||
const population = cells.pop[cellId];
|
||||
if (!cells.burg[cellId] || population <= 5) {
|
||||
if (population < 5 && [1, 2, 3, 4].includes(biome)) return "Nomadic";
|
||||
if (biome > 4 && biome < 10) return "Hunting";
|
||||
}
|
||||
|
||||
return "Generic";
|
||||
};
|
||||
|
||||
const defineBurgFeatures = burg => {
|
||||
const {cells} = pack;
|
||||
|
||||
pack.burgs
|
||||
.filter(b => (burg ? b.i == burg.i : b.i && !b.removed && !b.lock))
|
||||
.forEach(b => {
|
||||
const pop = b.population;
|
||||
b.citadel = Number(b.capital || (pop > 50 && P(0.75)) || (pop > 15 && P(0.5)) || P(0.1));
|
||||
b.plaza = Number(pop > 20 || (pop > 10 && P(0.8)) || (pop > 4 && P(0.7)) || P(0.6));
|
||||
b.walls = Number(b.capital || pop > 30 || (pop > 20 && P(0.75)) || (pop > 10 && P(0.5)) || P(0.1));
|
||||
b.shanty = Number(pop > 60 || (pop > 40 && P(0.75)) || (pop > 20 && b.walls && P(0.4)));
|
||||
const religion = cells.religion[b.cell];
|
||||
const theocracy = pack.states[b.state].form === "Theocracy";
|
||||
b.temple = Number(
|
||||
(religion && theocracy && P(0.5)) || pop > 50 || (pop > 35 && P(0.75)) || (pop > 20 && P(0.5))
|
||||
);
|
||||
});
|
||||
};
|
||||
|
||||
// expand cultures across the map (Dijkstra-like algorithm)
|
||||
const expandStates = () => {
|
||||
TIME && console.time("expandStates");
|
||||
const {cells, states, cultures, burgs} = pack;
|
||||
|
||||
cells.state = cells.state || new Uint16Array(cells.i.length);
|
||||
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
const globalGrowthRate = byId("growthRate").valueAsNumber || 1;
|
||||
const statesGrowthRate = byId("statesGrowthRate")?.valueAsNumber || 1;
|
||||
const growthRate = (cells.i.length / 2) * globalGrowthRate * statesGrowthRate; // limit cost for state growth
|
||||
|
||||
// remove state from all cells except of locked
|
||||
for (const cellId of cells.i) {
|
||||
const state = states[cells.state[cellId]];
|
||||
if (state.lock) continue;
|
||||
cells.state[cellId] = 0;
|
||||
}
|
||||
|
||||
for (const state of states) {
|
||||
if (!state.i || state.removed) continue;
|
||||
|
||||
const capitalCell = burgs[state.capital].cell;
|
||||
cells.state[capitalCell] = state.i;
|
||||
const cultureCenter = cultures[state.culture].center;
|
||||
const b = cells.biome[cultureCenter]; // state native biome
|
||||
queue.push({e: state.center, p: 0, s: state.i, b}, 0);
|
||||
cost[state.center] = 1;
|
||||
}
|
||||
|
||||
while (queue.length) {
|
||||
const next = queue.pop();
|
||||
|
||||
const {e, p, s, b} = next;
|
||||
const {type, culture} = states[s];
|
||||
|
||||
cells.c[e].forEach(e => {
|
||||
const state = states[cells.state[e]];
|
||||
if (state.lock) return; // do not overwrite cell of locked states
|
||||
if (cells.state[e] && e === state.center) return; // do not overwrite capital cells
|
||||
|
||||
const cultureCost = culture === cells.culture[e] ? -9 : 100;
|
||||
const populationCost = cells.h[e] < 20 ? 0 : cells.s[e] ? Math.max(20 - cells.s[e], 0) : 5000;
|
||||
const biomeCost = getBiomeCost(b, cells.biome[e], type);
|
||||
const heightCost = getHeightCost(pack.features[cells.f[e]], cells.h[e], type);
|
||||
const riverCost = getRiverCost(cells.r[e], e, type);
|
||||
const typeCost = getTypeCost(cells.t[e], type);
|
||||
const cellCost = Math.max(cultureCost + populationCost + biomeCost + heightCost + riverCost + typeCost, 0);
|
||||
const totalCost = p + 10 + cellCost / states[s].expansionism;
|
||||
|
||||
if (totalCost > growthRate) return;
|
||||
|
||||
if (!cost[e] || totalCost < cost[e]) {
|
||||
if (cells.h[e] >= 20) cells.state[e] = s; // assign state to cell
|
||||
cost[e] = totalCost;
|
||||
queue.push({e, p: totalCost, s, b}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
burgs.filter(b => b.i && !b.removed).forEach(b => (b.state = cells.state[b.cell])); // assign state to burgs
|
||||
|
||||
function getBiomeCost(b, biome, type) {
|
||||
if (b === biome) return 10; // tiny penalty for native biome
|
||||
if (type === "Hunting") return biomesData.cost[biome] * 2; // non-native biome penalty for hunters
|
||||
if (type === "Nomadic" && biome > 4 && biome < 10) return biomesData.cost[biome] * 3; // forest biome penalty for nomads
|
||||
return biomesData.cost[biome]; // general non-native biome penalty
|
||||
}
|
||||
|
||||
function getHeightCost(f, h, type) {
|
||||
if (type === "Lake" && f.type === "lake") return 10; // low lake crossing penalty for Lake cultures
|
||||
if (type === "Naval" && h < 20) return 300; // low sea crossing penalty for Navals
|
||||
if (type === "Nomadic" && h < 20) return 10000; // giant sea crossing penalty for Nomads
|
||||
if (h < 20) return 1000; // general sea crossing penalty
|
||||
if (type === "Highland" && h < 62) return 1100; // penalty for highlanders on lowlands
|
||||
if (type === "Highland") return 0; // no penalty for highlanders on highlands
|
||||
if (h >= 67) return 2200; // general mountains crossing penalty
|
||||
if (h >= 44) return 300; // general hills crossing penalty
|
||||
return 0;
|
||||
}
|
||||
|
||||
function getRiverCost(r, i, type) {
|
||||
if (type === "River") return r ? 0 : 100; // penalty for river cultures
|
||||
if (!r) return 0; // no penalty for others if there is no river
|
||||
return minmax(cells.fl[i] / 10, 20, 100); // river penalty from 20 to 100 based on flux
|
||||
}
|
||||
|
||||
function getTypeCost(t, type) {
|
||||
if (t === 1) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline
|
||||
if (t === 2) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads
|
||||
if (t !== -1) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals
|
||||
return 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("expandStates");
|
||||
};
|
||||
|
||||
const normalizeStates = () => {
|
||||
TIME && console.time("normalizeStates");
|
||||
const {cells, burgs} = pack;
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.h[i] < 20 || cells.burg[i]) continue; // do not overwrite burgs
|
||||
if (pack.states[cells.state[i]]?.lock) continue; // do not overwrite cells of locks states
|
||||
if (cells.c[i].some(c => burgs[cells.burg[c]].capital)) continue; // do not overwrite near capital
|
||||
const neibs = cells.c[i].filter(c => cells.h[c] >= 20);
|
||||
const adversaries = neibs.filter(c => !pack.states[cells.state[c]]?.lock && cells.state[c] !== cells.state[i]);
|
||||
if (adversaries.length < 2) continue;
|
||||
const buddies = neibs.filter(c => !pack.states[cells.state[c]]?.lock && cells.state[c] === cells.state[i]);
|
||||
if (buddies.length > 2) continue;
|
||||
if (adversaries.length <= buddies.length) continue;
|
||||
cells.state[i] = cells.state[adversaries[0]];
|
||||
}
|
||||
TIME && console.timeEnd("normalizeStates");
|
||||
};
|
||||
|
||||
// calculate pole of inaccessibility for each state
|
||||
const getPoles = () => {
|
||||
const getType = cellId => pack.cells.state[cellId];
|
||||
const poles = getPolesOfInaccessibility(pack, getType);
|
||||
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
s.pole = poles[s.i] || [0, 0];
|
||||
});
|
||||
};
|
||||
|
||||
// Resets the cultures of all burgs and states to their cell or center cell's (respectively) culture
|
||||
const updateCultures = () => {
|
||||
TIME && console.time("updateCulturesForBurgsAndStates");
|
||||
|
||||
// Assign the culture associated with the burgs cell
|
||||
pack.burgs = pack.burgs.map((burg, index) => {
|
||||
if (index === 0) return burg;
|
||||
return {...burg, culture: pack.cells.culture[burg.cell]};
|
||||
});
|
||||
|
||||
// Assign the culture associated with the states' center cell
|
||||
pack.states = pack.states.map((state, index) => {
|
||||
if (index === 0) return state;
|
||||
return {...state, culture: pack.cells.culture[state.center]};
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("updateCulturesForBurgsAndStates");
|
||||
};
|
||||
|
||||
// calculate states data like area, population etc.
|
||||
const collectStatistics = () => {
|
||||
TIME && console.time("collectStatistics");
|
||||
const {cells, states} = pack;
|
||||
|
||||
states.forEach(s => {
|
||||
if (s.removed) return;
|
||||
s.cells = s.area = s.burgs = s.rural = s.urban = 0;
|
||||
s.neighbors = new Set();
|
||||
});
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.h[i] < 20) continue;
|
||||
const s = cells.state[i];
|
||||
|
||||
// check for neighboring states
|
||||
cells.c[i]
|
||||
.filter(c => cells.h[c] >= 20 && cells.state[c] !== s)
|
||||
.forEach(c => states[s].neighbors.add(cells.state[c]));
|
||||
|
||||
// collect stats
|
||||
states[s].cells += 1;
|
||||
states[s].area += cells.area[i];
|
||||
states[s].rural += cells.pop[i];
|
||||
if (cells.burg[i]) {
|
||||
states[s].urban += pack.burgs[cells.burg[i]].population;
|
||||
states[s].burgs++;
|
||||
}
|
||||
}
|
||||
|
||||
// convert neighbors Set object into array
|
||||
states.forEach(s => {
|
||||
if (!s.neighbors) return;
|
||||
s.neighbors = Array.from(s.neighbors);
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("collectStatistics");
|
||||
};
|
||||
|
||||
const assignColors = () => {
|
||||
TIME && console.time("assignColors");
|
||||
const colors = ["#66c2a5", "#fc8d62", "#8da0cb", "#e78ac3", "#a6d854", "#ffd92f"]; // d3.schemeSet2;
|
||||
|
||||
// assign basic color using greedy coloring algorithm
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed || s.lock) return;
|
||||
const neibs = s.neighbors;
|
||||
s.color = colors.find(c => neibs.every(n => pack.states[n].color !== c));
|
||||
if (!s.color) s.color = getRandomColor();
|
||||
colors.push(colors.shift());
|
||||
});
|
||||
|
||||
// randomize each already used color a bit
|
||||
colors.forEach(c => {
|
||||
const sameColored = pack.states.filter(s => s.color === c && !s.lock);
|
||||
sameColored.forEach((s, d) => {
|
||||
if (!d) return;
|
||||
s.color = getMixedColor(s.color);
|
||||
});
|
||||
});
|
||||
|
||||
TIME && console.timeEnd("assignColors");
|
||||
};
|
||||
|
||||
const wars = {
|
||||
War: 6,
|
||||
Conflict: 2,
|
||||
Campaign: 4,
|
||||
Invasion: 2,
|
||||
Rebellion: 2,
|
||||
Conquest: 2,
|
||||
Intervention: 1,
|
||||
Expedition: 1,
|
||||
Crusade: 1
|
||||
};
|
||||
|
||||
const generateCampaign = state => {
|
||||
const neighbors = state.neighbors.length ? state.neighbors : [0];
|
||||
return neighbors
|
||||
.map(i => {
|
||||
const name = i && P(0.8) ? pack.states[i].name : Names.getCultureShort(state.culture);
|
||||
const start = gauss(options.year - 100, 150, 1, options.year - 6);
|
||||
const end = start + gauss(4, 5, 1, options.year - start - 1);
|
||||
return {name: getAdjective(name) + " " + rw(wars), start, end};
|
||||
})
|
||||
.sort((a, b) => a.start - b.start);
|
||||
};
|
||||
|
||||
// generate historical conflicts of each state
|
||||
const generateCampaigns = () => {
|
||||
pack.states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
s.campaigns = generateCampaign(s);
|
||||
});
|
||||
};
|
||||
|
||||
// generate Diplomatic Relationships
|
||||
const generateDiplomacy = () => {
|
||||
TIME && console.time("generateDiplomacy");
|
||||
const {cells, states} = pack;
|
||||
const chronicle = (states[0].diplomacy = []);
|
||||
const valid = states.filter(s => s.i && !states.removed);
|
||||
|
||||
const neibs = {Ally: 1, Friendly: 2, Neutral: 1, Suspicion: 10, Rival: 9}; // relations to neighbors
|
||||
const neibsOfNeibs = {Ally: 10, Friendly: 8, Neutral: 5, Suspicion: 1}; // relations to neighbors of neighbors
|
||||
const far = {Friendly: 1, Neutral: 12, Suspicion: 2, Unknown: 6}; // relations to other
|
||||
const navals = {Neutral: 1, Suspicion: 2, Rival: 1, Unknown: 1}; // relations of naval powers
|
||||
|
||||
valid.forEach(s => (s.diplomacy = new Array(states.length).fill("x"))); // clear all relationships
|
||||
if (valid.length < 2) return; // no states to renerate relations with
|
||||
const areaMean = d3.mean(valid.map(s => s.area)); // average state area
|
||||
|
||||
// generic relations
|
||||
for (let f = 1; f < states.length; f++) {
|
||||
if (states[f].removed) continue;
|
||||
|
||||
if (states[f].diplomacy.includes("Vassal")) {
|
||||
// Vassals copy relations from their Suzerains
|
||||
const suzerain = states[f].diplomacy.indexOf("Vassal");
|
||||
|
||||
for (let i = 1; i < states.length; i++) {
|
||||
if (i === f || i === suzerain) continue;
|
||||
states[f].diplomacy[i] = states[suzerain].diplomacy[i];
|
||||
if (states[suzerain].diplomacy[i] === "Suzerain") states[f].diplomacy[i] = "Ally";
|
||||
for (let e = 1; e < states.length; e++) {
|
||||
if (e === f || e === suzerain) continue;
|
||||
if (states[e].diplomacy[suzerain] === "Suzerain" || states[e].diplomacy[suzerain] === "Vassal") continue;
|
||||
states[e].diplomacy[f] = states[e].diplomacy[suzerain];
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
for (let t = f + 1; t < states.length; t++) {
|
||||
if (states[t].removed) continue;
|
||||
|
||||
if (states[t].diplomacy.includes("Vassal")) {
|
||||
const suzerain = states[t].diplomacy.indexOf("Vassal");
|
||||
states[f].diplomacy[t] = states[f].diplomacy[suzerain];
|
||||
continue;
|
||||
}
|
||||
|
||||
const naval =
|
||||
states[f].type === "Naval" &&
|
||||
states[t].type === "Naval" &&
|
||||
cells.f[states[f].center] !== cells.f[states[t].center];
|
||||
const neib = naval ? false : states[f].neighbors.includes(t);
|
||||
const neibOfNeib =
|
||||
naval || neib
|
||||
? false
|
||||
: states[f].neighbors
|
||||
.map(n => states[n].neighbors)
|
||||
.join("")
|
||||
.includes(t);
|
||||
|
||||
let status = naval ? rw(navals) : neib ? rw(neibs) : neibOfNeib ? rw(neibsOfNeibs) : rw(far);
|
||||
|
||||
// add Vassal
|
||||
if (
|
||||
neib &&
|
||||
P(0.8) &&
|
||||
states[f].area > areaMean &&
|
||||
states[t].area < areaMean &&
|
||||
states[f].area / states[t].area > 2
|
||||
)
|
||||
status = "Vassal";
|
||||
states[f].diplomacy[t] = status === "Vassal" ? "Suzerain" : status;
|
||||
states[t].diplomacy[f] = status;
|
||||
}
|
||||
}
|
||||
|
||||
// declare wars
|
||||
for (let attacker = 1; attacker < states.length; attacker++) {
|
||||
const ad = states[attacker].diplomacy; // attacker relations;
|
||||
if (states[attacker].removed) continue;
|
||||
if (!ad.includes("Rival")) continue; // no rivals to attack
|
||||
if (ad.includes("Vassal")) continue; // not independent
|
||||
if (ad.includes("Enemy")) continue; // already at war
|
||||
|
||||
// random independent rival
|
||||
const defender = ra(
|
||||
ad.map((r, d) => (r === "Rival" && !states[d].diplomacy.includes("Vassal") ? d : 0)).filter(d => d)
|
||||
);
|
||||
let ap = states[attacker].area * states[attacker].expansionism;
|
||||
let dp = states[defender].area * states[defender].expansionism;
|
||||
if (ap < dp * gauss(1.6, 0.8, 0, 10, 2)) continue; // defender is too strong
|
||||
|
||||
const an = states[attacker].name;
|
||||
const dn = states[defender].name; // names
|
||||
const attackers = [attacker];
|
||||
const defenders = [defender]; // attackers and defenders array
|
||||
const dd = states[defender].diplomacy; // defender relations;
|
||||
|
||||
// start an ongoing war
|
||||
const name = `${an}-${trimVowels(dn)}ian War`;
|
||||
const start = options.year - gauss(2, 3, 0, 10);
|
||||
const war = [name, `${an} declared a war on its rival ${dn}`];
|
||||
const campaign = {name, start, attacker, defender};
|
||||
states[attacker].campaigns.push(campaign);
|
||||
states[defender].campaigns.push(campaign);
|
||||
|
||||
// attacker vassals join the war
|
||||
ad.forEach((r, d) => {
|
||||
if (r === "Suzerain") {
|
||||
attackers.push(d);
|
||||
war.push(`${an}'s vassal ${states[d].name} joined the war on attackers side`);
|
||||
}
|
||||
});
|
||||
|
||||
// defender vassals join the war
|
||||
dd.forEach((r, d) => {
|
||||
if (r === "Suzerain") {
|
||||
defenders.push(d);
|
||||
war.push(`${dn}'s vassal ${states[d].name} joined the war on defenders side`);
|
||||
}
|
||||
});
|
||||
|
||||
ap = d3.sum(attackers.map(a => states[a].area * states[a].expansionism)); // attackers joined power
|
||||
dp = d3.sum(defenders.map(d => states[d].area * states[d].expansionism)); // defender joined power
|
||||
|
||||
// defender allies join
|
||||
dd.forEach((r, d) => {
|
||||
if (r !== "Ally" || states[d].diplomacy.includes("Vassal")) return;
|
||||
if (states[d].diplomacy[attacker] !== "Rival" && ap / dp > 2 * gauss(1.6, 0.8, 0, 10, 2)) {
|
||||
const reason = states[d].diplomacy.includes("Enemy") ? "Being already at war," : `Frightened by ${an},`;
|
||||
war.push(`${reason} ${states[d].name} severed the defense pact with ${dn}`);
|
||||
dd[d] = states[d].diplomacy[defender] = "Suspicion";
|
||||
return;
|
||||
}
|
||||
defenders.push(d);
|
||||
dp += states[d].area * states[d].expansionism;
|
||||
war.push(`${dn}'s ally ${states[d].name} joined the war on defenders side`);
|
||||
|
||||
// ally vassals join
|
||||
states[d].diplomacy
|
||||
.map((r, d) => (r === "Suzerain" ? d : 0))
|
||||
.filter(d => d)
|
||||
.forEach(v => {
|
||||
defenders.push(v);
|
||||
dp += states[v].area * states[v].expansionism;
|
||||
war.push(`${states[d].name}'s vassal ${states[v].name} joined the war on defenders side`);
|
||||
});
|
||||
});
|
||||
|
||||
// attacker allies join if the defender is their rival or joined power > defenders power and defender is not an ally
|
||||
ad.forEach((r, d) => {
|
||||
if (r !== "Ally" || states[d].diplomacy.includes("Vassal") || defenders.includes(d)) return;
|
||||
const name = states[d].name;
|
||||
if (states[d].diplomacy[defender] !== "Rival" && (P(0.2) || ap <= dp * 1.2)) {
|
||||
war.push(`${an}'s ally ${name} avoided entering the war`);
|
||||
return;
|
||||
}
|
||||
const allies = states[d].diplomacy.map((r, d) => (r === "Ally" ? d : 0)).filter(d => d);
|
||||
if (allies.some(ally => defenders.includes(ally))) {
|
||||
war.push(`${an}'s ally ${name} did not join the war as its allies are in war on both sides`);
|
||||
return;
|
||||
}
|
||||
|
||||
attackers.push(d);
|
||||
ap += states[d].area * states[d].expansionism;
|
||||
war.push(`${an}'s ally ${name} joined the war on attackers side`);
|
||||
|
||||
// ally vassals join
|
||||
states[d].diplomacy
|
||||
.map((r, d) => (r === "Suzerain" ? d : 0))
|
||||
.filter(d => d)
|
||||
.forEach(v => {
|
||||
attackers.push(v);
|
||||
dp += states[v].area * states[v].expansionism;
|
||||
war.push(`${states[d].name}'s vassal ${states[v].name} joined the war on attackers side`);
|
||||
});
|
||||
});
|
||||
|
||||
// change relations to Enemy for all participants
|
||||
attackers.forEach(a => defenders.forEach(d => (states[a].diplomacy[d] = states[d].diplomacy[a] = "Enemy")));
|
||||
chronicle.push(war); // add a record to diplomatical history
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateDiplomacy");
|
||||
};
|
||||
|
||||
// select a forms for listed or all valid states
|
||||
const defineStateForms = list => {
|
||||
TIME && console.time("defineStateForms");
|
||||
const states = pack.states.filter(s => s.i && !s.removed && !s.lock);
|
||||
if (states.length < 1) return;
|
||||
|
||||
const generic = {Monarchy: 25, Republic: 2, Union: 1};
|
||||
const naval = {Monarchy: 25, Republic: 8, Union: 3};
|
||||
|
||||
const median = d3.median(pack.states.map(s => s.area));
|
||||
const empireMin = states.map(s => s.area).sort((a, b) => b - a)[Math.max(Math.ceil(states.length ** 0.4) - 2, 0)];
|
||||
const expTiers = pack.states.map(s => {
|
||||
let tier = Math.min(Math.floor((s.area / median) * 2.6), 4);
|
||||
if (tier === 4 && s.area < empireMin) tier = 3;
|
||||
return tier;
|
||||
});
|
||||
|
||||
const monarchy = ["Duchy", "Grand Duchy", "Principality", "Kingdom", "Empire"]; // per expansionism tier
|
||||
const republic = {
|
||||
Republic: 75,
|
||||
Federation: 4,
|
||||
"Trade Company": 4,
|
||||
"Most Serene Republic": 2,
|
||||
Oligarchy: 2,
|
||||
Tetrarchy: 1,
|
||||
Triumvirate: 1,
|
||||
Diarchy: 1,
|
||||
Junta: 1
|
||||
}; // weighted random
|
||||
const union = {
|
||||
Union: 3,
|
||||
League: 4,
|
||||
Confederation: 1,
|
||||
"United Kingdom": 1,
|
||||
"United Republic": 1,
|
||||
"United Provinces": 2,
|
||||
Commonwealth: 1,
|
||||
Heptarchy: 1
|
||||
}; // weighted random
|
||||
const theocracy = {Theocracy: 20, Brotherhood: 1, Thearchy: 2, See: 1, "Holy State": 1};
|
||||
const anarchy = {"Free Territory": 2, Council: 3, Commune: 1, Community: 1};
|
||||
|
||||
for (const s of states) {
|
||||
if (list && !list.includes(s.i)) continue;
|
||||
const tier = expTiers[s.i];
|
||||
|
||||
const religion = pack.cells.religion[s.center];
|
||||
const isTheocracy =
|
||||
(religion && pack.religions[religion].expansion === "state") ||
|
||||
(P(0.1) && ["Organized", "Cult"].includes(pack.religions[religion].type));
|
||||
const isAnarchy = P(0.01 - tier / 500);
|
||||
|
||||
if (isTheocracy) s.form = "Theocracy";
|
||||
else if (isAnarchy) s.form = "Anarchy";
|
||||
else s.form = s.type === "Naval" ? rw(naval) : rw(generic);
|
||||
s.formName = selectForm(s, tier);
|
||||
s.fullName = getFullName(s);
|
||||
}
|
||||
|
||||
function selectForm(s, tier) {
|
||||
const base = pack.cultures[s.culture].base;
|
||||
|
||||
if (s.form === "Monarchy") {
|
||||
const form = monarchy[tier];
|
||||
// Default name depends on exponent tier, some culture bases have special names for tiers
|
||||
if (s.diplomacy) {
|
||||
if (
|
||||
form === "Duchy" &&
|
||||
s.neighbors.length > 1 &&
|
||||
rand(6) < s.neighbors.length &&
|
||||
s.diplomacy.includes("Vassal")
|
||||
)
|
||||
return "Marches"; // some vassal duchies on borderland
|
||||
if (base === 1 && P(0.3) && s.diplomacy.includes("Vassal")) return "Dominion"; // English vassals
|
||||
if (P(0.3) && s.diplomacy.includes("Vassal")) return "Protectorate"; // some vassals
|
||||
}
|
||||
|
||||
if (base === 31 && (form === "Empire" || form === "Kingdom")) return "Khanate"; // Mongolian
|
||||
if (base === 16 && form === "Principality") return "Beylik"; // Turkic
|
||||
if (base === 5 && (form === "Empire" || form === "Kingdom")) return "Tsardom"; // Ruthenian
|
||||
if (base === 16 && (form === "Empire" || form === "Kingdom")) return "Khaganate"; // Turkic
|
||||
if (base === 12 && (form === "Kingdom" || form === "Grand Duchy")) return "Shogunate"; // Japanese
|
||||
if ([18, 17].includes(base) && form === "Empire") return "Caliphate"; // Arabic, Berber
|
||||
if (base === 18 && (form === "Grand Duchy" || form === "Duchy")) return "Emirate"; // Arabic
|
||||
if (base === 7 && (form === "Grand Duchy" || form === "Duchy")) return "Despotate"; // Greek
|
||||
if (base === 31 && (form === "Grand Duchy" || form === "Duchy")) return "Ulus"; // Mongolian
|
||||
if (base === 16 && (form === "Grand Duchy" || form === "Duchy")) return "Horde"; // Turkic
|
||||
if (base === 24 && (form === "Grand Duchy" || form === "Duchy")) return "Satrapy"; // Iranian
|
||||
return form;
|
||||
}
|
||||
|
||||
if (s.form === "Republic") {
|
||||
// Default name is from weighted array, special case for small states with only 1 burg
|
||||
if (tier < 2 && s.burgs === 1) {
|
||||
if (trimVowels(s.name) === trimVowels(pack.burgs[s.capital].name)) {
|
||||
s.name = pack.burgs[s.capital].name;
|
||||
return "Free City";
|
||||
}
|
||||
if (P(0.3)) return "City-state";
|
||||
}
|
||||
return rw(republic);
|
||||
}
|
||||
|
||||
if (s.form === "Union") return rw(union);
|
||||
if (s.form === "Anarchy") return rw(anarchy);
|
||||
|
||||
if (s.form === "Theocracy") {
|
||||
// European
|
||||
if ([0, 1, 2, 3, 4, 6, 8, 9, 13, 15, 20].includes(base)) {
|
||||
if (P(0.1)) return "Divine " + monarchy[tier];
|
||||
if (tier < 2 && P(0.5)) return "Diocese";
|
||||
if (tier < 2 && P(0.5)) return "Bishopric";
|
||||
}
|
||||
if (P(0.9) && [7, 5].includes(base)) {
|
||||
// Greek, Ruthenian
|
||||
if (tier < 2) return "Eparchy";
|
||||
if (tier === 2) return "Exarchate";
|
||||
if (tier > 2) return "Patriarchate";
|
||||
}
|
||||
if (P(0.9) && [21, 16].includes(base)) return "Imamah"; // Nigerian, Turkish
|
||||
if (tier > 2 && P(0.8) && [18, 17, 28].includes(base)) return "Caliphate"; // Arabic, Berber, Swahili
|
||||
return rw(theocracy);
|
||||
}
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("defineStateForms");
|
||||
};
|
||||
|
||||
// state forms requiring Adjective + Name, all other forms use scheme Form + Of + Name
|
||||
const adjForms = [
|
||||
"Empire",
|
||||
"Sultanate",
|
||||
"Khaganate",
|
||||
"Shogunate",
|
||||
"Caliphate",
|
||||
"Despotate",
|
||||
"Theocracy",
|
||||
"Oligarchy",
|
||||
"Union",
|
||||
"Confederation",
|
||||
"Trade Company",
|
||||
"League",
|
||||
"Tetrarchy",
|
||||
"Triumvirate",
|
||||
"Diarchy",
|
||||
"Horde",
|
||||
"Marches"
|
||||
];
|
||||
|
||||
const getFullName = state => {
|
||||
if (!state.formName) return state.name;
|
||||
if (!state.name && state.formName) return "The " + state.formName;
|
||||
const adjName = adjForms.includes(state.formName) && !/-| /.test(state.name);
|
||||
return adjName ? `${getAdjective(state.name)} ${state.formName}` : `${state.formName} of ${state.name}`;
|
||||
};
|
||||
|
||||
return {
|
||||
generate,
|
||||
expandStates,
|
||||
normalizeStates,
|
||||
getPoles,
|
||||
assignColors,
|
||||
specifyBurgs,
|
||||
defineBurgFeatures,
|
||||
getType,
|
||||
collectStatistics,
|
||||
generateCampaign,
|
||||
generateCampaigns,
|
||||
generateDiplomacy,
|
||||
defineStateForms,
|
||||
getFullName,
|
||||
updateCultures,
|
||||
getCloseToEdgePoint
|
||||
};
|
||||
})();
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./burgs-and-states.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./burgs-and-states_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in burgs-and-states_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into burgs-and-states_render.md
|
||||
35
procedural/src/engine/support/burgs-and-states_render.md
Normal file
35
procedural/src/engine/support/burgs-and-states_render.md
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
# Burgs and States Module - Removed Rendering/UI Logic
|
||||
|
||||
After analyzing the original `burgs-and-states.js` code, **no rendering or UI logic was found to remove**.
|
||||
|
||||
## Analysis Results
|
||||
|
||||
The module contains only:
|
||||
|
||||
- **Data structure generation** (burgs, states arrays)
|
||||
- **Pure computational logic** for placement algorithms
|
||||
- **Mathematical calculations** for state expansion and diplomacy
|
||||
- **Statistical calculations** for population and area
|
||||
- **Algorithmic processing** for territorial assignment
|
||||
|
||||
## No Rendering Logic Found
|
||||
|
||||
The original module was already focused purely on data generation without any:
|
||||
|
||||
- ❌ DOM manipulation (no `d3.select`, `document.getElementById`, etc.)
|
||||
- ❌ SVG rendering (no path creation, element styling, etc.)
|
||||
- ❌ Canvas drawing operations
|
||||
- ❌ HTML element creation or modification
|
||||
- ❌ CSS style manipulation
|
||||
- ❌ UI event handling
|
||||
|
||||
## Module Characteristics
|
||||
|
||||
This module represents a **pure computational engine** that:
|
||||
|
||||
1. **Receives data** (`pack`, `grid`) as input
|
||||
2. **Applies algorithms** for territorial and settlement generation
|
||||
3. **Returns structured data** for use by rendering systems
|
||||
4. **Contains no visual output** or DOM dependencies
|
||||
|
||||
The separation of concerns was already well-maintained in the original codebase for this particular module, requiring only the removal of global state dependencies and DOM-based configuration reading.
|
||||
40
procedural/src/engine/support/coa-generator_config.md
Normal file
40
procedural/src/engine/support/coa-generator_config.md
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
# Configuration Properties for coa-generator.js
|
||||
|
||||
The refactored `coa-generator.js` module requires a `config` object with the following properties:
|
||||
|
||||
## Required Config Properties
|
||||
|
||||
### emblemShape
|
||||
- **Type**: String
|
||||
- **Description**: The selected emblem shape value from the UI dropdown
|
||||
- **Original DOM Call**: `document.getElementById("emblemShape").value`
|
||||
- **Usage**: Used in `getShield()` function to determine shield type
|
||||
|
||||
### emblemShapeGroup
|
||||
- **Type**: String
|
||||
- **Description**: The parent group label of the selected emblem shape option
|
||||
- **Original DOM Call**: `emblemShape.selectedOptions[0]?.parentNode.label`
|
||||
- **Default**: "Diversiform" when no parent group exists
|
||||
- **Usage**: Used in `getShield()` function to determine if custom shield logic should be applied
|
||||
|
||||
## Config Object Structure
|
||||
|
||||
The config object should be structured as follows:
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
emblemShape: "heater", // Value from emblem shape selector
|
||||
emblemShapeGroup: "Basic" // Parent group of the selected option
|
||||
};
|
||||
```
|
||||
|
||||
## Function Signatures
|
||||
|
||||
### getShield(pack, culture, state, config)
|
||||
The `getShield` function now accepts the config object as the fourth parameter instead of reading from the DOM directly.
|
||||
|
||||
## Migration Notes
|
||||
|
||||
- The original code read these values directly from the DOM using `byId("emblemShape")`
|
||||
- The refactored version receives these values through the config parameter
|
||||
- The calling code (Viewer/Client) is responsible for reading from the DOM and passing these values to the engine
|
||||
32
procedural/src/engine/support/coa-generator_external.md
Normal file
32
procedural/src/engine/support/coa-generator_external.md
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
# External Dependencies for coa-generator.js
|
||||
|
||||
The refactored `coa-generator.js` module requires the following external dependencies to be imported:
|
||||
|
||||
## Required Utility Functions
|
||||
|
||||
The module expects a `utils` object containing:
|
||||
|
||||
- **`P(probability)`** - Probability function that returns true/false based on given probability (0-1)
|
||||
- **`rw(weightedObject)`** - Random weighted selection function that picks a key from an object based on weighted values
|
||||
|
||||
These utilities should be imported from a shared utilities module in the engine.
|
||||
|
||||
## Required Data Objects
|
||||
|
||||
The following data objects must be passed as parameters:
|
||||
|
||||
- **`pack`** - The main game data object containing:
|
||||
- `pack.states` - Array of state objects with COA data
|
||||
- `pack.cultures` - Array of culture objects with shield preferences
|
||||
|
||||
## External Error Handling
|
||||
|
||||
The original code referenced a global `ERROR` variable for error logging. The refactored version removes this dependency. Error handling should now be implemented by the calling code or through a logging utility passed in the utils object if needed.
|
||||
|
||||
## Removed Global Dependencies
|
||||
|
||||
The following global dependencies have been removed:
|
||||
- `window` object attachment
|
||||
- `document` object access
|
||||
- `byId()` DOM utility function
|
||||
- Global `ERROR` variable
|
||||
2295
procedural/src/engine/support/coa-generator_prompt.md
Normal file
2295
procedural/src/engine/support/coa-generator_prompt.md
Normal file
File diff suppressed because it is too large
Load diff
48
procedural/src/engine/support/coa-generator_render.md
Normal file
48
procedural/src/engine/support/coa-generator_render.md
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
# Removed Rendering/UI Logic from coa-generator.js
|
||||
|
||||
The following DOM manipulation and UI-related code blocks have been **removed** from the core engine module and should be moved to the Viewer application:
|
||||
|
||||
## DOM Element Access - Lines 2269-2271
|
||||
|
||||
**Removed Code:**
|
||||
```javascript
|
||||
const emblemShape = document.getElementById("emblemShape");
|
||||
const shapeGroup = emblemShape.selectedOptions[0]?.parentNode.label || "Diversiform";
|
||||
if (shapeGroup !== "Diversiform") return emblemShape.value;
|
||||
```
|
||||
|
||||
**Location**: Originally in `getShield()` function (lines 2269-2271)
|
||||
**Reason**: Direct DOM access via `document.getElementById()` and manipulation of select element options
|
||||
**Replacement**: These values should be read by the Viewer and passed via the `config` parameter
|
||||
|
||||
## DOM Value Reading - Line 2273
|
||||
|
||||
**Removed Code:**
|
||||
```javascript
|
||||
if (emblemShape.value === "state" && state && pack.states[state].coa) return pack.states[state].coa.shield;
|
||||
```
|
||||
|
||||
**Location**: Originally in `getShield()` function (line 2273)
|
||||
**Reason**: Direct access to DOM element `.value` property
|
||||
**Replacement**: The `emblemShape` value should be passed via `config.emblemShape`
|
||||
|
||||
## Error Console Logging - Line 2275
|
||||
|
||||
**Removed Code:**
|
||||
```javascript
|
||||
ERROR && console.error("Shield shape is not defined on culture level", pack.cultures[culture]);
|
||||
```
|
||||
|
||||
**Location**: Originally in `getShield()` function (line 2275)
|
||||
**Reason**: Global `ERROR` variable dependency and console error logging
|
||||
**Replacement**: Error handling should be implemented by the calling Viewer code
|
||||
|
||||
## Summary
|
||||
|
||||
All removed code was related to:
|
||||
1. **DOM Element Selection**: `document.getElementById("emblemShape")`
|
||||
2. **DOM Property Access**: `.selectedOptions[0]?.parentNode.label`, `.value`
|
||||
3. **Global Variable Dependencies**: `ERROR` variable
|
||||
4. **Direct Console Logging**: `console.error()` calls
|
||||
|
||||
These UI concerns should now be handled by the Viewer application, which will read the DOM values and pass them to the core engine via the config parameter.
|
||||
6
procedural/src/engine/support/coa-renderer_config.md
Normal file
6
procedural/src/engine/support/coa-renderer_config.md
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
# Config Properties for coa-renderer.js
|
||||
|
||||
The refactored coa-renderer.js module is self-contained in terms of configuration and does not require any properties to be passed in a config object.
|
||||
|
||||
Notes
|
||||
All necessary parameters and definitions are derived directly from the coa (Coat of Arms) object that is passed as a primary argument to the render function. This module has no dependency on UI settings or external configuration values.
|
||||
39
procedural/src/engine/support/coa-renderer_external.md
Normal file
39
procedural/src/engine/support/coa-renderer_external.md
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
# coa-renderer_external.md
|
||||
|
||||
External Dependencies for coa-renderer.js
|
||||
The refactored coa-renderer.js module has one critical external data dependency that must be provided by the calling environment.
|
||||
|
||||
- Required Data Dependencies
|
||||
- chargesData
|
||||
- Type: Object
|
||||
- Description: An object that serves as a map between a charge's name and its raw SVG content. The engine no longer fetches these files itself; the Viewer/Client is responsible for loading them and passing them into the render function.
|
||||
Structure:
|
||||
|
||||
```javascript
|
||||
{
|
||||
"chargeName1": "<g>...</g>", // The raw <g> tag content of the charge's SVG
|
||||
"chargeName2": "<g>...</g>",
|
||||
// etc.
|
||||
}
|
||||
```
|
||||
|
||||
Example:
|
||||
|
||||
```javascript
|
||||
const chargesData = {
|
||||
"lion": '<g><path d="..."/></g>',
|
||||
"eagle": '<g><path d="..."/></g>'
|
||||
};
|
||||
```
|
||||
|
||||
## Notes on Viewer Implementation
|
||||
|
||||
The Viewer application is now responsible for the I/O operations previously handled by the engine. It must:
|
||||
|
||||
- Identify all unique charges required for a set of Coats of Arms.
|
||||
- Fetch the corresponding SVG files (e.g., from a /charges/ directory).
|
||||
- Read the content of each file into a string.
|
||||
- Assemble the chargesData object.
|
||||
- Pass this object to the coa-renderer.render() function.
|
||||
|
||||
This change ensures the core engine remains free of environment-specific APIs like fetch and is fully portable.
|
||||
2128
procedural/src/engine/support/coa-renderer_prompt.md
Normal file
2128
procedural/src/engine/support/coa-renderer_prompt.md
Normal file
File diff suppressed because it is too large
Load diff
74
procedural/src/engine/support/coa-renderer_render.md
Normal file
74
procedural/src/engine/support/coa-renderer_render.md
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
# coa-renderer_render.md
|
||||
|
||||
Removed Rendering/UI Logic from coa-renderer.js
|
||||
|
||||
The following code blocks, responsible for direct DOM manipulation, I/O, and UI-layer logic, were removed from coa-renderer.js. This logic must now be handled by the Viewer application.
|
||||
|
||||
1. Direct SVG Injection into the DOM
|
||||
Original Code (in draw function):
|
||||
|
||||
```javascript
|
||||
// insert coa svg to defs
|
||||
document.getElementById("coas").insertAdjacentHTML("beforeend", svg);
|
||||
return true;
|
||||
```
|
||||
Reason for Removal: Direct DOM manipulation. The engine must not know about or interact with the DOM. The refactored render function now returns the complete SVG string.
|
||||
|
||||
2. File Fetching and Parsing (I/O)
|
||||
Original Code:
|
||||
|
||||
```javascript
|
||||
async function fetchCharge(charge, id) {
|
||||
const fetched = fetch(PATH + charge + ".svg")
|
||||
.then(res => {
|
||||
if (res.ok) return res.text();
|
||||
else throw new Error("Cannot fetch charge");
|
||||
})
|
||||
.then(text => {
|
||||
const html = document.createElement("html");
|
||||
html.innerHTML = text;
|
||||
const g = html.querySelector("g");
|
||||
g.setAttribute("id", charge + "_" + id);
|
||||
return g.outerHTML;
|
||||
})
|
||||
.catch(err => {
|
||||
ERROR && console.error(err);
|
||||
});
|
||||
return fetched;
|
||||
}
|
||||
```
|
||||
|
||||
Reason for Removal: Contains environment-specific I/O (fetch) and DOM parsing (document.createElement, innerHTML, querySelector). This entire responsibility is now shifted to the Viewer, which must provide the charge data to the engine.
|
||||
|
||||
3. UI Triggering Logic
|
||||
Original Code:
|
||||
|
||||
```javascript
|
||||
const trigger = async function (id, coa) {
|
||||
if (!coa) return console.warn(`Emblem ${id} is undefined`);
|
||||
if (coa.custom) return console.warn("Cannot render custom emblem", coa);
|
||||
if (!document.getElementById(id)) return draw(id, coa);
|
||||
};
|
||||
```
|
||||
|
||||
Reason for Removal: Checks for the existence of an element in the DOM (document.getElementById) to decide whether to render. This is UI-level conditional logic.
|
||||
|
||||
4. Emblem Placement on Map
|
||||
Original Code:
|
||||
|
||||
```javascript
|
||||
const add = function (type, i, coa, x, y) {
|
||||
const id = type + "COA" + i;
|
||||
const g = document.getElementById(type + "Emblems");
|
||||
|
||||
if (emblems.selectAll("use").size()) {
|
||||
const size = +g.getAttribute("font-size") || 50;
|
||||
const use = `<use data-i="${i}" x="${x - size / 2}" y="${y - size / 2}" width="1em" height="1em" href="#${id}"/>`;
|
||||
g.insertAdjacentHTML("beforeend", use);
|
||||
}
|
||||
if (layerIsOn("toggleEmblems")) trigger(id, coa);
|
||||
};
|
||||
```
|
||||
|
||||
Reason for Removal: This function is entirely for rendering/UI. It finds a specific SVG group on the map (#burgEmblems, #stateEmblems), reads its attributes, creates a <use> element referencing the generated CoA, and inserts it. It also depends on another UI function (layerIsOn). This is quintessential Viewer logic.
|
||||
|
||||
618
procedural/src/engine/support/cultures-generator-original.txt
Normal file
618
procedural/src/engine/support/cultures-generator-original.txt
Normal file
|
|
@ -0,0 +1,618 @@
|
|||
"use strict";
|
||||
|
||||
window.Cultures = (function () {
|
||||
let cells;
|
||||
|
||||
const generate = function () {
|
||||
TIME && console.time("generateCultures");
|
||||
cells = pack.cells;
|
||||
|
||||
const cultureIds = new Uint16Array(cells.i.length); // cell cultures
|
||||
|
||||
const culturesInputNumber = +byId("culturesInput").value;
|
||||
const culturesInSetNumber = +byId("culturesSet").selectedOptions[0].dataset.max;
|
||||
let count = Math.min(culturesInputNumber, culturesInSetNumber);
|
||||
|
||||
const populated = cells.i.filter(i => cells.s[i]); // populated cells
|
||||
if (populated.length < count * 25) {
|
||||
count = Math.floor(populated.length / 50);
|
||||
if (!count) {
|
||||
WARN && console.warn(`There are no populated cells. Cannot generate cultures`);
|
||||
pack.cultures = [{name: "Wildlands", i: 0, base: 1, shield: "round"}];
|
||||
cells.culture = cultureIds;
|
||||
|
||||
alertMessage.innerHTML = /* html */ `The climate is harsh and people cannot live in this world.<br />
|
||||
No cultures, states and burgs will be created.<br />
|
||||
Please consider changing climate settings in the World Configurator`;
|
||||
|
||||
$("#alert").dialog({
|
||||
resizable: false,
|
||||
title: "Extreme climate warning",
|
||||
buttons: {
|
||||
Ok: function () {
|
||||
$(this).dialog("close");
|
||||
}
|
||||
}
|
||||
});
|
||||
return;
|
||||
} else {
|
||||
WARN && console.warn(`Not enough populated cells (${populated.length}). Will generate only ${count} cultures`);
|
||||
alertMessage.innerHTML = /* html */ ` There are only ${populated.length} populated cells and it's insufficient livable area.<br />
|
||||
Only ${count} out of ${culturesInput.value} requested cultures will be generated.<br />
|
||||
Please consider changing climate settings in the World Configurator`;
|
||||
$("#alert").dialog({
|
||||
resizable: false,
|
||||
title: "Extreme climate warning",
|
||||
buttons: {
|
||||
Ok: function () {
|
||||
$(this).dialog("close");
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const cultures = (pack.cultures = selectCultures(count));
|
||||
const centers = d3.quadtree();
|
||||
const colors = getColors(count);
|
||||
const emblemShape = document.getElementById("emblemShape").value;
|
||||
|
||||
const codes = [];
|
||||
|
||||
cultures.forEach(function (c, i) {
|
||||
const newId = i + 1;
|
||||
|
||||
if (c.lock) {
|
||||
codes.push(c.code);
|
||||
centers.add(c.center);
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.culture[i] === c.i) cultureIds[i] = newId;
|
||||
}
|
||||
|
||||
c.i = newId;
|
||||
return;
|
||||
}
|
||||
|
||||
const sortingFn = c.sort ? c.sort : i => cells.s[i];
|
||||
const center = placeCenter(sortingFn);
|
||||
|
||||
centers.add(cells.p[center]);
|
||||
c.center = center;
|
||||
c.i = newId;
|
||||
delete c.odd;
|
||||
delete c.sort;
|
||||
c.color = colors[i];
|
||||
c.type = defineCultureType(center);
|
||||
c.expansionism = defineCultureExpansionism(c.type);
|
||||
c.origins = [0];
|
||||
c.code = abbreviate(c.name, codes);
|
||||
codes.push(c.code);
|
||||
cultureIds[center] = newId;
|
||||
if (emblemShape === "random") c.shield = getRandomShield();
|
||||
});
|
||||
|
||||
cells.culture = cultureIds;
|
||||
|
||||
function placeCenter(sortingFn) {
|
||||
let spacing = (graphWidth + graphHeight) / 2 / count;
|
||||
const MAX_ATTEMPTS = 100;
|
||||
|
||||
const sorted = [...populated].sort((a, b) => sortingFn(b) - sortingFn(a));
|
||||
const max = Math.floor(sorted.length / 2);
|
||||
|
||||
let cellId = 0;
|
||||
for (let i = 0; i < MAX_ATTEMPTS; i++) {
|
||||
cellId = sorted[biased(0, max, 5)];
|
||||
spacing *= 0.9;
|
||||
if (!cultureIds[cellId] && !centers.find(cells.p[cellId][0], cells.p[cellId][1], spacing)) break;
|
||||
}
|
||||
|
||||
return cellId;
|
||||
}
|
||||
|
||||
// the first culture with id 0 is for wildlands
|
||||
cultures.unshift({name: "Wildlands", i: 0, base: 1, origins: [null], shield: "round"});
|
||||
|
||||
// make sure all bases exist in nameBases
|
||||
if (!nameBases.length) {
|
||||
ERROR && console.error("Name base is empty, default nameBases will be applied");
|
||||
nameBases = Names.getNameBases();
|
||||
}
|
||||
|
||||
cultures.forEach(c => (c.base = c.base % nameBases.length));
|
||||
|
||||
function selectCultures(culturesNumber) {
|
||||
let defaultCultures = getDefault(culturesNumber);
|
||||
const cultures = [];
|
||||
|
||||
pack.cultures?.forEach(function (culture) {
|
||||
if (culture.lock && !culture.removed) cultures.push(culture);
|
||||
});
|
||||
|
||||
if (!cultures.length) {
|
||||
if (culturesNumber === defaultCultures.length) return defaultCultures;
|
||||
if (defaultCultures.every(d => d.odd === 1)) return defaultCultures.splice(0, culturesNumber);
|
||||
}
|
||||
|
||||
for (let culture, rnd, i = 0; cultures.length < culturesNumber && defaultCultures.length > 0; ) {
|
||||
do {
|
||||
rnd = rand(defaultCultures.length - 1);
|
||||
culture = defaultCultures[rnd];
|
||||
i++;
|
||||
} while (i < 200 && !P(culture.odd));
|
||||
cultures.push(culture);
|
||||
defaultCultures.splice(rnd, 1);
|
||||
}
|
||||
return cultures;
|
||||
}
|
||||
|
||||
// set culture type based on culture center position
|
||||
function defineCultureType(i) {
|
||||
if (cells.h[i] < 70 && [1, 2, 4].includes(cells.biome[i])) return "Nomadic"; // high penalty in forest biomes and near coastline
|
||||
if (cells.h[i] > 50) return "Highland"; // no penalty for hills and moutains, high for other elevations
|
||||
const f = pack.features[cells.f[cells.haven[i]]]; // opposite feature
|
||||
if (f.type === "lake" && f.cells > 5) return "Lake"; // low water cross penalty and high for growth not along coastline
|
||||
if (
|
||||
(cells.harbor[i] && f.type !== "lake" && P(0.1)) ||
|
||||
(cells.harbor[i] === 1 && P(0.6)) ||
|
||||
(pack.features[cells.f[i]].group === "isle" && P(0.4))
|
||||
)
|
||||
return "Naval"; // low water cross penalty and high for non-along-coastline growth
|
||||
if (cells.r[i] && cells.fl[i] > 100) return "River"; // no River cross penalty, penalty for non-River growth
|
||||
if (cells.t[i] > 2 && [3, 7, 8, 9, 10, 12].includes(cells.biome[i])) return "Hunting"; // high penalty in non-native biomes
|
||||
return "Generic";
|
||||
}
|
||||
|
||||
function defineCultureExpansionism(type) {
|
||||
let base = 1; // Generic
|
||||
if (type === "Lake") base = 0.8;
|
||||
else if (type === "Naval") base = 1.5;
|
||||
else if (type === "River") base = 0.9;
|
||||
else if (type === "Nomadic") base = 1.5;
|
||||
else if (type === "Hunting") base = 0.7;
|
||||
else if (type === "Highland") base = 1.2;
|
||||
return rn(((Math.random() * byId("sizeVariety").value) / 2 + 1) * base, 1);
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateCultures");
|
||||
};
|
||||
|
||||
const add = function (center) {
|
||||
const defaultCultures = getDefault();
|
||||
let culture, base, name;
|
||||
|
||||
if (pack.cultures.length < defaultCultures.length) {
|
||||
// add one of the default cultures
|
||||
culture = pack.cultures.length;
|
||||
base = defaultCultures[culture].base;
|
||||
name = defaultCultures[culture].name;
|
||||
} else {
|
||||
// add random culture besed on one of the current ones
|
||||
culture = rand(pack.cultures.length - 1);
|
||||
name = Names.getCulture(culture, 5, 8, "");
|
||||
base = pack.cultures[culture].base;
|
||||
}
|
||||
|
||||
const code = abbreviate(
|
||||
name,
|
||||
pack.cultures.map(c => c.code)
|
||||
);
|
||||
const i = pack.cultures.length;
|
||||
const color = getRandomColor();
|
||||
|
||||
// define emblem shape
|
||||
let shield = culture.shield;
|
||||
const emblemShape = document.getElementById("emblemShape").value;
|
||||
if (emblemShape === "random") shield = getRandomShield();
|
||||
|
||||
pack.cultures.push({
|
||||
name,
|
||||
color,
|
||||
base,
|
||||
center,
|
||||
i,
|
||||
expansionism: 1,
|
||||
type: "Generic",
|
||||
cells: 0,
|
||||
area: 0,
|
||||
rural: 0,
|
||||
urban: 0,
|
||||
origins: [pack.cells.culture[center]],
|
||||
code,
|
||||
shield
|
||||
});
|
||||
};
|
||||
|
||||
const getDefault = function (count) {
|
||||
// generic sorting functions
|
||||
const cells = pack.cells,
|
||||
s = cells.s,
|
||||
sMax = d3.max(s),
|
||||
t = cells.t,
|
||||
h = cells.h,
|
||||
temp = grid.cells.temp;
|
||||
const n = cell => Math.ceil((s[cell] / sMax) * 3); // normalized cell score
|
||||
const td = (cell, goal) => {
|
||||
const d = Math.abs(temp[cells.g[cell]] - goal);
|
||||
return d ? d + 1 : 1;
|
||||
}; // temperature difference fee
|
||||
const bd = (cell, biomes, fee = 4) => (biomes.includes(cells.biome[cell]) ? 1 : fee); // biome difference fee
|
||||
const sf = (cell, fee = 4) =>
|
||||
cells.haven[cell] && pack.features[cells.f[cells.haven[cell]]].type !== "lake" ? 1 : fee; // not on sea coast fee
|
||||
|
||||
if (culturesSet.value === "european") {
|
||||
return [
|
||||
{name: "Shwazen", base: 0, odd: 1, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "swiss"},
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "wedged"},
|
||||
{name: "Luari", base: 2, odd: 1, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "french"},
|
||||
{name: "Tallian", base: 3, odd: 1, sort: i => n(i) / td(i, 15), shield: "horsehead"},
|
||||
{name: "Astellian", base: 4, odd: 1, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
{name: "Slovan", base: 5, odd: 1, sort: i => (n(i) / td(i, 6)) * t[i], shield: "polish"},
|
||||
{name: "Norse", base: 6, odd: 1, sort: i => n(i) / td(i, 5), shield: "heater"},
|
||||
{name: "Elladan", base: 7, odd: 1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.2, sort: i => n(i) / td(i, 15) / t[i], shield: "roman"},
|
||||
{name: "Soumi", base: 9, odd: 1, sort: i => (n(i) / td(i, 5) / bd(i, [9])) * t[i], shield: "pavise"},
|
||||
{name: "Portuzian", base: 13, odd: 1, sort: i => n(i) / td(i, 17) / sf(i), shield: "renaissance"},
|
||||
{name: "Vengrian", base: 15, odd: 1, sort: i => (n(i) / td(i, 11) / bd(i, [4])) * t[i], shield: "horsehead2"},
|
||||
{name: "Turchian", base: 16, odd: 0.05, sort: i => n(i) / td(i, 14), shield: "round"},
|
||||
{name: "Euskati", base: 20, odd: 0.05, sort: i => (n(i) / td(i, 15)) * h[i], shield: "oldFrench"},
|
||||
{name: "Keltan", base: 22, odd: 0.05, sort: i => (n(i) / td(i, 11) / bd(i, [6, 8])) * t[i], shield: "oval"}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "oriental") {
|
||||
return [
|
||||
{name: "Koryo", base: 10, odd: 1, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 1, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 1, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Turchian", base: 16, odd: 1, sort: i => n(i) / td(i, 12), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.2,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "oval"
|
||||
},
|
||||
{name: "Eurabic", base: 18, odd: 1, sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i], shield: "oval"},
|
||||
{name: "Efratic", base: 23, odd: 0.1, sort: i => (n(i) / td(i, 22)) * t[i], shield: "round"},
|
||||
{name: "Tehrani", base: 24, odd: 1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "round"},
|
||||
{name: "Maui", base: 25, odd: 0.2, sort: i => n(i) / td(i, 24) / sf(i) / t[i], shield: "vesicaPiscis"},
|
||||
{name: "Carnatic", base: 26, odd: 0.5, sort: i => n(i) / td(i, 26), shield: "round"},
|
||||
{name: "Vietic", base: 29, odd: 0.8, sort: i => n(i) / td(i, 25) / bd(i, [7], 7) / t[i], shield: "banner"},
|
||||
{name: "Guantzu", base: 30, odd: 0.5, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{name: "Ulus", base: 31, odd: 1, sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i], shield: "banner"}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "english") {
|
||||
const getName = () => Names.getBase(1, 5, 9, "", 0);
|
||||
return [
|
||||
{name: getName(), base: 1, odd: 1, shield: "heater"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "wedged"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "swiss"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "oldFrench"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "swiss"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "spanish"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "hessen"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy5"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy4"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy1"}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "antique") {
|
||||
return [
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 14) / t[i], shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 15) / sf(i), shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 16) / sf(i), shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 17) / t[i], shield: "roman"}, // Roman
|
||||
{name: "Hellenic", base: 7, odd: 1, sort: i => (n(i) / td(i, 18) / sf(i)) * h[i], shield: "boeotian"}, // Greek
|
||||
{name: "Hellenic", base: 7, odd: 1, sort: i => (n(i) / td(i, 19) / sf(i)) * h[i], shield: "boeotian"}, // Greek
|
||||
{name: "Macedonian", base: 7, odd: 0.5, sort: i => (n(i) / td(i, 12)) * h[i], shield: "round"}, // Greek
|
||||
{name: "Celtic", base: 22, odd: 1, sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [6, 8]), shield: "round"},
|
||||
{name: "Germanic", base: 0, odd: 1, sort: i => n(i) / td(i, 10) ** 0.5 / bd(i, [6, 8]), shield: "round"},
|
||||
{name: "Persian", base: 24, odd: 0.8, sort: i => (n(i) / td(i, 18)) * h[i], shield: "oval"}, // Iranian
|
||||
{name: "Scythian", base: 24, odd: 0.5, sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [4]), shield: "round"}, // Iranian
|
||||
{name: "Cantabrian", base: 20, odd: 0.5, sort: i => (n(i) / td(i, 16)) * h[i], shield: "oval"}, // Basque
|
||||
{name: "Estian", base: 9, odd: 0.2, sort: i => (n(i) / td(i, 5)) * t[i], shield: "pavise"}, // Finnic
|
||||
{name: "Carthaginian", base: 42, odd: 0.3, sort: i => n(i) / td(i, 20) / sf(i), shield: "oval"}, // Levantine
|
||||
{name: "Hebrew", base: 42, odd: 0.2, sort: i => (n(i) / td(i, 19)) * sf(i), shield: "oval"}, // Levantine
|
||||
{name: "Mesopotamian", base: 23, odd: 0.2, sort: i => n(i) / td(i, 22) / bd(i, [1, 2, 3]), shield: "oval"} // Mesopotamian
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "highFantasy") {
|
||||
return [
|
||||
// fantasy races
|
||||
{
|
||||
name: "Quenian (Elfish)",
|
||||
base: 33,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i],
|
||||
shield: "gondor"
|
||||
}, // Elves
|
||||
{
|
||||
name: "Eldar (Elfish)",
|
||||
base: 33,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i],
|
||||
shield: "noldor"
|
||||
}, // Elves
|
||||
{
|
||||
name: "Trow (Dark Elfish)",
|
||||
base: 34,
|
||||
odd: 0.9,
|
||||
sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i],
|
||||
shield: "hessen"
|
||||
}, // Dark Elves
|
||||
{
|
||||
name: "Lothian (Dark Elfish)",
|
||||
base: 34,
|
||||
odd: 0.3,
|
||||
sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i],
|
||||
shield: "wedged"
|
||||
}, // Dark Elves
|
||||
{name: "Dunirr (Dwarven)", base: 35, odd: 1, sort: i => n(i) + h[i], shield: "ironHills"}, // Dwarfs
|
||||
{name: "Khazadur (Dwarven)", base: 35, odd: 1, sort: i => n(i) + h[i], shield: "erebor"}, // Dwarfs
|
||||
{name: "Kobold (Goblin)", base: 36, odd: 1, sort: i => t[i] - s[i], shield: "moriaOrc"}, // Goblin
|
||||
{name: "Uruk (Orkish)", base: 37, odd: 1, sort: i => h[i] * t[i], shield: "urukHai"}, // Orc
|
||||
{
|
||||
name: "Ugluk (Orkish)",
|
||||
base: 37,
|
||||
odd: 0.5,
|
||||
sort: i => (h[i] * t[i]) / bd(i, [1, 2, 10, 11]),
|
||||
shield: "moriaOrc"
|
||||
}, // Orc
|
||||
{name: "Yotunn (Giants)", base: 38, odd: 0.7, sort: i => td(i, -10), shield: "pavise"}, // Giant
|
||||
{name: "Rake (Drakonic)", base: 39, odd: 0.7, sort: i => -s[i], shield: "fantasy2"}, // Draconic
|
||||
{name: "Arago (Arachnid)", base: 40, odd: 0.7, sort: i => t[i] - s[i], shield: "horsehead2"}, // Arachnid
|
||||
{name: "Aj'Snaga (Serpents)", base: 41, odd: 0.7, sort: i => n(i) / bd(i, [12], 10), shield: "fantasy1"}, // Serpents
|
||||
// fantasy human
|
||||
{name: "Anor (Human)", base: 32, odd: 1, sort: i => n(i) / td(i, 10), shield: "fantasy5"},
|
||||
{name: "Dail (Human)", base: 32, odd: 1, sort: i => n(i) / td(i, 13), shield: "roman"},
|
||||
{name: "Rohand (Human)", base: 16, odd: 1, sort: i => n(i) / td(i, 16), shield: "round"},
|
||||
{
|
||||
name: "Dulandir (Human)",
|
||||
base: 31,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i],
|
||||
shield: "easterling"
|
||||
}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "darkFantasy") {
|
||||
return [
|
||||
// common real-world English
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "heater"},
|
||||
{name: "Enlandic", base: 1, odd: 1, sort: i => n(i) / td(i, 12), shield: "heater"},
|
||||
{name: "Westen", base: 1, odd: 1, sort: i => n(i) / td(i, 10), shield: "heater"},
|
||||
{name: "Nortumbic", base: 1, odd: 1, sort: i => n(i) / td(i, 7), shield: "heater"},
|
||||
{name: "Mercian", base: 1, odd: 1, sort: i => n(i) / td(i, 9), shield: "heater"},
|
||||
{name: "Kentian", base: 1, odd: 1, sort: i => n(i) / td(i, 12), shield: "heater"},
|
||||
// rare real-world western
|
||||
{name: "Norse", base: 6, odd: 0.7, sort: i => n(i) / td(i, 5) / sf(i), shield: "oldFrench"},
|
||||
{name: "Schwarzen", base: 0, odd: 0.3, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "gonfalon"},
|
||||
{name: "Luarian", base: 2, odd: 0.3, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "oldFrench"},
|
||||
{name: "Hetallian", base: 3, odd: 0.3, sort: i => n(i) / td(i, 15), shield: "oval"},
|
||||
{name: "Astellian", base: 4, odd: 0.3, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
// rare real-world exotic
|
||||
{
|
||||
name: "Kiswaili",
|
||||
base: 28,
|
||||
odd: 0.05,
|
||||
sort: i => n(i) / td(i, 29) / bd(i, [1, 3, 5, 7]),
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Yoruba", base: 21, odd: 0.05, sort: i => n(i) / td(i, 15) / bd(i, [5, 7]), shield: "vesicaPiscis"},
|
||||
{name: "Koryo", base: 10, odd: 0.05, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 0.05, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 0.05, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Guantzu", base: 30, odd: 0.05, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{
|
||||
name: "Ulus",
|
||||
base: 31,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i],
|
||||
shield: "banner"
|
||||
},
|
||||
{name: "Turan", base: 16, odd: 0.05, sort: i => n(i) / td(i, 12), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{
|
||||
name: "Eurabic",
|
||||
base: 18,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{name: "Slovan", base: 5, odd: 0.05, sort: i => (n(i) / td(i, 6)) * t[i], shield: "round"},
|
||||
{
|
||||
name: "Keltan",
|
||||
base: 22,
|
||||
odd: 0.1,
|
||||
sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [6, 8]),
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Elladan", base: 7, odd: 0.2, sort: i => (n(i) / td(i, 18) / sf(i)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.2, sort: i => n(i) / td(i, 14) / t[i], shield: "roman"},
|
||||
// fantasy races
|
||||
{name: "Eldar", base: 33, odd: 0.5, sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i], shield: "fantasy5"}, // Elves
|
||||
{name: "Trow", base: 34, odd: 0.8, sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i], shield: "hessen"}, // Dark Elves
|
||||
{name: "Durinn", base: 35, odd: 0.8, sort: i => n(i) + h[i], shield: "erebor"}, // Dwarven
|
||||
{name: "Kobblin", base: 36, odd: 0.8, sort: i => t[i] - s[i], shield: "moriaOrc"}, // Goblin
|
||||
{name: "Uruk", base: 37, odd: 0.8, sort: i => (h[i] * t[i]) / bd(i, [1, 2, 10, 11]), shield: "urukHai"}, // Orc
|
||||
{name: "Yotunn", base: 38, odd: 0.8, sort: i => td(i, -10), shield: "pavise"}, // Giant
|
||||
{name: "Drake", base: 39, odd: 0.9, sort: i => -s[i], shield: "fantasy2"}, // Draconic
|
||||
{name: "Rakhnid", base: 40, odd: 0.9, sort: i => t[i] - s[i], shield: "horsehead2"}, // Arachnid
|
||||
{name: "Aj'Snaga", base: 41, odd: 0.9, sort: i => n(i) / bd(i, [12], 10), shield: "fantasy1"} // Serpents
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "random") {
|
||||
return d3.range(count).map(function () {
|
||||
const rnd = rand(nameBases.length - 1);
|
||||
const name = Names.getBaseShort(rnd);
|
||||
return {name, base: rnd, odd: 1, shield: getRandomShield()};
|
||||
});
|
||||
}
|
||||
|
||||
// all-world
|
||||
return [
|
||||
{name: "Shwazen", base: 0, odd: 0.7, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "hessen"},
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "heater"},
|
||||
{name: "Luari", base: 2, odd: 0.6, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "oldFrench"},
|
||||
{name: "Tallian", base: 3, odd: 0.6, sort: i => n(i) / td(i, 15), shield: "horsehead2"},
|
||||
{name: "Astellian", base: 4, odd: 0.6, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
{name: "Slovan", base: 5, odd: 0.7, sort: i => (n(i) / td(i, 6)) * t[i], shield: "round"},
|
||||
{name: "Norse", base: 6, odd: 0.7, sort: i => n(i) / td(i, 5), shield: "heater"},
|
||||
{name: "Elladan", base: 7, odd: 0.7, sort: i => (n(i) / td(i, 18)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.7, sort: i => n(i) / td(i, 15), shield: "roman"},
|
||||
{name: "Soumi", base: 9, odd: 0.3, sort: i => (n(i) / td(i, 5) / bd(i, [9])) * t[i], shield: "pavise"},
|
||||
{name: "Koryo", base: 10, odd: 0.1, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 0.1, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 0.1, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Portuzian", base: 13, odd: 0.4, sort: i => n(i) / td(i, 17) / sf(i), shield: "spanish"},
|
||||
{name: "Nawatli", base: 14, odd: 0.1, sort: i => h[i] / td(i, 18) / bd(i, [7]), shield: "square"},
|
||||
{name: "Vengrian", base: 15, odd: 0.2, sort: i => (n(i) / td(i, 11) / bd(i, [4])) * t[i], shield: "wedged"},
|
||||
{name: "Turchian", base: 16, odd: 0.2, sort: i => n(i) / td(i, 13), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.1,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{name: "Eurabic", base: 18, odd: 0.2, sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i], shield: "round"},
|
||||
{name: "Inuk", base: 19, odd: 0.05, sort: i => td(i, -1) / bd(i, [10, 11]) / sf(i), shield: "square"},
|
||||
{name: "Euskati", base: 20, odd: 0.05, sort: i => (n(i) / td(i, 15)) * h[i], shield: "spanish"},
|
||||
{name: "Yoruba", base: 21, odd: 0.05, sort: i => n(i) / td(i, 15) / bd(i, [5, 7]), shield: "vesicaPiscis"},
|
||||
{
|
||||
name: "Keltan",
|
||||
base: 22,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 11) / bd(i, [6, 8])) * t[i],
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Efratic", base: 23, odd: 0.05, sort: i => (n(i) / td(i, 22)) * t[i], shield: "diamond"},
|
||||
{name: "Tehrani", base: 24, odd: 0.1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "round"},
|
||||
{name: "Maui", base: 25, odd: 0.05, sort: i => n(i) / td(i, 24) / sf(i) / t[i], shield: "round"},
|
||||
{name: "Carnatic", base: 26, odd: 0.05, sort: i => n(i) / td(i, 26), shield: "round"},
|
||||
{name: "Inqan", base: 27, odd: 0.05, sort: i => h[i] / td(i, 13), shield: "square"},
|
||||
{name: "Kiswaili", base: 28, odd: 0.1, sort: i => n(i) / td(i, 29) / bd(i, [1, 3, 5, 7]), shield: "vesicaPiscis"},
|
||||
{name: "Vietic", base: 29, odd: 0.1, sort: i => n(i) / td(i, 25) / bd(i, [7], 7) / t[i], shield: "banner"},
|
||||
{name: "Guantzu", base: 30, odd: 0.1, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{name: "Ulus", base: 31, odd: 0.1, sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i], shield: "banner"},
|
||||
{name: "Hebrew", base: 42, odd: 0.2, sort: i => (n(i) / td(i, 18)) * sf(i), shield: "oval"} // Levantine
|
||||
];
|
||||
};
|
||||
|
||||
// expand cultures across the map (Dijkstra-like algorithm)
|
||||
const expand = function () {
|
||||
TIME && console.time("expandCultures");
|
||||
const {cells, cultures} = pack;
|
||||
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
const neutralRate = byId("neutralRate")?.valueAsNumber || 1;
|
||||
const maxExpansionCost = cells.i.length * 0.6 * neutralRate; // limit cost for culture growth
|
||||
|
||||
// remove culture from all cells except of locked
|
||||
const hasLocked = cultures.some(c => !c.removed && c.lock);
|
||||
if (hasLocked) {
|
||||
for (const cellId of cells.i) {
|
||||
const culture = cultures[cells.culture[cellId]];
|
||||
if (culture.lock) continue;
|
||||
cells.culture[cellId] = 0;
|
||||
}
|
||||
} else {
|
||||
cells.culture = new Uint16Array(cells.i.length);
|
||||
}
|
||||
|
||||
for (const culture of cultures) {
|
||||
if (!culture.i || culture.removed || culture.lock) continue;
|
||||
queue.push({cellId: culture.center, cultureId: culture.i, priority: 0}, 0);
|
||||
}
|
||||
|
||||
while (queue.length) {
|
||||
const {cellId, priority, cultureId} = queue.pop();
|
||||
const {type, expansionism} = cultures[cultureId];
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (hasLocked) {
|
||||
const neibCultureId = cells.culture[neibCellId];
|
||||
if (neibCultureId && cultures[neibCultureId].lock) return; // do not overwrite cell of locked culture
|
||||
}
|
||||
|
||||
const biome = cells.biome[neibCellId];
|
||||
const biomeCost = getBiomeCost(cultureId, biome, type);
|
||||
const biomeChangeCost = biome === cells.biome[neibCellId] ? 0 : 20; // penalty on biome change
|
||||
const heightCost = getHeightCost(neibCellId, cells.h[neibCellId], type);
|
||||
const riverCost = getRiverCost(cells.r[neibCellId], neibCellId, type);
|
||||
const typeCost = getTypeCost(cells.t[neibCellId], type);
|
||||
|
||||
const cellCost = (biomeCost + biomeChangeCost + heightCost + riverCost + typeCost) / expansionism;
|
||||
const totalCost = priority + cellCost;
|
||||
|
||||
if (totalCost > maxExpansionCost) return;
|
||||
|
||||
if (!cost[neibCellId] || totalCost < cost[neibCellId]) {
|
||||
if (cells.pop[neibCellId] > 0) cells.culture[neibCellId] = cultureId; // assign culture to populated cell
|
||||
cost[neibCellId] = totalCost;
|
||||
queue.push({cellId: neibCellId, cultureId, priority: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function getBiomeCost(c, biome, type) {
|
||||
if (cells.biome[cultures[c].center] === biome) return 10; // tiny penalty for native biome
|
||||
if (type === "Hunting") return biomesData.cost[biome] * 5; // non-native biome penalty for hunters
|
||||
if (type === "Nomadic" && biome > 4 && biome < 10) return biomesData.cost[biome] * 10; // forest biome penalty for nomads
|
||||
return biomesData.cost[biome] * 2; // general non-native biome penalty
|
||||
}
|
||||
|
||||
function getHeightCost(i, h, type) {
|
||||
const f = pack.features[cells.f[i]],
|
||||
a = cells.area[i];
|
||||
if (type === "Lake" && f.type === "lake") return 10; // no lake crossing penalty for Lake cultures
|
||||
if (type === "Naval" && h < 20) return a * 2; // low sea/lake crossing penalty for Naval cultures
|
||||
if (type === "Nomadic" && h < 20) return a * 50; // giant sea/lake crossing penalty for Nomads
|
||||
if (h < 20) return a * 6; // general sea/lake crossing penalty
|
||||
if (type === "Highland" && h < 44) return 3000; // giant penalty for highlanders on lowlands
|
||||
if (type === "Highland" && h < 62) return 200; // giant penalty for highlanders on lowhills
|
||||
if (type === "Highland") return 0; // no penalty for highlanders on highlands
|
||||
if (h >= 67) return 200; // general mountains crossing penalty
|
||||
if (h >= 44) return 30; // general hills crossing penalty
|
||||
return 0;
|
||||
}
|
||||
|
||||
function getRiverCost(riverId, cellId, type) {
|
||||
if (type === "River") return riverId ? 0 : 100; // penalty for river cultures
|
||||
if (!riverId) return 0; // no penalty for others if there is no river
|
||||
return minmax(cells.fl[cellId] / 10, 20, 100); // river penalty from 20 to 100 based on flux
|
||||
}
|
||||
|
||||
function getTypeCost(t, type) {
|
||||
if (t === 1) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline
|
||||
if (t === 2) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads
|
||||
if (t !== -1) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals
|
||||
return 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("expandCultures");
|
||||
};
|
||||
|
||||
const getRandomShield = function () {
|
||||
const type = rw(COA.shields.types);
|
||||
return rw(COA.shields[type]);
|
||||
};
|
||||
|
||||
return {generate, add, expand, getDefault, getRandomShield};
|
||||
})();
|
||||
68
procedural/src/engine/support/cultures-generator_config.md
Normal file
68
procedural/src/engine/support/cultures-generator_config.md
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
# Config Properties for cultures-generator.js
|
||||
|
||||
The refactored `cultures-generator.js` module requires the following configuration properties to be passed via the `config` object parameter:
|
||||
|
||||
## Required Configuration Properties
|
||||
|
||||
### Culture Generation Settings
|
||||
- **`culturesInput`** (number) - Number of cultures requested by user
|
||||
- *Replaces:* `+byId("culturesInput").value`
|
||||
- *Usage:* Determines how many cultures to generate
|
||||
|
||||
- **`culturesInSetNumber`** (number) - Maximum cultures available in selected culture set
|
||||
- *Replaces:* `+byId("culturesSet").selectedOptions[0].dataset.max`
|
||||
- *Usage:* Limits the number of cultures that can be generated based on the selected culture set
|
||||
|
||||
- **`culturesSet`** (string) - Selected culture set type
|
||||
- *Replaces:* `byId("culturesSet").value`
|
||||
- *Usage:* Determines which predefined culture set to use
|
||||
- *Valid values:* `"european"`, `"oriental"`, `"english"`, `"antique"`, `"highFantasy"`, `"darkFantasy"`, `"random"`, or default (all-world)
|
||||
|
||||
### Map Dimensions
|
||||
- **`graphWidth`** (number) - Width of the map/graph
|
||||
- *Usage:* Used for calculating culture center spacing
|
||||
- *Note:* This should be derived from the map generation settings
|
||||
|
||||
- **`graphHeight`** (number) - Height of the map/graph
|
||||
- *Usage:* Used for calculating culture center spacing
|
||||
- *Note:* This should be derived from the map generation settings
|
||||
|
||||
### Culture Expansion Settings
|
||||
- **`sizeVariety`** (number) - Variety factor for culture expansionism
|
||||
- *Replaces:* `byId("sizeVariety").value`
|
||||
- *Usage:* Controls how much culture expansionism varies from base values
|
||||
- *Typical range:* 0-2, where 1 is default variety
|
||||
|
||||
- **`neutralRate`** (number, optional) - Rate modifier for culture expansion
|
||||
- *Replaces:* `byId("neutralRate")?.valueAsNumber || 1`
|
||||
- *Usage:* Affects maximum expansion cost calculations
|
||||
- *Default:* 1 if not provided
|
||||
|
||||
### Visual Settings
|
||||
- **`emblemShape`** (string) - Shield/emblem shape setting
|
||||
- *Replaces:* `document.getElementById("emblemShape").value`
|
||||
- *Usage:* Determines shield shapes for cultures
|
||||
- *Valid values:* `"random"` for random shield selection, or specific shield type names
|
||||
|
||||
## Usage Example
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
culturesInput: 8,
|
||||
culturesInSetNumber: 15,
|
||||
culturesSet: "european",
|
||||
graphWidth: 2048,
|
||||
graphHeight: 1024,
|
||||
sizeVariety: 1.2,
|
||||
neutralRate: 1.0,
|
||||
emblemShape: "random"
|
||||
};
|
||||
|
||||
const result = generate(pack, grid, config, utils);
|
||||
```
|
||||
|
||||
## Notes
|
||||
- All numeric values should be validated before passing to ensure they are valid numbers
|
||||
- The `graphWidth` and `graphHeight` should match the actual map dimensions
|
||||
- Optional properties will use sensible defaults if not provided
|
||||
- The config object enables the engine to be completely independent of DOM/UI elements
|
||||
38
procedural/src/engine/support/cultures-generator_external.md
Normal file
38
procedural/src/engine/support/cultures-generator_external.md
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
# External Dependencies for cultures-generator.js
|
||||
|
||||
The refactored `cultures-generator.js` module requires the following external dependencies to be imported or passed via the `utils` object:
|
||||
|
||||
## Core Utility Functions
|
||||
- `TIME` - Boolean flag for timing operations
|
||||
- `WARN` - Boolean flag for warning messages
|
||||
- `ERROR` - Boolean flag for error messages
|
||||
- `rand(max)` - Random number generator function
|
||||
- `rn(value, precision)` - Round number function
|
||||
- `P(probability)` - Probability function
|
||||
- `minmax(value, min, max)` - Min/max clamp function
|
||||
- `biased(min, max, bias)` - Biased random function
|
||||
- `rw(array)` - Random weighted selection function
|
||||
- `abbreviate(name, existingCodes)` - Name abbreviation function
|
||||
|
||||
## External Modules/Objects
|
||||
- `d3` - D3.js library (specifically `d3.quadtree()`, `d3.max()`, `d3.range()`)
|
||||
- `Names` - Names generation module with methods:
|
||||
- `Names.getNameBases()`
|
||||
- `Names.getCulture(culture, min, max, suffix)`
|
||||
- `Names.getBase(base, min, max, suffix, index)`
|
||||
- `Names.getBaseShort(index)`
|
||||
- `COA` - Coat of Arms data object with shield types:
|
||||
- `COA.shields.types`
|
||||
- `COA.shields[type]`
|
||||
- `FlatQueue` - Priority queue implementation
|
||||
- `biomesData` - Biome cost data object with `cost` array
|
||||
- `nameBases` - Array of name bases
|
||||
|
||||
## Data Structures
|
||||
- `grid` - Grid data structure with `cells.temp` array
|
||||
- `getRandomColor()` - Function to generate random colors (optional utility)
|
||||
|
||||
## Notes
|
||||
- All these dependencies should be passed through the `utils` parameter to maintain the module's pure, headless nature
|
||||
- The `grid` parameter should be passed separately as it's core map data
|
||||
- Some utility functions like `getRandomColor` may need to be implemented if not available in the existing codebase
|
||||
702
procedural/src/engine/support/cultures-generator_prompt.md
Normal file
702
procedural/src/engine/support/cultures-generator_prompt.md
Normal file
|
|
@ -0,0 +1,702 @@
|
|||
# cultures-generator.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `cultures-generator.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Cultures = (function () {
|
||||
let cells;
|
||||
|
||||
const generate = function () {
|
||||
TIME && console.time("generateCultures");
|
||||
cells = pack.cells;
|
||||
|
||||
const cultureIds = new Uint16Array(cells.i.length); // cell cultures
|
||||
|
||||
const culturesInputNumber = +byId("culturesInput").value;
|
||||
const culturesInSetNumber = +byId("culturesSet").selectedOptions[0].dataset.max;
|
||||
let count = Math.min(culturesInputNumber, culturesInSetNumber);
|
||||
|
||||
const populated = cells.i.filter(i => cells.s[i]); // populated cells
|
||||
if (populated.length < count * 25) {
|
||||
count = Math.floor(populated.length / 50);
|
||||
if (!count) {
|
||||
WARN && console.warn(`There are no populated cells. Cannot generate cultures`);
|
||||
pack.cultures = [{name: "Wildlands", i: 0, base: 1, shield: "round"}];
|
||||
cells.culture = cultureIds;
|
||||
|
||||
alertMessage.innerHTML = /* html */ `The climate is harsh and people cannot live in this world.<br />
|
||||
No cultures, states and burgs will be created.<br />
|
||||
Please consider changing climate settings in the World Configurator`;
|
||||
|
||||
$("#alert").dialog({
|
||||
resizable: false,
|
||||
title: "Extreme climate warning",
|
||||
buttons: {
|
||||
Ok: function () {
|
||||
$(this).dialog("close");
|
||||
}
|
||||
}
|
||||
});
|
||||
return;
|
||||
} else {
|
||||
WARN && console.warn(`Not enough populated cells (${populated.length}). Will generate only ${count} cultures`);
|
||||
alertMessage.innerHTML = /* html */ ` There are only ${populated.length} populated cells and it's insufficient livable area.<br />
|
||||
Only ${count} out of ${culturesInput.value} requested cultures will be generated.<br />
|
||||
Please consider changing climate settings in the World Configurator`;
|
||||
$("#alert").dialog({
|
||||
resizable: false,
|
||||
title: "Extreme climate warning",
|
||||
buttons: {
|
||||
Ok: function () {
|
||||
$(this).dialog("close");
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const cultures = (pack.cultures = selectCultures(count));
|
||||
const centers = d3.quadtree();
|
||||
const colors = getColors(count);
|
||||
const emblemShape = document.getElementById("emblemShape").value;
|
||||
|
||||
const codes = [];
|
||||
|
||||
cultures.forEach(function (c, i) {
|
||||
const newId = i + 1;
|
||||
|
||||
if (c.lock) {
|
||||
codes.push(c.code);
|
||||
centers.add(c.center);
|
||||
|
||||
for (const i of cells.i) {
|
||||
if (cells.culture[i] === c.i) cultureIds[i] = newId;
|
||||
}
|
||||
|
||||
c.i = newId;
|
||||
return;
|
||||
}
|
||||
|
||||
const sortingFn = c.sort ? c.sort : i => cells.s[i];
|
||||
const center = placeCenter(sortingFn);
|
||||
|
||||
centers.add(cells.p[center]);
|
||||
c.center = center;
|
||||
c.i = newId;
|
||||
delete c.odd;
|
||||
delete c.sort;
|
||||
c.color = colors[i];
|
||||
c.type = defineCultureType(center);
|
||||
c.expansionism = defineCultureExpansionism(c.type);
|
||||
c.origins = [0];
|
||||
c.code = abbreviate(c.name, codes);
|
||||
codes.push(c.code);
|
||||
cultureIds[center] = newId;
|
||||
if (emblemShape === "random") c.shield = getRandomShield();
|
||||
});
|
||||
|
||||
cells.culture = cultureIds;
|
||||
|
||||
function placeCenter(sortingFn) {
|
||||
let spacing = (graphWidth + graphHeight) / 2 / count;
|
||||
const MAX_ATTEMPTS = 100;
|
||||
|
||||
const sorted = [...populated].sort((a, b) => sortingFn(b) - sortingFn(a));
|
||||
const max = Math.floor(sorted.length / 2);
|
||||
|
||||
let cellId = 0;
|
||||
for (let i = 0; i < MAX_ATTEMPTS; i++) {
|
||||
cellId = sorted[biased(0, max, 5)];
|
||||
spacing *= 0.9;
|
||||
if (!cultureIds[cellId] && !centers.find(cells.p[cellId][0], cells.p[cellId][1], spacing)) break;
|
||||
}
|
||||
|
||||
return cellId;
|
||||
}
|
||||
|
||||
// the first culture with id 0 is for wildlands
|
||||
cultures.unshift({name: "Wildlands", i: 0, base: 1, origins: [null], shield: "round"});
|
||||
|
||||
// make sure all bases exist in nameBases
|
||||
if (!nameBases.length) {
|
||||
ERROR && console.error("Name base is empty, default nameBases will be applied");
|
||||
nameBases = Names.getNameBases();
|
||||
}
|
||||
|
||||
cultures.forEach(c => (c.base = c.base % nameBases.length));
|
||||
|
||||
function selectCultures(culturesNumber) {
|
||||
let defaultCultures = getDefault(culturesNumber);
|
||||
const cultures = [];
|
||||
|
||||
pack.cultures?.forEach(function (culture) {
|
||||
if (culture.lock && !culture.removed) cultures.push(culture);
|
||||
});
|
||||
|
||||
if (!cultures.length) {
|
||||
if (culturesNumber === defaultCultures.length) return defaultCultures;
|
||||
if (defaultCultures.every(d => d.odd === 1)) return defaultCultures.splice(0, culturesNumber);
|
||||
}
|
||||
|
||||
for (let culture, rnd, i = 0; cultures.length < culturesNumber && defaultCultures.length > 0; ) {
|
||||
do {
|
||||
rnd = rand(defaultCultures.length - 1);
|
||||
culture = defaultCultures[rnd];
|
||||
i++;
|
||||
} while (i < 200 && !P(culture.odd));
|
||||
cultures.push(culture);
|
||||
defaultCultures.splice(rnd, 1);
|
||||
}
|
||||
return cultures;
|
||||
}
|
||||
|
||||
// set culture type based on culture center position
|
||||
function defineCultureType(i) {
|
||||
if (cells.h[i] < 70 && [1, 2, 4].includes(cells.biome[i])) return "Nomadic"; // high penalty in forest biomes and near coastline
|
||||
if (cells.h[i] > 50) return "Highland"; // no penalty for hills and moutains, high for other elevations
|
||||
const f = pack.features[cells.f[cells.haven[i]]]; // opposite feature
|
||||
if (f.type === "lake" && f.cells > 5) return "Lake"; // low water cross penalty and high for growth not along coastline
|
||||
if (
|
||||
(cells.harbor[i] && f.type !== "lake" && P(0.1)) ||
|
||||
(cells.harbor[i] === 1 && P(0.6)) ||
|
||||
(pack.features[cells.f[i]].group === "isle" && P(0.4))
|
||||
)
|
||||
return "Naval"; // low water cross penalty and high for non-along-coastline growth
|
||||
if (cells.r[i] && cells.fl[i] > 100) return "River"; // no River cross penalty, penalty for non-River growth
|
||||
if (cells.t[i] > 2 && [3, 7, 8, 9, 10, 12].includes(cells.biome[i])) return "Hunting"; // high penalty in non-native biomes
|
||||
return "Generic";
|
||||
}
|
||||
|
||||
function defineCultureExpansionism(type) {
|
||||
let base = 1; // Generic
|
||||
if (type === "Lake") base = 0.8;
|
||||
else if (type === "Naval") base = 1.5;
|
||||
else if (type === "River") base = 0.9;
|
||||
else if (type === "Nomadic") base = 1.5;
|
||||
else if (type === "Hunting") base = 0.7;
|
||||
else if (type === "Highland") base = 1.2;
|
||||
return rn(((Math.random() * byId("sizeVariety").value) / 2 + 1) * base, 1);
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateCultures");
|
||||
};
|
||||
|
||||
const add = function (center) {
|
||||
const defaultCultures = getDefault();
|
||||
let culture, base, name;
|
||||
|
||||
if (pack.cultures.length < defaultCultures.length) {
|
||||
// add one of the default cultures
|
||||
culture = pack.cultures.length;
|
||||
base = defaultCultures[culture].base;
|
||||
name = defaultCultures[culture].name;
|
||||
} else {
|
||||
// add random culture besed on one of the current ones
|
||||
culture = rand(pack.cultures.length - 1);
|
||||
name = Names.getCulture(culture, 5, 8, "");
|
||||
base = pack.cultures[culture].base;
|
||||
}
|
||||
|
||||
const code = abbreviate(
|
||||
name,
|
||||
pack.cultures.map(c => c.code)
|
||||
);
|
||||
const i = pack.cultures.length;
|
||||
const color = getRandomColor();
|
||||
|
||||
// define emblem shape
|
||||
let shield = culture.shield;
|
||||
const emblemShape = document.getElementById("emblemShape").value;
|
||||
if (emblemShape === "random") shield = getRandomShield();
|
||||
|
||||
pack.cultures.push({
|
||||
name,
|
||||
color,
|
||||
base,
|
||||
center,
|
||||
i,
|
||||
expansionism: 1,
|
||||
type: "Generic",
|
||||
cells: 0,
|
||||
area: 0,
|
||||
rural: 0,
|
||||
urban: 0,
|
||||
origins: [pack.cells.culture[center]],
|
||||
code,
|
||||
shield
|
||||
});
|
||||
};
|
||||
|
||||
const getDefault = function (count) {
|
||||
// generic sorting functions
|
||||
const cells = pack.cells,
|
||||
s = cells.s,
|
||||
sMax = d3.max(s),
|
||||
t = cells.t,
|
||||
h = cells.h,
|
||||
temp = grid.cells.temp;
|
||||
const n = cell => Math.ceil((s[cell] / sMax) * 3); // normalized cell score
|
||||
const td = (cell, goal) => {
|
||||
const d = Math.abs(temp[cells.g[cell]] - goal);
|
||||
return d ? d + 1 : 1;
|
||||
}; // temperature difference fee
|
||||
const bd = (cell, biomes, fee = 4) => (biomes.includes(cells.biome[cell]) ? 1 : fee); // biome difference fee
|
||||
const sf = (cell, fee = 4) =>
|
||||
cells.haven[cell] && pack.features[cells.f[cells.haven[cell]]].type !== "lake" ? 1 : fee; // not on sea coast fee
|
||||
|
||||
if (culturesSet.value === "european") {
|
||||
return [
|
||||
{name: "Shwazen", base: 0, odd: 1, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "swiss"},
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "wedged"},
|
||||
{name: "Luari", base: 2, odd: 1, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "french"},
|
||||
{name: "Tallian", base: 3, odd: 1, sort: i => n(i) / td(i, 15), shield: "horsehead"},
|
||||
{name: "Astellian", base: 4, odd: 1, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
{name: "Slovan", base: 5, odd: 1, sort: i => (n(i) / td(i, 6)) * t[i], shield: "polish"},
|
||||
{name: "Norse", base: 6, odd: 1, sort: i => n(i) / td(i, 5), shield: "heater"},
|
||||
{name: "Elladan", base: 7, odd: 1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.2, sort: i => n(i) / td(i, 15) / t[i], shield: "roman"},
|
||||
{name: "Soumi", base: 9, odd: 1, sort: i => (n(i) / td(i, 5) / bd(i, [9])) * t[i], shield: "pavise"},
|
||||
{name: "Portuzian", base: 13, odd: 1, sort: i => n(i) / td(i, 17) / sf(i), shield: "renaissance"},
|
||||
{name: "Vengrian", base: 15, odd: 1, sort: i => (n(i) / td(i, 11) / bd(i, [4])) * t[i], shield: "horsehead2"},
|
||||
{name: "Turchian", base: 16, odd: 0.05, sort: i => n(i) / td(i, 14), shield: "round"},
|
||||
{name: "Euskati", base: 20, odd: 0.05, sort: i => (n(i) / td(i, 15)) * h[i], shield: "oldFrench"},
|
||||
{name: "Keltan", base: 22, odd: 0.05, sort: i => (n(i) / td(i, 11) / bd(i, [6, 8])) * t[i], shield: "oval"}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "oriental") {
|
||||
return [
|
||||
{name: "Koryo", base: 10, odd: 1, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 1, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 1, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Turchian", base: 16, odd: 1, sort: i => n(i) / td(i, 12), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.2,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "oval"
|
||||
},
|
||||
{name: "Eurabic", base: 18, odd: 1, sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i], shield: "oval"},
|
||||
{name: "Efratic", base: 23, odd: 0.1, sort: i => (n(i) / td(i, 22)) * t[i], shield: "round"},
|
||||
{name: "Tehrani", base: 24, odd: 1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "round"},
|
||||
{name: "Maui", base: 25, odd: 0.2, sort: i => n(i) / td(i, 24) / sf(i) / t[i], shield: "vesicaPiscis"},
|
||||
{name: "Carnatic", base: 26, odd: 0.5, sort: i => n(i) / td(i, 26), shield: "round"},
|
||||
{name: "Vietic", base: 29, odd: 0.8, sort: i => n(i) / td(i, 25) / bd(i, [7], 7) / t[i], shield: "banner"},
|
||||
{name: "Guantzu", base: 30, odd: 0.5, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{name: "Ulus", base: 31, odd: 1, sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i], shield: "banner"}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "english") {
|
||||
const getName = () => Names.getBase(1, 5, 9, "", 0);
|
||||
return [
|
||||
{name: getName(), base: 1, odd: 1, shield: "heater"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "wedged"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "swiss"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "oldFrench"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "swiss"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "spanish"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "hessen"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy5"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy4"},
|
||||
{name: getName(), base: 1, odd: 1, shield: "fantasy1"}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "antique") {
|
||||
return [
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 14) / t[i], shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 15) / sf(i), shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 16) / sf(i), shield: "roman"}, // Roman
|
||||
{name: "Roman", base: 8, odd: 1, sort: i => n(i) / td(i, 17) / t[i], shield: "roman"}, // Roman
|
||||
{name: "Hellenic", base: 7, odd: 1, sort: i => (n(i) / td(i, 18) / sf(i)) * h[i], shield: "boeotian"}, // Greek
|
||||
{name: "Hellenic", base: 7, odd: 1, sort: i => (n(i) / td(i, 19) / sf(i)) * h[i], shield: "boeotian"}, // Greek
|
||||
{name: "Macedonian", base: 7, odd: 0.5, sort: i => (n(i) / td(i, 12)) * h[i], shield: "round"}, // Greek
|
||||
{name: "Celtic", base: 22, odd: 1, sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [6, 8]), shield: "round"},
|
||||
{name: "Germanic", base: 0, odd: 1, sort: i => n(i) / td(i, 10) ** 0.5 / bd(i, [6, 8]), shield: "round"},
|
||||
{name: "Persian", base: 24, odd: 0.8, sort: i => (n(i) / td(i, 18)) * h[i], shield: "oval"}, // Iranian
|
||||
{name: "Scythian", base: 24, odd: 0.5, sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [4]), shield: "round"}, // Iranian
|
||||
{name: "Cantabrian", base: 20, odd: 0.5, sort: i => (n(i) / td(i, 16)) * h[i], shield: "oval"}, // Basque
|
||||
{name: "Estian", base: 9, odd: 0.2, sort: i => (n(i) / td(i, 5)) * t[i], shield: "pavise"}, // Finnic
|
||||
{name: "Carthaginian", base: 42, odd: 0.3, sort: i => n(i) / td(i, 20) / sf(i), shield: "oval"}, // Levantine
|
||||
{name: "Hebrew", base: 42, odd: 0.2, sort: i => (n(i) / td(i, 19)) * sf(i), shield: "oval"}, // Levantine
|
||||
{name: "Mesopotamian", base: 23, odd: 0.2, sort: i => n(i) / td(i, 22) / bd(i, [1, 2, 3]), shield: "oval"} // Mesopotamian
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "highFantasy") {
|
||||
return [
|
||||
// fantasy races
|
||||
{
|
||||
name: "Quenian (Elfish)",
|
||||
base: 33,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i],
|
||||
shield: "gondor"
|
||||
}, // Elves
|
||||
{
|
||||
name: "Eldar (Elfish)",
|
||||
base: 33,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i],
|
||||
shield: "noldor"
|
||||
}, // Elves
|
||||
{
|
||||
name: "Trow (Dark Elfish)",
|
||||
base: 34,
|
||||
odd: 0.9,
|
||||
sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i],
|
||||
shield: "hessen"
|
||||
}, // Dark Elves
|
||||
{
|
||||
name: "Lothian (Dark Elfish)",
|
||||
base: 34,
|
||||
odd: 0.3,
|
||||
sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i],
|
||||
shield: "wedged"
|
||||
}, // Dark Elves
|
||||
{name: "Dunirr (Dwarven)", base: 35, odd: 1, sort: i => n(i) + h[i], shield: "ironHills"}, // Dwarfs
|
||||
{name: "Khazadur (Dwarven)", base: 35, odd: 1, sort: i => n(i) + h[i], shield: "erebor"}, // Dwarfs
|
||||
{name: "Kobold (Goblin)", base: 36, odd: 1, sort: i => t[i] - s[i], shield: "moriaOrc"}, // Goblin
|
||||
{name: "Uruk (Orkish)", base: 37, odd: 1, sort: i => h[i] * t[i], shield: "urukHai"}, // Orc
|
||||
{
|
||||
name: "Ugluk (Orkish)",
|
||||
base: 37,
|
||||
odd: 0.5,
|
||||
sort: i => (h[i] * t[i]) / bd(i, [1, 2, 10, 11]),
|
||||
shield: "moriaOrc"
|
||||
}, // Orc
|
||||
{name: "Yotunn (Giants)", base: 38, odd: 0.7, sort: i => td(i, -10), shield: "pavise"}, // Giant
|
||||
{name: "Rake (Drakonic)", base: 39, odd: 0.7, sort: i => -s[i], shield: "fantasy2"}, // Draconic
|
||||
{name: "Arago (Arachnid)", base: 40, odd: 0.7, sort: i => t[i] - s[i], shield: "horsehead2"}, // Arachnid
|
||||
{name: "Aj'Snaga (Serpents)", base: 41, odd: 0.7, sort: i => n(i) / bd(i, [12], 10), shield: "fantasy1"}, // Serpents
|
||||
// fantasy human
|
||||
{name: "Anor (Human)", base: 32, odd: 1, sort: i => n(i) / td(i, 10), shield: "fantasy5"},
|
||||
{name: "Dail (Human)", base: 32, odd: 1, sort: i => n(i) / td(i, 13), shield: "roman"},
|
||||
{name: "Rohand (Human)", base: 16, odd: 1, sort: i => n(i) / td(i, 16), shield: "round"},
|
||||
{
|
||||
name: "Dulandir (Human)",
|
||||
base: 31,
|
||||
odd: 1,
|
||||
sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i],
|
||||
shield: "easterling"
|
||||
}
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "darkFantasy") {
|
||||
return [
|
||||
// common real-world English
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "heater"},
|
||||
{name: "Enlandic", base: 1, odd: 1, sort: i => n(i) / td(i, 12), shield: "heater"},
|
||||
{name: "Westen", base: 1, odd: 1, sort: i => n(i) / td(i, 10), shield: "heater"},
|
||||
{name: "Nortumbic", base: 1, odd: 1, sort: i => n(i) / td(i, 7), shield: "heater"},
|
||||
{name: "Mercian", base: 1, odd: 1, sort: i => n(i) / td(i, 9), shield: "heater"},
|
||||
{name: "Kentian", base: 1, odd: 1, sort: i => n(i) / td(i, 12), shield: "heater"},
|
||||
// rare real-world western
|
||||
{name: "Norse", base: 6, odd: 0.7, sort: i => n(i) / td(i, 5) / sf(i), shield: "oldFrench"},
|
||||
{name: "Schwarzen", base: 0, odd: 0.3, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "gonfalon"},
|
||||
{name: "Luarian", base: 2, odd: 0.3, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "oldFrench"},
|
||||
{name: "Hetallian", base: 3, odd: 0.3, sort: i => n(i) / td(i, 15), shield: "oval"},
|
||||
{name: "Astellian", base: 4, odd: 0.3, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
// rare real-world exotic
|
||||
{
|
||||
name: "Kiswaili",
|
||||
base: 28,
|
||||
odd: 0.05,
|
||||
sort: i => n(i) / td(i, 29) / bd(i, [1, 3, 5, 7]),
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Yoruba", base: 21, odd: 0.05, sort: i => n(i) / td(i, 15) / bd(i, [5, 7]), shield: "vesicaPiscis"},
|
||||
{name: "Koryo", base: 10, odd: 0.05, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 0.05, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 0.05, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Guantzu", base: 30, odd: 0.05, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{
|
||||
name: "Ulus",
|
||||
base: 31,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i],
|
||||
shield: "banner"
|
||||
},
|
||||
{name: "Turan", base: 16, odd: 0.05, sort: i => n(i) / td(i, 12), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{
|
||||
name: "Eurabic",
|
||||
base: 18,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{name: "Slovan", base: 5, odd: 0.05, sort: i => (n(i) / td(i, 6)) * t[i], shield: "round"},
|
||||
{
|
||||
name: "Keltan",
|
||||
base: 22,
|
||||
odd: 0.1,
|
||||
sort: i => n(i) / td(i, 11) ** 0.5 / bd(i, [6, 8]),
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Elladan", base: 7, odd: 0.2, sort: i => (n(i) / td(i, 18) / sf(i)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.2, sort: i => n(i) / td(i, 14) / t[i], shield: "roman"},
|
||||
// fantasy races
|
||||
{name: "Eldar", base: 33, odd: 0.5, sort: i => (n(i) / bd(i, [6, 7, 8, 9], 10)) * t[i], shield: "fantasy5"}, // Elves
|
||||
{name: "Trow", base: 34, odd: 0.8, sort: i => (n(i) / bd(i, [7, 8, 9, 12], 10)) * t[i], shield: "hessen"}, // Dark Elves
|
||||
{name: "Durinn", base: 35, odd: 0.8, sort: i => n(i) + h[i], shield: "erebor"}, // Dwarven
|
||||
{name: "Kobblin", base: 36, odd: 0.8, sort: i => t[i] - s[i], shield: "moriaOrc"}, // Goblin
|
||||
{name: "Uruk", base: 37, odd: 0.8, sort: i => (h[i] * t[i]) / bd(i, [1, 2, 10, 11]), shield: "urukHai"}, // Orc
|
||||
{name: "Yotunn", base: 38, odd: 0.8, sort: i => td(i, -10), shield: "pavise"}, // Giant
|
||||
{name: "Drake", base: 39, odd: 0.9, sort: i => -s[i], shield: "fantasy2"}, // Draconic
|
||||
{name: "Rakhnid", base: 40, odd: 0.9, sort: i => t[i] - s[i], shield: "horsehead2"}, // Arachnid
|
||||
{name: "Aj'Snaga", base: 41, odd: 0.9, sort: i => n(i) / bd(i, [12], 10), shield: "fantasy1"} // Serpents
|
||||
];
|
||||
}
|
||||
|
||||
if (culturesSet.value === "random") {
|
||||
return d3.range(count).map(function () {
|
||||
const rnd = rand(nameBases.length - 1);
|
||||
const name = Names.getBaseShort(rnd);
|
||||
return {name, base: rnd, odd: 1, shield: getRandomShield()};
|
||||
});
|
||||
}
|
||||
|
||||
// all-world
|
||||
return [
|
||||
{name: "Shwazen", base: 0, odd: 0.7, sort: i => n(i) / td(i, 10) / bd(i, [6, 8]), shield: "hessen"},
|
||||
{name: "Angshire", base: 1, odd: 1, sort: i => n(i) / td(i, 10) / sf(i), shield: "heater"},
|
||||
{name: "Luari", base: 2, odd: 0.6, sort: i => n(i) / td(i, 12) / bd(i, [6, 8]), shield: "oldFrench"},
|
||||
{name: "Tallian", base: 3, odd: 0.6, sort: i => n(i) / td(i, 15), shield: "horsehead2"},
|
||||
{name: "Astellian", base: 4, odd: 0.6, sort: i => n(i) / td(i, 16), shield: "spanish"},
|
||||
{name: "Slovan", base: 5, odd: 0.7, sort: i => (n(i) / td(i, 6)) * t[i], shield: "round"},
|
||||
{name: "Norse", base: 6, odd: 0.7, sort: i => n(i) / td(i, 5), shield: "heater"},
|
||||
{name: "Elladan", base: 7, odd: 0.7, sort: i => (n(i) / td(i, 18)) * h[i], shield: "boeotian"},
|
||||
{name: "Romian", base: 8, odd: 0.7, sort: i => n(i) / td(i, 15), shield: "roman"},
|
||||
{name: "Soumi", base: 9, odd: 0.3, sort: i => (n(i) / td(i, 5) / bd(i, [9])) * t[i], shield: "pavise"},
|
||||
{name: "Koryo", base: 10, odd: 0.1, sort: i => n(i) / td(i, 12) / t[i], shield: "round"},
|
||||
{name: "Hantzu", base: 11, odd: 0.1, sort: i => n(i) / td(i, 13), shield: "banner"},
|
||||
{name: "Yamoto", base: 12, odd: 0.1, sort: i => n(i) / td(i, 15) / t[i], shield: "round"},
|
||||
{name: "Portuzian", base: 13, odd: 0.4, sort: i => n(i) / td(i, 17) / sf(i), shield: "spanish"},
|
||||
{name: "Nawatli", base: 14, odd: 0.1, sort: i => h[i] / td(i, 18) / bd(i, [7]), shield: "square"},
|
||||
{name: "Vengrian", base: 15, odd: 0.2, sort: i => (n(i) / td(i, 11) / bd(i, [4])) * t[i], shield: "wedged"},
|
||||
{name: "Turchian", base: 16, odd: 0.2, sort: i => n(i) / td(i, 13), shield: "round"},
|
||||
{
|
||||
name: "Berberan",
|
||||
base: 17,
|
||||
odd: 0.1,
|
||||
sort: i => (n(i) / td(i, 19) / bd(i, [1, 2, 3], 7)) * t[i],
|
||||
shield: "round"
|
||||
},
|
||||
{name: "Eurabic", base: 18, odd: 0.2, sort: i => (n(i) / td(i, 26) / bd(i, [1, 2], 7)) * t[i], shield: "round"},
|
||||
{name: "Inuk", base: 19, odd: 0.05, sort: i => td(i, -1) / bd(i, [10, 11]) / sf(i), shield: "square"},
|
||||
{name: "Euskati", base: 20, odd: 0.05, sort: i => (n(i) / td(i, 15)) * h[i], shield: "spanish"},
|
||||
{name: "Yoruba", base: 21, odd: 0.05, sort: i => n(i) / td(i, 15) / bd(i, [5, 7]), shield: "vesicaPiscis"},
|
||||
{
|
||||
name: "Keltan",
|
||||
base: 22,
|
||||
odd: 0.05,
|
||||
sort: i => (n(i) / td(i, 11) / bd(i, [6, 8])) * t[i],
|
||||
shield: "vesicaPiscis"
|
||||
},
|
||||
{name: "Efratic", base: 23, odd: 0.05, sort: i => (n(i) / td(i, 22)) * t[i], shield: "diamond"},
|
||||
{name: "Tehrani", base: 24, odd: 0.1, sort: i => (n(i) / td(i, 18)) * h[i], shield: "round"},
|
||||
{name: "Maui", base: 25, odd: 0.05, sort: i => n(i) / td(i, 24) / sf(i) / t[i], shield: "round"},
|
||||
{name: "Carnatic", base: 26, odd: 0.05, sort: i => n(i) / td(i, 26), shield: "round"},
|
||||
{name: "Inqan", base: 27, odd: 0.05, sort: i => h[i] / td(i, 13), shield: "square"},
|
||||
{name: "Kiswaili", base: 28, odd: 0.1, sort: i => n(i) / td(i, 29) / bd(i, [1, 3, 5, 7]), shield: "vesicaPiscis"},
|
||||
{name: "Vietic", base: 29, odd: 0.1, sort: i => n(i) / td(i, 25) / bd(i, [7], 7) / t[i], shield: "banner"},
|
||||
{name: "Guantzu", base: 30, odd: 0.1, sort: i => n(i) / td(i, 17), shield: "banner"},
|
||||
{name: "Ulus", base: 31, odd: 0.1, sort: i => (n(i) / td(i, 5) / bd(i, [2, 4, 10], 7)) * t[i], shield: "banner"},
|
||||
{name: "Hebrew", base: 42, odd: 0.2, sort: i => (n(i) / td(i, 18)) * sf(i), shield: "oval"} // Levantine
|
||||
];
|
||||
};
|
||||
|
||||
// expand cultures across the map (Dijkstra-like algorithm)
|
||||
const expand = function () {
|
||||
TIME && console.time("expandCultures");
|
||||
const {cells, cultures} = pack;
|
||||
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
const neutralRate = byId("neutralRate")?.valueAsNumber || 1;
|
||||
const maxExpansionCost = cells.i.length * 0.6 * neutralRate; // limit cost for culture growth
|
||||
|
||||
// remove culture from all cells except of locked
|
||||
const hasLocked = cultures.some(c => !c.removed && c.lock);
|
||||
if (hasLocked) {
|
||||
for (const cellId of cells.i) {
|
||||
const culture = cultures[cells.culture[cellId]];
|
||||
if (culture.lock) continue;
|
||||
cells.culture[cellId] = 0;
|
||||
}
|
||||
} else {
|
||||
cells.culture = new Uint16Array(cells.i.length);
|
||||
}
|
||||
|
||||
for (const culture of cultures) {
|
||||
if (!culture.i || culture.removed || culture.lock) continue;
|
||||
queue.push({cellId: culture.center, cultureId: culture.i, priority: 0}, 0);
|
||||
}
|
||||
|
||||
while (queue.length) {
|
||||
const {cellId, priority, cultureId} = queue.pop();
|
||||
const {type, expansionism} = cultures[cultureId];
|
||||
|
||||
cells.c[cellId].forEach(neibCellId => {
|
||||
if (hasLocked) {
|
||||
const neibCultureId = cells.culture[neibCellId];
|
||||
if (neibCultureId && cultures[neibCultureId].lock) return; // do not overwrite cell of locked culture
|
||||
}
|
||||
|
||||
const biome = cells.biome[neibCellId];
|
||||
const biomeCost = getBiomeCost(cultureId, biome, type);
|
||||
const biomeChangeCost = biome === cells.biome[neibCellId] ? 0 : 20; // penalty on biome change
|
||||
const heightCost = getHeightCost(neibCellId, cells.h[neibCellId], type);
|
||||
const riverCost = getRiverCost(cells.r[neibCellId], neibCellId, type);
|
||||
const typeCost = getTypeCost(cells.t[neibCellId], type);
|
||||
|
||||
const cellCost = (biomeCost + biomeChangeCost + heightCost + riverCost + typeCost) / expansionism;
|
||||
const totalCost = priority + cellCost;
|
||||
|
||||
if (totalCost > maxExpansionCost) return;
|
||||
|
||||
if (!cost[neibCellId] || totalCost < cost[neibCellId]) {
|
||||
if (cells.pop[neibCellId] > 0) cells.culture[neibCellId] = cultureId; // assign culture to populated cell
|
||||
cost[neibCellId] = totalCost;
|
||||
queue.push({cellId: neibCellId, cultureId, priority: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function getBiomeCost(c, biome, type) {
|
||||
if (cells.biome[cultures[c].center] === biome) return 10; // tiny penalty for native biome
|
||||
if (type === "Hunting") return biomesData.cost[biome] * 5; // non-native biome penalty for hunters
|
||||
if (type === "Nomadic" && biome > 4 && biome < 10) return biomesData.cost[biome] * 10; // forest biome penalty for nomads
|
||||
return biomesData.cost[biome] * 2; // general non-native biome penalty
|
||||
}
|
||||
|
||||
function getHeightCost(i, h, type) {
|
||||
const f = pack.features[cells.f[i]],
|
||||
a = cells.area[i];
|
||||
if (type === "Lake" && f.type === "lake") return 10; // no lake crossing penalty for Lake cultures
|
||||
if (type === "Naval" && h < 20) return a * 2; // low sea/lake crossing penalty for Naval cultures
|
||||
if (type === "Nomadic" && h < 20) return a * 50; // giant sea/lake crossing penalty for Nomads
|
||||
if (h < 20) return a * 6; // general sea/lake crossing penalty
|
||||
if (type === "Highland" && h < 44) return 3000; // giant penalty for highlanders on lowlands
|
||||
if (type === "Highland" && h < 62) return 200; // giant penalty for highlanders on lowhills
|
||||
if (type === "Highland") return 0; // no penalty for highlanders on highlands
|
||||
if (h >= 67) return 200; // general mountains crossing penalty
|
||||
if (h >= 44) return 30; // general hills crossing penalty
|
||||
return 0;
|
||||
}
|
||||
|
||||
function getRiverCost(riverId, cellId, type) {
|
||||
if (type === "River") return riverId ? 0 : 100; // penalty for river cultures
|
||||
if (!riverId) return 0; // no penalty for others if there is no river
|
||||
return minmax(cells.fl[cellId] / 10, 20, 100); // river penalty from 20 to 100 based on flux
|
||||
}
|
||||
|
||||
function getTypeCost(t, type) {
|
||||
if (t === 1) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline
|
||||
if (t === 2) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads
|
||||
if (t !== -1) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals
|
||||
return 0;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("expandCultures");
|
||||
};
|
||||
|
||||
const getRandomShield = function () {
|
||||
const type = rw(COA.shields.types);
|
||||
return rw(COA.shields[type]);
|
||||
};
|
||||
|
||||
return {generate, add, expand, getDefault, getRandomShield};
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./cultures-generator.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./cultures-generator_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in cultures-generator_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into cultures-generator_render.md
|
||||
99
procedural/src/engine/support/cultures-generator_render.md
Normal file
99
procedural/src/engine/support/cultures-generator_render.md
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
# Removed Rendering/UI Logic from cultures-generator.js
|
||||
|
||||
The following UI and rendering logic was removed from the legacy `cultures-generator.js` and needs to be implemented in the Viewer/Client application:
|
||||
|
||||
## Alert Dialog System
|
||||
|
||||
### Extreme Climate Warning Dialog
|
||||
**Location:** Lines 96-109 in original code
|
||||
**Removed Code:**
|
||||
```javascript
|
||||
alertMessage.innerHTML = /* html */ `The climate is harsh and people cannot live in this world.<br />
|
||||
No cultures, states and burgs will be created.<br />
|
||||
Please consider changing climate settings in the World Configurator`;
|
||||
|
||||
$("#alert").dialog({
|
||||
resizable: false,
|
||||
title: "Extreme climate warning",
|
||||
buttons: {
|
||||
Ok: function () {
|
||||
$(this).dialog("close");
|
||||
}
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
**Replacement Strategy:** The engine now returns an error object with type `"extreme_climate"` that the UI can use to display the appropriate dialog.
|
||||
|
||||
### Insufficient Population Warning Dialog
|
||||
**Location:** Lines 112-124 in original code
|
||||
**Removed Code:**
|
||||
```javascript
|
||||
alertMessage.innerHTML = /* html */ ` There are only ${populated.length} populated cells and it's insufficient livable area.<br />
|
||||
Only ${count} out of ${culturesInput.value} requested cultures will be generated.<br />
|
||||
Please consider changing climate settings in the World Configurator`;
|
||||
$("#alert").dialog({
|
||||
resizable: false,
|
||||
title: "Extreme climate warning",
|
||||
buttons: {
|
||||
Ok: function () {
|
||||
$(this).dialog("close");
|
||||
}
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
**Replacement Strategy:** The engine can return a warning object that the UI can use to display this information.
|
||||
|
||||
## DOM Element Access
|
||||
|
||||
### Removed DOM Queries
|
||||
All `byId()` and `document.getElementById()` calls were removed:
|
||||
|
||||
1. **`byId("culturesInput").value`** → Replaced with `config.culturesInput`
|
||||
2. **`byId("culturesSet").selectedOptions[0].dataset.max`** → Replaced with `config.culturesInSetNumber`
|
||||
3. **`byId("culturesSet").value`** → Replaced with `config.culturesSet`
|
||||
4. **`byId("sizeVariety").value`** → Replaced with `config.sizeVariety`
|
||||
5. **`document.getElementById("emblemShape").value`** → Replaced with `config.emblemShape`
|
||||
6. **`byId("neutralRate")?.valueAsNumber`** → Replaced with `config.neutralRate`
|
||||
|
||||
### Additional DOM Reference Removed
|
||||
- **`culturesInput.value`** (Line 113) → Should use `config.culturesInput`
|
||||
|
||||
## Implementation Notes for Viewer/Client
|
||||
|
||||
### Error Handling
|
||||
The refactored engine returns structured error/warning information instead of directly showing UI dialogs:
|
||||
|
||||
```javascript
|
||||
// Example error return structure
|
||||
{
|
||||
cultures: [...],
|
||||
cells: { culture: [...] },
|
||||
error: {
|
||||
type: "extreme_climate",
|
||||
message: "The climate is harsh...",
|
||||
populated: 150
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Warning Handling
|
||||
For non-fatal warnings (insufficient population), the Viewer should:
|
||||
1. Check if the returned culture count is less than requested
|
||||
2. Display appropriate warning message to user
|
||||
3. Allow user to proceed or modify settings
|
||||
|
||||
### Dialog Implementation
|
||||
The Viewer should implement:
|
||||
1. **Alert dialog system** using modern UI framework (React/Vue/etc.) instead of jQuery UI
|
||||
2. **Error message formatting** with HTML support for multi-line messages
|
||||
3. **User confirmation handling** for proceeding with warnings
|
||||
4. **Settings modification links** to help users fix configuration issues
|
||||
|
||||
### Configuration Reading
|
||||
The Viewer is responsible for:
|
||||
1. Reading all DOM input values
|
||||
2. Assembling the `config` object
|
||||
3. Passing the config to the engine
|
||||
4. Handling any validation of config values before engine calls
|
||||
302
procedural/src/engine/support/features.txt
Normal file
302
procedural/src/engine/support/features.txt
Normal file
|
|
@ -0,0 +1,302 @@
|
|||
"use strict";
|
||||
|
||||
const DEEPER_LAND = 3;
|
||||
const LANDLOCKED = 2;
|
||||
const LAND_COAST = 1;
|
||||
const UNMARKED = 0;
|
||||
const WATER_COAST = -1;
|
||||
const DEEP_WATER = -2;
|
||||
|
||||
// calculate distance to coast for every cell
|
||||
function markup({distanceField, neighbors, start, increment, limit = utils.INT8_MAX}) {
|
||||
for (let distance = start, marked = Infinity; marked > 0 && distance !== limit; distance += increment) {
|
||||
marked = 0;
|
||||
const prevDistance = distance - increment;
|
||||
for (let cellId = 0; cellId < neighbors.length; cellId++) {
|
||||
if (distanceField[cellId] !== prevDistance) continue;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
if (distanceField[neighborId] !== UNMARKED) continue;
|
||||
distanceField[neighborId] = distance;
|
||||
marked++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// mark Grid features (ocean, lakes, islands) and calculate distance field
|
||||
export function markupGrid(grid, config, utils) {
|
||||
const {TIME, seed, aleaPRNG} = config;
|
||||
const {rn} = utils;
|
||||
|
||||
TIME && console.time("markupGrid");
|
||||
Math.random = aleaPRNG(seed); // get the same result on heightmap edit in Erase mode
|
||||
|
||||
const {h: heights, c: neighbors, b: borderCells, i} = grid.cells;
|
||||
const cellsNumber = i.length;
|
||||
const distanceField = new Int8Array(cellsNumber); // gird.cells.t
|
||||
const featureIds = new Uint16Array(cellsNumber); // gird.cells.f
|
||||
const features = [0];
|
||||
|
||||
const queue = [0];
|
||||
for (let featureId = 1; queue[0] !== -1; featureId++) {
|
||||
const firstCell = queue[0];
|
||||
featureIds[firstCell] = featureId;
|
||||
|
||||
const land = heights[firstCell] >= 20;
|
||||
let border = false; // set true if feature touches map edge
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (!border && borderCells[cellId]) border = true;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
const isNeibLand = heights[neighborId] >= 20;
|
||||
|
||||
if (land === isNeibLand && featureIds[neighborId] === UNMARKED) {
|
||||
featureIds[neighborId] = featureId;
|
||||
queue.push(neighborId);
|
||||
} else if (land && !isNeibLand) {
|
||||
distanceField[cellId] = LAND_COAST;
|
||||
distanceField[neighborId] = WATER_COAST;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const type = land ? "island" : border ? "ocean" : "lake";
|
||||
features.push({i: featureId, land, border, type});
|
||||
|
||||
queue[0] = featureIds.findIndex(f => f === UNMARKED); // find unmarked cell
|
||||
}
|
||||
|
||||
// markup deep ocean cells
|
||||
markup({distanceField, neighbors, start: DEEP_WATER, increment: -1, limit: -10});
|
||||
|
||||
const updatedGrid = {
|
||||
...grid,
|
||||
cells: {
|
||||
...grid.cells,
|
||||
t: distanceField,
|
||||
f: featureIds
|
||||
},
|
||||
features
|
||||
};
|
||||
|
||||
TIME && console.timeEnd("markupGrid");
|
||||
|
||||
return updatedGrid;
|
||||
}
|
||||
|
||||
// mark Pack features (ocean, lakes, islands), calculate distance field and add properties
|
||||
export function markupPack(pack, grid, config, utils, modules) {
|
||||
const {TIME} = config;
|
||||
const {isLand, isWater, dist2, rn, clipPoly, unique, createTypedArray, connectVertices} = utils;
|
||||
const {Lakes} = modules;
|
||||
const {d3} = utils;
|
||||
|
||||
TIME && console.time("markupPack");
|
||||
|
||||
const {cells, vertices} = pack;
|
||||
const {c: neighbors, b: borderCells, i} = cells;
|
||||
const packCellsNumber = i.length;
|
||||
if (!packCellsNumber) return pack; // no cells -> there is nothing to do
|
||||
|
||||
const distanceField = new Int8Array(packCellsNumber); // pack.cells.t
|
||||
const featureIds = new Uint16Array(packCellsNumber); // pack.cells.f
|
||||
const haven = createTypedArray({maxValue: packCellsNumber, length: packCellsNumber}); // haven: opposite water cell
|
||||
const harbor = new Uint8Array(packCellsNumber); // harbor: number of adjacent water cells
|
||||
const features = [0];
|
||||
|
||||
const queue = [0];
|
||||
for (let featureId = 1; queue[0] !== -1; featureId++) {
|
||||
const firstCell = queue[0];
|
||||
featureIds[firstCell] = featureId;
|
||||
|
||||
const land = isLand(firstCell);
|
||||
let border = Boolean(borderCells[firstCell]); // true if feature touches map border
|
||||
let totalCells = 1; // count cells in a feature
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (borderCells[cellId]) border = true;
|
||||
if (!border && borderCells[cellId]) border = true;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
const isNeibLand = isLand(neighborId);
|
||||
|
||||
if (land && !isNeibLand) {
|
||||
distanceField[cellId] = LAND_COAST;
|
||||
distanceField[neighborId] = WATER_COAST;
|
||||
if (!haven[cellId]) defineHaven(cellId);
|
||||
} else if (land && isNeibLand) {
|
||||
if (distanceField[neighborId] === UNMARKED && distanceField[cellId] === LAND_COAST)
|
||||
distanceField[neighborId] = LANDLOCKED;
|
||||
else if (distanceField[cellId] === UNMARKED && distanceField[neighborId] === LAND_COAST)
|
||||
distanceField[cellId] = LANDLOCKED;
|
||||
}
|
||||
|
||||
if (!featureIds[neighborId] && land === isNeibLand) {
|
||||
queue.push(neighborId);
|
||||
featureIds[neighborId] = featureId;
|
||||
totalCells++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
features.push(addFeature({firstCell, land, border, featureId, totalCells}));
|
||||
queue[0] = featureIds.findIndex(f => f === UNMARKED); // find unmarked cell
|
||||
}
|
||||
|
||||
markup({distanceField, neighbors, start: DEEPER_LAND, increment: 1}); // markup pack land
|
||||
markup({distanceField, neighbors, start: DEEP_WATER, increment: -1, limit: -10}); // markup pack water
|
||||
|
||||
const updatedPack = {
|
||||
...pack,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
t: distanceField,
|
||||
f: featureIds,
|
||||
haven,
|
||||
harbor
|
||||
},
|
||||
features
|
||||
};
|
||||
|
||||
TIME && console.timeEnd("markupPack");
|
||||
|
||||
return updatedPack;
|
||||
|
||||
function defineHaven(cellId) {
|
||||
const waterCells = neighbors[cellId].filter(isWater);
|
||||
const distances = waterCells.map(neibCellId => dist2(cells.p[cellId], cells.p[neibCellId]));
|
||||
const closest = distances.indexOf(Math.min.apply(Math, distances));
|
||||
|
||||
haven[cellId] = waterCells[closest];
|
||||
harbor[cellId] = waterCells.length;
|
||||
}
|
||||
|
||||
function addFeature({firstCell, land, border, featureId, totalCells}) {
|
||||
const type = land ? "island" : border ? "ocean" : "lake";
|
||||
const [startCell, featureVertices] = getCellsData(type, firstCell);
|
||||
const points = clipPoly(featureVertices.map(vertex => vertices.p[vertex]));
|
||||
const area = d3.polygonArea(points); // feature perimiter area
|
||||
const absArea = Math.abs(rn(area));
|
||||
|
||||
const feature = {
|
||||
i: featureId,
|
||||
type,
|
||||
land,
|
||||
border,
|
||||
cells: totalCells,
|
||||
firstCell: startCell,
|
||||
vertices: featureVertices,
|
||||
area: absArea
|
||||
};
|
||||
|
||||
if (type === "lake") {
|
||||
if (area > 0) feature.vertices = feature.vertices.reverse();
|
||||
feature.shoreline = unique(feature.vertices.map(vertex => vertices.c[vertex].filter(isLand)).flat());
|
||||
feature.height = Lakes.getHeight(feature);
|
||||
}
|
||||
|
||||
return feature;
|
||||
|
||||
function getCellsData(featureType, firstCell) {
|
||||
if (featureType === "ocean") return [firstCell, []];
|
||||
|
||||
const getType = cellId => featureIds[cellId];
|
||||
const type = getType(firstCell);
|
||||
const ofSameType = cellId => getType(cellId) === type;
|
||||
const ofDifferentType = cellId => getType(cellId) !== type;
|
||||
|
||||
const startCell = findOnBorderCell(firstCell);
|
||||
const featureVertices = getFeatureVertices(startCell);
|
||||
return [startCell, featureVertices];
|
||||
|
||||
function findOnBorderCell(firstCell) {
|
||||
const isOnBorder = cellId => borderCells[cellId] || neighbors[cellId].some(ofDifferentType);
|
||||
if (isOnBorder(firstCell)) return firstCell;
|
||||
|
||||
const startCell = cells.i.filter(ofSameType).find(isOnBorder);
|
||||
if (startCell === undefined)
|
||||
throw new Error(`Markup: firstCell ${firstCell} is not on the feature or map border`);
|
||||
|
||||
return startCell;
|
||||
}
|
||||
|
||||
function getFeatureVertices(startCell) {
|
||||
const startingVertex = cells.v[startCell].find(v => vertices.c[v].some(ofDifferentType));
|
||||
if (startingVertex === undefined)
|
||||
throw new Error(`Markup: startingVertex for cell ${startCell} is not found`);
|
||||
|
||||
return connectVertices({vertices, startingVertex, ofSameType, closeRing: false});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// add properties to pack features
|
||||
export function specify(pack, grid, modules) {
|
||||
const {Lakes} = modules;
|
||||
const gridCellsNumber = grid.cells.i.length;
|
||||
const OCEAN_MIN_SIZE = gridCellsNumber / 25;
|
||||
const SEA_MIN_SIZE = gridCellsNumber / 1000;
|
||||
const CONTINENT_MIN_SIZE = gridCellsNumber / 10;
|
||||
const ISLAND_MIN_SIZE = gridCellsNumber / 1000;
|
||||
|
||||
const updatedFeatures = pack.features.map(feature => {
|
||||
if (!feature || feature.type === "ocean") return feature;
|
||||
|
||||
const updatedFeature = {
|
||||
...feature,
|
||||
group: defineGroup(feature)
|
||||
};
|
||||
|
||||
if (feature.type === "lake") {
|
||||
updatedFeature.height = Lakes.getHeight(feature);
|
||||
updatedFeature.name = Lakes.getName(feature);
|
||||
}
|
||||
|
||||
return updatedFeature;
|
||||
});
|
||||
|
||||
return {
|
||||
...pack,
|
||||
features: updatedFeatures
|
||||
};
|
||||
|
||||
function defineGroup(feature) {
|
||||
if (feature.type === "island") return defineIslandGroup(feature);
|
||||
if (feature.type === "ocean") return defineOceanGroup(feature);
|
||||
if (feature.type === "lake") return defineLakeGroup(feature);
|
||||
throw new Error(`Markup: unknown feature type ${feature.type}`);
|
||||
}
|
||||
|
||||
function defineOceanGroup(feature) {
|
||||
if (feature.cells > OCEAN_MIN_SIZE) return "ocean";
|
||||
if (feature.cells > SEA_MIN_SIZE) return "sea";
|
||||
return "gulf";
|
||||
}
|
||||
|
||||
function defineIslandGroup(feature) {
|
||||
const prevFeature = pack.features[pack.cells.f[feature.firstCell - 1]];
|
||||
if (prevFeature && prevFeature.type === "lake") return "lake_island";
|
||||
if (feature.cells > CONTINENT_MIN_SIZE) return "continent";
|
||||
if (feature.cells > ISLAND_MIN_SIZE) return "island";
|
||||
return "isle";
|
||||
}
|
||||
|
||||
function defineLakeGroup(feature) {
|
||||
if (feature.temp < -3) return "frozen";
|
||||
if (feature.height > 60 && feature.cells < 10 && feature.firstCell % 10 === 0) return "lava";
|
||||
|
||||
if (!feature.inlets && !feature.outlet) {
|
||||
if (feature.evaporation > feature.flux * 4) return "dry";
|
||||
if (feature.cells < 3 && feature.firstCell % 10 === 0) return "sinkhole";
|
||||
}
|
||||
|
||||
if (!feature.outlet && feature.evaporation > feature.flux) return "salt";
|
||||
|
||||
return "freshwater";
|
||||
}
|
||||
}
|
||||
37
procedural/src/engine/support/features_config.md
Normal file
37
procedural/src/engine/support/features_config.md
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
# Configuration Properties for features.js
|
||||
|
||||
## Analysis Results
|
||||
|
||||
After thorough analysis of the original `features.js` code, **no DOM-based configuration parameters were found**.
|
||||
|
||||
The original module does not contain any `byId()` calls or direct DOM reads that would need to be replaced with `config` object properties.
|
||||
|
||||
## Configuration Object Structure
|
||||
|
||||
The `config` object passed to the features module functions should contain:
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
// Timing and debugging
|
||||
TIME: boolean, // Enable/disable console timing logs
|
||||
|
||||
// Randomization
|
||||
seed: string|number, // Random seed for reproducible generation
|
||||
aleaPRNG: function // Pseudo-random number generator function
|
||||
};
|
||||
```
|
||||
|
||||
## Notes
|
||||
|
||||
- This module is purely computational and operates entirely on the provided data structures
|
||||
- All configuration is derived from the input `grid` and `pack` objects or calculated dynamically
|
||||
- No user interface input values are required for this module's operation
|
||||
- The module focuses on geometric and topological analysis of map features rather than user-configurable parameters
|
||||
|
||||
## Comparison with Other Modules
|
||||
|
||||
Unlike modules such as `burgs-and-states.js` which read values like `statesNumber` from the DOM, the `features.js` module:
|
||||
- Does not read any DOM elements
|
||||
- Does not require user input parameters
|
||||
- Operates purely on mathematical calculations and data structure analysis
|
||||
- Uses only internally calculated constants and thresholds
|
||||
51
procedural/src/engine/support/features_external.md
Normal file
51
procedural/src/engine/support/features_external.md
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
# External Dependencies for features.js
|
||||
|
||||
The refactored `features.js` module requires the following external dependencies to be imported:
|
||||
|
||||
## Module Dependencies
|
||||
|
||||
### `Lakes` module
|
||||
- **Functions used:**
|
||||
- `Lakes.getHeight(feature)` - Calculate height for lake features
|
||||
- `Lakes.getName(feature)` - Generate names for lake features
|
||||
|
||||
## Utility Functions Required
|
||||
|
||||
The following utility functions need to be passed via the `utils` parameter:
|
||||
|
||||
### Core Utilities
|
||||
- `INT8_MAX` - Maximum value for Int8 arrays
|
||||
- `rn(value)` - Rounding function
|
||||
- `isLand(cellId)` - Check if a cell is land
|
||||
- `isWater(cellId)` - Check if a cell is water
|
||||
- `dist2(point1, point2)` - Calculate squared distance between two points
|
||||
- `clipPoly(vertices)` - Clip polygon vertices
|
||||
- `unique(array)` - Remove duplicates from array
|
||||
- `createTypedArray({maxValue, length})` - Create appropriately typed array
|
||||
- `connectVertices({vertices, startingVertex, ofSameType, closeRing})` - Connect vertices to form paths
|
||||
|
||||
### D3.js Integration
|
||||
- `d3.polygonArea(points)` - Calculate polygon area (accessed via `utils.d3.polygonArea`)
|
||||
|
||||
## Configuration Dependencies
|
||||
|
||||
The following configuration values need to be passed via the `config` parameter:
|
||||
|
||||
### Timing and Randomization
|
||||
- `TIME` - Boolean flag to enable/disable timing logs
|
||||
- `seed` - Random seed value for reproducible generation
|
||||
- `aleaPRNG` - Pseudo-random number generator function
|
||||
|
||||
## Module Integration
|
||||
|
||||
The module should be imported and used as follows:
|
||||
|
||||
```javascript
|
||||
import { markupGrid, markupPack, specify } from './features.js';
|
||||
import { Lakes } from './lakes.js';
|
||||
|
||||
// Usage example
|
||||
const updatedGrid = markupGrid(grid, config, utils);
|
||||
const updatedPack = markupPack(pack, grid, config, utils, { Lakes });
|
||||
const finalPack = specify(updatedPack, grid, { Lakes });
|
||||
```
|
||||
353
procedural/src/engine/support/features_prompt.md
Normal file
353
procedural/src/engine/support/features_prompt.md
Normal file
|
|
@ -0,0 +1,353 @@
|
|||
# features.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
7. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
8. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `features.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Features = (function () {
|
||||
const DEEPER_LAND = 3;
|
||||
const LANDLOCKED = 2;
|
||||
const LAND_COAST = 1;
|
||||
const UNMARKED = 0;
|
||||
const WATER_COAST = -1;
|
||||
const DEEP_WATER = -2;
|
||||
|
||||
// calculate distance to coast for every cell
|
||||
function markup({distanceField, neighbors, start, increment, limit = INT8_MAX}) {
|
||||
for (let distance = start, marked = Infinity; marked > 0 && distance !== limit; distance += increment) {
|
||||
marked = 0;
|
||||
const prevDistance = distance - increment;
|
||||
for (let cellId = 0; cellId < neighbors.length; cellId++) {
|
||||
if (distanceField[cellId] !== prevDistance) continue;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
if (distanceField[neighborId] !== UNMARKED) continue;
|
||||
distanceField[neighborId] = distance;
|
||||
marked++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// mark Grid features (ocean, lakes, islands) and calculate distance field
|
||||
function markupGrid() {
|
||||
TIME && console.time("markupGrid");
|
||||
Math.random = aleaPRNG(seed); // get the same result on heightmap edit in Erase mode
|
||||
|
||||
const {h: heights, c: neighbors, b: borderCells, i} = grid.cells;
|
||||
const cellsNumber = i.length;
|
||||
const distanceField = new Int8Array(cellsNumber); // gird.cells.t
|
||||
const featureIds = new Uint16Array(cellsNumber); // gird.cells.f
|
||||
const features = [0];
|
||||
|
||||
const queue = [0];
|
||||
for (let featureId = 1; queue[0] !== -1; featureId++) {
|
||||
const firstCell = queue[0];
|
||||
featureIds[firstCell] = featureId;
|
||||
|
||||
const land = heights[firstCell] >= 20;
|
||||
let border = false; // set true if feature touches map edge
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (!border && borderCells[cellId]) border = true;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
const isNeibLand = heights[neighborId] >= 20;
|
||||
|
||||
if (land === isNeibLand && featureIds[neighborId] === UNMARKED) {
|
||||
featureIds[neighborId] = featureId;
|
||||
queue.push(neighborId);
|
||||
} else if (land && !isNeibLand) {
|
||||
distanceField[cellId] = LAND_COAST;
|
||||
distanceField[neighborId] = WATER_COAST;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const type = land ? "island" : border ? "ocean" : "lake";
|
||||
features.push({i: featureId, land, border, type});
|
||||
|
||||
queue[0] = featureIds.findIndex(f => f === UNMARKED); // find unmarked cell
|
||||
}
|
||||
|
||||
// markup deep ocean cells
|
||||
markup({distanceField, neighbors, start: DEEP_WATER, increment: -1, limit: -10});
|
||||
|
||||
grid.cells.t = distanceField;
|
||||
grid.cells.f = featureIds;
|
||||
grid.features = features;
|
||||
|
||||
TIME && console.timeEnd("markupGrid");
|
||||
}
|
||||
|
||||
// mark Pack features (ocean, lakes, islands), calculate distance field and add properties
|
||||
function markupPack() {
|
||||
TIME && console.time("markupPack");
|
||||
|
||||
const {cells, vertices} = pack;
|
||||
const {c: neighbors, b: borderCells, i} = cells;
|
||||
const packCellsNumber = i.length;
|
||||
if (!packCellsNumber) return; // no cells -> there is nothing to do
|
||||
|
||||
const distanceField = new Int8Array(packCellsNumber); // pack.cells.t
|
||||
const featureIds = new Uint16Array(packCellsNumber); // pack.cells.f
|
||||
const haven = createTypedArray({maxValue: packCellsNumber, length: packCellsNumber}); // haven: opposite water cell
|
||||
const harbor = new Uint8Array(packCellsNumber); // harbor: number of adjacent water cells
|
||||
const features = [0];
|
||||
|
||||
const queue = [0];
|
||||
for (let featureId = 1; queue[0] !== -1; featureId++) {
|
||||
const firstCell = queue[0];
|
||||
featureIds[firstCell] = featureId;
|
||||
|
||||
const land = isLand(firstCell);
|
||||
let border = Boolean(borderCells[firstCell]); // true if feature touches map border
|
||||
let totalCells = 1; // count cells in a feature
|
||||
|
||||
while (queue.length) {
|
||||
const cellId = queue.pop();
|
||||
if (borderCells[cellId]) border = true;
|
||||
if (!border && borderCells[cellId]) border = true;
|
||||
|
||||
for (const neighborId of neighbors[cellId]) {
|
||||
const isNeibLand = isLand(neighborId);
|
||||
|
||||
if (land && !isNeibLand) {
|
||||
distanceField[cellId] = LAND_COAST;
|
||||
distanceField[neighborId] = WATER_COAST;
|
||||
if (!haven[cellId]) defineHaven(cellId);
|
||||
} else if (land && isNeibLand) {
|
||||
if (distanceField[neighborId] === UNMARKED && distanceField[cellId] === LAND_COAST)
|
||||
distanceField[neighborId] = LANDLOCKED;
|
||||
else if (distanceField[cellId] === UNMARKED && distanceField[neighborId] === LAND_COAST)
|
||||
distanceField[cellId] = LANDLOCKED;
|
||||
}
|
||||
|
||||
if (!featureIds[neighborId] && land === isNeibLand) {
|
||||
queue.push(neighborId);
|
||||
featureIds[neighborId] = featureId;
|
||||
totalCells++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
features.push(addFeature({firstCell, land, border, featureId, totalCells}));
|
||||
queue[0] = featureIds.findIndex(f => f === UNMARKED); // find unmarked cell
|
||||
}
|
||||
|
||||
markup({distanceField, neighbors, start: DEEPER_LAND, increment: 1}); // markup pack land
|
||||
markup({distanceField, neighbors, start: DEEP_WATER, increment: -1, limit: -10}); // markup pack water
|
||||
|
||||
pack.cells.t = distanceField;
|
||||
pack.cells.f = featureIds;
|
||||
pack.cells.haven = haven;
|
||||
pack.cells.harbor = harbor;
|
||||
pack.features = features;
|
||||
|
||||
TIME && console.timeEnd("markupPack");
|
||||
|
||||
function defineHaven(cellId) {
|
||||
const waterCells = neighbors[cellId].filter(isWater);
|
||||
const distances = waterCells.map(neibCellId => dist2(cells.p[cellId], cells.p[neibCellId]));
|
||||
const closest = distances.indexOf(Math.min.apply(Math, distances));
|
||||
|
||||
haven[cellId] = waterCells[closest];
|
||||
harbor[cellId] = waterCells.length;
|
||||
}
|
||||
|
||||
function addFeature({firstCell, land, border, featureId, totalCells}) {
|
||||
const type = land ? "island" : border ? "ocean" : "lake";
|
||||
const [startCell, featureVertices] = getCellsData(type, firstCell);
|
||||
const points = clipPoly(featureVertices.map(vertex => vertices.p[vertex]));
|
||||
const area = d3.polygonArea(points); // feature perimiter area
|
||||
const absArea = Math.abs(rn(area));
|
||||
|
||||
const feature = {
|
||||
i: featureId,
|
||||
type,
|
||||
land,
|
||||
border,
|
||||
cells: totalCells,
|
||||
firstCell: startCell,
|
||||
vertices: featureVertices,
|
||||
area: absArea
|
||||
};
|
||||
|
||||
if (type === "lake") {
|
||||
if (area > 0) feature.vertices = feature.vertices.reverse();
|
||||
feature.shoreline = unique(feature.vertices.map(vertex => vertices.c[vertex].filter(isLand)).flat());
|
||||
feature.height = Lakes.getHeight(feature);
|
||||
}
|
||||
|
||||
return feature;
|
||||
|
||||
function getCellsData(featureType, firstCell) {
|
||||
if (featureType === "ocean") return [firstCell, []];
|
||||
|
||||
const getType = cellId => featureIds[cellId];
|
||||
const type = getType(firstCell);
|
||||
const ofSameType = cellId => getType(cellId) === type;
|
||||
const ofDifferentType = cellId => getType(cellId) !== type;
|
||||
|
||||
const startCell = findOnBorderCell(firstCell);
|
||||
const featureVertices = getFeatureVertices(startCell);
|
||||
return [startCell, featureVertices];
|
||||
|
||||
function findOnBorderCell(firstCell) {
|
||||
const isOnBorder = cellId => borderCells[cellId] || neighbors[cellId].some(ofDifferentType);
|
||||
if (isOnBorder(firstCell)) return firstCell;
|
||||
|
||||
const startCell = cells.i.filter(ofSameType).find(isOnBorder);
|
||||
if (startCell === undefined)
|
||||
throw new Error(`Markup: firstCell ${firstCell} is not on the feature or map border`);
|
||||
|
||||
return startCell;
|
||||
}
|
||||
|
||||
function getFeatureVertices(startCell) {
|
||||
const startingVertex = cells.v[startCell].find(v => vertices.c[v].some(ofDifferentType));
|
||||
if (startingVertex === undefined)
|
||||
throw new Error(`Markup: startingVertex for cell ${startCell} is not found`);
|
||||
|
||||
return connectVertices({vertices, startingVertex, ofSameType, closeRing: false});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// add properties to pack features
|
||||
function specify() {
|
||||
const gridCellsNumber = grid.cells.i.length;
|
||||
const OCEAN_MIN_SIZE = gridCellsNumber / 25;
|
||||
const SEA_MIN_SIZE = gridCellsNumber / 1000;
|
||||
const CONTINENT_MIN_SIZE = gridCellsNumber / 10;
|
||||
const ISLAND_MIN_SIZE = gridCellsNumber / 1000;
|
||||
|
||||
for (const feature of pack.features) {
|
||||
if (!feature || feature.type === "ocean") continue;
|
||||
|
||||
feature.group = defineGroup(feature);
|
||||
|
||||
if (feature.type === "lake") {
|
||||
feature.height = Lakes.getHeight(feature);
|
||||
feature.name = Lakes.getName(feature);
|
||||
}
|
||||
}
|
||||
|
||||
function defineGroup(feature) {
|
||||
if (feature.type === "island") return defineIslandGroup(feature);
|
||||
if (feature.type === "ocean") return defineOceanGroup();
|
||||
if (feature.type === "lake") return defineLakeGroup(feature);
|
||||
throw new Error(`Markup: unknown feature type ${feature.type}`);
|
||||
}
|
||||
|
||||
function defineOceanGroup(feature) {
|
||||
if (feature.cells > OCEAN_MIN_SIZE) return "ocean";
|
||||
if (feature.cells > SEA_MIN_SIZE) return "sea";
|
||||
return "gulf";
|
||||
}
|
||||
|
||||
function defineIslandGroup(feature) {
|
||||
const prevFeature = pack.features[pack.cells.f[feature.firstCell - 1]];
|
||||
if (prevFeature && prevFeature.type === "lake") return "lake_island";
|
||||
if (feature.cells > CONTINENT_MIN_SIZE) return "continent";
|
||||
if (feature.cells > ISLAND_MIN_SIZE) return "island";
|
||||
return "isle";
|
||||
}
|
||||
|
||||
function defineLakeGroup(feature) {
|
||||
if (feature.temp < -3) return "frozen";
|
||||
if (feature.height > 60 && feature.cells < 10 && feature.firstCell % 10 === 0) return "lava";
|
||||
|
||||
if (!feature.inlets && !feature.outlet) {
|
||||
if (feature.evaporation > feature.flux * 4) return "dry";
|
||||
if (feature.cells < 3 && feature.firstCell % 10 === 0) return "sinkhole";
|
||||
}
|
||||
|
||||
if (!feature.outlet && feature.evaporation > feature.flux) return "salt";
|
||||
|
||||
return "freshwater";
|
||||
}
|
||||
}
|
||||
|
||||
return {markupGrid, markupPack, specify};
|
||||
})();
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./features.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./features_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in features_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into features_render.md
|
||||
46
procedural/src/engine/support/features_render.md
Normal file
46
procedural/src/engine/support/features_render.md
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
# Removed Rendering/UI Logic from features.js
|
||||
|
||||
## Analysis Results
|
||||
|
||||
After thorough analysis of the original `features.js` code, **no DOM manipulation or SVG rendering logic was found**.
|
||||
|
||||
## What Was Analyzed
|
||||
|
||||
The analysis looked for the following types of rendering/UI code:
|
||||
- `d3.select()` calls for DOM manipulation
|
||||
- `document.getElementById()` or similar DOM queries
|
||||
- Direct DOM element creation (e.g., creating `<path>` elements)
|
||||
- SVG rendering commands
|
||||
- Direct DOM property assignments (e.g., `element.innerHTML = ...`)
|
||||
- Canvas drawing operations
|
||||
|
||||
## Findings
|
||||
|
||||
The `features.js` module is purely computational and contains:
|
||||
- Mathematical calculations for distance fields
|
||||
- Geometric analysis of map features (islands, lakes, oceans)
|
||||
- Data structure operations and transformations
|
||||
- Feature classification and property assignment
|
||||
|
||||
## No Rendering Logic Removed
|
||||
|
||||
**No code blocks were removed** from the original module because:
|
||||
- The module does not contain any rendering or DOM manipulation code
|
||||
- All functionality is related to data processing and analysis
|
||||
- The module operates entirely on data structures without visual output
|
||||
|
||||
## Viewer Application Responsibilities
|
||||
|
||||
Since no rendering logic was present in the original module, the Viewer application will need to implement its own rendering logic for:
|
||||
- Visualizing the calculated distance fields
|
||||
- Rendering feature boundaries and classifications
|
||||
- Displaying feature properties and labels
|
||||
- Creating SVG paths for islands, lakes, and ocean features
|
||||
|
||||
## Module Purity
|
||||
|
||||
This module exemplifies the ideal separation of concerns where:
|
||||
- **Engine**: Pure computational logic (this module)
|
||||
- **Viewer**: All rendering and visualization (to be implemented separately)
|
||||
|
||||
The refactored module maintains this separation by focusing exclusively on data generation and analysis.
|
||||
20
procedural/src/engine/support/fonts_config.md
Normal file
20
procedural/src/engine/support/fonts_config.md
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
# Config Properties for fonts.js
|
||||
|
||||
## Config Properties Identified: None
|
||||
|
||||
The original `fonts.js` module did **not contain any DOM reads** that required configuration properties.
|
||||
|
||||
## Analysis
|
||||
|
||||
The original code had the following characteristics:
|
||||
- No `byId()` calls to read DOM input values
|
||||
- No configuration parameters read from UI elements
|
||||
- All font data was hardcoded in the fonts array
|
||||
- Functions operated on provided data parameters rather than reading global configuration
|
||||
|
||||
## Notes
|
||||
|
||||
- The refactored module is purely data-driven and functional
|
||||
- All necessary data is passed as function parameters (e.g., `svgData` in `getUsedFonts()`)
|
||||
- No configuration object is needed for this module
|
||||
- The module provides utility functions that work with any font data provided to them
|
||||
16
procedural/src/engine/support/fonts_external.md
Normal file
16
procedural/src/engine/support/fonts_external.md
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
# External Dependencies for fonts.js
|
||||
|
||||
The refactored `fonts.js` module has **no external engine dependencies**.
|
||||
|
||||
## Imports Required: None
|
||||
|
||||
The fonts module is completely self-contained and only depends on:
|
||||
- Standard JavaScript APIs (fetch, Promise, FileReader)
|
||||
- Browser APIs (when running in browser environment)
|
||||
|
||||
## Notes
|
||||
|
||||
- The module provides pure utility functions for font management
|
||||
- All font data is embedded directly in the module
|
||||
- No dependencies on other engine modules like Names, COA, etc.
|
||||
- Network requests are handled internally via fetch API for Google Fonts
|
||||
477
procedural/src/engine/support/fonts_prompt.md
Normal file
477
procedural/src/engine/support/fonts_prompt.md
Normal file
|
|
@ -0,0 +1,477 @@
|
|||
# fonts.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `fonts.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
const fonts = [
|
||||
{family: "Arial"},
|
||||
{family: "Brush Script MT"},
|
||||
{family: "Century Gothic"},
|
||||
{family: "Comic Sans MS"},
|
||||
{family: "Copperplate"},
|
||||
{family: "Courier New"},
|
||||
{family: "Garamond"},
|
||||
{family: "Georgia"},
|
||||
{family: "Herculanum"},
|
||||
{family: "Impact"},
|
||||
{family: "Papyrus"},
|
||||
{family: "Party LET"},
|
||||
{family: "Times New Roman"},
|
||||
{family: "Verdana"},
|
||||
{
|
||||
family: "Almendra SC",
|
||||
src: "url(https://fonts.gstatic.com/s/almendrasc/v13/Iure6Yx284eebowr7hbyTaZOrLQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Amarante",
|
||||
src: "url(https://fonts.gstatic.com/s/amarante/v22/xMQXuF1KTa6EvGx9bp-wAXs.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Amatic SC",
|
||||
src: "url(https://fonts.gstatic.com/s/amaticsc/v11/TUZ3zwprpvBS1izr_vOMscGKfrUC.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Arima Madurai",
|
||||
src: "url(https://fonts.gstatic.com/s/arimamadurai/v14/t5tmIRoeKYORG0WNMgnC3seB3T7Prw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Architects Daughter",
|
||||
src: "url(https://fonts.gstatic.com/s/architectsdaughter/v8/RXTgOOQ9AAtaVOHxx0IUBM3t7GjCYufj5TXV5VnA2p8.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Bitter",
|
||||
src: "url(https://fonts.gstatic.com/s/bitter/v12/zfs6I-5mjWQ3nxqccMoL2A.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Caesar Dressing",
|
||||
src: "url(https://fonts.gstatic.com/s/caesardressing/v6/yYLx0hLa3vawqtwdswbotmK4vrRHdrz7.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Cinzel",
|
||||
src: "url(https://fonts.gstatic.com/s/cinzel/v7/zOdksD_UUTk1LJF9z4tURA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Dancing Script",
|
||||
src: "url(https://fonts.gstatic.com/s/dancingscript/v9/KGBfwabt0ZRLA5W1ywjowUHdOuSHeh0r6jGTOGdAKHA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Eagle Lake",
|
||||
src: "url(https://fonts.gstatic.com/s/eaglelake/v24/ptRMTiqbbuNJDOiKj9wG1On4KCFtpe4.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Faster One",
|
||||
src: "url(https://fonts.gstatic.com/s/fasterone/v17/H4ciBXCHmdfClFb-vWhf-LyYhw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Forum",
|
||||
src: "url(https://fonts.gstatic.com/s/forum/v16/6aey4Ky-Vb8Ew8IROpI.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Fredericka the Great",
|
||||
src: "url(https://fonts.gstatic.com/s/frederickathegreat/v6/9Bt33CxNwt7aOctW2xjbCstzwVKsIBVV--Sjxbc.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Gloria Hallelujah",
|
||||
src: "url(https://fonts.gstatic.com/s/gloriahallelujah/v9/CA1k7SlXcY5kvI81M_R28cNDay8z-hHR7F16xrcXsJw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Great Vibes",
|
||||
src: "url(https://fonts.gstatic.com/s/greatvibes/v5/6q1c0ofG6NKsEhAc2eh-3Y4P5ICox8Kq3LLUNMylGO4.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Henny Penny",
|
||||
src: "url(https://fonts.gstatic.com/s/hennypenny/v17/wXKvE3UZookzsxz_kjGSfPQtvXI.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "IM Fell English",
|
||||
src: "url(https://fonts.gstatic.com/s/imfellenglish/v7/xwIisCqGFi8pff-oa9uSVAkYLEKE0CJQa8tfZYc_plY.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Kelly Slab",
|
||||
src: "url(https://fonts.gstatic.com/s/kellyslab/v15/-W_7XJX0Rz3cxUnJC5t6fkQLfg.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Kranky",
|
||||
src: "url(https://fonts.gstatic.com/s/kranky/v24/hESw6XVgJzlPsFn8oR2F.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Lobster Two",
|
||||
src: "url(https://fonts.gstatic.com/s/lobstertwo/v18/BngMUXZGTXPUvIoyV6yN5-fN5qU.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Lugrasimo",
|
||||
src: "url(https://fonts.gstatic.com/s/lugrasimo/v4/qkBXXvoF_s_eT9c7Y7au455KsgbLMA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Kaushan Script",
|
||||
src: "url(https://fonts.gstatic.com/s/kaushanscript/v6/qx1LSqts-NtiKcLw4N03IEd0sm1ffa_JvZxsF_BEwQk.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Macondo",
|
||||
src: "url(https://fonts.gstatic.com/s/macondo/v21/RrQQboN9-iB1IXmOe2LE0Q.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "MedievalSharp",
|
||||
src: "url(https://fonts.gstatic.com/s/medievalsharp/v9/EvOJzAlL3oU5AQl2mP5KdgptMqhwMg.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Metal Mania",
|
||||
src: "url(https://fonts.gstatic.com/s/metalmania/v22/RWmMoKWb4e8kqMfBUdPFJdXFiaQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Metamorphous",
|
||||
src: "url(https://fonts.gstatic.com/s/metamorphous/v7/Wnz8HA03aAXcC39ZEX5y133EOyqs.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Montez",
|
||||
src: "url(https://fonts.gstatic.com/s/montez/v8/aq8el3-0osHIcFK6bXAPkw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Nova Script",
|
||||
src: "url(https://fonts.gstatic.com/s/novascript/v10/7Au7p_IpkSWSTWaFWkumvlQKGFw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Orbitron",
|
||||
src: "url(https://fonts.gstatic.com/s/orbitron/v9/HmnHiRzvcnQr8CjBje6GQvesZW2xOQ-xsNqO47m55DA.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Oregano",
|
||||
src: "url(https://fonts.gstatic.com/s/oregano/v13/If2IXTPxciS3H4S2oZDVPg.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Pirata One",
|
||||
src: "url(https://fonts.gstatic.com/s/pirataone/v22/I_urMpiDvgLdLh0fAtofhi-Org.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Sail",
|
||||
src: "url(https://fonts.gstatic.com/s/sail/v16/DPEjYwiBxwYJJBPJAQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Satisfy",
|
||||
src: "url(https://fonts.gstatic.com/s/satisfy/v8/2OzALGYfHwQjkPYWELy-cw.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Shadows Into Light",
|
||||
src: "url(https://fonts.gstatic.com/s/shadowsintolight/v7/clhLqOv7MXn459PTh0gXYFK2TSYBz0eNcHnp4YqE4Ts.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
},
|
||||
{
|
||||
family: "Tapestry",
|
||||
src: "url(https://fonts.gstatic.com/s/macondo/v21/RrQQboN9-iB1IXmOe2LE0Q.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Uncial Antiqua",
|
||||
src: "url(https://fonts.gstatic.com/s/uncialantiqua/v5/N0bM2S5WOex4OUbESzoESK-i-MfWQZQ.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Underdog",
|
||||
src: "url(https://fonts.gstatic.com/s/underdog/v6/CHygV-jCElj7diMroWSlWV8.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "UnifrakturMaguntia",
|
||||
src: "url(https://fonts.gstatic.com/s/unifrakturmaguntia/v16/WWXPlieVYwiGNomYU-ciRLRvEmK7oaVemGZM.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD"
|
||||
},
|
||||
{
|
||||
family: "Yellowtail",
|
||||
src: "url(https://fonts.gstatic.com/s/yellowtail/v8/GcIHC9QEwVkrA19LJU1qlPk_vArhqVIZ0nv9q090hN8.woff2)",
|
||||
unicodeRange:
|
||||
"U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215"
|
||||
}
|
||||
];
|
||||
|
||||
declareDefaultFonts(); // execute once on load
|
||||
|
||||
function declareFont(font) {
|
||||
const {family, src, ...rest} = font;
|
||||
addFontOption(family);
|
||||
|
||||
if (!src) return;
|
||||
const fontFace = new FontFace(family, src, {...rest, display: "block"});
|
||||
document.fonts.add(fontFace);
|
||||
}
|
||||
|
||||
function declareDefaultFonts() {
|
||||
fonts.forEach(font => declareFont(font));
|
||||
}
|
||||
|
||||
function getUsedFonts(svg) {
|
||||
const usedFontFamilies = new Set();
|
||||
|
||||
const labelGroups = svg.querySelectorAll("#labels g");
|
||||
for (const labelGroup of labelGroups) {
|
||||
const font = labelGroup.getAttribute("font-family");
|
||||
if (font) usedFontFamilies.add(font);
|
||||
}
|
||||
|
||||
const provinceFont = provs.attr("font-family");
|
||||
if (provinceFont) usedFontFamilies.add(provinceFont);
|
||||
|
||||
const legend = svg.querySelector("#legend");
|
||||
const legendFont = legend?.getAttribute("font-family");
|
||||
if (legendFont) usedFontFamilies.add(legendFont);
|
||||
|
||||
const usedFonts = fonts.filter(font => usedFontFamilies.has(font.family));
|
||||
return usedFonts;
|
||||
}
|
||||
|
||||
function addFontOption(family) {
|
||||
const options = document.getElementById("styleSelectFont");
|
||||
const option = document.createElement("option");
|
||||
option.value = family;
|
||||
option.innerText = family;
|
||||
option.style.fontFamily = family;
|
||||
options.add(option);
|
||||
}
|
||||
|
||||
async function fetchGoogleFont(family) {
|
||||
const url = `https://fonts.googleapis.com/css2?family=${family.replace(/ /g, "+")}`;
|
||||
try {
|
||||
const resp = await fetch(url);
|
||||
const text = await resp.text();
|
||||
|
||||
const fontFaceRules = text.match(/font-face\s*{[^}]+}/g);
|
||||
const fonts = fontFaceRules.map(fontFace => {
|
||||
const srcURL = fontFace.match(/url\(['"]?(.+?)['"]?\)/)[1];
|
||||
const src = `url(${srcURL})`;
|
||||
const unicodeRange = fontFace.match(/unicode-range: (.*?);/)?.[1];
|
||||
const variant = fontFace.match(/font-style: (.*?);/)?.[1];
|
||||
|
||||
const font = {family, src};
|
||||
if (unicodeRange) font.unicodeRange = unicodeRange;
|
||||
if (variant && variant !== "normal") font.variant = variant;
|
||||
return font;
|
||||
});
|
||||
|
||||
return fonts;
|
||||
} catch (err) {
|
||||
ERROR && console.error(err);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function readBlobAsDataURL(blob) {
|
||||
return new Promise(function (resolve, reject) {
|
||||
const reader = new FileReader();
|
||||
reader.onloadend = () => resolve(reader.result);
|
||||
reader.onerror = reject;
|
||||
reader.readAsDataURL(blob);
|
||||
});
|
||||
}
|
||||
|
||||
async function loadFontsAsDataURI(fonts) {
|
||||
const promises = fonts.map(async font => {
|
||||
const url = font.src.match(/url\(['"]?(.+?)['"]?\)/)[1];
|
||||
const resp = await fetch(url);
|
||||
const blob = await resp.blob();
|
||||
const dataURL = await readBlobAsDataURL(blob);
|
||||
|
||||
return {...font, src: `url('${dataURL}')`};
|
||||
});
|
||||
|
||||
return await Promise.all(promises);
|
||||
}
|
||||
|
||||
async function addGoogleFont(family) {
|
||||
const fontRanges = await fetchGoogleFont(family);
|
||||
if (!fontRanges) return tip("Cannot fetch Google font for this value", true, "error", 4000);
|
||||
tip(`Google font ${family} is loading...`, true, "warn", 4000);
|
||||
|
||||
const promises = fontRanges.map(range => {
|
||||
const {src, unicodeRange, variant} = range;
|
||||
const fontFace = new FontFace(family, src, {unicodeRange, variant, display: "block"});
|
||||
return fontFace.load();
|
||||
});
|
||||
|
||||
Promise.all(promises)
|
||||
.then(fontFaces => {
|
||||
fontFaces.forEach(fontFace => document.fonts.add(fontFace));
|
||||
fonts.push(...fontRanges);
|
||||
tip(`Google font ${family} is added to the list`, true, "success", 4000);
|
||||
addFontOption(family);
|
||||
document.getElementById("styleSelectFont").value = family;
|
||||
changeFont();
|
||||
})
|
||||
.catch(err => {
|
||||
tip(`Failed to load Google font ${family}`, true, "error", 4000);
|
||||
ERROR && console.error(err);
|
||||
});
|
||||
}
|
||||
|
||||
function addLocalFont(family) {
|
||||
fonts.push({family});
|
||||
|
||||
const fontFace = new FontFace(family, `local(${family})`, {display: "block"});
|
||||
document.fonts.add(fontFace);
|
||||
tip(`Local font ${family} is added to the fonts list`, true, "success", 4000);
|
||||
addFontOption(family);
|
||||
document.getElementById("styleSelectFont").value = family;
|
||||
changeFont();
|
||||
}
|
||||
|
||||
function addWebFont(family, url) {
|
||||
const src = `url('${url}')`;
|
||||
fonts.push({family, src});
|
||||
|
||||
const fontFace = new FontFace(family, src, {display: "block"});
|
||||
document.fonts.add(fontFace);
|
||||
tip(`Font ${family} is added to the list`, true, "success", 4000);
|
||||
addFontOption(family);
|
||||
document.getElementById("styleSelectFont").value = family;
|
||||
changeFont();
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./fonts.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./fonts_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in fonts_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into fonts_render.md
|
||||
134
procedural/src/engine/support/fonts_render.md
Normal file
134
procedural/src/engine/support/fonts_render.md
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
# Removed Rendering/UI Logic from fonts.js
|
||||
|
||||
The following code blocks related to DOM manipulation and UI rendering have been **removed** from the engine module and should be moved to the Viewer application:
|
||||
|
||||
## 1. Font Option DOM Manipulation
|
||||
|
||||
```javascript
|
||||
function addFontOption(family) {
|
||||
const options = document.getElementById("styleSelectFont");
|
||||
const option = document.createElement("option");
|
||||
option.value = family;
|
||||
option.innerText = family;
|
||||
option.style.fontFamily = family;
|
||||
options.add(option);
|
||||
}
|
||||
```
|
||||
|
||||
## 2. DOM Font Registration
|
||||
|
||||
```javascript
|
||||
function declareFont(font) {
|
||||
const {family, src, ...rest} = font;
|
||||
addFontOption(family); // <- UI logic
|
||||
|
||||
if (!src) return;
|
||||
const fontFace = new FontFace(family, src, {...rest, display: "block"});
|
||||
document.fonts.add(fontFace); // <- Browser-specific DOM API
|
||||
}
|
||||
|
||||
function declareDefaultFonts() {
|
||||
fonts.forEach(font => declareFont(font)); // <- Uses DOM
|
||||
}
|
||||
|
||||
// Auto-execution on load
|
||||
declareDefaultFonts(); // execute once on load
|
||||
```
|
||||
|
||||
## 3. SVG DOM Querying
|
||||
|
||||
```javascript
|
||||
function getUsedFonts(svg) {
|
||||
const usedFontFamilies = new Set();
|
||||
|
||||
// Direct DOM querying - moved to viewer
|
||||
const labelGroups = svg.querySelectorAll("#labels g");
|
||||
for (const labelGroup of labelGroups) {
|
||||
const font = labelGroup.getAttribute("font-family");
|
||||
if (font) usedFontFamilies.add(font);
|
||||
}
|
||||
|
||||
// Global variable access
|
||||
const provinceFont = provs.attr("font-family");
|
||||
if (provinceFont) usedFontFamilies.add(provinceFont);
|
||||
|
||||
// Direct DOM querying
|
||||
const legend = svg.querySelector("#legend");
|
||||
const legendFont = legend?.getAttribute("font-family");
|
||||
if (legendFont) usedFontFamilies.add(legendFont);
|
||||
|
||||
const usedFonts = fonts.filter(font => usedFontFamilies.has(font.family));
|
||||
return usedFonts;
|
||||
}
|
||||
```
|
||||
|
||||
## 4. UI Notification and Interaction Logic
|
||||
|
||||
```javascript
|
||||
// From addGoogleFont function
|
||||
async function addGoogleFont(family) {
|
||||
const fontRanges = await fetchGoogleFont(family);
|
||||
if (!fontRanges) return tip("Cannot fetch Google font for this value", true, "error", 4000);
|
||||
tip(`Google font ${family} is loading...`, true, "warn", 4000);
|
||||
|
||||
// ... font loading logic ...
|
||||
|
||||
Promise.all(promises)
|
||||
.then(fontFaces => {
|
||||
fontFaces.forEach(fontFace => document.fonts.add(fontFace)); // <- DOM manipulation
|
||||
fonts.push(...fontRanges);
|
||||
tip(`Google font ${family} is added to the list`, true, "success", 4000); // <- UI notification
|
||||
addFontOption(family); // <- DOM manipulation
|
||||
document.getElementById("styleSelectFont").value = family; // <- DOM manipulation
|
||||
changeFont(); // <- UI callback
|
||||
})
|
||||
.catch(err => {
|
||||
tip(`Failed to load Google font ${family}`, true, "error", 4000); // <- UI notification
|
||||
ERROR && console.error(err);
|
||||
});
|
||||
}
|
||||
|
||||
// From addLocalFont function
|
||||
function addLocalFont(family) {
|
||||
fonts.push({family});
|
||||
|
||||
const fontFace = new FontFace(family, `local(${family})`, {display: "block"});
|
||||
document.fonts.add(fontFace); // <- DOM manipulation
|
||||
tip(`Local font ${family} is added to the fonts list`, true, "success", 4000); // <- UI notification
|
||||
addFontOption(family); // <- DOM manipulation
|
||||
document.getElementById("styleSelectFont").value = family; // <- DOM manipulation
|
||||
changeFont(); // <- UI callback
|
||||
}
|
||||
|
||||
// From addWebFont function
|
||||
function addWebFont(family, url) {
|
||||
const src = `url('${url}')`;
|
||||
fonts.push({family, src});
|
||||
|
||||
const fontFace = new FontFace(family, src, {display: "block"});
|
||||
document.fonts.add(fontFace); // <- DOM manipulation
|
||||
tip(`Font ${family} is added to the list`, true, "success", 4000); // <- UI notification
|
||||
addFontOption(family); // <- DOM manipulation
|
||||
document.getElementById("styleSelectFont").value = family; // <- DOM manipulation
|
||||
changeFont(); // <- UI callback
|
||||
}
|
||||
```
|
||||
|
||||
## 5. Global Variable Dependencies
|
||||
|
||||
- Access to `provs` global variable
|
||||
- Calls to `tip()` function for UI notifications
|
||||
- Calls to `changeFont()` function for UI updates
|
||||
- Access to `ERROR` global flag
|
||||
|
||||
## Summary
|
||||
|
||||
All DOM manipulation, UI notification, browser font registration, and SVG querying logic has been removed. The refactored engine module now provides pure data processing functions that the Viewer can use to:
|
||||
|
||||
1. Get available fonts
|
||||
2. Determine used fonts from SVG data structure
|
||||
3. Fetch Google Font definitions
|
||||
4. Load fonts as data URIs
|
||||
5. Create font definitions
|
||||
|
||||
The Viewer application should handle all DOM interactions, UI updates, and browser-specific font registration.
|
||||
542
procedural/src/engine/support/heightmap-generator.txt
Normal file
542
procedural/src/engine/support/heightmap-generator.txt
Normal file
|
|
@ -0,0 +1,542 @@
|
|||
"use strict";
|
||||
|
||||
export function generate(graph, config, utils) {
|
||||
const { aleaPRNG, createTypedArray, findGridCell, getNumberInRange, lim, minmax, rand, P, d3, heightmapTemplates, TIME } = utils;
|
||||
const { templateId, seed, graphWidth, graphHeight } = config;
|
||||
|
||||
TIME && console.time("defineHeightmap");
|
||||
|
||||
Math.random = aleaPRNG(seed);
|
||||
const isTemplate = templateId in heightmapTemplates;
|
||||
const heights = isTemplate ? fromTemplate(graph, templateId, config, utils) : null;
|
||||
|
||||
TIME && console.timeEnd("defineHeightmap");
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function fromTemplate(graph, id, config, utils) {
|
||||
const { heightmapTemplates } = utils;
|
||||
const templateString = heightmapTemplates[id]?.template || "";
|
||||
const steps = templateString.split("\n");
|
||||
|
||||
if (!steps.length) throw new Error(`Heightmap template: no steps. Template: ${id}. Steps: ${steps}`);
|
||||
|
||||
let { heights, blobPower, linePower } = setGraph(graph, utils);
|
||||
|
||||
for (const step of steps) {
|
||||
const elements = step.trim().split(" ");
|
||||
if (elements.length < 2) throw new Error(`Heightmap template: steps < 2. Template: ${id}. Step: ${elements}`);
|
||||
heights = addStep(heights, graph, blobPower, linePower, config, utils, ...elements);
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
function setGraph(graph, utils) {
|
||||
const { createTypedArray } = utils;
|
||||
const { cellsDesired, cells, points } = graph;
|
||||
const heights = cells.h ? Uint8Array.from(cells.h) : createTypedArray({ maxValue: 100, length: points.length });
|
||||
const blobPower = getBlobPower(cellsDesired);
|
||||
const linePower = getLinePower(cellsDesired);
|
||||
|
||||
return { heights, blobPower, linePower };
|
||||
}
|
||||
|
||||
function addStep(heights, graph, blobPower, linePower, config, utils, tool, a2, a3, a4, a5) {
|
||||
if (tool === "Hill") return addHill(heights, graph, blobPower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Pit") return addPit(heights, graph, blobPower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Range") return addRange(heights, graph, linePower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Trough") return addTrough(heights, graph, linePower, config, utils, a2, a3, a4, a5);
|
||||
if (tool === "Strait") return addStrait(heights, graph, config, utils, a2, a3);
|
||||
if (tool === "Mask") return mask(heights, graph, config, utils, a2);
|
||||
if (tool === "Invert") return invert(heights, graph, config, utils, a2, a3);
|
||||
if (tool === "Add") return modify(heights, a3, +a2, 1);
|
||||
if (tool === "Multiply") return modify(heights, a3, 0, +a2);
|
||||
if (tool === "Smooth") return smooth(heights, graph, utils, a2);
|
||||
return heights;
|
||||
}
|
||||
|
||||
function getBlobPower(cells) {
|
||||
const blobPowerMap = {
|
||||
1000: 0.93,
|
||||
2000: 0.95,
|
||||
5000: 0.97,
|
||||
10000: 0.98,
|
||||
20000: 0.99,
|
||||
30000: 0.991,
|
||||
40000: 0.993,
|
||||
50000: 0.994,
|
||||
60000: 0.995,
|
||||
70000: 0.9955,
|
||||
80000: 0.996,
|
||||
90000: 0.9964,
|
||||
100000: 0.9973
|
||||
};
|
||||
return blobPowerMap[cells] || 0.98;
|
||||
}
|
||||
|
||||
function getLinePower(cells) {
|
||||
const linePowerMap = {
|
||||
1000: 0.75,
|
||||
2000: 0.77,
|
||||
5000: 0.79,
|
||||
10000: 0.81,
|
||||
20000: 0.82,
|
||||
30000: 0.83,
|
||||
40000: 0.84,
|
||||
50000: 0.86,
|
||||
60000: 0.87,
|
||||
70000: 0.88,
|
||||
80000: 0.91,
|
||||
90000: 0.92,
|
||||
100000: 0.93
|
||||
};
|
||||
|
||||
return linePowerMap[cells] || 0.81;
|
||||
}
|
||||
|
||||
export function addHill(heights, graph, blobPower, config, utils, count, height, rangeX, rangeY) {
|
||||
const { getNumberInRange, lim, findGridCell } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOneHill();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneHill() {
|
||||
const change = new Uint8Array(heights.length);
|
||||
let limit = 0;
|
||||
let start;
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
do {
|
||||
const x = getPointInRange(rangeX, graphWidth, utils);
|
||||
const y = getPointInRange(rangeY, graphHeight, utils);
|
||||
start = findGridCell(x, y, graph);
|
||||
limit++;
|
||||
} while (heights[start] + h > 90 && limit < 50);
|
||||
|
||||
change[start] = h;
|
||||
const queue = [start];
|
||||
while (queue.length) {
|
||||
const q = queue.shift();
|
||||
|
||||
for (const c of graph.cells.c[q]) {
|
||||
if (change[c]) continue;
|
||||
change[c] = change[q] ** blobPower * (Math.random() * 0.2 + 0.9);
|
||||
if (change[c] > 1) queue.push(c);
|
||||
}
|
||||
}
|
||||
|
||||
heights = heights.map((h, i) => lim(h + change[i]));
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addPit(heights, graph, blobPower, config, utils, count, height, rangeX, rangeY) {
|
||||
const { getNumberInRange, lim, findGridCell } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOnePit();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOnePit() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let limit = 0,
|
||||
start;
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
do {
|
||||
const x = getPointInRange(rangeX, graphWidth, utils);
|
||||
const y = getPointInRange(rangeY, graphHeight, utils);
|
||||
start = findGridCell(x, y, graph);
|
||||
limit++;
|
||||
} while (heights[start] < 20 && limit < 50);
|
||||
|
||||
const queue = [start];
|
||||
while (queue.length) {
|
||||
const q = queue.shift();
|
||||
h = h ** blobPower * (Math.random() * 0.2 + 0.9);
|
||||
if (h < 1) return;
|
||||
|
||||
graph.cells.c[q].forEach(function (c, i) {
|
||||
if (used[c]) return;
|
||||
heights[c] = lim(heights[c] - h * (Math.random() * 0.2 + 0.9));
|
||||
used[c] = 1;
|
||||
queue.push(c);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addRange(heights, graph, linePower, config, utils, count, height, rangeX, rangeY, startCell, endCell) {
|
||||
const { getNumberInRange, lim, findGridCell, d3 } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOneRange();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneRange() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
if (rangeX && rangeY) {
|
||||
// find start and end points
|
||||
const startX = getPointInRange(rangeX, graphWidth, utils);
|
||||
const startY = getPointInRange(rangeY, graphHeight, utils);
|
||||
|
||||
let dist = 0,
|
||||
limit = 0,
|
||||
endX,
|
||||
endY;
|
||||
|
||||
do {
|
||||
endX = Math.random() * graphWidth * 0.8 + graphWidth * 0.1;
|
||||
endY = Math.random() * graphHeight * 0.7 + graphHeight * 0.15;
|
||||
dist = Math.abs(endY - startY) + Math.abs(endX - startX);
|
||||
limit++;
|
||||
} while ((dist < graphWidth / 8 || dist > graphWidth / 3) && limit < 50);
|
||||
|
||||
startCell = findGridCell(startX, startY, graph);
|
||||
endCell = findGridCell(endX, endY, graph);
|
||||
}
|
||||
|
||||
let range = getRange(startCell, endCell);
|
||||
|
||||
// get main ridge
|
||||
function getRange(cur, end) {
|
||||
const range = [cur];
|
||||
const p = graph.points;
|
||||
used[cur] = 1;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
graph.cells.c[cur].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.85) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
if (min === Infinity) return range;
|
||||
range.push(cur);
|
||||
used[cur] = 1;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
// add height to ridge and cells around
|
||||
let queue = range.slice(),
|
||||
i = 0;
|
||||
while (queue.length) {
|
||||
const frontier = queue.slice();
|
||||
(queue = []), i++;
|
||||
frontier.forEach(i => {
|
||||
heights[i] = lim(heights[i] + h * (Math.random() * 0.3 + 0.85));
|
||||
});
|
||||
h = h ** linePower - 1;
|
||||
if (h < 2) break;
|
||||
frontier.forEach(f => {
|
||||
graph.cells.c[f].forEach(i => {
|
||||
if (!used[i]) {
|
||||
queue.push(i);
|
||||
used[i] = 1;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// generate prominences
|
||||
range.forEach((cur, d) => {
|
||||
if (d % 6 !== 0) return;
|
||||
for (const l of d3.range(i)) {
|
||||
const min = graph.cells.c[cur][d3.scan(graph.cells.c[cur], (a, b) => heights[a] - heights[b])]; // downhill cell
|
||||
heights[min] = (heights[cur] * 2 + heights[min]) / 3;
|
||||
cur = min;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addTrough(heights, graph, linePower, config, utils, count, height, rangeX, rangeY, startCell, endCell) {
|
||||
const { getNumberInRange, lim, findGridCell, d3 } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
count = getNumberInRange(count);
|
||||
|
||||
while (count > 0) {
|
||||
addOneTrough();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneTrough() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
if (rangeX && rangeY) {
|
||||
// find start and end points
|
||||
let limit = 0,
|
||||
startX,
|
||||
startY,
|
||||
dist = 0,
|
||||
endX,
|
||||
endY;
|
||||
do {
|
||||
startX = getPointInRange(rangeX, graphWidth, utils);
|
||||
startY = getPointInRange(rangeY, graphHeight, utils);
|
||||
startCell = findGridCell(startX, startY, graph);
|
||||
limit++;
|
||||
} while (heights[startCell] < 20 && limit < 50);
|
||||
|
||||
limit = 0;
|
||||
do {
|
||||
endX = Math.random() * graphWidth * 0.8 + graphWidth * 0.1;
|
||||
endY = Math.random() * graphHeight * 0.7 + graphHeight * 0.15;
|
||||
dist = Math.abs(endY - startY) + Math.abs(endX - startX);
|
||||
limit++;
|
||||
} while ((dist < graphWidth / 8 || dist > graphWidth / 2) && limit < 50);
|
||||
|
||||
endCell = findGridCell(endX, endY, graph);
|
||||
}
|
||||
|
||||
let range = getRange(startCell, endCell);
|
||||
|
||||
// get main ridge
|
||||
function getRange(cur, end) {
|
||||
const range = [cur];
|
||||
const p = graph.points;
|
||||
used[cur] = 1;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
graph.cells.c[cur].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.8) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
if (min === Infinity) return range;
|
||||
range.push(cur);
|
||||
used[cur] = 1;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
// add height to ridge and cells around
|
||||
let queue = range.slice(),
|
||||
i = 0;
|
||||
while (queue.length) {
|
||||
const frontier = queue.slice();
|
||||
(queue = []), i++;
|
||||
frontier.forEach(i => {
|
||||
heights[i] = lim(heights[i] - h * (Math.random() * 0.3 + 0.85));
|
||||
});
|
||||
h = h ** linePower - 1;
|
||||
if (h < 2) break;
|
||||
frontier.forEach(f => {
|
||||
graph.cells.c[f].forEach(i => {
|
||||
if (!used[i]) {
|
||||
queue.push(i);
|
||||
used[i] = 1;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// generate prominences
|
||||
range.forEach((cur, d) => {
|
||||
if (d % 6 !== 0) return;
|
||||
for (const l of d3.range(i)) {
|
||||
const min = graph.cells.c[cur][d3.scan(graph.cells.c[cur], (a, b) => heights[a] - heights[b])]; // downhill cell
|
||||
//debug.append("circle").attr("cx", p[min][0]).attr("cy", p[min][1]).attr("r", 1);
|
||||
heights[min] = (heights[cur] * 2 + heights[min]) / 3;
|
||||
cur = min;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function addStrait(heights, graph, config, utils, width, direction = "vertical") {
|
||||
const { getNumberInRange, findGridCell, P } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
width = Math.min(getNumberInRange(width), graph.cellsX / 3);
|
||||
if (width < 1 && P(width)) return heights;
|
||||
|
||||
const used = new Uint8Array(heights.length);
|
||||
const vert = direction === "vertical";
|
||||
const startX = vert ? Math.floor(Math.random() * graphWidth * 0.4 + graphWidth * 0.3) : 5;
|
||||
const startY = vert ? 5 : Math.floor(Math.random() * graphHeight * 0.4 + graphHeight * 0.3);
|
||||
const endX = vert
|
||||
? Math.floor(graphWidth - startX - graphWidth * 0.1 + Math.random() * graphWidth * 0.2)
|
||||
: graphWidth - 5;
|
||||
const endY = vert
|
||||
? graphHeight - 5
|
||||
: Math.floor(graphHeight - startY - graphHeight * 0.1 + Math.random() * graphHeight * 0.2);
|
||||
|
||||
const start = findGridCell(startX, startY, graph);
|
||||
const end = findGridCell(endX, endY, graph);
|
||||
let range = getRange(start, end);
|
||||
const query = [];
|
||||
|
||||
function getRange(cur, end) {
|
||||
const range = [];
|
||||
const p = graph.points;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
graph.cells.c[cur].forEach(function (e) {
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.8) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
range.push(cur);
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
const step = 0.1 / width;
|
||||
|
||||
while (width > 0) {
|
||||
const exp = 0.9 - step * width;
|
||||
range.forEach(function (r) {
|
||||
graph.cells.c[r].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
used[e] = 1;
|
||||
query.push(e);
|
||||
heights[e] **= exp;
|
||||
if (heights[e] > 100) heights[e] = 5;
|
||||
});
|
||||
});
|
||||
range = query.slice();
|
||||
|
||||
width--;
|
||||
}
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function modify(heights, range, add, mult, power) {
|
||||
const { lim } = utils;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
const min = range === "land" ? 20 : range === "all" ? 0 : +range.split("-")[0];
|
||||
const max = range === "land" || range === "all" ? 100 : +range.split("-")[1];
|
||||
const isLand = min === 20;
|
||||
|
||||
heights = heights.map(h => {
|
||||
if (h < min || h > max) return h;
|
||||
|
||||
if (add) h = isLand ? Math.max(h + add, 20) : h + add;
|
||||
if (mult !== 1) h = isLand ? (h - 20) * mult + 20 : h * mult;
|
||||
if (power) h = isLand ? (h - 20) ** power + 20 : h ** power;
|
||||
return lim(h);
|
||||
});
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function smooth(heights, graph, utils, fr = 2, add = 0) {
|
||||
const { lim, d3 } = utils;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
heights = heights.map((h, i) => {
|
||||
const a = [h];
|
||||
graph.cells.c[i].forEach(c => a.push(heights[c]));
|
||||
if (fr === 1) return d3.mean(a) + add;
|
||||
return lim((h * (fr - 1) + d3.mean(a) + add) / fr);
|
||||
});
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function mask(heights, graph, config, utils, power = 1) {
|
||||
const { lim } = utils;
|
||||
const { graphWidth, graphHeight } = config;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
const fr = power ? Math.abs(power) : 1;
|
||||
|
||||
heights = heights.map((h, i) => {
|
||||
const [x, y] = graph.points[i];
|
||||
const nx = (2 * x) / graphWidth - 1; // [-1, 1], 0 is center
|
||||
const ny = (2 * y) / graphHeight - 1; // [-1, 1], 0 is center
|
||||
let distance = (1 - nx ** 2) * (1 - ny ** 2); // 1 is center, 0 is edge
|
||||
if (power < 0) distance = 1 - distance; // inverted, 0 is center, 1 is edge
|
||||
const masked = h * distance;
|
||||
return lim((h * (fr - 1) + masked) / fr);
|
||||
});
|
||||
|
||||
return heights;
|
||||
}
|
||||
|
||||
export function invert(heights, graph, config, utils, count, axes) {
|
||||
const { P } = utils;
|
||||
|
||||
if (!P(count)) return heights;
|
||||
|
||||
heights = new Uint8Array(heights);
|
||||
const invertX = axes !== "y";
|
||||
const invertY = axes !== "x";
|
||||
const { cellsX, cellsY } = graph;
|
||||
|
||||
const inverted = heights.map((h, i) => {
|
||||
const x = i % cellsX;
|
||||
const y = Math.floor(i / cellsX);
|
||||
|
||||
const nx = invertX ? cellsX - x - 1 : x;
|
||||
const ny = invertY ? cellsY - y - 1 : y;
|
||||
const invertedI = nx + ny * cellsX;
|
||||
return heights[invertedI];
|
||||
});
|
||||
|
||||
return inverted;
|
||||
}
|
||||
|
||||
function getPointInRange(range, length, utils) {
|
||||
const { rand } = utils;
|
||||
|
||||
if (typeof range !== "string") {
|
||||
console.error("Range should be a string");
|
||||
return;
|
||||
}
|
||||
|
||||
const min = range.split("-")[0] / 100 || 0;
|
||||
const max = range.split("-")[1] / 100 || min;
|
||||
return rand(min * length, max * length);
|
||||
}
|
||||
18
procedural/src/engine/support/heightmap-generator_config.md
Normal file
18
procedural/src/engine/support/heightmap-generator_config.md
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
# Config Properties for heightmap-generator.js
|
||||
|
||||
The refactored heightmap-generator module requires the following configuration properties:
|
||||
|
||||
## Core Configuration
|
||||
- `templateId` - String identifier for the heightmap template to use (replaces `byId("templateInput").value`)
|
||||
- `seed` - Random seed value for deterministic generation
|
||||
- `graphWidth` - Width of the graph/map area
|
||||
- `graphHeight` - Height of the graph/map area
|
||||
|
||||
## Original DOM Reads Converted
|
||||
- **`byId("templateInput").value`** → **`config.templateId`**
|
||||
- Used in the `generate()` function to determine which heightmap template or precreated heightmap to use
|
||||
|
||||
## Global Variables Now in Config
|
||||
- **`graphWidth`** - Previously a global variable, now passed via config
|
||||
- **`graphHeight`** - Previously a global variable, now passed via config
|
||||
- **`seed`** - Previously a global variable, now passed via config
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# External Dependencies for heightmap-generator.js
|
||||
|
||||
The refactored heightmap-generator module requires the following external dependencies to be imported or provided via the `utils` object:
|
||||
|
||||
## Utility Functions
|
||||
- `aleaPRNG` - Pseudo-random number generator function for seeding
|
||||
- `createTypedArray` - Creates typed arrays with specified parameters
|
||||
- `findGridCell` - Finds grid cell at given coordinates
|
||||
- `getNumberInRange` - Converts range string to numeric value
|
||||
- `lim` - Limits/clamps values to valid range
|
||||
- `minmax` - Min/max utility function
|
||||
- `rand` - Random number generator within range
|
||||
- `P` - Probability utility function
|
||||
|
||||
## Libraries
|
||||
- `d3` - D3.js library methods:
|
||||
- `d3.mean()` - Calculates mean of array
|
||||
- `d3.range()` - Creates array of numbers
|
||||
- `d3.scan()` - Finds index of minimum/maximum element
|
||||
|
||||
## Data Objects
|
||||
- `heightmapTemplates` - Object containing heightmap template definitions
|
||||
|
||||
## Configuration/Global Variables
|
||||
- `TIME` - Boolean flag for timing operations
|
||||
625
procedural/src/engine/support/heightmap-generator_prompt.md
Normal file
625
procedural/src/engine/support/heightmap-generator_prompt.md
Normal file
|
|
@ -0,0 +1,625 @@
|
|||
# heightmap-generator.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
7. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
8. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `heightmap-generator.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.HeightmapGenerator = (function () {
|
||||
let grid = null;
|
||||
let heights = null;
|
||||
let blobPower;
|
||||
let linePower;
|
||||
|
||||
const setGraph = graph => {
|
||||
const {cellsDesired, cells, points} = graph;
|
||||
heights = cells.h ? Uint8Array.from(cells.h) : createTypedArray({maxValue: 100, length: points.length});
|
||||
blobPower = getBlobPower(cellsDesired);
|
||||
linePower = getLinePower(cellsDesired);
|
||||
grid = graph;
|
||||
};
|
||||
|
||||
const getHeights = () => heights;
|
||||
|
||||
const clearData = () => {
|
||||
heights = null;
|
||||
grid = null;
|
||||
};
|
||||
|
||||
const fromTemplate = (graph, id) => {
|
||||
const templateString = heightmapTemplates[id]?.template || "";
|
||||
const steps = templateString.split("\n");
|
||||
|
||||
if (!steps.length) throw new Error(`Heightmap template: no steps. Template: ${id}. Steps: ${steps}`);
|
||||
setGraph(graph);
|
||||
|
||||
for (const step of steps) {
|
||||
const elements = step.trim().split(" ");
|
||||
if (elements.length < 2) throw new Error(`Heightmap template: steps < 2. Template: ${id}. Step: ${elements}`);
|
||||
addStep(...elements);
|
||||
}
|
||||
|
||||
return heights;
|
||||
};
|
||||
|
||||
const fromPrecreated = (graph, id) => {
|
||||
return new Promise(resolve => {
|
||||
// create canvas where 1px corresponts to a cell
|
||||
const canvas = document.createElement("canvas");
|
||||
const ctx = canvas.getContext("2d");
|
||||
const {cellsX, cellsY} = graph;
|
||||
canvas.width = cellsX;
|
||||
canvas.height = cellsY;
|
||||
|
||||
// load heightmap into image and render to canvas
|
||||
const img = new Image();
|
||||
img.src = `./heightmaps/${id}.png`;
|
||||
img.onload = () => {
|
||||
ctx.drawImage(img, 0, 0, cellsX, cellsY);
|
||||
const imageData = ctx.getImageData(0, 0, cellsX, cellsY);
|
||||
setGraph(graph);
|
||||
getHeightsFromImageData(imageData.data);
|
||||
canvas.remove();
|
||||
img.remove();
|
||||
resolve(heights);
|
||||
};
|
||||
});
|
||||
};
|
||||
|
||||
const generate = async function (graph) {
|
||||
TIME && console.time("defineHeightmap");
|
||||
const id = byId("templateInput").value;
|
||||
|
||||
Math.random = aleaPRNG(seed);
|
||||
const isTemplate = id in heightmapTemplates;
|
||||
const heights = isTemplate ? fromTemplate(graph, id) : await fromPrecreated(graph, id);
|
||||
TIME && console.timeEnd("defineHeightmap");
|
||||
|
||||
clearData();
|
||||
return heights;
|
||||
};
|
||||
|
||||
function addStep(tool, a2, a3, a4, a5) {
|
||||
if (tool === "Hill") return addHill(a2, a3, a4, a5);
|
||||
if (tool === "Pit") return addPit(a2, a3, a4, a5);
|
||||
if (tool === "Range") return addRange(a2, a3, a4, a5);
|
||||
if (tool === "Trough") return addTrough(a2, a3, a4, a5);
|
||||
if (tool === "Strait") return addStrait(a2, a3);
|
||||
if (tool === "Mask") return mask(a2);
|
||||
if (tool === "Invert") return invert(a2, a3);
|
||||
if (tool === "Add") return modify(a3, +a2, 1);
|
||||
if (tool === "Multiply") return modify(a3, 0, +a2);
|
||||
if (tool === "Smooth") return smooth(a2);
|
||||
}
|
||||
|
||||
function getBlobPower(cells) {
|
||||
const blobPowerMap = {
|
||||
1000: 0.93,
|
||||
2000: 0.95,
|
||||
5000: 0.97,
|
||||
10000: 0.98,
|
||||
20000: 0.99,
|
||||
30000: 0.991,
|
||||
40000: 0.993,
|
||||
50000: 0.994,
|
||||
60000: 0.995,
|
||||
70000: 0.9955,
|
||||
80000: 0.996,
|
||||
90000: 0.9964,
|
||||
100000: 0.9973
|
||||
};
|
||||
return blobPowerMap[cells] || 0.98;
|
||||
}
|
||||
|
||||
function getLinePower() {
|
||||
const linePowerMap = {
|
||||
1000: 0.75,
|
||||
2000: 0.77,
|
||||
5000: 0.79,
|
||||
10000: 0.81,
|
||||
20000: 0.82,
|
||||
30000: 0.83,
|
||||
40000: 0.84,
|
||||
50000: 0.86,
|
||||
60000: 0.87,
|
||||
70000: 0.88,
|
||||
80000: 0.91,
|
||||
90000: 0.92,
|
||||
100000: 0.93
|
||||
};
|
||||
|
||||
return linePowerMap[cells] || 0.81;
|
||||
}
|
||||
|
||||
const addHill = (count, height, rangeX, rangeY) => {
|
||||
count = getNumberInRange(count);
|
||||
while (count > 0) {
|
||||
addOneHill();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneHill() {
|
||||
const change = new Uint8Array(heights.length);
|
||||
let limit = 0;
|
||||
let start;
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
do {
|
||||
const x = getPointInRange(rangeX, graphWidth);
|
||||
const y = getPointInRange(rangeY, graphHeight);
|
||||
start = findGridCell(x, y, grid);
|
||||
limit++;
|
||||
} while (heights[start] + h > 90 && limit < 50);
|
||||
|
||||
change[start] = h;
|
||||
const queue = [start];
|
||||
while (queue.length) {
|
||||
const q = queue.shift();
|
||||
|
||||
for (const c of grid.cells.c[q]) {
|
||||
if (change[c]) continue;
|
||||
change[c] = change[q] ** blobPower * (Math.random() * 0.2 + 0.9);
|
||||
if (change[c] > 1) queue.push(c);
|
||||
}
|
||||
}
|
||||
|
||||
heights = heights.map((h, i) => lim(h + change[i]));
|
||||
}
|
||||
};
|
||||
|
||||
const addPit = (count, height, rangeX, rangeY) => {
|
||||
count = getNumberInRange(count);
|
||||
while (count > 0) {
|
||||
addOnePit();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOnePit() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let limit = 0,
|
||||
start;
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
do {
|
||||
const x = getPointInRange(rangeX, graphWidth);
|
||||
const y = getPointInRange(rangeY, graphHeight);
|
||||
start = findGridCell(x, y, grid);
|
||||
limit++;
|
||||
} while (heights[start] < 20 && limit < 50);
|
||||
|
||||
const queue = [start];
|
||||
while (queue.length) {
|
||||
const q = queue.shift();
|
||||
h = h ** blobPower * (Math.random() * 0.2 + 0.9);
|
||||
if (h < 1) return;
|
||||
|
||||
grid.cells.c[q].forEach(function (c, i) {
|
||||
if (used[c]) return;
|
||||
heights[c] = lim(heights[c] - h * (Math.random() * 0.2 + 0.9));
|
||||
used[c] = 1;
|
||||
queue.push(c);
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// fromCell, toCell are options cell ids
|
||||
const addRange = (count, height, rangeX, rangeY, startCell, endCell) => {
|
||||
count = getNumberInRange(count);
|
||||
while (count > 0) {
|
||||
addOneRange();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneRange() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
if (rangeX && rangeY) {
|
||||
// find start and end points
|
||||
const startX = getPointInRange(rangeX, graphWidth);
|
||||
const startY = getPointInRange(rangeY, graphHeight);
|
||||
|
||||
let dist = 0,
|
||||
limit = 0,
|
||||
endX,
|
||||
endY;
|
||||
|
||||
do {
|
||||
endX = Math.random() * graphWidth * 0.8 + graphWidth * 0.1;
|
||||
endY = Math.random() * graphHeight * 0.7 + graphHeight * 0.15;
|
||||
dist = Math.abs(endY - startY) + Math.abs(endX - startX);
|
||||
limit++;
|
||||
} while ((dist < graphWidth / 8 || dist > graphWidth / 3) && limit < 50);
|
||||
|
||||
startCell = findGridCell(startX, startY, grid);
|
||||
endCell = findGridCell(endX, endY, grid);
|
||||
}
|
||||
|
||||
let range = getRange(startCell, endCell);
|
||||
|
||||
// get main ridge
|
||||
function getRange(cur, end) {
|
||||
const range = [cur];
|
||||
const p = grid.points;
|
||||
used[cur] = 1;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
grid.cells.c[cur].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.85) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
if (min === Infinity) return range;
|
||||
range.push(cur);
|
||||
used[cur] = 1;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
// add height to ridge and cells around
|
||||
let queue = range.slice(),
|
||||
i = 0;
|
||||
while (queue.length) {
|
||||
const frontier = queue.slice();
|
||||
(queue = []), i++;
|
||||
frontier.forEach(i => {
|
||||
heights[i] = lim(heights[i] + h * (Math.random() * 0.3 + 0.85));
|
||||
});
|
||||
h = h ** linePower - 1;
|
||||
if (h < 2) break;
|
||||
frontier.forEach(f => {
|
||||
grid.cells.c[f].forEach(i => {
|
||||
if (!used[i]) {
|
||||
queue.push(i);
|
||||
used[i] = 1;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// generate prominences
|
||||
range.forEach((cur, d) => {
|
||||
if (d % 6 !== 0) return;
|
||||
for (const l of d3.range(i)) {
|
||||
const min = grid.cells.c[cur][d3.scan(grid.cells.c[cur], (a, b) => heights[a] - heights[b])]; // downhill cell
|
||||
heights[min] = (heights[cur] * 2 + heights[min]) / 3;
|
||||
cur = min;
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
const addTrough = (count, height, rangeX, rangeY, startCell, endCell) => {
|
||||
count = getNumberInRange(count);
|
||||
while (count > 0) {
|
||||
addOneTrough();
|
||||
count--;
|
||||
}
|
||||
|
||||
function addOneTrough() {
|
||||
const used = new Uint8Array(heights.length);
|
||||
let h = lim(getNumberInRange(height));
|
||||
|
||||
if (rangeX && rangeY) {
|
||||
// find start and end points
|
||||
let limit = 0,
|
||||
startX,
|
||||
startY,
|
||||
dist = 0,
|
||||
endX,
|
||||
endY;
|
||||
do {
|
||||
startX = getPointInRange(rangeX, graphWidth);
|
||||
startY = getPointInRange(rangeY, graphHeight);
|
||||
startCell = findGridCell(startX, startY, grid);
|
||||
limit++;
|
||||
} while (heights[startCell] < 20 && limit < 50);
|
||||
|
||||
limit = 0;
|
||||
do {
|
||||
endX = Math.random() * graphWidth * 0.8 + graphWidth * 0.1;
|
||||
endY = Math.random() * graphHeight * 0.7 + graphHeight * 0.15;
|
||||
dist = Math.abs(endY - startY) + Math.abs(endX - startX);
|
||||
limit++;
|
||||
} while ((dist < graphWidth / 8 || dist > graphWidth / 2) && limit < 50);
|
||||
|
||||
endCell = findGridCell(endX, endY, grid);
|
||||
}
|
||||
|
||||
let range = getRange(startCell, endCell);
|
||||
|
||||
// get main ridge
|
||||
function getRange(cur, end) {
|
||||
const range = [cur];
|
||||
const p = grid.points;
|
||||
used[cur] = 1;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
grid.cells.c[cur].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.8) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
if (min === Infinity) return range;
|
||||
range.push(cur);
|
||||
used[cur] = 1;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
// add height to ridge and cells around
|
||||
let queue = range.slice(),
|
||||
i = 0;
|
||||
while (queue.length) {
|
||||
const frontier = queue.slice();
|
||||
(queue = []), i++;
|
||||
frontier.forEach(i => {
|
||||
heights[i] = lim(heights[i] - h * (Math.random() * 0.3 + 0.85));
|
||||
});
|
||||
h = h ** linePower - 1;
|
||||
if (h < 2) break;
|
||||
frontier.forEach(f => {
|
||||
grid.cells.c[f].forEach(i => {
|
||||
if (!used[i]) {
|
||||
queue.push(i);
|
||||
used[i] = 1;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// generate prominences
|
||||
range.forEach((cur, d) => {
|
||||
if (d % 6 !== 0) return;
|
||||
for (const l of d3.range(i)) {
|
||||
const min = grid.cells.c[cur][d3.scan(grid.cells.c[cur], (a, b) => heights[a] - heights[b])]; // downhill cell
|
||||
//debug.append("circle").attr("cx", p[min][0]).attr("cy", p[min][1]).attr("r", 1);
|
||||
heights[min] = (heights[cur] * 2 + heights[min]) / 3;
|
||||
cur = min;
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
const addStrait = (width, direction = "vertical") => {
|
||||
width = Math.min(getNumberInRange(width), grid.cellsX / 3);
|
||||
if (width < 1 && P(width)) return;
|
||||
const used = new Uint8Array(heights.length);
|
||||
const vert = direction === "vertical";
|
||||
const startX = vert ? Math.floor(Math.random() * graphWidth * 0.4 + graphWidth * 0.3) : 5;
|
||||
const startY = vert ? 5 : Math.floor(Math.random() * graphHeight * 0.4 + graphHeight * 0.3);
|
||||
const endX = vert
|
||||
? Math.floor(graphWidth - startX - graphWidth * 0.1 + Math.random() * graphWidth * 0.2)
|
||||
: graphWidth - 5;
|
||||
const endY = vert
|
||||
? graphHeight - 5
|
||||
: Math.floor(graphHeight - startY - graphHeight * 0.1 + Math.random() * graphHeight * 0.2);
|
||||
|
||||
const start = findGridCell(startX, startY, grid);
|
||||
const end = findGridCell(endX, endY, grid);
|
||||
let range = getRange(start, end);
|
||||
const query = [];
|
||||
|
||||
function getRange(cur, end) {
|
||||
const range = [];
|
||||
const p = grid.points;
|
||||
|
||||
while (cur !== end) {
|
||||
let min = Infinity;
|
||||
grid.cells.c[cur].forEach(function (e) {
|
||||
let diff = (p[end][0] - p[e][0]) ** 2 + (p[end][1] - p[e][1]) ** 2;
|
||||
if (Math.random() > 0.8) diff = diff / 2;
|
||||
if (diff < min) {
|
||||
min = diff;
|
||||
cur = e;
|
||||
}
|
||||
});
|
||||
range.push(cur);
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
|
||||
const step = 0.1 / width;
|
||||
|
||||
while (width > 0) {
|
||||
const exp = 0.9 - step * width;
|
||||
range.forEach(function (r) {
|
||||
grid.cells.c[r].forEach(function (e) {
|
||||
if (used[e]) return;
|
||||
used[e] = 1;
|
||||
query.push(e);
|
||||
heights[e] **= exp;
|
||||
if (heights[e] > 100) heights[e] = 5;
|
||||
});
|
||||
});
|
||||
range = query.slice();
|
||||
|
||||
width--;
|
||||
}
|
||||
};
|
||||
|
||||
const modify = (range, add, mult, power) => {
|
||||
const min = range === "land" ? 20 : range === "all" ? 0 : +range.split("-")[0];
|
||||
const max = range === "land" || range === "all" ? 100 : +range.split("-")[1];
|
||||
const isLand = min === 20;
|
||||
|
||||
heights = heights.map(h => {
|
||||
if (h < min || h > max) return h;
|
||||
|
||||
if (add) h = isLand ? Math.max(h + add, 20) : h + add;
|
||||
if (mult !== 1) h = isLand ? (h - 20) * mult + 20 : h * mult;
|
||||
if (power) h = isLand ? (h - 20) ** power + 20 : h ** power;
|
||||
return lim(h);
|
||||
});
|
||||
};
|
||||
|
||||
const smooth = (fr = 2, add = 0) => {
|
||||
heights = heights.map((h, i) => {
|
||||
const a = [h];
|
||||
grid.cells.c[i].forEach(c => a.push(heights[c]));
|
||||
if (fr === 1) return d3.mean(a) + add;
|
||||
return lim((h * (fr - 1) + d3.mean(a) + add) / fr);
|
||||
});
|
||||
};
|
||||
|
||||
const mask = (power = 1) => {
|
||||
const fr = power ? Math.abs(power) : 1;
|
||||
|
||||
heights = heights.map((h, i) => {
|
||||
const [x, y] = grid.points[i];
|
||||
const nx = (2 * x) / graphWidth - 1; // [-1, 1], 0 is center
|
||||
const ny = (2 * y) / graphHeight - 1; // [-1, 1], 0 is center
|
||||
let distance = (1 - nx ** 2) * (1 - ny ** 2); // 1 is center, 0 is edge
|
||||
if (power < 0) distance = 1 - distance; // inverted, 0 is center, 1 is edge
|
||||
const masked = h * distance;
|
||||
return lim((h * (fr - 1) + masked) / fr);
|
||||
});
|
||||
};
|
||||
|
||||
const invert = (count, axes) => {
|
||||
if (!P(count)) return;
|
||||
|
||||
const invertX = axes !== "y";
|
||||
const invertY = axes !== "x";
|
||||
const {cellsX, cellsY} = grid;
|
||||
|
||||
const inverted = heights.map((h, i) => {
|
||||
const x = i % cellsX;
|
||||
const y = Math.floor(i / cellsX);
|
||||
|
||||
const nx = invertX ? cellsX - x - 1 : x;
|
||||
const ny = invertY ? cellsY - y - 1 : y;
|
||||
const invertedI = nx + ny * cellsX;
|
||||
return heights[invertedI];
|
||||
});
|
||||
|
||||
heights = inverted;
|
||||
};
|
||||
|
||||
function getPointInRange(range, length) {
|
||||
if (typeof range !== "string") {
|
||||
ERROR && console.error("Range should be a string");
|
||||
return;
|
||||
}
|
||||
|
||||
const min = range.split("-")[0] / 100 || 0;
|
||||
const max = range.split("-")[1] / 100 || min;
|
||||
return rand(min * length, max * length);
|
||||
}
|
||||
|
||||
function getHeightsFromImageData(imageData) {
|
||||
for (let i = 0; i < heights.length; i++) {
|
||||
const lightness = imageData[i * 4] / 255;
|
||||
const powered = lightness < 0.2 ? lightness : 0.2 + (lightness - 0.2) ** 0.8;
|
||||
heights[i] = minmax(Math.floor(powered * 100), 0, 100);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
setGraph,
|
||||
getHeights,
|
||||
generate,
|
||||
fromTemplate,
|
||||
fromPrecreated,
|
||||
addHill,
|
||||
addRange,
|
||||
addTrough,
|
||||
addStrait,
|
||||
addPit,
|
||||
smooth,
|
||||
modify,
|
||||
mask,
|
||||
invert
|
||||
};
|
||||
})();
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./heightmap-generator.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./heightmap-generator_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in heightmap-generator_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application.
|
||||
18
procedural/src/engine/support/heightmap-generator_render.md
Normal file
18
procedural/src/engine/support/heightmap-generator_render.md
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
# Removed Rendering/UI Logic
|
||||
|
||||
The following DOM/browser-dependent code was completely removed:
|
||||
- **fromPrecreated() function** - Created DOM canvas and image elements, used document.createElement(), canvas context manipulation, and image loading
|
||||
- **Canvas manipulation code** - canvas.width/height, ctx.drawImage(), ctx.getImageData()
|
||||
- **Image loading logic** - new Image(), img.src, img.onload event handling
|
||||
- **DOM element removal** - canvas.remove(), img.remove()
|
||||
|
||||
## Future Work Required
|
||||
|
||||
The `fromPrecreated()` function has been replaced with a placeholder that throws an error. To make this work in a headless environment, the following will be needed:
|
||||
|
||||
1. **Image Loading Utility** - A `utils.loadImage()` function that can load PNG files in any JavaScript environment
|
||||
2. **Image Processing Library** - For Node.js environments, a library like the `canvas` package to process image data
|
||||
3. **Refactored getHeightsFromImageData()** - This function needs to be updated to work with headless image processing
|
||||
4. **Environment Detection** - Logic to determine whether to use browser APIs or Node.js alternatives
|
||||
|
||||
Currently, attempting to generate heightmaps from precreated PNG files will throw an error indicating this functionality requires further implementation.
|
||||
44
procedural/src/engine/support/lakes_config.md
Normal file
44
procedural/src/engine/support/lakes_config.md
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
# Config Properties for lakes.js
|
||||
|
||||
The refactored `lakes.js` module identified the following DOM reads that have been converted to config properties:
|
||||
|
||||
## Config Properties
|
||||
|
||||
### 1. lakeElevationLimit
|
||||
- **Original DOM read:** `+byId("lakeElevationLimitOutput").value`
|
||||
- **Config property:** `config.lakeElevationLimit`
|
||||
- **Used in:** `detectCloseLakes()` function
|
||||
- **Type:** Number
|
||||
- **Description:** The elevation limit used to determine if a lake can be potentially open (not in deep depression)
|
||||
|
||||
### 2. heightExponent
|
||||
- **Original DOM read:** `heightExponentInput.value`
|
||||
- **Config property:** `config.heightExponent`
|
||||
- **Used in:** `defineClimateData()` function (specifically in `getLakeEvaporation()`)
|
||||
- **Type:** Number
|
||||
- **Description:** The height exponent used in evaporation calculations for lakes
|
||||
|
||||
## Config Object Structure
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
lakeElevationLimit: 50, // Example value - was read from "lakeElevationLimitOutput" element
|
||||
heightExponent: 2 // Example value - was read from "heightExponentInput" element
|
||||
};
|
||||
```
|
||||
|
||||
## Function Signatures
|
||||
|
||||
Functions that require the config object:
|
||||
|
||||
```javascript
|
||||
detectCloseLakes(pack, grid, heights, config)
|
||||
defineClimateData(pack, grid, heights, config, utils)
|
||||
```
|
||||
|
||||
## Notes
|
||||
|
||||
- Both config properties are numeric values used in mathematical calculations
|
||||
- `lakeElevationLimit` affects lake classification logic
|
||||
- `heightExponent` affects evaporation rate calculations
|
||||
- These values were previously read directly from DOM input elements
|
||||
39
procedural/src/engine/support/lakes_external.md
Normal file
39
procedural/src/engine/support/lakes_external.md
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
# External Dependencies for lakes.js
|
||||
|
||||
The refactored `lakes.js` module requires the following external modules to be imported:
|
||||
|
||||
## Required Imports
|
||||
|
||||
1. **Names module** - for generating lake names
|
||||
- Used in: `getName()` function
|
||||
- Dependency: `Names.getCulture(culture)`
|
||||
|
||||
## Utility Dependencies
|
||||
|
||||
The module also requires utility functions passed via a `utils` object parameter:
|
||||
|
||||
1. **d3 utilities**
|
||||
- `d3.min()` - for finding minimum values in arrays
|
||||
- `d3.mean()` - for calculating averages
|
||||
- Used in: `defineClimateData()`, `getHeight()` functions
|
||||
|
||||
2. **rn() function** - rounding utility
|
||||
- Used for rounding numerical values to specified decimal places
|
||||
- Used in: `defineClimateData()`, `getHeight()` functions
|
||||
|
||||
## Import Structure
|
||||
|
||||
```javascript
|
||||
import { Names } from './names.js';
|
||||
|
||||
// Usage in function calls:
|
||||
// defineClimateData(pack, grid, heights, config, { d3, rn })
|
||||
// getHeight(feature, pack, { d3, rn })
|
||||
// getName(feature, pack, Names)
|
||||
```
|
||||
|
||||
## Notes
|
||||
|
||||
- The `utils` object containing `d3` and `rn` should be passed as function parameters
|
||||
- The `Names` module should be imported and passed to the `getName()` function
|
||||
- All other dependencies have been eliminated through dependency injection
|
||||
200
procedural/src/engine/support/lakes_prompt.md
Normal file
200
procedural/src/engine/support/lakes_prompt.md
Normal file
|
|
@ -0,0 +1,200 @@
|
|||
# lakes.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `lakes.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Lakes = (function () {
|
||||
const LAKE_ELEVATION_DELTA = 0.1;
|
||||
|
||||
// check if lake can be potentially open (not in deep depression)
|
||||
const detectCloseLakes = h => {
|
||||
const {cells} = pack;
|
||||
const ELEVATION_LIMIT = +byId("lakeElevationLimitOutput").value;
|
||||
|
||||
pack.features.forEach(feature => {
|
||||
if (feature.type !== "lake") return;
|
||||
delete feature.closed;
|
||||
|
||||
const MAX_ELEVATION = feature.height + ELEVATION_LIMIT;
|
||||
if (MAX_ELEVATION > 99) {
|
||||
feature.closed = false;
|
||||
return;
|
||||
}
|
||||
|
||||
let isDeep = true;
|
||||
const lowestShorelineCell = feature.shoreline.sort((a, b) => h[a] - h[b])[0];
|
||||
const queue = [lowestShorelineCell];
|
||||
const checked = [];
|
||||
checked[lowestShorelineCell] = true;
|
||||
|
||||
while (queue.length && isDeep) {
|
||||
const cellId = queue.pop();
|
||||
|
||||
for (const neibCellId of cells.c[cellId]) {
|
||||
if (checked[neibCellId]) continue;
|
||||
if (h[neibCellId] >= MAX_ELEVATION) continue;
|
||||
|
||||
if (h[neibCellId] < 20) {
|
||||
const nFeature = pack.features[cells.f[neibCellId]];
|
||||
if (nFeature.type === "ocean" || feature.height > nFeature.height) isDeep = false;
|
||||
}
|
||||
|
||||
checked[neibCellId] = true;
|
||||
queue.push(neibCellId);
|
||||
}
|
||||
}
|
||||
|
||||
feature.closed = isDeep;
|
||||
});
|
||||
};
|
||||
|
||||
const defineClimateData = function (heights) {
|
||||
const {cells, features} = pack;
|
||||
const lakeOutCells = new Uint16Array(cells.i.length);
|
||||
|
||||
features.forEach(feature => {
|
||||
if (feature.type !== "lake") return;
|
||||
feature.flux = getFlux(feature);
|
||||
feature.temp = getLakeTemp(feature);
|
||||
feature.evaporation = getLakeEvaporation(feature);
|
||||
if (feature.closed) return; // no outlet for lakes in depressed areas
|
||||
|
||||
feature.outCell = getLowestShoreCell(feature);
|
||||
lakeOutCells[feature.outCell] = feature.i;
|
||||
});
|
||||
|
||||
return lakeOutCells;
|
||||
|
||||
function getFlux(lake) {
|
||||
return lake.shoreline.reduce((acc, c) => acc + grid.cells.prec[cells.g[c]], 0);
|
||||
}
|
||||
|
||||
function getLakeTemp(lake) {
|
||||
if (lake.cells < 6) return grid.cells.temp[cells.g[lake.firstCell]];
|
||||
return rn(d3.mean(lake.shoreline.map(c => grid.cells.temp[cells.g[c]])), 1);
|
||||
}
|
||||
|
||||
function getLakeEvaporation(lake) {
|
||||
const height = (lake.height - 18) ** heightExponentInput.value; // height in meters
|
||||
const evaporation = ((700 * (lake.temp + 0.006 * height)) / 50 + 75) / (80 - lake.temp); // based on Penman formula, [1-11]
|
||||
return rn(evaporation * lake.cells);
|
||||
}
|
||||
|
||||
function getLowestShoreCell(lake) {
|
||||
return lake.shoreline.sort((a, b) => heights[a] - heights[b])[0];
|
||||
}
|
||||
};
|
||||
|
||||
const cleanupLakeData = function () {
|
||||
for (const feature of pack.features) {
|
||||
if (feature.type !== "lake") continue;
|
||||
delete feature.river;
|
||||
delete feature.enteringFlux;
|
||||
delete feature.outCell;
|
||||
delete feature.closed;
|
||||
feature.height = rn(feature.height, 3);
|
||||
|
||||
const inlets = feature.inlets?.filter(r => pack.rivers.find(river => river.i === r));
|
||||
if (!inlets || !inlets.length) delete feature.inlets;
|
||||
else feature.inlets = inlets;
|
||||
|
||||
const outlet = feature.outlet && pack.rivers.find(river => river.i === feature.outlet);
|
||||
if (!outlet) delete feature.outlet;
|
||||
}
|
||||
};
|
||||
|
||||
const getHeight = function (feature) {
|
||||
const heights = pack.cells.h;
|
||||
const minShoreHeight = d3.min(feature.shoreline.map(cellId => heights[cellId])) || 20;
|
||||
return rn(minShoreHeight - LAKE_ELEVATION_DELTA, 2);
|
||||
};
|
||||
|
||||
const getName = function (feature) {
|
||||
const landCell = pack.cells.c[feature.firstCell].find(c => pack.cells.h[c] >= 20);
|
||||
const culture = pack.cells.culture[landCell];
|
||||
return Names.getCulture(culture);
|
||||
};
|
||||
|
||||
return {defineClimateData, cleanupLakeData, detectCloseLakes, getHeight, getName};
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./lakes.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./lakes_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in lakes_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into lakes_render.md
|
||||
41
procedural/src/engine/support/lakes_render.md
Normal file
41
procedural/src/engine/support/lakes_render.md
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
# Removed Rendering/UI Logic from lakes.js
|
||||
|
||||
## Analysis Result: No Rendering Logic Found
|
||||
|
||||
After careful analysis of the original `lakes.js` module, **no DOM manipulation or SVG rendering logic was found** that needed to be removed.
|
||||
|
||||
## Original Code Analysis
|
||||
|
||||
The original `lakes.js` module contained only:
|
||||
|
||||
1. **Data Processing Functions:**
|
||||
- `detectCloseLakes()` - Pure computational logic for lake classification
|
||||
- `defineClimateData()` - Mathematical calculations for lake climate properties
|
||||
- `cleanupLakeData()` - Data cleanup and filtering operations
|
||||
- `getHeight()` - Mathematical calculation for lake elevation
|
||||
- `getName()` - Name generation using external Names module
|
||||
|
||||
2. **DOM Reads Only (No DOM Writes):**
|
||||
- `byId("lakeElevationLimitOutput").value` - Configuration input (converted to config property)
|
||||
- `heightExponentInput.value` - Configuration input (converted to config property)
|
||||
|
||||
## No Removed Code Blocks
|
||||
|
||||
There were **no code blocks removed** from the original module because:
|
||||
|
||||
- No `d3.select()` calls for DOM/SVG manipulation
|
||||
- No `document.getElementById().innerHTML` assignments
|
||||
- No DOM element creation or modification
|
||||
- No SVG path generation or rendering
|
||||
- No UI notification calls (like `tip()`)
|
||||
- No direct DOM manipulation whatsoever
|
||||
|
||||
## Conclusion
|
||||
|
||||
The original `lakes.js` module was already focused purely on data processing and mathematical calculations. The only browser dependencies were:
|
||||
|
||||
1. DOM reads for configuration (converted to config parameters)
|
||||
2. Access to global state variables (converted to dependency injection)
|
||||
3. External utility dependencies (converted to injected parameters)
|
||||
|
||||
All refactoring work was focused on **dependency injection** and **config parameter extraction** rather than removing rendering logic, as none existed in the original code.
|
||||
17
procedural/src/engine/support/markers-generator_config.md
Normal file
17
procedural/src/engine/support/markers-generator_config.md
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
# Configuration Properties for markers-generator.js
|
||||
|
||||
The refactored `markers-generator.js` module requires the following configuration properties to be passed via the `config` object:
|
||||
|
||||
## Required Config Properties
|
||||
|
||||
### `culturesSet` (string)
|
||||
- **Source**: Originally `document.getElementById("culturesSet").value` on line 80
|
||||
- **Purpose**: Determines the culture set being used for map generation
|
||||
- **Usage**: Used to detect if Fantasy cultures are enabled, which affects multiplier values for fantasy-themed markers like portals, rifts, and disturbed burials
|
||||
- **Example**: `"Fantasy European"`, `"Real World"`
|
||||
|
||||
## Notes
|
||||
|
||||
Only one DOM call was identified in the original code that needed to be converted to a configuration property. The `culturesSet` value is used to determine whether fantasy elements should be included in marker generation by checking if the string contains "Fantasy".
|
||||
|
||||
The calling application should read this value from the UI and pass it in the config object when calling the marker generation functions.
|
||||
40
procedural/src/engine/support/markers-generator_external.md
Normal file
40
procedural/src/engine/support/markers-generator_external.md
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
# External Dependencies for markers-generator.js
|
||||
|
||||
The refactored `markers-generator.js` module requires the following external modules to be imported:
|
||||
|
||||
## Core Modules
|
||||
- `Names` - Used for generating culture-specific names and toponyms
|
||||
- `Routes` - Used for checking crossroads, connections, and road availability
|
||||
- `BurgsAndStates` - Used for generating campaign data for battlefields
|
||||
|
||||
## Utility Functions
|
||||
The following utility functions need to be passed in the `utils` object:
|
||||
|
||||
### Random/Math Utilities
|
||||
- `P(probability)` - Probability function (returns true with given probability)
|
||||
- `rw(weights)` - Random weighted selection from object
|
||||
- `ra(array)` - Random array element selection
|
||||
- `rand(min, max)` - Random integer between min and max
|
||||
- `gauss(mean, deviation, min, max)` - Gaussian distribution random number
|
||||
- `rn(number)` - Round number function
|
||||
- `last(array)` - Get last element of array
|
||||
|
||||
### Data Processing
|
||||
- `d3` - D3.js library (specifically `d3.mean()` for bridge generation)
|
||||
- `getFriendlyHeight(point)` - Convert height coordinates to readable format
|
||||
- `convertTemperature(value)` - Temperature conversion utility
|
||||
- `getAdjective(name)` - Generate adjective form of name
|
||||
- `capitalize(string)` - String capitalization utility
|
||||
- `generateDate(start, end)` - Date generation utility
|
||||
|
||||
### Global Configuration
|
||||
- `populationRate` - Population calculation rate
|
||||
- `urbanization` - Urbanization factor
|
||||
- `heightUnit` - Height measurement unit object with `.value` property
|
||||
- `biomesData` - Biome data object with `.habitability` array
|
||||
- `options` - Global options object with `.era` property
|
||||
- `seed` - Global random seed
|
||||
- `TIME` - Debug timing flag
|
||||
|
||||
## Notes
|
||||
All external dependencies are injected through function parameters to maintain the engine's environment-agnostic design. The calling code is responsible for providing these dependencies.
|
||||
1371
procedural/src/engine/support/markers-generator_prompt.md
Normal file
1371
procedural/src/engine/support/markers-generator_prompt.md
Normal file
File diff suppressed because it is too large
Load diff
51
procedural/src/engine/support/markers-generator_render.md
Normal file
51
procedural/src/engine/support/markers-generator_render.md
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
# Removed Rendering/UI Logic from markers-generator.js
|
||||
|
||||
The following DOM manipulation and UI-related code blocks were identified and **removed** from the engine module. This logic should be moved to the Viewer/Client application:
|
||||
|
||||
## DOM Element Manipulation
|
||||
|
||||
### Marker Element Removal (Line 154)
|
||||
```javascript
|
||||
document.getElementById(id)?.remove();
|
||||
```
|
||||
**Purpose**: Removes marker DOM elements from the UI when regenerating markers
|
||||
**Location**: Inside the `regenerate()` function
|
||||
**Replacement**: The refactored code now returns `removedMarkerIds` array so the viewer can handle DOM cleanup
|
||||
|
||||
### Notes Array Manipulation (Lines 155-156)
|
||||
```javascript
|
||||
const index = notes.findIndex(note => note.id === id);
|
||||
if (index != -1) notes.splice(index, 1);
|
||||
```
|
||||
**Purpose**: Removes notes from the global `notes` array when markers are deleted
|
||||
**Location**: Inside the `regenerate()` function
|
||||
**Replacement**: The engine now returns a new `notes` array instead of mutating a global one
|
||||
|
||||
## Global State Mutations Removed
|
||||
|
||||
### Pack Markers Direct Mutation
|
||||
```javascript
|
||||
pack.markers = [];
|
||||
pack.markers.push(marker);
|
||||
pack.markers = pack.markers.filter(...);
|
||||
```
|
||||
**Purpose**: Direct manipulation of the global `pack.markers` array
|
||||
**Replacement**: Functions now return new marker arrays instead of mutating the input
|
||||
|
||||
### Occupied Array Global Access
|
||||
```javascript
|
||||
occupied[cell] = true;
|
||||
```
|
||||
**Purpose**: Tracking occupied cells in a module-level variable
|
||||
**Replacement**: `occupied` is now passed as a local parameter and managed within function scope
|
||||
|
||||
## Summary
|
||||
|
||||
The refactored engine module is now pure and stateless:
|
||||
- No DOM manipulation
|
||||
- No global state mutation
|
||||
- Returns data objects instead of side effects
|
||||
- The viewer application must handle:
|
||||
- DOM element creation/removal based on returned marker data
|
||||
- Note management and display
|
||||
- State persistence and updates
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
# Config Properties for military-generator.js
|
||||
|
||||
The refactored military-generator module requires the following configuration properties:
|
||||
|
||||
## From options object:
|
||||
- `military` - Array of military unit configurations (defaults to getDefaultOptions() if not provided)
|
||||
- `year` - Current calendar year for note generation
|
||||
- `eraShort` - Short era designation (e.g., "AD", "BC")
|
||||
- `era` - Full era designation (e.g., "Anno Domini")
|
||||
|
||||
## Usage:
|
||||
```javascript
|
||||
const config = {
|
||||
military: options.military || getDefaultOptions(),
|
||||
year: options.year,
|
||||
eraShort: options.eraShort,
|
||||
era: options.era
|
||||
};
|
||||
|
||||
generate(pack, config, utils, notes);
|
||||
```
|
||||
|
||||
**Note:** This module did not contain any direct DOM reads (byId() calls), so no additional configuration properties were needed to replace DOM access. All configuration comes from the existing global `options` object.
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
# External Dependencies for military-generator.js
|
||||
|
||||
The refactored military-generator module requires the following external dependencies to be imported:
|
||||
|
||||
## Utility Functions
|
||||
- `d3` - D3.js library for quadtree operations and array operations (d3.sum, d3.quadtree)
|
||||
- `minmax` - Utility function to clamp values between min and max
|
||||
- `rn` - Rounding/number formatting utility function
|
||||
- `ra` - Random array element selection utility function
|
||||
- `rand` - Random number generator function
|
||||
- `gauss` - Gaussian distribution random number generator
|
||||
- `si` - SI unit formatter utility function
|
||||
- `nth` - Ordinal number formatter utility function
|
||||
|
||||
## Runtime Configuration
|
||||
- `populationRate` - Global population rate multiplier
|
||||
- `urbanization` - Global urbanization rate
|
||||
- `TIME` - Debug timing flag
|
||||
|
||||
## Notes System
|
||||
- `notes` - Global notes array for storing regiment notes
|
||||
|
||||
These dependencies need to be provided via the `utils` parameter when calling the `generate` function.
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
# Removed Rendering/UI Logic from military-generator.js
|
||||
|
||||
## Analysis Result: No Rendering Logic Found
|
||||
|
||||
After thorough analysis of the military-generator.js module, **no rendering or UI logic was identified that needed to be removed**.
|
||||
|
||||
The module is purely computational and focuses on:
|
||||
- Calculating military units and regiments based on population, diplomacy, and geographic factors
|
||||
- Processing state-level military configurations and modifiers
|
||||
- Generating regiment data structures with composition and positioning information
|
||||
- Creating notes for regiments
|
||||
|
||||
**No code blocks were removed** because the module does not contain:
|
||||
- DOM manipulation (no `d3.select`, `document.getElementById`, etc.)
|
||||
- SVG element creation
|
||||
- HTML content generation
|
||||
- UI event handling
|
||||
- Rendering operations
|
||||
|
||||
The module was already well-architected as a pure data processing engine, making it suitable for headless operation without modification of its core computational logic.
|
||||
478
procedural/src/engine/support/military-generator_prompt.md
Normal file
478
procedural/src/engine/support/military-generator_prompt.md
Normal file
|
|
@ -0,0 +1,478 @@
|
|||
# military-generator.js.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `military-generator.js.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Military = (function () {
|
||||
const generate = function () {
|
||||
TIME && console.time("generateMilitary");
|
||||
const {cells, states} = pack;
|
||||
const {p} = cells;
|
||||
const valid = states.filter(s => s.i && !s.removed); // valid states
|
||||
if (!options.military) options.military = getDefaultOptions();
|
||||
|
||||
const expn = d3.sum(valid.map(s => s.expansionism)); // total expansion
|
||||
const area = d3.sum(valid.map(s => s.area)); // total area
|
||||
const rate = {
|
||||
x: 0,
|
||||
Ally: -0.2,
|
||||
Friendly: -0.1,
|
||||
Neutral: 0,
|
||||
Suspicion: 0.1,
|
||||
Enemy: 1,
|
||||
Unknown: 0,
|
||||
Rival: 0.5,
|
||||
Vassal: 0.5,
|
||||
Suzerain: -0.5
|
||||
};
|
||||
|
||||
const stateModifier = {
|
||||
melee: {Nomadic: 0.5, Highland: 1.2, Lake: 1, Naval: 0.7, Hunting: 1.2, River: 1.1},
|
||||
ranged: {Nomadic: 0.9, Highland: 1.3, Lake: 1, Naval: 0.8, Hunting: 2, River: 0.8},
|
||||
mounted: {Nomadic: 2.3, Highland: 0.6, Lake: 0.7, Naval: 0.3, Hunting: 0.7, River: 0.8},
|
||||
machinery: {Nomadic: 0.8, Highland: 1.4, Lake: 1.1, Naval: 1.4, Hunting: 0.4, River: 1.1},
|
||||
naval: {Nomadic: 0.5, Highland: 0.5, Lake: 1.2, Naval: 1.8, Hunting: 0.7, River: 1.2},
|
||||
armored: {Nomadic: 1, Highland: 0.5, Lake: 1, Naval: 1, Hunting: 0.7, River: 1.1},
|
||||
aviation: {Nomadic: 0.5, Highland: 0.5, Lake: 1.2, Naval: 1.2, Hunting: 0.6, River: 1.2},
|
||||
magical: {Nomadic: 1, Highland: 2, Lake: 1, Naval: 1, Hunting: 1, River: 1}
|
||||
};
|
||||
|
||||
const cellTypeModifier = {
|
||||
nomadic: {
|
||||
melee: 0.2,
|
||||
ranged: 0.5,
|
||||
mounted: 3,
|
||||
machinery: 0.4,
|
||||
naval: 0.3,
|
||||
armored: 1.6,
|
||||
aviation: 1,
|
||||
magical: 0.5
|
||||
},
|
||||
wetland: {
|
||||
melee: 0.8,
|
||||
ranged: 2,
|
||||
mounted: 0.3,
|
||||
machinery: 1.2,
|
||||
naval: 1.0,
|
||||
armored: 0.2,
|
||||
aviation: 0.5,
|
||||
magical: 0.5
|
||||
},
|
||||
highland: {
|
||||
melee: 1.2,
|
||||
ranged: 1.6,
|
||||
mounted: 0.3,
|
||||
machinery: 3,
|
||||
naval: 1.0,
|
||||
armored: 0.8,
|
||||
aviation: 0.3,
|
||||
magical: 2
|
||||
}
|
||||
};
|
||||
|
||||
const burgTypeModifier = {
|
||||
nomadic: {
|
||||
melee: 0.3,
|
||||
ranged: 0.8,
|
||||
mounted: 3,
|
||||
machinery: 0.4,
|
||||
naval: 1.0,
|
||||
armored: 1.6,
|
||||
aviation: 1,
|
||||
magical: 0.5
|
||||
},
|
||||
wetland: {
|
||||
melee: 1,
|
||||
ranged: 1.6,
|
||||
mounted: 0.2,
|
||||
machinery: 1.2,
|
||||
naval: 1.0,
|
||||
armored: 0.2,
|
||||
aviation: 0.5,
|
||||
magical: 0.5
|
||||
},
|
||||
highland: {melee: 1.2, ranged: 2, mounted: 0.3, machinery: 3, naval: 1.0, armored: 0.8, aviation: 0.3, magical: 2}
|
||||
};
|
||||
|
||||
valid.forEach(s => {
|
||||
s.temp = {};
|
||||
const d = s.diplomacy;
|
||||
|
||||
const expansionRate = minmax(s.expansionism / expn / (s.area / area), 0.25, 4); // how much state expansionism is realized
|
||||
const diplomacyRate = d.some(d => d === "Enemy")
|
||||
? 1
|
||||
: d.some(d => d === "Rival")
|
||||
? 0.8
|
||||
: d.some(d => d === "Suspicion")
|
||||
? 0.5
|
||||
: 0.1; // peacefulness
|
||||
const neighborsRateRaw = s.neighbors
|
||||
.map(n => (n ? pack.states[n].diplomacy[s.i] : "Suspicion"))
|
||||
.reduce((s, r) => (s += rate[r]), 0.5);
|
||||
const neighborsRate = minmax(neighborsRateRaw, 0.3, 3); // neighbors rate
|
||||
s.alert = minmax(rn(expansionRate * diplomacyRate * neighborsRate, 2), 0.1, 5); // alert rate (area modifier)
|
||||
s.temp.platoons = [];
|
||||
|
||||
// apply overall state modifiers for unit types based on state features
|
||||
for (const unit of options.military) {
|
||||
if (!stateModifier[unit.type]) continue;
|
||||
|
||||
let modifier = stateModifier[unit.type][s.type] || 1;
|
||||
if (unit.type === "mounted" && s.formName.includes("Horde")) modifier *= 2;
|
||||
else if (unit.type === "naval" && s.form === "Republic") modifier *= 1.2;
|
||||
s.temp[unit.name] = modifier * s.alert;
|
||||
}
|
||||
});
|
||||
|
||||
const getType = cell => {
|
||||
if ([1, 2, 3, 4].includes(cells.biome[cell])) return "nomadic";
|
||||
if ([7, 8, 9, 12].includes(cells.biome[cell])) return "wetland";
|
||||
if (cells.h[cell] >= 70) return "highland";
|
||||
return "generic";
|
||||
};
|
||||
|
||||
function passUnitLimits(unit, biome, state, culture, religion) {
|
||||
if (unit.biomes && !unit.biomes.includes(biome)) return false;
|
||||
if (unit.states && !unit.states.includes(state)) return false;
|
||||
if (unit.cultures && !unit.cultures.includes(culture)) return false;
|
||||
if (unit.religions && !unit.religions.includes(religion)) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
// rural cells
|
||||
for (const i of cells.i) {
|
||||
if (!cells.pop[i]) continue;
|
||||
|
||||
const biome = cells.biome[i];
|
||||
const state = cells.state[i];
|
||||
const culture = cells.culture[i];
|
||||
const religion = cells.religion[i];
|
||||
|
||||
const stateObj = states[state];
|
||||
if (!state || stateObj.removed) continue;
|
||||
|
||||
let modifier = cells.pop[i] / 100; // basic rural army in percentages
|
||||
if (culture !== stateObj.culture) modifier = stateObj.form === "Union" ? modifier / 1.2 : modifier / 2; // non-dominant culture
|
||||
if (religion !== cells.religion[stateObj.center])
|
||||
modifier = stateObj.form === "Theocracy" ? modifier / 2.2 : modifier / 1.4; // non-dominant religion
|
||||
if (cells.f[i] !== cells.f[stateObj.center])
|
||||
modifier = stateObj.type === "Naval" ? modifier / 1.2 : modifier / 1.8; // different landmass
|
||||
const type = getType(i);
|
||||
|
||||
for (const unit of options.military) {
|
||||
const perc = +unit.rural;
|
||||
if (isNaN(perc) || perc <= 0 || !stateObj.temp[unit.name]) continue;
|
||||
if (!passUnitLimits(unit, biome, state, culture, religion)) continue;
|
||||
if (unit.type === "naval" && !cells.haven[i]) continue; // only near-ocean cells create naval units
|
||||
|
||||
const cellTypeMod = type === "generic" ? 1 : cellTypeModifier[type][unit.type]; // cell specific modifier
|
||||
const army = modifier * perc * cellTypeMod; // rural cell army
|
||||
const total = rn(army * stateObj.temp[unit.name] * populationRate); // total troops
|
||||
if (!total) continue;
|
||||
|
||||
let [x, y] = p[i];
|
||||
let n = 0;
|
||||
|
||||
// place naval units to sea
|
||||
if (unit.type === "naval") {
|
||||
const haven = cells.haven[i];
|
||||
[x, y] = p[haven];
|
||||
n = 1;
|
||||
}
|
||||
|
||||
stateObj.temp.platoons.push({
|
||||
cell: i,
|
||||
a: total,
|
||||
t: total,
|
||||
x,
|
||||
y,
|
||||
u: unit.name,
|
||||
n,
|
||||
s: unit.separate,
|
||||
type: unit.type
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// burgs
|
||||
for (const b of pack.burgs) {
|
||||
if (!b.i || b.removed || !b.state || !b.population) continue;
|
||||
|
||||
const biome = cells.biome[b.cell];
|
||||
const state = b.state;
|
||||
const culture = b.culture;
|
||||
const religion = cells.religion[b.cell];
|
||||
|
||||
const stateObj = states[state];
|
||||
let m = (b.population * urbanization) / 100; // basic urban army in percentages
|
||||
if (b.capital) m *= 1.2; // capital has household troops
|
||||
if (culture !== stateObj.culture) m = stateObj.form === "Union" ? m / 1.2 : m / 2; // non-dominant culture
|
||||
if (religion !== cells.religion[stateObj.center]) m = stateObj.form === "Theocracy" ? m / 2.2 : m / 1.4; // non-dominant religion
|
||||
if (cells.f[b.cell] !== cells.f[stateObj.center]) m = stateObj.type === "Naval" ? m / 1.2 : m / 1.8; // different landmass
|
||||
const type = getType(b.cell);
|
||||
|
||||
for (const unit of options.military) {
|
||||
const perc = +unit.urban;
|
||||
if (isNaN(perc) || perc <= 0 || !stateObj.temp[unit.name]) continue;
|
||||
if (!passUnitLimits(unit, biome, state, culture, religion)) continue;
|
||||
if (unit.type === "naval" && (!b.port || !cells.haven[b.cell])) continue; // only ports create naval units
|
||||
|
||||
const mod = type === "generic" ? 1 : burgTypeModifier[type][unit.type]; // cell specific modifier
|
||||
const army = m * perc * mod; // urban cell army
|
||||
const total = rn(army * stateObj.temp[unit.name] * populationRate); // total troops
|
||||
if (!total) continue;
|
||||
|
||||
let [x, y] = p[b.cell];
|
||||
let n = 0;
|
||||
|
||||
// place naval to sea
|
||||
if (unit.type === "naval") {
|
||||
const haven = cells.haven[b.cell];
|
||||
[x, y] = p[haven];
|
||||
n = 1;
|
||||
}
|
||||
|
||||
stateObj.temp.platoons.push({
|
||||
cell: b.cell,
|
||||
a: total,
|
||||
t: total,
|
||||
x,
|
||||
y,
|
||||
u: unit.name,
|
||||
n,
|
||||
s: unit.separate,
|
||||
type: unit.type
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const expected = 3 * populationRate; // expected regiment size
|
||||
const mergeable = (n0, n1) => (!n0.s && !n1.s) || n0.u === n1.u; // check if regiments can be merged
|
||||
|
||||
// get regiments for each state
|
||||
valid.forEach(s => {
|
||||
s.military = createRegiments(s.temp.platoons, s);
|
||||
delete s.temp; // do not store temp data
|
||||
});
|
||||
|
||||
function createRegiments(nodes, s) {
|
||||
if (!nodes.length) return [];
|
||||
|
||||
nodes.sort((a, b) => a.a - b.a); // form regiments in cells with most troops
|
||||
const tree = d3.quadtree(
|
||||
nodes,
|
||||
d => d.x,
|
||||
d => d.y
|
||||
);
|
||||
|
||||
nodes.forEach(node => {
|
||||
tree.remove(node);
|
||||
const overlap = tree.find(node.x, node.y, 20);
|
||||
if (overlap && overlap.t && mergeable(node, overlap)) {
|
||||
merge(node, overlap);
|
||||
return;
|
||||
}
|
||||
if (node.t > expected) return;
|
||||
const r = (expected - node.t) / (node.s ? 40 : 20); // search radius
|
||||
const candidates = tree.findAll(node.x, node.y, r);
|
||||
for (const c of candidates) {
|
||||
if (c.t < expected && mergeable(node, c)) {
|
||||
merge(node, c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// add n0 to n1's ultimate parent
|
||||
function merge(n0, n1) {
|
||||
if (!n1.childen) n1.childen = [n0];
|
||||
else n1.childen.push(n0);
|
||||
if (n0.childen) n0.childen.forEach(n => n1.childen.push(n));
|
||||
n1.t += n0.t;
|
||||
n0.t = 0;
|
||||
}
|
||||
|
||||
// parse regiments data
|
||||
const regiments = nodes
|
||||
.filter(n => n.t)
|
||||
.sort((a, b) => b.t - a.t)
|
||||
.map((r, i) => {
|
||||
const u = {};
|
||||
u[r.u] = r.a;
|
||||
(r.childen || []).forEach(n => (u[n.u] = u[n.u] ? (u[n.u] += n.a) : n.a));
|
||||
return {i, a: r.t, cell: r.cell, x: r.x, y: r.y, bx: r.x, by: r.y, u, n: r.n, name, state: s.i};
|
||||
});
|
||||
|
||||
// generate name for regiments
|
||||
regiments.forEach(r => {
|
||||
r.name = getName(r, regiments);
|
||||
r.icon = getEmblem(r);
|
||||
generateNote(r, s);
|
||||
});
|
||||
|
||||
return regiments;
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateMilitary");
|
||||
};
|
||||
|
||||
const getDefaultOptions = function () {
|
||||
return [
|
||||
{icon: "⚔️", name: "infantry", rural: 0.25, urban: 0.2, crew: 1, power: 1, type: "melee", separate: 0},
|
||||
{icon: "🏹", name: "archers", rural: 0.12, urban: 0.2, crew: 1, power: 1, type: "ranged", separate: 0},
|
||||
{icon: "🐴", name: "cavalry", rural: 0.12, urban: 0.03, crew: 2, power: 2, type: "mounted", separate: 0},
|
||||
{icon: "💣", name: "artillery", rural: 0, urban: 0.03, crew: 8, power: 12, type: "machinery", separate: 0},
|
||||
{icon: "🌊", name: "fleet", rural: 0, urban: 0.015, crew: 100, power: 50, type: "naval", separate: 1}
|
||||
];
|
||||
};
|
||||
|
||||
// utilize si function to make regiment total text fit regiment box
|
||||
const getTotal = reg => (reg.a > (reg.n ? 999 : 99999) ? si(reg.a) : reg.a);
|
||||
|
||||
const getName = function (r, regiments) {
|
||||
const cells = pack.cells;
|
||||
const proper = r.n
|
||||
? null
|
||||
: cells.province[r.cell] && pack.provinces[cells.province[r.cell]]
|
||||
? pack.provinces[cells.province[r.cell]].name
|
||||
: cells.burg[r.cell] && pack.burgs[cells.burg[r.cell]]
|
||||
? pack.burgs[cells.burg[r.cell]].name
|
||||
: null;
|
||||
const number = nth(regiments.filter(reg => reg.n === r.n && reg.i < r.i).length + 1);
|
||||
const form = r.n ? "Fleet" : "Regiment";
|
||||
return `${number}${proper ? ` (${proper}) ` : ` `}${form}`;
|
||||
};
|
||||
|
||||
// get default regiment emblem
|
||||
const getEmblem = function (r) {
|
||||
if (!r.n && !Object.values(r.u).length) return "🔰"; // "Newbie" regiment without troops
|
||||
if (
|
||||
!r.n &&
|
||||
pack.states[r.state].form === "Monarchy" &&
|
||||
pack.cells.burg[r.cell] &&
|
||||
pack.burgs[pack.cells.burg[r.cell]].capital
|
||||
)
|
||||
return "👑"; // "Royal" regiment based in capital
|
||||
const mainUnit = Object.entries(r.u).sort((a, b) => b[1] - a[1])[0][0]; // unit with more troops in regiment
|
||||
const unit = options.military.find(u => u.name === mainUnit);
|
||||
return unit.icon;
|
||||
};
|
||||
|
||||
const generateNote = function (r, s) {
|
||||
const cells = pack.cells;
|
||||
const base =
|
||||
cells.burg[r.cell] && pack.burgs[cells.burg[r.cell]]
|
||||
? pack.burgs[cells.burg[r.cell]].name
|
||||
: cells.province[r.cell] && pack.provinces[cells.province[r.cell]]
|
||||
? pack.provinces[cells.province[r.cell]].fullName
|
||||
: null;
|
||||
const station = base ? `${r.name} is ${r.n ? "based" : "stationed"} in ${base}. ` : "";
|
||||
|
||||
const composition = r.a
|
||||
? Object.keys(r.u)
|
||||
.map(t => `— ${t}: ${r.u[t]}`)
|
||||
.join("\r\n")
|
||||
: null;
|
||||
const troops = composition
|
||||
? `\r\n\r\nRegiment composition in ${options.year} ${options.eraShort}:\r\n${composition}.`
|
||||
: "";
|
||||
|
||||
const campaign = s.campaigns ? ra(s.campaigns) : null;
|
||||
const year = campaign
|
||||
? rand(campaign.start, campaign.end || options.year)
|
||||
: gauss(options.year - 100, 150, 1, options.year - 6);
|
||||
const conflict = campaign ? ` during the ${campaign.name}` : "";
|
||||
const legend = `Regiment was formed in ${year} ${options.era}${conflict}. ${station}${troops}`;
|
||||
notes.push({id: `regiment${s.i}-${r.i}`, name: r.name, legend});
|
||||
};
|
||||
|
||||
return {
|
||||
generate,
|
||||
getDefaultOptions,
|
||||
getName,
|
||||
generateNote,
|
||||
getTotal,
|
||||
getEmblem
|
||||
};
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./military-generator.js.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./military-generator.js_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in military-generator.js_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into military-generator.js_render.md
|
||||
25
procedural/src/engine/support/names-generator_config.md
Normal file
25
procedural/src/engine/support/names-generator_config.md
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
# Config Properties for names-generator.js
|
||||
|
||||
The refactored `names-generator.js` module identified the following configuration properties that were previously read from the DOM:
|
||||
|
||||
## Configuration Properties
|
||||
|
||||
Currently, no direct config properties were identified in this module, as the original code had minimal DOM interaction. The main DOM interaction was:
|
||||
|
||||
- **Map Name Storage**: The original code wrote to `mapName.value` but this was rendering logic that has been removed.
|
||||
|
||||
## Notes
|
||||
|
||||
- The `getMapName()` function previously wrote directly to a DOM element (`mapName.value = name`)
|
||||
- This has been removed and the function now returns the generated name instead
|
||||
- The calling code (Viewer/Client) should handle storing or displaying the generated map name
|
||||
- All name generation functions now operate purely on the data passed to them as parameters
|
||||
|
||||
## Function Signature Changes
|
||||
|
||||
Functions that previously read global state now require data to be passed as parameters:
|
||||
|
||||
- `getCulture()` now requires `cultures` parameter
|
||||
- `getCultureShort()` now requires `cultures` parameter
|
||||
- `getState()` now requires `cultures` parameter
|
||||
- All functions now require `nameBases` and `utils` parameters
|
||||
24
procedural/src/engine/support/names-generator_external.md
Normal file
24
procedural/src/engine/support/names-generator_external.md
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
# External Dependencies for names-generator.js
|
||||
|
||||
The refactored `names-generator.js` module requires the following external dependencies to be imported:
|
||||
|
||||
## Utility Functions
|
||||
- `ERROR` - Error logging flag/function
|
||||
- `WARN` - Warning logging flag/function
|
||||
- `P` - Probability function (returns true/false based on probability)
|
||||
- `ra` - Random array element selector function
|
||||
- `last` - Function to get last character/element of a string/array
|
||||
- `vowel` - Function to check if a character is a vowel
|
||||
- `capitalize` - Function to capitalize a string
|
||||
- `rand` - Random number generator function
|
||||
|
||||
These utilities should be imported from a common utilities module (e.g., `../utils/index.js`) and passed as a `utils` object parameter to the exported functions.
|
||||
|
||||
## Data Dependencies
|
||||
- `nameBases` - Array of name base configurations (passed as parameter)
|
||||
- `cultures` - Culture data object with base references (passed as parameter from pack data)
|
||||
|
||||
## Notes
|
||||
- All global state access has been removed and replaced with parameter injection
|
||||
- The module is now pure and environment-agnostic
|
||||
- No browser or DOM dependencies remain
|
||||
371
procedural/src/engine/support/names-generator_prompt.md
Normal file
371
procedural/src/engine/support/names-generator_prompt.md
Normal file
|
|
@ -0,0 +1,371 @@
|
|||
# names-generator.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `names-generator.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Names = (function () {
|
||||
let chains = [];
|
||||
|
||||
// calculate Markov chain for a namesbase
|
||||
const calculateChain = function (string) {
|
||||
const chain = [];
|
||||
const array = string.split(",");
|
||||
|
||||
for (const n of array) {
|
||||
let name = n.trim().toLowerCase();
|
||||
const basic = !/[^\u0000-\u007f]/.test(name); // basic chars and English rules can be applied
|
||||
|
||||
// split word into pseudo-syllables
|
||||
for (let i = -1, syllable = ""; i < name.length; i += syllable.length || 1, syllable = "") {
|
||||
let prev = name[i] || ""; // pre-onset letter
|
||||
let v = 0; // 0 if no vowels in syllable
|
||||
|
||||
for (let c = i + 1; name[c] && syllable.length < 5; c++) {
|
||||
const that = name[c],
|
||||
next = name[c + 1]; // next char
|
||||
syllable += that;
|
||||
if (syllable === " " || syllable === "-") break; // syllable starts with space or hyphen
|
||||
if (!next || next === " " || next === "-") break; // no need to check
|
||||
|
||||
if (vowel(that)) v = 1; // check if letter is vowel
|
||||
|
||||
// do not split some diphthongs
|
||||
if (that === "y" && next === "e") continue; // 'ye'
|
||||
if (basic) {
|
||||
// English-like
|
||||
if (that === "o" && next === "o") continue; // 'oo'
|
||||
if (that === "e" && next === "e") continue; // 'ee'
|
||||
if (that === "a" && next === "e") continue; // 'ae'
|
||||
if (that === "c" && next === "h") continue; // 'ch'
|
||||
}
|
||||
|
||||
if (vowel(that) === next) break; // two same vowels in a row
|
||||
if (v && vowel(name[c + 2])) break; // syllable has vowel and additional vowel is expected soon
|
||||
}
|
||||
|
||||
if (chain[prev] === undefined) chain[prev] = [];
|
||||
chain[prev].push(syllable);
|
||||
}
|
||||
}
|
||||
|
||||
return chain;
|
||||
};
|
||||
|
||||
const updateChain = i => {
|
||||
chains[i] = nameBases[i]?.b ? calculateChain(nameBases[i].b) : null;
|
||||
};
|
||||
|
||||
const clearChains = () => {
|
||||
chains = [];
|
||||
};
|
||||
|
||||
// generate name using Markov's chain
|
||||
const getBase = function (base, min, max, dupl) {
|
||||
if (base === undefined) return ERROR && console.error("Please define a base");
|
||||
|
||||
if (nameBases[base] === undefined) {
|
||||
if (nameBases[0]) {
|
||||
WARN && console.warn("Namebase " + base + " is not found. First available namebase will be used");
|
||||
base = 0;
|
||||
} else {
|
||||
ERROR && console.error("Namebase " + base + " is not found");
|
||||
return "ERROR";
|
||||
}
|
||||
}
|
||||
|
||||
if (!chains[base]) updateChain(base);
|
||||
|
||||
const data = chains[base];
|
||||
if (!data || data[""] === undefined) {
|
||||
tip("Namesbase " + base + " is incorrect. Please check in namesbase editor", false, "error");
|
||||
ERROR && console.error("Namebase " + base + " is incorrect!");
|
||||
return "ERROR";
|
||||
}
|
||||
|
||||
if (!min) min = nameBases[base].min;
|
||||
if (!max) max = nameBases[base].max;
|
||||
if (dupl !== "") dupl = nameBases[base].d;
|
||||
|
||||
let v = data[""],
|
||||
cur = ra(v),
|
||||
w = "";
|
||||
for (let i = 0; i < 20; i++) {
|
||||
if (cur === "") {
|
||||
// end of word
|
||||
if (w.length < min) {
|
||||
cur = "";
|
||||
w = "";
|
||||
v = data[""];
|
||||
} else break;
|
||||
} else {
|
||||
if (w.length + cur.length > max) {
|
||||
// word too long
|
||||
if (w.length < min) w += cur;
|
||||
break;
|
||||
} else v = data[last(cur)] || data[""];
|
||||
}
|
||||
|
||||
w += cur;
|
||||
cur = ra(v);
|
||||
}
|
||||
|
||||
// parse word to get a final name
|
||||
const l = last(w); // last letter
|
||||
if (l === "'" || l === " " || l === "-") w = w.slice(0, -1); // not allow some characters at the end
|
||||
|
||||
let name = [...w].reduce(function (r, c, i, d) {
|
||||
if (c === d[i + 1] && !dupl.includes(c)) return r; // duplication is not allowed
|
||||
if (!r.length) return c.toUpperCase();
|
||||
if (r.slice(-1) === "-" && c === " ") return r; // remove space after hyphen
|
||||
if (r.slice(-1) === " ") return r + c.toUpperCase(); // capitalize letter after space
|
||||
if (r.slice(-1) === "-") return r + c.toUpperCase(); // capitalize letter after hyphen
|
||||
if (c === "a" && d[i + 1] === "e") return r; // "ae" => "e"
|
||||
if (i + 2 < d.length && c === d[i + 1] && c === d[i + 2]) return r; // remove three same letters in a row
|
||||
return r + c;
|
||||
}, "");
|
||||
|
||||
// join the word if any part has only 1 letter
|
||||
if (name.split(" ").some(part => part.length < 2))
|
||||
name = name
|
||||
.split(" ")
|
||||
.map((p, i) => (i ? p.toLowerCase() : p))
|
||||
.join("");
|
||||
|
||||
if (name.length < 2) {
|
||||
ERROR && console.error("Name is too short! Random name will be selected");
|
||||
name = ra(nameBases[base].b.split(","));
|
||||
}
|
||||
|
||||
return name;
|
||||
};
|
||||
|
||||
// generate name for culture
|
||||
const getCulture = function (culture, min, max, dupl) {
|
||||
if (culture === undefined) return ERROR && console.error("Please define a culture");
|
||||
const base = pack.cultures[culture].base;
|
||||
return getBase(base, min, max, dupl);
|
||||
};
|
||||
|
||||
// generate short name for culture
|
||||
const getCultureShort = function (culture) {
|
||||
if (culture === undefined) return ERROR && console.error("Please define a culture");
|
||||
return getBaseShort(pack.cultures[culture].base);
|
||||
};
|
||||
|
||||
// generate short name for base
|
||||
const getBaseShort = function (base) {
|
||||
const min = nameBases[base] ? nameBases[base].min - 1 : null;
|
||||
const max = min ? Math.max(nameBases[base].max - 2, min) : null;
|
||||
return getBase(base, min, max, "", 0);
|
||||
};
|
||||
|
||||
// generate state name based on capital or random name and culture-specific suffix
|
||||
const getState = function (name, culture, base) {
|
||||
if (name === undefined) return ERROR && console.error("Please define a base name");
|
||||
if (culture === undefined && base === undefined) return ERROR && console.error("Please define a culture");
|
||||
if (base === undefined) base = pack.cultures[culture].base;
|
||||
|
||||
// exclude endings inappropriate for states name
|
||||
if (name.includes(" ")) name = capitalize(name.replace(/ /g, "").toLowerCase()); // don't allow multiword state names
|
||||
if (name.length > 6 && name.slice(-4) === "berg") name = name.slice(0, -4); // remove -berg for any
|
||||
if (name.length > 5 && name.slice(-3) === "ton") name = name.slice(0, -3); // remove -ton for any
|
||||
|
||||
if (base === 5 && ["sk", "ev", "ov"].includes(name.slice(-2))) name = name.slice(0, -2);
|
||||
// remove -sk/-ev/-ov for Ruthenian
|
||||
else if (base === 12) return vowel(name.slice(-1)) ? name : name + "u";
|
||||
// Japanese ends on any vowel or -u
|
||||
else if (base === 18 && P(0.4))
|
||||
name = vowel(name.slice(0, 1).toLowerCase()) ? "Al" + name.toLowerCase() : "Al " + name; // Arabic starts with -Al
|
||||
|
||||
// no suffix for fantasy bases
|
||||
if (base > 32 && base < 42) return name;
|
||||
|
||||
// define if suffix should be used
|
||||
if (name.length > 3 && vowel(name.slice(-1))) {
|
||||
if (vowel(name.slice(-2, -1)) && P(0.85)) name = name.slice(0, -2);
|
||||
// 85% for vv
|
||||
else if (P(0.7)) name = name.slice(0, -1);
|
||||
// ~60% for cv
|
||||
else return name;
|
||||
} else if (P(0.4)) return name; // 60% for cc and vc
|
||||
|
||||
// define suffix
|
||||
let suffix = "ia"; // standard suffix
|
||||
|
||||
const rnd = Math.random(),
|
||||
l = name.length;
|
||||
if (base === 3 && rnd < 0.03 && l < 7) suffix = "terra";
|
||||
// Italian
|
||||
else if (base === 4 && rnd < 0.03 && l < 7) suffix = "terra";
|
||||
// Spanish
|
||||
else if (base === 13 && rnd < 0.03 && l < 7) suffix = "terra";
|
||||
// Portuguese
|
||||
else if (base === 2 && rnd < 0.03 && l < 7) suffix = "terre";
|
||||
// French
|
||||
else if (base === 0 && rnd < 0.5 && l < 7) suffix = "land";
|
||||
// German
|
||||
else if (base === 1 && rnd < 0.4 && l < 7) suffix = "land";
|
||||
// English
|
||||
else if (base === 6 && rnd < 0.3 && l < 7) suffix = "land";
|
||||
// Nordic
|
||||
else if (base === 32 && rnd < 0.1 && l < 7) suffix = "land";
|
||||
// generic Human
|
||||
else if (base === 7 && rnd < 0.1) suffix = "eia";
|
||||
// Greek
|
||||
else if (base === 9 && rnd < 0.35) suffix = "maa";
|
||||
// Finnic
|
||||
else if (base === 15 && rnd < 0.4 && l < 6) suffix = "orszag";
|
||||
// Hungarian
|
||||
else if (base === 16) suffix = rnd < 0.6 ? "yurt" : "eli";
|
||||
// Turkish
|
||||
else if (base === 10) suffix = "guk";
|
||||
// Korean
|
||||
else if (base === 11) suffix = " Guo";
|
||||
// Chinese
|
||||
else if (base === 14) suffix = rnd < 0.5 && l < 6 ? "tlan" : "co";
|
||||
// Nahuatl
|
||||
else if (base === 17 && rnd < 0.8) suffix = "a";
|
||||
// Berber
|
||||
else if (base === 18 && rnd < 0.8) suffix = "a"; // Arabic
|
||||
|
||||
return validateSuffix(name, suffix);
|
||||
};
|
||||
|
||||
function validateSuffix(name, suffix) {
|
||||
if (name.slice(-1 * suffix.length) === suffix) return name; // no suffix if name already ends with it
|
||||
const s1 = suffix.charAt(0);
|
||||
if (name.slice(-1) === s1) name = name.slice(0, -1); // remove name last letter if it's a suffix first letter
|
||||
if (vowel(s1) === vowel(name.slice(-1)) && vowel(s1) === vowel(name.slice(-2, -1))) name = name.slice(0, -1); // remove name last char if 2 last chars are the same type as suffix's 1st
|
||||
if (name.slice(-1) === s1) name = name.slice(0, -1); // remove name last letter if it's a suffix first letter
|
||||
return name + suffix;
|
||||
}
|
||||
|
||||
// generato name for the map
|
||||
const getMapName = function (force) {
|
||||
if (!force && locked("mapName")) return;
|
||||
if (force && locked("mapName")) unlock("mapName");
|
||||
const base = P(0.7) ? 2 : P(0.5) ? rand(0, 6) : rand(0, 31);
|
||||
if (!nameBases[base]) {
|
||||
tip("Namebase is not found", false, "error");
|
||||
return "";
|
||||
}
|
||||
const min = nameBases[base].min - 1;
|
||||
const max = Math.max(nameBases[base].max - 3, min);
|
||||
const baseName = getBase(base, min, max, "", 0);
|
||||
const name = P(0.7) ? addSuffix(baseName) : baseName;
|
||||
mapName.value = name;
|
||||
};
|
||||
|
||||
function addSuffix(name) {
|
||||
const suffix = P(0.8) ? "ia" : "land";
|
||||
if (suffix === "ia" && name.length > 6) name = name.slice(0, -(name.length - 3));
|
||||
else if (suffix === "land" && name.length > 6) name = name.slice(0, -(name.length - 5));
|
||||
return validateSuffix(name, suffix);
|
||||
}
|
||||
|
||||
const getNameBases = function () {
|
||||
// name, min length, max length, letters to allow duplication, multi-word name rate [deprecated]
|
||||
// prettier-ignore
|
||||
return [
|
||||
// real-world bases by Azgaar:
|
||||
{name: "German", i: 0, min: 5, max: 12, d: "lt", m: 0, b: "Achern,Aichhalden,Aitern,Albbruck,Alpirsbach,Altensteig,Althengstett,Appenweier,Auggen,Badenen,Badenweiler,Baiersbronn,Ballrechten,Bellingen,Berghaupten,Bernau,Biberach,Biederbach,Binzen,Birkendorf,Birkenfeld,Bischweier,Blumberg,Bollen,Bollschweil,Bonndorf,Bosingen,Braunlingen,Breisach,Breisgau,Breitnau,Brigachtal,Buchenbach,Buggingen,Buhl,Buhlertal,Calw,Dachsberg,Dobel,Donaueschingen,Dornhan,Dornstetten,Dottingen,Dunningen,Durbach,Durrheim,Ebhausen,Ebringen,Efringen,Egenhausen,Ehrenkirchen,Ehrsberg,Eimeldingen,Eisenbach,Elzach,Elztal,Emmendingen,Endingen,Engelsbrand,Enz,Enzklosterle,Eschbronn,Ettenheim,Ettlingen,Feldberg,Fischerbach,Fischingen,Fluorn,Forbach,Freiamt,Freiburg,Freudenstadt,Friedenweiler,Friesenheim,Frohnd,Furtwangen,Gaggenau,Geisingen,Gengenbach,Gernsbach,Glatt,Glatten,Glottertal,Gorwihl,Gottenheim,Grafenhausen,Grenzach,Griesbach,Gutach,Gutenbach,Hag,Haiterbach,Hardt,Harmersbach,Hasel,Haslach,Hausach,Hausen,Hausern,Heitersheim,Herbolzheim,Herrenalb,Herrischried,Hinterzarten,Hochenschwand,Hofen,Hofstetten,Hohberg,Horb,Horben,Hornberg,Hufingen,Ibach,Ihringen,Inzlingen,Kandern,Kappel,Kappelrodeck,Karlsbad,Karlsruhe,Kehl,Keltern,Kippenheim,Kirchzarten,Konigsfeld,Krozingen,Kuppenheim,Kussaberg,Lahr,Lauchringen,Lauf,Laufenburg,Lautenbach,Lauterbach,Lenzkirch,Liebenzell,Loffenau,Loffingen,Lorrach,Lossburg,Mahlberg,Malsburg,Malsch,March,Marxzell,Marzell,Maulburg,Monchweiler,Muhlenbach,Mullheim,Munstertal,Murg,Nagold,Neubulach,Neuenburg,Neuhausen,Neuried,Neuweiler,Niedereschach,Nordrach,Oberharmersbach,Oberkirch,Oberndorf,Oberbach,Oberried,Oberwolfach,Offenburg,Ohlsbach,Oppenau,Ortenberg,otigheim,Ottenhofen,Ottersweier,Peterstal,Pfaffenweiler,Pfalzgrafenweiler,Pforzheim,Rastatt,Renchen,Rheinau,Rheinfelden,Rheinmunster,Rickenbach,Rippoldsau,Rohrdorf,Rottweil,Rummingen,Rust,Sackingen,Sasbach,Sasbachwalden,Schallbach,Schallstadt,Schapbach,Schenkenzell,Schiltach,Schliengen,Schluchsee,Schomberg,Schonach,Schonau,Schonenberg,Schonwald,Schopfheim,Schopfloch,Schramberg,Schuttertal,Schwenningen,Schworstadt,Seebach,Seelbach,Seewald,Sexau,Simmersfeld,Simonswald,Sinzheim,Solden,Staufen,Stegen,Steinach,Steinen,Steinmauern,Straubenhardt,Stuhlingen,Sulz,Sulzburg,Teinach,Tiefenbronn,Tiengen,Titisee,Todtmoos,Todtnau,Todtnauberg,Triberg,Tunau,Tuningen,uhlingen,Unterkirnach,Reichenbach,Utzenfeld,Villingen,Villingendorf,Vogtsburg,Vohrenbach,Waldachtal,Waldbronn,Waldkirch,Waldshut,Wehr,Weil,Weilheim,Weisenbach,Wembach,Wieden,Wiesental,Wildbad,Wildberg,Winzeln,Wittlingen,Wittnau,Wolfach,Wutach,Wutoschingen,Wyhlen,Zavelstein"},
|
||||
{name: "English", i: 1, min: 6, max: 11, d: "", m: .1, b: "Abingdon,Albrighton,Alcester,Almondbury,Altrincham,Amersham,Andover,Appleby,Ashboume,Atherstone,Aveton,Axbridge,Aylesbury,Baldock,Bamburgh,Barton,Basingstoke,Berden,Bere,Berkeley,Berwick,Betley,Bideford,Bingley,Birmingham,Blandford,Blechingley,Bodmin,Bolton,Bootham,Boroughbridge,Boscastle,Bossinney,Bramber,Brampton,Brasted,Bretford,Bridgetown,Bridlington,Bromyard,Bruton,Buckingham,Bungay,Burton,Calne,Cambridge,Canterbury,Carlisle,Castleton,Caus,Charmouth,Chawleigh,Chichester,Chillington,Chinnor,Chipping,Chisbury,Cleobury,Clifford,Clifton,Clitheroe,Cockermouth,Coleshill,Combe,Congleton,Crafthole,Crediton,Cuddenbeck,Dalton,Darlington,Dodbrooke,Drax,Dudley,Dunstable,Dunster,Dunwich,Durham,Dymock,Exeter,Exning,Faringdon,Felton,Fenny,Finedon,Flookburgh,Fowey,Frampton,Gateshead,Gatton,Godmanchester,Grampound,Grantham,Guildford,Halesowen,Halton,Harbottle,Harlow,Hatfield,Hatherleigh,Haydon,Helston,Henley,Hertford,Heytesbury,Hinckley,Hitchin,Holme,Hornby,Horsham,Kendal,Kenilworth,Kilkhampton,Kineton,Kington,Kinver,Kirby,Knaresborough,Knutsford,Launceston,Leighton,Lewes,Linton,Louth,Luton,Lyme,Lympstone,Macclesfield,Madeley,Malborough,Maldon,Manchester,Manningtree,Marazion,Marlborough,Marshfield,Mere,Merryfield,Middlewich,Midhurst,Milborne,Mitford,Modbury,Montacute,Mousehole,Newbiggin,Newborough,Newbury,Newenden,Newent,Norham,Northleach,Noss,Oakham,Olney,Orford,Ormskirk,Oswestry,Padstow,Paignton,Penkneth,Penrith,Penzance,Pershore,Petersfield,Pevensey,Pickering,Pilton,Pontefract,Portsmouth,Preston,Quatford,Reading,Redcliff,Retford,Rockingham,Romney,Rothbury,Rothwell,Salisbury,Saltash,Seaford,Seasalter,Sherston,Shifnal,Shoreham,Sidmouth,Skipsea,Skipton,Solihull,Somerton,Southam,Southwark,Standon,Stansted,Stapleton,Stottesdon,Sudbury,Swavesey,Tamerton,Tarporley,Tetbury,Thatcham,Thaxted,Thetford,Thornbury,Tintagel,Tiverton,Torksey,Totnes,Towcester,Tregoney,Trematon,Tutbury,Uxbridge,Wallingford,Wareham,Warenmouth,Wargrave,Warton,Watchet,Watford,Wendover,Westbury,Westcheap,Weymouth,Whitford,Wickwar,Wigan,Wigmore,Winchelsea,Winkleigh,Wiscombe,Witham,Witheridge,Wiveliscombe,Woodbury,Yeovil"},
|
||||
// additional by Avengium:
|
||||
{name: "Levantine", i: 42, min: 4, max: 12, d: "ankprs", m: 0, b: "Adme,Adramet,Agadir,Akko,Akzib,Alimas,Alis-Ubbo,Alqosh,Amid,Ammon,Ampi,Amurru,Andarig,Anpa,Araden,Aram,Arwad,Ashkelon,Athar,Atiq,Aza,Azeka,Baalbek,Babel,Batrun,Beerot,Beersheba,Beit Shemesh,Berytus,Bet Agus,Bet Anya,Beth-Horon,Bethel,Bethlehem,Bethuel,Bet Nahrin,Bet Nohadra,Bet Zalin,Birmula,Biruta,Bit Agushi,Bitan,Bit Zamani,Cerne,Dammeseq,Darmsuq,Dor,Eddial,Eden Ekron,Elah,Emek,Emun,Ephratah,Eyn Ganim,Finike,Gades,Galatia,Gaza,Gebal,Gedera,Gerizzim,Gethsemane,Gibeon,Gilead,Gilgal,Golgotha,Goshen,Gytte,Hagalil,Haifa,Halab,Haqel Dma,Har Habayit,Har Nevo,Har Pisga,Havilah,Hazor,Hebron,Hormah,Iboshim,Iriho,Irinem,Irridu,Israel,Kadesh,Kanaan,Kapara,Karaly,Kart-Hadasht,Keret Chadeshet,Kernah,Kesed,Keysariya,Kfar,Kfar Nahum,Khalibon,Khalpe,Khamat,Kiryat,Kittim,Kurda,Lapethos,Larna,Lepqis,Lepriptza,Liksos,Lod,Luv,Malaka,Malet,Marat,Megido,Melitta,Merdin,Metsada,Mishmarot,Mitzrayim,Moab,Mopsos,Motye,Mukish,Nampigi,Nampigu,Natzrat,Nimrud,Nineveh,Nob,Nuhadra,Oea,Ofir,Oyat,Phineka,Phoenicus,Pleshet,Qart-Tubah Sarepta,Qatna,Rabat Amon,Rakkath,Ramat Aviv,Ramitha,Ramta,Rehovot,Reshef,Rushadir,Rushakad,Samrin,Sefarad,Sehyon,Sepat,Sexi,Sharon,Shechem,Shefelat,Shfanim,Shiloh,Shmaya,Shomron,Sidon,Sinay,Sis,Solki,Sur,Suria,Tabetu,Tadmur,Tarshish,Tartus,Teberya,Tefessedt,Tekoa,Teyman,Tinga,Tipasa,Tsabratan,Tur Abdin,Tzarfat,Tziyon,Tzor,Ugarit,Unubaal,Ureshlem,Urhay,Urushalim,Vaga,Yaffa,Yamhad,Yam hamelach,Yam Kineret,Yamutbal,Yathrib,Yaudi,Yavne,Yehuda,Yerushalayim,Yev,Yevus,Yizreel,Yurdnan,Zarefat,Zeboim,Zeurta,Zeytim,Zikhron,Zmurna"}
|
||||
];
|
||||
};
|
||||
|
||||
return {
|
||||
getBase,
|
||||
getCulture,
|
||||
getCultureShort,
|
||||
getBaseShort,
|
||||
getState,
|
||||
updateChain,
|
||||
clearChains,
|
||||
getNameBases,
|
||||
getMapName,
|
||||
calculateChain
|
||||
};
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./names-generator.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./names-generator_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in names-generator_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into names-generator_render.md
|
||||
46
procedural/src/engine/support/names-generator_render.md
Normal file
46
procedural/src/engine/support/names-generator_render.md
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
# Removed Rendering/UI Logic from names-generator.js
|
||||
|
||||
The following rendering and UI logic was removed from the `names-generator.js` module and should be implemented in the Viewer/Client application:
|
||||
|
||||
## DOM Manipulation
|
||||
|
||||
### Map Name Storage
|
||||
**Original Code (lines 325):**
|
||||
```javascript
|
||||
mapName.value = name;
|
||||
```
|
||||
|
||||
**Location**: `getMapName()` function
|
||||
**Description**: Direct DOM manipulation to set the value of a map name input field
|
||||
**Replacement**: The `getMapName()` function now returns the generated name instead of setting it directly
|
||||
|
||||
## UI Feedback and State Management
|
||||
|
||||
### Lock State Checks
|
||||
**Original Code (lines 314-315):**
|
||||
```javascript
|
||||
if (!force && locked("mapName")) return;
|
||||
if (force && locked("mapName")) unlock("mapName");
|
||||
```
|
||||
|
||||
**Location**: `getMapName()` function
|
||||
**Description**: UI state management for locking/unlocking map name generation
|
||||
**Replacement**: These checks should be handled by the Viewer/Client before calling `getMapName()`
|
||||
|
||||
### User Notifications
|
||||
**Original Code (lines 149, 318):**
|
||||
```javascript
|
||||
tip("Namesbase " + base + " is incorrect. Please check in namesbase editor", false, "error");
|
||||
tip("Namebase is not found", false, "error");
|
||||
```
|
||||
|
||||
**Location**: `getBase()` and `getMapName()` functions
|
||||
**Description**: UI notifications/tooltips to inform user of errors
|
||||
**Replacement**: Error handling should be done by the Viewer/Client based on return values or thrown errors
|
||||
|
||||
## Implementation Notes for Viewer/Client
|
||||
|
||||
1. **Map Name Generation**: Call `getMapName()` and handle the returned value by setting it to the appropriate DOM element
|
||||
2. **Lock State Management**: Implement lock/unlock logic in the UI layer before calling name generation functions
|
||||
3. **Error Display**: Handle error states and display appropriate user feedback when name generation fails
|
||||
4. **State Persistence**: Handle saving/loading of generated names as needed by the application
|
||||
92
procedural/src/engine/support/ocean-layers-original.txt
Normal file
92
procedural/src/engine/support/ocean-layers-original.txt
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
"use strict";
|
||||
|
||||
window.OceanLayers = (function () {
|
||||
let cells, vertices, pointsN, used;
|
||||
|
||||
const OceanLayers = function OceanLayers() {
|
||||
const outline = oceanLayers.attr("layers");
|
||||
if (outline === "none") return;
|
||||
TIME && console.time("drawOceanLayers");
|
||||
|
||||
lineGen.curve(d3.curveBasisClosed);
|
||||
(cells = grid.cells), (pointsN = grid.cells.i.length), (vertices = grid.vertices);
|
||||
const limits = outline === "random" ? randomizeOutline() : outline.split(",").map(s => +s);
|
||||
|
||||
const chains = [];
|
||||
const opacity = rn(0.4 / limits.length, 2);
|
||||
used = new Uint8Array(pointsN); // to detect already passed cells
|
||||
|
||||
for (const i of cells.i) {
|
||||
const t = cells.t[i];
|
||||
if (t > 0) continue;
|
||||
if (used[i] || !limits.includes(t)) continue;
|
||||
const start = findStart(i, t);
|
||||
if (!start) continue;
|
||||
used[i] = 1;
|
||||
const chain = connectVertices(start, t); // vertices chain to form a path
|
||||
if (chain.length < 4) continue;
|
||||
const relax = 1 + t * -2; // select only n-th point
|
||||
const relaxed = chain.filter((v, i) => !(i % relax) || vertices.c[v].some(c => c >= pointsN));
|
||||
if (relaxed.length < 4) continue;
|
||||
const points = clipPoly(
|
||||
relaxed.map(v => vertices.p[v]),
|
||||
1
|
||||
);
|
||||
chains.push([t, points]);
|
||||
}
|
||||
|
||||
for (const t of limits) {
|
||||
const layer = chains.filter(c => c[0] === t);
|
||||
let path = layer.map(c => round(lineGen(c[1]))).join("");
|
||||
if (path) oceanLayers.append("path").attr("d", path).attr("fill", "#ecf2f9").attr("fill-opacity", opacity);
|
||||
}
|
||||
|
||||
// find eligible cell vertex to start path detection
|
||||
function findStart(i, t) {
|
||||
if (cells.b[i]) return cells.v[i].find(v => vertices.c[v].some(c => c >= pointsN)); // map border cell
|
||||
return cells.v[i][cells.c[i].findIndex(c => cells.t[c] < t || !cells.t[c])];
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("drawOceanLayers");
|
||||
};
|
||||
|
||||
function randomizeOutline() {
|
||||
const limits = [];
|
||||
let odd = 0.2;
|
||||
for (let l = -9; l < 0; l++) {
|
||||
if (P(odd)) {
|
||||
odd = 0.2;
|
||||
limits.push(l);
|
||||
} else {
|
||||
odd *= 2;
|
||||
}
|
||||
}
|
||||
return limits;
|
||||
}
|
||||
|
||||
// connect vertices to chain
|
||||
function connectVertices(start, t) {
|
||||
const chain = []; // vertices chain to form a path
|
||||
for (let i = 0, current = start; i === 0 || (current !== start && i < 10000); i++) {
|
||||
const prev = chain[chain.length - 1]; // previous vertex in chain
|
||||
chain.push(current); // add current vertex to sequence
|
||||
const c = vertices.c[current]; // cells adjacent to vertex
|
||||
c.filter(c => cells.t[c] === t).forEach(c => (used[c] = 1));
|
||||
const v = vertices.v[current]; // neighboring vertices
|
||||
const c0 = !cells.t[c[0]] || cells.t[c[0]] === t - 1;
|
||||
const c1 = !cells.t[c[1]] || cells.t[c[1]] === t - 1;
|
||||
const c2 = !cells.t[c[2]] || cells.t[c[2]] === t - 1;
|
||||
if (v[0] !== undefined && v[0] !== prev && c0 !== c1) current = v[0];
|
||||
else if (v[1] !== undefined && v[1] !== prev && c1 !== c2) current = v[1];
|
||||
else if (v[2] !== undefined && v[2] !== prev && c0 !== c2) current = v[2];
|
||||
if (current === chain[chain.length - 1]) {
|
||||
ERROR && console.error("Next vertex is not found");
|
||||
break;
|
||||
}
|
||||
}
|
||||
chain.push(chain[0]); // push first vertex as the last one
|
||||
return chain;
|
||||
}
|
||||
|
||||
return OceanLayers;
|
||||
})();
|
||||
94
procedural/src/engine/support/ocean-layers-refactor.txt
Normal file
94
procedural/src/engine/support/ocean-layers-refactor.txt
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
"use strict";
|
||||
|
||||
export function generateOceanLayers(grid, config, utils) {
|
||||
const { lineGen, clipPoly, round, rn, P } = utils;
|
||||
|
||||
if (config.outline === "none") return { layers: [] };
|
||||
|
||||
const cells = grid.cells;
|
||||
const pointsN = grid.cells.i.length;
|
||||
const vertices = grid.vertices;
|
||||
const limits = config.outline === "random" ? randomizeOutline(P) : config.outline.split(",").map(s => +s);
|
||||
|
||||
const chains = [];
|
||||
const opacity = rn(0.4 / limits.length, 2);
|
||||
const used = new Uint8Array(pointsN); // to detect already passed cells
|
||||
|
||||
for (const i of cells.i) {
|
||||
const t = cells.t[i];
|
||||
if (t > 0) continue;
|
||||
if (used[i] || !limits.includes(t)) continue;
|
||||
const start = findStart(i, t, cells, vertices, pointsN);
|
||||
if (!start) continue;
|
||||
used[i] = 1;
|
||||
const chain = connectVertices(start, t, cells, vertices, pointsN, used); // vertices chain to form a path
|
||||
if (chain.length < 4) continue;
|
||||
const relax = 1 + t * -2; // select only n-th point
|
||||
const relaxed = chain.filter((v, i) => !(i % relax) || vertices.c[v].some(c => c >= pointsN));
|
||||
if (relaxed.length < 4) continue;
|
||||
const points = clipPoly(
|
||||
relaxed.map(v => vertices.p[v]),
|
||||
1
|
||||
);
|
||||
chains.push([t, points]);
|
||||
}
|
||||
|
||||
const layers = [];
|
||||
for (const t of limits) {
|
||||
const layer = chains.filter(c => c[0] === t);
|
||||
const paths = layer.map(c => round(lineGen(c[1]))).filter(path => path);
|
||||
if (paths.length > 0) {
|
||||
layers.push({
|
||||
type: t,
|
||||
paths: paths,
|
||||
opacity: opacity
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return { layers };
|
||||
}
|
||||
|
||||
function randomizeOutline(P) {
|
||||
const limits = [];
|
||||
let odd = 0.2;
|
||||
for (let l = -9; l < 0; l++) {
|
||||
if (P(odd)) {
|
||||
odd = 0.2;
|
||||
limits.push(l);
|
||||
} else {
|
||||
odd *= 2;
|
||||
}
|
||||
}
|
||||
return limits;
|
||||
}
|
||||
|
||||
// find eligible cell vertex to start path detection
|
||||
function findStart(i, t, cells, vertices, pointsN) {
|
||||
if (cells.b[i]) return cells.v[i].find(v => vertices.c[v].some(c => c >= pointsN)); // map border cell
|
||||
return cells.v[i][cells.c[i].findIndex(c => cells.t[c] < t || !cells.t[c])];
|
||||
}
|
||||
|
||||
// connect vertices to chain
|
||||
function connectVertices(start, t, cells, vertices, pointsN, used) {
|
||||
const chain = []; // vertices chain to form a path
|
||||
for (let i = 0, current = start; i === 0 || (current !== start && i < 10000); i++) {
|
||||
const prev = chain[chain.length - 1]; // previous vertex in chain
|
||||
chain.push(current); // add current vertex to sequence
|
||||
const c = vertices.c[current]; // cells adjacent to vertex
|
||||
c.filter(c => cells.t[c] === t).forEach(c => (used[c] = 1));
|
||||
const v = vertices.v[current]; // neighboring vertices
|
||||
const c0 = !cells.t[c[0]] || cells.t[c[0]] === t - 1;
|
||||
const c1 = !cells.t[c[1]] || cells.t[c[1]] === t - 1;
|
||||
const c2 = !cells.t[c[2]] || cells.t[c[2]] === t - 1;
|
||||
if (v[0] !== undefined && v[0] !== prev && c0 !== c1) current = v[0];
|
||||
else if (v[1] !== undefined && v[1] !== prev && c1 !== c2) current = v[1];
|
||||
else if (v[2] !== undefined && v[2] !== prev && c0 !== c2) current = v[2];
|
||||
if (current === chain[chain.length - 1]) {
|
||||
console.error("Next vertex is not found");
|
||||
break;
|
||||
}
|
||||
}
|
||||
chain.push(chain[0]); // push first vertex as the last one
|
||||
return chain;
|
||||
}
|
||||
27
procedural/src/engine/support/ocean-layers_config.md
Normal file
27
procedural/src/engine/support/ocean-layers_config.md
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
# Config Properties for ocean-layers.js
|
||||
|
||||
The refactored `ocean-layers.js` module requires the following configuration properties:
|
||||
|
||||
## Required Config Properties
|
||||
|
||||
### `outline`
|
||||
- **Type**: `string`
|
||||
- **Description**: Defines the ocean layer outline configuration
|
||||
- **Values**:
|
||||
- `"none"` - No ocean layers will be generated
|
||||
- `"random"` - Use randomized outline limits
|
||||
- Comma-separated numbers (e.g., `"-1,-2,-3"`) - Specific depth limits for layer generation
|
||||
- **Original DOM Source**: `oceanLayers.attr("layers")`
|
||||
- **Usage**: Controls which ocean depth levels should have visible layers drawn
|
||||
|
||||
## Example Config Object
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
outline: "-1,-2,-3" // Generate layers for depths -1, -2, and -3
|
||||
};
|
||||
```
|
||||
|
||||
## Migration Notes
|
||||
|
||||
The original code read this value directly from a DOM element's `layers` attribute. In the refactored version, this configuration must be provided via the `config` parameter to maintain environment independence.
|
||||
17
procedural/src/engine/support/ocean-layers_external.md
Normal file
17
procedural/src/engine/support/ocean-layers_external.md
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
# External Dependencies for ocean-layers.js
|
||||
|
||||
The refactored `ocean-layers.js` module requires the following external utilities to be imported:
|
||||
|
||||
## Required Utilities (from utils object)
|
||||
|
||||
- `lineGen` - D3 line generator for creating SVG path strings from point arrays
|
||||
- `clipPoly` - Function to clip polygons, likely for map boundary handling
|
||||
- `round` - Rounding utility function for numeric precision
|
||||
- `rn` - Random number utility function
|
||||
- `P` - Probability utility function for random boolean generation
|
||||
|
||||
These utilities should be passed in via the `utils` parameter when calling `generateOceanLayers()`.
|
||||
|
||||
## Note on D3 Dependency
|
||||
|
||||
The `lineGen` utility appears to be a D3.js line generator that was previously accessed globally. The engine module now receives this as a dependency, maintaining separation from browser-specific D3 imports.
|
||||
176
procedural/src/engine/support/ocean-layers_prompt.md
Normal file
176
procedural/src/engine/support/ocean-layers_prompt.md
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
# ocean-layers.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `ocean-layers.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.OceanLayers = (function () {
|
||||
let cells, vertices, pointsN, used;
|
||||
|
||||
const OceanLayers = function OceanLayers() {
|
||||
const outline = oceanLayers.attr("layers");
|
||||
if (outline === "none") return;
|
||||
TIME && console.time("drawOceanLayers");
|
||||
|
||||
lineGen.curve(d3.curveBasisClosed);
|
||||
(cells = grid.cells), (pointsN = grid.cells.i.length), (vertices = grid.vertices);
|
||||
const limits = outline === "random" ? randomizeOutline() : outline.split(",").map(s => +s);
|
||||
|
||||
const chains = [];
|
||||
const opacity = rn(0.4 / limits.length, 2);
|
||||
used = new Uint8Array(pointsN); // to detect already passed cells
|
||||
|
||||
for (const i of cells.i) {
|
||||
const t = cells.t[i];
|
||||
if (t > 0) continue;
|
||||
if (used[i] || !limits.includes(t)) continue;
|
||||
const start = findStart(i, t);
|
||||
if (!start) continue;
|
||||
used[i] = 1;
|
||||
const chain = connectVertices(start, t); // vertices chain to form a path
|
||||
if (chain.length < 4) continue;
|
||||
const relax = 1 + t * -2; // select only n-th point
|
||||
const relaxed = chain.filter((v, i) => !(i % relax) || vertices.c[v].some(c => c >= pointsN));
|
||||
if (relaxed.length < 4) continue;
|
||||
const points = clipPoly(
|
||||
relaxed.map(v => vertices.p[v]),
|
||||
1
|
||||
);
|
||||
chains.push([t, points]);
|
||||
}
|
||||
|
||||
for (const t of limits) {
|
||||
const layer = chains.filter(c => c[0] === t);
|
||||
let path = layer.map(c => round(lineGen(c[1]))).join("");
|
||||
if (path) oceanLayers.append("path").attr("d", path).attr("fill", "#ecf2f9").attr("fill-opacity", opacity);
|
||||
}
|
||||
|
||||
// find eligible cell vertex to start path detection
|
||||
function findStart(i, t) {
|
||||
if (cells.b[i]) return cells.v[i].find(v => vertices.c[v].some(c => c >= pointsN)); // map border cell
|
||||
return cells.v[i][cells.c[i].findIndex(c => cells.t[c] < t || !cells.t[c])];
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("drawOceanLayers");
|
||||
};
|
||||
|
||||
function randomizeOutline() {
|
||||
const limits = [];
|
||||
let odd = 0.2;
|
||||
for (let l = -9; l < 0; l++) {
|
||||
if (P(odd)) {
|
||||
odd = 0.2;
|
||||
limits.push(l);
|
||||
} else {
|
||||
odd *= 2;
|
||||
}
|
||||
}
|
||||
return limits;
|
||||
}
|
||||
|
||||
// connect vertices to chain
|
||||
function connectVertices(start, t) {
|
||||
const chain = []; // vertices chain to form a path
|
||||
for (let i = 0, current = start; i === 0 || (current !== start && i < 10000); i++) {
|
||||
const prev = chain[chain.length - 1]; // previous vertex in chain
|
||||
chain.push(current); // add current vertex to sequence
|
||||
const c = vertices.c[current]; // cells adjacent to vertex
|
||||
c.filter(c => cells.t[c] === t).forEach(c => (used[c] = 1));
|
||||
const v = vertices.v[current]; // neighboring vertices
|
||||
const c0 = !cells.t[c[0]] || cells.t[c[0]] === t - 1;
|
||||
const c1 = !cells.t[c[1]] || cells.t[c[1]] === t - 1;
|
||||
const c2 = !cells.t[c[2]] || cells.t[c[2]] === t - 1;
|
||||
if (v[0] !== undefined && v[0] !== prev && c0 !== c1) current = v[0];
|
||||
else if (v[1] !== undefined && v[1] !== prev && c1 !== c2) current = v[1];
|
||||
else if (v[2] !== undefined && v[2] !== prev && c0 !== c2) current = v[2];
|
||||
if (current === chain[chain.length - 1]) {
|
||||
ERROR && console.error("Next vertex is not found");
|
||||
break;
|
||||
}
|
||||
}
|
||||
chain.push(chain[0]); // push first vertex as the last one
|
||||
return chain;
|
||||
}
|
||||
|
||||
return OceanLayers;
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./ocean-layers.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./ocean-layers_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in ocean-layers_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into ocean-layers_render.md
|
||||
55
procedural/src/engine/support/ocean-layers_render.md
Normal file
55
procedural/src/engine/support/ocean-layers_render.md
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
# Removed Rendering Logic from ocean-layers.js
|
||||
|
||||
The following DOM manipulation and SVG rendering code blocks were removed from the engine module and should be implemented in the Viewer application:
|
||||
|
||||
## Removed DOM/SVG Rendering Code
|
||||
|
||||
### 1. DOM Configuration Reading
|
||||
**Original Code (Line 79):**
|
||||
```javascript
|
||||
const outline = oceanLayers.attr("layers");
|
||||
```
|
||||
**Reason for Removal**: Direct DOM element access for reading configuration
|
||||
|
||||
### 2. SVG Path Creation and Styling
|
||||
**Original Code (Line 113):**
|
||||
```javascript
|
||||
if (path) oceanLayers.append("path").attr("d", path).attr("fill", "#ecf2f9").attr("fill-opacity", opacity);
|
||||
```
|
||||
**Reason for Removal**: Direct SVG DOM manipulation for rendering ocean layer paths
|
||||
|
||||
### 3. Performance Timing (Debug)
|
||||
**Original Code (Lines 81, 122):**
|
||||
```javascript
|
||||
TIME && console.time("drawOceanLayers");
|
||||
// ... at end of function ...
|
||||
TIME && console.timeEnd("drawOceanLayers");
|
||||
```
|
||||
**Reason for Removal**: Debug/timing logic should be handled by the viewer application
|
||||
|
||||
## Viewer Implementation Guidance
|
||||
|
||||
The Viewer application should:
|
||||
|
||||
1. **Configuration**: Read the `layers` attribute from the `oceanLayers` DOM element and pass it as `config.outline`
|
||||
2. **Rendering**: Take the returned `layers` array and create SVG `<path>` elements with:
|
||||
- `d` attribute set to each path string
|
||||
- `fill` attribute set to `#ecf2f9`
|
||||
- `fill-opacity` attribute set to the calculated opacity value
|
||||
3. **Performance**: Optionally implement timing logic using `console.time/timeEnd` if needed
|
||||
|
||||
## Data Structure Returned by Engine
|
||||
|
||||
The engine now returns a structured object instead of directly manipulating the DOM:
|
||||
|
||||
```javascript
|
||||
{
|
||||
layers: [
|
||||
{
|
||||
type: -1, // depth level
|
||||
paths: ["M10,20L30,40..."], // array of SVG path strings
|
||||
opacity: 0.13 // calculated opacity value
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
367
procedural/src/engine/support/original_resample.txt
Normal file
367
procedural/src/engine/support/original_resample.txt
Normal file
|
|
@ -0,0 +1,367 @@
|
|||
"use strict";
|
||||
|
||||
window.Resample = (function () {
|
||||
/*
|
||||
generate new map based on an existing one (resampling parentMap)
|
||||
parentMap: {grid, pack, notes} from original map
|
||||
projection: f(Number, Number) -> [Number, Number]
|
||||
inverse: f(Number, Number) -> [Number, Number]
|
||||
scale: Number
|
||||
*/
|
||||
function process({projection, inverse, scale}) {
|
||||
const parentMap = {grid: deepCopy(grid), pack: deepCopy(pack), notes: deepCopy(notes)};
|
||||
const riversData = saveRiversData(pack.rivers);
|
||||
|
||||
grid = generateGrid();
|
||||
pack = {};
|
||||
notes = parentMap.notes;
|
||||
|
||||
resamplePrimaryGridData(parentMap, inverse, scale);
|
||||
|
||||
Features.markupGrid();
|
||||
addLakesInDeepDepressions();
|
||||
openNearSeaLakes();
|
||||
|
||||
OceanLayers();
|
||||
calculateMapCoordinates();
|
||||
calculateTemperatures();
|
||||
|
||||
reGraph();
|
||||
Features.markupPack();
|
||||
createDefaultRuler();
|
||||
|
||||
restoreCellData(parentMap, inverse, scale);
|
||||
restoreRivers(riversData, projection, scale);
|
||||
restoreCultures(parentMap, projection);
|
||||
restoreBurgs(parentMap, projection, scale);
|
||||
restoreStates(parentMap, projection);
|
||||
restoreRoutes(parentMap, projection);
|
||||
restoreReligions(parentMap, projection);
|
||||
restoreProvinces(parentMap);
|
||||
restoreFeatureDetails(parentMap, inverse);
|
||||
restoreMarkers(parentMap, projection);
|
||||
restoreZones(parentMap, projection, scale);
|
||||
|
||||
showStatistics();
|
||||
}
|
||||
|
||||
function resamplePrimaryGridData(parentMap, inverse, scale) {
|
||||
grid.cells.h = new Uint8Array(grid.points.length);
|
||||
grid.cells.temp = new Int8Array(grid.points.length);
|
||||
grid.cells.prec = new Uint8Array(grid.points.length);
|
||||
|
||||
grid.points.forEach(([x, y], newGridCell) => {
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentPackCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
const parentGridCell = parentMap.pack.cells.g[parentPackCell];
|
||||
|
||||
grid.cells.h[newGridCell] = parentMap.grid.cells.h[parentGridCell];
|
||||
grid.cells.temp[newGridCell] = parentMap.grid.cells.temp[parentGridCell];
|
||||
grid.cells.prec[newGridCell] = parentMap.grid.cells.prec[parentGridCell];
|
||||
});
|
||||
|
||||
if (scale >= 2) smoothHeightmap();
|
||||
}
|
||||
|
||||
function smoothHeightmap() {
|
||||
grid.cells.h.forEach((height, newGridCell) => {
|
||||
const heights = [height, ...grid.cells.c[newGridCell].map(c => grid.cells.h[c])];
|
||||
const meanHeight = d3.mean(heights);
|
||||
grid.cells.h[newGridCell] = isWater(grid, newGridCell) ? Math.min(meanHeight, 19) : Math.max(meanHeight, 20);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCellData(parentMap, inverse, scale) {
|
||||
pack.cells.biome = new Uint8Array(pack.cells.i.length);
|
||||
pack.cells.fl = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.s = new Int16Array(pack.cells.i.length);
|
||||
pack.cells.pop = new Float32Array(pack.cells.i.length);
|
||||
pack.cells.culture = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.state = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.burg = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.religion = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.province = new Uint16Array(pack.cells.i.length);
|
||||
|
||||
const parentPackCellGroups = groupCellsByType(parentMap.pack);
|
||||
const parentPackLandCellsQuadtree = d3.quadtree(parentPackCellGroups.land);
|
||||
|
||||
for (const newPackCell of pack.cells.i) {
|
||||
const [x, y] = inverse(...pack.cells.p[newPackCell]);
|
||||
if (isWater(pack, newPackCell)) continue;
|
||||
|
||||
const parentPackCell = parentPackLandCellsQuadtree.find(x, y, Infinity)[2];
|
||||
const parentCellArea = parentMap.pack.cells.area[parentPackCell];
|
||||
const areaRatio = pack.cells.area[newPackCell] / parentCellArea;
|
||||
const scaleRatio = areaRatio / scale;
|
||||
|
||||
pack.cells.biome[newPackCell] = parentMap.pack.cells.biome[parentPackCell];
|
||||
pack.cells.fl[newPackCell] = parentMap.pack.cells.fl[parentPackCell];
|
||||
pack.cells.s[newPackCell] = parentMap.pack.cells.s[parentPackCell] * scaleRatio;
|
||||
pack.cells.pop[newPackCell] = parentMap.pack.cells.pop[parentPackCell] * scaleRatio;
|
||||
pack.cells.culture[newPackCell] = parentMap.pack.cells.culture[parentPackCell];
|
||||
pack.cells.state[newPackCell] = parentMap.pack.cells.state[parentPackCell];
|
||||
pack.cells.religion[newPackCell] = parentMap.pack.cells.religion[parentPackCell];
|
||||
pack.cells.province[newPackCell] = parentMap.pack.cells.province[parentPackCell];
|
||||
}
|
||||
}
|
||||
|
||||
function saveRiversData(parentRivers) {
|
||||
return parentRivers.map(river => {
|
||||
const meanderedPoints = Rivers.addMeandering(river.cells, river.points);
|
||||
return {...river, meanderedPoints};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRivers(riversData, projection, scale) {
|
||||
pack.cells.r = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.conf = new Uint8Array(pack.cells.i.length);
|
||||
|
||||
pack.rivers = riversData
|
||||
.map(river => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
river.meanderedPoints.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const cells = points.map(point => findCell(...point));
|
||||
cells.forEach(cellId => {
|
||||
if (pack.cells.r[cellId]) pack.cells.conf[cellId] = 1;
|
||||
pack.cells.r[cellId] = river.i;
|
||||
});
|
||||
|
||||
const widthFactor = river.widthFactor * scale;
|
||||
return {...river, cells, points, source: cells.at(0), mouth: cells.at(-2), widthFactor};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.rivers.forEach(river => {
|
||||
river.basin = Rivers.getBasin(river.i);
|
||||
river.length = Rivers.getApproximateLength(river.points);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCultures(parentMap, projection) {
|
||||
const validCultures = new Set(pack.cells.culture);
|
||||
const culturePoles = getPolesOfInaccessibility(pack, cellId => pack.cells.culture[cellId]);
|
||||
pack.cultures = parentMap.pack.cultures.map(culture => {
|
||||
if (!culture.i || culture.removed) return culture;
|
||||
if (!validCultures.has(culture.i)) return {...culture, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[culture.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : culturePoles[culture.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...culture, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreBurgs(parentMap, projection, scale) {
|
||||
const packLandCellsQuadtree = d3.quadtree(groupCellsByType(pack).land);
|
||||
const findLandCell = (x, y) => packLandCellsQuadtree.find(x, y, Infinity)?.[2];
|
||||
|
||||
pack.burgs = parentMap.pack.burgs.map(burg => {
|
||||
if (!burg.i || burg.removed) return burg;
|
||||
burg.population *= scale; // adjust for populationRate change
|
||||
|
||||
const [xp, yp] = projection(burg.x, burg.y);
|
||||
if (!isInMap(xp, yp)) return {...burg, removed: true, lock: false};
|
||||
|
||||
const closestCell = findCell(xp, yp);
|
||||
const cell = isWater(pack, closestCell) ? findLandCell(xp, yp) : closestCell;
|
||||
|
||||
if (pack.cells.burg[cell]) {
|
||||
WARN && console.warn(`Cell ${cell} already has a burg. Removing burg ${burg.name} (${burg.i})`);
|
||||
return {...burg, removed: true, lock: false};
|
||||
}
|
||||
|
||||
pack.cells.burg[cell] = burg.i;
|
||||
const [x, y] = getBurgCoordinates(burg, closestCell, cell, xp, yp);
|
||||
return {...burg, cell, x, y};
|
||||
});
|
||||
|
||||
function getBurgCoordinates(burg, closestCell, cell, xp, yp) {
|
||||
const haven = pack.cells.haven[cell];
|
||||
if (burg.port && haven) return BurgsAndStates.getCloseToEdgePoint(cell, haven);
|
||||
|
||||
if (closestCell !== cell) return pack.cells.p[cell];
|
||||
return [rn(xp, 2), rn(yp, 2)];
|
||||
}
|
||||
}
|
||||
|
||||
function restoreStates(parentMap, projection) {
|
||||
const validStates = new Set(pack.cells.state);
|
||||
pack.states = parentMap.pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
if (validStates.has(state.i)) return state;
|
||||
return {...state, removed: true, lock: false};
|
||||
});
|
||||
|
||||
BurgsAndStates.getPoles();
|
||||
const regimentCellsMap = {};
|
||||
const VERTICAL_GAP = 8;
|
||||
|
||||
pack.states = pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
|
||||
const capital = pack.burgs[state.capital];
|
||||
state.center = !capital || capital.removed ? findCell(...state.pole) : capital.cell;
|
||||
|
||||
const military = state.military.map(regiment => {
|
||||
const cellCoords = projection(...parentMap.pack.cells.p[regiment.cell]);
|
||||
const cell = isInMap(...cellCoords) ? findCell(...cellCoords) : state.center;
|
||||
|
||||
const [xPos, yPos] = projection(regiment.x, regiment.y);
|
||||
const [xBase, yBase] = projection(regiment.bx, regiment.by);
|
||||
const [xCell, yCell] = pack.cells.p[cell];
|
||||
|
||||
const regsOnCell = regimentCellsMap[cell] || 0;
|
||||
regimentCellsMap[cell] = regsOnCell + 1;
|
||||
|
||||
const name =
|
||||
isInMap(xPos, yPos) || regiment.name.includes("[relocated]") ? regiment.name : `[relocated] ${regiment.name}`;
|
||||
|
||||
const pos = isInMap(xPos, yPos)
|
||||
? {x: rn(xPos, 2), y: rn(yPos, 2)}
|
||||
: {x: xCell, y: yCell + regsOnCell * VERTICAL_GAP};
|
||||
|
||||
const base = isInMap(xBase, yBase) ? {bx: rn(xBase, 2), by: rn(yBase, 2)} : {bx: xCell, by: yCell};
|
||||
|
||||
return {...regiment, cell, name, ...base, ...pos};
|
||||
});
|
||||
|
||||
const neighbors = state.neighbors.filter(stateId => validStates.has(stateId));
|
||||
return {...state, neighbors, military};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRoutes(parentMap, projection) {
|
||||
pack.routes = parentMap.pack.routes
|
||||
.map(route => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
route.points.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const bbox = [0, 0, graphWidth, graphHeight];
|
||||
const clipped = lineclip(points, bbox)[0].map(([x, y]) => [rn(x, 2), rn(y, 2), findCell(x, y)]);
|
||||
const firstCell = clipped[0][2];
|
||||
const feature = pack.cells.f[firstCell];
|
||||
return {...route, feature, points: clipped};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.cells.routes = Routes.buildLinks(pack.routes);
|
||||
}
|
||||
|
||||
function restoreReligions(parentMap, projection) {
|
||||
const validReligions = new Set(pack.cells.religion);
|
||||
const religionPoles = getPolesOfInaccessibility(pack, cellId => pack.cells.religion[cellId]);
|
||||
|
||||
pack.religions = parentMap.pack.religions.map(religion => {
|
||||
if (!religion.i || religion.removed) return religion;
|
||||
if (!validReligions.has(religion.i)) return {...religion, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[religion.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : religionPoles[religion.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...religion, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreProvinces(parentMap) {
|
||||
const validProvinces = new Set(pack.cells.province);
|
||||
pack.provinces = parentMap.pack.provinces.map(province => {
|
||||
if (!province.i || province.removed) return province;
|
||||
if (!validProvinces.has(province.i)) return {...province, removed: true, lock: false};
|
||||
|
||||
return province;
|
||||
});
|
||||
|
||||
Provinces.getPoles();
|
||||
|
||||
pack.provinces.forEach(province => {
|
||||
if (!province.i || province.removed) return;
|
||||
const capital = pack.burgs[province.burg];
|
||||
province.center = !capital?.removed ? capital.cell : findCell(...province.pole);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreMarkers(parentMap, projection) {
|
||||
pack.markers = parentMap.pack.markers;
|
||||
pack.markers.forEach(marker => {
|
||||
const [x, y] = projection(marker.x, marker.y);
|
||||
if (!isInMap(x, y)) Markers.deleteMarker(marker.i);
|
||||
|
||||
const cell = findCell(x, y);
|
||||
marker.x = rn(x, 2);
|
||||
marker.y = rn(y, 2);
|
||||
marker.cell = cell;
|
||||
});
|
||||
}
|
||||
|
||||
function restoreZones(parentMap, projection, scale) {
|
||||
const getSearchRadius = cellId => Math.sqrt(parentMap.pack.cells.area[cellId] / Math.PI) * scale;
|
||||
|
||||
pack.zones = parentMap.pack.zones.map(zone => {
|
||||
const cells = zone.cells
|
||||
.map(cellId => {
|
||||
const [x, y] = projection(...parentMap.pack.cells.p[cellId]);
|
||||
if (!isInMap(x, y)) return null;
|
||||
return findAll(x, y, getSearchRadius(cellId));
|
||||
})
|
||||
.filter(Boolean)
|
||||
.flat();
|
||||
|
||||
return {...zone, cells: unique(cells)};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreFeatureDetails(parentMap, inverse) {
|
||||
pack.features.forEach(feature => {
|
||||
if (!feature) return;
|
||||
const [x, y] = pack.cells.p[feature.firstCell];
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
if (parentCell === undefined) return;
|
||||
const parentFeature = parentMap.pack.features[parentMap.pack.cells.f[parentCell]];
|
||||
|
||||
if (parentFeature.group) feature.group = parentFeature.group;
|
||||
if (parentFeature.name) feature.name = parentFeature.name;
|
||||
if (parentFeature.height) feature.height = parentFeature.height;
|
||||
});
|
||||
}
|
||||
|
||||
function groupCellsByType(graph) {
|
||||
return graph.cells.p.reduce(
|
||||
(acc, [x, y], cellId) => {
|
||||
const group = isWater(graph, cellId) ? "water" : "land";
|
||||
acc[group].push([x, y, cellId]);
|
||||
return acc;
|
||||
},
|
||||
{land: [], water: []}
|
||||
);
|
||||
}
|
||||
|
||||
function isWater(graph, cellId) {
|
||||
return graph.cells.h[cellId] < 20;
|
||||
}
|
||||
|
||||
function isInMap(x, y) {
|
||||
return x >= 0 && x <= graphWidth && y >= 0 && y <= graphHeight;
|
||||
}
|
||||
|
||||
return {process};
|
||||
})();
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# Config Properties for provinces-generator.js
|
||||
|
||||
The refactored `provinces-generator.js` module requires the following configuration properties:
|
||||
|
||||
## Required Config Properties:
|
||||
|
||||
### `provincesRatio` (Number)
|
||||
- **Original DOM source**: `byId("provincesRatio").value`
|
||||
- **Description**: Ratio determining the number of provinces to generate (0-100)
|
||||
- **Usage**: Controls how many provinces are created relative to the number of burgs in each state
|
||||
- **Type**: Number (typically 0-100)
|
||||
|
||||
### `seed` (String/Number)
|
||||
- **Description**: Random seed for province generation
|
||||
- **Usage**: Used when `regenerate` parameter is false to maintain consistent generation
|
||||
- **Type**: String or Number
|
||||
- **Note**: This replaces the global `seed` variable access
|
||||
|
||||
## Config Object Structure:
|
||||
```javascript
|
||||
const config = {
|
||||
provincesRatio: 50, // 0-100, percentage of burgs to become province centers
|
||||
seed: "some-seed-value" // Random seed for reproducible generation
|
||||
};
|
||||
```
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# External Dependencies for provinces-generator.js
|
||||
|
||||
The refactored `provinces-generator.js` module requires the following external modules and utilities to be imported:
|
||||
|
||||
## Core Utilities (passed via `utils` object):
|
||||
- `TIME` - Debug timing flag
|
||||
- `generateSeed()` - Random seed generation function
|
||||
- `aleaPRNG()` - Seeded pseudo-random number generator
|
||||
- `gauss()` - Gaussian distribution function
|
||||
- `P()` - Probability function (random true/false with given probability)
|
||||
- `Names` - Name generation utilities
|
||||
- `Names.getState()`
|
||||
- `Names.getCultureShort()`
|
||||
- `rw()` - Weighted random selection function
|
||||
- `getMixedColor()` - Color mixing utility
|
||||
- `BurgsAndStates` - Burg and state utilities
|
||||
- `BurgsAndStates.getType()`
|
||||
- `COA` - Coat of Arms generation utilities
|
||||
- `COA.generate()`
|
||||
- `COA.getShield()`
|
||||
- `FlatQueue` - Priority queue implementation
|
||||
- `d3` - D3.js library (specifically `d3.max()`)
|
||||
- `rand()` - Random integer generation function
|
||||
- `getPolesOfInaccessibility()` - Pole of inaccessibility calculation function
|
||||
|
||||
## Data Dependencies (passed as parameters):
|
||||
- `pack` - Main data structure containing:
|
||||
- `pack.cells` - Cell data arrays
|
||||
- `pack.states` - State definitions
|
||||
- `pack.burgs` - Settlement data
|
||||
- `pack.provinces` - Existing province data (for regeneration)
|
||||
- `pack.features` - Geographic feature data
|
||||
- `config` - Configuration object (see config file for details)
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
# Removed Rendering/UI Logic from provinces-generator.js
|
||||
|
||||
## Analysis Result:
|
||||
|
||||
**No rendering or UI logic was found in the original `provinces-generator.js.js` file.**
|
||||
|
||||
The original module was purely computational and contained:
|
||||
- Province generation algorithms
|
||||
- Geographic calculations
|
||||
- Data structure manipulations
|
||||
- Mathematical computations for province boundaries
|
||||
|
||||
## What was NOT present (and therefore not removed):
|
||||
- No DOM manipulation code
|
||||
- No SVG rendering logic
|
||||
- No `d3.select()` calls for visualization
|
||||
- No `document.getElementById()` calls for DOM updates
|
||||
- No HTML element creation or modification
|
||||
- No CSS styling operations
|
||||
- No canvas or WebGL rendering code
|
||||
|
||||
## Note:
|
||||
This module was already well-separated in terms of concerns - it focused purely on the computational aspects of province generation without any visualization or user interface components. The only UI-related code was the single DOM read (`byId("provincesRatio").value`) which has been converted to a config property (`config.provincesRatio`).
|
||||
341
procedural/src/engine/support/provinces-generator_prompt.md
Normal file
341
procedural/src/engine/support/provinces-generator_prompt.md
Normal file
|
|
@ -0,0 +1,341 @@
|
|||
# provinces-generator.js.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
7. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
8. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
9. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `provinces-generator.js.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Provinces = (function () {
|
||||
const forms = {
|
||||
Monarchy: {County: 22, Earldom: 6, Shire: 2, Landgrave: 2, Margrave: 2, Barony: 2, Captaincy: 1, Seneschalty: 1},
|
||||
Republic: {Province: 6, Department: 2, Governorate: 2, District: 1, Canton: 1, Prefecture: 1},
|
||||
Theocracy: {Parish: 3, Deanery: 1},
|
||||
Union: {Province: 1, State: 1, Canton: 1, Republic: 1, County: 1, Council: 1},
|
||||
Anarchy: {Council: 1, Commune: 1, Community: 1, Tribe: 1},
|
||||
Wild: {Territory: 10, Land: 5, Region: 2, Tribe: 1, Clan: 1, Dependency: 1, Area: 1}
|
||||
};
|
||||
|
||||
const generate = (regenerate = false, regenerateLockedStates = false) => {
|
||||
TIME && console.time("generateProvinces");
|
||||
const localSeed = regenerate ? generateSeed() : seed;
|
||||
Math.random = aleaPRNG(localSeed);
|
||||
|
||||
const {cells, states, burgs} = pack;
|
||||
const provinces = [0]; // 0 index is reserved for "no province"
|
||||
const provinceIds = new Uint16Array(cells.i.length);
|
||||
|
||||
const isProvinceLocked = province => province.lock || (!regenerateLockedStates && states[province.state]?.lock);
|
||||
const isProvinceCellLocked = cell => provinceIds[cell] && isProvinceLocked(provinces[provinceIds[cell]]);
|
||||
|
||||
if (regenerate) {
|
||||
pack.provinces.forEach(province => {
|
||||
if (!province.i || province.removed || !isProvinceLocked(province)) return;
|
||||
|
||||
const newId = provinces.length;
|
||||
for (const i of cells.i) {
|
||||
if (cells.province[i] === province.i) provinceIds[i] = newId;
|
||||
}
|
||||
|
||||
province.i = newId;
|
||||
provinces.push(province);
|
||||
});
|
||||
}
|
||||
|
||||
const provincesRatio = +byId("provincesRatio").value;
|
||||
const max = provincesRatio == 100 ? 1000 : gauss(20, 5, 5, 100) * provincesRatio ** 0.5; // max growth
|
||||
|
||||
// generate provinces for selected burgs
|
||||
states.forEach(s => {
|
||||
s.provinces = [];
|
||||
if (!s.i || s.removed) return;
|
||||
if (provinces.length) s.provinces = provinces.filter(p => p.state === s.i).map(p => p.i); // locked provinces ids
|
||||
if (s.lock && !regenerateLockedStates) return; // don't regenerate provinces of a locked state
|
||||
|
||||
const stateBurgs = burgs
|
||||
.filter(b => b.state === s.i && !b.removed && !provinceIds[b.cell])
|
||||
.sort((a, b) => b.population * gauss(1, 0.2, 0.5, 1.5, 3) - a.population)
|
||||
.sort((a, b) => b.capital - a.capital);
|
||||
if (stateBurgs.length < 2) return; // at least 2 provinces are required
|
||||
const provincesNumber = Math.max(Math.ceil((stateBurgs.length * provincesRatio) / 100), 2);
|
||||
|
||||
const form = Object.assign({}, forms[s.form]);
|
||||
|
||||
for (let i = 0; i < provincesNumber; i++) {
|
||||
const provinceId = provinces.length;
|
||||
const center = stateBurgs[i].cell;
|
||||
const burg = stateBurgs[i].i;
|
||||
const c = stateBurgs[i].culture;
|
||||
const nameByBurg = P(0.5);
|
||||
const name = nameByBurg ? stateBurgs[i].name : Names.getState(Names.getCultureShort(c), c);
|
||||
const formName = rw(form);
|
||||
form[formName] += 10;
|
||||
const fullName = name + " " + formName;
|
||||
const color = getMixedColor(s.color);
|
||||
const kinship = nameByBurg ? 0.8 : 0.4;
|
||||
const type = BurgsAndStates.getType(center, burg.port);
|
||||
const coa = COA.generate(stateBurgs[i].coa, kinship, null, type);
|
||||
coa.shield = COA.getShield(c, s.i);
|
||||
|
||||
s.provinces.push(provinceId);
|
||||
provinces.push({i: provinceId, state: s.i, center, burg, name, formName, fullName, color, coa});
|
||||
}
|
||||
});
|
||||
|
||||
// expand generated provinces
|
||||
const queue = new FlatQueue();
|
||||
const cost = [];
|
||||
|
||||
provinces.forEach(p => {
|
||||
if (!p.i || p.removed || isProvinceLocked(p)) return;
|
||||
provinceIds[p.center] = p.i;
|
||||
queue.push({e: p.center, province: p.i, state: p.state, p: 0}, 0);
|
||||
cost[p.center] = 1;
|
||||
});
|
||||
|
||||
while (queue.length) {
|
||||
const {e, p, province, state} = queue.pop();
|
||||
|
||||
cells.c[e].forEach(e => {
|
||||
if (isProvinceCellLocked(e)) return; // do not overwrite cell of locked provinces
|
||||
|
||||
const land = cells.h[e] >= 20;
|
||||
if (!land && !cells.t[e]) return; // cannot pass deep ocean
|
||||
if (land && cells.state[e] !== state) return;
|
||||
const evevation = cells.h[e] >= 70 ? 100 : cells.h[e] >= 50 ? 30 : cells.h[e] >= 20 ? 10 : 100;
|
||||
const totalCost = p + evevation;
|
||||
|
||||
if (totalCost > max) return;
|
||||
if (!cost[e] || totalCost < cost[e]) {
|
||||
if (land) provinceIds[e] = province; // assign province to a cell
|
||||
cost[e] = totalCost;
|
||||
queue.push({e, province, state, p: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// justify provinces shapes a bit
|
||||
for (const i of cells.i) {
|
||||
if (cells.burg[i]) continue; // do not overwrite burgs
|
||||
if (isProvinceCellLocked(i)) continue; // do not overwrite cell of locked provinces
|
||||
|
||||
const neibs = cells.c[i]
|
||||
.filter(c => cells.state[c] === cells.state[i] && !isProvinceCellLocked(c))
|
||||
.map(c => provinceIds[c]);
|
||||
const adversaries = neibs.filter(c => c !== provinceIds[i]);
|
||||
if (adversaries.length < 2) continue;
|
||||
|
||||
const buddies = neibs.filter(c => c === provinceIds[i]).length;
|
||||
if (buddies.length > 2) continue;
|
||||
|
||||
const competitors = adversaries.map(p => adversaries.reduce((s, v) => (v === p ? s + 1 : s), 0));
|
||||
const max = d3.max(competitors);
|
||||
if (buddies >= max) continue;
|
||||
|
||||
provinceIds[i] = adversaries[competitors.indexOf(max)];
|
||||
}
|
||||
|
||||
// add "wild" provinces if some cells don't have a province assigned
|
||||
const noProvince = Array.from(cells.i).filter(i => cells.state[i] && !provinceIds[i]); // cells without province assigned
|
||||
states.forEach(s => {
|
||||
if (!s.i || s.removed) return;
|
||||
if (s.lock && !regenerateLockedStates) return;
|
||||
if (!s.provinces.length) return;
|
||||
|
||||
const coreProvinceNames = s.provinces.map(p => provinces[p]?.name);
|
||||
const colonyNamePool = [s.name, ...coreProvinceNames].filter(name => name && !/new/i.test(name));
|
||||
const getColonyName = () => {
|
||||
if (colonyNamePool.length < 1) return null;
|
||||
|
||||
const index = rand(colonyNamePool.length - 1);
|
||||
const spliced = colonyNamePool.splice(index, 1);
|
||||
return spliced[0] ? `New ${spliced[0]}` : null;
|
||||
};
|
||||
|
||||
let stateNoProvince = noProvince.filter(i => cells.state[i] === s.i && !provinceIds[i]);
|
||||
while (stateNoProvince.length) {
|
||||
// add new province
|
||||
const provinceId = provinces.length;
|
||||
const burgCell = stateNoProvince.find(i => cells.burg[i]);
|
||||
const center = burgCell ? burgCell : stateNoProvince[0];
|
||||
const burg = burgCell ? cells.burg[burgCell] : 0;
|
||||
provinceIds[center] = provinceId;
|
||||
|
||||
// expand province
|
||||
const cost = [];
|
||||
cost[center] = 1;
|
||||
queue.push({e: center, p: 0}, 0);
|
||||
while (queue.length) {
|
||||
const {e, p} = queue.pop();
|
||||
|
||||
cells.c[e].forEach(nextCellId => {
|
||||
if (provinceIds[nextCellId]) return;
|
||||
const land = cells.h[nextCellId] >= 20;
|
||||
if (cells.state[nextCellId] && cells.state[nextCellId] !== s.i) return;
|
||||
const ter = land ? (cells.state[nextCellId] === s.i ? 3 : 20) : cells.t[nextCellId] ? 10 : 30;
|
||||
const totalCost = p + ter;
|
||||
|
||||
if (totalCost > max) return;
|
||||
if (!cost[nextCellId] || totalCost < cost[nextCellId]) {
|
||||
if (land && cells.state[nextCellId] === s.i) provinceIds[nextCellId] = provinceId; // assign province to a cell
|
||||
cost[nextCellId] = totalCost;
|
||||
queue.push({e: nextCellId, p: totalCost}, totalCost);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// generate "wild" province name
|
||||
const c = cells.culture[center];
|
||||
const f = pack.features[cells.f[center]];
|
||||
const color = getMixedColor(s.color);
|
||||
|
||||
const provCells = stateNoProvince.filter(i => provinceIds[i] === provinceId);
|
||||
const singleIsle = provCells.length === f.cells && !provCells.find(i => cells.f[i] !== f.i);
|
||||
const isleGroup = !singleIsle && !provCells.find(i => pack.features[cells.f[i]].group !== "isle");
|
||||
const colony = !singleIsle && !isleGroup && P(0.5) && !isPassable(s.center, center);
|
||||
|
||||
const name = (() => {
|
||||
const colonyName = colony && P(0.8) && getColonyName();
|
||||
if (colonyName) return colonyName;
|
||||
if (burgCell && P(0.5)) return burgs[burg].name;
|
||||
return Names.getState(Names.getCultureShort(c), c);
|
||||
})();
|
||||
|
||||
const formName = (() => {
|
||||
if (singleIsle) return "Island";
|
||||
if (isleGroup) return "Islands";
|
||||
if (colony) return "Colony";
|
||||
return rw(forms["Wild"]);
|
||||
})();
|
||||
|
||||
const fullName = name + " " + formName;
|
||||
|
||||
const dominion = colony ? P(0.95) : singleIsle || isleGroup ? P(0.7) : P(0.3);
|
||||
const kinship = dominion ? 0 : 0.4;
|
||||
const type = BurgsAndStates.getType(center, burgs[burg]?.port);
|
||||
const coa = COA.generate(s.coa, kinship, dominion, type);
|
||||
coa.shield = COA.getShield(c, s.i);
|
||||
|
||||
provinces.push({i: provinceId, state: s.i, center, burg, name, formName, fullName, color, coa});
|
||||
s.provinces.push(provinceId);
|
||||
|
||||
// check if there is a land way within the same state between two cells
|
||||
function isPassable(from, to) {
|
||||
if (cells.f[from] !== cells.f[to]) return false; // on different islands
|
||||
const passableQueue = [from],
|
||||
used = new Uint8Array(cells.i.length),
|
||||
state = cells.state[from];
|
||||
while (passableQueue.length) {
|
||||
const current = passableQueue.pop();
|
||||
if (current === to) return true; // way is found
|
||||
cells.c[current].forEach(c => {
|
||||
if (used[c] || cells.h[c] < 20 || cells.state[c] !== state) return;
|
||||
passableQueue.push(c);
|
||||
used[c] = 1;
|
||||
});
|
||||
}
|
||||
return false; // way is not found
|
||||
}
|
||||
|
||||
// re-check
|
||||
stateNoProvince = noProvince.filter(i => cells.state[i] === s.i && !provinceIds[i]);
|
||||
}
|
||||
});
|
||||
|
||||
cells.province = provinceIds;
|
||||
pack.provinces = provinces;
|
||||
|
||||
TIME && console.timeEnd("generateProvinces");
|
||||
};
|
||||
|
||||
// calculate pole of inaccessibility for each province
|
||||
const getPoles = () => {
|
||||
const getType = cellId => pack.cells.province[cellId];
|
||||
const poles = getPolesOfInaccessibility(pack, getType);
|
||||
|
||||
pack.provinces.forEach(province => {
|
||||
if (!province.i || province.removed) return;
|
||||
province.pole = poles[province.i] || [0, 0];
|
||||
});
|
||||
};
|
||||
|
||||
return {generate, getPoles};
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./provinces-generator.js.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./provinces-generator.js_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in provinces-generator.js_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into provinces-generator.js_render.md
|
||||
410
procedural/src/engine/support/refactored_resample.txt
Normal file
410
procedural/src/engine/support/refactored_resample.txt
Normal file
|
|
@ -0,0 +1,410 @@
|
|||
"use strict";
|
||||
|
||||
/*
|
||||
generate new map based on an existing one (resampling parentMap)
|
||||
parentMap: {grid, pack, notes} from original map
|
||||
projection: f(Number, Number) -> [Number, Number]
|
||||
inverse: f(Number, Number) -> [Number, Number]
|
||||
scale: Number
|
||||
*/
|
||||
export function process({projection, inverse, scale}, grid, pack, notes, config, utils) {
|
||||
const {deepCopy, generateGrid, rn, findCell, findAll, isInMap, unique, lineclip, WARN} = utils;
|
||||
const parentMap = {grid: deepCopy(grid), pack: deepCopy(pack), notes: deepCopy(notes)};
|
||||
const riversData = saveRiversData(parentMap.pack.rivers, utils);
|
||||
|
||||
const newGrid = generateGrid();
|
||||
const newPack = {};
|
||||
const newNotes = parentMap.notes;
|
||||
|
||||
resamplePrimaryGridData(parentMap, inverse, scale, newGrid, utils);
|
||||
|
||||
// External module calls that modify newGrid and newPack would need to be handled by caller
|
||||
// Features.markupGrid(), addLakesInDeepDepressions(), openNearSeaLakes(),
|
||||
// OceanLayers(), calculateMapCoordinates(), calculateTemperatures(),
|
||||
// reGraph(), Features.markupPack(), createDefaultRuler()
|
||||
|
||||
const cellData = restoreCellData(parentMap, inverse, scale, newPack, config, utils);
|
||||
const rivers = restoreRivers(riversData, projection, scale, newPack, config, utils);
|
||||
const cultures = restoreCultures(parentMap, projection, newPack, utils);
|
||||
const burgs = restoreBurgs(parentMap, projection, scale, newPack, utils);
|
||||
const states = restoreStates(parentMap, projection, newPack, config, utils);
|
||||
const routes = restoreRoutes(parentMap, projection, newPack, config, utils);
|
||||
const religions = restoreReligions(parentMap, projection, newPack, utils);
|
||||
const provinces = restoreProvinces(parentMap, newPack, utils);
|
||||
const featureDetails = restoreFeatureDetails(parentMap, inverse, newPack, utils);
|
||||
const markers = restoreMarkers(parentMap, projection, newPack, utils);
|
||||
const zones = restoreZones(parentMap, projection, scale, newPack, utils);
|
||||
|
||||
return {
|
||||
grid: newGrid,
|
||||
pack: {
|
||||
...newPack,
|
||||
cells: cellData.cells,
|
||||
rivers: rivers,
|
||||
cultures: cultures,
|
||||
burgs: burgs,
|
||||
states: states,
|
||||
routes: routes,
|
||||
religions: religions,
|
||||
provinces: provinces,
|
||||
markers: markers,
|
||||
zones: zones,
|
||||
features: newPack.features || []
|
||||
},
|
||||
notes: newNotes
|
||||
};
|
||||
}
|
||||
|
||||
function resamplePrimaryGridData(parentMap, inverse, scale, grid, utils) {
|
||||
const {smoothHeightmap} = utils;
|
||||
grid.cells.h = new Uint8Array(grid.points.length);
|
||||
grid.cells.temp = new Int8Array(grid.points.length);
|
||||
grid.cells.prec = new Uint8Array(grid.points.length);
|
||||
|
||||
grid.points.forEach(([x, y], newGridCell) => {
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentPackCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
const parentGridCell = parentMap.pack.cells.g[parentPackCell];
|
||||
|
||||
grid.cells.h[newGridCell] = parentMap.grid.cells.h[parentGridCell];
|
||||
grid.cells.temp[newGridCell] = parentMap.grid.cells.temp[parentGridCell];
|
||||
grid.cells.prec[newGridCell] = parentMap.grid.cells.prec[parentGridCell];
|
||||
});
|
||||
|
||||
if (scale >= 2) smoothHeightmap(grid);
|
||||
}
|
||||
|
||||
function smoothHeightmap(grid) {
|
||||
const {d3, isWater} = grid.utils || {};
|
||||
grid.cells.h.forEach((height, newGridCell) => {
|
||||
const heights = [height, ...grid.cells.c[newGridCell].map(c => grid.cells.h[c])];
|
||||
const meanHeight = d3.mean(heights);
|
||||
grid.cells.h[newGridCell] = isWater(grid, newGridCell) ? Math.min(meanHeight, 19) : Math.max(meanHeight, 20);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCellData(parentMap, inverse, scale, pack, config, utils) {
|
||||
const {d3, isWater} = utils;
|
||||
|
||||
const cells = {
|
||||
biome: new Uint8Array(pack.cells.i.length),
|
||||
fl: new Uint16Array(pack.cells.i.length),
|
||||
s: new Int16Array(pack.cells.i.length),
|
||||
pop: new Float32Array(pack.cells.i.length),
|
||||
culture: new Uint16Array(pack.cells.i.length),
|
||||
state: new Uint16Array(pack.cells.i.length),
|
||||
burg: new Uint16Array(pack.cells.i.length),
|
||||
religion: new Uint16Array(pack.cells.i.length),
|
||||
province: new Uint16Array(pack.cells.i.length)
|
||||
};
|
||||
|
||||
const parentPackCellGroups = groupCellsByType(parentMap.pack);
|
||||
const parentPackLandCellsQuadtree = d3.quadtree(parentPackCellGroups.land);
|
||||
|
||||
for (const newPackCell of pack.cells.i) {
|
||||
const [x, y] = inverse(...pack.cells.p[newPackCell]);
|
||||
if (isWater(pack, newPackCell)) continue;
|
||||
|
||||
const parentPackCell = parentPackLandCellsQuadtree.find(x, y, Infinity)[2];
|
||||
const parentCellArea = parentMap.pack.cells.area[parentPackCell];
|
||||
const areaRatio = pack.cells.area[newPackCell] / parentCellArea;
|
||||
const scaleRatio = areaRatio / scale;
|
||||
|
||||
cells.biome[newPackCell] = parentMap.pack.cells.biome[parentPackCell];
|
||||
cells.fl[newPackCell] = parentMap.pack.cells.fl[parentPackCell];
|
||||
cells.s[newPackCell] = parentMap.pack.cells.s[parentPackCell] * scaleRatio;
|
||||
cells.pop[newPackCell] = parentMap.pack.cells.pop[parentPackCell] * scaleRatio;
|
||||
cells.culture[newPackCell] = parentMap.pack.cells.culture[parentPackCell];
|
||||
cells.state[newPackCell] = parentMap.pack.cells.state[parentPackCell];
|
||||
cells.religion[newPackCell] = parentMap.pack.cells.religion[parentPackCell];
|
||||
cells.province[newPackCell] = parentMap.pack.cells.province[parentPackCell];
|
||||
}
|
||||
|
||||
return {cells};
|
||||
}
|
||||
|
||||
function saveRiversData(parentRivers, utils) {
|
||||
const {Rivers} = utils;
|
||||
return parentRivers.map(river => {
|
||||
const meanderedPoints = Rivers.addMeandering(river.cells, river.points);
|
||||
return {...river, meanderedPoints};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRivers(riversData, projection, scale, pack, config, utils) {
|
||||
const {rn, isInMap, findCell, Rivers} = utils;
|
||||
|
||||
pack.cells.r = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.conf = new Uint8Array(pack.cells.i.length);
|
||||
|
||||
const rivers = riversData
|
||||
.map(river => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
river.meanderedPoints.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y, config.graphWidth, config.graphHeight);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const cells = points.map(point => findCell(...point));
|
||||
cells.forEach(cellId => {
|
||||
if (pack.cells.r[cellId]) pack.cells.conf[cellId] = 1;
|
||||
pack.cells.r[cellId] = river.i;
|
||||
});
|
||||
|
||||
const widthFactor = river.widthFactor * scale;
|
||||
return {...river, cells, points, source: cells.at(0), mouth: cells.at(-2), widthFactor};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
rivers.forEach(river => {
|
||||
river.basin = Rivers.getBasin(river.i);
|
||||
river.length = Rivers.getApproximateLength(river.points);
|
||||
});
|
||||
|
||||
return rivers;
|
||||
}
|
||||
|
||||
function restoreCultures(parentMap, projection, pack, utils) {
|
||||
const {rn, isInMap, findCell, getPolesOfInaccessibility} = utils;
|
||||
|
||||
const validCultures = new Set(pack.cells.culture);
|
||||
const culturePoles = getPolesOfInaccessibility(pack, cellId => pack.cells.culture[cellId]);
|
||||
|
||||
return parentMap.pack.cultures.map(culture => {
|
||||
if (!culture.i || culture.removed) return culture;
|
||||
if (!validCultures.has(culture.i)) return {...culture, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[culture.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : culturePoles[culture.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...culture, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreBurgs(parentMap, projection, scale, pack, utils) {
|
||||
const {d3, rn, isInMap, findCell, isWater, WARN, BurgsAndStates} = utils;
|
||||
|
||||
const packLandCellsQuadtree = d3.quadtree(groupCellsByType(pack).land);
|
||||
const findLandCell = (x, y) => packLandCellsQuadtree.find(x, y, Infinity)?.[2];
|
||||
|
||||
return parentMap.pack.burgs.map(burg => {
|
||||
if (!burg.i || burg.removed) return burg;
|
||||
burg.population *= scale; // adjust for populationRate change
|
||||
|
||||
const [xp, yp] = projection(burg.x, burg.y);
|
||||
if (!isInMap(xp, yp)) return {...burg, removed: true, lock: false};
|
||||
|
||||
const closestCell = findCell(xp, yp);
|
||||
const cell = isWater(pack, closestCell) ? findLandCell(xp, yp) : closestCell;
|
||||
|
||||
if (pack.cells.burg[cell]) {
|
||||
WARN && console.warn(`Cell ${cell} already has a burg. Removing burg ${burg.name} (${burg.i})`);
|
||||
return {...burg, removed: true, lock: false};
|
||||
}
|
||||
|
||||
pack.cells.burg[cell] = burg.i;
|
||||
const [x, y] = getBurgCoordinates(burg, closestCell, cell, xp, yp, pack, utils);
|
||||
return {...burg, cell, x, y};
|
||||
});
|
||||
|
||||
function getBurgCoordinates(burg, closestCell, cell, xp, yp, pack, utils) {
|
||||
const {rn, BurgsAndStates} = utils;
|
||||
const haven = pack.cells.haven[cell];
|
||||
if (burg.port && haven) return BurgsAndStates.getCloseToEdgePoint(cell, haven);
|
||||
|
||||
if (closestCell !== cell) return pack.cells.p[cell];
|
||||
return [rn(xp, 2), rn(yp, 2)];
|
||||
}
|
||||
}
|
||||
|
||||
function restoreStates(parentMap, projection, pack, config, utils) {
|
||||
const {rn, isInMap, findCell, BurgsAndStates} = utils;
|
||||
|
||||
const validStates = new Set(pack.cells.state);
|
||||
let states = parentMap.pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
if (validStates.has(state.i)) return state;
|
||||
return {...state, removed: true, lock: false};
|
||||
});
|
||||
|
||||
BurgsAndStates.getPoles();
|
||||
const regimentCellsMap = {};
|
||||
const VERTICAL_GAP = 8;
|
||||
|
||||
states = states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
|
||||
const capital = pack.burgs[state.capital];
|
||||
state.center = !capital || capital.removed ? findCell(...state.pole) : capital.cell;
|
||||
|
||||
const military = state.military.map(regiment => {
|
||||
const cellCoords = projection(...parentMap.pack.cells.p[regiment.cell]);
|
||||
const cell = isInMap(...cellCoords, config.graphWidth, config.graphHeight) ? findCell(...cellCoords) : state.center;
|
||||
|
||||
const [xPos, yPos] = projection(regiment.x, regiment.y);
|
||||
const [xBase, yBase] = projection(regiment.bx, regiment.by);
|
||||
const [xCell, yCell] = pack.cells.p[cell];
|
||||
|
||||
const regsOnCell = regimentCellsMap[cell] || 0;
|
||||
regimentCellsMap[cell] = regsOnCell + 1;
|
||||
|
||||
const name =
|
||||
isInMap(xPos, yPos, config.graphWidth, config.graphHeight) || regiment.name.includes("[relocated]") ? regiment.name : `[relocated] ${regiment.name}`;
|
||||
|
||||
const pos = isInMap(xPos, yPos, config.graphWidth, config.graphHeight)
|
||||
? {x: rn(xPos, 2), y: rn(yPos, 2)}
|
||||
: {x: xCell, y: yCell + regsOnCell * VERTICAL_GAP};
|
||||
|
||||
const base = isInMap(xBase, yBase, config.graphWidth, config.graphHeight) ? {bx: rn(xBase, 2), by: rn(yBase, 2)} : {bx: xCell, by: yCell};
|
||||
|
||||
return {...regiment, cell, name, ...base, ...pos};
|
||||
});
|
||||
|
||||
const neighbors = state.neighbors.filter(stateId => validStates.has(stateId));
|
||||
return {...state, neighbors, military};
|
||||
});
|
||||
|
||||
return states;
|
||||
}
|
||||
|
||||
function restoreRoutes(parentMap, projection, pack, config, utils) {
|
||||
const {rn, isInMap, findCell, lineclip, Routes} = utils;
|
||||
|
||||
const routes = parentMap.pack.routes
|
||||
.map(route => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
route.points.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y, config.graphWidth, config.graphHeight);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const bbox = [0, 0, config.graphWidth, config.graphHeight];
|
||||
const clipped = lineclip(points, bbox)[0].map(([x, y]) => [rn(x, 2), rn(y, 2), findCell(x, y)]);
|
||||
const firstCell = clipped[0][2];
|
||||
const feature = pack.cells.f[firstCell];
|
||||
return {...route, feature, points: clipped};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.cells.routes = Routes.buildLinks(routes);
|
||||
return routes;
|
||||
}
|
||||
|
||||
function restoreReligions(parentMap, projection, pack, utils) {
|
||||
const {rn, isInMap, findCell, getPolesOfInaccessibility} = utils;
|
||||
|
||||
const validReligions = new Set(pack.cells.religion);
|
||||
const religionPoles = getPolesOfInaccessibility(pack, cellId => pack.cells.religion[cellId]);
|
||||
|
||||
return parentMap.pack.religions.map(religion => {
|
||||
if (!religion.i || religion.removed) return religion;
|
||||
if (!validReligions.has(religion.i)) return {...religion, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[religion.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : religionPoles[religion.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...religion, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreProvinces(parentMap, pack, utils) {
|
||||
const {findCell, Provinces} = utils;
|
||||
|
||||
const validProvinces = new Set(pack.cells.province);
|
||||
const provinces = parentMap.pack.provinces.map(province => {
|
||||
if (!province.i || province.removed) return province;
|
||||
if (!validProvinces.has(province.i)) return {...province, removed: true, lock: false};
|
||||
|
||||
return province;
|
||||
});
|
||||
|
||||
Provinces.getPoles();
|
||||
|
||||
provinces.forEach(province => {
|
||||
if (!province.i || province.removed) return;
|
||||
const capital = pack.burgs[province.burg];
|
||||
province.center = !capital?.removed ? capital.cell : findCell(...province.pole);
|
||||
});
|
||||
|
||||
return provinces;
|
||||
}
|
||||
|
||||
function restoreMarkers(parentMap, projection, pack, utils) {
|
||||
const {rn, isInMap, findCell, Markers} = utils;
|
||||
|
||||
const markers = parentMap.pack.markers;
|
||||
markers.forEach(marker => {
|
||||
const [x, y] = projection(marker.x, marker.y);
|
||||
if (!isInMap(x, y)) Markers.deleteMarker(marker.i);
|
||||
|
||||
const cell = findCell(x, y);
|
||||
marker.x = rn(x, 2);
|
||||
marker.y = rn(y, 2);
|
||||
marker.cell = cell;
|
||||
});
|
||||
|
||||
return markers;
|
||||
}
|
||||
|
||||
function restoreZones(parentMap, projection, scale, pack, utils) {
|
||||
const {isInMap, findAll, unique} = utils;
|
||||
|
||||
const getSearchRadius = cellId => Math.sqrt(parentMap.pack.cells.area[cellId] / Math.PI) * scale;
|
||||
|
||||
return parentMap.pack.zones.map(zone => {
|
||||
const cells = zone.cells
|
||||
.map(cellId => {
|
||||
const [x, y] = projection(...parentMap.pack.cells.p[cellId]);
|
||||
if (!isInMap(x, y)) return null;
|
||||
return findAll(x, y, getSearchRadius(cellId));
|
||||
})
|
||||
.filter(Boolean)
|
||||
.flat();
|
||||
|
||||
return {...zone, cells: unique(cells)};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreFeatureDetails(parentMap, inverse, pack, utils) {
|
||||
pack.features.forEach(feature => {
|
||||
if (!feature) return;
|
||||
const [x, y] = pack.cells.p[feature.firstCell];
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
if (parentCell === undefined) return;
|
||||
const parentFeature = parentMap.pack.features[parentMap.pack.cells.f[parentCell]];
|
||||
|
||||
if (parentFeature.group) feature.group = parentFeature.group;
|
||||
if (parentFeature.name) feature.name = parentFeature.name;
|
||||
if (parentFeature.height) feature.height = parentFeature.height;
|
||||
});
|
||||
|
||||
return pack.features;
|
||||
}
|
||||
|
||||
function groupCellsByType(graph) {
|
||||
return graph.cells.p.reduce(
|
||||
(acc, [x, y], cellId) => {
|
||||
const group = isWater(graph, cellId) ? "water" : "land";
|
||||
acc[group].push([x, y, cellId]);
|
||||
return acc;
|
||||
},
|
||||
{land: [], water: []}
|
||||
);
|
||||
}
|
||||
|
||||
function isWater(graph, cellId) {
|
||||
return graph.cells.h[cellId] < 20;
|
||||
}
|
||||
30
procedural/src/engine/support/religions-generator_config.md
Normal file
30
procedural/src/engine/support/religions-generator_config.md
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
# Config Properties for religions-generator.js
|
||||
|
||||
The refactored module requires the following configuration properties:
|
||||
|
||||
## Required Config Properties
|
||||
|
||||
### `religionsNumber`
|
||||
- **Type**: `number`
|
||||
- **Source**: Previously read from `religionsNumber.value` (DOM element)
|
||||
- **Description**: The desired number of organized religions to generate
|
||||
- **Usage**: Used in `generateOrganizedReligions()` to determine how many religions to create
|
||||
|
||||
### `growthRate`
|
||||
- **Type**: `number`
|
||||
- **Source**: Previously read from `byId("growthRate").valueAsNumber` (DOM element)
|
||||
- **Description**: Growth rate multiplier that affects how far religions can expand
|
||||
- **Usage**: Used in `expandReligions()` to calculate `maxExpansionCost = (cells.i.length / 20) * config.growthRate`
|
||||
|
||||
## Config Object Structure
|
||||
|
||||
The config object should be structured as:
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
religionsNumber: 5, // Number of organized religions to generate
|
||||
growthRate: 1.0 // Growth rate multiplier for religion expansion
|
||||
};
|
||||
```
|
||||
|
||||
These properties replace the original DOM-based configuration reads and allow the engine to be run in any environment without browser dependencies.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# External Dependencies for religions-generator.js
|
||||
|
||||
The refactored module requires the following external dependencies to be imported or provided via the `utils` parameter:
|
||||
|
||||
## Core Utilities
|
||||
- `TIME` - Boolean flag for timing console outputs
|
||||
- `WARN` - Boolean flag for warning console outputs
|
||||
- `ERROR` - Boolean flag for error console outputs
|
||||
- `rand(min, max)` - Random number generator
|
||||
- `ra(array)` - Random array element selector
|
||||
- `rw(weightedObject)` - Random weighted selection
|
||||
- `gauss(mean, deviation, min, max, step)` - Gaussian random number generator
|
||||
- `each(n)` - Function that returns a function checking if number is divisible by n
|
||||
|
||||
## Data Structure Utilities
|
||||
- `d3.quadtree()` - D3 quadtree for spatial indexing
|
||||
- `FlatQueue` - Priority queue implementation
|
||||
- `Uint16Array` - Typed array constructor
|
||||
|
||||
## Helper Functions
|
||||
- `getRandomColor()` - Generates random color
|
||||
- `getMixedColor(baseColor, saturation, lightness)` - Mixes colors
|
||||
- `abbreviate(name, existingCodes)` - Creates abbreviation codes
|
||||
- `trimVowels(string)` - Removes vowels from string
|
||||
- `getAdjective(string)` - Converts string to adjective form
|
||||
- `isWater(cellId)` - Checks if cell is water
|
||||
|
||||
## External Modules
|
||||
- `Names.getCulture(culture, param1, param2, param3, param4)` - Name generation system
|
||||
- `Routes.getRoute(cellId1, cellId2)` - Route finding system
|
||||
- `biomesData.cost[biomeId]` - Biome traversal cost data
|
||||
|
||||
All of these dependencies should be provided through the `utils` parameter when calling the exported functions.
|
||||
1012
procedural/src/engine/support/religions-generator_prompt.md
Normal file
1012
procedural/src/engine/support/religions-generator_prompt.md
Normal file
File diff suppressed because it is too large
Load diff
31
procedural/src/engine/support/religions-generator_render.md
Normal file
31
procedural/src/engine/support/religions-generator_render.md
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
# Removed Rendering/UI Logic from religions-generator.js
|
||||
|
||||
## Analysis Result
|
||||
|
||||
**No rendering or UI logic was found in the original religions-generator.js module.**
|
||||
|
||||
The original code was purely computational and focused on:
|
||||
|
||||
1. **Data Generation**: Creating religion data structures
|
||||
2. **Algorithm Logic**: Implementing religion placement, expansion, and naming algorithms
|
||||
3. **Data Transformation**: Processing and organizing religion data
|
||||
4. **State Management**: Managing religion relationships and properties
|
||||
|
||||
## What Was NOT Removed
|
||||
|
||||
The code contained **zero** instances of:
|
||||
- DOM manipulation (no `document.getElementById`, `innerHTML`, etc.)
|
||||
- SVG rendering (no `d3.select`, path creation, etc.)
|
||||
- UI updates (no element styling, class additions, etc.)
|
||||
- Browser-specific APIs
|
||||
|
||||
## Conclusion
|
||||
|
||||
This module was already well-separated in terms of concerns - it handled pure data generation logic without any rendering responsibilities. The refactoring focused entirely on:
|
||||
|
||||
- Converting from IIFE to ES modules
|
||||
- Replacing DOM-based configuration reads with config parameters
|
||||
- Implementing dependency injection for global state access
|
||||
- Making functions pure by returning new data instead of mutating globals
|
||||
|
||||
No rendering logic needed to be extracted to a separate viewer component.
|
||||
26
procedural/src/engine/support/resample_config.md
Normal file
26
procedural/src/engine/support/resample_config.md
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
# Config Properties for resample.js
|
||||
|
||||
The refactored `resample.js` module requires the following configuration properties to be passed in the `config` object:
|
||||
|
||||
## Required Config Properties
|
||||
|
||||
### Map Dimensions
|
||||
- `graphWidth` (Number) - The width of the map/graph canvas
|
||||
- `graphHeight` (Number) - The height of the map/graph canvas
|
||||
|
||||
## Usage Context
|
||||
|
||||
These configuration properties replace the original global variables that were accessed directly:
|
||||
|
||||
### Original Global Access → Config Property
|
||||
- `graphWidth` → `config.graphWidth`
|
||||
- `graphHeight` → `config.graphHeight`
|
||||
|
||||
## Notes
|
||||
|
||||
The `graphWidth` and `graphHeight` properties are used extensively throughout the module for:
|
||||
- Boundary checking with `isInMap()` function calls
|
||||
- Creating bounding boxes for route clipping
|
||||
- Determining if projected coordinates fall within the map area
|
||||
|
||||
These values were previously accessed as global variables but are now properly injected as configuration parameters following the dependency injection pattern.
|
||||
40
procedural/src/engine/support/resample_external.md
Normal file
40
procedural/src/engine/support/resample_external.md
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
# External Module Dependencies for resample.js
|
||||
|
||||
The refactored `resample.js` module requires the following external modules to be imported:
|
||||
|
||||
## Engine Modules
|
||||
- `Features` - for `markupGrid()` and `markupPack()` methods
|
||||
- `Rivers` - for river processing methods like `addMeandering()`, `getBasin()`, `getApproximateLength()`
|
||||
- `BurgsAndStates` - for `getCloseToEdgePoint()` and `getPoles()` methods
|
||||
- `Routes` - for `buildLinks()` method
|
||||
- `Provinces` - for `getPoles()` method
|
||||
- `Markers` - for `deleteMarker()` method
|
||||
|
||||
## Utility Functions Required
|
||||
The `utils` parameter should include:
|
||||
- `deepCopy` - for deep copying objects
|
||||
- `generateGrid` - for generating new grid
|
||||
- `rn` - for rounding numbers
|
||||
- `findCell` - for finding cell by coordinates
|
||||
- `findAll` - for finding all cells in radius
|
||||
- `isInMap` - for checking if coordinates are within map bounds
|
||||
- `unique` - for getting unique values from array
|
||||
- `lineclip` - for line clipping operations
|
||||
- `WARN` - warning flag for console logging
|
||||
- `d3` - D3.js library functions (quadtree, mean)
|
||||
- `isWater` - utility to check if cell is water
|
||||
- `getPolesOfInaccessibility` - for calculating poles of inaccessibility
|
||||
- `smoothHeightmap` - for smoothing heightmap data
|
||||
|
||||
## Grid Processing Functions
|
||||
These functions need to be called externally after grid generation:
|
||||
- `addLakesInDeepDepressions()`
|
||||
- `openNearSeaLakes()`
|
||||
- `OceanLayers()`
|
||||
- `calculateMapCoordinates()`
|
||||
- `calculateTemperatures()`
|
||||
- `reGraph()`
|
||||
- `createDefaultRuler()`
|
||||
|
||||
## Library Dependencies
|
||||
- D3.js - for quadtree operations and mathematical functions
|
||||
451
procedural/src/engine/support/resample_prompt.md
Normal file
451
procedural/src/engine/support/resample_prompt.md
Normal file
|
|
@ -0,0 +1,451 @@
|
|||
# resample.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Pure functions:** Functions should not have side effects. They should either return a new state object or a specific piece of data.
|
||||
6. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
7. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
8. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `resample.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Resample = (function () {
|
||||
/*
|
||||
generate new map based on an existing one (resampling parentMap)
|
||||
parentMap: {grid, pack, notes} from original map
|
||||
projection: f(Number, Number) -> [Number, Number]
|
||||
inverse: f(Number, Number) -> [Number, Number]
|
||||
scale: Number
|
||||
*/
|
||||
function process({projection, inverse, scale}) {
|
||||
const parentMap = {grid: deepCopy(grid), pack: deepCopy(pack), notes: deepCopy(notes)};
|
||||
const riversData = saveRiversData(pack.rivers);
|
||||
|
||||
grid = generateGrid();
|
||||
pack = {};
|
||||
notes = parentMap.notes;
|
||||
|
||||
resamplePrimaryGridData(parentMap, inverse, scale);
|
||||
|
||||
Features.markupGrid();
|
||||
addLakesInDeepDepressions();
|
||||
openNearSeaLakes();
|
||||
|
||||
OceanLayers();
|
||||
calculateMapCoordinates();
|
||||
calculateTemperatures();
|
||||
|
||||
reGraph();
|
||||
Features.markupPack();
|
||||
createDefaultRuler();
|
||||
|
||||
restoreCellData(parentMap, inverse, scale);
|
||||
restoreRivers(riversData, projection, scale);
|
||||
restoreCultures(parentMap, projection);
|
||||
restoreBurgs(parentMap, projection, scale);
|
||||
restoreStates(parentMap, projection);
|
||||
restoreRoutes(parentMap, projection);
|
||||
restoreReligions(parentMap, projection);
|
||||
restoreProvinces(parentMap);
|
||||
restoreFeatureDetails(parentMap, inverse);
|
||||
restoreMarkers(parentMap, projection);
|
||||
restoreZones(parentMap, projection, scale);
|
||||
|
||||
showStatistics();
|
||||
}
|
||||
|
||||
function resamplePrimaryGridData(parentMap, inverse, scale) {
|
||||
grid.cells.h = new Uint8Array(grid.points.length);
|
||||
grid.cells.temp = new Int8Array(grid.points.length);
|
||||
grid.cells.prec = new Uint8Array(grid.points.length);
|
||||
|
||||
grid.points.forEach(([x, y], newGridCell) => {
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentPackCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
const parentGridCell = parentMap.pack.cells.g[parentPackCell];
|
||||
|
||||
grid.cells.h[newGridCell] = parentMap.grid.cells.h[parentGridCell];
|
||||
grid.cells.temp[newGridCell] = parentMap.grid.cells.temp[parentGridCell];
|
||||
grid.cells.prec[newGridCell] = parentMap.grid.cells.prec[parentGridCell];
|
||||
});
|
||||
|
||||
if (scale >= 2) smoothHeightmap();
|
||||
}
|
||||
|
||||
function smoothHeightmap() {
|
||||
grid.cells.h.forEach((height, newGridCell) => {
|
||||
const heights = [height, ...grid.cells.c[newGridCell].map(c => grid.cells.h[c])];
|
||||
const meanHeight = d3.mean(heights);
|
||||
grid.cells.h[newGridCell] = isWater(grid, newGridCell) ? Math.min(meanHeight, 19) : Math.max(meanHeight, 20);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCellData(parentMap, inverse, scale) {
|
||||
pack.cells.biome = new Uint8Array(pack.cells.i.length);
|
||||
pack.cells.fl = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.s = new Int16Array(pack.cells.i.length);
|
||||
pack.cells.pop = new Float32Array(pack.cells.i.length);
|
||||
pack.cells.culture = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.state = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.burg = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.religion = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.province = new Uint16Array(pack.cells.i.length);
|
||||
|
||||
const parentPackCellGroups = groupCellsByType(parentMap.pack);
|
||||
const parentPackLandCellsQuadtree = d3.quadtree(parentPackCellGroups.land);
|
||||
|
||||
for (const newPackCell of pack.cells.i) {
|
||||
const [x, y] = inverse(...pack.cells.p[newPackCell]);
|
||||
if (isWater(pack, newPackCell)) continue;
|
||||
|
||||
const parentPackCell = parentPackLandCellsQuadtree.find(x, y, Infinity)[2];
|
||||
const parentCellArea = parentMap.pack.cells.area[parentPackCell];
|
||||
const areaRatio = pack.cells.area[newPackCell] / parentCellArea;
|
||||
const scaleRatio = areaRatio / scale;
|
||||
|
||||
pack.cells.biome[newPackCell] = parentMap.pack.cells.biome[parentPackCell];
|
||||
pack.cells.fl[newPackCell] = parentMap.pack.cells.fl[parentPackCell];
|
||||
pack.cells.s[newPackCell] = parentMap.pack.cells.s[parentPackCell] * scaleRatio;
|
||||
pack.cells.pop[newPackCell] = parentMap.pack.cells.pop[parentPackCell] * scaleRatio;
|
||||
pack.cells.culture[newPackCell] = parentMap.pack.cells.culture[parentPackCell];
|
||||
pack.cells.state[newPackCell] = parentMap.pack.cells.state[parentPackCell];
|
||||
pack.cells.religion[newPackCell] = parentMap.pack.cells.religion[parentPackCell];
|
||||
pack.cells.province[newPackCell] = parentMap.pack.cells.province[parentPackCell];
|
||||
}
|
||||
}
|
||||
|
||||
function saveRiversData(parentRivers) {
|
||||
return parentRivers.map(river => {
|
||||
const meanderedPoints = Rivers.addMeandering(river.cells, river.points);
|
||||
return {...river, meanderedPoints};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRivers(riversData, projection, scale) {
|
||||
pack.cells.r = new Uint16Array(pack.cells.i.length);
|
||||
pack.cells.conf = new Uint8Array(pack.cells.i.length);
|
||||
|
||||
pack.rivers = riversData
|
||||
.map(river => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
river.meanderedPoints.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const cells = points.map(point => findCell(...point));
|
||||
cells.forEach(cellId => {
|
||||
if (pack.cells.r[cellId]) pack.cells.conf[cellId] = 1;
|
||||
pack.cells.r[cellId] = river.i;
|
||||
});
|
||||
|
||||
const widthFactor = river.widthFactor * scale;
|
||||
return {...river, cells, points, source: cells.at(0), mouth: cells.at(-2), widthFactor};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.rivers.forEach(river => {
|
||||
river.basin = Rivers.getBasin(river.i);
|
||||
river.length = Rivers.getApproximateLength(river.points);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreCultures(parentMap, projection) {
|
||||
const validCultures = new Set(pack.cells.culture);
|
||||
const culturePoles = getPolesOfInaccessibility(pack, cellId => pack.cells.culture[cellId]);
|
||||
pack.cultures = parentMap.pack.cultures.map(culture => {
|
||||
if (!culture.i || culture.removed) return culture;
|
||||
if (!validCultures.has(culture.i)) return {...culture, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[culture.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : culturePoles[culture.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...culture, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreBurgs(parentMap, projection, scale) {
|
||||
const packLandCellsQuadtree = d3.quadtree(groupCellsByType(pack).land);
|
||||
const findLandCell = (x, y) => packLandCellsQuadtree.find(x, y, Infinity)?.[2];
|
||||
|
||||
pack.burgs = parentMap.pack.burgs.map(burg => {
|
||||
if (!burg.i || burg.removed) return burg;
|
||||
burg.population *= scale; // adjust for populationRate change
|
||||
|
||||
const [xp, yp] = projection(burg.x, burg.y);
|
||||
if (!isInMap(xp, yp)) return {...burg, removed: true, lock: false};
|
||||
|
||||
const closestCell = findCell(xp, yp);
|
||||
const cell = isWater(pack, closestCell) ? findLandCell(xp, yp) : closestCell;
|
||||
|
||||
if (pack.cells.burg[cell]) {
|
||||
WARN && console.warn(`Cell ${cell} already has a burg. Removing burg ${burg.name} (${burg.i})`);
|
||||
return {...burg, removed: true, lock: false};
|
||||
}
|
||||
|
||||
pack.cells.burg[cell] = burg.i;
|
||||
const [x, y] = getBurgCoordinates(burg, closestCell, cell, xp, yp);
|
||||
return {...burg, cell, x, y};
|
||||
});
|
||||
|
||||
function getBurgCoordinates(burg, closestCell, cell, xp, yp) {
|
||||
const haven = pack.cells.haven[cell];
|
||||
if (burg.port && haven) return BurgsAndStates.getCloseToEdgePoint(cell, haven);
|
||||
|
||||
if (closestCell !== cell) return pack.cells.p[cell];
|
||||
return [rn(xp, 2), rn(yp, 2)];
|
||||
}
|
||||
}
|
||||
|
||||
function restoreStates(parentMap, projection) {
|
||||
const validStates = new Set(pack.cells.state);
|
||||
pack.states = parentMap.pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
if (validStates.has(state.i)) return state;
|
||||
return {...state, removed: true, lock: false};
|
||||
});
|
||||
|
||||
BurgsAndStates.getPoles();
|
||||
const regimentCellsMap = {};
|
||||
const VERTICAL_GAP = 8;
|
||||
|
||||
pack.states = pack.states.map(state => {
|
||||
if (!state.i || state.removed) return state;
|
||||
|
||||
const capital = pack.burgs[state.capital];
|
||||
state.center = !capital || capital.removed ? findCell(...state.pole) : capital.cell;
|
||||
|
||||
const military = state.military.map(regiment => {
|
||||
const cellCoords = projection(...parentMap.pack.cells.p[regiment.cell]);
|
||||
const cell = isInMap(...cellCoords) ? findCell(...cellCoords) : state.center;
|
||||
|
||||
const [xPos, yPos] = projection(regiment.x, regiment.y);
|
||||
const [xBase, yBase] = projection(regiment.bx, regiment.by);
|
||||
const [xCell, yCell] = pack.cells.p[cell];
|
||||
|
||||
const regsOnCell = regimentCellsMap[cell] || 0;
|
||||
regimentCellsMap[cell] = regsOnCell + 1;
|
||||
|
||||
const name =
|
||||
isInMap(xPos, yPos) || regiment.name.includes("[relocated]") ? regiment.name : `[relocated] ${regiment.name}`;
|
||||
|
||||
const pos = isInMap(xPos, yPos)
|
||||
? {x: rn(xPos, 2), y: rn(yPos, 2)}
|
||||
: {x: xCell, y: yCell + regsOnCell * VERTICAL_GAP};
|
||||
|
||||
const base = isInMap(xBase, yBase) ? {bx: rn(xBase, 2), by: rn(yBase, 2)} : {bx: xCell, by: yCell};
|
||||
|
||||
return {...regiment, cell, name, ...base, ...pos};
|
||||
});
|
||||
|
||||
const neighbors = state.neighbors.filter(stateId => validStates.has(stateId));
|
||||
return {...state, neighbors, military};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreRoutes(parentMap, projection) {
|
||||
pack.routes = parentMap.pack.routes
|
||||
.map(route => {
|
||||
let wasInMap = true;
|
||||
const points = [];
|
||||
|
||||
route.points.forEach(([parentX, parentY]) => {
|
||||
const [x, y] = projection(parentX, parentY);
|
||||
const inMap = isInMap(x, y);
|
||||
if (inMap || wasInMap) points.push([rn(x, 2), rn(y, 2)]);
|
||||
wasInMap = inMap;
|
||||
});
|
||||
if (points.length < 2) return null;
|
||||
|
||||
const bbox = [0, 0, graphWidth, graphHeight];
|
||||
const clipped = lineclip(points, bbox)[0].map(([x, y]) => [rn(x, 2), rn(y, 2), findCell(x, y)]);
|
||||
const firstCell = clipped[0][2];
|
||||
const feature = pack.cells.f[firstCell];
|
||||
return {...route, feature, points: clipped};
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
pack.cells.routes = Routes.buildLinks(pack.routes);
|
||||
}
|
||||
|
||||
function restoreReligions(parentMap, projection) {
|
||||
const validReligions = new Set(pack.cells.religion);
|
||||
const religionPoles = getPolesOfInaccessibility(pack, cellId => pack.cells.religion[cellId]);
|
||||
|
||||
pack.religions = parentMap.pack.religions.map(religion => {
|
||||
if (!religion.i || religion.removed) return religion;
|
||||
if (!validReligions.has(religion.i)) return {...religion, removed: true, lock: false};
|
||||
|
||||
const [xp, yp] = projection(...parentMap.pack.cells.p[religion.center]);
|
||||
const [x, y] = [rn(xp, 2), rn(yp, 2)];
|
||||
const centerCoords = isInMap(x, y) ? [x, y] : religionPoles[religion.i];
|
||||
const center = findCell(...centerCoords);
|
||||
return {...religion, center};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreProvinces(parentMap) {
|
||||
const validProvinces = new Set(pack.cells.province);
|
||||
pack.provinces = parentMap.pack.provinces.map(province => {
|
||||
if (!province.i || province.removed) return province;
|
||||
if (!validProvinces.has(province.i)) return {...province, removed: true, lock: false};
|
||||
|
||||
return province;
|
||||
});
|
||||
|
||||
Provinces.getPoles();
|
||||
|
||||
pack.provinces.forEach(province => {
|
||||
if (!province.i || province.removed) return;
|
||||
const capital = pack.burgs[province.burg];
|
||||
province.center = !capital?.removed ? capital.cell : findCell(...province.pole);
|
||||
});
|
||||
}
|
||||
|
||||
function restoreMarkers(parentMap, projection) {
|
||||
pack.markers = parentMap.pack.markers;
|
||||
pack.markers.forEach(marker => {
|
||||
const [x, y] = projection(marker.x, marker.y);
|
||||
if (!isInMap(x, y)) Markers.deleteMarker(marker.i);
|
||||
|
||||
const cell = findCell(x, y);
|
||||
marker.x = rn(x, 2);
|
||||
marker.y = rn(y, 2);
|
||||
marker.cell = cell;
|
||||
});
|
||||
}
|
||||
|
||||
function restoreZones(parentMap, projection, scale) {
|
||||
const getSearchRadius = cellId => Math.sqrt(parentMap.pack.cells.area[cellId] / Math.PI) * scale;
|
||||
|
||||
pack.zones = parentMap.pack.zones.map(zone => {
|
||||
const cells = zone.cells
|
||||
.map(cellId => {
|
||||
const [x, y] = projection(...parentMap.pack.cells.p[cellId]);
|
||||
if (!isInMap(x, y)) return null;
|
||||
return findAll(x, y, getSearchRadius(cellId));
|
||||
})
|
||||
.filter(Boolean)
|
||||
.flat();
|
||||
|
||||
return {...zone, cells: unique(cells)};
|
||||
});
|
||||
}
|
||||
|
||||
function restoreFeatureDetails(parentMap, inverse) {
|
||||
pack.features.forEach(feature => {
|
||||
if (!feature) return;
|
||||
const [x, y] = pack.cells.p[feature.firstCell];
|
||||
const [parentX, parentY] = inverse(x, y);
|
||||
const parentCell = parentMap.pack.cells.q.find(parentX, parentY, Infinity)[2];
|
||||
if (parentCell === undefined) return;
|
||||
const parentFeature = parentMap.pack.features[parentMap.pack.cells.f[parentCell]];
|
||||
|
||||
if (parentFeature.group) feature.group = parentFeature.group;
|
||||
if (parentFeature.name) feature.name = parentFeature.name;
|
||||
if (parentFeature.height) feature.height = parentFeature.height;
|
||||
});
|
||||
}
|
||||
|
||||
function groupCellsByType(graph) {
|
||||
return graph.cells.p.reduce(
|
||||
(acc, [x, y], cellId) => {
|
||||
const group = isWater(graph, cellId) ? "water" : "land";
|
||||
acc[group].push([x, y, cellId]);
|
||||
return acc;
|
||||
},
|
||||
{land: [], water: []}
|
||||
);
|
||||
}
|
||||
|
||||
function isWater(graph, cellId) {
|
||||
return graph.cells.h[cellId] < 20;
|
||||
}
|
||||
|
||||
function isInMap(x, y) {
|
||||
return x >= 0 && x <= graphWidth && y >= 0 && y <= graphHeight;
|
||||
}
|
||||
|
||||
return {process};
|
||||
})();
|
||||
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./resample.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./resample_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in resample_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into resample_render.md
|
||||
30
procedural/src/engine/support/resample_render.md
Normal file
30
procedural/src/engine/support/resample_render.md
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
# Removed Rendering/UI Logic from resample.js
|
||||
|
||||
The following rendering and UI-related code blocks were **removed** from the engine module and should be moved to the Viewer application:
|
||||
|
||||
## Removed UI/Rendering Logic
|
||||
|
||||
### Statistics Display
|
||||
```javascript
|
||||
// Line 117 in original code
|
||||
showStatistics();
|
||||
```
|
||||
|
||||
**Description:** This function call was responsible for displaying statistics to the user interface after the resampling process completed. This is purely a UI/rendering concern and has been removed from the core engine.
|
||||
|
||||
**Location in Original:** Called at the end of the `process()` function (line 117)
|
||||
|
||||
**Reason for Removal:** This function updates the DOM/UI to show statistics about the generated map, which violates the separation of concerns principle for the headless engine.
|
||||
|
||||
## Notes
|
||||
|
||||
The original `resample.js` module was relatively clean in terms of separation of concerns. The only UI-related code was the single `showStatistics()` call, which was a clear DOM/UI interaction that needed to be removed from the core engine.
|
||||
|
||||
All other code in the module was focused on data processing and transformation, which aligns well with the headless engine architecture.
|
||||
|
||||
## Viewer Integration
|
||||
|
||||
The Viewer application should:
|
||||
1. Call the engine's `process()` function to get the resampled map data
|
||||
2. Call `showStatistics()` with the returned data to update the UI
|
||||
3. Handle any other UI updates needed after resampling
|
||||
559
procedural/src/engine/support/river-generator.txt
Normal file
559
procedural/src/engine/support/river-generator.txt
Normal file
|
|
@ -0,0 +1,559 @@
|
|||
"use strict";
|
||||
|
||||
export const generate = function (pack, grid, config, utils, modules, allowErosion = true) {
|
||||
const {TIME, seed, aleaPRNG, resolveDepressionsSteps, cellsCount, graphWidth, graphHeight, WARN} = config;
|
||||
const {rn, rw, each, round, d3, lineGen} = utils;
|
||||
const {Lakes, Names} = modules;
|
||||
|
||||
TIME && console.time("generateRivers");
|
||||
Math.random = aleaPRNG(seed);
|
||||
const {cells, features} = pack;
|
||||
|
||||
const riversData = {}; // rivers data
|
||||
const riverParents = {};
|
||||
|
||||
const addCellToRiver = function (cell, river) {
|
||||
if (!riversData[river]) riversData[river] = [cell];
|
||||
else riversData[river].push(cell);
|
||||
};
|
||||
|
||||
const newCells = {
|
||||
...cells,
|
||||
fl: new Uint16Array(cells.i.length), // water flux array
|
||||
r: new Uint16Array(cells.i.length), // rivers array
|
||||
conf: new Uint8Array(cells.i.length) // confluences array
|
||||
};
|
||||
|
||||
let riverNext = 1; // first river id is 1
|
||||
|
||||
const h = alterHeights(pack, utils);
|
||||
Lakes.detectCloseLakes(h);
|
||||
const resolvedH = resolveDepressions(pack, config, utils, h);
|
||||
const {updatedCells, updatedFeatures, updatedRivers} = drainWater(pack, grid, config, utils, modules, newCells, resolvedH, riversData, riverParents, riverNext);
|
||||
const {finalCells, finalRivers} = defineRivers(pack, config, utils, updatedCells, riversData, riverParents);
|
||||
|
||||
calculateConfluenceFlux(finalCells, resolvedH);
|
||||
Lakes.cleanupLakeData();
|
||||
|
||||
let finalH = resolvedH;
|
||||
if (allowErosion) {
|
||||
finalH = Uint8Array.from(resolvedH); // apply gradient
|
||||
downcutRivers(pack, finalCells, finalH); // downcut river beds
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateRivers");
|
||||
|
||||
return {
|
||||
pack: {
|
||||
...pack,
|
||||
cells: {
|
||||
...pack.cells,
|
||||
...finalCells,
|
||||
h: finalH
|
||||
},
|
||||
features: updatedFeatures,
|
||||
rivers: finalRivers
|
||||
}
|
||||
};
|
||||
|
||||
function drainWater(pack, grid, config, utils, modules, cells, h, riversData, riverParents, riverNext) {
|
||||
const {cellsCount} = config;
|
||||
const {Lakes} = modules;
|
||||
const MIN_FLUX_TO_FORM_RIVER = 30;
|
||||
const cellsNumberModifier = (cellsCount / 10000) ** 0.25;
|
||||
|
||||
const prec = grid.cells.prec;
|
||||
const land = cells.i.filter(i => h[i] >= 20).sort((a, b) => h[b] - h[a]);
|
||||
const lakeOutCells = Lakes.defineClimateData(h);
|
||||
|
||||
land.forEach(function (i) {
|
||||
cells.fl[i] += prec[cells.g[i]] / cellsNumberModifier; // add flux from precipitation
|
||||
|
||||
// create lake outlet if lake is not in deep depression and flux > evaporation
|
||||
const lakes = lakeOutCells[i]
|
||||
? features.filter(feature => i === feature.outCell && feature.flux > feature.evaporation)
|
||||
: [];
|
||||
for (const lake of lakes) {
|
||||
const lakeCell = cells.c[i].find(c => h[c] < 20 && cells.f[c] === lake.i);
|
||||
cells.fl[lakeCell] += Math.max(lake.flux - lake.evaporation, 0); // not evaporated lake water drains to outlet
|
||||
|
||||
// allow chain lakes to retain identity
|
||||
if (cells.r[lakeCell] !== lake.river) {
|
||||
const sameRiver = cells.c[lakeCell].some(c => cells.r[c] === lake.river);
|
||||
|
||||
if (sameRiver) {
|
||||
cells.r[lakeCell] = lake.river;
|
||||
addCellToRiver(lakeCell, lake.river);
|
||||
} else {
|
||||
cells.r[lakeCell] = riverNext;
|
||||
addCellToRiver(lakeCell, riverNext);
|
||||
riverNext++;
|
||||
}
|
||||
}
|
||||
|
||||
lake.outlet = cells.r[lakeCell];
|
||||
flowDown(i, cells.fl[lakeCell], lake.outlet);
|
||||
}
|
||||
|
||||
// assign all tributary rivers to outlet basin
|
||||
const outlet = lakes[0]?.outlet;
|
||||
for (const lake of lakes) {
|
||||
if (!Array.isArray(lake.inlets)) continue;
|
||||
for (const inlet of lake.inlets) {
|
||||
riverParents[inlet] = outlet;
|
||||
}
|
||||
}
|
||||
|
||||
// near-border cell: pour water out of the screen
|
||||
if (cells.b[i] && cells.r[i]) return addCellToRiver(-1, cells.r[i]);
|
||||
|
||||
// downhill cell (make sure it's not in the source lake)
|
||||
let min = null;
|
||||
if (lakeOutCells[i]) {
|
||||
const filtered = cells.c[i].filter(c => !lakes.map(lake => lake.i).includes(cells.f[c]));
|
||||
min = filtered.sort((a, b) => h[a] - h[b])[0];
|
||||
} else if (cells.haven[i]) {
|
||||
min = cells.haven[i];
|
||||
} else {
|
||||
min = cells.c[i].sort((a, b) => h[a] - h[b])[0];
|
||||
}
|
||||
|
||||
// cells is depressed
|
||||
if (h[i] <= h[min]) return;
|
||||
|
||||
if (cells.fl[i] < MIN_FLUX_TO_FORM_RIVER) {
|
||||
// flux is too small to operate as a river
|
||||
if (h[min] >= 20) cells.fl[min] += cells.fl[i];
|
||||
return;
|
||||
}
|
||||
|
||||
// proclaim a new river
|
||||
if (!cells.r[i]) {
|
||||
cells.r[i] = riverNext;
|
||||
addCellToRiver(i, riverNext);
|
||||
riverNext++;
|
||||
}
|
||||
|
||||
flowDown(min, cells.fl[i], cells.r[i]);
|
||||
});
|
||||
|
||||
function flowDown(toCell, fromFlux, river) {
|
||||
const toFlux = cells.fl[toCell] - cells.conf[toCell];
|
||||
const toRiver = cells.r[toCell];
|
||||
|
||||
if (toRiver) {
|
||||
// downhill cell already has river assigned
|
||||
if (fromFlux > toFlux) {
|
||||
cells.conf[toCell] += cells.fl[toCell]; // mark confluence
|
||||
if (h[toCell] >= 20) riverParents[toRiver] = river; // min river is a tributary of current river
|
||||
cells.r[toCell] = river; // re-assign river if downhill part has less flux
|
||||
} else {
|
||||
cells.conf[toCell] += fromFlux; // mark confluence
|
||||
if (h[toCell] >= 20) riverParents[river] = toRiver; // current river is a tributary of min river
|
||||
}
|
||||
} else cells.r[toCell] = river; // assign the river to the downhill cell
|
||||
|
||||
if (h[toCell] < 20) {
|
||||
// pour water to the water body
|
||||
const waterBody = features[cells.f[toCell]];
|
||||
if (waterBody.type === "lake") {
|
||||
if (!waterBody.river || fromFlux > waterBody.enteringFlux) {
|
||||
waterBody.river = river;
|
||||
waterBody.enteringFlux = fromFlux;
|
||||
}
|
||||
waterBody.flux = waterBody.flux + fromFlux;
|
||||
if (!waterBody.inlets) waterBody.inlets = [river];
|
||||
else waterBody.inlets.push(river);
|
||||
}
|
||||
} else {
|
||||
// propagate flux and add next river segment
|
||||
cells.fl[toCell] += fromFlux;
|
||||
}
|
||||
|
||||
addCellToRiver(toCell, river);
|
||||
}
|
||||
|
||||
return {
|
||||
updatedCells: cells,
|
||||
updatedFeatures: features,
|
||||
updatedRivers: []
|
||||
};
|
||||
}
|
||||
|
||||
function defineRivers(pack, config, utils, cells, riversData, riverParents) {
|
||||
const {cellsCount} = config;
|
||||
const {rn} = utils;
|
||||
|
||||
// re-initialize rivers and confluence arrays
|
||||
const newCells = {
|
||||
...cells,
|
||||
r: new Uint16Array(cells.i.length),
|
||||
conf: new Uint16Array(cells.i.length)
|
||||
};
|
||||
const rivers = [];
|
||||
|
||||
const defaultWidthFactor = rn(1 / (cellsCount / 10000) ** 0.25, 2);
|
||||
const mainStemWidthFactor = defaultWidthFactor * 1.2;
|
||||
|
||||
for (const key in riversData) {
|
||||
const riverCells = riversData[key];
|
||||
if (riverCells.length < 3) continue; // exclude tiny rivers
|
||||
|
||||
const riverId = +key;
|
||||
for (const cell of riverCells) {
|
||||
if (cell < 0 || cells.h[cell] < 20) continue;
|
||||
|
||||
// mark real confluences and assign river to cells
|
||||
if (newCells.r[cell]) newCells.conf[cell] = 1;
|
||||
else newCells.r[cell] = riverId;
|
||||
}
|
||||
|
||||
const source = riverCells[0];
|
||||
const mouth = riverCells[riverCells.length - 2];
|
||||
const parent = riverParents[key] || 0;
|
||||
|
||||
const widthFactor = !parent || parent === riverId ? mainStemWidthFactor : defaultWidthFactor;
|
||||
const meanderedPoints = addMeandering(pack, utils, riverCells);
|
||||
const discharge = cells.fl[mouth]; // m3 in second
|
||||
const length = getApproximateLength(utils, meanderedPoints);
|
||||
const sourceWidth = getSourceWidth(utils, cells.fl[source]);
|
||||
const width = getWidth(utils,
|
||||
getOffset(utils, {
|
||||
flux: discharge,
|
||||
pointIndex: meanderedPoints.length,
|
||||
widthFactor,
|
||||
startingWidth: sourceWidth
|
||||
})
|
||||
);
|
||||
|
||||
rivers.push({
|
||||
i: riverId,
|
||||
source,
|
||||
mouth,
|
||||
discharge,
|
||||
length,
|
||||
width,
|
||||
widthFactor,
|
||||
sourceWidth,
|
||||
parent,
|
||||
cells: riverCells
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
finalCells: newCells,
|
||||
finalRivers: rivers
|
||||
};
|
||||
}
|
||||
|
||||
function downcutRivers(pack, cells, h) {
|
||||
const MAX_DOWNCUT = 5;
|
||||
|
||||
for (const i of pack.cells.i) {
|
||||
if (cells.h[i] < 35) continue; // don't donwcut lowlands
|
||||
if (!cells.fl[i]) continue;
|
||||
|
||||
const higherCells = cells.c[i].filter(c => cells.h[c] > cells.h[i]);
|
||||
const higherFlux = higherCells.reduce((acc, c) => acc + cells.fl[c], 0) / higherCells.length;
|
||||
if (!higherFlux) continue;
|
||||
|
||||
const downcut = Math.floor(cells.fl[i] / higherFlux);
|
||||
if (downcut) cells.h[i] -= Math.min(downcut, MAX_DOWNCUT);
|
||||
}
|
||||
}
|
||||
|
||||
function calculateConfluenceFlux(cells, h) {
|
||||
for (const i of cells.i) {
|
||||
if (!cells.conf[i]) continue;
|
||||
|
||||
const sortedInflux = cells.c[i]
|
||||
.filter(c => cells.r[c] && h[c] > h[i])
|
||||
.map(c => cells.fl[c])
|
||||
.sort((a, b) => b - a);
|
||||
cells.conf[i] = sortedInflux.reduce((acc, flux, index) => (index ? acc + flux : acc), 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// add distance to water value to land cells to make map less depressed
|
||||
export const alterHeights = (pack, utils) => {
|
||||
const {d3} = utils;
|
||||
const {h, c, t} = pack.cells;
|
||||
return Array.from(h).map((h, i) => {
|
||||
if (h < 20 || t[i] < 1) return h;
|
||||
return h + t[i] / 100 + d3.mean(c[i].map(c => t[c])) / 10000;
|
||||
});
|
||||
};
|
||||
|
||||
// depression filling algorithm (for a correct water flux modeling)
|
||||
export const resolveDepressions = function (pack, config, utils, h) {
|
||||
const {resolveDepressionsSteps, WARN} = config;
|
||||
const {d3} = utils;
|
||||
const {cells, features} = pack;
|
||||
const maxIterations = resolveDepressionsSteps;
|
||||
const checkLakeMaxIteration = maxIterations * 0.85;
|
||||
const elevateLakeMaxIteration = maxIterations * 0.75;
|
||||
|
||||
const height = i => features[cells.f[i]].height || h[i]; // height of lake or specific cell
|
||||
|
||||
const lakes = features.filter(f => f.type === "lake");
|
||||
const land = cells.i.filter(i => h[i] >= 20 && !cells.b[i]); // exclude near-border cells
|
||||
land.sort((a, b) => h[a] - h[b]); // lowest cells go first
|
||||
|
||||
const progress = [];
|
||||
let depressions = Infinity;
|
||||
let prevDepressions = null;
|
||||
for (let iteration = 0; depressions && iteration < maxIterations; iteration++) {
|
||||
if (progress.length > 5 && d3.sum(progress) > 0) {
|
||||
// bad progress, abort and set heights back
|
||||
h = alterHeights(pack, utils);
|
||||
depressions = progress[0];
|
||||
break;
|
||||
}
|
||||
|
||||
depressions = 0;
|
||||
|
||||
if (iteration < checkLakeMaxIteration) {
|
||||
for (const l of lakes) {
|
||||
if (l.closed) continue;
|
||||
const minHeight = d3.min(l.shoreline.map(s => h[s]));
|
||||
if (minHeight >= 100 || l.height > minHeight) continue;
|
||||
|
||||
if (iteration > elevateLakeMaxIteration) {
|
||||
l.shoreline.forEach(i => (h[i] = cells.h[i]));
|
||||
l.height = d3.min(l.shoreline.map(s => h[s])) - 1;
|
||||
l.closed = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
depressions++;
|
||||
l.height = minHeight + 0.2;
|
||||
}
|
||||
}
|
||||
|
||||
for (const i of land) {
|
||||
const minHeight = d3.min(cells.c[i].map(c => height(c)));
|
||||
if (minHeight >= 100 || h[i] > minHeight) continue;
|
||||
|
||||
depressions++;
|
||||
h[i] = minHeight + 0.1;
|
||||
}
|
||||
|
||||
prevDepressions !== null && progress.push(depressions - prevDepressions);
|
||||
prevDepressions = depressions;
|
||||
}
|
||||
|
||||
depressions && WARN && console.warn(`Unresolved depressions: ${depressions}. Edit heightmap to fix`);
|
||||
return h;
|
||||
};
|
||||
|
||||
// add points at 1/3 and 2/3 of a line between adjacents river cells
|
||||
export const addMeandering = function (pack, utils, riverCells, riverPoints = null, meandering = 0.5) {
|
||||
const {fl, h} = pack.cells;
|
||||
const meandered = [];
|
||||
const lastStep = riverCells.length - 1;
|
||||
const points = getRiverPoints(pack, riverCells, riverPoints);
|
||||
let step = h[riverCells[0]] < 20 ? 1 : 10;
|
||||
|
||||
for (let i = 0; i <= lastStep; i++, step++) {
|
||||
const cell = riverCells[i];
|
||||
const isLastCell = i === lastStep;
|
||||
|
||||
const [x1, y1] = points[i];
|
||||
|
||||
meandered.push([x1, y1, fl[cell]]);
|
||||
if (isLastCell) break;
|
||||
|
||||
const nextCell = riverCells[i + 1];
|
||||
const [x2, y2] = points[i + 1];
|
||||
|
||||
if (nextCell === -1) {
|
||||
meandered.push([x2, y2, fl[cell]]);
|
||||
break;
|
||||
}
|
||||
|
||||
const dist2 = (x2 - x1) ** 2 + (y2 - y1) ** 2; // square distance between cells
|
||||
if (dist2 <= 25 && riverCells.length >= 6) continue;
|
||||
|
||||
const meander = meandering + 1 / step + Math.max(meandering - step / 100, 0);
|
||||
const angle = Math.atan2(y2 - y1, x2 - x1);
|
||||
const sinMeander = Math.sin(angle) * meander;
|
||||
const cosMeander = Math.cos(angle) * meander;
|
||||
|
||||
if (step < 20 && (dist2 > 64 || (dist2 > 36 && riverCells.length < 5))) {
|
||||
// if dist2 is big or river is small add extra points at 1/3 and 2/3 of segment
|
||||
const p1x = (x1 * 2 + x2) / 3 + -sinMeander;
|
||||
const p1y = (y1 * 2 + y2) / 3 + cosMeander;
|
||||
const p2x = (x1 + x2 * 2) / 3 + sinMeander / 2;
|
||||
const p2y = (y1 + y2 * 2) / 3 - cosMeander / 2;
|
||||
meandered.push([p1x, p1y, 0], [p2x, p2y, 0]);
|
||||
} else if (dist2 > 25 || riverCells.length < 6) {
|
||||
// if dist is medium or river is small add 1 extra middlepoint
|
||||
const p1x = (x1 + x2) / 2 + -sinMeander;
|
||||
const p1y = (y1 + y2) / 2 + cosMeander;
|
||||
meandered.push([p1x, p1y, 0]);
|
||||
}
|
||||
}
|
||||
|
||||
return meandered;
|
||||
};
|
||||
|
||||
export const getRiverPoints = (pack, riverCells, riverPoints) => {
|
||||
if (riverPoints) return riverPoints;
|
||||
|
||||
const {p} = pack.cells;
|
||||
return riverCells.map((cell, i) => {
|
||||
if (cell === -1) return getBorderPoint(pack, riverCells[i - 1]);
|
||||
return p[cell];
|
||||
});
|
||||
};
|
||||
|
||||
export const getBorderPoint = (pack, config, i) => {
|
||||
const {graphWidth, graphHeight} = config;
|
||||
const [x, y] = pack.cells.p[i];
|
||||
const min = Math.min(y, graphHeight - y, x, graphWidth - x);
|
||||
if (min === y) return [x, 0];
|
||||
else if (min === graphHeight - y) return [x, graphHeight];
|
||||
else if (min === x) return [0, y];
|
||||
return [graphWidth, y];
|
||||
};
|
||||
|
||||
const FLUX_FACTOR = 500;
|
||||
const MAX_FLUX_WIDTH = 1;
|
||||
const LENGTH_FACTOR = 200;
|
||||
const LENGTH_STEP_WIDTH = 1 / LENGTH_FACTOR;
|
||||
const LENGTH_PROGRESSION = [1, 1, 2, 3, 5, 8, 13, 21, 34].map(n => n / LENGTH_FACTOR);
|
||||
|
||||
export const getOffset = (utils, {flux, pointIndex, widthFactor, startingWidth}) => {
|
||||
if (pointIndex === 0) return startingWidth;
|
||||
|
||||
const fluxWidth = Math.min(flux ** 0.7 / FLUX_FACTOR, MAX_FLUX_WIDTH);
|
||||
const lengthWidth = pointIndex * LENGTH_STEP_WIDTH + (LENGTH_PROGRESSION[pointIndex] || LENGTH_PROGRESSION.at(-1));
|
||||
return widthFactor * (lengthWidth + fluxWidth) + startingWidth;
|
||||
};
|
||||
|
||||
export const getSourceWidth = (utils, flux) => {
|
||||
const {rn} = utils;
|
||||
return rn(Math.min(flux ** 0.9 / FLUX_FACTOR, MAX_FLUX_WIDTH), 2);
|
||||
};
|
||||
|
||||
// build polygon from a list of points and calculated offset (width)
|
||||
export const getRiverPath = (utils, points, widthFactor, startingWidth) => {
|
||||
const {lineGen, d3, round} = utils;
|
||||
lineGen.curve(d3.curveCatmullRom.alpha(0.1));
|
||||
const riverPointsLeft = [];
|
||||
const riverPointsRight = [];
|
||||
let flux = 0;
|
||||
|
||||
for (let pointIndex = 0; pointIndex < points.length; pointIndex++) {
|
||||
const [x0, y0] = points[pointIndex - 1] || points[pointIndex];
|
||||
const [x1, y1, pointFlux] = points[pointIndex];
|
||||
const [x2, y2] = points[pointIndex + 1] || points[pointIndex];
|
||||
if (pointFlux > flux) flux = pointFlux;
|
||||
|
||||
const offset = getOffset(utils, {flux, pointIndex, widthFactor, startingWidth});
|
||||
const angle = Math.atan2(y0 - y2, x0 - x2);
|
||||
const sinOffset = Math.sin(angle) * offset;
|
||||
const cosOffset = Math.cos(angle) * offset;
|
||||
|
||||
riverPointsLeft.push([x1 - sinOffset, y1 + cosOffset]);
|
||||
riverPointsRight.push([x1 + sinOffset, y1 - cosOffset]);
|
||||
}
|
||||
|
||||
const right = lineGen(riverPointsRight.reverse());
|
||||
let left = lineGen(riverPointsLeft);
|
||||
left = left.substring(left.indexOf("C"));
|
||||
|
||||
return round(right + left, 1);
|
||||
};
|
||||
|
||||
export const specify = function (pack, modules, utils) {
|
||||
const rivers = pack.rivers;
|
||||
if (!rivers.length) return pack;
|
||||
|
||||
const updatedRivers = rivers.map(river => ({
|
||||
...river,
|
||||
basin: getBasin(pack, river.i),
|
||||
name: getName(pack, modules, river.mouth),
|
||||
type: getType(pack, utils, river)
|
||||
}));
|
||||
|
||||
return {
|
||||
...pack,
|
||||
rivers: updatedRivers
|
||||
};
|
||||
};
|
||||
|
||||
export const getName = function (pack, modules, cell) {
|
||||
const {Names} = modules;
|
||||
return Names.getCulture(pack.cells.culture[cell]);
|
||||
};
|
||||
|
||||
// weighted arrays of river type names
|
||||
const riverTypes = {
|
||||
main: {
|
||||
big: {River: 1},
|
||||
small: {Creek: 9, River: 3, Brook: 3, Stream: 1}
|
||||
},
|
||||
fork: {
|
||||
big: {Fork: 1},
|
||||
small: {Branch: 1}
|
||||
}
|
||||
};
|
||||
|
||||
let smallLength = null;
|
||||
export const getType = function (pack, utils, {i, length, parent}) {
|
||||
const {rw, each} = utils;
|
||||
if (smallLength === null) {
|
||||
const threshold = Math.ceil(pack.rivers.length * 0.15);
|
||||
smallLength = pack.rivers.map(r => r.length || 0).sort((a, b) => a - b)[threshold];
|
||||
}
|
||||
|
||||
const isSmall = length < smallLength;
|
||||
const isFork = each(3)(i) && parent && parent !== i;
|
||||
return rw(riverTypes[isFork ? "fork" : "main"][isSmall ? "small" : "big"]);
|
||||
};
|
||||
|
||||
export const getApproximateLength = (utils, points) => {
|
||||
const {rn} = utils;
|
||||
const length = points.reduce((s, v, i, p) => s + (i ? Math.hypot(v[0] - p[i - 1][0], v[1] - p[i - 1][1]) : 0), 0);
|
||||
return rn(length, 2);
|
||||
};
|
||||
|
||||
// Real mouth width examples: Amazon 6000m, Volga 6000m, Dniepr 3000m, Mississippi 1300m, Themes 900m,
|
||||
// Danube 800m, Daugava 600m, Neva 500m, Nile 450m, Don 400m, Wisla 300m, Pripyat 150m, Bug 140m, Muchavets 40m
|
||||
export const getWidth = (utils, offset) => {
|
||||
const {rn} = utils;
|
||||
return rn((offset / 1.5) ** 1.8, 2); // mouth width in km
|
||||
};
|
||||
|
||||
// remove river and all its tributaries
|
||||
export const remove = function (pack, grid, id) {
|
||||
const cells = pack.cells;
|
||||
const riversToRemove = pack.rivers.filter(r => r.i === id || r.parent === id || r.basin === id).map(r => r.i);
|
||||
|
||||
// Update cells data
|
||||
cells.r.forEach((r, i) => {
|
||||
if (!r || !riversToRemove.includes(r)) return;
|
||||
cells.r[i] = 0;
|
||||
cells.fl[i] = grid.cells.prec[cells.g[i]];
|
||||
cells.conf[i] = 0;
|
||||
});
|
||||
|
||||
const updatedRivers = pack.rivers.filter(r => !riversToRemove.includes(r.i));
|
||||
|
||||
return {
|
||||
...pack,
|
||||
rivers: updatedRivers
|
||||
};
|
||||
};
|
||||
|
||||
export const getBasin = function (pack, r) {
|
||||
const parent = pack.rivers.find(river => river.i === r)?.parent;
|
||||
if (!parent || r === parent) return r;
|
||||
return getBasin(pack, parent);
|
||||
};
|
||||
|
||||
export const getNextId = function (rivers) {
|
||||
return rivers.length ? Math.max(...rivers.map(r => r.i)) + 1 : 1;
|
||||
};
|
||||
66
procedural/src/engine/support/river-generator_config.md
Normal file
66
procedural/src/engine/support/river-generator_config.md
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
# Configuration Properties for river-generator.js
|
||||
|
||||
## DOM-Based Configuration Parameters Identified
|
||||
|
||||
The refactored `river-generator.js` module identified the following DOM reads that were converted to config properties:
|
||||
|
||||
### `resolveDepressionsSteps`
|
||||
- **Original DOM read:** `document.getElementById("resolveDepressionsStepsOutput").value` (line 330)
|
||||
- **Purpose:** Maximum number of iterations for the depression resolution algorithm
|
||||
- **Type:** Number (integer)
|
||||
- **Default suggestion:** 1000
|
||||
|
||||
### Derived Configuration Parameters
|
||||
|
||||
Additionally, the following parameters were extracted from global variables that should be configurable:
|
||||
|
||||
### `cellsCount`
|
||||
- **Original source:** `pointsInput.dataset.cells` (lines 111, 240)
|
||||
- **Purpose:** Total number of cells in the map for calculations
|
||||
- **Type:** Number (integer)
|
||||
- **Usage:** Used in cellsNumberModifier calculations and width factor calculations
|
||||
|
||||
### Graph Dimensions
|
||||
- **Original source:** Global `graphWidth` and `graphHeight` (lines 449, 453)
|
||||
- **Purpose:** Map boundaries for border point calculations
|
||||
- **Type:** Number
|
||||
- **Properties:** `graphWidth`, `graphHeight`
|
||||
|
||||
### Flags and Constants
|
||||
- **Original source:** Global variables
|
||||
- **Properties:**
|
||||
- `TIME` - Boolean flag for timing logs
|
||||
- `WARN` - Boolean flag for warning messages
|
||||
- `seed` - Random seed for reproducible generation
|
||||
- `aleaPRNG` - Pseudo-random number generator function
|
||||
|
||||
## Configuration Object Structure
|
||||
|
||||
```javascript
|
||||
const config = {
|
||||
// DOM-derived parameters
|
||||
resolveDepressionsSteps: 1000, // Max iterations for depression resolution
|
||||
|
||||
// System parameters
|
||||
cellsCount: 10000, // Total number of map cells
|
||||
graphWidth: 1920, // Map width
|
||||
graphHeight: 1080, // Map height
|
||||
|
||||
// Flags and utilities
|
||||
TIME: true, // Enable timing logs
|
||||
WARN: true, // Enable warning messages
|
||||
seed: 'map_seed_123', // Random seed
|
||||
aleaPRNG: seedrandom // PRNG function
|
||||
};
|
||||
```
|
||||
|
||||
## Usage Notes
|
||||
|
||||
1. **`resolveDepressionsSteps`** is critical for terrain depression resolution - higher values provide more accurate results but take longer to compute
|
||||
2. **`cellsCount`** affects river width calculations and flux modifiers
|
||||
3. **Graph dimensions** are essential for proper border calculations when rivers flow off the map
|
||||
4. **Timing flags** should be configurable for debugging and performance monitoring
|
||||
|
||||
## Migration Impact
|
||||
|
||||
This conversion removes the last DOM dependency from the river generation system, making it fully headless and environment-agnostic while maintaining all original functionality through proper configuration injection.
|
||||
95
procedural/src/engine/support/river-generator_external.md
Normal file
95
procedural/src/engine/support/river-generator_external.md
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
# External Dependencies for river-generator.js
|
||||
|
||||
The refactored `river-generator.js` module requires the following external dependencies to be imported:
|
||||
|
||||
## Module Dependencies
|
||||
|
||||
### `Lakes` module
|
||||
- **Functions used:**
|
||||
- `Lakes.detectCloseLakes(h)` - Detect lakes close to each other
|
||||
- `Lakes.defineClimateData(h)` - Define climate data for lakes
|
||||
- `Lakes.cleanupLakeData()` - Clean up lake data after processing
|
||||
|
||||
### `Names` module
|
||||
- **Functions used:**
|
||||
- `Names.getCulture(cultureId)` - Get cultural names for rivers
|
||||
|
||||
## Utility Functions Required
|
||||
|
||||
The following utility functions need to be passed via the `utils` parameter:
|
||||
|
||||
### Core Utilities
|
||||
- `rn(value, precision)` - Rounding function with precision
|
||||
- `rw(weightedObject)` - Random weighted selection from object
|
||||
- `each(n)` - Function that returns a function checking if value is divisible by n
|
||||
- `round(value, precision)` - General rounding function
|
||||
|
||||
### D3.js Integration
|
||||
- `d3.mean(array)` - Calculate array mean
|
||||
- `d3.sum(array)` - Calculate array sum
|
||||
- `d3.min(array)` - Find minimum value in array
|
||||
- `d3.curveCatmullRom.alpha(value)` - D3 curve interpolation
|
||||
- `lineGen` - D3 line generator for creating SVG paths
|
||||
|
||||
## Configuration Dependencies
|
||||
|
||||
The following configuration values need to be passed via the `config` parameter:
|
||||
|
||||
### Core Configuration
|
||||
- `TIME` - Boolean flag to enable/disable timing logs
|
||||
- `seed` - Random seed value for reproducible generation
|
||||
- `aleaPRNG` - Pseudo-random number generator function
|
||||
- `resolveDepressionsSteps` - Maximum iterations for depression resolution algorithm
|
||||
- `cellsCount` - Total number of cells in the map
|
||||
- `graphWidth` - Width of the map graph
|
||||
- `graphHeight` - Height of the map graph
|
||||
- `WARN` - Boolean flag to enable/disable warning messages
|
||||
|
||||
## Module Integration
|
||||
|
||||
The module should be imported and used as follows:
|
||||
|
||||
```javascript
|
||||
import {
|
||||
generate,
|
||||
alterHeights,
|
||||
resolveDepressions,
|
||||
addMeandering,
|
||||
getRiverPath,
|
||||
specify,
|
||||
getName,
|
||||
getType,
|
||||
getBasin,
|
||||
getWidth,
|
||||
getOffset,
|
||||
getSourceWidth,
|
||||
getApproximateLength,
|
||||
getRiverPoints,
|
||||
remove,
|
||||
getNextId
|
||||
} from './river-generator.js';
|
||||
import { Lakes } from './lakes.js';
|
||||
import { Names } from './names.js';
|
||||
|
||||
// Usage example
|
||||
const config = {
|
||||
TIME: true,
|
||||
seed: 'map_seed_123',
|
||||
aleaPRNG: seedrandom,
|
||||
resolveDepressionsSteps: 1000,
|
||||
cellsCount: 10000,
|
||||
graphWidth: 1920,
|
||||
graphHeight: 1080,
|
||||
WARN: true
|
||||
};
|
||||
|
||||
const utils = {
|
||||
rn, rw, each, round,
|
||||
d3: { mean: d3.mean, sum: d3.sum, min: d3.min, curveCatmullRom: d3.curveCatmullRom },
|
||||
lineGen: d3.line()
|
||||
};
|
||||
|
||||
const modules = { Lakes, Names };
|
||||
|
||||
const result = generate(pack, grid, config, utils, modules, true);
|
||||
```
|
||||
602
procedural/src/engine/support/river-generator_prompt.md
Normal file
602
procedural/src/engine/support/river-generator_prompt.md
Normal file
|
|
@ -0,0 +1,602 @@
|
|||
# river-generator.js
|
||||
|
||||
**You are an expert senior JavaScript developer specializing in refactoring legacy code into modern, modular, and environment-agnostic libraries. You have a deep understanding of design patterns like dependency injection and the separation of concerns.**
|
||||
|
||||
**Your Goal:**
|
||||
|
||||
Your task is to refactor a single JavaScript module from a legacy Fantasy Map Generator application. The goal is to migrate it from its old, browser-dependent format into a pure, headless-first ES module that will be part of a core generation engine. This engine must be able to run in any JavaScript environment, including Node.js, without any dependencies on a browser or DOM.
|
||||
|
||||
**Architectural Context:**
|
||||
|
||||
* **Old Architecture:** The original code is wrapped in an IIFE and attaches its exports to the global `window` object. It directly reads from and mutates global state variables like `pack` and `grid`, and directly accesses the DOM via `byId()`.
|
||||
* **New Architecture (Target):**
|
||||
1. **Core Engine:** A collection of pure ES modules. It receives all necessary data (`pack`, `grid`) and configuration as function arguments. It performs its logic and returns the newly generated data. It has **zero** knowledge of the browser.
|
||||
2. **Viewer/Client:** The application responsible for all DOM interaction, UI, and rendering SVG based on the data object produced by the engine.
|
||||
|
||||
**The Golden Rules of Refactoring for the Core Engine:**
|
||||
|
||||
1. **No Globals:** Remove the IIFE and the attachment to the `window` object.
|
||||
2. **Use ES Modules:** All exported functions and data must use the `export` keyword.
|
||||
3. **Dependency Injection:** Functions must not read from or mutate global state. All data they need (`pack`, `grid`) must be passed in as arguments.
|
||||
4. **Introduce a `config` Object:**
|
||||
* **When you find code that reads a value from the DOM (e.g., `byId("statesNumber").value`), this is a configuration parameter.**
|
||||
* **You must replace this DOM call with a property from a `config` object (e.g., `config.statesNumber`).**
|
||||
* Add this `config` object as a new argument to the function's signature.
|
||||
5. **Return New Data:** Instead of modifying an object in place (e.g., `pack.cells.biome = ...`), functions should create the new data and return it. The calling function will be responsible for merging this data into the main state object.
|
||||
6. **Strict Separation of Concerns (Crucial):**
|
||||
* **UI Input Reading:** As per Rule #4, these `byId()` calls are your guide to what properties the `config` object needs.
|
||||
* **Rendering Logic:** Any code that **writes to the DOM or SVG** (e.g., `d3.select`, `document.getElementById(...).innerHTML = ...`, creating `<path>` elements, etc.) is considered rendering logic.
|
||||
* **You must REMOVE all rendering logic** from the engine module.
|
||||
7. **Maintain Style:** Preserve the original code style, comments, and variable names as much as possible for consistency.
|
||||
8. **Efficient Destructuring:** When passing a utils object, only destructure the specific properties needed within the scope of the function that uses them, rather than destructuring the entire object at the top of every function. This improves clarity and reduces code repetition.
|
||||
|
||||
---
|
||||
|
||||
**Concrete Example of Refactoring:**
|
||||
|
||||
**BEFORE (Legacy `burgs-and-states.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
function placeCapitals() {
|
||||
// Direct DOM read - THIS IS A CONFIGURATION VALUE
|
||||
let count = +byId("statesNumber").value;
|
||||
// ...
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
**AFTER (Refactored `engine/modules/burgsAndStates.js`):**
|
||||
|
||||
```javascript
|
||||
// ...
|
||||
// Dependencies, including the new `config` object, are injected.
|
||||
export function placeCapitals(cells, graphWidth, graphHeight, config) {
|
||||
// DOM read is replaced by a property from the `config` object.
|
||||
let count = config.statesNumber;
|
||||
// ...
|
||||
// Returns the generated data
|
||||
return { burgs, states };
|
||||
}
|
||||
// ...
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Your Specific Task:**
|
||||
|
||||
Now, please apply these principles to refactor the following module: `river-generator.js`.
|
||||
|
||||
**File Content:**
|
||||
```javascript
|
||||
"use strict";
|
||||
|
||||
window.Rivers = (function () {
|
||||
const generate = function (allowErosion = true) {
|
||||
TIME && console.time("generateRivers");
|
||||
Math.random = aleaPRNG(seed);
|
||||
const {cells, features} = pack;
|
||||
|
||||
const riversData = {}; // rivers data
|
||||
const riverParents = {};
|
||||
|
||||
const addCellToRiver = function (cell, river) {
|
||||
if (!riversData[river]) riversData[river] = [cell];
|
||||
else riversData[river].push(cell);
|
||||
};
|
||||
|
||||
cells.fl = new Uint16Array(cells.i.length); // water flux array
|
||||
cells.r = new Uint16Array(cells.i.length); // rivers array
|
||||
cells.conf = new Uint8Array(cells.i.length); // confluences array
|
||||
let riverNext = 1; // first river id is 1
|
||||
|
||||
const h = alterHeights();
|
||||
Lakes.detectCloseLakes(h);
|
||||
resolveDepressions(h);
|
||||
drainWater();
|
||||
defineRivers();
|
||||
|
||||
calculateConfluenceFlux();
|
||||
Lakes.cleanupLakeData();
|
||||
|
||||
if (allowErosion) {
|
||||
cells.h = Uint8Array.from(h); // apply gradient
|
||||
downcutRivers(); // downcut river beds
|
||||
}
|
||||
|
||||
TIME && console.timeEnd("generateRivers");
|
||||
|
||||
function drainWater() {
|
||||
const MIN_FLUX_TO_FORM_RIVER = 30;
|
||||
const cellsNumberModifier = (pointsInput.dataset.cells / 10000) ** 0.25;
|
||||
|
||||
const prec = grid.cells.prec;
|
||||
const land = cells.i.filter(i => h[i] >= 20).sort((a, b) => h[b] - h[a]);
|
||||
const lakeOutCells = Lakes.defineClimateData(h);
|
||||
|
||||
land.forEach(function (i) {
|
||||
cells.fl[i] += prec[cells.g[i]] / cellsNumberModifier; // add flux from precipitation
|
||||
|
||||
// create lake outlet if lake is not in deep depression and flux > evaporation
|
||||
const lakes = lakeOutCells[i]
|
||||
? features.filter(feature => i === feature.outCell && feature.flux > feature.evaporation)
|
||||
: [];
|
||||
for (const lake of lakes) {
|
||||
const lakeCell = cells.c[i].find(c => h[c] < 20 && cells.f[c] === lake.i);
|
||||
cells.fl[lakeCell] += Math.max(lake.flux - lake.evaporation, 0); // not evaporated lake water drains to outlet
|
||||
|
||||
// allow chain lakes to retain identity
|
||||
if (cells.r[lakeCell] !== lake.river) {
|
||||
const sameRiver = cells.c[lakeCell].some(c => cells.r[c] === lake.river);
|
||||
|
||||
if (sameRiver) {
|
||||
cells.r[lakeCell] = lake.river;
|
||||
addCellToRiver(lakeCell, lake.river);
|
||||
} else {
|
||||
cells.r[lakeCell] = riverNext;
|
||||
addCellToRiver(lakeCell, riverNext);
|
||||
riverNext++;
|
||||
}
|
||||
}
|
||||
|
||||
lake.outlet = cells.r[lakeCell];
|
||||
flowDown(i, cells.fl[lakeCell], lake.outlet);
|
||||
}
|
||||
|
||||
// assign all tributary rivers to outlet basin
|
||||
const outlet = lakes[0]?.outlet;
|
||||
for (const lake of lakes) {
|
||||
if (!Array.isArray(lake.inlets)) continue;
|
||||
for (const inlet of lake.inlets) {
|
||||
riverParents[inlet] = outlet;
|
||||
}
|
||||
}
|
||||
|
||||
// near-border cell: pour water out of the screen
|
||||
if (cells.b[i] && cells.r[i]) return addCellToRiver(-1, cells.r[i]);
|
||||
|
||||
// downhill cell (make sure it's not in the source lake)
|
||||
let min = null;
|
||||
if (lakeOutCells[i]) {
|
||||
const filtered = cells.c[i].filter(c => !lakes.map(lake => lake.i).includes(cells.f[c]));
|
||||
min = filtered.sort((a, b) => h[a] - h[b])[0];
|
||||
} else if (cells.haven[i]) {
|
||||
min = cells.haven[i];
|
||||
} else {
|
||||
min = cells.c[i].sort((a, b) => h[a] - h[b])[0];
|
||||
}
|
||||
|
||||
// cells is depressed
|
||||
if (h[i] <= h[min]) return;
|
||||
|
||||
// debug
|
||||
// .append("line")
|
||||
// .attr("x1", pack.cells.p[i][0])
|
||||
// .attr("y1", pack.cells.p[i][1])
|
||||
// .attr("x2", pack.cells.p[min][0])
|
||||
// .attr("y2", pack.cells.p[min][1])
|
||||
// .attr("stroke", "#333")
|
||||
// .attr("stroke-width", 0.2);
|
||||
|
||||
if (cells.fl[i] < MIN_FLUX_TO_FORM_RIVER) {
|
||||
// flux is too small to operate as a river
|
||||
if (h[min] >= 20) cells.fl[min] += cells.fl[i];
|
||||
return;
|
||||
}
|
||||
|
||||
// proclaim a new river
|
||||
if (!cells.r[i]) {
|
||||
cells.r[i] = riverNext;
|
||||
addCellToRiver(i, riverNext);
|
||||
riverNext++;
|
||||
}
|
||||
|
||||
flowDown(min, cells.fl[i], cells.r[i]);
|
||||
});
|
||||
}
|
||||
|
||||
function flowDown(toCell, fromFlux, river) {
|
||||
const toFlux = cells.fl[toCell] - cells.conf[toCell];
|
||||
const toRiver = cells.r[toCell];
|
||||
|
||||
if (toRiver) {
|
||||
// downhill cell already has river assigned
|
||||
if (fromFlux > toFlux) {
|
||||
cells.conf[toCell] += cells.fl[toCell]; // mark confluence
|
||||
if (h[toCell] >= 20) riverParents[toRiver] = river; // min river is a tributary of current river
|
||||
cells.r[toCell] = river; // re-assign river if downhill part has less flux
|
||||
} else {
|
||||
cells.conf[toCell] += fromFlux; // mark confluence
|
||||
if (h[toCell] >= 20) riverParents[river] = toRiver; // current river is a tributary of min river
|
||||
}
|
||||
} else cells.r[toCell] = river; // assign the river to the downhill cell
|
||||
|
||||
if (h[toCell] < 20) {
|
||||
// pour water to the water body
|
||||
const waterBody = features[cells.f[toCell]];
|
||||
if (waterBody.type === "lake") {
|
||||
if (!waterBody.river || fromFlux > waterBody.enteringFlux) {
|
||||
waterBody.river = river;
|
||||
waterBody.enteringFlux = fromFlux;
|
||||
}
|
||||
waterBody.flux = waterBody.flux + fromFlux;
|
||||
if (!waterBody.inlets) waterBody.inlets = [river];
|
||||
else waterBody.inlets.push(river);
|
||||
}
|
||||
} else {
|
||||
// propagate flux and add next river segment
|
||||
cells.fl[toCell] += fromFlux;
|
||||
}
|
||||
|
||||
addCellToRiver(toCell, river);
|
||||
}
|
||||
|
||||
function defineRivers() {
|
||||
// re-initialize rivers and confluence arrays
|
||||
cells.r = new Uint16Array(cells.i.length);
|
||||
cells.conf = new Uint16Array(cells.i.length);
|
||||
pack.rivers = [];
|
||||
|
||||
const defaultWidthFactor = rn(1 / (pointsInput.dataset.cells / 10000) ** 0.25, 2);
|
||||
const mainStemWidthFactor = defaultWidthFactor * 1.2;
|
||||
|
||||
for (const key in riversData) {
|
||||
const riverCells = riversData[key];
|
||||
if (riverCells.length < 3) continue; // exclude tiny rivers
|
||||
|
||||
const riverId = +key;
|
||||
for (const cell of riverCells) {
|
||||
if (cell < 0 || cells.h[cell] < 20) continue;
|
||||
|
||||
// mark real confluences and assign river to cells
|
||||
if (cells.r[cell]) cells.conf[cell] = 1;
|
||||
else cells.r[cell] = riverId;
|
||||
}
|
||||
|
||||
const source = riverCells[0];
|
||||
const mouth = riverCells[riverCells.length - 2];
|
||||
const parent = riverParents[key] || 0;
|
||||
|
||||
const widthFactor = !parent || parent === riverId ? mainStemWidthFactor : defaultWidthFactor;
|
||||
const meanderedPoints = addMeandering(riverCells);
|
||||
const discharge = cells.fl[mouth]; // m3 in second
|
||||
const length = getApproximateLength(meanderedPoints);
|
||||
const sourceWidth = getSourceWidth(cells.fl[source]);
|
||||
const width = getWidth(
|
||||
getOffset({
|
||||
flux: discharge,
|
||||
pointIndex: meanderedPoints.length,
|
||||
widthFactor,
|
||||
startingWidth: sourceWidth
|
||||
})
|
||||
);
|
||||
|
||||
pack.rivers.push({
|
||||
i: riverId,
|
||||
source,
|
||||
mouth,
|
||||
discharge,
|
||||
length,
|
||||
width,
|
||||
widthFactor,
|
||||
sourceWidth,
|
||||
parent,
|
||||
cells: riverCells
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function downcutRivers() {
|
||||
const MAX_DOWNCUT = 5;
|
||||
|
||||
for (const i of pack.cells.i) {
|
||||
if (cells.h[i] < 35) continue; // don't donwcut lowlands
|
||||
if (!cells.fl[i]) continue;
|
||||
|
||||
const higherCells = cells.c[i].filter(c => cells.h[c] > cells.h[i]);
|
||||
const higherFlux = higherCells.reduce((acc, c) => acc + cells.fl[c], 0) / higherCells.length;
|
||||
if (!higherFlux) continue;
|
||||
|
||||
const downcut = Math.floor(cells.fl[i] / higherFlux);
|
||||
if (downcut) cells.h[i] -= Math.min(downcut, MAX_DOWNCUT);
|
||||
}
|
||||
}
|
||||
|
||||
function calculateConfluenceFlux() {
|
||||
for (const i of cells.i) {
|
||||
if (!cells.conf[i]) continue;
|
||||
|
||||
const sortedInflux = cells.c[i]
|
||||
.filter(c => cells.r[c] && h[c] > h[i])
|
||||
.map(c => cells.fl[c])
|
||||
.sort((a, b) => b - a);
|
||||
cells.conf[i] = sortedInflux.reduce((acc, flux, index) => (index ? acc + flux : acc), 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// add distance to water value to land cells to make map less depressed
|
||||
const alterHeights = () => {
|
||||
const {h, c, t} = pack.cells;
|
||||
return Array.from(h).map((h, i) => {
|
||||
if (h < 20 || t[i] < 1) return h;
|
||||
return h + t[i] / 100 + d3.mean(c[i].map(c => t[c])) / 10000;
|
||||
});
|
||||
};
|
||||
|
||||
// depression filling algorithm (for a correct water flux modeling)
|
||||
const resolveDepressions = function (h) {
|
||||
const {cells, features} = pack;
|
||||
const maxIterations = +document.getElementById("resolveDepressionsStepsOutput").value;
|
||||
const checkLakeMaxIteration = maxIterations * 0.85;
|
||||
const elevateLakeMaxIteration = maxIterations * 0.75;
|
||||
|
||||
const height = i => features[cells.f[i]].height || h[i]; // height of lake or specific cell
|
||||
|
||||
const lakes = features.filter(f => f.type === "lake");
|
||||
const land = cells.i.filter(i => h[i] >= 20 && !cells.b[i]); // exclude near-border cells
|
||||
land.sort((a, b) => h[a] - h[b]); // lowest cells go first
|
||||
|
||||
const progress = [];
|
||||
let depressions = Infinity;
|
||||
let prevDepressions = null;
|
||||
for (let iteration = 0; depressions && iteration < maxIterations; iteration++) {
|
||||
if (progress.length > 5 && d3.sum(progress) > 0) {
|
||||
// bad progress, abort and set heights back
|
||||
h = alterHeights();
|
||||
depressions = progress[0];
|
||||
break;
|
||||
}
|
||||
|
||||
depressions = 0;
|
||||
|
||||
if (iteration < checkLakeMaxIteration) {
|
||||
for (const l of lakes) {
|
||||
if (l.closed) continue;
|
||||
const minHeight = d3.min(l.shoreline.map(s => h[s]));
|
||||
if (minHeight >= 100 || l.height > minHeight) continue;
|
||||
|
||||
if (iteration > elevateLakeMaxIteration) {
|
||||
l.shoreline.forEach(i => (h[i] = cells.h[i]));
|
||||
l.height = d3.min(l.shoreline.map(s => h[s])) - 1;
|
||||
l.closed = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
depressions++;
|
||||
l.height = minHeight + 0.2;
|
||||
}
|
||||
}
|
||||
|
||||
for (const i of land) {
|
||||
const minHeight = d3.min(cells.c[i].map(c => height(c)));
|
||||
if (minHeight >= 100 || h[i] > minHeight) continue;
|
||||
|
||||
depressions++;
|
||||
h[i] = minHeight + 0.1;
|
||||
}
|
||||
|
||||
prevDepressions !== null && progress.push(depressions - prevDepressions);
|
||||
prevDepressions = depressions;
|
||||
}
|
||||
|
||||
depressions && WARN && console.warn(`Unresolved depressions: ${depressions}. Edit heightmap to fix`);
|
||||
};
|
||||
|
||||
// add points at 1/3 and 2/3 of a line between adjacents river cells
|
||||
const addMeandering = function (riverCells, riverPoints = null, meandering = 0.5) {
|
||||
const {fl, h} = pack.cells;
|
||||
const meandered = [];
|
||||
const lastStep = riverCells.length - 1;
|
||||
const points = getRiverPoints(riverCells, riverPoints);
|
||||
let step = h[riverCells[0]] < 20 ? 1 : 10;
|
||||
|
||||
for (let i = 0; i <= lastStep; i++, step++) {
|
||||
const cell = riverCells[i];
|
||||
const isLastCell = i === lastStep;
|
||||
|
||||
const [x1, y1] = points[i];
|
||||
|
||||
meandered.push([x1, y1, fl[cell]]);
|
||||
if (isLastCell) break;
|
||||
|
||||
const nextCell = riverCells[i + 1];
|
||||
const [x2, y2] = points[i + 1];
|
||||
|
||||
if (nextCell === -1) {
|
||||
meandered.push([x2, y2, fl[cell]]);
|
||||
break;
|
||||
}
|
||||
|
||||
const dist2 = (x2 - x1) ** 2 + (y2 - y1) ** 2; // square distance between cells
|
||||
if (dist2 <= 25 && riverCells.length >= 6) continue;
|
||||
|
||||
const meander = meandering + 1 / step + Math.max(meandering - step / 100, 0);
|
||||
const angle = Math.atan2(y2 - y1, x2 - x1);
|
||||
const sinMeander = Math.sin(angle) * meander;
|
||||
const cosMeander = Math.cos(angle) * meander;
|
||||
|
||||
if (step < 20 && (dist2 > 64 || (dist2 > 36 && riverCells.length < 5))) {
|
||||
// if dist2 is big or river is small add extra points at 1/3 and 2/3 of segment
|
||||
const p1x = (x1 * 2 + x2) / 3 + -sinMeander;
|
||||
const p1y = (y1 * 2 + y2) / 3 + cosMeander;
|
||||
const p2x = (x1 + x2 * 2) / 3 + sinMeander / 2;
|
||||
const p2y = (y1 + y2 * 2) / 3 - cosMeander / 2;
|
||||
meandered.push([p1x, p1y, 0], [p2x, p2y, 0]);
|
||||
} else if (dist2 > 25 || riverCells.length < 6) {
|
||||
// if dist is medium or river is small add 1 extra middlepoint
|
||||
const p1x = (x1 + x2) / 2 + -sinMeander;
|
||||
const p1y = (y1 + y2) / 2 + cosMeander;
|
||||
meandered.push([p1x, p1y, 0]);
|
||||
}
|
||||
}
|
||||
|
||||
return meandered;
|
||||
};
|
||||
|
||||
const getRiverPoints = (riverCells, riverPoints) => {
|
||||
if (riverPoints) return riverPoints;
|
||||
|
||||
const {p} = pack.cells;
|
||||
return riverCells.map((cell, i) => {
|
||||
if (cell === -1) return getBorderPoint(riverCells[i - 1]);
|
||||
return p[cell];
|
||||
});
|
||||
};
|
||||
|
||||
const getBorderPoint = i => {
|
||||
const [x, y] = pack.cells.p[i];
|
||||
const min = Math.min(y, graphHeight - y, x, graphWidth - x);
|
||||
if (min === y) return [x, 0];
|
||||
else if (min === graphHeight - y) return [x, graphHeight];
|
||||
else if (min === x) return [0, y];
|
||||
return [graphWidth, y];
|
||||
};
|
||||
|
||||
const FLUX_FACTOR = 500;
|
||||
const MAX_FLUX_WIDTH = 1;
|
||||
const LENGTH_FACTOR = 200;
|
||||
const LENGTH_STEP_WIDTH = 1 / LENGTH_FACTOR;
|
||||
const LENGTH_PROGRESSION = [1, 1, 2, 3, 5, 8, 13, 21, 34].map(n => n / LENGTH_FACTOR);
|
||||
|
||||
const getOffset = ({flux, pointIndex, widthFactor, startingWidth}) => {
|
||||
if (pointIndex === 0) return startingWidth;
|
||||
|
||||
const fluxWidth = Math.min(flux ** 0.7 / FLUX_FACTOR, MAX_FLUX_WIDTH);
|
||||
const lengthWidth = pointIndex * LENGTH_STEP_WIDTH + (LENGTH_PROGRESSION[pointIndex] || LENGTH_PROGRESSION.at(-1));
|
||||
return widthFactor * (lengthWidth + fluxWidth) + startingWidth;
|
||||
};
|
||||
|
||||
const getSourceWidth = flux => rn(Math.min(flux ** 0.9 / FLUX_FACTOR, MAX_FLUX_WIDTH), 2);
|
||||
|
||||
// build polygon from a list of points and calculated offset (width)
|
||||
const getRiverPath = (points, widthFactor, startingWidth) => {
|
||||
lineGen.curve(d3.curveCatmullRom.alpha(0.1));
|
||||
const riverPointsLeft = [];
|
||||
const riverPointsRight = [];
|
||||
let flux = 0;
|
||||
|
||||
for (let pointIndex = 0; pointIndex < points.length; pointIndex++) {
|
||||
const [x0, y0] = points[pointIndex - 1] || points[pointIndex];
|
||||
const [x1, y1, pointFlux] = points[pointIndex];
|
||||
const [x2, y2] = points[pointIndex + 1] || points[pointIndex];
|
||||
if (pointFlux > flux) flux = pointFlux;
|
||||
|
||||
const offset = getOffset({flux, pointIndex, widthFactor, startingWidth});
|
||||
const angle = Math.atan2(y0 - y2, x0 - x2);
|
||||
const sinOffset = Math.sin(angle) * offset;
|
||||
const cosOffset = Math.cos(angle) * offset;
|
||||
|
||||
riverPointsLeft.push([x1 - sinOffset, y1 + cosOffset]);
|
||||
riverPointsRight.push([x1 + sinOffset, y1 - cosOffset]);
|
||||
}
|
||||
|
||||
const right = lineGen(riverPointsRight.reverse());
|
||||
let left = lineGen(riverPointsLeft);
|
||||
left = left.substring(left.indexOf("C"));
|
||||
|
||||
return round(right + left, 1);
|
||||
};
|
||||
|
||||
const specify = function () {
|
||||
const rivers = pack.rivers;
|
||||
if (!rivers.length) return;
|
||||
|
||||
for (const river of rivers) {
|
||||
river.basin = getBasin(river.i);
|
||||
river.name = getName(river.mouth);
|
||||
river.type = getType(river);
|
||||
}
|
||||
};
|
||||
|
||||
const getName = function (cell) {
|
||||
return Names.getCulture(pack.cells.culture[cell]);
|
||||
};
|
||||
|
||||
// weighted arrays of river type names
|
||||
const riverTypes = {
|
||||
main: {
|
||||
big: {River: 1},
|
||||
small: {Creek: 9, River: 3, Brook: 3, Stream: 1}
|
||||
},
|
||||
fork: {
|
||||
big: {Fork: 1},
|
||||
small: {Branch: 1}
|
||||
}
|
||||
};
|
||||
|
||||
let smallLength = null;
|
||||
const getType = function ({i, length, parent}) {
|
||||
if (smallLength === null) {
|
||||
const threshold = Math.ceil(pack.rivers.length * 0.15);
|
||||
smallLength = pack.rivers.map(r => r.length || 0).sort((a, b) => a - b)[threshold];
|
||||
}
|
||||
|
||||
const isSmall = length < smallLength;
|
||||
const isFork = each(3)(i) && parent && parent !== i;
|
||||
return rw(riverTypes[isFork ? "fork" : "main"][isSmall ? "small" : "big"]);
|
||||
};
|
||||
|
||||
const getApproximateLength = points => {
|
||||
const length = points.reduce((s, v, i, p) => s + (i ? Math.hypot(v[0] - p[i - 1][0], v[1] - p[i - 1][1]) : 0), 0);
|
||||
return rn(length, 2);
|
||||
};
|
||||
|
||||
// Real mouth width examples: Amazon 6000m, Volga 6000m, Dniepr 3000m, Mississippi 1300m, Themes 900m,
|
||||
// Danube 800m, Daugava 600m, Neva 500m, Nile 450m, Don 400m, Wisla 300m, Pripyat 150m, Bug 140m, Muchavets 40m
|
||||
const getWidth = offset => rn((offset / 1.5) ** 1.8, 2); // mouth width in km
|
||||
|
||||
// remove river and all its tributaries
|
||||
const remove = function (id) {
|
||||
const cells = pack.cells;
|
||||
const riversToRemove = pack.rivers.filter(r => r.i === id || r.parent === id || r.basin === id).map(r => r.i);
|
||||
riversToRemove.forEach(r => rivers.select("#river" + r).remove());
|
||||
cells.r.forEach((r, i) => {
|
||||
if (!r || !riversToRemove.includes(r)) return;
|
||||
cells.r[i] = 0;
|
||||
cells.fl[i] = grid.cells.prec[cells.g[i]];
|
||||
cells.conf[i] = 0;
|
||||
});
|
||||
pack.rivers = pack.rivers.filter(r => !riversToRemove.includes(r.i));
|
||||
};
|
||||
|
||||
const getBasin = function (r) {
|
||||
const parent = pack.rivers.find(river => river.i === r)?.parent;
|
||||
if (!parent || r === parent) return r;
|
||||
return getBasin(parent);
|
||||
};
|
||||
|
||||
const getNextId = function (rivers) {
|
||||
return rivers.length ? Math.max(...rivers.map(r => r.i)) + 1 : 1;
|
||||
};
|
||||
|
||||
return {
|
||||
generate,
|
||||
alterHeights,
|
||||
resolveDepressions,
|
||||
addMeandering,
|
||||
getRiverPath,
|
||||
specify,
|
||||
getName,
|
||||
getType,
|
||||
getBasin,
|
||||
getWidth,
|
||||
getOffset,
|
||||
getSourceWidth,
|
||||
getApproximateLength,
|
||||
getRiverPoints,
|
||||
remove,
|
||||
getNextId
|
||||
};
|
||||
})();
|
||||
```
|
||||
|
||||
**Instructions:**
|
||||
|
||||
Provide a response in three parts:
|
||||
|
||||
1. **Refactored Code:** The complete JavaScript code for the new ES module in ./river-generator.js
|
||||
2. **Engine Dependencies:**
|
||||
* List the external modules the refactored code will need to `import` (e.g., `Names`, `COA`) in ./river-generator_external.md
|
||||
* **List the new `config` properties you identified and used** (e.g., `statesNumber`, `growthRate`) in river-generator_config.md This is essential.
|
||||
3. **Removed Rendering/UI Logic:** List all the code blocks related to DOM manipulation or SVG rendering that you have **removed** so they can be moved to the Viewer application into river-generator_render.md
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue