From 89d61fda5f144dcd3776f67dd62eb96e0140f9f2 Mon Sep 17 00:00:00 2001
From: Azgaar <maxganiev@yandex.com>
Date: Sat, 25 Feb 2023 13:36:44 +0400
Subject: [PATCH 1/7] chore: change meta description

---
 index.html | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)
diff --git a/index.html b/index.html
index 84323f43..a4e25780 100644
--- a/index.html
+++ b/index.html
@@ -3,14 +3,33 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
     <title>Azgaar's Fantasy Map Generator</title>
     <meta name="application-name" content="Azgaar's Fantasy Map Generator" />
-    <meta name="author" content="Azgaar (Max Ganiev)" />
-    <meta name="description" content="Azgaar's Fantasy Map Generator and Editor" />
+    <meta name="author" content="Azgaar" />
+    <meta
+      name="description"
+      content="Free web app that helps fantasy writers, game masters, and cartographers create and edit fantasy maps"
+    />
+
     <meta property="og:url" content="https://azgaar.github.io/Fantasy-Map-Generator" />
     <meta property="og:title" content="Azgaar's Fantasy Map Generator" />
-    <meta property="og:description" content="Web application generating interactive and customizable maps" />
+    <meta
+      property="og:description"
+      content="Free web app that helps fantasy writers, game masters, and cartographers create and edit fantasy maps"
+    />
     <meta property="og:image" content="images/preview.png" />
+
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta property="twitter:domain" content="azgaar.github.io" />
+    <meta property="twitter:url" content="https://azgaar.github.io/Fantasy-Map-Generator/" />
+    <meta name="twitter:title" content="Azgaar's Fantasy Map Generator" />
+    <meta
+      name="twitter:description"
+      content="Free web app that helps fantasy writers, game masters, and cartographers create and edit fantasy maps"
+    />
+    <meta name="twitter:image" content="images/preview.png" />
+
     <link rel="icon" type="image/png" href="images/icons/favicon-32x32.png" sizes="32x32" />
     <link rel="icon" type="image/png" href="images/icons/favicon-16x16.png" sizes="16x16" />
     <link rel="apple-touch-icon" href="images/icons/maskable_icon_x192.png" />

From f018256f7af0b293581d9ec52fcfcd21822fd41d Mon Sep 17 00:00:00 2001
From: Azgaar <maxganiev@yandex.com>
Date: Sat, 25 Feb 2023 16:01:22 +0400
Subject: [PATCH 2/7] fix(#906): ice to follow expected size, reduce ice
 elements in general

---
 index.html               |  8 ++++----
 modules/ui/ice-editor.js |  8 ++++----
 modules/ui/layers.js     | 34 ++++++++++++++++------------------
 utils/numberUtils.js     |  4 ++++
 versioning.js            |  2 +-
 5 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/index.html b/index.html
index a4e25780..19795b6a 100644
--- a/index.html
+++ b/index.html
@@ -2768,7 +2768,7 @@
       <div id="iceEditor" class="dialog" style="display: none">
         <button id="iceEditStyle" data-tip="Edit style in Style Editor" class="icon-brush"></button>
         <button id="iceRandomize" data-tip="Randomize Iceberg shape" class="icon-shuffle"></button>
-        <input id="iceSize" data-tip="Change Iceberg size" type="range" min=".05" max="1" step=".01" />
+        <input id="iceSize" data-tip="Change Iceberg size" type="range" min=".05" max="2" step=".01" />
         <button id="iceNew" data-tip="Add an Iceberg (click on map)" class="icon-plus"></button>
         <button
           id="iceRemove"
@@ -7849,7 +7849,7 @@
     <script src="utils/colorUtils.js"></script>
     <script src="utils/graphUtils.js?v=1.88.02"></script>
     <script src="utils/nodeUtils.js"></script>
-    <script src="utils/numberUtils.js"></script>
+    <script src="utils/numberUtils.js?v=1.89.08"></script>
     <script src="utils/polyfills.js"></script>
     <script src="utils/probabilityUtils.js?v=1.88.00"></script>
     <script src="utils/stringUtils.js"></script>
@@ -7860,7 +7860,7 @@
     <script src="config/heightmap-templates.js"></script>
     <script src="config/precreated-heightmaps.js"></script>
     <script src="modules/heightmap-generator.js?v=1.88.00"></script>
-    <script src="modules/ocean-layers.js?v=1.87.15"></script>
+    <script src="modules/ocean-layers.js?v=1.89.08"></script>
     <script src="modules/river-generator.js"></script>
     <script src="modules/lakes.js"></script>
     <script src="modules/names-generator.js?v=1.87.14"></script>
@@ -7896,7 +7896,7 @@
     <script defer src="modules/ui/elevation-profile.js"></script>
     <script defer src="modules/ui/temperature-graph.js"></script>
     <script defer src="modules/ui/routes-editor.js?v=1.89.04"></script>
-    <script defer src="modules/ui/ice-editor.js"></script>
+    <script defer src="modules/ui/ice-editor.js?v=1.89.08"></script>
     <script defer src="modules/ui/lakes-editor.js?v=1.87.10"></script>
     <script defer src="modules/ui/coastline-editor.js"></script>
     <script defer src="modules/ui/labels-editor.js"></script>
diff --git a/modules/ui/ice-editor.js b/modules/ui/ice-editor.js
index f07cb6f9..a9e6ff28 100644
--- a/modules/ui/ice-editor.js
+++ b/modules/ui/ice-editor.js
@@ -67,11 +67,11 @@ function editIce() {
   function addIcebergOnClick() {
     const [x, y] = d3.mouse(this);
     const i = findGridCell(x, y, grid);
-    const c = grid.points[i];
-    const s = +document.getElementById("iceSize").value;
+    const [cx, cy] = grid.points[i];
+    const size = +document.getElementById("iceSize")?.value || 1;
 
-    const points = getGridPolygon(i).map(p => [(p[0] + (c[0] - p[0]) / s) | 0, (p[1] + (c[1] - p[1]) / s) | 0]);
-    const iceberg = ice.append("polygon").attr("points", points).attr("cell", i).attr("size", s);
+    const points = getGridPolygon(i).map(([x, y]) => [rn(lerp(cx, x, size), 2), rn(lerp(cy, y, size), 2)]);
+    const iceberg = ice.append("polygon").attr("points", points).attr("cell", i).attr("size", size);
     iceberg.call(d3.drag().on("drag", dragElement));
     if (d3.event.shiftKey === false) toggleAdd();
   }
diff --git a/modules/ui/layers.js b/modules/ui/layers.js
index 28b6ef57..3ea64e72 100644
--- a/modules/ui/layers.js
+++ b/modules/ui/layers.js
@@ -671,11 +671,10 @@ function toggleIce(event) {
 }
 
 function drawIce() {
-  const cells = grid.cells,
-    vertices = grid.vertices,
-    n = cells.i.length,
-    temp = cells.temp,
-    h = cells.h;
+  const {cells, vertices} = grid;
+  const {temp, h} = cells;
+  const n = cells.i.length;
+
   const used = new Uint8Array(cells.i.length);
   Math.random = aleaPRNG(seed);
 
@@ -700,23 +699,22 @@ function drawIce() {
       continue;
     }
 
+    const tNormalized = normalize(t, -8, 2);
+    const randomFactor = t > -5 ? 0.4 + rand() * 1.2 : 1;
+
     // mildly cold: iceberd
-    if (P(normalize(t, -7, 2.5))) continue; // t[-5; 2] cold: skip some cells
+    if (P(tNormalized ** 0.5 * randomFactor)) continue; // cold: skip some cells
     if (grid.features[cells.f[i]].type === "lake") continue; // lake: no icebers
-    let size = (6.5 + t) / 10; // iceberg size: 0 = full size, 1 = zero size
-    if (cells.t[i] === -1) size *= 1.3; // coasline: smaller icebers
-    size = Math.min(size * (0.4 + rand() * 1.2), 0.95); // randomize iceberg size
-    resizePolygon(i, size);
+
+    let size = 1 - tNormalized; // iceberg size: 0 = zero size, 1 = full size
+    if (cells.t[i] === -1) size /= 1.3; // coasline: smaller icebers
+    resizePolygon(i, minmax(rn(size * randomFactor, 2), 0.08, 1));
   }
 
-  function resizePolygon(i, s) {
-    const c = grid.points[i];
-    const points = getGridPolygon(i).map(p => [(p[0] + (c[0] - p[0]) * s) | 0, (p[1] + (c[1] - p[1]) * s) | 0]);
-    ice
-      .append("polygon")
-      .attr("points", points)
-      .attr("cell", i)
-      .attr("size", rn(1 - s, 2));
+  function resizePolygon(i, size) {
+    const [cx, cy] = grid.points[i];
+    const points = getGridPolygon(i).map(([x, y]) => [rn(lerp(cx, x, size), 2), rn(lerp(cy, y, size), 2)]);
+    ice.append("polygon").attr("points", points).attr("cell", i).attr("size", size);
   }
 
   // connect vertices to chain
diff --git a/utils/numberUtils.js b/utils/numberUtils.js
index e3f143a5..ada7c284 100644
--- a/utils/numberUtils.js
+++ b/utils/numberUtils.js
@@ -20,3 +20,7 @@ function lim(v) {
 function normalize(val, min, max) {
   return minmax((val - min) / (max - min), 0, 1);
 }
+
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
diff --git a/versioning.js b/versioning.js
index ec4f6f9d..c901a46a 100644
--- a/versioning.js
+++ b/versioning.js
@@ -1,7 +1,7 @@
 "use strict";
 
 // version and caching control
-const version = "1.89.07"; // generator version, update each time
+const version = "1.89.08"; // generator version, update each time
 
 {
   document.title += " v" + version;

From 64764dcd782cc88f621ad34a8651747f95268d43 Mon Sep 17 00:00:00 2001
From: Canis Artorus <acjames148@gmail.com>
Date: Wed, 1 Mar 2023 22:29:09 -0700
Subject: [PATCH 3/7] Bugfixes

---
 main.js                                     |  1 +
 modules/cultures-generator.js               | 14 ++++++++------
 modules/dynamic/editors/religions-editor.js |  6 +++---
 3 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/main.js b/main.js
index 5cf0edc3..82787684 100644
--- a/main.js
+++ b/main.js
@@ -684,6 +684,7 @@ async function generate(options) {
     const timeStart = performance.now();
     const {seed: precreatedSeed, graph: precreatedGraph} = options || {};
 
+    pack = {};
     invokeActiveZooming();
     setSeed(precreatedSeed);
     INFO && console.group("Generated Map " + seed);
diff --git a/modules/cultures-generator.js b/modules/cultures-generator.js
index eeb09407..b167b88e 100644
--- a/modules/cultures-generator.js
+++ b/modules/cultures-generator.js
@@ -118,21 +118,23 @@ window.Cultures = (function () {
 
     function selectCultures(culturesNumber) {
       let def = getDefault(culturesNumber);
-      if (culturesNumber === def.length) return def;
-      if (def.every(d => d.odd === 1)) return def.splice(0, culturesNumber);
-
-      const count = Math.min(culturesNumber, def.length);
 
       const cultures = [];
       pack.cultures?.forEach(function (culture) {
         if (culture.lock) cultures.push(culture);
       });
+      
+      if (!cultures.length) {
+        if (culturesNumber === def.length) return def;
+        if (def.every(d => d.odd === 1)) return def.splice(0, culturesNumber);
+      }
 
-      for (let culture, rnd, i = 0; cultures.length < count && i < 200; i++) {
+      for (let culture, rnd, i = 0; cultures.length < culturesNumber && def.length > 0;) {
         do {
           rnd = rand(def.length - 1);
           culture = def[rnd];
-        } while (!P(culture.odd));
+          i++;
+        } while (i < 200 && !P(culture.odd));
         cultures.push(culture);
         def.splice(rnd, 1);
       }
diff --git a/modules/dynamic/editors/religions-editor.js b/modules/dynamic/editors/religions-editor.js
index 8a4abc5e..45d9886f 100644
--- a/modules/dynamic/editors/religions-editor.js
+++ b/modules/dynamic/editors/religions-editor.js
@@ -5,7 +5,7 @@ export function open() {
   closeDialogs("#religionsEditor, .stable");
   if (layerIsOn("toggleStates")) toggleStates();
   if (layerIsOn("toggleBiomes")) toggleBiomes();
-  if (layerIsOn("toggleCultures")) toggleReligions();
+  if (layerIsOn("toggleCultures")) toggleCultures();
   if (layerIsOn("toggleProvinces")) toggleProvinces();
   if (!layerIsOn("toggleReligions")) toggleReligions();
 
@@ -213,7 +213,7 @@ function religionsEditorAddLines() {
       <span data-tip="${populationTip}" class="icon-male hide"></span>
       <div data-tip="${populationTip}" class="religionPopulation hide pointer">${si(population)}</div>
       <span
-        data-tip="Lock religion, will regenerate the origin folk and organized religion if they are not also locked"
+        data-tip="Lock this religion"
         class="icon-lock${r.lock ? "" : "-open"} hide"
       ></span>
       <span data-tip="Remove religion" class="icon-trash-empty hide"></span>
@@ -475,7 +475,7 @@ function drawReligionCenters() {
     .attr("stroke", "#444444")
     .style("cursor", "move");
 
-  const data = pack.religions.filter(r => r.i && r.center && r.cells && !r.removed);
+  const data = pack.religions.filter(r => r.i && r.center && !r.removed);
   religionCenters
     .selectAll("circle")
     .data(data)

From cbb36a487536bf54da4323bd7de9613e17d2ddc1 Mon Sep 17 00:00:00 2001
From: Canis Artorus <acjames148@gmail.com>
Date: Thu, 2 Mar 2023 03:46:23 -0700
Subject: [PATCH 4/7] Refactor toward modern style

---
 modules/religions-generator.js | 611 +++++++++++++++++----------------
 1 file changed, 313 insertions(+), 298 deletions(-)

diff --git a/modules/religions-generator.js b/modules/religions-generator.js
index 0ae9be91..13d03585 100644
--- a/modules/religions-generator.js
+++ b/modules/religions-generator.js
@@ -304,15 +304,34 @@ window.Religions = (function () {
     Heresy: {Heresy: 1}
   };
 
-  const methods = {
-    "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
+  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 = {
@@ -342,29 +361,209 @@ window.Religions = (function () {
     }
   };
 
-  const generate = function () {
+  function generate() {
     TIME && console.time("generateReligions");
-    const {cells, states, cultures} = pack;
+    // const {cells, states, cultures, burgs} = pack;
 
-    const religionIds = new Uint16Array(cells.culture); // cell religion; initially based on culture
-    const religions = [];
+    const folkReligions = generateFolkReligions();
+    const {lockedReligions, lockedReligionCount} = restoreLockedReligions();
+    const basicReligions = generateOrganizedReligions(+religionsInput.value, lockedReligionCount);
 
+    const {religions, religionIds} = specifyReligions([...folkReligions, ...basicReligions], lockedReligions);
+    
+    pack.religions = religions;
+    pack.cells.religion = religionIds;
+
+    TIME && console.timeEnd("generateReligions");
+  };
+
+  function generateFolkReligions() {
+    return pack.cultures.filter(c => c.i && !c.removed).map(culture => {
+      const {i: culutreId, center} = culture;
+      const form = rw(forms.Folk);
+
+      return {type:"Folk", form, culture: culutreId, center};
+    });
+  }
+
+  function restoreLockedReligions() {
+    //TODO
+    return {lockedReligions: [], lockedReligionCount: 0};
+  }
+
+  function generateOrganizedReligions(desiredReligionNumber, lockedReligionCount) {
+    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, 2) / 10) * religionCores.length); // 0 - 20%, was gauss(0,1, 0,3) per organized with expansionism >= 3
+    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
+      // TODO
+
+      // min distance between religion inceptions
+      const spacing = (graphWidth + graphHeight) / 2 / desiredReligionNumber; // was major gauss(1,0.3, 0.2,2, 2) / 6; cult gauss(2,0.3, 1,3, 2) /6; heresy /60
+
+      for (const cellId of candidateCells) { // was biased random major ^5, cult ^1
+        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(newReligions, lockedReligions) {
+    const {cells, cultures} = pack;
+
+    const expansionismMap = {
+      Folk: () => 0,
+      Organized: () => gauss(5, 3, 0, 10, 1), // was rand(3, 8)
+      Cult: () => gauss(0.5, 0.5, 0, 5, 1), // was gauss(1.1, 0.5, 0, 5)
+      Heresy: () => gauss(1, 0.5, 0, 5, 1) // was gauss(1.2, 0.5, 0, 5)
+    };
+    const religionOriginsParamsMap = {
+      Organized: {clusterSize: 100, maxReligions: 2}, // was 150/count, 2
+      Cult: {clusterSize: 50, maxReligions: 3}, // was 300/count, rand(0,4)
+      Heresy: {clusterSize: 50, maxReligions: 4}
+    };
+    
+    const rawReligions = newReligions.map(({type, form, culture: cultureId, center}, index) => {
+      const supreme = generateDeityName(cultures[cultureId]);
+      const deity = form === "Non-theism" || form === "Animism" ? null : supreme;
+
+      const stateId = cells.state[center];
+
+      let {name, expansion} = generateReligionName(form, supreme, center);
+      if (expansion === "state" && !stateId) expansion = "global";
+
+      const expansionism = expansionismMap[type]();
+
+      const color = getReligionColor(cultures[cultureId], type);
+
+      return {i: index + 1, name, type, form, culture: cultureId, center, deity, expansion, expansionism, color};
+    });
+
+    const religionIds = expandReligions(rawReligions);
+    const names = renameOldReligions(rawReligions);
+    const origins = defineOrigins(religionIds, rawReligions, cells.c);
+
+    return {religions: combineReligionsData(), religionIds};
+
+    function getReligionColor(culture, type) {
+      if (!culture.i) throw new Error(`Culture ${culture.i} is not a valid culture`);
+
+      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);
+    }
+
+    function combineReligionsData() {
+      const noReligion = {i: 0, name: "No religion"};
+
+      const religions = rawReligions.map((religion, index) => ({
+        ...religion,
+        name: names[index],
+        origins: origins[index]
+      }));
+
+      return [noReligion, ...religions];
+    }
+
+    // prepend 'Old' to names of folk religions which have organized competitors
+    function renameOldReligions(rawReligions) {
+      return rawReligions.map(({name, type, culture: cultureId}) => {
+        if (type !== "Folk") return name;
+
+        const haveOrganized = rawReligions.some(({type, culture, expansion}) => culture === cultureId && type === "Organized" && expansion === "culture");
+        if (haveOrganized && name.slice(0, 3) !== "Old") return `Old ${name}`;
+        return name;
+      });
+    }
+
+    function defineOrigins(religionIds, rawReligions, neighbors) {
+      return rawReligions.map(religion => {
+        if (religion.type === "Folk") return [0];
+
+        const {i, type, culture: cultureId, expansion, center} = religion;
+
+        const folkReligion = rawReligions.find(({culture, type}) => type === "Folk" && culture === cultureId);
+        const isFolkBased = folkReligion && cultureId && expansion === "culture" && each(2)(center); // P(0.5) -> isEven cellId
+
+        if (isFolkBased) return [folkReligion.i];
+
+        const {clusterSize, maxReligions} = religionOriginsParamsMap[type];
+        const origins = getReligionsInRadius(neighbors, center, religionIds, i, clusterSize, maxReligions);
+        return origins;
+      });
+    }
+
+    function getReligionsInRadius(neighbors, center, religionIds, religionId, clusterSize, maxReligions) {
+      const foundReligions = new Set();
+      const queue = [center];
+      const checked = {};
+
+      for (let size = 0; queue.length && size < clusterSize; size++) {
+        const cellId = queue.pop();
+        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);
+          queue.push(neibId);
+        }
+      }
+
+      return foundReligions.size ? [...foundReligions].slice(0, maxReligions) : [0];
+    }
+  }
+
+/*
     // add folk religions
     cultures.forEach(c => {
       if (!c.i) return religions.push({i: 0, name: "No religion"});
 
-      if (c.removed) {
-        religions.push({
-          i: c.i,
-          name: "Extinct religion for " + c.name,
-          color: getMixedColor(c.color, 0.1, 0),
-          removed: true
-        });
-        return;
-      }
-
-      const newId = c.i;
-
       if (pack.religions) {
         const lockedFolkReligion = pack.religions.find(
           r => r.culture === c.i && !r.removed && r.lock && r.type === "Folk"
@@ -381,48 +580,8 @@ window.Religions = (function () {
         }
       }
 
-      const form = rw(forms.Folk);
-      const name = c.name + " " + rw(types[form]);
-      const deity = form === "Animism" ? null : getDeityName(c.i);
-      const color = getMixedColor(c.color, 0.1, 0);
-      religions.push({
-        i: newId,
-        name,
-        color,
-        culture: newId,
-        type: "Folk",
-        form,
-        deity,
-        center: c.center,
-        origins: [0]
-      });
     });
 
-    if (religionsInput.value == 0 || pack.cultures.length < 2) {
-      religions.filter(r => r.i).forEach(r => (r.code = abbreviate(r.name)));
-      cells.religion = religionIds;
-      pack.religions = religions;
-      return;
-    }
-
-    const burgs = pack.burgs.filter(b => b.i && !b.removed);
-    const sorted =
-      burgs.length > +religionsInput.value
-        ? burgs.sort((a, b) => b.population - a.population).map(b => b.cell)
-        : cells.i.filter(i => cells.s[i] > 2).sort((a, b) => cells.s[b] - cells.s[a]);
-
-    const religionsTree = d3.quadtree();
-    const spacing = (graphWidth + graphHeight) / 6 / religionsInput.value; // base min distance between towns
-    const cultsCount = Math.floor((rand(10, 40) / 100) * religionsInput.value);
-    const count = +religionsInput.value - cultsCount + religions.length;
-
-    function getReligionsInRadius({x, y, r, max}) {
-      if (max === 0) return [0];
-      const cellsInRadius = findAll(x, y, r);
-      const religions = unique(cellsInRadius.map(i => religionIds[i]).filter(r => r));
-      return religions.length ? religions.slice(0, max) : [0];
-    }
-
     // restore locked non-folk religions
     if (pack.religions) {
       const lockedNonFolkReligions = pack.religions.filter(r => r.lock && !r.removed && r.type !== "Folk");
@@ -438,218 +597,86 @@ window.Religions = (function () {
         religions.push(religion);
       }
     }
+*/
+  // growth algorithm to assign cells to religions
+  function expandReligions(religions) {
+    const religionIds = spreadFolkReligions(religions);
 
-    // generate organized religions
-    for (let i = 0; religions.length < count && i < 1000; i++) {
-      let center = sorted[biased(0, sorted.length - 1, 5)]; // religion center
-      const form = rw(forms.Organized);
-      const state = cells.state[center];
-      const culture = cells.culture[center];
+    const queue = new PriorityQueue({comparator: (a, b) => a.p - b.p});
+    const cost = [];
 
-      const deity = form === "Non-theism" ? null : getDeityName(culture);
-      let [name, expansion] = getReligionName(form, deity, center);
-      if (expansion === "state" && !state) expansion = "global";
-      if (expansion === "culture" && !culture) expansion = "global";
+    const maxExpansionCost = (cells.i.length / 20) * gauss(1, 0.3, 0.2, 2, 2) * neutralInput.value; // limit cost for organized religions growth (was /25)
 
-      if (expansion === "state" && Math.random() > 0.5) center = states[state].center;
-      if (expansion === "culture" && Math.random() > 0.5) center = cultures[culture].center;
+    const biomePassageCost = (cellId) => biomesData.cost[cells.biome[cellId]];
 
-      if (!cells.burg[center] && cells.c[center].some(c => cells.burg[c]))
-        center = cells.c[center].find(c => cells.burg[c]);
-      const [x, y] = cells.p[center];
-
-      const s = spacing * gauss(1, 0.3, 0.2, 2, 2); // randomize to make the placement not uniform
-      if (religionsTree.find(x, y, s) !== undefined) continue; // to close to existing religion
-
-      // add "Old" to name of the folk religion on this culture
-      const isFolkBased = expansion === "culture" || P(0.5);
-      const folk = isFolkBased && religions.find(r => r.culture === culture && r.type === "Folk");
-      if (folk && expansion === "culture" && folk.name.slice(0, 3) !== "Old") folk.name = "Old " + folk.name;
-
-      const origins = folk ? [folk.i] : getReligionsInRadius({x, y, r: 150 / count, max: 2});
-      const expansionism = rand(3, 8);
-      const baseColor = religions[culture]?.color || states[state]?.color || getRandomColor();
-      const color = getMixedColor(baseColor, 0.3, 0);
-
-      religions.push({
-        i: religions.length,
-        name,
-        color,
-        culture,
-        type: "Organized",
-        form,
-        deity,
-        expansion,
-        expansionism,
-        center,
-        origins
-      });
-      religionsTree.add([x, y]);
-    }
-
-    // generate cults
-    for (let i = 0; religions.length < count + cultsCount && i < 1000; i++) {
-      const form = rw(forms.Cult);
-      let center = sorted[biased(0, sorted.length - 1, 1)]; // religion center
-      if (!cells.burg[center] && cells.c[center].some(c => cells.burg[c]))
-        center = cells.c[center].find(c => cells.burg[c]);
-      const [x, y] = cells.p[center];
-
-      const s = spacing * gauss(2, 0.3, 1, 3, 2); // randomize to make the placement not uniform
-      if (religionsTree.find(x, y, s) !== undefined) continue; // to close to existing religion
-
-      const culture = cells.culture[center];
-      const origins = getReligionsInRadius({x, y, r: 300 / count, max: rand(0, 4)});
-
-      const deity = getDeityName(culture);
-      const name = getCultName(form, center);
-      const expansionism = gauss(1.1, 0.5, 0, 5);
-      const color = getMixedColor(cultures[culture].color, 0.5, 0); // "url(#hatch7)";
-      religions.push({
-        i: religions.length,
-        name,
-        color,
-        culture,
-        type: "Cult",
-        form,
-        deity,
-        expansion: "global",
-        expansionism,
-        center,
-        origins
-      });
-      religionsTree.add([x, y]);
-    }
-
-    expandReligions();
-
-    // generate heresies
     religions
-      .filter(r => r.type === "Organized")
+      .filter(r => r.i && !r.lock && r.type !== "Folk")
       .forEach(r => {
-        if (r.expansionism < 3) return;
-        const count = gauss(0, 1, 0, 3);
-        for (let i = 0; i < count; i++) {
-          let center = ra(cells.i.filter(i => religionIds[i] === r.i && cells.c[i].some(c => religionIds[c] !== r.i)));
-          if (!center) continue;
-          if (!cells.burg[center] && cells.c[center].some(c => cells.burg[c]))
-            center = cells.c[center].find(c => cells.burg[c]);
-          const [x, y] = cells.p[center];
-          if (religionsTree.find(x, y, spacing / 10) !== undefined) continue; // to close to other
+        religionIds[r.center] = r.i;
+        queue.queue({e: r.center, p: 0, r: r.i, s: cells.state[r.center]});
+        cost[r.center] = 1;
+      });
+    
+    const religionsMap = new Map(religions.map(r => [r.i, r]));
 
-          const culture = cells.culture[center];
-          const name = getCultName("Heresy", center);
-          const expansionism = gauss(1.2, 0.5, 0, 5);
-          const color = getMixedColor(r.color, 0.4, 0.2); // "url(#hatch6)";
-          religions.push({
-            i: religions.length,
-            name,
-            color,
-            culture,
-            type: "Heresy",
-            form: r.form,
-            deity: r.deity,
-            expansion: "global",
-            expansionism,
-            center,
-            origins: [r.i]
-          });
-          religionsTree.add([x, y]);
+    const isMainRoad = (cellId) => (cells.road[cellId] - cells.crossroad[cellId]) > 4;
+    const isTrail = (cellId) => cells.h > 19 && (cells.road[cellId] - cells.crossroad[cellId]) === 1;
+    const isSeaRoute = (cellId) => cells.h < 20 && cells.road;
+    const isWater = (cellId) => cells.h < 20;
+    // const popCost = d3.max(cells.pop) / 3; // enougth population to spered religion without penalty
+
+    while (queue.length) {
+      const {e: cellId, p, r, s: state} = queue.dequeue();
+      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(nextCell);
+        // const populationCost = Math.max(rn(popCost - cells.pop[nextCell]), 0);
+        // const heightCost = Math.max(cells.h[nextCell], 20) - 20;
+
+        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.queue({e: nextCell, p: totalCost, r, s});
         }
       });
-
-    expandHeresies();
-
-    checkCenters();
-
-    cells.religion = religionIds;
-    pack.religions = religions;
-
-    TIME && console.timeEnd("generateReligions");
-
-    // growth algorithm to assign cells to religions
-    function expandReligions() {
-      const queue = new PriorityQueue({comparator: (a, b) => a.p - b.p});
-      const cost = [];
-
-      religions
-        .filter(r => !r.lock && (r.type === "Organized" || r.type === "Cult"))
-        .forEach(r => {
-          religionIds[r.center] = r.i;
-          queue.queue({e: r.center, p: 0, r: r.i, s: cells.state[r.center], c: r.culture});
-          cost[r.center] = 1;
-        });
-
-      const neutral = (cells.i.length / 5000) * 200 * gauss(1, 0.3, 0.2, 2, 2) * neutralInput.value; // limit cost for organized religions growth
-      const popCost = d3.max(cells.pop) / 3; // enougth population to spered religion without penalty
-
-      while (queue.length) {
-        const {e, p, r, c, s} = queue.dequeue();
-        const expansion = religions[r].expansion;
-
-        cells.c[e].forEach(nextCell => {
-          if (expansion === "culture" && c !== cells.culture[nextCell]) return;
-          if (expansion === "state" && s !== cells.state[nextCell]) return;
-          if (religions[religionIds[nextCell]]?.lock) return;
-
-          const cultureCost = c !== cells.culture[nextCell] ? 10 : 0;
-          const stateCost = s !== cells.state[nextCell] ? 10 : 0;
-          const biomeCost = cells.road[nextCell] ? 1 : biomesData.cost[cells.biome[nextCell]];
-          const populationCost = Math.max(rn(popCost - cells.pop[nextCell]), 0);
-          const heightCost = Math.max(cells.h[nextCell], 20) - 20;
-          const waterCost = cells.h[nextCell] < 20 ? (cells.road[nextCell] ? 50 : 1000) : 0;
-          const totalCost =
-            p +
-            (cultureCost + stateCost + biomeCost + populationCost + heightCost + waterCost) / religions[r].expansionism;
-          if (totalCost > neutral) return;
-
-          if (!cost[nextCell] || totalCost < cost[nextCell]) {
-            if (cells.h[nextCell] >= 20 && cells.culture[nextCell]) religionIds[nextCell] = r; // assign religion to cell
-            cost[nextCell] = totalCost;
-            queue.queue({e: nextCell, p: totalCost, r, c, s});
-          }
-        });
-      }
     }
 
-    // growth algorithm to assign cells to heresies
-    function expandHeresies() {
-      const queue = new PriorityQueue({comparator: (a, b) => a.p - b.p});
-      const cost = [];
+    return religionIds;
 
-      religions
-        .filter(r => !r.lock && r.type === "Heresy")
-        .forEach(r => {
-          const b = religionIds[r.center]; // "base" religion id
-          religionIds[r.center] = r.i; // heresy id
-          queue.queue({e: r.center, p: 0, r: r.i, b});
-          cost[r.center] = 1;
-        });
-
-      const neutral = (cells.i.length / 5000) * 500 * neutralInput.value; // limit cost for heresies growth
-
-      while (queue.length) {
-        const {e, p, r, b} = queue.dequeue();
-
-        cells.c[e].forEach(nextCell => {
-          if (religions[religionIds[nextCell]]?.lock) return;
-          const religionCost = religionIds[nextCell] === b ? 0 : 2000;
-          const biomeCost = cells.road[nextCell] ? 0 : biomesData.cost[cells.biome[nextCell]];
-          const heightCost = Math.max(cells.h[nextCell], 20) - 20;
-          const waterCost = cells.h[nextCell] < 20 ? (cells.road[nextCell] ? 50 : 1000) : 0;
-          const totalCost =
-            p + (religionCost + biomeCost + heightCost + waterCost) / Math.max(religions[r].expansionism, 0.1);
-
-          if (totalCost > neutral) return;
-
-          if (!cost[nextCell] || totalCost < cost[nextCell]) {
-            if (cells.h[nextCell] >= 20 && cells.culture[nextCell]) religionIds[nextCell] = r; // assign religion to cell
-            cost[nextCell] = totalCost;
-            queue.queue({e: nextCell, p: totalCost, r});
-          }
-        });
-      }
+    function getPassageCost(cellId) {
+      if (isWater(cellId)) return isSeaRoute ? 50 : 500; // was 50 : 1000
+      if (isMainRoad(cellId)) return 1;
+      const biomeCost = biomePassageCost(cellId);
+      return (isTrail(cellId)) ? biomeCost / 1.5 : biomeCost; // was same as main road
     }
+  }
+
+  // folk religions initially get all cells of their culture
+  function spreadFolkReligions(religions) {
+    const religionIds = new Uint16Array(cells.i.length);
+
+    const folkReligions = religions.filter(({type}) => type === "Folk");
+    const cultureToReligionMap = new Map(folkReligions.map(({i, culture}) => [culture, i]));
+
+    for (const cellId of cells.i) {
+      const cultureId = cells.culture[cellId];
+      religionIds[cellId] = cultureToReligionMap.get(cultureId) || 0;
+    }
+
+    return religionIds;
+  }
 
     function checkCenters() {
       const codes = religions.map(r => r.code);
@@ -663,7 +690,6 @@ window.Religions = (function () {
         if (firstCell) r.center = firstCell; // move center, othervise it's an extinct religion
       });
     }
-  };
 
   const add = function (center) {
     const {cells, religions} = pack;
@@ -676,10 +702,10 @@ window.Religions = (function () {
       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" ? null : getDeityName(culture);
+      type === "Heresy" ? religions[religionId].deity : form === "Non-theism" ? null : generateDeityName(culture);
 
     let name, expansion;
-    if (type === "Organized") [name, expansion] = getReligionName(form, deity, center);
+    if (type === "Organized") [name, expansion] = generateReligionName(form, deity, center);
     else {
       name = getCultName(form, center);
       expansion = "global";
@@ -721,7 +747,7 @@ window.Religions = (function () {
   }
 
   // get supreme deity name
-  const getDeityName = function (culture) {
+  const generateDeityName = function (culture) {
     if (culture === undefined) {
       ERROR && console.error("Please define a culture");
       return;
@@ -736,22 +762,24 @@ window.Religions = (function () {
     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 === "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);
+      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);
+      return `${ra(base.adjective)} ${ra(base.animal)} of ${ra(base.genitive)}`;
+
+    ERROR && console.error("Unkown generation approach");
   }
 
-  function getReligionName(form, deity, center) {
+  function generateReligionName(form, deity, center) {
     const {cells, cultures, burgs, states} = pack;
 
     const random = () => Names.getCulture(cells.culture[center], null, null, "", 0);
@@ -767,7 +795,7 @@ window.Religions = (function () {
       return adj ? getAdjective(name) : name;
     };
 
-    const m = rw(methods);
+    const m = rw(namingMethods);
     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"];
@@ -777,24 +805,11 @@ window.Religions = (function () {
     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()}`, "global"];
     return [trimVowels(random()) + "ism", "global"]; // else
   }
 
-  function getCultName(form, center) {
-    const cells = pack.cells;
-    const type = function () {
-      return rw(types[form]);
-    };
-    const random = function () {
-      return trimVowels(Names.getCulture(cells.culture[center], null, null, "", 0).split(/[ ,]+/)[0]);
-    };
-    const burg = function () {
-      return trimVowels(pack.burgs[cells.burg[center]].name.split(/[ ,]+/)[0]);
-    };
-    if (cells.burg[center]) return burg() + "ian " + type();
-    if (Math.random() > 0.5) return random() + "ian " + type();
-    return type() + " of the " + generateMeaning();
-  }
-
-  return {generate, add, getDeityName, updateCultures};
+  return {generate, add, getDeityName: generateDeityName, updateCultures};
 })();

From 85f639954e7d811080e4522aedb5f83ae3ea9e45 Mon Sep 17 00:00:00 2001
From: Canis Artorus <acjames148@gmail.com>
Date: Thu, 2 Mar 2023 16:34:35 -0700
Subject: [PATCH 5/7] Prepare to lock - Further refactor

---
 modules/religions-generator.js | 205 ++++++++++++++++++++-------------
 1 file changed, 122 insertions(+), 83 deletions(-)

diff --git a/modules/religions-generator.js b/modules/religions-generator.js
index 13d03585..65a7380a 100644
--- a/modules/religions-generator.js
+++ b/modules/religions-generator.js
@@ -360,16 +360,25 @@ window.Religions = (function () {
       Society: 1
     }
   };
+  const expansionismMap = {
+    Folk: () => 0,
+    Organized: () => gauss(5, 3, 0, 10, 1), // was rand(3, 8)
+    Cult: () => gauss(0.5, 0.5, 0, 5, 1), // was gauss(1.1, 0.5, 0, 5)
+    Heresy: () => gauss(1, 0.5, 0, 5, 1) // was gauss(1.2, 0.5, 0, 5)
+  };
 
   function generate() {
     TIME && console.time("generateReligions");
     // const {cells, states, cultures, burgs} = pack;
 
     const folkReligions = generateFolkReligions();
-    const {lockedReligions, lockedReligionCount} = restoreLockedReligions();
+    const {lockedReligions, lockedReligionCount} = saveLockedReligions();
     const basicReligions = generateOrganizedReligions(+religionsInput.value, lockedReligionCount);
 
-    const {religions, religionIds} = specifyReligions([...folkReligions, ...basicReligions], lockedReligions);
+    const namedReligions = specifyReligions([...folkReligions, ...basicReligions]);
+    const indexedReligions = combineReligions(namedReligions, lockedReligions);
+    const religionIds = expandReligions(indexedReligions);
+    const religions = defineOrigins(religionIds, indexedReligions);
     
     pack.religions = religions;
     pack.cells.religion = religionIds;
@@ -386,9 +395,10 @@ window.Religions = (function () {
     });
   }
 
-  function restoreLockedReligions() {
-    //TODO
-    return {lockedReligions: [], lockedReligionCount: 0};
+  function saveLockedReligions() {
+    const lockedReligions = pack.religions?.filter(religion => religion.locked && !religion.removed) || [];
+    const lockedReligionCount = lockedReligions.filter(({type}) => type !== "Folk").length || 0;
+    return {lockedReligions, lockedReligionCount};
   }
 
   function generateOrganizedReligions(desiredReligionNumber, lockedReligionCount) {
@@ -450,113 +460,145 @@ window.Religions = (function () {
     }
   }
 
-  function specifyReligions(newReligions, lockedReligions) {
+  function specifyReligions(newReligions) {
     const {cells, cultures} = pack;
 
-    const expansionismMap = {
-      Folk: () => 0,
-      Organized: () => gauss(5, 3, 0, 10, 1), // was rand(3, 8)
-      Cult: () => gauss(0.5, 0.5, 0, 5, 1), // was gauss(1.1, 0.5, 0, 5)
-      Heresy: () => gauss(1, 0.5, 0, 5, 1) // was gauss(1.2, 0.5, 0, 5)
-    };
-    const religionOriginsParamsMap = {
-      Organized: {clusterSize: 100, maxReligions: 2}, // was 150/count, 2
-      Cult: {clusterSize: 50, maxReligions: 3}, // was 300/count, rand(0,4)
-      Heresy: {clusterSize: 50, maxReligions: 4}
-    };
-    
-    const rawReligions = newReligions.map(({type, form, culture: cultureId, center}, index) => {
-      const supreme = generateDeityName(cultures[cultureId]);
+    const rawReligions = newReligions.map(({type, form, culture: cultureId, center}) => {
+      const supreme = getDeityName(cultures[cultureId]);
       const deity = form === "Non-theism" || form === "Animism" ? null : supreme;
 
       const stateId = cells.state[center];
 
-      let {name, expansion} = generateReligionName(form, supreme, center);
+      let {name, expansion} = generateReligionName(type, form, supreme, center);
       if (expansion === "state" && !stateId) expansion = "global";
 
       const expansionism = expansionismMap[type]();
 
       const color = getReligionColor(cultures[cultureId], type);
 
-      return {i: index + 1, name, type, form, culture: cultureId, center, deity, expansion, expansionism, color};
+      return {name, type, form, culture: cultureId, center, deity, expansion, expansionism, color};
     });
 
-    const religionIds = expandReligions(rawReligions);
-    const names = renameOldReligions(rawReligions);
-    const origins = defineOrigins(religionIds, rawReligions, cells.c);
+    return rawReligions;
 
-    return {religions: combineReligionsData(), religionIds};
+    // const religionIds = expandReligions(rawReligions);
+    // const names = renameOldReligions(rawReligions);
+    // const origins = defineOrigins(religionIds, rawReligions, cells.c);
+
+    // return {religions: combineReligionsData(), religionIds};
 
     function getReligionColor(culture, type) {
-      if (!culture.i) throw new Error(`Culture ${culture.i} is not a valid culture`);
+      if (!culture.i) ERROR && console.error(`Culture ${culture.i} is not a valid culture`);
 
       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);
     }
+  }
 
-    function combineReligionsData() {
-      const noReligion = {i: 0, name: "No religion"};
+  // indexes, conditionally renames, and abbreviates religions
+  function combineReligions(namedReligions, lockedReligions) {
+    const noReligion = {i: 0, name: "No religion"};
+    const indexedReligions = [noReligion];
 
-      const religions = rawReligions.map((religion, index) => ({
-        ...religion,
-        name: names[index],
-        origins: origins[index]
-      }));
+    const {lockedReligionQueue, highestLockedIndex, codes} = parseLockedReligions();
+    const maxIndex = Math.max(highestLockedIndex, namedReligions.length + lockedReligions.length + 1);
+    for (let index = 1, progress = 0; index < maxIndex; index++) {
+      if (index === lockedReligionQueue[0]?.i) {
+        const nextReligion = lockedReligionQueue.shift();
+        indexedReligions.push(nextReligion);
+        continue;
+      }
+      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
 
-      return [noReligion, ...religions];
+        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, name: "Padding", removed: true});
+    }
+    return indexedReligions;
+
+    function parseLockedReligions() {
+      const lockedReligionQueue = lockedReligions.map(r => r).sort((a, b) => a.i - b.i);
+      const highestLockedIndex = lockedReligionQueue[-1]?.i;
+
+      const codes = lockedReligions.length > 0 ? lockedReligions.map(r => r.code) : [];
+
+      return {lockedReligionQueue, highestLockedIndex, codes};
     }
 
     // prepend 'Old' to names of folk religions which have organized competitors
-    function renameOldReligions(rawReligions) {
-      return rawReligions.map(({name, type, culture: cultureId}) => {
-        if (type !== "Folk") return name;
-
-        const haveOrganized = rawReligions.some(({type, culture, expansion}) => culture === cultureId && type === "Organized" && expansion === "culture");
-        if (haveOrganized && name.slice(0, 3) !== "Old") return `Old ${name}`;
-        return name;
-      });
+    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;
     }
+  }
 
-    function defineOrigins(religionIds, rawReligions, neighbors) {
-      return rawReligions.map(religion => {
-        if (religion.type === "Folk") return [0];
+  // finally generate origins tree
+  function defineOrigins(religionIds, indexedReligions) {
+    const religionOriginsParamsMap = {
+      Organized: {clusterSize: 100, maxReligions: 2}, // was 150/count, 2
+      Cult: {clusterSize: 50, maxReligions: 3}, // was 300/count, rand(0,4)
+      Heresy: {clusterSize: 50, maxReligions: 4}
+    };
 
-        const {i, type, culture: cultureId, expansion, center} = religion;
+    const origins = indexedReligions.map((religion, index) => {
+      if (religion.type === "Folk") return [0];
+      if (index === 0) return null;
 
-        const folkReligion = rawReligions.find(({culture, type}) => type === "Folk" && culture === cultureId);
-        const isFolkBased = folkReligion && cultureId && expansion === "culture" && each(2)(center); // P(0.5) -> isEven cellId
+      const {i, type, culture: cultureId, expansion, center} = religion;
 
-        if (isFolkBased) return [folkReligion.i];
+      const folkReligion = indexedReligions.find(({culture, type}) => type === "Folk" && culture === cultureId);
+      const isFolkBased = folkReligion && cultureId && expansion === "culture" && each(2)(center); // P(0.5) -> isEven cellId
 
-        const {clusterSize, maxReligions} = religionOriginsParamsMap[type];
-        const origins = getReligionsInRadius(neighbors, center, religionIds, i, clusterSize, maxReligions);
-        return origins;
-      });
-    }
+      if (isFolkBased) return [folkReligion.i];
 
-    function getReligionsInRadius(neighbors, center, religionIds, religionId, clusterSize, maxReligions) {
-      const foundReligions = new Set();
-      const queue = [center];
-      const checked = {};
+      const {clusterSize, maxReligions} = religionOriginsParamsMap[type];
+      const origins = getReligionsInRadius(pack.cells.c, center, religionIds, i, clusterSize, maxReligions);
+      if (origins === [0]) return [folkReligion.i]; // hegemony has local roots
+      return origins;
+    });
 
-      for (let size = 0; queue.length && size < clusterSize; size++) {
-        const cellId = queue.pop();
-        checked[cellId] = true;
+    return indexedReligions.map((religion, index) => ({
+      ...religion,
+      origins: origins[index]
+    }));
+  }
 
-        for (const neibId of neighbors[cellId]) {
-          if (checked[neibId]) continue;
-          checked[neibId] = true;
+  function getReligionsInRadius(neighbors, center, religionIds, religionId, clusterSize, maxReligions) {
+    const foundReligions = new Set();
+    const queue = [center];
+    const checked = {};
 
-          const neibReligion = religionIds[neibId];
-          if (neibReligion && neibReligion !== religionId) foundReligions.add(neibReligion);
-          queue.push(neibId);
-        }
+    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);
+        queue.push(neibId);
       }
-
-      return foundReligions.size ? [...foundReligions].slice(0, maxReligions) : [0];
     }
+
+    return foundReligions.size ? [...foundReligions].slice(0, maxReligions) : [0];
   }
 
 /*
@@ -671,6 +713,8 @@ window.Religions = (function () {
     const cultureToReligionMap = new Map(folkReligions.map(({i, culture}) => [culture, i]));
 
     for (const cellId of cells.i) {
+      const oldId = cells.religion[cellId];
+      // TODO locked
       const cultureId = cells.culture[cellId];
       religionIds[cellId] = cultureToReligionMap.get(cultureId) || 0;
     }
@@ -702,14 +746,9 @@ window.Religions = (function () {
       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" ? null : generateDeityName(culture);
+      type === "Heresy" ? religions[religionId].deity : form === "Non-theism" ? null : getDeityName(culture);
 
-    let name, expansion;
-    if (type === "Organized") [name, expansion] = generateReligionName(form, deity, center);
-    else {
-      name = getCultName(form, center);
-      expansion = "global";
-    }
+    const {name, expansion} = generateReligionName(type, form, deity, center);
 
     const formName = type === "Heresy" ? religions[religionId].form : form;
     const code = abbreviate(
@@ -727,7 +766,7 @@ window.Religions = (function () {
       form: formName,
       deity,
       expansion,
-      expansionism: 0,
+      expansionism: expansionismMap[type](),
       center,
       cells: 0,
       area: 0,
@@ -747,7 +786,7 @@ window.Religions = (function () {
   }
 
   // get supreme deity name
-  const generateDeityName = function (culture) {
+  const getDeityName = function (culture) {
     if (culture === undefined) {
       ERROR && console.error("Please define a culture");
       return;
@@ -779,7 +818,7 @@ window.Religions = (function () {
     ERROR && console.error("Unkown generation approach");
   }
 
-  function generateReligionName(form, deity, center) {
+  function generateReligionName(variety, form, deity, center) {
     const {cells, cultures, burgs, states} = pack;
 
     const random = () => Names.getCulture(cells.culture[center], null, null, "", 0);
@@ -795,7 +834,7 @@ window.Religions = (function () {
       return adj ? getAdjective(name) : name;
     };
 
-    const m = rw(namingMethods);
+    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"];
@@ -811,5 +850,5 @@ window.Religions = (function () {
     return [trimVowels(random()) + "ism", "global"]; // else
   }
 
-  return {generate, add, getDeityName: generateDeityName, updateCultures};
+  return {generate, add, getDeityName, updateCultures};
 })();

From 3b90b62219401af9b8ecdc7a6929a893e4ec24bf Mon Sep 17 00:00:00 2001
From: Canis Artorus <acjames148@gmail.com>
Date: Thu, 2 Mar 2023 17:45:05 -0700
Subject: [PATCH 6/7] Complete locked religions functionality

---
 modules/religions-generator.js | 94 ++++++++++------------------------
 1 file changed, 26 insertions(+), 68 deletions(-)

diff --git a/modules/religions-generator.js b/modules/religions-generator.js
index 65a7380a..e26389f8 100644
--- a/modules/religions-generator.js
+++ b/modules/religions-generator.js
@@ -371,9 +371,10 @@ window.Religions = (function () {
     TIME && console.time("generateReligions");
     // const {cells, states, cultures, burgs} = pack;
 
+    const lockedReligions = pack.religions?.filter(religion => religion.locked && !religion.removed) || [];
+
     const folkReligions = generateFolkReligions();
-    const {lockedReligions, lockedReligionCount} = saveLockedReligions();
-    const basicReligions = generateOrganizedReligions(+religionsInput.value, lockedReligionCount);
+    const basicReligions = generateOrganizedReligions(+religionsInput.value, lockedReligions);
 
     const namedReligions = specifyReligions([...folkReligions, ...basicReligions]);
     const indexedReligions = combineReligions(namedReligions, lockedReligions);
@@ -395,13 +396,8 @@ window.Religions = (function () {
     });
   }
 
-  function saveLockedReligions() {
-    const lockedReligions = pack.religions?.filter(religion => religion.locked && !religion.removed) || [];
+  function generateOrganizedReligions(desiredReligionNumber, lockedReligions) {
     const lockedReligionCount = lockedReligions.filter(({type}) => type !== "Folk").length || 0;
-    return {lockedReligions, lockedReligionCount};
-  }
-
-  function generateOrganizedReligions(desiredReligionNumber, lockedReligionCount) {
     const requiredReligionsNumber = desiredReligionNumber - lockedReligionCount;
     if (requiredReligionsNumber < 1) return [];
 
@@ -431,7 +427,7 @@ window.Religions = (function () {
       const religionsTree = d3.quadtree();
 
       // pre-populate with locked centers
-      // TODO
+      lockedReligions.forEach(({center}) => religionsTree.add(cells.p[center]));
 
       // min distance between religion inceptions
       const spacing = (graphWidth + graphHeight) / 2 / desiredReligionNumber; // was major gauss(1,0.3, 0.2,2, 2) / 6; cult gauss(2,0.3, 1,3, 2) /6; heresy /60
@@ -481,12 +477,6 @@ window.Religions = (function () {
 
     return rawReligions;
 
-    // const religionIds = expandReligions(rawReligions);
-    // const names = renameOldReligions(rawReligions);
-    // const origins = defineOrigins(religionIds, rawReligions, cells.c);
-
-    // return {religions: combineReligionsData(), religionIds};
-
     function getReligionColor(culture, type) {
       if (!culture.i) ERROR && console.error(`Culture ${culture.i} is not a valid culture`);
 
@@ -504,12 +494,15 @@ window.Religions = (function () {
 
     const {lockedReligionQueue, highestLockedIndex, codes} = parseLockedReligions();
     const maxIndex = Math.max(highestLockedIndex, namedReligions.length + lockedReligions.length + 1);
+
     for (let index = 1, progress = 0; index < maxIndex; index++) {
+      // 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++;
@@ -529,7 +522,7 @@ window.Religions = (function () {
 
     function parseLockedReligions() {
       const lockedReligionQueue = lockedReligions.map(r => r).sort((a, b) => a.i - b.i);
-      const highestLockedIndex = lockedReligionQueue[-1]?.i;
+      const highestLockedIndex = Math.max(lockedReligions.map(r => r.i));
 
       const codes = lockedReligions.length > 0 ? lockedReligions.map(r => r.code) : [];
 
@@ -548,7 +541,7 @@ window.Religions = (function () {
     }
   }
 
-  // finally generate origins tree
+  // finally generate and stores origins trees
   function defineOrigins(religionIds, indexedReligions) {
     const religionOriginsParamsMap = {
       Organized: {clusterSize: 100, maxReligions: 2}, // was 150/count, 2
@@ -569,6 +562,7 @@ window.Religions = (function () {
 
       const {clusterSize, maxReligions} = religionOriginsParamsMap[type];
       const origins = getReligionsInRadius(pack.cells.c, center, religionIds, i, clusterSize, maxReligions);
+
       if (origins === [0]) return [folkReligion.i]; // hegemony has local roots
       return origins;
     });
@@ -601,58 +595,20 @@ window.Religions = (function () {
     return foundReligions.size ? [...foundReligions].slice(0, maxReligions) : [0];
   }
 
-/*
-    // add folk religions
-    cultures.forEach(c => {
-      if (!c.i) return religions.push({i: 0, name: "No religion"});
-
-      if (pack.religions) {
-        const lockedFolkReligion = pack.religions.find(
-          r => r.culture === c.i && !r.removed && r.lock && r.type === "Folk"
-        );
-
-        if (lockedFolkReligion) {
-          for (const i of cells.i) {
-            if (cells.religion[i] === lockedFolkReligion.i) religionIds[i] = newId;
-          }
-
-          lockedFolkReligion.i = newId;
-          religions.push(lockedFolkReligion);
-          return;
-        }
-      }
-
-    });
-
-    // restore locked non-folk religions
-    if (pack.religions) {
-      const lockedNonFolkReligions = pack.religions.filter(r => r.lock && !r.removed && r.type !== "Folk");
-      for (const religion of lockedNonFolkReligions) {
-        const newId = religions.length;
-        for (const i of cells.i) {
-          if (cells.religion[i] === religion.i) religionIds[i] = newId;
-        }
-
-        religion.i = newId;
-        religion.origins = religion.origins.filter(origin => origin < newId);
-        religionsTree.add(cells.p[religion.center]);
-        religions.push(religion);
-      }
-    }
-*/
   // growth algorithm to assign cells to religions
   function expandReligions(religions) {
+    const cells = pack.cells;
     const religionIds = spreadFolkReligions(religions);
 
     const queue = new PriorityQueue({comparator: (a, b) => a.p - b.p});
     const cost = [];
 
-    const maxExpansionCost = (cells.i.length / 20) * gauss(1, 0.3, 0.2, 2, 2) * neutralInput.value; // limit cost for organized religions growth (was /25)
+    const maxExpansionCost = (cells.i.length / 20) * gauss(1, 0.3, 0.2, 2, 2) * neutralInput.value; // limit cost for organized religions growth (was /25, heresy /10)
 
     const biomePassageCost = (cellId) => biomesData.cost[cells.biome[cellId]];
 
     religions
-      .filter(r => r.i && !r.lock && r.type !== "Folk")
+      .filter(r => r.i && !r.lock && r.type !== "Folk" && !r.removed)
       .forEach(r => {
         religionIds[r.center] = r.i;
         queue.queue({e: r.center, p: 0, r: r.i, s: cells.state[r.center]});
@@ -662,9 +618,9 @@ window.Religions = (function () {
     const religionsMap = new Map(religions.map(r => [r.i, r]));
 
     const isMainRoad = (cellId) => (cells.road[cellId] - cells.crossroad[cellId]) > 4;
-    const isTrail = (cellId) => cells.h > 19 && (cells.road[cellId] - cells.crossroad[cellId]) === 1;
-    const isSeaRoute = (cellId) => cells.h < 20 && cells.road;
-    const isWater = (cellId) => cells.h < 20;
+    const isTrail = (cellId) => cells.h[cellId] > 19 && (cells.road[cellId] - cells.crossroad[cellId]) === 1;
+    const isSeaRoute = (cellId) => cells.h[cellId] < 20 && cells.road[cellId];
+    const isWater = (cellId) => cells.h[cellId] < 20;
     // const popCost = d3.max(cells.pop) / 3; // enougth population to spered religion without penalty
 
     while (queue.length) {
@@ -705,16 +661,19 @@ window.Religions = (function () {
     }
   }
 
-  // folk religions initially get all cells of their culture
+  // folk religions initially get all cells of their culture, and locked religions are retained
   function spreadFolkReligions(religions) {
     const religionIds = new Uint16Array(cells.i.length);
 
-    const folkReligions = religions.filter(({type}) => type === "Folk");
+    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 = cells.religion[cellId];
-      // TODO locked
+      const oldId = 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;
     }
@@ -723,15 +682,14 @@ window.Religions = (function () {
   }
 
     function checkCenters() {
-      const codes = religions.map(r => r.code);
       religions.forEach(r => {
         if (!r.i) return;
-        r.code = abbreviate(r.name, codes);
-
         // move religion center if it's not within religion area after expansion
         if (religionIds[r.center] === r.i) return; // in area
         const firstCell = cells.i.find(i => religionIds[i] === r.i);
+        const cultureHome = pack.cultures[r.culture]?.center;
         if (firstCell) r.center = firstCell; // move center, othervise it's an extinct religion
+        else if (type === "Folk" && cultureHome) r.center = cultureHome;
       });
     }
 

From 0f6c1fdde0e9d90bd5321f0d77919614f2bd4e29 Mon Sep 17 00:00:00 2001
From: Canis Artorus <acjames148@gmail.com>
Date: Thu, 2 Mar 2023 18:16:04 -0700
Subject: [PATCH 7/7] Prepare for live updates

---
 modules/religions-generator.js | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/modules/religions-generator.js b/modules/religions-generator.js
index e26389f8..1e85b11d 100644
--- a/modules/religions-generator.js
+++ b/modules/religions-generator.js
@@ -360,6 +360,7 @@ window.Religions = (function () {
       Society: 1
     }
   };
+
   const expansionismMap = {
     Folk: () => 0,
     Organized: () => gauss(5, 3, 0, 10, 1), // was rand(3, 8)
@@ -460,7 +461,7 @@ window.Religions = (function () {
     const {cells, cultures} = pack;
 
     const rawReligions = newReligions.map(({type, form, culture: cultureId, center}) => {
-      const supreme = getDeityName(cultures[cultureId]);
+      const supreme = getDeityName(cultureId);
       const deity = form === "Non-theism" || form === "Animism" ? null : supreme;
 
       const stateId = cells.state[center];
@@ -693,18 +694,28 @@ window.Religions = (function () {
       });
     }
 
+  function recalculate() {
+    const newReligionIds = expandReligions(pack.religions);
+    pack.cells.religion = newReligionIds;
+  }
+
   const add = function (center) {
     const {cells, religions} = pack;
     const religionId = cells.religion[center];
 
-    const culture = cells.culture[center];
+    const cultureId = cells.culture[center];
     const color = getMixedColor(religions[religionId].color, 0.3, 0);
+    const missingFolk = !religions.some(({type, culture}) => type === "Folk" && culture === cultureId);
 
     const type =
-      religions[religionId].type === "Organized" ? rw({Organized: 4, Cult: 1, Heresy: 2}) : rw({Organized: 5, Cult: 2});
+      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" ? null : getDeityName(culture);
+      type === "Heresy" ? religions[religionId].deity : 
+      (form === "Non-theism" || form === "Animism") ? null 
+      : getDeityName(cultureId);
 
     const {name, expansion} = generateReligionName(type, form, deity, center);
 
@@ -713,13 +724,15 @@ window.Religions = (function () {
       name,
       religions.map(r => r.code)
     );
+    const influences = getReligionsInRadius(cells.c, center, cells.religion, 0, 25, 3);
+    const origins = type === "Folk" ? [0] : influences;
 
     const i = religions.length;
     religions.push({
       i,
       name,
       color,
-      culture,
+      culture: cultureId,
       type,
       form: formName,
       deity,
@@ -730,7 +743,7 @@ window.Religions = (function () {
       area: 0,
       rural: 0,
       urban: 0,
-      origins: [religionId],
+      origins,
       code
     });
     cells.religion[center] = i;
@@ -808,5 +821,5 @@ window.Religions = (function () {
     return [trimVowels(random()) + "ism", "global"]; // else
   }
 
-  return {generate, add, getDeityName, updateCultures};
+  return {generate, add, getDeityName, updateCultures, recalculate};
 })();
