@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/core/src/physics/interpolation-buffer.js

@@ -0,0 +1,182 @@
+/**
+ * Double-buffered interpolation buffer for smooth rendering between
+ * fixed-timestep physics ticks.
+ *
+ * Two preallocated `Float32Array` slots (`prev`, `curr`), each sized
+ * `maxEntities × 8` (pos.xyz + rot.xyzw + 1 pad). No per-entity per-frame
+ * allocation in the hot path.
+ *
+ * The rendered state is ~1 tick behind (no extrapolation): we interpolate
+ * between `prev` and `curr` using the accumulator's alpha.
+ */
+export class InterpolationBuffer {
+    maxEntities;
+    prev;
+    curr;
+    /** Map from entity index → slot offset in the buffer. */
+    entityToSlot = new Map();
+    /** Reverse map: slot → entity index. */
+    slotToEntity = new Map();
+    nextSlot = 0;
+    /** Whether writeTick has been called at least once. */
+    initialized = false;
+    constructor(maxEntities) {
+        this.maxEntities = maxEntities;
+        this.prev = new Float32Array(maxEntities * 8);
+        this.curr = new Float32Array(maxEntities * 8);
+    }
+    /**
+     * Assign a slot for an entity. Called when a body is registered.
+     * Returns the slot index, or -1 if capacity is exceeded.
+     */
+    assignSlot(entityIndex) {
+        if (this.entityToSlot.has(entityIndex))
+            return this.entityToSlot.get(entityIndex);
+        if (this.nextSlot >= this.maxEntities)
+            return -1;
+        const slot = this.nextSlot++;
+        this.entityToSlot.set(entityIndex, slot);
+        this.slotToEntity.set(slot, entityIndex);
+        return slot;
+    }
+    /**
+     * Release the slot for an entity. The slot is not reclaimed (simple
+     * bump allocator); call `resize` to compact if needed.
+     */
+    releaseSlot(entityIndex) {
+        const slot = this.entityToSlot.get(entityIndex);
+        if (slot === undefined)
+            return;
+        this.entityToSlot.delete(entityIndex);
+        this.slotToEntity.delete(slot);
+    }
+    /**
+     * Write the current tick's transforms into `curr`, then swap `prev ↔ curr`.
+     * Uses `readTransforms` from the backend (one FFI pass per realm).
+     *
+     * The caller provides a `readFn(realmId, buffer, count)` that delegates to
+     * `PhysicsBackend.readTransforms`.
+     */
+    writeTick(realmId, readFn, entityCount) {
+        const count = Math.min(entityCount, this.maxEntities);
+        // On the first tick, copy data to both prev and curr so interpolation
+        // produces correct values instead of interpolating from zeros.
+        if (!this.initialized) {
+            readFn(realmId, this.curr, count);
+            this.prev.set(this.curr);
+            this.initialized = true;
+            return;
+        }
+        // Read into prev (reused as scratch), then swap so curr = new data
+        readFn(realmId, this.prev, count);
+        // Swap: the new data is in prev; we want curr = new, prev = old curr
+        const tmp = this.curr;
+        this.curr = this.prev;
+        this.prev = tmp;
+    }
+    /**
+     * Read interpolated transforms into `outBuffer`.
+     * Linear interpolation for position, nlerp for rotation quaternions.
+     * `alpha` is in [0, 1] — the fraction between prev and curr.
+     */
+    readInterpolated(alpha, outBuffer, entityCount) {
+        const a = Math.max(0, Math.min(1, alpha));
+        const count = Math.min(entityCount, this.maxEntities);
+        const byteCount = count * 8;
+        // Fast paths: when alpha is 0 or 1, skip per-entity nlerp math entirely.
+        // alpha=1 is the most common case (render rate > sim rate → stalled at
+        // curr until the next tick arrives).
+        if (a >= 1) {
+            outBuffer.set(this.curr.subarray(0, byteCount));
+            return;
+        }
+        if (a <= 0) {
+            outBuffer.set(this.prev.subarray(0, byteCount));
+            return;
+        }
+        const invA = 1 - a;
+        for (let i = 0; i < count; i++) {
+            const offset = i * 8;
+            // Position: linear interp
+            outBuffer[offset] = this.prev[offset] * invA + this.curr[offset] * a;
+            outBuffer[offset + 1] = this.prev[offset + 1] * invA + this.curr[offset + 1] * a;
+            outBuffer[offset + 2] = this.prev[offset + 2] * invA + this.curr[offset + 2] * a;
+            // Rotation: nlerp (normalized lerp) — good enough for smooth visuals
+            const px = this.prev[offset + 3];
+            const py = this.prev[offset + 4];
+            const pz = this.prev[offset + 5];
+            const pw = this.prev[offset + 6];
+            const cx = this.curr[offset + 3];
+            const cy = this.curr[offset + 4];
+            const cz = this.curr[offset + 5];
+            const cw = this.curr[offset + 6];
+            // Choose the shorter arc (negate curr if dot < 0)
+            const dot = px * cx + py * cy + pz * cz + pw * cw;
+            const sign = dot < 0 ? -1 : 1;
+            let rx = px * invA + cx * a * sign;
+            let ry = py * invA + cy * a * sign;
+            let rz = pz * invA + cz * a * sign;
+            let rw = pw * invA + cw * a * sign;
+            // Normalize
+            const len = Math.sqrt(rx * rx + ry * ry + rz * rz + rw * rw);
+            if (len > 1e-9) {
+                rx /= len;
+                ry /= len;
+                rz /= len;
+                rw /= len;
+            }
+            else {
+                rx = 0;
+                ry = 0;
+                rz = 0;
+                rw = 1;
+            }
+            outBuffer[offset + 3] = rx;
+            outBuffer[offset + 4] = ry;
+            outBuffer[offset + 5] = rz;
+            outBuffer[offset + 6] = rw;
+            // offset + 7 is padding (scale or unused)
+            outBuffer[offset + 7] = this.curr[offset + 7];
+        }
+    }
+    /**
+     * Reseed both prev and curr slots for a body (post-transfer).
+     * Writes identical values to avoid interpolation snap.
+     */
+    reseed(entityIndex, pos, rot, scale = 1) {
+        const slot = this.entityToSlot.get(entityIndex);
+        if (slot === undefined)
+            return;
+        const offset = slot * 8;
+        [this.prev, this.curr].forEach((buf) => {
+            buf[offset] = pos[0];
+            buf[offset + 1] = pos[1];
+            buf[offset + 2] = pos[2];
+            buf[offset + 3] = rot[0];
+            buf[offset + 4] = rot[1];
+            buf[offset + 5] = rot[2];
+            buf[offset + 6] = rot[3];
+            buf[offset + 7] = scale;
+        });
+    }
+    /**
+     * Reseed from a PhysicsBody's current state (post-transfer convenience).
+     * Reads pos/rot via the provided getter functions.
+     */
+    reseedBody(body, getPos, getRot) {
+        this.reseed(body.entity.index, getPos(body), getRot(body));
+    }
+    resize(maxEntities) {
+        if (maxEntities === this.maxEntities)
+            return;
+        this.maxEntities = maxEntities;
+        this.prev = new Float32Array(maxEntities * 8);
+        this.curr = new Float32Array(maxEntities * 8);
+        this.entityToSlot.clear();
+        this.slotToEntity.clear();
+        this.nextSlot = 0;
+    }
+    getMaxEntities() {
+        return this.maxEntities;
+    }
+}

package/dist/core/src/physics/lifecycle.js

@@ -0,0 +1,66 @@
+import { PhysicsRealm } from "./realm.js";
+export class PhysicsLifecycle {
+    backend;
+    pending = [];
+    realms = new Map();
+    realmNames = new Map();
+    constructor(backend) {
+        this.backend = backend;
+    }
+    registerRealm(name, config, phase = "scene-start") {
+        this.pending.push({ config: { ...config }, phase, realm: null });
+    }
+    bootstrap(phase) {
+        this.pending.forEach((pending) => {
+            if (pending.phase === phase && pending.realm === null) {
+                const realm = new PhysicsRealm(this.backend, pending.config);
+                pending.realm = realm;
+                this.realms.set(realm.id, realm);
+                this.realmNames.set(pending.config.name, realm.id);
+            }
+        });
+    }
+    getRealm(id) {
+        return this.realms.get(id);
+    }
+    getRealmByName(name) {
+        const id = this.realmNames.get(name);
+        return id !== undefined ? this.realms.get(id) : undefined;
+    }
+    createRealmNow(config) {
+        const realm = new PhysicsRealm(this.backend, config);
+        this.realms.set(realm.id, realm);
+        this.realmNames.set(config.name, realm.id);
+        return realm;
+    }
+    destroyRealm(id) {
+        const realm = this.realms.get(id);
+        if (realm) {
+            realm.destroy();
+            this.realms.delete(id);
+            for (const [name, rid] of this.realmNames.entries()) {
+                if (rid === id) {
+                    this.realmNames.delete(name);
+                    break;
+                }
+            }
+        }
+    }
+    destroyAll() {
+        for (const realm of this.realms.values()) {
+            realm.destroy();
+        }
+        this.realms.clear();
+        this.realmNames.clear();
+        this.pending = [];
+    }
+    stepAll(dt) {
+        this.backend.stepAll(dt);
+    }
+    getRealmCount() {
+        return this.realms.size;
+    }
+    listRealms() {
+        return [...this.realmNames.keys()];
+    }
+}

package/dist/core/src/physics/load-shedder.js

@@ -0,0 +1,155 @@
+/**
+ * Island-aware load shedding for physics.
+ *
+ * When the accumulator is over budget (spiral-of-death risk), the shedder
+ * progressively freezes whole islands of bodies to reduce simulation cost.
+ *
+ * Strategy:
+ * 1. **Aggressive sleep** (first line of defense): lower sleep thresholds
+ *    for low-importance bodies so Rapier's native sleep kicks in.
+ * 2. **Hard freeze** (emergency only): set whole islands to kinematic +
+ *    zero velocity. Islands are sorted by importance (ascending) and
+ *    avgVelocity (ascending) so the least-important, near-rest islands
+ *    freeze first.
+ * 3. **Hysteresis unfreeze**: require budget headroom for N consecutive
+ *    frames before unfreezing.
+ */
+export class LoadShedder {
+    importanceWeights = new Map();
+    frozenBodies = new Set();
+    frozenBodyRefs = new Map();
+    consecutiveHeadroomFrames = 0;
+    unfreezeHeadroomFrames;
+    constructor(opts = {}) {
+        this.unfreezeHeadroomFrames = opts.unfreezeHeadroomFrames ?? 60;
+    }
+    setImportance(bodyId, weight) {
+        this.importanceWeights.set(bodyId, weight);
+    }
+    /**
+     * Check if the accumulator is over budget (shedding needed).
+     */
+    checkBudget(accumulator) {
+        return accumulator.isOverBudget();
+    }
+    /**
+     * First line of defense: lower sleep thresholds for low-importance bodies.
+     * Leverages Rapier's native island-aware sleep.
+     */
+    aggressiveSleep(realmId, backend, bodies) {
+        bodies.forEach((body) => {
+            const weight = this.importanceWeights.get(body.id) ?? 0;
+            if (weight < 0.3) {
+                // Low importance — make it easier to sleep (higher threshold = sleeps sooner)
+                backend.setSleepThresholds(realmId, 0.5, 0.5);
+            }
+        });
+    }
+    /**
+     * Hard freeze: island-aware freezing of whole islands.
+     * Sorts islands by max importance (ascending), then freezes the
+     * least-important islands until the accumulator recovers.
+     *
+     * Returns the number of bodies frozen.
+     */
+    shed(realmId, backend, tier, bodyMap) {
+        const islands = backend.getIslands(realmId);
+        if (islands.length === 0)
+            return 0;
+        // Score each island: max importance of any member (lower = freeze first)
+        const scored = islands.map((island) => {
+            let maxImportance = 0;
+            island.bodyIds.forEach((bodyId) => {
+                const w = this.importanceWeights.get(bodyId) ?? 0;
+                if (w > maxImportance)
+                    maxImportance = w;
+            });
+            return { island, maxImportance, avgVelocity: island.avgVelocity };
+        });
+        // Sort by importance ascending, then by avgVelocity ascending (near-rest first)
+        scored.sort((a, b) => {
+            if (a.maxImportance !== b.maxImportance)
+                return a.maxImportance - b.maxImportance;
+            return a.avgVelocity - b.avgVelocity;
+        });
+        let frozenCount = 0;
+        scored.forEach(({ island }) => {
+            // Freeze this entire island
+            for (let _i = 0, _it = island.bodyIds, _n = _it.length; _i < _n; _i++) {
+                const bodyId = _it[_i];
+                if (this.frozenBodies.has(bodyId))
+                    continue;
+                const body = bodyMap?.get(bodyId);
+                if (body) {
+                    // Actually freeze the body (set kinematic + zero velocity)
+                    this.freezeBody(body, backend, tier);
+                }
+                else {
+                    // No body ref available — just track the id
+                    this.frozenBodies.add(bodyId);
+                }
+                frozenCount++;
+            }
+            // In a real implementation, we'd check the accumulator after each
+            // island and stop once budget recovers. The caller drives this.
+        });
+        return frozenCount;
+    }
+    /**
+     * Freeze a specific body (set to kinematic + zero velocity).
+     * Called by the shedder when it determines an island should be frozen.
+     */
+    freezeBody(body, backend, tier) {
+        if (this.frozenBodies.has(body.id))
+            return;
+        backend.setBodyType(body, "kinematic");
+        backend.setLinearVelocity(body, [0, 0, 0]);
+        backend.setAngularVelocity(body, [0, 0, 0]);
+        this.frozenBodies.add(body.id);
+        this.frozenBodyRefs.set(body.id, { body, tier });
+    }
+    /**
+     * Unfreeze a previously frozen body (restore to dynamic).
+     */
+    unfreezeBody(body, backend) {
+        if (!this.frozenBodies.has(body.id))
+            return;
+        backend.setBodyType(body, "dynamic");
+        this.frozenBodies.delete(body.id);
+        this.frozenBodyRefs.delete(body.id);
+    }
+    /**
+     * Unfreeze all frozen bodies. Called when the accumulator has had
+     * enough headroom for `unfreezeHeadroomFrames` consecutive frames.
+     */
+    unfreezeAll(backend) {
+        for (const { body } of this.frozenBodyRefs.values()) {
+            backend.setBodyType(body, "dynamic");
+        }
+        this.frozenBodies.clear();
+        this.frozenBodyRefs.clear();
+        this.consecutiveHeadroomFrames = 0;
+    }
+    /**
+     * Called every frame. If the accumulator is NOT over budget, increment
+     * the headroom counter; once it exceeds the threshold, unfreeze all.
+     * If over budget, reset the counter.
+     */
+    tick(accumulator, backend) {
+        if (accumulator.isOverBudget()) {
+            this.consecutiveHeadroomFrames = 0;
+        }
+        else {
+            this.consecutiveHeadroomFrames++;
+            if (this.consecutiveHeadroomFrames >= this.unfreezeHeadroomFrames && this.frozenBodies.size > 0) {
+                this.unfreezeAll(backend);
+            }
+        }
+    }
+    getFrozenCount() {
+        return this.frozenBodies.size;
+    }
+    isFrozen(bodyId) {
+        return this.frozenBodies.has(bodyId);
+    }
+}

package/dist/core/src/physics/physics-accumulator.js

@@ -0,0 +1,94 @@
+/**
+ * Fixed-timestep accumulator for deterministic physics stepping.
+ *
+ * Accumulates real-time frame deltas and produces a list of fixed-dt steps
+ * to run each frame. Caps catch-up steps to avoid spiral-of-death; if the
+ * cap is hit, the remainder is dropped and `overBudget` is set (panic-freeze
+ * trigger for the LoadShedder).
+ */
+export class PhysicsAccumulator {
+    /** Fixed simulation timestep in seconds (default 1/60). */
+    fixedDt;
+    /** Max number of catch-up steps per frame (default 5). */
+    maxCatchUpSteps;
+    /** Per-step wall-time budget in ms before declaring over-budget (default 12). */
+    stepBudgetMs;
+    accumulator = 0;
+    overBudget = false;
+    slipAmount = 0;
+    lastStepWallMs = 0;
+    constructor(opts = {}) {
+        const fixedDt = opts.fixedDt ?? 1 / 60;
+        if (fixedDt <= 0 || !Number.isFinite(fixedDt))
+            throw new Error(`Invalid fixedDt: ${fixedDt}`);
+        this.fixedDt = fixedDt;
+        this.maxCatchUpSteps = opts.maxCatchUpSteps ?? 5;
+        this.stepBudgetMs = opts.stepBudgetMs ?? 12;
+    }
+    /**
+     * Add real-time delta to the accumulator.
+     * Validates `realDt` is finite and non-negative; ignores invalid values.
+     */
+    accumulate(realDt) {
+        if (!Number.isFinite(realDt) || realDt < 0)
+            return;
+        this.accumulator += realDt;
+    }
+    /**
+     * Returns the list of fixed-dt steps to run this frame, capped at
+     * `maxCatchUpSteps`. If the accumulator still has leftover after the cap,
+     * the remainder is dropped, `slipAmount` is recorded, and `overBudget`
+     * is set.
+     */
+    consumeSteps() {
+        const steps = [];
+        let count = 0;
+        while (this.accumulator >= this.fixedDt && count < this.maxCatchUpSteps) {
+            steps.push(this.fixedDt);
+            this.accumulator -= this.fixedDt;
+            count++;
+        }
+        // If there's still time left after capping, we're slipping
+        if (this.accumulator >= this.fixedDt) {
+            this.slipAmount = this.accumulator;
+            this.overBudget = true;
+            // Drop the remainder to avoid unbounded growth
+            this.accumulator = 0;
+        }
+        else {
+            // Only clear over-budget if we're keeping up AND step wall time is OK
+            if (!this.overBudget || this.lastStepWallMs <= this.stepBudgetMs) {
+                this.overBudget = false;
+            }
+            this.slipAmount = 0;
+        }
+        return steps;
+    }
+    /**
+     * Record the wall-clock time of the last step batch. If it exceeds
+     * `stepBudgetMs`, set `overBudget`.
+     */
+    recordStepWallTime(ms) {
+        if (!Number.isFinite(ms) || ms < 0)
+            return;
+        this.lastStepWallMs = ms;
+        if (ms > this.stepBudgetMs) {
+            this.overBudget = true;
+        }
+    }
+    isOverBudget() {
+        return this.overBudget;
+    }
+    getSlipAmount() {
+        return this.slipAmount;
+    }
+    getAccumulator() {
+        return this.accumulator;
+    }
+    reset() {
+        this.accumulator = 0;
+        this.overBudget = false;
+        this.slipAmount = 0;
+        this.lastStepWallMs = 0;
+    }
+}

package/dist/core/src/physics/physics-system.js

@@ -0,0 +1,142 @@
+import { getColumnValue } from "../ecs/archetype.js";
+import { Stage, system } from "../ecs/system.js";
+import { PhysicsTransform, RigidBody, Velocity } from "./body.js";
+import { RealmTier } from "./interface.js";
+/**
+ * Create the physics system. The resources are attached to the system
+ * via closure (the caller provides them when creating the system).
+ */
+export function createPhysicsSystem(resources) {
+    const query = {
+        descriptor: {
+            required: [RigidBody.id, PhysicsTransform.id],
+            excluded: [],
+            lastReadTick: 0,
+        },
+        // Stubs — the actual query is iterated via archetypes in the system fn
+    };
+    return system("PhysicsSystem", Stage.Physics, (ctx) => {
+        const { world, dt } = ctx;
+        const { backend, realmManager, accumulator, interpolationBuffer, loadShedder, safety, ccdHeuristic, snapshotManager, playerCameras, maxEntities, nanSweepInterval = 10, nanSweepVelocityThreshold = 0.1, } = resources;
+        // 1. Sync ECS transform → physics (kinematic/static bodies)
+        syncEcsToPhysics(world, realmManager);
+        // 2. Accumulate real dt and consume fixed steps
+        accumulator.accumulate(dt);
+        const steps = accumulator.consumeSteps();
+        const stepStart = performance.now();
+        steps.forEach((fixedDt) => {
+            realmManager.step(fixedDt);
+        });
+        const stepWallMs = steps.length > 0 ? (performance.now() - stepStart) / steps.length : 0;
+        accumulator.recordStepWallTime(stepWallMs);
+        // 3. Update realm membership (promote/demote based on distance)
+        realmManager.updateRealmMembership(playerCameras, dt);
+        // 4. Write tick to interpolation buffer
+        const nearRealm = realmManager.getRealm(RealmTier.Near);
+        interpolationBuffer.writeTick(nearRealm.id, (realmId, buf, count) => backend.readTransforms(realmId, buf, count), maxEntities);
+        // 5. Load shedding
+        if (loadShedder.checkBudget(accumulator)) {
+            const nearBodies = nearRealm.listBodies();
+            loadShedder.aggressiveSleep(nearRealm.id, backend, nearBodies);
+            if (accumulator.isOverBudget()) {
+                const bodyMap = new Map();
+                nearBodies.forEach((b) => { bodyMap.set(b.id, b); ; });
+                loadShedder.shed(nearRealm.id, backend, RealmTier.Near, bodyMap);
+            }
+        }
+        loadShedder.tick(accumulator, backend);
+        // 6. CCD heuristic update
+        const dynamicBodies = nearRealm.listBodies();
+        ccdHeuristic.updateCCD(backend, dynamicBodies, dt, (_body) => {
+            return 0.5; // Default collider size; caller can override
+        });
+        // 7. Safety: sanitize solver output every tick; periodic sweep on interval
+        safety.sanitizeSolverOutput(backend, dynamicBodies);
+        safety.periodicFiniteSweep(backend, dynamicBodies, nanSweepInterval, nanSweepVelocityThreshold);
+        // 8. Sync physics → ECS (dynamic bodies)
+        syncPhysicsToEcs(world, realmManager);
+        // 9. Snapshot tick
+        snapshotManager.tick();
+    }, { queries: [query] });
+}
+/**
+ * Iterate entities that have RigidBody + PhysicsTransform components.
+ * Uses the archetype graph directly (no per-frame allocation).
+ */
+function* iterRigidBodies(world) {
+    const rbId = RigidBody.id;
+    const transformId = PhysicsTransform.id;
+    const velocityId = Velocity.id;
+    for (let _i = 0, _it = world.allArchetypes, _n = _it.length; _i < _n; _i++) {
+        const arch = _it[_i];
+        if (!arch.componentSet.has(rbId) || !arch.componentSet.has(transformId))
+            continue;
+        const rbCol = arch.columns.get(rbId);
+        const transformCol = arch.columns.get(transformId);
+        const velocityCol = arch.columns.get(velocityId);
+        if (!rbCol || !transformCol)
+            continue;
+        for (let i = 0; i < arch.entities.length; i++) {
+            const entity = arch.entities[i];
+            yield {
+                entity,
+                rb: getColumnValue(rbCol, i),
+                transform: getColumnValue(transformCol, i),
+                velocity: getColumnValue(velocityCol, i),
+            };
+        }
+    }
+}
+/**
+ * Sync ECS transform data → physics backend for kinematic/static bodies.
+ * Dynamic bodies are driven by the physics simulation, not ECS.
+ */
+function syncEcsToPhysics(world, realmManager) {
+    for (const { rb, transform } of iterRigidBodies(world)) {
+        if (rb.bodyType === "dynamic")
+            continue;
+        const body = findBody(realmManager, rb.bodyId, rb.realmId);
+        if (!body)
+            continue;
+        const realm = realmManager.getRealm(body.realmId);
+        realm.setPosition(body, transform.position);
+        realm.setRotation(body, transform.rotation);
+    }
+}
+/**
+ * Sync physics backend → ECS transform data for dynamic bodies.
+ */
+function syncPhysicsToEcs(world, realmManager) {
+    for (const { rb, transform, velocity } of iterRigidBodies(world)) {
+        if (rb.bodyType !== "dynamic")
+            continue;
+        const body = findBody(realmManager, rb.bodyId, rb.realmId);
+        if (!body)
+            continue;
+        const realm = realmManager.getRealm(body.realmId);
+        const pos = realm.getPosition(body);
+        const rot = realm.getRotation(body);
+        // Store previous for interpolation
+        transform.prevPosition = transform.position;
+        transform.prevRotation = transform.rotation;
+        transform.position = pos;
+        transform.rotation = rot;
+        // Also sync velocity
+        if (velocity) {
+            velocity.linear = realm.getLinearVelocity(body);
+        }
+    }
+}
+/** Look up a PhysicsBody by bodyId + realmId in the RealmManager. */
+function findBody(realmManager, bodyId, realmId) {
+    for (let _i = 0, _it = [RealmTier.Near, RealmTier.Mid, RealmTier.Far], _n = _it.length; _i < _n; _i++) {
+        const tier = _it[_i];
+        const realm = realmManager.getRealm(tier);
+        if (realm.id !== realmId)
+            continue;
+        const body = realm.getBody(bodyId);
+        if (body)
+            return body;
+    }
+    return null;
+}