@its-not-rocket-science/ananke 0.1.69 → 0.5.1

package/dist/src/sim/resolvers/capability-resolver.js

@@ -0,0 +1,270 @@
+import { SCALE, q, clampQ, qMul } from "../../units.js";
+import { DamageChannel } from "../../channels.js";
+import { isCapabilityAvailable } from "../tech.js";
+import { eventSeed } from "../seeds.js";
+import { entityInCone } from "../cone.js";
+import { vAdd } from "../vec3.js";
+import { TraceKinds } from "../kinds.js";
+const CAPABILITY_CHANNEL_WEAPONS = {
+    [DamageChannel.Kinetic]: { id: "cap_kinetic", kind: "weapon", name: "Kinetic Force", mass_kg: 0, bulk: q(0), damage: { penetrationBias: q(0.30), surfaceFrac: q(0.30), internalFrac: q(0.30), structuralFrac: q(0.40), bleedFactor: q(0.30) } },
+    [DamageChannel.Thermal]: { id: "cap_thermal", kind: "weapon", name: "Thermal", mass_kg: 0, bulk: q(0), damage: { penetrationBias: q(0), surfaceFrac: q(0.40), internalFrac: q(0.50), structuralFrac: q(0.10), bleedFactor: q(0.10) } },
+    [DamageChannel.Electrical]: { id: "cap_elec", kind: "weapon", name: "Electrical", mass_kg: 0, bulk: q(0), damage: { penetrationBias: q(0.20), surfaceFrac: q(0.20), internalFrac: q(0.60), structuralFrac: q(0.20), bleedFactor: q(0.05) } },
+    [DamageChannel.Chemical]: { id: "cap_chem", kind: "weapon", name: "Chemical", mass_kg: 0, bulk: q(0), damage: { penetrationBias: q(0), surfaceFrac: q(0.45), internalFrac: q(0.45), structuralFrac: q(0.10), bleedFactor: q(0.20) } },
+    [DamageChannel.Radiation]: { id: "cap_rad", kind: "weapon", name: "Radiation", mass_kg: 0, bulk: q(0), damage: { penetrationBias: q(0), surfaceFrac: q(0.05), internalFrac: q(0.90), structuralFrac: q(0.05), bleedFactor: q(0.05) } },
+};
+const CAPABILITY_WEAPON_DEFAULT = {
+    id: "cap_generic", kind: "weapon", name: "Capability", mass_kg: 0, bulk: q(0),
+    damage: { penetrationBias: q(0.10), surfaceFrac: q(0.30), internalFrac: q(0.40), structuralFrac: q(0.30), bleedFactor: q(0.20) },
+};
+export function applyPayload(world, actor, target, payload, trace, tick, effectId, helpers) {
+    switch (payload.kind) {
+        case "impact": {
+            const hitRegion = helpers.resolveCapabilityHitSegment(world, tick, actor, target, 0xCAB1);
+            if (!target.injury.byRegion[hitRegion])
+                break;
+            let effectiveEnergy = payload.spec.energy_J;
+            if ((target.condition.shieldReserve_J ?? 0) > 0 &&
+                target.condition.shieldExpiry_tick !== undefined &&
+                tick <= target.condition.shieldExpiry_tick) {
+                const absorbed = Math.min(target.condition.shieldReserve_J, effectiveEnergy);
+                target.condition.shieldReserve_J -= absorbed;
+                effectiveEnergy -= absorbed;
+            }
+            if (effectiveEnergy > 0) {
+                const wpn = CAPABILITY_CHANNEL_WEAPONS[payload.spec.channel] ?? CAPABILITY_WEAPON_DEFAULT;
+                helpers.applyImpactToInjury(target, wpn, effectiveEnergy, hitRegion, false, trace, tick);
+            }
+            break;
+        }
+        case "treatment": {
+            const BASE_CAP_HEAL = q(0.0050);
+            const healRate = qMul(BASE_CAP_HEAL, payload.rateMul);
+            for (const reg of Object.values(target.injury.byRegion)) {
+                if (reg.bleedingRate > 0) {
+                    reg.bleedingRate = clampQ((reg.bleedingRate - healRate), 0, SCALE.Q);
+                }
+            }
+            target.injury.shock = clampQ((target.injury.shock - qMul(q(0.01), payload.rateMul)), 0, SCALE.Q);
+            break;
+        }
+        case "armourLayer": {
+            target.condition.shieldReserve_J = (target.condition.shieldReserve_J ?? 0) + payload.resist_J;
+            const newExpiry = tick + payload.duration_ticks;
+            target.condition.shieldExpiry_tick = Math.max(target.condition.shieldExpiry_tick ?? 0, newExpiry);
+            break;
+        }
+        case "velocity": {
+            target.velocity_mps = vAdd(target.velocity_mps, payload.delta_mps);
+            break;
+        }
+        case "substance": {
+            if (!target.substances)
+                target.substances = [];
+            target.substances.push({ ...payload.substance });
+            break;
+        }
+        case "structuralRepair": {
+            const seg = target.injury.byRegion[payload.region];
+            if (seg) {
+                const floor = seg.permanentDamage ?? 0;
+                const repaired = Math.max(floor, seg.structuralDamage - payload.amount);
+                seg.structuralDamage = clampQ(repaired, 0, SCALE.Q);
+            }
+            break;
+        }
+        case "fieldEffect": {
+            if (!world.activeFieldEffects)
+                world.activeFieldEffects = [];
+            const fe = {
+                ...payload.spec,
+                id: `${actor.id}_${effectId}_${tick}`,
+                origin: { x: actor.position_m.x, y: actor.position_m.y, z: actor.position_m.z },
+                placedByEntityId: actor.id,
+            };
+            world.activeFieldEffects.push(fe);
+            break;
+        }
+        case "weaponImpact": {
+            const wpn = {
+                id: "cap_weaponimpact",
+                kind: "weapon",
+                name: "WeaponImpact",
+                mass_kg: 0,
+                bulk: q(0),
+                damage: payload.profile,
+            };
+            const hitRegion = helpers.resolveCapabilityHitSegment(world, tick, actor, target, 0xCAB2);
+            if (!target.injury.byRegion[hitRegion])
+                break;
+            let effectiveEnergy = payload.energy_J;
+            if ((target.condition.shieldReserve_J ?? 0) > 0 &&
+                target.condition.shieldExpiry_tick !== undefined &&
+                tick <= target.condition.shieldExpiry_tick) {
+                const absorbed = Math.min(target.condition.shieldReserve_J, effectiveEnergy);
+                target.condition.shieldReserve_J -= absorbed;
+                effectiveEnergy -= absorbed;
+            }
+            if (effectiveEnergy > 0) {
+                helpers.applyImpactToInjury(target, wpn, effectiveEnergy, hitRegion, false, trace, tick);
+            }
+            break;
+        }
+    }
+}
+export function applyCapabilityEffect(world, actor, targetId, effect, trace, tick, helpers) {
+    const payloads = Array.isArray(effect.payload)
+        ? effect.payload
+        : [effect.payload];
+    let targets;
+    if (effect.coneHalfAngle_rad !== undefined) {
+        const range_m = effect.range_m ?? 0;
+        let dir;
+        if (effect.coneDir === "fixed" && effect.coneDirFixed) {
+            dir = effect.coneDirFixed;
+        }
+        else {
+            const fx = actor.action.facingDirQ.x;
+            const fy = actor.action.facingDirQ.y;
+            const mag = Math.sqrt(fx * fx + fy * fy);
+            const sc = mag > 0 ? SCALE.m / mag : 1;
+            dir = { dx: Math.round(fx * sc), dy: Math.round(fy * sc) };
+        }
+        const cone = {
+            origin: { x: actor.position_m.x, y: actor.position_m.y },
+            dir,
+            halfAngle_rad: effect.coneHalfAngle_rad,
+            range_m,
+        };
+        targets = world.entities.filter(e => !e.injury.dead && entityInCone(e, cone));
+    }
+    else if (effect.aoeRadius_m !== undefined) {
+        const origin = targetId !== undefined
+            ? (world.entities.find(e => e.id === targetId)?.position_m ?? actor.position_m)
+            : actor.position_m;
+        const radSq = effect.aoeRadius_m * effect.aoeRadius_m;
+        targets = world.entities.filter(e => {
+            if (e.injury.dead)
+                return false;
+            const dx = e.position_m.x - origin.x;
+            const dy = e.position_m.y - origin.y;
+            return dx * dx + dy * dy <= radSq;
+        });
+    }
+    else if (targetId !== undefined) {
+        const t = world.entities.find(e => e.id === targetId);
+        targets = t && !t.injury.dead ? [t] : [];
+    }
+    else {
+        targets = [actor];
+    }
+    for (const target of targets) {
+        if (target.id !== actor.id) {
+            const mr = target.attributes.resilience.magicResist ?? 0;
+            if (mr > 0) {
+                const resistSeed = eventSeed(world.seed, tick, actor.id, target.id, 0x5E515);
+                if ((resistSeed % SCALE.Q) < mr)
+                    continue;
+            }
+        }
+        for (const p of payloads) {
+            applyPayload(world, actor, target, p, trace, tick, effect.id, helpers);
+        }
+    }
+}
+export function resolveActivation(world, actor, cmd, ctx, trace, tick, onInstantResolve) {
+    if (!actor.capabilitySources)
+        return;
+    const source = actor.capabilitySources.find(s => s.id === cmd.sourceId);
+    if (!source)
+        return;
+    const effect = source.effects.find(ef => ef.id === cmd.effectId);
+    if (!effect)
+        return;
+    const cooldownKey = `${source.id}:${effect.id}`;
+    if ((actor.action.capabilityCooldowns?.get(cooldownKey) ?? 0) > 0)
+        return;
+    if (effect.requiredCapability !== undefined && ctx.techCtx !== undefined) {
+        if (!isCapabilityAvailable(ctx.techCtx, effect.requiredCapability))
+            return;
+    }
+    const ax = actor.position_m.x;
+    const ay = actor.position_m.y;
+    const suppressed = (world.activeFieldEffects ?? []).some(fe => {
+        const dx = ax - fe.origin.x;
+        const dy = ay - fe.origin.y;
+        const distSq = dx * dx + dy * dy;
+        const radSq = fe.radius_m * fe.radius_m;
+        return distSq <= radSq && source.tags.some(t => fe.suppressesTags.includes(t));
+    });
+    if (suppressed) {
+        trace.onEvent({ kind: TraceKinds.CapabilitySuppressed, tick, entityId: actor.id, sourceId: cmd.sourceId, effectId: cmd.effectId });
+        return;
+    }
+    if (effect.range_m !== undefined && cmd.targetId !== undefined) {
+        const tgt = world.entities.find(e => e.id === cmd.targetId);
+        if (tgt) {
+            const dx = tgt.position_m.x - ax;
+            const dy = tgt.position_m.y - ay;
+            if (dx * dx + dy * dy > effect.range_m * effect.range_m)
+                return;
+        }
+    }
+    if (effect.castTime_ticks < 0) {
+        actor.activeConcentration = {
+            sourceId: source.id,
+            effectId: effect.id,
+            ...(cmd.targetId !== undefined ? { targetId: cmd.targetId } : {}),
+        };
+        trace.onEvent({ kind: TraceKinds.CapabilityActivated, tick, entityId: actor.id, sourceId: source.id, effectId: effect.id });
+        return;
+    }
+    const isBoundless = source.regenModel.type === "boundless";
+    let sourceToDraw = source;
+    if (!isBoundless && source.reserve_J < effect.cost_J) {
+        if (source.linkedFallbackId) {
+            const fallback = actor.capabilitySources.find(s => s.id === source.linkedFallbackId);
+            if (fallback && (fallback.regenModel.type === "boundless" || fallback.reserve_J >= effect.cost_J)) {
+                sourceToDraw = fallback;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    }
+    const drawIsBoundless = sourceToDraw.regenModel.type === "boundless";
+    if (effect.castTime_ticks > 0) {
+        if (!actor.pendingActivation) {
+            if (!drawIsBoundless)
+                sourceToDraw.reserve_J -= effect.cost_J;
+            actor.pendingActivation = cmd.targetId !== undefined
+                ? { sourceId: cmd.sourceId, effectId: cmd.effectId, targetId: cmd.targetId, resolveAtTick: tick + effect.castTime_ticks }
+                : { sourceId: cmd.sourceId, effectId: cmd.effectId, resolveAtTick: tick + effect.castTime_ticks };
+            if (effect.cooldown_ticks && effect.cooldown_ticks > 0) {
+                if (!actor.action.capabilityCooldowns)
+                    actor.action.capabilityCooldowns = new Map();
+                actor.action.capabilityCooldowns.set(cooldownKey, effect.cooldown_ticks);
+            }
+        }
+        return;
+    }
+    if (!drawIsBoundless)
+        sourceToDraw.reserve_J -= effect.cost_J;
+    onInstantResolve?.(effect);
+    trace.onEvent({ kind: TraceKinds.CapabilityActivated, tick, entityId: actor.id, sourceId: cmd.sourceId, effectId: cmd.effectId });
+    if (effect.cooldown_ticks && effect.cooldown_ticks > 0) {
+        if (!actor.action.capabilityCooldowns)
+            actor.action.capabilityCooldowns = new Map();
+        actor.action.capabilityCooldowns.set(cooldownKey, effect.cooldown_ticks);
+    }
+    if (effect.sustainedTicks && effect.sustainedTicks > 1) {
+        actor.action.sustainedEmission = {
+            sourceId: cmd.sourceId,
+            effectId: cmd.effectId,
+            ...(cmd.targetId !== undefined ? { targetId: cmd.targetId } : {}),
+            remainingTicks: effect.sustainedTicks - 1,
+        };
+    }
+}

package/dist/src/sim/resolvers/grapple-resolver.d.ts

@@ -0,0 +1,28 @@
+import type { WorldState } from "../world.js";
+import { type Entity } from "../entity.js";
+import type { BreakGrappleCommand, GrappleCommand } from "../commands.js";
+import { type SimulationTuning } from "../tuning.js";
+import { type Q } from "../../units.js";
+import type { WorldIndex } from "../indexing.js";
+import { type ImpactEvent } from "../events.js";
+import type { TraceSink } from "../trace.js";
+type ResolveGrappleCommandOptions = {
+    world: WorldState;
+    entity: Entity;
+    command: GrappleCommand;
+    tuning: SimulationTuning;
+    index: WorldIndex;
+    impacts: ImpactEvent[];
+    trace: TraceSink;
+};
+export declare function resolveGrappleCommand(options: ResolveGrappleCommandOptions): void;
+type ResolveBreakBindOptions = {
+    world: WorldState;
+    entity: Entity;
+    intensity: Q;
+    index: WorldIndex;
+    trace: TraceSink;
+};
+export declare function resolveBreakBind(options: ResolveBreakBindOptions): void;
+export declare function resolveBreakGrappleCommand(world: WorldState, entity: Entity, command: BreakGrappleCommand, tuning: SimulationTuning, index: WorldIndex, trace: TraceSink): void;
+export {};

package/dist/src/sim/resolvers/grapple-resolver.js

@@ -0,0 +1,70 @@
+import { SCALE, clampQ, q, qMul } from "../../units.js";
+import { findWeapon } from "../../equipment.js";
+import { eventSeed } from "../seeds.js";
+import { breakBindContestQ } from "../weapon_dynamics.js";
+import { resolveGrappleAttempt, resolveGrappleThrow, resolveGrappleChoke, resolveGrappleJointLock, resolveBreakGrapple, } from "../grapple.js";
+import { TraceKinds } from "../kinds.js";
+export function resolveGrappleCommand(options) {
+    const { world, entity, command, tuning, index, impacts, trace } = options;
+    const target = index.byId.get(command.targetId);
+    if (!target || target.injury.dead)
+        return;
+    const mode = command.mode ?? "grapple";
+    if (mode === "grapple") {
+        if (entity.grapple.holdingTargetId === 0 || entity.grapple.holdingTargetId !== command.targetId) {
+            resolveGrappleAttempt(world, entity, target, command.intensity, tuning, impacts, trace);
+        }
+        else {
+            trace.onEvent({
+                kind: TraceKinds.Grapple,
+                tick: world.tick, attackerId: entity.id, targetId: target.id,
+                phase: "tick", strengthQ: entity.grapple.gripQ,
+            });
+        }
+    }
+    else if (mode === "throw") {
+        resolveGrappleThrow(world, entity, target, command.intensity, tuning, impacts, trace);
+    }
+    else if (mode === "choke") {
+        resolveGrappleChoke(entity, target, command.intensity, tuning);
+    }
+    else if (mode === "jointLock") {
+        resolveGrappleJointLock(world, entity, target, command.intensity, tuning, impacts);
+    }
+}
+export function resolveBreakBind(options) {
+    const { world, entity, intensity, index, trace } = options;
+    if (entity.action.weaponBindPartnerId === 0)
+        return;
+    const partner = index.byId.get(entity.action.weaponBindPartnerId);
+    if (!partner || partner.injury.dead) {
+        entity.action.weaponBindPartnerId = 0;
+        entity.action.weaponBindTicks = 0;
+        return;
+    }
+    const breakerWpn = findWeapon(entity.loadout);
+    const holderWpn = findWeapon(partner.loadout);
+    const breakerArm = breakerWpn?.momentArm_m ?? Math.trunc(0.55 * SCALE.m);
+    const holderArm = holderWpn?.momentArm_m ?? Math.trunc(0.55 * SCALE.m);
+    const baseWinQ = breakBindContestQ(entity.attributes.performance.peakForce_N, partner.attributes.performance.peakForce_N, breakerArm, holderArm);
+    const winQ = clampQ(qMul(baseWinQ, intensity), q(0.05), q(0.95));
+    const breakSeed = eventSeed(world.seed, world.tick, entity.id, partner.id, 0xBB1D);
+    const breakRoll = (breakSeed % SCALE.Q);
+    if (breakRoll < winQ) {
+        partner.condition.stunned = clampQ(partner.condition.stunned + q(0.05), 0, SCALE.Q);
+        entity.action.weaponBindPartnerId = 0;
+        entity.action.weaponBindTicks = 0;
+        partner.action.weaponBindPartnerId = 0;
+        partner.action.weaponBindTicks = 0;
+        trace.onEvent({
+            kind: TraceKinds.WeaponBindBreak,
+            tick: world.tick,
+            entityId: entity.id,
+            partnerId: partner.id,
+            reason: "forced",
+        });
+    }
+}
+export function resolveBreakGrappleCommand(world, entity, command, tuning, index, trace) {
+    resolveBreakGrapple(world, entity, command.intensity, tuning, index, trace);
+}

package/dist/src/sim/resolvers/shoot-resolver.d.ts

@@ -0,0 +1,27 @@
+import type { WorldState } from "../world.js";
+import { type Entity } from "../entity.js";
+import type { ShootCommand } from "../commands.js";
+import type { KernelContext } from "../context.js";
+import { type Q } from "../../units.js";
+import { type Shield } from "../../equipment.js";
+import { type SimulationTuning } from "../tuning.js";
+import { type HitArea } from "../combat.js";
+import { type ImpactEvent } from "../events.js";
+import type { TraceSink } from "../trace.js";
+export type HitSegmentId = string;
+type ResolveShootOptions = {
+    world: WorldState;
+    shooter: Entity;
+    cmd: ShootCommand;
+    tuning: SimulationTuning;
+    impacts: ImpactEvent[];
+    trace: TraceSink;
+    ctx: KernelContext;
+    target: Entity | undefined;
+    resolveTargetHitSegment: (target: Entity, roll01: Q, sideBit: 0 | 1, fallbackArea?: HitArea) => HitSegmentId;
+    shieldBlocksSegment: (shield: Shield | undefined, target: Entity, segmentId: HitSegmentId, area: HitArea | undefined) => boolean;
+    regionCoverageQ: (coverageByRegion: Record<string, Q>, segmentId: HitSegmentId) => Q;
+    armourCoversHit: (world: WorldState, coverage: Q, aId: number, bId: number) => boolean;
+};
+export declare function resolveShoot(options: ResolveShootOptions): void;
+export {};

package/dist/src/sim/resolvers/shoot-resolver.js

@@ -0,0 +1,212 @@
+import { SCALE, q, clampQ, qMul, mulDiv } from "../../units.js";
+import { DamageChannel } from "../../channels.js";
+import { deriveArmourProfile, findRangedWeapon, findShield } from "../../equipment.js";
+import { deriveFunctionalState } from "../impairment.js";
+import { chooseArea } from "../combat.js";
+import { eventSeed } from "../seeds.js";
+import { coverFractionAtPosition, elevationAtPosition } from "../terrain.js";
+import { computeWindAimError } from "../weather.js";
+import { energyAtRange_J, adjustedDispersionQ, groupingRadius_m, thrownLaunchEnergy_J, recycleTicks, shootCost_J, } from "../ranged.js";
+import { getSkill } from "../skills.js";
+import { TICK_HZ } from "../tick.js";
+import { TraceKinds } from "../kinds.js";
+const AIM_MAX_TICKS = 20;
+const AIM_MIN_MUL = q(0.50);
+const AIM_STILL_THRESHOLD = 5_000;
+export function resolveShoot(options) {
+    const { world, shooter, cmd, tuning, impacts, trace, ctx, target, resolveTargetHitSegment, shieldBlocksSegment, regionCoverageQ, armourCoversHit } = options;
+    void tuning;
+    {
+        const svx = shooter.velocity_mps.x;
+        const svy = shooter.velocity_mps.y;
+        const shooterVelMag = Math.trunc(Math.sqrt(svx * svx + svy * svy));
+        if (cmd.targetId !== shooter.action.aimTargetId || shooterVelMag > AIM_STILL_THRESHOLD) {
+            shooter.action.aimTicks = 0;
+            shooter.action.aimTargetId = cmd.targetId;
+        }
+        else if (shooter.action.shootCooldownTicks > 0 && shooterVelMag <= AIM_STILL_THRESHOLD) {
+            shooter.action.aimTicks = Math.min(shooter.action.aimTicks + 1, AIM_MAX_TICKS);
+        }
+    }
+    if (shooter.action.shootCooldownTicks > 0)
+        return;
+    const wpn = findRangedWeapon(shooter.loadout, cmd.weaponId);
+    if (!wpn)
+        return;
+    if (!target || target.injury.dead)
+        return;
+    const ammo = cmd.ammoId ? wpn.ammo?.find(a => a.id === cmd.ammoId) : undefined;
+    const projMass_kg = ammo?.projectileMass_kg ?? wpn.projectileMass_kg;
+    const dragCoeff_perM = ammo?.dragCoeff_perM ?? wpn.dragCoeff_perM;
+    const ammoDamage = ammo?.damage ?? wpn.damage;
+    const launchMul = ammo?.launchEnergyMul ?? SCALE.Q;
+    const funcA = deriveFunctionalState(shooter, tuning);
+    if (!funcA.canAct)
+        return;
+    const dx = BigInt(target.position_m.x - shooter.position_m.x);
+    const dy = BigInt(target.position_m.y - shooter.position_m.y);
+    const cellSizeRS = ctx.cellSize_m ?? Math.trunc(4 * SCALE.m);
+    const elevSh = elevationAtPosition(ctx.elevationGrid, cellSizeRS, shooter.position_m.x, shooter.position_m.y);
+    const elevTg = elevationAtPosition(ctx.elevationGrid, cellSizeRS, target.position_m.x, target.position_m.y);
+    const dz = BigInt(target.position_m.z - shooter.position_m.z + (elevTg - elevSh));
+    const dist_m = Number(isqrtBig(dx * dx + dy * dy + dz * dz));
+    const intensity = clampQ(cmd.intensity ?? q(1.0), q(0.1), q(1.0));
+    const launchEnergy = wpn.category === "thrown"
+        ? mulDiv(thrownLaunchEnergy_J(shooter.attributes.performance.peakPower_W), getSkill(shooter.skills, "throwingWeapons").energyTransferMul, SCALE.Q)
+        : Math.trunc(qMul(wpn.launchEnergy_J, launchMul));
+    const energy_J = energyAtRange_J(launchEnergy, dragCoeff_perM, dist_m);
+    const v_impact_mps = projMass_kg > 0
+        ? Math.trunc(Math.sqrt(2 * energy_J * SCALE.kg / projMass_kg) * SCALE.mps)
+        : 0;
+    const ctrl = shooter.attributes.control;
+    const adjDisp = adjustedDispersionQ(wpn.dispersionQ, ctrl.controlQuality, ctrl.fineControl, shooter.energy.fatigue, intensity);
+    const rangedSkill = getSkill(shooter.skills, "rangedCombat");
+    const skillAdjDisp = qMul(adjDisp, rangedSkill.dispersionMul);
+    let gRadius_m = groupingRadius_m(skillAdjDisp, dist_m);
+    const aimReduction = mulDiv(SCALE.Q - AIM_MIN_MUL, Math.min(shooter.action.aimTicks, AIM_MAX_TICKS), AIM_MAX_TICKS);
+    const aimMul = (SCALE.Q - aimReduction);
+    gRadius_m = Math.trunc(qMul(gRadius_m, aimMul));
+    const tvx = target.velocity_mps.x;
+    const tvy = target.velocity_mps.y;
+    const targetVelMag = Math.trunc(Math.sqrt(tvx * tvx + tvy * tvy));
+    const leadError_m = mulDiv(targetVelMag, 2_000, SCALE.mps);
+    gRadius_m += leadError_m;
+    if (ctx.weather?.wind && v_impact_mps > 0 && dist_m > 0) {
+        gRadius_m += computeWindAimError(ctx.weather.wind, Number(dx), Number(dy), dist_m, v_impact_mps);
+    }
+    const rawHalfWidth_m = mulDiv(shooter.attributes.morphology.stature_m, 2000, SCALE.Q);
+    const cover = ctx.obstacleGrid
+        ? coverFractionAtPosition(ctx.obstacleGrid, cellSizeRS, target.position_m.x, target.position_m.y)
+        : 0;
+    const bodyHalfWidth_m = cover > 0
+        ? mulDiv(rawHalfWidth_m, Math.max(0, SCALE.Q - cover), SCALE.Q)
+        : rawHalfWidth_m;
+    const dispSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15A);
+    const errorMag_m = gRadius_m > 0
+        ? mulDiv(dispSeed % SCALE.Q, gRadius_m, SCALE.Q)
+        : 0;
+    const hit = errorMag_m <= bodyHalfWidth_m;
+    const suppressed = !hit && errorMag_m <= bodyHalfWidth_m * 3;
+    shooter.energy.reserveEnergy_J = Math.max(0, shooter.energy.reserveEnergy_J - shootCost_J(wpn, intensity, shooter.attributes.performance.peakPower_W));
+    shooter.action.aimTicks = 0;
+    if (wpn.magCapacity !== undefined) {
+        if (shooter.action.roundsInMag === undefined) {
+            shooter.action.roundsInMag = wpn.magCapacity;
+        }
+        shooter.action.roundsInMag -= 1;
+        if (shooter.action.roundsInMag <= 0) {
+            shooter.action.roundsInMag = wpn.magCapacity;
+            shooter.action.shootCooldownTicks = recycleTicks(wpn, TICK_HZ);
+        }
+        else {
+            shooter.action.shootCooldownTicks =
+                wpn.shotInterval_s !== undefined
+                    ? Math.ceil((wpn.shotInterval_s * TICK_HZ) / SCALE.s)
+                    : recycleTicks(wpn, TICK_HZ);
+        }
+    }
+    else {
+        shooter.action.shootCooldownTicks = recycleTicks(wpn, TICK_HZ);
+    }
+    if (suppressed) {
+        target.condition.suppressedTicks = Math.max(target.condition.suppressedTicks, 4);
+        target.condition.suppressionFearMul = wpn.suppressionFearMul ?? SCALE.Q;
+    }
+    let hitRegion;
+    if (hit && energy_J > 0) {
+        const sideSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15B);
+        const areaSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15C);
+        const hitArea = target.bodyPlan
+            ? undefined
+            : chooseArea((areaSeed % SCALE.Q));
+        const sideBit = (sideSeed & 1);
+        hitRegion = resolveTargetHitSegment(target, ((areaSeed >>> 8) % SCALE.Q), sideBit, hitArea);
+        const shield = findShield(target.loadout);
+        const shieldSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15D);
+        const projBypassQ = ("shieldBypassQ" in wpn) ? wpn.shieldBypassQ : 0;
+        const effectiveCoverageQ = projBypassQ > 0
+            ? Math.max(0, qMul((shield)?.coverageQ ?? 0, SCALE.Q - projBypassQ))
+            : ((shield)?.coverageQ ?? 0);
+        const shieldHit = shield !== undefined &&
+            ((shieldSeed % SCALE.Q) < effectiveCoverageQ) &&
+            shieldBlocksSegment(shield, target, hitRegion, hitArea);
+        const armour = deriveArmourProfile(target.loadout, target.armourState);
+        const isEnergyProjectile = !!(wpn).energyType;
+        const PROJ_CHANNEL_MASK = isEnergyProjectile ? (1 << DamageChannel.Energy) : (1 << DamageChannel.Kinetic);
+        const armourHit = armourCoversHit(world, regionCoverageQ(armour.coverageByRegion, hitRegion), shooter.id, target.id);
+        const protectedByArmour = armourHit && ((armour.protects & PROJ_CHANNEL_MASK) !== 0);
+        let finalEnergy = energy_J;
+        if (shield && shieldHit) {
+            const shieldResidual = Math.max(0, energy_J - (shield).blockResist_J);
+            finalEnergy = mulDiv(shieldResidual, (shield).deflectQ ?? q(0.30), SCALE.Q);
+        }
+        if (protectedByArmour) {
+            if (isEnergyProjectile && armour.reflectivity > q(0)) {
+                finalEnergy = mulDiv(finalEnergy, SCALE.Q - armour.reflectivity, SCALE.Q);
+            }
+            else if (!isEnergyProjectile) {
+                finalEnergy = applyKineticArmourPenetration(finalEnergy, armour.resist_J, armour.protectedDamageMul);
+            }
+            if (target.armourState) {
+                const armourItems = target.loadout.items.filter(it => it.kind === "armour");
+                for (const it of armourItems) {
+                    if ((it).ablative && target.armourState.has(it.id)) {
+                        const st = target.armourState.get(it.id);
+                        st.resistRemaining_J = Math.max(0, st.resistRemaining_J - energy_J);
+                    }
+                }
+            }
+        }
+        const wpnProxy = {
+            id: wpn.id,
+            kind: "weapon",
+            name: wpn.name,
+            mass_kg: projMass_kg,
+            bulk: q(0),
+            damage: ammoDamage,
+        };
+        impacts.push({
+            kind: "impact",
+            attackerId: shooter.id,
+            targetId: target.id,
+            region: hitRegion,
+            energy_J: finalEnergy,
+            protectedByArmour,
+            weaponId: wpn.id,
+            wpn: wpnProxy,
+            blocked: shieldHit ?? false,
+            parried: false,
+            hitQuality: q(0.75),
+            shieldBlocked: shieldHit ?? false,
+            massEff_kg: projMass_kg,
+            v_impact_mps,
+        });
+    }
+    trace.onEvent({
+        kind: TraceKinds.ProjectileHit,
+        tick: world.tick,
+        shooterId: shooter.id,
+        targetId: target.id,
+        weaponId: wpn.id,
+        hit,
+        ...(hitRegion !== undefined ? { region: hitRegion } : {}),
+        distance_m: dist_m,
+        energyAtImpact_J: energy_J,
+        suppressed,
+    });
+}
+function applyKineticArmourPenetration(energy_J, resist_J, postMul) {
+    const remaining = Math.max(0, energy_J - Math.max(0, resist_J));
+    return mulDiv(remaining, postMul, SCALE.Q);
+}
+function isqrtBig(n) {
+    if (n <= 0n)
+        return 0n;
+    let r = n;
+    let r1 = (r + 1n) >> 1n;
+    while (r1 < r) {
+        r = r1;
+        r1 = (r + n / r) >> 1n;
+    }
+    return r;
+}

package/dist/src/sim/resolvers/treat-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { WorldState } from "../world.js";
+import { type Entity } from "../entity.js";
+import type { TreatCommand } from "../commands.js";
+import type { KernelContext } from "../context.js";
+import type { WorldIndex } from "../indexing.js";
+import type { TraceSink } from "../trace.js";
+type ResolveTreatOptions = {
+    world: WorldState;
+    treater: Entity;
+    cmd: TreatCommand;
+    index: WorldIndex;
+    trace: TraceSink;
+    ctx: KernelContext;
+};
+export declare function resolveTreat(options: ResolveTreatOptions): void;
+export {};