Rebuild map bundle: Forgotten Plains grass/cliffs/props/stones

web/mapSandbox.js re-bundled from auto-battler — picks up the Forgotten Plains
overhaul: plain-green grass base, 2.5D plateau cliffs (shared bakeCliffs), expanded
foliage + multi-tile props + water reeds, the full 3×4 tree, and the new stone-clump
system. No new assets (FP tile/prop sheets were already curated).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

web/mapSandbox.js

@@ -710,6 +710,31 @@ function centerTile([c0, r0], dNW, dNE, dSW, dSE) {
   if (dSW) return [c0, r0 + 4];
   return [c0 + 1, r0 + 4];
 }
+function bakeCliffs(cfg, { chunk, x0, y0, seed, raised, place, accept = () => true }) {
+  for (let ty = 0; ty < chunk; ty++) for (let tx = 0; tx < chunk; tx++) {
+    if (!accept(tx, ty)) continue;
+    const wx = x0 + tx, wy = y0 + ty;
+    if (raised(wx, wy)) {
+      const bN = !raised(wx, wy - 1), bE = !raised(wx + 1, wy), bS = !raised(wx, wy + 1), bW = !raised(wx - 1, wy);
+      if (bN && bW) place(cfg.LIP_TL, tx, ty);
+      else if (bN && bE) place(cfg.LIP_TR, tx, ty);
+      else if (bS && bW) place(cfg.LIP_SW, tx, ty);
+      else if (bS && bE) place(cfg.LIP_SE, tx, ty);
+      else if (bN) place(sparse(cfg.LIP_T, cfg.LIP_T_VAR, wx, wy, 1, cfg.RATE, seed), tx, ty);
+      else if (bS) place(sparse(cfg.LIP_S, cfg.LIP_S_VAR, wx, wy, 2, cfg.RATE, seed), tx, ty);
+      else if (bW) place(sparse(cfg.WALL_L, cfg.WALL_L_VAR, wx, wy, 3, cfg.RATE, seed), tx, ty);
+      else if (bE) place(sparse(cfg.WALL_R, cfg.WALL_R_VAR, wx, wy, 4, cfg.RATE, seed), tx, ty);
+    } else {
+      for (let k = 1; k <= cfg.FACE_H; k++) {
+        if (raised(wx, wy - k)) {
+          const leftEnd = !raised(wx - 1, wy - k), rightEnd = !raised(wx + 1, wy - k);
+          place(leftEnd ? cfg.FACE_L[k - 1] : rightEnd ? cfg.FACE_R[k - 1] : sparse(cfg.FACE[k - 1], cfg.FACE_VAR[k - 1], wx, wy, 5 + k, cfg.RATE, seed), tx, ty);
+          break;
+        }
+      }
+    }
+  }
+}
 
 // ../auto-battler/src/render/orcKingdom.js
 var ORC = "/assets/minifantasy/Minifantasy_Orc_Kingdom_v1.0/Minifantasy_Orc_Kingdom_Assets";
@@ -890,6 +915,15 @@ var FOREST_SCALE = 0.05;
 function forestField(seed, x, y) {
   return fbm(sub3(seed, 15740503), x * FOREST_SCALE, y * FOREST_SCALE);
 }
+var STONE_CLUMP_SCALE = 0.11;
+function stoneClumpField(seed, x, y) {
+  return fbm(sub3(seed, 5702849), x * STONE_CLUMP_SCALE, y * STONE_CLUMP_SCALE);
+}
+var ELEV_SCALE = 0.025;
+var ELEV_THRESHOLD = 0.6;
+function isRaised(seed, x, y) {
+  return fbm(sub3(seed, 57836), x * ELEV_SCALE, y * ELEV_SCALE) > ELEV_THRESHOLD;
+}
 var RIVER_SCALE = 0.022;
 var RIVER_WIDTH = 0.035;
 var WARP_SCALE2 = 0.03;
@@ -912,9 +946,9 @@ var FP_MOCKUP_URL = `${FP}/Minifantasy_ForgottenPlainsMockup.png`;
 var FP_MAP_ASSETS = [TILES2, SHADOW, PROPS, PROP_SHADOW];
 var TILE3 = 8;
 var CHUNK2 = 32;
-var GRASS_BASE = [2, 4];
-var GRASS_VARS = [[1, 1], [2, 1], [3, 1], [4, 1]];
-var GRASS_RATE = 5;
+var GRASS_BASE = [37, 11];
+var GRASS_VARS = [...rect(1, 1, 4, 1), ...rect(2, 3, 3, 5)];
+var GRASS_RATE = 9;
 var DIRT_BLOCK = [7, 3];
 var DIRT_FILL = [8, 4];
 var DIRT_VARS2 = [[7, 1], [8, 1], [9, 1]];
@@ -925,21 +959,54 @@ var WATER_BLOCK = [25, 3];
 var WATER_FILL = [26, 4];
 var WATER_VARS = [[26, 4]];
 var FILL_RATE = 6;
+var FP_CLIFF = {
+  LIP_T: [25, 16],
+  LIP_T_VAR: [],
+  LIP_TL: [24, 16],
+  LIP_TR: [26, 16],
+  WALL_L: [24, 17],
+  WALL_L_VAR: [],
+  WALL_R: [26, 17],
+  WALL_R_VAR: [],
+  LIP_S: [25, 18],
+  LIP_S_VAR: [],
+  LIP_SW: [24, 18],
+  LIP_SE: [26, 18],
+  FACE_H: 2,
+  FACE: [[25, 19], [25, 20]],
+  FACE_VAR: [[], []],
+  FACE_L: [[24, 19], [24, 20]],
+  FACE_R: [[26, 19], [26, 20]],
+  RATE: 4
+};
+var COL_CLIFF = [150, 138, 112];
 var FOLIAGE = [
-  { tiles: [[9, 6], [10, 6], [11, 6]], weight: 4 },
-  // grass tufts (most common)
-  { tiles: [[9, 9], [10, 9], [11, 9]], weight: 2 },
-  // flowers (red / purple / daisy)
-  { tiles: [[12, 6], [13, 6], [14, 6]], weight: 1 }
+  { weight: 5, tiles: [[9, 6], [10, 6], [11, 6]] },
+  // grass tufts
+  { weight: 3, tiles: [[12, 6], [13, 6]] },
   // small reeds
+  { weight: 3, tiles: [[9, 9], [10, 9], [11, 9], [12, 9], [13, 9]] },
+  // flowers (red/purple/daisy) + small grass
+  { weight: 1, sprite: { c: 14, r: 6, w: 1, h: 3 } },
+  // tall reed 1×3
+  { weight: 1, sprite: { c: 15, r: 6, w: 2, h: 3 } },
+  // wide reed 2×3
+  { weight: 1, sprite: { c: 17, r: 6, w: 2, h: 3 } },
+  // wide reed 2×3
+  { weight: 1, sprite: { c: 14, r: 9, w: 1, h: 2 } }
+  // cattail 1×2
 ];
 var FOLIAGE_WEIGHT = FOLIAGE.reduce((s, g) => s + g.weight, 0);
 var FOLIAGE_RATE = 11;
+var WATER_FOLIAGE = { c: 15, r: 9, w: 1, h: 2 };
+var WATER_FOLIAGE_RATE = 16;
 var TREES = [
   { frame: [155, 3, 21, 25], ax: 0.48, ay: 0.96 },
-  // tree 1
-  { frame: [155, 35, 21, 25], ax: 0.48, ay: 0.96 }
+  // tree 1 (plain)
+  { frame: [155, 35, 21, 25], ax: 0.48, ay: 0.96 },
   // tree 2 (fruited)
+  { frame: [152, 32, 24, 32], ax: 0.5, ay: 0.94 }
+  // tree 3 — full 3×4 fruited (19,4)
 ];
 var TREE_SCALE_BASE = 1;
 var TREE_SCALE_JITTER = 0.14;
@@ -950,6 +1017,32 @@ var FOREST_BLOCK_Y = 2;
 var FOREST_THRESHOLD = 0.6;
 var FOREST_MIN_NB = 2;
 var FOREST_FILL = 0.5;
+var STONES = [
+  { c: 8, r: 3, w: 2, h: 2, weight: 3 },
+  // small rock
+  { c: 10, r: 3, w: 2, h: 2, weight: 3 },
+  // small rock
+  { c: 12, r: 3, w: 2, h: 2, weight: 3 },
+  // small flat rock
+  { c: 14, r: 3, w: 2, h: 2, weight: 3 },
+  // small rock
+  { c: 16, r: 3, w: 2, h: 2, weight: 3 },
+  // small rock
+  { c: 6, r: 3, w: 2, h: 3, weight: 2 },
+  // medium boulder
+  { c: 0, r: 3, w: 2, h: 4, weight: 1 },
+  // big boulder
+  { c: 2, r: 3, w: 2, h: 4, weight: 1 },
+  // big boulder
+  { c: 4, r: 3, w: 2, h: 4, weight: 1 }
+  // big knobbly boulder
+];
+var STONE_WEIGHT = STONES.reduce((s, g) => s + g.weight, 0);
+var STONE_BLOCK_X = 2;
+var STONE_BLOCK_Y = 2;
+var STONE_CLUMP_THRESHOLD = 0.7;
+var STONE_CLUMP_MIN_NB = 3;
+var STONE_CLUMP_FILL = 0.7;
 var COL_GRASS2 = [97, 150, 55];
 var COL_DIRT2 = [118, 80, 38];
 var COL_STONE = [120, 120, 122];
@@ -1006,6 +1099,8 @@ function chunkFields2(seed, x0, y0) {
     return cur;
   };
   const waterF = clean((x, y) => isRiver(seed, x, y));
+  const raisedField = clean((x, y) => isRaised(seed, x, y));
+  for (let k = 0; k < waterF.length; k++) if (raisedField[k]) waterF[k] = 0;
   const dirtRaw = clean((x, y) => isDirt(seed, x, y));
   const stoneRaw = clean((x, y) => isStone(seed, x, y));
   const fraw = new Uint8Array(SZ * SZ);
@@ -1017,6 +1112,15 @@ function chunkFields2(seed, x0, y0) {
     for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) if ((di || dj) && fraw[idx(i + di, j + dj)]) c++;
     forestRegion[idx(i, j)] = c >= FOREST_MIN_NB ? 1 : 0;
   }
+  const sraw = new Uint8Array(SZ * SZ);
+  for (let j = 0; j < SZ; j++) for (let i = 0; i < SZ; i++) sraw[idx(i, j)] = stoneClumpField(seed, x0 + i - M, y0 + j - M) > STONE_CLUMP_THRESHOLD ? 1 : 0;
+  const stoneClumpRegion = new Uint8Array(SZ * SZ);
+  for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
+    if (!sraw[idx(i, j)]) continue;
+    let c = 0;
+    for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) if ((di || dj) && sraw[idx(i + di, j + dj)]) c++;
+    stoneClumpRegion[idx(i, j)] = c >= STONE_CLUMP_MIN_NB ? 1 : 0;
+  }
   const dirt = new Uint8Array(SZ * SZ), stone = new Uint8Array(SZ * SZ);
   for (let j = WATER_BUFFER; j < SZ - WATER_BUFFER; j++) for (let i = WATER_BUFFER; i < SZ - WATER_BUFFER; i++) {
     let nearW = 0;
@@ -1024,10 +1128,11 @@ function chunkFields2(seed, x0, y0) {
       nearW = 1;
       break;
     }
-    dirt[idx(i, j)] = dirtRaw[idx(i, j)] && !nearW ? 1 : 0;
-    stone[idx(i, j)] = stoneRaw[idx(i, j)] && !dirtRaw[idx(i, j)] && !nearW ? 1 : 0;
+    const rais = raisedField[idx(i, j)];
+    dirt[idx(i, j)] = dirtRaw[idx(i, j)] && !nearW && !rais ? 1 : 0;
+    stone[idx(i, j)] = stoneRaw[idx(i, j)] && !dirtRaw[idx(i, j)] && !nearW && !rais ? 1 : 0;
   }
-  return { waterF, dirt, stone, forestRegion, M, SZ, x0, y0 };
+  return { waterF, dirt, stone, raisedField, forestRegion, stoneClumpRegion, M, SZ, x0, y0 };
 }
 var FP_GROUND_FILLS = [
   { key: "grass", url: TILES2, tile: GRASS_BASE },
@@ -1078,11 +1183,12 @@ var fpConfig = (seed) => ({
   // standalone map is unchanged; the multi-biome overworld passes a per-biome dither mask.
   bake({ x0, y0, seed: seed2, ctx, tmp, Sprite, tex, texFrame, add, accept = () => true }) {
     const f = chunkFields2(seed2, x0, y0);
-    const { waterF, dirt, stone, forestRegion, M, SZ } = f;
+    const { waterF, dirt, stone, raisedField, forestRegion, stoneClumpRegion, M, SZ } = f;
     const idx = (i, j) => j * SZ + i;
     const atW = (wx, wy) => waterF[idx(wx - x0 + M, wy - y0 + M)] === 1;
     const atD = (wx, wy) => dirt[idx(wx - x0 + M, wy - y0 + M)] === 1;
     const atS = (wx, wy) => stone[idx(wx - x0 + M, wy - y0 + M)] === 1;
+    const isRaisedAt = (wx, wy) => raisedField[idx(wx - x0 + M, wy - y0 + M)] === 1;
     const place = (coord, tx, ty) => {
       add(ctx.tiles, coord[0], coord[1], tx, ty);
       if (ctx.shadow && (!ctx.shadowSet || ctx.shadowSet.has(coord[0] + "," + coord[1]))) {
@@ -1117,10 +1223,23 @@ var fpConfig = (seed) => ({
       if (atS(wx, wy)) blob(atS, STONE_BLOCK, STONE_FILL, STONE_VARS, 2, wx, wy, tx, ty);
       if (atW(wx, wy)) blob(atW, WATER_BLOCK, WATER_FILL, WATER_VARS, 3, wx, wy, tx, ty);
     }
+    const live = [];
+    const propSprite = (spec, wx, wy) => {
+      const sp = new Sprite(texFrame(ctx.props, spec.c * TILE3, (spec.r - spec.h + 1) * TILE3, spec.w * TILE3, spec.h * TILE3));
+      sp.anchor.set(0.5, 1);
+      sp.x = wx * TILE3 + TILE3 / 2;
+      sp.y = (wy + 1) * TILE3;
+      sp.zIndex = (wy + 1) * TILE3;
+      return sp;
+    };
     if (ctx.props) for (let ty = 0; ty < CHUNK2; ty++) for (let tx = 0; tx < CHUNK2; tx++) {
       if (!accept(tx, ty)) continue;
       const wx = x0 + tx, wy = y0 + ty;
-      if (atW(wx, wy) || atD(wx, wy) || atS(wx, wy)) continue;
+      if (atW(wx, wy)) {
+        if (hashU32(seed2 ^ 24301, wx, wy) % WATER_FOLIAGE_RATE === 0) live.push({ sprite: propSprite(WATER_FOLIAGE, wx, wy), shadow: null });
+        continue;
+      }
+      if (atD(wx, wy) || atS(wx, wy)) continue;
       const h2 = hashU32(seed2 ^ 15733114, wx, wy);
       if (h2 % FOLIAGE_RATE !== 0) continue;
       let pick = (h2 >>> 8) % FOLIAGE_WEIGHT, g = FOLIAGE[0];
@@ -1131,13 +1250,17 @@ var fpConfig = (seed) => ({
         }
         pick -= grp.weight;
       }
+      if (g.sprite) {
+        live.push({ sprite: propSprite(g.sprite, wx, wy), shadow: null });
+        continue;
+      }
       const [c, r] = g.tiles[(h2 >>> 16) % g.tiles.length];
       const sp = new Sprite(texFrame(ctx.props, c * TILE3, r * TILE3, TILE3, TILE3));
       sp.x = tx * TILE3;
       sp.y = ty * TILE3;
       tmp.addChild(sp);
     }
-    const live = [];
+    bakeCliffs(FP_CLIFF, { chunk: CHUNK2, x0, y0, seed: seed2, raised: isRaisedAt, place, accept });
     if (ctx.props) {
       const inGrove = (wx, wy) => forestRegion[idx(wx - x0 + M, wy - y0 + M)] === 1;
       const bx0 = Math.floor(x0 / FOREST_BLOCK_X), bx1 = Math.floor((x0 + CHUNK2 - 1) / FOREST_BLOCK_X);
@@ -1150,6 +1273,13 @@ var fpConfig = (seed) => ({
         if (!inGrove(wx, wy)) continue;
         if ((h2 >>> 8 & 65535) / 65536 >= FOREST_FILL) continue;
         if (atW(wx, wy) || atS(wx, wy)) continue;
+        if (isRaisedAt(wx, wy)) continue;
+        let onFace = false;
+        for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
+          onFace = true;
+          break;
+        }
+        if (onFace) continue;
         const T = TREES[(h2 >>> 24) % TREES.length];
         const flip = (h2 >>> 20 & 255) / 256 < TREE_FLIP_RATE;
         const sc = TREE_SCALE_BASE * (1 + ((h2 >>> 12 & 255) / 256 - 0.5) * 2 * TREE_SCALE_JITTER);
@@ -1172,13 +1302,43 @@ var fpConfig = (seed) => ({
         live.push({ sprite: tr, shadow });
       }
     }
+    if (ctx.props) {
+      const inClump = (wx, wy) => stoneClumpRegion[idx(wx - x0 + M, wy - y0 + M)] === 1;
+      const sbx0 = Math.floor(x0 / STONE_BLOCK_X), sbx1 = Math.floor((x0 + CHUNK2 - 1) / STONE_BLOCK_X);
+      const sby0 = Math.floor(y0 / STONE_BLOCK_Y), sby1 = Math.floor((y0 + CHUNK2 - 1) / STONE_BLOCK_Y);
+      for (let by = sby0; by <= sby1; by++) for (let bx = sbx0; bx <= sbx1; bx++) {
+        const h2 = hashU32(seed2 ^ 5702885, bx, by);
+        const wx = bx * STONE_BLOCK_X + h2 % STONE_BLOCK_X, wy = by * STONE_BLOCK_Y + (h2 >>> 4) % STONE_BLOCK_Y;
+        if (wx < x0 || wx >= x0 + CHUNK2 || wy < y0 || wy >= y0 + CHUNK2) continue;
+        if (!accept(wx - x0, wy - y0)) continue;
+        if (!inClump(wx, wy)) continue;
+        if ((h2 >>> 8 & 65535) / 65536 >= STONE_CLUMP_FILL) continue;
+        if (atW(wx, wy) || isRaisedAt(wx, wy)) continue;
+        let onFace = false;
+        for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
+          onFace = true;
+          break;
+        }
+        if (onFace) continue;
+        let pick = (h2 >>> 20) % STONE_WEIGHT, st = STONES[0];
+        for (const s of STONES) {
+          if (pick < s.weight) {
+            st = s;
+            break;
+          }
+          pick -= s.weight;
+        }
+        live.push({ sprite: propSprite(st, wx, wy), shadow: null });
+      }
+    }
     return { meta: f, live };
   },
   macroColor(seed2, tx, ty) {
-    if (isRiver(seed2, tx, ty)) return COL_WATER;
-    if (isStone(seed2, tx, ty) && !isDirt(seed2, tx, ty)) return COL_STONE;
-    if (isDirt(seed2, tx, ty)) return COL_DIRT2;
-    return COL_GRASS2;
+    const raised = isRaised(seed2, tx, ty);
+    if (!raised && isRiver(seed2, tx, ty)) return COL_WATER;
+    let c = isStone(seed2, tx, ty) && !isDirt(seed2, tx, ty) ? COL_STONE : isDirt(seed2, tx, ty) ? COL_DIRT2 : COL_GRASS2;
+    if (raised) c = lerp3(c, COL_CLIFF, 0.25);
+    return c;
   },
   tileIndexAt(wx, wy, meta) {
     if (!meta) return null;
@@ -1217,10 +1377,10 @@ var DARK_THRESHOLD = 0.6;
 function isDark(seed, x, y) {
   return fbm(sub4(seed, 55852), x * DARK_SCALE, y * DARK_SCALE) > DARK_THRESHOLD;
 }
-var ELEV_SCALE = 0.025;
-var ELEV_THRESHOLD = 0.6;
-function isRaised(seed, x, y) {
-  return fbm(sub4(seed, 57836), x * ELEV_SCALE, y * ELEV_SCALE) > ELEV_THRESHOLD;
+var ELEV_SCALE2 = 0.025;
+var ELEV_THRESHOLD2 = 0.6;
+function isRaised2(seed, x, y) {
+  return fbm(sub4(seed, 57836), x * ELEV_SCALE2, y * ELEV_SCALE2) > ELEV_THRESHOLD2;
 }
 var BONE_SCALE = 0.055;
 var BONE_THRESHOLD = 0.62;
@@ -1295,6 +1455,26 @@ var FACE_VAR = [[[2, 16], [4, 16], [5, 16]], [[2, 17], [4, 17], [5, 17]]];
 var FACE_L = [[1, 16], [1, 17]];
 var FACE_R = [[6, 16], [6, 17]];
 var CLIFF_SPARSE_RATE = 2;
+var NECRO_CLIFF = {
+  LIP_T,
+  LIP_T_VAR,
+  LIP_TL,
+  LIP_TR,
+  WALL_L,
+  WALL_L_VAR,
+  WALL_R,
+  WALL_R_VAR,
+  LIP_S,
+  LIP_S_VAR,
+  LIP_SW,
+  LIP_SE,
+  FACE_H,
+  FACE,
+  FACE_VAR,
+  FACE_L,
+  FACE_R,
+  RATE: CLIFF_SPARSE_RATE
+};
 var CORRUPT_LIGHT = [1, 1];
 var CORRUPT_DARK = [2, 1];
 var NECRO_GROUND_FILLS = [
@@ -1327,7 +1507,7 @@ var COL_LIGHT = [130, 119, 136];
 var COL_DARK = [105, 99, 113];
 var COL_WATER2 = [74, 142, 48];
 var COL_BONE = [180, 156, 126];
-var COL_CLIFF = [175, 146, 109];
+var COL_CLIFF2 = [175, 146, 109];
 var COL_FOREST = [96, 101, 70];
 var NECRO_LAYERS = [
   ["m-bg", "Background", "ground"],
@@ -1377,12 +1557,12 @@ function boneCenterTile([c0, r0], dNW, dNE, dSW, dSE) {
   return [c0 + 1, r0 + 1];
 }
 function biomeColor(seed, tx, ty) {
-  const raised = isRaised(seed, tx, ty);
+  const raised = isRaised2(seed, tx, ty);
   if (!raised && isRiver2(seed, tx, ty)) return COL_WATER2;
   if (isBone(seed, tx, ty)) return COL_BONE;
   let c = isDark(seed, tx, ty) ? COL_DARK : COL_LIGHT;
   if (forestField2(seed, tx, ty) > FOREST_THRESHOLD2) c = lerp3(c, COL_FOREST, 0.5);
-  if (raised) c = lerp3(c, COL_CLIFF, 0.22);
+  if (raised) c = lerp3(c, COL_CLIFF2, 0.22);
   return c;
 }
 function loadImg2(url) {
@@ -1439,7 +1619,7 @@ function chunkFields3(seed, x0, y0) {
   };
   const darkRaw = clean((x, y) => isDark(seed, x, y));
   const waterField = clean((x, y) => isRiver2(seed, x, y));
-  const raisedField = clean((x, y) => isRaised(seed, x, y));
+  const raisedField = clean((x, y) => isRaised2(seed, x, y));
   const boneField = clean((x, y) => isBone(seed, x, y));
   const fraw = new Uint8Array(SZ * SZ);
   for (let j = 0; j < SZ; j++) for (let i = 0; i < SZ; i++) fraw[idx(i, j)] = forestField2(seed, x0 + i - M, y0 + j - M) > FOREST_THRESHOLD2 ? 1 : 0;
@@ -1614,29 +1794,7 @@ var necropolisConfig = (seed) => ({
       sp.y = ty * TILE4;
       tmp.addChild(sp);
     }
-    for (let ty = 0; ty < CHUNK3; ty++) for (let tx = 0; tx < CHUNK3; tx++) {
-      if (!accept(tx, ty)) continue;
-      const wx = x0 + tx, wy = y0 + ty;
-      if (isRaisedAt(wx, wy)) {
-        const bN = !isRaisedAt(wx, wy - 1), bE = !isRaisedAt(wx + 1, wy), bS = !isRaisedAt(wx, wy + 1), bW = !isRaisedAt(wx - 1, wy);
-        if (bN && bW) place(LIP_TL, tx, ty);
-        else if (bN && bE) place(LIP_TR, tx, ty);
-        else if (bS && bW) place(LIP_SW, tx, ty);
-        else if (bS && bE) place(LIP_SE, tx, ty);
-        else if (bN) place(sparse(LIP_T, LIP_T_VAR, wx, wy, 1, CLIFF_SPARSE_RATE, seed2), tx, ty);
-        else if (bS) place(sparse(LIP_S, LIP_S_VAR, wx, wy, 2, CLIFF_SPARSE_RATE, seed2), tx, ty);
-        else if (bW) place(sparse(WALL_L, WALL_L_VAR, wx, wy, 3, CLIFF_SPARSE_RATE, seed2), tx, ty);
-        else if (bE) place(sparse(WALL_R, WALL_R_VAR, wx, wy, 4, CLIFF_SPARSE_RATE, seed2), tx, ty);
-      } else {
-        for (let k = 1; k <= FACE_H; k++) {
-          if (isRaisedAt(wx, wy - k)) {
-            const leftEnd = !isRaisedAt(wx - 1, wy - k), rightEnd = !isRaisedAt(wx + 1, wy - k);
-            place(leftEnd ? FACE_L[k - 1] : rightEnd ? FACE_R[k - 1] : sparse(FACE[k - 1], FACE_VAR[k - 1], wx, wy, 5 + k, CLIFF_SPARSE_RATE, seed2), tx, ty);
-            break;
-          }
-        }
-      }
-    }
+    bakeCliffs(NECRO_CLIFF, { chunk: CHUNK3, x0, y0, seed: seed2, raised: isRaisedAt, place, accept });
     const live = [];
     if (ctx.props) {
       const nearWater = (wx, wy) => {