refactor: lake names

src/modules/names-generator.js

@@ -63,10 +63,7 @@ window.Names = (function () {
 
   // generate name using Markov's chain
   const getBase = function (base, min, max, dupl) {
-    if (base === undefined) {
+    if (base === undefined) return ERROR && console.error("Please define a base");
-      ERROR && console.error("Please define a base");
-      return;
-    }
     if (!chains[base]) updateChain(base);
 
     const data = chains[base];

src/scripts/generation/pack/lakes/generateLakeNames.ts

@@ -0,0 +1,17 @@
+const {Names} = window;
+
+export function generateLakeNames(features: TPackFeatures, culture: UintArray, cultures: TCultures) {
+  const updatedFeatures = features.map(feature => {
+    if (feature === 0) return 0;
+    if (feature.type !== "lake") return feature;
+
+    const landCell = feature.shoreline[0];
+    const cultureId = culture[landCell];
+    const namebase = cultures[cultureId].base;
+
+    const name: string = Names.getBase(namebase);
+    return {...feature, name};
+  });
+
+  return updatedFeatures as TPackFeatures;
+}

src/scripts/generation/pack/lakes/lakes.ts

@@ -3,8 +3,6 @@ import * as d3 from "d3";
 import {rn} from "utils/numberUtils";
 import {getRealHeight} from "utils/unitUtils";
 
-const {Names} = window;
-
 export interface ILakeClimateData extends IPackFeatureLake {
   flux: number;
   temp: number;
@@ -100,17 +98,3 @@ function defineLakeGroup({
 
   return "freshwater";
 }
-
-export function generateLakeNames(features: TPackFeatures, culture: UintArray) {
-  const updatedFeatures = features.map(feature => {
-    if (!feature) return 0;
-    if (feature.type !== "lake") return feature;
-
-    const landCell = feature.shoreline[0];
-    const cultureId = culture[landCell];
-    const name = Names.getCulture(cultureId) as string;
-    return {...feature, name};
-  });
-
-  return updatedFeatures as TPackFeatures;
-}

src/scripts/generation/pack/pack.ts

@@ -4,10 +4,12 @@ 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";
 
 const {Biomes} = window;
@@ -16,11 +18,13 @@ export function createPack(grid: IGrid): IPack {
   const {temp, prec} = grid.cells;
   const {vertices, cells} = repackGrid(grid);
 
-  const {features, featureIds, distanceField, haven, harbor} = markupPackFeatures(
+  const {
-    grid,
+    features: rawFeatures,
-    vertices,
+    featureIds,
-    pick(cells, "v", "c", "b", "p", "h")
+    distanceField,
-  );
+    haven,
+    harbor
+  } = markupPackFeatures(grid, vertices, pick(cells, "v", "c", "b", "p", "h"));
 
   const {
     heights,
@@ -31,7 +35,7 @@ export function createPack(grid: IGrid): IPack {
     mergedFeatures
   } = generateRivers(
     {...pick(cells, "i", "c", "b", "g", "h", "p"), f: featureIds, t: distanceField, haven},
-    features,
+    rawFeatures,
     prec,
     temp
   );
@@ -155,8 +159,8 @@ export function createPack(grid: IGrid): IPack {
     burg: burgIds
   });
 
-  // Rivers.specify();
+  const rivers = specifyRivers(rawRivers, cultureIds, cultures);
-  // const updatedFeatures = generateLakeNames();
+  const features = generateLakeNames(mergedFeatures, cultureIds, cultures);
 
   // Military.generate();
   // Markers.generate();
@@ -191,8 +195,8 @@ export function createPack(grid: IGrid): IPack {
       religion: religionIds,
       province: provinceIds
     },
-    features: mergedFeatures,
+    features,
-    rivers: rawRivers, // "name" | "basin" | "type"
+    rivers,
     cultures,
     states,
     burgs,

src/scripts/generation/pack/religions/generateReligions.ts

@@ -1,5 +1,4 @@
 import {TIME} from "config/logging";
-import {drawPoint} from "utils/debugUtils";
 import {pick} from "utils/functionUtils";
 import {generateFolkReligions} from "./generateFolkReligions";
 import {generateOrganizedReligions} from "./generateOrganizedReligions";

src/scripts/generation/pack/rivers/specifyRivers.ts

@@ -0,0 +1,52 @@
+import {each, rw} from "utils/probabilityUtils";
+
+const {Names} = window;
+
+// 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}
+  }
+};
+
+export function specifyRivers(
+  rawRivers: Omit<IRiver, "name" | "basin" | "type">[],
+  cultureIds: Uint16Array,
+  cultures: TCultures
+): TRivers {
+  const thresholdIndex = Math.ceil(rawRivers.length * 0.15);
+  const smallLength = rawRivers.map(r => r.length).sort((a, b) => a - b)[thresholdIndex];
+
+  const rivers: TRivers = rawRivers.map(river => {
+    const basin = getBasin(rawRivers, river.i);
+    const name = getName(river.mouth, cultureIds, cultures);
+    const type = getType(smallLength, river.i, river.length, river.parent);
+
+    return {...river, basin, name, type};
+  });
+
+  return rivers;
+}
+
+function getBasin(rivers: {i: number; parent: number}[], riverId: number): number {
+  const parent = rivers.find(river => river.i === riverId)?.parent;
+  if (!parent || riverId === parent) return riverId;
+  return getBasin(rivers, parent);
+}
+
+const getName = function (cellId: number, cultureIds: Uint16Array, cultures: TCultures) {
+  const culture = cultures[cultureIds[cellId]];
+  const namebase = culture.base;
+  return Names.getBase(namebase);
+};
+
+const getType = function (smallLength: number, riverId: number, length: number, parent: number) {
+  const isSmall = length < smallLength;
+  const isFork = parent && parent !== riverId && each(3)(riverId);
+  return rw(riverTypes[isFork ? "fork" : "main"][isSmall ? "small" : "big"] as {[key: string]: number});
+};