A!leys Galerie

// Ailey's Dynamic Crafting Studio - RPG Maker MZ Plugin Simulation
// Simulates a crafting system with dynamic recipes, random bonuses, and visual animations

const { join } = require('path');
const fs = require('fs').promises;

// Modern ES Modules setup for Node.js
const craftingSystem = (() => {
    // Plugin configuration
    const config = {
        recipeFolder: join(__dirname, 'crafting_recipes'),
        materialFolder: join(__dirname, 'crafting_materials'),
        outputFolder: join(__dirname, 'crafted_items'),
        animationStyles: ['sparkle', 'pulse', 'glow', 'shatter', 'melt'],
        bonusEffects: ['+10% Attack', '+5% Defense', 'Critical +5%', 'Elemental: Fire', 'Elemental: Ice'],
        defaultMaterialChances: [0.3, 0.5, 0.2] // For basic, advanced, rare materials
    };

    // Data structures
    let recipes = [];
    let materials = [];
    let craftedItems = [];

    // Initialize the system
    async function initialize() {
        try {
            await loadRecipes();
            await loadMaterials();
            console.log('Crafting System initialized successfully!');
        } catch (error) {
            console.error('Failed to initialize Crafting System:', error);
        }
    }

    // Load recipes from JSON files
    async function loadRecipes() {
        try {
            const files = await fs.readdir(config.recipeFolder);
            for (const file of files) {
                if (file.endsWith('.json')) {
                    const data = await fs.readFile(join(config.recipeFolder, file), 'utf8');
                    recipes.push(JSON.parse(data));
                }
            }
        } catch (error) {
            console.warn('No recipes found or error loading recipes:', error);
        }
    }

    // Load materials from JSON files
    async function loadMaterials() {
        try {
            const files = await fs.readdir(config.materialFolder);
            for (const file of files) {
                if (file.endsWith('.json')) {
                    const data = await fs.readFile(join(config.materialFolder, file), 'utf8');
                    materials.push(JSON.parse(data));
                }
            }
        } catch (error) {
            console.warn('No materials found or error loading materials:', error);
        }
    }

    // Craft an item with dynamic effects
    async function craftItem(recipeId, playerLevel, playerSkill) {
        const recipe = recipes.find(r => r.id === recipeId);
        if (!recipe) throw new Error('Recipe not found');

        // Find available materials with weighted chance
        const selectedMaterials = await selectMaterials(recipe.requiredMaterials, playerLevel, playerSkill);
        if (selectedMaterials.length < recipe.requiredMaterials.length) {
            throw new Error('Not enough materials to craft');
        }

        // Determine crafting success and quality
        const { success, quality, bonusEffect } = determineCraftingOutcome(playerLevel, playerSkill);

        // Generate crafted item with dynamic properties
        const craftedItem = {
            id: `crafted_${recipeId}_${Date.now()}`,
            name: `${recipe.name} (Quality: ${quality})`,
            baseItem: recipe.baseItem,
            quality,
            bonusEffect,
            animation: getRandomAnimation(),
            materials: selectedMaterials
        };

        // Save the crafted item (simulate in memory)
        craftedItems.push(craftedItem);

        // Simulate saving to output folder
        try {
            await fs.writeFile(
                join(config.outputFolder, craftedItem.id + '.json'),
                JSON.stringify(craftedItem, null, 2)
            );
            console.log(`Successfully crafted ${craftedItem.name} with ${bonusEffect}!`);
        } catch (error) {
            console.warn('Could not save crafted item:', error);
        }

        return craftedItem;
    }

    // Select materials with dynamic probabilities
    async function selectMaterials(requiredMaterials, playerLevel, playerSkill) {
        const selected = [];

        for (const material of requiredMaterials) {
            // Find all materials that match the required type
            const matchingMaterials = materials.filter(m =>
                m.type === material.type && m.level <= playerLevel
            );

            if (matchingMaterials.length === 0) {
                console.warn(`No materials found for type: ${material.type}`);
                continue;
            }

            // Calculate weights based on material rarity and player skill
            const weights = matchingMaterials.map(m => {
                // Base chance + skill bonus + level bonus
                let baseChance = config.defaultMaterialChances[m.rarity];
                baseChance += (playerSkill * 0.05); // 5% per skill point
                baseChance += (playerLevel * 0.01); // 1% per level
                return Math.max(0.01, baseChance);
            });

            // Normalize weights
            const totalWeight = weights.reduce((a, b) => a + b, 0);
            const normalizedWeights = weights.map(w => w / totalWeight);

            // Select one material using weighted probability
            const randomIndex = getWeightedRandomIndex(normalizedWeights);
            selected.push(matchingMaterials[randomIndex]);
        }

        return selected;
    }

    // Determine crafting success and quality
    function determineCraftingOutcome(playerLevel, playerSkill) {
        // Base success chance (improves with level and skill)
        const baseSuccess = 0.7 + (playerLevel * 0.02) + (playerSkill * 0.1);
        const success = Math.random() < baseSuccess;

        // Quality and bonus effect based on success and randomness
        if (success) {
            const qualityRoll = Math.random();
            let quality, bonusEffect;

            if (qualityRoll < 0.3) {
                quality = 'Rare';
                bonusEffect = getRandomBonusEffect('rare');
            } else if (qualityRoll < 0.7) {
                quality = 'Good';
                bonusEffect = getRandomBonusEffect('common');
            } else {
                quality = 'Normal';
                bonusEffect = getRandomBonusEffect('normal');
            }

            return { success: true, quality, bonusEffect };
        } else {
            return { success: false, quality: 'Failed', bonusEffect: 'None' };
        }
    }

    // Get random bonus effect with tiered probability
    function getRandomBonusEffect(tier = 'common') {
        const allEffects = [...config.bonusEffects];
        const effectIndices = [0, 1, 2, 3, 4]; // Base indices for common

        if (tier === 'rare') {
            effectIndices.push(3, 4); // Higher chance for good effects
        } else if (tier === 'normal') {
            effectIndices.push(0, 1); // Slightly more common effects
        }

        // Remove duplicates and get a random one
        const uniqueIndices = [...new Set(effectIndices)];
        return allEffects[getRandomIndex(uniqueIndices)];
    }

    // Helper function to get random index from weighted array
    function getWeightedRandomIndex(weights) {
        let random = Math.random() * weights.reduce((a, b) => a + b, 0);
        let total = 0;
        for (let i = 0; i < weights.length; i++) {
            total += weights[i];
            if (random <= total) {
                return i;
            }
        }
        return weights.length - 1;
    }

    // Get random index from array
    function getRandomIndex(array) {
        return Math.floor(Math.random() * array.length);
    }

    // Get random animation style
    function getRandomAnimation() {
        return config.animationStyles[getRandomIndex(config.animationStyles)];
    }

    // Generate a sample recipe for testing
    async function generateSampleRecipe() {
        const sampleRecipe = {
            id: 'sample_recipe_001',
            name: 'Mystic Robe',
            description: 'A robe crafted with mystical materials that enhances your spiritual abilities.',
            baseItem: 'Clothes',
            requiredMaterials: [
                { type: 'mystic_thread', amount: 3 },
                { type: 'arcane_fabric', amount: 2 },
                { type: 'spiritual_crystal', amount: 1 }
            ],
            baseStats: {
                attack: 5,
                defense: 10,
                magic: 15,
                agility: 5
            },
            requiredLevel: 5,
            requiredSkill: 3
        };

        try {
            await fs.writeFile(
                join(config.recipeFolder, 'sample_recipe.json'),
                JSON.stringify(sampleRecipe, null, 2)
            );
            console.log('Generated sample recipe successfully!');
        } catch (error) {
            console.error('Could not generate sample recipe:', error);
        }
    }

    // Generate a sample material for testing
    async function generateSampleMaterial() {
        const sampleMaterial = {
            id: 'sample_material_001',
            name: 'Mystic Thread',
            type: 'mystic_thread',
            description: 'A thread woven from mystical energy that grants spiritual bonuses.',
            level: 5,
            rarity: 1, // 0 = common, 1 = uncommon, 2 = rare
            stats: {
                magic: 3,
                luck: 2
            },
            craftingValue: 20
        };

        try {
            await fs.writeFile(
                join(config.materialFolder, 'sample_material.json'),
                JSON.stringify(sampleMaterial, null, 2)
            );
            console.log('Generated sample material successfully!');
        } catch (error) {
            console.error('Could not generate sample material:', error);
        }
    }

    // Create necessary directories if they don't exist
    async function ensureDirectories() {
        try {
            await fs.mkdir(config.recipeFolder, { recursive: true });
            await fs.mkdir(config.materialFolder, { recursive: true });
            await fs.mkdir(config.outputFolder, { recursive: true });
        } catch (error) {
            if (error.code !== 'EEXIST') {
                console.error('Error creating directories:', error);
            }
        }
    }

    return {
        initialize,
        craftItem,
        generateSampleRecipe,
        generateSampleMaterial,
        ensureDirectories,
        getRecipes: () => recipes,
        getMaterials: () => materials,
        getCraftedItems: () => craftedItems
    };
})();

// Main execution
(async () => {
    try {
        console.log('=== Ailey\'s Dynamic Crafting Studio ===');
        console.log('Initializing crafting system...');

        // Ensure directories exist
        await craftingSystem.ensureDirectories();

        // Generate sample data if folders are empty
        if ((await fs.readdir(craftingSystem.config.recipeFolder)).length === 0) {
            console.log('No recipes found. Generating sample data...');
            await craftingSystem.generateSampleRecipe();
        }

        if ((await fs.readdir(craftingSystem.config.materialFolder)).length === 0) {
            console.log('No materials found. Generating sample data...');
            await craftingSystem.generateSampleMaterial();
        }

        // Initialize the system
        await craftingSystem.initialize();

        // Display available recipes and materials
        console.log('\nAvailable Recipes:');
        craftingSystem.getRecipes().forEach(recipe => {
            console.log(`- ${recipe.name} (Level ${recipe.requiredLevel}, Skill ${recipe.requiredSkill})`);
        });

        console.log('\nAvailable Materials:');
        craftingSystem.getMaterials().forEach(material => {
            console.log(`- ${material.name} (Type: ${material.type}, Rarity: ${['Common', 'Uncommon', 'Rare'][material.rarity]})`);
        });

        // Example crafting process
        console.log('\n=== Starting Crafting Simulation ===');
        const playerLevel = 10;
        const playerSkill = 5;

        // Try to craft the sample recipe
        const result = await craftingSystem.craftItem('sample_recipe_001', playerLevel, playerSkill);
        if (result) {
            console.log('\nCrafted Item Details:');
            console.log(`- Name: ${result.name}`);
            console.log(`- Base Item: ${result.baseItem}`);
            console.log(`- Quality: ${result.quality}`);
            console.log(`- Bonus Effect: ${result.bonusEffect}`);
            console.log(`- Animation: ${result.animation}`);
            console.log(`- Materials Used:`);
            result.materials.forEach(material => {
                console.log(`  - ${material.name} (${material.description})`);
            });
        }

        // Show all crafted items
        console.log('\nAll Crafted Items:');
        craftingSystem.getCraftedItems().forEach(item => {
            console.log(`- ${item.name}`);
        });

    } catch (error) {
        console.error('Error in Crafting System:', error);
    } finally {
        console.log('\n=== Crafting Simulation Complete ===');
    }
})();