@jgengine/core 0.6.0 → 0.8.0

package/dist/game/lootFilter.d.ts

@@ -0,0 +1,33 @@
+export interface LootFilterItem {
+    rarity: string;
+    baseType: string;
+    affixTier?: number;
+}
+export interface LootFilterCondition {
+    rarity?: string | readonly string[];
+    baseType?: string | readonly string[];
+    minAffixTier?: number;
+    maxAffixTier?: number;
+}
+export interface LootFilterRule {
+    id: string;
+    when: LootFilterCondition;
+    hide?: boolean;
+    color?: string;
+    beam?: boolean;
+    label?: string;
+}
+export interface LootFilterOverride {
+    hidden?: boolean;
+    color?: string;
+    beam?: boolean;
+    label?: string;
+}
+/**
+ * First matching rule wins (PoE/Last Epoch block semantics) — later rules
+ * never override an earlier match. Returns overrides only; fields the rule
+ * doesn't set are left for the caller's baseline (rarity style) to fill in.
+ */
+export declare function evaluateLootFilter(rules: readonly LootFilterRule[], item: LootFilterItem): LootFilterOverride;
+/** Validating factory — rule ids must be unique so authoring mistakes fail loudly. */
+export declare function lootFilter(rules: readonly LootFilterRule[]): readonly LootFilterRule[];

package/dist/game/lootFilter.js

@@ -0,0 +1,48 @@
+function matchesOneOf(value, expected) {
+    if (expected === undefined)
+        return true;
+    return typeof expected === "string" ? expected === value : expected.includes(value);
+}
+function matchesCondition(when, item) {
+    if (!matchesOneOf(item.rarity, when.rarity))
+        return false;
+    if (!matchesOneOf(item.baseType, when.baseType))
+        return false;
+    if (when.minAffixTier !== undefined && (item.affixTier ?? 0) < when.minAffixTier)
+        return false;
+    if (when.maxAffixTier !== undefined && (item.affixTier ?? 0) > when.maxAffixTier)
+        return false;
+    return true;
+}
+/**
+ * First matching rule wins (PoE/Last Epoch block semantics) — later rules
+ * never override an earlier match. Returns overrides only; fields the rule
+ * doesn't set are left for the caller's baseline (rarity style) to fill in.
+ */
+export function evaluateLootFilter(rules, item) {
+    for (const rule of rules) {
+        if (!matchesCondition(rule.when, item))
+            continue;
+        const override = {};
+        if (rule.hide !== undefined)
+            override.hidden = rule.hide;
+        if (rule.color !== undefined)
+            override.color = rule.color;
+        if (rule.beam !== undefined)
+            override.beam = rule.beam;
+        if (rule.label !== undefined)
+            override.label = rule.label;
+        return override;
+    }
+    return {};
+}
+/** Validating factory — rule ids must be unique so authoring mistakes fail loudly. */
+export function lootFilter(rules) {
+    const seen = new Set();
+    for (const rule of rules) {
+        if (seen.has(rule.id))
+            throw new Error(`loot filter rule id "${rule.id}" is duplicated`);
+        seen.add(rule.id);
+    }
+    return rules;
+}

package/dist/game/ping.d.ts

@@ -0,0 +1,67 @@
+import type { PointerHit } from "../input/pointer.js";
+import type { MapMarker, MarkerPosition, MarkerSet } from "../world/markers.js";
+export type PingCategory = string;
+export interface PingCategoryDef {
+    id: PingCategory;
+    markerKind: string;
+    label: string;
+    callout: string;
+}
+/** Content-agnostic default ping wheel: enemy / loot / location / danger. */
+export declare const DEFAULT_PING_CATEGORIES: Record<PingCategory, PingCategoryDef>;
+export declare const PING_FEED_ACTION = "party.ping";
+export interface PingClassifyDeps {
+    roleOf?(entityId: string): string | null | undefined;
+    categoryOf?(objectId: string): PingCategory | null | undefined;
+}
+export interface PingClassifyOptions {
+    hostileRoles?: readonly string[];
+    enemyCategory?: PingCategory;
+    lootCategory?: PingCategory;
+    locationCategory?: PingCategory;
+    dangerCategory?: PingCategory;
+}
+/**
+ * Classify what a pointer/aim ray hit into a ping category. Entity hits resolve
+ * by catalog role (hostile → enemy, else location); object hits by an
+ * optional catalog category tag; open ground is a location ping.
+ */
+export declare function classifyPing(hit: PointerHit, deps?: PingClassifyDeps, options?: PingClassifyOptions): PingCategory;
+export interface PingPayload {
+    id: string;
+    from: string;
+    category: PingCategory;
+    position: MarkerPosition;
+    entityId: string | null;
+    objectId: string | null;
+    at: number;
+    callout: string;
+    /** Party members the broadcast targets; empty when solo or party unconfigured. */
+    recipients: readonly string[];
+}
+export interface PingFeedSink {
+    push(action: string, entry: unknown): void;
+}
+export interface PingParty {
+    membersOf(userId: string): string[];
+}
+export interface PingSystemDeps {
+    markers: MarkerSet;
+    feed: PingFeedSink;
+    party?: PingParty;
+    categories?: Record<PingCategory, PingCategoryDef>;
+    now?(): number;
+    /** Marker lifetime in ms; omit for permanent markers. */
+    ttlMs?: number;
+    feedAction?: string;
+    classify?: PingClassifyDeps;
+    classifyOptions?: PingClassifyOptions;
+}
+export interface PingSystem {
+    classify(hit: PointerHit): PingCategory;
+    buildPayload(from: string, hit: PointerHit, category?: PingCategory): PingPayload;
+    broadcast(payload: PingPayload): MapMarker;
+    /** Classify → build → broadcast in one call; the ping verb. */
+    ping(from: string, hit: PointerHit, category?: PingCategory): PingPayload;
+}
+export declare function createPingSystem(deps: PingSystemDeps): PingSystem;

package/dist/game/ping.js

@@ -0,0 +1,86 @@
+/** Content-agnostic default ping wheel: enemy / loot / location / danger. */
+export const DEFAULT_PING_CATEGORIES = {
+    enemy: { id: "enemy", markerKind: "enemy", label: "Enemy", callout: "Enemy spotted" },
+    loot: { id: "loot", markerKind: "loot", label: "Loot", callout: "Loot here" },
+    location: { id: "location", markerKind: "location", label: "Location", callout: "Going here" },
+    danger: { id: "danger", markerKind: "danger", label: "Danger", callout: "Watch out" },
+};
+export const PING_FEED_ACTION = "party.ping";
+const DEFAULT_HOSTILE_ROLES = ["enemy", "hostile"];
+/**
+ * Classify what a pointer/aim ray hit into a ping category. Entity hits resolve
+ * by catalog role (hostile → enemy, else location); object hits by an
+ * optional catalog category tag; open ground is a location ping.
+ */
+export function classifyPing(hit, deps = {}, options = {}) {
+    const hostileRoles = options.hostileRoles ?? DEFAULT_HOSTILE_ROLES;
+    const enemyCategory = options.enemyCategory ?? "enemy";
+    const locationCategory = options.locationCategory ?? "location";
+    if (hit.entity !== null) {
+        const role = deps.roleOf?.(hit.entity);
+        if (role !== null && role !== undefined && hostileRoles.includes(role))
+            return enemyCategory;
+        return locationCategory;
+    }
+    if (hit.object !== null) {
+        const category = deps.categoryOf?.(hit.object);
+        if (category !== null && category !== undefined)
+            return category;
+        return locationCategory;
+    }
+    return locationCategory;
+}
+function categoryDef(categories, category) {
+    return categories[category] ?? { id: category, markerKind: category, label: category, callout: category };
+}
+export function createPingSystem(deps) {
+    const now = deps.now ?? Date.now;
+    const categories = deps.categories ?? DEFAULT_PING_CATEGORIES;
+    const feedAction = deps.feedAction ?? PING_FEED_ACTION;
+    let counter = 0;
+    const system = {
+        classify(hit) {
+            return classifyPing(hit, deps.classify, deps.classifyOptions);
+        },
+        buildPayload(from, hit, category) {
+            const resolved = category ?? system.classify(hit);
+            const at = now();
+            counter += 1;
+            const def = categoryDef(categories, resolved);
+            const recipients = deps.party?.membersOf(from).filter((member) => member !== from) ?? [];
+            return {
+                id: `ping-${from}-${counter}`,
+                from,
+                category: resolved,
+                position: hit.point,
+                entityId: hit.entity,
+                objectId: hit.object,
+                at,
+                callout: def.callout,
+                recipients,
+            };
+        },
+        broadcast(payload) {
+            const def = categoryDef(categories, payload.category);
+            const markerInput = {
+                id: payload.id,
+                kind: def.markerKind,
+                position: payload.position,
+                label: def.label,
+                owner: payload.from,
+                createdAt: payload.at,
+                ...(deps.ttlMs !== undefined ? { expiresAt: payload.at + deps.ttlMs } : {}),
+                meta: { ping: true, category: payload.category, callout: payload.callout },
+            };
+            deps.markers.add(markerInput);
+            deps.feed.push(feedAction, payload);
+            return deps.markers.get(payload.id);
+        },
+        ping(from, hit, category) {
+            const payload = system.buildPayload(from, hit, category);
+            system.broadcast(payload);
+            return payload;
+        },
+    };
+    return system;
+}