@jgengine/core 0.7.0 → 0.9.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/effects.d.ts

@@ -65,7 +65,7 @@ export interface EffectSystemDeps {
     onLethal?(instanceId: string, ctx: LethalContext): void;
 }
 export interface EffectSystem {
-    canReceive(instanceId: string, effect: string): string | null;
+    canReceive(instanceId: string, effect: string, magnitude?: number): string | null;
     preview(input: SingleTargetEffectInput): number;
     applyEffect(input: EffectInput): EffectResult[];
 }

package/dist/combat/effects.js

@@ -40,18 +40,21 @@ export function createEffectSystem(deps) {
         }
         return result;
     }
-    function canReceive(instanceId, effect) {
+    function canReceive(instanceId, effect, magnitude) {
         const rule = resolveRule(instanceId, effect);
         if (rule === null)
             return "not-receivable";
         const stats = deps.resolveStats(instanceId);
         if (stats === undefined)
             return "unknown-instance";
-        const anyPoolAboveMin = rule.order.some((statId) => {
+        const restorative = magnitude !== undefined && magnitude < 0;
+        const anyPoolHasHeadroom = rule.order.some((statId) => {
             const stat = stats[statId];
-            return stat !== undefined && stat.current > stat.min;
+            if (stat === undefined)
+                return false;
+            return restorative ? stat.current < stat.max : stat.current > stat.min;
         });
-        if (!anyPoolAboveMin)
+        if (!anyPoolHasHeadroom)
             return "pools-depleted";
         return null;
     }
@@ -80,13 +83,13 @@ export function createEffectSystem(deps) {
         return { instanceId, effect, applied, lethal };
     }
     function applyTo(instanceId, effect, via, from, scale) {
-        if (canReceive(instanceId, effect) !== null)
-            return null;
         const rule = resolveRule(instanceId, effect);
         const stats = deps.resolveStats(instanceId);
         if (rule === null || stats === undefined)
             return null;
         const drainMagnitude = modifiedDrainMagnitude(baseDrainMagnitude(effect, via) * scale, rule);
+        if (canReceive(instanceId, effect, drainMagnitude) !== null)
+            return null;
         const result = drainPools(instanceId, effect, rule, stats, drainMagnitude);
         if (result.lethal)
             deps.onLethal?.(instanceId, { from, via, effect });

package/dist/combat/projectiles.d.ts

@@ -1,18 +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: "legacy" }` — aim.origin or shooter position. */
+    originPolicy?: ShotOriginPolicy;
 }
-export interface RaycastHit {
+export interface EntityRaycastHit {
+    kind: "entity";
     instanceId: string;
     distance: number;
     at: EntityPosition;
+    colliderName?: string;
+    damageEligible?: boolean;
+    blocks?: boolean;
 }
-export type Raycast = (from: string, aim: Aim, range: number) => RaycastHit[];
+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, originPolicy?: ShotOriginPolicy) => RaycastHit[];
 export interface ProjectileSettleReport {
     from: string;
     origin: EntityPosition;
@@ -20,26 +41,63 @@ export interface ProjectileSettleReport {
     effect: string;
     hit: boolean;
 }
+export interface ProjectileObjectsDeps {
+    list(): readonly {
+        instanceId: string;
+        catalogId: string;
+        position: readonly [number, number, number];
+        rotationY?: number;
+    }[];
+    inBox?(min: EntityPosition, max: EntityPosition): readonly {
+        instanceId: string;
+        catalogId: string;
+        position: readonly [number, number, number];
+        rotationY?: number;
+    }[];
+    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;
+    sceneRaycast?: SceneRaycastApi;
+    objects?: ProjectileObjectsDeps;
+    entityCollidersOf?(instanceId: string): EntityColliderSet | null | undefined;
+    rotationYOf?(instanceId: string): number | undefined;
+    sweepBallistic?: BallisticSweep;
+    defaultOriginPolicy?: ShotOriginPolicy;
     now?: () => number;
     onSettle?(report: ProjectileSettleReport): void;
 }
+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: {
-        instanceId: string;
-        distance: number;
-    }[];
+    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,69 +1,169 @@
+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;
-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];
+function isEntityHit(hit) {
+    return hit.kind === "entity";
 }
-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 isObjectHit(hit) {
+    return hit.kind === "object";
 }
-function aimSpreadDeg(aim) {
-    return "origin" in aim ? 0 : aim.spread ?? 0;
+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 {
+        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 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 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: "legacy" };
     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,
+        }, 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 hits = [];
-            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;
-                hits.push({ instanceId, distance: along, at: position });
+            const mapped = [];
+            for (const hit of until) {
+                if (hit.targetKind === "entity" && spreadRad > 0) {
+                    const position = deps.spatial.positionOf(hit.instanceId);
+                    if (position !== undefined) {
+                        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];
+                        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 > 0.5 + Math.tan(spreadRad) * along)
+                            continue;
+                    }
+                }
+                mapped.push(sceneHitToRaycast(hit));
             }
-            return hits.sort((a, b) => a.distance - b.distance);
+            return mapped;
         });
     function resolveRange(via) {
         return itemStat(via, "range") ?? DEFAULT_RANGE;
@@ -71,9 +171,10 @@ export function createProjectileSystem(deps) {
     function isBallistic(via) {
         return itemStat(via, "projectile.fuseTime") !== null || itemStat(via, "explosion.radius") !== null;
     }
-    function ballisticSettlePoint(input) {
-        const origin = shotOrigin(input.from, input.aim) ?? [0, 0, 0];
-        const direction = aimDirection(input.aim) ?? [0, 0, 1];
+    function ballisticArc(input) {
+        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");
@@ -85,37 +186,66 @@ export function createProjectileSystem(deps) {
             : flightCap;
         const flightTime = Math.min(impactTime, flightCap);
         const settledY = Math.max(0, origin[1] + verticalSpeed * flightTime - 0.5 * gravity * flightTime * flightTime);
-        return [
-            origin[0] + direction[0] * speed * flightTime,
-            settledY,
-            origin[2] + direction[2] * speed * flightTime,
-        ];
+        return {
+            origin,
+            velocity: [direction[0] * speed, verticalSpeed, direction[2] * speed],
+            gravity,
+            flightTime,
+            landing: [
+                origin[0] + direction[0] * speed * flightTime,
+                settledY,
+                origin[2] + direction[2] * speed * flightTime,
+            ],
+        };
+    }
+    function ballisticSettlePoint(input) {
+        const arc = ballisticArc(input);
+        const sweep = deps.sweepBallistic;
+        if (sweep !== undefined) {
+            const impact = sweep(arc.origin, arc.velocity, arc.gravity, arc.flightTime);
+            if (impact !== null)
+                return impact.point;
+        }
+        return arc.landing;
     }
     function predictHits(input) {
         const aim = withWeaponSpread(input.via, input.aim);
-        const rawHits = raycast(input.from, aim, resolveRange(input.via));
-        const visible = rawHits.filter((hit) => deps.spatial.hasLineOfSight(input.from, hit.instanceId));
-        return { rawHits, visible };
+        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,
+            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(({ instanceId, distance }) => ({ instanceId, 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) {
@@ -132,19 +262,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 receivable = visible.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,
@@ -153,9 +302,18 @@ export function createProjectileSystem(deps) {
                     }));
                 }
             }
-            const at = settledAt(input, receivable);
-            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 };
         },
     };
 }

package/dist/combat/resistance.d.ts

@@ -1,13 +1,25 @@
 export type ResistVerdict = "immune" | "resist" | "normal" | "vulnerable";
-export interface ResistanceMatrix {
-    categories: Record<string, Record<string, ResistVerdict>>;
+export declare class UnknownResistanceCategoryError extends Error {
+    readonly category: string;
+    constructor(category: string);
+}
+export declare class UnknownResistancePropertyError extends Error {
+    readonly category: string;
+    readonly property: string;
+    constructor(category: string, property: string);
+}
+export interface ResistanceMatrix<TCategory extends string = string, TProperty extends string = string> {
+    categories: Partial<Record<TCategory, Partial<Record<TProperty, ResistVerdict>>>>;
+    categoryIds?: readonly TCategory[];
+    propertyIds?: readonly TProperty[];
     multipliers?: Partial<Record<ResistVerdict, number>>;
     default?: ResistVerdict;
+    unknownCategory?: ResistVerdict;
 }
 export interface ResistanceResult {
     verdict: ResistVerdict;
     multiplier: number;
     immune: boolean;
 }
-export declare function resolveResistance(matrix: ResistanceMatrix, category: string, targetProperties: readonly string[]): ResistanceResult;
-export declare function resistanceScale(matrix: ResistanceMatrix, category: string, targetProperties: readonly string[]): number;
+export declare function resolveResistance<TCategory extends string = string, TProperty extends string = string>(matrix: ResistanceMatrix<TCategory, TProperty>, category: TCategory | string, targetProperties: readonly (TProperty | string)[]): ResistanceResult;
+export declare function resistanceScale<TCategory extends string = string, TProperty extends string = string>(matrix: ResistanceMatrix<TCategory, TProperty>, category: TCategory | string, targetProperties: readonly (TProperty | string)[]): number;

package/dist/combat/resistance.js

@@ -1,3 +1,21 @@
+export class UnknownResistanceCategoryError extends Error {
+    category;
+    constructor(category) {
+        super(`Unknown resistance category: ${category}`);
+        this.name = "UnknownResistanceCategoryError";
+        this.category = category;
+    }
+}
+export class UnknownResistancePropertyError extends Error {
+    category;
+    property;
+    constructor(category, property) {
+        super(`Unknown resistance property "${property}" for category "${category}"`);
+        this.name = "UnknownResistancePropertyError";
+        this.category = category;
+        this.property = property;
+    }
+}
 const DEFAULT_MULTIPLIERS = {
     immune: 0,
     resist: 0.5,
@@ -17,13 +35,35 @@ function summaryVerdict(matrix, immune, net) {
         return "resist";
     return "normal";
 }
+function fromVerdict(matrix, verdict) {
+    if (verdict === "immune")
+        return { verdict: "immune", multiplier: 0, immune: true };
+    const multiplier = multiplierFor(matrix, verdict);
+    return { verdict, multiplier, immune: false };
+}
+function categoryTable(matrix, category) {
+    return matrix.categories[category];
+}
 export function resolveResistance(matrix, category, targetProperties) {
-    const byProperty = matrix.categories[category] ?? {};
+    const byProperty = categoryTable(matrix, category);
+    if (byProperty === undefined) {
+        if (matrix.unknownCategory !== undefined)
+            return fromVerdict(matrix, matrix.unknownCategory);
+        const catalog = matrix.categoryIds ?? Object.keys(matrix.categories);
+        if (catalog.length === 0 && matrix.default !== undefined) {
+            return fromVerdict(matrix, matrix.default);
+        }
+        throw new UnknownResistanceCategoryError(category);
+    }
+    const propertyCatalog = matrix.propertyIds !== undefined ? new Set(matrix.propertyIds) : null;
     const fallback = matrix.default ?? "normal";
     let net = 1;
     let matched = false;
     let immune = false;
     for (const property of targetProperties) {
+        if (propertyCatalog !== null && !propertyCatalog.has(property)) {
+            throw new UnknownResistancePropertyError(category, property);
+        }
         const verdict = byProperty[property];
         if (verdict === undefined)
             continue;
@@ -32,12 +72,8 @@ export function resolveResistance(matrix, category, targetProperties) {
             immune = true;
         net *= multiplierFor(matrix, verdict);
     }
-    if (!matched) {
-        if (fallback === "immune")
-            return { verdict: "immune", multiplier: 0, immune: true };
-        const multiplier = multiplierFor(matrix, fallback);
-        return { verdict: fallback, multiplier, immune: false };
-    }
+    if (!matched)
+        return fromVerdict(matrix, fallback);
     const multiplier = immune ? 0 : net;
     return { verdict: summaryVerdict(matrix, immune, multiplier), multiplier, immune };
 }