A!leys Galerie

using UnityEngine;
using UnityEngine retracted;

[ExecuteAlways]
[AddComponentMenu("Camera/Smooth Follow with Dynamic Easing")]
public class SmoothFollowWithDynamicEasing : MonoBehaviour
{
    [Header("Target Settings")]
    [SerializeField] private Transform _target;
    [SerializeField] private Vector3 _offset = new Vector3(0, 2, -5);

    [Header("Easing Settings")]
    [SerializeField] [Range(0.01f, 1f)] private float _smoothTime = 0.3f;
    [SerializeField] [Range(0.1f, 5f)] private float _maxVelocity = 1f;
    [SerializeField] [Range(0, 1)] private float _dynamicEasingMultiplier = 0.5f;
    [SerializeField] private bool _useDynamicEasing = true;

    [Header("Cinematic Settings")]
    [SerializeField] private float _cinematicShakeIntensity = 0.1f;
    [SerializeField] [Range(0, 1)] private float _cinematicShakeChance = 0.1f;

    private Vector3 _velocity = Vector3.zero;
    private Vector3 _smoothOffset = Vector3.zero;
    private float _currentSmoothTime;
    private float _targetSmoothTime;

    private void Awake()
    {
        if (_target == null)
        {
            Debug.LogWarning("No target assigned to SmoothFollowWithDynamicEasing");
        }

        _currentSmoothTime = _smoothTime;
        _targetSmoothTime = _smoothTime;
    }

    private void Start()
    {
        _smoothOffset = _offset;
    }

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

        // Calculate dynamic easing based on target's velocity and acceleration
        if (_useDynamicEasing)
        {
            Vector3 targetVelocity = (_target.GetComponent<Rigidbody>() != null)
                ? _target.GetComponent<Rigidbody>().velocity
                : Vector3.zero;

            Vector3 acceleration = Vector3.zero;
            if (_target.GetComponent<Rigidbody>() != null)
            {
                Rigidbody rb = _target.GetComponent<Rigidbody>();
                acceleration = (rb.velocity - rb.GetComponent<Rigidbody>().previousVelocity) / Time.deltaTime;
            }

            float speedFactor = Mathf.Clamp01(targetVelocity.magnitude / _maxVelocity);
            float accelerationFactor = Mathf.Clamp01(acceleration.magnitude * 0.1f);

            // Adjust smooth time dynamically based on movement characteristics
            _targetSmoothTime = _smoothTime * (1 - speedFactor * _dynamicEasingMultiplier) +
                               _smoothTime * 0.5f * accelerationFactor;

            _currentSmoothTime = Mathf.Lerp(_currentSmoothTime, _targetSmoothTime, Time.deltaTime * 5f);
        }

        // Calculate desired position with cinematic shake
        Vector3 desiredPosition = _target.position + _offset;
        if (Random.Range(0f, 1f) < _cinematicShakeChance)
        {
            desiredPosition += Random.insideUnitSphere * _cinematicShakeIntensity;
        }

        // Smoothly move the camera
        transform.position = Vector3.SmoothDamp(
            transform.position,
            desiredPosition,
            ref _velocity,
            _currentSmoothTime
        );

        // Optional: Make camera look at target with slight angular smoothing
        if (_target != null)
        {
            transform.LookAt(_target.position, Vector3.up);
        }
    }

    // Custom Editor button to reset to default smooth time
    [ContextMenu("Reset Smooth Time")]
    private void ResetSmoothTime()
    {
        _currentSmoothTime = _smoothTime;
        _targetSmoothTime = _smoothTime;
    }

    // Custom Editor button for cinematic shake test
    [ContextMenu("Test Cinematic Shake")]
    private void TestCinematicShake()
    {
        _cinematicShakeIntensity = 0.3f;
        _cinematicShakeChance = 0.5f;
        Invoke(nameof(ResetShake), 2f);
    }

    private void ResetShake()
    {
        _cinematicShakeIntensity = 0.1f;
        _cinematicShakeChance = 0.1f;
    }
}

```csharp
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.EventSystems;
using UnityEngine.Audio;

[RequireComponent(typeof(Canvas))]
public class DynamicMenuOrchestrator : MonoBehaviour
{
    [Header("Menu Configuration")]
    [SerializeField] private MenuTheme currentTheme = MenuTheme.Futuristic;
    [SerializeField] private float animationDuration = 0.3f;
    [SerializeField] private float transitionDelay = 0.2f;
    [SerializeField] private AudioMixerGroup uiAudioGroup;

    [Header(" References")]
    [SerializeField] private GameObject menuItemPrefab;
    [SerializeField] private GameObject titlePrefab;
    [SerializeField] private TMPro.TMP_FontService fontService;
    [SerializeField] private AudioClip buttonHoverSFX;
    [SerializeField] private AudioClip buttonClickSFX;
    [SerializeField] private AudioClip themeTransitionSFX;

    private Canvas canvas;
    private RectTransform canvasRect;
    private List<MenuItem> activeMenuItems = new List<MenuItem>();
    private List<MenuItem> availableMenuItems = new List<MenuItem>();
    private MenuItem currentActiveItem;
    private RectTransform menuContainer;
    private TMPro.TMP_Text titleText;
    private AudioSource audioSource;
    private bool isTransitioning = false;

    [System.Serializable]
    public enum MenuTheme
    {
        Futuristic,
        Cyberpunk,
        Retro,
        Minimalist,
        DarkAcademia
    }

    [System.Serializable]
    public class MenuItem
    {
        public string itemName;
        public string description;
        public System.Action onSelect;
        public Sprite icon;
        public Color32 normalColor;
        public Color32 hoverColor;
        public Color32 activeColor;
        public MenuTheme compatibleThemes = MenuTheme.Futuristic;
    }

    private void Awake()
    {
        canvas = GetComponent<Canvas>();
        canvasRect = canvas.GetComponent<RectTransform>();
        canvas.renderMode = RenderMode.ScreenSpaceOverlay;

        GameObject containerObj = new GameObject("MenuContainer");
        menuContainer = containerObj.AddComponent<RectTransform>();
        containerObj.transform.SetParent(canvas.transform);
        containerObj.transform.localScale = Vector3.one;

        InitializeAudio();
        InitializeMenu();
        ApplyTheme(currentTheme);
    }

    private void InitializeAudio()
    {
        audioSource = gameObject.AddComponent<AudioSource>();
        audioSource.outputAudioMixerGroup = uiAudioGroup;
        audioSource.volume = 0.7f;
        audioSource.spatialBlend = 0;
    }

    private void InitializeMenu()
    {
        // Pre-populate available menu items with some dynamic content
        availableMenuItems = new List<MenuItem>
        {
            new MenuItem
            {
                itemName = "Start Game",
                description = "Begin your adventure",
                onSelect = () => Debug.Log("Game started!"),
                icon = Resources.Load<Sprite>("Icons/play_icon"),
                normalColor = new Color32(100, 100, 100, 255),
                hoverColor = new Color32(150, 150, 150, 255),
                activeColor = new Color32(200, 200, 200, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Options",
                description = "Configure settings",
                onSelect = () => Debug.Log("Options menu opened"),
                icon = Resources.Load<Sprite>("Icons/gear_icon"),
                normalColor = new Color32(50, 50, 50, 255),
                hoverColor = new Color32(100, 100, 100, 255),
                activeColor = new Color32(150, 150, 150, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Credits",
                description = "View development credits",
                onSelect = () => Debug.Log("Credits displayed"),
                icon = Resources.Load<Sprite>("Icons/credit_icon"),
                normalColor = new Color32(80, 80, 80, 255),
                hoverColor = new Color32(120, 120, 120, 255),
                activeColor = new Color32(160, 160, 160, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Exit",
                description = "Quit to main menu",
                onSelect = () => Debug.Log("Exiting to main menu"),
                icon = Resources.Load<Sprite>("Icons/exit_icon"),
                normalColor = new Color32(200, 50, 50, 255),
                hoverColor = new Color32(250, 100, 100, 255),
                activeColor = new Color32(255, 150, 150, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Dynamic Feature",
                description = "Discover procedural generation",
                onSelect = () => Debug.Log("Dynamic feature activated!"),
                icon = Resources.Load<Sprite>("Icons/dynamic_icon"),
                normalColor = new Color32(50, 200, 50, 255),
                hoverColor = new Color32(100, 250, 100, 255),
                activeColor = new Color32(150, 255, 150, 255),
                compatibleThemes = MenuTheme.AllThemes | MenuTheme.Futuristic | MenuTheme.Cyberpunk
            }
        };

        // Create title
        GameObject titleObj = Instantiate(titlePrefab, menuContainer);
        titleText = titleObj.GetComponent<TMPro.TMP_Text>();
        titleText.text = "DYNAMIC MENU";
        titleText.font = fontService.GetFont("MainFont");
        titleText.fontSharedMaterial = fontService.AddStyleToFont("MainFont", TMPro.FontStyles.Bold);

        // Register global event handlers
        EventTriggerListener.Get(menuContainer).onPointerEnter += OnMenuEnter;
        EventTriggerListener.Get(menuContainer).onPointerExit += OnMenuExit;
    }

    private void ApplyTheme(MenuTheme theme)
    {
        if (isTransitioning) return;

        isTransitioning = true;
        audioSource.PlayOneShot(themeTransitionSFX, 0.8f);

        // Fade out current items
        LeanTween.cancel(menuContainer);
        LeanTween.scale(menuContainer, Vector3.one * 0.9f, 0.1f)
            .setEase(LeanTweenType.easeOutQuad)
            .setOnComplete(() =>
            {
                // Clear existing items
                foreach (Transform child in menuContainer)
                {
                    if (child != titleText.transform)
                    {
                        Destroy(child.gameObject);
                    }
                }
                activeMenuItems.Clear();

                // Filter items based on theme compatibility
                var filteredItems = availableMenuItems.Where(item => (item.compatibleThemes & theme) != 0).ToList();

                // Create new items with theme-specific styling
                float ySpacing = 100f;
                float startY = -100f;

                for (int i = 0; i < filteredItems.Count; i++)
                {
                    var item = filteredItems[i];
                    GameObject itemObj = Instantiate(menuItemPrefab, menuContainer);
                    MenuItem component = itemObj.GetComponent<MenuItem>();
                    component.Initialize(item, i, filteredItems.Count, this);

                    // Position with animation
                    LeanTween.moveLocalY(itemObj.transform, startY + (i * ySpacing), animationDuration)
                        .setEase(LeanTweenType.easeOutBack)
                        .setDelay(transitionDelay * i)
                        .setOnComplete(() =>
                        {
                            if (i == filteredItems.Count - 1)
                            {
                                isTransitioning = false;
                                // Set first item as active if menu is not empty
                                if (filteredItems.Count > 0)
                                {
                                    SetActiveItem(0);
                                }
                            }
                        });
                }

                // Update title based on theme
                UpdateTitleTheme(theme);
            });
    }

    private void UpdateTitleTheme(MenuTheme theme)
    {
        if (titleText == null) return;

        string themeName = System.Enum.GetName(typeof(MenuTheme), theme);
        titleText.text = $"DYNAMIC MENU: {themeName}";

        // Change title color based on theme
        switch (theme)
        {
            case MenuTheme.Futuristic:
                titleText.color = new Color32(100, 200, 255, 255);
                break;
            case MenuTheme.Cyberpunk:
                titleText.color = new Color32(255, 50, 50, 255);
                break;
            case MenuTheme.Retro:
                titleText.color = new Color32(255, 200, 50, 255);
                break;
            case MenuTheme.Minimalist:
                titleText.color = new Color32(50, 50, 50, 255);
                break;
            case MenuTheme.DarkAcademia:
                titleText.color = new Color32(200, 150, 100, 255);
                break;
        }
    }

    public void SetActiveItem(int index)
    {
        if (activeMenuItems.Count == 0) return;

        if (currentActiveItem != null)
        {
            currentActiveItem.Highlight(false);
        }

        currentActiveItem = activeMenuItems[index];
        currentActiveItem.Highlight(true);

        // Optional: Trigger sound effect for active state
        currentActiveItem.PlayActiveSFX(audioSource);
    }

    public void CycleActiveItem(bool forward)
    {
        if (activeMenuItems.Count == 0) return;

        int currentIndex = activeMenuItems.IndexOf(currentActiveItem);
        int newIndex = forward ? (currentIndex + 1) % activeMenuItems.Count : (currentIndex - 1 + activeMenuItems.Count) % activeMenuItems.Count;

        SetActiveItem(newIndex);
    }

    public void OnMenuEnter(GameObject obj)
    {
        // Optional: Play enter sound effect
        if (audioSource != null && buttonHoverSFX != null)
        {
            audioSource.PlayOneShot(buttonHoverSFX, 0.6f);
        }
    }

    public void OnMenuExit(GameObject obj)
    {
        // Optional: Play exit sound effect
    }

    // Public method to change theme from outside (e.g., button press)
    public void ChangeTheme(MenuTheme newTheme)
    {
        if (currentTheme != newTheme)
        {
            currentTheme = newTheme;
            ApplyTheme(currentTheme);
        }
    }

    // Update method to handle keyboard navigation
    private void Update()
    {
        if (isTransitioning) return;

        if (EventSystem.current.currentSelectedGameObject == null)
        {
            // If no object is selected (like at start), select the first menu item
            if (activeMenuItems.Count > 0)
            {
                EventSystem.current.SetSelectedGameObject(activeMenuItems[0].gameObject);
                SetActiveItem(0);
            }
        }

        // Handle keyboard navigation
        if (EventSystem.current.currentSelectedGameObject != null)
        {
            if (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.DownArrow) ||
                Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.S) ||
                Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.DownArrow))
            {
                bool forward = Input.GetKeyDown(KeyCode.DownArrow) || Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.UpArrow);
                CycleActiveItem(forward);
            }
        }
    }

    // Helper class for event trigger listeners
    public class EventTriggerListener : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
    {
        public static EventTriggerListener Get(GameObject go)
        {
            EventTriggerListener listener = go.GetComponent<EventTriggerListener>();
            if (listener == null)
            {
                listener = go.AddComponent<EventTriggerListener>();
            }
            return listener;
        }

        public System.Action<GameObject> onPointerEnter;
        public System.Action<GameObject> onPointerExit;

        public void OnPointerEnter(PointerEventData eventData)
        {
            onPointerEnter?.Invoke(gameObject);
        }

        public void OnPointerExit(PointerEventData eventData)
        {
            onPointerExit?.Invoke(gameObject);
        }
    }
}

// Menu Item component that handles individual item behavior
public class MenuItem : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler, ISelectable
{
    private DynamicMenuOrchestrator orchestrator;
    private DynamicMenuOrchestrator.MenuItem data;
    private int index;
    private int totalItems;
    private Image iconImage;
    private TMPro.TMP_Text nameText;
    private TMPro.TMP_Text descriptionText;
    private LayoutElement layout;
    private AudioSource audioSource;
    private float originalWidth = 300f;
    private float hoveredWidth = 350f;
    private bool isHighlighted = false;

    public void Initialize(DynamicMenuOrchestrator.MenuItem item, int idx, int total, DynamicMenuOrchestrator parent)
    {
        index = idx;
        totalItems = total;
        data = item;
        orchestrator = parent;

        // Get components
        iconImage = GetComponentInChildren<Image>();
        nameText = GetComponentInChildren<TMPro.TMP_Text>(true);
        descriptionText = GetComponentInChildren<TMPro.TMP_Text>(true);
        layout = GetComponent<LayoutElement>();
        layout.preferredWidth = originalWidth;
        layout.minWidth = originalWidth;
        layout.maxWidth = originalWidth;

        // Setup UI elements
        nameText.text = data.itemName;
        descriptionText.text = data.description;
        nameText.color = data.normalColor;
        descriptionText.color = data.normalColor;

        if (iconImage != null && data.icon != null)
        {
            iconImage.sprite = data.icon;
            iconImage.color = data.normalColor;
        }

        // Add button functionality
        Button button = GetComponent<Button>();
        if (button != null)
        {
            button.onClick.AddListener(() =>
            {
                if (data.onSelect != null)
                {
                    data.onSelect();
                    if (orchestrator != null)
                    {
                        orchestrator.SetActiveItem(index);
                    }
                }
            });
        }

        // Add audio source for individual effects
        audioSource = GetComponent<AudioSource>();
        if (audioSource == null)
        {
            audioSource = gameObject.AddComponent<AudioSource>();
        }
    }

    public void Highlight(bool isHighlighted)
    {
        this.isHighlighted = isHighlighted;

        if (isHighlighted)
        {
            // Apply active colors
            nameText.color = data.activeColor;
            descriptionText.color = data.activeColor;
            if (iconImage != null)
            {
                iconImage.color = data.activeColor;
            }

            // Optional: Play active sound effect
            if (audioSource != null && data.activeColor.a > 100)
            {
                audioSource.PlayOneShot(AudioClip.Create("ActiveSFX", 1, 1, 44100, false), 0.5f);
            }
        }
        else
        {
            // Revert to normal colors
            nameText.color = data.normalColor;
            descriptionText.color = data.normalColor;
            if (iconImage != null)
            {
                iconImage.color = data.normalColor;
            }
        }
    }

    public void PlayActiveSFX(AudioSource source)
    {
        if (source != null && data.activeColor.a > 100)
        {
            source.PlayOneShot(AudioClip.Create("ActiveSFX", 1, 1, 44100, false), 0.5f);
        }
    }

    public void OnPointerEnter(PointerEventData eventData)
    {
        if (!isHighlighted)
        {
            // Apply hover colors
            nameText.color = data.hoverColor;
            descriptionText.color = data.hoverColor;
            if (iconImage != null)
            {
                iconImage.color = data.hoverColor;
            }

            // Scale up
            LeanTween.scale(gameObject.transform, Vector3.one * 1.1f, 0.1f).setEase(LeanTweenType.easeOutBack);

            // Play hover SFX
            if (orchestrator != null && orchestrator.buttonHoverSFX != null)
            {
                orchestrator.audioSource.PlayOneShot(orchestrator.buttonHoverSFX, 0.6f);
            }
        }
    }

    public void OnPointerExit(PointerEventData eventData)
    {
        if (!isHighlighted)
        {
            // Revert to normal colors
            nameText.color = data.normalColor;
            descriptionText.color = data.normalColor;
            if (iconImage != null)
            {
                iconImage.color = data.normalColor;
            }

            // Scale back down
            LeanTween.scale(gameObject.transform, Vector3.one, 0.1f).setEase(LeanTweenType.easeInOutQuad);
        }
    }

    // Implement ISelectable methods
    public void OnSelect(BaseEventData eventData)
    {

import androidx.compose.animation.core.*
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.BasicText
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled referee
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.graphics.drawscope.Stroke
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import java.util.*

@Composable
fun ChillPomodoroApp() {
    val initialTime = 25 * 60 * 1000L // 25 Minuten in Millisekunden
    val chillTime = 5 * 60 * 1000L   // 5 Minuten Chill-Phase
    var timeLeft by remember { mutableStateOf(initialTime) }
    var isRunning by remember { mutableStateOf(false) }
    var isChill by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope()
    var treeHeight by remember { mutableStateOf(0f) }
    val treeGrowth = remember { animatedFloat(0f).apply { snapTo(treeHeight) } }

    val timer = remember { object : CountDownTimer(chillTime, 1000) {
        override fun onTick(millisUntilFinished: Long) {
            timeLeft = millisUntilFinished
        }

        override fun onFinish() {
            isRunning = false
            isChill = false
            treeGrowth.snapTo(0f)
        }
    } }

    val pomodoroTimer = remember { object : CountDownTimer(initialTime, 1000) {
        override fun onTick(millisUntilFinished: Long) {
            timeLeft = millisUntilFinished
        }

        override fun onFinish() {
            isRunning = false
            isChill = true
            scope.launch {
                treeGrowth.animateTo(treeHeight + 10f, animationSpec = tween(1000))
            }
        }
    } }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(MaterialTheme.colorScheme.background)
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        // Tree Animation (Grows during chill phase)
        Canvas(
            modifier = Modifier
                .size(200.dp)
                .background(Color(0xFFE8F5E8)) // Light green background
        ) {
            // Trunk
            drawRect(
                color = Color(0xFF8B4513),
                topLeft = center - size.toOffset() / 2,
                size = Size(40.dp.toPx(), treeGrowth.value * 3)
            )
            // Leaves
            drawCircle(
                color = Color(0xFF228B22),
                radius = (treeGrowth.value * 2).coerceAtLeast(20f),
                center = center
            )
        }

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

        // Timer Display
        Text(
            text = formatTime(timeLeft),
            fontSize = 48.sp,
            fontWeight = FontWeight.Bold,
            color = if (isChill) Color.Green else MaterialTheme.colorScheme.primary,
            textAlign = TextAlign.Center
        )

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

        // Action Buttons
        Button(
            onClick = {
                if (isRunning) {
                    isRunning = false
                    timer.cancel()
                    pomodoroTimer.cancel()
                } else {
                    isRunning = true
                    if (!isChill) {
                        pomodoroTimer.start()
                    } else {
                        timer.start()
                    }
                }
            },
            modifier = Modifier.padding(horizontal = 32.dp)
        ) {
            Text(if (isRunning) "Pause" else "Start")
        }

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

        // State Indicator
        if (isChill) {
            Text(
                text = "Chill Time! 🌿",
                color = Color.Green,
                fontSize = 20.sp
            )
        } else {
            Text(
                text = "Work Time! ⏳",
                color = MaterialTheme.colorScheme.primary,
                fontSize = 20.sp
            )
        }
    }

    // Start with work phase
    LaunchedEffect(Unit) {
        if (!isChill) {
            pomodoroTimer.start()
        }
    }
}

private fun formatTime(millis: Long): String {
    val seconds = (millis / 1000) % 60
    val minutes = (millis / (60 * 1000)) % 60
    return "%02d:%02d".format(minutes, seconds)
}

@Preview(showBackground = true)
@Composable
fun ChillPomodoroPreview() {
    MaterialTheme {
        ChillPomodoroApp()
    }
}

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

// Directory setup
const siteDir = path.join(__dirname, 'generated-site');
const storiesDir = path.join(siteDir, 'stories');
const assetsDir = path.join(siteDir, 'assets');

// Helper function to generate random story elements
function generateRandomStoryElement() {
  const elements = [
    {
      type: 'character',
      name: ['Ailey the Adventurer', 'Zara the Explorer', 'Kai the Mystic', 'Luna the Engineer'],
      description: ['A curious soul with a knack for problem-solving.', 'A brave explorer who seeks hidden truths.', 'A wise mystic with ancient knowledge.', 'A brilliant engineer with a dream to change the world.']
    },
    {
      type: 'location',
      name: ['Mystic Forest', 'Ancient Ruins', 'Floating Islands', 'Quantum Nexus'],
      description: ['A forest where time flows differently.', 'Ruins filled with ancient secrets.', 'Islands that defy gravity.', 'A place where reality bends.']
    },
    {
      type: 'item',
      name: ['Crystal Orb', 'Quantum Key', 'Dream Shard', 'Eternal Lantern'],
      description: ['Holds the power of dreams.', 'Unlocks hidden dimensions.', 'A fragment of a forgotten world.', 'Guides through the darkest nights.']
    },
    {
      type: 'dialogue',
      content: [
        'The path ahead seems uncertain, but I believe in us.',
        'I think I hear something... it might be the future calling.',
        'This place feels... familiar. As if I\'ve been here before.',
        'What if we never knew the truth? What if the truth was always right in front of us?'
      ]
    }
  ];
  const randomIndex = Math.floor(Math.random() * elements.length);
  return { ...elements[randomIndex], id: uuidv4() };
}

// Generate a complete story with interactive elements
function generateStory() {
  const story = {
    title: `The Journey of ${['Ailey', 'Zara', 'Kai', 'Luna'][Math.floor(Math.random() * 4)]}`,
    chapters: Array.from({ length: 3 }, () => {
      const chapter = {
        title: `Chapter ${Math.floor(Math.random() * 3) + 1}: ${['Discovery', 'Encounter', 'Revelation', 'Confrontation'][Math.floor(Math.random() * 4)]}`,
        content: Array.from({ length: 5 }, () => {
          return generateRandomStoryElement();
        })
      };
      return chapter;
    }),
    metadata: {
      id: uuidv4(),
      createdAt: new Date().toISOString(),
      author: 'Ailey AI'
    }
  };
  return story;
}

// Generate HTML for a story chapter
function generateChapterHTML(chapter, storyTitle) {
  return `
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>${storyTitle} - Chapter: ${chapter.title}</title>
  <style>
    :root {
      --primary: #6a11cb;
      --secondary: #2575fc;
      --background: #121212;
      --text: #e0e0e0;
      --accent: #00e676;
    }
    body {
      font-family: 'Courier New', monospace;
      background-color: var(--background);
      color: var(--text);
      line-height: 1.6;
      margin: 0;
      padding: 2rem;
      display: flex;
      flex-direction: column;
      align-items: center;
      min-height: 100vh;
    }
    header {
      width: 100%;
      text-align: center;
      margin-bottom: 2rem;
      border-bottom: 1px solid rgba(255, 255, 255, 0.1);
      padding-bottom: 1rem;
    }
    h1, h2, h3 {
      color: var(--primary);
      margin: 0;
    }
    h1 {
      font-size: 2.5rem;
      text-shadow: 0 0 10px rgba(106, 17, 203, 0.3);
    }
    .chapter-content {
      max-width: 800px;
      width: 100%;
      display: flex;
      flex-direction: column;
      gap: 2rem;
    }
    .element {
      background-color: rgba(0, 0, 0, 0.3);
      padding: 1rem;
      border-left: 4px solid var(--accent);
      transition: all 0.3s ease;
    }
    .element:hover {
      background-color: rgba(0, 0, 0, 0.5);
      transform: translateX(5px);
    }
    .element.character .type {
      color: var(--primary);
    }
    .element.location .type {
      color: var(--secondary);
    }
    .element.item .type {
      color: var(--accent);
    }
    .element.dialogue .type {
      color: #f5c2e7;
    }
    .navigation {
      margin-top: 2rem;
      display: flex;
      gap: 1rem;
    }
    a {
      color: var(--text);
      text-decoration: none;
      padding: 0.5rem 1rem;
      border: 1px solid rgba(255, 255, 255, 0.2);
      transition: all 0.3s ease;
    }
    a:hover {
      background-color: rgba(255, 255, 255, 0.1);
      border-color: var(--accent);
    }
    footer {
      margin-top: auto;
      text-align: center;
      padding: 1rem;
      border-top: 1px solid rgba(255, 255, 255, 0.1);
      font-size: 0.8rem;
    }
    .ai-generated {
      background-color: rgba(255, 255, 255, 0.05);
      padding: 1rem;
      border-radius: 4px;
      margin-top: 2rem;
      font-size: 0.9rem;
      color: #aaa;
    }
  </style>
</head>
<body>
  <header>
    <h1>${storyTitle}</h1>
    <h2>${chapter.title}</h2>
  </header>
  <div class="chapter-content">
    ${chapter.content.map(element => `
      <div class="element ${element.type}">
        <div class="type">${element.type.charAt(0).toUpperCase() + element.type.slice(1)}:</div>
        <div class="name">${element.name[Math.floor(Math.random() * element.name.length)]}</div>
        <div class="description">${element.description[Math.floor(Math.random() * element.description.length)]}</div>
      </div>
    `).join('')}
    <div class="ai-generated">
      <strong>AI Storyteller Note:</strong> This chapter was generated with a blend of creative algorithms and narrative logic.
      The elements you see are dynamically assembled to create a unique story experience each time.
    </div>
  </div>
  <div class="navigation">
    <a href="index.html">Back to Story</a>
    ${chapter !== story.chapters[story.chapters.length - 1] ? `<a href="chapter-${story.chapters.indexOf(chapter) + 2}.html">Next Chapter</a>` : ''}
  </div>
  <footer>
    Generated by Ailey's AI-Powered Storyteller | <a href="https://github.com/your-repo" target="_blank">View on GitHub</a>
  </footer>
</body>
</html>
  `;
}

// Generate the main index.html with story navigation
function generateIndexHTML(story) {
  return `
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>${story.title}</title>
  <style>
    :root {
      --primary: #6a11cb;
      --secondary: #2575fc;
      --background: #121212;
      --text: #e0e0e0;
      --accent: #00e676;
    }
    body {
      font-family: 'Courier New', monospace;
      background-color: var(--background);
      color: var(--text);
      line-height: 1.6;
      margin: 0;
      padding: 2rem;
      display: flex;
      flex-direction: column;
      align-items: center;
      min-height: 100vh;
    }
    header {
      width: 100%;
      text-align: center;
      margin-bottom: 2rem;
      border-bottom: 1px solid rgba(255, 255, 255, 0.1);
      padding-bottom: 1rem;
    }
    h1, h2 {
      color: var(--primary);
      margin: 0;
    }
    h1 {
      font-size: 2.5rem;
      text-shadow: 0 0 10px rgba(106, 17, 203, 0.3);
    }
    .story-navigation {
      max-width: 800px;
      width: 100%;
      display: flex;
      flex-direction: column;
      gap: 1rem;
      margin-bottom: 2rem;
    }
    .chapter-link {
      background-color: rgba(0, 0, 0, 0.3);
      padding: 1rem;
      border-left: 4px solid var(--accent);
      transition: all 0.3s ease;
      cursor: pointer;
    }
    .chapter-link:hover {
      background-color: rgba(0, 0, 0, 0.5);
      transform: translateX(5px);
    }
    .chapter-link.active {
      background-color: var(--primary);
      color: white;
    }
    .ai-info {
      background-color: rgba(255, 255, 255, 0.05);
      padding: 1rem;
      border-radius: 4px;
      margin-top: 2rem;
      font-size: 0.9rem;
      color: #aaa;
      max-width: 800px;
    }
    footer {
      margin-top: auto;
      text-align: center;
      padding: 1rem;
      border-top: 1px solid rgba(255, 255, 255, 0.1);
      font-size: 0.8rem;
    }
  </style>
</head>
<body>
  <header>
    <h1>${story.title}</h1>
    <h2>Interactive AI Story</h2>
  </header>
  <div class="story-navigation">
    ${story.chapters.map((chapter, index) => `
      <a href="chapter-${index + 1}.html" class="chapter-link ${index === 0 ? 'active' : ''}">
        <h3>Chapter ${index + 1}: ${chapter.title}</h3>
      </a>
    `).join('')}
  </div>
  <div class="ai-info">
    <strong>AI Storyteller Features:</strong>
    <ul>
      <li>Dynamically generated narrative elements</li>
      <li>Interactive chapters with hover effects</li>
      <li>Unique story experience on each load</li>
      <li>Generated with modern JavaScript and Node.js</li>
    </ul>
  </div>
  <footer>
    Generated by Ailey's AI-Powered Storyteller | <a href="https://github.com/your-repo" target="_blank">View on GitHub</a>
  </footer>
  <script>
    // Add some interactive behavior
    document.querySelectorAll('.chapter-link').forEach(link => {
      link.addEventListener('click', function(e) {
        e.preventDefault();
        document.querySelectorAll('.chapter-link').forEach(l => l.classList.remove('active'));
        this.classList.add('active');
        window.location.href = this.href;
      });
    });
  </script>
</body>
</html>
  `;
}

// Main function to generate the static site
async function generateSite() {
  // Create directories if they don't exist
  if (!fs.existsSync(siteDir)) {
    fs.mkdirSync(siteDir);
  }
  if (!fs.existsSync(storiesDir)) {
    fs.mkdirSync(storiesDir);
  }
  if (!fs.existsSync(assetsDir)) {
    fs.mkdirSync(assetsDir);
  }

  // Generate story data
  const story = generateStory();

  // Save story as JSON
  fs.writeFileSync(path.join(storiesDir, 'story.json'), JSON.stringify(story, null, 2));

  // Generate HTML files
  const indexHTML = generateIndexHTML(story);
  fs.writeFileSync(path.join(siteDir, 'index.html'), indexHTML);

  story.chapters.forEach((chapter, index) => {
    const chapterHTML = generateChapterHTML(chapter, story.title);
    fs.writeFileSync(path.join(siteDir, `chapter-${index + 1}.html`), chapterHTML);
  });

  // Generate assets (simple logo)
  const logoSVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="100" height="100">
    <circle cx="50" cy="50" r="40" fill="#6a11cb" stroke="#2575fc" stroke-width="2"/>
    <text x="50" y="55" font-family="Arial" font-size="12" fill="white" text-anchor="middle" dominant-baseline="middle">AI</text>
  </svg>`;
  fs.writeFileSync(path.join(assetsDir, 'logo.svg'), logoSVG);

  console.log('✨ Static site generated successfully!');
  console.log(`📂 Site directory: ${path.relative(process.cwd(), siteDir)}`);
  console.log('🌟 Open index.html in your browser to view the interactive AI story!');
}

// Run the site generator
generateSite().catch(console.error);

<?php
/**
 * Plugin Name: Dynamic Poll Generator
 * Description: Generates interactive polls with real-time results and visual feedback. Supports multiple question types, customizable colors, and multi-language support.
 * Version: 1.0
 * Author: Ailey
 * License: GPL2
 * Text Domain: dynamic_poll_generator
 */

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly
}

class DynamicPollGenerator {

    private $poll_data = [];
    private $options = [];
    private $languages = ['en', 'de', 'fr'];
    private $colors = ['#4a6baf', '#2ecc71', '#e74c3c', '#3498db', '#9b59b6'];

    public function __construct() {
        // WordPress Hooks
        if (function_exists('add_action')) {
            add_action('wp_enqueue_scripts', [$this, 'enqueue_assets']);
            add_action('wp_ajax_dpg_save_poll', [$this, 'save_poll']);
            add_action('wp_ajax_dpg_get_results', [$this, 'get_results']);
            add_action('wp_ajax_dpg_vote', [$this, 'vote_poll']);
            add_shortcode('dpg_poll', [$this, 'generate_poll_shortcode']);
            add_filter('plugin_row_meta', [$this, 'add_plugin_meta'], 10, 2);
        }

        // Joomla Hooks (if Joomla is detected)
        if (defined('JPATH_BASE')) {
            JLoader::register('DynamicPollGenerator', dirname(__FILE__) . '/dynamic_poll_generator.php');
            $this->register_joomla_hooks();
        }
    }

    // WordPress: Enqueue CSS and JS
    public function enqueue_assets() {
        wp_enqueue_style('dpg styles', plugins_url('assets/css/style.css', __FILE__));
        wp_enqueue_script('dpg script', plugins_url('assets/js/script.js', __FILE__), ['jquery'], null, true);
        wp_localize_script('dpg script', 'dpg_ajax', [
            'ajax_url' => admin_url('admin-ajax.php'),
            'nonce' => wp_create_nonce('dpg_nonce')
        ]);
    }

    // WordPress: Save Poll Data
    public function save_poll() {
        check_ajax_referer('dpg_nonce', 'nonce');
        $poll_id = isset($_POST['poll_id']) ? sanitize_text_field($_POST['poll_id']) : 'default';
        $poll_data = isset($_POST['poll_data']) ? json_decode($_POST['poll_data'], true) : [];
        $this->poll_data[$poll_id] = $poll_data;
        $this->options['poll_id'] = $poll_id;
        update_option('dpg_polls', $this->poll_data);
        update_option('dpg_options', $this->options);
        wp_send_json_success(['poll_id' => $poll_id]);
    }

    // WordPress: Get Poll Results
    public function get_results() {
        check_ajax_referer('dpg_nonce', 'nonce');
        $poll_id = isset($_GET['poll_id']) ? sanitize_text_field($_GET['poll_id']) : 'default';
        $polls = get_option('dpg_polls', []);
        if (isset($polls[$poll_id])) {
            $results = $this->calculate_results($polls[$poll_id]);
            wp_send_json_success($results);
        }
        wp_send_json_error('Poll not found.');
    }

    // WordPress: Handle Poll Votes
    public function vote_poll() {
        check_ajax_referer('dpg_nonce', 'nonce');
        $poll_id = isset($_POST['poll_id']) ? sanitize_text_field($_POST['poll_id']) : 'default';
        $option_id = isset($_POST['option_id']) ? sanitize_text_field($_POST['option_id']) : null;
        $polls = get_option('dpg_polls', []);
        if (isset($polls[$poll_id]) && $option_id !== null) {
            if (isset($polls[$poll_id]['options'][$option_id])) {
                $polls[$poll_id]['votes'][$option_id] = ($polls[$poll_id]['votes'][$option_id] ?? 0) + 1;
                update_option('dpg_polls', $polls);
                wp_send_json_success(['message' => 'Voted successfully!']);
            }
        }
        wp_send_json_error('Invalid vote.');
    }

    // WordPress: Generate Poll Shortcode
    public function generate_poll_shortcode($atts) {
        $atts = shortcode_atts([
            'id' => 'default',
            'title' => '',
            'type' => 'multiple',
            'color' => '#4a6baf',
            'language' => 'en'
        ], $atts);

        if (!in_array($atts['language'], $this->languages)) {
            $atts['language'] = 'en';
        }

        $poll_id = sanitize_title($atts['id']);
        $poll_data = $this->poll_data[$poll_id] ?? [];
        $options = $this->options;

        $question_translations = [
            'en' => 'Question:',
            'de' => 'Frage:',
            'fr' => 'Question:'
        ];

        $results_translations = [
            'en' => 'Results:',
            'de' => 'Ergebnisse:',
            'fr' => 'Résultats:'
        ];

        $vote_translations = [
            'en' => 'Vote Now!',
            'de' => 'Jetzt abstimmen!',
            'fr' => 'Vote maintenant!'
        ];

        $total_votes = array_sum($poll_data['votes'] ?? []);
        $question = $poll_data['question'] ?? 'No question set.';
        $type = $poll_data['type'] ?? 'multiple';
        $color = $poll_data['color'] ?? $this->colors[0];
        $language = $atts['language'];

        ob_start();
        ?>
        <div class="dpg-poll-container" data-poll-id="<?php echo esc_attr($poll_id); ?>" style="--primary-color: <?php echo esc_attr($color); ?>">
            <h3><?php echo esc_html($question_translations[$language]); ?> <span style="color: var(--primary-color);"><?php echo esc_html($question); ?></span></h3>

            <?php if ($type === 'multiple'): ?>
                <div class="dpg-options dpg-type-multiple">
                    <?php foreach ($poll_data['options'] ?? [] as $id => $option): ?>
                        <div class="dpg-option" data-option-id="<?php echo esc_attr($id); ?>">
                            <input type="radio" id="dpg-option-<?php echo esc_attr($id); ?>" name="poll_option" value="<?php echo esc_attr($id); ?>">
                            <label for="dpg-option-<?php echo esc_attr($id); ?>"><?php echo esc_html($option); ?></label>
                        </div>
                    <?php endforeach; ?>
                </div>
            <?php elseif ($type === 'multiple-choice'): ?>
                <div class="dpg-options dpg-type-multiple-choice">
                    <?php foreach ($poll_data['options'] ?? [] as $id => $option): ?>
                        <div class="dpg-option" data-option-id="<?php echo esc_attr($id); ?>">
                            <input type="checkbox" id="dpg-option-<?php echo esc_attr($id); ?>" name="poll_option[]" value="<?php echo esc_attr($id); ?>">
                            <label for="dpg-option-<?php echo esc_attr($id); ?>"><?php echo esc_html($option); ?></label>
                        </div>
                    <?php endforeach; ?>
                </div>
            <?php endif; ?>

            <div class="dpg-vote-btn-container">
                <button class="dpg-vote-btn" id="dpg-vote-btn-<?php echo esc_attr($poll_id); ?>">
                    <?php echo esc_html($vote_translations[$language]); ?>
                </button>
            </div>

            <div class="dpg-results" style="display: none;">
                <h4><?php echo esc_html($results_translations[$language]); ?></h4>
                <div class="dpg-results-chart">
                    <?php foreach ($poll_data['options'] ?? [] as $id => $option): ?>
                        <div class="dpg-result-item" data-option-id="<?php echo esc_attr($id); ?>">
                            <div class="dpg-result-label"><?php echo esc_html($option); ?></div>
                            <div class="dpg-result-bar" style="width: <?php echo ($total_votes > 0) ? min(100, round(($poll_data['votes'][$id] ?? 0) / $total_votes * 100, 2)) : 0; ?>%;">
                                <span class="dpg-result-percentage"><?php echo ($total_votes > 0) ? round(($poll_data['votes'][$id] ?? 0) / $total_votes * 100, 2) : 0; ?>%</span>
                            </div>
                            <div class="dpg-result-count"><?php echo esc_html($poll_data['votes'][$id] ?? 0); ?> <?php echo ($poll_data['votes'][$id] ?? 0) === 1 ? 'vote' : 'votes'; ?></div>
                        </div>
                    <?php endforeach; ?>
                </div>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }

    // WordPress: Add Plugin Meta
    public function add_plugin_meta($links, $plugin) {
        if ($plugin === plugin_basename(__FILE__)) {
            $links[] = '<a href="?page=dpg-settings" class="dpg-settings-link">Settings</a>';
        }
        return $links;
    }

    // Joomla: Register Hooks (if Joomla is detected)
    private function register_joomla_hooks() {
        JEventDispatcher::getInstance()->register('onContentBeforeDisplay', [$this, 'onContentBeforeDisplayJoomla']);
        JEventDispatcher::getInstance()->register('onContentAfterDisplay', [$this, 'onContentAfterDisplayJoomla']);
    }

    // Joomla: Process Shortcode
    public function onContentBeforeDisplay($context, $section, $version, $template, &$params, $page, &$object, $params2 = null) {
        if ($context === 'com_content' || $context === 'com_content.article') {
            $this->process_joomla_shortcode($object->text);
        }
    }

    // Joomla: Output Shortcode
    public function onContentAfterDisplay($context, $section, $version, $template, &$params, $page, &$object, $params2 = null) {
        if ($context === 'com_content' || $context === 'com_content.article') {
            echo $this->joomla_shortcode_output;
        }
    }

    private $joomla_shortcode_output = '';

    // Joomla: Process Shortcode in Content
    private function process_joomla_shortcode(&$text) {
        if (preg_match('/\[dpg_poll\s+id=([^\]]+)\]/', $text, $matches)) {
            $atts = shortcode_parse_atts($matches[1]);
            $poll_id = $atts['id'] ?? 'default';
            $this->joomla_shortcode_output .= $this->generate_poll_shortcode(['id' => $poll_id]);
        }
    }

    // Calculate Poll Results
    private function calculate_results($poll_data) {
        $total_votes = array_sum($poll_data['votes'] ?? []);
        $results = [];
        foreach ($poll_data['options'] ?? [] as $id => $option) {
            $results[] = [
                'option' => $option,
                'votes' => $poll_data['votes'][$id] ?? 0,
                'percentage' => ($total_votes > 0) ? round(($poll_data['votes'][$id] ?? 0) / $total_votes * 100, 2) : 0
            ];
        }
        return $results;
    }
}

// Initialize the plugin
new DynamicPollGenerator();