backups/Fantasy-Map-Generator
1
0
Fork 0
mirror of https://github.com/Azgaar/Fantasy-Map-Generator.git synced 2026-02-05 01:51:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix for iceBerg generation

Browse source
This commit is contained in:
kruschen 2024-09-10 17:28:11 +00:00
parent 6b5d3fd67e
commit 0b520da04c
3 changed files with 99 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

36
src/scripts/generation/pack/generateIce.ts
View file

@ -1,33 +1,32 @@
import { ERROR } from "config/logging"; import { ERROR } from "config/logging";
import { aleaPRNG } from "scripts/aleaPRNG"; import { aleaPRNG } from "scripts/aleaPRNG";
import { clipPoly, last, normalize, P, rn } from "utils"; import { clipPoly, getGridPolygonWithGrid, last, normalize, P, rn } from "utils";
export function generateIce( export function generateIce(
cells: Pick<IPack["cells"], "i" | "h" | "c" | "v" | "p">, gridCells: Pick<IGrid["cells"],"i" | "h" | "c"| "v" | "f" | "t" | "temp">,
vertices: IGraphVertices, vertices: IGraphVertices,
temp: Int8Array, gridPoints: TPoints,
features: TGridFeatures, features: TGridFeatures,
gridCells: Pick<IGrid["cells"], "f" | "t">
): IIce { ): IIce {
const shieldMin = -8; // max temp to form ice shield (glacier) const shieldMin = -8; // max temp to form ice shield (glacier)
const icebergMax = 1; // max temp to form an iceberg const icebergMax = 1; // max temp to form an iceberg
const nOfCells = cells.i.length; const nOfCells = gridCells.i.length;
const used = new Uint8Array(cells.i.length); const used = new Uint8Array(gridCells.i.length);
Math.random = aleaPRNG(seed); Math.random = aleaPRNG(seed);
const icePack: IIce = { icebergs: [], iceShields: [] }; const icePack: IIce = { icebergs: [], iceShields: [] };
for (const i of cells.i) { for (const i of gridCells.i) {
const temperature = temp[i]; const temperature = gridCells.temp[i];
if (temperature > icebergMax) continue; // too warm: no ice if (temperature > icebergMax) continue; // too warm: no ice
if (temperature > shieldMin && cells.h[i] >= 20) continue; // non-glacier land: no ice if (temperature > shieldMin && gridCells.h[i] >= 20) continue; // non-glacier land: no ice
if (temperature <= shieldMin) { if (temperature <= shieldMin) {
// very cold: ice shield // very cold: ice shield
if (used[i]) continue; // already rendered if (used[i]) continue; // already rendered
const onborder = cells.c[i].some((n) => temp[n] > shieldMin); const onborder = gridCells.c[i].some((n) => gridCells.temp[n] > shieldMin);
if (!onborder) continue; // need to start from onborder cell if (!onborder) continue; // need to start from onborder cell
const vertex = cells.v[i].find((v) => const vertex = gridCells.v[i].find((v) =>
vertices.c[v]?.some((i) => temp[i] > shieldMin) vertices.c[v]?.some((i) => gridCells.temp[i] > shieldMin)
); );
if (vertex === undefined) continue; // no suitable vertex found if (vertex === undefined) continue; // no suitable vertex found
const chain = connectVertices(vertex); const chain = connectVertices(vertex);
@ -52,9 +51,8 @@ export function generateIce(
// Helper functions // Helper functions
function generateIceberg(i: number, size: number): IiceBerg { function generateIceberg(i: number, size: number): IiceBerg {
const cellMidPoint = cells.p[i]; const cellMidPoint = gridPoints[i];
const points: TPoints = cells.v[i] const points: TPoints = getGridPolygonWithGrid(i, gridCells, vertices)
.map((v) => vertices.p[v])
.map((point) => [ .map((point) => [
(point[0] + (cellMidPoint[0] - point[0]) * size) | 0, (point[0] + (cellMidPoint[0] - point[0]) * size) | 0,
(point[1] + (cellMidPoint[1] - point[1]) * size) | 0, (point[1] + (cellMidPoint[1] - point[1]) * size) | 0,
@ -79,14 +77,14 @@ export function generateIce(
chain.push(current); // add current vertex to sequence chain.push(current); // add current vertex to sequence
const currentVertex = vertices.c[current]; // cells adjacent to vertex const currentVertex = vertices.c[current]; // cells adjacent to vertex
currentVertex currentVertex
.filter((cellIndicie) => temp[cellIndicie] <= shieldMin) .filter((cellIndicie) => gridCells.temp[cellIndicie] <= shieldMin)
.forEach((cellIndice) => (used[cellIndice] = 1)); .forEach((cellIndice) => (used[cellIndice] = 1));
const c0 = const c0 =
currentVertex[0] >= nOfCells || temp[currentVertex[0]] > shieldMin; currentVertex[0] >= nOfCells || gridCells.temp[currentVertex[0]] > shieldMin;
const c1 = const c1 =
currentVertex[1] >= nOfCells || temp[currentVertex[1]] > shieldMin; currentVertex[1] >= nOfCells || gridCells.temp[currentVertex[1]] > shieldMin;
const c2 = const c2 =
currentVertex[2] >= nOfCells || temp[currentVertex[2]] > shieldMin; currentVertex[2] >= nOfCells || gridCells.temp[currentVertex[2]] > shieldMin;
const vertexNeighbors = vertices.v[current]; // neighboring vertices const vertexNeighbors = vertices.v[current]; // neighboring vertices
if (vertexNeighbors[0] !== prev && c0 !== c1) if (vertexNeighbors[0] !== prev && c0 !== c1)
current = vertexNeighbors[0]; current = vertexNeighbors[0];

143
src/scripts/generation/pack/pack.ts
View file

@ -1,30 +1,30 @@
import {markupPackFeatures} from "scripts/generation/markup"; import { markupPackFeatures } from "scripts/generation/markup";
import {rankCells} from "scripts/generation/pack/rankCells"; import { rankCells } from "scripts/generation/pack/rankCells";
import {pick} from "utils/functionUtils"; import { pick } from "utils/functionUtils";
import {generateBurgsAndStates} from "./burgsAndStates/generateBurgsAndStates"; import { generateBurgsAndStates } from "./burgsAndStates/generateBurgsAndStates";
import {expandCultures} from "./cultures/expandCultures"; import { expandCultures } from "./cultures/expandCultures";
import {generateCultures} from "./cultures/generateCultures"; import { generateCultures } from "./cultures/generateCultures";
import {generateLakeNames} from "./lakes/generateLakeNames"; import { generateLakeNames } from "./lakes/generateLakeNames";
import {generateProvinces} from "./provinces/generateProvinces"; import { generateProvinces } from "./provinces/generateProvinces";
import {generateReligions} from "./religions/generateReligions"; import { generateReligions } from "./religions/generateReligions";
import {repackGrid} from "./repackGrid"; import { repackGrid } from "./repackGrid";
import {generateRivers} from "./rivers/generateRivers"; import { generateRivers } from "./rivers/generateRivers";
import {specifyRivers} from "./rivers/specifyRivers"; import { specifyRivers } from "./rivers/specifyRivers";
import {generateRoutes} from "./routes/generateRoutes"; import { generateRoutes } from "./routes/generateRoutes";
import { generateIce } from "./generateIce"; import { generateIce } from "./generateIce";
const {Biomes} = window; const { Biomes } = window;
export function createPack(grid: IGrid): IPack { export function createPack(grid: IGrid): IPack {
const {temp, prec} = grid.cells; const { temp, prec } = grid.cells;
const {vertices, cells} = repackGrid(grid); const { vertices, cells } = repackGrid(grid);
const { const {
features: rawFeatures, features: rawFeatures,
featureIds, featureIds,
distanceField, distanceField,
haven, haven,
harbor harbor,
} = markupPackFeatures(grid, vertices, pick(cells, "v", "c", "b", "p", "h")); } = markupPackFeatures(grid, vertices, pick(cells, "v", "c", "b", "p", "h"));
const { const {
@ -33,9 +33,14 @@ export function createPack(grid: IGrid): IPack {
riverIds, riverIds,
conf, conf,
rivers: rawRivers, rivers: rawRivers,
mergedFeatures mergedFeatures,
} = generateRivers( } = generateRivers(
{...pick(cells, "i", "c", "b", "g", "h", "p"), f: featureIds, t: distanceField, haven}, {
...pick(cells, "i", "c", "b", "g", "h", "p"),
f: featureIds,
t: distanceField,
haven,
},
rawFeatures, rawFeatures,
prec, prec,
temp temp
@ -48,10 +53,10 @@ export function createPack(grid: IGrid): IPack {
riverIds, riverIds,
heights, heights,
neighbors: cells.c, neighbors: cells.c,
gridReference: cells.g gridReference: cells.g,
}); });
const {suitability, population} = rankCells(mergedFeatures, { const { suitability, population } = rankCells(mergedFeatures, {
t: distanceField, t: distanceField,
f: featureIds, f: featureIds,
fl: flux, fl: flux,
@ -61,7 +66,7 @@ export function createPack(grid: IGrid): IPack {
area: cells.area, area: cells.area,
biome, biome,
haven, haven,
harbor harbor,
}); });
const cultures = generateCultures( const cultures = generateCultures(
@ -79,7 +84,7 @@ export function createPack(grid: IGrid): IPack {
fl: flux, fl: flux,
s: suitability, s: suitability,
pop: population, pop: population,
biome biome,
}, },
temp temp
); );
@ -93,42 +98,43 @@ export function createPack(grid: IGrid): IPack {
r: riverIds, r: riverIds,
fl: flux, fl: flux,
biome, biome,
pop: population pop: population,
}); });
const {burgIds, stateIds, burgs, states, conflicts} = generateBurgsAndStates( const { burgIds, stateIds, burgs, states, conflicts } =
cultures, generateBurgsAndStates(
mergedFeatures, cultures,
temp, mergedFeatures,
rawRivers, temp,
vertices, rawRivers,
{ vertices,
...pick(cells, "v", "c", "p", "b", "i", "g", "area"), {
h: heights, ...pick(cells, "v", "c", "p", "b", "i", "g", "area"),
f: featureIds, h: heights,
t: distanceField, f: featureIds,
haven, t: distanceField,
harbor, haven,
r: riverIds, harbor,
fl: flux, r: riverIds,
biome, fl: flux,
s: suitability, biome,
pop: population, s: suitability,
culture: cultureIds pop: population,
} culture: cultureIds,
); }
);
const {cellRoutes, routes} = generateRoutes(burgs, temp, { const { cellRoutes, routes } = generateRoutes(burgs, temp, {
c: cells.c, c: cells.c,
p: cells.p, p: cells.p,
g: cells.g, g: cells.g,
h: heights, h: heights,
t: distanceField, t: distanceField,
biome, biome,
burg: burgIds burg: burgIds,
}); });
const {religionIds, religions} = generateReligions({ const { religionIds, religions } = generateReligions({
states, states,
cultures, cultures,
burgs, burgs,
@ -144,31 +150,38 @@ export function createPack(grid: IGrid): IPack {
culture: cultureIds, culture: cultureIds,
burg: burgIds, burg: burgIds,
state: stateIds, state: stateIds,
route: cellRoutes route: cellRoutes,
} },
}); });
const {provinceIds, provinces} = generateProvinces(states, burgs, cultures, mergedFeatures, vertices, { const { provinceIds, provinces } = generateProvinces(
i: cells.i, states,
c: cells.c, burgs,
v: cells.v, cultures,
h: heights, mergedFeatures,
t: distanceField, vertices,
f: featureIds, {
culture: cultureIds, i: cells.i,
state: stateIds, c: cells.c,
burg: burgIds v: cells.v,
}); h: heights,
t: distanceField,
f: featureIds,
culture: cultureIds,
state: stateIds,
burg: burgIds,
}
);
const rivers = specifyRivers(rawRivers, cultureIds, cultures); const rivers = specifyRivers(rawRivers, cultureIds, cultures);
const features = generateLakeNames(mergedFeatures, cultureIds, cultures); const features = generateLakeNames(mergedFeatures, cultureIds, cultures);
const ice = generateIce(cells, vertices, temp, features, grid.cells); const ice = generateIce(grid.cells, grid.vertices, grid.points, features);
// Military.generate(); // Military.generate();
// Markers.generate(); // Markers.generate();
// addZones(); // add to pack data // addZones(); // add to pack data
const events: IEvents = {conflicts}; const events: IEvents = { conflicts };
const pack: IPack = { const pack: IPack = {
vertices, vertices,
@ -190,7 +203,7 @@ export function createPack(grid: IGrid): IPack {
state: stateIds, state: stateIds,
route: cellRoutes, route: cellRoutes,
religion: religionIds, religion: religionIds,
province: provinceIds province: provinceIds,
}, },
features, features,
rivers, rivers,
@ -201,7 +214,7 @@ export function createPack(grid: IGrid): IPack {
religions, religions,
provinces, provinces,
events, events,
ice ice,
}; };
return pack; return pack;

4
src/utils/graphUtils.ts
View file

@ -56,6 +56,10 @@ export function getGridPolygon(i: number): TPoints {
return grid.cells.v[i].map(v => grid.vertices.p[v]); return grid.cells.v[i].map(v => grid.vertices.p[v]);
} }
export function getGridPolygonWithGrid(i: number, cells: Pick<IGrid["cells"], "v">, vertices: IGraphVertices): TPoints {
return cells.v[i].map(v => vertices.p[v]);
}
export function isLand(cellId: number) { export function isLand(cellId: number) {
return pack.cells.h[cellId] >= MIN_LAND_HEIGHT; return pack.cells.h[cellId] >= MIN_LAND_HEIGHT;
} }