@nice2dev/game-engine 0.1.0 → 1.0.3

package/dist/types/inventory/InventorySystem.d.ts

@@ -0,0 +1,336 @@
+import type { EntityId } from '../core/types';
+import { EventBus } from '../core/EventBus';
+import React from 'react';
+/** Item rarity levels */
+export type ItemRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic' | 'unique';
+/** Item categories */
+export type ItemCategory = 'weapon' | 'armor' | 'accessory' | 'consumable' | 'material' | 'currency' | 'quest' | 'key' | 'tool' | 'mount' | 'pet' | 'cosmetic' | 'container' | 'misc';
+/** Equipment slot types */
+export type EquipmentSlot = 'head' | 'chest' | 'legs' | 'feet' | 'hands' | 'shoulders' | 'back' | 'waist' | 'mainHand' | 'offHand' | 'twoHand' | 'ring1' | 'ring2' | 'neck' | 'trinket1' | 'trinket2';
+/** Stat modifier types */
+export type StatType = 'health' | 'mana' | 'stamina' | 'attack' | 'defense' | 'magic' | 'speed' | 'critRate' | 'critDamage' | 'dodge' | 'accuracy' | 'luck' | 'custom';
+/** Container types */
+export type ContainerType = 'player' | 'chest' | 'shop' | 'bank' | 'guild' | 'mail' | 'crafting' | 'loot';
+export interface StatModifier {
+    stat: StatType;
+    /** Flat value added */
+    flat?: number;
+    /** Percentage modifier (0.1 = +10%) */
+    percent?: number;
+    /** Custom stat name if type is 'custom' */
+    customName?: string;
+}
+export interface ItemDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category: ItemCategory;
+    rarity: ItemRarity;
+    /** Icon URL or icon key */
+    icon: string;
+    /** Maximum stack size (1 = not stackable) */
+    maxStack: number;
+    /** Item weight for capacity systems */
+    weight: number;
+    /** Base value in currency */
+    value: number;
+    /** Level requirement to use/equip */
+    levelRequirement?: number;
+    /** Class/role requirements */
+    classRequirement?: string[];
+    /** Stat requirements (e.g., min strength) */
+    statRequirements?: StatModifier[];
+    /** Whether item can be traded */
+    tradable: boolean;
+    /** Whether item can be sold */
+    sellable: boolean;
+    /** Whether item is destroyed on use */
+    consumeOnUse: boolean;
+    /** Equipment slot if equippable */
+    equipSlot?: EquipmentSlot;
+    /** Stat bonuses when equipped/active */
+    stats?: StatModifier[];
+    /** Max durability (undefined = indestructible) */
+    maxDurability?: number;
+    /** Set ID if part of a set */
+    setId?: string;
+    /** Soulbound type */
+    binding?: 'none' | 'onPickup' | 'onEquip' | 'account';
+    /** Cool-down in milliseconds for consumables */
+    cooldown?: number;
+    /** Effect ID when consumed */
+    effectId?: string;
+    /** Tags for filtering/searching */
+    tags?: string[];
+    /** Custom data */
+    customData?: Record<string, unknown>;
+}
+export interface ItemInstance {
+    /** Unique instance ID */
+    instanceId: string;
+    /** Reference to item definition */
+    itemId: string;
+    /** Current stack count */
+    count: number;
+    /** Current durability */
+    durability?: number;
+    /** Bound to player ID */
+    boundTo?: string;
+    /** Enchantments applied */
+    enchantments?: string[];
+    /** Socket gems */
+    sockets?: string[];
+    /** Custom display name override */
+    customName?: string;
+    /** Last used timestamp (for cooldown) */
+    lastUsed?: number;
+    /** Created timestamp */
+    createdAt: number;
+    /** Custom instance data */
+    customData?: Record<string, unknown>;
+}
+export interface InventorySlot {
+    /** Slot index */
+    index: number;
+    /** Item in this slot (null if empty) */
+    item: ItemInstance | null;
+    /** Whether slot is locked */
+    locked?: boolean;
+}
+export interface Container {
+    id: string;
+    type: ContainerType;
+    name: string;
+    /** Owner entity ID */
+    ownerId?: EntityId;
+    /** Maximum number of slots */
+    maxSlots: number;
+    /** Maximum weight capacity (undefined = unlimited) */
+    maxWeight?: number;
+    /** Slots array */
+    slots: InventorySlot[];
+    /** Currency stored in container */
+    currency?: Map<string, number>;
+    /** Whether container is sorted */
+    sorted?: boolean;
+    /** Filter for allowed item categories */
+    allowedCategories?: ItemCategory[];
+    /** Filter for disallowed item categories */
+    disallowedCategories?: ItemCategory[];
+}
+export interface EquipmentState {
+    ownerId: EntityId;
+    slots: Map<EquipmentSlot, ItemInstance | null>;
+    /** Calculated total stats from all equipped items */
+    totalStats: Map<StatType, number>;
+}
+export interface CraftingIngredient {
+    itemId: string;
+    count: number;
+    consumed: boolean;
+}
+export interface CraftingRecipe {
+    id: string;
+    name: string;
+    description: string;
+    /** Required ingredients */
+    ingredients: CraftingIngredient[];
+    /** Output item ID */
+    outputItemId: string;
+    /** Output quantity */
+    outputCount: number;
+    /** Crafting time in milliseconds */
+    craftTime: number;
+    /** Required skill/profession */
+    requiredSkill?: string;
+    /** Required skill level */
+    requiredSkillLevel?: number;
+    /** Whether recipe is learned or always available */
+    requiresLearning: boolean;
+    /** Success rate (0-1) */
+    successRate: number;
+    /** XP granted on success */
+    experienceGrant?: number;
+}
+export interface LootEntry {
+    itemId: string;
+    /** Drop weight (relative to other entries) */
+    weight: number;
+    /** Minimum quantity */
+    minCount: number;
+    /** Maximum quantity */
+    maxCount: number;
+    /** Per-item drop chance (0-1) after selection */
+    dropChance: number;
+    /** Conditions for this entry to be included */
+    conditions?: {
+        minLevel?: number;
+        maxLevel?: number;
+        requiredTags?: string[];
+    };
+}
+export interface LootTable {
+    id: string;
+    name: string;
+    /** Entries with drop weights */
+    entries: LootEntry[];
+    /** Number of rolls on this table */
+    rolls: number;
+    /** Guaranteed drops (always included) */
+    guaranteedDrops?: {
+        itemId: string;
+        count: number;
+    }[];
+}
+export interface ShopListing {
+    itemId: string;
+    /** Override price (uses item.value if undefined) */
+    price?: number;
+    /** Currency type for this listing */
+    currencyId: string;
+    /** Available stock (-1 = unlimited) */
+    stock: number;
+    /** Restock interval in milliseconds */
+    restockInterval?: number;
+    /** Requirements to see/buy */
+    requirements?: {
+        level?: number;
+        reputation?: {
+            factionId: string;
+            minLevel: number;
+        };
+        questCompleted?: string;
+    };
+}
+export interface Shop {
+    id: string;
+    name: string;
+    /** NPC or location ID owning this shop */
+    ownerId?: string;
+    /** Buy rate (percentage of item value) */
+    buyRate: number;
+    /** Sell rate (percentage of item value) */
+    sellRate: number;
+    /** Available listings */
+    listings: ShopListing[];
+    /** Currencies accepted */
+    acceptedCurrencies: string[];
+}
+export type InventoryEventType = 'item:added' | 'item:removed' | 'item:moved' | 'item:stacked' | 'item:split' | 'item:equipped' | 'item:unequipped' | 'item:used' | 'item:destroyed' | 'item:repaired' | 'item:enchanted' | 'craft:started' | 'craft:completed' | 'craft:failed' | 'shop:bought' | 'shop:sold' | 'loot:generated' | 'currency:changed' | 'container:created' | 'container:destroyed' | 'container:sorted';
+export interface InventoryEvent {
+    type: InventoryEventType;
+    containerId?: string;
+    ownerId?: EntityId;
+    item?: ItemInstance;
+    itemId?: string;
+    slot?: number;
+    fromSlot?: number;
+    toSlot?: number;
+    count?: number;
+    currencyId?: string;
+    amount?: number;
+    recipeId?: string;
+    shopId?: string;
+    timestamp: number;
+    customData?: Record<string, unknown>;
+}
+export interface InventoryManagerConfig {
+    /** Default container size */
+    defaultSlots: number;
+    /** Enable weight system */
+    enableWeight: boolean;
+    /** Enable durability system */
+    enableDurability: boolean;
+    /** Auto-stack on pickup */
+    autoStack: boolean;
+    /** Auto-sort after changes */
+    autoSort: boolean;
+    /** Maximum containers per entity */
+    maxContainersPerEntity: number;
+}
+export declare class InventoryManager {
+    private config;
+    private eventBus;
+    private itemDefinitions;
+    private containers;
+    private equipment;
+    private recipes;
+    private lootTables;
+    private shops;
+    private learnedRecipes;
+    private cooldowns;
+    constructor(config?: Partial<InventoryManagerConfig>);
+    setEventBus(bus: EventBus): void;
+    private emit;
+    registerItem(definition: ItemDefinition): void;
+    registerItems(definitions: ItemDefinition[]): void;
+    getItemDefinition(itemId: string): ItemDefinition | undefined;
+    getAllItemDefinitions(): ItemDefinition[];
+    createContainer(type: ContainerType, ownerId?: EntityId, options?: Partial<Container>): Container;
+    getContainer(containerId: string): Container | undefined;
+    getContainersByOwner(ownerId: EntityId): Container[];
+    destroyContainer(containerId: string): boolean;
+    createItemInstance(itemId: string, count?: number, options?: Partial<ItemInstance>): ItemInstance | null;
+    addItem(containerId: string, itemId: string, count?: number, options?: Partial<ItemInstance>): ItemInstance | null;
+    removeItem(containerId: string, slotIndex: number, count?: number): ItemInstance | null;
+    moveItem(fromContainerId: string, fromSlot: number, toContainerId: string, toSlot: number): boolean;
+    splitStack(containerId: string, slotIndex: number, splitCount: number): boolean;
+    getContainerWeight(containerId: string): number;
+    getContainerFreeSlots(containerId: string): number;
+    initializeEquipment(ownerId: EntityId): EquipmentState;
+    getEquipment(ownerId: EntityId): EquipmentState | undefined;
+    equipItem(ownerId: EntityId, containerId: string, slotIndex: number): boolean;
+    unequipItem(ownerId: EntityId, equipSlot: EquipmentSlot, containerId: string): boolean;
+    private unequipToContainer;
+    private recalculateEquipmentStats;
+    damageDurability(instance: ItemInstance, damage: number): boolean;
+    repairItem(instance: ItemInstance, amount?: number): boolean;
+    useItem(containerId: string, slotIndex: number, targetEntityId?: EntityId): boolean;
+    registerRecipe(recipe: CraftingRecipe): void;
+    learnRecipe(entityId: EntityId, recipeId: string): boolean;
+    canCraft(entityId: EntityId, recipeId: string, containerId: string): boolean;
+    craft(entityId: EntityId, recipeId: string, containerId: string): ItemInstance | null;
+    registerLootTable(table: LootTable): void;
+    generateLoot(tableId: string, modifiers?: {
+        luckBonus?: number;
+        levelContext?: number;
+    }): ItemInstance[];
+    registerShop(shop: Shop): void;
+    getShop(shopId: string): Shop | undefined;
+    buyFromShop(shopId: string, listingIndex: number, quantity: number, buyerContainerId: string): boolean;
+    sellToShop(shopId: string, sellerContainerId: string, slotIndex: number, quantity: number): boolean;
+    addCurrency(containerId: string, currencyId: string, amount: number): boolean;
+    removeCurrency(containerId: string, currencyId: string, amount: number): boolean;
+    getCurrency(containerId: string, currencyId: string): number;
+    sortContainer(containerId: string, criteria?: 'category' | 'rarity' | 'name' | 'value'): void;
+    countItemsInContainer(containerId: string, itemId: string): number;
+    private removeItemsByIdFromContainer;
+    findItem(containerId: string, itemId: string): {
+        slot: InventorySlot;
+        instance: ItemInstance;
+    } | null;
+    serialize(): InventorySnapshot;
+    deserialize(snapshot: InventorySnapshot): void;
+}
+export interface InventorySnapshot {
+    containers: Array<Omit<Container, 'currency'> & {
+        currency: [string, number][];
+    }>;
+    equipment: Array<{
+        ownerId: EntityId;
+        slots: [EquipmentSlot, ItemInstance | null][];
+        totalStats: [StatType, number][];
+    }>;
+    learnedRecipes: Array<{
+        entityId: EntityId;
+        recipes: string[];
+    }>;
+}
+export declare const InventoryProvider: React.FC<{
+    manager: InventoryManager;
+    children: React.ReactNode;
+}>;
+export declare function useInventoryManager(): InventoryManager;
+export declare function useContainer(containerId: string): Container | undefined;
+export declare function useEquipment(ownerId: EntityId): EquipmentState | undefined;
+export default InventoryManager;

package/dist/types/performance/WebGPUCompute.d.ts

@@ -72,16 +72,6 @@ declare global {
     interface GPUDeviceLostInfo {
         readonly message: string;
     }
-    namespace GPUBufferUsage {
-        const STORAGE: number;
-        const COPY_SRC: number;
-        const COPY_DST: number;
-        const MAP_READ: number;
-        const UNIFORM: number;
-    }
-    namespace GPUMapMode {
-        const READ: number;
-    }
     interface GPU {
         requestAdapter(options?: {
             powerPreference?: string;

package/dist/types/quest/QuestSystem.d.ts

@@ -0,0 +1,287 @@
+import type { EntityId } from '../core/types';
+import { EventBus } from '../core/EventBus';
+import React from 'react';
+/** Quest categories */
+export type QuestType = 'main' | 'side' | 'daily' | 'weekly' | 'achievement' | 'tutorial' | 'hidden';
+/** Quest status */
+export type QuestStatus = 'locked' | 'available' | 'active' | 'completed' | 'failed' | 'expired';
+/** Objective types */
+export type ObjectiveType = 'collect' | 'kill' | 'interact' | 'reach' | 'escort' | 'defend' | 'survive' | 'craft' | 'talk' | 'discover' | 'score' | 'custom';
+/** Reward types */
+export type RewardType = 'experience' | 'currency' | 'item' | 'skill' | 'reputation' | 'unlock' | 'achievement' | 'custom';
+/** Difficulty levels */
+export type QuestDifficulty = 'trivial' | 'easy' | 'normal' | 'hard' | 'legendary';
+export interface QuestObjective {
+    id: string;
+    type: ObjectiveType;
+    description: string;
+    /** Current progress */
+    current: number;
+    /** Target value to complete */
+    target: number;
+    /** Whether this objective is optional */
+    optional?: boolean;
+    /** Whether this objective is hidden until progress is made */
+    hidden?: boolean;
+    /** Order for sequential objectives */
+    order?: number;
+    /** Custom data for objective tracking */
+    trackingData?: {
+        itemId?: string;
+        enemyType?: string;
+        entityId?: EntityId;
+        locationId?: string;
+        npcId?: string;
+        [key: string]: unknown;
+    };
+    /** Completion status */
+    completed: boolean;
+}
+export interface QuestReward {
+    id: string;
+    type: RewardType;
+    /** Display name */
+    name: string;
+    /** Icon URL or icon key */
+    icon?: string;
+    /** Reward amount (for currency, experience) */
+    amount?: number;
+    /** Item ID (for item rewards) */
+    itemId?: string;
+    /** Quantity of items */
+    quantity?: number;
+    /** Skill ID (for skill unlocks) */
+    skillId?: string;
+    /** Reputation faction and amount */
+    reputation?: {
+        factionId: string;
+        amount: number;
+    };
+    /** What gets unlocked */
+    unlockId?: string;
+    /** Custom reward data */
+    customData?: Record<string, unknown>;
+}
+export interface QuestPrerequisite {
+    type: 'quest' | 'level' | 'item' | 'reputation' | 'skill' | 'time' | 'custom';
+    /** Quest ID that must be completed */
+    questId?: string;
+    /** Minimum level required */
+    level?: number;
+    /** Item that must be possessed */
+    itemId?: string;
+    /** Minimum reputation with faction */
+    reputation?: {
+        factionId: string;
+        amount: number;
+    };
+    /** Skill that must be unlocked */
+    skillId?: string;
+    /** Time window (for daily/weekly quests) */
+    timeWindow?: {
+        start: number;
+        end: number;
+    };
+    /** Custom condition key */
+    customKey?: string;
+}
+export interface Quest {
+    id: string;
+    /** Display name */
+    name: string;
+    /** Short description shown in quest list */
+    summary: string;
+    /** Full description with story/context */
+    description: string;
+    /** Quest category */
+    type: QuestType;
+    /** Difficulty rating */
+    difficulty: QuestDifficulty;
+    /** Quest icon */
+    icon?: string;
+    /** Quest giver NPC ID */
+    giverNpcId?: string;
+    /** Quest turn-in NPC ID */
+    turnInNpcId?: string;
+    /** Location hint */
+    locationHint?: string;
+    /** Level recommendation */
+    recommendedLevel?: number;
+    /** Objectives to complete */
+    objectives: QuestObjective[];
+    /** Rewards on completion */
+    rewards: QuestReward[];
+    /** Bonus rewards for optional objectives */
+    bonusRewards?: QuestReward[];
+    /** Prerequisites to unlock */
+    prerequisites: QuestPrerequisite[];
+    /** Quests that follow this one */
+    followUpQuests?: string[];
+    /** Tags for filtering */
+    tags?: string[];
+    /** Time limit in seconds (0 = no limit) */
+    timeLimit?: number;
+    /** Can quest be abandoned? */
+    canAbandon?: boolean;
+    /** Can quest be repeated? */
+    repeatable?: boolean;
+    /** Cooldown between repeats (ms) */
+    repeatCooldown?: number;
+    /** Custom quest data */
+    metadata?: Record<string, unknown>;
+}
+export interface QuestState {
+    questId: string;
+    status: QuestStatus;
+    objectives: QuestObjective[];
+    /** When quest was accepted */
+    startedAt?: number;
+    /** When quest was completed/failed */
+    endedAt?: number;
+    /** Time remaining (for timed quests) */
+    timeRemaining?: number;
+    /** Number of times completed (for repeatable) */
+    completionCount: number;
+    /** Last completion timestamp */
+    lastCompletedAt?: number;
+}
+export interface QuestJournal {
+    activeQuests: QuestState[];
+    completedQuests: QuestState[];
+    failedQuests: QuestState[];
+    trackedQuestId?: string;
+}
+export type QuestEventType = 'quest:unlocked' | 'quest:accepted' | 'quest:objective-progress' | 'quest:objective-completed' | 'quest:completed' | 'quest:failed' | 'quest:abandoned' | 'quest:reward-claimed' | 'quest:tracked';
+export interface QuestEvent {
+    type: QuestEventType;
+    questId: string;
+    objectiveId?: string;
+    data?: unknown;
+    timestamp: number;
+}
+export declare class QuestManager {
+    private quests;
+    private journal;
+    private events;
+    private playerLevel;
+    private playerItems;
+    private playerSkills;
+    private reputation;
+    private customConditions;
+    constructor(events?: EventBus);
+    registerQuest(quest: Quest): void;
+    registerQuests(quests: Quest[]): void;
+    unregisterQuest(questId: string): void;
+    getQuest(questId: string): Quest | undefined;
+    getAllQuests(): Quest[];
+    setPlayerLevel(level: number): void;
+    addPlayerItem(itemId: string): void;
+    removePlayerItem(itemId: string): void;
+    addPlayerSkill(skillId: string): void;
+    setReputation(factionId: string, amount: number): void;
+    addReputation(factionId: string, amount: number): void;
+    registerCustomCondition(key: string, condition: () => boolean): void;
+    getQuestState(questId: string): QuestState | undefined;
+    getQuestStatus(questId: string): QuestStatus;
+    getActiveQuests(): QuestState[];
+    getCompletedQuests(): QuestState[];
+    getAvailableQuests(): Quest[];
+    getJournal(): QuestJournal;
+    canUnlockQuest(questId: string): boolean;
+    private checkPrerequisite;
+    acceptQuest(questId: string): boolean;
+    abandonQuest(questId: string): boolean;
+    updateObjectiveProgress(questId: string, objectiveId: string, amount: number): boolean;
+    setObjectiveProgress(questId: string, objectiveId: string, value: number): boolean;
+    completeObjective(questId: string, objectiveId: string): boolean;
+    private checkQuestCompletion;
+    completeQuest(questId: string): boolean;
+    failQuest(questId: string): boolean;
+    private checkQuestUnlocks;
+    private checkFollowUpQuests;
+    getQuestRewards(questId: string): {
+        main: QuestReward[];
+        bonus: QuestReward[];
+    } | null;
+    claimRewards(questId: string): QuestReward[] | null;
+    trackQuest(questId: string): void;
+    untrackQuest(): void;
+    getTrackedQuest(): QuestState | undefined;
+    update(deltaMs: number): void;
+    saveState(): QuestJournal;
+    loadState(journal: QuestJournal): void;
+    private emitEvent;
+    subscribe(eventType: QuestEventType, handler: (event: QuestEvent) => void): () => void;
+}
+export declare class QuestBuilder {
+    private quest;
+    private objectiveCounter;
+    private rewardCounter;
+    constructor(id: string, name: string);
+    summary(summary: string): this;
+    description(description: string): this;
+    type(type: QuestType): this;
+    difficulty(difficulty: QuestDifficulty): this;
+    icon(icon: string): this;
+    giver(npcId: string): this;
+    turnIn(npcId: string): this;
+    location(hint: string): this;
+    level(level: number): this;
+    timeLimit(seconds: number): this;
+    cannotAbandon(): this;
+    repeatable(cooldownMs?: number): this;
+    tags(tags: string[]): this;
+    followUp(questIds: string[]): this;
+    requireQuest(questId: string): this;
+    requireLevel(level: number): this;
+    requireItem(itemId: string): this;
+    requireReputation(factionId: string, amount: number): this;
+    requireSkill(skillId: string): this;
+    requireCustom(customKey: string): this;
+    private addObjective;
+    collect(itemId: string, amount: number, description: string, optional?: boolean): this;
+    kill(enemyType: string, amount: number, description: string, optional?: boolean): this;
+    interact(entityId: EntityId, description: string, optional?: boolean): this;
+    reach(locationId: string, description: string, optional?: boolean): this;
+    escort(npcId: string, locationId: string, description: string, optional?: boolean): this;
+    defend(seconds: number, description: string, optional?: boolean): this;
+    survive(seconds: number, description: string, optional?: boolean): this;
+    craft(itemId: string, amount: number, description: string, optional?: boolean): this;
+    talk(npcId: string, description: string, optional?: boolean): this;
+    discover(locationId: string, description: string, optional?: boolean): this;
+    score(threshold: number, description: string, optional?: boolean): this;
+    customObjective(type: string, target: number, description: string, data?: Record<string, unknown>, optional?: boolean): this;
+    private generateRewardId;
+    rewardXP(amount: number, name?: string): this;
+    rewardCurrency(amount: number, currencyName?: string): this;
+    rewardItem(itemId: string, name: string, quantity?: number, icon?: string): this;
+    rewardSkill(skillId: string, name: string, icon?: string): this;
+    rewardReputation(factionId: string, amount: number, factionName: string): this;
+    rewardUnlock(unlockId: string, name: string, icon?: string): this;
+    rewardAchievement(achievementId: string, name: string, icon?: string): this;
+    bonusXP(amount: number, name?: string): this;
+    bonusItem(itemId: string, name: string, quantity?: number, icon?: string): this;
+    build(): Quest;
+}
+export interface QuestListProps {
+    quests: QuestState[];
+    questDefinitions: Map<string, Quest>;
+    trackedId?: string;
+    onSelect?: (questId: string) => void;
+    onTrack?: (questId: string) => void;
+    filter?: QuestType[];
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const QuestList: React.FC<QuestListProps>;
+export interface QuestTrackerProps {
+    state: QuestState;
+    quest: Quest;
+    showOptional?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const QuestTracker: React.FC<QuestTrackerProps>;
+export declare function createEmptyQuest(id: string, name: string): Quest;
+export declare const DIFFICULTY_COLORS: Record<QuestDifficulty, string>;
+export declare const DIFFICULTY_XP_MULTIPLIERS: Record<QuestDifficulty, number>;