@plasius/renderer 1.0.0

package/dist/player/playerstore.js

@@ -0,0 +1,500 @@
+import { createScopedStoreContext } from "@plasius/react-state";
+export const defaultAttributesBase = {
+    physical: { strength: 33, dexterity: 33, endurance: 33 },
+    mental: { intellect: 33, willpower: 33, creativity: 33 },
+    spiritual: { spirit: 33, wisdom: 33, charisma: 33 },
+};
+export const zeroFlat = {
+    strength: 0,
+    dexterity: 0,
+    endurance: 0,
+    intellect: 0,
+    willpower: 0,
+    creativity: 0,
+    spirit: 0,
+    wisdom: 0,
+    charisma: 0,
+};
+export const defaultState = {
+    position: { x: 0, y: 1.6, z: 0 },
+    lookAt: { x: 0, y: 1.6, z: -1 },
+    velocity: { x: 0, y: 0, z: 0 },
+    attributesBase: { ...defaultAttributesBase },
+    attributesGear: { ...zeroFlat },
+    attributesEffects: { ...zeroFlat },
+    resources: { health: 100, healthMax: 100, energy: 100, energyMax: 100 },
+    items: {},
+    inventory: [],
+    inventoryCapacity: 24,
+    equipment: {},
+    skills: {},
+    effects: {},
+    lastActiveAt: undefined,
+};
+// ====== Helpers ======
+const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+function stackableCount(item) {
+    if (!item)
+        return 1;
+    if (!item.stackable)
+        return 1;
+    return item.maxStack ?? 99;
+}
+function addToInventory(state, itemId, qty) {
+    if (qty <= 0)
+        return state;
+    const item = state.items[itemId];
+    const maxStack = stackableCount(item);
+    let remaining = qty;
+    // Fill existing stacks first
+    const inv = state.inventory.map((slot) => {
+        if (remaining === 0)
+            return slot;
+        if (slot.itemId !== itemId)
+            return slot;
+        const space = maxStack - slot.qty;
+        if (space <= 0)
+            return slot;
+        const add = Math.min(space, remaining);
+        remaining -= add;
+        return { ...slot, qty: slot.qty + add };
+    });
+    // Create new stacks while capacity allows
+    const result = [...inv];
+    while (remaining > 0 && result.length < state.inventoryCapacity) {
+        const add = Math.min(remaining, maxStack);
+        result.push({ itemId, qty: add });
+        remaining -= add;
+    }
+    return { ...state, inventory: result };
+}
+function removeFromInventory(state, itemId, qty) {
+    if (qty <= 0)
+        return state;
+    let remaining = qty;
+    const result = [];
+    for (const slot of state.inventory) {
+        if (slot.itemId !== itemId) {
+            result.push(slot);
+            continue;
+        }
+        if (remaining === 0) {
+            result.push(slot);
+            continue;
+        }
+        if (slot.qty > remaining) {
+            result.push({ itemId, qty: slot.qty - remaining });
+            remaining = 0;
+        }
+        else {
+            remaining -= slot.qty; // drop this slot
+        }
+    }
+    return { ...state, inventory: result };
+}
+function clampAttr(n) {
+    return Math.max(1, Math.min(49, Math.round(n)));
+}
+function sum3(a, b, c) {
+    return a + b + c;
+}
+function normalizeTriangle(a, b, c) {
+    // Ensure sum=99 and each in [1,49]
+    let x = clampAttr(a), y = clampAttr(b), z = clampAttr(c);
+    let total = x + y + z;
+    if (total === 99)
+        return [x, y, z];
+    // Scale to 99, then clamp again, then adjust leftovers greedily
+    const scale = 99 / total;
+    x = clampAttr(x * scale);
+    y = clampAttr(y * scale);
+    z = clampAttr(z * scale);
+    total = x + y + z;
+    // Distribute deficit/excess (typed tuples + stable resorting)
+    let order = [
+        ["x", x],
+        ["y", y],
+        ["z", z],
+    ];
+    const sortDesc = () => {
+        order.sort((a, b) => b[1] - a[1]);
+    };
+    sortDesc();
+    while (total !== 99) {
+        if (total > 99) {
+            // reduce the largest above 1
+            for (const [k, v] of order) {
+                if (v > 1) {
+                    if (k === "x")
+                        x--;
+                    else if (k === "y")
+                        y--;
+                    else
+                        z--;
+                    total--;
+                    // update order values and resort
+                    if (k === "x")
+                        order[0][1] = x;
+                    else if (k === "y")
+                        order[1][1] = y;
+                    else
+                        order[2][1] = z;
+                    sortDesc();
+                    break;
+                }
+            }
+        }
+        else {
+            // increase the smallest below 49
+            for (const [k, v] of [...order].reverse()) {
+                if (v < 49) {
+                    if (k === "x")
+                        x++;
+                    else if (k === "y")
+                        y++;
+                    else
+                        z++;
+                    total++;
+                    // update order values and resort
+                    if (k === "x")
+                        order[0][1] = x;
+                    else if (k === "y")
+                        order[1][1] = y;
+                    else
+                        order[2][1] = z;
+                    sortDesc();
+                    break;
+                }
+            }
+        }
+    }
+    return [x, y, z];
+}
+function flattenBase(base) {
+    const [S, D, E] = normalizeTriangle(base.physical.strength, base.physical.dexterity, base.physical.endurance);
+    const [I, W, C] = normalizeTriangle(base.mental.intellect, base.mental.willpower, base.mental.creativity);
+    const [Sp, Wi, Ch] = normalizeTriangle(base.spiritual.spirit, base.spiritual.wisdom, base.spiritual.charisma);
+    return {
+        strength: S,
+        dexterity: D,
+        endurance: E,
+        intellect: I,
+        willpower: W,
+        creativity: C,
+        spirit: Sp,
+        wisdom: Wi,
+        charisma: Ch,
+    };
+}
+// === Skill-side cross-triangle modifiers ===
+function lnContribution(x, s = 25) {
+    return Math.log(1 + Math.max(0, x) / s); // safe-guard
+}
+function emptyFlat() {
+    return {
+        strength: 0,
+        dexterity: 0,
+        endurance: 0,
+        intellect: 0,
+        willpower: 0,
+        creativity: 0,
+        spirit: 0,
+        wisdom: 0,
+        charisma: 0,
+    };
+}
+// Map rare/hidden skills to cross-triangle penalties (and potential future bonuses) using ln scaling
+// Data-driven skill → attribute modifier map (multiplier per ln unit)
+const SKILL_ATTR_MODS = {
+    shadowstep: { charisma: -2.0 },
+    dreamwalking: { wisdom: -1.0, charisma: -1.0 },
+    soulbinding: { creativity: -1.5, endurance: -1.5 },
+    chronomancy: { endurance: -1.5, spirit: -0.5 },
+    astral_projection: { strength: -1.0, endurance: -1.0 },
+    bloodcraft: { charisma: -2.0, spirit: -2.0 },
+    telepathy: { charisma: -0.5, wisdom: -0.5 },
+    telekinesis: { endurance: -0.5 },
+    possession: { spirit: -2.5, charisma: -2.5 },
+};
+function addFlatInto(dst, src) {
+    dst.strength += src.strength;
+    dst.dexterity += src.dexterity;
+    dst.endurance += src.endurance;
+    dst.intellect += src.intellect;
+    dst.willpower += src.willpower;
+    dst.creativity += src.creativity;
+    dst.spirit += src.spirit;
+    dst.wisdom += src.wisdom;
+    dst.charisma += src.charisma;
+}
+function skillAttributeModifiers(state) {
+    const out = emptyFlat();
+    for (const s of Object.values(state.skills)) {
+        if (!s || !(s.active ?? false) || (s.level ?? 0) <= 0)
+            continue;
+        const lnP = lnContribution(s.level ?? 0, 25);
+        const mods = SKILL_ATTR_MODS[s.id.toLowerCase()];
+        if (!mods)
+            continue;
+        for (const [k, mult] of Object.entries(mods)) {
+            const key = k;
+            const delta = Math.trunc(mult * lnP);
+            out[key] = (out[key] ?? 0) + delta;
+        }
+    }
+    return out;
+}
+function effectiveAttributes(state) {
+    // Start with normalized base
+    const base = flattenBase(state.attributesBase);
+    // Add gear/effects layers
+    const eff = { ...base };
+    const addFlat = (src) => {
+        eff.strength += src.strength;
+        eff.dexterity += src.dexterity;
+        eff.endurance += src.endurance;
+        eff.intellect += src.intellect;
+        eff.willpower += src.willpower;
+        eff.creativity += src.creativity;
+        eff.spirit += src.spirit;
+        eff.wisdom += src.wisdom;
+        eff.charisma += src.charisma;
+    };
+    addFlat(state.attributesGear);
+    addFlat(state.attributesEffects);
+    // Add equipment modifiers
+    for (const slot of Object.keys(state.equipment)) {
+        const itemId = state.equipment[slot];
+        if (!itemId)
+            continue;
+        const item = state.items[itemId];
+        if (item?.modifiers) {
+            for (const [k, v] of Object.entries(item.modifiers)) {
+                const key = k;
+                const val = v ?? 0;
+                eff[key] = (eff[key] ?? 0) + val;
+            }
+        }
+    }
+    // Add status effects
+    for (const effx of Object.values(state.effects)) {
+        const mods = effx.modifiers?.attributes;
+        if (!mods)
+            continue;
+        for (const [k, v] of Object.entries(mods)) {
+            const key = k;
+            const val = v ?? 0;
+            eff[key] = (eff[key] ?? 0) + val;
+        }
+    }
+    // Apply cross-triangle penalties/bonuses derived from active skills (rare/hidden)
+    const skillMods = skillAttributeModifiers(state);
+    addFlatInto(eff, skillMods);
+    return eff;
+}
+// ====== Reducer ======
+function reducer(state, action) {
+    switch (action.type) {
+        case "set_position":
+            return { ...state, position: { ...action.payload } };
+        case "set_look_at":
+            return { ...state, lookAt: { ...action.payload } };
+        case "set_velocity":
+            return { ...state, velocity: { ...action.payload } };
+        case "set_resource": {
+            const next = { ...state.resources, ...action.payload };
+            next.health = clamp(next.health, 0, next.healthMax);
+            next.energy = clamp(next.energy, 0, next.energyMax);
+            return { ...state, resources: next };
+        }
+        case "set_attributes_base": {
+            const next = { ...state.attributesBase };
+            const apply = (k, v) => {
+                switch (k) {
+                    case "strength":
+                        next.physical.strength = v;
+                        break;
+                    case "dexterity":
+                        next.physical.dexterity = v;
+                        break;
+                    case "endurance":
+                        next.physical.endurance = v;
+                        break;
+                    case "intellect":
+                        next.mental.intellect = v;
+                        break;
+                    case "willpower":
+                        next.mental.willpower = v;
+                        break;
+                    case "creativity":
+                        next.mental.creativity = v;
+                        break;
+                    case "spirit":
+                        next.spiritual.spirit = v;
+                        break;
+                    case "wisdom":
+                        next.spiritual.wisdom = v;
+                        break;
+                    case "charisma":
+                        next.spiritual.charisma = v;
+                        break;
+                }
+            };
+            for (const [k, v] of Object.entries(action.payload))
+                apply(k, clampAttr(v));
+            return { ...state, attributesBase: next };
+        }
+        case "set_attributes_gear": {
+            const next = {
+                ...state.attributesGear,
+            };
+            for (const [k, v] of Object.entries(action.payload))
+                next[k] = (next[k] ?? 0) + v;
+            return { ...state, attributesGear: next };
+        }
+        case "set_attributes_effects": {
+            const next = {
+                ...state.attributesEffects,
+            };
+            for (const [k, v] of Object.entries(action.payload))
+                next[k] = (next[k] ?? 0) + v;
+            return { ...state, attributesEffects: next };
+        }
+        case "register_item": {
+            const it = action.payload;
+            return { ...state, items: { ...state.items, [it.id]: it } };
+        }
+        case "add_item":
+            return addToInventory(state, action.payload.itemId, action.payload.qty);
+        case "remove_item":
+            return removeFromInventory(state, action.payload.itemId, action.payload.qty);
+        case "equip": {
+            const { slot, itemId } = action.payload;
+            // Ensure we have the item and it exists in inventory or is otherwise obtainable
+            if (!state.items[itemId])
+                return state;
+            return { ...state, equipment: { ...state.equipment, [slot]: itemId } };
+        }
+        case "unequip": {
+            const { slot } = action.payload;
+            const eq = { ...state.equipment };
+            delete eq[slot];
+            return { ...state, equipment: eq };
+        }
+        case "learn_skill": {
+            const s = action.payload;
+            return { ...state, skills: { ...state.skills, [s.id]: s } };
+        }
+        case "set_skill_active": {
+            const { id, active } = action.payload;
+            const prev = state.skills[id];
+            if (!prev)
+                return state;
+            return {
+                ...state,
+                skills: { ...state.skills, [id]: { ...prev, active } },
+            };
+        }
+        case "set_skill_level": {
+            const { id, level } = action.payload;
+            const prev = state.skills[id];
+            if (!prev)
+                return state;
+            return {
+                ...state,
+                skills: {
+                    ...state.skills,
+                    [id]: {
+                        ...prev,
+                        level: Math.max(0, Math.min(100, Math.round(level))),
+                    },
+                },
+            };
+        }
+        case "forget_skill": {
+            const { id } = action.payload;
+            const next = { ...state.skills };
+            delete next[id];
+            return { ...state, skills: next };
+        }
+        case "apply_effect": {
+            const e = action.payload;
+            return { ...state, effects: { ...state.effects, [e.id]: e } };
+        }
+        case "remove_effect": {
+            const { id } = action.payload;
+            const next = { ...state.effects };
+            delete next[id];
+            return { ...state, effects: next };
+        }
+        default:
+            return state;
+    }
+}
+export const PlayerStore = createScopedStoreContext(reducer, defaultState);
+// Convenience re-exports for common actions (keeps call sites tidy)
+export const PlayerActions = {
+    setPosition: (payload) => ({
+        type: "set_position",
+        payload,
+    }),
+    setLookAt: (payload) => ({
+        type: "set_look_at",
+        payload,
+    }),
+    setVelocity: (payload) => ({
+        type: "set_velocity",
+        payload,
+    }),
+    setResource: (payload) => ({
+        type: "set_resource",
+        payload,
+    }),
+    setAttributesBase: (payload) => ({ type: "set_attributes_base", payload }),
+    setAttributesGear: (payload) => ({ type: "set_attributes_gear", payload }),
+    setAttributesEffects: (payload) => ({ type: "set_attributes_effects", payload }),
+    registerItem: (payload) => ({
+        type: "register_item",
+        payload,
+    }),
+    addItem: (itemId, qty) => ({
+        type: "add_item",
+        payload: { itemId, qty },
+    }),
+    removeItem: (itemId, qty) => ({
+        type: "remove_item",
+        payload: { itemId, qty },
+    }),
+    equip: (slot, itemId) => ({
+        type: "equip",
+        payload: { slot, itemId },
+    }),
+    unequip: (slot) => ({
+        type: "unequip",
+        payload: { slot },
+    }),
+    learnSkill: (payload) => ({
+        type: "learn_skill",
+        payload,
+    }),
+    setSkillActive: (id, active) => ({
+        type: "set_skill_active",
+        payload: { id, active },
+    }),
+    setSkillLevel: (id, level) => ({
+        type: "set_skill_level",
+        payload: { id, level },
+    }),
+    forgetSkill: (id) => ({
+        type: "forget_skill",
+        payload: { id },
+    }),
+    applyEffect: (payload) => ({
+        type: "apply_effect",
+        payload,
+    }),
+    removeEffect: (id) => ({
+        type: "remove_effect",
+        payload: { id },
+    }),
+};

package/dist/renderStateProvider.d.ts

@@ -0,0 +1,57 @@
+import { createScopedStoreContext } from "@plasius/react-state";
+import type { IState } from "@plasius/react-state";
+import type { CameraRigProfile } from "./camera/cameraRigProfile.js";
+type RenderAction = {
+    type: "set_camera_profile";
+    payload: CameraRigProfile;
+} | {
+    type: "set_frame";
+    payload: number;
+} | {
+    type: "set_last_render_time";
+    payload: number;
+} | {
+    type: "update";
+} | {
+    type: "reset";
+} | {
+    type: "set_frame_rate";
+    payload: number;
+} | {
+    type: "increment_accumulated_frames";
+} | {
+    type: "set_performance_tier";
+    payload: "low" | "medium" | "high" | "ultra";
+} | {
+    type: "set_is_animating";
+    payload: boolean;
+} | {
+    type: "set_pause_render";
+    payload: boolean;
+} | {
+    type: "set_scene_hash";
+    payload: string;
+} | {
+    type: "set_vr_mode";
+    payload: boolean;
+};
+interface RenderState extends IState {
+    frame: number;
+    lastRenderTime: number;
+    debugEnabled: boolean;
+    frameRate: number;
+    accumulatedFrames: number;
+    performanceTier: "low" | "medium" | "high" | "ultra";
+    isAnimating: boolean;
+    pauseRender: boolean;
+    sceneHash: string;
+    cameraRigProfile: CameraRigProfile;
+    useVR: boolean;
+}
+export type RenderStoreContext = ReturnType<typeof createScopedStoreContext<RenderState, RenderAction>>;
+export declare const RenderStore: RenderStoreContext;
+export declare const RenderProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react").JSX.Element;
+export {};
+//# sourceMappingURL=renderStateProvider.d.ts.map

package/dist/renderStateProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderStateProvider.d.ts","sourceRoot":"","sources":["../src/renderStateProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,KAAK,YAAY,GACb;IACE,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,gBAAgB,CAAC;CAC3B,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;CAChB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;CACf,GACD;IACE,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,8BAA8B,CAAC;CACtC,GACD;IACE,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;CAC9C,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB,GACD;IACE,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEN,UAAU,WAAY,SAAQ,MAAM;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACrD,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,KAAK,EAAE,OAAO,CAAC;CAChB;AA+CD,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,OAAO,wBAAwB,CAAC,WAAW,EAAE,YAAY,CAAC,CAC3D,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,kBACkD,CAAC;AAE7E,eAAO,MAAM,cAAc,GAAI,cAAc;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,gCAEzE,CAAC"}

package/dist/renderStateProvider.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createScopedStoreContext } from "@plasius/react-state";
+import { VIEW_PROFILE } from "./camera/cameraRigProfile.js";
+const initialState = {
+    frame: 0,
+    lastRenderTime: 0,
+    debugEnabled: false,
+    frameRate: 0,
+    accumulatedFrames: 0,
+    performanceTier: "high",
+    isAnimating: true,
+    pauseRender: false,
+    sceneHash: "",
+    cameraRigProfile: VIEW_PROFILE,
+    useVR: false,
+};
+const reducer = (state, action) => {
+    switch (action.type) {
+        case "update":
+            return { ...state };
+        case "reset":
+            return initialState;
+        case "set_frame_rate":
+            return { ...state, frameRate: action.payload };
+        case "increment_accumulated_frames":
+            return { ...state, accumulatedFrames: state.accumulatedFrames + 1 };
+        case "set_performance_tier":
+            return { ...state, performanceTier: action.payload };
+        case "set_is_animating":
+            return { ...state, isAnimating: action.payload };
+        case "set_pause_render":
+            return { ...state, pauseRender: action.payload };
+        case "set_scene_hash":
+            return { ...state, sceneHash: action.payload };
+        case "set_camera_profile":
+            return { ...state, cameraRigProfile: action.payload };
+        case "set_frame":
+            return { ...state, frame: action.payload };
+        case "set_last_render_time":
+            return { ...state, lastRenderTime: action.payload };
+        case "set_vr_mode":
+            return { ...state, useVR: action.payload };
+        default:
+            return state;
+    }
+};
+export const RenderStore = createScopedStoreContext(reducer, initialState);
+export const RenderProvider = ({ children }) => {
+    return _jsx(RenderStore.Provider, { children: children });
+};

package/dist/renderer.d.ts

@@ -0,0 +1,9 @@
+import { type Vector3 } from "three";
+export interface RendererProps {
+    cameraPosition: Vector3;
+    cameraRotation: Vector3;
+    multiview: boolean;
+}
+declare function WrappedRenderer(props: React.PropsWithChildren<RendererProps>): import("react").JSX.Element;
+export { WrappedRenderer as Renderer };
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,OAAO,CAAC;AAuDjD,MAAM,WAAW,aAAa;IAC5B,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;CACpB;AAkOD,iBAAS,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,aAAa,CAAC,+BAMrE;AAED,OAAO,EAAE,eAAe,IAAI,QAAQ,EAAE,CAAC"}