chore: modularize main.js

src/modules/zones.js

@@ -0,0 +1,451 @@
+import FlatQueue from "flatqueue";
+
+import {TIME} from "config/logging";
+import {findCell, getPackPolygon} from "utils/graphUtils";
+import {getAdjective} from "utils/languageUtils";
+import {rn} from "utils/numberUtils";
+import {P, ra, rand, rw} from "utils/probabilityUtils";
+import {byId} from "utils/shorthands";
+
+// generate zones
+export function addZones(number = 1) {
+  TIME && console.time("addZones");
+  const {cells, states, burgs} = pack;
+  const used = new Uint8Array(cells.i.length); // to store used cells
+  const zonesData = [];
+  const randomize = modifier => rn(Math.random() * modifier * number);
+
+  for (let i = 0; i < randomize(1.8); i++) addInvasion(); // invasion of enemy lands
+  for (let i = 0; i < randomize(1.6); i++) addRebels(); // rebels along a state border
+  for (let i = 0; i < randomize(1.6); i++) addProselytism(); // proselitism of organized religion
+  for (let i = 0; i < randomize(1.6); i++) addCrusade(); // crusade on heresy lands
+  for (let i = 0; i < randomize(1.8); i++) addDisease(); // disease starting in a random city
+  for (let i = 0; i < randomize(1.4); i++) addDisaster(); // disaster starting in a random city
+  for (let i = 0; i < randomize(1.4); i++) addEruption(); // volcanic eruption aroung volcano
+  for (let i = 0; i < randomize(1.0); i++) addAvalanche(); // avalanche impacting highland road
+  for (let i = 0; i < randomize(1.4); i++) addFault(); // fault line in elevated areas
+  for (let i = 0; i < randomize(1.4); i++) addFlood(); // flood on river banks
+  for (let i = 0; i < randomize(1.2); i++) addTsunami(); // tsunami starting near coast
+
+  drawZones();
+
+  function addInvasion() {
+    const atWar = states.filter(s => s.diplomacy && s.diplomacy.some(d => d === "Enemy"));
+    if (!atWar.length) return;
+
+    const invader = ra(atWar);
+    const target = invader.diplomacy.findIndex(d => d === "Enemy");
+
+    const cell = ra(
+      cells.i.filter(i => cells.state[i] === target && cells.c[i].some(c => cells.state[c] === invader.i))
+    );
+    if (!cell) return;
+
+    const cellsArray = [],
+      queue = [cell],
+      power = rand(5, 30);
+
+    while (queue.length) {
+      const q = P(0.4) ? queue.shift() : queue.pop();
+      cellsArray.push(q);
+      if (cellsArray.length > power) break;
+
+      cells.c[q].forEach(e => {
+        if (used[e]) return;
+        if (cells.state[e] !== target) return;
+        used[e] = 1;
+        queue.push(e);
+      });
+    }
+
+    const invasion = rw({
+      Invasion: 4,
+      Occupation: 3,
+      Raid: 2,
+      Conquest: 2,
+      Subjugation: 1,
+      Foray: 1,
+      Skirmishes: 1,
+      Incursion: 2,
+      Pillaging: 1,
+      Intervention: 1
+    });
+    const name = getAdjective(invader.name) + " " + invasion;
+    zonesData.push({name, type: "Invasion", cells: cellsArray, fill: "url(#hatch1)"});
+  }
+
+  function addRebels() {
+    const state = ra(states.filter(s => s.i && !s.removed && s.neighbors.some(n => n)));
+    if (!state) return;
+
+    const neib = ra(state.neighbors.filter(n => n && !states[n].removed));
+    if (!neib) return;
+    const cell = cells.i.find(
+      i => cells.state[i] === state.i && !state.removed && cells.c[i].some(c => cells.state[c] === neib)
+    );
+    const cellsArray = [];
+    const queue = [];
+    if (cell) queue.push(cell);
+
+    const power = rand(10, 30);
+
+    while (queue.length) {
+      const q = queue.shift();
+      cellsArray.push(q);
+      if (cellsArray.length > power) break;
+
+      cells.c[q].forEach(e => {
+        if (used[e]) return;
+        if (cells.state[e] !== state.i) return;
+        used[e] = 1;
+        if (e % 4 !== 0 && !cells.c[e].some(c => cells.state[c] === neib)) return;
+        queue.push(e);
+      });
+    }
+
+    const rebels = rw({
+      Rebels: 5,
+      Insurgents: 2,
+      Mutineers: 1,
+      Rioters: 1,
+      Separatists: 1,
+      Secessionists: 1,
+      Insurrection: 2,
+      Rebellion: 1,
+      Conspiracy: 2
+    });
+    const name = getAdjective(states[neib].name) + " " + rebels;
+    zonesData.push({name, type: "Rebels", cells: cellsArray, fill: "url(#hatch3)"});
+  }
+
+  function addProselytism() {
+    const organized = ra(pack.religions.filter(r => r.type === "Organized"));
+    if (!organized) return;
+
+    const cell = ra(
+      cells.i.filter(
+        i =>
+          cells.religion[i] &&
+          cells.religion[i] !== organized.i &&
+          cells.c[i].some(c => cells.religion[c] === organized.i)
+      )
+    );
+    if (!cell) return;
+    const target = cells.religion[cell];
+    const cellsArray = [],
+      queue = [cell],
+      power = rand(10, 30);
+
+    while (queue.length) {
+      const q = queue.shift();
+      cellsArray.push(q);
+      if (cellsArray.length > power) break;
+
+      cells.c[q].forEach(e => {
+        if (used[e]) return;
+        if (cells.religion[e] !== target) return;
+        if (cells.h[e] < 20) return;
+        used[e] = 1;
+        //if (e%2 !== 0 && !cells.c[e].some(c => cells.state[c] === neib)) return;
+        queue.push(e);
+      });
+    }
+
+    const name = getAdjective(organized.name.split(" ")[0]) + " Proselytism";
+    zonesData.push({name, type: "Proselytism", cells: cellsArray, fill: "url(#hatch6)"});
+  }
+
+  function addCrusade() {
+    const heresy = ra(pack.religions.filter(r => r.type === "Heresy"));
+    if (!heresy) return;
+
+    const cellsArray = cells.i.filter(i => !used[i] && cells.religion[i] === heresy.i);
+    if (!cellsArray.length) return;
+    cellsArray.forEach(i => (used[i] = 1));
+
+    const name = getAdjective(heresy.name.split(" ")[0]) + " Crusade";
+    zonesData.push({name, type: "Crusade", cells: cellsArray, fill: "url(#hatch6)"});
+  }
+
+  function addDisease() {
+    const burg = ra(burgs.filter(b => !used[b.cell] && b.i && !b.removed)); // random burg
+    if (!burg) return;
+
+    const cellsArray = [];
+    const costs = [];
+    const power = rand(20, 37);
+
+    const queue = new FlatQueue();
+    queue.push(burg.cell, 0);
+
+    while (queue.length) {
+      const priority = queue.peekValue();
+      const next = queue.pop();
+
+      if (cells.burg[next] || cells.pop[next]) cellsArray.push(next);
+      used[next] = 1;
+
+      cells.c[next].forEach(neibCellId => {
+        const roadValue = cells.road[next];
+        const cost = roadValue ? Math.max(10 - roadValue, 1) : 100;
+        const totalPriority = priority + cost;
+        if (totalPriority > power) return;
+
+        if (!costs[neibCellId] || totalPriority < costs[neibCellId]) {
+          costs[neibCellId] = totalPriority;
+          queue.push(neibCellId, totalPriority);
+        }
+      });
+    }
+
+    const adjective = () =>
+      ra(["Great", "Silent", "Severe", "Blind", "Unknown", "Loud", "Deadly", "Burning", "Bloody", "Brutal", "Fatal"]);
+    const animal = () =>
+      ra([
+        "Ape",
+        "Bear",
+        "Boar",
+        "Cat",
+        "Cow",
+        "Dog",
+        "Pig",
+        "Fox",
+        "Bird",
+        "Horse",
+        "Rat",
+        "Raven",
+        "Sheep",
+        "Spider",
+        "Wolf"
+      ]);
+    const color = () =>
+      ra([
+        "Golden",
+        "White",
+        "Black",
+        "Red",
+        "Pink",
+        "Purple",
+        "Blue",
+        "Green",
+        "Yellow",
+        "Amber",
+        "Orange",
+        "Brown",
+        "Grey"
+      ]);
+
+    const type = rw({
+      Fever: 5,
+      Pestilence: 2,
+      Flu: 2,
+      Pox: 2,
+      Smallpox: 2,
+      Plague: 4,
+      Cholera: 2,
+      Dropsy: 1,
+      Leprosy: 2
+    });
+    const name = rw({[color()]: 4, [animal()]: 2, [adjective()]: 1}) + " " + type;
+    zonesData.push({name, type: "Disease", cells: cellsArray, fill: "url(#hatch12)"});
+  }
+
+  function addDisaster() {
+    const burg = ra(burgs.filter(b => !used[b.cell] && b.i && !b.removed)); // random burg
+    if (!burg) return;
+
+    const cellsArray = [];
+    const costs = [];
+    const power = rand(5, 25);
+
+    const queue = new FlatQueue();
+    queue.push(burg.cell, 0);
+
+    while (queue.length) {
+      const priority = queue.peekValue();
+      const next = queue.pop();
+
+      if (cells.burg[next] || cells.pop[next]) cellsArray.push(next);
+      used[next] = 1;
+
+      cells.c[next].forEach(neibCellId => {
+        const cost = rand(1, 10);
+        const totalPriority = priority + cost;
+        if (totalPriority > power) return;
+
+        if (!costs[neibCellId] || totalPriority < costs[neibCellId]) {
+          costs[neibCellId] = totalPriority;
+          queue.push(neibCellId, totalPriority);
+        }
+      });
+    }
+
+    const type = rw({Famine: 5, Dearth: 1, Drought: 3, Earthquake: 3, Tornadoes: 1, Wildfires: 1});
+    const name = getAdjective(burg.name) + " " + type;
+    zonesData.push({name, type: "Disaster", cells: cellsArray, fill: "url(#hatch5)"});
+  }
+
+  function addEruption() {
+    const volcano = byId("markers").querySelector("use[data-id='#marker_volcano']");
+    if (!volcano) return;
+
+    const x = +volcano.dataset.x,
+      y = +volcano.dataset.y,
+      cell = findCell(x, y);
+    const id = volcano.id;
+    const note = notes.filter(n => n.id === id);
+
+    if (note[0]) note[0].legend = note[0].legend.replace("Active volcano", "Erupting volcano");
+    const name = note[0] ? note[0].name.replace(" Volcano", "") + " Eruption" : "Volcano Eruption";
+
+    const cellsArray = [];
+    const queue = [cell];
+    const power = rand(10, 30);
+
+    while (queue.length) {
+      const q = P(0.5) ? queue.shift() : queue.pop();
+      cellsArray.push(q);
+      if (cellsArray.length > power) break;
+      cells.c[q].forEach(e => {
+        if (used[e] || cells.h[e] < 20) return;
+        used[e] = 1;
+        queue.push(e);
+      });
+    }
+
+    zonesData.push({name, type: "Disaster", cells: cellsArray, fill: "url(#hatch7)"});
+  }
+
+  function addAvalanche() {
+    const roads = cells.i.filter(i => !used[i] && cells.road[i] && cells.h[i] >= 70);
+    if (!roads.length) return;
+
+    const cell = +ra(roads);
+    const cellsArray = [];
+    const queue = [cell];
+    const power = rand(3, 15);
+
+    while (queue.length) {
+      const q = P(0.3) ? queue.shift() : queue.pop();
+      cellsArray.push(q);
+      if (cellsArray.length > power) break;
+      cells.c[q].forEach(e => {
+        if (used[e] || cells.h[e] < 65) return;
+        used[e] = 1;
+        queue.push(e);
+      });
+    }
+
+    const proper = getAdjective(Names.getCultureShort(cells.culture[cell]));
+    const name = proper + " Avalanche";
+    zonesData.push({name, type: "Disaster", cells: cellsArray, fill: "url(#hatch5)"});
+  }
+
+  function addFault() {
+    const elevated = cells.i.filter(i => !used[i] && cells.h[i] > 50 && cells.h[i] < 70);
+    if (!elevated.length) return;
+
+    const cell = ra(elevated);
+    const cellsArray = [];
+    const queue = [cell];
+    const power = rand(3, 15);
+
+    while (queue.length) {
+      const q = queue.pop();
+      if (cells.h[q] >= 20) cellsArray.push(q);
+      if (cellsArray.length > power) break;
+      cells.c[q].forEach(e => {
+        if (used[e] || cells.r[e]) return;
+        used[e] = 1;
+        queue.push(e);
+      });
+    }
+
+    const proper = getAdjective(Names.getCultureShort(cells.culture[cell]));
+    const name = proper + " Fault";
+    zonesData.push({name, type: "Disaster", cells: cellsArray, fill: "url(#hatch2)"});
+  }
+
+  function addFlood() {
+    const fl = cells.fl.filter(fl => fl),
+      meanFlux = d3.mean(fl),
+      maxFlux = d3.max(fl),
+      flux = (maxFlux - meanFlux) / 2 + meanFlux;
+    const rivers = cells.i.filter(
+      i => !used[i] && cells.h[i] < 50 && cells.r[i] && cells.fl[i] > flux && cells.burg[i]
+    );
+    if (!rivers.length) return;
+
+    const cell = +ra(rivers),
+      river = cells.r[cell];
+    const cellsArray = [];
+    const queue = [cell];
+    const power = rand(5, 30);
+
+    while (queue.length) {
+      const q = queue.pop();
+      cellsArray.push(q);
+      if (cellsArray.length > power) break;
+
+      cells.c[q].forEach(e => {
+        if (used[e] || cells.h[e] < 20 || cells.r[e] !== river || cells.h[e] > 50 || cells.fl[e] < meanFlux) return;
+        used[e] = 1;
+        queue.push(e);
+      });
+    }
+
+    const name = getAdjective(burgs[cells.burg[cell]].name) + " Flood";
+    zonesData.push({name, type: "Disaster", cells: cellsArray, fill: "url(#hatch13)"});
+  }
+
+  function addTsunami() {
+    const coastal = cells.i.filter(i => !used[i] && cells.t[i] === -1 && pack.features[cells.f[i]].type !== "lake");
+    if (!coastal.length) return;
+
+    const cell = +ra(coastal);
+    const cellsArray = [];
+    const queue = [cell];
+    const power = rand(10, 30);
+
+    while (queue.length) {
+      const q = queue.shift();
+      if (cells.t[q] === 1) cellsArray.push(q);
+      if (cellsArray.length > power) break;
+
+      cells.c[q].forEach(e => {
+        if (used[e]) return;
+        if (cells.t[e] > 2) return;
+        if (pack.features[cells.f[e]].type === "lake") return;
+        used[e] = 1;
+        queue.push(e);
+      });
+    }
+
+    const proper = getAdjective(Names.getCultureShort(cells.culture[cell]));
+    const name = proper + " Tsunami";
+    zonesData.push({name, type: "Disaster", cells: cellsArray, fill: "url(#hatch13)"});
+  }
+
+  function drawZones() {
+    zones
+      .selectAll("g")
+      .data(zonesData)
+      .enter()
+      .append("g")
+      .attr("id", (d, i) => "zone" + i)
+      .attr("data-description", d => d.name)
+      .attr("data-type", d => d.type)
+      .attr("data-cells", d => d.cells.join(","))
+      .attr("fill", d => d.fill)
+      .selectAll("polygon")
+      .data(d => d.cells)
+      .enter()
+      .append("polygon")
+      .attr("points", d => getPackPolygon(d))
+      .attr("id", function (d) {
+        return this.parentNode.id + "_" + d;
+      });
+  }
+
+  TIME && console.timeEnd("addZones");
+}