@adatechnology/game-crowd 0.2.6 → 0.4.0

package/dist/physics-worker.js

@@ -0,0 +1,580 @@
+// src/physics/offload/frame.ts
+var F32_INPUTS = ["x", "z", "y", "vx", "vz", "pushX", "pushZ", "mass", "build", "aimX", "aimZ", "driveFactor", "fieldPrev"];
+var U8_INPUTS = ["band", "balance", "state", "type"];
+var F32_OUTPUTS = ["deltaX", "deltaZ", "deltaPushX", "deltaPushZ", "deltaVx", "deltaVz", "field", "shove", "doorLoad"];
+var HEADER = { n: 0, h: 1, playerOn: 2, playerX: 3, playerZ: 4, contacts: 5, maxOverlap: 6, overlapSum: 7, playerLoad: 8, drivers: 9, fieldMax: 10, size: 16 };
+var align8 = (bytes) => Math.ceil(bytes / 8) * 8;
+function createFrame(buffer, shape) {
+  const { capacity, cells } = shape;
+  let offset = 0;
+  const take = (make, bytesPerElement, length) => {
+    const view = make(buffer, offset, length);
+    offset += align8(length * bytesPerElement);
+    return view;
+  };
+  const f64 = (b, o, l) => new Float64Array(b, o, l);
+  const f32 = (b, o, l) => new Float32Array(b, o, l);
+  const u8 = (b, o, l) => new Uint8Array(b, o, l);
+  const header = take(f64, 8, HEADER.size);
+  const floats = {};
+  for (const key of [...F32_INPUTS, ...F32_OUTPUTS]) floats[key] = take(f32, 4, capacity);
+  const identity = take((b, o, l) => new Uint32Array(b, o, l), 4, capacity);
+  const doorCell = take((b, o, l) => new Int32Array(b, o, l), 4, capacity);
+  const bytes = {};
+  for (const key of U8_INPUTS) bytes[key] = take(u8, 1, capacity);
+  const occ = take(u8, 1, cells);
+  return { header, f32: floats, u8: bytes, identity, doorCell, occ };
+}
+
+// src/grid.ts
+var createCellOf = (half, cell, n) => (x, z) => {
+  const gx = Math.floor((x + half) / cell);
+  const gz = Math.floor((z + half) / cell);
+  return gx < 0 || gz < 0 || gx >= n || gz >= n ? -1 : gz * n + gx;
+};
+
+// src/identity.ts
+var mix32 = (value) => {
+  let hash = value >>> 0;
+  hash ^= hash >>> 16;
+  hash = Math.imul(hash, 2246822507);
+  hash ^= hash >>> 13;
+  hash = Math.imul(hash, 3266489909);
+  hash ^= hash >>> 16;
+  return hash >>> 0;
+};
+var unit = (identity, step, salt) => (mix32(mix32(identity ^ salt) + Math.imul(step + 1, 2654435769) >>> 0) >>> 0) / 4294967296;
+var SALT = {
+  FALL: 62481,
+  TRIP: 29209,
+  LIMB: 110848,
+  REGION: 189968,
+  JAW: 239536,
+  CORPSE: 311518,
+  SPIN: 364922,
+  SPEED: 413981,
+  REACTION: 466972,
+  STABILITY: 569886,
+  TRIP_FACTOR: 605021,
+  DRIVE: 655571,
+  CADENCE: 728142,
+  AGGRESSION: 797335,
+  IDLE: 867848,
+  GAIT: 937753
+};
+
+// src/types.ts
+var STATE = {
+  WANDER: 0,
+  CHASE: 1,
+  GRAB: 2,
+  STUNNED: 3,
+  CALLING: 4,
+  AIRBORNE: 5,
+  DORMANT: 6,
+  SWELLING: 7,
+  SWING: 8,
+  EATING: 9,
+  PILE_STEP: 10,
+  SEEKING_SOUND: 12
+};
+var BALANCE = { STANDING: 0, STAGGERING: 1, FALLEN: 2, GETTING_UP: 3, THROWN: 4 };
+
+// src/physics/contact.ts
+var GROUND_MASS_FACTOR = 3;
+var PAIR_MARGIN = 0.15;
+var MAX_LEVEL_GAP = 0.15;
+var PAIRS_PER_AGENT = 12;
+var MIN_DISTANCE = 1e-6;
+var createContactWorkspace = (capacity, grid) => ({
+  head: new Int32Array(Math.floor(grid.size) ** 2).fill(-1),
+  next: new Int32Array(capacity),
+  touched: new Int32Array(capacity),
+  touchedCount: 0,
+  pairI: new Int32Array(capacity * PAIRS_PER_AGENT),
+  pairJ: new Int32Array(capacity * PAIRS_PER_AGENT),
+  pairCount: 0,
+  deltaX: new Float32Array(capacity),
+  deltaZ: new Float32Array(capacity),
+  count: new Uint8Array(capacity),
+  pushBeforeX: new Float32Array(capacity),
+  pushBeforeZ: new Float32Array(capacity),
+  shove: new Float32Array(capacity),
+  takesPart: new Uint8Array(capacity),
+  radiusOf: new Float64Array(capacity),
+  massOf: new Float64Array(capacity),
+  pairReach: new Float64Array(capacity * PAIRS_PER_AGENT),
+  pairDistance: new Float64Array(capacity * PAIRS_PER_AGENT),
+  pairNormalX: new Float64Array(capacity * PAIRS_PER_AGENT),
+  pairNormalZ: new Float64Array(capacity * PAIRS_PER_AGENT)
+});
+var takesPartInContact = (store, i) => store.band[i] === 0 && store.balance[i] !== BALANCE.THROWN && store.state[i] !== STATE.PILE_STEP && store.state[i] !== STATE.DORMANT;
+var isOnGround = (store, i) => store.balance[i] === BALANCE.FALLEN || store.balance[i] === BALANCE.GETTING_UP;
+var effectiveMass = (store, i) => store.mass[i] * (isOnGround(store, i) ? GROUND_MASS_FACTOR : 1);
+var bodyRadius = (store, i, radius) => radius * store.build[i];
+function readBodies(view, radius) {
+  const { store, workspace } = view;
+  const { takesPart, radiusOf, massOf } = workspace;
+  for (let i = 0; i < view.n; i++) {
+    const takes = takesPartInContact(store, i);
+    takesPart[i] = takes ? 1 : 0;
+    radiusOf[i] = bodyRadius(store, i, radius);
+    massOf[i] = effectiveMass(store, i);
+  }
+}
+function rebuildHash(view) {
+  const { store, grid, workspace } = view;
+  const side = Math.floor(grid.size);
+  for (let k = 0; k < workspace.touchedCount; k++) workspace.head[workspace.touched[k]] = -1;
+  workspace.touchedCount = 0;
+  for (let i = 0; i < view.n; i++) {
+    if (!workspace.takesPart[i]) continue;
+    const hx = Math.floor(store.x[i] + grid.half);
+    const hz = Math.floor(store.z[i] + grid.half);
+    if (hx < 0 || hz < 0 || hx >= side || hz >= side) continue;
+    const cell = hz * side + hx;
+    if (workspace.head[cell] === -1) workspace.touched[workspace.touchedCount++] = cell;
+    workspace.next[i] = workspace.head[cell];
+    workspace.head[cell] = i;
+  }
+}
+var FORWARD_CELLS = [1, 0, -1, 1, 0, 1, 1, 1];
+function addPairsOfCell(view, i, cell, sameCell) {
+  const { store, workspace } = view;
+  const { head, next, radiusOf, pairI, pairJ } = workspace;
+  const { x, z, y } = store;
+  const xi = x[i];
+  const zi = z[i];
+  const yi = y[i];
+  const reachBase = radiusOf[i] + PAIR_MARGIN;
+  for (let j = head[cell]; j !== -1; j = next[j]) {
+    if (sameCell && j <= i || Math.abs(yi - y[j]) > MAX_LEVEL_GAP) continue;
+    const reach = reachBase + radiusOf[j];
+    const ex = x[j] - xi;
+    const ez = z[j] - zi;
+    if (ex * ex + ez * ez >= reach * reach || workspace.pairCount >= pairI.length) continue;
+    pairI[workspace.pairCount] = i;
+    pairJ[workspace.pairCount++] = j;
+  }
+}
+function collectPairs(view) {
+  const { store, grid, workspace } = view;
+  const side = Math.floor(grid.size);
+  workspace.pairCount = 0;
+  for (let i = 0; i < view.n; i++) {
+    if (!workspace.takesPart[i]) continue;
+    const hx = Math.floor(store.x[i] + grid.half);
+    const hz = Math.floor(store.z[i] + grid.half);
+    if (hx < 0 || hz < 0 || hx >= side || hz >= side) continue;
+    addPairsOfCell(view, i, hz * side + hx, true);
+    for (let k = 0; k < FORWARD_CELLS.length; k += 2) {
+      const qx = hx + FORWARD_CELLS[k];
+      const qz = hz + FORWARD_CELLS[k + 1];
+      if (qx >= 0 && qz >= 0 && qx < side && qz < side) addPairsOfCell(view, i, qz * side + qx, false);
+    }
+  }
+}
+function measurePairs(view) {
+  const { store, workspace } = view;
+  const { pairI, pairJ, radiusOf, pairReach, pairDistance, pairNormalX, pairNormalZ } = workspace;
+  const { x, z, identity } = store;
+  for (let p = 0; p < workspace.pairCount; p++) {
+    const i = pairI[p];
+    const j = pairJ[p];
+    const reach = radiusOf[i] + radiusOf[j];
+    const ex = x[i] - x[j];
+    const ez = z[i] - z[j];
+    const distance = Math.sqrt(ex * ex + ez * ez);
+    pairReach[p] = reach;
+    pairDistance[p] = distance;
+    if (distance >= reach) continue;
+    if (distance > MIN_DISTANCE) {
+      pairNormalX[p] = ex / distance;
+      pairNormalZ[p] = ez / distance;
+      continue;
+    }
+    const angle = 2 * Math.PI * unit(identity[i] ^ identity[j], 0, SALT.SPIN);
+    pairNormalX[p] = Math.cos(angle);
+    pairNormalZ[p] = Math.sin(angle);
+  }
+}
+function solveImpulse(store, workspace, p) {
+  if (workspace.pairDistance[p] >= workspace.pairReach[p]) return;
+  const i = workspace.pairI[p];
+  const j = workspace.pairJ[p];
+  const nx = workspace.pairNormalX[p];
+  const nz = workspace.pairNormalZ[p];
+  const { vx, vz, pushX, pushZ } = store;
+  const closing = (vx[i] + pushX[i] - vx[j] - pushX[j]) * nx + (vz[i] + pushZ[i] - vz[j] - pushZ[j]) * nz;
+  if (closing >= 0) return;
+  const massI = workspace.massOf[i];
+  const massJ = workspace.massOf[j];
+  const impulse = -closing * massI * massJ / (massI + massJ);
+  pushX[i] += impulse * nx / massI;
+  pushZ[i] += impulse * nz / massI;
+  pushX[j] -= impulse * nx / massJ;
+  pushZ[j] -= impulse * nz / massJ;
+}
+function accumulateCorrection(workspace, p, relaxation) {
+  const distance = workspace.pairDistance[p];
+  const reach = workspace.pairReach[p];
+  if (distance >= reach) return;
+  const i = workspace.pairI[p];
+  const j = workspace.pairJ[p];
+  const massI = workspace.massOf[i];
+  const massJ = workspace.massOf[j];
+  const move = relaxation * (reach - distance);
+  const nx = workspace.pairNormalX[p];
+  const nz = workspace.pairNormalZ[p];
+  workspace.deltaX[i] += move * nx * (massJ / (massI + massJ));
+  workspace.deltaZ[i] += move * nz * (massJ / (massI + massJ));
+  workspace.deltaX[j] -= move * nx * (massI / (massI + massJ));
+  workspace.deltaZ[j] -= move * nz * (massI / (massI + massJ));
+  workspace.count[i]++;
+  workspace.count[j]++;
+}
+var isOpen = (grid, x, z) => {
+  const cell = grid.cellOf(x, z);
+  return cell >= 0 && (grid.occ[cell] === 0 || grid.occ[cell] === 3);
+};
+function applyCorrection(view, agent, params) {
+  const { store, grid, workspace } = view;
+  const count = workspace.count[agent];
+  if (!count) return;
+  workspace.count[agent] = 0;
+  const cap = params.maxCorrection;
+  const dx = Math.max(-cap, Math.min(cap, workspace.deltaX[agent] / count));
+  const dz = Math.max(-cap, Math.min(cap, workspace.deltaZ[agent] / count));
+  if (isOpen(grid, store.x[agent] + dx, store.z[agent])) store.x[agent] += dx;
+  if (isOpen(grid, store.x[agent], store.z[agent] + dz)) store.z[agent] += dz;
+}
+function resetCorrection(workspace, agent) {
+  workspace.deltaX[agent] = 0;
+  workspace.deltaZ[agent] = 0;
+  workspace.count[agent] = 0;
+}
+function correctPositions(view, params) {
+  const { workspace } = view;
+  for (let p = 0; p < workspace.pairCount; p++) {
+    resetCorrection(workspace, workspace.pairI[p]);
+    resetCorrection(workspace, workspace.pairJ[p]);
+  }
+  for (let p = 0; p < workspace.pairCount; p++) accumulateCorrection(workspace, p, params.relaxation);
+  for (let p = 0; p < workspace.pairCount; p++) {
+    applyCorrection(view, workspace.pairI[p], params);
+    applyCorrection(view, workspace.pairJ[p], params);
+  }
+}
+function measureOverlaps(view, out) {
+  const { store, workspace } = view;
+  for (let p = 0; p < workspace.pairCount; p++) {
+    const i = workspace.pairI[p];
+    const j = workspace.pairJ[p];
+    if (isOnGround(store, i) && isOnGround(store, j)) continue;
+    const reach = workspace.radiusOf[i] + workspace.radiusOf[j];
+    const overlap = reach - Math.hypot(store.x[i] - store.x[j], store.z[i] - store.z[j]);
+    if (overlap <= 0) continue;
+    out.contacts++;
+    out.overlapSum += overlap;
+    if (overlap > out.maxOverlap) out.maxOverlap = overlap;
+  }
+}
+function dampPush(view, params) {
+  const { store, workspace } = view;
+  const lambda = Math.exp(-params.friction * params.h);
+  for (let i = 0; i < view.n; i++) {
+    workspace.shove[i] = Math.hypot(store.pushX[i] - workspace.pushBeforeX[i], store.pushZ[i] - workspace.pushBeforeZ[i]);
+    store.pushX[i] *= lambda;
+    store.pushZ[i] *= lambda;
+    const speed = Math.hypot(store.pushX[i], store.pushZ[i]);
+    if (speed <= params.maxPush) continue;
+    store.pushX[i] *= params.maxPush / speed;
+    store.pushZ[i] *= params.maxPush / speed;
+  }
+}
+function contactStep(view, params, out) {
+  const { store, workspace } = view;
+  out.contacts = 0;
+  out.maxOverlap = 0;
+  out.overlapSum = 0;
+  for (let i = 0; i < view.n; i++) {
+    workspace.pushBeforeX[i] = store.pushX[i];
+    workspace.pushBeforeZ[i] = store.pushZ[i];
+  }
+  readBodies(view, params.radius);
+  rebuildHash(view);
+  collectPairs(view);
+  for (let iteration = 0; iteration < params.iterations; iteration++) {
+    measurePairs(view);
+    for (let p = 0; p < workspace.pairCount; p++) solveImpulse(store, workspace, p);
+    for (let p = workspace.pairCount - 1; p >= 0; p--) solveImpulse(store, workspace, p);
+    correctPositions(view, params);
+  }
+  measureOverlaps(view, out);
+  dampPush(view, params);
+}
+
+// src/physics/pressure.ts
+var TOUCH_SLACK = 0.08;
+var WALL_PROBE = 0.12;
+var PLAYER_REACH = 1.3;
+var PLAYER_RADIUS_SQUARED = PLAYER_REACH * PLAYER_REACH;
+var createPressureWorkspace = (capacity, pairCapacity) => ({
+  weightSum: new Float32Array(capacity),
+  pressing: new Uint8Array(capacity),
+  wallKind: new Uint8Array(capacity),
+  wallDoor: new Int32Array(capacity),
+  playerWeight: new Float32Array(capacity),
+  cutExcess: new Float32Array(capacity),
+  cutX: new Float32Array(capacity),
+  cutZ: new Float32Array(capacity),
+  pairWeightForward: new Float32Array(pairCapacity),
+  pairWeightBackward: new Float32Array(pairCapacity),
+  canPress: new Uint8Array(capacity)
+});
+var isPressing = (store, i) => takesPartInContact(store, i) && (store.balance[i] === BALANCE.STANDING || store.balance[i] === BALANCE.STAGGERING);
+function readPressing(view, workspace) {
+  for (let i = 0; i < view.n; i++) workspace.canPress[i] = isPressing(view.store, i) ? 1 : 0;
+}
+var frontWeight = (alignment, cone) => alignment > cone ? (alignment - cone) / (1 - cone) : 0;
+var hasAim = (store, i) => store.aimX[i] !== 0 || store.aimZ[i] !== 0;
+function noteCut(store, workspace, i, j, nx, nz) {
+  const excess = (store.vx[i] - store.vx[j]) * nx + (store.vz[i] - store.vz[j]) * nz;
+  if (excess <= workspace.cutExcess[i]) return;
+  workspace.cutExcess[i] = excess;
+  workspace.cutX[i] = nx;
+  workspace.cutZ[i] = nz;
+}
+function weighPairs(view, workspace, params) {
+  const { store } = view;
+  for (let p = 0; p < view.workspace.pairCount; p++) {
+    workspace.pairWeightForward[p] = 0;
+    workspace.pairWeightBackward[p] = 0;
+    const i = view.workspace.pairI[p];
+    const j = view.workspace.pairJ[p];
+    if (!workspace.canPress[i] || !workspace.canPress[j]) continue;
+    const ex = store.x[j] - store.x[i];
+    const ez = store.z[j] - store.z[i];
+    const distance = Math.sqrt(ex * ex + ez * ez);
+    if (distance < 1e-6 || distance > (store.build[i] + store.build[j]) * params.radius + TOUCH_SLACK) continue;
+    const nx = ex / distance;
+    const nz = ez / distance;
+    const forward = frontWeight(store.aimX[i] * nx + store.aimZ[i] * nz, params.frontCone);
+    const backward = frontWeight(-(store.aimX[j] * nx + store.aimZ[j] * nz), params.frontCone);
+    if (forward > 0) {
+      workspace.pressing[i] = 1;
+      noteCut(store, workspace, i, j, nx, nz);
+    }
+    if (backward > 0) {
+      workspace.pressing[j] = 1;
+      noteCut(store, workspace, j, i, -nx, -nz);
+    }
+    if (forward > 0 && backward > 0) continue;
+    workspace.pairWeightForward[p] = forward;
+    workspace.pairWeightBackward[p] = backward;
+    workspace.weightSum[i] += forward;
+    workspace.weightSum[j] += backward;
+  }
+}
+function weighWalls(view, workspace, params, doorAt) {
+  const { store, grid } = view;
+  for (let i = 0; i < view.n; i++) {
+    if (!workspace.canPress[i] || !hasAim(store, i)) continue;
+    const reach = store.build[i] * params.radius + WALL_PROBE;
+    const cell = grid.cellOf(store.x[i] + store.aimX[i] * reach, store.z[i] + store.aimZ[i] * reach);
+    if (cell >= 0 && (grid.occ[cell] === 0 || grid.occ[cell] === 3)) continue;
+    workspace.wallKind[i] = 1;
+    workspace.wallDoor[i] = cell >= 0 && grid.occ[cell] === 5 ? doorAt(cell) : -1;
+    workspace.pressing[i] = 1;
+    workspace.weightSum[i] += 1;
+  }
+}
+function weighPlayer(view, workspace, params, player) {
+  const { store } = view;
+  for (let i = 0; i < view.n; i++) {
+    if (!workspace.canPress[i]) continue;
+    const ex = player.x - store.x[i];
+    const ez = player.z - store.z[i];
+    const squared = ex * ex + ez * ez;
+    if (squared > PLAYER_RADIUS_SQUARED || squared < 1e-6) continue;
+    const distance = Math.sqrt(squared);
+    const weight = hasAim(store, i) ? frontWeight((store.aimX[i] * ex + store.aimZ[i] * ez) / distance, params.frontCone) : 1;
+    workspace.playerWeight[i] = weight;
+    if (weight > 0) workspace.pressing[i] = 1;
+    workspace.weightSum[i] += weight;
+  }
+}
+function clearWorkspace(view, workspace) {
+  const { store } = view;
+  for (let i = 0; i < view.n; i++) {
+    workspace.weightSum[i] = 0;
+    workspace.pressing[i] = 0;
+    workspace.wallKind[i] = 0;
+    workspace.playerWeight[i] = 0;
+    workspace.cutExcess[i] = 0;
+    store.field[i] = 0;
+  }
+}
+function ownDrive(store, context, workspace, i) {
+  if (!hasAim(store, i) || !workspace.pressing[i]) return 0;
+  return context.driveForceOfType[store.type[i]] * store.driveFactor[i];
+}
+function spreadField(view, workspace, params, context, out) {
+  const { store } = view;
+  for (let i = 0; i < view.n; i++) {
+    if (!workspace.canPress[i]) continue;
+    store.field[i] = ownDrive(store, context, workspace, i);
+    if (store.field[i] > 0) out.drivers++;
+  }
+  for (let p = 0; p < view.workspace.pairCount; p++) {
+    const i = view.workspace.pairI[p];
+    const j = view.workspace.pairJ[p];
+    const forward = workspace.pairWeightForward[p];
+    const backward = workspace.pairWeightBackward[p];
+    if (forward > 0) store.field[j] += params.transmission * store.fieldPrev[i] * forward * forward / workspace.weightSum[i];
+    if (backward > 0) store.field[i] += params.transmission * store.fieldPrev[j] * backward * backward / workspace.weightSum[j];
+  }
+  for (let i = 0; i < view.n; i++) {
+    if (!workspace.canPress[i]) continue;
+    const passed = params.transmission * store.fieldPrev[i] / (workspace.weightSum[i] || 1);
+    if (workspace.wallKind[i] && workspace.wallDoor[i] >= 0) {
+      if (context.doorOut) {
+        context.doorOut.cell[i] = workspace.wallDoor[i];
+        context.doorOut.load[i] = passed * params.h;
+      } else context.doorLoad[workspace.wallDoor[i]] += passed * params.h;
+    }
+    if (workspace.playerWeight[i] > 0) out.playerLoad += passed * workspace.playerWeight[i] * workspace.playerWeight[i];
+    if (store.field[i] > params.cap) store.field[i] = params.cap;
+  }
+}
+function applyCuts(view, workspace) {
+  const { store } = view;
+  for (let i = 0; i < view.n; i++) {
+    const excess = workspace.cutExcess[i];
+    if (excess <= 0) continue;
+    store.vx[i] -= excess * workspace.cutX[i];
+    store.vz[i] -= excess * workspace.cutZ[i];
+  }
+}
+function pressureStep(view, workspace, params, context, out) {
+  out.playerLoad = 0;
+  out.drivers = 0;
+  clearWorkspace(view, workspace);
+  readPressing(view, workspace);
+  weighPairs(view, workspace, params);
+  weighWalls(view, workspace, params, context.doorAt);
+  if (context.player) weighPlayer(view, workspace, params, context.player);
+  spreadField(view, workspace, params, context, out);
+  applyCuts(view, workspace);
+  for (let i = 0; i < view.n; i++) view.store.fieldPrev[i] = view.store.field[i];
+}
+
+// src/physics/offload/kernel.ts
+var PAIRS_PER_AGENT2 = 12;
+var STORE_KEYS = ["x", "z", "y", "vx", "vz", "pushX", "pushZ", "mass", "build", "aimX", "aimZ", "driveFactor", "fieldPrev"];
+function createKernel(setup) {
+  const { capacity } = setup;
+  const side = Math.floor(setup.gridSize / setup.gridCell);
+  const half = setup.gridSize / 2;
+  const before = { x: new Float32Array(capacity), z: new Float32Array(capacity), pushX: new Float32Array(capacity), pushZ: new Float32Array(capacity), vx: new Float32Array(capacity), vz: new Float32Array(capacity) };
+  const driveForceOfType = Float32Array.from(setup.driveForceOfType);
+  const contactResult = { contacts: 0, maxOverlap: 0, overlapSum: 0 };
+  const pressureResult = { playerLoad: 0, drivers: 0 };
+  const workspace = setup.pressure ? createPressureWorkspace(capacity, capacity * PAIRS_PER_AGENT2) : null;
+  const cellOf = createCellOf(half, setup.gridCell, side);
+  const doorLoadUnused = new Float32Array(0);
+  const store = {};
+  const grid = { size: setup.gridSize, half, occ: new Uint8Array(0), cellOf };
+  const view = { n: 0, store, grid, workspace: createContactWorkspace(capacity, grid) };
+  const bind = (frame) => {
+    Object.assign(store, frame.u8, { identity: frame.identity, field: frame.f32.field });
+    for (const key of STORE_KEYS) store[key] = frame.f32[key];
+    grid.occ = frame.occ;
+    return view;
+  };
+  const run = (frame) => {
+    const { header } = frame;
+    const n = header[HEADER.n];
+    const contact = bind(frame);
+    contact.n = n;
+    for (let i = 0; i < n; i++) {
+      before.x[i] = frame.f32.x[i];
+      before.z[i] = frame.f32.z[i];
+      before.pushX[i] = frame.f32.pushX[i];
+      before.pushZ[i] = frame.f32.pushZ[i];
+      before.vx[i] = frame.f32.vx[i];
+      before.vz[i] = frame.f32.vz[i];
+    }
+    const h = header[HEADER.h];
+    const params = { ...setup.contact, h };
+    contactStep(contact, params, contactResult);
+    header[HEADER.contacts] = contactResult.contacts;
+    header[HEADER.maxOverlap] = contactResult.maxOverlap;
+    header[HEADER.overlapSum] = contactResult.overlapSum;
+    frame.doorCell.fill(-1, 0, n);
+    frame.f32.doorLoad.fill(0, 0, n);
+    if (workspace && setup.pressure) {
+      const player = header[HEADER.playerOn] ? { x: header[HEADER.playerX], z: header[HEADER.playerZ] } : void 0;
+      const doorOut = { cell: frame.doorCell, load: frame.f32.doorLoad };
+      pressureStep(contact, workspace, { ...setup.pressure, h, radius: setup.contact.radius }, { driveForceOfType, doorAt: (cell) => cell, doorLoad: doorLoadUnused, player, doorOut }, pressureResult);
+      let top = 0;
+      for (let i = 0; i < n; i++) top = Math.max(top, frame.f32.field[i]);
+      header[HEADER.fieldMax] = top;
+    } else header[HEADER.fieldMax] = 0;
+    header[HEADER.playerLoad] = pressureResult.playerLoad;
+    header[HEADER.drivers] = pressureResult.drivers;
+    const { f32 } = frame;
+    for (let i = 0; i < n; i++) {
+      f32.deltaX[i] = f32.x[i] - before.x[i];
+      f32.deltaZ[i] = f32.z[i] - before.z[i];
+      f32.deltaPushX[i] = f32.pushX[i] - before.pushX[i];
+      f32.deltaPushZ[i] = f32.pushZ[i] - before.pushZ[i];
+      f32.deltaVx[i] = f32.vx[i] - before.vx[i];
+      f32.deltaVz[i] = f32.vz[i] - before.vz[i];
+      f32.shove[i] = contact.workspace.shove[i];
+    }
+  };
+  return { run };
+}
+
+// src/physics/offload/worker-host.ts
+var CONTROL = { IDLE: 0, SUBMITTED: 1, DONE: 2, STOP: 3 };
+function attachPhysicsWorker(port) {
+  let kernel = null;
+  let shape = null;
+  port.onMessage((data) => {
+    const message = data;
+    if (message.type === "init") {
+      kernel = createKernel(message.setup);
+      shape = message.shape;
+      if (message.frames && message.control) runShared(kernel, message.frames.map((buffer) => createFrame(buffer, message.shape)), new Int32Array(message.control));
+      return;
+    }
+    if (!kernel || !shape) return;
+    const frame = createFrame(message.buffer, shape);
+    kernel.run(frame);
+    port.postMessage({ type: "done", buffer: message.buffer }, [message.buffer]);
+  });
+}
+function runShared(kernel, frames, control) {
+  for (let turn = 0; ; turn++) {
+    const slot = turn % frames.length;
+    for (; ; ) {
+      const state = Atomics.load(control, slot);
+      if (state === CONTROL.STOP) return;
+      if (state === CONTROL.SUBMITTED) break;
+      Atomics.wait(control, slot, state);
+    }
+    kernel.run(frames[slot]);
+    Atomics.store(control, slot, CONTROL.DONE);
+    Atomics.notify(control, slot);
+  }
+}
+
+// src/physics/offload/worker-entry.ts
+var scope = globalThis;
+if (typeof scope.WorkerGlobalScope !== "undefined" && scope.postMessage && scope.addEventListener) {
+  const self = scope;
+  attachPhysicsWorker({ postMessage: (message, transfer) => self.postMessage(message, transfer), onMessage: (listener) => self.addEventListener("message", (event) => listener(event.data)) });
+}
+//# sourceMappingURL=physics-worker.js.map