@adatechnology/game-terrain 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1068 @@
+// src/catalog.ts
+var TERRAIN_MATERIALS = [
+  {
+    id: "turf",
+    debris: "clods",
+    rimShare: 0.25,
+    reposeDegrees: 55,
+    color: [0.09, 0.2, 0.04],
+    pattern: "grass",
+    hits: {
+      ballistic: { specificEnergy: 3e6, aspect: 0.6 },
+      blunt: { specificEnergy: 2e6, aspect: 0.2, thresholdJoules: 60 },
+      slash: { specificEnergy: 3e5, aspect: 0.5 },
+      explosive: { specificEnergy: 3e6, aspect: 0.45 }
+    },
+    fire: { maxScorch: 1, scorchPerSecond: 0.45, flammable: true }
+  },
+  {
+    id: "soil",
+    debris: "clods",
+    rimShare: 0.35,
+    reposeDegrees: 40,
+    color: [0.2, 0.12, 0.06],
+    pattern: "soil",
+    hits: {
+      ballistic: { specificEnergy: 4e6, aspect: 0.6 },
+      blunt: { specificEnergy: 2e6, aspect: 0.2, thresholdJoules: 60 },
+      slash: { specificEnergy: 3e5, aspect: 0.5 },
+      explosive: { specificEnergy: 4e6, aspect: 0.45 }
+    },
+    fire: { maxScorch: 0.6, scorchPerSecond: 0.15 }
+  },
+  {
+    id: "sand",
+    debris: "dust",
+    rimShare: 0.5,
+    reposeDegrees: 33,
+    color: [0.62, 0.5, 0.3],
+    pattern: "sand",
+    hits: {
+      ballistic: { specificEnergy: 25e5, aspect: 0.5 },
+      blunt: { specificEnergy: 1e6, aspect: 0.2, thresholdJoules: 30 },
+      slash: { specificEnergy: 15e4, aspect: 0.5 },
+      explosive: { specificEnergy: 3e6, aspect: 0.35 }
+    },
+    fire: { maxScorch: 0.2, scorchPerSecond: 0.05 }
+  },
+  {
+    id: "gravel",
+    debris: "chips",
+    rimShare: 0.3,
+    reposeDegrees: 38,
+    color: [0.27, 0.25, 0.22],
+    pattern: "stone",
+    hits: {
+      ballistic: { specificEnergy: 8e6, aspect: 0.4 },
+      blunt: { specificEnergy: 8e6, aspect: 0.2, thresholdJoules: 200 },
+      slash: { specificEnergy: 3e7, aspect: 0.3, thresholdJoules: 400 },
+      explosive: { specificEnergy: 1e7, aspect: 0.35 }
+    },
+    fire: { maxScorch: 0.3, scorchPerSecond: 0.06 }
+  },
+  {
+    id: "asphalt",
+    debris: "chips",
+    color: [0.05, 0.05, 0.055],
+    pattern: "asphalt",
+    hits: {
+      ballistic: { specificEnergy: 3e7, aspect: 0.2, minRadius: 0.03 },
+      blunt: { specificEnergy: 1e8, aspect: 0.1, thresholdJoules: 400 },
+      slash: { specificEnergy: 3e8, aspect: 0.2, thresholdJoules: 400 },
+      explosive: { specificEnergy: 2e8, aspect: 0.12 }
+    },
+    fire: { maxScorch: 0.85, scorchPerSecond: 0.1, burnsAway: 5e-5 }
+  },
+  {
+    id: "concrete",
+    debris: "chips",
+    color: [0.33, 0.33, 0.31],
+    pattern: "concrete",
+    hits: {
+      ballistic: { specificEnergy: 15e7, aspect: 0.14, minRadius: 0.018 },
+      blunt: { specificEnergy: 3e8, aspect: 0.08, thresholdJoules: 800 },
+      slash: { specificEnergy: 1e9, aspect: 0.2, thresholdJoules: 800 },
+      explosive: { specificEnergy: 27e8, aspect: 0.12 }
+    },
+    fire: { maxScorch: 0.45, scorchPerSecond: 0.08 }
+  },
+  {
+    id: "mortar",
+    debris: "chips",
+    color: [0.42, 0.4, 0.36],
+    pattern: "plain",
+    hits: {
+      ballistic: { specificEnergy: 4e7, aspect: 0.2 },
+      blunt: { specificEnergy: 8e7, aspect: 0.1, thresholdJoules: 300 },
+      slash: { specificEnergy: 3e8, aspect: 0.2, thresholdJoules: 300 },
+      explosive: { specificEnergy: 8e8, aspect: 0.14 }
+    },
+    fire: { maxScorch: 0.45, scorchPerSecond: 0.08 }
+  },
+  {
+    id: "ceramic",
+    debris: "shards",
+    color: [0.72, 0.7, 0.66],
+    pattern: "tile",
+    hits: {
+      ballistic: { specificEnergy: 8e6, aspect: 0.1, minRadius: 0.05 },
+      blunt: { specificEnergy: 1e7, aspect: 0.08, thresholdJoules: 80, minRadius: 0.06 },
+      slash: { specificEnergy: 2e8, aspect: 0.1, thresholdJoules: 200, minRadius: 0.03 },
+      explosive: { specificEnergy: 1e8, aspect: 0.03, minRadius: 0.12 }
+    },
+    fire: { maxScorch: 0.5, scorchPerSecond: 0.08 }
+  },
+  {
+    id: "wood_hard",
+    debris: "splinters",
+    color: [0.3, 0.16, 0.07],
+    pattern: "planks",
+    hits: {
+      ballistic: { specificEnergy: 25e6, aspect: 0.35, minRadius: 0.012 },
+      blunt: { specificEnergy: 8e7, aspect: 0.1, thresholdJoules: 120 },
+      slash: { specificEnergy: 15e6, aspect: 0.4, thresholdJoules: 15 },
+      explosive: { specificEnergy: 2e8, aspect: 0.1, minRadius: 0.1 }
+    },
+    fire: { maxScorch: 1, scorchPerSecond: 0.2, burnsAway: 12e-4, flammable: true }
+  },
+  {
+    id: "stone",
+    debris: "chips",
+    color: [0.23, 0.22, 0.2],
+    pattern: "stone",
+    hits: {
+      ballistic: { specificEnergy: 25e7, aspect: 0.12, minRadius: 0.015 },
+      blunt: { specificEnergy: 5e8, aspect: 0.08, thresholdJoules: 1500 },
+      slash: { specificEnergy: 2e9, aspect: 0.2, thresholdJoules: 1500 },
+      explosive: { specificEnergy: 4e9, aspect: 0.14 }
+    },
+    fire: { maxScorch: 0.4, scorchPerSecond: 0.06 }
+  }
+];
+var TERRAIN_PROFILES = [
+  { id: "lawn", strata: [{ material: "turf", thickness: 0.05 }, { material: "soil", thickness: 1.5 }, { material: "stone", thickness: 0.5 }] },
+  { id: "dirt", strata: [{ material: "soil", thickness: 1.8 }, { material: "stone", thickness: 0.5 }] },
+  { id: "sand", strata: [{ material: "sand", thickness: 2.5 }] },
+  { id: "road", strata: [{ material: "asphalt", thickness: 0.05 }, { material: "gravel", thickness: 0.25 }, { material: "soil", thickness: 1.5 }] },
+  { id: "concrete_slab", strata: [{ material: "concrete", thickness: 0.12, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+  { id: "suspended_slab", drop: 3, strata: [{ material: "concrete", thickness: 0.12, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+  { id: "tile_floor", strata: [{ material: "ceramic", thickness: 8e-3 }, { material: "mortar", thickness: 0.03 }, { material: "concrete", thickness: 0.1, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+  { id: "wood_floor", strata: [{ material: "wood_hard", thickness: 0.022 }, { material: "mortar", thickness: 0.03 }, { material: "concrete", thickness: 0.1, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+  { id: "stone_paving", strata: [{ material: "stone", thickness: 0.08 }, { material: "gravel", thickness: 0.2 }, { material: "soil", thickness: 1.2 }] }
+];
+var DEFAULT_BAR_YIELD_JOULES = 24e5;
+var DEFAULT_PROFILE = "concrete_slab";
+
+// src/debris.ts
+var REST_SPEED = 0.6;
+var RESTITUTION = 0.25;
+var FRICTION = 0.55;
+var MAX_BOUNCES = 2;
+var REST_GAP = 0.01;
+function createDebrisStore(max) {
+  const list = [];
+  let serial = 0;
+  function makeRoom() {
+    if (list.length < max()) return;
+    let at = 0;
+    let oldest = Infinity;
+    let oldestResting = -1;
+    let restingBorn = Infinity;
+    list.forEach((piece, index) => {
+      if (piece.born < oldest) {
+        oldest = piece.born;
+        at = index;
+      }
+      if (piece.atRest && piece.born < restingBorn) {
+        restingBorn = piece.born;
+        oldestResting = index;
+      }
+    });
+    list.splice(oldestResting >= 0 ? oldestResting : at, 1);
+  }
+  return {
+    list,
+    throwPiece(spec) {
+      makeRoom();
+      list.push({ ...spec, id: ++serial, born: serial, atRest: false, bounces: 0 });
+    },
+    update(dt, world) {
+      for (let i = list.length - 1; i >= 0; i--) {
+        const piece = list[i];
+        if (piece.atRest) {
+          const under = world.heightAt(piece.position[0], piece.position[2]) + piece.radius * 0.6;
+          if (piece.position[1] > under + REST_GAP) piece.atRest = false;
+          else if (piece.position[1] < under - REST_GAP) piece.position[1] = under;
+          if (piece.atRest) continue;
+        }
+        const { position, velocity } = piece;
+        velocity[1] -= world.gravity * dt;
+        position[0] += velocity[0] * dt;
+        position[1] += velocity[1] * dt;
+        position[2] += velocity[2] * dt;
+        const ground = world.heightAt(position[0], position[2]) + piece.radius * 0.6;
+        if (position[1] > ground) continue;
+        position[1] = ground;
+        const speed = Math.hypot(velocity[0], velocity[1], velocity[2]);
+        if (speed < REST_SPEED || piece.bounces >= MAX_BOUNCES) {
+          piece.atRest = true;
+          if (world.settle(piece)) list.splice(i, 1);
+          continue;
+        }
+        piece.bounces++;
+        velocity[1] = Math.abs(velocity[1]) * RESTITUTION;
+        velocity[0] *= FRICTION;
+        velocity[2] *= FRICTION;
+      }
+    },
+    clear() {
+      list.length = 0;
+    }
+  };
+}
+
+// src/marks.ts
+var SAME_HOLE = 0.75;
+function createMarkStore(budget) {
+  const list = [];
+  const areas = /* @__PURE__ */ new Map();
+  let serial = 0;
+  let version = 0;
+  const areaKey = (x, z) => Math.floor(x / budget.markAreaSize) * 100003 + Math.floor(z / budget.markAreaSize);
+  function detach(mark) {
+    const key = areaKey(mark.x, mark.z);
+    const area = areas.get(key);
+    if (area) {
+      const at2 = area.indexOf(mark);
+      if (at2 >= 0) area.splice(at2, 1);
+      if (area.length === 0) areas.delete(key);
+    }
+    const at = list.indexOf(mark);
+    if (at >= 0) list.splice(at, 1);
+    version++;
+  }
+  function attach(mark) {
+    const key = areaKey(mark.x, mark.z);
+    const area = areas.get(key);
+    if (area) area.push(mark);
+    else areas.set(key, [mark]);
+    list.push(mark);
+    version++;
+  }
+  function mergeClosestPair(area) {
+    let bestA = area[0];
+    let bestB = area[1];
+    let best = Infinity;
+    for (let i = 0; i < area.length; i++) {
+      for (let j = i + 1; j < area.length; j++) {
+        const distance = Math.hypot(area[i].x - area[j].x, area[i].z - area[j].z);
+        if (distance < best) {
+          best = distance;
+          bestA = area[i];
+          bestB = area[j];
+        }
+      }
+    }
+    const weight = bestA.radius ** 2 + bestB.radius ** 2;
+    const shareB = weight > 0 ? bestB.radius ** 2 / weight : 0.5;
+    detach(bestB);
+    bestA.x += (bestB.x - bestA.x) * shareB;
+    bestA.z += (bestB.z - bestA.z) * shareB;
+    bestA.radius = Math.sqrt(weight);
+    bestA.depth = Math.max(bestA.depth, bestB.depth);
+    bestA.count += bestB.count;
+    version++;
+  }
+  return {
+    list,
+    add(spec) {
+      const mark = { ...spec, id: ++serial, count: 1, born: serial };
+      attach(mark);
+      const area = areas.get(areaKey(mark.x, mark.z));
+      if (area.length > budget.maxMarksPerArea) mergeClosestPair(area);
+      if (list.length > budget.maxMarks) detach(list.reduce((oldest, candidate) => candidate.born < oldest.born ? candidate : oldest));
+      return mark;
+    },
+    near(x, z, radius) {
+      let found;
+      let best = Infinity;
+      const reach = Math.ceil((radius + 0.5) / budget.markAreaSize);
+      const baseX = Math.floor(x / budget.markAreaSize);
+      const baseZ = Math.floor(z / budget.markAreaSize);
+      for (let dx = -reach; dx <= reach; dx++) {
+        for (let dz = -reach; dz <= reach; dz++) {
+          for (const mark of areas.get((baseX + dx) * 100003 + baseZ + dz) ?? []) {
+            const distance = Math.hypot(mark.x - x, mark.z - z);
+            if (distance < best && distance < Math.max(mark.radius, radius) * SAME_HOLE) {
+              best = distance;
+              found = mark;
+            }
+          }
+        }
+      }
+      return found;
+    },
+    depthAt(x, z) {
+      let depth = 0;
+      for (const mark of areas.get(areaKey(x, z)) ?? []) {
+        const distance = Math.hypot(mark.x - x, mark.z - z);
+        if (distance < mark.radius) depth = Math.max(depth, mark.depth * (1 - (distance / mark.radius) ** 2));
+      }
+      return depth;
+    },
+    remove: detach,
+    removeInside(x, z, radius) {
+      for (const mark of [...list]) if (Math.hypot(mark.x - x, mark.z - z) + mark.radius * 0.5 < radius) detach(mark);
+    },
+    clear() {
+      list.length = 0;
+      areas.clear();
+      version++;
+    },
+    load(marks) {
+      this.clear();
+      for (const mark of marks) {
+        attach({ ...mark });
+        serial = Math.max(serial, mark.id);
+      }
+    },
+    get version() {
+      return version;
+    }
+  };
+}
+
+// src/random.ts
+function createRandom(seed) {
+  let state = seed | 0;
+  return () => {
+    state = state + 1831565813 | 0;
+    let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+    mixed = mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed) ^ mixed;
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/terrain.ts
+var DEFAULT_TERRAIN_BUDGET = {
+  markAreaSize: 2,
+  maxMarksPerArea: 24,
+  maxMarks: 800,
+  maxDirtyChunksPerFrame: 6,
+  maxDebris: 400,
+  maxDebrisPerBlow: 36,
+  maxSlideCellsPerFrame: 2500,
+  maxBurningCells: 300
+};
+var GRAVITY = 9.81;
+var FINE_CELLS = 1.5;
+var FINE_DEPTH_CELLS = 0.4;
+var RIGID_WIDENING = 2.5;
+var COLLAPSE_DEPTH_SHARE = 0.75;
+var COLLAPSE_SPREAD_BEND = 0.5;
+var RIM_REACH = 1.45;
+var FLAME_MINIMUM = 200;
+var FLAME_REACH = 0.6;
+var BLAST_HEIGHT_REACH = 0.35;
+var THROW_SHARE = 0.02;
+var FIRE_CELL = 0.5;
+var FIRE_SECONDS = 7;
+var FIRE_SPREAD_PER_SECOND = 0.35;
+var SLIDE_SHARE = 0.4;
+var SLIDE_EPSILON = 2e-3;
+var PIECE_RADIUS = { clods: 0.045, chips: 0.022, shards: 0.028, splinters: 0.02, dust: 0.012 };
+var MAX_PIECE_SPEED = { explosive: 14, ballistic: 5, blunt: 2.5, slash: 1.5 };
+var clampIndex = (value, max) => Math.max(0, Math.min(max, value));
+var sparse = (array) => {
+  const entries = [];
+  array.forEach((value, index) => {
+    if (value !== 0) entries.push([index, value]);
+  });
+  return entries;
+};
+var fillSparse = (array, entries) => {
+  array.fill(0);
+  for (const [index, value] of entries) array[index] = value;
+};
+function stratumAtDepth(profile, depth) {
+  let top = 0;
+  for (let index2 = 0; index2 < profile.strata.length; index2++) {
+    const stratum2 = profile.strata[index2];
+    if (depth < top + stratum2.thickness - 1e-6) return { index: index2, stratum: stratum2, top };
+    top += stratum2.thickness;
+  }
+  const index = profile.strata.length - 1;
+  const stratum = profile.strata[index];
+  return { index, stratum, top: top - stratum.thickness };
+}
+var totalThickness = (profile) => profile.strata.reduce((sum, stratum) => sum + stratum.thickness, 0);
+function createTerrain(options) {
+  const [x0, z0, x1, z1] = options.bounds;
+  const cellSize = options.cellSize ?? 0.1;
+  const chunkCells = options.chunkCells ?? 32;
+  const columns = Math.max(1, Math.ceil((x1 - x0) / cellSize));
+  const rows = Math.max(1, Math.ceil((z1 - z0) / cellSize));
+  const stride = columns + 1;
+  const vertexCount = stride * (rows + 1);
+  const chunksX = Math.ceil(columns / chunkCells);
+  const chunksZ = Math.ceil(rows / chunkCells);
+  const budget = { ...DEFAULT_TERRAIN_BUDGET, ...options.budget };
+  const gravity = options.gravity ?? GRAVITY;
+  const materials = new Map([...TERRAIN_MATERIALS, ...options.materials ?? []].map((material) => [material.id, material]));
+  const profileMap = new Map([...TERRAIN_PROFILES, ...options.profiles ?? []].map((profile) => [profile.id, profile]));
+  const profileList = [...profileMap.values()];
+  for (const profile of profileList) {
+    for (const stratum of profile.strata) if (!materials.has(stratum.material)) throw new Error(`game-terrain: profile "${profile.id}" uses material "${stratum.material}", which has no ground behaviour`);
+  }
+  const indexOfProfile = new Map(profileList.map((profile, index) => [profile.id, index]));
+  const maxDepthOf = profileList.map(totalThickness);
+  const base = new Float32Array(vertexCount);
+  if (options.baseHeight) {
+    for (let row = 0; row <= rows; row++) for (let column = 0; column <= columns; column++) base[row * stride + column] = options.baseHeight(x0 + column * cellSize, z0 + row * cellSize);
+  }
+  const dug = new Float32Array(vertexCount);
+  const loose = new Float32Array(vertexCount);
+  const scorch = new Float32Array(vertexCount);
+  const barBend = new Float32Array(vertexCount);
+  const profileIndex = new Uint8Array(vertexCount);
+  const touched = new Uint8Array(chunksX * chunksZ);
+  const mixed = new Uint8Array(chunksX * chunksZ);
+  const dirty = /* @__PURE__ */ new Set();
+  const marks = createMarkStore(budget);
+  const debrisStore = createDebrisStore(() => budget.maxDebris);
+  const sliding = /* @__PURE__ */ new Set();
+  const burning = /* @__PURE__ */ new Map();
+  const random = createRandom(options.seed ?? 1);
+  let currentLayout = options.layout ?? { surface: DEFAULT_PROFILE };
+  const deformListeners = /* @__PURE__ */ new Set();
+  const emitDeform = (x, z, radius) => {
+    for (const listener of deformListeners) listener({ x, z, radius });
+  };
+  const chunkOfVertex = (column, row) => Math.min(chunksZ - 1, Math.floor(row / chunkCells)) * chunksX + Math.min(chunksX - 1, Math.floor(column / chunkCells));
+  function touchVertex(column, row) {
+    const chunk2 = chunkOfVertex(column, row);
+    touched[chunk2] = 1;
+    dirty.add(chunk2);
+    if (column % chunkCells === 0 && column > 0) markChunk(chunk2 - 1);
+    if (row % chunkCells === 0 && row > 0) markChunk(chunk2 - chunksX);
+    if (column % chunkCells === 0 && row % chunkCells === 0 && column > 0 && row > 0) markChunk(chunk2 - chunksX - 1);
+  }
+  function markChunk(chunk2) {
+    touched[chunk2] = 1;
+    dirty.add(chunk2);
+  }
+  const profileId = (id) => indexOfProfile.get(id) ?? indexOfProfile.get(DEFAULT_PROFILE) ?? 0;
+  function applyLayout(layout) {
+    currentLayout = layout;
+    profileIndex.fill(profileId(layout.surface));
+    for (const zone of layout.zones ?? []) {
+      const index = profileId(zone.surface);
+      const [zx0, zz0, zx1, zz1] = zone.rect;
+      const column0 = clampIndex(Math.round((zx0 - x0) / cellSize), columns);
+      const column1 = clampIndex(Math.round((zx1 - x0) / cellSize), columns);
+      const row0 = clampIndex(Math.round((zz0 - z0) / cellSize), rows);
+      const row1 = clampIndex(Math.round((zz1 - z0) / cellSize), rows);
+      for (let row = row0; row <= row1; row++) profileIndex.fill(index, row * stride + column0, row * stride + column1 + 1);
+    }
+    for (let chunkZ = 0; chunkZ < chunksZ; chunkZ++) {
+      for (let chunkX = 0; chunkX < chunksX; chunkX++) {
+        const chunk2 = chunkZ * chunksX + chunkX;
+        const first = profileIndex[chunkZ * chunkCells * stride + chunkX * chunkCells];
+        let isMixed = 0;
+        const lastRow = Math.min(rows, (chunkZ + 1) * chunkCells);
+        const lastColumn = Math.min(columns, (chunkX + 1) * chunkCells);
+        for (let row = chunkZ * chunkCells; row <= lastRow && !isMixed; row++) {
+          for (let column = chunkX * chunkCells; column <= lastColumn; column++) {
+            if (profileIndex[row * stride + column] !== first) {
+              isMixed = 1;
+              break;
+            }
+          }
+        }
+        mixed[chunk2] = isMixed;
+        dirty.add(chunk2);
+      }
+    }
+  }
+  const vertexHeight = (column, row) => {
+    const index = row * stride + column;
+    return base[index] - dug[index] + loose[index];
+  };
+  const contains = (x, z) => x >= x0 && x <= x1 && z >= z0 && z <= z1;
+  function heightAt(x, z) {
+    if (!contains(x, z)) return options.baseHeight?.(x, z) ?? 0;
+    const fx = Math.max(0, Math.min(columns - 1e-6, (x - x0) / cellSize));
+    const fz = Math.max(0, Math.min(rows - 1e-6, (z - z0) / cellSize));
+    const column = fx | 0;
+    const row = fz | 0;
+    const tx = fx - column;
+    const tz = fz - row;
+    const index = row * stride + column;
+    const h = (i) => base[i] - dug[i] + loose[i];
+    return (h(index) * (1 - tx) + h(index + 1) * tx) * (1 - tz) + (h(index + stride) * (1 - tx) + h(index + stride + 1) * tx) * tz;
+  }
+  const vertexOf = (x, z) => {
+    const column = clampIndex(Math.round((x - x0) / cellSize), columns);
+    const row = clampIndex(Math.round((z - z0) / cellSize), rows);
+    return { column, row, index: row * stride + column };
+  };
+  function vertexMaterial(column, row) {
+    const index = row * stride + column;
+    return materials.get(stratumAtDepth(profileList[profileIndex[index]], dug[index]).stratum.material);
+  }
+  function columnAt(x, z) {
+    const { index } = vertexOf(x, z);
+    const which = profileIndex[index];
+    const profile = profileList[which];
+    const depth = Math.min(maxDepthOf[which], dug[index] + marks.depthAt(x, z));
+    const layer = stratumAtDepth(profile, depth);
+    return { profile: profile.id, material: layer.stratum.material, stratum: layer.index, depth, remaining: maxDepthOf[which] - depth, scorch: scorch[index], loose: loose[index] };
+  }
+  function removeFromVertex(index, amount) {
+    const fromLoose = Math.min(loose[index], amount);
+    loose[index] = loose[index] - fromLoose;
+    const fromColumn = Math.min(maxDepthOf[profileIndex[index]] - dug[index], amount - fromLoose);
+    if (fromColumn > 0) dug[index] = dug[index] + fromColumn;
+    return fromLoose + Math.max(0, fromColumn);
+  }
+  function addToVertex(index, amount, fillsColumn) {
+    const filled = fillsColumn ? Math.min(dug[index], amount) : 0;
+    dug[index] = dug[index] - filled;
+    loose[index] = loose[index] + amount - filled;
+  }
+  const isSoftExposed = (index) => materials.get(stratumAtDepth(profileList[profileIndex[index]], dug[index]).stratum.material).reposeDegrees !== void 0;
+  function stampBowl(x, z, radius, depth, rimVolume) {
+    const reach = radius * RIM_REACH;
+    const column0 = clampIndex(Math.floor((x - reach - x0) / cellSize), columns);
+    const column1 = clampIndex(Math.ceil((x + reach - x0) / cellSize), columns);
+    const row0 = clampIndex(Math.floor((z - reach - z0) / cellSize), rows);
+    const row1 = clampIndex(Math.ceil((z + reach - z0) / cellSize), rows);
+    const phaseA = random() * 6.283;
+    const phaseB = random() * 6.283;
+    const shapeOf = (px, pz) => {
+      const angle = Math.atan2(pz - z, px - x);
+      return Math.hypot(px - x, pz - z) / (radius * (1 + 0.12 * Math.sin(angle * 5 + phaseA) + 0.06 * Math.sin(angle * 11 + phaseB)));
+    };
+    let rimWeight = 0;
+    if (rimVolume > 0) {
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          const q = shapeOf(x0 + column * cellSize, z0 + row * cellSize);
+          if (q >= 1 && q < RIM_REACH) rimWeight += Math.sin((q - 1) / (RIM_REACH - 1) * Math.PI);
+        }
+      }
+    }
+    const cellArea = cellSize * cellSize;
+    for (let row = row0; row <= row1; row++) {
+      for (let column = column0; column <= column1; column++) {
+        const q = shapeOf(x0 + column * cellSize, z0 + row * cellSize);
+        const index = row * stride + column;
+        if (q < 1) {
+          removeFromVertex(index, depth * (1 - q * q) * (0.92 + random() * 0.16));
+          sliding.add(index);
+          touchVertex(column, row);
+        } else if (q < RIM_REACH && rimWeight > 0) {
+          loose[index] = loose[index] + rimVolume * Math.sin((q - 1) / (RIM_REACH - 1) * Math.PI) / (rimWeight * cellArea);
+          sliding.add(index);
+          touchVertex(column, row);
+        }
+      }
+    }
+    marks.removeInside(x, z, radius);
+    emitDeform(x, z, reach);
+  }
+  function throwPieces(spec) {
+    const radius = PIECE_RADIUS[spec.material.debris];
+    const pieceVolume = 4 / 3 * Math.PI * radius ** 3;
+    const count = Math.min(spec.quota, Math.max(1, Math.round(spec.volume / pieceVolume)));
+    const mass = Math.max(1e-3, spec.volume * 1500);
+    const launch = Math.min(MAX_PIECE_SPEED[spec.blow], Math.sqrt(2 * spec.energy * THROW_SHARE / mass));
+    for (let i = 0; i < count; i++) {
+      const angle = random() * 6.283;
+      const out = spec.bowlRadius * Math.sqrt(random()) * 0.8;
+      const speed = launch * (0.5 + random() * 0.7);
+      const spread = 0.35 + random() * 0.65;
+      const backX = spec.direction ? -(spec.direction[0] ?? 0) * 0.4 : 0;
+      const backZ = spec.direction ? -(spec.direction[2] ?? 0) * 0.4 : 0;
+      debrisStore.throwPiece({
+        material: spec.material.id,
+        kind: spec.material.debris,
+        radius: radius * (0.6 + random() * 0.9),
+        position: [spec.x + Math.cos(angle) * out, spec.y + 0.03, spec.z + Math.sin(angle) * out],
+        velocity: [(Math.cos(angle) * spread + backX) * speed, (0.6 + random() * 0.7) * speed, (Math.sin(angle) * spread + backZ) * speed],
+        spin: [(random() - 0.5) * 14, (random() - 0.5) * 14, (random() - 0.5) * 14]
+      });
+    }
+  }
+  function strike(blow, spec) {
+    const { x, z } = spec;
+    const start = columnAt(x, z);
+    const profile = profileMap.get(start.profile);
+    const removed = [];
+    const point = [x, heightAt(x, z), z];
+    let energy = spec.energy;
+    let depth = start.depth;
+    let radius = 0;
+    let carved = 0;
+    const firstMaterial = materials.get(start.material);
+    if (start.loose <= 0) {
+      for (; ; ) {
+        const layer = stratumAtDepth(profile, depth);
+        const bottom = layer.top + layer.stratum.thickness;
+        const room = bottom - depth;
+        if (room <= 1e-6) break;
+        const material = materials.get(layer.stratum.material);
+        const response = material.hits[blow];
+        if (!response || energy < (response.thresholdJoules ?? 0)) break;
+        const bars = layer.stratum.reinforcement;
+        const pastCover = bars !== void 0 && depth - layer.top >= bars.cover - 1e-6;
+        const specificEnergy = response.specificEnergy * (pastCover ? bars.resistance : 1);
+        const limit = bars && !pastCover ? Math.min(room, layer.top + bars.cover - depth) : room;
+        const volume = energy / specificEnergy;
+        const wanted = Math.cbrt(2 * volume / (Math.PI * response.aspect));
+        const wantedDepth = wanted * response.aspect;
+        const takenDepth = Math.min(wantedDepth, limit);
+        const takenRadius = takenDepth < wantedDepth ? takenDepth / response.aspect : wanted;
+        const takenVolume = Math.PI * takenRadius * takenRadius * takenDepth / 2;
+        energy -= takenVolume * specificEnergy;
+        depth += takenDepth;
+        carved += takenDepth;
+        radius = Math.max(radius, takenRadius, response.minRadius ?? 0, spec.contactRadius ?? 0);
+        const last = removed[removed.length - 1];
+        if (last?.material === material.id) last.volume += takenVolume;
+        else removed.push({ material: material.id, volume: takenVolume });
+        if (energy <= 1e-6 || takenDepth >= wantedDepth - 1e-9) break;
+      }
+    } else {
+      const response = firstMaterial.hits[blow];
+      if (response && energy >= (response.thresholdJoules ?? 0)) {
+        const volume = energy / response.specificEnergy;
+        radius = Math.cbrt(2 * volume / (Math.PI * response.aspect));
+        carved = radius * response.aspect;
+        removed.push({ material: firstMaterial.id, volume });
+      }
+    }
+    const collapsed = loadBars(blow, spec.energy, x, z, profile);
+    if (radius <= 0) return { point, radius: 0, depth: 0, totalDepth: columnAt(x, z).depth, removed: [], exposed: start.material, atLimit: start.remaining <= 1e-6, rebarExposed: rebarShowing(profile, start.depth), collapsed, fine: true };
+    if (firstMaterial.reposeDegrees === void 0 && start.loose <= 0) radius *= 1 + RIGID_WIDENING * (start.depth / maxDepthOfProfile(profile));
+    const volumeTotal = removed.reduce((sum, entry) => sum + entry.volume, 0);
+    const fine = radius < cellSize * FINE_CELLS;
+    if (fine) depositMark({ x, z, radius, depth: carved, blow, profile, cap: maxDepthOfProfile(profile) });
+    else {
+      const rimShare = materials.get(removed[0].material).rimShare ?? 0;
+      stampBowl(x, z, radius, carved, volumeTotal * rimShare);
+    }
+    let quota = budget.maxDebrisPerBlow;
+    for (const entry of removed) {
+      const material = materials.get(entry.material);
+      const thrown = entry.volume * (1 - (fine ? 0 : material.rimShare ?? 0));
+      if (thrown <= 0 || quota <= 0) continue;
+      const share = Math.max(1, Math.round(quota * entry.volume / volumeTotal));
+      throwPieces({ x, y: point[1], z, volume: thrown, material, energy: spec.energy * (entry.volume / volumeTotal), direction: spec.direction, quota: share, bowlRadius: radius, blow });
+      quota -= share;
+    }
+    const after = columnAt(x, z);
+    return { point, radius, depth: carved, totalDepth: after.depth, removed, exposed: after.material, atLimit: after.remaining <= 1e-4, rebarExposed: rebarShowing(profile, after.depth), collapsed, fine };
+  }
+  function loadBars(blow, energy, x, z, profile) {
+    const bars = profile.strata.find((stratum) => stratum.reinforcement);
+    if (!bars?.reinforcement) return false;
+    const response = materials.get(bars.material).hits[blow];
+    if (!response || energy < (response.thresholdJoules ?? 0)) return false;
+    const yieldJoules = bars.reinforcement.yieldJoules ?? DEFAULT_BAR_YIELD_JOULES;
+    let cover = bars.reinforcement.cover;
+    for (const stratum of profile.strata) {
+      if (stratum === bars) break;
+      cover += stratum.thickness;
+    }
+    const reach = Math.max(cellSize * FINE_CELLS, Math.cbrt(2 * energy / response.specificEnergy / (Math.PI * response.aspect)) * (1 + RIGID_WIDENING));
+    const column0 = clampIndex(Math.floor((x - reach - x0) / cellSize), columns);
+    const column1 = clampIndex(Math.ceil((x + reach - x0) / cellSize), columns);
+    const row0 = clampIndex(Math.floor((z - reach - z0) / cellSize), rows);
+    const row1 = clampIndex(Math.ceil((z + reach - z0) / cellSize), rows);
+    const limit = maxDepthOfProfile(profile);
+    let collapsed = false;
+    for (let row = row0; row <= row1; row++) {
+      for (let column = column0; column <= column1; column++) {
+        const index = row * stride + column;
+        if (dug[index] < cover) continue;
+        const q = Math.hypot(x0 + column * cellSize - x, z0 + row * cellSize - z) / reach;
+        if (q >= 1) continue;
+        barBend[index] = barBend[index] + energy / yieldJoules * (1 - q * q);
+        touchVertex(column, row);
+        if (barBend[index] >= 1 && profile.drop !== void 0 && dug[index] >= limit * COLLAPSE_DEPTH_SHARE && dug[index] < limit + profile.drop) {
+          dug[index] = limit + profile.drop;
+          collapsed = true;
+        }
+      }
+    }
+    if (collapsed) emitDeform(x, z, reach);
+    if (collapsed && profile.drop !== void 0) {
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          const index = row * stride + column;
+          if (barBend[index] >= COLLAPSE_SPREAD_BEND && dug[index] < limit + profile.drop) {
+            dug[index] = limit + profile.drop;
+            touchVertex(column, row);
+          }
+        }
+      }
+    }
+    return collapsed;
+  }
+  const maxDepthOfProfile = (profile) => maxDepthOf[indexOfProfile.get(profile.id)];
+  function rebarShowing(profile, depth) {
+    const layer = stratumAtDepth(profile, depth);
+    return layer.stratum.reinforcement !== void 0 && depth - layer.top >= layer.stratum.reinforcement.cover - 1e-6;
+  }
+  function depositMark(spec) {
+    const { x, z, radius, depth, blow, profile, cap } = spec;
+    const dugHere = dug[vertexOf(x, z).index];
+    const existing = marks.near(x, z, radius);
+    let mark;
+    if (existing) {
+      existing.radius = Math.hypot(existing.radius, radius);
+      existing.depth = Math.min(cap - dugHere, existing.depth + depth);
+      existing.count++;
+      existing.blow = blow;
+      mark = existing;
+    } else {
+      mark = marks.add({ x, z, radius, depth: Math.min(cap - dugHere, depth), blow, material: "" });
+    }
+    mark.material = stratumAtDepth(profile, dugHere + mark.depth - 1e-6).stratum.material;
+    if (mark.radius >= cellSize * FINE_CELLS || mark.depth >= cellSize * FINE_DEPTH_CELLS) {
+      const bowlRadius = Math.max(mark.radius, cellSize * FINE_CELLS);
+      const bowlDepth = mark.depth;
+      marks.remove(mark);
+      stampBowl(mark.x, mark.z, bowlRadius, bowlDepth, 0);
+    }
+  }
+  function burn(spec) {
+    if (spec.temperature < FLAME_MINIMUM) return;
+    const column0 = clampIndex(Math.floor((spec.x - spec.radius - x0) / cellSize), columns);
+    const column1 = clampIndex(Math.ceil((spec.x + spec.radius - x0) / cellSize), columns);
+    const row0 = clampIndex(Math.floor((spec.z - spec.radius - z0) / cellSize), rows);
+    const row1 = clampIndex(Math.ceil((spec.z + spec.radius - z0) / cellSize), rows);
+    for (let row = row0; row <= row1; row++) {
+      for (let column = column0; column <= column1; column++) {
+        if (Math.hypot(x0 + column * cellSize - spec.x, z0 + row * cellSize - spec.z) > spec.radius) continue;
+        burnVertex(column, row, spec.seconds);
+      }
+    }
+  }
+  function burnVertex(column, row, seconds) {
+    const index = row * stride + column;
+    const material = vertexMaterial(column, row);
+    const response = material.fire;
+    if (!response) return;
+    const before = scorch[index];
+    scorch[index] = Math.max(before, Math.min(response.maxScorch, before + response.scorchPerSecond * seconds));
+    if (response.burnsAway) removeFromVertex(index, response.burnsAway * seconds);
+    if (scorch[index] !== before || response.burnsAway) touchVertex(column, row);
+    if (response.flammable) ignite(x0 + column * cellSize, z0 + row * cellSize);
+  }
+  const fireKey = (x, z) => Math.floor((z - z0) / FIRE_CELL) * 65536 + Math.floor((x - x0) / FIRE_CELL);
+  function ignite(x, z) {
+    const key = fireKey(x, z);
+    if (burning.has(key) || burning.size >= budget.maxBurningCells) return;
+    const index = vertexOf(x, z).index;
+    if (scorch[index] >= 1) return;
+    burning.set(key, FIRE_SECONDS);
+  }
+  function updateFire(dt) {
+    for (const [key, remaining] of [...burning]) {
+      const cellRow = Math.floor(key / 65536);
+      const cellColumn = key - cellRow * 65536;
+      const x = x0 + (cellColumn + 0.5) * FIRE_CELL;
+      const z = z0 + (cellRow + 0.5) * FIRE_CELL;
+      burn({ x, z, radius: FIRE_CELL * 0.75, temperature: 600, seconds: dt });
+      if (random() < FIRE_SPREAD_PER_SECOND * dt) {
+        const angle = Math.floor(random() * 4) * (Math.PI / 2);
+        const nextX = x + Math.cos(angle) * FIRE_CELL;
+        const nextZ = z + Math.sin(angle) * FIRE_CELL;
+        if (contains(nextX, nextZ)) {
+          const { column, row, index } = vertexOf(nextX, nextZ);
+          if (vertexMaterial(column, row).fire?.flammable && scorch[index] < 1) ignite(nextX, nextZ);
+        }
+      }
+      if (remaining - dt <= 0) burning.delete(key);
+      else burning.set(key, remaining - dt);
+    }
+  }
+  function updateSlides() {
+    if (sliding.size === 0) return;
+    let budgetLeft = budget.maxSlideCellsPerFrame;
+    let minX = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxZ = -Infinity;
+    for (const index of sliding) {
+      if (budgetLeft-- <= 0) break;
+      sliding.delete(index);
+      const column = index % stride;
+      const row = (index - column) / stride;
+      if (!isSoftExposed(index)) continue;
+      const material = vertexMaterial(column, row);
+      const slope = Math.tan((material.reposeDegrees ?? 90) * Math.PI / 180) * cellSize;
+      const height = vertexHeight(column, row);
+      const neighbours = [[column - 1, row], [column + 1, row], [column, row - 1], [column, row + 1]];
+      for (const [nextColumn, nextRow] of neighbours) {
+        if (nextColumn < 0 || nextRow < 0 || nextColumn > columns || nextRow > rows) continue;
+        const excess = height - vertexHeight(nextColumn, nextRow) - slope;
+        if (excess <= SLIDE_EPSILON) continue;
+        const moved = removeFromVertex(index, excess * SLIDE_SHARE);
+        if (moved <= 0) continue;
+        const next = nextRow * stride + nextColumn;
+        addToVertex(next, moved, isSoftExposed(next));
+        sliding.add(index);
+        sliding.add(next);
+        touchVertex(column, row);
+        touchVertex(nextColumn, nextRow);
+        const px = x0 + column * cellSize;
+        const pz = z0 + row * cellSize;
+        minX = Math.min(minX, px);
+        maxX = Math.max(maxX, px);
+        minZ = Math.min(minZ, pz);
+        maxZ = Math.max(maxZ, pz);
+      }
+    }
+    if (minX <= maxX) emitDeform((minX + maxX) / 2, (minZ + maxZ) / 2, Math.hypot(maxX - minX, maxZ - minZ) / 2 + cellSize * 2);
+  }
+  function settle(piece) {
+    const material = materials.get(piece.material);
+    if (!material || material.reposeDegrees === void 0) return false;
+    if (!contains(piece.position[0], piece.position[2])) return true;
+    const { index, column, row } = vertexOf(piece.position[0], piece.position[2]);
+    addToVertex(index, 4 / 3 * Math.PI * piece.radius ** 3 / (cellSize * cellSize), false);
+    sliding.add(index);
+    touchVertex(column, row);
+    return true;
+  }
+  function applyHit(hit) {
+    const [x, y, z] = hit.point;
+    switch (hit.type) {
+      case "ballistic":
+      case "blunt":
+      case "slash": {
+        if (!hit.energy) return null;
+        const contactRadius = hit.type === "blunt" ? hit.radius : void 0;
+        return strike(hit.type, { x, z, energy: hit.energy, ...hit.direction ? { direction: hit.direction } : {}, ...contactRadius !== void 0 ? { contactRadius } : {} });
+      }
+      case "explosive": {
+        if (!hit.energy) return null;
+        const above = Math.max(0, y - heightAt(x, z));
+        const reach = (hit.radius ?? 1) * BLAST_HEIGHT_REACH;
+        if (above >= reach) return null;
+        return strike("explosive", { x, z, energy: hit.energy * (1 - above / reach) ** 2 });
+      }
+      case "fire":
+      case "heat":
+        if (y - heightAt(x, z) > (hit.radius ?? 0.2) + FLAME_REACH) return null;
+        burn({ x, z, radius: hit.radius ?? 0.2, temperature: hit.temperature ?? 0, seconds: hit.duration ?? 0.016 });
+        return null;
+      default:
+        return null;
+    }
+  }
+  function raycast(origin, direction, maxDistance) {
+    const [ox = 0, oy = 0, oz = 0] = origin;
+    const [dx = 0, dy = 0, dz = 0] = direction;
+    const step = cellSize * 0.75;
+    let previous = 0;
+    for (let t = 0; t <= maxDistance; t += step) {
+      const x = ox + dx * t;
+      const z = oz + dz * t;
+      if (contains(x, z) && oy + dy * t <= heightAt(x, z)) {
+        let low = previous;
+        let high = t;
+        for (let i = 0; i < 6; i++) {
+          const middle = (low + high) / 2;
+          if (oy + dy * middle <= heightAt(ox + dx * middle, oz + dz * middle)) high = middle;
+          else low = middle;
+        }
+        const px = ox + dx * high;
+        const pz = oz + dz * high;
+        const gx = heightAt(px + cellSize, pz) - heightAt(px - cellSize, pz);
+        const gz = heightAt(px, pz + cellSize) - heightAt(px, pz - cellSize);
+        const length = Math.hypot(gx, 2 * cellSize, gz);
+        return { point: [px, oy + dy * high, pz], distance: high, normal: [-gx / length, 2 * cellSize / length, -gz / length] };
+      }
+      previous = t;
+    }
+    return null;
+  }
+  function chunk(index) {
+    const chunkZ = Math.floor(index / chunksX);
+    const chunkX = index - chunkZ * chunksX;
+    return { index, column: chunkX * chunkCells, row: chunkZ * chunkCells, cells: chunkCells, pristine: !touched[index] && !mixed[index] && !options.baseHeight };
+  }
+  function reset() {
+    dug.fill(0);
+    loose.fill(0);
+    scorch.fill(0);
+    barBend.fill(0);
+    touched.fill(0);
+    marks.clear();
+    debrisStore.clear();
+    sliding.clear();
+    burning.clear();
+    applyLayout(currentLayout);
+  }
+  applyLayout(currentLayout);
+  return {
+    bounds: options.bounds,
+    cellSize,
+    columns,
+    rows,
+    stride,
+    chunkCells,
+    chunksX,
+    chunksZ,
+    budget,
+    dug,
+    loose,
+    scorch,
+    barBend,
+    profileIndex,
+    profileList,
+    material: (id) => {
+      const material = materials.get(id);
+      if (!material) throw new Error(`game-terrain: unknown material "${id}"`);
+      return material;
+    },
+    layout: () => currentLayout,
+    setLayout(layout) {
+      currentLayout = layout;
+      reset();
+    },
+    heightAt,
+    vertexHeight,
+    vertexMaterial,
+    columnAt,
+    contains,
+    raycast,
+    strike,
+    burn,
+    applyHit,
+    onDeform(listener) {
+      deformListeners.add(listener);
+      return () => deformListeners.delete(listener);
+    },
+    update(dt) {
+      debrisStore.update(dt, { heightAt, gravity, settle });
+      updateSlides();
+      updateFire(dt);
+    },
+    drainDirtyChunks(max = budget.maxDirtyChunksPerFrame) {
+      const taken = [];
+      for (const index of dirty) {
+        if (taken.length >= max) break;
+        dirty.delete(index);
+        taken.push(chunk(index));
+      }
+      return taken;
+    },
+    chunk,
+    marks: () => marks.list,
+    debris: () => debrisStore.list,
+    burningPoints: () => [...burning.keys()].map((key) => {
+      const cellRow = Math.floor(key / 65536);
+      const cellColumn = key - cellRow * 65536;
+      return [x0 + (cellColumn + 0.5) * FIRE_CELL, z0 + (cellRow + 0.5) * FIRE_CELL];
+    }),
+    get marksVersion() {
+      return marks.version;
+    },
+    stats: () => ({ marks: marks.list.length, debris: debrisStore.list.length, debrisMoving: debrisStore.list.filter((piece) => !piece.atRest).length, dirtyChunks: dirty.size, burning: burning.size }),
+    reset,
+    serialize() {
+      return { layout: currentLayout, dug: sparse(dug), loose: sparse(loose), scorch: sparse(scorch), barBend: sparse(barBend), marks: marks.list.map((mark) => ({ ...mark })) };
+    },
+    load(snapshot) {
+      currentLayout = snapshot.layout;
+      reset();
+      fillSparse(dug, snapshot.dug);
+      fillSparse(loose, snapshot.loose);
+      fillSparse(scorch, snapshot.scorch);
+      fillSparse(barBend, snapshot.barBend ?? []);
+      marks.load(snapshot.marks);
+      for (let chunkIndex = 0; chunkIndex < touched.length; chunkIndex++) markChunk(chunkIndex);
+    }
+  };
+}
+
+// src/impl.ts
+var PART_ID = "ground";
+var PART_DEPTH = 3;
+var RAY_BACKOFF = 1;
+function createTerrainImpl(terrain, options) {
+  const { id } = options;
+  const [x0, z0, x1, z1] = terrain.bounds;
+  const spec = () => ({
+    name: options.name ?? "Ground",
+    parts: [
+      {
+        id: PART_ID,
+        material: terrain.columnAt((x0 + x1) / 2, (z0 + z1) / 2).material,
+        shape: { kind: "box", size: [x1 - x0, PART_DEPTH, z1 - z0] },
+        position: [(x0 + x1) / 2, -PART_DEPTH / 2, (z0 + z1) / 2],
+        hp: 1e12,
+        anchored: true,
+        tags: ["terrain"]
+      }
+    ],
+    joints: []
+  });
+  const resolve = (hit) => {
+    if (hit.type !== "ballistic" && hit.type !== "blunt" && hit.type !== "slash") return hit;
+    if (!hit.direction) return { ...hit, point: [hit.point[0], terrain.heightAt(hit.point[0], hit.point[2]), hit.point[2]] };
+    const [dx, dy, dz] = hit.direction;
+    const from = [hit.point[0] - dx * RAY_BACKOFF, hit.point[1] - dy * RAY_BACKOFF, hit.point[2] - dz * RAY_BACKOFF];
+    const onGround = terrain.raycast(from, hit.direction, RAY_BACKOFF + PART_DEPTH);
+    return onGround ? { ...hit, point: onGround.point } : hit;
+  };
+  return {
+    id,
+    ...options.name ? { name: options.name } : {},
+    describe: spec,
+    hit(hit) {
+      const landed = resolve(hit);
+      const result = terrain.applyHit(landed);
+      if (!result || result.radius <= 0) return [];
+      options.onBlow?.(result, landed);
+      return [{ type: "damage", object: id, time: 0, part: PART_ID, amount: 0, hp: 1e12, damageType: hit.type, ...hit.source ? { source: hit.source } : {} }];
+    },
+    update(dt) {
+      terrain.update(dt);
+      return [];
+    },
+    state() {
+      return {
+        id,
+        position: [0, 0, 0],
+        rotation: [0, 0, 0, 1],
+        parts: [],
+        joints: [],
+        groups: [[PART_ID]],
+        destroyed: false
+      };
+    },
+    reset: () => terrain.reset(),
+    serialize: () => terrain.serialize(),
+    load: (data) => terrain.load(data)
+  };
+}
+
+// src/types.ts
+var TERRAIN_PATTERNS = ["plain", "grass", "soil", "sand", "asphalt", "concrete", "tile", "planks", "stone"];
+export {
+  DEFAULT_BAR_YIELD_JOULES,
+  DEFAULT_PROFILE,
+  DEFAULT_TERRAIN_BUDGET,
+  TERRAIN_MATERIALS,
+  TERRAIN_PATTERNS,
+  TERRAIN_PROFILES,
+  createTerrain,
+  createTerrainImpl
+};
+//# sourceMappingURL=index.js.map