A!leys Galerie

#!/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! 🎼");
}

// DynamicBattleEnhancer.js
// A creative plugin for RPG Maker MZ that adds dynamic battle effects when imported as a Node.js script for development.

// This script simulates the behavior of a battle system plugin for RPG Maker MZ.
// It's designed to be run with Node.js to test and develop the plugin's logic.

// ============================================================================
// Plugin Manager Structure Simulation
// ============================================================================
const $plugins = [];
let $gameMap = { displayName: "Battle Map", tileset: {}, events: [] };
let $gameTroop = { members: [], _initMembers: () => {}, _startAction: () => {} };
let $gameParty = { actors: () => [], actor: () => ({}), _onBattleStart: () => {} };
let $gameVariables = new Map();
let $gameSelfSwitches = new Map();

// ============================================================================
// Core Battle Enhancer Logic
// ============================================================================
class DynamicBattleEnhancer {
    constructor() {
        this.weatherEffects = [
            { name: "Rain", intensity: 0.5, duration: 120, effect: this._handleRain },
            { name: "Thunder", intensity: 0.3, duration: 60, effect: this._handleThunder },
            { name: "Fog", intensity: 0.7, duration: 180, effect: this._handleFog },
            { name: "Sandstorm", intensity: 0.4, duration: 90, effect: this._handleSandstorm }
        ];

        this.terrainEffects = {
            'water': { effect: this._handleWater, priority: 2 },
            'lava': { effect: this._handleLava, priority: 3 },
            'mud': { effect: this._handleMud, priority: 1 },
            'grass': { effect: this._handleGrass, priority: 0 }
        };

        this.enemyBehaviors = {
            'aggressive': this._aggressiveBehavior,
            'defensive': this._defensiveBehavior,
            'passive': this._passiveBehavior,
            'opportunistic': this._opportunisticBehavior
        };

        this.activeWeather = null;
        this.activeTerrain = null;
        this.battleTurn = 0;
    }

    // Initialize the plugin
    init() {
        this._setupBattleEvents();
        this._simulateBattle();
    }

    // Set up battle events
    _setupBattleEvents() {
        $gameTroop._startAction = () => {
            this._startBattle();
        };
    }

    // Start battle simulation
    _startBattle() {
        console.log("\n=== BATTLE STARTED ===");
        this._setRandomWeather();
        this._setRandomTerrain();
        this._assignBehaviorsToEnemies();
        this.battleTurn = 0;
    }

    // Simulate battle turns
    _simulateBattle() {
        const interval = setInterval(() => {
            this.battleTurn++;
            console.log(`\n--- TURN ${this.battleTurn} ---`);

            // Apply weather and terrain effects
            if (this.activeWeather) {
                this.activeWeather.effect();
            }

            if (this.activeTerrain) {
                this.activeTerrain.effect();
            }

            // Simulate enemy actions
            $gameTroop.members.forEach(enemy => {
                if (enemy._behavior) {
                    enemy._behavior();
                }
            });

            // Check if battle should end
            if (this.battleTurn >= 10 || $gameParty.actors().length === 0) {
                clearInterval(interval);
                console.log("\n=== BATTLE ENDED ===");
            }
        }, 1000);
    }

    // Weather effect handlers
    _handleRain() {
        console.log("Rain is falling. Accuracy is reduced slightly.");
        // Simulate accuracy reduction
        this._applyStatusEffect("AccuracyDown", 0.9);
    }

    _handleThunder() {
        console.log("Thunder strikes! Chance of instant damage to enemies.");
        // 30% chance to strike a random enemy
        if (Math.random() < 0.3) {
            const randomEnemy = $gameTroop.members[Math.floor(Math.random() * $gameTroop.members.length)];
            console.log(`Thunder struck ${randomEnemy._name}! (${randomEnemy._hp} HP damage)`);
            randomEnemy._hp = Math.max(0, randomEnemy._hp - 20);
        }
    }

    _handleFog() {
        console.log("Thick fog obscures vision. Evasion is increased.");
        this._applyStatusEffect("EvasionUp", 1.2);
    }

    _handleSandstorm() {
        console.log("Sandstorm! Attacks have a chance to miss.");
        this._applyStatusEffect("EvasionUp", 1.1);
    }

    // Terrain effect handlers
    _handleWater() {
        console.log("Water terrain! Electric attacks are super effective.");
        this._applyStatusEffect("ElectricEffect", 1.5);
    }

    _handleLava() {
        console.log("Lava terrain! Fire attacks are super effective, but takes damage.");
        this._applyStatusEffect("FireEffect", 1.5);
        console.log("Taking 10 damage per turn from lava...");
        $gameParty.actors().forEach(actor => {
            actor._hp = Math.max(0, actor._hp - 10);
        });
    }

    _handleMud() {
        console.log("Muddy terrain! Movement is slower, but physical attacks are slightly stronger.");
        this._applyStatusEffect("PhysicalAttackUp", 1.1);
    }

    _handleGrass() {
        console.log("Grass terrain! Healing effects are more potent.");
        this._applyStatusEffect("HealingEffect", 1.2);
    }

    // Enemy behavior implementations
    _aggressiveBehavior() {
        console.log(`${this._name} is aggressive! Always targets the weakest party member.`);
        const weakestActor = $gameParty.actors().reduce((weakest, actor) =>
            actor._hp < weakest._hp ? actor : weakest
        );
        console.log(`Attacking ${weakestActor._name}!`);
    }

    _defensiveBehavior() {
        console.log(`${this._name} is defensive! Always tries to avoid damage.`);
        if (Math.random() < 0.5) {
            console.log(`${this._name} guards!`);
        } else {
            console.log(`${this._name} attacks randomly.`);
        }
    }

    _passiveBehavior() {
        console.log(`${this._name} is passive! Only attacks when HP is below 50%.`);
        if (this._hp < this._maxhp * 0.5) {
            console.log(`${this._name} attacks!`);
        }
    }

    _opportunisticBehavior() {
        console.log(`${this._name} is opportunistic! Waits for a weak enemy before attacking.`);
        if (Math.random() < 0.3 || $gameTroop.members.some(e =>
            e._hp < e._maxhp * 0.3 && e !== this)) {
            console.log(`${this._name} sees an opening and attacks!`);
        }
    }

    // Utility methods
    _setRandomWeather() {
        const weather = this.weatherEffects[Math.floor(Math.random() * this.weatherEffects.length)];
        this.activeWeather = weather;
        console.log(`Weather: ${weather.name} (intensity: ${weather.intensity}, duration: ${weather.duration} turns)`);
    }

    _setRandomTerrain() {
        const terrainKeys = Object.keys(this.terrainEffects);
        const terrain = terrainKeys[Math.floor(Math.random() * terrainKeys.length)];
        this.activeTerrain = this.terrainEffects[terrain];
        console.log(`Terrain: ${terrain} (priority: ${this.activeTerrain.priority})`);
    }

    _assignBehaviorsToEnemies() {
        $gameTroop.members = Array.from({ length: 3 }, (_, i) => {
            const behaviors = ['aggressive', 'defensive', 'passive', 'opportunistic'];
            const behavior = behaviors[Math.floor(Math.random() * behaviors.length)];
            return {
                _name: `Enemy ${i + 1}`,
                _hp: 100,
                _maxhp: 100,
                _behavior: this.enemyBehaviors[behavior],
                _behavior: this.enemyBehaviors[behavior].bind({ _name: `Enemy ${i + 1}` })
            };
        });
    }

    _applyStatusEffect(name, value) {
        $gameVariables.set(name, value);
        console.log(`Applied ${name}: ${value}`);
    }
}

// ============================================================================
// Mock RPG Maker MZ Classes
// ============================================================================
class Game_Actor {
    constructor(actorId) {
        this._actorId = actorId;
        this._name = `Actor ${actorId}`;
        this._hp = 100;
        this._maxhp = 100;
    }
}

class Game_Enemy {
    constructor(enemyId) {
        this._enemyId = enemyId;
        this._name = `Enemy ${enemyId}`;
        this._hp = 100;
        this._maxhp = 100;
    }
}

// ============================================================================
// Initialize and run the simulation
// ============================================================================
function main() {
    // Set up mock game objects
    $gameParty._onBattleStart = () => {
        $gameParty.actors = () => Array.from({ length: 3 }, (_, i) => new Game_Actor(i + 1));
    };

    $gameTroop._initMembers = () => {
        $gameTroop.members = [];
    };

    $gameParty._onBattleStart();
    $gameTroop._initMembers();

    // Initialize and start the battle enhancer
    const enhancer = new DynamicBattleEnhancer();
    enhancer.init();
}

// Run the simulation
main();

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Linq;

public class QuantumMenuSystem : MonoBehaviour
{
    [SerializeField] private RectTransform _menuContainer;
    [SerializeField] private RectTransform _iconPrefab;
    [SerializeField] private AnimationCurve _morphCurve;
    [SerializeField] private float _morphDuration = 0.8f;
    [SerializeField] private float _hapticFeedbackForce = 0.5f;
    [SerializeField] private Vector2[] _quantumStates = new Vector2[]
    {
        new Vector2(0.3f, 0.3f), // Superposition
        new Vector2(0.7f, 0.7f), // Entangled
        new Vector2(0.1f, 0.9f), // Collapsed
        new Vector2(0.9f, 0.1f)  // Observer Effect
    };

    private RectTransform[] _activeIcons;
    private int _currentStateIndex = 0;
    private Coroutine _morphRoutine;

    private void Awake()
    {
        if (_menuContainer == null)
        {
            Debug.LogError("Menu Container reference is missing!");
            enabled = false;
            return;
        }

        InitializeMenu();
        TriggerRandomMorph();
    }

    private void InitializeMenu()
    {
        _activeIcons = new RectTransform[4]; // 4 quantum states per menu

        for (int i = 0; i < _activeIcons.Length; i++)
        {
            var iconInstance = Instantiate(_iconPrefab, _menuContainer);
            iconInstance.anchoredPosition = new Vector2(
                Random.Range(-150f, 150f),
                Random.Range(-150f, 150f)
            );
            _activeIcons[i] = iconInstance;

            // Add haptic feedback on click
            var button = iconInstance.GetComponent<Button>();
            if (button != null)
            {
                button.onClick.AddListener(() => TriggerHapticFeedback());
            }
        }
    }

    public void TriggerRandomMorph()
    {
        if (_morphRoutine != null)
        {
            StopCoroutine(_morphRoutine);
        }

        _morphRoutine = StartCoroutine(MorphToRandomState());
    }

    private IEnumerator MorphToRandomState()
    {
        int targetIndex = Random.Range(0, _quantumStates.Length);

        for (float t = 0; t < 1; t += Time.deltaTime / _morphDuration)
        {
            float progress = Mathf.Clamp01(_morphCurve.Evaluate(t));

            // Animate position and scale based on quantum state
            Vector2 newState = Vector2.Lerp(_quantumStates[_currentStateIndex], _quantumStates[targetIndex], progress);

            foreach (RectTransform icon in _activeIcons)
            {
                icon.anchoredPosition = Vector2.Lerp(
                    icon.anchoredPosition,
                    new Vector2(
                        Mathf.Lerp(-150f, 150f, newState.x),
                        Mathf.Lerp(-150f, 150f, newState.y)
                    ),
                    progress
                );

                icon.localScale = Vector3.Lerp(
                    icon.localScale,
                    new Vector3(1 + (0.3f * newState.y), 1 + (0.3f * newState.x), 1),
                    progress * 0.7f
                );
            }

            yield return null;
        }

        _currentStateIndex = targetIndex;
    }

    private void TriggerHapticFeedback()
    {
        #if UNITY_EDITOR
        Debug.Log("Quantum Observer Effect Detected! Haptic Feedback Triggered");
        #else
        Handheld.Vibrate(_hapticFeedbackForce, _morphDuration * 0.5f);
        #endif
    }

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