diff --git a/main.js b/main.js index 85edae18..4e05d8d4 100644 --- a/main.js +++ b/main.js @@ -545,7 +545,6 @@ function generate() { reGraph(); drawCoastline(); - elevateLakes(); Rivers.generate(); defineBiomes(); @@ -626,7 +625,7 @@ function calculateVoronoi(graph, points) { TIME && console.timeEnd("calculateDelaunay"); TIME && console.time("calculateVoronoi"); - const voronoi = Voronoi(delaunay, allPoints, n); + const voronoi = new Voronoi(delaunay, allPoints, n); graph.cells = voronoi.cells; graph.cells.i = n < 65535 ? Uint16Array.from(d3.range(n)) : Uint32Array.from(d3.range(n)); // array of indexes graph.vertices = voronoi.vertices; @@ -1137,22 +1136,6 @@ function reMarkFeatures() { TIME && console.timeEnd("reMarkFeatures"); } -// temporary elevate some lakes to resolve depressions and flux the water to form an open (exorheic) lake -function elevateLakes() { - if (templateInput.value === "Atoll") return; // no need for Atolls - TIME && console.time('elevateLakes'); - const cells = pack.cells, features = pack.features; - const maxCells = cells.i.length / 100; // size limit; let big lakes be closed (endorheic) - cells.i.forEach(i => { - if (cells.h[i] >= 20) return; - if (features[cells.f[i]].group !== "freshwater" || features[cells.f[i]].cells > maxCells) return; - cells.h[i] = 20; - //debug.append("circle").attr("cx", cells.p[i][0]).attr("cy", cells.p[i][1]).attr("r", .5).attr("fill", "blue"); - }); - - TIME && console.timeEnd('elevateLakes'); -} - // assign biome id for each cell function defineBiomes() { TIME && console.time("defineBiomes"); @@ -1160,7 +1143,6 @@ function defineBiomes() { cells.biome = new Uint8Array(cells.i.length); // biomes array for (const i of cells.i) { - if (f[cells.f[i]].group === "freshwater") cells.h[i] = 19; // de-elevate lakes; here to save some resources const t = temp[cells.g[i]]; // cell temperature const h = cells.h[i]; // cell height const m = h < 20 ? 0 : calculateMoisture(i); // cell moisture @@ -1718,11 +1700,7 @@ function addZones(number = 1) { function showStatistics() { const template = templateInput.value; const templateRandom = locked("template") ? "" : "(random)"; - - mapId = Date.now(); // unique map id is it's creation date number - mapHistory.push({seed, width:graphWidth, height:graphHeight, template, created:mapId}); - console.log(` - Seed: ${seed} + const stats = ` Seed: ${seed} Canvas size: ${graphWidth}x${graphHeight} Template: ${template} ${templateRandom} Points: ${grid.points.length} @@ -1733,7 +1711,11 @@ function showStatistics() { Burgs: ${pack.burgs.length-1} Religions: ${pack.religions.length-1} Culture set: ${culturesSet.selectedOptions[0].innerText} - Cultures: ${pack.cultures.length-1}`); + Cultures: ${pack.cultures.length-1}`; + + mapId = Date.now(); // unique map id is it's creation date number + mapHistory.push({seed, width:graphWidth, height:graphHeight, template, created:mapId}); + INFO && console.log(stats); } const regenerateMap = debounce(function() { diff --git a/modules/burgs-and-states.js b/modules/burgs-and-states.js index 6120c27a..4270870c 100644 --- a/modules/burgs-and-states.js +++ b/modules/burgs-and-states.js @@ -419,7 +419,7 @@ const hull = getHull(start, s.i, s.cells / 10); const points = [...hull].map(v => pack.vertices.p[v]); const delaunay = Delaunator.from(points); - const voronoi = Voronoi(delaunay, points, points.length); + const voronoi = new Voronoi(delaunay, points, points.length); const chain = connectCenters(voronoi.vertices, s.pole[1]); const relaxed = chain.map(i => voronoi.vertices.p[i]).filter((p, i) => i%15 === 0 || i+1 === chain.length); paths.push([s.i, relaxed]); diff --git a/modules/river-generator.js b/modules/river-generator.js index e0c5cdbe..2e6c5022 100644 --- a/modules/river-generator.js +++ b/modules/river-generator.js @@ -1,296 +1,376 @@ (function (global, factory) { - typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : - typeof define === 'function' && define.amd ? define(factory) : - (global.Rivers = factory()); + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global.Rivers = factory()); }(this, (function () {'use strict'; - const generate = function(changeHeights = true) { - TIME && console.time('generateRivers'); - Math.random = aleaPRNG(seed); - const cells = pack.cells, p = cells.p, features = pack.features; +const generate = function(changeHeights = true) { + TIME && console.time('generateRivers'); + Math.random = aleaPRNG(seed); + const cells = pack.cells, p = cells.p, features = pack.features; - // build distance field in cells from water (cells.t) - void function markupLand() { - const q = t => cells.i.filter(i => cells.t[i] === t); - for (let t = 2, queue = q(t); queue.length; t++, queue = q(t)) { - queue.forEach(i => cells.c[i].forEach(c => { - if (!cells.t[c]) cells.t[c] = t+1; - })); + // build distance field in cells from water (cells.t) + void function markupLand() { + const q = t => cells.i.filter(i => cells.t[i] === t); + for (let t = 2, queue = q(t); queue.length; t++, queue = q(t)) { + queue.forEach(i => cells.c[i].forEach(c => { + if (!cells.t[c]) cells.t[c] = t+1; + })); + } + }() + + // height with added t value to make map less depressed + const h = Array.from(cells.h) + .map((h, i) => h < 20 || cells.t[i] < 1 ? h : h + cells.t[i] / 100) + .map((h, i) => h < 20 || cells.t[i] < 1 ? h : h + d3.mean(cells.c[i].map(c => cells.t[c])) / 10000); + + resolveDepressions(h); + features.forEach(f => {delete f.river; delete f.flux; delete f.inlets}); + + const riversData = []; // rivers data + cells.fl = new Uint16Array(cells.i.length); // water flux array + cells.r = new Uint16Array(cells.i.length); // rivers array + cells.conf = new Uint8Array(cells.i.length); // confluences array + let riverNext = 1; // first river id is 1, not 0 + + void function drainWater() { + const land = cells.i.filter(i => h[i] >= 20).sort((a,b) => h[b] - h[a]); + const outlets = new Uint32Array(features.length); + // enumerate lake outlet positions + features.filter(f => f.type === "lake" && (f.group === "freshwater" || f.group === "frozen")).forEach(l => { + let outlet = 0; + if (l.shoreline) { + outlet = l.shoreline[d3.scan(l.shoreline, (a,b) => h[a] - h[b])]; + } else { // in case it got missed or deleted + WARN && console.warn('Re-scanning shoreline of a lake'); + const shallows = cells.i.filter(j => cells.t[j] === -1 && cells.f[j] === l.i); + let shoreline = []; + shallows.map(w => cells.c[w]).forEach(cList => cList.forEach(s => shoreline.push(s))); + outlet = shoreline[d3.scan(shoreline, (a,b) => h[a] - h[b])]; } - }() + outlets[l.i] = outlet; + delete l.shoreline // cleanup temp data once used + }); - // height with added t value to make map less depressed - const h = Array.from(cells.h) - .map((h, i) => h < 20 || cells.t[i] < 1 ? h : h + cells.t[i] / 100) - .map((h, i) => h < 20 || cells.t[i] < 1 ? h : h + d3.mean(cells.c[i].map(c => cells.t[c])) / 10000); - - resolveDepressions(h); - features.forEach(f => {delete f.river; delete f.flux;}); - - const riversData = []; // rivers data - cells.fl = new Uint16Array(cells.i.length); // water flux array - cells.r = new Uint16Array(cells.i.length); // rivers array - cells.conf = new Uint8Array(cells.i.length); // confluences array - let riverNext = 1; // first river id is 1, not 0 - - void function drainWater() { - const land = cells.i.filter(i => h[i] >= 20).sort((a,b) => h[b] - h[a]); - land.forEach(function(i) { - cells.fl[i] += grid.cells.prec[cells.g[i]]; // flux from precipitation - const x = p[i][0], y = p[i][1]; - - // near-border cell: pour out of the screen - if (cells.b[i]) { - if (cells.r[i]) { - const to = []; - const min = Math.min(y, graphHeight - y, x, graphWidth - x); - if (min === y) {to[0] = x; to[1] = 0;} else - if (min === graphHeight - y) {to[0] = x; to[1] = graphHeight;} else - if (min === x) {to[0] = 0; to[1] = y;} else - if (min === graphWidth - x) {to[0] = graphWidth; to[1] = y;} - riversData.push({river: cells.r[i], cell: i, x: to[0], y: to[1]}); - } - return; - } - - //const min = cells.c[i][d3.scan(cells.c[i], (a, b) => h[a] - h[b])]; // downhill cell - let min = cells.c[i][d3.scan(cells.c[i], (a, b) => h[a] - h[b])]; // downhill cell - - // allow only one river can flow through a lake - const cf = features[cells.f[i]]; // current cell feature - if (cf.river && cf.river !== cells.r[i]) { - cells.fl[i] = 0; - } - - if (cells.fl[i] < 30) { - if (h[min] >= 20) cells.fl[min] += cells.fl[i]; - return; // flux is too small to operate as river - } - - // Proclaim a new river - if (!cells.r[i]) { - cells.r[i] = riverNext; - riversData.push({river: riverNext, cell: i, x, y}); - riverNext++; - } - - if (cells.r[min]) { // downhill cell already has river assigned - if (cells.fl[min] < cells.fl[i]) { - cells.conf[min] = cells.fl[min]; // mark confluence - if (h[min] >= 20) riversData.find(r => r.river === cells.r[min]).parent = cells.r[i]; // min river is a tributary of current river - cells.r[min] = cells.r[i]; // re-assign river if downhill part has less flux - } else { - cells.conf[min] += cells.fl[i]; // mark confluence - if (h[min] >= 20) riversData.find(r => r.river === cells.r[i]).parent = cells.r[min]; // current river is a tributary of min river - } - } else cells.r[min] = cells.r[i]; // assign the river to the downhill cell - - const nx = p[min][0], ny = p[min][1]; - if (h[min] < 20) { - // pour water to the sea haven - riversData.push({river: cells.r[i], cell: cells.haven[i], x: nx, y: ny}); + const flowDown = function(min, mFlux, iFlux, ri, i = 0){ + if (cells.r[min]) { // downhill cell already has river assigned + if (mFlux < iFlux) { + cells.conf[min] = cells.fl[min]; // mark confluence + if (h[min] >= 20) riversData.find(r => r.river === cells.r[min]).parent = ri; // min river is a tributary of current river + cells.r[min] = ri; // re-assign river if downhill part has less flux } else { - const mf = features[cells.f[min]]; // feature of min cell - if (mf.type === "lake") { - if (!mf.river || cells.fl[i] > mf.flux) { - mf.river = cells.r[i]; // pour water to temporaly elevated lake - mf.flux = cells.fl[i]; // entering flux + cells.conf[min] += iFlux; // mark confluence + if (h[min] >= 20) riversData.find(r => r.river === ri).parent = cells.r[min]; // current river is a tributary of min river + } + } else cells.r[min] = ri; // assign the river to the downhill cell + + if (h[min] < 20) { + // pour water to the sea haven + const oh = i ? cells.haven[i] : min; + riversData.push({river: ri, cell: oh, x: p[min][0], y: p[min][1]}); + const mf = features[cells.f[min]]; // feature of min cell + if (mf.type === "lake") { + if (!mf.river || iFlux > mf.flux) { + mf.river = ri; // pour water to temporaly elevated lake + mf.flux = iFlux; // entering flux + } + mf.totalFlux += iFlux; + if (mf.inlets) { + mf.inlets.push(ri); + } else { + mf.inlets = [ri]; + } + } + } else { + cells.fl[min] += iFlux; // propagate flux + riversData.push({river: ri, cell: min, x: p[min][0], y: p[min][1]}); // add next River segment + } + } + + land.forEach(function(i) { + cells.fl[i] += grid.cells.prec[cells.g[i]]; // flux from precipitation + const x = p[i][0], y = p[i][1]; + + // lake outlets draw from lake + let n = -1, out2 = 0; + while (outlets.includes(i, n+1)) { + n = outlets.indexOf(i, n+1); + const l = features[n]; + if ( ! l ) {continue;} + const j = cells.haven[i]; + // allow chain lakes to retain identity + if(cells.r[j] !== l.river) { + let touch = false; + for (const c of cells.c[j]){ + if (cells.r[c] === l.river) { + touch = true; + break; } } - cells.fl[min] += cells.fl[i]; // propagate flux - riversData.push({river: cells.r[i], cell: min, x: nx, y: ny}); // add next River segment - } - - }); - }() - - void function defineRivers() { - pack.rivers = []; // rivers data - const riverPaths = []; // temporary data for all rivers - - for (let r = 1; r <= riverNext; r++) { - const riverSegments = riversData.filter(d => d.river === r); - - if (riverSegments.length > 2) { - const riverEnhanced = addMeandring(riverSegments); - const width = rn(.8 + Math.random() * .4, 1); // river width modifier - const increment = rn(.8 + Math.random() * .6, 1); // river bed widening modifier - const [path, length] = getPath(riverEnhanced, width, increment); - riverPaths.push([r, path, width, increment]); - const source = riverSegments[0], mouth = riverSegments[riverSegments.length-2]; - const parent = source.parent || 0; - pack.rivers.push({i:r, parent, length, source:source.cell, mouth:mouth.cell}); - } else { - // remove too short rivers - riverSegments.filter(s => cells.r[s.cell] === r).forEach(s => cells.r[s.cell] = 0); + if (touch) { + cells.r[j] = l.river; + riversData.push({river: l.river, cell: j, x: p[j][0], y: p[j][1]}); + } else { + cells.r[j] = riverNext; + riversData.push({river: riverNext, cell: j, x: p[j][0], y: p[j][1]}); + riverNext++; + } } + cells.fl[j] = l.totalFlux; // signpost river size + flowDown(i, cells.fl[i], l.totalFlux, cells.r[j]); + // prevent dropping imediately back into the lake + out2 = cells.c[i].filter(c => (h[c] >= 20 || cells.f[c] !== cells.f[j])).sort((a,b) => h[a] - h[b])[0]; // downhill cell not in the source lake + // assign all to outlet basin + if (l.inlets) l.inlets.forEach(fork => riversData.find(r => r.river === fork).parent = cells.r[j]); } - const html = riverPaths.map(r =>``).join(""); - rivers.html(html); - }() - - // apply change heights as basic one - if (changeHeights) cells.h = Uint8Array.from(h); - - TIME && console.timeEnd('generateRivers'); - } - - // depression filling algorithm (for a correct water flux modeling) - const resolveDepressions = function(h) { - const cells = pack.cells; - const land = cells.i.filter(i => h[i] >= 20 && h[i] < 100 && !cells.b[i]); // exclude near-border cells - land.sort((a,b) => h[b] - h[a]); // highest cells go first - let depressed = false; - - for (let l = 0, depression = Infinity; depression && l < 100; l++) { - depression = 0; - for (const i of land) { - const minHeight = d3.min(cells.c[i].map(c => h[c])); - if (minHeight === 100) continue; // already max height - if (h[i] <= minHeight) { - h[i] = Math.min(minHeight + 1, 100); - depression++; - depressed = true; + // near-border cell: pour out of the screen + if (cells.b[i]) { + if (cells.r[i]) { + const to = []; + const min = Math.min(y, graphHeight - y, x, graphWidth - x); + if (min === y) {to[0] = x; to[1] = 0;} else + if (min === graphHeight - y) {to[0] = x; to[1] = graphHeight;} else + if (min === x) {to[0] = 0; to[1] = y;} else + if (min === graphWidth - x) {to[0] = graphWidth; to[1] = y;} + riversData.push({river: cells.r[i], cell: i, x: to[0], y: to[1]}); } + return; + } + + const min = out2 ? out2 : cells.c[i][d3.scan(cells.c[i], (a, b) => h[a] - h[b])]; // downhill cell + + if (cells.fl[i] < 30) { + if (h[min] >= 20) cells.fl[min] += cells.fl[i]; + return; // flux is too small to operate as river + } + + // Proclaim a new river + if (!cells.r[i]) { + cells.r[i] = riverNext; + riversData.push({river: riverNext, cell: i, x, y}); + riverNext++; + } + + flowDown(min, cells.fl[min], cells.fl[i], cells.r[i], i); + + }); + }() + + void function defineRivers() { + pack.rivers = []; // rivers data + const riverPaths = []; // temporary data for all rivers + + for (let r = 1; r <= riverNext; r++) { + const riverSegments = riversData.filter(d => d.river === r); + + if (riverSegments.length > 2) { + const source = riverSegments[0], mouth = riverSegments[riverSegments.length-2]; + const riverEnhanced = addMeandring(riverSegments); + let width = rn(.8 + Math.random() * .4, 1); // river width modifier [.2, 10] + let increment = rn(.8 + Math.random() * .6, 1); // river bed widening modifier [.01, 3] + const [path, length] = getPath(riverEnhanced, width, increment, cells.h[source.cell] >= 20 ? .1 : .6); + riverPaths.push([r, path, width, increment]); + const parent = source.parent || 0; + pack.rivers.push({i:r, parent, length, source:source.cell, mouth:mouth.cell}); + } else { + // remove too short rivers + riverSegments.filter(s => cells.r[s.cell] === r).forEach(s => cells.r[s.cell] = 0); } } - return depressed; - } + // drawRivers + rivers.selectAll("path").remove(); + rivers.selectAll("path").data(riverPaths).enter() + .append("path").attr("d", d => d[1]).attr("id", d => "river"+d[0]) + .attr("data-width", d => d[2]).attr("data-increment", d => d[3]); + }() - // add more river points on 1/3 and 2/3 of length - const addMeandring = function(segments, rndFactor = 0.3) { - const riverEnhanced = []; // to store enhanced segments - let side = 1; // to control meandring direction + // apply change heights as basic one + if (changeHeights) cells.h = Uint8Array.from(h); - for (let s = 0; s < segments.length; s++) { - const sX = segments[s].x, sY = segments[s].y; // segment start coordinates - const c = pack.cells.conf[segments[s].cell] || 0; // if segment is river confluence - riverEnhanced.push([sX, sY, c]); + TIME && console.timeEnd('generateRivers'); +} - if (s+1 === segments.length) break; // do not enhance last segment - - const eX = segments[s+1].x, eY = segments[s+1].y; // segment end coordinates - const angle = Math.atan2(eY - sY, eX - sX); - const sin = Math.sin(angle), cos = Math.cos(angle); - const serpentine = 1 / (s + 1) + 0.3; - const meandr = serpentine + Math.random() * rndFactor; - if (P(.5)) side *= -1; // change meandring direction in 50% - const dist2 = (eX - sX) ** 2 + (eY - sY) ** 2; - // if dist2 is big or river is small add extra points at 1/3 and 2/3 of segment - if (dist2 > 64 || (dist2 > 16 && segments.length < 6)) { - const p1x = (sX * 2 + eX) / 3 + side * -sin * meandr; - const p1y = (sY * 2 + eY) / 3 + side * cos * meandr; - if (P(.2)) side *= -1; // change 2nd extra point meandring direction in 20% - const p2x = (sX + eX * 2) / 3 + side * sin * meandr; - const p2y = (sY + eY * 2) / 3 + side * cos * meandr; - riverEnhanced.push([p1x, p1y], [p2x, p2y]); - // if dist is medium or river is small add 1 extra middlepoint - } else if (dist2 > 16 || segments.length < 6) { - const p1x = (sX + eX) / 2 + side * -sin * meandr; - const p1y = (sY + eY) / 2 + side * cos * meandr; - riverEnhanced.push([p1x, p1y]); +// depression filling algorithm (for a correct water flux modeling) +const resolveDepressions = function(h) { + const cells = pack.cells; + const land = cells.i.filter(i => h[i] >= 20 && h[i] < 100 && !cells.b[i]); // exclude near-border cells + const lakes = pack.features.filter(f => f.type === "lake" && (f.group === "freshwater" || f.group === "frozen")); // to keep lakes flat + lakes.forEach(l => { + l.shoreline = []; + l.height = 21; + l.totalFlux = grid.cells.prec[cells.g[l.firstCell]]; + }); + for (let i of land.filter(i => cells.t[i] === 1)) { // select shoreline cells + cells.c[i].map(c => pack.features[cells.f[c]]).forEach(cf => { + if (lakes.includes(cf) && !cf.shoreline.includes(i)) { + cf.shoreline.push(i); } + }) + } + land.sort((a,b) => h[b] - h[a]); // highest cells go first + let depressed = false; + for (let l = 0, depression = Infinity; depression && l < 100; l++) { + depression = 0; + for (const l of lakes) { + const minHeight = d3.min(l.shoreline.map(s => h[s])); + if (minHeight === 100) continue; // already max height + if (l.height <= minHeight) { + l.height = Math.min(minHeight + 1, 100); + depression++; + depressed = true; + } + } + for (const i of land) { + const minHeight = d3.min(cells.c[i].map(c => cells.t[c] > 0 ? h[c] : + pack.features[cells.f[c]].height || h[c] // NB undefined is falsy (a || b is short for a ? a : b) + )); + if (minHeight === 100) continue; // already max height + if (h[i] <= minHeight) { + h[i] = Math.min(minHeight + 1, 100); + depression++; + depressed = true; + } } - return riverEnhanced; } - const getPath = function(points, width = 1, increment = 1) { - let offset, extraOffset = .1; // starting river width (to make river source visible) - const riverLength = points.reduce((s, v, i, p) => s + (i ? Math.hypot(v[0] - p[i-1][0], v[1] - p[i-1][1]) : 0), 0); // summ of segments length - const widening = rn((1000 + (riverLength * 30)) * increment); - const riverPointsLeft = [], riverPointsRight = []; // store points on both sides to build a valid polygon - const last = points.length - 1; - const factor = riverLength / points.length; + return depressed; +} - // first point - let x = points[0][0], y = points[0][1], c; - let angle = Math.atan2(y - points[1][1], x - points[1][0]); - let sin = Math.sin(angle), cos = Math.cos(angle); - let xLeft = x + -sin * extraOffset, yLeft = y + cos * extraOffset; - riverPointsLeft.push([xLeft, yLeft]); - let xRight = x + sin * extraOffset, yRight = y + -cos * extraOffset; - riverPointsRight.unshift([xRight, yRight]); +// add more river points on 1/3 and 2/3 of length +const addMeandring = function(segments, rndFactor = 0.3) { + const riverEnhanced = []; // to store enhanced segments + let side = 1; // to control meandring direction - // middle points - for (let p = 1; p < last; p++) { - x = points[p][0], y = points[p][1], c = points[p][2] || 0; - const xPrev = points[p-1][0], yPrev = points[p - 1][1]; - const xNext = points[p+1][0], yNext = points[p + 1][1]; - angle = Math.atan2(yPrev - yNext, xPrev - xNext); - sin = Math.sin(angle), cos = Math.cos(angle); - offset = (Math.atan(Math.pow(p * factor, 2) / widening) / 2 * width) + extraOffset; - const confOffset = Math.atan(c * 5 / widening); - extraOffset += confOffset; - xLeft = x + -sin * offset, yLeft = y + cos * (offset + confOffset); - riverPointsLeft.push([xLeft, yLeft]); - xRight = x + sin * offset, yRight = y + -cos * offset; - riverPointsRight.unshift([xRight, yRight]); + for (let s = 0; s < segments.length; s++) { + const sX = segments[s].x, sY = segments[s].y; // segment start coordinates + const c = pack.cells.conf[segments[s].cell] || 0; // if segment is river confluence + riverEnhanced.push([sX, sY, c]); + + if (s+1 === segments.length) break; // do not enhance last segment + + const eX = segments[s+1].x, eY = segments[s+1].y; // segment end coordinates + const angle = Math.atan2(eY - sY, eX - sX); + const sin = Math.sin(angle), cos = Math.cos(angle); + const serpentine = 1 / (s + 1) + 0.3; + const meandr = serpentine + Math.random() * rndFactor; + if (P(.5)) side *= -1; // change meandring direction in 50% + const dist2 = (eX - sX) ** 2 + (eY - sY) ** 2; + // if dist2 is big or river is small add extra points at 1/3 and 2/3 of segment + if (dist2 > 64 || (dist2 > 16 && segments.length < 6)) { + const p1x = (sX * 2 + eX) / 3 + side * -sin * meandr; + const p1y = (sY * 2 + eY) / 3 + side * cos * meandr; + if (P(.2)) side *= -1; // change 2nd extra point meandring direction in 20% + const p2x = (sX + eX * 2) / 3 + side * sin * meandr; + const p2y = (sY + eY * 2) / 3 + side * cos * meandr; + riverEnhanced.push([p1x, p1y], [p2x, p2y]); + // if dist is medium or river is small add 1 extra middlepoint + } else if (dist2 > 16 || segments.length < 6) { + const p1x = (sX + eX) / 2 + side * -sin * meandr; + const p1y = (sY + eY) / 2 + side * cos * meandr; + riverEnhanced.push([p1x, p1y]); } - // end point - x = points[last][0], y = points[last][1], c = points[last][2]; - if (c) extraOffset += Math.atan(c * 10 / widening); // add extra width on river confluence - angle = Math.atan2(points[last-1][1] - y, points[last-1][0] - x); + } + return riverEnhanced; +} + +const getPath = function(points, width = 1, increment = 1, starting = .1) { + let offset, extraOffset = starting; // starting river width (to make river source visible) + const riverLength = points.reduce((s, v, i, p) => s + (i ? Math.hypot(v[0] - p[i-1][0], v[1] - p[i-1][1]) : 0), 0); // summ of segments length + const widening = rn((1000 + (riverLength * 30)) * increment); + const riverPointsLeft = [], riverPointsRight = []; // store points on both sides to build a valid polygon + const last = points.length - 1; + const factor = riverLength / points.length; + + // first point + let x = points[0][0], y = points[0][1], c; + let angle = Math.atan2(y - points[1][1], x - points[1][0]); + let sin = Math.sin(angle), cos = Math.cos(angle); + let xLeft = x + -sin * extraOffset, yLeft = y + cos * extraOffset; + riverPointsLeft.push([xLeft, yLeft]); + let xRight = x + sin * extraOffset, yRight = y + -cos * extraOffset; + riverPointsRight.unshift([xRight, yRight]); + + // middle points + for (let p = 1; p < last; p++) { + x = points[p][0], y = points[p][1], c = points[p][2] || 0; + const xPrev = points[p-1][0], yPrev = points[p - 1][1]; + const xNext = points[p+1][0], yNext = points[p + 1][1]; + angle = Math.atan2(yPrev - yNext, xPrev - xNext); sin = Math.sin(angle), cos = Math.cos(angle); - xLeft = x + -sin * offset, yLeft = y + cos * offset; + offset = (Math.atan(Math.pow(p * factor, 2) / widening) / 2 * width) + extraOffset; + const confOffset = Math.atan(c * 5 / widening); + extraOffset += confOffset; + xLeft = x + -sin * offset, yLeft = y + cos * (offset + confOffset); riverPointsLeft.push([xLeft, yLeft]); xRight = x + sin * offset, yRight = y + -cos * offset; riverPointsRight.unshift([xRight, yRight]); - - // generate polygon path and return - lineGen.curve(d3.curveCatmullRom.alpha(0.1)); - const right = lineGen(riverPointsRight); - let left = lineGen(riverPointsLeft); - left = left.substring(left.indexOf("C")); - return [round(right + left, 2), rn(riverLength, 2)]; } - const specify = function() { - if (!pack.rivers.length) return; - Math.random = aleaPRNG(seed); - const smallLength = pack.rivers.map(r => r.length||0).sort((a,b) => a-b)[Math.ceil(pack.rivers.length * .15)]; - const smallType = {"Creek":9, "River":3, "Brook":3, "Stream":1}; // weighted small river types + // end point + x = points[last][0], y = points[last][1], c = points[last][2]; + if (c) extraOffset += Math.atan(c * 10 / widening); // add extra width on river confluence + angle = Math.atan2(points[last-1][1] - y, points[last-1][0] - x); + sin = Math.sin(angle), cos = Math.cos(angle); + xLeft = x + -sin * offset, yLeft = y + cos * offset; + riverPointsLeft.push([xLeft, yLeft]); + xRight = x + sin * offset, yRight = y + -cos * offset; + riverPointsRight.unshift([xRight, yRight]); - for (const r of pack.rivers) { - r.basin = getBasin(r.i, r.parent); - r.name = getName(r.mouth); - //debug.append("circle").attr("cx", pack.cells.p[r.mouth][0]).attr("cy", pack.cells.p[r.mouth][1]).attr("r", 2); - const small = r.length < smallLength; - r.type = r.parent && !(r.i%6) ? small ? "Branch" : "Fork" : small ? rw(smallType) : "River"; - } + // generate polygon path and return + lineGen.curve(d3.curveCatmullRom.alpha(0.1)); + const right = lineGen(riverPointsRight); + let left = lineGen(riverPointsLeft); + left = left.substring(left.indexOf("C")); + return [round(right + left, 2), rn(riverLength, 2)]; +} + +const specify = function() { + if (!pack.rivers.length) return; + Math.random = aleaPRNG(seed); + const smallLength = pack.rivers.map(r => r.length||0).sort((a,b) => a-b)[Math.ceil(pack.rivers.length * .15)]; + const smallType = {"Creek":9, "River":3, "Brook":3, "Stream":1}; // weighted small river types + + for (const r of pack.rivers) { + r.basin = getBasin(r.i, r.parent); + r.name = getName(r.mouth); + //debug.append("circle").attr("cx", pack.cells.p[r.mouth][0]).attr("cy", pack.cells.p[r.mouth][1]).attr("r", 2); + const small = r.length < smallLength; + r.type = r.parent && !(r.i%6) ? small ? "Branch" : "Fork" : small ? rw(smallType) : "River"; } +} - const getName = function(cell) { - return Names.getCulture(pack.cells.culture[cell]); +const getName = function(cell) { + return Names.getCulture(pack.cells.culture[cell]); +} + +// remove river and all its tributaries +const remove = function(id) { + const cells = pack.cells; + const riversToRemove = pack.rivers.filter(r => r.i === id || getBasin(r.i, r.parent, id) === id).map(r => r.i); + riversToRemove.forEach(r => rivers.select("#river"+r).remove()); + cells.r.forEach((r, i) => { + if (!r || !riversToRemove.includes(r)) return; + cells.r[i] = 0; + cells.fl[i] = grid.cells.prec[cells.g[i]]; + cells.conf[i] = 0; + }); + pack.rivers = pack.rivers.filter(r => !riversToRemove.includes(r.i)); +} + +const getBasin = function(r, p, e) { + while (p && r !== p && r !== e) { + const parent = pack.rivers.find(r => r.i === p); + if (!parent) return r; + r = parent.i; + p = parent.parent; } + return r; +} - // remove river and all its tributaries - const remove = function(id) { - const cells = pack.cells; - const riversToRemove = pack.rivers.filter(r => r.i === id || getBasin(r.i, r.parent, id) === id).map(r => r.i); - riversToRemove.forEach(r => rivers.select("#river"+r).remove()); - cells.r.forEach((r, i) => { - if (!r || !riversToRemove.includes(r)) return; - cells.r[i] = 0; - cells.fl[i] = grid.cells.prec[cells.g[i]]; - cells.conf[i] = 0; - }); - pack.rivers = pack.rivers.filter(r => !riversToRemove.includes(r.i)); - } +return {generate, resolveDepressions, addMeandring, getPath, specify, getName, getBasin, remove}; - const getBasin = function(r, p, e) { - while (p && r !== p && r !== e) { - const parent = pack.rivers.find(r => r.i === p); - if (!parent) return r; - r = parent.i; - p = parent.parent; - } - return r; - } - - return {generate, resolveDepressions, addMeandring, getPath, specify, getName, getBasin, remove}; - -}))); +}))); \ No newline at end of file diff --git a/modules/ui/heightmap-editor.js b/modules/ui/heightmap-editor.js index 73a8006e..34a77e1d 100644 --- a/modules/ui/heightmap-editor.js +++ b/modules/ui/heightmap-editor.js @@ -176,7 +176,6 @@ function editHeightmap() { reGraph(); drawCoastline(); - elevateLakes(); Rivers.generate(change); if (!change) { @@ -288,10 +287,7 @@ function editHeightmap() { reGraph(); drawCoastline(); - if (changeHeights.checked) { - elevateLakes(); - Rivers.generate(changeHeights.checked); - } + if (changeHeights.checked) Rivers.generate(changeHeights.checked); // assign saved pack data from grid back to pack const n = pack.cells.i.length; @@ -314,7 +310,6 @@ function editHeightmap() { for (const i of pack.cells.i) { const g = pack.cells.g[i]; - if (pack.features[pack.cells.f[i]].group === "freshwater") pack.cells.h[i] = 19; // de-elevate lakes const land = pack.cells.h[i] >= 20; // check biome diff --git a/modules/ui/tools.js b/modules/ui/tools.js index d41fbc91..5269e185 100644 --- a/modules/ui/tools.js +++ b/modules/ui/tools.js @@ -73,12 +73,7 @@ function processFeatureRegeneration(event, button) { } function regenerateRivers() { - elevateLakes(); Rivers.generate(); - for (const i of pack.cells.i) { - const f = pack.features[pack.cells.f[i]]; // feature - if (f.group === "freshwater") pack.cells.h[i] = 19; // de-elevate lakes - } Rivers.specify(); if (!layerIsOn("toggleRivers")) toggleRivers(); } diff --git a/modules/ui/world-configurator.js b/modules/ui/world-configurator.js index 11eef897..913e4f77 100644 --- a/modules/ui/world-configurator.js +++ b/modules/ui/world-configurator.js @@ -45,7 +45,6 @@ function editWorld() { updateGlobePosition(); calculateTemperatures(); generatePrecipitation(); - elevateLakes(); const heights = new Uint8Array(pack.cells.h); Rivers.generate(); Rivers.specify(); diff --git a/modules/voronoi.js b/modules/voronoi.js index f7b82292..f5e4b45c 100644 --- a/modules/voronoi.js +++ b/modules/voronoi.js @@ -1,82 +1,135 @@ -(function (global, factory) { - typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : - typeof define === 'function' && define.amd ? define(factory) : - (global.Voronoi = factory()); -}(this, (function () { 'use strict'; +class Voronoi { + /** + * Creates a Voronoi diagram from the given Delaunator, a list of points, and the number of points. The Voronoi diagram is constructed using (I think) the {@link https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm |Bowyer-Watson Algorithm} + * The {@link https://github.com/mapbox/delaunator/ |Delaunator} library uses {@link https://en.wikipedia.org/wiki/Doubly_connected_edge_list |half-edges} to represent the relationship between points and triangles. + * @param {{triangles: Uint32Array, halfedges: Int32Array}} delaunay A {@link https://github.com/mapbox/delaunator/blob/master/index.js |Delaunator} instance. + * @param {[number, number][]} points A list of coordinates. + * @param {number} pointsN The number of points. + */ + constructor(delaunay, points, pointsN) { + this.delaunay = delaunay; + this.points = points; + this.pointsN = pointsN; + this.cells = { v: [], c: [], b: [] }; // voronoi cells: v = cell vertices, c = adjacent cells, b = near-border cell + this.vertices = { p: [], v: [], c: [] }; // cells vertices: p = vertex coordinates, v = neighboring vertices, c = adjacent cells - var Voronoi = function Voronoi(delaunay, points, pointsN) { - const cells = {v: [], c: [], b: []}; // voronoi cells: v = cell vertices, c = adjacent cells, b = near-border cell - const vertices = {p: [], v: [], c: []}; // cells vertices: p = vertex coordinates, v = neighboring vertices, c = adjacent cells + // Half-edges are the indices into the delaunator outputs: + // delaunay.triangles[e] gives the point ID where the half-edge starts + // delaunay.triangles[e] returns either the opposite half-edge in the adjacent triangle, or -1 if there's not an adjacent triangle. + for (let e = 0; e < this.delaunay.triangles.length; e++) { - for (let e=0; e < delaunay.triangles.length; e++) { - - const p = delaunay.triangles[nextHalfedge(e)]; - if (p < pointsN && !cells.c[p]) { - const edges = edgesAroundPoint(e); - cells.v[p] = edges.map(e => triangleOfEdge(e)); // cell: adjacent vertex - cells.c[p] = edges.map(e => delaunay.triangles[e]).filter(c => c < pointsN); // cell: adjacent valid cells - cells.b[p] = edges.length > cells.c[p].length ? 1 : 0; // cell: is border + const p = this.delaunay.triangles[this.nextHalfedge(e)]; + if (p < this.pointsN && !this.cells.c[p]) { + const edges = this.edgesAroundPoint(e); + this.cells.v[p] = edges.map(e => this.triangleOfEdge(e)); // cell: adjacent vertex + this.cells.c[p] = edges.map(e => this.delaunay.triangles[e]).filter(c => c < this.pointsN); // cell: adjacent valid cells + this.cells.b[p] = edges.length > this.cells.c[p].length ? 1 : 0; // cell: is border } - const t = triangleOfEdge(e); - if (!vertices.p[t]) { - vertices.p[t] = triangleCenter(t); // vertex: coordinates - vertices.v[t] = trianglesAdjacentToTriangle(t); // vertex: adjacent vertices - vertices.c[t] = pointsOfTriangle(t); // vertex: adjacent cells + const t = this.triangleOfEdge(e); + if (!this.vertices.p[t]) { + this.vertices.p[t] = this.triangleCenter(t); // vertex: coordinates + this.vertices.v[t] = this.trianglesAdjacentToTriangle(t); // vertex: adjacent vertices + this.vertices.c[t] = this.pointsOfTriangle(t); // vertex: adjacent cells } } - - function pointsOfTriangle(t) { - return edgesOfTriangle(t).map(e => delaunay.triangles[e]); - } - - function trianglesAdjacentToTriangle(t) { - let triangles = []; - for (let e of edgesOfTriangle(t)) { - let opposite = delaunay.halfedges[e]; - triangles.push(triangleOfEdge(opposite)); - } - return triangles; - } - - function edgesAroundPoint(start) { - let result = [], incoming = start; - do { - result.push(incoming); - const outgoing = nextHalfedge(incoming); - incoming = delaunay.halfedges[outgoing]; - } while (incoming !== -1 && incoming !== start && result.length < 20); - return result; - } - - function triangleCenter(t) { - let vertices = pointsOfTriangle(t).map(p => points[p]); - return circumcenter(vertices[0], vertices[1], vertices[2]); - } - - return {cells, vertices} - } - function edgesOfTriangle(t) {return [3*t, 3*t+1, 3*t+2];} + /** + * Gets the IDs of the points comprising the given triangle. Taken from {@link https://mapbox.github.io/delaunator/#triangle-to-points| the Delaunator docs.} + * @param {number} t The index of the triangle + * @returns {[number, number, number]} The IDs of the points comprising the given triangle. + */ + pointsOfTriangle(t) { + return this.edgesOfTriangle(t).map(edge => this.delaunay.triangles[edge]); + } - function triangleOfEdge(e) {return Math.floor(e/3);} + /** + * Identifies what triangles are adjacent to the given triangle. Taken from {@link https://mapbox.github.io/delaunator/#triangle-to-triangles| the Delaunator docs.} + * @param {number} t The index of the triangle + * @returns {number[]} The indices of the triangles that share half-edges with this triangle. + */ + trianglesAdjacentToTriangle(t) { + let triangles = []; + for (let edge of this.edgesOfTriangle(t)) { + let opposite = this.delaunay.halfedges[edge]; + triangles.push(this.triangleOfEdge(opposite)); + } + return triangles; + } - function nextHalfedge(e) {return (e % 3 === 2) ? e-2 : e+1;} + /** + * Gets the indices of all the incoming and outgoing half-edges that touch the given point. Taken from {@link https://mapbox.github.io/delaunator/#point-to-edges| the Delaunator docs.} + * @param {number} start The index of an incoming half-edge that leads to the desired point + * @returns {number[]} The indices of all half-edges (incoming or outgoing) that touch the point. + */ + edgesAroundPoint(start) { + const result = []; + let incoming = start; + do { + result.push(incoming); + const outgoing = this.nextHalfedge(incoming); + incoming = this.delaunay.halfedges[outgoing]; + } while (incoming !== -1 && incoming !== start && result.length < 20); + return result; + } - function prevHalfedge(e) {return (e % 3 === 0) ? e+2 : e-1;} + /** + * Returns the center of the triangle located at the given index. + * @param {number} t The index of the triangle + * @returns {[number, number]} + */ + triangleCenter(t) { + let vertices = this.pointsOfTriangle(t).map(p => this.points[p]); + return this.circumcenter(vertices[0], vertices[1], vertices[2]); + } - function circumcenter(a, b, c) { - let ad = a[0]*a[0] + a[1]*a[1], - bd = b[0]*b[0] + b[1]*b[1], - cd = c[0]*c[0] + c[1]*c[1]; - let D = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1])); + /** + * Retrieves all of the half-edges for a specific triangle `t`. Taken from {@link https://mapbox.github.io/delaunator/#edge-and-triangle| the Delaunator docs.} + * @param {number} t The index of the triangle + * @returns {[number, number, number]} The edges of the triangle. + */ + edgesOfTriangle(t) { return [3 * t, 3 * t + 1, 3 * t + 2]; } + + /** + * Enables lookup of a triangle, given one of the half-edges of that triangle. Taken from {@link https://mapbox.github.io/delaunator/#edge-and-triangle| the Delaunator docs.} + * @param {number} e The index of the edge + * @returns {number} The index of the triangle + */ + triangleOfEdge(e) { return Math.floor(e / 3); } + + /** + * Moves to the next half-edge of a triangle, given the current half-edge's index. Taken from {@link https://mapbox.github.io/delaunator/#edge-to-edges| the Delaunator docs.} + * @param {number} e The index of the current half edge + * @returns {number} The index of the next half edge + */ + nextHalfedge(e) { return (e % 3 === 2) ? e - 2 : e + 1; } + + /** + * Moves to the previous half-edge of a triangle, given the current half-edge's index. Taken from {@link https://mapbox.github.io/delaunator/#edge-to-edges| the Delaunator docs.} + * @param {number} e The index of the current half edge + * @returns {number} The index of the previous half edge + */ + prevHalfedge(e) { return (e % 3 === 0) ? e + 2 : e - 1; } + + /** + * Finds the circumcenter of the triangle identified by points a, b, and c. Taken from {@link https://en.wikipedia.org/wiki/Circumscribed_circle#Circumcenter_coordinates| Wikipedia} + * @param {[number, number]} a The coordinates of the first point of the triangle + * @param {[number, number]} b The coordinates of the second point of the triangle + * @param {[number, number]} c The coordinates of the third point of the triangle + * @return {[number, number]} The coordinates of the circumcenter of the triangle. + */ + circumcenter(a, b, c) { + const [ax, ay] = a; + const [bx, by] = b; + const [cx, cy] = c; + const ad = ax * ax + ay * ay; + const bd = bx * bx + by * by; + const cd = cx * cx + cy * cy; + const D = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)); return [ - Math.floor(1/D * (ad * (b[1] - c[1]) + bd * (c[1] - a[1]) + cd * (a[1] - b[1]))), - Math.floor(1/D * (ad * (c[0] - b[0]) + bd * (a[0] - c[0]) + cd * (b[0] - a[0]))) + Math.floor(1 / D * (ad * (by - cy) + bd * (cy - ay) + cd * (ay - by))), + Math.floor(1 / D * (ad * (cx - bx) + bd * (ax - cx) + cd * (bx - ax))) ]; } - - return Voronoi; - -}))); \ No newline at end of file +} \ No newline at end of file