diff --git a/src/scripts/generation/pack/cultures/expandCultures.ts b/src/scripts/generation/pack/cultures/expandCultures.ts new file mode 100644 index 00000000..e93e938b --- /dev/null +++ b/src/scripts/generation/pack/cultures/expandCultures.ts @@ -0,0 +1,106 @@ +import FlatQueue from "flatqueue"; + +import {DISTANCE_FIELD, ELEVATION, FOREST_BIOMES, MIN_LAND_HEIGHT} from "config/generation"; +import {TIME} from "config/logging"; +import {getInputNumber} from "utils/nodeUtils"; +import {minmax} from "utils/numberUtils"; +import {isCulture} from "utils/typeUtils"; + +const {LAND_COAST, LANDLOCKED, WATER_COAST} = DISTANCE_FIELD; +const {MOUNTAINS, HILLS} = ELEVATION; + +// expand cultures across the map (Dijkstra-like algorithm) +export function expandCultures( + cultures: TCultures, + features: TPackFeatures, + cells: Pick +) { + TIME && console.time("expandCultures"); + + const cultureIds = new Uint16Array(cells.h.length); // cell cultures + const queue = new FlatQueue<{cellId: number; cultureId: number}>(); + + cultures.filter(isCulture).forEach(culture => { + queue.push({cellId: culture.center, cultureId: culture.i}, 0); + }); + + const cellsNumberFactor = cells.h.length / 1.6; + const maxExpansionCost = cellsNumberFactor * getInputNumber("neutralInput"); // limit cost for culture growth + const cost: number[] = []; + + while (queue.length) { + const priority = queue.peekValue()!; + const {cellId, cultureId} = queue.pop()!; + + const {type, expansionism, center} = getCulture(cultureId); + const cultureBiome = cells.biome[center]; + + cells.c[cellId].forEach(neibCellId => { + const biomeCost = getBiomeCost(neibCellId, cultureBiome, type); + const heightCost = getHeightCost(neibCellId, cells.h[neibCellId], type); + const riverCost = getRiverCost(cells.r[neibCellId], neibCellId, type); + const typeCost = getTypeCost(cells.t[neibCellId], type); + + const totalCost = priority + (biomeCost + heightCost + riverCost + typeCost) / expansionism; + if (totalCost > maxExpansionCost) return; + + if (!cost[neibCellId] || totalCost < cost[neibCellId]) { + if (cells.pop[neibCellId] > 0) cultureIds[neibCellId] = cultureId; // assign culture to populated cell + cost[neibCellId] = totalCost; + queue.push({cellId: neibCellId, cultureId}, totalCost); + } + }); + } + + TIME && console.timeEnd("expandCultures"); + return cultureIds; + + function getCulture(cultureId: number) { + const culture = cultures[cultureId]; + if (!isCulture(culture)) throw new Error("Wilderness cannot expand"); + return culture; + } + + function getBiomeCost(cellId: number, cultureBiome: number, type: TCultureType) { + const biome = cells.biome[cellId]; + if (cultureBiome === 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" && FOREST_BIOMES.includes(biome)) return biomesData.cost[biome] * 10; // forest biome penalty for nomads + return biomesData.cost[biome] * 2; // general non-native biome penalty + } + + function getHeightCost(cellId: number, height: number, type: TCultureType) { + if (height < MIN_LAND_HEIGHT) { + const feature = features[cells.f[cellId]]; + const area = cells.area[cellId]; + + if (type === "Lake" && feature && feature.type === "lake") return 10; // almost lake crossing penalty for Lake cultures + if (type === "Naval") return area * 2; // low sea or lake crossing penalty for Naval cultures + if (type === "Nomadic") return area * 50; // giant sea or lake crossing penalty for Nomads + return area * 6; // general sea or lake crossing penalty + } + + if (type === "Highland") { + if (height >= MOUNTAINS) return 0; // no penalty for highlanders on highlands + if (height < HILLS) return 3000; // giant penalty for highlanders on lowlands + return 100; // penalty for highlanders on hills + } + + if (height >= MOUNTAINS) return 200; // general mountains crossing penalty + if (height >= HILLS) return 30; // general hills crossing penalty + return 0; + } + + function getRiverCost(riverId: number, cellId: number, type: TCultureType) { + 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: number, type: TCultureType) { + if (t === LAND_COAST) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline + if (t === LANDLOCKED) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads + if (t !== WATER_COAST) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals + return 0; + } +} diff --git a/src/scripts/generation/pack/cultures.ts b/src/scripts/generation/pack/cultures/generateCultures.ts similarity index 63% rename from src/scripts/generation/pack/cultures.ts rename to src/scripts/generation/pack/cultures/generateCultures.ts index bf598782..905ba04e 100644 --- a/src/scripts/generation/pack/cultures.ts +++ b/src/scripts/generation/pack/cultures/generateCultures.ts @@ -1,24 +1,15 @@ import * as d3 from "d3"; -import FlatQueue from "flatqueue"; import {cultureSets, DEFAULT_SORT_STRING, TCultureSetName} from "config/cultureSets"; -import { - DISTANCE_FIELD, - ELEVATION, - FOREST_BIOMES, - HUNTING_BIOMES, - MIN_LAND_HEIGHT, - NOMADIC_BIOMES -} from "config/generation"; +import {DISTANCE_FIELD, ELEVATION, HUNTING_BIOMES, NOMADIC_BIOMES} from "config/generation"; import {ERROR, TIME, WARN} from "config/logging"; import {getColors} from "utils/colorUtils"; import {abbreviate} from "utils/languageUtils"; import {getInputNumber, getInputValue, getSelectedOption} from "utils/nodeUtils"; -import {minmax, rn} from "utils/numberUtils"; +import {rn} from "utils/numberUtils"; import {biased, P, rand} from "utils/probabilityUtils"; import {byId} from "utils/shorthands"; import {defaultNameBases} from "config/namebases"; -import {isCulture} from "utils/typeUtils"; const {COA} = window; @@ -33,16 +24,14 @@ const cultureTypeBaseExpansionism: {[key in TCultureType]: number} = { }; const {MOUNTAINS, HILLS} = ELEVATION; -const {LAND_COAST, LANDLOCKED, WATER_COAST} = DISTANCE_FIELD; +const {LAND_COAST, LANDLOCKED} = DISTANCE_FIELD; -export const generateCultures = function ( - features: TPackFeatures, - cells: Pick< - IPack["cells"], - "p" | "i" | "g" | "t" | "h" | "haven" | "harbor" | "f" | "r" | "fl" | "s" | "pop" | "biome" - >, - temp: Int8Array -): TCultures { +type TCellsData = Pick< + IPack["cells"], + "p" | "i" | "g" | "t" | "h" | "haven" | "harbor" | "f" | "r" | "fl" | "s" | "pop" | "biome" +>; + +export function generateCultures(features: TPackFeatures, cells: TCellsData, temp: Int8Array): TCultures { TIME && console.time("generateCultures"); const wildlands: TWilderness = {name: "Wildlands", i: 0, base: 1, origins: [null], shield: "round"}; @@ -272,100 +261,4 @@ export const generateCultures = function ( ERROR && console.error(`Name base ${base} is not available, applying a fallback one`); return base % nameBases.length; } -}; - -// expand cultures across the map (Dijkstra-like algorithm) -export const expandCultures = function ( - cultures: TCultures, - features: TPackFeatures, - cells: Pick -) { - TIME && console.time("expandCultures"); - - const cultureIds = new Uint16Array(cells.h.length); // cell cultures - const queue = new FlatQueue<{cellId: number; cultureId: number}>(); - - cultures.filter(isCulture).forEach(culture => { - queue.push({cellId: culture.center, cultureId: culture.i}, 0); - }); - - const cellsNumberFactor = cells.h.length / 1.6; - const maxExpansionCost = cellsNumberFactor * getInputNumber("neutralInput"); // limit cost for culture growth - const cost: number[] = []; - - while (queue.length) { - const priority = queue.peekValue()!; - const {cellId, cultureId} = queue.pop()!; - - const {type, expansionism, center} = getCulture(cultureId); - const cultureBiome = cells.biome[center]; - - cells.c[cellId].forEach(neibCellId => { - const biomeCost = getBiomeCost(neibCellId, cultureBiome, type); - const heightCost = getHeightCost(neibCellId, cells.h[neibCellId], type); - const riverCost = getRiverCost(cells.r[neibCellId], neibCellId, type); - const typeCost = getTypeCost(cells.t[neibCellId], type); - - const totalCost = priority + (biomeCost + heightCost + riverCost + typeCost) / expansionism; - if (totalCost > maxExpansionCost) return; - - if (!cost[neibCellId] || totalCost < cost[neibCellId]) { - if (cells.pop[neibCellId] > 0) cultureIds[neibCellId] = cultureId; // assign culture to populated cell - cost[neibCellId] = totalCost; - queue.push({cellId: neibCellId, cultureId}, totalCost); - } - }); - } - - TIME && console.timeEnd("expandCultures"); - return cultureIds; - - function getCulture(cultureId: number) { - const culture = cultures[cultureId]; - if (!isCulture(culture)) throw new Error("Wilderness cannot expand"); - return culture; - } - - function getBiomeCost(cellId: number, cultureBiome: number, type: TCultureType) { - const biome = cells.biome[cellId]; - if (cultureBiome === 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" && FOREST_BIOMES.includes(biome)) return biomesData.cost[biome] * 10; // forest biome penalty for nomads - return biomesData.cost[biome] * 2; // general non-native biome penalty - } - - function getHeightCost(cellId: number, height: number, type: TCultureType) { - if (height < MIN_LAND_HEIGHT) { - const feature = features[cells.f[cellId]]; - const area = cells.area[cellId]; - - if (type === "Lake" && feature && feature.type === "lake") return 10; // almost lake crossing penalty for Lake cultures - if (type === "Naval") return area * 2; // low sea or lake crossing penalty for Naval cultures - if (type === "Nomadic") return area * 50; // giant sea or lake crossing penalty for Nomads - return area * 6; // general sea or lake crossing penalty - } - - if (type === "Highland") { - if (height >= MOUNTAINS) return 0; // no penalty for highlanders on highlands - if (height < HILLS) return 3000; // giant penalty for highlanders on lowlands - return 100; // penalty for highlanders on hills - } - - if (height >= MOUNTAINS) return 200; // general mountains crossing penalty - if (height >= HILLS) return 30; // general hills crossing penalty - return 0; - } - - function getRiverCost(riverId: number, cellId: number, type: TCultureType) { - 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: number, type: TCultureType) { - if (t === LAND_COAST) return type === "Naval" || type === "Lake" ? 0 : type === "Nomadic" ? 60 : 20; // penalty for coastline - if (t === LANDLOCKED) return type === "Naval" || type === "Nomadic" ? 30 : 0; // low penalty for land level 2 for Navals and nomads - if (t !== WATER_COAST) return type === "Naval" || type === "Lake" ? 100 : 0; // penalty for mainland for navals - return 0; - } -}; +} diff --git a/src/scripts/generation/pack/lakes.ts b/src/scripts/generation/pack/lakes/lakes.ts similarity index 94% rename from src/scripts/generation/pack/lakes.ts rename to src/scripts/generation/pack/lakes/lakes.ts index 367ad85c..869eb402 100644 --- a/src/scripts/generation/pack/lakes.ts +++ b/src/scripts/generation/pack/lakes/lakes.ts @@ -14,7 +14,7 @@ export interface ILakeClimateData extends IPackFeatureLake { enteringFlux?: number; } -export const getClimateData = function ( +export function getClimateData( lakes: IPackFeatureLake[], heights: Float32Array, drainableLakes: Dict, @@ -44,13 +44,9 @@ export const getClimateData = function ( }); return lakeData; -}; +} -export const mergeLakeData = function ( - features: TPackFeatures, - lakeData: ILakeClimateData[], - rivers: Pick[] -) { +export function mergeLakeData(features: TPackFeatures, lakeData: ILakeClimateData[], rivers: Pick[]) { const updatedFeatures = features.map(feature => { if (!feature) return 0; if (feature.type !== "lake") return feature; @@ -71,7 +67,7 @@ export const mergeLakeData = function ( }); return updatedFeatures as TPackFeatures; -}; +} function defineLakeGroup({ firstCell, diff --git a/src/scripts/generation/pack/pack.ts b/src/scripts/generation/pack/pack.ts index df1969ef..4c53e1f8 100644 --- a/src/scripts/generation/pack/pack.ts +++ b/src/scripts/generation/pack/pack.ts @@ -1,21 +1,15 @@ -import * as d3 from "d3"; - -import {UINT16_MAX} from "config/constants"; -import {DISTANCE_FIELD, MIN_LAND_HEIGHT} from "config/generation"; -import {TIME} from "config/logging"; -import {calculateVoronoi} from "scripts/generation/graph"; import {markupPackFeatures} from "scripts/generation/markup"; import {rankCells} from "scripts/generation/pack/rankCells"; -import {createTypedArray} from "utils/arrayUtils"; import {pick} from "utils/functionUtils"; -import {rn} from "utils/numberUtils"; -import {generateCultures, expandCultures} from "./cultures"; -import {generateRivers} from "./rivers"; import {generateBurgsAndStates} from "./burgsAndStates/generateBurgsAndStates"; -import {generateRoutes} from "./generateRoutes"; +import {expandCultures} from "./cultures/expandCultures"; +import {generateCultures} from "./cultures/generateCultures"; +import {generateProvinces} from "./provinces/generateProvinces"; import {generateReligions} from "./religions/generateReligions"; +import {repackGrid} from "./repackGrid"; +import {generateRivers} from "./rivers/generateRivers"; +import {generateRoutes} from "./routes/generateRoutes"; -const {LAND_COAST, WATER_COAST, DEEPER_WATER} = DISTANCE_FIELD; const {Biomes} = window; export function createPack(grid: IGrid): IPack { @@ -149,13 +143,10 @@ export function createPack(grid: IGrid): IPack { } }); + const {provinceIds, provinces} = generateProvinces(); + // BurgsAndStates.generateProvinces(); // BurgsAndStates.defineBurgFeatures(); - - // renderLayer("states"); - // renderLayer("borders"); - // BurgsAndStates.drawStateLabels(); - // Rivers.specify(); // const updatedFeatures = generateLakeNames(); @@ -190,7 +181,7 @@ export function createPack(grid: IGrid): IPack { state: stateIds, route: cellRoutes, religion: religionIds, - province: new Uint16Array(cells.i.length) + province: provinceIds }, features: mergedFeatures, rivers: rawRivers, // "name" | "basin" | "type" @@ -199,77 +190,9 @@ export function createPack(grid: IGrid): IPack { burgs, routes, religions, + provinces, events }; return pack; } - -// repack grid cells: discart deep water cells, add land cells along the coast -function repackGrid(grid: IGrid) { - TIME && console.time("repackGrid"); - const {cells: gridCells, points, features} = grid; - const newCells: {p: TPoints; g: number[]; h: number[]} = {p: [], g: [], h: []}; // store new data - const spacing2 = grid.spacing ** 2; - - for (const i of gridCells.i) { - const height = gridCells.h[i]; - const type = gridCells.t[i]; - - // exclude ocean points far from coast - if (height < MIN_LAND_HEIGHT && type !== WATER_COAST && type !== DEEPER_WATER) continue; - - const feature = features[gridCells.f[i]]; - const isLake = feature && feature.type === "lake"; - - // exclude non-coastal lake points - if (type === DEEPER_WATER && (i % 4 === 0 || isLake)) continue; - - const [x, y] = points[i]; - addNewPoint(i, x, y, height); - - // add additional points for cells along coast - if (type === LAND_COAST || type === WATER_COAST) { - if (gridCells.b[i]) continue; // not for near-border cells - gridCells.c[i].forEach(e => { - if (i > e) return; - if (gridCells.t[e] === type) { - const dist2 = (y - points[e][1]) ** 2 + (x - points[e][0]) ** 2; - if (dist2 < spacing2) return; // too close to each other - const x1 = rn((x + points[e][0]) / 2, 1); - const y1 = rn((y + points[e][1]) / 2, 1); - addNewPoint(i, x1, y1, height); - } - }); - } - } - - function addNewPoint(i: number, x: number, y: number, height: number) { - newCells.p.push([x, y]); - newCells.g.push(i); - newCells.h.push(height); - } - - const {cells, vertices} = calculateVoronoi(newCells.p, grid.boundary); - - function getCellArea(i: number) { - const polygon = cells.v[i].map(v => vertices.p[v]); - const area = Math.abs(d3.polygonArea(polygon)); - return Math.min(area, UINT16_MAX); - } - - const pack = { - vertices, - cells: { - ...cells, - p: newCells.p, - g: createTypedArray({maxValue: grid.points.length, from: newCells.g}), - q: d3.quadtree(newCells.p.map(([x, y], i) => [x, y, i])) as unknown as Quadtree, - h: new Uint8Array(newCells.h), - area: createTypedArray({maxValue: UINT16_MAX, from: cells.i}).map(getCellArea) - } - }; - - TIME && console.timeEnd("repackGrid"); - return pack; -} diff --git a/src/scripts/generation/pack/provinces/generateProvinces.ts b/src/scripts/generation/pack/provinces/generateProvinces.ts new file mode 100644 index 00000000..57e86914 --- /dev/null +++ b/src/scripts/generation/pack/provinces/generateProvinces.ts @@ -0,0 +1,11 @@ +import {TIME} from "config/logging"; + +export function generateProvinces() { + TIME && console.time("generateProvinces"); + + const provinceIds = new Uint16Array(1000); // cells.i.length + const provinces = [] as TProvinces; + + TIME && console.timeEnd("generateProvinces"); + return {provinceIds, provinces}; +} diff --git a/src/scripts/generation/pack/repackGrid.ts b/src/scripts/generation/pack/repackGrid.ts new file mode 100644 index 00000000..48a32b1e --- /dev/null +++ b/src/scripts/generation/pack/repackGrid.ts @@ -0,0 +1,79 @@ +import * as d3 from "d3"; + +import {UINT16_MAX} from "config/constants"; +import {DISTANCE_FIELD, MIN_LAND_HEIGHT} from "config/generation"; +import {TIME} from "config/logging"; +import {createTypedArray} from "utils/arrayUtils"; +import {rn} from "utils/numberUtils"; +import {calculateVoronoi} from "../graph"; + +const {LAND_COAST, WATER_COAST, DEEPER_WATER} = DISTANCE_FIELD; + +// repack grid cells: discart deep water cells, add land cells along the coast +export function repackGrid(grid: IGrid) { + TIME && console.time("repackGrid"); + const {cells: gridCells, points, features} = grid; + const newCells: {p: TPoints; g: number[]; h: number[]} = {p: [], g: [], h: []}; // store new data + const spacing2 = grid.spacing ** 2; + + for (const i of gridCells.i) { + const height = gridCells.h[i]; + const type = gridCells.t[i]; + + // exclude ocean points far from coast + if (height < MIN_LAND_HEIGHT && type !== WATER_COAST && type !== DEEPER_WATER) continue; + + const feature = features[gridCells.f[i]]; + const isLake = feature && feature.type === "lake"; + + // exclude non-coastal lake points + if (type === DEEPER_WATER && (i % 4 === 0 || isLake)) continue; + + const [x, y] = points[i]; + addNewPoint(i, x, y, height); + + // add additional points for cells along coast + if (type === LAND_COAST || type === WATER_COAST) { + if (gridCells.b[i]) continue; // not for near-border cells + gridCells.c[i].forEach(e => { + if (i > e) return; + if (gridCells.t[e] === type) { + const dist2 = (y - points[e][1]) ** 2 + (x - points[e][0]) ** 2; + if (dist2 < spacing2) return; // too close to each other + const x1 = rn((x + points[e][0]) / 2, 1); + const y1 = rn((y + points[e][1]) / 2, 1); + addNewPoint(i, x1, y1, height); + } + }); + } + } + + function addNewPoint(i: number, x: number, y: number, height: number) { + newCells.p.push([x, y]); + newCells.g.push(i); + newCells.h.push(height); + } + + const {cells, vertices} = calculateVoronoi(newCells.p, grid.boundary); + + function getCellArea(i: number) { + const polygon = cells.v[i].map(v => vertices.p[v]); + const area = Math.abs(d3.polygonArea(polygon)); + return Math.min(area, UINT16_MAX); + } + + const pack = { + vertices, + cells: { + ...cells, + p: newCells.p, + g: createTypedArray({maxValue: grid.points.length, from: newCells.g}), + q: d3.quadtree(newCells.p.map(([x, y], i) => [x, y, i])) as unknown as Quadtree, + h: new Uint8Array(newCells.h), + area: createTypedArray({maxValue: UINT16_MAX, from: cells.i}).map(getCellArea) + } + }; + + TIME && console.timeEnd("repackGrid"); + return pack; +} diff --git a/src/scripts/generation/pack/rivers.ts b/src/scripts/generation/pack/rivers/generateRivers.ts similarity index 62% rename from src/scripts/generation/pack/rivers.ts rename to src/scripts/generation/pack/rivers/generateRivers.ts index 8fe4bc21..b21b5fe5 100644 --- a/src/scripts/generation/pack/rivers.ts +++ b/src/scripts/generation/pack/rivers/generateRivers.ts @@ -1,13 +1,13 @@ import * as d3 from "d3"; -import {INFO, TIME, WARN} from "config/logging"; +import {TIME} from "config/logging"; import {rn} from "utils/numberUtils"; import {aleaPRNG} from "scripts/aleaPRNG"; -import {DISTANCE_FIELD, MAX_HEIGHT, MIN_LAND_HEIGHT} from "config/generation"; -import {getInputNumber} from "utils/nodeUtils"; +import {DISTANCE_FIELD, MIN_LAND_HEIGHT} from "config/generation"; import {pick} from "utils/functionUtils"; import {byId} from "utils/shorthands"; -import {mergeLakeData, getClimateData, ILakeClimateData} from "./lakes"; +import {mergeLakeData, getClimateData, ILakeClimateData} from "../lakes/lakes"; +import {resolveDepressions} from "./resolveDepressions"; const {Rivers} = window; const {LAND_COAST} = DISTANCE_FIELD; @@ -276,155 +276,10 @@ export function generateRivers( } // add distance to water value to land cells to make map less depressed -const applyDistanceField = ({h, c, t}: Pick) => { +function applyDistanceField({h, c, t}: Pick) { return new Float32Array(h.length).map((_, index) => { if (h[index] < MIN_LAND_HEIGHT || t[index] < LAND_COAST) return h[index]; const mean = d3.mean(c[index].map(c => t[c])) || 0; return h[index] + t[index] / 100 + mean / 10000; }); -}; - -// depression filling algorithm (for a correct water flux modeling) -const resolveDepressions = function ( - cells: Pick, - features: TPackFeatures, - initialCellHeights: Float32Array -): [Float32Array, Dict] { - TIME && console.time("resolveDepressions"); - - const MAX_INTERATIONS = getInputNumber("resolveDepressionsStepsOutput"); - const checkLakeMaxIteration = MAX_INTERATIONS * 0.85; - const elevateLakeMaxIteration = MAX_INTERATIONS * 0.75; - - const LAND_ELEVATION_INCREMENT = 0.1; - const LAKE_ELEVATION_INCREMENT = 0.2; - - const lakes = features.filter(feature => feature && feature.type === "lake") as IPackFeatureLake[]; - lakes.sort((a, b) => a.height - b.height); // lowest lakes go first - - const getHeight = (i: number) => currentLakeHeights[cells.f[i]] || currentCellHeights[i]; - const getMinHeight = (cellsIds: number[]) => Math.min(...cellsIds.map(getHeight)); - const getMinLandHeight = (cellsIds: number[]) => Math.min(...cellsIds.map(i => currentCellHeights[i])); - - const landCells = cells.i.filter(i => initialCellHeights[i] >= MIN_LAND_HEIGHT && !cells.b[i]); - landCells.sort((a, b) => initialCellHeights[a] - initialCellHeights[b]); // lowest cells go first - - const currentCellHeights = Float32Array.from(initialCellHeights); - const currentLakeHeights = Object.fromEntries(lakes.map(({i, height}) => [i, height])); - const currentDrainableLakes = checkLakesDrainability(); - const depressions: number[] = []; - - let bestDepressions = Infinity; - let bestCellHeights: typeof currentCellHeights | null = null; - let bestDrainableLakes: typeof currentDrainableLakes | null = null; - - for (let iteration = 0; depressions.at(-1) !== 0 && iteration < MAX_INTERATIONS; iteration++) { - let depressionsLeft = 0; - - // elevate potentially drainable lakes - if (iteration < checkLakeMaxIteration) { - for (const lake of lakes) { - if (currentDrainableLakes[lake.i] !== true) continue; - - const minShoreHeight = getMinLandHeight(lake.shoreline); - if (minShoreHeight >= MAX_HEIGHT || currentLakeHeights[lake.i] > minShoreHeight) continue; - - if (iteration > elevateLakeMaxIteration) { - // reset heights - for (const shoreCellId of lake.shoreline) { - currentCellHeights[shoreCellId] = initialCellHeights[shoreCellId]; - } - currentLakeHeights[lake.i] = lake.height; - - currentDrainableLakes[lake.i] = false; - continue; - } - - currentLakeHeights[lake.i] = minShoreHeight + LAKE_ELEVATION_INCREMENT; - depressionsLeft++; - } - } - - for (const cellId of landCells) { - const minHeight = getMinHeight(cells.c[cellId]); - if (minHeight >= MAX_HEIGHT || currentCellHeights[cellId] > minHeight) continue; - - currentCellHeights[cellId] = minHeight + LAND_ELEVATION_INCREMENT; - depressionsLeft++; - } - - depressions.push(depressionsLeft); - if (depressionsLeft < bestDepressions) { - bestDepressions = depressionsLeft; - bestCellHeights = Float32Array.from(currentCellHeights); - bestDrainableLakes = structuredClone(currentDrainableLakes); - } - } - - TIME && console.timeEnd("resolveDepressions"); - - const depressionsLeft = depressions.at(-1); - if (depressionsLeft) { - if (bestCellHeights && bestDrainableLakes) { - WARN && - console.warn(`Cannot resolve all depressions. Depressions: ${depressions[0]}. Best result: ${bestDepressions}`); - return [bestCellHeights, bestDrainableLakes]; - } - - WARN && console.warn(`Cannot resolve depressions. Depressions: ${depressionsLeft}`); - return [initialCellHeights, {}]; - } - - INFO && console.info(`ⓘ resolved all ${depressions[0]} depressions in ${depressions.length} iterations`); - return [currentCellHeights, currentDrainableLakes]; - - // define lakes that potentially can be open (drained into another water body) - function checkLakesDrainability() { - const canBeDrained: Dict = {}; // all false by default - - const ELEVATION_LIMIT = getInputNumber("lakeElevationLimitOutput"); - const drainAllLakes = ELEVATION_LIMIT === MAX_HEIGHT - MIN_LAND_HEIGHT; - - for (const lake of lakes) { - if (drainAllLakes) { - canBeDrained[lake.i] = true; - continue; - } - - canBeDrained[lake.i] = false; - const minShoreHeight = getMinHeight(lake.shoreline); - const minHeightShoreCell = - lake.shoreline.find(cellId => initialCellHeights[cellId] === minShoreHeight) || lake.shoreline[0]; - - const queue = [minHeightShoreCell]; - const checked = []; - checked[minHeightShoreCell] = true; - const breakableHeight = lake.height + ELEVATION_LIMIT; - - loopCellsAroundLake: while (queue.length) { - const cellId = queue.pop()!; - - for (const neibCellId of cells.c[cellId]) { - if (checked[neibCellId]) continue; - if (initialCellHeights[neibCellId] >= breakableHeight) continue; - - if (initialCellHeights[neibCellId] < MIN_LAND_HEIGHT) { - const waterFeatureMet = features[cells.f[neibCellId]]; - const isOceanMet = waterFeatureMet && waterFeatureMet.type === "ocean"; - const isLakeMet = waterFeatureMet && waterFeatureMet.type === "lake"; - - if (isOceanMet || (isLakeMet && lake.height > waterFeatureMet.height)) { - canBeDrained[lake.i] = true; - break loopCellsAroundLake; - } - } - - checked[neibCellId] = true; - queue.push(neibCellId); - } - } - } - - return canBeDrained; - } -}; +} diff --git a/src/scripts/generation/pack/rivers/resolveDepressions.ts b/src/scripts/generation/pack/rivers/resolveDepressions.ts new file mode 100644 index 00000000..301a425e --- /dev/null +++ b/src/scripts/generation/pack/rivers/resolveDepressions.ts @@ -0,0 +1,148 @@ +import {MIN_LAND_HEIGHT, MAX_HEIGHT} from "config/generation"; +import {TIME, WARN, INFO} from "config/logging"; +import {getInputNumber} from "utils/nodeUtils"; + +// depression filling algorithm (for a correct water flux modeling) +export function resolveDepressions( + cells: Pick, + features: TPackFeatures, + initialCellHeights: Float32Array +): [Float32Array, Dict] { + TIME && console.time("resolveDepressions"); + + const MAX_INTERATIONS = getInputNumber("resolveDepressionsStepsOutput"); + const checkLakeMaxIteration = MAX_INTERATIONS * 0.85; + const elevateLakeMaxIteration = MAX_INTERATIONS * 0.75; + + const LAND_ELEVATION_INCREMENT = 0.1; + const LAKE_ELEVATION_INCREMENT = 0.2; + + const lakes = features.filter(feature => feature && feature.type === "lake") as IPackFeatureLake[]; + lakes.sort((a, b) => a.height - b.height); // lowest lakes go first + + const getHeight = (i: number) => currentLakeHeights[cells.f[i]] || currentCellHeights[i]; + const getMinHeight = (cellsIds: number[]) => Math.min(...cellsIds.map(getHeight)); + const getMinLandHeight = (cellsIds: number[]) => Math.min(...cellsIds.map(i => currentCellHeights[i])); + + const landCells = cells.i.filter(i => initialCellHeights[i] >= MIN_LAND_HEIGHT && !cells.b[i]); + landCells.sort((a, b) => initialCellHeights[a] - initialCellHeights[b]); // lowest cells go first + + const currentCellHeights = Float32Array.from(initialCellHeights); + const currentLakeHeights = Object.fromEntries(lakes.map(({i, height}) => [i, height])); + const currentDrainableLakes = checkLakesDrainability(); + const depressions: number[] = []; + + let bestDepressions = Infinity; + let bestCellHeights: typeof currentCellHeights | null = null; + let bestDrainableLakes: typeof currentDrainableLakes | null = null; + + for (let iteration = 0; depressions.at(-1) !== 0 && iteration < MAX_INTERATIONS; iteration++) { + let depressionsLeft = 0; + + // elevate potentially drainable lakes + if (iteration < checkLakeMaxIteration) { + for (const lake of lakes) { + if (currentDrainableLakes[lake.i] !== true) continue; + + const minShoreHeight = getMinLandHeight(lake.shoreline); + if (minShoreHeight >= MAX_HEIGHT || currentLakeHeights[lake.i] > minShoreHeight) continue; + + if (iteration > elevateLakeMaxIteration) { + // reset heights + for (const shoreCellId of lake.shoreline) { + currentCellHeights[shoreCellId] = initialCellHeights[shoreCellId]; + } + currentLakeHeights[lake.i] = lake.height; + + currentDrainableLakes[lake.i] = false; + continue; + } + + currentLakeHeights[lake.i] = minShoreHeight + LAKE_ELEVATION_INCREMENT; + depressionsLeft++; + } + } + + for (const cellId of landCells) { + const minHeight = getMinHeight(cells.c[cellId]); + if (minHeight >= MAX_HEIGHT || currentCellHeights[cellId] > minHeight) continue; + + currentCellHeights[cellId] = minHeight + LAND_ELEVATION_INCREMENT; + depressionsLeft++; + } + + depressions.push(depressionsLeft); + if (depressionsLeft < bestDepressions) { + bestDepressions = depressionsLeft; + bestCellHeights = Float32Array.from(currentCellHeights); + bestDrainableLakes = structuredClone(currentDrainableLakes); + } + } + + TIME && console.timeEnd("resolveDepressions"); + + const depressionsLeft = depressions.at(-1); + if (depressionsLeft) { + if (bestCellHeights && bestDrainableLakes) { + WARN && + console.warn(`Cannot resolve all depressions. Depressions: ${depressions[0]}. Best result: ${bestDepressions}`); + return [bestCellHeights, bestDrainableLakes]; + } + + WARN && console.warn(`Cannot resolve depressions. Depressions: ${depressionsLeft}`); + return [initialCellHeights, {}]; + } + + INFO && console.info(`ⓘ resolved all ${depressions[0]} depressions in ${depressions.length} iterations`); + return [currentCellHeights, currentDrainableLakes]; + + // define lakes that potentially can be open (drained into another water body) + function checkLakesDrainability() { + const canBeDrained: Dict = {}; // all false by default + + const ELEVATION_LIMIT = getInputNumber("lakeElevationLimitOutput"); + const drainAllLakes = ELEVATION_LIMIT === MAX_HEIGHT - MIN_LAND_HEIGHT; + + for (const lake of lakes) { + if (drainAllLakes) { + canBeDrained[lake.i] = true; + continue; + } + + canBeDrained[lake.i] = false; + const minShoreHeight = getMinHeight(lake.shoreline); + const minHeightShoreCell = + lake.shoreline.find(cellId => initialCellHeights[cellId] === minShoreHeight) || lake.shoreline[0]; + + const queue = [minHeightShoreCell]; + const checked = []; + checked[minHeightShoreCell] = true; + const breakableHeight = lake.height + ELEVATION_LIMIT; + + loopCellsAroundLake: while (queue.length) { + const cellId = queue.pop()!; + + for (const neibCellId of cells.c[cellId]) { + if (checked[neibCellId]) continue; + if (initialCellHeights[neibCellId] >= breakableHeight) continue; + + if (initialCellHeights[neibCellId] < MIN_LAND_HEIGHT) { + const waterFeatureMet = features[cells.f[neibCellId]]; + const isOceanMet = waterFeatureMet && waterFeatureMet.type === "ocean"; + const isLakeMet = waterFeatureMet && waterFeatureMet.type === "lake"; + + if (isOceanMet || (isLakeMet && lake.height > waterFeatureMet.height)) { + canBeDrained[lake.i] = true; + break loopCellsAroundLake; + } + } + + checked[neibCellId] = true; + queue.push(neibCellId); + } + } + } + + return canBeDrained; + } +} diff --git a/src/scripts/generation/pack/generateRoutes.ts b/src/scripts/generation/pack/routes/generateRoutes.ts similarity index 88% rename from src/scripts/generation/pack/generateRoutes.ts rename to src/scripts/generation/pack/routes/generateRoutes.ts index b7f3e76a..e852fbd6 100644 --- a/src/scripts/generation/pack/generateRoutes.ts +++ b/src/scripts/generation/pack/routes/generateRoutes.ts @@ -1,10 +1,10 @@ -import Delaunator from "delaunator"; import FlatQueue from "flatqueue"; import {TIME} from "config/logging"; import {ELEVATION, MIN_LAND_HEIGHT, ROUTES} from "config/generation"; import {dist2} from "utils/functionUtils"; import {isBurg} from "utils/typeUtils"; +import {calculateUrquhartEdges} from "./urquhart"; type TCellsData = Pick; @@ -292,44 +292,3 @@ function getRouteSegments(pathCells: number[], connections: Map 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: TPoints) { - const score = (p0: number, p1: number) => dist2(points[p0], points[p1]); - - const {halfedges, triangles} = 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; -} diff --git a/src/scripts/generation/pack/routes/urquhart.ts b/src/scripts/generation/pack/routes/urquhart.ts new file mode 100644 index 00000000..67d6ecd3 --- /dev/null +++ b/src/scripts/generation/pack/routes/urquhart.ts @@ -0,0 +1,44 @@ +import Delaunator from "delaunator"; + +import {dist2} from "utils/functionUtils"; + +// 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 +export function calculateUrquhartEdges(points: TPoints) { + const score = (p0: number, p1: number) => dist2(points[p0], points[p1]); + + const {halfedges, triangles} = 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; +}