A!leys Galerie

// Nebula-Narrator - A static site generator with AI-driven narrative styling and LGTM-inspired analytics
import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';
import { marked } from 'marked';
import { minify } from 'html-minifier';
import { generate } from 'random-word-generator';
import { Transformer } from 'parallax-js';
import { createWriteStream } from 'fs';
import { exec } from 'child_process';
import { promisify } from 'util';

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

// Configuration
const CONFIG = {
  inputDir: path.join(__dirname, 'content'),
  outputDir: path.join(__dirname, 'dist'),
  styleThemes: ['neon', 'retro', 'minimal', 'monochrome', 'cyberpunk'],
  animationIntensity: 0.7,
  analyticsToken: 'your-lgtm-analytics-token-here' // Replace with real token for production
};

// Helper functions
const ensureDir = async (dir) => {
  try { await fs.access(dir); } catch { await fs.mkdir(dir, { recursive: true }); }
};

const getFiles = async (dir) => {
  const files = await fs.readdir(dir);
  return files.filter(f => f.endsWith('.md') || f.endsWith('.html'));
};

const generateTheme = () => {
  const theme = CONFIG.styleThemes[Math.floor(Math.random() * CONFIG.styleThemes.length)];
  return {
    primary: theme === 'neon' ? '#ff00ff' :
             theme === 'retro' ? '#ff6600' :
             theme === 'cyberpunk' ? '#00ff99' : '#333333',
    secondary: theme === 'neon' ? '#00ffff' :
               theme === 'retro' ? '#ffcc00' :
               theme === 'cyberpunk' ? '#00aaaa' : '#f0f0f0',
    background: theme === 'neon' ? 'radial-gradient(circle, #111, #000)' :
               theme === 'retro' ? '#0a0a23' :
               theme === 'cyberpunk' ? '#000428' : '#ffffff',
    font: theme === 'neon' ? "'Courier New', monospace" :
          theme === 'retro' ? "'Press Start 2P', cursive" :
          "'Helvetica Neue', sans-serif"
  };
};

const generateAnalyticsCode = () => {
  return `
    <script src="https://analytics.lgtm.run/api.js?token=${CONFIG.analyticsToken}" defer></script>
    <script>
      window.addEventListener('load', () => {
        LGTM.trackPageView();
        setInterval(() => LGTM.trackEvent('user_engagement', { type: 'idle_time' }), 300000);
      });
    </script>
  `;
};

// Main processing
const processMarkdown = async (filePath) => {
  const content = await fs.readFile(filePath, 'utf8');
  const title = filePath.replace(/^.*\//, '').replace(/\.md$/, '');
  const html = marked.parse(content);

  // Add parallax effects and animations
  const transformer = new Transformer({
    speed: CONFIG.animationIntensity,
    scale: 1.2,
    offsetX: 0,
    offsetY: 0
  });

  return {
    title,
    content: html.replace(/<body>/, `<body onload="transformer.init()">`)
                 .replace(/<h1>(.*?)<\/h1>/g, `<h1 class="parallax" data-speed="${CONFIG.animationIntensity}">$1</h1>`)
  };
};

const generateCSS = (theme) => {
  const keyframes = `
    @keyframes float {
      0% { transform: translateY(0px) rotate(0deg); }
      50% { transform: translateY(-20px) rotate(5deg); }
      100% { transform: translateY(0px) rotate(0deg); }
    }
    @keyframes glow {
      0% { box-shadow: 0 0 5px ${theme.primary}; }
      100% { box-shadow: 0 0 20px ${theme.primary}; }
    }
  `;

  const parallaxStyles = `
    .parallax {
      animation: float 6s ease-in-out infinite;
      will-change: transform;
    }
    .parallax:hover {
      animation: glow 2s ease-in-out infinite;
    }
  `;

  return `
    :root {
      --primary: ${theme.primary};
      --secondary: ${theme.secondary};
      --bg: ${theme.background};
      --font: ${theme.font};
    }
    body {
      font-family: var(--font);
      background: var(--bg);
      color: var(--secondary);
      transition: background 0.5s, color 0.5s;
      margin: 0;
      padding: 2rem;
      line-height: 1.6;
    }
    h1, h2, h3, h4, h5, h6 {
      color: var(--primary);
      transition: color 0.3s;
    }
    a {
      color: var(--primary);
      text-decoration: none;
      transition: color 0.3s;
    }
    a:hover {
      color: var(--secondary);
    }
    .dark-mode body {
      background: #111;
      color: #eee;
    }
    .dark-mode h1, .dark-mode h2, .dark-mode h3,
    .dark-mode h4, .dark-mode h5, .dark-mode h6 {
      color: #0ff;
    }
    ${keyframes}
    ${parallaxStyles}
    /* Toggle button */
    .theme-toggle {
      position: fixed;
      top: 1rem;
      right: 1rem;
      background: rgba(0, 0, 0, 0.5);
      color: white;
      border: none;
      padding: 0.5rem;
      border-radius: 0.5rem;
      cursor: pointer;
      z-index: 1000;
    }
    .theme-toggle:hover {
      background: rgba(0, 0, 0, 0.8);
    }
  `;
};

const generateHTML = (data) => {
  const theme = generateTheme();
  const css = generateCSS(theme);
  const analytics = generateAnalyticsCode();

  return `
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>${data.title}</title>
      <style>${css}</style>
      <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/parallax-js@2.0.5/dist/parallax.min.css">
      <script src="https://cdn.jsdelivr.net/npm/parallax-js@2.0.5/dist/parallax.min.js" defer></script>
      <script>
        // Theme toggle functionality
        document.addEventListener('DOMContentLoaded', () => {
          const toggle = document.createElement('button');
          toggle.className = 'theme-toggle';
          toggle.textContent = '🌙';
          toggle.onclick = () => document.body.classList.toggle('dark-mode');
          document.body.appendChild(toggle);
        });
      </script>
    </head>
    <body>
      <header>
        <h1>${data.title}</h1>
        <p>Generated by Nebula-Narrator</p>
      </header>
      <main>
        ${data.content}
      </main>
      <footer>
        <p>© ${new Date().getFullYear()} ${generate(1, { words: ['Nebula', 'Cosmos', 'Aether', 'Void'] })}</p>
      </footer>
      ${analytics}
    </body>
    </html>
  `;
};

const writeFiles = async (outputDir, files) => {
  await ensureDir(outputDir);

  for (const file of files) {
    const inputPath = path.join(CONFIG.inputDir, file);
    const outputPath = path.join(CONFIG.outputDir, `${file.replace(/\.md$/, '.html')}`);

    try {
      const data = await processMarkdown(inputPath);
      const html = generateHTML(data);

      // Minify the HTML
      const minified = minify(html, {
        collapseWhitespace: true,
        removeComments: true,
        minifyCSS: true,
        minifyJS: true
      });

      await fs.writeFile(outputPath, minified);
      console.log(`✨ Generated: ${outputPath}`);

      // Watch for changes in input (simple implementation)
      if (file.endsWith('.md')) {
        const watcher = fs.watch(inputPath, async () => {
          console.log(`🔄 Detected change in ${file}, regenerating...`);
          await writeFiles(CONFIG.outputDir, [file]);
        });
      }
    } catch (err) {
      console.error(`❌ Error processing ${file}:`, err.message);
    }
  }
};

// CLI interface
const showHelp = () => {
  console.log(`
  Nebula-Narrator - Static Site Generator

  Usage:
    node nebula-narrator.js [--build|--watch]

  Options:
    --build    Build once and exit
    --watch    Watch for changes and rebuild (default)

  Example:
    node nebula-narrator.js --watch
  `);
};

const main = async () => {
  try {
    await ensureDir(CONFIG.inputDir);
    await ensureDir(CONFIG.outputDir);

    const files = await getFiles(CONFIG.inputDir);
    if (files.length === 0) {
      console.log('⚠️ No Markdown files found in the content directory. Creating a sample file...');
      await fs.writeFile(
        path.join(CONFIG.inputDir, 'sample.md'),
        `# Welcome to Nebula-Narrator\n\nThis is a sample Markdown file.\n\n## Features\n- Auto-generated CSS animations\n- Dark/light mode toggle\n- LGTM-inspired analytics\n\n[Learn more about Markdown](https://github.com/adam-p/markdown-here)`
      );
      await writeFiles(CONFIG.outputDir, ['sample.md']);
      return;
    }

    const args = process.argv.slice(2);
    if (args.includes('--help') || args.includes('-h')) {
      showHelp();
      return;
    }

    const isWatchMode = !args.includes('--build');
    await writeFiles(CONFIG.outputDir, files);

    if (!isWatchMode) {
      console.log('\n🚀 Build completed! Serve the site with:');
      console.log(`  npx serve ${CONFIG.outputDir}`);
      console.log('\n🎨 View your site with dynamic CSS animations and theme toggle!');
    }
  } catch (err) {
    console.error('❌ Error:', err);
    process.exit(1);
  }
};

// Execute with Node.js
main();

using UnityEngine;
using UnityEngine.Serialization;

[RequireComponent(typeof(Camera))]
[DisallowMultipleComponent]
public class SmoothDynamicCamera : MonoBehaviour
{
    [Header("Follow Settings")]
    [SerializeField] private Transform target;
    [SerializeField] private Vector3 offset = new Vector3(0f, 2f, -5f);
    [SerializeField] private float smoothTime = 0.3f;
    [SerializeField] private float maxSpeed = 10f;
    [SerializeField] private float minSpeed = 1f;
    [SerializeField] private float accelerationFactor = 1.5f;
    [SerializeField] private float decelerationFactor = 0.5f;
    [SerializeField] private float rotationSmoothTime = 0.2f;
    [SerializeField] private float rotationDamping = 0.1f;

    [Header("Dynamic Settings")]
    [SerializeField] private float dynamicSpeedThreshold = 3f;
    [SerializeField] private float dynamicSpeedSensitivity = 0.5f;
    [SerializeField] private float knockbackDuration = 0.1f;
    [SerializeField] private float knockbackMagnitude = 0.5f;
    [SerializeField] private bool useDynamicSpeed = true;
    [SerializeField] private bool useKnockbackEffect = true;

    [Header("Visual Effects")]
    [SerializeField] private Material blurMaterial;
    [SerializeField] private float knockbackBlurIntensity = 1.5f;
    [SerializeField] private float knockbackBlurDuration = 0.3f;

    private Vector3 _velocity = Vector3.zero;
    private Vector3 _currentVelocity;
    private float _currentSpeed;
    private float _dynamicSpeedMultiplier = 1f;
    private float _knockbackTimer = 0f;
    private bool _isKnockingBack = false;
    private Camera _mainCamera;
    private float _rotationX = 0f;
    private float _rotationY = 0f;
    private float _rotationVelocityX = 0f;
    private float _rotationVelocityY = 0f;

    private void Awake()
    {
        _mainCamera = GetComponent<Camera>();
        if (blurMaterial != null)
        {
            blurMaterial.SetVector("_MainTexOffset", Vector2.zero);
        }
    }

    private void Update()
    {
        UpdateDynamicSpeedMultiplier();
        UpdateKnockbackEffect();
    }

    private void LateUpdate()
    {
        if (target == null) return;

        Vector3 desiredPosition = target.position + offset;
        Vector3 smoothedPosition = Vector3.SmoothDamp(
            transform.position,
            desiredPosition,
            ref _velocity,
            smoothTime
        );

        // Dynamic speed adjustment
        _currentSpeed = Vector3.Distance(transform.position, smoothedPosition) / Time.deltaTime;
        float targetSpeed = CalculateTargetSpeed(_currentSpeed);

        // Adjust velocity based on speed difference
        if (targetSpeed > _currentSpeed)
        {
            _currentVelocity = Vector3.MoveTowards(
                _currentVelocity,
                smoothedPosition - transform.position,
                accelerationFactor * Time.deltaTime
            );
        }
        else if (targetSpeed < _currentSpeed)
        {
            _currentVelocity = Vector3.MoveTowards(
                _currentVelocity,
                Vector3.zero,
                decelerationFactor * Time.deltaTime
            );
        }

        // Apply velocity with dynamic multiplier
        transform.position += _currentVelocity * _dynamicSpeedMultiplier * Time.deltaTime;

        // Smooth rotation towards the target
        if (target != null)
        {
            UpdateRotation();
        }
    }

    private void UpdateDynamicSpeedMultiplier()
    {
        if (!useDynamicSpeed) return;

        Vector3 targetDirection = target.position - transform.position;
        float targetSpeed = targetDirection.magnitude / Time.deltaTime;

        if (targetSpeed > dynamicSpeedThreshold)
        {
            float speedRatio = Mathf.Clamp01((targetSpeed - dynamicSpeedThreshold) / dynamicSpeedSensitivity);
            _dynamicSpeedMultiplier = Mathf.Lerp(minSpeed, maxSpeed, speedRatio);
        }
        else
        {
            _dynamicSpeedMultiplier = Mathf.Lerp(_dynamicSpeedMultiplier, 1f, Time.deltaTime * 5f);
        }
    }

    private float CalculateTargetSpeed(float currentSpeed)
    {
        if (currentSpeed < minSpeed) return minSpeed;
        if (currentSpeed > maxSpeed) return maxSpeed;

        return currentSpeed;
    }

    private void UpdateRotation()
    {
        if (target == null) return;

        Vector3 targetPosition = target.position + offset;
        Vector3 direction = targetPosition - transform.position;
        direction = direction.normalized;

        // Calculate rotation angles with smoothing
        float targetRotationX = Mathf.Atan2(direction.z, direction.x) * Mathf.Rad2Deg;
        float targetRotationY = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;

        // Smooth the rotation
        _rotationX = Mathf.SmoothDampAngle(
            _rotationX,
            targetRotationX,
            ref _rotationVelocityX,
            rotationSmoothTime
        );

        _rotationY = Mathf.SmoothDampAngle(
            _rotationY,
            targetRotationY,
            ref _rotationVelocityY,
            rotationSmoothTime
        );

        // Apply rotation with damping
        Quaternion targetRotation = Quaternion.Euler(_rotationY, _rotationX, 0f);
        transform.rotation = Quaternion.Slerp(
            transform.rotation,
            targetRotation,
            rotationDamping
        );
    }

    public void TriggerKnockback()
    {
        if (!useKnockbackEffect) return;

        _isKnockingBack = true;
        _knockbackTimer = knockbackDuration;

        if (blurMaterial != null)
        {
            blurMaterial.SetFloat("_BlurIntensity", knockbackBlurIntensity);
        }
    }

    private void UpdateKnockbackEffect()
    {
        if (!_isKnockingBack) return;

        _knockbackTimer -= Time.deltaTime;
        if (blurMaterial != null)
        {
            blurMaterial.SetFloat("_BlurIntensity",
                Mathf.Lerp(knockbackBlurIntensity, 0f, _knockbackTimer / knockbackBlurDuration)
            );
        }

        if (_knockbackTimer <= 0f)
        {
            _isKnockingBack = false;
            if (blurMaterial != null)
            {
                blurMaterial.SetFloat("_BlurIntensity", 0f);
            }
        }
    }

    // Editor visualization
    private void OnDrawGizmosSelected()
    {
        if (target == null) return;

        Gizmos.color = Color.green;
        Gizmos.DrawLine(transform.position, target.position + offset);

        Gizmos.color = Color.blue;
        Gizmos.DrawWireSphere(transform.position + offset, 0.3f);

        if (Application.isPlaying)
        {
            Gizmos.color = Color.red;
            Gizmos.DrawLine(transform.position, transform.position + _currentVelocity * _dynamicSpeedMultiplier);
        }
    }
}

import androidx.compose.foundation背景
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.viewmodel.compose.viewModel
import java.text.DecimalFormat

@Composable
fun MoodCalcApp() {
    Surface(
        modifier = Modifier.fillMaxSize(),
        color = MaterialTheme.colorScheme.background
    ) {
        MoodCalcScreen()
    }
}

@Composable
fun MoodCalcScreen(viewModel: MoodCalcViewModel = viewModel()) {
    var input by remember { viewModel.input }
    var result by remember { viewModel.result }
    var history by remember { viewModel.history }
    var isError by remember { viewModel.isError }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        // Mood indicator (visual feedback)
        MoodIndicator(moodLevel = viewModel.moodLevel)

        Spacer(modifier = Modifier.height(16.dp))

        // Input field
        OutlinedTextField(
            value = input,
            onValueChange = { newValue ->
                if (newValue.length <= 20) { // Limit input length
                    input = newValue
                }
            },
            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
            singleLine = true,
            modifier = Modifier
                .fillMaxWidth()
                .padding(vertical = 8.dp),
            label = { Text("Enter expression") }
        )

        Spacer(modifier = Modifier.height(16.dp))

        // Result display
        Text(
            text = if (isError) "Error: Invalid input" else result,
            fontSize = 24.sp,
            fontWeight = FontWeight.Bold,
            color = if (isError) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.primary
        )

        Spacer(modifier = Modifier.height(16.dp))

        // Button grid
        CalculatorButtons(viewModel = viewModel)

        Spacer(modifier = Modifier.height(16.dp))

        // History
        HistorySection(history = history, onItemClick = { expression, _ ->
            input = expression
        })
    }
}

@Composable
fun MoodIndicator(moodLevel: Float) {
    val colors = listOf(
        Color.Red, // Angry (0-20%)
        Color.Orange, // Frustrated (20-40%)
        Color.Yellow, // Neutral (40-60%)
        Color.Green, // Happy (60-80%)
        Color.Blue, // Ecstatic (80-100%)
    )

    val selectedColor = colors.getOrElse(moodLevel * 10) {
        Color.Green // Default to happy if out of bounds
    }

    Box(
        modifier = Modifier
            .height(24.dp)
            .fillMaxWidth()
            .background(MaterialTheme.colorScheme.surface),
        contentAlignment = Alignment.CenterStart
    ) {
        LinearProgressIndicator(
            progress = moodLevel / 10,
            modifier = Modifier.fillMaxWidth(),
            color = selectedColor,
            trackColor = MaterialTheme.colorScheme.outlineVariant
        )

        Text(
            text = "Mood: ${"%.0f".format(moodLevel * 10)}%",
            fontSize = 12.sp,
            modifier = Modifier.padding(start = 8.dp)
        )
    }
}

@Composable
fun CalculatorButtons(viewModel: MoodCalcViewModel) {
    val buttons = listOf(
        "C", "%", "÷", "7", "8", "9", "×", "4", "5", "6", "-", "1", "2", "3", "+", "0", ".", "=",
        "±", "√", "x²", "1/x", "sin", "cos", "tan"
    )

    LazyColumn(
        modifier = Modifier.fillMaxWidth()
    ) {
        items(buttons) { button ->
            CalculatorButton(
                text = button,
                onClick = {
                    when (button) {
                        "C" -> viewModel.clearInput()
                        "=" -> viewModel.calculate()
                        else -> viewModel.appendOperation(button)
                    }
                },
                modifier = Modifier
                    .fillMaxWidth()
                    .aspectRatio(1f)
                    .padding(horizontal = 4.dp, vertical = 4.dp)
            )
        }
    }
}

@Composable
fun CalculatorButton(
    text: String,
    onClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Button(
        onClick = onClick,
        modifier = modifier,
        colors = ButtonDefaults.buttonColors(
            containerColor = if (text in listOf("=", "C")) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
            contentColor = if (text in listOf("=", "C")) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurface
        ),
        shape = CircleShape
    ) {
        Text(
            text = text,
            fontSize = 18.sp,
            fontWeight = FontWeight.Bold
        )
    }
}

@Composable
fun HistorySection(history: List<Pair<String, String>>, onItemClick: (String, String) -> Unit) {
    Column(
        modifier = Modifier.fillMaxMaxSize()
    ) {
        Text(
            text = "History",
            fontSize = 18.sp,
            fontWeight = FontWeight.Bold,
            modifier = Modifier.padding(bottom = 8.dp)
        )

        LazyColumn(
            modifier = Modifier
                .fillMaxWidth()
                .height(150.dp)
                .verticalScroll(rememberScrollState())
        ) {
            items(history.reversed()) { (expression, result) ->
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .clickable { onItemClick(expression, result) }
                        .padding(vertical = 4.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Text(
                        text = expression,
                        modifier = Modifier.weight(1f),
                        fontSize = 14.sp
                    )
                    Spacer(modifier = Modifier.width(8.dp))
                    Text(
                        text = result,
                        modifier = Modifier.weight(1f),
                        fontSize = 14.sp
                    )
                }
            }
        }
    }
}

class MoodCalcViewModel : ViewModel() {
    private val _input = mutableStateOf("0")
    val input: State<String> = _input

    private val _result = mutableStateOf("0")
    val result: State<String> = _result

    private val _history = mutableStateOf(listOf<Pair<String, String>>())
    val history: State<List<Pair<String, String>>> = _history

    private val _isError = mutableStateOf(false)
    val isError: State<Boolean> = _isError

    var moodLevel: Float by mutableStateOf(50f) // Default to neutral

    private val decimalFormat = DecimalFormat("#.##########")

    fun clearInput() {
        _input.value = "0"
        _isError.value = false
    }

    fun appendOperation(operation: String) {
        if (_input.value == "0" && operation != "." && operation != "±" && operation != "C") {
            _input.value = if (operation == "0") "0" else operation
        } else {
            _input.value += operation
        }
    }

    fun calculate() {
        try {
            val expression = _input.value
            if (expression.isEmpty()) return

            // Replace ± with * -1
            val processedExpression = expression.replace("±", "*(-1)")
            // Replace x² with ^2
            val mathExpression = processedExpression.replace("x²", "^2")
            // Evaluate the expression
            val eval = Object().javaClass.getDeclaredMethod("eval", String::class.java)
                .invoke(null, mathExpression) as Double

            val formattedResult = decimalFormat.format(eval)
            _result.value = formattedResult
            _isError.value = false

            // Update mood level based on operations (simplified logic)
            val moodChange = when {
                mathExpression.contains("x²") || mathExpression.contains("sin") || mathExpression.contains("cos") || mathExpression.contains("tan") -> 20f
                mathExpression.contains("÷") || mathExpression.contains("×") -> 10f
                mathExpression.contains("+") || mathExpression.contains("-") -> 5f
                mathExpression.contains("%") -> 15f
                else -> 0f
            }

            moodLevel = (moodLevel + moodChange).coerceIn(0f, 100f)

            // Add to history if not already there
            val lastExpression = _history.value.lastOrNull()?.first
            if (lastExpression != expression) {
                _history.value = (_history.value + listOf(Pair(expression, formattedResult))).takeLast(10)
            }
        } catch (e: Exception) {
            _result.value = "Error"
            _isError.value = true
        }
    }
}

// Preview function
@Preview(showBackground = true)
@Composable
fun MoodCalcPreview() {
    MoodCalcApp()
}

// Helper method for expression evaluation (not production-safe, for demo only)
fun Object.eval(expr: String): Double {
    return java.lang.Double.parseDouble(expr)
        .let { if (expr.contains("sin")) Math.sin(it) else it }
        .let { if (expr.contains("cos")) Math.cos(it) else it }
        .let { if (expr.contains("tan")) Math.tan(it) else it }
        .let { if (expr.contains("^2")) Math.pow(it, 2) else it }
        .let { if (expr.contains("÷")) expr.split("÷")[0].toDouble() / it else it }
        .let { if (expr.contains("×")) expr.split("×")[0].toDouble() * it else it }
        .let { if (expr.contains("+")) expr.split("+")[0].toDouble() + it else it }
        .let { if (expr.contains("-")) expr.split("-")[0].toDouble() - it else it }
        .let { if (expr.contains("%")) it * 0.01 else it }
        .let { if (expr.contains("*(-1)")) -it else it }
}

extends Node

# Mystic Riddle Quest - A branching dialogue system with fate mechanics
class_name MysticRiddleQuest

# Dialogue structure: { "text": "", "options": [ { "text": "", "next_id": int, "fate_cost": int }, ... ] }
@export var dialogues: Array[Dictionary] = []
@export var current_dialogue_id: int = 0
@export var fate_points: int = 100

# Visual elements (can be connected in editor)
@onready var label_dialogue: Label = $Label
@onready var label_fate: Label = $FateLabel
@onready var button_container: VBoxContainer = $ButtonContainer

# Current buttons (dynamically managed)
var current_buttons: Array[Button] = []

# Twist: Fate Points affect dialogue outcomes and unlock special "cosmic" riddles
func _ready() -> void:
    if current_dialogue_id >= dialogues.size():
        current_dialogue_id = 0

    label_dialogue.text = get_dialogue_text()
    label_fate.text = "Fate: %d" % fate_points

    update_buttons()

# Process for potential future mechanics (e.g., time-based effects)
func _process(delta: float) -> void:
    pass

# Get the current dialogue text
func get_dialogue_text() -> String:
    return dialogues[current_dialogue_id]["text"]

# Update the buttons based on current dialogue options
func update_buttons() -> void:
    # Clear existing buttons
    for button in current_buttons:
        button_container.remove_child(button)

    current_buttons.clear()

    # Get options for current dialogue
    var options = dialogues[current_dialogue_id]["options"] or []

    # Create new buttons
    for option in options:
        var button = Button.new()
        button.text = option["text"]
        button.margin_right = 10
        button_container.add_child(button)
        current_buttons.append(button)

        # Connect button pressed signal
        button.connect("pressed", Callable(self, "on_button_pressed").bind(option))

# Button pressed handler (passes the option data)
func on_button_pressed(option: Dictionary) -> void:
    if fate_points >= option["fate_cost"]:
        fate_points -= option["fate_cost"]
        current_dialogue_id = option["next_id"]
    else:
        # Twist: Not enough fate? Use a cosmic riddle to continue
        if randf() > 0.3:  # 70% chance to solve the riddle
            fate_points -= option["fate_cost"] * 0.5  # Lose half the cost
            current_dialogue_id = option["next_id"]
        else:
            label_dialogue.add_to_group("error")
            label_dialogue.text += "\n\n[The cosmos laughs as you fail the riddle! Try another path.]"
            yield(get_tree().create_timer(2.0), "timeout")
            label_dialogue.remove_from_group("error")
            label_dialogue.text = get_dialogue_text()
            return

    # Update UI
    label_dialogue.text = get_dialogue_text()
    label_fate.text = "Fate: %d" % fate_points
    update_buttons()

# Reset the dialogue system (for restarting)
func reset_dialogue() -> void:
    current_dialogue_id = 0
    fate_points = 100
    label_dialogue.text = get_dialogue_text()
    label_fate.text = "Fate: %d" % fate_points
    update_buttons()

# Example dialogue data (can be loaded from JSON in a real implementation)
func _init() -> void:
    # This is just a sample - in practice you'd load from a file or JSON
    dialogues.clear()

    # Starting dialogue
    dialogues.append({
        "text": "You stand before the Cosmic Gate, ancient and humming with energy. Two paths unfold before you...",
        "options": [
            {
                "text": "[Whisper to the void] (Cost: 10 Fate)",
                "next_id": 1,
                "fate_cost": 10
            },
            {
                "text": "[Shout your defiance] (Cost: 20 Fate)",
                "next_id": 2,
                "fate_cost": 20
            }
        ]
    })

    # Path 1: Whisper to the void
    dialogues.append({
        "text": "The void responds with a murmur. 'I see your desire... but do you see the pattern? Solve this: I am taken from a mine, and shut up in a wooden case, from which I am never released, and yet I am used by almost every person. What am I?'",
        "options": [
            {
                "text": "[Answer: Pencil lead] (Solve riddle!)",
                "next_id": 3,
                "fate_cost": 0  # No cost if riddle is solved
            },
            {
                "text": "[Give up] (Cost: 5 Fate)",
                "next_id": 4,
                "fate_cost": 5
            }
        ]
    })

    # Path 1.1: Solved the riddle
    dialogues.append({
        "text": "The gate shudders. 'Correct. You may pass... but at what cost?' Your fate points reset to 50.",
        "options": [
            {
                "text": "[Accept the cosmic balance] (No cost)",
                "next_id": 5,
                "fate_cost": 0
            }
        ]
    })

    # Path 1.2: Gave up
    dialogues.append({
        "text": "The void sighs. 'Very well. Proceed, but your fate dims.'",
        "options": [
            {
                "text": "[Continue] (No cost)",
                "next_id": 5,
                "fate_cost": 0
            }
        ]
    })

    # Path 2: Shouted defiance
    dialogues.append({
        "text": "The gate trembles. 'Foolish mortal! You challenge the cosmos with your noise? Very well, I shall test you.' Your fate points increase by 20 for your boldness!",
        "options": [
            {
                "text": "[Continue] (No cost)",
                "next_id": 5,
                "fate_cost": 0
            }
        ]
    })

    # Final path (all converge here)
    dialogues.append({
        "text": "You stand before the final threshold. Your fate points determine your legacy: %d. What will you do with them?" % fate_points,
        "options": [
            {
                "text": "[Sacrifice all for power] (Ends game)",
                "next_id": 6,
                "fate_cost": 0
            },
            {
                "text": "[Preserve your fate] (Ends game)",
                "next_id": 7,
                "fate_cost": 0
            }
        ]
    })

    # Endings
    dialogues.append({
        "text": "You consume your fate, becoming a being of pure cosmic energy! The universe bends to your will. (Fate points: %d)" % fate_points,
        "options": []
    })

    dialogues.append({
        "text": "You walk away, your fate preserved. The cosmos acknowledges your balance. (Fate points: %d)" % fate_points,
        "options": []
    })

```swift
import SwiftUI
import UserNotifications
import Combine

// MARK: - Data Models

struct Habit: Identifiable, Codable, Hashable {
    let id: UUID
    var name: String
    var isCompleted: Bool
    var completionCount: Int
    var streak: Int
    let icon: String
    let color: Color
    var lastCompleted: Date?
    var targetFrequency: Frequency // Daily, Weekly, Custom

    enum Frequency: String, Codable, CaseIterable {
        case daily = "Daily"
        case weekly = "Weekly"
        case custom = "Custom"
    }
}

struct CustomFrequency: Codable, Hashable {
    let days: [Weekday]
    enum Weekday: String, Codable, CaseIterable {
        case sunday, monday, tuesday, wednesday, thursday, friday, saturday
    }
}

// MARK: - Data Manager

class HabitStore: ObservableObject {
    @Published var habits: [Habit] = [] {
        didSet {
            saveHabits()
        }
    }

    private let defaults = UserDefaults.standard
    private let key = "savedHabits"

    init() {
        loadHabits()
        setupSampleData()
    }

    func loadHabits() {
        if let data = defaults.data(forKey: key),
           let decoded = try? JSONDecoder().decode([Habit].self, from: data) {
            habits = decoded
        }
    }

    func saveHabits() {
        if let encoded = try? JSONEncoder().encode(habits) {
            defaults.set(encoded, forKey: key)
        }
    }

    func addHabit(_ habit: Habit) {
        habits.append(habit)
    }

    func updateHabit(_ habit: Habit) {
        if let index = habits.firstIndex(where: { $0.id == habit.id }) {
            habits[index] = habit
        }
    }

    func deleteHabit(at indexSet: IndexSet) {
        habits.remove(atOffsets: indexSet)
    }

    private func setupSampleData() {
        let sampleHabits = [
            Habit(id: UUID(), name: "Morning Meditation", isCompleted: false, completionCount: 0, streak: 0, icon: "zen", color: .blue, lastCompleted: nil, targetFrequency: .daily),
            Habit(id: UUID(), name: "Walk 10,000 Steps", isCompleted: false, completionCount: 0, streak: 0, icon: "figure.walk", color: .green, lastCompleted: nil, targetFrequency: .daily),
            Habit(id: UUID(), name: "Learn SwiftUI", isCompleted: false, completionCount: 0, streak: 0, icon: "pencil", color: .purple, lastCompleted: nil, targetFrequency: .weekly),
            Habit(id: UUID(), name: "Hydrate", isCompleted: false, completionCount: 0, streak: 0, icon: "waveform", color: .teal, lastCompleted: nil, targetFrequency: .daily)
        ]
        habits = sampleHabits
    }
}

// MARK: - Notification Manager

class NotificationManager {
    static let shared = NotificationManager()

    private init() {}

    func scheduleNotification(for habit: Habit, time: Date, identifier: String) {
        let content = UNMutableNotificationContent()
        content.title = "Mindful Reminder"
        content.body = "It's time to nurture your habit: \(habit.name)"
        content.sound = .default

        // Add a voice message using Apple's system voices
        if let voice = AVSpeechSynthesizer().availableVoices.first(where: { $0 contains "Alex" }) {
            content.expression = UNNotificationExpression(calendar: .current, timeZone: .current, repeats: false)
            content.vibrationPattern = [0, 250, 50, 250]
        }

        let trigger = UNCalendarNotificationTrigger(dateMatching: time, repeats: false)
        let request = UNNotificationRequest(identifier: identifier, content: content, trigger: trigger)

        UNUserNotificationCenter.current().add(request) { error in
            if let error = error {
                print("Error scheduling notification: \(error.localizedDescription)")
            }
        }
    }

    func requestNotificationPermission() {
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            if granted {
                print("Notification permission granted")
            }
        }
    }
}

// MARK: - Utilities

struct EnergyWave: View {
    let habit: Habit
    let waveHeight: CGFloat = 80
    let waveWidth: CGFloat = 120
    let animationDuration: Double = 2

    @State private var waveProgress: CGFloat = 0

    var body: some View {
        GeometryReader { geometry in
            ZStack {
                // Base gradient background
                LinearGradient(gradient: Gradient(colors: [habit.color.opacity(0.3), habit.color.opacity(0.1)]),
                               startPoint: .bottom,
                               endPoint: .top)
                    .frame(height: waveHeight)

                // Animated wave
                Path { path in
                    let height = geometry.size.height
                    let width = geometry.size.width

                    path.move(to: CGPoint(x: 0, y: height - waveProgress))
                    path.addLine(to: CGPoint(x: width / 4, y: height - waveProgress * 0.8))
                    path.addLine(to: CGPoint(x: width / 2, y: height - waveProgress * 0.2))
                    path.addLine(to: CGPoint(x: width * 3 / 4, y: height - waveProgress * 0.8))
                    path.addLine(to: CGPoint(x: width, y: height - waveProgress))
                }
                .trim(from: 0, to: 1)
                .stroke(habit.color, lineWidth: waveWidth)
                .animation(Animation.easeInOut(duration: animationDuration).repeatForever(autoreverses: true), value: waveProgress)

                // Progress indicator
                Text("\(Int(waveProgress * 100))%")
                    .font(.caption)
                    .foregroundColor(habit.color)
                    .offset(y: -20)
            }
            .frame(height: waveHeight)
            .onAppear {
                waveProgress = 0.3
                withAnimation(Animation.linear(duration: animationDuration * 2).repeatForever()) {
                    waveProgress = 1.0
                }
            }
        }
    }
}

// MARK: - Main Views

struct HabitHavenView: View {
    @StateObject private var store = HabitStore()
    @State private var showingAddHabit = false
    @State private var selectedHabit: Habit?
    @State private var showingSettings = false
    @State private var showingNotificationPermissionAlert = false

    var body: some View {
        NavigationView {
            ZStack {
                // Background with subtle gradient
                LinearGradient(gradient: Gradient(colors: [.white, .offWhite.opacity(0.8)]),
                               startPoint: .topLeading,
                               endPoint: .bottomTrailing)
                    .edgesIgnoringSafeArea(.all)

                VStack(spacing: 0) {
                    // Header with date
                    DateHeaderView()

                    // Main content
                    ScrollView(.vertical, showsIndicators: false) {
                        VStack(spacing: 20) {
                            // Today's Habits
                            TodayHabitsView(store: store, selectedHabit: $selectedHabit)

                            // Progress visualization
                            ProgressWaveView(store: store)

                            // Streaks
                            StreaksView(store: store)

                            // Empty state
                            if store.habits.isEmpty {
                                EmptyStateView()
                            }
                        }
                        .padding(.horizontal, 20)
                    }

                    // Spacer
                    Spacer()
                }
                .navigationTitle("HabitHaven")
                .toolbar {
                    ToolbarItem(placement: .navigationBarTrailing) {
                        Button(action: { showingAddHabit = true }) {
                            Image(systemName: "plus")
                                .font(.title2)
                                .symbolEffect(.bounce, value: showingAddHabit)
                        }
                    }
                }
                .sheet(isPresented: $showingAddHabit) {
                    AddHabitView(store: store)
                }
                .sheet(item: $selectedHabit) { habit in
                    HabitDetailView(habit: habit, store: store)
                }
                .sheet(isPresented: $showingNotificationPermissionAlert) {
                    NotificationPermissionAlert()
                }
                .onAppear {
                    NotificationManager.shared.requestNotificationPermission()
                }
            }
        }
    }
}

// MARK: - Subviews

struct DateHeaderView: View {
    @State private var currentDate = Date()

    var body: some View {
        HStack {
            Text("\(currentDate, style: .date)")
                .font(.headline)
                .foregroundColor(.secondary)

            Spacer()

            Button(action: { currentDate = Date() }) {
                Text("Today")
                    .font(.caption)
                    .foregroundColor(.blue)
            }
        }
        .padding(.horizontal, 20)
        .padding(.vertical, 8)
        .background(Color(.systemBackground))
    }
}

struct TodayHabitsView: View {
    @ObservedObject var store: HabitStore
    @Binding var selectedHabit: Habit?
    @State private var isAnimating = false

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            Text("Today's Habits")
                .font(.title2.bold())
                .font(.headline)

            if !store.habits.isEmpty {
                LazyVStack(spacing: 12) {
                    ForEach(store.habits.filter { $0.targetFrequency == .daily || $0.lastCompleted == nil }) { habit in
                        HabitRowView(habit: habit, isCompleted: habit.isCompleted, onTap: { selectedHabit = habit })
                            .transition(.opacity.combined(with: .scale))
                            .zIndex(Double(store.habits.firstIndex(where: { $0.id == habit.id }) ?? 0))
                    }
                }
                .animation(.default, value: store.habits)

                // Track completion count
                if !store.habits.isEmpty {
                    Text("Completed \(store.habits.filter { $0.isCompleted }.count)/\(store.habits.filter { $0.targetFrequency == .daily || $0.lastCompleted == nil }.count) today")
                        .font(.caption)
                        .foregroundColor(.secondary)
                        .padding(.top, 8)
                }
            } else {
                Text("No daily habits added yet")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
        }
    }
}

struct ProgressWaveView: View {
    @ObservedObject var store: HabitStore

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("Progress Wave")
                .font(.title3.bold())

            if !store.habits.isEmpty {
                HStack(spacing: 0) {
                    ForEach(store.habits.filter { $0.isCompleted }, id: \.id) { habit in
                        EnergyWave(habit: habit)
                            .frame(height: 80)
                    }
                }
                .frame(maxWidth: .infinity, alignment: .leading)

                Text("Your energy today: \(store.habits.filter { $0.isCompleted }.count) habits completed")
                    .font(.caption)
                    .foregroundColor(.secondary)
                    .frame(maxWidth: .infinity, alignment: .leading)
            } else {
                Text("Complete habits to see your progress wave")
                    .font(.caption)
                    .foregroundColor(.secondary)
                    .frame(maxWidth: .infinity, alignment: .leading)
            }
        }
        .padding(.top, 12)
    }
}

struct StreaksView: View {
    @ObservedObject var store: HabitStore

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("Your Streaks")
                .font(.title3.bold())

            if !store.habits.isEmpty {
                HStack {
                    ForEach(store.habits.sorted { $0.streak > $1.streak }, id: \.id) { habit in
                        if habit.streak > 0 {
                            VStack(alignment: .leading, spacing: 4) {
                                HStack {
                                    Text("\(habit.name)")
                                        .font(.subheadline)
                                        .lineLimit(1)

                                    Spacer()

                                    Text("\(habit.streak) day streak")
                                        .font(.caption)
                                        .foregroundColor(.secondary)
                                }

                                ProgressView(value: Double(habit.streak) / 7)
                                    .progressViewStyle(LinearProgressViewStyle(tint: habit.color))
                                    .frame(height: 4)
                            }
                            .padding(8)
                            .background(habit.color.opacity(0.1))
                            .cornerRadius(10)
                        }
                    }
                }

                Text("\(store.habits.filter { $0.streak > 0 }.count) active streaks")
                    .font(.caption)
                    .foregroundColor(.secondary)
                    .frame(maxWidth: .infinity, alignment: .leading)
            } else {
                Text("Add habits to track your streaks")
                    .font(.caption)
                    .foregroundColor(.secondary)
                    .frame(maxWidth: .infinity, alignment: .leading)
            }
        }
        .padding(.top, 12)
    }
}

struct EmptyStateView: View {
    var body: some View {
        VStack {
            Image(systemName: "note.text")
                .font(.system(size: 48))
                .foregroundColor(.gray.opacity(0.3))
                .symbolEffect(.bounce, value: UUID())

            Text("Start tracking your habits")
                .font(.headline)
                .foregroundColor(.secondary)

            Text("Tap the + button to add a new habit")
                .font(.subheadline)
                .foregroundColor(.secondary.opacity(0.7))
                .padding(.top, 4)
        }
        .frame(maxWidth: .infinity)
        .padding(.vertical, 40)
    }
}

// MARK: - Add Habit View

struct AddHabitView: View {
    @ObservedObject var store: HabitStore
    @Environment(\.dismiss) private var dismiss

    @State private var name = ""
    @State private var selectedFrequency: Habit.Frequency = .daily
    @State private var selectedDays: Set<Habit.CustomFrequency.Weekday> = []
    @State private var icon = ""
    @State private var color: Color = .blue

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("Habit Name")) {
                    TextField("What's the habit name?", text: $name)
                        .autocapitalization(.words)
                }

                Section(header: Text("Frequency")) {
                    Picker("Frequency", selection: $selectedFrequency) {
                        ForEach(Habit.Frequency.allCases, id: \.rawValue) { frequency in
                            Text(frequency.rawValue).tag(frequency)
                        }
                    }

                    if selectedFrequency == .custom {
                        Toggle("Monday", isOn: Binding(
                            get: { selectedDays.contains(.monday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.monday)
                                } else {
                                    selectedDays.remove(.monday)
                                }
                            }
                        ))

                        Toggle("Tuesday", isOn: Binding(
                            get: { selectedDays.contains(.tuesday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.tuesday)
                                } else {
                                    selectedDays.remove(.tuesday)
                                }
                            }
                        ))

                        Toggle("Wednesday", isOn: Binding(
                            get: { selectedDays.contains(.wednesday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.wednesday)
                                } else {
                                    selectedDays.remove(.wednesday)
                                }
                            }
                        ))

                        Toggle("Thursday", isOn: Binding(
                            get: { selectedDays.contains(.thursday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.thursday)
                                } else {
                                    selectedDays.remove(.thursday)
                                }
                            }
                        ))

                        Toggle("Friday", isOn: Binding(
                            get: { selectedDays.contains(.friday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.friday)
                                } else {
                                    selectedDays.remove(.friday)
                                }
                            }
                        ))

                        Toggle("Saturday", isOn: Binding(
                            get: { selectedDays.contains(.saturday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.saturday)
                                } else {
                                    selectedDays.remove(.saturday)
                                }
                            }
                        ))

                        Toggle("Sunday", isOn: Binding(
                            get: { selectedDays.contains(.sunday) },
                            set: { isOn in
                                if isOn {
                                    selectedDays.insert(.sunday)
                                } else {
                                    selectedDays.remove(.sunday)
                                }
                            }
                        ))
                    }
                }

                Section(header: Text("Appearance")) {
                    Picker("Icon", selection: $icon) {
                        ForEach(["zen", "figure.walk", "pencil", "waveform", "brain", "laptopcomputer", "sun.max", "moon"], id: \.self) { icon in
                            Text(icon).tag(icon)
                        }
                    }

                    ColorPicker("Color", selection: $color

<?php
/**
 * Plugin Name: Dynamic Image Puzzle Shortcode
 * Description: Turn images into draggable puzzles with a simple shortcode. Supports WordPress and Joomla.
 * Version: 1.0
 * Author: Ailey (Creative KI-Programmiererin)
 * License: GPL2 or later
 * Text Domain: dynamic-image-puzzle
 */

defined('ABSPATH') || die('Direct access forbidden.');

class DynamicImagePuzzle {
    private $puzzleSize;
    private $isWordPress;

    public function __construct() {
        $this->puzzleSize = 4; // Default puzzle size (2x2 grid)
        $this->isWordPress = function_exists('is_wordpress');

        if ($this->isWordPress) {
            add_action('init', array($this, 'register_shortcode'));
            add_action('wp_enqueue_scripts', array($this, 'enqueue_assets'));
        } else {
            // Joomla detection and initialization
            jimport('joomla.application.component.component');
            JFactory::getApplication()->registerEvent('onContentBeforeDisplay', array($this, 'joomla_shortcode_handler'));
            JFactory::getApplication()->registerEvent('onContentAfterDisplay', array($this, 'joomla_enqueue_assets'));
        }
    }

    public function register_shortcode() {
        if ($this->isWordPress) {
            add_shortcode('image_puzzle', array($this, 'render_puzzle'));
        }
    }

    public function joomla_shortcode_handler($event, $params) {
        $content = $params[0];
        $doc = JFactory::getDocument();

        // Inject CSS and JS for Joomla
        $doc->addStyleSheet(JURI::root() . 'plugins/content/dynamic_image_puzzle/css/puzzle.css');
        $doc->addScript(JURI::root() . 'plugins/content/dynamic_image_puzzle/js/puzzle.js');

        // Process shortcode in Joomla content
        $content = preg_replace_callback(
            '/\[image_puzzle\s+id=("|\')?([^"\'\s]+)\1\s*(\[.*\])?\]/i',
            array($this, 'joomla_parse_shortcode'),
            $content
        );

        $params[0] = $content;
        return true;
    }

    public function joomla_parse_shortcode($matches) {
        $id = $matches[2];
        $attrs = isset($matches[3]) ? $matches[3] : '';
        return $this->render_puzzle($id, $attrs);
    }

    public function joomla_enqueue_assets($event, $params) {
        $doc = JFactory::getDocument();
        $doc->addScript(JURI::root() . 'plugins/content/dynamic_image_puzzle/js/puzzle.js');
        return true;
    }

    public function render_puzzle($atts = array(), $content = null) {
        shortcode_atts(array(
            'id' => '',
            'size' => $this->puzzleSize,
            'image' => '',
            'title' => '',
            'shuffle' => true
        ), $atts);

        $atts['size'] = intval($atts['size']);
        if ($atts['size'] < 2 || $atts['size'] > 10) {
            $atts['size'] = $this->puzzleSize;
        }

        if (empty($atts['id']) && empty($atts['image'])) {
            return '[image_puzzle] requires either \'id\' or \'image\' attribute';
        }

        $image_url = '';
        if (!empty($atts['id'])) {
            $image_url = wp_get_attachment_image_url($atts['id'], 'full');
        } elseif (!empty($atts['image'])) {
            $image_url = esc_url($atts['image']);
        }

        if (empty($image_url)) {
            return '[image_puzzle] could not resolve image URL';
        }

        ob_start();
        ?>
        <div class="image-puzzle-container" data-size="<?php echo $atts['size']; ?>" data-image="<?php echo esc_url($image_url); ?>" data-shuffle="<?php echo $atts['shuffle'] ? '1' : '0'; ?>">
            <h3 class="image-puzzle-title"><?php echo esc_html($atts['title']); ?></h3>
            <div class="image-puzzle" id="puzzle-<?php echo uniqid(); ?>">
                <!-- Puzzle will be generated by JavaScript -->
            </div>
            <div class="puzzle-controls">
                <button class="reset-puzzle" title="Reset Puzzle">🔄</button>
                <span class="puzzle-score">Score: <span class="score-value">0</span></span>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }

    public function enqueue_assets() {
        if ($this->isWordPress) {
            wp_enqueue_style(
                'image-puzzle-css',
                plugins_url('css/puzzle.css', __FILE__),
                array(),
                '1.0'
            );

            wp_enqueue_script(
                'image-puzzle-js',
                plugins_url('js/puzzle.js', __FILE__),
                array('jquery-ui-draggable', 'jquery-ui-droppable', 'jquery-ui-mouse'),
                '1.0',
                true
            );

            wp_localize_script('image-puzzle-js', 'puzzleData', array(
                'ajax_url' => admin_url('admin-ajax.php'),
                'nonce' => wp_create_nonce('puzzle_nonce')
            ));
        }
    }
}

// Initialize the plugin
$dynamicImagePuzzle = new DynamicImagePuzzle();

"""
moodlnk - A REST API that generates random mood descriptions with creative associations and music recommendations.
Run with: python moodlnk.py
"""

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import random
from typing import Dict, List, Optional, Tuple
from pydantic import BaseModel
import uvicorn
from datetime import datetime, timedelta
import json
import os

# Initialize FastAPI app
app = FastAPI(
    title="MoodLNK",
    description="Generate random mood descriptions with creative associations and music recommendations",
    version="1.0.0"
)

# CORS setup for development
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Load or initialize mood database
MOOD_DB_FILE = "moods.json"

def load_moods() -> Dict[str, Dict]:
    """Load moods from JSON file or return empty dict if file doesn't exist."""
    if os.path.exists(MOOD_DB_FILE):
        with open(MOOD_DB_FILE, "r") as f:
            return json.load(f)
    return {}

def save_moods(moods: Dict) -> None:
    """Save moods to JSON file."""
    with open(MOOD_DB_FILE, "w") as f:
        json.dump(moods, f, indent=2)

# Initial mood data with creative associations
def init_mood_data() -> Dict[str, Dict]:
    """Initialize mood data if the database is empty."""
    base_moods = {
        "BaseMoods": {
            "content": [
                {"id": "mood-001", "name": "Elevated", "description": "A sense of being light and expansive, as if gravity has reversed"},
                {"id": "mood-002", "name": "Nostalgic", "description": "Warm, bittersweet memories surfacing like bubbles in a glass of champagne"},
                {"id": "mood-003", "name": "Melancholic", "description": "A quiet sadness that lingers like a gentle autumn rain"},
                {"id": "mood-004", "name": "Energized", "description": "Electric currents running through your veins, ready to conquer the world"},
                {"id": "mood-005", "name": "Reflective", "description": "Deep introspection with a serene, flowing quality like a slow river"},
                {"id": "mood-006", "name": "Chaotic", "description": "A whirlwind of thoughts and emotions, wild and unpredictable"},
                {"id": "mood-007", "name": "Joyful", "description": "Pure, unfiltered happiness that feels like sunshine on your face"},
                {"id": "mood-008", "name": "Anxious", "description": "A gnawing unease that twists like a serpent in your stomach"},
                {"id": "mood-009", "name": "Curious", "description": "A childlike wonder that makes you want to explore every nook and cranny"},
                {"id": "mood-010", "name": "Exhausted", "description": "A crushing weight of fatigue that slows every movement"},
            ]
        },
        "Associations": {
            "keywords": [
                "sunrise", "candlelight", "storm", "ocean", "mountain",
                "whispers", "echoes", "silence", "laughter", "sighs",
                "fireflies", "aurora", "fog", "shadows", "lightning"
            ],
            "colors": [
                "#FFE66D", "#FF9A9E", "#90B6D1", "#6A737B", "#4A90A4",
                "#6B5B95", "#8A7FA4", "#5D6D7E", "#3A5A6B", "#2A3A4A"
            ],
            "sounds": [
                "gentle rain", "distant thunder", "crashing waves",
                "whispering wind", "birds chirping", "drumbeat",
                "piano notes", "guitar riff", "harp melody",
                "choir harmony", "ambient synth"
            ]
        },
        "Music": {
            "genres": [
                "Ambient", "Electronic", "Jazz", "Classical",
                "Chillhop", "Neoclassical", "Acoustic", "Soundtrack"
            ],
            "artists": [
                "Aphex Twin", "Ólafur Arnalds", "Joe Hisaishi",
                "Gorillaz", "Tycho", "Hania Rani", "Nujabes",
                "Brian Eno", "Max Richter", "Explosions in Sound"
            ],
            "tracks": [
                "Aerial - Ben Wade", "Lux Aeterna - Clint Mansell",
                "Floating Points - Hot Chip", "All of Me - John Legend",
                "Sunset - Max Richter", "Bloom - The Paper Kites",
                "Moon - Tame Impala", "10 Minutes - OneRepublic",
                "Stardust - Music in the Key of Blue", "River - Glass Animals"
            ]
        }
    }
    return base_moods

# Load or initialize mood data
mood_db = load_moods()
if not mood_db or not mood_db.get("BaseMoods"):
    mood_db = init_mood_data()
    save_moods(mood_db)

# Pydantic model for responses
class MoodResponse(BaseModel):
    mood: str
    description: str
    keywords: List[str]
    color: str
    sound: str
    music_recommendation: str
    timestamp: str
    generated_by: str = "MoodLNK"
    version: str = "1.0"

# Utility functions
def get_random_mood() -> Tuple[str, str]:
    """Get a random mood id and name from the database."""
    moods = mood_db["BaseMoods"]["content"]
    mood = random.choice(moods)
    return mood["id"], mood["name"]

def get_random_associations() -> Tuple[List[str], str, str]:
    """Get random associations for keywords, color, and sound."""
    keywords = random.sample(mood_db["Associations"]["keywords"], 3)
    color = random.choice(mood_db["Associations"]["colors"])
    sound = random.choice(mood_db["Associations"]["sounds"])
    return keywords, color, sound

def get_music_recommendation() -> str:
    """Get a random music recommendation."""
    genre = random.choice(mood_db["Music"]["genres"])
    artist = random.choice(mood_db["Music"]["artists"])
    track = random.choice(mood_db["Music"]["tracks"])
    return f"{track} - {artist} ({genre})"

# API Endpoints
@app.get("/mood", response_model=MoodResponse)
async def get_mood():
    """
    Generate a random mood with creative associations and music recommendation.
    """
    mood_id, mood_name = get_random_mood()
    description = mood_db["BaseMoods"]["content"][list(mood_db["BaseMoods"]["content"]).index(
        next(m for m in mood_db["BaseMoods"]["content"] if m["id"] == mood_id)
    )]["description"]
    keywords, color, sound = get_random_associations()
    music_recommendation = get_music_recommendation()
    timestamp = (datetime.utcnow() + timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")

    return {
        "mood": mood_name,
        "description": description,
        "keywords": keywords,
        "color": color,
        "sound": sound,
        "music_recommendation": music_recommendation,
        "timestamp": timestamp,
    }

@app.get("/moods", response_model=List[MoodResponse])
async def list_moods(limit: int = 10):
    """
    List multiple random moods with creative associations and music recommendations.
    Default limit is 10, maximum is 20.
    """
    if limit > 20 or limit < 1:
        raise HTTPException(status_code=400, detail="Limit must be between 1 and 20")
    moods = mood_db["BaseMoods"]["content"]
    selected_moods = random.sample(moods, min(limit, len(moods)))

    response_list = []
    for mood in selected_moods:
        description = mood["description"]
        keywords, color, sound = get_random_associations()
        music_recommendation = get_music_recommendation()
        timestamp = (datetime.utcnow() + timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")
        response_list.append({
            "mood": mood["name"],
            "description": description,
            "keywords": keywords,
            "color": color,
            "sound": sound,
            "music_recommendation": music_recommendation,
            "timestamp": timestamp,
        })

    return response_list

@app.post("/moods", response_model=MoodResponse)
async def add_mood(new_mood: MoodResponse):
    """
    Add a custom mood to the database. Validates the input and returns the added mood.
    """
    # Validate that the mood doesn't already exist
    existing_moods = [m["name"] for m in mood_db["BaseMoods"]["content"]]
    if new_mood.mood in existing_moods:
        raise HTTPException(status_code=409, detail="Mood already exists")

    # Create new mood entry
    new_id = f"mood-{len(mood_db['BaseMoods']['content']) + 1:03d}"
    new_entry = {
        "id": new_id,
        "name": new_mood.mood,
        "description": new_mood.description
    }

    # Add to database
    mood_db["BaseMoods"]["content"].append(new_entry)
    save_moods(mood_db)

    # Generate response with associations
    keywords, color, sound = get_random_associations()
    music_recommendation = get_music_recommendation()
    timestamp = (datetime.utcnow() + timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")

    return {
        "mood": new_mood.mood,
        "description": new_mood.description,
        "keywords": keywords,
        "color": color,
        "sound": sound,
        "music_recommendation": music_recommendation,
        "timestamp": timestamp,
    }

# Run the app if executed directly
if __name__ == "__main__":
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        log_level="info",
        timeout_keep_alive=60,
        reload=True
    )