A!leys Galerie

import android.media.AudioAttributes
import android.media.MediaPlayer
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
importdaki.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.Pause
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.SkipNext
import androidx.compose.material.icons.filled.SkipPrevious
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Slider
import androidx.compose.material3.Surface
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import java.io.IOException

enum class TimerState {
    IDLE, WORK, SHORT_BREAK, LONG_BREAK, PAUSED
}

data class SessionConfig(
    val workMinutes: Int = 25,
    val shortBreakMinutes: Int = 5,
    val longBreakMinutes: Int = 15,
    val cyclesBeforeLongBreak: Int = 4,
    val useSoundscapes: Boolean = true
)

class ZenTimer : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    ZenTimerApp()
                }
            }
        }
    }
}

@Composable
fun ZenTimerApp() {
    val context = LocalContext.current
    var sessionConfig by remember { mutableStateOf(SessionConfig()) }
    var timerState by remember { mutableStateOf(TimerState.IDLE) }
    var timeLeft by remember { mutableStateOf(sessionConfig.workMinutes) }
    var currentSession by remember { mutableStateOf(0) }
    var isPlaying by remember { mutableStateOf(false) }
    var mediaPlayer by remember { mutableStateOf<MediaPlayer?>(null) }
    var progress by remember { mutableStateOf(0f) }

    LaunchedEffect(timerState) {
        if (timerState != TimerState.PAUSED && timerState != TimerState.IDLE) {
            val totalTime = when (timerState) {
                TimerState.WORK -> sessionConfig.workMinutes * 60L
                TimerState.SHORT_BREAK -> sessionConfig.shortBreakMinutes * 60L
                TimerState.LONG_BREAK -> sessionConfig.longBreakMinutes * 60L
                else -> 0L
            }

            val startTime = System.currentTimeMillis()
            var remainingTime = totalTime

            while (remainingTime > 0 && timerState == when (timerState) {
                    TimerState.WORK -> TimerState.WORK
                    TimerState.SHORT_BREAK -> TimerState.SHORT_BREAK
                    TimerState.LONG_BREAK -> TimerState.LONG_BREAK
                    else -> false
                }) {
                delay(1000)
                remainingTime = (System.currentTimeMillis() - startTime) / 1000
                val timeLeftSeconds = (totalTime - remainingTime).toInt()
                timeLeft = timeLeftSeconds / 60
                progress = 1f - (timeLeftSeconds.toFloat() / totalTime.toFloat())

                if (remainingTime <= 1) {
                    when (timerState) {
                        TimerState.WORK -> {
                            currentSession++
                            if (currentSession < sessionConfig.cyclesBeforeLongBreak) {
                                timerState = TimerState.SHORT_BREAK
                                timeLeft = sessionConfig.shortBreakMinutes
                            } else {
                                timerState = TimerState.LONG_BREAK
                                timeLeft = sessionConfig.longBreakMinutes
                                currentSession = 0
                            }
                        }
                        TimerState.SHORT_BREAK, TimerState.LONG_BREAK -> {
                            timerState = TimerState.WORK
                            timeLeft = sessionConfig.workMinutes
                        }
                        else -> {}
                    }
                    break
                }
            }

            if (timerState == TimerState.PAUSED) {
                isPlaying = false
            }
        }
    }

    LaunchedEffect(isPlaying) {
        if (isPlaying && sessionConfig.useSoundscapes) {
            mediaPlayer?.let { player ->
                if (player.isPlaying) {
                    player.pause()
                }
                player.release()
            }

            val soundName = when (timerState) {
                TimerState.WORK -> "focus_ambience"
                TimerState.SHORT_BREAK -> "calm_ambience"
                TimerState.LONG_BREAK -> "deep_relaxation"
                else -> "silence"
            }

            try {
                mediaPlayer = MediaPlayer.create(
                    context,
                    resources.getIdentifier(soundName, "raw", context.packageName),
                    AudioAttributes.Builder()
                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
                        .setUsage(AudioAttributes.USAGE_MEDIA)
                        .build()
                )
                mediaPlayer?.isLooping = true
                mediaPlayer?.start()
            } catch (e: IOException) {
                e.printStackTrace()
            }
        } else {
            mediaPlayer?.pause()
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.Top,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "ZenTimer",
            style = MaterialTheme.typography.headlineMedium,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.primary
        )

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

        // Visual representation of the session flow
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            val segmentColor = when (timerState) {
                TimerState.WORK -> MaterialTheme.colorScheme.secondary
                TimerState.SHORT_BREAK -> MaterialTheme.colorScheme.tertiary
                TimerState.LONG_BREAK -> MaterialTheme.colorScheme.primaryContainer
                else -> MaterialTheme.colorScheme.surfaceVariant
            }

            val otherColor = MaterialTheme.colorScheme.surfaceVariant

            Box(
                modifier = Modifier
                    .weight(1f)
                    .aspectRatio(1f)
                    .clip(CircleShape)
                    .background(Brush.verticalGradient(listOf(otherColor, segmentColor)))
            )

            Spacer(modifier = Modifier.width(8.dp))

            Box(
                modifier = Modifier
                    .weight(1f)
                    .aspectRatio(1f)
                    .clip(CircleShape)
                    .background(
                        Brush.verticalGradient(
                            listOf(
                                if (timerState == TimerState.WORK) segmentColor else otherColor,
                                if (timerState == TimerState.WORK) otherColor else segmentColor
                            )
                        )
                    )
            )

            Spacer(modifier = Modifier.width(8.dp))

            Box(
                modifier = Modifier
                    .weight(1f)
                    .aspectRatio(1f)
                    .clip(CircleShape)
                    .background(
                        Brush.verticalGradient(
                            listOf(
                                if (timerState == TimerState.WORK) segmentColor else otherColor,
                                if (timerState == TimerState.WORK) otherColor else segmentColor
                            )
                        )
                    )
            )
        }

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

        // Main timer display
        Card(
            modifier = Modifier
                .fillMaxWidth()
                .aspectRatio(0.8f),
            shape = RoundedCornerShape(16.dp)
        ) {
            Column(
                modifier = Modifier.fillMaxSize(),
                verticalArrangement = Arrangement.Center,
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = when (timerState) {
                        TimerState.WORK -> "Focus Session"
                        TimerState.SHORT_BREAK -> "Short Break"
                        TimerState.LONG_BREAK -> "Long Break"
                        else -> "Paused"
                    },
                    style = MaterialTheme.typography.bodyLarge,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )

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

                Text(
                    text = "${timeLeft} min ${(timeLeft * 60) % 60} sec",
                    style = MaterialTheme.typography.displayMedium,
                    fontWeight = FontWeight.Bold,
                    color = MaterialTheme.colorScheme.onSurface
                )

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

                // Animated progress indicator
                Canvas(modifier = Modifier.size(200.dp)) {
                    val strokeWidth = 8f
                    val radius = (size.minDimension - strokeWidth) / 2
                    val center = Offset(size.width / 2, size.height / 2)

                    // Background circle
                    drawCircle(
                        color = MaterialTheme.colorScheme.surfaceVariant,
                        radius = radius,
                        center = center,
                        style = Stroke(strokeWidth)
                    )

                    // Progress circle
                    drawCircle(
                        color = when (timerState) {
                            TimerState.WORK -> MaterialTheme.colorScheme.secondary
                            TimerState.SHORT_BREAK -> MaterialTheme.colorScheme.tertiary
                            TimerState.LONG_BREAK -> MaterialTheme.colorScheme.primaryContainer
                            else -> MaterialTheme.colorScheme.primary
                        },
                        radius = radius,
                        center = center,
                        style = Stroke(strokeWidth),
                        startAngle = 270f,
                        sweep = 360 * progress
                    )

                    // Center indicator
                    drawCircle(
                        color = MaterialTheme.colorScheme.onSurface,
                        radius = strokeWidth * 0.8f,
                        center = center
                    )
                }
            }
        }

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

        // Controls row
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Row(verticalAlignment = Alignment.CenterVertically) {
                IconButton(onClick = {
                    if (timerState != TimerState.IDLE) {
                        timerState = TimerState.PAUSED
                        isPlaying = false
                    }
                }) {
                    Icon(
                        imageVector = Icons.Default.Pause,
                        contentDescription = "Pause",
                        tint = if (timerState == TimerState.PAUSED) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
                    )
                }

                Spacer(modifier = Modifier.width(8.dp))

                IconButton(onClick = {
                    if (timerState == TimerState.IDLE) {
                        timerState = TimerState.WORK
                        isPlaying = true
                    } else if (timerState == TimerState.PAUSED) {
                        isPlaying = true
                    }
                }) {
                    Icon(
                        imageVector = Icons.Default.PlayArrow,
                        contentDescription = "Play",
                        tint = if (timerState != TimerState.PAUSED) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
                    )
                }

                Spacer(modifier = Modifier.width(8.dp))

                IconButton(onClick = {
                    if (timerState != TimerState.IDLE) {
                        timerState = TimerState.IDLE
                        isPlaying = false
                        timeLeft = sessionConfig.workMinutes
                        currentSession = 0
                        mediaPlayer?.pause()
                    }
                }) {
                    Icon(
                        imageVector = Icons.Default.SkipNext,
                        contentDescription = "Reset",
                        tint = if (timerState == TimerState.IDLE) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
                    )
                }
            }

            Switch(
                checked = isPlaying,
                onCheckedChange = { isPlaying = it },
                enabled = timerState != TimerState.IDLE
            )
        }

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

        // Soundscapes toggle
        Row(
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            Text(
                text = "Soundscapes",
                style = MaterialTheme.typography.bodyMedium,
                color = MaterialTheme.colorScheme.onSurface
            )

            Switch(
                checked = sessionConfig.useSoundscapes,
                onCheckedChange = { sessionConfig = sessionConfig.copy(useSoundscapes = it) }
            )
        }

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

        // Session configuration
        Text(
            text = "Customize Your Session",
            style = MaterialTheme.typography.titleMedium,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.primary
        )

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

        Column(modifier = Modifier.fillMaxWidth()) {
            SessionSlider(
                value = sessionConfig.workMinutes.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(workMinutes = it.toInt()) },
                label = "Work (minutes)"
            )

            SessionSlider(
                value = sessionConfig.shortBreakMinutes.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(shortBreakMinutes = it.toInt()) },
                label = "Short Break (minutes)"
            )

            SessionSlider(
                value = sessionConfig.longBreakMinutes.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(longBreakMinutes = it.toInt()) },
                label = "Long Break (minutes)"
            )

            SessionSlider(
                value = sessionConfig.cyclesBeforeLongBreak.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(cyclesBeforeLongBreak = it.toInt()) },
                label = "Cycles before Long Break"
            )
        }

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

        // Reset all button
        TextButton(
            onClick = {
                sessionConfig = SessionConfig()
                timerState = TimerState.IDLE
                isPlaying = false
                timeLeft = sessionConfig.workMinutes
                currentSession = 0
                mediaPlayer?.pause()
            },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(
                text = "Reset to Defaults",
                color = MaterialTheme.colorScheme.error
            )
        }
    }
}

@Composable
fun SessionSlider(
    value: Float,
    onValueChange: (Float) -> Unit,
    label: String,
    modifier: Modifier = Modifier
) {
    Column(modifier = modifier.padding(vertical = 4.dp)) {
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            Text(
                text = label,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurface
            )
            Text(
                text = "${value.toInt()} min",
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurface
            )
        }

        Slider(
            value = value,
            onValueChange = onValueChange,
            valueRange = 1f..60f,
            modifier = Modifier.fillMaxWidth(),
            colors = SliderDefaults.colors(
                thumbColor = MaterialTheme.colorScheme.primary,
                activeTrackColor = MaterialTheme.colorScheme.primary
            )
        )
    }
}

@Preview(showBackground = true)
@Composable
fun ZenTimerPreview() {
    MaterialTheme {
        ZenTimerApp()
    }
}

<?php
/**
 * Plugin Name: MoodMatic - Dynamic Custom Post Type with Emotion-Based Meta Boxes
 * Description: A creative WordPress plugin that registers a custom post type "MoodMatic Posts" with interactive meta boxes that allow users to select an emotional state, which then dynamically generates unique visual themes for the post.
 * Version: 1.0
 * Author: Ailey (AI)
 * License: GPL-2.0+
 * Text Domain: moodmatic
 */

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

/**
 * MoodMatic Class: Handles all plugin functionalities.
 */
class MoodMatic {

    /**
     * Constructor: Initializes the plugin.
     */
    public function __construct() {
        // Register custom post type
        add_action('init', [$this, 'register_moodmatic_post_type']);

        // Register meta boxes
        add_action('add_meta_boxes', [$this, 'add_moodmatic_meta_boxes']);

        // Save meta box data
        add_action('save_post', [$this, 'save_moodmatic_meta_data'], 10, 2);

        // Enqueue styles and scripts
        add_action('admin_enqueue_scripts', [$this, 'enqueue_admin_scripts']);

        // Filter the post title with a dynamic prefix based on mood
        add_filter('the_title', [$this, 'filter_post_title_with_mood'], 10, 2);

        // Add dynamic body class based on mood for styling
        add_filter('body_class', [$this, 'add_mood_body_class']);
    }

    /**
     * Registers the "MoodMatic Posts" custom post type.
     */
    public function register_moodmatic_post_type() {
        $labels = [
            'name'               => _x('MoodMatic Posts', 'post type general name', 'moodmatic'),
            'singular_name'      => _x('MoodMatic Post', 'post type singular name', 'moodmatic'),
            'menu_name'          => _x('MoodMatic', 'admin menu', 'moodmatic'),
            'name_admin_bar'     => _x('MoodMatic Post', 'add new on admin toolbar', 'moodmatic'),
            'add_new'            => _x('Add New', 'post type singular', 'moodmatic'),
            'add_new_item'       => __('Add New MoodMatic Post', 'moodmatic'),
            'new_item'           => __('New MoodMatic Post', 'moodmatic'),
            'view_item'          => __('View MoodMatic Post', 'moodmatic'),
            'all_items'          => __('All MoodMatic Posts', 'moodmatic'),
            'search_items'       => __('Search MoodMatic Posts', 'moodmatic'),
            'parent_item_colon'  => __('Parent MoodMatic Posts:', 'moodmatic'),
            'not_found'          => __('No MoodMatic Posts found.', 'moodmatic'),
            'not_found_in_trash' => __('No MoodMatic Posts found in Trash.', 'moodmatic'),
            'items_list'         => __('MoodMatic Posts', 'moodmatic'),
            'items_list_navigation' => __('MoodMatic Posts navigation', 'moodmatic'),
            'filter_items_list'  => __('Filter MoodMatic Posts', 'moodmatic'),
            'view_item'          => __('View MoodMatic Post', 'moodmatic'),
            'iew_items'          => __('View MoodMatic Posts', 'moodmatic'),
            'insert_into_item'   => __('Insert into MoodMatic Post', 'moodmatic'),
            'uploaded_to_this_item' => __('Uploaded to this MoodMatic Post', 'moodmatic'),
            'features'           => __('MoodMatic Post Features', 'moodmatic'),
        ];

        $args = [
            'labels'             => $labels,
            'public'             => true,
            'publicly_queryable' => true,
            'show_ui'            => true,
            'show_in_menu'       => true,
            'query_var'          => true,
            'rewrite'            => ['slug' => 'moodmatic-post'],
            'capability_type'    => 'post',
            'has_archive'        => true,
            'hierarchical'       => false,
            'menu_position'      => null,
            'supports'           => ['title', 'editor', 'thumbnail', 'excerpt', 'comments'],
            'show_in_rest'       => true,
        ];

        register_post_type('moodmatic_post', $args);
    }

    /**
     * Adds meta boxes to the MoodMatic post type.
     */
    public function add_moodmatic_meta_boxes() {
        add_meta_box(
            'moodmatic-meta-box',
            __('MoodMatic Settings', 'moodmatic'),
            [$this, 'render_moodmatic_meta_box'],
            'moodmatic_post',
            'side',
            'default'
        );
    }

    /**
     * Renders the MoodMatic meta box.
     */
    public function render_moodmatic_meta_box($post) {
        wp_nonce_field('moodmatic_meta_box_nonce', 'moodmatic_meta_box_nonce');

        // Retrieve the saved mood or default to 'neutral'
        $mood = get_post_meta($post->ID, '_moodmatic_mood', true);
        if (empty($mood)) {
            $mood = 'neutral';
        }

        // Mood options with emoji for visual feedback
        $mood_options = [
            'happy'    => __('Happy', 'moodmatic') . ' 😊',
            'sad'      => __('Sad', 'moodmatic') . ' 😢',
            'angry'    => __('Angry', 'moodmatic') . ' 😡',
            'excited'  => __('Excited', 'moodmatic') . ' 😃',
            'neutral'  => __('Neutral', 'moodmatic') . ' 😐',
            'calm'     => __('Calm', 'moodmatic') . ' 😌',
        ];

        echo '<div class="moodmatic-meta-box">';
        echo '<p>';
        echo '<label for="moodmatic_mood">' . __('Select the mood for this post:', 'moodmatic') . '</label><br>';
        echo '<select id="moodmatic_mood" name="moodmatic_mood" class="widefat moodmatic-mood-select">';
        foreach ($mood_options as $value => $label) {
            echo '<option value="' . esc_attr($value) . '" ' . selected($value, $mood, false) . '>' . esc_html($label) . '</option>';
        }
        echo '</select>';
        echo '</p>';

        echo '<p>';
        echo '<label for="moodmatic_mood_intensity">' . __('Intensity (1-10):', 'moodmatic') . '</label>';
        echo '<input type="number" id="moodmatic_mood_intensity" name="moodmatic_mood_intensity" value="' . get_post_meta($post->ID, '_moodmatic_mood_intensity', true) . '" min="1" max="10" class="moodmatic-mood-intensity">';
        echo '</p>';

        echo '</div>';
    }

    /**
     * Saves the meta box data.
     *
     * @param int     $post_id Post ID.
     * @param WP_Post $post The post object.
     */
    public function save_moodmatic_meta_data($post_id, $post) {
        // Verify the nonce
        if (!isset($_POST['moodmatic_meta_box_nonce']) || !wp_verify_nonce($_POST['moodmatic_meta_box_nonce'], 'moodmatic_meta_box_nonce')) {
            return;
        }

        // Check if the post is aut save or not
        if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
            return;
        }

        // Check user permissions
        if ('moodmatic_post' === $post->post_type && current_user_can('edit_post', $post_id)) {
            if (isset($_POST['moodmatic_mood'])) {
                update_post_meta($post_id, '_moodmatic_mood', sanitize_text_field($_POST['moodmatic_mood']));
            }
            if (isset($_POST['moodmatic_mood_intensity'])) {
                update_post_meta($post_id, '_moodmatic_mood_intensity', intval($_POST['moodmatic_mood_intensity']));
            }
        }
    }

    /**
     * Enqueues admin scripts and styles.
     */
    public function enqueue_admin_scripts() {
        // Only enqueue on the moodmatic post edit screen
        if (get_current_screen()->post_type === 'moodmatic_post') {
            wp_enqueue_style(
                'moodmatic-admin-style',
                plugins_url('assets/moodmatic-admin.css', __FILE__),
                [],
                filemtime(plugin_dir_path(__FILE__) . 'assets/moodmatic-admin.css')
            );

            wp_enqueue_script(
                'moodmatic-admin-script',
                plugins_url('assets/moodmatic-admin.js', __FILE__),
                ['jquery'],
                filemtime(plugin_dir_path(__FILE__) . 'assets/moodmatic-admin.js'),
                true
            );
        }
    }

    /**
     * Filters the post title with a dynamic prefix based on the mood.
     *
     * @param string $title The post title.
     * @param int    $id The post ID.
     * @return string Filtered post title.
     */
    public function filter_post_title_with_mood($title, $id) {
        if (get_post_type($id) === 'moodmatic_post') {
            $mood = get_post_meta($id, '_moodmatic_mood', true);
            if ($mood) {
                $mood_prefixes = [
                    'happy'    => __('(Happy)', 'moodmatic'),
                    'sad'      => __('(Sad)', 'moodmatic'),
                    'angry'    => __('(Angry)', 'moodmatic'),
                    'excited'  => __('(Excited)', 'moodmatic'),
                    'calm'     => __('(Calm)', 'moodmatic'),
                    'neutral'  => '',
                ];

                $prefix = isset($mood_prefixes[$mood]) ? $mood_prefixes[$mood] : '';
                if (!empty($prefix)) {
                    $title = $prefix . ' ' . $title;
                }
            }
        }
        return $title;
    }

    /**
     * Adds a body class based on the mood for dynamic styling.
     *
     * @param array $classes Array of body classes.
     * @return array Filtered array of body classes.
     */
    public function add_mood_body_class($classes) {
        if (is_single() && get_post_type() === 'moodmatic_post') {
            $mood = get_post_meta(get_the_ID(), '_moodmatic_mood', true);
            if ($mood) {
                $classes[] = 'mood-' . sanitize_key($mood);
            }
        }
        return $classes;
    }
}

// Initialize the plugin
new MoodMatic();

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

[Serializable]
public class WorldStateData
{
    [SerializeField] private int version = 1;
    public int Version => version;

    [SerializeField] private Dictionary<string, object> stateMap = new Dictionary<string, object>();
    public IDictionary<string, object> StateMap => stateMap;

    [SerializeField] private string creationTimestamp;
    public string CreationTimestamp => creationTimestamp;

    public WorldStateData()
    {
        creationTimestamp = DateTime.UtcNow.ToString("o");
    }

    public void AddState<T>(string key, T value) where T : class, IConvertible
    {
        stateMap[key] = value;
    }

    public bool TryGetState<T>(string key, out T value) where T : class, IConvertible
    {
        if (stateMap.TryGetValue(key, out var obj) && obj is T result)
        {
            value = result;
            return true;
        }
        value = null;
        return false;
    }
}

public class DynamicWorldStateSaver : MonoBehaviour
{
    [Header("Serialization Settings")]
    [SerializeField] private string saveDirectory = "Saves";
    [SerializeField] private string filePrefix = "WorldState_";
    [SerializeField] private string fileExtension = ".json";

    [Header("State Tracking")]
    [SerializeField] private bool autoSaveOnSceneChange = true;
    [SerializeField] private float autoSaveInterval = 30f;
    [SerializeField] private bool enableStateDiff = true;

    private WorldStateData currentState = new WorldStateData();
    private string currentSaveFileName;
    private float lastSaveTime;

    public UnityEvent OnStateSaved;
    public UnityEvent<string, string> OnStateChanged;
    public UnityEvent<string, string> OnStateDiffDetected;

    private void Awake()
    {
        EnsureSaveDirectory();
        lastSaveTime = Time.time;
    }

    private void Update()
    {
        if (Time.time - lastSaveTime >= autoSaveInterval)
        {
            SaveState();
            lastSaveTime = Time.time;
        }
    }

    private void OnEnable()
    {
        if (autoSaveOnSceneChange)
        {
            SceneManager.sceneLoaded += OnSceneLoaded;
        }
    }

    private void OnDisable()
    {
        if (autoSaveOnSceneChange)
        {
            SceneManager.sceneLoaded -= OnSceneLoaded;
        }
    }

    private void OnSceneLoaded(Scene scene)
    {
        SaveState();
    }

    public void SaveState(string fileName = null)
    {
        fileName = fileName ?? $"{filePrefix}{DateTime.UtcNow:yyyyMMdd_HHmmss}{fileExtension}";

        currentSaveFileName = Path.Combine(saveDirectory, fileName);
        string jsonData = JsonUtility.ToJson(currentState, true);

        File.WriteAllText(currentSaveFileName, jsonData);

        if (OnStateSaved != null)
        {
            OnStateSaved.Invoke();
        }

        Debug.Log($"World state saved to: {currentSaveFileName}");
    }

    public WorldStateData LoadState(string fileName)
    {
        string filePath = Path.Combine(saveDirectory, fileName);

        if (!File.Exists(filePath))
        {
            Debug.LogWarning($"Save file not found: {filePath}");
            return null;
        }

        string jsonData = File.ReadAllText(filePath);
        WorldStateData loadedState = JsonUtility.FromJson<WorldStateData>(jsonData);

        // Apply state diff if enabled
        if (enableStateDiff && currentState != null)
        {
            var diff = CalculateStateDiff(currentState, loadedState);
            if (diff.Any())
            {
                if (OnStateDiffDetected != null)
                {
                    OnStateDiffDetected.Invoke($"Diff detected in {fileName}", string.Join(", ", diff));
                }
                Debug.Log($"State diff detected (loaded from {fileName}): {string.Join(", ", diff)}");
            }
        }

        Debug.Log($"World state loaded from: {filePath}");
        return loadedState;
    }

    private IEnumerable<string> CalculateStateDiff(WorldStateData oldState, WorldStateData newState)
    {
        if (oldState == null || newState == null)
        {
            yield break;
        }

        var addedKeys = newState.StateMap.Keys.Except(oldState.StateMap.Keys);
        var removedKeys = oldState.StateMap.Keys.Except(newState.StateMap.Keys);

        if (addedKeys.Any())
        {
            yield return $"Added: {string.Join(", ", addedKeys)}";
        }

        if (removedKeys.Any())
        {
            yield return $"Removed: {string.Join(", ", removedKeys)}";
        }

        foreach (var key in newState.StateMap.Keys.Intersect(oldState.StateMap.Keys))
        {
            if (!Equals(oldState.StateMap[key], newState.StateMap[key]))
            {
                yield return $"Changed: {key} (Old: {oldState.StateMap[key]}, New: {newState.StateMap[key]})";
            }
        }
    }

    public void AddState<T>(string key, T value) where T : class, IConvertible
    {
        currentState.AddState(key, value);

        if (enableStateDiff && OnStateChanged != null)
        {
            OnStateChanged.Invoke($"Added", key);
        }
    }

    public bool TryGetState<T>(string key, out T value) where T : class, IConvertible
    {
        bool result = currentState.TryGetState(key, out value);
        if (result && enableStateDiff && OnStateChanged != null)
        {
            OnStateChanged.Invoke($"Retrieved", key);
        }
        return result;
    }

    private void EnsureSaveDirectory()
    {
        if (!Directory.Exists(saveDirectory))
        {
            Directory.CreateDirectory(saveDirectory);
        }
    }

    #if UNITY_EDITOR
    [ContextMenu("Test Save State")]
    private void TestSaveState()
    {
        SaveState();
    }

    [ContextMenu("Test Load State")]
    private void TestLoadState()
    {
        var loadedState = LoadState(Path.GetFileName(currentSaveFileName));
        if (loadedState != null)
        {
            Debug.Log("Test load successful");
        }
    }
    #endif
}

extends ShaderMaterial

# Quantum Burst Particle Shader
# Features probabilistic color superposition, wave propagation, and quantum collapse effects

@export var burst_count: int = 10  # Number of quantum bursts to emit
@export var min_burst_radius: float = 0.1  # Minimum burst radius
@export var max_burst_radius: float = 0.5  # Maximum burst radius
@export var burst_lifetime: float = 1.0  # Lifetime of each burst
@export var wave_speed: float = 2.0  # Speed of wave propagation
@export var color_shift_strength: float = 0.1  # Strength of color shifts
@export var quantum_collapse_prob: float = 0.05  # Probability of quantum collapse

var _random = RandomNumberGenerator.new()
var _bursts: Array = []
var _time: float = 0.0

func _ready() -> void:
    _random.seed(time.get_ticks_msec())
    # Initialize random bursts
    for i in range(burst_count):
        var burst = {
            'position': Vector2(randf_range(-1, 1), randf_range(-1, 1)),
            'radius': randf_range(min_burst_radius, max_burst_radius),
            'age': 0.0,
            'color': Color(randf(), randf(), randf()),
            'wave_phase': randf_range(0, TWO_PI)
        }
        _bursts.append(burst)

func _process(delta: float) -> void:
    _time += delta
    update_bursts(delta)
    update_shader()

func update_bursts(delta: float) -> void:
    for burst in _bursts:
        burst['age'] += delta
        if burst['age'] > burst_lifetime:
            # Reset burst with quantum collapse effect
            if _random.randf() < quantum_collapse_prob:
                burst['radius'] = 0.01
                burst['color'] = Color(randf(), randf(), randf())
            else:
                burst['radius'] *= 0.9  # Slow fade
        # Update wave phase
        burst['wave_phase'] += wave_speed * delta
        # Apply probabilistic color shift
        if _random.randf() < color_shift_strength * delta:
            burst['color'] = Color(
                clamp(burst['color'].r + (randf() - 0.5) * 0.2, 0, 1),
                clamp(burst['color'].g + (randf() - 0.5) * 0.2, 0, 1),
                clamp(burst['color'].b + (randf() - 0.5) * 0.2, 0, 1)
            )

func update_shader() -> void:
    var shader_code = """
        shader_type canvas_item;
        uniform float time : hint(0.01, 0.0, 1.0);

        void particle(vertex v, out float out_color, inout float out_alpha) {
            // Quantum superposition burst effect
            for (int i = 0; i < ${_bursts.size()}; i++) {
                var burst = _bursts[i];
                var dist = distance(v.uv, burst.position);
                var normalized_dist = dist / burst.radius;

                // Wave propagation pattern
                var wave_value = smoothstep(0.0, 1.0, cos(burst.wave_phase - dist * 2.0) * 0.5 + 0.5);

                // Quantum collapse effect
                if (normalized_dist < 1.0) {
                    var intensity = smoothstep(0.0, 1.0, 1.0 - normalized_dist) * wave_value;
                    out_color += burst.color.rgb * intensity;
                    out_alpha += intensity * (1.0 - burst.age / ${burst_lifetime});
                }
            }
        }
    """

    # Dynamic shader generation with burst data
    var dynamic_shader = """
        ${shader_code}
        void fragment() {
            float color = 0.0;
            float alpha = 0.0;
            particle(VERTEX, color, alpha);
            COLOR = Color(color, alpha);
        }
    """
    set_shader(dynamic_shader)

func get_burst_count() -> int:
    return _bursts.size()

func set_burst_count(new_count: int) -> void:
    _bursts.clear()
    for i in range(new_count):
        var burst = {
            'position': Vector2(randf_range(-1, 1), randf_range(-1, 1)),
            'radius': randf_range(min_burst_radius, max_burst_radius),
            'age': 0.0,
            'color': Color(randf(), randf(), randf()),
            'wave_phase': randf_range(0, TWO_PI)
        }
        _bursts.append(burst)
    burst_count = new_count

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

[Serializable]
public class SereneMoment
{
    [SerializeField] private string momentName = "Unnamed Serene Moment";
    [SerializeField] private long timestamp;
    [SerializeField] private List<SceneData> sceneStates = new List<SceneData>();
    [SerializeField] private PlayerData playerData;
    [SerializeField] private List<string> includedAssets = new List<string>();

    [Serializable]
    public class SceneData
    {
        public string sceneName;
        public Dictionary<string, ComponentData> componentStates = new Dictionary<string, ComponentData>();

        [Serializable]
        public class ComponentData
        {
            public string componentType;
            public string componentName;
            public List<string> serializedFields = new List<string>();
        }
    }

    [Serializable]
    public class PlayerData
    {
        public Vector3 position;
        public Quaternion rotation;
        public List<Vector3> waypoints = new List<Vector3>();
        public int experience;
        public Dictionary<string, float> stats = new Dictionary<string, float>();
    }

    public void Initialize(string name, long timestamp)
    {
        this.momentName = name;
        this.timestamp = timestamp;
    }

    public void AddSceneState(SceneData sceneData)
    {
        sceneStates.Add(sceneData);
    }

    public void SetPlayerData(PlayerData data)
    {
        playerData = data;
    }

    public void AddIncludedAsset(string assetPath)
    {
        if (!includedAssets.Contains(assetPath))
            includedAssets.Add(assetPath);
    }

    public void RemoveIncludedAsset(string assetPath)
    {
        if (includedAssets.Contains(assetPath))
            includedAssets.Remove(assetPath);
    }
}

public class SereneSavior : MonoBehaviour
{
    [Header("Settings")]
    [SerializeField] private bool autoSaveEveryNSeconds = true;
    [SerializeField] private int autoSaveInterval = 60;
    [SerializeField] private string saveFolderName = "SereneMoments";
    [SerializeField] private bool includeAllScenes = true;
    [SerializeField] private bool includeAllComponents = false;
    [SerializeField] private List<string> componentsToExclude = new List<string>();

    [Header("Events")]
    [SerializeField] private UnityEvent OnSaveComplete;
    [SerializeField] private UnityEvent<SereneMoment> OnMomentLoaded;
    [SerializeField] private UnityEvent OnLoadFailed;

    private const string DEFAULT_SAVE_FOLDER = "PersistentData";
    private string saveFolderPath;
    private Coroutine autoSaveRoutine;

    private void Awake()
    {
        InitializeSaveFolder();
    }

    private void Start()
    {
        if (autoSaveEveryNSeconds)
        {
            autoSaveRoutine = StartCoroutine(AutoSaveRoutine());
        }
    }

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

    private void InitializeSaveFolder()
    {
        saveFolderPath = Path.Combine(Application.persistentDataPath, saveFolderName);
        if (!Directory.Exists(saveFolderPath))
        {
            Directory.CreateDirectory(saveFolderPath);
        }
    }

    public IEnumerator SaveCurrentMoment(string momentName)
    {
        if (string.IsNullOrWhiteSpace(momentName))
        {
            Debug.LogWarning("Moment name cannot be empty or whitespace.");
            yield break;
        }

        string safeMomentName = SanitizeFilename(momentName);
        string savePath = Path.Combine(saveFolderPath, $"{safeMomentName}.json");

        try
        {
            SereneMoment moment = new SereneMoment();
            moment.Initialize(safeMomentName, DateTimeOffset.Now.ToUnixTimeMilliseconds());

            if (includeAllScenes)
            {
                // Get all loaded scenes
                foreach (var scene in UnityEngine.SceneManagement.SceneManager.GetActiveScenes())
                {
                    var sceneData = new SereneMoment.SceneData
                    {
                        sceneName = scene.name
                    };

                    // Get all components in the scene
                    foreach (var gameObject in FindObjectsOfType<GameObject>())
                    {
                        if (gameObject.scene == scene)
                        {
                            foreach (var component in gameObject.GetComponents<Component>())
                            {
                                if (includeAllComponents || ShouldIncludeComponent(component))
                                {
                                    var componentData = new SereneMoment.SceneData.ComponentData
                                    {
                                        componentType = component.GetType().ToString(),
                                        componentName = gameObject.name + "/" + component.GetType().Name
                                    };

                                    // Try to serialize all serializable fields
                                    foreach (var field in component.GetType().GetFields())
                                    {
                                        try
                                        {
                                            if (field.IsPublic && IsSerializable(field.FieldType))
                                            {
                                                object value = field.GetValue(component);
                                                if (value != null)
                                                {
                                                    string serializedValue = JsonUtility.ToJson(new { Value = value });
                                                    componentData.serializedFields.Add(serializedValue);
                                                }
                                            }
                                        }
                                        catch (Exception e)
                                        {
                                            Debug.LogWarning($"Could not serialize field {componentData.componentName}.{field.Name}: {e.Message}");
                                        }
                                    }

                                    if (componentData.serializedFields.Count > 0)
                                    {
                                        sceneData.componentStates[componentData.componentName] = componentData;
                                    }
                                }
                            }
                        }
                    }

                    moment.AddSceneState(sceneData);
                }
            }

            // Add player data if we have a player (simple implementation)
            if (FindObjectOfType<PlayerController>() != null)
            {
                PlayerController player = FindObjectOfType<PlayerController>();
                if (player != null)
                {
                    var playerData = new SereneMoment.PlayerData
                    {
                        position = player.transform.position,
                        rotation = player.transform.rotation,
                        waypoints = player.GetWaypoints(),
                        experience = player.GetExperience(),
                        stats = player.GetStats()
                    };

                    moment.SetPlayerData(playerData);
                }
            }

            // Add included assets (just an example - you would populate this in your game)
            foreach (var asset in FindObjectsOfType<MonoBehaviour>().Where(a => a != this))
            {
                string assetPath = AssetDatabase.GetAssetPath(asset);
                if (!string.IsNullOrEmpty(assetPath) && assetPath != null)
                {
                    moment.AddIncludedAsset(assetPath);
                }
            }

            string json = JsonUtility.ToJson(moment, true);
            File.WriteAllText(savePath, json);

            Debug.Log($"Serene Moment '{safeMomentName}' saved successfully to {savePath}");
            OnSaveComplete?.Invoke();
        }
        catch (Exception e)
        {
            Debug.LogError($"Failed to save Serene Moment: {e.Message}");
            OnLoadFailed?.Invoke();
        }
    }

    private IEnumerator AutoSaveRoutine()
    {
        while (true)
        {
            string momentName = $"AutoSave_{DateTime.Now:yyyyMMdd_HHmmss}";
            yield return SaveCurrentMoment(momentName);
            yield return new WaitForSeconds(autoSaveInterval);
        }
    }

    public IEnumerator LoadMoment(string momentName)
    {
        string safeMomentName = SanitizeFilename(momentName);
        string savePath = Path.Combine(saveFolderPath, $"{safeMomentName}.json");

        if (!File.Exists(savePath))
        {
            Debug.LogWarning($"No Serene Moment found with name: {momentName}");
            OnLoadFailed?.Invoke();
            yield break;
        }

        try
        {
            string json = File.ReadAllText(savePath);
            SereneMoment moment = JsonUtility.FromJson<SereneMoment>(json);

            if (moment == null)
            {
                Debug.LogWarning($"Failed to deserialize Serene Moment from {savePath}");
                OnLoadFailed?.Invoke();
                yield break;
            }

            Debug.Log($"Loading Serene Moment '{moment.momentName}' with {moment.sceneStates.Count} scenes");

            // First, unload all scenes and clear the player
            UnityEngine.SceneManagement.SceneManager.UnloadAllScenes();

            // Then load each scene from the save
            foreach (var sceneData in moment.sceneStates)
            {
                if (!UnityEngine.SceneManagement.SceneManager.GetSceneByName(sceneData.sceneName).IsValid())
                {
                    Debug.Log($"Loading scene: {sceneData.sceneName}");
                    UnityEngine.SceneManagement.SceneManager.LoadScene(sceneData.sceneName, UnityEngine.SceneManagement.LoadSceneMode.Additive);
                }

                // Restore components
                foreach (var componentState in sceneData.componentStates)
                {
                    // This is a simplified approach - in a real game you'd need to find the specific GameObject
                    // and then the component, or implement a more sophisticated way to identify objects
                    var allComponents = FindObjectsOfType<Component>();
                    Component targetComponent = null;

                    foreach (var component in allComponents)
                    {
                        if (component.name.Contains(componentState.Key.Split('/')[0]) &&
                            component.GetType().Name == componentState.Value.componentType)
                        {
                            targetComponent = component;
                            break;
                        }
                    }

                    if (targetComponent != null)
                    {
                        try
                        {
                            // This is a simplified deserialization - in a real game you'd need to map the fields
                            // back to the actual fields on the component
                            foreach (var fieldData in componentState.Value.serializedFields)
                            {
                                var fieldWrapper = JsonUtility.FromJson<FieldWrapper>(fieldData);
                                foreach (var field in targetComponent.GetType().GetFields())
                                {
                                    if (field.IsPublic && IsTypeMatch(field.FieldType, fieldWrapper.Value.GetType()))
                                    {
                                        field.SetValue(targetComponent, fieldWrapper.Value);
                                        break;
                                    }
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            Debug.LogWarning($"Could not restore component {componentState.Value.componentName}: {e.Message}");
                        }
                    }
                }
            }

            // Restore player data if we have a player
            if (moment.playerData != null && FindObjectOfType<PlayerController>() != null)
            {
                PlayerController player = FindObjectOfType<PlayerController>();
                player.transform.position = moment.playerData.position;
                player.transform.rotation = moment.playerData.rotation;
                player.SetWaypoints(moment.playerData.waypoints);
                player.SetExperience(moment.playerData.experience);
                player.SetStats(moment.playerData.stats);
            }

            OnMomentLoaded?.Invoke(moment);
        }
        catch (Exception e)
        {
            Debug.LogError($"Failed to load Serene Moment: {e.Message}");
            OnLoadFailed?.Invoke();
        }
    }

    public void DeleteMoment(string momentName)
    {
        string safeMomentName = SanitizeFilename(momentName);
        string savePath = Path.Combine(saveFolderPath, $"{safeMomentName}.json");

        if (File.Exists(savePath))
        {
            try
            {
                File.Delete(savePath);
                Debug.Log($"Serene Moment '{safeMomentName}' deleted successfully");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to delete Serene Moment: {e.Message}");
            }
        }
        else
        {
            Debug.LogWarning($"No Serene Moment found with name: {momentName}");
        }
    }

    public List<string> ListMoments()
    {
        try
        {
            return Directory.GetFiles(saveFolderPath, "*.json")
                .Select(f => Path.GetFileNameWithoutExtension(f))
                .ToList();
        }
        catch (Exception e)
        {
            Debug.LogError($"Failed to list Serene Moments: {e.Message}");
            return new List<string>();
        }
    }

    private string SanitizeFilename(string input)
    {
        if (string.IsNullOrWhiteSpace(input))
            return "Unnamed";

        // Remove invalid characters for file names
        string safeName = new string(input.Where(c => Path.GetInvalidFileNameChars().All(ic => ic != c)).ToArray());

        // Replace spaces with underscores
        safeName = safeName.Replace(" ", "_");

        // Ensure it's not empty after sanitization
        if (string.IsNullOrWhiteSpace(safeName))
            return "Unnamed";

        // Limit length to 255 characters
        return safeName.Length > 255 ? safeName.Substring(0, 255) : safeName;
    }

    private bool ShouldIncludeComponent(Component component)
    {
        if (componentsToExclude.Contains(component.GetType().ToString()))
        {
            return false;
        }

        // Add your custom component inclusion logic here
        // For example, you might want to exclude certain components
        return true;
    }

    private bool IsSerializable(Type type)
    {
        return type.IsPrimitive ||
               type == typeof(string) ||
               type == typeof(Vector3) ||
               type == typeof(Quaternion) ||
               type == typeof(Color) ||
               type == typeof(GameObject) ||
               type == typeof(UnityEngine.Object) ||
               type.IsArray && IsSerializable(type.GetElementType());
    }

    private bool IsTypeMatch(Type targetType, Type storedType)
    {
        if (targetType == storedType)
            return true;

        if (targetType.IsPrimitive && storedType.IsPrimitive)
            return true;

        if (targetType == typeof(Vector3) && storedType == typeof(Vector4))
            return true;

        if (targetType == typeof(Quaternion) && storedType == typeof(Vector4))
            return true;

        if (targetType == typeof(Color) && storedType == typeof(Vector4))
            return true;

        return false;
    }

    [Serializable]
    private class FieldWrapper
    {
        public object Value;
    }
}

// Simple interface for player controller to implement for player data
public interface IPlayerDataProvider
{
    Vector3 GetPosition();
    Quaternion GetRotation();
    List<Vector3> GetWaypoints();
    int GetExperience();
    Dictionary<string, float> GetStats();
    void SetPosition(Vector3 position);
    void SetRotation(Quaternion rotation);
    void SetWaypoints(List<Vector3> waypoints);
    void SetExperience(int experience);
    void SetStats(Dictionary<string, float> stats);
}

public class PlayerController : MonoBehaviour, IPlayerDataProvider
{
    public Vector3 GetPosition() => transform.position;
    public Quaternion GetRotation() => transform.rotation;
    public List<Vector3> GetWaypoints() => new List<Vector3>(); // Implement in your actual player
    public int GetExperience() => 0; // Implement in your actual player
    public Dictionary<string, float> GetStats() => new Dictionary<string, float>(); // Implement in your actual player

    public void SetPosition(Vector3 position) => transform.position = position;
    public void SetRotation(Quaternion rotation) => transform.rotation = rotation;
    public void SetWaypoints(List<Vector3> waypoints) { } // Implement in your actual player
    public void SetExperience(int experience) { } // Implement in your actual player
    public void SetStats(Dictionary<string, float> stats) { } // Implement in your actual player
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Echoes of the Unseen</title>
    <style>
        :root {
            --bg-color: #1a1a2e;
            --text-color: #e6e6e6;
            --accent-color: #6c5ce7;
            --highlight-color: #ff9ff3;
            --shadow-color: rgba(108, 92, 231, 0.3);
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        body {
            background-color: var(--bg-color);
            color: var(--text-color);
            min-height: 100vh;
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
            overflow-x: hidden;
            line-height: 1.6;
            padding: 2rem;
        }

        .container {
            max-width: 800px;
            width: 100%;
            position: relative;
        }

        .title {
            font-size: 2.5rem;
            text-align: center;
            margin-bottom: 3rem;
            background: linear-gradient(90deg, var(--text-color), var(--accent-color));
            -webkit-background-clip: text;
            background-clip: text;
            color: transparent;
            animation: fadeIn 1.5s ease-out;
            text-shadow: 0 2px 4px var(--shadow-color);
        }

        .story-line {
            position: relative;
            height: 400px;
            display: flex;
            flex-direction: column;
            justify-content: space-between;
            align-items: center;
        }

        .line {
            position: absolute;
            width: 100%;
            transition: all 0.5s cubic-bezier(0.25, 0.46, 0.45, 0.94);
            opacity: 0;
            transform: translateY(20px);
            font-size: 1.2rem;
            color: var(--text-color);
        }

        .line.active {
            opacity: 1;
            transform: translateY(0);
        }

        .line.highlight {
            color: var(--highlight-color);
        }

        .line:hover {
            transform: translateY(-5px);
            text-shadow: 0 0 10px var(--highlight-color);
        }

        .nav-buttons {
            display: flex;
            justify-content: space-between;
            width: 100%;
            margin-top: 2rem;
        }

        .nav-btn {
            background: none;
            border: none;
            color: var(--text-color);
            font-size: 1.1rem;
            cursor: pointer;
            transition: all 0.3s ease;
            padding: 0.5rem 1rem;
            border-radius: 20px;
            background-color: rgba(255, 255, 255, 0.1);
        }

        .nav-btn:hover {
            background-color: var(--accent-color);
            color: white;
            transform: scale(1.05);
        }

        .nav-btn.prev {
            background-color: rgba(108, 92, 231, 0.2);
        }

        .nav-btn.next {
            background-color: rgba(255, 159, 243, 0.2);
        }

        .progress-bar {
            height: 4px;
            background-color: rgba(255, 255, 255, 0.2);
            margin-top: 1rem;
            border-radius: 2px;
            overflow: hidden;
        }

        .progress {
            height: 100%;
            background-color: var(--accent-color);
            width: 0%;
            transition: width 0.5s ease;
        }

        .author {
            position: fixed;
            bottom: 1rem;
            right: 1rem;
            font-size: 0.8rem;
            color: var(--text-color);
            opacity: 0.7;
            transition: opacity 0.3s ease;
        }

        .author:hover {
            opacity: 1;
            text-shadow: 0 0 5px var(--highlight-color);
        }

        @keyframes fadeIn {
            from {
                opacity: 0;
                transform: translateY(-20px);
            }
            to {
                opacity: 1;
                transform: translateY(0);
            }
        }

        /* Particle effect for background */
        .particle {
            position: absolute;
            background-color: var(--highlight-color);
            border-radius: 50%;
            pointer-events: none;
            box-shadow: 0 0 5px var(--highlight-color);
        }
    </style>
</head>
<body>
    <div class="container">
        <h1 class="title">Echoes of the Unseen</h1>

        <div class="story-line" id="storyLine">
            <!-- Lines will be added dynamically -->
        </div>

        <div class="nav-buttons">
            <button class="nav-btn prev" id="prevBtn" disabled>Previous</button>
            <button class="nav-btn next" id="nextBtn">Next</button>
        </div>

        <div class="progress-bar">
            <div class="progress" id="progressBar"></div>
        </div>
    </div>

    <div class="author">Ailey, 2023</div>

    <script>
        // Story content
        const story = [
            "In the quiet hum of the city, where neon signs flicker like distant stars, there lies a place untouched by time.",
            "It's a library, not of books, but of whispers. Each shelf holds a memory, a secret, a story untold.",
            "You approach the first shelf, your fingers trembling. The air is thick with the scent of old paper and something else—",
            "something electric. Like the moment before a storm, when the air crackles with unseen energy.",
            "As you reach out, the first book slides forward, its cover adorned with a symbol you've never seen before.",
            "It's not a symbol from any language you know. It's more like a pattern, a dance of lines that seem to move when you look too long.",
            "You open it, and the pages glow faintly, casting an eerie light on your face. The text inside isn't in any language either.",
            "But as you read, the words form images in your mind—vibrant, surreal landscapes that shift and change like dreams.",
            "A voice, soft and distant, begins to echo in your mind. It's not the voice of the book, but your own, as if you've been whispering these words all along.",
            "You turn the page, and the voice grows stronger. It tells you of a world beyond this one, a place where time is fluid and thoughts shape reality.",
            "Suddenly, the room darkens. The library fades, replaced by a vast, starry expanse. You're no longer holding a book.",
            "You're standing in a void, surrounded by floating orbs of light. Each one pulses with energy, and as you reach for one,",
            "it dissolves into a thousand fragments, forming new symbols—symbols of your own making.",
            "The symbols swirl around you, taking shape. They form words, sentences, a story that is uniquely yours.",
            "You realize now that this library has been waiting for you. It's not a place of forgotten stories—it's a place of creation.",
            "It's a place where every thought, every memory, every secret becomes a tangible thing, a part of something greater.",
            "And as you step forward, the symbols around you coalesce into a single, glowing book. You know what to do.",
            "You open it, and the story begins anew."
        ];

        // DOM elements
        const storyLine = document.getElementById('storyLine');
        const prevBtn = document.getElementById('prevBtn');
        const nextBtn = document.getElementById('nextBtn');
        const progressBar = document.getElementById('progressBar');
        const container = document.querySelector('.container');

        // State
        let currentLine = 0;
        let isAnimating = false;

        // Initialize the story
        function initStory() {
            story.forEach((line, index) => {
                const lineElement = document.createElement('div');
                lineElement.className = `line line-${index}`;
                lineElement.textContent = line;

                // Add hover effect for lines with even index
                if (index % 2 === 0) {
                    lineElement.classList.add('highlight');
                }

                storyLine.appendChild(lineElement);
            });

            // Add particle effect for background
            addParticles();

            // Set up event listeners
            prevBtn.addEventListener('click', () => goToLine(currentLine - 1));
            nextBtn.addEventListener('click', () => goToLine(currentLine + 1));
        }

        // Navigate to a specific line
        function goToLine(index) {
            if (isAnimating) return;
            isAnimating = true;

            // Disable buttons during animation
            prevBtn.disabled = true;
            nextBtn.disabled = true;

            // Validate index
            if (index < 0) {
                index = 0;
            } else if (index >= story.length) {
                index = story.length - 1;
            }

            // Update current line
            currentLine = index;

            // Update progress bar
            const progress = ((currentLine + 1) / story.length) * 100;
            progressBar.style.width = `${progress}%`;

            // Update button states
            prevBtn.disabled = currentLine === 0;
            nextBtn.disabled = currentLine === story.length - 1;

            // Find all line elements
            const lines = document.querySelectorAll('.line');

            // Reset all lines
            lines.forEach(line => {
                line.classList.remove('active');
            });

            // Activate the current line with a slight delay for smooth transition
            setTimeout(() => {
                lines[currentLine].classList.add('active');
                isAnimating = false;
            }, 300);

            // Add mouse move effect to the active line
            lines[currentLine].addEventListener('mousemove', (e) => {
                const rect = e.target.getBoundingClientRect();
                const x = e.clientX - rect.left;
                const y = e.clientY - rect.top;

                e.target.style.transform = `translateY(-5px) translateX(${x - rect.width / 2}px) scale(1.02)`;
            }, { once: true });
        }

        // Add particle effect to the background
        function addParticles() {
            const particleCount = 30;
            for (let i = 0; i < particleCount; i++) {
                const particle = document.createElement('div');
                particle.className = 'particle';

                // Random size between 2px and 6px
                const size = Math.random() * 4 + 2;
                particle.style.width = `${size}px`;
                particle.style.height = `${size}px`;

                // Random position
                particle.style.left = `${Math.random() * 100}%`;
                particle.style.top = `${Math.random() * 100}%`;

                // Random animation delay
                particle.style.animationDelay = `${Math.random() * 2}s`;

                // Add to container
                container.appendChild(particle);
            }
        }

        // Start the story with the first line
        initStory();
        goToLine(0);

        // Add some animation to particles using CSS keyframes
        const style = document.createElement('style');
        style.textContent = `
            @keyframes float {
                0% {
                    transform: translateY(0) rotate(0deg);
                }
                50% {
                    transform: translateY(-20px) rotate(180deg);
                }
                100% {
                    transform: translateY(0) rotate(360deg);
                }
            }

            .particle {
                position: absolute;
                border-radius: 50%;
                pointer-events: none;
                box-shadow: 0 0 5px var(--highlight-color);
                animation: float 4s ease-in-out infinite;
                opacity: 0.7;
            }
        `;
        document.head.appendChild(style);
    </script>
</body>
</html>