Set erosion to all neighbors

Author: hacktoon

src/model/tilemap/worldmap/index.js

@@ -20,6 +20,7 @@ import { CivilLayer } from './world/civil'
 
 import { WorldTileMapDiagram } from './diagram'
 
+import { LandMaskZone } from './zone/landmask'
 import { SurfaceZone } from './zone/surface'
 import { RiverZone } from './zone/river'
 
@@ -114,6 +115,7 @@ export class WorldTileMap extends TileMap {
             seed
         }
         Random.seed = seed  // change seed for this specific zone
+        zone.landmask = new LandMaskZone(context)
         zone.surface = new SurfaceZone(context)
         zone.river = new RiverZone(context)
         return zone

src/model/tilemap/worldmap/world/basin/index.js

@@ -128,7 +128,6 @@ export class BasinLayer {
         const directions = this.#erosionMaskGrid.get(tilePoint)
         for(let direction of directions) {
             // build a point for each flow that points to this point
-            // create a midpoint at tile's square side
             const sidePoint = Point.atDirection(tilePoint, direction)
             // get average between this point and neighbor
             const sideTopology = this.#world.topology.get(sidePoint)

src/model/tilemap/worldmap/world/basin/model.js

@@ -78,7 +78,7 @@ class BasinGridFill extends ConcurrentFill {
     }
 
     getNeighbors(fill, parentPoint) {
-        return Point.adjacents(parentPoint)
+        return Point.around(parentPoint)
     }
 
     _fillBasin(fill, fillPoint, parentPoint) {

src/model/tilemap/worldmap/world/river/index.js

@@ -84,7 +84,7 @@ export class RiverLayer {
 
     draw(props, params) {
         const {canvas, canvasPoint, tileSize, tilePoint} = props
-        props.world.biome.draw(props, params)
+        props.world.surface.draw(props, params)
         if (! this.has(tilePoint)) {
             return
         }

src/model/tilemap/worldmap/zone/landmask.js

@@ -0,0 +1,60 @@
+import { Point } from '/src/lib/geometry/point'
+import { Rect } from '/src/lib/geometry/rect'
+import { Grid } from '/src/lib/grid'
+
+
+const SURFACE_NOISE_RATIO = .6
+const REGION_WATER = false
+const REGION_LAND = true
+
+
+export class LandMaskZone {
+    #landMaskGrid
+
+    constructor(context) {
+        this.size = context.zoneSize
+        this.#landMaskGrid = buildModel(context)
+    }
+
+    get(zonePoint) {
+        const isLand = this.#landMaskGrid.get(zonePoint)
+        return isLand
+    }
+
+    draw(props, params) {
+        const {canvas, canvasPoint, tileSize} = props
+        const zoneSize = this.size
+        const size = tileSize / zoneSize
+        // render zone tiles
+        for (let x=0; x < zoneSize; x++) {
+            const xSize = x * size
+            for (let y=0; y < zoneSize; y++) {
+                const zonePoint = [y, x]
+                const ySize = y * size
+                const zoneCanvasPoint = Point.plus(canvasPoint, [ySize, xSize])
+                const color = this.get(zonePoint) ? '#71b13e' : '#1d2255'
+                canvas.rect(zoneCanvasPoint, size, color)
+            }
+        }
+    }
+}
+
+
+function buildModel(context) {
+    const hash = Point.hash(context.worldPoint)
+    // cache de zone grid noise
+    // if (SURFACE_GRID_CACHE.has(hash)) {
+    //     return SURFACE_GRID_CACHE.get(hash)
+    // }
+    // Generate a boolean grid (land or water)
+    const {worldPoint, world, rect, zoneRect} = context
+    const relativePoint = Point.multiplyScalar(worldPoint, zoneRect.width)
+    const noiseRect = Rect.multiply(rect, zoneRect.width)
+    const landMaskGrid = Grid.fromRect(zoneRect, zonePoint => {
+        const noisePoint = Point.plus(relativePoint, zonePoint)
+        const noise = world.noise.get4DZoneOutline(noiseRect, noisePoint)
+        return noise > SURFACE_NOISE_RATIO ? REGION_LAND : REGION_WATER
+    })
+    // SURFACE_GRID_CACHE.set(hash, landMaskGrid)
+    return landMaskGrid
+}