@jgengine/core 0.8.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/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: "legacy" }` — aim.origin or shooter position. */
+    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,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;
-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: "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 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 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));
             }
-            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 +172,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 +210,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 +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 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 +302,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 };
         },
     };
 }

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 };
 }