@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,193 @@
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,228 @@
+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;