@jgengine/core 0.8.0 → 0.10.0

package/dist/combat/defensiveWindow.js

@@ -38,8 +38,10 @@ export function createDefensiveWindow(config) {
         if (openedAt === null)
             return null;
         const dt = nowMs - openedAt;
-        if (dt < 0 || dt >= totalWindowMs(config))
+        if (dt < 0 || dt >= totalWindowMs(config)) {
+            openedAt = null;
             return null;
+        }
         return dt;
     }
     return {
@@ -49,8 +51,8 @@ export function createDefensiveWindow(config) {
         close() {
             openedAt = null;
         },
-        isOpen() {
-            return openedAt !== null;
+        isOpen(nowMs) {
+            return elapsed(nowMs) !== null;
         },
         evaluate(nowMs, attack) {
             const dt = elapsed(nowMs);

package/dist/combat/dotField.d.ts

@@ -0,0 +1,43 @@
+import type { BuildupProc } from "./breakMeters.js";
+/** A single damage-over-time instance: how hard, how often, and for how long. */
+export interface DotSpec {
+    /** Damage dealt at each interval. */
+    damagePerTick: number;
+    /** Milliseconds between damage ticks; clamped to a positive minimum. */
+    intervalMs: number;
+    /** Total lifetime in milliseconds; the DoT expires once its age reaches this. */
+    durationMs: number;
+    /** Label echoed on each emitted tick (bleed, poison, burn); defaults to the apply key. */
+    status?: string;
+}
+/** One damage event (or expiry marker) emitted by `DotField.tick` for the game to route through its effects. */
+export interface DotTick {
+    /** The key the DoT was applied under. */
+    id: string;
+    /** The DoT's `status` label, or its key when none was given. */
+    status: string;
+    /** Damage to route through the game's effect pipeline this frame; 0 on a bare expiry marker. */
+    damage: number;
+    /** True on the entry that ends the DoT — remove any HUD icon on it. */
+    expired: boolean;
+}
+/**
+ * A pool of timed damage-over-time instances keyed by string (`bleed`, `poison`, `burn`) — the
+ * recurring-damage counterpart to `breakMeters`' one-shot buildup procs (#536.4). `tick` advances
+ * every active DoT and returns the damage due this frame, one entry per interval crossed, so the game
+ * routes each through its own effect pipeline; a pure scheduler that never applies damage itself.
+ */
+export interface DotField {
+    /** Start or refresh a DoT under `id`; reapplying the same key restarts its age and lifetime. */
+    apply(id: string, spec: DotSpec): void;
+    /** Bridge a `breakMeters` buildup proc into recurring damage under `id`. */
+    applyProc(id: string, proc: BuildupProc, damagePerTick: number, intervalMs: number): void;
+    active(id: string): boolean;
+    cancel(id: string): void;
+    clear(): void;
+    count(): number;
+    /** Advance every active DoT; returns the damage due this frame plus an `expired` marker per finished DoT. */
+    tick(dtSeconds: number): DotTick[];
+}
+/** Builds an empty {@link DotField}; `apply` DoTs onto it and drain damage each frame with `tick`. */
+export declare function createDotField(): DotField;

package/dist/combat/dotField.js

@@ -0,0 +1,48 @@
+/** Builds an empty {@link DotField}; `apply` DoTs onto it and drain damage each frame with `tick`. */
+export function createDotField() {
+    const dots = new Map();
+    return {
+        apply(id, spec) {
+            dots.set(id, {
+                status: spec.status ?? id,
+                damagePerTick: spec.damagePerTick,
+                intervalMs: Math.max(1, spec.intervalMs),
+                durationMs: Math.max(0, spec.durationMs),
+                ageMs: 0,
+                ticksEmitted: 0,
+            });
+        },
+        applyProc(id, proc, damagePerTick, intervalMs) {
+            this.apply(id, { damagePerTick, intervalMs, durationMs: proc.durationMs, status: proc.status });
+        },
+        active: (id) => dots.has(id),
+        cancel: (id) => void dots.delete(id),
+        clear: () => dots.clear(),
+        count: () => dots.size,
+        tick(dtSeconds) {
+            if (dtSeconds <= 0)
+                return [];
+            const dtMs = dtSeconds * 1000;
+            const emitted = [];
+            for (const [id, dot] of dots) {
+                dot.ageMs += dtMs;
+                const activeMs = Math.min(dot.ageMs, dot.durationMs);
+                const dueTicks = Math.floor(activeMs / dot.intervalMs);
+                let last = null;
+                while (dot.ticksEmitted < dueTicks) {
+                    dot.ticksEmitted += 1;
+                    last = { id, status: dot.status, damage: dot.damagePerTick, expired: false };
+                    emitted.push(last);
+                }
+                if (dot.ageMs >= dot.durationMs) {
+                    dots.delete(id);
+                    if (last !== null)
+                        last.expired = true;
+                    else
+                        emitted.push({ id, status: dot.status, damage: 0, expired: true });
+                }
+            }
+            return emitted;
+        },
+    };
+}

package/dist/combat/projectiles.d.ts

@@ -1,30 +1,39 @@
 import type { BallisticSweep } from "../physics/ballisticSweep.js";
 import type { EntityPosition } from "../scene/entityStore.js";
+import { type EntityColliderSet } from "../scene/colliders.js";
+import { type SceneRaycastApi } from "../scene/sceneRaycast.js";
 import type { Aim } from "../scene/spatial.js";
 import type { CombatSpatialDeps, EffectResult, EffectSystem, EffectVia } from "./effects.js";
+import { type ShotOriginPolicy } from "./shotOrigin.js";
 export interface ProjectileShotInput {
     from: string;
     via: EffectVia;
     aim: Aim;
     effect: string;
+    /** Defaults to `{ kind: "eye" }` — aim.origin when given, else shooter position at eye height. */
+    originPolicy?: ShotOriginPolicy;
 }
-/** A raycast hit against a scene entity — the ray reached `instanceId` at `distance` along its length. */
 export interface EntityRaycastHit {
     kind: "entity";
     instanceId: string;
     distance: number;
     at: EntityPosition;
+    colliderName?: string;
+    damageEligible?: boolean;
+    blocks?: boolean;
 }
-/** A raycast hit against a placed scene object's bounding box — see `ProjectileObjectsDeps.halfExtents`. */
 export interface ObjectRaycastHit {
     kind: "object";
     instanceId: string;
     catalogId: string;
     distance: number;
     at: EntityPosition;
+    colliderName?: string;
+    damageEligible?: boolean;
+    blocks?: boolean;
 }
 export type RaycastHit = EntityRaycastHit | ObjectRaycastHit;
-export type Raycast = (from: string, aim: Aim, range: number) => RaycastHit[];
+export type Raycast = (from: string, aim: Aim, range: number, originPolicy?: ShotOriginPolicy) => RaycastHit[];
 export interface ProjectileSettleReport {
     from: string;
     origin: EntityPosition;
@@ -32,29 +41,33 @@ export interface ProjectileSettleReport {
     effect: string;
     hit: boolean;
 }
-/** Read-only scene object access for the default `raycast`; matches `ObjectStore.list()`/a catalog lookup structurally. */
 export interface ProjectileObjectsDeps {
     list(): readonly {
         instanceId: string;
         catalogId: string;
-        position: [number, number, number];
+        position: readonly [number, number, number];
+        rotationY?: number;
+    }[];
+    inBox?(min: EntityPosition, max: EntityPosition): readonly {
+        instanceId: string;
+        catalogId: string;
+        position: readonly [number, number, number];
+        rotationY?: number;
     }[];
-    /** Half-extents of the object's axis-aligned bounding box; `null`/omitted falls back to `[0.5, 0.5, 0.5]`. */
     halfExtents?(catalogId: string): [number, number, number] | null;
+    collidersOf?(instanceId: string): EntityColliderSet | null | undefined;
 }
 export interface ProjectileSystemDeps {
     effects: EffectSystem;
     spatial: CombatSpatialDeps;
     getStat(itemId: string, stat: string): number | null;
     raycast?: Raycast;
-    /** Optional object awareness for the default `raycast`; when set, placed objects can block or absorb a shot. */
+    sceneRaycast?: SceneRaycastApi;
     objects?: ProjectileObjectsDeps;
-    /**
-     * Optional collision-aware arc test for ballistic shots (see `createBallisticSweep` in
-     * `physics/ballisticSweep`). A hit settles the shot at the impact point; `null` or omission
-     * falls back to the closed-form landing.
-     */
+    entityCollidersOf?(instanceId: string): EntityColliderSet | null | undefined;
+    rotationYOf?(instanceId: string): number | undefined;
     sweepBallistic?: BallisticSweep;
+    defaultOriginPolicy?: ShotOriginPolicy;
     now?: () => number;
     onSettle?(report: ProjectileSettleReport): void;
 }
@@ -62,21 +75,29 @@ export type ProjectileHit = {
     kind: "entity";
     instanceId: string;
     distance: number;
+    colliderName?: string;
+    damageEligible?: boolean;
 } | {
     kind: "object";
     instanceId: string;
     catalogId: string;
     distance: number;
+    colliderName?: string;
+    damageEligible?: boolean;
 };
 export interface ProjectilePrediction {
     hits: ProjectileHit[];
     blocked?: boolean;
+    origin?: EntityPosition;
+    direction?: EntityPosition;
+    firstImpact?: ProjectileHit | null;
 }
 export type SettleResult = {
     status: "settled";
     shotId: string;
     at: [number, number, number];
     hits: EffectResult[];
+    origin?: [number, number, number];
 } | {
     status: "rejected";
     shotId: string;

package/dist/combat/projectiles.js

@@ -1,135 +1,182 @@
+import { defaultEntityColliders, resolveColliders } from "../scene/colliders.js";
+import { createSceneRaycast, firstImpact, hitsUntilBlocked, } from "../scene/sceneRaycast.js";
+import { aimDirection, aimSpreadDeg, resolveShot, } from "./shotOrigin.js";
 const DEFAULT_RANGE = 100;
 const DEFAULT_PROJECTILE_SPEED = 15;
 const GRAVITY = 9.8;
 const BASE_HIT_RADIUS = 0.5;
-const DEFAULT_OBJECT_HALF_EXTENTS = [0.5, 0.5, 0.5];
 function isEntityHit(hit) {
     return hit.kind === "entity";
 }
 function isObjectHit(hit) {
     return hit.kind === "object";
 }
-function raySegmentAabbDistance(origin, direction, range, min, max) {
-    let tMin = 0;
-    let tMax = range;
-    for (let axis = 0; axis < 3; axis += 1) {
-        const o = origin[axis];
-        const d = direction[axis];
-        const lo = min[axis];
-        const hi = max[axis];
-        if (Math.abs(d) < 1e-9) {
-            if (o < lo || o > hi)
-                return null;
-            continue;
-        }
-        const inv = 1 / d;
-        let t1 = (lo - o) * inv;
-        let t2 = (hi - o) * inv;
-        if (t1 > t2)
-            [t1, t2] = [t2, t1];
-        tMin = Math.max(tMin, t1);
-        tMax = Math.min(tMax, t2);
-        if (tMin > tMax)
-            return null;
+function sceneHitToRaycast(hit) {
+    if (hit.targetKind === "entity") {
+        return {
+            kind: "entity",
+            instanceId: hit.instanceId,
+            distance: hit.distance,
+            at: hit.point,
+            colliderName: hit.colliderName,
+            damageEligible: hit.damageEligible,
+            blocks: hit.blocks,
+        };
     }
-    return tMin;
-}
-function normalize(vector) {
-    const length = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]);
-    if (length === 0)
-        return null;
-    return [vector[0] / length, vector[1] / length, vector[2] / length];
+    return {
+        kind: "object",
+        instanceId: hit.instanceId,
+        catalogId: hit.catalogId ?? hit.targetKind,
+        distance: hit.distance,
+        at: hit.point,
+        colliderName: hit.colliderName,
+        damageEligible: hit.damageEligible,
+        blocks: hit.blocks,
+    };
 }
-function aimDirection(aim) {
-    if ("origin" in aim)
-        return normalize(aim.direction);
-    const cosPitch = Math.cos(aim.pitch);
-    return [Math.sin(aim.yaw) * cosPitch, Math.sin(aim.pitch), Math.cos(aim.yaw) * cosPitch];
+function toProjectileHit(hit) {
+    if (isObjectHit(hit)) {
+        return {
+            kind: "object",
+            instanceId: hit.instanceId,
+            catalogId: hit.catalogId,
+            distance: hit.distance,
+            ...(hit.colliderName !== undefined ? { colliderName: hit.colliderName } : {}),
+            ...(hit.damageEligible !== undefined ? { damageEligible: hit.damageEligible } : {}),
+        };
+    }
+    return {
+        kind: "entity",
+        instanceId: hit.instanceId,
+        distance: hit.distance,
+        ...(hit.colliderName !== undefined ? { colliderName: hit.colliderName } : {}),
+        ...(hit.damageEligible !== undefined ? { damageEligible: hit.damageEligible } : {}),
+    };
 }
-function aimSpreadDeg(aim) {
-    return "origin" in aim ? 0 : aim.spread ?? 0;
+function asSceneHits(hits) {
+    return hits.map((hit) => ({
+        targetKind: hit.kind === "entity" ? "entity" : "object",
+        instanceId: hit.instanceId,
+        catalogId: hit.kind === "object" ? hit.catalogId : undefined,
+        colliderName: hit.colliderName ?? "body",
+        purpose: hit.damageEligible === false ? "physical" : "damage",
+        damageEligible: hit.kind === "entity" ? hit.damageEligible !== false : hit.damageEligible === true,
+        blocks: hit.blocks !== false,
+        distance: hit.distance,
+        point: hit.at,
+        normal: [0, 1, 0],
+    }));
 }
 export function createProjectileSystem(deps) {
     const shots = new Map();
     let shotCounter = 0;
     const now = deps.now ?? (() => Date.now());
+    const defaultPolicy = deps.defaultOriginPolicy ?? { kind: "eye" };
     function itemStat(via, stat) {
         return via.item === undefined ? null : deps.getStat(via.item, stat);
     }
-    function shotOrigin(from, aim) {
-        return "origin" in aim ? aim.origin : deps.spatial.positionOf(from);
-    }
     function withWeaponSpread(via, aim) {
         if ("origin" in aim || aim.spread !== undefined)
             return aim;
         const spread = itemStat(via, "spread");
         return spread === null ? aim : { ...aim, spread };
     }
+    function resolveShotFor(from, aim, policy) {
+        return resolveShot({
+            positionOf: deps.spatial.positionOf,
+            rotationYOf: deps.rotationYOf,
+            collidersOf: deps.entityCollidersOf,
+        }, from, aim, policy ?? defaultPolicy);
+    }
+    const internalSceneRaycast = deps.sceneRaycast ??
+        createSceneRaycast({
+            entities: {
+                list: () => {
+                    const ids = deps.spatial.inRadius([0, 0, 0], 1e9);
+                    const out = [];
+                    for (const id of ids) {
+                        const position = deps.spatial.positionOf(id);
+                        if (position === undefined)
+                            continue;
+                        out.push({ id, position, rotationY: deps.rotationYOf?.(id) ?? 0 });
+                    }
+                    return out;
+                },
+                collidersOf: deps.entityCollidersOf,
+                inRadius: (center, radius) => deps.spatial.inRadius(center, radius),
+                get: (id) => {
+                    const position = deps.spatial.positionOf(id);
+                    if (position === undefined)
+                        return null;
+                    return { id, position, rotationY: deps.rotationYOf?.(id) ?? 0 };
+                },
+            },
+            objects: deps.objects === undefined
+                ? undefined
+                : {
+                    list: () => deps.objects.list().map((object) => ({
+                        instanceId: object.instanceId,
+                        catalogId: object.catalogId,
+                        position: [object.position[0], object.position[1], object.position[2]],
+                        rotationY: object.rotationY ?? 0,
+                    })),
+                    inBox: deps.objects.inBox
+                        ? (min, max) => deps.objects.inBox(min, max).map((object) => ({
+                            instanceId: object.instanceId,
+                            catalogId: object.catalogId,
+                            position: [object.position[0], object.position[1], object.position[2]],
+                            rotationY: object.rotationY ?? 0,
+                        }))
+                        : undefined,
+                    halfExtentsOf: deps.objects.halfExtents,
+                    collidersOf: deps.objects.collidersOf,
+                },
+        });
     const raycast = deps.raycast ??
-        ((from, aim, range) => {
-            const origin = shotOrigin(from, aim);
-            if (origin === undefined)
-                return [];
-            const direction = aimDirection(aim);
-            if (direction === null)
+        ((from, aim, range, originPolicy) => {
+            const resolved = resolveShotFor(from, aim, originPolicy);
+            if (resolved === null)
                 return [];
+            const { origin, direction } = resolved;
+            const all = internalSceneRaycast.raycastAll({
+                origin,
+                direction,
+                maxDistance: range,
+                excludeInstanceIds: [from],
+            });
+            const until = hitsUntilBlocked(all);
             const spreadRad = (aimSpreadDeg(aim) * Math.PI) / 180;
-            const entityHits = [];
-            for (const instanceId of deps.spatial.inRadius(origin, range)) {
-                if (instanceId === from)
-                    continue;
-                const position = deps.spatial.positionOf(instanceId);
-                if (position === undefined)
-                    continue;
-                const dx = position[0] - origin[0];
-                const dy = position[1] - origin[1];
-                const dz = position[2] - origin[2];
-                const along = dx * direction[0] + dy * direction[1] + dz * direction[2];
-                if (along <= 0 || along > range)
-                    continue;
-                const px = dx - direction[0] * along;
-                const py = dy - direction[1] * along;
-                const pz = dz - direction[2] * along;
-                const perpendicular = Math.sqrt(px * px + py * py + pz * pz);
-                if (perpendicular > BASE_HIT_RADIUS + Math.tan(spreadRad) * along)
-                    continue;
-                entityHits.push({ kind: "entity", instanceId, distance: along, at: position });
-            }
-            let nearestObject = null;
-            for (const object of deps.objects?.list() ?? []) {
-                const half = deps.objects?.halfExtents?.(object.catalogId) ?? DEFAULT_OBJECT_HALF_EXTENTS;
-                const min = [
-                    object.position[0] - half[0],
-                    object.position[1] - half[1],
-                    object.position[2] - half[2],
-                ];
-                const max = [
-                    object.position[0] + half[0],
-                    object.position[1] + half[1],
-                    object.position[2] + half[2],
-                ];
-                const distance = raySegmentAabbDistance(origin, direction, range, min, max);
-                if (distance === null)
-                    continue;
-                if (nearestObject === null || distance < nearestObject.distance) {
-                    nearestObject = {
-                        kind: "object",
-                        instanceId: object.instanceId,
-                        catalogId: object.catalogId,
-                        distance,
-                        at: [
-                            origin[0] + direction[0] * distance,
-                            origin[1] + direction[1] * distance,
-                            origin[2] + direction[2] * distance,
-                        ],
-                    };
+            const mapped = [];
+            for (const hit of until) {
+                if (hit.targetKind === "entity" && spreadRad > 0) {
+                    const position = deps.spatial.positionOf(hit.instanceId);
+                    if (position !== undefined) {
+                        const colliders = resolveColliders(deps.entityCollidersOf?.(hit.instanceId) ?? defaultEntityColliders());
+                        const collider = colliders.find((candidate) => candidate.name === hit.colliderName) ?? colliders[0];
+                        const localOffset = collider?.shape.offset ?? [0, 0, 0];
+                        const slack = collider === undefined
+                            ? BASE_HIT_RADIUS
+                            : collider.shape.kind === "sphere"
+                                ? collider.shape.radius
+                                : Math.hypot(...collider.shape.halfExtents);
+                        const rotationY = deps.rotationYOf?.(hit.instanceId) ?? 0;
+                        const cos = Math.cos(rotationY);
+                        const sin = Math.sin(rotationY);
+                        const dx = position[0] + localOffset[0] * cos + localOffset[2] * sin - origin[0];
+                        const dy = position[1] + localOffset[1] - origin[1];
+                        const dz = position[2] - localOffset[0] * sin + localOffset[2] * cos - origin[2];
+                        const along = dx * direction[0] + dy * direction[1] + dz * direction[2];
+                        const px = dx - direction[0] * along;
+                        const py = dy - direction[1] * along;
+                        const pz = dz - direction[2] * along;
+                        const perpendicular = Math.sqrt(px * px + py * py + pz * pz);
+                        if (perpendicular > slack + Math.tan(spreadRad) * along)
+                            continue;
+                    }
                 }
+                mapped.push(sceneHitToRaycast(hit));
             }
-            const blockDistance = nearestObject?.distance ?? Infinity;
-            const hits = entityHits.filter((hit) => hit.distance <= blockDistance);
-            if (nearestObject !== null)
-                hits.push(nearestObject);
-            return hits.sort((a, b) => a.distance - b.distance);
+            return mapped;
         });
     function resolveRange(via) {
         return itemStat(via, "range") ?? DEFAULT_RANGE;
@@ -138,8 +185,9 @@ export function createProjectileSystem(deps) {
         return itemStat(via, "projectile.fuseTime") !== null || itemStat(via, "explosion.radius") !== null;
     }
     function ballisticArc(input) {
-        const origin = shotOrigin(input.from, input.aim) ?? [0, 0, 0];
-        const direction = aimDirection(input.aim) ?? [0, 0, 1];
+        const resolved = resolveShotFor(input.from, input.aim, input.originPolicy);
+        const origin = resolved?.origin ?? [0, 0, 0];
+        const direction = resolved?.direction ?? aimDirection(input.aim) ?? [0, 0, 1];
         const speed = itemStat(input.via, "projectile.speed") ?? DEFAULT_PROJECTILE_SPEED;
         const gravityScale = itemStat(input.via, "projectile.gravity") ?? 1;
         const fuseTime = itemStat(input.via, "projectile.fuseTime");
@@ -175,31 +223,42 @@ export function createProjectileSystem(deps) {
     }
     function predictHits(input) {
         const aim = withWeaponSpread(input.via, input.aim);
-        const rawHits = raycast(input.from, aim, resolveRange(input.via));
+        const resolved = resolveShotFor(input.from, aim, input.originPolicy);
+        const rawHits = raycast(input.from, aim, resolveRange(input.via), input.originPolicy);
         const visible = rawHits.filter((hit) => isObjectHit(hit) || deps.spatial.hasLineOfSight(input.from, hit.instanceId));
-        return { rawHits, visible };
+        return {
+            rawHits,
+            visible,
+            origin: resolved?.origin,
+            direction: resolved?.direction,
+        };
     }
-    function settledAt(input, hits) {
-        const first = hits[0];
-        if (first !== undefined)
-            return [first.at[0], first.at[1], first.at[2]];
-        const origin = shotOrigin(input.from, input.aim);
-        const direction = origin === undefined ? null : aimDirection(input.aim);
-        if (origin === undefined || direction === null)
+    function missPoint(input) {
+        const resolved = resolveShotFor(input.from, input.aim, input.originPolicy);
+        if (resolved === null)
             return [0, 0, 0];
         const range = resolveRange(input.via);
-        return [origin[0] + direction[0] * range, origin[1] + direction[1] * range, origin[2] + direction[2] * range];
+        return [
+            resolved.origin[0] + resolved.direction[0] * range,
+            resolved.origin[1] + resolved.direction[1] * range,
+            resolved.origin[2] + resolved.direction[2] * range,
+        ];
     }
     return {
         willHitProjectile(input) {
-            const { rawHits, visible } = predictHits(input);
+            const { rawHits, visible, origin, direction } = predictHits(input);
+            const impact = firstImpact(asSceneHits(rawHits));
+            const solidBlock = impact !== null && impact.blocks && !impact.damageEligible;
             const prediction = {
-                hits: visible.map((hit) => isObjectHit(hit)
-                    ? { kind: "object", instanceId: hit.instanceId, catalogId: hit.catalogId, distance: hit.distance }
-                    : { kind: "entity", instanceId: hit.instanceId, distance: hit.distance }),
+                hits: visible.map(toProjectileHit),
+                ...(origin !== undefined ? { origin } : {}),
+                ...(direction !== undefined ? { direction } : {}),
+                firstImpact: impact === null ? null : toProjectileHit(sceneHitToRaycast(impact)),
             };
             if (rawHits.length > 0 && visible.length === 0)
                 prediction.blocked = true;
+            else if (solidBlock)
+                prediction.blocked = true;
             return prediction;
         },
         fireProjectile(input) {
@@ -216,21 +275,38 @@ export function createProjectileSystem(deps) {
                 return { status: "rejected", shotId, reason: "already-settled" };
             shot.settled = true;
             const { input } = shot;
-            const origin = shotOrigin(input.from, input.aim) ?? [0, 0, 0];
+            const resolved = resolveShotFor(input.from, input.aim, input.originPolicy);
+            const origin = resolved?.origin ?? [0, 0, 0];
+            const originTuple = [origin[0], origin[1], origin[2]];
             if (isBallistic(input.via)) {
                 const at = ballisticSettlePoint(input);
-                deps.onSettle?.({ from: input.from, origin, at, effect: input.effect, hit: false });
-                return { status: "settled", shotId, at, hits: [] };
+                const splashRadius = itemStat(input.via, "explosion.radius");
+                const radius = splashRadius ?? BASE_HIT_RADIUS;
+                const hits = deps.effects.applyEffect({
+                    from: input.from,
+                    effect: input.effect,
+                    via: input.via,
+                    at,
+                    radius,
+                    falloff: splashRadius === null ? "none" : "linear",
+                });
+                deps.onSettle?.({ from: input.from, origin, at, effect: input.effect, hit: hits.length > 0 });
+                return { status: "settled", shotId, at, hits, origin: originTuple };
             }
-            const { visible } = predictHits(input);
-            const entityHits = visible.filter(isEntityHit);
-            const objectHits = visible.filter(isObjectHit);
-            const receivable = entityHits.filter((hit) => deps.effects.canReceive(hit.instanceId, input.effect) === null);
+            const { visible, rawHits } = predictHits(input);
+            const ordered = asSceneHits(rawHits);
+            const untilBlock = hitsUntilBlocked(ordered);
+            const impact = firstImpact(untilBlock);
+            const solidBlock = impact !== null && impact.blocks && !impact.damageEligible;
+            const damageEntityHits = visible.filter((hit) => isEntityHit(hit) &&
+                hit.damageEligible !== false &&
+                (!solidBlock || hit.distance <= (impact?.distance ?? Infinity) + 1e-9) &&
+                deps.effects.canReceive(hit.instanceId, input.effect) === null);
             const pellets = Math.max(1, Math.round(itemStat(input.via, "pellets") ?? 1));
             const hits = [];
-            if (receivable.length > 0) {
-                for (let pellet = 0; pellet < pellets; pellet++) {
-                    const target = receivable[pellet % receivable.length];
+            if (!solidBlock && damageEntityHits.length > 0) {
+                for (let pellet = 0; pellet < pellets; pellet += 1) {
+                    const target = damageEntityHits[pellet % damageEntityHits.length];
                     hits.push(...deps.effects.applyEffect({
                         from: input.from,
                         to: target.instanceId,
@@ -239,9 +315,18 @@ export function createProjectileSystem(deps) {
                     }));
                 }
             }
-            const at = settledAt(input, receivable.length > 0 ? receivable : objectHits);
-            deps.onSettle?.({ from: input.from, origin, at, effect: input.effect, hit: receivable.length > 0 });
-            return { status: "settled", shotId, at, hits };
+            let at;
+            if (impact !== null) {
+                at = [impact.point[0], impact.point[1], impact.point[2]];
+            }
+            else if (damageEntityHits[0] !== undefined) {
+                at = [damageEntityHits[0].at[0], damageEntityHits[0].at[1], damageEntityHits[0].at[2]];
+            }
+            else {
+                at = missPoint(input);
+            }
+            deps.onSettle?.({ from: input.from, origin, at, effect: input.effect, hit: hits.length > 0 });
+            return { status: "settled", shotId, at, hits, origin: originTuple };
         },
     };
 }