A!leys Galerie

// ==========================================================================
// DYNAMIC SKILL TREE GENERATOR FOR RPG MAKER MZ
// ==========================================================================
// Authors: Ailey (KI) & RPG Maker Community
// Version: 1.0.0
// Description: Generates adaptive, evolutionary skill trees with real-time adjustments
// to character stats. Designed as a standalone Node.js script for development
// and testing, with full RPG Maker MZ plugin compatibility structure.

// ==========================================================================
// MODULE IMPORTS
// ==========================================================================
const fs = require('fs');
const path = require('path');
const { v4: uuidv4 } = require('uuid');

// ==========================================================================
// CORE PLUGIN STRUCTURE
// ==========================================================================
class DynamicSkillTree {
  constructor(game, pluginName) {
    this.game = game;
    this.pluginName = pluginName;
    this.skillTrees = new Map();
    this.dependencies = [];
    this.evolutionTriggers = new Map();
    this._initializePlugin();
  }

  _initializePlugin() {
    this.game.PluginManager.add(this.pluginName, this);
    this._setupEventListeners();
    this._generateBaseSkillTrees();
  }

  _setupEventListeners() {
    this.game._SceneManager.on('SceneStart', () => this._updateActiveTrees());
  }

  _generateBaseSkillTrees() {
    // Example: Generate 3 base skill trees (Fighter, Mage, Rogue)
    ['Fighter', 'Mage', 'Rogue'].forEach(treeName => {
      const tree = this._createBaseTree(treeName);
      this.skillTrees.set(treeName, tree);
    });
  }

  _createBaseTree(name) {
    const tree = {
      id: uuidv4(),
      name,
      description: `Base ${name} skill tree`,
      nodes: this._generateBaseNodes(name),
      depth: 3,
      evolutionPath: [],
      unlocked: false,
      levelRequirements: { level: 5, stat: 'str' }
    };
    return tree;
  }

  _generateBaseNodes(treeName) {
    const nodes = [];
    const maxDepth = 3;
    const branches = ['Basic', 'Advanced', 'Expert'];

    branches.forEach((branch, branchIndex) => {
      const baseNodes = this._generateBranchNodes(branch, branchIndex, maxDepth);
      nodes.push(...baseNodes);
    });

    return nodes;
  }

  _generateBranchNodes(branch, branchIndex, maxDepth) {
    const nodes = [];
    for (let i = 1; i <= maxDepth; i++) {
      const level = i;
      const requiredPrevious = level > 1 ? `Level ${level - 1}` : null;

      nodes.push({
        id: uuidv4(),
        name: `${branch} ${level}`,
        description: `Level ${level} ${branch} technique`,
        treeName: branch,
        level: level,
        depth: i,
        cost: { xp: 100 * i, stat: 'str' },
        effect: this._generateSkillEffect(branch, level),
        requirements: requiredPrevious ? { previous: requiredPrevious } : { level: 5 },
        unlocked: false,
        children: []
      });
    }
    return nodes;
  }

  _generateSkillEffect(branch, level) {
    const effects = {
      Basic: ['Attack +5%', 'Defense +3%', 'Accuracy +5%'],
      Advanced: ['Critical Hit +10%', 'Elemental Damage +15%', 'Evasion +8%'],
      Expert: ['Ultimate Technique: Elemental Overload', 'Skill Cooldown -20%', 'Combo Damage +30%']
    };
    return effects[branch][level - 1];
  }

  generateEvolutionPath(actorData) {
    const { level, stats } = actorData;
    const evolutionPath = [];

    // Dynamic evolution based on stat distribution
    if (stats.str > stats.dex && stats.str > stats.int) {
      evolutionPath.push({
        name: 'Berserker Path',
        effect: 'Increase melee damage by 20% and reduce defense by 10%',
        threshold: { str: 30, level: 20 }
      });
    } else if (stats.dex > stats.str && stats.dex > stats.int) {
      evolutionPath.push({
        name: 'Ninja Path',
        effect: 'Increase critical hit rate by 15% and add stealth ability',
        threshold: { dex: 30, level: 18 }
      });
    } else {
      evolutionPath.push({
        name: 'Balanced Path',
        effect: 'Increase all stats by 10% and grant a universal skill',
        threshold: { level: 15 }
      });
    }

    // Add secondary evolution based on class
    if (this.skillTrees.get('Mage').evolutionPath.length > 0) {
      evolutionPath.push({
        name: 'Arcane Mastery',
        effect: 'Unlock advanced elemental spells and reduce MP cost by 15%',
        threshold: { int: 25, level: 12 }
      });
    }

    return evolutionPath;
  }

  unlockTree(treeName, actorData) {
    const tree = this.skillTrees.get(treeName);
    if (!tree) return false;

    if (actorData.level >= tree.levelRequirements.level &&
        actorData.stats[tree.levelRequirements.stat] >= tree.levelRequirements.stat) {
      tree.unlocked = true;
      this._updateNodeUnlocks(tree);
      this._generateEvolutionPath(tree, actorData);
      return true;
    }
    return false;
  }

  _updateNodeUnlocks(tree) {
    tree.nodes.forEach(node => {
      if (node.requirements.previous) {
        const previousNode = tree.nodes.find(n => n.name === node.requirements.previous);
        node.unlocked = previousNode ? previousNode.unlocked : false;
      } else {
        node.unlocked = true;
      }
    });
  }

  _generateEvolutionPath(tree, actorData) {
    tree.evolutionPath = this.generateEvolutionPath(actorData);
  }

  _updateActiveTrees() {
    const actor = this.game.actors ? this.game.actors[0] : null;
    if (actor) {
      this.skillTrees.forEach((tree, name) => {
        if (!tree.unlocked) this.unlockTree(name, actor);
      });
    }
  }

  exportPluginData() {
    const pluginData = {
      name: this.pluginName,
      skillTrees: Array.from(this.skillTrees.values()),
      evolutionTriggers: Array.from(this.evolutionTriggers.values())
    };
    const pluginDir = path.join(__dirname, 'plugins');
    if (!fs.existsSync(pluginDir)) fs.mkdirSync(pluginDir);
    fs.writeFileSync(
      path.join(pluginDir, `${this.pluginName}.json`),
      JSON.stringify(pluginData, null, 2)
    );
    console.log(`Plugin data exported to ${path.join(pluginDir, `${this.pluginName}.json`)}`);
    return pluginData;
  }

  importPluginData(data) {
    this.skillTrees = new Map(data.skillTrees.map(tree => [tree.name, tree]));
    this.evolutionTriggers = new Map(data.evolutionTriggers.map(trigger => [trigger.name, trigger]));
    console.log(`Plugin data imported: ${data.skillTrees.length} skill trees loaded`);
  }
}

// ==========================================================================
// TESTING INTERFACE (NODE.JS COMPATIBLE)
// ==========================================================================
if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'production') {
  class MockGame {
    constructor() {
      this.PluginManager = {
        add: (name, plugin) => console.log(`Plugin registered: ${name}`),
        plugins: new Map()
      };
      this._SceneManager = {
        on: (event, callback) => {
          if (event === 'SceneStart') callback();
        }
      };
      this.actors = [{
        level: 15,
        stats: { str: 30, dex: 15, int: 20 }
      }];
    }
  }

  const game = new MockGame();
  const plugin = new DynamicSkillTree(game, 'DynamicSkillTreeGenerator');

  // Export sample data for testing
  plugin.exportPluginData();

  // Test unlocking trees
  console.log('Unlocking Fighter tree:', plugin.unlockTree('Fighter', game.actors[0]));

  // Test evolution path generation
  console.log('Evolution path:', plugin.generateEvolutionPath(game.actors[0]));
}

// ==========================================================================
// EXPORT FOR RPG MAKER MZ INTEGRATION
// ==========================================================================
if (typeof window !== 'undefined' && window.PluginManager) {
  window.PluginManager.registerPlugin({
    name: 'DynamicSkillTreeGenerator',
    version: '1.0.0',
    description: 'Generates adaptive, evolutionary skill trees with real-time adjustments',
    author: 'Ailey (KI) & RPG Maker Community',
    plugin: DynamicSkillTree
  });
}

// ==========================================================================
// END OF FILE
// ==========================================================================

// DynamicRPGInventoryEnhancer.js
// A creative inventory generator for RPG Maker MZ with randomized loot tables, rarity tiers, and visual metadata

const fs = require('fs');
const path = require('path');
const { v4: uuidv4 } = require('uuid');

class InventoryGenerator {
    constructor() {
        this.lootPools = {
            common: ['Rusty Sword', 'Leather Armor', 'Potion', 'Elixir'],
            uncommon: ['Iron Sword', 'Chainmail', 'Mana Potion', ' antidote'],
            rare: ['Silver Dagger', 'Scale Mail', 'Ether Tonic'],
            legendary: ['Mithril Greatsword', 'Plate Armor', 'Phantom Potion'],
            unique: ['Dragon Scale', 'Mystic Robe', 'Eternal Elixir']
        };

        this.rarityWeights = {
            common: 60,
            uncommon: 30,
            rare: 8,
            legendary: 1.5,
            unique: 0.5
        };

        this.visualAttributes = {
            colors: ['#FF5733', '#33FF57', '#3357FF', '#F3FF33', '#FF33F3'],
            shapes: ['square', 'circle', 'triangle', 'diamond', 'star'],
            effects: ['glow', 'pulse', 'shimmer', 'flicker', 'static']
        };

        this.itemDatabase = [];
        this.miscDatabase = {
            skills: [],
            weapons: [],
            armors: [],
            consumables: [],
            special: []
        };
    }

    generateRandomItem() {
        const rarity = this.getRandomRarity();
        const baseItem = this.getRandomItemFromPool(rarity);
        const visualStyle = this.getRandomVisualStyle();

        return {
            id: uuidv4(),
            name: this.enhanceItemName(baseItem, rarity),
            rarity: rarity,
            value: this.calculateValue(rarity),
            description: this.generateDescription(baseItem, rarity),
            visual: {
                color: visualStyle.color,
                shape: visualStyle.shape,
                effect: visualStyle.effect,
                sprite: this.generateSpriteName(rarity)
            },
            type: this.determineItemType(baseItem),
            stats: this.generateStats(rarity, baseItem),
            lootTable: {
                chance: this.getRarityChance(rarity),
                minLevel: this.getMinLevel(rarity),
                maxLevel: this.getMaxLevel(rarity)
            }
        };
    }

    getRandomRarity() {
        const weights = Object.values(this.rarityWeights);
        const total = weights.reduce((a, b) => a + b, 0);
        const rand = Math.random() * total;
        let cumulative = 0;

        for (const [rarity, weight] of Object.entries(this.rarityWeights)) {
            cumulative += weight;
            if (rand < cumulative) {
                return rarity;
            }
        }
        return 'common';
    }

    getRandomItemFromPool(rarity) {
        return this.lootPools[rarity][Math.floor(Math.random() * this.lootPools[rarity].length)];
    }

    getRandomVisualStyle() {
        return {
            color: this.visualAttributes.colors[Math.floor(Math.random() * this.visualAttributes.colors.length)],
            shape: this.visualAttributes.shapes[Math.floor(Math.random() * this.visualAttributes.shapes.length)],
            effect: this.visualAttributes.effects[Math.floor(Math.random() * this.visualAttributes.effects.length)]
        };
    }

    enhanceItemName(baseName, rarity) {
        const enhancements = {
            common: ['', 'Simple ', 'Rough '],
            uncommon: ['Enchanted ', 'Reinforced ', 'Rare '],
            rare: ['Ancient ', 'Mystic ', 'Legendary '],
            legendary: ['Epic ', 'Divine ', 'Mythic '],
            unique: ['Unique ', 'Exotic ', 'Eternal ']
        };

        const suffixes = {
            common: ['', ' of the Land'],
            uncommon: [' of Power', ' of Strength'],
            rare: [' of Wisdom', ' of the Elements'],
            legendary: [' of Legend', ' of the Gods'],
            unique: [' of Destiny', ' of the Void']
        };

        const prefix = enhancements[rarity][Math.floor(Math.random() * enhancements[rarity].length)];
        const suffix = suffixes[rarity][Math.floor(Math.random() * suffixes[rarity].length)];

        return `${prefix}${baseName}${suffix}`;
    }

    calculateValue(rarity) {
        const baseValues = { common: 10, uncommon: 50, rare: 200, legendary: 1000, unique: 5000 };
        return baseValues[rarity] * (1 + (Math.random() * 0.5));
    }

    generateDescription(baseItem, rarity) {
        const descriptors = {
            common: ['a simple weapon', 'a basic tool', 'a common item'],
            uncommon: ['an enchanted artifact', 'a powerful weapon', 'a rare treasure'],
            rare: ['an ancient relic', 'a mystical item', 'a legendary artifact'],
            legendary: ['a divine weapon', 'a godly item', 'an epic treasure'],
            unique: ['a unique artifact', 'a void-infused item', 'a destiny-bound treasure']
        };

        const effects = {
            common: ['has basic properties', 'works as expected', 'is functional'],
            uncommon: ['has magical properties', 'grants bonus stats', 'enhances abilities'],
            rare: ['has ancient properties', 'grants significant bonuses', 'unlocks special abilities'],
            legendary: ['has divine properties', 'grants massive bonuses', 'is legendary in power'],
            unique: ['has void properties', 'is one-of-a-kind', 'defies all known laws']
        };

        const first = descriptors[rarity][Math.floor(Math.random() * descriptors[rarity].length)];
        const second = effects[rarity][Math.floor(Math.random() * effects[rarity].length)];

        return `${first}. ${second}.`;
    }

    generateSpriteName(rarity) {
        return `Items/${rarity.charAt(0).toUpperCase() + rarity.slice(1)}/${this.itemDatabase.length + 1}.png`;
    }

    determineItemType(baseItem) {
        if (baseItem.includes('Sword') || baseItem.includes('Dagger') || baseItem.includes('Greatsword')) {
            return 'weapon';
        } else if (baseItem.includes('Armor') || baseItem.includes('Mail') || baseItem.includes('Robe')) {
            return 'armor';
        } else if (baseItem.includes('Potion') || baseItem.includes('Elixir') || baseItem.includes('Tonic')) {
            return 'consumable';
        } else {
            return 'special';
        }
    }

    generateStats(rarity, baseItem) {
        const baseStats = {
            weapon: { attack: 5, defense: 0, magic: 0 },
            armor: { attack: 0, defense: 5, magic: 0 },
            consumable: { attack: 0, defense: 0, magic: 5 }
        };

        const rarityMultipliers = {
            common: 1,
            uncommon: 1.5,
            rare: 2.5,
            legendary: 4,
            unique: 10
        };

        const stats = { ...baseStats[this.determineItemType(baseItem)] };
        Object.keys(stats).forEach(key => {
            stats[key] = Math.floor(stats[key] * rarityMultipliers[rarity] * (1 + Math.random() * 0.3));
        });

        return stats;
    }

    getRarityChance(rarity) {
        return (this.rarityWeights[rarity] / Object.values(this.rarityWeights).reduce((a, b) => a + b, 0)) * 100;
    }

    getMinLevel(rarity) {
        const levels = { common: 1, uncommon: 3, rare: 6, legendary: 10, unique: 15 };
        return levels[rarity];
    }

    getMaxLevel(rarity) {
        const levels = { common: 5, uncommon: 8, rare: 12, legendary: 20, unique: 50 };
        return levels[rarity];
    }

    generateInventory(quantity) {
        for (let i = 0; i < quantity; i++) {
            const item = this.generateRandomItem();
            this.itemDatabase.push(item);
            this.miscDatabase[item.type].push(item);
        }
        return this.itemDatabase;
    }

    saveToFile(filename) {
        const data = {
            items: this.itemDatabase,
            metadata: {
                generatedAt: new Date().toISOString(),
                version: '1.0.0',
                description: 'Dynamically generated RPG Maker MZ inventory with enhanced visual and statistical properties'
            },
            lootTables: this.miscDatabase
        };

        const outputPath = path.join(__dirname, filename || 'inventory_data.json');
        fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
        console.log(`Inventory data saved to ${outputPath}`);
        return outputPath;
    }
}

// Main execution
const generator = new InventoryGenerator();
const inventorySize = process.argv[2] ? parseInt(process.argv[2]) : 20; // Default to 20 items if no argument provided

// Generate and save inventory
const generatedInventory = generator.generateInventory(inventorySize);
generator.saveToFile('generated_inventory.json');

// Optional: Export as RPG Maker MZ JSONL format
const rpgMakerData = generatedInventory.map(item => ({
    name: item.name,
    description: item.description,
    iconIndex: parseInt(item.visual.sprite.split('.')[0].split('/')[2]) - 1,
    value: item.value,
    price: Math.floor(item.value * 0.8),
    type: item.type,
    meta: {
        rarity: item.rarity,
        stats: item.stats,
        lootTable: item.lootTable
    }
}));

fs.writeFileSync('rpg_maker_inventory.jsonl', JSON.stringify(rpgMakerData, null, 2));
console.log('RPG Maker compatible inventory saved to rpg_maker_inventory.jsonl');

#!/usr/bin/env node
import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';
import { marked } from 'marked';
import * as jsp from 'jsprism';
import * as themeGenerator from 'color-theme-generator';
import * as chrome from 'google-translate-api';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

// Generate a dynamic color theme based on text content sentiment
const generateTheme = async (content) => {
  const sentiment = await chrome.translate(content, { to: 'en', format: 'text' }).then(res => {
    const score = res.detectedLanguage?.confidence || 0;
    return Math.min(1, Math.max(0, score - 0.5)); // Normalize to 0-1
  }).catch(() => 0.5); // Fallback to neutral

  const theme = themeGenerator.generate(sentiment);
  return {
    primary: theme[0],
    secondary: theme[1],
    background: theme[2],
    text: theme[3],
    highlight: theme[4]
  };
};

// Custom marked renderer with interactive hover effects
const renderer = new marked.Renderer();
renderer.heading = (text, level) => {
  const id = text.toLowerCase().replace(/[^\w]+/g, '-');
  return `<h${level} class="dynamic-heading" data-id="${id}" style="--level:${level}">` +
         `<span class="hover-pulse">${text}</span>` +
         `<div class="hover-expand" style="--bg:#{theme.primary}">${text}</div>` +
         `</h${level}>`;
};

// Main conversion function with theme generation
export const convert = async (markdownPath, outputPath) => {
  try {
    const markdown = await fs.readFile(markdownPath, 'utf8');
    const theme = await generateTheme(markdown);

    const html = marked(markdown, {
      renderer,
      smartypants: true,
      highlight: (code, lang) => jsp.highlight(code, lang, theme.highlight)
    });

    const styledHtml = `
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Markdown Synth Theme</title>
  <style>
    :root {
      --primary: ${theme.primary};
      --secondary: ${theme.secondary};
      --bg: ${theme.background};
      --text: ${theme.text};
      --highlight: ${theme.highlight};
    }
    body {
      font-family: 'Fira Code', 'Fira Sans', system-ui, sans-serif;
      background: var(--bg);
      color: var(--text);
      line-height: 1.6;
      margin: 0;
      padding: 2rem;
      transition: background 0.5s, color 0.5s;
    }
    a {
      color: var(--primary);
      text-decoration: none;
      transition: color 0.3s;
    }
    a:hover {
      color: var(--secondary);
    }
    pre {
      background: var(--secondary) !important;
      border-radius: 0.5rem;
      padding: 1rem;
    }
    code {
      font-family: 'Fira Code', monospace;
      background: rgba(255, 255, 255, 0.1);
      padding: 0.2rem 0.4rem;
      border-radius: 0.2rem;
    }
    .dynamic-heading {
      position: relative;
      padding-bottom: 0.5rem;
    }
    .dynamic-heading .hover-pulse {
      transition: transform 0.3s;
    }
    .dynamic-heading:hover .hover-pulse {
      transform: scale(1.05);
    }
    .hover-expand {
      position: absolute;
      bottom: calc(-1 * var(--level) * 0.5rem);
      left: 0;
      right: 0;
      height: 1px;
      background: var(--primary);
      transition: bottom 0.3s, opacity 0.3s;
    }
    .dynamic-heading:hover .hover-expand {
      opacity: 1;
      bottom: 0;
    }
  </style>
</head>
<body>
  ${html}
  <script>
    // Add interactive color shifting on hover
    document.querySelectorAll('.dynamic-heading').forEach(el => {
      el.addEventListener('mouseenter', () => {
        el.style.setProperty('--primary', 'hsl(${Math.random() * 30 + 200}, 80%, 50%)');
      });
    });
  </script>
</body>
</html>
    `;

    await fs.writeFile(outputPath, styledHtml);
    console.log(`Conversion complete: ${outputPath}`);
  } catch (err) {
    console.error('Conversion failed:', err);
    process.exit(1);
  }
};

// CLI interface
if (process.argv[2]) {
  const input = path.resolve(process.argv[2]);
  const output = path.resolve(process.argv[3] || 'output.html');

  if (!fs.existsSync(input)) {
    console.error('Input file not found');
    process.exit(1);
  }

  convert(input, output).catch(console.error);
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Interactive Colorful Galaxy</title>
    <style>
        body {
            margin: 0;
            overflow: hidden;
            background: #000;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Arial', sans-serif;
        }
        canvas {
            display: block;
        }
        .instructions {
            position: absolute;
            bottom: 20px;
            color: #fff;
            text-shadow: 0 0 5px #00ffff;
            font-size: 16px;
        }
    </style>
</head>
<body>
    <div class="instructions">Move your mouse to interact with the galaxy particles</div>
    <canvas id="galaxyCanvas"></canvas>

    <script>
        // Canvas setup
        const canvas = document.getElementById('galaxyCanvas');
        const ctx = canvas.getContext('2d');

        // Set canvas to full window size
        canvas.width = window.innerWidth;
        canvas.height = window.innerHeight;

        // Mouse position tracking
        const mouse = {
            x: canvas.width / 2,
            y: canvas.height / 2
        };

        // Particle class
        class Particle {
            constructor() {
                this.x = Math.random() * canvas.width;
                this.y = Math.random() * canvas.height;
                this.size = Math.random() * 3 + 1;
                this.baseColor = `hsl(${Math.random() * 360}, 70%, 50%)`;
                this.color = this.baseColor;
                this.baseSize = this.size;
                this.speed = {
                    x: (Math.random() - 0.5) * 0.5,
                    y: (Math.random() - 0.5) * 0.5
                };
                this.acceleration = 0;
                this.maxSpeed = 1;
                this.lifetime = Math.random() * 100 + 100;
                this.decay = Math.random() * 0.01 + 0.005;
                this.brightness = 0.5 + Math.random() * 0.5;
                this.isActive = true;
                this.twinkle = Math.random() > 0.7;
                this.twinkleInterval = Math.random() * 1000 + 500;
                this.twinkleTimer = 0;
            }

            update(mouseX, mouseY) {
                if (!this.isActive) return;

                // Calculate distance to mouse
                const dx = mouseX - this.x;
                const dy = mouseY - this.y;
                const distance = Math.sqrt(dx * dx + dy * dy);

                // If particle is close to mouse, make it accelerate towards it
                if (distance < 200) {
                    this.acceleration = (200 - distance) / 200;
                } else {
                    this.acceleration = 0;
                }

                // Apply acceleration to speed
                this.speed.x += dx * this.acceleration * 0.001;
                this.speed.y += dy * this.acceleration * 0.001;

                // Limit speed
                const speed = Math.sqrt(this.speed.x * this.speed.x + this.speed.y * this.speed.y);
                if (speed > this.maxSpeed) {
                    this.speed.x = this.speed.x / speed * this.maxSpeed;
                    this.speed.y = this.speed.y / speed * this.maxSpeed;
                }

                // Update position
                this.x += this.speed.x;
                this.y += this.speed.y;

                // Boundary checks
                if (this.x < 0 || this.x > canvas.width) this.speed.x *= -1;
                if (this.y < 0 || this.y > canvas.height) this.speed.y *= -1;

                // Update lifetime
                this.lifetime -= this.decay;

                // Twinkle effect
                if (this.twinkle) {
                    this.twinkleTimer += 16; // Using approximate frame time
                    if (this.twinkleTimer > this.twinkleInterval) {
                        this.twinkleTimer = 0;
                        this.size = this.baseSize * (0.5 + Math.random());
                        this.brightness = 0.2 + Math.random() * 0.8;
                    }
                } else {
                    this.size = this.baseSize;
                }

                // Deactivate when lifetime is over
                if (this.lifetime <= 0) {
                    this.isActive = false;
                }
            }

            draw() {
                if (!this.isActive) return;

                // Save context state
                ctx.save();

                // Set color and size
                ctx.fillStyle = this.color;
                ctx.strokeStyle = `hsla(${Math.floor(hueToHSL(this.color) * 30 + 150)}, 100%, 80%, 0.5)`;
                ctx.lineWidth = 0.5;

                // Draw gradient for glow effect
                const gradient = ctx.createRadialGradient(this.x, this.y, 0, this.x, this.y, this.size * 2);
                gradient.addColorStop(0, `hsla(${hueToHSL(this.color)}, 80%, ${this.brightness * 60 + 30}%, ${this.brightness})`);
                gradient.addColorStop(1, `hsla(${hueToHSL(this.color)}, 80%, ${this.brightness * 60 + 20}%, 0)`);
                ctx.fillStyle = gradient;

                // Draw particle
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
                ctx.fill();
                ctx.stroke();

                // Restore context state
                ctx.restore();
            }
        }

        // Helper function to extract hue from HSL color string
        function hueToHSL(color) {
            const regex = /hsl\((\d+),/;
            const match = color.match(regex);
            return match ? parseInt(match[1]) : 0;
        }

        // Particle system
        class ParticleSystem {
            constructor() {
                this.particles = [];
                this.particleCount = 200;
                this.lastTime = 0;
                this.mouseTrailLength = 0;
                this.mouseTrail = [];
                this.creationInterval = 1000 / 30; // Create 30 particles per second
                this.lastCreationTime = 0;
            }

            init() {
                // Create initial particles
                for (let i = 0; i < this.particleCount; i++) {
                    this.particles.push(new Particle());
                }
            }

            update(mouseX, mouseY, time) {
                // Add mouse position to trail
                this.mouseTrail.push({x: mouseX, y: mouseY});
                if (this.mouseTrail.length > 20) {
                    this.mouseTrail.shift();
                }

                // Create new particles if it's time
                if (time - this.lastCreationTime > this.creationInterval) {
                    for (let i = 0; i < 3; i++) {
                        this.particles.push(new Particle());
                    }
                    this.lastCreationTime = time;
                }

                // Update all particles
                for (let i = 0; i < this.particles.length; i++) {
                    if (this.particles[i].isActive) {
                        this.particles[i].update(mouseX, mouseY);
                    }
                }

                // Update mouse trail particles (larger particles that follow mouse)
                if (this.mouseTrail.length > 0) {
                    const trailParticle = this.particles.find(p => p.trailParticle);
                    if (trailParticle) {
                        trailParticle.x = this.mouseTrail[this.mouseTrail.length - 1].x;
                        trailParticle.y = this.mouseTrail[this.mouseTrail.length - 1].y;
                        trailParticle.size = 3 + Math.sin(time * 0.002) * 2;
                        trailParticle.brightness = 0.7 + Math.sin(time * 0.001) * 0.3;
                        trailParticle.color = `hsl(${Math.sin(time * 0.001) * 60 + 150}, 100%, 50%)`;
                    }
                }
            }

            draw() {
                // Clear canvas
                ctx.clearRect(0, 0, canvas.width, canvas.height);

                // Draw starfield in background
                this.drawStarfield();

                // Draw all particles
                for (let i = 0; i < this.particles.length; i++) {
                    this.particles[i].draw();
                }

                // Draw mouse trail
                if (this.mouseTrail.length > 0) {
                    const trailParticle = this.particles.find(p => p.trailParticle);
                    if (!trailParticle) {
                        const newParticle = new Particle();
                        newParticle.trailParticle = true;
                        newParticle.size = 5;
                        newParticle.brightness = 1;
                        newParticle.decay = 0.001;
                        newParticle.lifetime = 10000;
                        this.particles.push(newParticle);
                    }
                }
            }

            drawStarfield() {
                // Draw starfield background
                ctx.fillStyle = 'hsla(0, 0%, 5%, 1)';
                ctx.fillRect(0, 0, canvas.width, canvas.height);

                // Add some stars
                for (let i = 0; i < 100; i++) {
                    const x = Math.random() * canvas.width;
                    const y = Math.random() * canvas.height;
                    const size = Math.random() * 0.5 + 0.1;
                    const brightness = Math.random() * 0.5 + 0.1;

                    ctx.fillStyle = `hsla(0, 0%, ${10 + brightness * 20}%, ${brightness})`;
                    ctx.beginPath();
                    ctx.arc(x, y, size, 0, Math.PI * 2);
                    ctx.fill();
                }
            }
        }

        // Main system
        const particleSystem = new ParticleSystem();
        particleSystem.init();

        // Mouse event handlers
        window.addEventListener('mousemove', (e) => {
            mouse.x = e.clientX;
            mouse.y = e.clientY;
        });

        // Animation loop
        function animate(time) {
            requestAnimationFrame(animate);

            // Calculate delta time
            const deltaTime = time - (particleSystem.lastTime || time);
            particleSystem.lastTime = time;

            // Update and draw
            particleSystem.update(mouse.x, mouse.y, time);
            particleSystem.draw();
        }

        // Start animation
        animate();

        // Handle window resize
        window.addEventListener('resize', () => {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
        });
    </script>
</body>
</html>

using UnityEngine;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Events;
using UnityEngineassertions;

namespace QuantumPoolingSystem
{
    [Serializable]
    public class PoolObjectConfiguration : IEquatable<PoolObjectConfiguration>
    {
        [SerializeField] private string objectId;
        [SerializeField] private GameObject prefab;
        [SerializeField] private int initialPoolSize = 10;
        [SerializeField] private float resurrectionProbability = 0.2f;
        [SerializeField] private int maxPoolSize = 100;
        [SerializeField] private bool useDynamicResizing = true;
        [SerializeField] private float growthThreshold = 0.7f;
        [SerializeField] private int growthIncrement = 5;
        [SerializeField] private UnityEvent<GameObject> onObjectSpawned;
        [SerializeField] private UnityEvent<GameObject> onObjectRecycled;
        [SerializeField] private UnityEvent<GameObject> onObjectResurrected;
        [SerializeField] private PoolObjectLifetimeBehavior lifetimeBehavior = PoolObjectLifetimeBehavior.QuantumResurrection;

        public string ObjectId => objectId;
        public GameObject Prefab => prefab;
        public int InitialPoolSize => initialPoolSize;
        public float ResurrectionProbability => resurrectionProbability;
        public int MaxPoolSize => maxPoolSize;
        public bool UseDynamicResizing => useDynamicResizing;
        public float GrowthThreshold => growthThreshold;
        public int GrowthIncrement => growthIncrement;
        public UnityEvent<GameObject> OnObjectSpawned => onObjectSpawned;
        public UnityEvent<GameObject> OnObjectRecycled => onObjectRecycled;
        public UnityEvent<GameObject> OnObjectResurrected => onObjectResurrected;
        public PoolObjectLifetimeBehavior LifetimeBehavior => lifetimeBehavior;

        public bool Equals(PoolObjectConfiguration other)
        {
            if (other is null) return false;
            return string.Equals(objectId, other.objectId) && Equals(prefab, other.prefab);
        }

        public override bool Equals(object obj) => Equals(obj as PoolObjectConfiguration);
        public override int GetHashCode() => objectId != null ? objectId.GetHashCode() : 0;
    }

    [Serializable]
    public enum PoolObjectLifetimeBehavior
    {
        StandardPooling,
        QuantumResurrection,
        InfiniteLifetime
    }

    public class QuantumPooler : MonoBehaviour
    {
        [SerializeField] private List<PoolObjectConfiguration> poolConfigurations = new List<PoolObjectConfiguration>();
        [SerializeField] private bool logPoolActivity = true;
        [SerializeField] private bool showPoolStats = false;
        [SerializeField] private float statsUpdateInterval = 1f;

        private Dictionary<string, Pool> objectPools = new Dictionary<string, Pool>();
        private List<Pool> activePools = new List<Pool>();
        private List<Pool> inactivePools = new List<Pool>();

        private Coroutine statsCoroutine;
        private bool isInitialized = false;
        private int totalActiveObjects = 0;
        private int totalRecycledObjects = 0;
        private int totalResurrectedObjects = 0;
        private int memoryUsageEstimate = 0;

        private class Pool
        {
            public string Id { get; private set; }
            public PoolObjectConfiguration Config { get; private set; }
            public Queue<GameObject> AvailableObjects { get; private set; } = new Queue<GameObject>();
            public List<GameObject> ActiveObjects { get; private set; } = new List<GameObject>();
            public int CurrentSize { get; private set; }
            public int MaxSize { get; private set; }
            public float ResurrectionProbability { get; private set; }
            public PoolObjectLifetimeBehavior LifetimeBehavior { get; private set; }
            public bool IsUsingDynamicResizing { get; private set; }

            public Pool(PoolObjectConfiguration config)
            {
                Id = config.ObjectId;
                Config = config;
                MaxSize = config.MaxPoolSize;
                ResurrectionProbability = config.ResurrectionProbability;
                LifetimeBehavior = config.LifetimeBehavior;
                IsUsingDynamicResizing = config.UseDynamicResizing;

                InitializePool(config.InitialPoolSize);
            }

            private void InitializePool(int initialSize)
            {
                for (int i = 0; i < initialSize; i++)
                {
                    GameObject obj = Instantiate(Config.Prefab, transform);
                    obj.SetActive(false);
                    AvailableObjects.Enqueue(obj);
                }
                CurrentSize = initialSize;
            }

            public GameObject GetObject()
            {
                if (AvailableObjects.Count > 0)
                {
                    GameObject obj = AvailableObjects.Dequeue();
                    ActiveObjects.Add(obj);
                    obj.SetActive(true);
                    obj.transform.SetParent(transform);
                    Config.OnObjectSpawned?.Invoke(obj);
                    return obj;
                }

                if (CurrentSize < MaxSize && (IsUsingDynamicResizing || CurrentSize < MaxSize))
                {
                    return SpawnNewObject();
                }

                return null;
            }

            public void RecycleObject(GameObject obj, bool forceRecycle = false)
            {
                if (!ActiveObjects.Contains(obj)) return;

                ActiveObjects.Remove(obj);
                obj.SetActive(false);

                if (forceRecycle)
                {
                    AvailableObjects.Enqueue(obj);
                    Config.OnObjectRecycled?.Invoke(obj);
                    return;
                }

                if (LifetimeBehavior == PoolObjectLifetimeBehavior.StandardPooling)
                {
                    AvailableObjects.Enqueue(obj);
                    Config.OnObjectRecycled?.Invoke(obj);
                }
                else if (LifetimeBehavior == PoolObjectLifetimeBehavior.QuantumResurrection && UnityEngine.Random.value < ResurrectionProbability)
                {
                    // Quantum resurrection - the object disappears but might come back later!
                    Config.OnObjectResurrected?.Invoke(obj);
                    Destroy(obj);
                }
                else if (LifetimeBehavior == PoolObjectLifetimeBehavior.InfiniteLifetime)
                {
                    // Object lives forever but we can still recycle it when needed
                    AvailableObjects.Enqueue(obj);
                    Config.OnObjectRecycled?.Invoke(obj);
                }
            }

            public void RecycleAllObjects()
            {
                foreach (var obj in ActiveObjects)
                {
                    RecycleObject(obj, true);
                }
            }

            private GameObject SpawnNewObject()
            {
                if (CurrentSize >= MaxSize) return null;

                GameObject newObj = Instantiate(Config.Prefab, transform);
                ActiveObjects.Add(newObj);
                newObj.SetActive(true);
                Config.OnObjectSpawned?.Invoke(newObj);
                CurrentSize++;

                if (logPoolActivity)
                {
                    Debug.Log($"[QuantumPooler] Created new {Id} object. Current pool size: {CurrentSize}/{MaxSize}");
                }

                return newObj;
            }

            public int GetAvailableCount() => AvailableObjects.Count;
            public int GetActiveCount() => ActiveObjects.Count;
            public float GetUtilizationRatio() => ActiveObjects.Count / (float)CurrentSize;
        }

        public void Initialize()
        {
            if (isInitialized) return;

            foreach (var config in poolConfigurations)
            {
                if (string.IsNullOrEmpty(config.ObjectId) || config.Prefab == null)
                {
                    Debug.LogError($"[QuantumPooler] Invalid configuration: {config.ObjectId} has no ID or prefab");
                    continue;
                }

                if (objectPools.ContainsKey(config.ObjectId))
                {
                    Debug.LogWarning($"[QuantumPooler] Duplicate pool ID: {config.ObjectId}. Using existing pool.");
                }
                else
                {
                    var pool = new Pool(config);
                    objectPools[config.ObjectId] = pool;
                    activePools.Add(pool);
                }
            }

            if (showPoolStats)
            {
                statsCoroutine = StartCoroutine(UpdatePoolStats());
            }

            isInitialized = true;
            Debug.Log($"[QuantumPooler] Initialized with {activePools.Count} active pools");
        }

        public GameObject GetObject(string poolId, Vector3 position, Quaternion rotation)
        {
            if (!objectPools.TryGetValue(poolId, out var pool))
            {
                Debug.LogError($"[QuantumPooler] Pool with ID '{poolId}' not found");
                return null;
            }

            var obj = pool.GetObject();
            if (obj != null)
            {
                obj.transform.position = position;
                obj.transform.rotation = rotation;
                return obj;
            }

            return null;
        }

        public void RecycleObject(GameObject obj, string poolId)
        {
            if (!objectPools.TryGetValue(poolId, out var pool))
            {
                Debug.LogError($"[QuantumPooler] Pool with ID '{poolId}' not found");
                return;
            }

            // Try to find the object in any of the active pools
            foreach (var p in activePools)
            {
                if (p.ActiveObjects.Contains(obj))
                {
                    p.RecycleObject(obj);
                    totalRecycledObjects++;
                    return;
                }
            }

            Debug.LogWarning($"[QuantumPooler] Object not found in any active pool - attempting to destroy: {obj.name}");
            Destroy(obj);
        }

        public void RecycleAllObjects()
        {
            foreach (var pool in activePools)
            {
                pool.RecycleAllObjects();
            }
            totalRecycledObjects += activePools.Sum(p => p.ActiveObjects.Count);
        }

        public void ForceQuantumResurrection(GameObject obj, string poolId)
        {
            if (!objectPools.TryGetValue(poolId, out var pool) || pool.LifetimeBehavior != PoolObjectLifetimeBehavior.QuantumResurrection)
            {
                Debug.LogError($"[QuantumPooler] Cannot force resurrection: invalid pool or lifetime behavior");
                return;
            }

            if (!pool.ActiveObjects.Contains(obj) && !pool.AvailableObjects.Contains(obj))
            {
                Debug.LogWarning($"[QuantumPooler] Object not in pool - cannot force resurrection: {obj.name}");
                return;
            }

            pool.RecycleObject(obj, true); // Force recycle to trigger potential resurrection
            pool.RecycleObject(obj, true); // Second recycle ensures it's properly handled
            totalResurrectedObjects++;
        }

        private IEnumerator UpdatePoolStats()
        {
            while (true)
            {
                totalActiveObjects = activePools.Sum(p => p.GetActiveCount());
                memoryUsageEstimate = activePools.Sum(p => p.ActiveObjects.Count * EstimateObjectMemoryUsage(p.Config.Prefab));

                Debug.Log($"[QuantumPooler] Pool Stats - Active Objects: {totalActiveObjects} | Total Recycled: {totalRecycledObjects} | Total Resurrected: {totalResurrectedObjects} | Memory Estimate: {MemorySizeSuffix(memoryUsageEstimate)}");

                yield return new WaitForSeconds(statsUpdateInterval);
            }
        }

        private int EstimateObjectMemoryUsage(GameObject prefab)
        {
            // Simple memory estimation - this would be more accurate with actual memory profiling
            int componentCount = prefab.GetComponents<Component>().Count();
            return componentCount * 1000 + (prefab.GetComponentInChildren<Renderer>() != null ? 5000 : 0);
        }

        private string MemorySizeSuffix(long value)
        {
            string[] sizes = { "B", "KB", "MB", "GB" };
            int order = 0;
            while (value >= 1024 && order < sizes.Length - 1)
            {
                order++;
                value /= 1024;
            }
            return $"{value:0.##} {sizes[order]}";
        }

        public void DeactivatePool(string poolId)
        {
            if (objectPools.TryGetValue(poolId, out var pool))
            {
                activePools.Remove(pool);
                inactivePools.Add(pool);
                pool.RecycleAllObjects();
                Debug.Log($"[QuantumPooler] Deactivated pool: {poolId}");
            }
            else
            {
                Debug.LogWarning($"[QuantumPooler] Pool not found: {poolId}");
            }
        }

        public void ActivatePool(string poolId)
        {
            if (inactivePools.TryGetValue(poolId, out var pool))
            {
                activePools.Add(pool);
                inactivePools.Remove(pool);
                Debug.Log($"[QuantumPooler] Activated pool: {poolId}");
            }
            else if (objectPools.TryGetValue(poolId, out var activePool))
            {
                Debug.LogWarning($"[QuantumPooler] Pool is already active: {poolId}");
            }
            else
            {
                Debug.LogWarning($"[QuantumPooler] Pool not found: {poolId}");
            }
        }

        private void OnDestroy()
        {
            if (statsCoroutine != null)
            {
                StopCoroutine(statsCoroutine);
            }

            RecycleAllObjects();
        }

        // Editor helper methods
#if UNITY_EDITOR
        [UnityEditor.MenuItem("Tools/Quantum Pooling System/QuantumPooler Example")]
        public static void CreateQuantumPoolerExample()
        {
            var pooler = new GameObject("QuantumPooler").AddComponent<QuantumPooler>();
            var bulletConfig = new PoolObjectConfiguration
            {
                ObjectId = "Bullet",
                Prefab = UnityEditor.AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Bullet.prefab"),
                InitialPoolSize = 20,
                MaxPoolSize = 100,
                ResurrectionProbability = 0.3f,
                LifetimeBehavior = PoolObjectLifetimeBehavior.QuantumResurrection
            };

            var explosionConfig = new PoolObjectConfiguration
            {
                ObjectId = "Explosion",
                Prefab = UnityEditor.AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Explosion.prefab"),
                InitialPoolSize = 5,
                MaxPoolSize = 20,
                LifetimeBehavior = PoolObjectLifetimeBehavior.StandardPooling
            };

            pooler.poolConfigurations = new List<PoolObjectConfiguration> { bulletConfig, explosionConfig };
            pooler.showPoolStats = true;
            UnityEditor.SceneManagement.CommandLine.AddScene("Assets/Scenes/ExampleScene.unity");
            UnityEditor.SceneManagement.CommandLine.SaveScene();
            UnityEditor.EditorUtility.SetDirty(pooler);
        }
#endif
    }
}

use serde_json::{Value, from_str, Error};
use std::io::{self, Write};

/// ASCII musical notes for visual flair
const NOTES: &[&str] = &[
    "♩", "♫", "♬", "♩", "♫", "♬", "♩", "♩", "♩", "♩", "♩", "♩",  // C Major scale
    "♫", "♬", "♩", "♫", "♬", "♩", "♫", "♬",                   // G Major scale
];

/// Generates a random note for visual decoration
fn random_note() -> char {
    let index = rand::random::<usize>() % NOTES.len();
    NOTES[index].chars().next().unwrap()
}

/// Recursively pretty-prints JSON with musical annotations
fn pretty_print_json(value: &Value, indent_level: usize) -> String {
    let indent = "  ".repeat(indent_level);
    match value {
        Value::Null => format!("{indent}♩null"),
        Value::Bool(b) => format!("{indent}{}{}: {}", if *b { "♫" } else { "♬" }, b),
        Value::Number(n) => {
            if n.is_f64() {
                format!("{indent}♬{:.2}", n.as_f64().unwrap())
            } else {
                format!("{indent}♬{}", n)
            }
        }
        Value::String(s) => format!("{indent}♫\"{}\"", s),
        Value::Array(arr) => {
            let mut result = String::new();
            result += &format!("{indent}♩[{}; {} elements]\n", arr.len(), random_note());
            for (i, item) in arr.iter().enumerate() {
                result += &pretty_print_json(item, indent_level + 1);
                if i < arr.len() - 1 {
                    result += ",\n";
                }
            }
            if !arr.is_empty() {
                result += "\n";
            }
            result + &format!("{indent}♩]")
        }
        Value::Object(obj) => {
            let mut result = String::new();
            result += &format!("{indent}♬{{\n");
            for (i, (key, value)) in obj.iter().enumerate() {
                result += &format!("{indent}  {}{}: {}\n",
                    if i == 0 { "♩" } else { random_note() },
                    key,
                    random_note()
                );
                result += &pretty_print_json(value, indent_level + 2);
                if i < obj.len() - 1 {
                    result += ",\n";
                }
            }
            result + &format!("\n{indent}♬}}")
        }
    }
}

/// Main function with user interaction
fn main() {
    println!("JSON Symphony - Pretty-prints JSON with musical flair!\n");

    loop {
        print!("Enter JSON (or 'exit' to quit): ");
        io::stdout().flush().unwrap();

        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Failed to read input");

        if input.trim().eq_ignore_ascii_case("exit") {
            break;
        }

        match from_str::<Value>(&input) {
            Ok(json) => {
                println!("\nParsed JSON:\n{}\n", pretty_print_json(&json, 0));
            }
            Err(e) => match e {
                Error::InvalidSyntax { .. } => {
                    println!("\n❌ Invalid JSON syntax: {}\n", e);
                }
                _ => {
                    println!("\n❌ JSON parsing error: {}\n", e);
                }
            },
        }
        println!();
    }

    println!("Farewell, JSON composer! 🎼");
}