Blast System

Ore veins — not homogeneous. Each ore has a separate Simplex field with high threshold, producing elongated veins:

export interface VoxelOreComposition {
  ores: Array<{ oreId: string; density: number }>; // density 0–1
}

Step 1 — Energy Propagation

Per-voxel energy threshold (weighted by rock composition):

T(v) = Σ_r [ coefficient[r] * rockDef[r].energyAbsorption ]

Initial energy (per charged hole cell):

E_init(v) = explosiveDef.energyPerKg * chargeKg * stemmingEfficiency(stemmingM, depthM)

Propagation loop (iterative, guard at MAX_PROPAGATION_ITERATIONS = 500):

For each voxel v with overflowEnergy[v] > 0:
  absorbed = min(incoming, T(v) - effectiveEnergy[v])
  effectiveEnergy[v] += absorbed
  leftover = incoming - absorbed
  generatedOverflow[v] += leftover  // used in Step 4

  if leftover > 0:
    distribute share to up to 6 face-adjacent non-air neighbours

This naturally models confined blasts (strong rock → energy stays local) and overcharged blasts (energy radiates outward).

Step 2 — Fragmentation & Damage

Fragmentation criterion:

if effectiveEnergy[v] >= FRAGMENTATION_MULTIPLIER * T(v):  → voxel becomes air (fragment)

FRAGMENTATION_MULTIPLIER = 1.0 (balance constant).

Isolated rock islands: After fragmentation pass, flood-fill from grid boundary. Solid clusters with no path to boundary are also fragmented (handles hanging rock arches).

Entity damage:

• Employees/vehicles on a fragmented voxel → instantly killed/destroyed
• Buildings: sum effectiveEnergy of all voxels beneath footprint. If sum > buildingDef.structuralResistance → building destroyed. Occupant survival:

  deathProbability = clamp((totalEnergy / structuralResistance - 1.0) * 0.5, 0.30, 1.00)
  

  Uses seeded PRNG.

NavMesh update: All fragmented voxels + new exposed surface cells → submitted as dirty region to NavGrid (Ch.6).

Step 3 — Fragment Shape Generation (Voronoi)

Fragmentation score per voxel:

F(v) = FRAGMENTATION_SCORE_SCALE * (effectiveEnergy[v] / T(v))
fragmentCount(v) = max(1, round(F(v)))

FRAGMENTATION_SCORE_SCALE = 3.0.

Voronoi seed sampling: randomly sample fragmentCount(v) 3D points inside each fragmented voxel's unit cube. All points form a global point cloud P.

3D Voronoi decomposition:

1. Bowyer–Watson Delaunay tetrahedralization of point cloud P
2. Dual Voronoi cells: circumcentres of Delaunay tetrahedra as vertices
3. Clip each cell to the fragmented voxel union bounding box

If count(P) > MAX_VORONOI_POINTS (2000), cull lowest-score voxels first.

Merging pass (non-convex, realistic shapes):

for each Voronoi cell C:
  if rng.next() < MERGE_PROBABILITY (0.35):
    merge with random face-adjacent neighbour N (union of convex hulls)

RockFragment schema:

export interface RockFragment {
  id: number;
  cx: number; cy: number; cz: number;
  graphicVertices: Float32Array;
  collisionVertices: Float32Array;   // deflated inward by COLLISION_DEFLATE_AMOUNT (0.05m)
  composition: VoxelRockComposition;
  oreComposition: VoxelOreComposition;
  volumeM3: number;
  massKg: number;
  overflowEnergy: number;            // inherited from source voxels
  velocity: Vec3;
  simulationTier: 'projected' | 'collapse';
  state: 'flying' | 'settling' | 'static';
}

Step 4 — Projection Velocity & Physics Settle

Velocity assignment (energy gradient + surface proximity):

grad_dir = normalize(-computeEnergyGradient(effectiveEnergy, C))
distToAir = distanceToNearestAirVoxel(C)
surfaceProximityFactor = exp(-distToAir * SURFACE_PROXIMITY_DECAY)  // decay = 0.5
v_mag = sqrt(2 * fragment.overflowEnergy / fragment.massKg) * surfaceProximityFactor
v_mag = min(v_mag, MAX_PROJECTION_VELOCITY)  // 80 m/s
F.velocity = grad_dir * v_mag

Classification: v_mag > PROJECTION_VELOCITY_THRESHOLD (2.0 m/s) → 'projected'; else 'collapse'.

Tier A — Projected fragments:

• Full Cannon-es rigid body with massKg and convex hull collision
• Hard cap: PHYSICS_FRAGMENT_CAP = 200 full bodies; beyond cap → parabolic trajectory (analytic)
• Aggressive sleep: |velocity| < SLEEP_VELOCITY_THRESHOLD (0.1 m/s) for SLEEP_TICKS_REQUIRED (15) ticks → 'static'

Tier B — Collapse fragments:

• No Cannon-es body. Drops straight down each tick until hitting terrain or static fragment
• Instantaneous landing → registers in surface grid → 'static' (CPU-free)

Landing damage (both tiers): if human, vehicle, or building in impact cell → apply impactEnergy = massKg * v_mag².

Fragment collection rules:

oversized = fragment.volumeM3 > OVERSIZED_FRAGMENT_THRESHOLD (0.5 m³)
oversized  → must be broken by Rock Fragmenter first
!oversized → Debris Hauler with capacity ≥ fragment.massKg can collect directly

Balance Constants (src/core/config/balance.ts)

export const MAX_PROPAGATION_ITERATIONS = 500;
export const FRAGMENTATION_MULTIPLIER = 1.0;
export const FRAGMENTATION_SCORE_SCALE = 3.0;
export const MERGE_PROBABILITY = 0.35;
export const COLLISION_DEFLATE_AMOUNT = 0.05;
export const SURFACE_PROXIMITY_DECAY = 0.5;
export const MAX_PROJECTION_VELOCITY = 80;
export const PROJECTION_VELOCITY_THRESHOLD = 2.0;
export const PHYSICS_FRAGMENT_CAP = 200;
export const SLEEP_VELOCITY_THRESHOLD = 0.1;
export const SLEEP_TICKS_REQUIRED = 15;
export const MAX_VORONOI_POINTS = 2000;
export const OVERSIZED_FRAGMENT_THRESHOLD = 0.5;

Blast Quality Rating

interface BlastReport {
  fragmentCount: number;
  averageFragmentSize: number;
  oversizedFragments: number;
  projectionCount: number;
  maxProjectionDistance: number;
  vibrationAtVillages: VillageVibration[];
  casualties: number;
  buildingsDestroyed: string[];
  totalRockVolume: number;
  totalOreValue: number;
  rating: 'perfect' | 'good' | 'mediocre' | 'bad' | 'catastrophic';
}

Software Upgrades (Prediction Tools)

Atomic Task Breakdown