@nice2dev/game-engine 1.3.12 → 1.3.14

package/dist/types/systems/NiceCooking.d.ts

@@ -1,193 +0,0 @@
-import { EventEmitter } from 'events';
-export type EntityId = string;
-export type RecipeId = string;
-export type IngredientId = string;
-export type StationId = string;
-export type FoodId = string;
-export type IngredientCategory = 'meat' | 'fish' | 'vegetable' | 'fruit' | 'grain' | 'dairy' | 'spice' | 'liquid' | 'sweetener' | 'oil' | 'herb';
-export interface Ingredient {
-    id: IngredientId;
-    name: string;
-    category: IngredientCategory;
-    quality: number;
-    freshness: number;
-    spoilRate: number;
-    stackSize: number;
-    flavorProfile: {
-        sweet: number;
-        sour: number;
-        salty: number;
-        bitter: number;
-        umami: number;
-        spicy: number;
-    };
-}
-export type DishCategory = 'appetizer' | 'main' | 'side' | 'dessert' | 'beverage' | 'soup' | 'salad' | 'snack';
-export interface RecipeIngredient {
-    ingredientId: IngredientId;
-    amount: number;
-    optional?: boolean;
-    substitutes?: IngredientId[];
-}
-export interface CookingStep {
-    action: 'chop' | 'mix' | 'heat' | 'cool' | 'season' | 'plate' | 'garnish';
-    duration: number;
-    temperature?: number;
-    intensity?: number;
-    skillCheck?: boolean;
-}
-export interface Recipe {
-    id: RecipeId;
-    name: string;
-    description: string;
-    category: DishCategory;
-    ingredients: RecipeIngredient[];
-    steps: CookingStep[];
-    requiredStation: StationId;
-    requiredSkill: number;
-    baseCookTime: number;
-    difficulty: number;
-    baseQuality: number;
-    effects: FoodEffect[];
-    servings: number;
-    expirationTime?: number;
-}
-export type EffectType = 'heal' | 'stamina' | 'buff' | 'debuff' | 'satiation' | 'hydration';
-export interface FoodEffect {
-    type: EffectType;
-    stat?: string;
-    value: number;
-    duration?: number;
-    scalewWithQuality?: boolean;
-}
-export interface CookedFood {
-    id: FoodId;
-    recipeId: RecipeId;
-    name: string;
-    quality: number;
-    freshness: number;
-    spoilRate: number;
-    effects: FoodEffect[];
-    cookedBy: EntityId;
-    cookedAt: number;
-    servingsRemaining: number;
-}
-export type StationType = 'prep-table' | 'stove' | 'oven' | 'grill' | 'fryer' | 'campfire' | 'cauldron' | 'mixer' | 'smoker';
-export interface CookingStation {
-    id: StationId;
-    type: StationType;
-    name: string;
-    tier: number;
-    speedMultiplier: number;
-    qualityBonus: number;
-    currentCook?: ActiveCook;
-    fuelLevel?: number;
-    fuelCapacity?: number;
-    temperature?: number;
-    targetTemperature?: number;
-}
-export interface ActiveCook {
-    recipeId: RecipeId;
-    chefId: EntityId;
-    startTime: number;
-    currentStep: number;
-    progress: number;
-    ingredients: Map<IngredientId, number>;
-    qualityAccumulated: number;
-    perfectCooks: number;
-    failedSteps: number;
-}
-export interface ChefProfile {
-    entityId: EntityId;
-    skillLevel: number;
-    experience: number;
-    experienceToNextLevel: number;
-    knownRecipes: Set<RecipeId>;
-    masteredRecipes: Set<RecipeId>;
-    bonuses: {
-        speed: number;
-        quality: number;
-        yieldBonus: number;
-        criticalChance: number;
-    };
-    stats: {
-        dishesCooked: number;
-        perfectDishes: number;
-        failedDishes: number;
-        recipesLearned: number;
-    };
-    specializations: Map<DishCategory, number>;
-}
-export type CookingEventType = 'cooking-started' | 'step-completed' | 'step-failed' | 'perfect-cook' | 'cooking-completed' | 'cooking-failed' | 'recipe-learned' | 'recipe-mastered' | 'skill-increased' | 'food-spoiled' | 'station-out-of-fuel';
-export interface CookingEvent {
-    type: CookingEventType;
-    entityId?: EntityId;
-    stationId?: StationId;
-    recipeId?: RecipeId;
-    data?: Record<string, unknown>;
-}
-export interface CookingSystemConfig {
-    baseSkillLevelCap?: number;
-    experiencePerDish?: number;
-    qualityFailureThreshold?: number;
-    perfectCookBonus?: number;
-    criticalSuccessBonus?: number;
-    spoilageMultiplier?: number;
-    masteryCookCount?: number;
-}
-export declare const DEFAULT_COOKING_CONFIG: CookingSystemConfig;
-export declare class NiceCooking extends EventEmitter {
-    private recipes;
-    private ingredients;
-    private stations;
-    private chefs;
-    private cookedFoods;
-    private recipeHistory;
-    private nextFoodId;
-    private config;
-    constructor(config?: Partial<CookingSystemConfig>);
-    defineRecipe(recipe: Recipe): void;
-    getRecipe(id: RecipeId): Recipe | undefined;
-    getAllRecipes(): Recipe[];
-    getRecipesByCategory(category: DishCategory): Recipe[];
-    defineIngredient(ingredient: Ingredient): void;
-    getIngredient(id: IngredientId): Ingredient | undefined;
-    registerStation(station: CookingStation): void;
-    getStation(id: StationId): CookingStation | undefined;
-    addFuel(stationId: StationId, amount: number): void;
-    setTemperature(stationId: StationId, temperature: number): void;
-    registerChef(entityId: EntityId): void;
-    getChef(entityId: EntityId): ChefProfile | undefined;
-    learnRecipe(entityId: EntityId, recipeId: RecipeId): boolean;
-    startCooking(entityId: EntityId, stationId: StationId, recipeId: RecipeId, ingredients: Map<IngredientId, number>): boolean;
-    cancelCooking(stationId: StationId): void;
-    performSkillCheck(stationId: StationId, performance: number): {
-        success: boolean;
-        perfect: boolean;
-        quality: number;
-    };
-    update(deltaTime: number): void;
-    private updateCooking;
-    private advanceStep;
-    private completeCooking;
-    private awardExperience;
-    consumeFood(foodId: FoodId, servings?: number): {
-        effects: FoodEffect[];
-    } | null;
-    getLearnableRecipes(entityId: EntityId): Recipe[];
-    canCook(entityId: EntityId, recipeId: RecipeId, stationId: StationId): {
-        canCook: boolean;
-        reason?: string;
-    };
-    getFood(foodId: FoodId): CookedFood | undefined;
-    getFreshFoods(): CookedFood[];
-}
-export declare function createCookingSystem(config?: Partial<CookingSystemConfig>): NiceCooking;
-export declare function defineRecipe(options: Recipe): Recipe;
-export declare function defineIngredient(options: Ingredient): Ingredient;
-export declare function createCookingStation(options: Partial<CookingStation> & {
-    id: StationId;
-    type: StationType;
-    name: string;
-}): CookingStation;
-export default NiceCooking;

package/dist/types/systems/NiceCoroutine.d.ts

@@ -1,101 +0,0 @@
-import { EventEmitter } from 'events';
-export type CoroutineId = string;
-export type CoroutineFunction = () => Generator<YieldInstruction, void, number>;
-export type YieldInstruction = WaitForSeconds | WaitForFrames | WaitForCondition | WaitForCoroutine | WaitForAll | WaitForAny | null;
-export declare class WaitForSeconds {
-    readonly seconds: number;
-    readonly type = "seconds";
-    constructor(seconds: number);
-}
-export declare class WaitForFrames {
-    readonly frames: number;
-    readonly type = "frames";
-    constructor(frames: number);
-}
-export declare class WaitForCondition {
-    readonly condition: () => boolean;
-    readonly type = "condition";
-    constructor(condition: () => boolean);
-}
-export declare class WaitForCoroutine {
-    readonly coroutineId: CoroutineId;
-    readonly type = "coroutine";
-    constructor(coroutineId: CoroutineId);
-}
-export declare class WaitForAll {
-    readonly coroutineIds: CoroutineId[];
-    readonly type = "all";
-    constructor(coroutineIds: CoroutineId[]);
-}
-export declare class WaitForAny {
-    readonly coroutineIds: CoroutineId[];
-    readonly type = "any";
-    constructor(coroutineIds: CoroutineId[]);
-}
-export type CoroutineState = 'running' | 'paused' | 'waiting' | 'completed' | 'cancelled';
-export interface CoroutineInstance {
-    id: CoroutineId;
-    generator: Generator<YieldInstruction, void, number>;
-    state: CoroutineState;
-    currentYield: YieldInstruction | null;
-    waitTimer: number;
-    waitFrames: number;
-    tags: Set<string>;
-    priority: number;
-    createdAt: number;
-    onComplete?: () => void;
-    onCancel?: () => void;
-}
-export type CoroutineEventType = 'started' | 'completed' | 'cancelled' | 'paused' | 'resumed' | 'error';
-export interface CoroutineEvent {
-    type: CoroutineEventType;
-    coroutineId: CoroutineId;
-    error?: Error;
-}
-export interface CoroutineConfig {
-    maxCoroutines?: number;
-    defaultPriority?: number;
-    warnOnExceed?: boolean;
-}
-export declare const DEFAULT_COROUTINE_CONFIG: CoroutineConfig;
-export declare class NiceCoroutine extends EventEmitter {
-    private coroutines;
-    private nextId;
-    private frame;
-    private config;
-    private globalPaused;
-    constructor(config?: Partial<CoroutineConfig>);
-    start(fn: CoroutineFunction, options?: {
-        tags?: string[];
-        priority?: number;
-        onComplete?: () => void;
-        onCancel?: () => void;
-    }): CoroutineId;
-    stop(id: CoroutineId): boolean;
-    pause(id: CoroutineId): boolean;
-    resume(id: CoroutineId): boolean;
-    stopAll(): void;
-    pauseAll(): void;
-    resumeAll(): void;
-    stopByTag(tag: string): number;
-    pauseByTag(tag: string): number;
-    resumeByTag(tag: string): number;
-    isRunning(id: CoroutineId): boolean;
-    getState(id: CoroutineId): CoroutineState | undefined;
-    getCount(): number;
-    getRunningCount(): number;
-    getByTag(tag: string): CoroutineId[];
-    update(deltaTime: number): void;
-    private stepCoroutine;
-    private setupWait;
-    private checkWaitCondition;
-    getFrame(): number;
-}
-export declare function waitForSeconds(seconds: number): WaitForSeconds;
-export declare function waitForFrames(frames: number): WaitForFrames;
-export declare function waitUntil(condition: () => boolean): WaitForCondition;
-export declare function waitForCoroutine(id: CoroutineId): WaitForCoroutine;
-export declare function waitForAll(ids: CoroutineId[]): WaitForAll;
-export declare function waitForAny(ids: CoroutineId[]): WaitForAny;
-export declare function createCoroutineSystem(config?: Partial<CoroutineConfig>): NiceCoroutine;
-export default NiceCoroutine;

package/dist/types/systems/NiceCrafting.d.ts

@@ -1,228 +0,0 @@
-export type RecipeId = string;
-export type ItemId = string;
-export type StationId = string;
-export type CraftingCategoryId = string;
-export type CraftingQuality = 'poor' | 'normal' | 'good' | 'excellent' | 'masterwork' | 'legendary';
-export type RecipeDiscoveryType = 'known' | 'discovered' | 'recipe-item' | 'skill-unlock' | 'quest' | 'purchase';
-export interface CraftingItem {
-    id: ItemId;
-    name: string;
-    description: string;
-    icon: string;
-    category: string;
-    stackable: boolean;
-    maxStack: number;
-    rarity: string;
-    value: number;
-    tags: string[];
-    customData?: Record<string, unknown>;
-}
-export interface ItemStack {
-    itemId: ItemId;
-    quantity: number;
-    quality?: CraftingQuality;
-    metadata?: Record<string, unknown>;
-}
-export interface RecipeIngredient {
-    itemId: ItemId;
-    quantity: number;
-    /** Allow specific quality or higher */
-    minQuality?: CraftingQuality;
-    /** Consumed in crafting (default true) */
-    consumed?: boolean;
-}
-export interface RecipeOutput {
-    itemId: ItemId;
-    quantity: number;
-    /** Base quality of output */
-    quality?: CraftingQuality;
-    /** Chance to produce (0-1, default 1) */
-    chance?: number;
-    /** Bonus quantity range */
-    bonusQuantity?: {
-        min: number;
-        max: number;
-        chance: number;
-    };
-}
-export interface RecipeDefinition {
-    id: RecipeId;
-    name: string;
-    description: string;
-    icon: string;
-    category: CraftingCategoryId;
-    /** Required crafting station */
-    stationId: StationId | null;
-    /** Required ingredients */
-    ingredients: RecipeIngredient[];
-    /** Primary output */
-    output: RecipeOutput;
-    /** Secondary/bonus outputs */
-    secondaryOutputs?: RecipeOutput[];
-    /** Byproducts */
-    byproducts?: RecipeOutput[];
-    /** Time to craft in seconds (0 = instant) */
-    craftingTime: number;
-    /** Required crafting skill level */
-    requiredLevel: number;
-    /** Experience gained from crafting */
-    experienceGain: number;
-    /** Base success rate (0-1) */
-    baseSuccessRate: number;
-    /** Can craft multiple at once */
-    batchCraftable: boolean;
-    /** Max batch size */
-    maxBatchSize: number;
-    /** Resource costs (fuel, energy, etc.) */
-    resourceCosts?: {
-        resource: string;
-        amount: number;
-    }[];
-    /** Discovery type */
-    discoveryType: RecipeDiscoveryType;
-    /** Item needed to learn recipe */
-    recipeItemId?: ItemId;
-    /** Sort order */
-    sortOrder?: number;
-    /** Tags for filtering */
-    tags?: string[];
-    /** Custom data */
-    customData?: Record<string, unknown>;
-}
-export interface CraftingStationDefinition {
-    id: StationId;
-    name: string;
-    description: string;
-    icon: string;
-    /** Categories this station can craft */
-    categories: CraftingCategoryId[];
-    /** Crafting speed multiplier */
-    speedMultiplier: number;
-    /** Success rate bonus */
-    successRateBonus: number;
-    /** Quality chance bonus */
-    qualityBonus: number;
-    /** Number of simultaneous crafting slots */
-    craftingSlots: number;
-    /** Required player level to use */
-    requiredLevel: number;
-    /** Fuel/energy requirements */
-    fuelTypes?: ItemId[];
-    /** Sort order */
-    sortOrder?: number;
-}
-export interface CraftingStationState {
-    id: StationId;
-    active: boolean;
-    fuelRemaining: number;
-    currentRecipes: ActiveCraft[];
-    lastUsed: number;
-}
-export interface ActiveCraft {
-    id: string;
-    recipeId: RecipeId;
-    stationId: StationId | null;
-    quantity: number;
-    startedAt: number;
-    completesAt: number;
-    paused: boolean;
-    progress: number;
-    completed: boolean;
-}
-export interface CraftingResult {
-    success: boolean;
-    outputs: ItemStack[];
-    experienceGained: number;
-    qualityAchieved: CraftingQuality;
-    criticalSuccess: boolean;
-    failureReason?: string;
-}
-export interface CraftingSkillState {
-    level: number;
-    experience: number;
-    experienceToNextLevel: number;
-    totalExperience: number;
-    bonusSuccessRate: number;
-    bonusQualityChance: number;
-    bonusSpeed: number;
-}
-export type CraftingEventType = 'craft-started' | 'craft-completed' | 'craft-failed' | 'craft-cancelled' | 'recipe-discovered' | 'recipe-unlocked' | 'level-up' | 'queue-updated';
-export interface CraftingEvent {
-    type: CraftingEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type CraftingEventCallback = (event: CraftingEvent) => void;
-export interface CraftingConfig {
-    /** Experience to level formula */
-    experienceFormula: (level: number) => number;
-    /** Max crafting skill level */
-    maxLevel: number;
-    /** Quality tier weights at different skill levels */
-    qualityWeights: Record<number, Record<CraftingQuality, number>>;
-    /** Success rate bonus per level */
-    successRatePerLevel: number;
-    /** Speed bonus per level */
-    speedPerLevel: number;
-    /** Auto-save state */
-    autoSave: boolean;
-    /** Storage key */
-    storageKey: string;
-    /** Inventory integration */
-    inventoryCheck?: (itemId: ItemId, quantity: number) => boolean;
-    inventoryRemove?: (itemId: ItemId, quantity: number) => boolean;
-    inventoryAdd?: (itemId: ItemId, quantity: number, quality?: CraftingQuality) => boolean;
-}
-export declare const DEFAULT_CRAFTING_CONFIG: CraftingConfig;
-export declare class NiceCrafting {
-    private config;
-    private recipes;
-    private stations;
-    private stationStates;
-    private discoveredRecipes;
-    private skillState;
-    private activeCrafts;
-    private craftingTimer;
-    private eventListeners;
-    constructor(config?: Partial<CraftingConfig>);
-    on(event: CraftingEventType, callback: CraftingEventCallback): () => void;
-    private emit;
-    registerRecipe(recipe: RecipeDefinition): void;
-    registerRecipes(recipes: RecipeDefinition[]): void;
-    getRecipe(id: RecipeId): RecipeDefinition | undefined;
-    getAllRecipes(): RecipeDefinition[];
-    getDiscoveredRecipes(): RecipeDefinition[];
-    getRecipesByCategory(category: CraftingCategoryId): RecipeDefinition[];
-    getRecipesByStation(stationId: StationId): RecipeDefinition[];
-    discoverRecipe(recipeId: RecipeId, method?: RecipeDiscoveryType): boolean;
-    isRecipeDiscovered(recipeId: RecipeId): boolean;
-    learnRecipeFromItem(itemId: ItemId): RecipeId[];
-    registerStation(station: CraftingStationDefinition): void;
-    registerStations(stations: CraftingStationDefinition[]): void;
-    getStation(id: StationId): CraftingStationDefinition | undefined;
-    getStationState(id: StationId): CraftingStationState | undefined;
-    getAllStations(): CraftingStationDefinition[];
-    canCraft(recipeId: RecipeId, quantity?: number, stationId?: StationId): {
-        canCraft: boolean;
-        reason?: string;
-    };
-    startCraft(recipeId: RecipeId, quantity?: number, stationId?: StationId): string | null;
-    cancelCraft(craftId: string): boolean;
-    private startCraftingTimer;
-    private updateCrafting;
-    private completeCraft;
-    private rollQuality;
-    private randomInt;
-    addExperience(amount: number): void;
-    getSkillState(): CraftingSkillState;
-    getActiveCrafts(): ActiveCraft[];
-    getCraftById(id: string): ActiveCraft | undefined;
-    getCraftableRecipes(): RecipeDefinition[];
-    getCategories(): CraftingCategoryId[];
-    save(): string;
-    load(data: string): void;
-    saveToStorage(): void;
-    loadFromStorage(): boolean;
-    destroy(): void;
-}
-export declare function createCraftingSystem(config?: Partial<CraftingConfig>): NiceCrafting;