@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/editor/CraftingEditor.js

@@ -0,0 +1,749 @@
+'use strict';
+
+/**
+ * @file CraftingEditor.ts
+ * @description Visual Crafting Recipe Editor system
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Recipe definition with ingredients
+ * - Crafting stations/workbenches
+ * - Recipe categories and discovery
+ * - Skill requirements
+ * - Recipe variants and tiers
+ * - Crafting time and progress
+ * - By-products and waste
+ * - Recipe chains
+ * - Salvaging/recycling
+ * - Quality system
+ */
+// ============================================================
+// Crafting Editor
+// ============================================================
+class CraftingEditor {
+    constructor() {
+        this.recipes = new Map();
+        this.stations = new Map();
+        this.chains = new Map();
+        this.salvageRules = new Map();
+        // Runtime
+        this.activeProgress = new Map();
+        this.craftingQueues = new Map();
+        // Player state
+        this.playerSkills = new Map();
+        this.playerInventory = new Map();
+        this.discoveredRecipes = new Set();
+    }
+    // ─── Recipe Management ─────────────────────────────────
+    createRecipe(name, category) {
+        const recipe = {
+            id: `recipe_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name,
+            description: '',
+            category,
+            ingredients: [],
+            outputs: [],
+            requirements: [],
+            skillRequired: 0,
+            craftingTime: 5,
+            experienceGained: 10,
+            isStackable: true,
+            maxBatch: 99,
+            discoveryMethod: 'known',
+            discoveredBy: new Set(),
+            tier: 1,
+            baseQuality: 'normal',
+            qualityFactors: [],
+            tags: [],
+            isFavorite: false,
+            createdAt: Date.now(),
+            modifiedAt: Date.now(),
+            version: 1,
+        };
+        this.recipes.set(recipe.id, recipe);
+        return recipe;
+    }
+    getRecipe(id) {
+        return this.recipes.get(id);
+    }
+    updateRecipe(id, updates) {
+        const recipe = this.recipes.get(id);
+        if (!recipe) {
+            return false;
+        }
+        Object.assign(recipe, updates, { modifiedAt: Date.now() });
+        return true;
+    }
+    deleteRecipe(id) {
+        return this.recipes.delete(id);
+    }
+    getAllRecipes() {
+        return Array.from(this.recipes.values());
+    }
+    getRecipesByCategory(category) {
+        return this.getAllRecipes().filter((r) => r.category === category);
+    }
+    // ─── Ingredient Management ─────────────────────────────
+    addIngredient(recipeId, itemId, amount, isConsumed = true) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return false;
+        }
+        const ingredient = {
+            itemId,
+            amount,
+            isConsumed,
+        };
+        recipe.ingredients.push(ingredient);
+        recipe.modifiedAt = Date.now();
+        return true;
+    }
+    removeIngredient(recipeId, index) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe || index < 0 || index >= recipe.ingredients.length) {
+            return false;
+        }
+        recipe.ingredients.splice(index, 1);
+        recipe.modifiedAt = Date.now();
+        return true;
+    }
+    setIngredientAlternatives(recipeId, ingredientIndex, alternativeIds) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe || !recipe.ingredients[ingredientIndex]) {
+            return false;
+        }
+        recipe.ingredients[ingredientIndex].alternativeIds = alternativeIds;
+        recipe.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Output Management ─────────────────────────────────
+    addOutput(recipeId, itemId, minAmount, maxAmount = minAmount, chance = 1) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return false;
+        }
+        const output = {
+            itemId,
+            minAmount,
+            maxAmount,
+            chance,
+        };
+        recipe.outputs.push(output);
+        recipe.modifiedAt = Date.now();
+        return true;
+    }
+    addByproduct(recipeId, itemId, chance, amount = 1) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return false;
+        }
+        if (!recipe.byproducts) {
+            recipe.byproducts = [];
+        }
+        recipe.byproducts.push({
+            itemId,
+            minAmount: amount,
+            maxAmount: amount,
+            chance,
+        });
+        recipe.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Requirement Management ────────────────────────────
+    addRequirement(recipeId, type, target, value, description) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return false;
+        }
+        recipe.requirements.push({ type, target, value, description });
+        recipe.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Station Management ────────────────────────────────
+    createStation(name, categories) {
+        const station = {
+            id: `station_${Date.now()}`,
+            name,
+            description: '',
+            categories,
+            tier: 1,
+        };
+        this.stations.set(station.id, station);
+        return station;
+    }
+    getStation(id) {
+        return this.stations.get(id);
+    }
+    getAllStations() {
+        return Array.from(this.stations.values());
+    }
+    getStationsForCategory(category) {
+        return this.getAllStations().filter((s) => s.categories.includes(category));
+    }
+    // ─── Recipe Chains ─────────────────────────────────────
+    createChain(name) {
+        const chain = {
+            id: `chain_${Date.now()}`,
+            name,
+            description: '',
+            recipeIds: [],
+            automatable: false,
+        };
+        this.chains.set(chain.id, chain);
+        return chain;
+    }
+    addRecipeToChain(chainId, recipeId) {
+        const chain = this.chains.get(chainId);
+        if (!chain) {
+            return false;
+        }
+        chain.recipeIds.push(recipeId);
+        return true;
+    }
+    // ─── Salvage Rules ─────────────────────────────────────
+    createSalvageRule(sourceItemId) {
+        const rule = {
+            sourceItemId,
+            outputs: [],
+            preserveEnchantments: false,
+        };
+        this.salvageRules.set(sourceItemId, rule);
+        return rule;
+    }
+    addSalvageOutput(sourceItemId, outputItemId, chance, amount = 1) {
+        const rule = this.salvageRules.get(sourceItemId);
+        if (!rule) {
+            return false;
+        }
+        rule.outputs.push({
+            itemId: outputItemId,
+            minAmount: amount,
+            maxAmount: amount,
+            chance,
+        });
+        return true;
+    }
+    // ─── Runtime: Availability ─────────────────────────────
+    getAvailableRecipes(playerId, stationId) {
+        return this.getAllRecipes().filter((recipe) => {
+            // Check discovery
+            if (recipe.discoveryMethod !== 'known' && !this.discoveredRecipes.has(recipe.id)) {
+                return false;
+            }
+            // Check station
+            if (stationId && recipe.stationId && recipe.stationId !== stationId) {
+                return false;
+            }
+            // Check requirements
+            for (const req of recipe.requirements) {
+                if (!this.checkRequirement(req, playerId)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    canCraft(recipeId, playerId, quantity = 1) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return { canCraft: false, reason: 'Recipe not found' };
+        }
+        // Check discovery
+        if (recipe.discoveryMethod !== 'known' && !this.discoveredRecipes.has(recipeId)) {
+            return { canCraft: false, reason: 'Recipe not discovered' };
+        }
+        // Check skill requirement
+        if (recipe.skillId) {
+            const skill = this.playerSkills.get(recipe.skillId) ?? 0;
+            if (skill < recipe.skillRequired) {
+                return {
+                    canCraft: false,
+                    reason: `Requires ${recipe.skillId} skill ${recipe.skillRequired}`,
+                };
+            }
+        }
+        // Check ingredients
+        for (const ingredient of recipe.ingredients) {
+            const required = ingredient.amount * quantity;
+            let hasIngredient = false;
+            // Check main item or alternatives
+            const itemIds = [ingredient.itemId, ...(ingredient.alternativeIds ?? [])];
+            for (const itemId of itemIds) {
+                const available = this.playerInventory.get(itemId) ?? 0;
+                if (available >= required) {
+                    hasIngredient = true;
+                    break;
+                }
+            }
+            if (!hasIngredient) {
+                return { canCraft: false, reason: `Insufficient ${ingredient.itemId}` };
+            }
+        }
+        // Check requirements
+        for (const req of recipe.requirements) {
+            if (!this.checkRequirement(req, playerId)) {
+                return { canCraft: false, reason: req.description ?? `Requirement not met: ${req.type}` };
+            }
+        }
+        return { canCraft: true };
+    }
+    checkRequirement(req, _playerId) {
+        switch (req.type) {
+            case 'skill':
+                const skill = this.playerSkills.get(req.target) ?? 0;
+                return skill >= req.value;
+            case 'level':
+                // Would integrate with player level system
+                return true;
+            default:
+                return true;
+        }
+    }
+    // ─── Runtime: Crafting ─────────────────────────────────
+    startCrafting(recipeId, playerId, quantity = 1) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return null;
+        }
+        const check = this.canCraft(recipeId, playerId, quantity);
+        if (!check.canCraft) {
+            return null;
+        }
+        // Consume ingredients
+        for (const ingredient of recipe.ingredients) {
+            if (!ingredient.isConsumed) {
+                continue;
+            }
+            const required = ingredient.amount * quantity;
+            const itemIds = [ingredient.itemId, ...(ingredient.alternativeIds ?? [])];
+            for (const itemId of itemIds) {
+                const available = this.playerInventory.get(itemId) ?? 0;
+                if (available >= required) {
+                    this.playerInventory.set(itemId, available - required);
+                    break;
+                }
+            }
+        }
+        const now = Date.now();
+        const craftingTime = recipe.craftingTime * 1000 * quantity;
+        const progress = {
+            id: `progress_${Date.now()}`,
+            recipeId,
+            playerId,
+            startedAt: now,
+            completesAt: now + craftingTime,
+            quantity,
+            isPaused: false,
+            accumulatedTime: 0,
+            cancelled: false,
+        };
+        this.activeProgress.set(progress.id, progress);
+        this.onCraftingStarted?.(progress);
+        // Instant crafting
+        if (recipe.craftingTime === 0) {
+            this.completeCrafting(progress.id);
+        }
+        return progress;
+    }
+    updateCraftingProgress(deltaTime) {
+        const now = Date.now();
+        for (const [progressId, progress] of this.activeProgress) {
+            if (progress.isPaused || progress.cancelled) {
+                continue;
+            }
+            const recipe = this.recipes.get(progress.recipeId);
+            if (!recipe) {
+                continue;
+            }
+            // Check if complete
+            if (now >= progress.completesAt) {
+                this.completeCrafting(progressId);
+            }
+            else {
+                // Report progress
+                const totalTime = progress.completesAt - progress.startedAt;
+                const elapsed = now - progress.startedAt + progress.accumulatedTime;
+                const percent = Math.min(1, elapsed / totalTime);
+                this.onCraftingProgress?.(progress, percent);
+            }
+        }
+    }
+    completeCrafting(progressId) {
+        const progress = this.activeProgress.get(progressId);
+        if (!progress) {
+            return;
+        }
+        const recipe = this.recipes.get(progress.recipeId);
+        if (!recipe) {
+            return;
+        }
+        // Determine quality
+        const quality = this.determineQuality(recipe, progress.playerId);
+        this.onQualityDetermined?.(recipe, quality, []);
+        // Generate outputs
+        const outputs = [];
+        for (const output of recipe.outputs) {
+            if (Math.random() <= output.chance) {
+                const baseAmount = Math.floor(Math.random() * (output.maxAmount - output.minAmount + 1) + output.minAmount) *
+                    progress.quantity;
+                // Apply skill bonus
+                let finalAmount = baseAmount;
+                if (output.bonusFromSkill && recipe.skillId) {
+                    const skill = this.playerSkills.get(recipe.skillId) ?? 0;
+                    finalAmount += Math.floor(skill * output.bonusFromSkill);
+                }
+                // Add to inventory
+                const current = this.playerInventory.get(output.itemId) ?? 0;
+                this.playerInventory.set(output.itemId, current + finalAmount);
+                outputs.push({ ...output, minAmount: finalAmount, maxAmount: finalAmount });
+            }
+        }
+        // Generate byproducts
+        if (recipe.byproducts) {
+            for (const byproduct of recipe.byproducts) {
+                if (Math.random() <= byproduct.chance) {
+                    const amount = Math.floor(Math.random() * (byproduct.maxAmount - byproduct.minAmount + 1) + byproduct.minAmount) * progress.quantity;
+                    const current = this.playerInventory.get(byproduct.itemId) ?? 0;
+                    this.playerInventory.set(byproduct.itemId, current + amount);
+                }
+            }
+        }
+        // Award experience
+        if (recipe.skillId && recipe.experienceGained > 0) {
+            const totalXp = recipe.experienceGained * progress.quantity;
+            this.onExperienceGained?.(recipe.skillId, totalXp);
+        }
+        this.activeProgress.delete(progressId);
+        this.onCraftingCompleted?.(recipe, outputs, quality);
+    }
+    determineQuality(recipe, playerId) {
+        const qualities = [
+            'poor',
+            'normal',
+            'fine',
+            'superior',
+            'masterwork',
+            'legendary',
+        ];
+        const baseIndex = qualities.indexOf(recipe.baseQuality);
+        let qualityScore = baseIndex;
+        for (const factor of recipe.qualityFactors) {
+            switch (factor.type) {
+                case 'skill':
+                    if (recipe.skillId) {
+                        const skill = this.playerSkills.get(recipe.skillId) ?? 0;
+                        qualityScore += (skill / 100) * factor.weight;
+                    }
+                    break;
+                case 'random':
+                    qualityScore += (Math.random() - 0.5) * factor.weight;
+                    break;
+            }
+        }
+        const finalIndex = Math.max(0, Math.min(qualities.length - 1, Math.round(qualityScore)));
+        return qualities[finalIndex];
+    }
+    pauseCrafting(progressId) {
+        const progress = this.activeProgress.get(progressId);
+        if (!progress || progress.isPaused) {
+            return false;
+        }
+        progress.isPaused = true;
+        progress.pausedAt = Date.now();
+        progress.accumulatedTime += progress.pausedAt - progress.startedAt;
+        return true;
+    }
+    resumeCrafting(progressId) {
+        const progress = this.activeProgress.get(progressId);
+        if (!progress || !progress.isPaused) {
+            return false;
+        }
+        const now = Date.now();
+        const remainingTime = progress.completesAt - progress.startedAt - progress.accumulatedTime;
+        progress.isPaused = false;
+        progress.startedAt = now;
+        progress.completesAt = now + remainingTime;
+        progress.pausedAt = undefined;
+        return true;
+    }
+    cancelCrafting(progressId, refundIngredients = false) {
+        const progress = this.activeProgress.get(progressId);
+        if (!progress) {
+            return false;
+        }
+        progress.cancelled = true;
+        if (refundIngredients) {
+            const recipe = this.recipes.get(progress.recipeId);
+            if (recipe) {
+                for (const ingredient of recipe.ingredients) {
+                    if (!ingredient.isConsumed) {
+                        continue;
+                    }
+                    const amount = ingredient.amount * progress.quantity;
+                    const current = this.playerInventory.get(ingredient.itemId) ?? 0;
+                    this.playerInventory.set(ingredient.itemId, current + amount);
+                }
+            }
+        }
+        this.activeProgress.delete(progressId);
+        return true;
+    }
+    // ─── Crafting Queue ────────────────────────────────────
+    addToQueue(playerId, recipeId, quantity, priority = 0) {
+        if (!this.craftingQueues.has(playerId)) {
+            this.craftingQueues.set(playerId, []);
+        }
+        const queue = this.craftingQueues.get(playerId);
+        queue.push({ recipeId, quantity, priority });
+        queue.sort((a, b) => b.priority - a.priority);
+        return true;
+    }
+    getQueue(playerId) {
+        return this.craftingQueues.get(playerId) ?? [];
+    }
+    processQueueItem(playerId) {
+        const queue = this.craftingQueues.get(playerId);
+        if (!queue || queue.length === 0) {
+            return null;
+        }
+        const item = queue.shift();
+        return this.startCrafting(item.recipeId, playerId, item.quantity);
+    }
+    // ─── Discovery ─────────────────────────────────────────
+    discoverRecipe(recipeId, playerId) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return false;
+        }
+        if (this.discoveredRecipes.has(recipeId)) {
+            return false;
+        }
+        this.discoveredRecipes.add(recipeId);
+        recipe.discoveredBy.add(playerId);
+        this.onRecipeDiscovered?.(recipe, playerId);
+        return true;
+    }
+    isRecipeDiscovered(recipeId) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return false;
+        }
+        if (recipe.discoveryMethod === 'known') {
+            return true;
+        }
+        return this.discoveredRecipes.has(recipeId);
+    }
+    // ─── Salvage ───────────────────────────────────────────
+    canSalvage(itemId, playerId) {
+        const rule = this.salvageRules.get(itemId);
+        if (!rule) {
+            return false;
+        }
+        if (rule.skillRequired) {
+            const skill = this.playerSkills.get('salvaging') ?? 0;
+            if (skill < rule.skillRequired) {
+                return false;
+            }
+        }
+        return true;
+    }
+    salvageItem(itemId, _playerId, quantity = 1) {
+        const rule = this.salvageRules.get(itemId);
+        if (!rule) {
+            return null;
+        }
+        // Consume items
+        const available = this.playerInventory.get(itemId) ?? 0;
+        if (available < quantity) {
+            return null;
+        }
+        this.playerInventory.set(itemId, available - quantity);
+        // Generate outputs
+        const outputs = [];
+        for (const output of rule.outputs) {
+            for (let i = 0; i < quantity; i++) {
+                if (Math.random() <= output.chance) {
+                    const amount = Math.floor(Math.random() * (output.maxAmount - output.minAmount + 1) + output.minAmount);
+                    const current = this.playerInventory.get(output.itemId) ?? 0;
+                    this.playerInventory.set(output.itemId, current + amount);
+                    outputs.push({ ...output, minAmount: amount, maxAmount: amount });
+                }
+            }
+        }
+        return outputs;
+    }
+    // ─── Player State ──────────────────────────────────────
+    setPlayerSkill(skillId, level) {
+        this.playerSkills.set(skillId, level);
+    }
+    setPlayerItem(itemId, count) {
+        this.playerInventory.set(itemId, count);
+    }
+    getPlayerInventory() {
+        return new Map(this.playerInventory);
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setOnRecipeDiscovered(callback) {
+        this.onRecipeDiscovered = callback;
+    }
+    setOnCraftingStarted(callback) {
+        this.onCraftingStarted = callback;
+    }
+    setOnCraftingProgress(callback) {
+        this.onCraftingProgress = callback;
+    }
+    setOnCraftingCompleted(callback) {
+        this.onCraftingCompleted = callback;
+    }
+    setOnCraftingFailed(callback) {
+        this.onCraftingFailed = callback;
+    }
+    setOnQualityDetermined(callback) {
+        this.onQualityDetermined = callback;
+    }
+    setOnExperienceGained(callback) {
+        this.onExperienceGained = callback;
+    }
+    // ─── Queries ───────────────────────────────────────────
+    getActiveProgress() {
+        return Array.from(this.activeProgress.values());
+    }
+    getProgressForPlayer(playerId) {
+        return this.getActiveProgress().filter((p) => p.playerId === playerId);
+    }
+    searchRecipes(query) {
+        const lowerQuery = query.toLowerCase();
+        return this.getAllRecipes().filter((r) => r.name.toLowerCase().includes(lowerQuery) ||
+            r.description.toLowerCase().includes(lowerQuery) ||
+            r.tags.some((t) => t.toLowerCase().includes(lowerQuery)));
+    }
+    getRecipesByTags(tags) {
+        return this.getAllRecipes().filter((r) => tags.some((t) => r.tags.includes(t)));
+    }
+    // ─── Serialization ─────────────────────────────────────
+    exportRecipes() {
+        const data = {
+            recipes: Array.from(this.recipes.entries()).map(([id, recipe]) => ({
+                ...recipe,
+                discoveredBy: Array.from(recipe.discoveredBy),
+            })),
+            stations: Array.from(this.stations.entries()),
+            chains: Array.from(this.chains.entries()),
+            salvageRules: Array.from(this.salvageRules.entries()),
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    importRecipes(json) {
+        try {
+            const data = JSON.parse(json);
+            this.recipes = new Map(data.recipes.map((r) => [
+                r.id,
+                { ...r, discoveredBy: new Set(r.discoveredBy) },
+            ]));
+            this.stations = new Map(data.stations);
+            this.chains = new Map(data.chains);
+            this.salvageRules = new Map(data.salvageRules);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    exportProgress() {
+        const data = {
+            activeProgress: Array.from(this.activeProgress.entries()),
+            craftingQueues: Array.from(this.craftingQueues.entries()),
+            discoveredRecipes: Array.from(this.discoveredRecipes),
+        };
+        return JSON.stringify(data);
+    }
+    importProgress(json) {
+        try {
+            const data = JSON.parse(json);
+            this.activeProgress = new Map(data.activeProgress);
+            this.craftingQueues = new Map(data.craftingQueues);
+            this.discoveredRecipes = new Set(data.discoveredRecipes);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ─── Graph Visualization ───────────────────────────────
+    getRecipeGraph(recipeId) {
+        const recipe = this.recipes.get(recipeId);
+        if (!recipe) {
+            return null;
+        }
+        const nodes = [];
+        const edges = [];
+        // Recipe node
+        nodes.push({
+            id: recipe.id,
+            type: 'recipe',
+            name: recipe.name,
+            x: 300,
+            y: 150,
+        });
+        // Ingredient nodes
+        let y = 50;
+        for (const ingredient of recipe.ingredients) {
+            nodes.push({
+                id: `ing_${ingredient.itemId}`,
+                type: 'ingredient',
+                name: ingredient.itemId,
+                amount: ingredient.amount,
+                x: 100,
+                y,
+            });
+            edges.push({
+                id: `edge_${ingredient.itemId}_${recipe.id}`,
+                from: `ing_${ingredient.itemId}`,
+                to: recipe.id,
+                type: ingredient.isConsumed ? 'consumed' : 'catalyst',
+            });
+            y += 60;
+        }
+        // Output nodes
+        y = 50;
+        for (const output of recipe.outputs) {
+            nodes.push({
+                id: `out_${output.itemId}`,
+                type: 'output',
+                name: output.itemId,
+                amount: output.minAmount === output.maxAmount
+                    ? output.minAmount
+                    : `${output.minAmount}-${output.maxAmount}`,
+                x: 500,
+                y,
+            });
+            edges.push({
+                id: `edge_${recipe.id}_${output.itemId}`,
+                from: recipe.id,
+                to: `out_${output.itemId}`,
+                type: 'produces',
+                chance: output.chance,
+            });
+            y += 60;
+        }
+        return { nodes, edges };
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createCraftingEditor() {
+    return new CraftingEditor();
+}
+function createIngredient(itemId, amount, isConsumed = true) {
+    return { itemId, amount, isConsumed };
+}
+function createOutput(itemId, amount, chance = 1) {
+    return { itemId, minAmount: amount, maxAmount: amount, chance };
+}
+
+exports.CraftingEditor = CraftingEditor;
+exports.createCraftingEditor = createCraftingEditor;
+exports.createIngredient = createIngredient;
+exports.createOutput = createOutput;
+//# sourceMappingURL=CraftingEditor.js.map