A!leys Galerie

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Divide
import androidx.compose.material.icons.filled.Multiply
import androidx.compose.material.icons.filled.Star
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.vector.ImageVector
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import java.lang.Exception

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            CalculAtorTheme {
                CalculAtorApp()
            }
        }
    }
}

@Composable
fun CalculAtorApp() {
    var currentInput by remember { mutableStateOf("") }
    var calculationHistory by remember { mutableStateOf(listOf<String>()) }
    var quizMode by remember { mutableStateOf(false) }
    var quizResult by remember { mutableStateOf(0) }
    var quizScore by remember { mutableStateOf(0) }
    var showResult by remember { mutableStateOf(false) }
    var operation by remember { mutableStateOf("") }

    val context = LocalContext.current

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = if (quizMode) "Emoji Quiz: ${quizScore}/10" else "CalculAtor: Emoji Arithmetic",
            style = MaterialTheme.typography.headlineMedium,
            modifier = Modifier.padding(vertical = 16.dp)
        )

        if (quizMode) {
            QuizDisplay(
                quizResult = quizResult,
                onResultChosen = { isCorrect ->
                    quizScore = if (isCorrect) quizScore + 1 else quizScore
                    if (quizScore >= 10) {
                        quizMode = false
                        SnackbarHost {
                            Snackbar(
                                message = "You won the quiz! Score: $quizScore/10",
                                action = {
                                    Button(onClick = { quizScore = 0 }) {
                                        Text("Reset")
                                    }
                                }
                            )
                        }
                    } else {
                        quizResult = (0..9).random()
                        showResult = true
                    }
                },
                showResult = showResult,
                result = operation
            )
        } else {
            CalculationDisplay(
                currentInput = currentInput,
                history = calculationHistory
            )

            CalculatorKeyboard(
                onNumberClick = { number ->
                    currentInput += number
                },
                onOperationClick = { op, emoji ->
                    if (currentInput.isNotEmpty()) {
                        operation = op
                        currentInput += " $emoji "
                    }
                },
                onEqualsClick = {
                    try {
                        val result = calculateExpression(currentInput)
                        val formattedResult = if (result.isFinite()) {
                            "%.2f".format(result)
                        } else {
                            result.toString()
                        }
                        val calculation = "$currentInput = $formattedResult"
                        calculationHistory = calculation + calculationHistory.take(9)
                        SnackbarHost {
                            Snackbar(
                                message = calculation
                            )
                        }
                        currentInput = formattedResult
                        operation = ""
                    } catch (e: Exception) {
                        currentInput = "Error"
                    }
                },
                onClearClick = {
                    currentInput = ""
                    operation = ""
                },
                onHistoryClick = {
                    if (calculationHistory.isNotEmpty()) {
                        currentInput = calculationHistory.first()
                    }
                },
                onQuizClick = {
                    quizMode = true
                    quizResult = (0..9).random()
                    showResult = true
                }
            )
        }
    }
}

@Composable
fun CalculationDisplay(currentInput: String, history: List<String>) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .weight(1f),
        verticalArrangement = Arrangement.Center
    ) {
        LazyColumn(
            modifier = Modifier
                .fillMaxWidth()
                .height(200.dp)
                .weight(1f),
            reverseLayout = true
        ) {
            items(history) { item ->
                Text(
                    text = item,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f),
                    modifier = Modifier.padding(8.dp)
                )
            }
        }

        Text(
            text = currentInput.ifEmpty { "Start typing or tap numbers" },
            fontSize = 32.sp,
            modifier = Modifier.padding(vertical = 16.dp)
        )
    }
}

@Composable
fun CalculatorKeyboard(
    onNumberClick: (String) -> Unit,
    onOperationClick: (String, String) -> Unit,
    onEqualsClick: () -> Unit,
    onClearClick: () -> Unit,
    onHistoryClick: () -> Unit,
    onQuizClick: () -> Unit
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .weight(1f)
    ) {
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            IconButton(onClick = onClearClick) {
                Icon(Icons.Default.Close, contentDescription = "Clear")
            }
            IconButton(onClick = onHistoryClick) {
                Icon(Icons.Default.Delete, contentDescription = "History")
            }
            IconButton(onClick = onQuizClick) {
                Icon(Icons.Default.Star, contentDescription = "Quiz Mode")
            }
        }

        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(vertical = 8.dp),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            OperationButton(
                text = "⁺",
                emoji = "🔟",
                onClick = { onOperationClick("+", "🔟") }
            )
            OperationButton(
                text = "⁻",
                emoji = "🔁",
                onClick = { onOperationClick("-", "🔁") }
            )
            OperationButton(
                text = "×",
                emoji = "✖️",
                onClick = { onOperationClick("*", "✖️") }
            )
            OperationButton(
                text = "÷",
                emoji = "🔹",
                onClick = { onOperationClick("/", "🔹") }
            )
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            NumberButton(text = "7", onClick = onNumberClick("7"))
            NumberButton(text = "8", onClick = onNumberClick("8"))
            NumberButton(text = "9", onClick = onNumberClick("9"))
            OperationButton(
                text = "🤔",
                emoji = "🤔",
                onClick = { onOperationClick("?", "🤔") }
            )
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            NumberButton(text = "4", onClick = onNumberClick("4"))
            NumberButton(text = "5", onClick = onNumberClick("5"))
            NumberButton(text = "6", onClick = onNumberClick("6"))
            OperationButton(
                text = "🔄",
                emoji = "🔄",
                onClick = { onOperationClick("^", "🔄") }
            )
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            NumberButton(text = "1", onClick = onNumberClick("1"))
            NumberButton(text = "2", onClick = onNumberClick("2"))
            NumberButton(text = "3", onClick = onNumberClick("3"))
            OperationButton(
                text = "🧩",
                emoji = "🧩",
                onClick = { onOperationClick("√", "🧩") }
            )
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            NumberButton(text = "0", onClick = onNumberClick("0"))
            NumberButton(text = ".", onClick = onNumberClick("."))
            NumberButton(text = "⌫", onClick = onNumberClick("⌫"))
            NumberButton(text = "=", onClick = onEqualsClick)
        }
    }
}

@Composable
fun NumberButton(text: String, onClick: () -> Unit) {
    Button(
        onClick = onClick,
        modifier = Modifier
            .size(64.dp)
            .padding(4.dp),
        colors = ButtonDefaults.buttonColors(
            containerColor = MaterialTheme.colorScheme.primaryContainer,
            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
        )
    ) {
        Text(text = text, fontSize = 20.sp)
    }
}

@Composable
fun OperationButton(text: String, emoji: String, onClick: () -> Unit) {
    Button(
        onClick = onClick,
        modifier = Modifier
            .size(64.dp)
            .padding(4.dp),
        colors = ButtonDefaults.buttonColors(
            containerColor = MaterialTheme.colorScheme.secondaryContainer,
            contentColor = MaterialTheme.colorScheme.onSecondaryContainer
        )
    ) {
        Column(horizontalAlignment = Alignment.CenterHorizontally) {
            Text(text = text, fontSize = 16.sp)
            Text(text = emoji, fontSize = 14.sp)
        }
    }
}

@Composable
fun QuizDisplay(
    quizResult: Int,
    onResultChosen: (Boolean) -> Unit,
    showResult: Boolean,
    result: String
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .weight(1f),
        verticalArrangement = Arrangement.Center
    ) {
        Text(
            text = "Was ist das Ergebnis von $result?",
            style = MaterialTheme.typography.bodyLarge,
            modifier = Modifier.padding(vertical = 16.dp)
        )

        if (showResult) {
            Text(
                text = quizResult.toString(),
                fontSize = 48.sp,
                modifier = Modifier.padding(vertical = 16.dp)
            )
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            OutlinedButton(
                onClick = { onResultChosen(true) },
                modifier = Modifier.weight(1f)
            ) {
                Text("Correct")
            }
            OutlinedButton(
                onClick = { onResultChosen(false) },
                modifier = Modifier.weight(1f)
            ) {
                Text("Wrong")
            }
        }
    }
}

fun calculateExpression(expression: String): Double {
    return expression
        .replace(" ", "")
        .replace("🔟", "+")
        .replace("🔁", "-")
        .replace("✖️", "*")
        .replace("🔹", "/")
        .replace("🔄", "^")
        .replace("🧩", "√")
        .let { expr ->
            try {
                val result = java.lang.Double.parseDouble(
                    expr
                        .replace("^", "").let { expr ->
                            expr.split("√").mapIndexed { index, s ->
                                if (index == 0) s else "Math.sqrt($s)"
                            }.joinToString("")
                        }
                        .replace("+", " + ")
                        .replace("-", " - ")
                        .replace("*", " * ")
                        .replace("/", " / ")
                )
                result
            } catch (e: Exception) {
                throw Exception("Invalid expression")
            }
        }
}

@Composable
fun CalculAtorTheme(content: @Composable () -> Unit) {
    MaterialTheme(
        colorScheme = ColorScheme.light(
            primary = Color(0xFF6200EE),
            secondary = Color(0xFF03DAC6),
            tertiary = Color(0xFFE6007A)
        ),
        content = content
    )
}

@Preview(showBackground = true)
@Composable
fun CalculAtorPreview() {
    CalculAtorTheme {
        CalculAtorApp()
    }
}

```javascript
// Ailey's Dynamic Battle System Plugin for RPG Maker MZ
// Runs as a standalone Node.js script for testing and development

const fs = require('fs');
const path = require('path');

class AileyBattleSystem {
    constructor() {
        this.battleState = {
            actors: [],
            enemies: [],
            environment: {
                terrain: 'default',
                weather: 'clear',
                hazards: []
            },
            phase: 'combat',
            dynamicSkills: {},
            elementalAffinity: {
                fire: 0.8,
                water: 1.2,
                earth: 1.0,
                wind: 0.9
            },
            skillTree: {
                branches: ['offense', 'defense', 'support', 'utility'],
                nodes: [],
                currentPath: null
            },
            battleLog: []
        };
    }

    // Initialize the battle system with default or custom parameters
    initBattle(actors = [], enemies = [], environment = {}) {
        this.battleState.actors = actors.map(actor => ({
            name: actor.name,
            hp: actor.hp,
            maxHp: actor.hp,
            mp: actor.mp,
            maxMp: actor.mp,
            attack: actor.attack,
            defense: actor.defense,
            skills: actor.skills || [],
            elementalResistances: actor.elementalResistances || { fire: 1, water: 1, earth: 1, wind: 1 },
            skillPoints: actor.skillPoints || 0,
            equippedSkills: []
        }));

        this.battleState.enemies = enemies.map(enemy => ({
            name: enemy.name,
            hp: enemy.hp,
            maxHp: enemy.hp,
            attack: enemy.attack,
            defense: enemy.defense,
            skills: enemy.skills || [],
            elementalResistances: enemy.elementalResistances || { fire: 1, water: 1, earth: 1, wind: 1 }
        }));

        this.battleState.environment = {
            ...this.battleState.environment,
            ...environment
        };

        this.battleState.battleLog.push({
            type: 'init',
            message: `Battle started with ${this.battleState.actors.length} actors and ${this.battleState.enemies.length} enemies.`,
            timestamp: new Date()
        });

        this.initializeSkillTree();
    }

    // Initialize the skill tree with branches and nodes
    initializeSkillTree() {
        const branches = this.battleState.skillTree.branches;

        // Generate skill tree nodes for each branch
        branches.forEach(branch => {
            for (let i = 1; i <= 3; i++) {
                const node = {
                    id: `${branch}_${i}`,
                    branch: branch,
                    level: i,
                    skills: this.generateSkillsForBranch(branch, i),
                    unlocked: false,
                    requiredPoints: i * 2
                };
                this.battleState.skillTree.nodes.push(node);
            }
        });

        // Set the first node in each branch as the starting path
        this.battleState.skillTree.currentPath = branches.map(branch => `${branch}_1`);
    }

    // Generate skills based on branch and level
    generateSkillsForBranch(branch, level) {
        const skills = [];

        switch (branch) {
            case 'offense':
                skills.push({
                    name: `Offensive Blow ${level}`,
                    type: 'attack',
                    damage: 5 * level,
                    element: level > 2 ? this.getRandomElement() : null,
                    effect: `Deals ${5 * level} damage.`
                });
                break;
            case 'defense':
                skills.push({
                    name: `Defensive Stance ${level}`,
                    type: 'defense',
                    defenseBoost: 2 * level,
                    duration: level === 3 ? 'permanent' : `${level * 2} turns`,
                    effect: `Increases defense by ${2 * level}. Lasts ${level === 3 ? 'permanently' : `${level * 2} turns`}.`
                });
                break;
            case 'support':
                skills.push({
                    name: `Healing Surge ${level}`,
                    type: 'heal',
                    healAmount: 10 * level,
                    effect: `Heals for ${10 * level} HP.`
                });
                break;
            case 'utility':
                skills.push({
                    name: `Utility Skill ${level}`,
                    type: 'utility',
                    effect: level === 1 ? `Grants +1 skill point.` : `Allows the actor to perform an action twice this turn.`,
                    cooldown: level > 1 ? level * 2 : null
                });
                break;
        }

        return skills;
    }

    // Get a random element (fire, water, earth, wind)
    getRandomElement() {
        const elements = ['fire', 'water', 'earth', 'wind'];
        return elements[Math.floor(Math.random() * elements.length)];
    }

    // Unlock the next node in the skill tree path
    unlockNextNode(branch) {
        const currentIndex = this.battleState.skillTree.currentPath.indexOf(branch);
        if (currentIndex === -1) return false;

        const nextNodeId = this.battleState.skillTree.nodes.find(node =>
            node.branch === branch && node.level === currentIndex + 2
        )?.id;

        if (!nextNodeId) return false;

        const node = this.battleState.skillTree.nodes.find(node => node.id === nextNodeId);
        if (node) {
            node.unlocked = true;
            this.battleState.battleLog.push({
                type: 'skill',
                message: `Node ${nextNodeId} unlocked!`,
                timestamp: new Date()
            });
            return true;
        }

        return false;
    }

    // Distribute skill points to unlock nodes
    distributeSkillPoints(points, branch) {
        if (points <= 0 || !branch) {
            this.battleState.battleLog.push({
                type: 'error',
                message: `Invalid distribution: ${points} points for branch ${branch}.`,
                timestamp: new Date()
            });
            return false;
        }

        const branchIndex = this.battleState.skillTree.branches.indexOf(branch);
        if (branchIndex === -1) {
            this.battleState.battleLog.push({
                type: 'error',
                message: `Invalid branch: ${branch}.`,
                timestamp: new Date()
            });
            return false;
        }

        const currentNode = this.battleState.skillTree.nodes.find(node =>
            node.branch === branch && node.id === this.battleState.skillTree.currentPath[branchIndex]
        );

        if (!currentNode) {
            this.battleState.battleLog.push({
                type: 'error',
                message: `Current node for branch ${branch} not found.`,
                timestamp: new Date()
            });
            return false;
        }

        if (points >= currentNode.requiredPoints) {
            const pointsSpent = currentNode.requiredPoints;
            currentNode.unlocked = true;
            this.unlockNextNode(branch);
            this.battleState.battleLog.push({
                type: 'skill',
                message: `Spent ${pointsSpent} skill points to unlock node ${branch}_${currentNode.level + 1}.`,
                timestamp: new Date()
            });
            return true;
        } else {
            this.battleState.battleLog.push({
                type: 'skill',
                message: `Not enough skill points. Required: ${currentNode.requiredPoints}, Provided: ${points}.`,
                timestamp: new Date()
            });
            return false;
        }
    }

    // Process a turn in the battle
    processTurn(actorIndex, action) {
        if (actorIndex < 0 || actorIndex >= this.battleState.actors.length) {
            this.battleState.battleLog.push({
                type: 'error',
                message: `Invalid actor index: ${actorIndex}.`,
                timestamp: new Date()
            });
            return false;
        }

        const actor = this.battleState.actors[actorIndex];
        const enemiesAlive = this.battleState.enemies.filter(enemy => enemy.hp > 0);

        if (enemiesAlive.length === 0) {
            this.battleState.battleLog.push({
                type: 'end',
                message: `Battle ended! All enemies defeated.`,
                timestamp: new Date()
            });
            return true;
        }

        if (action.type === 'attack') {
            const targetIndex = Math.floor(Math.random() * enemiesAlive.length);
            const targetEnemy = this.battleState.enemies[targetIndex];

            let damage = Math.floor(actor.attack * Math.random() * 2 + 1);
            if (action.skill?.element) {
                const elementalDamage = this.calculateElementalDamage(actor, targetEnemy, action.skill.element);
                damage = Math.floor(damage * elementalDamage);
            }

            targetEnemy.hp -= damage;
            this.battleState.battleLog.push({
                type: 'attack',
                message: `${actor.name} attacks ${targetEnemy.name} for ${damage} damage!`,
                timestamp: new Date()
            });

            if (targetEnemy.hp <= 0) {
                this.battleState.battleLog.push({
                    type: 'enemy_defeated',
                    message: `${targetEnemy.name} has been defeated!`,
                    timestamp: new Date()
                });
                this.battleState.enemies = this.battleState.enemies.filter(e => e !== targetEnemy);
            }

            return true;
        } else if (action.type === 'useSkill') {
            const skill = actor.skills.find(s => s.name === action.skillName);
            if (!skill) {
                this.battleState.battleLog.push({
                    type: 'error',
                    message: `Skill ${action.skillName} not found for ${actor.name}.`,
                    timestamp: new Date()
                });
                return false;
            }

            if (skill.type === 'heal') {
                const healAmount = skill.healAmount || 0;
                actor.hp = Math.min(actor.hp + healAmount, actor.maxHp);
                this.battleState.battleLog.push({
                    type: 'heal',
                    message: `${actor.name} uses ${skill.name} and heals for ${healAmount} HP.`,
                    timestamp: new Date()
                });
                return true;
            } else if (skill.type === 'defense') {
                const defenseBoost = skill.defenseBoost || 0;
                actor.defense += defenseBoost;
                this.battleState.battleLog.push({
                    type: 'defense',
                    message: `${actor.name} uses ${skill.name} and gains ${defenseBoost} defense.`,
                    timestamp: new Date()
                });
                return true;
            } else if (skill.type === 'utility') {
                if (skill.effect === 'Grants +1 skill point.') {
                    actor.skillPoints += 1;
                    this.battleState.battleLog.push({
                        type: 'utility',
                        message: `${actor.name} uses ${skill.name} and gains +1 skill point.`,
                        timestamp: new Date()
                    });
                    return true;
                } else if (skill.effect === 'Allows the actor to perform an action twice this turn.') {
                    actor.actionCount = 2;
                    this.battleState.battleLog.push({
                        type: 'utility',
                        message: `${actor.name} uses ${skill.name} and gets an extra action this turn.`,
                        timestamp: new Date()
                    });
                    return true;
                }
            } else if (skill.type === 'attack') {
                const enemiesAlive = this.battleState.enemies.filter(e => e.hp > 0);
                if (enemiesAlive.length === 0) {
                    this.battleState.battleLog.push({
                        type: 'end',
                        message: `Battle ended! All enemies defeated.`,
                        timestamp: new Date()
                    });
                    return true;
                }

                const targetIndex = Math.floor(Math.random() * enemiesAlive.length);
                const targetEnemy = enemiesAlive[targetIndex];

                let damage = skill.damage || Math.floor(actor.attack * Math.random() * 2 + 1);
                if (skill.element) {
                    const elementalDamage = this.calculateElementalDamage(actor, targetEnemy, skill.element);
                    damage = Math.floor(damage * elementalDamage);
                }

                targetEnemy.hp -= damage;
                this.battleState.battleLog.push({
                    type: 'attack',
                    message: `${actor.name} uses ${skill.name} on ${targetEnemy.name} for ${damage} damage!`,
                    timestamp: new Date()
                });

                if (targetEnemy.hp <= 0) {
                    this.battleState.battleLog.push({
                        type: 'enemy_defeated',
                        message: `${targetEnemy.name} has been defeated!`,
                        timestamp: new Date()
                    });
                    this.battleState.enemies = this.battleState.enemies.filter(e => e !== targetEnemy);
                }

                return true;
            }

            this.battleState.battleLog.push({
                type: 'error',
                message: `Skill ${skill.name} of type ${skill.type} is not implemented.`,
                timestamp: new Date()
            });
            return false;
        } else if (action.type === 'distributeSkillPoints') {
            const { points, branch } = action;
            if (this.distributeSkillPoints(points, branch)) {
                this.battleState.battleLog.push({
                    type: 'skill',
                    message: `Distributed ${points} skill points to branch ${branch}.`,
                    timestamp: new Date()
                });
                return true;
            }
            return false;
        }

        this.battleState.battleLog.push({
            type: 'error',
            message: `Action type ${action.type} is not implemented.`,
            timestamp: new Date()
        });
        return false;
    }

    // Calculate elemental damage based on actor's and enemy's resistances
    calculateElementalDamage(actor, enemy, element) {
        const actorElementalStrength = this.battleState.elementalAffinity[element] || 1.0;
        const enemyResistance = enemy.elementalResistances[element] || 1.0;

        return actorElementalStrength / enemyResistance;
    }

    // Check if the battle is over (all enemies or all actors defeated)
    isBattleOver() {
        const enemiesAlive = this.battleState.enemies.some(enemy => enemy.hp > 0);
        const actorsAlive = this.battleState.actors.some(actor => actor.hp > 0);

        if (!enemiesAlive) {
            this.battleState.battleLog.push({
                type: 'end',
                message: `Battle ended! All enemies defeated.`,
                timestamp: new Date()
            });
            return true;
        }

        if (!actorsAlive) {
            this.battleState.battleLog.push({
                type: 'end',
                message: `Battle ended! All actors defeated.`,
                timestamp: new Date()
            });
            return true;
        }

        return false;
    }

    // Get the current battle log
    getBattleLog() {
        return this.battleState.battleLog;
    }

    // Get the current skill tree state
    getSkillTreeState() {
        return this.battleState.skillTree;
    }

    // Save the battle state to a file (for RPG Maker MZ compatibility)
    saveBattleState(filePath) {
        const data = {
            battleState: this.battleState,
            timestamp: new Date().toISOString()
        };

        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
        this.battleState.battleLog.push({
            type: 'save',
            message: `Battle state saved to ${filePath}.`,
            timestamp: new Date()
        });

        return true;
    }

    // Load a battle state from a file (for RPG Maker MZ compatibility)
    loadBattleState(filePath) {
        if (!fs.existsSync(filePath)) {
            this.battleState.battleLog.push({
                type: 'error',
                message: `File ${filePath} not found.`,
                timestamp: new Date()
            });
            return false;
        }

        const rawData = fs.readFileSync(filePath, 'utf8');
        const data = JSON.parse(rawData);

        this.battleState = data.battleState;
        this.battleState.battleLog.push({
            type: 'load',
            message: `Battle state loaded from ${filePath}.`,
            timestamp: new Date()
        });

        return true;
    }
}

// Example usage
const battleSystem = new AileyBattleSystem();

// Define some actors and enemies for testing
const actors = [
    {
        name: 'Ailey',
        hp: 100,
        attack: 20,
        defense: 10,
        skills: [
            {
                name: 'Fireball',
                type: 'attack',
                damage: 25,
                element: 'fire',
                effect: 'Deals 25 fire damage.'
            },
            {
                name: 'Healing Surge',
                type: 'heal',
                healAmount: 30,
                effect: 'Heals for 30 HP.'
            },
            {
                name: 'Defensive Stance',
                type: 'defense',
                defenseBoost: 5,
                duration: '3 turns',
                effect: 'Increases defense by 5. Lasts 3 turns.'
            }
        ],
        elementalResistances: {
            fire: 1.0,
            water: 1.0,
            earth: 1.0,
            wind: 1.0
        },
        skillPoints: 3
    },
    {
        name: 'Kira',
        hp: 90,
        attack: 18,
        defense: 12,
        skills: [
            {
                name: 'Thunder Strike',
                type: 'attack',
                damage: 22,
                element

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Interactive Cosmic Particle Garden</title>
    <style>
        body {
            margin: 0;
            overflow: hidden;
            background: #000;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Arial', sans-serif;
        }

        canvas {
            display: block;
        }

        #info {
            position: absolute;
            top: 20px;
            color: #fff;
            text-shadow: 0 0 10px #0ff;
            font-size: 14px;
            background: rgba(0, 0, 0, 0.3);
            padding: 10px;
            border-radius: 5px;
            opacity: 0.8;
        }

        .controls {
            position: absolute;
            bottom: 20px;
            color: #fff;
            text-align: center;
        }

        button {
            background: rgba(255, 255, 255, 0.2);
            color: #fff;
            border: 1px solid rgba(255, 255, 255, 0.5);
            padding: 8px 16px;
            margin: 0 5px;
            border-radius: 5px;
            cursor: pointer;
            font-size: 12px;
            transition: all 0.2s;
        }

        button:hover {
            background: rgba(255, 255, 255, 0.4);
        }
    </style>
</head>
<body>
    <div id="info">Interactive Cosmic Particle Garden - Move your mouse to grow cosmic life!</div>
    <div class="controls">
        <button id="clearBtn">Clear All Particles</button>
        <button id="saveBtn">Save as Image</button>
    </div>
    <canvas id="canvas"></canvas>

    <script>
        // Main canvas setup
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        const info = document.getElementById('info');
        const clearBtn = document.getElementById('clearBtn');
        const saveBtn = document.getElementById('saveBtn');

        // Set canvas to full window size
        function resizeCanvas() {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
        }
        window.addEventListener('resize', resizeCanvas);
        resizeCanvas();

        // Particle system configuration
        const particleSystem = {
            particles: [],
            maxParticles: 300,
            particleSpawnRate: 0.0005,
            mouse: {
                x: canvas.width / 2,
                y: canvas.height / 2
            },
            colors: [
                '#FF00FF', '#00FFFF', '#FFFF00', '#FF0066', '#6600FF', '#00FF66',
                '#FF6600', '#0066FF', '#66FF00', '#FF00AA', '#AA00FF', '#00AFFF',
                '#AFFF00', '#FF66AA', '#66AFFF', '#AAFFAA'
            ],
            gravity: 0.01,
            friction: 0.99,
            wind: { x: 0, y: 0.001 },
            decay: 0.99,
            connectionThreshold: 100,
            bloom: true,
            bloomIntensity: 0.1
        };

        // Particle class
        class Particle {
            constructor(x, y, colorIndex) {
                this.x = x;
                this.y = y;
                this.colorIndex = colorIndex;
                this.color = particleSystem.colors[colorIndex];
                this.size = 1 + Math.random() * 3;
                this.speedX = (Math.random() - 0.5) * 2;
                this.speedY = (Math.random() - 0.5) * 2;
                this.life = 1;
                this.maxLife = 0.5 + Math.random() * 1;
                this.lifeCycle = 0;
                this.angle = Math.random() * Math.PI * 2;
                this.angleSpeed = (Math.random() - 0.5) * 0.05;
                this.brightness = 1;
                this.wasMouseOver = false;
            }

            update() {
                // Move particle with physics
                this.speedX *= particleSystem.friction;
                this.speedY *= particleSystem.friction;
                this.speedX += particleSystem.wind.x;
                this.speedY += particleSystem.wind.y + particleSystem.gravity;

                this.x += this.speedX;
                this.y += this.speedY;

                // Update life cycle and brightness
                this.lifeCycle += 0.005;
                if (this.lifeCycle >= this.maxLife) {
                    this.brightness = 1 - (this.lifeCycle - this.maxLife) * 2;
                    if (this.brightness <= 0) return true; // Return true if particle should be removed
                } else {
                    this.brightness = 1;
                }

                return false;
            }

            draw() {
                ctx.fillStyle = this.color;
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.size * this.brightness, 0, Math.PI * 2);
                ctx.fill();

                // Draw glow effect
                if (particleSystem.bloom && this.brightness > 0.3) {
                    const glowSize = this.size * 2 * this.brightness;
                    ctx.fillStyle = `rgba(255, 255, 255, ${this.brightness * 0.5})`;
                    ctx.beginPath();
                    ctx.arc(this.x, this.y, glowSize, 0, Math.PI * 2);
                    ctx.fill();
                }

                // Draw line to previous position if we're near another particle
                if (this.wasMouseOver) {
                    ctx.strokeStyle = this.color;
                    ctx.lineWidth = this.size * 0.2 * this.brightness;
                    ctx.beginPath();
                    ctx.moveTo(this.x, this.y);
                    ctx.lineTo(this.x + Math.cos(this.angle) * 10, this.y + Math.sin(this.angle) * 10);
                    ctx.stroke();
                }
            }
        }

        // Add mouse position tracking
        canvas.addEventListener('mousemove', (e) => {
            const rect = canvas.getBoundingClientRect();
            particleSystem.mouse.x = e.clientX - rect.left;
            particleSystem.mouse.y = e.clientY - rect.top;
        });

        canvas.addEventListener('mousedown', () => {
            // Small burst of particles when mouse is clicked
            for (let i = 0; i < 30; i++) {
                addParticle(particleSystem.mouse.x, particleSystem.mouse.y);
            }
        });

        // Add buttons functionality
        clearBtn.addEventListener('click', () => {
            particleSystem.particles = [];
            info.textContent = 'Cosmic garden cleared! Start growing new life by moving your mouse.';
        });

        saveBtn.addEventListener('click', () => {
            const link = document.createElement('a');
            link.download = 'cosmic-particle-garden.png';
            link.href = canvas.toDataURL('image/png');
            link.click();
            info.textContent = 'Image saved!';
            setTimeout(() => {
                info.textContent = 'Interactive Cosmic Particle Garden - Move your mouse to grow cosmic life!';
            }, 2000);
        });

        // Main game loop
        function animate() {
            // Clear canvas with subtle background
            ctx.fillStyle = 'rgba(0, 0, 0, 0.05)';
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // Update and draw particles
            for (let i = particleSystem.particles.length - 1; i >= 0; i--) {
                const particle = particleSystem.particles[i];

                // Check if particle is near mouse
                const distToMouse = Math.sqrt(
                    Math.pow(particle.x - particleSystem.mouse.x, 2) +
                    Math.pow(particle.y - particleSystem.mouse.y, 2)
                );

                if (distToMouse < 50) {
                    particle.wasMouseOver = true;
                    // Create connections between particles
                    for (let j = 0; j < particleSystem.particles.length; j++) {
                        if (i !== j) {
                            const otherParticle = particleSystem.particles[j];
                            const dist = Math.sqrt(
                                Math.pow(particle.x - otherParticle.x, 2) +
                                Math.pow(particle.y - otherParticle.y, 2)
                            );

                            if (dist < particleSystem.connectionThreshold) {
                                ctx.strokeStyle = `rgba(255, 255, 255, ${0.1 * particle.brightness * otherParticle.brightness})`;
                                ctx.lineWidth = 0.5;
                                ctx.beginPath();
                                ctx.moveTo(particle.x, particle.y);
                                ctx.lineTo(otherParticle.x, otherParticle.y);
                                ctx.stroke();
                            }
                        }
                    }
                } else {
                    particle.wasMouseOver = false;
                }

                // Update particle position and check if it should be removed
                if (particle.update()) {
                    particleSystem.particles.splice(i, 1);
                } else {
                    particle.draw();
                }
            }

            // Add new particles based on mouse position and spawn rate
            if (Math.random() < particleSystem.particleSpawnRate) {
                addParticle(particleSystem.mouse.x, particleSystem.mouse.y);
            }

            // Add wind with slight randomness
            particleSystem.wind.x += (Math.random() - 0.5) * 0.001;
            particleSystem.wind.y += (Math.random() - 0.5) * 0.0005;

            requestAnimationFrame(animate);
        }

        // Function to add a new particle
        function addParticle(x, y) {
            if (particleSystem.particles.length >= particleSystem.maxParticles) return;

            // Sometimes create a particle with different properties based on mouse position
            const colorIndex = Math.floor(Math.random() * particleSystem.colors.length);
            const particle = new Particle(x, y, colorIndex);

            // If mouse is moving fast, give the particle more initial speed
            const mouseSpeed = Math.sqrt(
                Math.pow(particleSystem.mouse.x - (particleSystem.mouse.x - 1), 2) +
                Math.pow(particleSystem.mouse.y - (particleSystem.mouse.y - 1), 2)
            );

            particle.speedX = (Math.random() - 0.5) * (2 + mouseSpeed * 2);
            particle.speedY = (Math.random() - 0.5) * (2 + mouseSpeed * 2);
            particle.size = 1 + Math.random() * 5;

            particleSystem.particles.push(particle);
        }

        // Start the animation
        animate();
    </script>
</body>
</html>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Execute with Node.js
main();

using UnityEngine;
using UnityEngine.Serialization;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return currentSpeed;
    }

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

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

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

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

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

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

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

        _isKnockingBack = true;
        _knockbackTimer = knockbackDuration;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // Button grid
        CalculatorButtons(viewModel = viewModel)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extends Node

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

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

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

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

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

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

    update_buttons()

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

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

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

    current_buttons.clear()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

```swift
import SwiftUI
import UserNotifications
import Combine

// MARK: - Data Models

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

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

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

// MARK: - Data Manager

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

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

    init() {
        loadHabits()
        setupSampleData()
    }

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

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

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

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

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

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

// MARK: - Notification Manager

class NotificationManager {
    static let shared = NotificationManager()

    private init() {}

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

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

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

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

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

// MARK: - Utilities

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

    @State private var waveProgress: CGFloat = 0

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

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

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

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

// MARK: - Main Views

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

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

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

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

                            // Progress visualization
                            ProgressWaveView(store: store)

                            // Streaks
                            StreaksView(store: store)

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

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

// MARK: - Subviews

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

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

            Spacer()

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

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

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

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

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

struct ProgressWaveView: View {
    @ObservedObject var store: HabitStore

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

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

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

struct StreaksView: View {
    @ObservedObject var store: HabitStore

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

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

                                    Spacer()

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

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

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

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

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

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

// MARK: - Add Habit View

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

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

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

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

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

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

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

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

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

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

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

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

                    ColorPicker("Color", selection: $color