Refactor

Author: hacktoon

src/model/world/basin/model.js

@@ -184,7 +184,7 @@ class LandBasinFill extends ConcurrentFill {
         const target = world.surface.get(fillPoint)
         const parent = world.surface.get(parentPoint)
         // avoid fill if different types
-        return target.isWater == parent.isWater
+        return target.type.isWater == parent.type.isWater
     }
 
     _fillBasin(fill, fillPoint, parentPoint) {

src/model/world/relief/index.js

@@ -30,7 +30,8 @@ export class ReliefLayer {
     #detectWaterType(world, point) {
         const outlineNoise = world.noise.get4DOutline(this.rect, point)
         const grainedNoise = world.noise.get4DGrained(this.rect, point)
-        if (world.surface.get(point).id == SeaSurface.id) {
+        const surface = world.surface.get(point)
+        if (surface.type.id == SeaSurface.id) {
             if (outlineNoise > OCEAN_RATIO) return Relief.OCEAN
             return Relief.PLATFORM
         }

src/model/world/surface/index.js

@@ -19,16 +19,21 @@ export class SurfaceLayer {
 
     get(point) {
         const bodyId = this.#model.body.get(point)
-        return Surface.parse(this.#model.bodyType.get(bodyId))
+        const borderId = this.#model.borderType.get(point)
+        return {
+            type: Surface.parse(this.#model.bodyType.get(bodyId)),
+            borderType: Surface.parse(borderId),
+        }
     }
 
     getText(point) {
         const surface = this.get(point)
         const surfaceArea = this.getArea(point)
         const attrs = [
-            `${surface.name}`,
+            `${surface.type.name}`,
             `area=${surfaceArea}`,
-        ].join(' | ')
+            `border=${surface.borderType.name}`,
+        ].join(', ')
         return `Surface(${attrs})`
     }
 
@@ -43,40 +48,41 @@ export class SurfaceLayer {
     }
 
     isWater(point) {
-        return this.get(point).isWater
+        return this.get(point).type.isWater
+    }
+
+    isLand(point) {
+        return ! this.isWater(point)
+    }
+
+    isBorder(point) {
+        return this.#model.borderType.get(point) != Surface.id
     }
 
     isLake(point) {
-        return this.get(point).id == LakeSurface.id
+        return this.get(point).type.id == LakeSurface.id
     }
 
     isOcean(point) {
-        return this.get(point).id == OceanSurface.id
+        return this.get(point).type.id == OceanSurface.id
     }
 
     isSea(point) {
-        return this.get(point).id == SeaSurface.id
+        return this.get(point).type.id == SeaSurface.id
     }
 
     isIsland(point) {
-        return this.get(point).id == IslandSurface.id
+        return this.get(point).type.id == IslandSurface.id
     }
 
     isContinent(point) {
-        return this.get(point).id == ContinentSurface.id
-    }
-
-    isLand(point) {
-        return ! this.get(point).isWater
-    }
-
-    isBorder(point) {
-        return this.#model.border.get(point) > 0
+        return this.get(point).type.id == ContinentSurface.id
     }
 
     draw(props, params) {
         const {canvas, canvasPoint, tileSize, tilePoint} = props
-        let color = this.get(tilePoint).color
+        const surface = this.get(tilePoint)
+        let color = surface.type.color
         if (this.isBorder(tilePoint)) {
             color = color.darken(20)
         }

src/model/world/surface/model.js

@@ -12,7 +12,6 @@ import {
 } from './type'
 
 
-const EMPTY = null
 const LAND = 0
 const WATER = 1
 // Area ratios
@@ -21,20 +20,22 @@ const MINIMUN_OCEAN_RATIO = 2
 const MINIMUN_SEA_RATIO = .05
 const MINIMUN_CONTINENT_RATIO = 1
 
+export const EMPTY = null
+
 
 export function buildSurfaceModel(context) {
     const {rect, world} = context
     // detect land or water tiles in the grid
     const landWaterGrid = detectLandWater(rect, world)
     // detect surface type by filling empty bodies
-    const {bodyGrid, bodyTypeMap, bodyAreaMap} = detectSurfaceAreas(context, landWaterGrid)
-    const borderGrid = detectBorders(context, landWaterGrid)
+    const {bodyGrid, bodyTypeMap, bodyAreaMap} = detectBodies(context, landWaterGrid)
+    const borderTypeGrid = detectBorderTypes(context, bodyTypeMap, bodyGrid)
     const waterArea = readWaterArea(bodyTypeMap, bodyAreaMap)
     return {
-        border: borderGrid,
         body: bodyGrid,
         bodyType: bodyTypeMap,
         bodyArea: bodyAreaMap,
+        borderType: borderTypeGrid,
         waterArea,
     }
 }
@@ -49,13 +50,13 @@ function detectLandWater(rect, world) {
 }
 
 
-function detectSurfaceAreas(baseContext, landWaterGrid) {
+function detectBodies(baseContext, landWaterGrid) {
     // flood fill "empty" points and determine body type by total area
     let bodyId = 1
     const bodyTypeMap = new Map()
     const bodyAreaMap = new Map()
     const bodyGrid = Grid.fromRect(baseContext.rect, () => EMPTY)
-    const context = {...baseContext, bodyTypeMap, bodyGrid, landWaterGrid}
+    const context = {...baseContext, bodyGrid, landWaterGrid}
 
     landWaterGrid.forEach(originPoint => {
         if(bodyGrid.get(originPoint) != EMPTY) return
@@ -106,20 +107,21 @@ function fillBodyArea(context, originPoint, bodyId) {
 }
 
 
-function detectBorders(context, landWaterGrid) {
-    // surface body matrix already defined, update it by setting
-    // water/land borders as negative ids
-    const borderGrid = Grid.fromRect(context.rect, point => {
-        const isWater = landWaterGrid.get(point) == WATER
+function detectBorderTypes(context, bodyTypeMap, bodyGrid) {
+    const getType = point => {
+        const bodyId = bodyGrid.get(point)
+        return Surface.parse(bodyTypeMap.get(bodyId))
+    }
+    return Grid.fromRect(context.rect, point => {
+        let type = getType(point)
         for (let sidePoint of Point.adjacents(point)) {
-            const isSideWater = landWaterGrid.get(sidePoint) == WATER
-            if (isWater && ! isSideWater || ! isWater && isSideWater) {
-                return 1
+            const sideType = getType(sidePoint)
+            if (type.isWater && ! sideType.isWater || ! type.isWater && sideType.isWater) {
+                return sideType.id
             }
         }
-        return 0
+        return Surface.id
     })
-    return borderGrid
 }
 
 

src/model/world/surface/type.js

@@ -2,101 +2,57 @@ import { Color } from '/src/lib/color'
 
 
 export class Surface {
+    static id = 0
+    static name = 'Inner'
+    static isWater = false
+    static color = Color.BLACK
+
     static parse(id) {
         return SURFACE_MAP[id]
     }
 }
 
 export class LakeSurface {
-    static id = 0
+    static id = 1
     static name = 'Lake'
     static isWater = true
-    static isBorder = false
     static color = Color.fromHex('#218484')
 }
 
 export class SeaSurface {
-    static id = 1
+    static id = 2
     static name = 'Sea'
     static isWater = true
-    static isBorder = false
     static color = Color.fromHex('#216384')
 }
 
 export class OceanSurface {
-    static id = 2
+    static id = 3
     static name = 'Ocean'
     static isWater = true
-    static isBorder = false
     static color = Color.fromHex('#1d2255')
 }
 
 export class IslandSurface {
-    static id = 3
+    static id = 4
     static name = 'Island'
     static isWater = false
-    static isBorder = false
     static color = Color.fromHex('#c5ed7d')
 }
 
 export class ContinentSurface {
-    static id = 4
+    static id = 5
     static name = 'Continent'
     static isWater = false
-    static isBorder = false
     static color = Color.fromHex('#71b13e')
 }
 
-export class LakeBorderSurface {
-    static id = 5
-    static name = 'Lake border'
-    static isWater = true
-    static isBorder = true
-    static color = Color.fromHex('#0D7070')
-}
-
-export class SeaBorderSurface {
-    static id = 6
-    static name = 'Sea border'
-    static isWater = true
-    static isBorder = true
-    static color = Color.fromHex('#0D4F70')
-}
-
-export class OceanBorderSurface {
-    static id = 7
-    static name = 'Ocean border'
-    static isWater = true
-    static isBorder = true
-    static color = Color.fromHex('#090E41')
-}
-
-export class IslandBorderSurface {
-    static id = 8
-    static name = 'Island border'
-    static isWater = false
-    static isBorder = true
-    static color = Color.fromHex('#B1D969')
-}
-
-export class ContinentBorderSurface {
-    static id = 9
-    static name = 'Continent border'
-    static isWater = false
-    static isBorder = true
-    static color = Color.fromHex('#5D9D2A')
-}
-
 
 const SURFACE_MAP = {
-    0: LakeSurface,
-    1: SeaSurface,
-    2: OceanSurface,
-    3: IslandSurface,
-    4: ContinentSurface,
-    5: LakeBorderSurface,
-    6: SeaBorderSurface,
-    7: OceanBorderSurface,
-    8: IslandBorderSurface,
-    9: ContinentBorderSurface,
+    0: Surface,
+    1: LakeSurface,
+    2: SeaSurface,
+    3: OceanSurface,
+    4: IslandSurface,
+    5: ContinentSurface,
 }