backups/Fantasy-Map-Generator
1
0
Fork 0
mirror of https://github.com/Azgaar/Fantasy-Map-Generator.git synced 2025-12-18 02:01:22 +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 { aleaPRNG } from "scripts/aleaPRNG";
import { clipPoly, last, normalize, P, rn } from "utils";
import { clipPoly, getGridPolygonWithGrid, last, normalize, P, rn } from "utils";
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,
temp: Int8Array,
gridPoints: TPoints,
features: TGridFeatures,
gridCells: Pick<IGrid["cells"], "f" | "t">
): IIce {
const shieldMin = -8; // max temp to form ice shield (glacier)
const icebergMax = 1; // max temp to form an iceberg
const nOfCells = cells.i.length;
const used = new Uint8Array(cells.i.length);
const nOfCells = gridCells.i.length;
const used = new Uint8Array(gridCells.i.length);
Math.random = aleaPRNG(seed);
const icePack: IIce = { icebergs: [], iceShields: [] };
for (const i of cells.i) {
const temperature = temp[i];
for (const i of gridCells.i) {
const temperature = gridCells.temp[i];
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) {
// very cold: ice shield
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
const vertex = cells.v[i].find((v) =>
vertices.c[v]?.some((i) => temp[i] > shieldMin)
const vertex = gridCells.v[i].find((v) =>
vertices.c[v]?.some((i) => gridCells.temp[i] > shieldMin)
);
if (vertex === undefined) continue; // no suitable vertex found
const chain = connectVertices(vertex);
@ -52,9 +51,8 @@ export function generateIce(
// Helper functions
function generateIceberg(i: number, size: number): IiceBerg {
const cellMidPoint = cells.p[i];
const points: TPoints = cells.v[i]
.map((v) => vertices.p[v])
const cellMidPoint = gridPoints[i];
const points: TPoints = getGridPolygonWithGrid(i, gridCells, vertices)
.map((point) => [
(point[0] + (cellMidPoint[0] - point[0]) * 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
const currentVertex = vertices.c[current]; // cells adjacent to vertex
currentVertex
.filter((cellIndicie) => temp[cellIndicie] <= shieldMin)
.filter((cellIndicie) => gridCells.temp[cellIndicie] <= shieldMin)
.forEach((cellIndice) => (used[cellIndice] = 1));
const c0 =
currentVertex[0] >= nOfCells || temp[currentVertex[0]] > shieldMin;
currentVertex[0] >= nOfCells || gridCells.temp[currentVertex[0]] > shieldMin;
const c1 =
currentVertex[1] >= nOfCells || temp[currentVertex[1]] > shieldMin;
currentVertex[1] >= nOfCells || gridCells.temp[currentVertex[1]] > shieldMin;
const c2 =
currentVertex[2] >= nOfCells || temp[currentVertex[2]] > shieldMin;
currentVertex[2] >= nOfCells || gridCells.temp[currentVertex[2]] > shieldMin;
const vertexNeighbors = vertices.v[current]; // neighboring vertices
if (vertexNeighbors[0] !== prev && c0 !== c1)
current = vertexNeighbors[0];

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

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