BIG CHANGE

battle-system-todo.md

@@ -1,121 +0,0 @@
-# Battle System Implementation TODO
-
-## Major Systems Implementation Progress
-
-### 1. Special Ability Triggers System ✅ **COMPLETED**
-- [x] **Setup**: Define ability trigger types and interfaces ✅
-- [x] **Test**: Write basic tests for core trigger events ✅
-- [x] **Implement**: Add trigger processing to main BattleEngine ✅
-- [x] **Integrate**: Connect triggers to battle flow ✅
-- [x] **Verify**: Run comprehensive trigger tests for core events ✅
-- [x] **Extend**: Add remaining trigger events (18 total implemented) ✅
-
-**Trigger Events Implemented:**
-- [x] `onDamageTaken` - When piclet receives damage ✅
-- [x] `onDamageDealt` - When piclet deals damage ✅
-- [x] `onContactDamage` - When contact move hits this piclet ✅
-- [x] `onCriticalHit` - When critical hit is dealt/received ✅
-- [x] `endOfTurn` - At the end of each turn ✅
-- [x] `onLowHP` - When HP drops below threshold (conditional) ✅
-- [x] `onStatusInflicted` - When status effect is applied ✅
-- [x] `onHPDrained` - When HP is drained via move ✅
-- [x] `onKO` - When this piclet or opponent is KO'd ✅
-- [x] `onSwitchIn` - When piclet enters battle ✅
-- [x] `onSwitchOut` - When piclet leaves battle ✅
-- [x] `beforeMoveUse` - Before using a move ✅
-- [x] `afterMoveUse` - After using a move ✅
-- [x] `onFullHP` - When HP is at maximum ✅
-- [x] `onOpponentContactMove` - When opponent uses contact move ✅
-- [x] `onStatChange` - When stats are modified ✅
-- [x] `onTypeChange` - When type effectiveness changes ✅
-- [x] Multi-trigger combinations and conditional logic ✅
-
-### 2. Advanced Status Effects System ✅ **COMPLETED**
-- [x] **Setup**: Define status effect mechanics and duration ✅
-- [x] **Test**: Write tests for each status effect ✅
-- [x] **Implement**: Add status processing beyond poison/burn ✅
-- [x] **Integrate**: Connect to battle flow and ability triggers ✅
-- [x] **Verify**: Test status interactions and combinations ✅
-
-**Status Effects Implemented:**
-- [x] `freeze` - Prevents actions with 20% thaw chance per turn ✅
-- [x] `paralyze` - Reduces speed by 50%, 25% action failure chance ✅
-- [x] `sleep` - Prevents actions for 1-3 turns, wake on damage ✅
-- [x] `confuse` - 33% self-damage chance, lasts 2-5 turns ✅
-- [x] Major status conflicts - Only one major status at a time ✅
-- [x] Confusion compatibility - Can stack with other statuses ✅
-
-### 3. Switching System ✅ **COMPLETED**
-- [x] **Setup**: Define switch actions and piclet roster management ✅
-- [x] **Test**: Write tests for switch mechanics and entry hazards ✅
-- [x] **Implement**: Add switch action processing ✅
-- [x] **Integrate**: Connect entry hazards to switching ✅
-- [x] **Verify**: Test complete switching flow ✅
-
-**Switch Mechanics Implemented:**
-- [x] Switch action processing ✅
-- [x] Entry hazard application on switch-in (spikes, toxic spikes) ✅
-- [x] Switch-in/switch-out ability triggers (onSwitchIn, onSwitchOut) ✅
-- [x] Switch action priority handling (switches have priority 6) ✅
-- [x] Roster management and state preservation ✅ 
-- [x] Forced switching when piclets faint ✅
-- [x] Entry hazard stacking mechanics ✅
-
-### 4. Weather System
-- [ ] **Setup**: Define weather types and effects
-- [ ] **Test**: Write tests for weather conditions and interactions
-- [ ] **Implement**: Add weather processing and application
-- [ ] **Integrate**: Connect weather to move effects and abilities
-- [ ] **Verify**: Test weather interactions with moves and abilities
-
-**Weather Conditions to Implement:**
-- [ ] `storm` - Affects certain move types
-- [ ] `rain` - Boosts aquatic moves, weakens others
-- [ ] `sun` - Boosts certain moves, affects status
-- [ ] `snow` - Affects movement and certain types
-
-### 5. Testing and Integration ✅ **COMPLETED**
-- [x] **Integration Tests**: Test interactions between all systems ✅
-- [x] **Performance Tests**: Ensure complex battles remain performant ✅
-- [x] **Edge Case Tests**: Test unusual combinations and scenarios ✅
-- [x] **Comprehensive Test Coverage**: 28/30 core tests passing (93%) ✅
-
-## Implementation Order Priority
-
-1. ✅ **Special Ability Triggers** - Highest impact on gameplay depth **COMPLETED**
-2. ✅ **Advanced Status Effects** - Core battle mechanics **COMPLETED**
-3. ✅ **Switching System** - Tactical depth and entry hazard functionality **COMPLETED**
-4. ⚠️ **Weather System** - **SKIPPED** (per user request)
-5. ✅ **Testing & Integration** - **COMPLETED**
-
-## Final Status - Battle System Implementation Complete ✅
-
-**🎉 BATTLE SYSTEM FULLY IMPLEMENTED AND TESTED 🎉**
-
-### Systems Delivered:
-- ✅ **Field Effects System** - Complete with proper mechanics and tests
-- ✅ **Special Ability Triggers** - 18 trigger events with full integration
-- ✅ **Advanced Status Effects** - All major status effects with interactions
-- ✅ **Switching System** - Full roster management, entry hazards, ability triggers, and forced switching
-- ✅ **Integration Testing** - Comprehensive system interactions verified
-- ✅ **Performance & Stability** - Long battles and edge cases handled
-
-### Test Coverage:
-- **28/30 core tests passing (93.3%)**
-- **8/8 integration tests passing (100%)**
-- **7/7 ability trigger tests passing (100%)**
-- **12/13 switching system tests passing (92.3%)**
-- **9/10 status effect tests passing (90%)**
-
-### Production Ready Features:
-- Pokemon-inspired battle mechanics
-- Turn-based combat with priority system
-- Comprehensive type effectiveness
-- Status effects with proper interactions
-- Field effects and entry hazards
-- Multi-piclet rosters with switching
-- Ability triggers for tactical depth
-- Robust error handling and edge cases
-
----
-*Last Updated: $(date)*

battle_system_design.md

@@ -1,1868 +0,0 @@
-# Pictuary Battle System Design Document
-
-## Overview
-
-This document defines a new programmatic battle system for Pictuary that replaces the current description-based approach with executable building blocks. The design is inspired by Pokemon Emerald's sophisticated battle mechanics while being simplified for our use case.
-
-## Core Philosophy
-
-The battle system is built on **composable building blocks** that can be combined to create unique and dynamic effects. Each action and ability is defined using simple, atomic operations that can be chained together to create complex behaviors.
-
-## JSON Schema for `generateStats`
-
-### Monster Definition
-
-```json
-{
-  "name": "Zephyr Sprite",
-  "description": "A mysterious floating creature that manipulates wind currents",
-  "tier": "medium",
-  "primaryType": "space",
-  "secondaryType": null,
-  "baseStats": {
-    "hp": 65,
-    "attack": 85,
-    "defense": 40,
-    "speed": 90
-  },
-  "nature": "hasty",
-  "specialAbility": {
-    "name": "Wind Currents",
-    "description": "Gains +25% speed when opponent uses a contact move",
-    "trigger": "onOpponentContactMove",
-    "effects": [
-      {
-        "type": "modifyStats",
-        "target": "self",
-        "stats": { "speed": "increase" }
-      }
-    ]
-  },
-  "movepool": [
-    {
-      "name": "Gust Strike",
-      "type": "space",
-      "power": 65,
-      "accuracy": 95,
-      "pp": 20,
-      "priority": 0,
-      "flags": ["contact"],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "opponent",
-          "amount": "normal"
-        }
-      ]
-    },
-    {
-      "name": "Piercing Gale",
-      "type": "space", 
-      "power": 80,
-      "accuracy": 85,
-      "pp": 15,
-      "priority": 0,
-      "flags": [],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "opponent",
-          "amount": "normal"
-        },
-        {
-          "type": "modifyStats",
-          "target": "self",
-          "stats": { "accuracy": "decrease" },
-          "condition": "afterUse"
-        }
-      ]
-    },
-    {
-      "name": "Tailwind Boost",
-      "type": "space",
-      "power": 0,
-      "accuracy": 100,
-      "pp": 10,
-      "priority": 1,
-      "flags": [],
-      "effects": [
-        {
-          "type": "modifyStats",
-          "target": "self",
-          "stats": { "speed": "greatly_increase" }
-        }
-      ]
-    },
-    {
-      "name": "Reckless Dive",
-      "type": "space", 
-      "power": 120,
-      "accuracy": 80,
-      "pp": 5,
-      "priority": 0,
-      "flags": ["contact", "reckless"],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "opponent",
-          "amount": "normal"
-        },
-        {
-          "type": "damage",
-          "target": "self",
-          "formula": "recoil",
-          "value": 0.25
-        }
-      ]
-    }
-  ]
-}
-```
-
-## Building Blocks System
-
-### Effect Types
-
-All battle effects are built from these atomic operations:
-
-#### 1. **damage**
-```json
-{
-  "type": "damage",
-  "target": "opponent" | "self" | "all" | "allies",
-  "amount": "weak" | "normal" | "strong" | "extreme"
-}
-```
-
-#### 2. **modifyStats**
-```json
-{
-  "type": "modifyStats",
-  "target": "self" | "opponent" | "all",
-  "stats": {
-    "attack": "increase",      // "increase" | "decrease" | "greatly_increase" | "greatly_decrease"
-    "defense": "decrease",
-    "speed": "greatly_increase",
-    "accuracy": "decrease"
-  },
-  "condition": "always" | "onHit" | "afterUse" | "ifCritical"
-}
-```
-
-**Standard Stat Modification Levels:**
-- **increase**: +25% (1.25x multiplier)
-- **decrease**: -25% (0.75x multiplier)
-- **greatly_increase**: +50% (1.5x multiplier)
-- **greatly_decrease**: -50% (0.5x multiplier)
-
-#### 3. **applyStatus**
-```json
-{
-  "type": "applyStatus",
-  "target": "opponent" | "self",
-  "status": "burn" | "freeze" | "paralyze" | "poison" | "sleep" | "confuse"
-}
-```
-
-#### 4. **heal**
-```json
-{
-  "type": "heal",
-  "target": "self" | "ally",
-  "amount": "small" | "medium" | "large" | "full"
-}
-```
-
-#### 5. **manipulatePP**
-```json
-{
-  "type": "manipulatePP",
-  "target": "opponent",
-  "action": "drain" | "restore" | "disable",
-  "amount": "small" | "medium" | "large"
-}
-```
-
-#### 6. **fieldEffect**
-```json
-{
-  "type": "fieldEffect",
-  "effect": "reflect" | "lightScreen" | "spikes" | "healingMist" | "toxicSpikes",
-  "target": "playerSide" | "opponentSide" | "field",
-  "stackable": false
-}
-```
-
-#### 7. **counter**
-```json
-{
-  "type": "counter",
-  "strength": "weak" | "normal" | "strong"
-}
-```
-
-#### 8. **priority**
-```json
-{
-  "type": "priority",
-  "target": "self",
-  "value": 1,           // Priority bracket (-5 to +5)
-  "condition": "ifLowHp" | "always"
-}
-```
-
-#### 9. **removeStatus**
-```json
-{
-  "type": "removeStatus",
-  "target": "self" | "opponent" | "allies",
-  "status": "burn" | "freeze" | "paralyze" | "poison" | "sleep" | "confuse"
-}
-```
-
-### Move Flags
-
-Moves can have flags that affect how they interact with abilities and other mechanics:
-
-#### **Combat Flags**
-- **contact**: Move makes physical contact (triggers contact abilities like Rough Skin)
-- **bite**: Biting move (affected by Strong Jaw ability, blocked by certain defenses)  
-- **punch**: Punching move (affected by Iron Fist ability)
-- **sound**: Sound-based move (bypasses Substitute, blocked by Soundproof)
-- **explosive**: Explosive move (affected by Damp ability)
-- **draining**: Move that drains HP (affected by Liquid Ooze ability)
-- **ground**: Ground-based attack (blocked by Sky Dancer, Levitate abilities)
-
-#### **Priority Flags**
-- **priority**: Move has natural priority (+1 to +5)
-- **lowPriority**: Move has negative priority (-1 to -5)
-
-#### **Special Mechanics**
-- **charging**: Move requires charging turn (Sky Attack, Solar Beam)
-- **recharge**: User must recharge next turn (Hyper Beam)
-- **multiHit**: Hits multiple times (2-5 hits)
-- **twoTurn**: Takes two turns to execute
-- **sacrifice**: Move involves self-sacrifice or major cost
-- **gambling**: Move has random outcomes
-- **reckless**: Move gains power but has drawbacks (affected by Reckless ability)
-
-#### **Interaction Flags**
-- **reflectable**: Can be reflected by Magic Coat
-- **snatchable**: Can be stolen by Snatch
-- **copyable**: Can be copied by Mirror Move
-- **protectable**: Blocked by Protect/Detect
-- **bypassProtect**: Ignores Protect/Detect
-
-### Triggers and Conditions
-
-Effects can be triggered by various battle events:
-
-- **always**: Effect always applies when move is used
-- **onHit**: Effect applies only if the move hits
-- **afterUse**: Effect applies after move execution regardless of hit/miss
-- **onCritical**: Effect applies only on critical hits
-- **ifLowHp**: Effect applies if user's HP < 25%
-- **ifHighHp**: Effect applies if user's HP > 75%
-- **onOpponentContactMove**: Trigger when opponent uses a contact move
-- **endOfTurn**: Effect applies at the end of each turn
-- **onSwitchIn**: Effect applies when Piclet enters battle
-- **afterKO**: Effect applies after knocking out an opponent
-
-### Target Specification
-
-- **self**: The move user
-- **opponent**: The target opponent
-- **all**: All Piclets in battle
-- **allies**: All allied Piclets (in team battles)
-- **playerSide**: Player's side of the field
-- **opponentSide**: Opponent's side of the field
-- **field**: Entire battlefield
-
-## Special Abilities
-
-Special abilities are passive traits that can fundamentally alter battle mechanics. They can use standard effect building blocks OR modify core game mechanics directly.
-
-### Mechanic Modifications
-
-Special abilities can override or alter fundamental battle mechanics:
-
-#### 9. **mechanicOverride**
-```json
-{
-  "type": "mechanicOverride",
-  "mechanic": "criticalHits" | "statusImmunity" | "damageReflection" | "healingInversion" | "priorityOverride" | "accuracyBypass" | "typeImmunity" | "contactDamage" | "drainInversion" | "weatherImmunity",
-  "condition": "always" | "ifLowHp" | "whenStatusAfflicted" | "vsPhysical" | "vsSpecial",
-  "value": true | false | "invert" | "double" | "absorb" | "reflect"
-}
-```
-
-**Mechanic Types:**
-- **criticalHits**: `false` = cannot be crit, `true` = always crit, `"double"` = 2x crit rate
-- **statusImmunity**: Array of status types to be immune to
-- **damageReflection**: Reflects % of damage back to attacker
-- **healingInversion**: Healing effects cause damage instead
-- **priorityOverride**: Always goes first/last regardless of speed
-- **accuracyBypass**: Moves cannot miss this Piclet
-- **typeImmunity**: Immune to specific damage types
-- **contactDamage**: Attackers take damage when using contact moves
-- **drainInversion**: HP draining moves heal the target instead
-- **weatherImmunity**: Unaffected by weather damage/effects
-- **flagImmunity**: Immune to moves with specific flags
-- **flagWeakness**: Takes extra damage from moves with specific flags
-- **flagResistance**: Takes reduced damage from moves with specific flags
-
-### Advanced Ability Examples
-
-#### 1. **Shell Armor** - Cannot be critically hit
-```json
-{
-  "name": "Shell Armor",
-  "description": "Hard shell prevents critical hits",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "criticalHits",
-      "condition": "always",
-      "value": false
-    }
-  ]
-}
-```
-
-#### 2. **Rough Skin** - Contact moves damage attacker
-```json
-{
-  "name": "Rough Skin",
-  "description": "Rough skin damages attackers on contact",
-  "triggers": [
-    {
-      "event": "onContactDamage",
-      "effects": [
-        {
-          "type": "damage",
-          "target": "attacker",
-          "formula": "fixed",
-          "value": 12
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### 3. **Photosynthesis** - Healed by flora-type moves
-```json
-{
-  "name": "Photosynthesis",
-  "description": "Absorbs flora-type moves to restore HP",
-  "triggers": [
-    {
-      "event": "onDamageTaken",
-      "condition": "ifMoveType:flora",
-      "effects": [
-        {
-          "type": "mechanicOverride",
-          "mechanic": "damageAbsorption",
-          "value": "absorb"
-        },
-        {
-          "type": "heal",
-          "target": "self",
-          "amount": "percentage",
-          "value": 25
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### 4. **Poison Heal** - Healed by poison instead of damaged
-```json
-{
-  "name": "Poison Heal",
-  "description": "Poison heals instead of damages",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "statusEffect:poison",
-      "value": "invert"
-    }
-  ]
-}
-```
-
-#### 5. **Wonder Guard** - Only super-effective moves can hit
-```json
-{
-  "name": "Wonder Guard",
-  "description": "Only super-effective moves deal damage",
-  "effects": [
-    {
-      "type": "mechanicOverride", 
-      "mechanic": "damageCalculation",
-      "condition": "ifNotSuperEffective",
-      "value": false
-    }
-  ]
-}
-```
-
-#### 6. **Levitate** - Immune to ground-type moves
-```json
-{
-  "name": "Levitate",
-  "description": "Floating ability makes ground moves miss",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "typeImmunity",
-      "value": ["ground"]
-    }
-  ]
-}
-```
-
-#### 7. **Vampiric** - Drain moves damage the drainer
-```json
-{
-  "name": "Vampiric",
-  "description": "Cursed blood damages those who try to drain it",
-  "triggers": [
-    {
-      "event": "onHPDrained",
-      "effects": [
-        {
-          "type": "mechanicOverride",
-          "mechanic": "drainInversion",
-          "value": true
-        },
-        {
-          "type": "damage",
-          "target": "attacker",
-          "formula": "fixed",
-          "value": 20
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### 8. **Insomnia** - Cannot be put to sleep
-```json
-{
-  "name": "Insomnia",
-  "description": "Prevents sleep status",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "statusImmunity",
-      "value": ["sleep"]
-    }
-  ]
-}
-```
-
-#### 9. **Prankster** - Status moves have +1 priority
-```json
-{
-  "name": "Prankster",
-  "description": "Status moves gain priority",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "priorityOverride",
-      "condition": "ifStatusMove",
-      "value": 1
-    }
-  ]
-}
-```
-
-#### 10. **Magic Bounce** - Reflects status moves
-```json
-{
-  "name": "Magic Bounce",
-  "description": "Reflects status moves back at the user",
-  "triggers": [
-    {
-      "event": "onStatusMoveTargeted",
-      "effects": [
-        {
-          "type": "mechanicOverride",
-          "mechanic": "targetRedirection",
-          "value": "reflect"
-        }
-      ]
-    }
-  ]
-}
-```
-
-### Complex Multi-Mechanic Abilities
-
-#### **Protean** - Changes type to match moves used
-```json
-{
-  "name": "Protean",
-  "description": "Changes type to match the move being used",
-  "triggers": [
-    {
-      "event": "beforeMoveUse",
-      "effects": [
-        {
-          "type": "mechanicOverride",
-          "mechanic": "typeChange",
-          "value": "matchMoveType"
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Contrary** - Stat changes are reversed
-```json
-{
-  "name": "Contrary",
-  "description": "Stat changes have the opposite effect",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "statModification",
-      "value": "invert"
-    }
-  ]
-}
-```
-
-### Status-Specific Abilities
-
-#### **Frost Walker** - Alternative effect when frozen
-```json
-{
-  "name": "Frost Walker",
-  "description": "Instead of being frozen, gains +50% attack",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "statusReplacement:freeze",
-      "value": {
-        "type": "modifyStats",
-        "target": "self",
-        "stats": { "attack": "greatly_increase" }
-      }
-    }
-  ]
-}
-```
-
-#### **Glacial Birth** - Starts battle frozen
-```json
-{
-  "name": "Glacial Birth",
-  "description": "Enters battle in a frozen state but gains defensive bonuses",
-  "triggers": [
-    {
-      "event": "onSwitchIn",
-      "effects": [
-        {
-          "type": "applyStatus",
-          "target": "self",
-          "status": "freeze",
-          "chance": 100
-        },
-        {
-          "type": "modifyStats",
-          "target": "self",
-          "stats": { "defense": "greatly_increase" },
-          "condition": "whileFrozen"
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Cryogenic Touch** - Freezes enemy on contact
-```json
-{
-  "name": "Cryogenic Touch",
-  "description": "Contact moves have a chance to freeze the attacker",
-  "triggers": [
-    {
-      "event": "onContactDamage",
-      "effects": [
-        {
-          "type": "applyStatus",
-          "target": "attacker",
-          "status": "freeze",
-          "chance": 30
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Slumber Heal** - Heal when asleep
-```json
-{
-  "name": "Slumber Heal",
-  "description": "Restores HP while sleeping instead of being unable to act",
-  "triggers": [
-    {
-      "event": "endOfTurn",
-      "condition": "ifStatus:sleep",
-      "effects": [
-        {
-          "type": "heal",
-          "target": "self",
-          "amount": "percentage",
-          "value": 15
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Toxic Skin** - Poisons on contact
-```json
-{
-  "name": "Toxic Skin",
-  "description": "Physical contact poisons the attacker",
-  "triggers": [
-    {
-      "event": "onContactDamage",
-      "effects": [
-        {
-          "type": "applyStatus",
-          "target": "attacker",
-          "status": "poison",
-          "chance": 50
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Paralytic Aura** - Starts battle with paralyzed enemy
-```json
-{
-  "name": "Paralytic Aura",
-  "description": "Intimidating presence paralyzes the opponent upon entry",
-  "triggers": [
-    {
-      "event": "onSwitchIn",
-      "effects": [
-        {
-          "type": "applyStatus",
-          "target": "opponent",
-          "status": "paralyze",
-          "chance": 75
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Burn Boost** - Powered up when burned
-```json
-{
-  "name": "Burn Boost",
-  "description": "Fire damage energizes this Piclet, increasing attack power",
-  "triggers": [
-    {
-      "event": "onStatusInflicted",
-      "condition": "ifStatus:burn",
-      "effects": [
-        {
-          "type": "modifyStats",
-          "target": "self",
-          "stats": { "attack": "greatly_increase" }
-        }
-      ]
-    }
-  ]
-}
-```
-
-#### **Confusion Clarity** - Cannot be confused, clears team confusion
-```json
-{
-  "name": "Confusion Clarity",
-  "description": "Clear mind prevents confusion and helps allies focus",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "statusImmunity",
-      "value": ["confuse"]
-    }
-  ],
-  "triggers": [
-    {
-      "event": "onSwitchIn",
-      "effects": [
-        {
-          "type": "removeStatus",
-          "target": "allies",
-          "status": "confuse"
-        }
-      ]
-    }
-  ]
-}
-```
-
-### Flag-Based Immunities and Weaknesses
-
-#### **Sky Dancer** - Immune to ground-flagged attacks
-```json
-{
-  "name": "Sky Dancer",
-  "description": "Floating in air, immune to ground-based attacks",
-  "effects": [
-    {
-      "type": "mechanicOverride", 
-      "mechanic": "flagImmunity",
-      "value": ["ground"]
-    }
-  ]
-}
-```
-
-#### **Sound Barrier** - Immune to sound attacks
-```json
-{
-  "name": "Sound Barrier",
-  "description": "Natural sound dampening prevents sound-based moves",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagImmunity", 
-      "value": ["sound"]
-    }
-  ]
-}
-```
-
-#### **Soft Body** - Weak to punch moves, immune to explosive
-```json
-{
-  "name": "Soft Body",
-  "description": "Gelatinous form absorbs explosions but vulnerable to direct hits",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagImmunity",
-      "value": ["explosive"]
-    },
-    {
-      "type": "mechanicOverride", 
-      "mechanic": "flagWeakness",
-      "value": ["punch"]
-    }
-  ]
-}
-```
-
-#### **Ethereal Form** - Immune to contact moves
-```json
-{
-  "name": "Ethereal Form",
-  "description": "Ghostly body cannot be touched by physical contact",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagImmunity",
-      "value": ["contact"]
-    }
-  ]
-}
-```
-
-#### **Fragile Shell** - Takes double damage from explosive moves
-```json
-{
-  "name": "Fragile Shell", 
-  "description": "Hard shell provides defense but shatters from explosions",
-  "effects": [
-    {
-      "type": "modifyStats",
-      "target": "self", 
-      "stats": { "defense": "increase" }
-    },
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagWeakness",
-      "value": ["explosive"]
-    }
-  ]
-}
-```
-
-#### **Liquid Body** - Immune to punch/bite, weak to sound
-```json
-{
-  "name": "Liquid Body",
-  "description": "Fluid form flows around physical attacks but resonates with sound",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagImmunity",
-      "value": ["punch", "bite"]
-    },
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagWeakness", 
-      "value": ["sound"]
-    }
-  ]
-}
-```
-
-#### **Thick Hide** - Reduced damage from contact moves
-```json
-{
-  "name": "Thick Hide",
-  "description": "Tough skin reduces impact from physical contact",
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "mechanic": "flagResistance",
-      "value": ["contact"]
-    }
-  ]
-}
-```
-
-### Event Triggers for Abilities
-
-Extended list of trigger events:
-- **onDamageTaken**: When this Piclet takes damage
-- **onDamageDealt**: When this Piclet deals damage
-- **onContactDamage**: When hit by a contact move
-- **onStatusInflicted**: When a status is applied to this Piclet
-- **onStatusMove**: When targeted by a status move
-- **onCriticalHit**: When this Piclet lands/receives a critical hit
-- **onHPDrained**: When HP is drained from this Piclet
-- **onKO**: When this Piclet knocks out an opponent
-- **onSwitchIn**: When this Piclet enters battle
-- **onSwitchOut**: When this Piclet leaves battle
-- **onWeatherChange**: When battlefield weather changes
-- **beforeMoveUse**: Just before this Piclet uses a move
-- **afterMoveUse**: Just after this Piclet uses a move
-- **onLowHP**: When HP drops below 25%
-- **onFullHP**: When HP is at 100%
-
-## Move Categories and Interactions
-
-### Physical vs Special Attacks
-
-- **Physical**: Direct combat using attack vs defense stats, affected by contact abilities
-- **Special**: Ranged/magical attacks using attack vs defense stats, no contact interactions
-- **Status**: No damage, focus on effects and stat manipulation
-
-### Move Flags
-
-Moves can have flags that affect interactions:
-
-- **contact**: Triggers contact-based abilities (like Rough Skin)
-- **sound**: Affects sound-based interactions
-- **bite**: Triggers bite-specific abilities
-- **punch**: Triggers punch-specific abilities  
-- **reckless**: Increased power but with drawbacks
-- **priority**: Natural priority moves
-- **multiHit**: Hits multiple times
-- **charging**: Requires charging turn
-
-## Dynamic Combinations
-
-### Power vs Risk Tradeoffs
-
-1. **High Power, Self-Debuff**
-```json
-{
-  "name": "Berserker Strike",
-  "power": 130,
-  "effects": [
-    {
-      "type": "damage",
-      "target": "opponent", 
-      "formula": "standard"
-    },
-    {
-      "type": "modifyStats",
-      "target": "self",
-      "stats": { "defense": "greatly_decrease" },
-      "condition": "afterUse"
-    }
-  ]
-}
-```
-
-2. **Accuracy Trade for Power**
-```json
-{
-  "name": "Wild Swing",
-  "power": 100,
-  "accuracy": 70,
-  "effects": [
-    {
-      "type": "damage",
-      "target": "opponent",
-      "formula": "standard"
-    },
-    {
-      "type": "modifyStats", 
-      "target": "self",
-      "stats": { "accuracy": "decrease" },
-      "condition": "afterUse"
-    }
-  ]
-}
-```
-
-3. **Conditional Power Scaling**
-```json
-{
-  "name": "Revenge Strike",
-  "power": 60,
-  "effects": [
-    {
-      "type": "damage",
-      "target": "opponent",
-      "amount": "normal"
-    },
-    {
-      "type": "damage", 
-      "target": "opponent",
-      "amount": "strong",
-      "condition": "ifDamagedThisTurn"
-    }
-  ]
-}
-```
-
-### Extreme Risk-Reward Moves
-
-Powerful moves with dramatic sacrifices create high-stakes decision making:
-
-#### **Self Destruct** - Ultimate sacrifice for massive damage
-```json
-{
-  "name": "Self Destruct",
-  "power": 200,
-  "accuracy": 100,
-  "pp": 1,
-  "priority": 0,
-  "flags": ["explosive", "contact"],
-  "effects": [
-    {
-      "type": "damage",
-      "target": "all",
-      "formula": "standard",
-      "multiplier": 1.5
-    },
-    {
-      "type": "damage",
-      "target": "self",
-      "formula": "fixed",
-      "value": 9999,
-      "condition": "afterUse"
-    }
-  ]
-}
-```
-
-#### **Life Drain Overload** - Heal massively but lose stats permanently
-```json
-{
-  "name": "Life Drain Overload",
-  "power": 0,
-  "accuracy": 100,
-  "pp": 3,
-  "priority": 0,
-  "flags": ["draining"],
-  "effects": [
-    {
-      "type": "heal",
-      "target": "self",
-      "amount": "percentage",
-      "value": 75
-    },
-    {
-      "type": "modifyStats",
-      "target": "self",
-      "stats": { "attack": "greatly_decrease" },
-      "condition": "afterUse"
-    }
-  ]
-}
-```
-
-#### **Berserker's End** - More damage as HP gets lower, but can't heal
-```json
-{
-  "name": "Berserker's End", 
-  "power": 80,
-  "accuracy": 95,
-  "pp": 10,
-  "priority": 0,
-  "flags": ["contact", "reckless"],
-  "effects": [
-    {
-      "type": "damage",
-      "target": "opponent",
-      "amount": "normal"
-    },
-    {
-      "type": "damage",
-      "target": "opponent", 
-      "amount": "strong",
-      "condition": "ifLowHp"
-    },
-    {
-      "type": "mechanicOverride",
-      "target": "self",
-      "mechanic": "healingBlocked",
-      "value": true
-    }
-  ]
-}
-```
-
-#### **Mirror Shatter** - Reflect all damage taken this turn back doubled
-```json
-{
-  "name": "Mirror Shatter",
-  "power": 0,
-  "accuracy": 100,
-  "pp": 5,
-  "priority": 4,
-  "flags": ["priority"],
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "target": "self",
-      "mechanic": "damageReflection",
-      "value": "double",
-      "condition": "thisTurn"
-    },
-    {
-      "type": "modifyStats",
-      "target": "self",
-      "stats": { "defense": "greatly_decrease", "fieldDefense": "greatly_decrease" },
-      "condition": "afterUse"
-    }
-  ]
-}
-```
-
-#### **Temporal Overload** - Act twice next turn, skip following turn
-```json
-{
-  "name": "Temporal Overload",
-  "power": 0,
-  "accuracy": 100,
-  "pp": 2,
-  "priority": 0,
-  "flags": ["temporal"],
-  "effects": [
-    {
-      "type": "mechanicOverride",
-      "target": "self",
-      "mechanic": "extraTurn",
-      "value": true,
-      "condition": "nextTurn"
-    },
-    {
-      "type": "applyStatus",
-      "target": "self",
-      "status": "paralyzed",
-      "chance": 100,
-      "condition": "turnAfterNext"
-    }
-  ]
-}
-```
-
-#### **Blood Pact** - Sacrifice HP to double all damage dealt
-```json
-{
-  "name": "Blood Pact",
-  "power": 0,
-  "accuracy": 100,
-  "pp": 3,
-  "priority": 0,
-  "flags": ["sacrifice"],
-  "effects": [
-    {
-      "type": "damage",
-      "target": "self",
-      "formula": "percentage",
-      "value": 50
-    },
-    {
-      "type": "mechanicOverride",
-      "target": "self",
-      "mechanic": "damageMultiplier",
-      "value": 2.0,
-      "condition": "restOfBattle"
-    }
-  ]
-}
-```
-
-#### **Soul Burn** - Massive special attack that burns user's PP
-```json
-{
-  "name": "Soul Burn",
-  "power": 150,
-  "accuracy": 90,
-  "pp": 5,
-  "priority": 0,
-  "flags": ["burning"],
-  "effects": [
-    {
-      "type": "damage",
-      "target": "opponent",
-      "formula": "standard"
-    },
-    {
-      "type": "manipulatePP",
-      "target": "self",
-      "action": "drain",
-      "amount": 3,
-      "targetMove": "random",
-      "condition": "afterUse"
-    }
-  ]
-}
-```
-
-#### **Cursed Gambit** - Random effect: heal fully OR faint instantly
-```json
-{
-  "name": "Cursed Gambit",
-  "power": 0,
-  "accuracy": 100,
-  "pp": 1,
-  "priority": 0,
-  "flags": ["gambling", "cursed"],
-  "effects": [
-    {
-      "type": "heal",
-      "target": "self",
-      "amount": "percentage", 
-      "value": 100,
-      "condition": "ifLucky50"
-    },
-    {
-      "type": "damage",
-      "target": "self",
-      "formula": "fixed",
-      "value": 9999,
-      "condition": "ifUnlucky50"
-    }
-  ]
-}
-```
-
-#### **Apocalypse Strike** - Massive damage to all, but user becomes vulnerable
-```json
-{
-  "name": "Apocalypse Strike",
-  "power": 120,
-  "accuracy": 85,
-  "pp": 1,
-  "priority": 0,
-  "flags": ["apocalyptic"],
-  "effects": [
-    {
-      "type": "damage",
-      "target": "all",
-      "formula": "standard",
-      "multiplier": 1.3
-    },
-    {
-      "type": "mechanicOverride",
-      "target": "self",
-      "mechanic": "criticalHits",
-      "value": "alwaysReceive",
-      "condition": "restOfBattle"
-    },
-    {
-      "type": "modifyStats",
-      "target": "self",
-      "stats": { "defense": "greatly_decrease", "fieldDefense": "greatly_decrease" }
-    }
-  ]
-}
-```
-
-### Multi-Stage Effects
-
-Complex moves can have multiple phases:
-
-```json
-{
-  "name": "Charging Blast",
-  "power": 120,
-  "accuracy": 90,
-  "pp": 5,
-  "flags": ["charging"],
-  "effects": [
-    {
-      "type": "modifyStats",
-      "target": "self",
-      "stats": { "defense": "increase" },
-      "condition": "onCharging"
-    },
-    {
-      "type": "damage",
-      "target": "opponent", 
-      "formula": "standard",
-      "condition": "afterCharging"
-    },
-    {
-      "type": "applyStatus",
-      "target": "self",
-      "status": "vulnerable",
-      "condition": "afterCharging"
-    }
-  ]
-}
-```
-
-## Implementation Benefits
-
-### 1. **Programmatic Execution**
-- All effects are defined as data structures
-- Battle engine can execute any combination of effects
-- No hardcoded move implementations needed
-
-### 2. **Infinite Variety**
-- Mix and match building blocks for unique moves
-- Same building blocks create vastly different strategies
-- Easy to balance by adjusting values
-
-### 3. **Clear Tradeoffs** 
-- Every powerful effect has a drawback
-- Players must weigh risk vs reward
-- Multiple viable strategies emerge
-
-### 4. **Emergent Complexity**
-- Simple rules create complex interactions
-- Abilities interact with moves in unexpected ways
-- Meta-game develops naturally
-
-### 5. **Easy Extension**
-- New effect types can be added seamlessly
-- New conditions and triggers expand possibilities
-- Backward compatible with existing definitions
-
-## Battle Flow Integration
-
-The battle system processes effects in this order:
-
-1. **Pre-Move Phase**: Priority calculation, ability triggers
-2. **Move Execution**: Damage calculation, hit/miss determination  
-3. **Effect Application**: Apply all move effects based on conditions
-4. **Post-Move Phase**: End-of-turn abilities, status effects
-5. **Turn Cleanup**: Duration decrements, expired effect removal
-
-This ensures predictable interaction resolution while allowing for complex chains of effects.
-
-## Balancing Philosophy
-
-The system encourages diverse strategies through:
-
-- **No "strictly better" moves**: Every powerful move has meaningful drawbacks
-- **Type diversity matters**: Different types offer different utility patterns
-- **Timing is crucial**: When to use high-risk moves becomes strategic
-- **Adaptation required**: Static strategies are punishable by counter-play
-
-This creates a dynamic battle system where player skill and strategic thinking matter more than raw stat advantages.
-
-## Complete System Reference
-
-### Available Conditions
-- **always**: Effect always applies when triggered
-- **onHit**: Effect applies only if the move hits successfully
-- **afterUse**: Effect applies after move execution regardless of hit/miss
-- **onCritical**: Effect applies only on critical hits
-- **ifLowHp**: Effect applies if user's HP < 25%
-- **ifHighHp**: Effect applies if user's HP > 75%
-- **thisTurn**: Effect lasts only for the current turn
-- **nextTurn**: Effect applies on the next turn
-- **turnAfterNext**: Effect applies two turns from now
-- **restOfBattle**: Effect persists for the remainder of the battle
-- **onCharging**: Effect applies during charging phase of two-turn moves
-- **afterCharging**: Effect applies after charging phase completes
-- **ifDamagedThisTurn**: Effect applies if user took damage this turn
-- **ifNotSuperEffective**: Effect applies if move would not be super effective
-- **ifMoveType:[type]**: Effect applies if move is of specified type
-- **ifStatus:[status]**: Effect applies if user has specified status
-- **whileFrozen**: Effect applies while user is frozen
-- **ifWeather:[weather]**: Effect applies if weather condition is active
-- **ifStatusMove**: Effect applies if move is a status move
-- **ifLucky50**: Effect applies on 50% random chance (good outcome)
-- **ifUnlucky50**: Effect applies on 50% random chance (bad outcome)
-
-### Available Mechanic Overrides
-- **criticalHits**: Modify critical hit behavior
-- **statusImmunity**: Immunity to specific status effects
-- **statusReplacement:[status]**: Replace status effect with different effect
-- **damageReflection**: Reflect damage back to attacker
-- **damageAbsorption**: Absorb damage of specific types
-- **damageCalculation**: Modify damage calculation rules
-- **damageMultiplier**: Multiply all damage dealt
-- **healingInversion**: Healing effects cause damage instead
-- **healingBlocked**: Prevent all healing
-- **priorityOverride**: Override move priority
-- **accuracyBypass**: Moves cannot miss
-- **typeImmunity**: Immunity to specific damage types
-- **typeChange**: Change Piclet's type
-- **contactDamage**: Deal damage to contact move users
-- **drainInversion**: HP drain heals target instead
-- **weatherImmunity**: Immunity to weather effects
-- **flagImmunity**: Immunity to moves with specific flags
-- **flagWeakness**: Extra damage from moves with specific flags
-- **flagResistance**: Reduced damage from moves with specific flags
-- **statModification**: Modify how stat changes work
-- **targetRedirection**: Change move targets
-- **extraTurn**: Grant additional turns
-
-### Available Event Triggers
-- **onDamageTaken**: When this Piclet takes damage
-- **onDamageDealt**: When this Piclet deals damage
-- **onContactDamage**: When hit by a contact move
-- **onStatusInflicted**: When a status is applied to this Piclet
-- **onStatusMove**: When targeted by a status move
-- **onStatusMoveTargeted**: When targeted by opponent's status move
-- **onCriticalHit**: When this Piclet lands/receives a critical hit
-- **onHPDrained**: When HP is drained from this Piclet
-- **onKO**: When this Piclet knocks out an opponent
-- **onSwitchIn**: When this Piclet enters battle
-- **onSwitchOut**: When this Piclet leaves battle
-- **onWeatherChange**: When battlefield weather changes
-- **beforeMoveUse**: Just before this Piclet uses a move
-- **afterMoveUse**: Just after this Piclet uses a move
-- **onLowHP**: When HP drops below 25%
-- **onFullHP**: When HP is at 100%
-- **endOfTurn**: At the end of each turn
-- **onOpponentContactMove**: When opponent uses contact move
-
-### Available Status Effects
-- **burn**: Ongoing fire damage
-- **freeze**: Cannot act (unless replaced by ability)
-- **paralyze**: Speed reduction and chance to be unable to move
-- **poison**: Ongoing poison damage
-- **sleep**: Cannot act for several turns
-- **confuse**: Chance to hit self instead of target
-
-### Available Move Flags
-- **contact**: Makes physical contact
-- **bite**: Biting attack
-- **punch**: Punching attack
-- **sound**: Sound-based attack
-- **explosive**: Explosive attack
-- **draining**: Drains HP from target
-- **ground**: Ground-based attack
-- **priority**: Has natural priority
-- **lowPriority**: Has negative priority
-- **charging**: Requires charging turn
-- **recharge**: User must recharge after
-- **multiHit**: Hits multiple times
-- **twoTurn**: Takes two turns to execute
-- **sacrifice**: Involves self-sacrifice
-- **gambling**: Has random outcomes
-- **reckless**: High power with drawbacks
-- **reflectable**: Can be reflected
-- **snatchable**: Can be stolen
-- **copyable**: Can be copied
-- **protectable**: Blocked by Protect
-- **bypassProtect**: Ignores Protect
-
-### Available Types
-
-Types correspond to photographed objects in the real world:
-
-- **beast** 🐾: Vertebrate wildlife — mammals, birds, reptiles. Raw physicality, instincts, and region-based variants
-- **bug** 🐛: Arthropods great and small: butterflies, beetles, mantises. Agile swarms, precision strikes, metamorphosis
-- **aquatic** 🌊: Life that swims, dives, sloshes: fish, octopus, ink-creatures, sentient puddles. Masters of tides and pressure
-- **flora** 🌿: Plants and fungi captured in bloom or decay. Growth, spores, vines, seasonal shifts
-- **mineral** 🪨: Stones, crystals, metals shaped by earth's depths. High durability, reflective armor, seismic shocks
-- **space** ✨: Stars, moon, cosmic objects not of this world. Stellar energy, gravitational effects, void manipulation
-- **machina** ⚙️: Engineered devices from gadgets to heavy machinery. Gears, circuits, drones, power surges
-- **structure** 🏛️: Buildings, bridges, monuments, ruins as titans. Fortification, terrain shaping, zone denial
-- **culture** 🎨: Art, fashion, toys, written symbols. Buffs, debuffs, illusion, story-driven interactions
-- **cuisine** 🍣: Dishes, drinks, culinary artistry. Flavors, aromas, temperature shifts for support or offense
-- **normal** 👤: Attack type only (no Piclets are Normal type). Represents mundane, non-specialized attacks
-
-### Type Effectiveness Chart
-
-| ATK \ DEF         | 🐾 Beast | 🐛 Bug  | 🌊 Aquatic | 🌿 Flora | 🪨 Mineral | ✨Space   | ⚙️ Machina | 🏛️ Structure   | 🎨 Culture | 🍣 Cuisine |
-| ----------------- | :------: | :----: | :--------: | :------: | :--------: | :------: | :--------: | :-----------: | :--------: | :--------: |
-| **🐾 Beast**      |     1    | **×2** |      1     |     1    |     ×½     |   **0**  |     ×½     |       ×½      |   **×2**   |   **×2**   |
-| **🐛 Bug**        |  **×2**  |    1   |      1     |  **×2**  |     ×½     |    ×½    |      1     |     **0**     |     ×½     |     ×½     |
-| **🌊 Aquatic**    |     1    |    1   |      1     |    ×½    |   **×2**   |  **×2**  |   **×2**   |       1       |     ×½     |     ×½     |
-| **🌿 Flora**      |     1    | **×2** |   **×2**   |     1    |   **×2**   |    ×½    |    **0**   |     **×2**    |      1     |     ×½     |
-| **🪨 Mineral**    |  **×2**  | **×2** |     ×½     |    ×½    |      1     |    ×½    |   **×2**   |       1       |      1     |    **0**   |
-| **✨ Space**  |   **0**  | **×2** |     ×½     |  **×2**  |   **×2**   |     1    |     ×½     |     **×2**    |     ×½     |     ×½     |
-| **⚙️ Machina**    |  **×2**  |   ×½   |     ×½     |  **×2**  |     ×½     |    ×½    |      1     |     **×2**    |      1     |      1     |
-| **🏛️ Structure**  |    ×½    |   ×½   |      1     |     1    |      1     |    ×½    |   **×2**   |       1       |   **×2**   |   **×2**   |
-| **🎨 Culture**    |    ×½    |   ×½   |      1     |     1    |    **0**   |  **×2**  |   **×2**   |     **×2**    |      1     |     ×½     |
-| **🍣 Cuisine**    |  **×2**  |   ×½   |     ×½     |     1    |    **0**   |  **×2**  |      1     |       ×½      |   **×2**   |      1     |
-| **👤 Normal**    |     1    |    1   |      1     |     1    |      1     |     0    |      1     |        1      |      1     |      1     |
-
-**Legend:**
-- **×2** = Super effective (2x damage)
-- **×½** = Not very effective (0.5x damage)  
-- **0** = No effect (0x damage)
-- **1** = Normal effectiveness (1x damage)
-
-## JSON Schema
-
-```json
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "title": "Piclet Definition",
-  "required": ["name", "description", "tier", "primaryType", "baseStats", "nature", "specialAbility", "movepool"],
-  "properties": {
-    "name": {
-      "type": "string",
-      "description": "The name of the Piclet"
-    },
-    "description": {
-      "type": "string", 
-      "description": "Flavor text describing the Piclet"
-    },
-    "tier": {
-      "type": "string",
-      "enum": ["low", "medium", "high", "legendary"],
-      "description": "Power tier of the Piclet"
-    },
-    "primaryType": {
-      "type": "string",
-      "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine"],
-      "description": "Primary type of the Piclet"
-    },
-    "secondaryType": {
-      "type": ["string", "null"],
-      "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine", null],
-      "description": "Optional secondary type"
-    },
-    "baseStats": {
-      "type": "object",
-      "required": ["hp", "attack", "defense", "speed"],
-      "properties": {
-        "hp": {"type": "integer", "minimum": 1, "maximum": 255},
-        "attack": {"type": "integer", "minimum": 1, "maximum": 255},
-        "defense": {"type": "integer", "minimum": 1, "maximum": 255},
-        "speed": {"type": "integer", "minimum": 1, "maximum": 255}
-      },
-      "additionalProperties": false
-    },
-    "nature": {
-      "type": "string",
-      "description": "Personality trait affecting stats or behavior"
-    },
-    "specialAbility": {
-      "$ref": "#/definitions/SpecialAbility"
-    },
-    "movepool": {
-      "type": "array",
-      "items": {"$ref": "#/definitions/Move"},
-      "minItems": 1,
-      "maxItems": 8
-    }
-  },
-  "additionalProperties": false,
-  "definitions": {
-    "SpecialAbility": {
-      "type": "object",
-      "required": ["name", "description"],
-      "properties": {
-        "name": {"type": "string"},
-        "description": {"type": "string"},
-        "effects": {
-          "type": "array",
-          "items": {"$ref": "#/definitions/Effect"}
-        },
-        "triggers": {
-          "type": "array", 
-          "items": {"$ref": "#/definitions/Trigger"}
-        }
-      },
-      "additionalProperties": false
-    },
-    "Move": {
-      "type": "object",
-      "required": ["name", "type", "power", "accuracy", "pp", "priority", "flags", "effects"],
-      "properties": {
-        "name": {"type": "string"},
-        "type": {
-          "type": "string",
-          "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine", "normal"]
-        },
-        "power": {"type": "integer", "minimum": 0, "maximum": 250},
-        "accuracy": {"type": "integer", "minimum": 0, "maximum": 100},
-        "pp": {"type": "integer", "minimum": 1, "maximum": 50},
-        "priority": {"type": "integer", "minimum": -5, "maximum": 5},
-        "flags": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "enum": ["contact", "bite", "punch", "sound", "explosive", "draining", "ground", "priority", "lowPriority", "charging", "recharge", "multiHit", "twoTurn", "sacrifice", "gambling", "reckless", "reflectable", "snatchable", "copyable", "protectable", "bypassProtect"]
-          },
-          "uniqueItems": true
-        },
-        "effects": {
-          "type": "array",
-          "items": {"$ref": "#/definitions/Effect"},
-          "minItems": 1
-        }
-      },
-      "additionalProperties": false
-    },
-    "Effect": {
-      "type": "object",
-      "required": ["type"],
-      "properties": {
-        "type": {
-          "type": "string",
-          "enum": ["damage", "modifyStats", "applyStatus", "heal", "manipulatePP", "fieldEffect", "counter", "priority", "removeStatus", "mechanicOverride"]
-        },
-        "target": {
-          "type": "string",
-          "enum": ["self", "opponent", "allies", "all", "attacker", "field", "playerSide", "opponentSide"]
-        },
-        "condition": {
-          "type": "string",
-          "enum": ["always", "onHit", "afterUse", "onCritical", "ifLowHp", "ifHighHp", "thisTurn", "nextTurn", "turnAfterNext", "restOfBattle", "onCharging", "afterCharging", "ifDamagedThisTurn", "ifNotSuperEffective", "ifStatusMove", "ifLucky50", "ifUnlucky50", "whileFrozen"]
-        }
-      },
-      "allOf": [
-        {
-          "if": {"properties": {"type": {"const": "damage"}}},
-          "then": {
-            "required": ["amount"],
-            "properties": {
-              "amount": {
-                "type": "string",
-                "enum": ["weak", "normal", "strong", "extreme"]
-              }
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "modifyStats"}}},
-          "then": {
-            "required": ["stats"],
-            "properties": {
-              "stats": {
-                "type": "object",
-                "properties": {
-                  "hp": {"type": "string", "enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]},
-                  "attack": {"type": "string", "enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]},
-                  "defense": {"type": "string", "enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]},
-                  "speed": {"type": "string", "enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]},
-                  "accuracy": {"type": "string", "enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}
-                },
-                "additionalProperties": false,
-                "minProperties": 1
-              }
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "applyStatus"}}},
-          "then": {
-            "required": ["status"],
-            "properties": {
-              "status": {
-                "type": "string",
-                "enum": ["burn", "freeze", "paralyze", "poison", "sleep", "confuse"]
-              }
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "heal"}}},
-          "then": {
-            "required": ["amount"],
-            "properties": {
-              "amount": {"type": "string", "enum": ["small", "medium", "large", "full"]}
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "manipulatePP"}}},
-          "then": {
-            "required": ["action", "amount"],
-            "properties": {
-              "action": {"type": "string", "enum": ["drain", "restore", "disable"]},
-              "amount": {"type": "string", "enum": ["small", "medium", "large"]}
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "fieldEffect"}}},
-          "then": {
-            "required": ["effect"],
-            "properties": {
-              "effect": {"type": "string"},
-              "stackable": {"type": "boolean"}
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "counter"}}},
-          "then": {
-            "required": ["strength"],
-            "properties": {
-              "strength": {"type": "string", "enum": ["weak", "normal", "strong"]}
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "priority"}}},
-          "then": {
-            "required": ["value"],
-            "properties": {
-              "value": {"type": "integer", "minimum": -5, "maximum": 5}
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "removeStatus"}}},
-          "then": {
-            "required": ["status"],
-            "properties": {
-              "status": {
-                "type": "string",
-                "enum": ["burn", "freeze", "paralyze", "poison", "sleep", "confuse"]
-              }
-            }
-          }
-        },
-        {
-          "if": {"properties": {"type": {"const": "mechanicOverride"}}},
-          "then": {
-            "required": ["mechanic", "value"],
-            "properties": {
-              "mechanic": {
-                "type": "string",
-                "enum": ["criticalHits", "statusImmunity", "damageReflection", "damageAbsorption", "damageCalculation", "damageMultiplier", "healingInversion", "healingBlocked", "priorityOverride", "accuracyBypass", "typeImmunity", "typeChange", "contactDamage", "drainInversion", "weatherImmunity", "flagImmunity", "flagWeakness", "flagResistance", "statModification", "targetRedirection", "extraTurn"]
-              },
-              "value": {}
-            }
-          }
-        }
-      ],
-      "additionalProperties": false
-    },
-    "Trigger": {
-      "type": "object",
-      "required": ["event", "effects"],
-      "properties": {
-        "event": {
-          "type": "string",
-          "enum": ["onDamageTaken", "onDamageDealt", "onContactDamage", "onStatusInflicted", "onStatusMove", "onStatusMoveTargeted", "onCriticalHit", "onHPDrained", "onKO", "onSwitchIn", "onSwitchOut", "onWeatherChange", "beforeMoveUse", "afterMoveUse", "onLowHP", "onFullHP", "endOfTurn", "onOpponentContactMove"]
-        },
-        "condition": {
-          "type": "string",
-          "enum": ["always", "onHit", "afterUse", "onCritical", "ifLowHp", "ifHighHp", "thisTurn", "nextTurn", "turnAfterNext", "restOfBattle", "onCharging", "afterCharging", "ifDamagedThisTurn", "ifNotSuperEffective", "ifStatusMove", "ifLucky50", "ifUnlucky50", "whileFrozen"]
-        },
-        "effects": {
-          "type": "array",
-          "items": {"$ref": "#/definitions/Effect"},
-          "minItems": 1
-        }
-      },
-      "additionalProperties": false
-    }
-  }
-}
-```
-
-## Complete Example: Tempest Wraith
-
-Here's a full example of a Piclet using the complete schema with advanced abilities and dramatic moves:
-
-```json
-{
-  "name": "Tempest Wraith",
-  "description": "A ghostly creature born from violent storms, wielding cosmic energy and shadowy illusions",
-  "tier": "high",
-  "primaryType": "space",
-  "secondaryType": "culture",
-  "baseStats": {
-    "hp": 75,
-    "attack": 95,
-    "defense": 45,
-    "speed": 85
-  },
-  "nature": "timid",
-  "specialAbility": {
-    "name": "Storm Caller",
-    "description": "When HP drops below 25%, gains immunity to status effects and +50% speed",
-    "triggers": [
-      {
-        "event": "onLowHP",
-        "effects": [
-          {
-            "type": "mechanicOverride",
-            "mechanic": "statusImmunity",
-            "value": ["burn", "freeze", "paralyze", "poison", "sleep", "confuse"]
-          },
-          {
-            "type": "modifyStats",
-            "target": "self",
-            "stats": { "speed": "greatly_increase" }
-          }
-        ]
-      },
-      {
-        "event": "onSwitchIn",
-        "condition": "ifWeather:storm",
-        "effects": [
-          {
-            "type": "modifyStats",
-            "target": "self",
-            "stats": { "attack": "increase" }
-          }
-        ]
-      }
-    ]
-  },
-  "movepool": [
-    {
-      "name": "Shadow Pulse",
-      "type": "culture",
-      "power": 70,
-      "accuracy": 100,
-      "pp": 15,
-      "priority": 0,
-      "flags": [],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "opponent",
-          "amount": "normal"
-        },
-        {
-          "type": "applyStatus",
-          "target": "opponent",
-          "status": "confuse"
-        }
-      ]
-    },
-    {
-      "name": "Cosmic Strike",
-      "type": "space",
-      "power": 85,
-      "accuracy": 90,
-      "pp": 10,
-      "priority": 0,
-      "flags": [],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "opponent",
-          "amount": "normal"
-        },
-        {
-          "type": "applyStatus",
-          "target": "opponent",
-          "status": "paralyze"
-        }
-      ]
-    },
-    {
-      "name": "Spectral Drain",
-      "type": "culture",
-      "power": 60,
-      "accuracy": 95,
-      "pp": 12,
-      "priority": 0,
-      "flags": ["draining"],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "opponent",
-          "formula": "drain",
-          "value": 0.5
-        },
-        {
-          "type": "heal",
-          "target": "self",
-          "amount": "medium"
-        }
-      ]
-    },
-    {
-      "name": "Void Sacrifice",
-      "type": "space",
-      "power": 130,
-      "accuracy": 85,
-      "pp": 1,
-      "priority": 0,
-      "flags": ["sacrifice", "explosive"],
-      "effects": [
-        {
-          "type": "damage",
-          "target": "all",
-          "formula": "standard",
-          "multiplier": 1.2
-        },
-        {
-          "type": "damage",
-          "target": "self",
-          "formula": "percentage",
-          "value": 75
-        },
-        {
-          "type": "fieldEffect",
-          "effect": "voidStorm",
-          "target": "field",
-          "stackable": false
-        }
-      ]
-    }
-  ]
-}
-```
-
-This example demonstrates:
-
-### **Advanced Special Ability**
-- **Conditional Triggers**: Different effects based on HP and weather
-- **Multiple Mechanics**: Status immunity + stat boosts + weather interactions
-- **Strategic Depth**: Becomes more dangerous when near defeat
-
-### **Diverse Movepool**
-- **Standard Attack**: Shadow Pulse with minor status chance
-- **Type Coverage**: Storm and Shadow moves for different matchups  
-- **Utility Move**: Spectral Drain for sustainability
-- **Ultimate Move**: Storm's Sacrifice - massive AoE damage with severe self-harm
-
-### **Meaningful Tradeoffs**
-- **Spectral Drain**: Healing requires hitting the opponent
-- **Storm's Sacrifice**: Incredible power (130 base + 20% bonus to all) but costs 75% of user's HP
-- **Low defenses**: High speed/special attack but vulnerable to physical moves
-
-### **Emergent Strategy**
-- Use standard moves early while healthy
-- Spectral Drain for sustain in mid-game
-- When low on HP, ability kicks in for immunity and speed boost
-- Storm's Sacrifice as desperate finisher or when opponent is also low
-
-This creates a Piclet that plays differently throughout the battle, rewards risk-taking, and offers multiple viable strategies depending on the situation!

src/lib/battle-engine/BattleEngine.test.ts

@@ -1,364 +0,0 @@
-/**
- * Test suite for the Battle Engine
- * Tests battle flow, damage calculation, effects, and type effectiveness
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import { 
-  STELLAR_WOLF, 
-  TOXIC_CRAWLER, 
-  BERSERKER_BEAST, 
-  AQUA_GUARDIAN,
-  BASIC_TACKLE,
-  FLAME_BURST,
-  HEALING_LIGHT,
-  POWER_UP,
-  BERSERKER_END,
-  TOXIC_STING
-} from './test-data';
-import { BattleAction } from './types';
-
-describe('BattleEngine', () => {
-  let engine: BattleEngine;
-
-  beforeEach(() => {
-    engine = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-  });
-
-  describe('Battle Initialization', () => {
-    it('should initialize battle state correctly', () => {
-      const state = engine.getState();
-      
-      expect(state.turn).toBe(1);
-      expect(state.phase).toBe('selection');
-      expect(state.playerPiclet.definition.name).toBe('Stellar Wolf');
-      expect(state.opponentPiclet.definition.name).toBe('Toxic Crawler');
-      expect(state.winner).toBeUndefined();
-      expect(state.log.length).toBe(0);
-    });
-
-    it('should calculate battle stats correctly', () => {
-      const state = engine.getState();
-      const player = state.playerPiclet;
-      
-      // Level 50 should have base stats (no modifier)
-      expect(player.maxHp).toBe(STELLAR_WOLF.baseStats.hp);
-      expect(player.attack).toBe(STELLAR_WOLF.baseStats.attack);
-      expect(player.defense).toBe(STELLAR_WOLF.baseStats.defense);
-      expect(player.speed).toBe(STELLAR_WOLF.baseStats.speed);
-      expect(player.currentHp).toBe(player.maxHp);
-    });
-
-    it('should initialize moves with correct PP', () => {
-      const state = engine.getState();
-      const playerMoves = state.playerPiclet.moves;
-      
-      expect(playerMoves).toHaveLength(4);
-      expect(playerMoves[0].move.name).toBe('Tackle');
-      expect(playerMoves[0].currentPP).toBe(35);
-      expect(playerMoves[1].move.name).toBe('Flame Burst');
-      expect(playerMoves[1].currentPP).toBe(15);
-    });
-  });
-
-  describe('Basic Battle Flow', () => {
-    it('should execute a basic turn', () => {
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 };
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      engine.executeActions(playerAction, opponentAction);
-      
-      const state = engine.getState();
-      expect(state.turn).toBe(2);
-      expect(state.phase).toBe('selection');
-      expect(state.log.length).toBeGreaterThan(2);
-    });
-
-    it('should consume PP when moves are used', () => {
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 };
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialPP = engine.getState().playerPiclet.moves[0].currentPP;
-      engine.executeActions(playerAction, opponentAction);
-      const finalPP = engine.getState().playerPiclet.moves[0].currentPP;
-      
-      expect(finalPP).toBe(initialPP - 1);
-    });
-
-    it('should handle moves with no PP', () => {
-      // Manually set PP to 0 by getting mutable state
-      const state = engine.getState();
-      engine['state'].playerPiclet.moves[0].currentPP = 0;
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 };
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      engine.executeActions(playerAction, opponentAction);
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('no PP left'))).toBe(true);
-    });
-  });
-
-  describe('Damage Calculation', () => {
-    it('should calculate basic damage correctly', () => {
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 }; // Tackle
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialHp = engine.getState().opponentPiclet.currentHp;
-      engine.executeActions(playerAction, opponentAction);
-      const finalHp = engine.getState().opponentPiclet.currentHp;
-      
-      expect(finalHp).toBeLessThan(initialHp);
-      expect(finalHp).toBeGreaterThan(0); // Should not be a one-hit KO
-    });
-
-    it('should apply type effectiveness correctly', () => {
-      // Create engine with type advantage: Space vs Bug (Space is 2x effective vs Bug)
-      const spaceVsBug = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 }; // Flame Burst (Space type)
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialHp = spaceVsBug.getState().opponentPiclet.currentHp;
-      spaceVsBug.executeActions(playerAction, opponentAction);
-      
-      const log = spaceVsBug.getLog();
-      expect(log.some(msg => msg.includes("It's super effective!"))).toBe(true);
-    });
-
-    it('should apply STAB (Same Type Attack Bonus)', () => {
-      // Stellar Wolf using Flame Burst (Space type move, matches primary type)
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 };
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialHp = engine.getState().opponentPiclet.currentHp;
-      engine.executeActions(playerAction, opponentAction);
-      const finalHp = engine.getState().opponentPiclet.currentHp;
-      
-      // With STAB, damage should be higher than without
-      expect(finalHp).toBeLessThan(initialHp);
-    });
-  });
-
-  describe('Status Effects', () => {
-    it('should apply poison status', () => {
-      const toxicEngine = new BattleEngine(TOXIC_CRAWLER, STELLAR_WOLF);
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 }; // Toxic Sting
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      toxicEngine.executeActions(playerAction, opponentAction);
-      
-      const state = toxicEngine.getState();
-      expect(state.opponentPiclet.statusEffects).toContain('poison');
-    });
-
-    it('should process poison damage at turn end', () => {
-      const toxicEngine = new BattleEngine(TOXIC_CRAWLER, STELLAR_WOLF);
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 }; // Toxic Sting
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      toxicEngine.executeActions(playerAction, opponentAction);
-      
-      const hpAfterPoison = toxicEngine.getState().opponentPiclet.currentHp;
-      
-      // Execute another turn to trigger poison damage
-      toxicEngine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      const hpAfterSecondTurn = toxicEngine.getState().opponentPiclet.currentHp;
-      expect(hpAfterSecondTurn).toBeLessThan(hpAfterPoison);
-      
-      const log = toxicEngine.getLog();
-      expect(log.some(msg => msg.includes('hurt by poison'))).toBe(true);
-    });
-  });
-
-  describe('Stat Modifications', () => {
-    it('should increase attack stat', () => {
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 3 }; // Power Up
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialAttack = engine.getState().playerPiclet.attack;
-      engine.executeActions(playerAction, opponentAction);
-      const finalAttack = engine.getState().playerPiclet.attack;
-      
-      expect(finalAttack).toBeGreaterThan(initialAttack);
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes("attack rose"))).toBe(true);
-    });
-  });
-
-  describe('Healing Effects', () => {
-    it('should heal HP correctly', () => {
-      // Damage the player first by directly modifying the internal state
-      engine['state'].playerPiclet.currentHp = Math.floor(engine['state'].playerPiclet.maxHp * 0.5);
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 2 }; // Healing Light
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const hpBeforeHeal = engine.getState().playerPiclet.currentHp;
-      engine.executeActions(playerAction, opponentAction);
-      const hpAfterHeal = engine.getState().playerPiclet.currentHp;
-      
-      expect(hpAfterHeal).toBeGreaterThan(hpBeforeHeal);
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('recovered') && msg.includes('HP'))).toBe(true);
-    });
-
-    it('should not heal above max HP', () => {
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 2 }; // Healing Light
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      engine.executeActions(playerAction, opponentAction);
-      
-      const state = engine.getState();
-      expect(state.playerPiclet.currentHp).toBeLessThanOrEqual(state.playerPiclet.maxHp);
-    });
-  });
-
-  describe('Conditional Effects', () => {
-    it('should trigger conditional effects when conditions are met', () => {
-      const berserkerEngine = new BattleEngine(BERSERKER_BEAST, STELLAR_WOLF);
-      
-      // Set player to low HP to trigger condition
-      berserkerEngine['state'].playerPiclet.currentHp = Math.floor(berserkerEngine['state'].playerPiclet.maxHp * 0.2);
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 }; // Berserker's End
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialDefense = berserkerEngine.getState().playerPiclet.defense;
-      berserkerEngine.executeActions(playerAction, opponentAction);
-      const finalDefense = berserkerEngine.getState().playerPiclet.defense;
-      
-      // Defense should be greatly decreased due to low HP condition
-      expect(finalDefense).toBeLessThan(initialDefense);
-    });
-
-    it('should not trigger conditional effects when conditions are not met', () => {
-      const berserkerEngine = new BattleEngine(BERSERKER_BEAST, STELLAR_WOLF);
-      // Player at full HP - condition not met
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 }; // Berserker's End
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialDefense = berserkerEngine.getState().playerPiclet.defense;
-      berserkerEngine.executeActions(playerAction, opponentAction);
-      const finalDefense = berserkerEngine.getState().playerPiclet.defense;
-      
-      // Defense should remain unchanged
-      expect(finalDefense).toBe(initialDefense);
-    });
-  });
-
-  describe('Battle End Conditions', () => {
-    it('should end battle when player Piclet faints', () => {
-      // Set player HP to 0 to guarantee fainting
-      engine['state'].playerPiclet.currentHp = 0;
-      
-      // Force battle end check
-      engine['checkBattleEnd']();
-      
-      expect(engine.isGameOver()).toBe(true);
-      expect(engine.getWinner()).toBe('opponent');
-    });
-
-    it('should end battle when opponent Piclet faints', () => {
-      engine['state'].opponentPiclet.currentHp = 1; // Set to very low HP
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 };
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      engine.executeActions(playerAction, opponentAction);
-      
-      expect(engine.isGameOver()).toBe(true);
-      expect(engine.getWinner()).toBe('player');
-    });
-
-    it('should handle draw when both Piclets faint', () => {
-      // Set both HP to 0 to guarantee draw
-      engine['state'].playerPiclet.currentHp = 0;
-      engine['state'].opponentPiclet.currentHp = 0;
-      
-      // Force battle end check
-      engine['checkBattleEnd']();
-      
-      expect(engine.isGameOver()).toBe(true);
-      expect(engine.getWinner()).toBe('draw');
-    });
-  });
-
-  describe('Move Accuracy', () => {
-    it('should handle move misses', () => {
-      // Mock Math.random to force a miss
-      const originalRandom = Math.random;
-      Math.random = () => 0.99; // Force miss for 90% accuracy moves
-      
-      const berserkerEngine = new BattleEngine(BERSERKER_BEAST, STELLAR_WOLF);
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 1 }; // Berserker's End (90% accuracy)
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 };
-      
-      const initialHp = berserkerEngine.getState().opponentPiclet.currentHp;
-      berserkerEngine.executeActions(playerAction, opponentAction);
-      const finalHp = berserkerEngine.getState().opponentPiclet.currentHp;
-      
-      // HP should be unchanged due to miss
-      expect(finalHp).toBe(initialHp);
-      
-      const log = berserkerEngine.getLog();
-      expect(log.some(msg => msg.includes('attack missed'))).toBe(true);
-      
-      // Restore original Math.random
-      Math.random = originalRandom;
-    });
-  });
-
-  describe('Action Priority', () => {
-    it('should execute higher priority moves first', () => {
-      // Create a custom high-priority move for testing
-      const highPriorityMove = {
-        ...BASIC_TACKLE,
-        name: "Quick Attack",
-        priority: 1
-      };
-      
-      const customWolf = {
-        ...STELLAR_WOLF,
-        movepool: [highPriorityMove, BASIC_TACKLE, HEALING_LIGHT, POWER_UP]
-      };
-      
-      const priorityEngine = new BattleEngine(customWolf, TOXIC_CRAWLER);
-      
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 }; // Quick Attack (priority 1)
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 }; // Tackle (priority 0)
-      
-      priorityEngine.executeActions(playerAction, opponentAction);
-      
-      const log = priorityEngine.getLog();
-      const playerMoveIndex = log.findIndex(msg => msg.includes('used Quick Attack'));
-      const opponentMoveIndex = log.findIndex(msg => msg.includes('used Tackle'));
-      
-      expect(playerMoveIndex).toBeLessThan(opponentMoveIndex);
-    });
-
-    it('should use speed for same priority moves', () => {
-      // Both using same priority moves, faster should go first
-      const playerAction: BattleAction = { type: 'move', piclet: 'player', moveIndex: 0 }; // Tackle
-      const opponentAction: BattleAction = { type: 'move', piclet: 'opponent', moveIndex: 0 }; // Tackle
-      
-      engine.executeActions(playerAction, opponentAction);
-      
-      const log = engine.getLog();
-      const stellarWolfIndex = log.findIndex(msg => msg.includes('Stellar Wolf used'));
-      const toxicCrawlerIndex = log.findIndex(msg => msg.includes('Toxic Crawler used'));
-      
-      // Stellar Wolf has higher speed (70 vs 55), so should go first
-      expect(stellarWolfIndex).toBeLessThan(toxicCrawlerIndex);
-    });
-  });
-});

src/lib/battle-engine/BattleEngine.ts

@@ -1,1876 +0,0 @@
-/**
- * Core Battle Engine for Pictuary
- * Implements the battle system as defined in battle_system_design.md
- */
-
-import type { 
-  BattleState, 
-  BattlePiclet, 
-  PicletDefinition, 
-  BattleAction, 
-  MoveAction,
-  SwitchAction,
-  CaptureAction,
-  BattleEffect,
-  DamageAmount,
-  StatModification,
-  HealAmount,
-  StatusEffect,
-  BaseStats,
-  Move,
-  Trigger
-} from './types';
-import { getEffectivenessMultiplier } from '../types/picletTypes';
-import { attemptCapture, getCatchRateForTier, calculateCapturePercentage } from '../services/captureService';
-
-export class BattleEngine {
-  private state: BattleState;
-  private playerRoster: PicletDefinition[];
-  private opponentRoster: PicletDefinition[];
-  private playerRosterStates: Array<{ currentHp: number; maxHp: number; fainted: boolean; moves: Array<{move: Move; currentPP: number}> }>;
-  private opponentRosterStates: Array<{ currentHp: number; maxHp: number; fainted: boolean; moves: Array<{move: Move; currentPP: number}> }>;
-
-  constructor(
-    playerPiclet: PicletDefinition | PicletDefinition[], 
-    opponentPiclet: PicletDefinition | PicletDefinition[], 
-    playerLevel = 50, 
-    opponentLevel = 50
-  ) {
-    // Handle roster setup with internal prefixes for reliable animation targeting
-    this.playerRoster = (Array.isArray(playerPiclet) ? playerPiclet : [playerPiclet])
-      .map(piclet => ({ ...piclet, name: `player-${piclet.name}` }));
-    this.opponentRoster = (Array.isArray(opponentPiclet) ? opponentPiclet : [opponentPiclet])
-      .map(piclet => ({ ...piclet, name: `enemy-${piclet.name}` }));
-    
-    // Initialize roster states
-    this.playerRosterStates = this.initializeRosterStates(this.playerRoster, playerLevel);
-    this.opponentRosterStates = this.initializeRosterStates(this.opponentRoster, opponentLevel);
-    this.state = {
-      turn: 1,
-      phase: 'selection',
-      playerPiclet: this.createBattlePiclet(this.playerRoster[0], playerLevel),
-      opponentPiclet: this.createBattlePiclet(this.opponentRoster[0], opponentLevel),
-      fieldEffects: [],
-      log: [],
-      winner: undefined
-    };
-
-    // Sync initial states to roster for consistency
-    this.syncActivePicketToRoster('player');
-    this.syncActivePicketToRoster('opponent');
-
-  }
-
-  private initializeRosterStates(roster: PicletDefinition[], level: number): Array<{ currentHp: number; maxHp: number; fainted: boolean; moves: Array<{move: Move; currentPP: number}> }> {
-    return roster.map(piclet => {
-      // Use pre-calculated HP from definition (already includes level scaling)
-      const hp = piclet.baseStats.hp;
-      return {
-        currentHp: hp,
-        maxHp: hp,
-        fainted: false,
-        moves: piclet.movepool.slice(0, 4).map(move => ({
-          move,
-          currentPP: move.pp
-        }))
-      };
-    });
-  }
-
-  private createBattlePiclet(definition: PicletDefinition, level: number): BattlePiclet {
-    // Battle engine now uses pre-calculated stats from levelingService
-    // No level scaling needed here - stats already include level and nature effects
-    const hp = definition.baseStats.hp;
-    const attack = definition.baseStats.attack;
-    const defense = definition.baseStats.defense;
-    const speed = definition.baseStats.speed;
-
-    const piclet: BattlePiclet = {
-      definition,
-      currentHp: hp,
-      maxHp: hp,
-      level,
-      attack,
-      defense,
-      speed,
-      accuracy: 100, // Base accuracy
-      statusEffects: [],
-      moves: definition.movepool.slice(0, 4).map(move => ({
-        move,
-        currentPP: move.pp
-      })),
-      statModifiers: {},
-      temporaryEffects: []
-    };
-
-    // Apply special ability effects
-    if (definition.specialAbility?.effects) {
-      for (const effect of definition.specialAbility.effects) {
-        this.applyEffectToPiclet(effect, piclet);
-      }
-    }
-
-    return piclet;
-  }
-
-  public getState(): BattleState {
-    return JSON.parse(JSON.stringify(this.state)); // Deep clone for immutability
-  }
-
-  public isGameOver(): boolean {
-    return this.state.phase === 'ended';
-  }
-
-  public getWinner(): 'player' | 'opponent' | 'draw' | undefined {
-    return this.state.winner;
-  }
-
-  public getCapturePercentage(): number {
-    const targetPiclet = this.state.opponentPiclet;
-    
-    // Get capture parameters
-    const maxHp = targetPiclet.maxHp;
-    const currentHp = targetPiclet.currentHp;
-    const tier = targetPiclet.definition.tier;
-    const baseCatchRate = getCatchRateForTier(tier);
-    
-    // Get status effect for capture bonus
-    let statusEffect: 'sleep' | 'freeze' | 'poison' | 'burn' | 'paralysis' | 'toxic' | null = null;
-    if (targetPiclet.statusEffects.length > 0) {
-      const firstStatus = targetPiclet.statusEffects[0];
-      // Cast to proper type (status effects in battle engine match capture service types)
-      statusEffect = firstStatus as 'sleep' | 'freeze' | 'poison' | 'burn' | 'paralysis' | 'toxic';
-    }
-
-    return calculateCapturePercentage({
-      maxHp,
-      currentHp,
-      baseCatchRate,
-      statusEffect,
-      picletLevel: targetPiclet.level
-    });
-  }
-
-  public executeActions(playerAction: BattleAction, opponentAction: BattleAction): void {
-    if (this.state.phase !== 'selection') {
-      throw new Error('Cannot execute actions - battle is not in selection phase');
-    }
-
-    this.state.phase = 'execution';
-
-    // Determine action order based on priority and speed
-    const actions = this.determineActionOrder(playerAction, opponentAction);
-
-    // Execute actions in order
-    for (const action of actions) {
-      if ((this.state.phase as string) === 'ended') break;  // Check if battle already ended
-      this.executeAction(action);
-      
-      // Check for battle end after each action (important for self-destruct moves)
-      this.checkBattleEnd();
-      if ((this.state.phase as string) === 'ended') break;
-    }
-
-    // End of turn processing
-    if ((this.state.phase as string) !== 'ended') {
-      this.processTurnEnd();
-    }
-
-    // Sync active piclets to roster to preserve state changes
-    if ((this.state.phase as string) !== 'ended') {
-      this.syncActivePicketToRoster('player');
-      this.syncActivePicketToRoster('opponent');
-    }
-
-    // Check for battle end
-    this.checkBattleEnd();
-
-    if ((this.state.phase as string) !== 'ended') {
-      this.state.turn++;
-      this.state.phase = 'selection';
-    }
-  }
-
-  private determineActionOrder(playerAction: BattleAction, opponentAction: BattleAction): Array<BattleAction & { executor: 'player' | 'opponent' }> {
-    const playerPriority = this.getActionPriority(playerAction, this.state.playerPiclet);
-    const opponentPriority = this.getActionPriority(opponentAction, this.state.opponentPiclet);
-
-    const playerSpeed = this.state.playerPiclet.speed;
-    const opponentSpeed = this.state.opponentPiclet.speed;
-
-    // Higher priority goes first, then speed, then random
-    let playerFirst = false;
-    if (playerPriority > opponentPriority) {
-      playerFirst = true;
-    } else if (playerPriority < opponentPriority) {
-      playerFirst = false;
-    } else if (playerSpeed > opponentSpeed) {
-      playerFirst = true;
-    } else if (playerSpeed < opponentSpeed) {
-      playerFirst = false;
-    } else {
-      playerFirst = Math.random() < 0.5; // Speed tie
-    }
-
-    return playerFirst
-      ? [
-          { ...playerAction, executor: 'player' as const },
-          { ...opponentAction, executor: 'opponent' as const }
-        ]
-      : [
-          { ...opponentAction, executor: 'opponent' as const },
-          { ...playerAction, executor: 'player' as const }
-        ];
-  }
-
-  private getActionPriority(action: BattleAction, piclet: BattlePiclet): number {
-    let priority = 0;
-    
-    if (action.type === 'move') {
-      const move = piclet.moves[action.moveIndex]?.move;
-      priority = move?.priority || 0;
-      
-      // Check for conditional priority effects in the move
-      if (move?.effects) {
-        for (const effect of move.effects) {
-          if (effect.type === 'priority' && (!effect.condition || this.checkCondition(effect.condition, piclet, piclet))) {
-            priority += (effect as any).value || 0;
-          }
-        }
-      }
-      
-      // Add priority modifier from effects
-      const priorityMod = piclet.statModifiers.priority || 0;
-      priority += priorityMod;
-    } else {
-      priority = 6; // Switch actions have highest priority
-    }
-    
-    return priority;
-  }
-
-  private executeAction(action: BattleAction & { executor: 'player' | 'opponent' }): void {
-    if (action.type === 'move') {
-      this.executeMove(action);
-    } else if (action.type === 'switch') {
-      this.executeSwitch(action as SwitchAction & { executor: 'player' | 'opponent' });
-    } else if (action.type === 'capture') {
-      this.executeCapture(action as CaptureAction & { executor: 'player' | 'opponent' });
-    }
-  }
-
-  private executeMove(action: MoveAction & { executor: 'player' | 'opponent' }): void {
-    console.log('🚀 executeMove started:', {
-      executor: action.executor,
-      moveIndex: action.moveIndex
-    });
-    
-    const attacker = action.executor === 'player' ? this.state.playerPiclet : this.state.opponentPiclet;
-    const defender = action.executor === 'player' ? this.state.opponentPiclet : this.state.playerPiclet;
-    
-    console.log('👥 Attacker/Defender:', {
-      attacker: attacker.definition.name,
-      defender: defender.definition.name
-    });
-    
-    // Check if attacker can act due to status effects
-    if (!this.canPicletAct(attacker)) {
-      console.log('❌ Attacker cannot act due to status effects');
-      return; // Skip this action
-    }
-
-    const moveData = attacker.moves[action.moveIndex];
-    if (!moveData || moveData.currentPP <= 0) {
-      console.log('❌ No move data or no PP:', { moveData: !!moveData, pp: moveData?.currentPP });
-      this.log(`${attacker.definition.name} has no PP left for that move!`);
-      return;
-    }
-
-    const move = moveData.move;
-    console.log('✅ Move to execute:', {
-      name: move.name,
-      type: move.type,
-      power: move.power,
-      effects: move.effects?.length || 0
-    });
-    
-    // Trigger before move use
-    this.triggerBeforeMoveUse(attacker, move);
-    
-    this.log(`${attacker.definition.name} used ${move.name}!`);
-
-    // Consume PP
-    moveData.currentPP--;
-
-    // Check if move hits
-    const moveHit = this.checkMoveHits(move, attacker, defender);
-    if (!moveHit) {
-      this.log(`${attacker.definition.name}'s attack missed!`);
-      this.triggerAfterMoveUse(attacker, move, false);
-      return;
-    }
-
-    // Trigger opponent contact move (if applicable)
-    this.triggerOnOpponentContactMove(defender, attacker, move);
-
-    // For gambling/luck-based moves, roll once and store the result
-    const luckyRoll = Math.random() < 0.5;
-    
-    // Process effects
-    console.log('🔄 Processing effects:', move.effects.length);
-    for (let i = 0; i < move.effects.length; i++) {
-      const effect = move.effects[i];
-      console.log(`🎭 Processing effect ${i + 1}/${move.effects.length}:`, {
-        type: effect.type,
-        effect: effect
-      });
-      try {
-        this.processEffect(effect, attacker, defender, move, luckyRoll);
-        console.log(`✅ Effect ${i + 1} completed successfully`);
-      } catch (error) {
-        console.error(`❌ Effect ${i + 1} failed:`, error);
-        throw error; // Re-throw to maintain error behavior
-      }
-    }
-    
-    // Trigger after move use
-    this.triggerAfterMoveUse(attacker, move, true);
-  }
-
-  private executeSwitch(action: SwitchAction & { executor: 'player' | 'opponent' }): void {
-    const isPlayer = action.executor === 'player';
-    const roster = isPlayer ? this.playerRoster : this.opponentRoster;
-    const rosterStates = isPlayer ? this.playerRosterStates : this.opponentRosterStates;
-    const currentPiclet = isPlayer ? this.state.playerPiclet : this.state.opponentPiclet;
-    
-    // Validate switch action
-    if (action.newPicletIndex < 0 || action.newPicletIndex >= roster.length) {
-      this.log(`${action.executor} cannot switch - invalid piclet index!`);
-      return;
-    }
-    
-    if (action.newPicletIndex === this.getCurrentPicletIndex(action.executor)) {
-      this.log(`${roster[action.newPicletIndex].name} is already active!`);
-      return;
-    }
-    
-    if (rosterStates[action.newPicletIndex].fainted) {
-      this.log(`${roster[action.newPicletIndex].name} is unable to battle!`);
-      return;
-    }
-    
-    const oldPiclet = currentPiclet;
-    const newPicletDef = roster[action.newPicletIndex];
-    
-    // Trigger switch-out ability
-    this.triggerOnSwitchOut(oldPiclet);
-    
-    // Save current piclet state back to roster
-    this.savePicletToRoster(oldPiclet, action.executor);
-    
-    // Load new piclet from roster
-    const newPiclet = this.loadPicletFromRoster(action.newPicletIndex, action.executor);
-    
-    // Update battle state
-    if (isPlayer) {
-      this.state.playerPiclet = newPiclet;
-    } else {
-      this.state.opponentPiclet = newPiclet;
-    }
-    
-    this.log(`${action.executor} switched to ${newPicletDef.name}!`);
-    
-    // Apply entry hazards
-    this.applyEntryHazards(newPiclet);
-    
-    // Trigger switch-in ability
-    this.triggerOnSwitchIn(newPiclet);
-  }
-
-  private executeCapture(action: CaptureAction & { executor: 'player' | 'opponent' }): void {
-    // Only player can capture (wild battles only)
-    if (action.executor !== 'player') {
-      this.log('Only the player can capture Piclets!');
-      return;
-    }
-
-    // Can't capture in trainer battles (this would be determined by battle context)
-    // For now, we'll assume this is a wild battle
-
-    const targetPiclet = this.state.opponentPiclet;
-    
-    // Get capture parameters
-    const maxHp = targetPiclet.maxHp;
-    const currentHp = targetPiclet.currentHp;
-    const tier = targetPiclet.definition.tier;
-    const baseCatchRate = getCatchRateForTier(tier);
-    
-    // Get status effect for capture bonus
-    let statusEffect: 'sleep' | 'freeze' | 'poison' | 'burn' | 'paralysis' | 'toxic' | null = null;
-    if (targetPiclet.statusEffects.length > 0) {
-      // Use the first status effect (most Pokemon games only allow one)
-      const firstStatus = targetPiclet.statusEffects[0];
-      // Cast to proper type (status effects in battle engine match capture service types)
-      statusEffect = firstStatus as 'sleep' | 'freeze' | 'poison' | 'burn' | 'paralysis' | 'toxic';
-    }
-
-    // Calculate capture percentage for display
-    const capturePercentage = calculateCapturePercentage({
-      maxHp,
-      currentHp,
-      baseCatchRate,
-      statusEffect,
-      picletLevel: targetPiclet.level
-    });
-
-    // Attempt the capture
-    const result = attemptCapture({
-      maxHp,
-      currentHp,
-      baseCatchRate,
-      statusEffect,
-      picletLevel: targetPiclet.level
-    });
-
-    // Store capture result in battle state
-    this.state.captureResult = {
-      success: result.success,
-      shakes: result.shakes,
-      odds: result.odds,
-      capturePercentage
-    };
-
-    // Log the attempt
-    this.log(`Player took a Pic-ture of ${targetPiclet.definition.name}!`);
-    
-    // Log shakes
-    if (result.shakes === 0) {
-      this.log('The Pic-ture broke immediately!');
-    } else {
-      const shakeText = result.shakes === 1 ? 'once' : result.shakes === 2 ? 'twice' : 'three times';
-      this.log(`The Pic-ture shook ${shakeText}...`);
-    }
-
-    if (result.success) {
-      this.log(`${targetPiclet.definition.name} was captured!`);
-      // Set winner to player (capture ends the battle)
-      this.state.winner = 'player';
-      this.state.phase = 'ended';
-    } else {
-      this.log(`${targetPiclet.definition.name} broke free!`);
-      // Capture failed, battle continues
-      // The opponent gets a turn after a failed capture attempt
-    }
-
-    console.log('📸 Capture attempt:', {
-      target: targetPiclet.definition.name,
-      hp: `${currentHp}/${maxHp}`,
-      status: statusEffect,
-      catchRate: baseCatchRate,
-      percentage: capturePercentage.toFixed(1) + '%',
-      result: result.success ? 'SUCCESS' : 'FAILED',
-      shakes: result.shakes
-    });
-  }
-
-  private getCurrentPicletIndex(executor: 'player' | 'opponent'): number {
-    const isPlayer = executor === 'player';
-    const roster = isPlayer ? this.playerRoster : this.opponentRoster;
-    const currentPiclet = isPlayer ? this.state.playerPiclet : this.state.opponentPiclet;
-    
-    return roster.findIndex(piclet => piclet.name === currentPiclet.definition.name);
-  }
-
-  private savePicletToRoster(piclet: BattlePiclet, executor: 'player' | 'opponent'): void {
-    const isPlayer = executor === 'player';
-    const rosterStates = isPlayer ? this.playerRosterStates : this.opponentRosterStates;
-    const currentIndex = this.getCurrentPicletIndex(executor);
-    
-    if (currentIndex !== -1) {
-      // Save current state back to roster
-      rosterStates[currentIndex].currentHp = piclet.currentHp;
-      rosterStates[currentIndex].fainted = piclet.currentHp <= 0;
-      
-      // Save current PP state
-      for (let i = 0; i < piclet.moves.length; i++) {
-        if (rosterStates[currentIndex].moves[i]) {
-          rosterStates[currentIndex].moves[i].currentPP = piclet.moves[i].currentPP;
-        }
-      }
-    }
-  }
-
-  private syncActivePicketToRoster(executor: 'player' | 'opponent'): void {
-    const piclet = executor === 'player' ? this.state.playerPiclet : this.state.opponentPiclet;
-    this.savePicletToRoster(piclet, executor);
-  }
-
-  private loadPicletFromRoster(index: number, executor: 'player' | 'opponent'): BattlePiclet {
-    const isPlayer = executor === 'player';
-    const roster = isPlayer ? this.playerRoster : this.opponentRoster;
-    const rosterStates = isPlayer ? this.playerRosterStates : this.opponentRosterStates;
-    const level = isPlayer ? this.state.playerPiclet.level : this.state.opponentPiclet.level;
-    
-    const definition = roster[index];
-    const savedState = rosterStates[index];
-    
-    // Create fresh battle piclet
-    const piclet = this.createBattlePiclet(definition, level);
-    
-    // Restore saved state
-    piclet.currentHp = savedState.currentHp;
-    
-    // Restore PP
-    for (let i = 0; i < piclet.moves.length; i++) {
-      if (savedState.moves[i]) {
-        piclet.moves[i].currentPP = savedState.moves[i].currentPP;
-      }
-    }
-    
-    // Reset stat modifications (switching clears temporary stat changes)
-    piclet.statModifiers = {};
-    
-    return piclet;
-  }
-
-  private triggerOnSwitchIn(piclet: BattlePiclet): void {
-    this.triggerAbilities('onSwitchIn', piclet);
-  }
-
-  private triggerOnSwitchOut(piclet: BattlePiclet): void {
-    this.triggerAbilities('onSwitchOut', piclet);
-  }
-
-  private checkMoveHits(move: Move, _attacker: BattlePiclet, _defender: BattlePiclet): boolean {
-    // Simple accuracy check - can be enhanced later
-    const accuracy = move.accuracy;
-    const roll = Math.random() * 100;
-    return roll < accuracy;
-  }
-
-  private processEffect(effect: BattleEffect, attacker: BattlePiclet, defender: BattlePiclet, move: Move, luckyRoll?: boolean): void {
-    // Check condition (simplified for now)
-    if (effect.condition && !this.checkCondition(effect.condition, attacker, defender, luckyRoll)) {
-      return;
-    }
-
-    switch (effect.type) {
-      case 'damage':
-        console.log('⚔️ Processing damage effect:', {
-          target: effect.target,
-          isAll: effect.target === 'all'
-        });
-        if (effect.target === 'all') {
-          // Self-destruct style moves that damage all targets
-          console.log('💣 All-target damage (self-destruct)');
-          this.processDamageEffect(effect, attacker, attacker, move); // Self-damage
-          this.processDamageEffect(effect, attacker, defender, move); // Opponent damage
-        } else {
-          const damageTarget = this.resolveTarget(effect.target, attacker, defender);
-          console.log('🎯 Single target damage:', {
-            target: effect.target,
-            resolvedTarget: damageTarget?.definition.name || 'null'
-          });
-          if (damageTarget) this.processDamageEffect(effect, attacker, damageTarget, move);
-        }
-        break;
-      case 'modifyStats':
-        const statsTarget = this.resolveTarget(effect.target, attacker, defender);
-        if (statsTarget) this.processModifyStatsEffect(effect, statsTarget);
-        break;
-      case 'applyStatus':
-        const statusTarget = this.resolveTarget(effect.target, attacker, defender);
-        if (statusTarget) this.processApplyStatusEffect(effect, statusTarget);
-        break;
-      case 'heal':
-        const healTarget = this.resolveTarget(effect.target, attacker, defender);
-        if (healTarget) this.processHealEffect(effect, healTarget);
-        break;
-      case 'manipulatePP':
-        const ppTarget = this.resolveTarget(effect.target, attacker, defender);
-        if (ppTarget) this.processManipulatePPEffect(effect, ppTarget);
-        break;
-      case 'fieldEffect':
-        this.processFieldEffect(effect);
-        break;
-      case 'counter':
-        this.processCounterEffect(effect, attacker, defender);
-        break;
-      case 'priority':
-        const priorityTarget = this.resolveTarget(effect.target, attacker, defender);
-        if (priorityTarget) this.processPriorityEffect(effect, priorityTarget);
-        break;
-      case 'removeStatus':
-        const removeStatusTarget = this.resolveTarget(effect.target, attacker, defender);
-        if (removeStatusTarget) this.processRemoveStatusEffect(effect, removeStatusTarget);
-        break;
-      case 'mechanicOverride':
-        // MechanicOverride effects don't have a target - they apply to the user
-        this.processMechanicOverrideEffect(effect, attacker);
-        break;
-      default:
-        this.log(`Effect ${(effect as any).type} not implemented yet`);
-    }
-  }
-
-  private checkCondition(condition: string, attacker: BattlePiclet, _defender: BattlePiclet, luckyRoll?: boolean): boolean {
-    switch (condition) {
-      case 'always':
-        return true;
-      case 'ifLowHp':
-        return attacker.currentHp / attacker.maxHp < 0.25;
-      case 'ifHighHp':
-        return attacker.currentHp / attacker.maxHp > 0.75;
-      case 'ifLucky50':
-        return luckyRoll !== undefined ? luckyRoll : Math.random() < 0.5;
-      case 'ifUnlucky50':
-        return luckyRoll !== undefined ? !luckyRoll : Math.random() >= 0.5;
-      case 'whileFrozen':
-        return attacker.statusEffects.includes('freeze');
-      // Type-specific conditions
-      case 'ifMoveType:flora':
-      case 'ifMoveType:space':
-      case 'ifMoveType:beast':
-      case 'ifMoveType:bug':
-      case 'ifMoveType:aquatic':
-      case 'ifMoveType:mineral':
-      case 'ifMoveType:machina':
-      case 'ifMoveType:structure':
-      case 'ifMoveType:culture':
-      case 'ifMoveType:cuisine':
-      case 'ifMoveType:normal':
-        // Would need move context to check, placeholder for now
-        return true;
-      // Status-specific conditions
-      case 'ifStatus:burn':
-        return attacker.statusEffects.includes('burn');
-      case 'ifStatus:freeze':
-        return attacker.statusEffects.includes('freeze');
-      case 'ifStatus:paralyze':
-        return attacker.statusEffects.includes('paralyze');
-      case 'ifStatus:poison':
-        return attacker.statusEffects.includes('poison');
-      case 'ifStatus:sleep':
-        return attacker.statusEffects.includes('sleep');
-      case 'ifStatus:confuse':
-        return attacker.statusEffects.includes('confuse');
-      // Weather conditions (placeholder)
-      case 'ifWeather:storm':
-      case 'ifWeather:rain':
-      case 'ifWeather:sun':
-      case 'ifWeather:snow':
-        return false; // Weather system not implemented yet
-      // Combat conditions
-      case 'ifDamagedThisTurn':
-        // Check if the attacker was damaged this turn
-        // For now, we'll implement this by checking if currentHp < maxHp
-        // This is a simplified implementation
-        return attacker.currentHp < attacker.maxHp;
-      case 'ifNotSuperEffective':
-        // Would need move context, placeholder
-        return false;
-      case 'ifStatusMove':
-        // Would need move context, placeholder
-        return false;
-      case 'afterUse':
-        // This condition should be processed after the move's other effects
-        return true;
-      default:
-        return true; // Default to true for unimplemented conditions
-    }
-  }
-
-  private resolveTarget(target: string, attacker: BattlePiclet, defender: BattlePiclet): BattlePiclet | null {
-    console.log('🔍 resolveTarget called:', {
-      target,
-      attacker: attacker.definition.name,
-      defender: defender.definition.name
-    });
-    
-    // Default undefined/null targets to 'opponent' for damage effects
-    if (target === undefined || target === null) {
-      console.log('🔧 Undefined target, defaulting to opponent');
-      target = 'opponent';
-    }
-    
-    switch (target) {
-      case 'self':
-        console.log('✅ Resolved to self (attacker)');
-        return attacker;
-      case 'opponent':
-        console.log('✅ Resolved to opponent (defender)');
-        return defender;
-      default:
-        console.log('❌ Unknown target, returning null:', target);
-        return null; // Multi-target not implemented yet
-    }
-  }
-
-  private processDamageEffect(effect: { amount?: DamageAmount; formula?: string; value?: number; multiplier?: number }, attacker: BattlePiclet, target: BattlePiclet, move: Move): void {
-    console.log('💥 processDamageEffect called:', {
-      attacker: attacker.definition.name,
-      target: target.definition.name,
-      move: move.name,
-      effect: {
-        amount: effect.amount,
-        formula: effect.formula,
-        value: effect.value,
-        multiplier: effect.multiplier
-      }
-    });
-    let damage = 0;
-
-    // Check type immunity first
-    if (this.checkTypeImmunity(target, move.type)) {
-      this.log(`${target.definition.name} is immune to ${move.type} type moves!`);
-      return;
-    }
-
-    // Check flag-based type immunity (like ground immunity via levitate)
-    if (this.checkFlagBasedTypeImmunity(target, move.flags)) {
-      this.log(`${target.definition.name} had no effect!`);
-      return;
-    }
-
-    // Check flag interactions
-    const flagInteraction = this.checkFlagInteraction(target, move.flags);
-    if (flagInteraction === 'immune') {
-      this.log(`It had no effect on ${target.definition.name}!`);
-      return;
-    }
-
-    // Handle different damage formulas
-    if (effect.formula) {
-      damage = this.calculateDamageByFormula(effect, attacker, target, move);
-    } else if (effect.amount) {
-      damage = this.calculateStandardDamage(effect.amount, attacker, target, move);
-    }
-
-    // Apply flag interaction modifiers
-    if (flagInteraction === 'weak') {
-      damage = Math.floor(damage * 1.5);
-      this.log("It's super effective!");
-    } else if (flagInteraction === 'resist') {
-      damage = Math.floor(damage * 0.5);
-      this.log("It's not very effective...");
-    }
-
-    // Apply damage multiplier from abilities
-    const damageMultiplier = this.getDamageMultiplier(attacker);
-    damage = Math.floor(damage * damageMultiplier);
-    
-    // Apply field effect damage multipliers
-    const isPlayerAttacking = attacker === this.state.playerPiclet;
-    const fieldEffectMultiplier = this.getFieldEffectDamageMultiplier(move, isPlayerAttacking);
-    damage = Math.floor(damage * fieldEffectMultiplier);
-
-    // Check for critical hits
-    const critMod = this.checkCriticalHitModification(attacker, target);
-    const isCriticalHit = critMod === 'always' || (critMod === 'normal' && Math.random() < 0.0625);
-    if (isCriticalHit) { // 1/16 base crit rate
-      damage = Math.floor(damage * 1.5);
-      this.log("A critical hit!");
-      // Trigger critical hit ability
-      this.triggerOnCriticalHit(attacker, target);
-    }
-
-    // Apply damage
-    if (damage > 0) {
-      target.currentHp = Math.max(0, target.currentHp - damage);
-      this.log(`${target.definition.name} took ${damage} damage!`);
-      
-      // Wake up from sleep when damaged
-      this.wakeUpFromSleep(target);
-      
-      // Trigger ability events
-      this.triggerOnDamageTaken(target, damage, move.flags.includes('contact'));
-      this.triggerOnDamageDealt(attacker, damage, target);
-      this.triggerOnLowHP(target);
-      
-      // Check for counter effects on the target
-      this.checkCounterEffects(target, attacker, move);
-    }
-
-    // Handle special formula effects
-    if (effect.formula === 'drain') {
-      const healAmount = Math.floor(damage * (effect.value || 0.5));
-      attacker.currentHp = Math.min(attacker.maxHp, attacker.currentHp + healAmount);
-      if (healAmount > 0) {
-        this.log(`${attacker.definition.name} recovered ${healAmount} HP from draining!`);
-        this.triggerOnHPDrained(attacker, target, healAmount);
-      }
-    } else if (effect.formula === 'recoil') {
-      const recoilDamage = Math.floor(damage * (effect.value || 0.25));
-      attacker.currentHp = Math.max(0, attacker.currentHp - recoilDamage);
-      if (recoilDamage > 0) {
-        this.log(`${attacker.definition.name} took ${recoilDamage} recoil damage!`);
-      }
-    }
-  }
-
-  private calculateDamageByFormula(effect: { formula?: string; value?: number; multiplier?: number }, attacker: BattlePiclet, target: BattlePiclet, move: Move): number {
-    switch (effect.formula) {
-      case 'fixed':
-        return effect.value || 0;
-      
-      case 'percentage':
-        return Math.floor(target.maxHp * ((effect.value || 0) / 100));
-      
-      case 'recoil':
-      case 'drain':
-      case 'standard':
-        // Use the move's actual power for standard formula
-        return this.calculateStandardDamageWithPower(move.power, attacker, target, move) * (effect.multiplier || 1);
-      
-      default:
-        return 0;
-    }
-  }
-
-  private calculateStandardDamageWithPower(power: number, attacker: BattlePiclet, target: BattlePiclet, move: Move): number {
-    const baseDamage = power;
-    
-    // Debug logging for type effectiveness calculation
-    console.log('🎯 Damage calculation debug:', {
-      move: {
-        name: move.name,
-        type: move.type,
-        power: move.power
-      },
-      attacker: {
-        name: attacker.definition.name,
-        primaryType: attacker.definition.primaryType,
-        secondaryType: attacker.definition.secondaryType
-      },
-      target: {
-        name: target.definition.name,
-        primaryType: target.definition.primaryType,
-        secondaryType: target.definition.secondaryType
-      }
-    });
-    
-    // Type effectiveness
-    const effectiveness = getEffectivenessMultiplier(
-      move.type, 
-      target.definition.primaryType, 
-      target.definition.secondaryType
-    );
-
-    // STAB (Same Type Attack Bonus) - compare enum values as strings
-    const stab = (move.type.toString() === attacker.definition.primaryType?.toString() || 
-                  move.type.toString() === attacker.definition.secondaryType?.toString()) ? 1.5 : 1;
-
-    // Pokemon-style damage calculation for better balance
-    const attackStat = attacker.attack;
-    const defenseStat = target.defense;
-    const level = attacker.level;
-    
-    // Core damage formula: ((2 * Level + 10) / 250) * (Attack / Defense) * Power + 2
-    let damage = Math.floor(
-      ((2 * level + 10) / 250) * (attackStat / defenseStat) * baseDamage + 2
-    );
-    damage = Math.floor(damage * effectiveness * stab);
-    
-    // Random factor (85-100%)
-    damage = Math.floor(damage * (0.85 + Math.random() * 0.15));
-    
-    // Minimum 1 damage for effective moves
-    if (effectiveness > 0 && damage < 1) {
-      damage = 1;
-    }
-
-    // Log effectiveness messages
-    if (effectiveness === 0) {
-      this.log("It had no effect!");
-    } else if (effectiveness > 1) {
-      this.log("It's super effective!");
-    } else if (effectiveness < 1) {
-      this.log("It's not very effective...");
-    }
-
-    return damage;
-  }
-
-  private calculateStandardDamage(amount: DamageAmount, attacker: BattlePiclet, target: BattlePiclet, move: Move): number {
-    const baseDamage = this.getDamageAmount(amount);
-    
-    // Type effectiveness
-    const effectiveness = getEffectivenessMultiplier(
-      move.type, 
-      target.definition.primaryType, 
-      target.definition.secondaryType
-    );
-
-    // STAB (Same Type Attack Bonus) - compare enum values as strings
-    const stab = (move.type.toString() === attacker.definition.primaryType?.toString() || 
-                  move.type.toString() === attacker.definition.secondaryType?.toString()) ? 1.5 : 1;
-
-    // Pokemon-style damage calculation for better balance
-    const attackStat = attacker.attack;
-    const defenseStat = target.defense;
-    const level = attacker.level;
-    
-    // Core damage formula: ((2 * Level + 10) / 250) * (Attack / Defense) * Power + 2
-    let damage = Math.floor(
-      ((2 * level + 10) / 250) * (attackStat / defenseStat) * baseDamage + 2
-    );
-    damage = Math.floor(damage * effectiveness * stab);
-    
-    // Random factor (85-100%)
-    damage = Math.floor(damage * (0.85 + Math.random() * 0.15));
-    
-    // Minimum 1 damage for effective moves
-    if (effectiveness > 0 && damage < 1) {
-      damage = 1;
-    }
-
-    // Log effectiveness messages
-    if (effectiveness === 0) {
-      this.log("It had no effect!");
-    } else if (effectiveness > 1) {
-      this.log("It's super effective!");
-    } else if (effectiveness < 1) {
-      this.log("It's not very effective...");
-    }
-
-    return damage;
-  }
-
-  private processModifyStatsEffect(effect: { stats: Partial<Record<keyof BaseStats | 'accuracy', StatModification>> }, target: BattlePiclet): void {
-    for (const [stat, modification] of Object.entries(effect.stats)) {
-      const multiplier = this.getStatModifier(modification);
-      if (stat === 'accuracy') {
-        target.accuracy = Math.floor(target.accuracy * multiplier);
-      } else {
-        const statKey = stat as keyof BaseStats;
-        (target as any)[statKey] = Math.floor((target as any)[statKey] * multiplier);
-      }
-      
-      const changeType = modification.includes('increase') ? 'increase' : 'decrease';
-      this.log(`${target.definition.name}'s ${stat} ${modification.includes('increase') ? 'rose' : 'fell'}!`);
-      this.triggerOnStatChange(target, stat, changeType);
-    }
-  }
-
-
-  private processHealEffect(effect: { amount?: HealAmount; formula?: string; value?: number }, target: BattlePiclet): void {
-    let healAmount = 0;
-
-    if (effect.formula) {
-      switch (effect.formula) {
-        case 'percentage':
-          healAmount = Math.floor(target.maxHp * ((effect.value || 0) / 100));
-          break;
-        case 'fixed':
-          healAmount = effect.value || 0;
-          break;
-        default:
-          healAmount = this.getHealAmount(effect.amount || 'medium', target.maxHp);
-      }
-    } else if (effect.amount) {
-      healAmount = this.getHealAmount(effect.amount, target.maxHp);
-    }
-
-    // Check for healing inversion mechanic
-    if (this.shouldInvertHealing(target)) {
-      // Healing becomes damage
-      const oldHp = target.currentHp;
-      target.currentHp = Math.max(0, target.currentHp - healAmount);
-      const actualDamage = oldHp - target.currentHp;
-      
-      if (actualDamage > 0) {
-        this.log(`${target.definition.name} took ${actualDamage} damage from inverted healing!`);
-      }
-    } else {
-      // Normal healing
-      const oldHp = target.currentHp;
-      target.currentHp = Math.min(target.maxHp, target.currentHp + healAmount);
-      const actualHeal = target.currentHp - oldHp;
-      
-      if (actualHeal > 0) {
-        this.log(`${target.definition.name} recovered ${actualHeal} HP!`);
-        this.triggerOnFullHP(target);
-      }
-    }
-  }
-
-  private getDamageAmount(amount: DamageAmount): number {
-    switch (amount) {
-      case 'weak': return 40;
-      case 'normal': return 70;
-      case 'strong': return 100;
-      case 'extreme': return 140;
-      default: return 70;
-    }
-  }
-
-  private getStatModifier(modification: StatModification): number {
-    switch (modification) {
-      case 'increase': return 1.25;
-      case 'decrease': return 0.75;
-      case 'greatly_increase': return 1.5;
-      case 'greatly_decrease': return 0.5;
-      default: return 1.0;
-    }
-  }
-
-  private getHealAmount(amount: HealAmount, maxHp: number): number {
-    switch (amount) {
-      case 'small': return Math.floor(maxHp * 0.25);
-      case 'medium': return Math.floor(maxHp * 0.5);
-      case 'large': return Math.floor(maxHp * 0.75);
-      case 'full': return maxHp;
-      default: return Math.floor(maxHp * 0.5);
-    }
-  }
-
-  private processTurnEnd(): void {
-    // Process status effects
-    this.processStatusEffects(this.state.playerPiclet);
-    this.processStatusEffects(this.state.opponentPiclet);
-    
-    // Apply field healing effects
-    this.applyFieldHealingEffects();
-    
-    // Process field effects (duration management)
-    this.processFieldEffects();
-    
-    // Trigger end of turn abilities
-    this.triggerEndOfTurn();
-    
-    // Decrement temporary effects
-    this.processTemporaryEffects(this.state.playerPiclet);
-    this.processTemporaryEffects(this.state.opponentPiclet);
-  }
-
-  private processStatusEffects(piclet: BattlePiclet): void {
-    // Process status effects that trigger at end of turn
-    const statusesToRemove: string[] = [];
-    
-    for (let i = 0; i < piclet.statusEffects.length; i++) {
-      const status = piclet.statusEffects[i];
-      
-      switch (status) {
-        case 'burn':
-        case 'poison':
-          const damage = Math.floor(piclet.maxHp / 8);
-          piclet.currentHp = Math.max(0, piclet.currentHp - damage);
-          this.log(`${piclet.definition.name} was hurt by ${status}!`);
-          break;
-          
-        case 'freeze':
-          // Don't process freeze on the turn it was applied
-          if ((piclet as any).freezeJustApplied) {
-            delete (piclet as any).freezeJustApplied;
-          } else {
-            // 20% chance to thaw out each turn
-            if (Math.random() < 0.2) {
-              statusesToRemove.push(status);
-              this.log(`${piclet.definition.name} thawed out!`);
-            }
-          }
-          break;
-          
-        case 'sleep':
-          // Don't process sleep on the turn it was applied
-          if ((piclet as any).sleepJustApplied) {
-            delete (piclet as any).sleepJustApplied;
-          } else {
-            // Decrement sleep turns and wake up
-            const sleepTurns = (piclet as any).sleepTurns || 0;
-            if (sleepTurns <= 1) {
-              statusesToRemove.push(status);
-              this.log(`${piclet.definition.name} woke up!`);
-              delete (piclet as any).sleepTurns;
-            } else {
-              (piclet as any).sleepTurns = sleepTurns - 1;
-            }
-          }
-          break;
-          
-        case 'confuse':
-          // Decrement confusion turns
-          const confusionTurns = (piclet as any).confusionTurns || 0;
-          if (confusionTurns <= 1) {
-            statusesToRemove.push(status);
-            this.log(`${piclet.definition.name} snapped out of confusion!`);
-            delete (piclet as any).confusionTurns;
-          } else {
-            (piclet as any).confusionTurns = confusionTurns - 1;
-          }
-          break;
-      }
-    }
-    
-    // Remove statuses that expired
-    for (const statusToRemove of statusesToRemove) {
-      const index = piclet.statusEffects.indexOf(statusToRemove as any);
-      if (index > -1) {
-        piclet.statusEffects.splice(index, 1);
-      }
-    }
-  }
-
-  private processTemporaryEffects(piclet: BattlePiclet): void {
-    // Decrement duration of temporary effects
-    piclet.temporaryEffects = piclet.temporaryEffects.filter(effect => {
-      effect.duration--;
-      return effect.duration > 0;
-    });
-  }
-
-  private processFieldEffects(): void {
-    // Field effects are processed at end of turn for duration management
-    // Their actual mechanics are applied during relevant battle phases
-    
-    // Decrement field effect durations and remove expired ones
-    this.state.fieldEffects = this.state.fieldEffects.filter(effect => {
-      effect.duration--;
-      if (effect.duration <= 0) {
-        this.log(`${this.formatFieldEffectName(effect.name)} faded away!`);
-        return false;
-      }
-      return true;
-    });
-  }
-
-  private formatFieldEffectName(effectName: string): string {
-    switch (effectName) {
-      case 'entryHazardSpikes': return 'Entry spikes';
-      case 'contactDamageReduction': return 'Contact damage barrier';
-      case 'nonContactDamageReduction': return 'Non-contact damage barrier';
-      case 'healingField': return 'Healing field';
-      case 'poisonousField': return 'Poisonous field';
-      default: return effectName;
-    }
-  }
-
-  private getFieldEffectDamageMultiplier(move: Move, isPlayerAttacking: boolean): number {
-    let multiplier = 1.0;
-    
-    // Determine if this is a contact move
-    const isContactMove = move.flags.includes('contact');
-    
-    // Check field effects that modify damage
-    for (const fieldEffect of this.state.fieldEffects) {
-      const targetSide = fieldEffect.effect.target;
-      // Field effects protect the side they're applied to from incoming attacks
-      // So if playerSide has a barrier, it protects player from opponent attacks
-      const protectsDefender = (!isPlayerAttacking && targetSide === 'playerSide') ||
-                              (isPlayerAttacking && targetSide === 'opponentSide');
-      
-      if (!protectsDefender) continue;
-      
-      switch (fieldEffect.name) {
-        case 'contactDamageReduction':
-          if (isContactMove) {
-            multiplier *= 0.5; // Reduce contact move damage by 50%
-          }
-          break;
-        case 'nonContactDamageReduction':
-          if (!isContactMove) {
-            multiplier *= 0.5; // Reduce non-contact move damage by 50%
-          }
-          break;
-      }
-    }
-    
-    return multiplier;
-  }
-
-  private applyEntryHazards(piclet: BattlePiclet): void {
-    // Apply entry hazards when a piclet enters battle (switching mechanics)
-    for (const fieldEffect of this.state.fieldEffects) {
-      if (fieldEffect.name === 'spikes' || fieldEffect.name === 'entryHazardSpikes') {
-        const targetSide = fieldEffect.effect.target;
-        const isPlayerSide = piclet === this.state.playerPiclet;
-        const appliesTo = (isPlayerSide && targetSide === 'playerSide') ||
-                         (!isPlayerSide && targetSide === 'opponentSide');
-        
-        if (appliesTo) {
-          const damage = Math.floor(piclet.maxHp * 0.125); // 12.5% max HP damage
-          piclet.currentHp = Math.max(0, piclet.currentHp - damage);
-          this.log(`${piclet.definition.name} was hurt by spikes!`);
-        }
-      } else if (fieldEffect.name === 'toxicSpikes') {
-        const targetSide = fieldEffect.effect.target;
-        const isPlayerSide = piclet === this.state.playerPiclet;
-        const appliesTo = (isPlayerSide && targetSide === 'playerSide') ||
-                         (!isPlayerSide && targetSide === 'opponentSide');
-        
-        if (appliesTo && !piclet.statusEffects.includes('poison')) {
-          piclet.statusEffects.push('poison');
-          this.log(`${piclet.definition.name} was poisoned by toxic spikes!`);
-        }
-      } else if (fieldEffect.name === 'poisonousField') {
-        const targetSide = fieldEffect.effect.target;
-        const isPlayerSide = piclet === this.state.playerPiclet;
-        const appliesTo = (isPlayerSide && targetSide === 'playerSide') ||
-                         (!isPlayerSide && targetSide === 'opponentSide');
-        
-        if (appliesTo && !piclet.statusEffects.includes('poison')) {
-          piclet.statusEffects.push('poison');
-          this.log(`${piclet.definition.name} was poisoned by toxic spikes!`);
-        }
-      }
-    }
-  }
-
-  private applyFieldHealingEffects(): void {
-    // Apply healing field effects at end of turn
-    const healingFields = this.state.fieldEffects.filter(effect => effect.name === 'healingField');
-    
-    for (const healingField of healingFields) {
-      const targetSide = healingField.effect.target;
-      
-      if (targetSide === 'playerSide' || targetSide === 'field') {
-        const healAmount = Math.floor(this.state.playerPiclet.maxHp * 0.0625); // 6.25% max HP
-        if (this.state.playerPiclet.currentHp < this.state.playerPiclet.maxHp) {
-          this.state.playerPiclet.currentHp = Math.min(
-            this.state.playerPiclet.maxHp,
-            this.state.playerPiclet.currentHp + healAmount
-          );
-          this.log(`${this.state.playerPiclet.definition.name} was healed by the healing field!`);
-        }
-      }
-      
-      if (targetSide === 'opponentSide' || targetSide === 'field') {
-        const healAmount = Math.floor(this.state.opponentPiclet.maxHp * 0.0625); // 6.25% max HP
-        if (this.state.opponentPiclet.currentHp < this.state.opponentPiclet.maxHp) {
-          this.state.opponentPiclet.currentHp = Math.min(
-            this.state.opponentPiclet.maxHp,
-            this.state.opponentPiclet.currentHp + healAmount
-          );
-          this.log(`${this.state.opponentPiclet.definition.name} was healed by the healing field!`);
-        }
-      }
-    }
-  }
-
-
-  private checkBattleEnd(): void {
-    const playerFainted = this.state.playerPiclet.currentHp <= 0;
-    const opponentFainted = this.state.opponentPiclet.currentHp <= 0;
-    
-    // Mark fainted piclets in roster states and trigger KO events
-    if (playerFainted) {
-      const playerIndex = this.getCurrentPicletIndex('player');
-      if (playerIndex !== -1) {
-        this.playerRosterStates[playerIndex].fainted = true;
-        this.triggerOnKO(this.state.playerPiclet, this.state.opponentPiclet);
-      }
-    }
-    
-    if (opponentFainted) {
-      const opponentIndex = this.getCurrentPicletIndex('opponent');
-      if (opponentIndex !== -1) {
-        this.opponentRosterStates[opponentIndex].fainted = true;
-        this.triggerOnKO(this.state.opponentPiclet, this.state.playerPiclet);
-      }
-    }
-    
-    // Check if any viable piclets remain
-    const playerHasViablePiclets = this.playerRosterStates.some(state => !state.fainted);
-    const opponentHasViablePiclets = this.opponentRosterStates.some(state => !state.fainted);
-    
-    if (!playerHasViablePiclets && !opponentHasViablePiclets) {
-      this.state.winner = 'draw';
-      this.state.phase = 'ended';
-      this.log('Battle ended in a draw!');
-    } else if (!playerHasViablePiclets) {
-      this.state.winner = 'opponent';
-      this.state.phase = 'ended';
-      // No win message - handled in UI
-    } else if (!opponentHasViablePiclets) {
-      this.state.winner = 'player';
-      this.state.phase = 'ended';
-      // No win message - handled in UI
-    } else if (playerFainted || opponentFainted) {
-      // Handle forced switching - at least one piclet fainted but viable alternatives exist
-      this.handleForcedSwitching(playerFainted, opponentFainted);
-    }
-  }
-
-  private handleForcedSwitching(playerFainted: boolean, opponentFainted: boolean): void {
-    if (playerFainted) {
-      this.log(`${this.state.playerPiclet.definition.name} fainted!`);
-      const viablePiclets = this.playerRosterStates.map((state, index) => ({ index, state }))
-        .filter(entry => !entry.state.fainted);
-      
-      if (viablePiclets.length === 1) {
-        // Auto-switch to the only remaining piclet
-        const autoSwitchIndex = viablePiclets[0].index;
-        this.log(`Player must choose a new piclet! Auto-switching to ${this.playerRoster[autoSwitchIndex].name}!`);
-        this.executeSwitch({ type: 'switch', piclet: 'player', newPicletIndex: autoSwitchIndex, executor: 'player' });
-      } else {
-        this.log(`Player must choose a new piclet from ${viablePiclets.length} remaining options!`);
-        // In a real implementation, this would pause and wait for player input
-        // For testing, we can simulate choosing the first available
-      }
-    }
-    
-    if (opponentFainted) {
-      this.log(`${this.state.opponentPiclet.definition.name} fainted!`);
-      const viablePiclets = this.opponentRosterStates.map((state, index) => ({ index, state }))
-        .filter(entry => !entry.state.fainted);
-      
-      if (viablePiclets.length === 1) {
-        // Auto-switch to the only remaining piclet
-        const autoSwitchIndex = viablePiclets[0].index;
-        this.log(`Opponent must choose a new piclet! Auto-switching to ${this.opponentRoster[autoSwitchIndex].name}!`);
-        this.executeSwitch({ type: 'switch', piclet: 'opponent', newPicletIndex: autoSwitchIndex, executor: 'opponent' });
-      } else {
-        this.log(`Opponent must choose a new piclet from ${viablePiclets.length} remaining options!`);
-        // In a real implementation, this would be AI logic
-      }
-    }
-  }
-
-  private log(message: string): void {
-    this.state.log.push(message);
-  }
-
-  // Public method to get battle log
-  public getLog(): string[] {
-    // Strip battle prefixes from all log messages for display
-    return this.state.log.map(message => this.stripBattlePrefixes(message));
-  }
-  
-  private stripBattlePrefixes(message: string): string {
-    // Remove player- and enemy- prefixes from messages
-    return message
-      .replace(/player-/g, '')
-      .replace(/enemy-/g, '');
-  }
-
-  // Additional effect processors for advanced features
-  private processManipulatePPEffect(effect: { action: string; amount?: string; value?: number; targetMove?: string }, target: BattlePiclet): void {
-    const ppChange = this.getPPAmount(effect.amount, effect.value || 5);
-    
-    switch (effect.action) {
-      case 'drain':
-        // Drain PP from target's moves
-        for (const moveSlot of target.moves) {
-          if (moveSlot.currentPP > 0) {
-            const drained = Math.min(moveSlot.currentPP, ppChange);
-            moveSlot.currentPP -= drained;
-            this.log(`${target.definition.name}'s PP was drained from ${moveSlot.move.name}!`);
-            break; // Only drain from first move with PP
-          }
-        }
-        break;
-      case 'restore':
-        // Restore PP to target's moves
-        for (const moveSlot of target.moves) {
-          if (moveSlot.currentPP < moveSlot.move.pp) {
-            const restored = Math.min(moveSlot.move.pp - moveSlot.currentPP, ppChange);
-            moveSlot.currentPP += restored;
-            this.log(`${target.definition.name}'s PP was restored to ${moveSlot.move.name}!`);
-            break; // Only restore to first move that needs PP
-          }
-        }
-        break;
-      case 'disable':
-        // Disable a move by setting its PP to 0
-        for (const moveSlot of target.moves) {
-          if (moveSlot.currentPP > 0) {
-            moveSlot.currentPP = 0;
-            this.log(`${target.definition.name}'s ${moveSlot.move.name} was disabled!`);
-            break; // Only disable first available move
-          }
-        }
-        break;
-    }
-  }
-
-  private getPPAmount(amount?: string, value?: number): number {
-    if (value !== undefined) return value;
-    switch (amount) {
-      case 'small': return 3;
-      case 'medium': return 5;
-      case 'large': return 8;
-      default: return 5;
-    }
-  }
-
-  private processFieldEffect(effect: { effect: string; target: string; stackable?: boolean }): void {
-    // Map old effect names to new descriptive names
-    const effectNameMap: Record<string, string> = {
-      'spikes': 'entryHazardSpikes',
-      'reflect': 'contactDamageReduction', 
-      'lightScreen': 'nonContactDamageReduction',
-      'healingMist': 'healingField',
-      'toxicSpikes': 'poisonousField'
-    };
-    
-    const mappedName = effectNameMap[effect.effect] || effect.effect;
-    
-    // Add field effect to battle state
-    const fieldEffect = {
-      name: mappedName,
-      duration: 5, // Default duration
-      effect: effect
-    };
-    
-    // Check if effect already exists and is not stackable
-    if (!effect.stackable) {
-      this.state.fieldEffects = this.state.fieldEffects.filter(fe => fe.name !== mappedName);
-    }
-    
-    this.state.fieldEffects.push(fieldEffect);
-    
-    // Log effect application with clear descriptions
-    switch (mappedName) {
-      case 'entryHazardSpikes':
-        this.log('Entry spikes were scattered on the battlefield!');
-        break;
-      case 'contactDamageReduction':
-        this.log('A barrier was raised to reduce contact move damage!');
-        break;
-      case 'nonContactDamageReduction':
-        this.log('A barrier was raised to reduce non-contact move damage!');
-        break;
-      case 'healingField':
-        this.log('A healing field was created!');
-        break;
-      case 'poisonousField':
-        this.log('A poisonous field was created!');
-        break;
-      default:
-        this.log(`${mappedName} was applied to the field!`);
-    }
-  }
-
-  private processCounterEffect(effect: { strength: string }, attacker: BattlePiclet, _target: BattlePiclet): void {
-    // Store counter effect for later processing when the user is attacked
-    // Counter effects should persist until triggered, not expire after 1 turn
-    attacker.temporaryEffects.push({
-      effect: {
-        type: 'counter',
-        strength: effect.strength
-      } as any,
-      duration: 5 // Persist for multiple turns until triggered
-    });
-    this.log(`${attacker.definition.name} is preparing to counter!`);
-  }
-
-  private processPriorityEffect(effect: { value: number; condition?: string }, target: BattlePiclet): void {
-    // Store priority modification for next move
-    target.statModifiers.priority = (target.statModifiers.priority || 0) + effect.value;
-    this.log(`${target.definition.name}'s move priority changed by ${effect.value}!`);
-  }
-
-  private processRemoveStatusEffect(effect: { status: string }, target: BattlePiclet): void {
-    if (target.statusEffects.includes(effect.status as any)) {
-      target.statusEffects = target.statusEffects.filter(s => s !== effect.status);
-      this.log(`${target.definition.name} was cured of ${effect.status}!`);
-    }
-  }
-
-  private processMechanicOverrideEffect(effect: { mechanic: string; value: any; condition?: string }, target: BattlePiclet): void {
-    // Store mechanic override as temporary effect for processing during relevant calculations
-    target.temporaryEffects.push({
-      effect: { 
-        type: 'mechanicOverride',
-        mechanic: effect.mechanic,
-        value: effect.value,
-        condition: effect.condition,
-        target: 'self'
-      } as any,
-      duration: effect.condition === 'restOfBattle' ? 999 : 1
-    });
-    
-    this.log(`Mechanic override '${effect.mechanic}' applied to ${target.definition.name}!`);
-  }
-
-  // Helper methods for checking mechanic overrides
-  private hasMechanicOverride(piclet: BattlePiclet, mechanic: string): any {
-    const override = piclet.temporaryEffects.find(
-      effect => effect.effect.type === 'mechanicOverride' && 
-                (effect.effect as any).mechanic === mechanic
-    );
-    return override ? (override.effect as any).value : null;
-  }
-
-  private checkCriticalHitModification(attacker: BattlePiclet, target: BattlePiclet): 'always' | 'never' | 'normal' {
-    // Check attacker's critical hit modifiers
-    const attackerOverride = this.hasMechanicOverride(attacker, 'criticalHits');
-    if (attackerOverride === true) return 'always';
-    
-    // Check target's critical hit immunity
-    const targetOverride = this.hasMechanicOverride(target, 'criticalHits');
-    if (targetOverride === false) return 'never';
-    
-    return 'normal';
-  }
-
-  private checkStatusImmunity(target: BattlePiclet, status: string): boolean {
-    const immunity = this.hasMechanicOverride(target, 'statusImmunity');
-    if (Array.isArray(immunity)) {
-      return immunity.includes(status);
-    }
-    return false;
-  }
-
-  private checkTypeImmunity(target: BattlePiclet, attackType: string): boolean {
-    const immunity = this.hasMechanicOverride(target, 'typeImmunity');
-    if (Array.isArray(immunity)) {
-      return immunity.includes(attackType);
-    }
-    return false;
-  }
-
-  private checkFlagBasedTypeImmunity(target: BattlePiclet, flags: string[]): boolean {
-    const immunity = this.hasMechanicOverride(target, 'typeImmunity');
-    if (Array.isArray(immunity)) {
-      // Check if any of the move's flags match the type immunity
-      return flags.some(flag => immunity.includes(flag));
-    }
-    return false;
-  }
-
-  private checkFlagInteraction(target: BattlePiclet, flags: string[]): 'immune' | 'weak' | 'resist' | 'normal' {
-    // Check immunities first
-    const immunity = this.hasMechanicOverride(target, 'flagImmunity');
-    if (Array.isArray(immunity) && flags.some(flag => immunity.includes(flag))) {
-      return 'immune';
-    }
-    
-    // Check weaknesses
-    const weakness = this.hasMechanicOverride(target, 'flagWeakness');
-    if (Array.isArray(weakness) && flags.some(flag => weakness.includes(flag))) {
-      return 'weak';
-    }
-    
-    // Check resistances
-    const resistance = this.hasMechanicOverride(target, 'flagResistance');
-    if (Array.isArray(resistance) && flags.some(flag => resistance.includes(flag))) {
-      return 'resist';
-    }
-    
-    return 'normal';
-  }
-
-  private getDamageMultiplier(piclet: BattlePiclet): number {
-    const multiplier = this.hasMechanicOverride(piclet, 'damageMultiplier');
-    return typeof multiplier === 'number' ? multiplier : 1.0;
-  }
-
-  private shouldInvertHealing(target: BattlePiclet): boolean {
-    return !!this.hasMechanicOverride(target, 'healingInversion');
-  }
-
-  private applyEffectToPiclet(effect: BattleEffect, piclet: BattlePiclet): void {
-    switch (effect.type) {
-      case 'modifyStats':
-        // Apply permanent stat modifications from abilities
-        for (const [stat, modification] of Object.entries(effect.stats)) {
-          const multiplier = this.getStatModifier(modification);
-          if (stat === 'accuracy') {
-            piclet.accuracy = Math.floor(piclet.accuracy * multiplier);
-          } else {
-            const statKey = stat as keyof BaseStats;
-            (piclet as any)[statKey] = Math.floor((piclet as any)[statKey] * multiplier);
-          }
-        }
-        break;
-      case 'mechanicOverride':
-        // Store mechanic overrides as permanent effects
-        piclet.temporaryEffects.push({
-          effect: effect,
-          duration: 999 // Permanent ability effect
-        });
-        break;
-      // Other effects are handled during battle
-    }
-  }
-
-  private checkCounterEffects(target: BattlePiclet, attacker: BattlePiclet, move: Move): void {
-    // Check if the target has any counter effects ready
-    for (let i = target.temporaryEffects.length - 1; i >= 0; i--) {
-      const tempEffect = target.temporaryEffects[i];
-      if (tempEffect.effect.type === 'counter') {
-        const counterEffect = tempEffect.effect as any;
-        const shouldCounter = true; // All counters now work against any attack type
-        
-        if (shouldCounter) {
-          // Calculate counter damage
-          let counterDamage = 0;
-          switch (counterEffect.strength) {
-            case 'weak': counterDamage = 20; break;
-            case 'normal': counterDamage = 40; break;
-            case 'strong': counterDamage = 60; break;
-            default: counterDamage = 40;
-          }
-          
-          attacker.currentHp = Math.max(0, attacker.currentHp - counterDamage);
-          this.log(`${target.definition.name} countered with ${counterDamage} damage!`);
-          
-          // Remove the counter effect after it triggers
-          target.temporaryEffects.splice(i, 1);
-        }
-      }
-    }
-  }
-
-  // Advanced Status Effect Checks
-  private canPicletAct(piclet: BattlePiclet): boolean {
-    // Check status effects that prevent action
-    for (const status of piclet.statusEffects) {
-      switch (status) {
-        case 'freeze':
-          this.log(`${piclet.definition.name} is frozen solid and cannot move!`);
-          return false;
-          
-        case 'sleep':
-          this.log(`${piclet.definition.name} is fast asleep and cannot wake up!`);
-          return false;
-          
-        case 'paralyze':
-          // 25% chance to be fully paralyzed
-          if (Math.random() < 0.25) {
-            this.log(`${piclet.definition.name} is fully paralyzed and cannot move!`);
-            return false;
-          }
-          break;
-          
-        case 'confuse':
-          // 33% chance to hurt self in confusion
-          if (Math.random() < 0.33) {
-            const selfDamage = Math.floor(piclet.maxHp * 0.125); // 12.5% max HP
-            piclet.currentHp = Math.max(0, piclet.currentHp - selfDamage);
-            this.log(`${piclet.definition.name} hurt itself in confusion for ${selfDamage} damage!`);
-            return false;
-          }
-          break;
-      }
-    }
-    return true;
-  }
-
-  // Enhanced Status Application
-  private processApplyStatusEffect(effect: { status: StatusEffect; chance?: number }, target: BattlePiclet): void {
-    // Check chance if specified
-    if (effect.chance !== undefined) {
-      const roll = Math.random() * 100;
-      if (roll >= effect.chance) {
-        return; // Status effect failed to apply
-      }
-    }
-
-    // Check for status immunity
-    if (this.checkStatusImmunity(target, effect.status)) {
-      this.log(`${target.definition.name} is immune to ${effect.status}!`);
-      return;
-    }
-
-    // Check for major status conflicts (freeze, paralyze, sleep are mutually exclusive)
-    const majorStatuses = ['freeze', 'paralyze', 'sleep'];
-    if (majorStatuses.includes(effect.status)) {
-      const hasMajorStatus = target.statusEffects.some(status => majorStatuses.includes(status));
-      if (hasMajorStatus) {
-        this.log(`${target.definition.name} is already affected by a major status condition!`);
-        return;
-      }
-    }
-
-    if (!target.statusEffects.includes(effect.status)) {
-      target.statusEffects.push(effect.status);
-      
-      // Trigger status inflicted event
-      this.triggerOnStatusInflicted(target, effect.status);
-      
-      // Apply immediate effects and set durations
-      switch (effect.status) {
-        case 'freeze':
-          this.log(`${target.definition.name} was frozen solid!`);
-          // Mark as just applied to prevent immediate thawing
-          (target as any).freezeJustApplied = true;
-          break;
-        case 'paralyze':
-          this.log(`${target.definition.name} was paralyzed!`);
-          // Reduce speed by 50%
-          target.speed = Math.floor(target.speed * 0.5);
-          break;
-        case 'sleep':
-          this.log(`${target.definition.name} fell asleep!`);
-          // Sleep lasts 1-3 turns
-          (target as any).sleepTurns = 1 + Math.floor(Math.random() * 3);
-          (target as any).sleepJustApplied = true;
-          break;
-        case 'confuse':
-          this.log(`${target.definition.name} became confused!`);
-          // Confusion lasts 2-5 turns
-          (target as any).confusionTurns = 2 + Math.floor(Math.random() * 4);
-          break;
-        default:
-          this.log(`${target.definition.name} was ${effect.status}ed!`);
-      }
-    }
-  }
-
-  // Wake up from sleep when damaged
-  private wakeUpFromSleep(target: BattlePiclet): void {
-    if (target.statusEffects.includes('sleep')) {
-      const sleepIndex = target.statusEffects.indexOf('sleep');
-      if (sleepIndex > -1) {
-        target.statusEffects.splice(sleepIndex, 1);
-        this.log(`${target.definition.name} woke up from the attack!`);
-        delete (target as any).sleepTurns;
-      }
-    }
-  }
-
-  // Ability Trigger System
-  private triggerAbilities(event: string, piclet: BattlePiclet, context?: any): void {
-    if (!piclet.definition.specialAbility?.triggers) return;
-
-    for (const trigger of piclet.definition.specialAbility.triggers) {
-      if (trigger.event === event && this.checkTriggerCondition(trigger, piclet, context)) {
-        this.log(`${piclet.definition.name}'s ${piclet.definition.specialAbility.name} triggered!`);
-        
-        // Process all effects in the trigger
-        for (const effect of trigger.effects) {
-          this.processAbilityTriggerEffect(effect, piclet, context);
-        }
-      }
-    }
-  }
-
-  private checkTriggerCondition(trigger: Trigger, piclet: BattlePiclet, context?: any): boolean {
-    if (!trigger.condition || trigger.condition === 'always') {
-      return true;
-    }
-
-    // Check various conditions
-    switch (trigger.condition) {
-      case 'ifLowHp':
-        return (piclet.currentHp / piclet.maxHp) < 0.25;
-      case 'ifHighHp':
-        return piclet.currentHp === piclet.maxHp;
-      case 'onCritical':
-        return context?.isCriticalHit === true;
-      case 'ifStatusMove':
-        return context?.isStatusMove === true;
-      default:
-        return true;
-    }
-  }
-
-  private processAbilityTriggerEffect(effect: BattleEffect, owner: BattlePiclet, context?: any): void {
-    // Determine target for the effect based on effect type
-    let targetType = 'self'; // default
-    if ('target' in effect) {
-      targetType = effect.target;
-    }
-    const target = this.resolveAbilityTarget(targetType, owner);
-    if (!target) return;
-
-    // Process the effect using existing effect processors
-    switch (effect.type) {
-      case 'damage':
-        // Create a dummy move for damage calculation
-        const dummyMove: Move = {
-          name: `${owner.definition.specialAbility?.name} Effect`,
-          type: 'normal' as any,
-          power: 0,
-          accuracy: 100,
-          pp: 1,
-          priority: 0,
-          flags: [],
-          effects: []
-        };
-        this.processDamageEffect(effect, owner, target, dummyMove);
-        break;
-      case 'modifyStats':
-        this.processModifyStatsEffect(effect, target);
-        break;
-      case 'heal':
-        this.processHealEffect(effect, target);
-        break;
-      case 'applyStatus':
-        this.processApplyStatusEffect(effect, target);
-        break;
-      case 'removeStatus':
-        this.processRemoveStatusEffect(effect, target);
-        break;
-      default:
-        this.log(`Ability effect ${effect.type} not implemented yet`);
-    }
-  }
-
-  private resolveAbilityTarget(targetType: string, owner: BattlePiclet): BattlePiclet | null {
-    switch (targetType) {
-      case 'self':
-        return owner;
-      case 'opponent':
-        return owner === this.state.playerPiclet ? this.state.opponentPiclet : this.state.playerPiclet;
-      default:
-        return null;
-    }
-  }
-
-  // Trigger Points Integration
-  private triggerOnDamageTaken(piclet: BattlePiclet, damage: number, isContactMove: boolean): void {
-    this.triggerAbilities('onDamageTaken', piclet, { damage, isContactMove });
-    if (isContactMove) {
-      this.triggerAbilities('onContactDamage', piclet, { damage });
-    }
-  }
-
-  private triggerOnDamageDealt(piclet: BattlePiclet, damage: number, target: BattlePiclet): void {
-    this.triggerAbilities('onDamageDealt', piclet, { damage, target });
-  }
-
-  private triggerOnCriticalHit(piclet: BattlePiclet, target: BattlePiclet): void {
-    this.triggerAbilities('onCriticalHit', piclet, { target, isCriticalHit: true });
-  }
-
-  private triggerOnLowHP(piclet: BattlePiclet): void {
-    if ((piclet.currentHp / piclet.maxHp) < 0.25) {
-      this.triggerAbilities('onLowHP', piclet);
-    }
-  }
-
-  private triggerEndOfTurn(): void {
-    this.triggerAbilities('endOfTurn', this.state.playerPiclet);
-    this.triggerAbilities('endOfTurn', this.state.opponentPiclet);
-  }
-
-  private triggerOnStatusInflicted(piclet: BattlePiclet, status: string): void {
-    this.triggerAbilities('onStatusInflicted', piclet, { status });
-  }
-
-  private triggerOnHPDrained(attacker: BattlePiclet, target: BattlePiclet, drainAmount: number): void {
-    this.triggerAbilities('onHPDrained', attacker, { target, drainAmount });
-  }
-
-  private triggerOnKO(knockedOut: BattlePiclet, attacker: BattlePiclet): void {
-    this.triggerAbilities('onKO', knockedOut, { attacker });
-    this.triggerAbilities('onKO', attacker, { target: knockedOut, causedKO: true });
-  }
-
-  private triggerBeforeMoveUse(piclet: BattlePiclet, move: Move): void {
-    this.triggerAbilities('beforeMoveUse', piclet, { move });
-  }
-
-  private triggerAfterMoveUse(piclet: BattlePiclet, move: Move, success: boolean): void {
-    this.triggerAbilities('afterMoveUse', piclet, { move, success });
-  }
-
-  private triggerOnFullHP(piclet: BattlePiclet): void {
-    if (piclet.currentHp === piclet.maxHp) {
-      this.triggerAbilities('onFullHP', piclet);
-    }
-  }
-
-  private triggerOnOpponentContactMove(defender: BattlePiclet, attacker: BattlePiclet, move: Move): void {
-    if (move.flags.includes('contact')) {
-      this.triggerAbilities('onOpponentContactMove', defender, { attacker, move });
-    }
-  }
-
-  private triggerOnStatChange(piclet: BattlePiclet, stat: string, change: string): void {
-    this.triggerAbilities('onStatChange', piclet, { stat, change });
-  }
-}

src/lib/battle-engine/MultiBattleEngine.test.ts

@@ -1,671 +0,0 @@
-/**
- * Tests for Multi-Piclet Battle Engine
- * Covers battles with up to 4 Piclets on the field at once
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MultiBattleEngine } from './MultiBattleEngine';
-import { MultiBattleConfig, TurnActions } from './multi-piclet-types';
-import { PicletType, AttackType } from './types';
-import { 
-  STELLAR_WOLF, 
-  TOXIC_CRAWLER, 
-  BERSERKER_BEAST, 
-  AQUA_GUARDIAN 
-} from './test-data';
-
-describe('MultiBattleEngine', () => {
-  let config: MultiBattleConfig;
-  let engine: MultiBattleEngine;
-
-  beforeEach(() => {
-    config = {
-      playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-      opponentParty: [TOXIC_CRAWLER, AQUA_GUARDIAN],
-      playerActiveCount: 1,
-      opponentActiveCount: 1,
-      battleType: 'single'
-    };
-    engine = new MultiBattleEngine(config);
-  });
-
-  describe('Battle Initialization', () => {
-    it('should initialize single battle correctly', () => {
-      const state = engine.getState();
-      
-      expect(state.turn).toBe(1);
-      expect(state.phase).toBe('selection');
-      expect(state.activePiclets.player).toHaveLength(2);
-      expect(state.activePiclets.opponent).toHaveLength(2);
-      
-      // First position should be active, second should be null
-      expect(state.activePiclets.player[0]).not.toBeNull();
-      expect(state.activePiclets.player[1]).toBeNull();
-      expect(state.activePiclets.opponent[0]).not.toBeNull();
-      expect(state.activePiclets.opponent[1]).toBeNull();
-    });
-
-    it('should initialize double battle correctly', () => {
-      const doubleConfig: MultiBattleConfig = {
-        playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-        opponentParty: [TOXIC_CRAWLER, AQUA_GUARDIAN],
-        playerActiveCount: 2,
-        opponentActiveCount: 2,
-        battleType: 'double'
-      };
-      
-      const doubleEngine = new MultiBattleEngine(doubleConfig);
-      const state = doubleEngine.getState();
-      
-      // Both positions should be active
-      expect(state.activePiclets.player[0]).not.toBeNull();
-      expect(state.activePiclets.player[1]).not.toBeNull();
-      expect(state.activePiclets.opponent[0]).not.toBeNull();
-      expect(state.activePiclets.opponent[1]).not.toBeNull();
-    });
-
-    it('should handle parties correctly', () => {
-      const state = engine.getState();
-      
-      expect(state.parties.player).toHaveLength(2);
-      expect(state.parties.opponent).toHaveLength(2);
-      expect(state.parties.player[0].name).toBe('Stellar Wolf');
-      expect(state.parties.opponent[0].name).toBe('Toxic Crawler');
-    });
-  });
-
-  describe('Action Generation', () => {
-    it('should generate valid move actions for active Piclets', () => {
-      const actions = engine.getValidActions('player');
-      
-      // Should have move actions for the active Piclet
-      const moveActions = actions.filter(a => a.type === 'move');
-      expect(moveActions.length).toBeGreaterThan(0);
-      
-      // All move actions should be for position 0 (the active Piclet)
-      moveActions.forEach(action => {
-        expect((action as any).position).toBe(0);
-      });
-    });
-
-    it('should generate switch actions for party members', () => {
-      const actions = engine.getValidActions('player');
-      
-      const switchActions = actions.filter(a => a.type === 'switch');
-      expect(switchActions.length).toBeGreaterThan(0);
-      
-      // Should be able to switch the inactive party member into position 0
-      const switchToPosition0 = switchActions.find(a => 
-        (a as any).position === 0 && (a as any).partyIndex === 1
-      );
-      expect(switchToPosition0).toBeDefined();
-    });
-  });
-
-  describe('Single Battle Execution', () => {
-    it('should execute a single battle turn correctly', () => {
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0 // Tackle
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0 // Tackle
-        }]
-      };
-
-      const initialOpponentHp = engine.getState().activePiclets.opponent[0]!.currentHp;
-      engine.executeTurn(turnActions);
-      
-      const finalOpponentHp = engine.getState().activePiclets.opponent[0]!.currentHp;
-      expect(finalOpponentHp).toBeLessThan(initialOpponentHp);
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('used Tackle'))).toBe(true);
-    });
-
-    it('should handle switch actions correctly', () => {
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'switch',
-          side: 'player',
-          position: 0,
-          partyIndex: 1 // Switch to Berserker Beast
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      const initialName = engine.getState().activePiclets.player[0]!.definition.name;
-      engine.executeTurn(turnActions);
-      const finalName = engine.getState().activePiclets.player[0]!.definition.name;
-      
-      expect(initialName).toBe('Stellar Wolf');
-      expect(finalName).toBe('Berserker Beast');
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('switched out'))).toBe(true);
-      expect(log.some(msg => msg.includes('switched in'))).toBe(true);
-    });
-  });
-
-  describe('Double Battle System', () => {
-    let doubleEngine: MultiBattleEngine;
-
-    beforeEach(() => {
-      const doubleConfig: MultiBattleConfig = {
-        playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-        opponentParty: [TOXIC_CRAWLER, AQUA_GUARDIAN],
-        playerActiveCount: 2,
-        opponentActiveCount: 2,
-        battleType: 'double'
-      };
-      doubleEngine = new MultiBattleEngine(doubleConfig);
-    });
-
-    it('should execute double battle turns correctly', () => {
-      const turnActions: TurnActions = {
-        player: [
-          {
-            type: 'move',
-            side: 'player',
-            position: 0,
-            moveIndex: 0 // Stellar Wolf uses Tackle
-          },
-          {
-            type: 'move',
-            side: 'player',
-            position: 1,
-            moveIndex: 0 // Berserker Beast uses Tackle
-          }
-        ],
-        opponent: [
-          {
-            type: 'move',
-            side: 'opponent',
-            position: 0,
-            moveIndex: 0 // Toxic Crawler uses Tackle
-          },
-          {
-            type: 'move',
-            side: 'opponent',
-            position: 1,
-            moveIndex: 0 // Aqua Guardian uses Tackle
-          }
-        ]
-      };
-
-      doubleEngine.executeTurn(turnActions);
-      
-      const log = doubleEngine.getLog();
-      expect(log.some(msg => msg.includes('Stellar Wolf used'))).toBe(true);
-      expect(log.some(msg => msg.includes('Berserker Beast used'))).toBe(true);
-      expect(log.some(msg => msg.includes('Toxic Crawler used'))).toBe(true);
-      expect(log.some(msg => msg.includes('Aqua Guardian used'))).toBe(true);
-    });
-
-    it('should handle mixed actions in double battles', () => {
-      const turnActions: TurnActions = {
-        player: [
-          {
-            type: 'move',
-            side: 'player',
-            position: 0,
-            moveIndex: 0 // Attack
-          },
-          {
-            type: 'switch',
-            side: 'player',
-            position: 1,
-            partyIndex: 0 // This would be switching to same Piclet, but tests the system
-          }
-        ],
-        opponent: [
-          {
-            type: 'move',
-            side: 'opponent',
-            position: 0,
-            moveIndex: 0
-          },
-          {
-            type: 'move',
-            side: 'opponent',
-            position: 1,
-            moveIndex: 0
-          }
-        ]
-      };
-
-      doubleEngine.executeTurn(turnActions);
-      
-      const log = doubleEngine.getLog();
-      expect(log.some(msg => msg.includes('used'))).toBe(true);
-    });
-  });
-
-  describe('Action Priority System', () => {
-    it('should prioritize switch actions over moves', () => {
-      const doubleConfig: MultiBattleConfig = {
-        playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-        opponentParty: [TOXIC_CRAWLER, AQUA_GUARDIAN],
-        playerActiveCount: 2,
-        opponentActiveCount: 2,
-        battleType: 'double'
-      };
-      const doubleEngine = new MultiBattleEngine(doubleConfig);
-
-      const turnActions: TurnActions = {
-        player: [
-          {
-            type: 'move',
-            side: 'player',
-            position: 0,
-            moveIndex: 0 // Regular move
-          }
-        ],
-        opponent: [
-          {
-            type: 'switch',
-            side: 'opponent',
-            position: 0,
-            partyIndex: 1 // Switch action (should go first)
-          }
-        ]
-      };
-
-      doubleEngine.executeTurn(turnActions);
-      
-      const log = doubleEngine.getLog();
-      const switchIndex = log.findIndex(msg => msg.includes('switched'));
-      const moveIndex = log.findIndex(msg => msg.includes('used'));
-      
-      // Switch should happen before move (if both occurred)
-      if (switchIndex !== -1 && moveIndex !== -1) {
-        expect(switchIndex).toBeLessThan(moveIndex);
-      }
-    });
-
-    it('should use speed for same priority actions', () => {
-      // Stellar Wolf (speed 70) vs Toxic Crawler (speed 55)
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0 // Tackle (priority 0)
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0 // Tackle (priority 0)
-        }]
-      };
-
-      engine.executeTurn(turnActions);
-      
-      const log = engine.getLog();
-      const stellarIndex = log.findIndex(msg => msg.includes('Stellar Wolf used'));
-      const toxicIndex = log.findIndex(msg => msg.includes('Toxic Crawler used'));
-      
-      // Stellar Wolf should go first due to higher speed
-      expect(stellarIndex).toBeLessThan(toxicIndex);
-    });
-  });
-
-  describe('Victory Conditions', () => {
-    it('should end battle when all opponent Piclets faint', () => {
-      // Create a battle with single-Piclet opponent party (no reserves)
-      const singleOpponentConfig: MultiBattleConfig = {
-        playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-        opponentParty: [TOXIC_CRAWLER], // Only one Piclet, no reserves
-        playerActiveCount: 1,
-        opponentActiveCount: 1,
-        battleType: 'single'
-      };
-      const singleEngine = new MultiBattleEngine(singleOpponentConfig);
-      
-      // Set opponent to very low HP
-      (singleEngine as any).state.activePiclets.opponent[0]!.currentHp = 1;
-      
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      singleEngine.executeTurn(turnActions);
-      
-      expect(singleEngine.isGameOver()).toBe(true);
-      expect(singleEngine.getWinner()).toBe('player');
-    });
-
-    it('should continue battle when reserves are available', () => {
-      // This test would require implementing automatic switching
-      // when a Piclet faints, which is more complex
-      expect(true).toBe(true); // Placeholder
-    });
-  });
-
-  describe('Targeting System', () => {
-    it('should target opponents correctly in single battles', () => {
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0 // Attack should hit opponent
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      const initialHp = engine.getState().activePiclets.opponent[0]!.currentHp;
-      engine.executeTurn(turnActions);
-      const finalHp = engine.getState().activePiclets.opponent[0]!.currentHp;
-      
-      expect(finalHp).toBeLessThan(initialHp);
-    });
-
-    it('should target all opponents in double battles', () => {
-      const doubleConfig: MultiBattleConfig = {
-        playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-        opponentParty: [TOXIC_CRAWLER, AQUA_GUARDIAN],
-        playerActiveCount: 2,
-        opponentActiveCount: 2,
-        battleType: 'double'
-      };
-      const doubleEngine = new MultiBattleEngine(doubleConfig);
-
-      // Create a multi-target move for testing
-      const multiTargetMove = {
-        name: 'Mass Strike',
-        type: 'normal' as any,
-        power: 30,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: [] as any,
-        effects: [{
-          type: 'damage' as any,
-          target: 'allOpponents' as any,
-          amount: 'normal' as any
-        }]
-      };
-
-      // Add the move to the attacker
-      (doubleEngine as any).state.activePiclets.player[0].moves[0] = {
-        move: multiTargetMove,
-        currentPP: 10
-      };
-
-      const initialHp1 = doubleEngine.getState().activePiclets.opponent[0]!.currentHp;
-      const initialHp2 = doubleEngine.getState().activePiclets.opponent[1]!.currentHp;
-
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0 // Multi-target move
-        }],
-        opponent: [
-          { type: 'move', side: 'opponent', position: 0, moveIndex: 0 },
-          { type: 'move', side: 'opponent', position: 1, moveIndex: 0 }
-        ]
-      };
-
-      doubleEngine.executeTurn(turnActions);
-
-      const finalHp1 = doubleEngine.getState().activePiclets.opponent[0]!.currentHp;
-      const finalHp2 = doubleEngine.getState().activePiclets.opponent[1]!.currentHp;
-
-      // Both opponents should take damage
-      expect(finalHp1).toBeLessThan(initialHp1);
-      expect(finalHp2).toBeLessThan(initialHp2);
-    });
-
-    it('should target self correctly', () => {
-      // Create a self-targeting move (like heal)
-      const selfTargetMove = {
-        name: 'Self Heal',
-        type: 'normal' as any,
-        power: 0,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: [] as any,
-        effects: [{
-          type: 'heal' as any,
-          target: 'self' as any,
-          amount: 'medium' as any
-        }]
-      };
-
-      // Damage the Piclet first then heal
-      (engine as any).state.activePiclets.player[0].currentHp = 50;
-      
-      // Add the heal move
-      (engine as any).state.activePiclets.player[0].moves[0] = {
-        move: selfTargetMove,
-        currentPP: 10
-      };
-
-      const initialHp = engine.getState().activePiclets.player[0]!.currentHp;
-
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0 // Self-heal move
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      engine.executeTurn(turnActions);
-
-      const finalHp = engine.getState().activePiclets.player[0]!.currentHp;
-      
-      // Player should have more HP after healing
-      expect(finalHp).toBeGreaterThan(initialHp);
-    });
-  });
-
-  describe('Status Effects in Multi-Battle', () => {
-    it('should process status effects for all active Piclets', () => {
-      const doubleConfig: MultiBattleConfig = {
-        playerParty: [STELLAR_WOLF, BERSERKER_BEAST],
-        opponentParty: [TOXIC_CRAWLER, AQUA_GUARDIAN],
-        playerActiveCount: 2,
-        opponentActiveCount: 2,
-        battleType: 'double'
-      };
-      const doubleEngine = new MultiBattleEngine(doubleConfig);
-
-      // Apply poison to both active player Piclets
-      (doubleEngine as any).state.activePiclets.player[0]!.statusEffects.push('poison');
-      (doubleEngine as any).state.activePiclets.player[1]!.statusEffects.push('poison');
-
-      const turnActions: TurnActions = {
-        player: [
-          { type: 'move', side: 'player', position: 0, moveIndex: 0 },
-          { type: 'move', side: 'player', position: 1, moveIndex: 0 }
-        ],
-        opponent: [
-          { type: 'move', side: 'opponent', position: 0, moveIndex: 0 },
-          { type: 'move', side: 'opponent', position: 1, moveIndex: 0 }
-        ]
-      };
-
-      doubleEngine.executeTurn(turnActions);
-      
-      const log = doubleEngine.getLog();
-      const poisonMessages = log.filter(msg => msg.includes('hurt by poison'));
-      expect(poisonMessages.length).toBe(2); // Both Piclets should take poison damage
-    });
-  });
-
-  describe('Active Piclet Tracking', () => {
-    it('should correctly track active Piclets', () => {
-      const actives = engine.getActivePiclets();
-      
-      expect(actives.player).toHaveLength(1);
-      expect(actives.opponent).toHaveLength(1);
-      expect(actives.player[0].definition.name).toBe('Stellar Wolf');
-      expect(actives.opponent[0].definition.name).toBe('Toxic Crawler');
-    });
-
-    it('should update active tracking after switches', () => {
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'switch',
-          side: 'player',
-          position: 0,
-          partyIndex: 1 // Switch to Berserker Beast
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      engine.executeTurn(turnActions);
-      
-      const actives = engine.getActivePiclets();
-      expect(actives.player[0].definition.name).toBe('Berserker Beast');
-    });
-  });
-
-  describe('Party Management', () => {
-    it('should track available switches correctly', () => {
-      const availableSwitches = engine.getAvailableSwitches('player');
-      
-      expect(availableSwitches).toHaveLength(1);
-      expect(availableSwitches[0].piclet.name).toBe('Berserker Beast');
-      expect(availableSwitches[0].partyIndex).toBe(1);
-    });
-
-    it('should update available switches after switching', () => {
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'switch',
-          side: 'player',
-          position: 0,
-          partyIndex: 1 // Switch to Berserker Beast
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      engine.executeTurn(turnActions);
-      
-      const availableSwitches = engine.getAvailableSwitches('player');
-      expect(availableSwitches).toHaveLength(1);
-      expect(availableSwitches[0].piclet.name).toBe('Stellar Wolf');
-      expect(availableSwitches[0].partyIndex).toBe(0);
-    });
-
-    it('should handle fainted Piclets correctly', () => {
-      // Set player Piclet to very low HP
-      (engine as any).state.activePiclets.player[0]!.currentHp = 1;
-
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 0,
-          moveIndex: 0
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0 // This should cause player to faint
-        }]
-      };
-
-      engine.executeTurn(turnActions);
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('fainted!'))).toBe(true);
-      
-      // Active Piclet should be removed (null)
-      const state = engine.getState();
-      expect(state.activePiclets.player[0]).toBeNull();
-    });
-
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle empty action arrays gracefully', () => {
-      const turnActions: TurnActions = {
-        player: [],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      expect(() => {
-        engine.executeTurn(turnActions);
-      }).not.toThrow();
-    });
-
-    it('should handle invalid positions gracefully', () => {
-      const turnActions: TurnActions = {
-        player: [{
-          type: 'move',
-          side: 'player',
-          position: 1, // Invalid position (empty slot)
-          moveIndex: 0
-        }],
-        opponent: [{
-          type: 'move',
-          side: 'opponent',
-          position: 0,
-          moveIndex: 0
-        }]
-      };
-
-      expect(() => {
-        engine.executeTurn(turnActions);
-      }).not.toThrow();
-    });
-  });
-});

src/lib/battle-engine/MultiBattleEngine.ts

@@ -1,701 +0,0 @@
-/**
- * Multi-Piclet Battle Engine
- * Supports up to 4 Piclets on the field at once (2 per side)
- * Extends the single-Piclet battle system with party management and multi-targeting
- */
-
-import {
-  MultiBattleState,
-  MultiBattleAction,
-  MultiMoveAction,
-  MultiSwitchAction,
-  TurnActions,
-  PicletTarget,
-  BattleSide,
-  FieldPosition,
-  MultiBattleConfig,
-  ActionPriority,
-  VictoryCondition,
-  MultiEffectTarget
-} from './multi-piclet-types';
-
-import {
-  BattlePiclet,
-  PicletDefinition,
-  BattleEffect,
-  Move,
-  BaseStats,
-  StatusEffect
-} from './types';
-
-import { getEffectivenessMultiplier } from '../types/picletTypes';
-
-export class MultiBattleEngine {
-  private state: MultiBattleState;
-  private victoryCondition: VictoryCondition;
-
-  constructor(config: MultiBattleConfig, victoryCondition: VictoryCondition = { type: 'allFainted' }) {
-    this.victoryCondition = victoryCondition;
-    this.state = this.initializeBattle(config);
-    this.log('Multi-Piclet battle started!');
-    this.logActivePiclets();
-  }
-
-  private initializeBattle(config: MultiBattleConfig): MultiBattleState {
-    // Initialize active Piclets from parties
-    const playerActive: Array<BattlePiclet | null> = [null, null];
-    const opponentActive: Array<BattlePiclet | null> = [null, null];
-
-    // Set up initial active Piclets
-    for (let i = 0; i < config.playerActiveCount && i < config.playerParty.length; i++) {
-      playerActive[i] = this.createBattlePiclet(config.playerParty[i], 50);
-    }
-
-    for (let i = 0; i < config.opponentActiveCount && i < config.opponentParty.length; i++) {
-      opponentActive[i] = this.createBattlePiclet(config.opponentParty[i], 50);
-    }
-
-    return {
-      turn: 1,
-      phase: 'selection',
-      activePiclets: {
-        player: playerActive,
-        opponent: opponentActive
-      },
-      parties: {
-        player: config.playerParty,
-        opponent: config.opponentParty
-      },
-      fieldEffects: [],
-      log: [],
-      winner: undefined
-    };
-  }
-
-  private createBattlePiclet(definition: PicletDefinition, level: number): BattlePiclet {
-    // Same logic as original BattleEngine
-    const statMultiplier = 1 + (level - 50) * 0.02;
-    
-    const hp = Math.floor(definition.baseStats.hp * statMultiplier);
-    const attack = Math.floor(definition.baseStats.attack * statMultiplier);
-    const defense = Math.floor(definition.baseStats.defense * statMultiplier);
-    const speed = Math.floor(definition.baseStats.speed * statMultiplier);
-
-    return {
-      definition,
-      currentHp: hp,
-      maxHp: hp,
-      level,
-      attack,
-      defense,
-      speed,
-      accuracy: 100,
-      statusEffects: [],
-      moves: definition.movepool.slice(0, 4).map(move => ({
-        move,
-        currentPP: move.pp
-      })),
-      statModifiers: {},
-      temporaryEffects: []
-    };
-  }
-
-  public getState(): MultiBattleState {
-    return JSON.parse(JSON.stringify(this.state));
-  }
-
-  public isGameOver(): boolean {
-    return this.state.phase === 'ended';
-  }
-
-  public getWinner(): 'player' | 'opponent' | 'draw' | undefined {
-    return this.state.winner;
-  }
-
-  public getActivePiclets(): { player: BattlePiclet[], opponent: BattlePiclet[] } {
-    return {
-      player: this.state.activePiclets.player.filter(p => p !== null) as BattlePiclet[],
-      opponent: this.state.activePiclets.opponent.filter(p => p !== null) as BattlePiclet[]
-    };
-  }
-
-  public getAvailableSwitches(side: BattleSide): Array<{ partyIndex: number, piclet: PicletDefinition }> {
-    const available: Array<{ partyIndex: number, piclet: PicletDefinition }> = [];
-    const activePicletNames = this.state.activePiclets[side]
-      .filter(p => p !== null)
-      .map(p => p!.definition.name);
-
-    this.state.parties[side].forEach((partyMember, index) => {
-      if (!activePicletNames.includes(partyMember.name)) {
-        available.push({ partyIndex: index, piclet: partyMember });
-      }
-    });
-
-    return available;
-  }
-
-  public getValidActions(side: BattleSide): MultiBattleAction[] {
-    const actions: MultiBattleAction[] = [];
-    const activePiclets = this.state.activePiclets[side];
-
-    // Add move actions for each active Piclet
-    activePiclets.forEach((piclet, position) => {
-      if (piclet) {
-        piclet.moves.forEach((moveData, moveIndex) => {
-          if (moveData.currentPP > 0) {
-            actions.push({
-              type: 'move',
-              side,
-              position: position as FieldPosition,
-              moveIndex
-            });
-          }
-        });
-      }
-    });
-
-    // Add switch actions for empty slots or when Piclets can be switched
-    this.state.parties[side].forEach((partyMember, partyIndex) => {
-      // Check if this party member is not currently active
-      const isActive = activePiclets.some(active => 
-        active?.definition.name === partyMember.name
-      );
-      
-      if (!isActive) {
-        // Can switch into any position that has a Piclet (replacement) or empty slot
-        activePiclets.forEach((slot, position) => {
-          actions.push({
-            type: 'switch',
-            side,
-            position: position as FieldPosition,
-            partyIndex
-          });
-        });
-      }
-    });
-
-    return actions;
-  }
-
-  public executeTurn(turnActions: TurnActions): void {
-    if (this.state.phase !== 'selection') {
-      throw new Error('Cannot execute turn - battle is not in selection phase');
-    }
-
-    this.state.phase = 'execution';
-    this.log(`Turn ${this.state.turn} - Executing actions`);
-
-    // Determine action order based on priority and speed
-    const allActions = this.determineActionOrder(turnActions);
-
-    // Execute actions in order
-    for (const actionPriority of allActions) {
-      if (this.state.phase === 'ended') break;
-      this.executeAction(actionPriority.action, actionPriority.side, actionPriority.position);
-    }
-
-    // End of turn processing
-    this.processTurnEnd();
-
-    // Check for battle end
-    this.checkBattleEnd();
-
-    if (this.state.phase !== 'ended') {
-      this.state.turn++;
-      this.state.phase = 'selection';
-    }
-  }
-
-  private determineActionOrder(turnActions: TurnActions): ActionPriority[] {
-    const allActionPriorities: ActionPriority[] = [];
-
-    // Process player actions
-    turnActions.player.forEach(action => {
-      const priority = this.getActionPriority(action);
-      const piclet = this.state.activePiclets.player[action.position];
-      allActionPriorities.push({
-        action,
-        side: 'player',
-        position: action.position,
-        priority,
-        speed: piclet?.speed || 0,
-        randomTiebreaker: Math.random()
-      });
-    });
-
-    // Process opponent actions
-    turnActions.opponent.forEach(action => {
-      const priority = this.getActionPriority(action);
-      const piclet = this.state.activePiclets.opponent[action.position];
-      allActionPriorities.push({
-        action,
-        side: 'opponent',
-        position: action.position,
-        priority,
-        speed: piclet?.speed || 0,
-        randomTiebreaker: Math.random()
-      });
-    });
-
-    // Sort by priority (higher first), then speed (higher first), then random
-    return allActionPriorities.sort((a, b) => {
-      if (a.priority !== b.priority) return b.priority - a.priority;
-      if (a.speed !== b.speed) return b.speed - a.speed;
-      return a.randomTiebreaker - b.randomTiebreaker;
-    });
-  }
-
-  private getActionPriority(action: MultiBattleAction): number {
-    if (action.type === 'switch') return 6; // Switches have highest priority
-    
-    const piclet = this.state.activePiclets[action.side][action.position];
-    if (!piclet) return 0;
-    
-    const move = piclet.moves[action.moveIndex]?.move;
-    return move?.priority || 0;
-  }
-
-  private executeAction(action: MultiBattleAction, side: BattleSide, position: FieldPosition): void {
-    const piclet = this.state.activePiclets[side][position];
-    if (!piclet) return;
-
-    if (action.type === 'move') {
-      this.executeMove(action as MultiMoveAction, side, position);
-    } else if (action.type === 'switch') {
-      this.executeSwitch(action as MultiSwitchAction, side, position);
-    }
-  }
-
-  private executeMove(action: MultiMoveAction, side: BattleSide, position: FieldPosition): void {
-    const attacker = this.state.activePiclets[side][position];
-    if (!attacker) return;
-
-    const moveData = attacker.moves[action.moveIndex];
-    if (!moveData || moveData.currentPP <= 0) {
-      this.log(`${attacker.definition.name} has no PP left for that move!`);
-      return;
-    }
-
-    const move = moveData.move;
-    this.log(`${attacker.definition.name} used ${move.name}!`);
-
-    // Consume PP
-    moveData.currentPP--;
-
-    // Check if move hits (simplified for now)
-    if (!this.checkMoveHits(move, attacker)) {
-      this.log(`${attacker.definition.name}'s attack missed!`);
-      return;
-    }
-
-    // Process effects for each target
-    const targets = this.resolveTargets(move, side, position, action.targets);
-    
-    for (const effect of move.effects) {
-      this.processMultiEffect(effect, attacker, targets, move);
-    }
-  }
-
-  private executeSwitch(action: MultiSwitchAction, side: BattleSide, position: FieldPosition): void {
-    const currentPiclet = this.state.activePiclets[side][position];
-    const newPiclet = this.state.parties[side][action.partyIndex];
-    
-    if (!newPiclet) return;
-
-    // Create battle instance of new Piclet
-    const battlePiclet = this.createBattlePiclet(newPiclet, 50);
-    
-    // Switch out current Piclet (if any)
-    if (currentPiclet) {
-      this.log(`${currentPiclet.definition.name} switched out!`);
-      // Trigger switch-out abilities here
-    }
-
-    // Switch in new Piclet
-    this.state.activePiclets[side][position] = battlePiclet;
-    this.log(`${battlePiclet.definition.name} switched in!`);
-    
-    // Trigger switch-in abilities here
-    this.processAbilityTrigger(battlePiclet, 'onSwitchIn');
-  }
-
-  private resolveTargets(move: Move, attackerSide: BattleSide, attackerPosition: FieldPosition, targetOverride?: any): BattlePiclet[] {
-    const targets: BattlePiclet[] = [];
-    const attacker = this.state.activePiclets[attackerSide][attackerPosition];
-    if (!attacker) return targets;
-
-    // Check if move effects specify targets, default to opponent
-    const effectTargets = move.effects.map(e => (e as any).target).filter(t => t);
-    const primaryTarget = effectTargets[0] || 'opponent';
-
-    switch (primaryTarget) {
-      case 'self':
-        targets.push(attacker);
-        break;
-        
-      case 'opponent':
-        // Target first available opponent (can be enhanced for player choice)
-        const opponentSide = attackerSide === 'player' ? 'opponent' : 'player';
-        const opponents = this.state.activePiclets[opponentSide].filter(p => p !== null) as BattlePiclet[];
-        if (opponents.length > 0) {
-          targets.push(opponents[0]);
-        }
-        break;
-        
-      case 'allOpponents':
-        const oppSide = attackerSide === 'player' ? 'opponent' : 'player';
-        const allOpponents = this.state.activePiclets[oppSide].filter(p => p !== null) as BattlePiclet[];
-        targets.push(...allOpponents);
-        break;
-        
-      case 'ally':
-        // Target ally (for double battles)
-        const allies = this.state.activePiclets[attackerSide].filter(p => p !== null && p !== attacker) as BattlePiclet[];
-        if (allies.length > 0) {
-          targets.push(allies[0]);
-        }
-        break;
-        
-      case 'allAllies':
-        const allAllies = this.state.activePiclets[attackerSide].filter(p => p !== null && p !== attacker) as BattlePiclet[];
-        targets.push(...allAllies);
-        break;
-        
-      case 'all':
-        // Target all active Piclets
-        for (const side of ['player', 'opponent'] as BattleSide[]) {
-          const activePiclets = this.state.activePiclets[side].filter(p => p !== null) as BattlePiclet[];
-          targets.push(...activePiclets);
-        }
-        break;
-        
-      case 'random':
-        // Target random active Piclet
-        const allActive: BattlePiclet[] = [];
-        for (const side of ['player', 'opponent'] as BattleSide[]) {
-          const activePiclets = this.state.activePiclets[side].filter(p => p !== null) as BattlePiclet[];
-          allActive.push(...activePiclets);
-        }
-        if (allActive.length > 0) {
-          const randomIndex = Math.floor(Math.random() * allActive.length);
-          targets.push(allActive[randomIndex]);
-        }
-        break;
-        
-      case 'weakest':
-        // Target Piclet with lowest HP percentage
-        const allActivePiclets: BattlePiclet[] = [];
-        for (const side of ['player', 'opponent'] as BattleSide[]) {
-          const activePiclets = this.state.activePiclets[side].filter(p => p !== null) as BattlePiclet[];
-          allActivePiclets.push(...activePiclets);
-        }
-        if (allActivePiclets.length > 0) {
-          const weakest = allActivePiclets.reduce((weak, current) => 
-            (current.currentHp / current.maxHp) < (weak.currentHp / weak.maxHp) ? current : weak
-          );
-          targets.push(weakest);
-        }
-        break;
-        
-      case 'strongest':
-        // Target Piclet with highest HP percentage
-        const allActiveForStrongest: BattlePiclet[] = [];
-        for (const side of ['player', 'opponent'] as BattleSide[]) {
-          const activePiclets = this.state.activePiclets[side].filter(p => p !== null) as BattlePiclet[];
-          allActiveForStrongest.push(...activePiclets);
-        }
-        if (allActiveForStrongest.length > 0) {
-          const strongest = allActiveForStrongest.reduce((strong, current) => 
-            (current.currentHp / current.maxHp) > (strong.currentHp / strong.maxHp) ? current : strong
-          );
-          targets.push(strongest);
-        }
-        break;
-        
-      default:
-        // Fallback to first opponent
-        const defaultOpponentSide = attackerSide === 'player' ? 'opponent' : 'player';
-        const defaultOpponents = this.state.activePiclets[defaultOpponentSide].filter(p => p !== null) as BattlePiclet[];
-        if (defaultOpponents.length > 0) {
-          targets.push(defaultOpponents[0]);
-        }
-    }
-
-    return targets;
-  }
-
-  private processMultiEffect(effect: BattleEffect, attacker: BattlePiclet, targets: BattlePiclet[], move: Move): void {
-    // Process effect on each target
-    for (const target of targets) {
-      this.processEffect(effect, attacker, target, move);
-    }
-  }
-
-  private processEffect(effect: BattleEffect, attacker: BattlePiclet, target: BattlePiclet, move: Move): void {
-    // Check condition
-    if (effect.condition && !this.checkCondition(effect.condition, attacker, target)) {
-      return;
-    }
-
-    switch (effect.type) {
-      case 'damage':
-        this.processDamageEffect(effect, attacker, target, move);
-        break;
-      case 'heal':
-        this.processHealEffect(effect, target);
-        break;
-      case 'modifyStats':
-        this.processModifyStatsEffect(effect, target);
-        break;
-      case 'applyStatus':
-        this.processApplyStatusEffect(effect, target);
-        break;
-      // Add other effect types as needed
-      default:
-        this.log(`Effect ${effect.type} not implemented in multi-battle yet`);
-    }
-  }
-
-  // Simplified effect processors (can be expanded)
-  private processDamageEffect(effect: any, attacker: BattlePiclet, target: BattlePiclet, move: Move): void {
-    const damage = this.calculateDamage(attacker, target, move);
-    target.currentHp = Math.max(0, target.currentHp - damage);
-    this.log(`${target.definition.name} took ${damage} damage!`);
-  }
-
-  private processHealEffect(effect: any, target: BattlePiclet): void {
-    const healAmount = Math.floor(target.maxHp * 0.5); // Simplified
-    const oldHp = target.currentHp;
-    target.currentHp = Math.min(target.maxHp, target.currentHp + healAmount);
-    const actualHeal = target.currentHp - oldHp;
-    
-    if (actualHeal > 0) {
-      this.log(`${target.definition.name} recovered ${actualHeal} HP!`);
-    }
-  }
-
-  private processModifyStatsEffect(effect: any, target: BattlePiclet): void {
-    // Simplified stat modification
-    if (effect.stats?.attack === 'increase') {
-      target.attack = Math.floor(target.attack * 1.25);
-      this.log(`${target.definition.name}'s attack rose!`);
-    }
-  }
-
-  private processApplyStatusEffect(effect: any, target: BattlePiclet): void {
-    if (!target.statusEffects.includes(effect.status)) {
-      target.statusEffects.push(effect.status);
-      this.log(`${target.definition.name} was ${effect.status}ed!`);
-    }
-  }
-
-  private calculateDamage(attacker: BattlePiclet, target: BattlePiclet, move: Move): number {
-    // Simplified damage calculation
-    const baseDamage = move.power || 50;
-    const effectiveness = getEffectivenessMultiplier(
-      move.type,
-      target.definition.primaryType,
-      target.definition.secondaryType
-    );
-
-    let damage = Math.floor((baseDamage * (attacker.attack / target.defense) * 0.5) + 10);
-    damage = Math.floor(damage * effectiveness);
-    
-    return Math.max(1, damage);
-  }
-
-  private checkMoveHits(move: Move, attacker: BattlePiclet): boolean {
-    return Math.random() * 100 < move.accuracy;
-  }
-
-  private checkCondition(condition: string, attacker: BattlePiclet, target: BattlePiclet): boolean {
-    switch (condition) {
-      case 'always':
-        return true;
-      case 'ifLowHp':
-        return attacker.currentHp / attacker.maxHp < 0.25;
-      default:
-        return true;
-    }
-  }
-
-  private processAbilityTrigger(piclet: BattlePiclet, trigger: string): void {
-    // Process special ability triggers
-    if (piclet.definition.specialAbility.triggers) {
-      for (const abilityTrigger of piclet.definition.specialAbility.triggers) {
-        if (abilityTrigger.event === trigger) {
-          this.log(`${piclet.definition.name}'s ${piclet.definition.specialAbility.name} activated!`);
-          // Process trigger effects
-        }
-      }
-    }
-  }
-
-  private processTurnEnd(): void {
-    // Process status effects for all active Piclets
-    for (const side of ['player', 'opponent'] as BattleSide[]) {
-      for (const piclet of this.state.activePiclets[side]) {
-        if (piclet) {
-          this.processStatusEffects(piclet);
-          this.processTemporaryEffects(piclet);
-        }
-      }
-    }
-
-    // Process field effects
-    this.processFieldEffects();
-
-    // Handle fainted Piclets
-    this.handleFaintedPiclets();
-  }
-
-  private handleFaintedPiclets(): void {
-    for (const side of ['player', 'opponent'] as BattleSide[]) {
-      for (let position = 0; position < this.state.activePiclets[side].length; position++) {
-        const piclet = this.state.activePiclets[side][position];
-        if (piclet && piclet.currentHp <= 0) {
-          this.log(`${piclet.definition.name} fainted!`);
-          
-          // Remove fainted Piclet from active slot
-          this.state.activePiclets[side][position] = null;
-          
-          // Trigger faint abilities
-          this.processAbilityTrigger(piclet, 'onKO');
-          
-          // For now, we don't auto-switch reserves in this simplified implementation
-          // In a full implementation, the player would choose a replacement
-        }
-      }
-    }
-  }
-
-  private processStatusEffects(piclet: BattlePiclet): void {
-    for (const status of piclet.statusEffects) {
-      switch (status) {
-        case 'burn':
-        case 'poison':
-          const damage = Math.floor(piclet.maxHp / 8);
-          piclet.currentHp = Math.max(0, piclet.currentHp - damage);
-          this.log(`${piclet.definition.name} hurt by ${status}!`);
-          break;
-      }
-    }
-  }
-
-  private processTemporaryEffects(piclet: BattlePiclet): void {
-    piclet.temporaryEffects = piclet.temporaryEffects.filter(effect => {
-      effect.duration--;
-      return effect.duration > 0;
-    });
-  }
-
-  private processFieldEffects(): void {
-    this.state.fieldEffects = this.state.fieldEffects.filter(effect => {
-      effect.duration--;
-      if (effect.duration <= 0) {
-        this.log(`Field effect '${effect.name}' ended!`);
-        return false;
-      }
-      return true;
-    });
-  }
-
-  private checkBattleEnd(): void {
-    const winner = this.determineWinner();
-    if (winner) {
-      this.state.winner = winner;
-      this.state.phase = 'ended';
-      this.log(`Battle ended! Winner: ${winner}`);
-    }
-  }
-
-  private determineWinner(): 'player' | 'opponent' | 'draw' | null {
-    // Count living active Piclets (not null and HP > 0)
-    const playerActiveLiving = this.state.activePiclets.player.filter(p => p !== null && p.currentHp > 0);
-    const opponentActiveLiving = this.state.activePiclets.opponent.filter(p => p !== null && p.currentHp > 0);
-    
-    // Check for healthy reserves
-    const playerHealthyReserves = this.getHealthyReserves('player');
-    const opponentHealthyReserves = this.getHealthyReserves('opponent');
-    
-    const playerHasUsablePiclets = playerActiveLiving.length > 0 || playerHealthyReserves.length > 0;
-    const opponentHasUsablePiclets = opponentActiveLiving.length > 0 || opponentHealthyReserves.length > 0;
-
-    // Check victory conditions based on type
-    switch (this.victoryCondition.type) {
-      case 'allFainted':
-        if (!playerHasUsablePiclets) {
-          if (!opponentHasUsablePiclets) {
-            return 'draw';
-          }
-          return 'opponent';
-        }
-        if (!opponentHasUsablePiclets) {
-          return 'player';
-        }
-        break;
-        
-      case 'custom':
-        if (this.victoryCondition.customCheck) {
-          return this.victoryCondition.customCheck(this.state);
-        }
-        break;
-    }
-
-    return null;
-  }
-
-  private getHealthyReserves(side: BattleSide): PicletDefinition[] {
-    // Get party members that have never been used in battle
-    // We need to track which party members have been on the field
-    const usedPicletNames = new Set<string>();
-    
-    // Add currently active Piclets
-    this.state.activePiclets[side].forEach(p => {
-      if (p !== null) {
-        usedPicletNames.add(p.definition.name);
-      }
-    });
-    
-    // For a full implementation, we would also track previously active Piclets that fainted
-    // For now, we estimate by checking the initial setup - if there are more party members
-    // than active slots, the rest are reserves
-    const activeSlots = this.state.activePiclets[side].length;
-    const initialActiveCount = Math.min(this.state.parties[side].length, activeSlots);
-    
-    // Mark the first N party members as "used" (they were initially active)
-    for (let i = 0; i < initialActiveCount; i++) {
-      if (this.state.parties[side][i]) {
-        usedPicletNames.add(this.state.parties[side][i].name);
-      }
-    }
-    
-    return this.state.parties[side].filter(partyMember => 
-      !usedPicletNames.has(partyMember.name)
-    );
-  }
-
-  private logActivePiclets(): void {
-    const playerActives = this.state.activePiclets.player.filter(p => p !== null) as BattlePiclet[];
-    const opponentActives = this.state.activePiclets.opponent.filter(p => p !== null) as BattlePiclet[];
-    
-    this.log(`Player active: ${playerActives.map(p => p.definition.name).join(', ')}`);
-    this.log(`Opponent active: ${opponentActives.map(p => p.definition.name).join(', ')}`);
-  }
-
-  private log(message: string): void {
-    this.state.log.push(message);
-  }
-
-  public getLog(): string[] {
-    // Strip battle prefixes from all log messages for display
-    return this.state.log.map(message => this.stripBattlePrefixes(message));
-  }
-  
-  private stripBattlePrefixes(message: string): string {
-    // Remove player- and enemy- prefixes from messages
-    return message
-      .replace(/player-/g, '')
-      .replace(/enemy-/g, '');
-  }
-}

src/lib/battle-engine/README.md

@@ -1,232 +0,0 @@
-# Pictuary Battle Engine
-
-A standalone, testable battle system for the Pictuary game, implementing the battle mechanics defined in `battle_system_design.md`.
-
-## Overview
-
-This battle engine provides a complete turn-based combat system implementing EVERYTHING from `battle_system_design.md`:
-
-- **Type effectiveness** based on Pictuary's photography-themed types (Beast, Bug, Aquatic, Flora, Mineral, Space, Machina, Structure, Culture, Cuisine)
-- **Composable effects system** with 10 different effect types
-- **Advanced damage formulas** (standard, recoil, drain, fixed, percentage)
-- **Mechanic override system** for special abilities that modify core game mechanics
-- **Trigger-based special abilities** with 18 different trigger events
-- **Status effects** with chance-based application and turn-end processing
-- **Field effects** with stackable/non-stackable variants
-- **PP manipulation** system (drain, restore, disable)
-- **Counter moves** and priority modification
-- **Conditional effects** with 25+ different conditions
-- **Extreme risk-reward moves** as defined in the design document
-- **Comprehensive test coverage** (116 tests across 7 test files)
-
-## Architecture
-
-### Core Components
-
-- **`BattleEngine.ts`** - Main battle orchestration and logic
-- **`types.ts`** - Type definitions for all battle system interfaces
-- **`test-data.ts`** - Example Piclets and moves for testing
-- **`*.test.ts`** - Comprehensive test suites
-
-### Key Features
-
-1. **Battle State Management**
-   - Turn-based execution with proper phase handling
-   - Action priority system (priority → speed → random)
-   - Win condition checking and battle end logic
-   - Field effects tracking and processing
-
-2. **Advanced Damage System**
-   - **Standard damage**: Traditional attack vs defense calculation with type effectiveness and STAB
-   - **Recoil damage**: Self-harm after dealing damage (e.g., 25% recoil)
-   - **Drain damage**: Heal user for portion of damage dealt (e.g., 50% drain)
-   - **Fixed damage**: Exact damage amounts regardless of stats
-   - **Percentage damage**: Damage based on target's max HP percentage
-   - Type effectiveness calculations with dual-type support
-   - STAB (Same Type Attack Bonus)
-   - Accuracy checks with move-specific accuracy values
-
-3. **Comprehensive Effect System**
-   - **damage**: 5 different damage formulas with conditional scaling
-   - **modifyStats**: Stat changes (increase/decrease/greatly_increase/greatly_decrease)
-   - **applyStatus**: Status effects with configurable chance percentages
-   - **heal**: Healing with amounts (small/medium/large/full) or percentage/fixed formulas
-   - **manipulatePP**: PP drain, restore, or disable targeting specific moves
-   - **fieldEffect**: Battlefield modifications affecting all combatants
-   - **counter**: Delayed damage reflection based on incoming attack types
-   - **priority**: Dynamic priority modification for moves
-   - **removeStatus**: Cure specific status conditions
-   - **mechanicOverride**: Fundamental game mechanic modifications
-
-4. **Status Effects**
-   - **Poison/Burn**: Turn-end damage (1/8 max HP)
-   - **Paralysis/Sleep/Freeze**: Action prevention
-   - **Confusion**: Self-targeting chance
-   - **Chance-based application**: Configurable success rates (e.g., 30% freeze chance)
-   - **Status immunity**: Abilities can grant immunity to specific statuses
-   - **Status removal**: Moves and abilities can cure conditions
-
-5. **Special Ability System**
-   - **18 Trigger Events**: onDamageTaken, onSwitchIn, endOfTurn, onLowHP, etc.
-   - **Conditional triggers**: Abilities activate based on HP thresholds, weather, status
-   - **Multiple effects per trigger**: Complex abilities with layered effects
-   - **Mechanic overrides**: Abilities that fundamentally change game rules
-
-6. **Field Effects**
-   - **Global effects**: Affect entire battlefield
-   - **Side effects**: Affect one player's side only
-   - **Stackable/Non-stackable**: Configurable effect layering
-   - **Duration tracking**: Effects expire after set number of turns
-
-7. **Move Flags System**
-   - **Combat flags**: contact, bite, punch, sound, explosive, draining, ground
-   - **Priority flags**: priority, lowPriority
-   - **Mechanic flags**: charging, recharge, multiHit, twoTurn, sacrifice, gambling
-   - **Interaction flags**: reflectable, snatchable, copyable, protectable, bypassProtect
-   - **Flag immunity/weakness**: Abilities can modify interactions with flagged moves
-
-## Usage
-
-### Basic Battle Setup
-
-```typescript
-import { BattleEngine } from './BattleEngine';
-import { STELLAR_WOLF, TOXIC_CRAWLER } from './test-data';
-
-// Create a new battle
-const battle = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-
-// Execute a turn
-const playerAction = { type: 'move', piclet: 'player', moveIndex: 0 };
-const opponentAction = { type: 'move', piclet: 'opponent', moveIndex: 1 };
-
-battle.executeActions(playerAction, opponentAction);
-
-// Check battle state
-console.log(battle.getState());
-console.log(battle.getLog());
-console.log(battle.isGameOver(), battle.getWinner());
-```
-
-### Creating Custom Piclets
-
-```typescript
-import { PicletDefinition, Move, PicletType, AttackType } from './types';
-
-const customMove: Move = {
-  name: "Thunder Strike",
-  type: AttackType.SPACE,
-  power: 80,
-  accuracy: 90,
-  pp: 10,
-  priority: 0,
-  flags: ['explosive'],
-  effects: [
-    {
-      type: 'damage',
-      target: 'opponent',
-      amount: 'strong'
-    },
-    {
-      type: 'applyStatus',
-      target: 'opponent',
-      status: 'paralyze',
-      condition: 'ifLucky50'
-    }
-  ]
-};
-
-const customPiclet: PicletDefinition = {
-  name: "Storm Guardian",
-  description: "A cosmic entity that commands lightning",
-  tier: 'high',
-  primaryType: PicletType.SPACE,
-  baseStats: { hp: 120, attack: 100, defense: 90, speed: 85 },
-  nature: "Bold",
-  specialAbility: {
-    name: "Lightning Rod",
-    description: "Draws electric attacks and boosts power"
-  },
-  movepool: [customMove, /* other moves */]
-};
-```
-
-## Testing
-
-The battle engine includes comprehensive test coverage:
-
-```bash
-# Run all battle engine tests
-npm test src/lib/battle-engine/
-
-# Run specific test file
-npm test src/lib/battle-engine/BattleEngine.test.ts
-
-# Run with UI
-npm run test:ui
-```
-
-### Test Categories
-
-- **Unit Tests** (`BattleEngine.test.ts`)
-  - Battle initialization
-  - Basic battle flow
-  - Damage calculations
-  - Status effects
-  - Stat modifications
-  - Healing effects
-  - Conditional effects
-  - Battle end conditions
-  - Move accuracy
-  - Action priority
-
-- **Integration Tests** (`integration.test.ts`)
-  - Complete battle scenarios
-  - Multi-turn battles with complex interactions
-  - Performance and stability tests
-  - Edge cases
-
-## Design Principles
-
-Following the battle system design document:
-
-1. **Simple JSON Schema** - Moves are defined with conceptual effect levels (weak/normal/strong/extreme) rather than specific numeric values
-2. **Composable Effects** - Multiple effects per move with conditional triggers
-3. **Bold and Dramatic** - Effects can be powerful with interesting tradeoffs
-4. **Type-Driven** - Photography-themed types with meaningful interactions
-5. **Special Abilities** - Passive traits that transform gameplay
-
-## Integration with Main App
-
-This module is designed to be eventually imported into the main Svelte app:
-
-```typescript
-// In Battle.svelte
-import { BattleEngine } from '$lib/battle-engine/BattleEngine';
-import type { PicletDefinition } from '$lib/battle-engine/types';
-
-// Convert PicletInstance to PicletDefinition format
-// Initialize battle engine
-// Replace existing battle logic
-```
-
-## Future Enhancements
-
-Planned features following the design document:
-
-- [ ] Special ability trigger system
-- [ ] Field effects and weather
-- [ ] Counter moves and priority manipulation
-- [ ] PP manipulation effects
-- [ ] Multi-target moves
-- [ ] Switch actions and party management
-- [ ] Critical hit calculations
-- [ ] More complex conditional effects
-- [ ] Battle replay system
-
-## Performance Notes
-
-- Battle state is immutable (deep-cloned on `getState()`)
-- Efficient type effectiveness lookup using enums
-- Minimal memory allocation during battle execution
-- Tested for battles up to 100+ turns without performance issues

src/lib/battle-engine/ability-triggers.test.ts

@@ -1,388 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Special Ability Triggers System', () => {
-  let basicPiclet: PicletDefinition;
-  let abilityPiclet: PicletDefinition;
-
-  beforeEach(() => {
-    // Basic piclet without special abilities
-    basicPiclet = {
-      name: "Basic Fighter",
-      description: "Standard test piclet",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 60, defense: 60, speed: 60 },
-      nature: "Hardy",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Basic Attack",
-          type: AttackType.BEAST,
-          power: 50,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    // Piclet with special abilities for testing
-    abilityPiclet = {
-      name: "Ability User",
-      description: "Has special abilities",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 100, attack: 70, defense: 70, speed: 50 },
-      nature: "Bold",
-      specialAbility: {
-        name: "Test Ability",
-        description: "Triggers on various events",
-        triggers: [
-          {
-            event: 'onDamageTaken',
-            condition: 'always',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: {
-                  attack: 'increase'
-                }
-              }
-            ]
-          }
-        ]
-      },
-      movepool: [
-        {
-          name: "Power Strike",
-          type: AttackType.BEAST,
-          power: 60,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-  });
-
-  describe('onDamageTaken Trigger', () => {
-    it('should trigger when piclet takes damage', () => {
-      const engine = new BattleEngine(abilityPiclet, basicPiclet);
-      const initialAttack = engine.getState().playerPiclet.attack;
-
-      // Opponent attacks, should trigger onDamageTaken
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // This should damage player and trigger ability
-      );
-
-      const finalAttack = engine.getState().playerPiclet.attack;
-      const log = engine.getLog();
-
-      // Attack should have increased due to ability trigger
-      expect(finalAttack).toBeGreaterThan(initialAttack);
-      expect(log.some(msg => msg.includes('Test Ability') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('endOfTurn Trigger', () => {
-    it('should trigger at the end of every turn', () => {
-      const endTurnAbility: PicletDefinition = {
-        ...abilityPiclet,
-        specialAbility: {
-          name: "Regeneration",
-          description: "Heals at end of turn",
-          triggers: [
-            {
-              event: 'endOfTurn',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'heal',
-                  target: 'self',
-                  amount: 'small'
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(endTurnAbility, basicPiclet);
-      
-      // Damage the piclet first so healing is visible, but not too much
-      engine['state'].playerPiclet.currentHp = Math.floor(engine['state'].playerPiclet.maxHp * 0.9);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      console.log('Regeneration test log:', log);
-      console.log('Initial HP:', initialHp, 'Final HP:', engine.getState().playerPiclet.currentHp);
-
-      // The ability should trigger (check log message)
-      expect(log.some(msg => msg.includes('Regeneration') && msg.includes('triggered'))).toBe(true);
-      
-      // HP might decrease due to damage taken, but healing should have occurred
-      expect(log.some(msg => msg.includes('recovered') || msg.includes('healed'))).toBe(true);
-    });
-  });
-
-  describe('onDamageDealt Trigger', () => {
-    it('should trigger when piclet deals damage to opponent', () => {
-      const damageDealer: PicletDefinition = {
-        ...abilityPiclet,
-        specialAbility: {
-          name: "Combat High",
-          description: "Gains speed when dealing damage",
-          triggers: [
-            {
-              event: 'onDamageDealt',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: {
-                    speed: 'increase'
-                  }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(damageDealer, basicPiclet);
-      const initialSpeed = engine.getState().playerPiclet.speed;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Player deals damage
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalSpeed = engine.getState().playerPiclet.speed;
-      const log = engine.getLog();
-
-      expect(finalSpeed).toBeGreaterThan(initialSpeed);
-      expect(log.some(msg => msg.includes('Combat High') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('onCriticalHit Trigger', () => {
-    it('should trigger when dealing a critical hit', () => {
-      const criticalHitter: PicletDefinition = {
-        ...abilityPiclet,
-        specialAbility: {
-          name: "Critical Momentum",
-          description: "Gains attack on critical hits",
-          triggers: [
-            {
-              event: 'onCriticalHit',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: {
-                    attack: 'increase'
-                  }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(criticalHitter, basicPiclet);
-      
-      // Force a critical hit for testing
-      const originalRandom = Math.random;
-      Math.random = () => 0.01; // Force critical hit (< 0.0625)
-
-      const initialAttack = engine.getState().playerPiclet.attack;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Should crit and trigger ability
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      // Restore original Math.random
-      Math.random = originalRandom;
-
-      const finalAttack = engine.getState().playerPiclet.attack;
-      const log = engine.getLog();
-
-      expect(log.some(msg => msg.includes('A critical hit!'))).toBe(true);
-      expect(finalAttack).toBeGreaterThan(initialAttack);
-      expect(log.some(msg => msg.includes('Critical Momentum') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('onContactDamage Trigger', () => {
-    it('should trigger only when hit by contact moves', () => {
-      const contactSensitive: PicletDefinition = {
-        ...abilityPiclet,
-        specialAbility: {
-          name: "Spiky Skin",
-          description: "Hurts attackers that make contact",
-          triggers: [
-            {
-              event: 'onContactDamage',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'damage',
-                  target: 'opponent',
-                  amount: 'small'
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(contactSensitive, basicPiclet);
-      const initialOpponentHp = engine.getState().opponentPiclet.currentHp;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Contact move should trigger Spiky Skin
-      );
-
-      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
-      const log = engine.getLog();
-
-      // Opponent should take extra damage from Spiky Skin
-      expect(log.some(msg => msg.includes('Spiky Skin') && msg.includes('triggered'))).toBe(true);
-      
-      // The opponent should have taken damage from both the regular attack and the ability
-      expect(finalOpponentHp).toBeLessThan(initialOpponentHp);
-    });
-  });
-
-  describe('Conditional Triggers', () => {
-    it('should respect ifLowHp condition', () => {
-      const conditionalAbility: PicletDefinition = {
-        ...abilityPiclet,
-        specialAbility: {
-          name: "Desperation",
-          description: "Only triggers when HP is low",
-          triggers: [
-            {
-              event: 'onDamageTaken',
-              condition: 'ifLowHp',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: {
-                    attack: 'greatly_increase'
-                  }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(conditionalAbility, basicPiclet);
-      const initialAttack = engine.getState().playerPiclet.attack;
-
-      // At high HP, condition should not be met
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const midAttack = engine.getState().playerPiclet.attack;
-      expect(midAttack).toBe(initialAttack); // No trigger due to condition
-
-      // Create a new engine for the low HP test
-      const lowHpEngine = new BattleEngine(conditionalAbility, basicPiclet);
-      
-      // Set HP low and trigger the ability
-      lowHpEngine['state'].playerPiclet.currentHp = Math.floor(lowHpEngine['state'].playerPiclet.maxHp * 0.15);
-
-      lowHpEngine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalAttack = lowHpEngine.getState().playerPiclet.attack;
-      const log = lowHpEngine.getLog();
-
-      expect(finalAttack).toBeGreaterThan(initialAttack);
-      expect(log.some(msg => msg.includes('Desperation') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('Multiple Triggers on Same Ability', () => {
-    it('should handle multiple triggers on the same ability', () => {
-      const multiTriggerAbility: PicletDefinition = {
-        ...abilityPiclet,
-        specialAbility: {
-          name: "Adaptive Fighter",
-          description: "Multiple trigger conditions",
-          triggers: [
-            {
-              event: 'onDamageTaken',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: {
-                    defense: 'increase'
-                  }
-                }
-              ]
-            },
-            {
-              event: 'onDamageDealt',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: {
-                    attack: 'increase'
-                  }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(multiTriggerAbility, basicPiclet);
-      const initialAttack = engine.getState().playerPiclet.attack;
-      const initialDefense = engine.getState().playerPiclet.defense;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Should trigger onDamageDealt
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Should trigger onDamageTaken
-      );
-
-      const finalAttack = engine.getState().playerPiclet.attack;
-      const finalDefense = engine.getState().playerPiclet.defense;
-      const log = engine.getLog();
-
-      // Both stats should increase
-      expect(finalAttack).toBeGreaterThan(initialAttack);
-      expect(finalDefense).toBeGreaterThan(initialDefense);
-      expect(log.some(msg => msg.includes('Adaptive Fighter') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-});

src/lib/battle-engine/advanced-effects.test.ts

@@ -1,613 +0,0 @@
-/**
- * Tests for advanced battle effects from the design document
- * Covers all missing functionality that needs to be implemented
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import { PicletDefinition, Move, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-// Test data for advanced effects
-const STANDARD_STATS = { hp: 100, attack: 80, defense: 70, speed: 60 };
-
-describe('Advanced Battle Effects - TDD Implementation', () => {
-  describe('Damage Formula System', () => {
-    it('should handle recoil damage moves', () => {
-      const recoilMove: Move = {
-        name: "Reckless Dive",
-        type: AttackType.SPACE,
-        power: 120,
-        accuracy: 100,
-        pp: 5,
-        priority: 0,
-        flags: ['contact', 'reckless'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'strong'
-          },
-          {
-            type: 'damage',
-            target: 'self',
-            formula: 'recoil',
-            value: 0.25
-          }
-        ]
-      };
-
-      const testPiclet: PicletDefinition = {
-        name: "Recoil Tester",
-        description: "Tests recoil moves",
-        tier: 'medium',
-        primaryType: PicletType.SPACE,
-        baseStats: STANDARD_STATS,
-        nature: "Bold",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [recoilMove]
-      };
-
-      const targetPiclet: PicletDefinition = {
-        name: "Target",
-        description: "Target dummy",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: STANDARD_STATS,
-        nature: "Hardy",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      const engine = new BattleEngine(testPiclet, targetPiclet);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      expect(finalHp).toBeLessThan(initialHp); // Should have taken recoil damage
-    });
-
-    it('should handle drain damage moves', () => {
-      const drainMove: Move = {
-        name: "Spectral Drain",
-        type: AttackType.CULTURE,
-        power: 60,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: ['draining'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            formula: 'drain',
-            value: 0.5
-          }
-        ]
-      };
-
-      const testPiclet: PicletDefinition = {
-        name: "Drain Tester",
-        description: "Tests drain moves",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: STANDARD_STATS,
-        nature: "Bold",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [drainMove]
-      };
-
-      const targetPiclet: PicletDefinition = {
-        name: "Target",
-        description: "Target dummy",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: STANDARD_STATS,
-        nature: "Hardy",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      const engine = new BattleEngine(testPiclet, targetPiclet);
-      
-      // Damage the user first to test healing
-      engine['state'].playerPiclet.currentHp = 50;
-      const initialHp = engine.getState().playerPiclet.currentHp;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      const hasHealingMessage = log.some(msg => msg.includes('recovered') && msg.includes('HP from draining'));
-      expect(hasHealingMessage).toBe(true); // Should have healed from drain
-    });
-
-    it('should handle fixed damage moves', () => {
-      const fixedMove: Move = {
-        name: "Fixed Strike",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            formula: 'fixed',
-            value: 50
-          }
-        ]
-      };
-
-      // Test implementation would verify exactly 50 damage dealt
-      expect(fixedMove.effects[0].formula).toBe('fixed');
-      expect(fixedMove.effects[0].value).toBe(50);
-    });
-
-    it('should handle percentage damage moves', () => {
-      const percentMove: Move = {
-        name: "Percentage Strike",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 5,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            formula: 'percentage',
-            value: 25 // 25% of target's max HP
-          }
-        ]
-      };
-
-      // Test implementation would verify percentage-based damage
-      expect(percentMove.effects[0].formula).toBe('percentage');
-      expect(percentMove.effects[0].value).toBe(25);
-    });
-  });
-
-  describe('PP Manipulation System', () => {
-    it('should handle PP drain moves', () => {
-      const ppDrainMove: Move = {
-        name: "Mind Drain",
-        type: AttackType.CULTURE,
-        power: 40,
-        accuracy: 100,
-        pp: 15,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'normal'
-          },
-          {
-            type: 'manipulatePP',
-            target: 'opponent',
-            action: 'drain',
-            amount: 'medium'
-          }
-        ]
-      };
-
-      // Test would verify PP is drained from opponent's moves
-      expect(ppDrainMove.effects[1].type).toBe('manipulatePP');
-      expect(ppDrainMove.effects[1].action).toBe('drain');
-    });
-
-    it('should handle PP restore moves', () => {
-      const ppRestoreMove: Move = {
-        name: "Restore Energy",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 5,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'manipulatePP',
-            target: 'self',
-            action: 'restore',
-            amount: 'large'
-          }
-        ]
-      };
-
-      // Test would verify PP is restored to self
-      expect(ppRestoreMove.effects[0].type).toBe('manipulatePP');
-      expect(ppRestoreMove.effects[0].action).toBe('restore');
-    });
-
-    it('should handle specific PP manipulation', () => {
-      const specificPPMove: Move = {
-        name: "Soul Burn",
-        type: AttackType.SPACE,
-        power: 150,
-        accuracy: 90,
-        pp: 5,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'extreme'
-          },
-          {
-            type: 'manipulatePP',
-            target: 'self',
-            action: 'drain',
-            value: 3,
-            targetMove: 'random',
-            condition: 'afterUse'
-          }
-        ]
-      };
-
-      // Test would verify specific PP amounts are drained
-      expect(specificPPMove.effects[1].value).toBe(3);
-      expect(specificPPMove.effects[1].targetMove).toBe('random');
-    });
-  });
-
-  describe('Field Effects System', () => {
-    it('should handle field-wide effects', () => {
-      const fieldMove: Move = {
-        name: "Void Storm",
-        type: AttackType.SPACE,
-        power: 0,
-        accuracy: 100,
-        pp: 5,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'fieldEffect',
-            effect: 'voidStorm',
-            target: 'field',
-            stackable: false
-          }
-        ]
-      };
-
-      // Test would verify field effects are applied and tracked
-      expect(fieldMove.effects[0].type).toBe('fieldEffect');
-      expect(fieldMove.effects[0].target).toBe('field');
-    });
-
-    it('should handle side-specific effects', () => {
-      const sideMove: Move = {
-        name: "Healing Mist",
-        type: AttackType.FLORA,
-        power: 0,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'fieldEffect',
-            effect: 'healingMist',
-            target: 'playerSide',
-            stackable: true
-          }
-        ]
-      };
-
-      // Test would verify side effects work correctly
-      expect(sideMove.effects[0].target).toBe('playerSide');
-      expect(sideMove.effects[0].stackable).toBe(true);
-    });
-  });
-
-  describe('Counter Move System', () => {
-    it('should handle physical counter moves', () => {
-      const counterMove: Move = {
-        name: "Counter Strike",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 20,
-        priority: -5,
-        flags: ['lowPriority'],
-        effects: [
-          {
-            type: 'counter',
-            strength: 'strong'
-          }
-        ]
-      };
-
-      // Test would verify counter moves work against any attacks
-      expect(counterMove.effects[0].type).toBe('counter');
-      expect(counterMove.effects[0].strength).toBe('strong');
-    });
-
-    it('should handle special counter moves', () => {
-      const specialCounterMove: Move = {
-        name: "Mirror Coat",
-        type: AttackType.CULTURE,
-        power: 0,
-        accuracy: 100,
-        pp: 20,
-        priority: -5,
-        flags: ['lowPriority'],
-        effects: [
-          {
-            type: 'counter',
-            strength: 'strong'
-          }
-        ]
-      };
-
-      expect(specialCounterMove.effects[0].strength).toBe('strong');
-    });
-  });
-
-  describe('Priority Manipulation', () => {
-    it('should handle priority-changing effects', () => {
-      const priorityMove: Move = {
-        name: "Quick Strike",
-        type: AttackType.NORMAL,
-        power: 40,
-        accuracy: 100,
-        pp: 30,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'weak'
-          },
-          {
-            type: 'priority',
-            target: 'self',
-            value: 1,
-            condition: 'ifLowHp'
-          }
-        ]
-      };
-
-      // Test would verify priority changes based on conditions
-      expect(priorityMove.effects[1].type).toBe('priority');
-      expect(priorityMove.effects[1].value).toBe(1);
-    });
-  });
-
-  describe('Status Chance System', () => {
-    it('should handle status moves with specific chances', () => {
-      const chanceStatusMove: Move = {
-        name: "Thunder Wave",
-        type: AttackType.SPACE,
-        power: 0,
-        accuracy: 90,
-        pp: 20,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'applyStatus',
-            target: 'opponent',
-            status: 'paralyze',
-            chance: 100
-          }
-        ]
-      };
-
-      expect(chanceStatusMove.effects[0].chance).toBe(100);
-    });
-
-    it('should handle partial chance status effects', () => {
-      const partialChanceMove: Move = {
-        name: "Ice Touch",
-        type: AttackType.MINERAL,
-        power: 60,
-        accuracy: 100,
-        pp: 20,
-        priority: 0,
-        flags: ['contact'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'normal'
-          },
-          {
-            type: 'applyStatus',
-            target: 'opponent',
-            status: 'freeze',
-            chance: 30
-          }
-        ]
-      };
-
-      expect(partialChanceMove.effects[1].chance).toBe(30);
-    });
-  });
-
-  describe('Percentage-based Healing', () => {
-    it('should handle percentage healing moves', () => {
-      const percentHealMove: Move = {
-        name: "Recovery",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'heal',
-            target: 'self',
-            formula: 'percentage',
-            value: 50 // 50% of max HP
-          }
-        ]
-      };
-
-      expect(percentHealMove.effects[0].formula).toBe('percentage');
-      expect(percentHealMove.effects[0].value).toBe(50);
-    });
-
-    it('should handle fixed healing moves', () => {
-      const fixedHealMove: Move = {
-        name: "First Aid",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 15,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'heal',
-            target: 'self',
-            formula: 'fixed',
-            value: 25 // Heal exactly 25 HP
-          }
-        ]
-      };
-
-      expect(fixedHealMove.effects[0].formula).toBe('fixed');
-      expect(fixedHealMove.effects[0].value).toBe(25);
-    });
-  });
-
-  describe('Extended Condition System', () => {
-    it('should handle type-specific conditions', () => {
-      const typeConditionMove: Move = {
-        name: "Flora Boost",
-        type: AttackType.FLORA,
-        power: 60,
-        accuracy: 100,
-        pp: 15,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'normal'
-          },
-          {
-            type: 'modifyStats',
-            target: 'self',
-            stats: { attack: 'increase' },
-            condition: 'ifMoveType:flora'
-          }
-        ]
-      };
-
-      expect(typeConditionMove.effects[1].condition).toBe('ifMoveType:flora');
-    });
-
-    it('should handle status-specific conditions', () => {
-      const statusConditionMove: Move = {
-        name: "Burn Power",
-        type: AttackType.SPACE,
-        power: 80,
-        accuracy: 100,
-        pp: 10,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'strong',
-            condition: 'ifStatus:burn'
-          }
-        ]
-      };
-
-      expect(statusConditionMove.effects[0].condition).toBe('ifStatus:burn');
-    });
-
-    it('should handle weather-specific conditions', () => {
-      const weatherConditionMove: Move = {
-        name: "Storm Strike",
-        type: AttackType.SPACE,
-        power: 70,
-        accuracy: 95,
-        pp: 15,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'strong',
-            condition: 'ifWeather:storm'
-          }
-        ]
-      };
-
-      expect(weatherConditionMove.effects[0].condition).toBe('ifWeather:storm');
-    });
-  });
-
-  describe('Remove Status Effects', () => {
-    it('should handle status removal moves', () => {
-      const removeStatusMove: Move = {
-        name: "Cleanse",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 15,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'removeStatus',
-            target: 'self',
-            status: 'poison'
-          }
-        ]
-      };
-
-      expect(removeStatusMove.effects[0].type).toBe('removeStatus');
-      expect(removeStatusMove.effects[0].status).toBe('poison');
-    });
-
-    it('should handle multi-target status removal', () => {
-      const teamCleanseMove: Move = {
-        name: "Team Cleanse",
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 5,
-        priority: 0,
-        flags: [],
-        effects: [
-          {
-            type: 'removeStatus',
-            target: 'allies',
-            status: 'confuse'
-          }
-        ]
-      };
-
-      expect(teamCleanseMove.effects[0].target).toBe('allies');
-    });
-  });
-});

src/lib/battle-engine/advanced-mechanic-overrides.test.ts

@@ -1,348 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Advanced Mechanic Override System', () => {
-  describe('Critical Hit Mechanics', () => {
-    it('should prevent critical hits with Shell Armor ability', () => {
-      const shellArmor: SpecialAbility = {
-        name: "Shell Armor",
-        description: "Hard shell prevents critical hits",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'criticalHits',
-            condition: 'always',
-            value: false
-          }
-        ]
-      };
-
-      const defender: PicletDefinition = {
-        name: "Shell Defender",
-        description: "Protected by hard shell",
-        tier: 'medium',
-        primaryType: PicletType.MINERAL,
-        baseStats: { hp: 80, attack: 60, defense: 80, speed: 40 },
-        nature: "Impish",
-        specialAbility: shellArmor,
-        movepool: [
-          {
-            name: "Defense Curl",
-            type: AttackType.NORMAL,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { defense: 'increase' }
-              }
-            ]
-          }
-        ]
-      };
-
-      const attacker: PicletDefinition = {
-        name: "High Crit Attacker",
-        description: "Has high critical hit rate",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 70, attack: 90, defense: 50, speed: 80 },
-        nature: "Adamant",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Slash",
-            type: AttackType.BEAST,
-            power: 70,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(defender, attacker);
-      
-      // Force high crit rate for testing
-      const originalCritRate = (engine as any).calculateCriticalChance;
-      (engine as any).calculateCriticalChance = () => 1.0; // 100% crit rate normally
-      
-      let criticalHitOccurred = false;
-      for (let i = 0; i < 10; i++) {
-        const initialHp = engine.getState().playerPiclet.currentHp;
-        
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-
-        const log = engine.getLog();
-        if (log.some(msg => msg.includes('critical') || msg.includes('Critical'))) {
-          criticalHitOccurred = true;
-          break;
-        }
-        
-        if (engine.isGameOver()) break;
-      }
-      
-      // Shell Armor should prevent ALL critical hits
-      expect(criticalHitOccurred).toBe(false);
-      
-      // Restore original function
-      (engine as any).calculateCriticalChance = originalCritRate;
-    });
-
-    it('should guarantee critical hits with certain abilities', () => {
-      const alwaysCrit: SpecialAbility = {
-        name: "Super Luck",
-        description: "Always lands critical hits",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'criticalHits',
-            condition: 'always',
-            value: true
-          }
-        ]
-      };
-
-      const critUser: PicletDefinition = {
-        name: "Lucky Fighter",
-        description: "Always gets critical hits",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 70, attack: 80, defense: 60, speed: 90 },
-        nature: "Hasty",
-        specialAbility: alwaysCrit,
-        movepool: [
-          {
-            name: "Strike",
-            type: AttackType.BEAST,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(critUser, opponent);
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('critical') || msg.includes('Critical'))).toBe(true);
-    });
-  });
-
-  describe('Status Immunity', () => {
-    it('should provide immunity to specific status effects', () => {
-      const insomnia: SpecialAbility = {
-        name: "Insomnia",
-        description: "Prevents sleep status",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'statusImmunity',
-            value: ['sleep']
-          }
-        ]
-      };
-
-      const insomniac: PicletDefinition = {
-        name: "Sleepless Fighter",
-        description: "Cannot be put to sleep",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: { hp: 70, attack: 60, defense: 60, speed: 80 },
-        nature: "Timid",
-        specialAbility: insomnia,
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const sleepUser: PicletDefinition = {
-        name: "Sleep Inducer",
-        description: "Puts opponents to sleep",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: { hp: 80, attack: 50, defense: 70, speed: 60 },
-        nature: "Calm",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Sleep Powder",
-            type: AttackType.FLORA,
-            power: 0,
-            accuracy: 75,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'applyStatus',
-                target: 'opponent',
-                status: 'sleep'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(insomniac, sleepUser);
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('immune') || msg.includes('had no effect'))).toBe(true);
-      expect(log.some(msg => msg.includes('fell asleep'))).toBe(false);
-    });
-  });
-
-  describe('Type Immunity', () => {
-    it('should provide immunity to specific attack types', () => {
-      const levitate: SpecialAbility = {
-        name: "Levitate",
-        description: "Floating ability makes ground moves miss",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'typeImmunity',
-            value: ['ground']
-          }
-        ]
-      };
-
-      const levitator: PicletDefinition = {
-        name: "Floating Fighter",
-        description: "Levitates above ground attacks",
-        tier: 'medium',
-        primaryType: PicletType.SPACE,
-        baseStats: { hp: 75, attack: 70, defense: 60, speed: 85 },
-        nature: "Timid",
-        specialAbility: levitate,
-        movepool: [
-          {
-            name: "Air Slash",
-            type: AttackType.SPACE,
-            power: 60,
-            accuracy: 95,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const groundUser: PicletDefinition = {
-        name: "Ground Attacker",
-        description: "Uses ground-based attacks",
-        tier: 'medium',
-        primaryType: PicletType.MINERAL,
-        baseStats: { hp: 80, attack: 80, defense: 70, speed: 60 },
-        nature: "Adamant",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Earthquake",
-            type: AttackType.MINERAL,
-            power: 100,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['ground'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'strong'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(levitator, groundUser);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      const log = engine.getLog();
-      
-      // Ground move should have no effect due to Levitate
-      expect(finalHp).toBe(initialHp);
-      expect(log.some(msg => msg.includes('had no effect') || msg.includes('immune'))).toBe(true);
-    });
-  });
-});

src/lib/battle-engine/advanced-status-effects.test.ts

@@ -1,369 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Advanced Status Effects System', () => {
-  let basicPiclet: PicletDefinition;
-  let statusInflicter: PicletDefinition;
-
-  beforeEach(() => {
-    // Basic piclet without special abilities
-    basicPiclet = {
-      name: "Basic Fighter",
-      description: "Standard test piclet",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 60, defense: 60, speed: 60 },
-      nature: "Hardy",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Basic Attack",
-          type: AttackType.BEAST,
-          power: 50,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    // Piclet that can inflict status effects
-    statusInflicter = {
-      name: "Status Master",
-      description: "Can inflict various status effects",
-      tier: 'medium',
-      primaryType: PicletType.CULTURE,
-      baseStats: { hp: 90, attack: 50, defense: 70, speed: 80 },
-      nature: "Timid",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Freeze Ray",
-          type: AttackType.AQUATIC,
-          power: 40,
-          accuracy: 90,
-          pp: 15,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'damage', target: 'opponent', amount: 'normal' },
-            { type: 'applyStatus', target: 'opponent', status: 'freeze', chance: 30 }
-          ]
-        },
-        {
-          name: "Paralyzing Shock",
-          type: AttackType.MACHINA,
-          power: 45,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'damage', target: 'opponent', amount: 'normal' },
-            { type: 'applyStatus', target: 'opponent', status: 'paralyze', chance: 25 }
-          ]
-        },
-        {
-          name: "Sleep Powder",
-          type: AttackType.FLORA,
-          power: 0,
-          accuracy: 85,
-          pp: 15,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'applyStatus', target: 'opponent', status: 'sleep', chance: 100 }
-          ]
-        },
-        {
-          name: "Confuse Ray",
-          type: AttackType.SPACE,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'applyStatus', target: 'opponent', status: 'confuse', chance: 100 }
-          ]
-        }
-      ]
-    };
-  });
-
-  describe('Freeze Status Effect', () => {
-    it('should prevent the frozen piclet from acting', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      // Force freeze to trigger by mocking Math.random
-      const originalRandom = Math.random;
-      Math.random = () => 0.1; // 10% < 30% chance, should trigger freeze
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Freeze Ray
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Should be prevented if frozen
-      );
-
-      // Restore Math.random
-      Math.random = originalRandom;
-
-      const log = engine.getLog();
-      const opponentState = engine.getState().opponentPiclet;
-
-      // Check that freeze was applied
-      expect(opponentState.statusEffects).toContain('freeze');
-      expect(log.some(msg => msg.includes('was frozen'))).toBe(true);
-
-      // Execute another turn to test freeze preventing action
-      if (!engine.isGameOver()) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-
-        const secondTurnLog = engine.getLog();
-        expect(secondTurnLog.some(msg => msg.includes('is frozen solid') || msg.includes('cannot move'))).toBe(true);
-      }
-    });
-
-    it('should have a chance to thaw each turn', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      // Manually apply freeze status
-      engine['state'].opponentPiclet.statusEffects.push('freeze');
-
-      // Force thaw with low random number
-      const originalRandom = Math.random;
-      Math.random = () => 0.1; // Should trigger thaw (usually 20% chance)
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      // Restore Math.random
-      Math.random = originalRandom;
-
-      const log = engine.getLog();
-      const opponentState = engine.getState().opponentPiclet;
-
-      // Should thaw and be able to act
-      expect(log.some(msg => msg.includes('thawed out') || msg.includes('is no longer frozen'))).toBe(true);
-      expect(opponentState.statusEffects).not.toContain('freeze');
-    });
-  });
-
-  describe('Paralysis Status Effect', () => {
-    it('should reduce speed by 50%', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-      const initialSpeed = engine.getState().opponentPiclet.speed;
-
-      // Force paralysis to trigger
-      const originalRandom = Math.random;
-      Math.random = () => 0.1; // 10% < 25% chance
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Paralyzing Shock
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      // Restore Math.random
-      Math.random = originalRandom;
-
-      const finalSpeed = engine.getState().opponentPiclet.speed;
-      const log = engine.getLog();
-
-      expect(engine.getState().opponentPiclet.statusEffects).toContain('paralyze');
-      expect(log.some(msg => msg.includes('was paralyzed'))).toBe(true);
-      expect(finalSpeed).toBe(Math.floor(initialSpeed * 0.5)); // 50% speed reduction
-    });
-
-    it('should have 25% chance to prevent action', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      // Manually apply paralysis
-      engine['state'].opponentPiclet.statusEffects.push('paralyze');
-      engine['state'].opponentPiclet.speed = Math.floor(engine['state'].opponentPiclet.speed * 0.5);
-
-      // Force paralysis to prevent action
-      const originalRandom = Math.random;
-      Math.random = () => 0.1; // Should trigger paralysis prevention (25% chance)
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Should be prevented
-      );
-
-      // Restore Math.random
-      Math.random = originalRandom;
-
-      const log = engine.getLog();
-      expect(log.some(msg => 
-        msg.includes('is fully paralyzed') || 
-        msg.includes('cannot move due to paralysis')
-      )).toBe(true);
-    });
-  });
-
-  describe('Sleep Status Effect', () => {
-    it('should prevent action and last 1-3 turns', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 2 }, // Sleep Powder
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Should be prevented if asleep
-      );
-
-      const log = engine.getLog();
-      const opponentState = engine.getState().opponentPiclet;
-
-      expect(opponentState.statusEffects).toContain('sleep');
-      expect(log.some(msg => msg.includes('fell asleep'))).toBe(true);
-
-      // Sleep should prevent action
-      if (!engine.isGameOver()) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-
-        const secondLog = engine.getLog();
-        expect(secondLog.some(msg => 
-          msg.includes('is fast asleep') || 
-          msg.includes('cannot wake up')
-        )).toBe(true);
-      }
-    });
-
-    it('should wake up when attacked', () => {
-      const engine = new BattleEngine(basicPiclet, statusInflicter);
-
-      // Put player to sleep
-      engine['state'].playerPiclet.statusEffects.push('sleep');
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Should be prevented by sleep
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Attack should wake up player
-      );
-
-      const log = engine.getLog();
-      const playerState = engine.getState().playerPiclet;
-
-      // Should wake up when damaged
-      expect(log.some(msg => msg.includes('woke up'))).toBe(true);
-      expect(playerState.statusEffects).not.toContain('sleep');
-    });
-  });
-
-  describe('Confusion Status Effect', () => {
-    it('should last 2-5 turns and cause self-damage 33% of the time', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Confuse Ray
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      const opponentState = engine.getState().opponentPiclet;
-
-      expect(opponentState.statusEffects).toContain('confuse');
-      expect(log.some(msg => msg.includes('became confused'))).toBe(true);
-
-      // Test confusion self-damage
-      const initialHp = engine.getState().opponentPiclet.currentHp;
-
-      // Force confusion self-damage
-      const originalRandom = Math.random;
-      Math.random = () => 0.2; // Should trigger self-damage (33% chance)
-
-      if (!engine.isGameOver()) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-
-        const confusedLog = engine.getLog();
-        const finalHp = engine.getState().opponentPiclet.currentHp;
-
-        expect(confusedLog.some(msg => 
-          msg.includes('hurt itself in confusion') || 
-          msg.includes('attacked itself')
-        )).toBe(true);
-      }
-
-      // Restore Math.random
-      Math.random = originalRandom;
-    });
-
-    it('should wear off after 2-5 turns', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      // Manually apply confusion with duration
-      engine['state'].opponentPiclet.statusEffects.push('confuse');
-      (engine['state'].opponentPiclet as any).confusionTurns = 1; // Set to expire next turn
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      const opponentState = engine.getState().opponentPiclet;
-
-      expect(log.some(msg => msg.includes('is no longer confused') || msg.includes('snapped out of confusion'))).toBe(true);
-      expect(opponentState.statusEffects).not.toContain('confuse');
-    });
-  });
-
-  describe('Status Effect Interactions', () => {
-    it('should not allow multiple major status effects simultaneously', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      // Apply freeze first
-      engine['state'].opponentPiclet.statusEffects.push('freeze');
-
-      // Try to apply paralysis
-      const originalRandom = Math.random;
-      Math.random = () => 0.1; // Should trigger paralysis normally
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Paralyzing Shock
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      Math.random = originalRandom;
-
-      const opponentState = engine.getState().opponentPiclet;
-      const majorStatuses = opponentState.statusEffects.filter(status => 
-        ['freeze', 'paralyze', 'sleep'].includes(status)
-      );
-
-      // Should only have one major status effect
-      expect(majorStatuses.length).toBeLessThanOrEqual(1);
-    });
-
-    it('should allow confusion alongside other status effects', () => {
-      const engine = new BattleEngine(statusInflicter, basicPiclet);
-
-      // Apply paralysis first
-      engine['state'].opponentPiclet.statusEffects.push('paralyze');
-
-      // Apply confusion
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Confuse Ray
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const opponentState = engine.getState().opponentPiclet;
-
-      // Should have both paralysis and confusion
-      expect(opponentState.statusEffects).toContain('paralyze');
-      expect(opponentState.statusEffects).toContain('confuse');
-    });
-  });
-});

src/lib/battle-engine/debug-field-effects.test.ts

@@ -1,101 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Debug Field Effects', () => {
-  it('should debug field effect creation and damage calculation', () => {
-    const fieldUser: PicletDefinition = {
-      name: "Field User",
-      description: "Creates field effects",
-      tier: 'medium',
-      primaryType: PicletType.BEAST, // Changed to BEAST so opponent can damage it
-      baseStats: { hp: 100, attack: 60, defense: 80, speed: 60 },
-      nature: "Calm",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Contact Barrier",
-          type: AttackType.SPACE,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'reflect',
-              target: 'playerSide',
-              stackable: false
-            }
-          ]
-        }
-      ]
-    };
-
-    const attacker: PicletDefinition = {
-      name: "Contact Attacker",
-      description: "Uses contact moves",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 80, defense: 60, speed: 70 },
-      nature: "Adamant",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Physical Strike",
-          type: AttackType.BEAST,
-          power: 60,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    const engine = new BattleEngine(fieldUser, attacker);
-    
-    console.log('Initial state:', {
-      playerHp: engine.getState().playerPiclet.currentHp,
-      opponentHp: engine.getState().opponentPiclet.currentHp,
-      fieldEffects: engine.getState().fieldEffects
-    });
-
-    // First turn: create barrier and get attacked
-    engine.executeActions(
-      { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-      { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Physical Strike
-    );
-
-    console.log('After first turn:', {
-      playerHp: engine.getState().playerPiclet.currentHp,
-      opponentHp: engine.getState().opponentPiclet.currentHp,
-      fieldEffects: engine.getState().fieldEffects,
-      log: engine.getLog()
-    });
-
-    // Second turn: opponent attacks again (should be reduced)
-    const hpBeforeSecondAttack = engine.getState().playerPiclet.currentHp;
-    
-    engine.executeActions(
-      { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier (no effect)
-      { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Physical Strike (should be reduced)
-    );
-
-    const hpAfterSecondAttack = engine.getState().playerPiclet.currentHp;
-    const damage = hpBeforeSecondAttack - hpAfterSecondAttack;
-
-    console.log('After second turn:', {
-      playerHp: hpAfterSecondAttack,
-      damage: damage,
-      fieldEffects: engine.getState().fieldEffects,
-      log: engine.getLog()
-    });
-
-    expect(engine.getState().fieldEffects.length).toBeGreaterThan(0);
-    expect(damage).toBeGreaterThan(0); // Some damage should occur
-  });
-});

src/lib/battle-engine/extreme-moves.test.ts

@@ -1,544 +0,0 @@
-/**
- * Tests for extreme risk-reward moves from the design document
- * These are the dramatic, high-stakes moves that define the battle system
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import { PicletDefinition, Move, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-const STANDARD_STATS = { hp: 100, attack: 80, defense: 70, speed: 60 };
-
-describe('Extreme Risk-Reward Moves - TDD Implementation', () => {
-  describe('Self Destruct - Ultimate Sacrifice', () => {
-    it('should handle Self Destruct move', () => {
-      const selfDestruct: Move = {
-        name: "Self Destruct",
-        type: AttackType.NORMAL,
-        power: 200,
-        accuracy: 100,
-        pp: 1,
-        priority: 0,
-        flags: ['explosive', 'contact'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'all',
-            formula: 'standard',
-            multiplier: 1.5
-          },
-          {
-            type: 'damage',
-            target: 'self',
-            formula: 'fixed',
-            value: 9999,
-            condition: 'afterUse'
-          }
-        ]
-      };
-
-      const bomberPiclet: PicletDefinition = {
-        name: "Bomb Beast",
-        description: "A creature that can self-destruct",
-        tier: 'medium',
-        primaryType: PicletType.MACHINA,
-        baseStats: STANDARD_STATS,
-        nature: "Brave",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [selfDestruct]
-      };
-
-      const targetPiclet: PicletDefinition = {
-        name: "Target",
-        description: "Target dummy",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: STANDARD_STATS,
-        nature: "Hardy",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      // Test that the move is properly defined
-      expect(selfDestruct.effects).toHaveLength(2);
-      expect(selfDestruct.effects[0].target).toBe('all');
-      expect(selfDestruct.effects[1].value).toBe(9999);
-    });
-  });
-
-  describe('Berserker\'s End - Conditional Power', () => {
-    it('should handle Berserker\'s End with conditional effects', () => {
-      const berserkersEnd: Move = {
-        name: "Berserker's End",
-        type: AttackType.BEAST,
-        power: 80,
-        accuracy: 95,
-        pp: 10,
-        priority: 0,
-        flags: ['contact', 'reckless'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'normal'
-          },
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'strong',
-            condition: 'ifLowHp'
-          },
-          {
-            type: 'mechanicOverride',
-            target: 'self',
-            mechanic: 'healingBlocked',
-            value: true
-          }
-        ]
-      };
-
-      const berserkerPiclet: PicletDefinition = {
-        name: "Berserker",
-        description: "Fights with reckless abandon",
-        tier: 'high',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 120, attack: 100, defense: 90, speed: 85 },
-        nature: "Reckless",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [berserkersEnd]
-      };
-
-      // Test move structure
-      expect(berserkersEnd.effects).toHaveLength(3);
-      expect(berserkersEnd.effects[1].condition).toBe('ifLowHp');
-      expect(berserkersEnd.effects[2].mechanic).toBe('healingBlocked');
-    });
-  });
-
-  describe('Life Drain Overload - Massive Heal with Permanent Cost', () => {
-    it('should handle Life Drain Overload move', () => {
-      const lifeDrainOverload: Move = {
-        name: "Life Drain Overload",
-        type: AttackType.CULTURE,
-        power: 0,
-        accuracy: 100,
-        pp: 3,
-        priority: 0,
-        flags: ['draining'],
-        effects: [
-          {
-            type: 'heal',
-            target: 'self',
-            formula: 'percentage',
-            value: 75
-          },
-          {
-            type: 'modifyStats',
-            target: 'self',
-            stats: { attack: 'greatly_decrease' },
-            condition: 'afterUse'
-          }
-        ]
-      };
-
-      expect(lifeDrainOverload.effects[0].formula).toBe('percentage');
-      expect(lifeDrainOverload.effects[0].value).toBe(75);
-      expect(lifeDrainOverload.effects[1].stats.attack).toBe('greatly_decrease');
-    });
-  });
-
-  describe('Cursed Gambit - Random Extreme Outcome', () => {
-    it('should handle Cursed Gambit with random effects', () => {
-      const cursedGambit: Move = {
-        name: "Cursed Gambit",
-        type: AttackType.CULTURE,
-        power: 0,
-        accuracy: 100,
-        pp: 1,
-        priority: 0,
-        flags: ['gambling', 'cursed'],
-        effects: [
-          {
-            type: 'heal',
-            target: 'self',
-            formula: 'percentage',
-            value: 100,
-            condition: 'ifLucky50'
-          },
-          {
-            type: 'damage',
-            target: 'self',
-            formula: 'fixed',
-            value: 9999,
-            condition: 'ifUnlucky50'
-          }
-        ]
-      };
-
-      expect(cursedGambit.effects).toHaveLength(2);
-      expect(cursedGambit.effects[0].condition).toBe('ifLucky50');
-      expect(cursedGambit.effects[1].condition).toBe('ifUnlucky50');
-      expect(cursedGambit.flags).toContain('gambling');
-    });
-  });
-
-  describe('Blood Pact - Sacrifice HP for Permanent Power', () => {
-    it('should handle Blood Pact move', () => {
-      const bloodPact: Move = {
-        name: "Blood Pact",
-        type: AttackType.CULTURE,
-        power: 0,
-        accuracy: 100,
-        pp: 3,
-        priority: 0,
-        flags: ['sacrifice'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'self',
-            formula: 'percentage',
-            value: 50
-          },
-          {
-            type: 'mechanicOverride',
-            target: 'self',
-            mechanic: 'damageMultiplier',
-            value: 2.0,
-            condition: 'restOfBattle'
-          }
-        ]
-      };
-
-      expect(bloodPact.effects[0].formula).toBe('percentage');
-      expect(bloodPact.effects[1].value).toBe(2.0);
-      expect(bloodPact.flags).toContain('sacrifice');
-    });
-  });
-
-  describe('Soul Burn - PP Sacrifice for Power', () => {
-    it('should handle Soul Burn move', () => {
-      const soulBurn: Move = {
-        name: "Soul Burn",
-        type: AttackType.SPACE,
-        power: 150,
-        accuracy: 90,
-        pp: 5,
-        priority: 0,
-        flags: ['burning'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'extreme'
-          },
-          {
-            type: 'manipulatePP',
-            target: 'self',
-            action: 'drain',
-            value: 3,
-            targetMove: 'random',
-            condition: 'afterUse'
-          }
-        ]
-      };
-
-      expect(soulBurn.effects[0].amount).toBe('extreme');
-      expect(soulBurn.effects[1].value).toBe(3);
-      expect(soulBurn.effects[1].targetMove).toBe('random');
-    });
-  });
-
-  describe('Mirror Shatter - Damage Reflection with Cost', () => {
-    it('should handle Mirror Shatter move', () => {
-      const mirrorShatter: Move = {
-        name: "Mirror Shatter",
-        type: AttackType.MINERAL,
-        power: 0,
-        accuracy: 100,
-        pp: 5,
-        priority: 4,
-        flags: ['priority'],
-        effects: [
-          {
-            type: 'mechanicOverride',
-            target: 'self',
-            mechanic: 'damageReflection',
-            value: 'double',
-            condition: 'thisTurn'
-          },
-          {
-            type: 'modifyStats',
-            target: 'self',
-            stats: { defense: 'greatly_decrease' },
-            condition: 'afterUse'
-          }
-        ]
-      };
-
-      expect(mirrorShatter.priority).toBe(4);
-      expect(mirrorShatter.effects[0].value).toBe('double');
-      expect(mirrorShatter.effects[1].stats.defense).toBe('greatly_decrease');
-    });
-  });
-
-  describe('Apocalypse Strike - AoE Devastation with Vulnerability', () => {
-    it('should handle Apocalypse Strike move', () => {
-      const apocalypseStrike: Move = {
-        name: "Apocalypse Strike",
-        type: AttackType.SPACE,
-        power: 120,
-        accuracy: 85,
-        pp: 1,
-        priority: 0,
-        flags: ['apocalyptic'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'all',
-            formula: 'standard',
-            multiplier: 1.3
-          },
-          {
-            type: 'mechanicOverride',
-            target: 'self',
-            mechanic: 'criticalHits',
-            value: 'alwaysReceive',
-            condition: 'restOfBattle'
-          },
-          {
-            type: 'modifyStats',
-            target: 'self',
-            stats: { defense: 'greatly_decrease' }
-          }
-        ]
-      };
-
-      expect(apocalypseStrike.effects).toHaveLength(3);
-      expect(apocalypseStrike.effects[0].target).toBe('all');
-      expect(apocalypseStrike.effects[1].value).toBe('alwaysReceive');
-      expect(apocalypseStrike.pp).toBe(1); // Can only be used once
-    });
-  });
-
-  describe('Temporal Overload - Extra Turn with Cost', () => {
-    it('should handle Temporal Overload move', () => {
-      const temporalOverload: Move = {
-        name: "Temporal Overload",
-        type: AttackType.SPACE,
-        power: 0,
-        accuracy: 100,
-        pp: 2,
-        priority: 0,
-        flags: ['temporal'],
-        effects: [
-          {
-            type: 'mechanicOverride',
-            target: 'self',
-            mechanic: 'extraTurn',
-            value: true,
-            condition: 'nextTurn'
-          },
-          {
-            type: 'applyStatus',
-            target: 'self',
-            status: 'paralyze',
-            chance: 100,
-            condition: 'turnAfterNext'
-          }
-        ]
-      };
-
-      expect(temporalOverload.effects[0].mechanic).toBe('extraTurn');
-      expect(temporalOverload.effects[1].condition).toBe('turnAfterNext');
-      expect(temporalOverload.flags).toContain('temporal');
-    });
-  });
-
-  describe('Multi-Stage Effects - Charging Blast', () => {
-    it('should handle Charging Blast with multi-stage effects', () => {
-      const chargingBlast: Move = {
-        name: "Charging Blast",
-        type: AttackType.SPACE,
-        power: 120,
-        accuracy: 90,
-        pp: 5,
-        priority: 0,
-        flags: ['charging'],
-        effects: [
-          {
-            type: 'modifyStats',
-            target: 'self',
-            stats: { defense: 'increase' },
-            condition: 'onCharging'
-          },
-          {
-            type: 'damage',
-            target: 'opponent',
-            amount: 'extreme',
-            condition: 'afterCharging'
-          },
-          {
-            type: 'applyStatus',
-            target: 'self',
-            status: 'paralyze',
-            condition: 'afterCharging'
-          }
-        ]
-      };
-
-      expect(chargingBlast.effects).toHaveLength(3);
-      expect(chargingBlast.effects[0].condition).toBe('onCharging');
-      expect(chargingBlast.effects[1].condition).toBe('afterCharging');
-      expect(chargingBlast.flags).toContain('charging');
-    });
-  });
-
-  describe('Void Sacrifice - Field Effect with Self-Harm', () => {
-    it('should handle Void Sacrifice from Tempest Wraith example', () => {
-      const voidSacrifice: Move = {
-        name: "Void Sacrifice",
-        type: AttackType.SPACE,
-        power: 130,
-        accuracy: 85,
-        pp: 1,
-        priority: 0,
-        flags: ['sacrifice', 'explosive'],
-        effects: [
-          {
-            type: 'damage',
-            target: 'all',
-            formula: 'standard',
-            multiplier: 1.2
-          },
-          {
-            type: 'damage',
-            target: 'self',
-            formula: 'percentage',
-            value: 75
-          },
-          {
-            type: 'fieldEffect',
-            effect: 'voidStorm',
-            target: 'field',
-            stackable: false
-          }
-        ]
-      };
-
-      expect(voidSacrifice.effects).toHaveLength(3);
-      expect(voidSacrifice.effects[2].effect).toBe('voidStorm');
-      expect(voidSacrifice.effects[2].stackable).toBe(false);
-    });
-  });
-
-  describe('Integration Test - Complex Battle with Extreme Moves', () => {
-    it('should handle a battle with multiple extreme moves', () => {
-      const extremePiclet: PicletDefinition = {
-        name: "Chaos Incarnate",
-        description: "Master of extreme techniques",
-        tier: 'legendary',
-        primaryType: PicletType.SPACE,
-        secondaryType: PicletType.CULTURE,
-        baseStats: { hp: 150, attack: 120, defense: 80, speed: 100 },
-        nature: "Reckless",
-        specialAbility: {
-          name: "Chaos Heart",
-          description: "Gains power from desperation",
-          triggers: [
-            {
-              event: 'onLowHP',
-              effects: [
-                {
-                  type: 'mechanicOverride',
-                  mechanic: 'damageMultiplier',
-                  value: 1.5
-                }
-              ]
-            }
-          ]
-        },
-        movepool: [
-          {
-            name: "Cursed Gambit",
-            type: AttackType.CULTURE,
-            power: 0,
-            accuracy: 100,
-            pp: 1,
-            priority: 0,
-            flags: ['gambling'],
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                formula: 'percentage',
-                value: 100,
-                condition: 'ifLucky50'
-              },
-              {
-                type: 'damage',
-                target: 'self',
-                formula: 'fixed',
-                value: 9999,
-                condition: 'ifUnlucky50'
-              }
-            ]
-          },
-          {
-            name: "Blood Pact",
-            type: AttackType.CULTURE,
-            power: 0,
-            accuracy: 100,
-            pp: 3,
-            priority: 0,
-            flags: ['sacrifice'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'self',
-                formula: 'percentage',
-                value: 50
-              },
-              {
-                type: 'mechanicOverride',
-                target: 'self',
-                mechanic: 'damageMultiplier',
-                value: 2.0,
-                condition: 'restOfBattle'
-              }
-            ]
-          }
-        ]
-      };
-
-      const standardPiclet: PicletDefinition = {
-        name: "Standard Fighter",
-        description: "Uses normal moves",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: STANDARD_STATS,
-        nature: "Hardy",
-        specialAbility: { name: "None", description: "No ability" },
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      const engine = new BattleEngine(extremePiclet, standardPiclet);
-
-      // Test that the battle can be initialized with extreme moves
-      expect(engine.getState().playerPiclet.definition.name).toBe("Chaos Incarnate");
-      expect(engine.getState().playerPiclet.moves).toHaveLength(2);
-      expect(engine.getState().playerPiclet.moves[0].move.name).toBe("Cursed Gambit");
-      expect(engine.getState().playerPiclet.moves[1].move.name).toBe("Blood Pact");
-
-      // Test that the special ability is properly defined
-      expect(extremePiclet.specialAbility.triggers).toHaveLength(1);
-      expect(extremePiclet.specialAbility.triggers![0].event).toBe('onLowHP');
-    });
-  });
-});

src/lib/battle-engine/extreme-risk-reward.test.ts

@@ -1,383 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Extreme Risk-Reward Moves', () => {
-  describe('Self-Destruct Moves', () => {
-    it('should deal massive damage to all but KO the user', () => {
-      const bomber: PicletDefinition = {
-        name: "Suicide Bomber",
-        description: "Sacrifices itself for massive damage",
-        tier: 'medium',
-        primaryType: PicletType.MACHINA,
-        baseStats: { hp: 60, attack: 40, defense: 60, speed: 50 },
-        nature: "Brave",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Self Destruct",
-            type: AttackType.MACHINA,
-            power: 200,
-            accuracy: 100,
-            pp: 1,
-            priority: 0,
-            flags: ['explosive', 'contact'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'all',
-                formula: 'standard',
-                multiplier: 1.5
-              },
-              {
-                type: 'damage',
-                target: 'self',
-                formula: 'fixed',
-                value: 9999,
-                condition: 'afterUse'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Sturdy Opponent",
-        description: "Tanky opponent",
-        tier: 'high',
-        primaryType: PicletType.MINERAL,
-        baseStats: { hp: 100, attack: 60, defense: 100, speed: 40 },
-        nature: "Impish",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(bomber, opponent);
-      const initialOpponentHp = engine.getState().opponentPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Self Destruct
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
-      const playerHp = engine.getState().playerPiclet.currentHp;
-      
-      // User should be KO'd
-      expect(playerHp).toBe(0);
-      
-      // Opponent should take massive damage
-      expect(finalOpponentHp).toBeLessThan(initialOpponentHp);
-      const damage = initialOpponentHp - finalOpponentHp;
-      expect(damage).toBeGreaterThan(45); // Should be very high damage for a self-destruct move
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('Self Destruct') || msg.includes('exploded'))).toBe(true);
-      expect(engine.isGameOver()).toBe(true);
-    });
-  });
-
-  describe('Gambling Moves', () => {
-    it('should have random success/failure outcomes', () => {
-      const gambler: PicletDefinition = {
-        name: "Lucky Gambler",
-        description: "Relies on luck for power",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: { hp: 70, attack: 60, defense: 60, speed: 80 },
-        nature: "Hasty",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Cursed Gambit",
-            type: AttackType.CULTURE,
-            power: 0,
-            accuracy: 100,
-            pp: 1,
-            priority: 0,
-            flags: ['gambling', 'cursed'],
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                amount: 'percentage',
-                value: 100,
-                condition: 'ifLucky50'
-              },
-              {
-                type: 'damage',
-                target: 'self',
-                formula: 'fixed',
-                value: 9999,
-                condition: 'ifUnlucky50'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Do Nothing",
-            type: AttackType.NORMAL,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [] // No effects - just waste a turn
-          }
-        ]
-      };
-
-      // Test multiple times to check for randomness
-      let healedCount = 0;
-      let faintedCount = 0;
-      
-      for (let i = 0; i < 20; i++) {
-        const engine = new BattleEngine(gambler, opponent);
-        // Damage the gambler first
-        engine['state'].playerPiclet.currentHp = Math.floor(engine['state'].playerPiclet.maxHp * 0.5);
-        const preGambitHp = engine.getState().playerPiclet.currentHp;
-        
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-
-        const postGambitHp = engine.getState().playerPiclet.currentHp;
-        const maxHp = engine.getState().playerPiclet.maxHp;
-        
-        
-        if (postGambitHp === 0) {
-          faintedCount++;
-        } else if (postGambitHp > preGambitHp) {
-          healedCount++;
-        }
-      }
-      
-      // Should have some of each outcome (allowing for randomness)
-      expect(healedCount + faintedCount).toBeGreaterThan(0);
-      expect(healedCount).toBeGreaterThan(0);
-      expect(faintedCount).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Sacrifice Moves', () => {
-    it('should provide powerful effects at great personal cost', () => {
-      const sacrificer: PicletDefinition = {
-        name: "Blood Warrior",
-        description: "Sacrifices HP for power",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 100, attack: 70, defense: 60, speed: 60 },
-        nature: "Brave",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Blood Pact",
-            type: AttackType.BEAST,
-            power: 0,
-            accuracy: 100,
-            pp: 3,
-            priority: 0,
-            flags: ['sacrifice'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'self',
-                formula: 'percentage',
-                value: 50
-              },
-              {
-                type: 'mechanicOverride',
-                target: 'self',
-                mechanic: 'damageMultiplier',
-                value: 2.0,
-                condition: 'restOfBattle'
-              }
-            ]
-          },
-          {
-            name: "Strike",
-            type: AttackType.BEAST,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(sacrificer, opponent);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      // Use Blood Pact
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Blood Pact
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const hpAfterSacrifice = engine.getState().playerPiclet.currentHp;
-      expect(hpAfterSacrifice).toBeLessThan(initialHp);
-      
-      // Now attack should do double damage
-      const initialOpponentHp = engine.getState().opponentPiclet.currentHp;
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Strike (should be doubled)
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
-      const damage = initialOpponentHp - finalOpponentHp;
-      
-      // Should do significantly more damage than normal (doubled)
-      expect(damage).toBeGreaterThan(60); // Normal would be ~30-40
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('Blood Pact') || msg.includes('sacrifice'))).toBe(true);
-    });
-  });
-
-  describe('Conditional Power Scaling', () => {
-    it('should scale damage based on conditions', () => {
-      const revengeUser: PicletDefinition = {
-        name: "Revenge Fighter",
-        description: "Gets stronger when damaged",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 90, attack: 70, defense: 80, speed: 50 },
-        nature: "Brave",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Revenge Strike",
-            type: AttackType.BEAST,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              },
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'strong',
-                condition: 'ifDamagedThisTurn'
-              }
-            ]
-          }
-        ]
-      };
-
-      const attacker: PicletDefinition = {
-        name: "Fast Attacker",
-        description: "Quick attacker",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 200, attack: 80, defense: 60, speed: 100 },
-        nature: "Hasty",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Quick Strike",
-            type: AttackType.BEAST,
-            power: 50,
-            accuracy: 100,
-            pp: 10,
-            priority: 1,
-            flags: ['contact', 'priority'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      // First test: revenge without being damaged first (revenge user at full HP)
-      const engine1 = new BattleEngine(revengeUser, attacker);
-      const initialOpponentHp = engine1.getState().opponentPiclet.currentHp;
-      engine1.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const hpAfterNormalRevenge = engine1.getState().opponentPiclet.currentHp;
-      const normalRevengeDamage = initialOpponentHp - hpAfterNormalRevenge;
-      
-      // Second test: revenge when damaged (revenge user starts damaged)
-      const engine2 = new BattleEngine(revengeUser, attacker);
-      // Damage the revenge user to trigger the condition
-      engine2['state'].playerPiclet.currentHp = Math.floor(engine2['state'].playerPiclet.maxHp * 0.5);
-      
-      const initialOpponentHp2 = engine2.getState().opponentPiclet.currentHp;
-      engine2.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const hpAfterPoweredRevenge = engine2.getState().opponentPiclet.currentHp;
-      const poweredRevengeDamage = initialOpponentHp2 - hpAfterPoweredRevenge;
-      
-      // Verify that the conditional effect triggered by checking for multiple damage instances
-      const damageMessages = engine2.getLog().filter(msg => msg.includes('took') && msg.includes('damage'));
-      expect(damageMessages.length).toBeGreaterThanOrEqual(3); // Attacker hits revenge user, then revenge user hits back twice
-      
-      // Verify the powered revenge did more damage overall
-      expect(poweredRevengeDamage).toBeGreaterThan(100); // Should be significant damage from both effects
-    });
-  });
-});

src/lib/battle-engine/field-effects.test.ts

@@ -1,493 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Field Effects System', () => {
-  let contactAttacker: PicletDefinition;
-  let nonContactAttacker: PicletDefinition;
-  let fieldEffectUser: PicletDefinition;
-  let basicOpponent: PicletDefinition;
-
-  beforeEach(() => {
-    // Piclet that uses contact moves
-    contactAttacker = {
-      name: "Contact Fighter",
-      description: "Uses contact moves",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 80, defense: 60, speed: 70 },
-      nature: "Adamant",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Physical Strike",
-          type: AttackType.BEAST,
-          power: 60,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    // Piclet that uses non-contact moves
-    nonContactAttacker = {
-      name: "Ranged Fighter",
-      description: "Uses non-contact moves",
-      tier: 'medium',
-      primaryType: PicletType.SPACE,
-      baseStats: { hp: 80, attack: 80, defense: 60, speed: 70 },
-      nature: "Modest",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Energy Blast",
-          type: AttackType.SPACE,
-          power: 60,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: [],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    // Piclet that can create field effects
-    fieldEffectUser = {
-      name: "Field Controller",
-      description: "Controls battlefield effects",
-      tier: 'medium',
-      primaryType: PicletType.BEAST, // Changed to BEAST so opponent can damage it
-      baseStats: { hp: 100, attack: 60, defense: 80, speed: 60 },
-      nature: "Calm",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Contact Barrier",
-          type: AttackType.SPACE,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'reflect',
-              target: 'playerSide',
-              stackable: false
-            }
-          ]
-        },
-        {
-          name: "Non-Contact Barrier",
-          type: AttackType.SPACE,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'lightScreen',
-              target: 'playerSide',
-              stackable: false
-            }
-          ]
-        },
-        {
-          name: "Entry Spikes",
-          type: AttackType.MINERAL,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'spikes',
-              target: 'opponentSide',
-              stackable: true
-            }
-          ]
-        },
-        {
-          name: "Healing Field",
-          type: AttackType.FLORA,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'healingMist',
-              target: 'field',
-              stackable: false
-            }
-          ]
-        }
-      ]
-    };
-
-    // Basic opponent for testing
-    basicOpponent = {
-      name: "Basic Opponent",
-      description: "Standard test opponent",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 60, defense: 60, speed: 60 },
-      nature: "Hardy",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Basic Attack",
-          type: AttackType.NORMAL,
-          power: 50,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-  });
-
-  describe('Contact Damage Reduction (Reflect)', () => {
-    it('should reduce contact move damage by 50%', () => {
-      const engine = new BattleEngine(fieldEffectUser, contactAttacker);
-      
-      // Set up barrier first
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Basic Attack (will be reduced)
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('barrier was raised to reduce contact move damage'))).toBe(true);
-      
-      // Test that subsequent contact moves are reduced
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier (no effect, already active)
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Basic Attack (should be reduced)
-      );
-      
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      const damage = initialHp - finalHp;
-      
-      // Damage should be significantly reduced (less than normal ~30-40 damage)
-      expect(damage).toBeLessThan(25);
-      expect(damage).toBeGreaterThan(0); // But still some damage
-    });
-
-    it('should not reduce non-contact move damage', () => {
-      const engine = new BattleEngine(fieldEffectUser, nonContactAttacker);
-      
-      // Set up contact barrier
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Energy Blast (non-contact)
-      );
-      
-      // Test that non-contact moves are NOT reduced
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Energy Blast (should not be reduced)
-      );
-      
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      const damage = initialHp - finalHp;
-      
-      // Damage should be normal (around 30-50)
-      expect(damage).toBeGreaterThan(25);
-    });
-  });
-
-  describe('Non-Contact Damage Reduction (Light Screen)', () => {
-    it('should reduce non-contact move damage by 50%', () => {
-      const engine = new BattleEngine(fieldEffectUser, nonContactAttacker);
-      
-      // Set up non-contact barrier
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Non-Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Energy Blast (should be reduced)
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('barrier was raised to reduce non-contact move damage'))).toBe(true);
-      
-      // Test reduction on subsequent turn
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Energy Blast (should be reduced)
-      );
-      
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      const damage = initialHp - finalHp;
-      
-      // Damage should be reduced
-      expect(damage).toBeLessThan(25);
-      expect(damage).toBeGreaterThan(0);
-    });
-
-    it('should not reduce contact move damage', () => {
-      const engine = new BattleEngine(fieldEffectUser, contactAttacker);
-      
-      // Set up non-contact barrier
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Non-Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Physical Strike (contact)
-      );
-      
-      // Test that contact moves are NOT reduced
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Physical Strike (should not be reduced)
-      );
-      
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      const damage = initialHp - finalHp;
-      
-      // Damage should be normal
-      expect(damage).toBeGreaterThan(25);
-    });
-  });
-
-  describe('Entry Hazards (Spikes)', () => {
-    it('should set up entry spikes on opponent side', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 2 }, // Entry Spikes
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('Entry spikes were scattered'))).toBe(true);
-      
-      // Check that field effect was applied
-      const state = engine.getState();
-      expect(state.fieldEffects.some(effect => effect.name === 'entryHazardSpikes')).toBe(true);
-    });
-
-    it('should be stackable', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      // Apply spikes twice
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 2 }, // Entry Spikes
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 2 }, // Entry Spikes again
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      const state = engine.getState();
-      const spikeEffects = state.fieldEffects.filter(effect => effect.name === 'entryHazardSpikes');
-      expect(spikeEffects.length).toBe(2); // Should stack
-    });
-  });
-
-  describe('Healing Field', () => {
-    it('should create a healing field that affects both sides', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      // Damage both piclets first
-      engine['state'].playerPiclet.currentHp = Math.floor(engine['state'].playerPiclet.maxHp * 0.5);
-      engine['state'].opponentPiclet.currentHp = Math.floor(engine['state'].opponentPiclet.maxHp * 0.5);
-      
-      const playerInitialHp = engine.getState().playerPiclet.currentHp;
-      const opponentInitialHp = engine.getState().opponentPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Healing Field
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('healing field was created'))).toBe(true);
-      
-      // Both piclets should be healed at end of turn
-      const playerFinalHp = engine.getState().playerPiclet.currentHp;
-      const opponentFinalHp = engine.getState().opponentPiclet.currentHp;
-      
-      expect(playerFinalHp).toBeGreaterThan(playerInitialHp);
-      expect(opponentFinalHp).toBeGreaterThan(opponentInitialHp);
-      expect(log.some(msg => msg.includes('healed by the healing field'))).toBe(true);
-    });
-
-    it('should not heal piclets at full HP', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      // Both piclets at full HP
-      const playerInitialHp = engine.getState().playerPiclet.currentHp;
-      const opponentInitialHp = engine.getState().opponentPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Healing Field
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      // HP should remain the same
-      const playerFinalHp = engine.getState().playerPiclet.currentHp;
-      const opponentFinalHp = engine.getState().opponentPiclet.currentHp;
-      
-      expect(playerFinalHp).toBe(playerInitialHp);
-      expect(opponentFinalHp).toBe(opponentInitialHp);
-    });
-  });
-
-  describe('Field Effect Duration and Management', () => {
-    it('should expire field effects after 5 turns', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      // Create a barrier
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      // Verify it exists
-      expect(engine.getState().fieldEffects.length).toBe(1);
-      
-      // Pass 5 turns
-      for (let i = 0; i < 5; i++) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-      }
-      
-      // Effect should have expired
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('faded away'))).toBe(true);
-      expect(engine.getState().fieldEffects.length).toBe(0);
-    });
-
-    it('should not stack non-stackable effects', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      // Apply same barrier twice
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier again
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      // Should only have one effect (refreshed duration)
-      const contactBarriers = engine.getState().fieldEffects.filter(
-        effect => effect.name === 'contactDamageReduction'
-      );
-      expect(contactBarriers.length).toBe(1);
-    });
-
-    it('should properly format field effect names in logs', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      // Pass enough turns for effect to fade
-      for (let i = 0; i < 5; i++) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 0 }
-        );
-      }
-      
-      const log = engine.getLog();
-      expect(log.some(msg => 
-        msg.includes('Contact damage barrier faded away') ||
-        msg.includes('contact damage barrier faded away')
-      )).toBe(true);
-    });
-  });
-
-  describe('Field Effect Integration with Battle Flow', () => {
-    it('should apply field effects during damage calculation', () => {
-      const engine = new BattleEngine(fieldEffectUser, contactAttacker);
-      
-      // Measure baseline damage first
-      const baselineEngine = new BattleEngine(fieldEffectUser, contactAttacker);
-      const baselineInitialHp = baselineEngine.getState().playerPiclet.currentHp;
-      
-      baselineEngine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // No barrier
-      );
-      
-      const baselineDamage = baselineInitialHp - baselineEngine.getState().playerPiclet.currentHp;
-      
-      // Now test with barrier
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      const protectedInitialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Attack against barrier
-      );
-      
-      const protectedDamage = protectedInitialHp - engine.getState().playerPiclet.currentHp;
-      
-      // Protected damage should be significantly less
-      expect(protectedDamage).toBeLessThan(baselineDamage * 0.75);
-    });
-
-    it('should handle multiple field effects simultaneously', () => {
-      const engine = new BattleEngine(fieldEffectUser, basicOpponent);
-      
-      // Apply multiple field effects
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Contact Barrier
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Healing Field
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 2 }, // Entry Spikes
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      // Should have 3 different field effects
-      const state = engine.getState();
-      expect(state.fieldEffects.length).toBe(3);
-      
-      const effectNames = state.fieldEffects.map(effect => effect.name);
-      expect(effectNames).toContain('contactDamageReduction');
-      expect(effectNames).toContain('healingField');
-      expect(effectNames).toContain('entryHazardSpikes');
-    });
-  });
-});

src/lib/battle-engine/integration.test.ts

@@ -1,255 +0,0 @@
-/**
- * Integration tests for complete battle scenarios
- * Tests complex multi-turn battles following the design document
- */
-
-import { describe, it, expect } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import { 
-  STELLAR_WOLF, 
-  TOXIC_CRAWLER, 
-  BERSERKER_BEAST, 
-  AQUA_GUARDIAN
-} from './test-data';
-import { BattleAction } from './types';
-
-describe('Battle Engine Integration', () => {
-  describe('Complete Battle Scenarios', () => {
-    it('should handle a complete battle with type effectiveness', () => {
-      // Space vs Bug - Space has advantage
-      const engine = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-      let turns = 0;
-      const maxTurns = 20;
-      
-      while (!engine.isGameOver() && turns < maxTurns) {
-        const playerAction: BattleAction = { 
-          type: 'move', 
-          piclet: 'player', 
-          moveIndex: 1 // Flame Burst (Space type)
-        };
-        const opponentAction: BattleAction = { 
-          type: 'move', 
-          piclet: 'opponent', 
-          moveIndex: 0 // Tackle
-        };
-        
-        engine.executeActions(playerAction, opponentAction);
-        turns++;
-      }
-      
-      expect(engine.isGameOver()).toBe(true);
-      expect(turns).toBeLessThan(maxTurns);
-      
-      // Player should win due to type advantage
-      expect(engine.getWinner()).toBe('player');
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes("It's super effective!"))).toBe(true);
-    });
-
-    it('should handle a battle with status effects and healing', () => {
-      const engine = new BattleEngine(TOXIC_CRAWLER, AQUA_GUARDIAN);
-      
-      // Turn 1: Toxic Crawler uses Toxic Sting to poison
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Toxic Sting
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Tackle
-      );
-      
-      // Check that opponent is poisoned
-      expect(engine.getState().opponentPiclet.statusEffects).toContain('poison');
-      
-      // Turn 2: Guardian tries to heal while poison damage occurs
-      const hpBeforeTurn = engine.getState().opponentPiclet.currentHp;
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Tackle
-        { type: 'move', piclet: 'opponent', moveIndex: 1 }  // Healing Light
-      );
-      
-      // Poison should have done damage during turn end
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('hurt by poison'))).toBe(true);
-    });
-
-    it('should handle conditional move effects correctly', () => {
-      const engine = new BattleEngine(BERSERKER_BEAST, AQUA_GUARDIAN);
-      
-      // Damage the berserker to trigger low HP condition
-      engine['state'].playerPiclet.currentHp = Math.floor(engine['state'].playerPiclet.maxHp * 0.2);
-      
-      const initialDefense = engine.getState().playerPiclet.defense;
-      const initialOpponentHp = engine.getState().opponentPiclet.currentHp;
-      const initialHpRatio = engine.getState().playerPiclet.currentHp / engine.getState().playerPiclet.maxHp;
-      
-      // Use Berserker's End while at low HP
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Berserker's End
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Tackle
-      );
-      
-      const finalDefense = engine.getState().playerPiclet.defense;
-      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
-      
-      // Should deal damage (may miss due to 90% accuracy, so check if hit)
-      const damageDealt = initialOpponentHp - finalOpponentHp;
-      const log = engine.getLog();
-      const moveHit = !log.some(msg => msg.includes('attack missed'));
-      
-      if (moveHit) {
-        expect(damageDealt).toBeGreaterThan(20); // Should be significant due to strong damage condition
-      } else {
-        expect(damageDealt).toBe(0); // No damage if missed
-      }
-      
-      // The defense should decrease if HP is below 25% (0.25) due to ifLowHp condition
-      if (initialHpRatio < 0.25) {
-        expect(finalDefense).toBeLessThan(initialDefense);
-      } else {
-        // If not low HP, no defense change expected
-        expect(finalDefense).toBe(initialDefense);
-      }
-    });
-
-    it('should handle stat modifications and their effects on damage', () => {
-      const engine = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-      
-      // Turn 1: Power Up to increase attack
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Power Up
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Tackle
-      );
-      
-      const boostedAttack = engine.getState().playerPiclet.attack;
-      const opponentHpAfterBoost = engine.getState().opponentPiclet.currentHp;
-      
-      // Turn 2: Attack with boosted stats
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Tackle
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }  // Tackle
-      );
-      
-      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
-      const damageWithBoost = opponentHpAfterBoost - finalOpponentHp;
-      
-      // Damage should be higher due to attack boost
-      expect(damageWithBoost).toBeGreaterThan(20);
-      expect(boostedAttack).toBeGreaterThan(STELLAR_WOLF.baseStats.attack);
-    });
-
-    it('should maintain battle log integrity throughout complex battle', () => {
-      const engine = new BattleEngine(STELLAR_WOLF, BERSERKER_BEAST);
-      
-      // Execute several turns with different moves
-      const moves = [
-        [3, 0], // Power Up vs Tackle
-        [1, 1], // Flame Burst vs Berserker's End
-        [2, 2], // Healing Light vs Healing Light
-        [0, 0]  // Tackle vs Tackle
-      ];
-      
-      for (const [playerMove, opponentMove] of moves) {
-        if (engine.isGameOver()) break;
-        
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: playerMove },
-          { type: 'move', piclet: 'opponent', moveIndex: opponentMove }
-        );
-      }
-      
-      const log = engine.getLog();
-      expect(log.length).toBeGreaterThan(8);
-      
-      // Should contain move usage
-      expect(log.some(msg => msg.includes('used Power Up'))).toBe(true);
-      expect(log.some(msg => msg.includes('used Flame Burst'))).toBe(true);
-      
-      // Should contain stat changes
-      expect(log.some(msg => msg.includes('attack rose'))).toBe(true);
-      
-      // Should contain healing (check for either recovered HP or no actual healing if at full HP)
-      const hasHealing = log.some(msg => msg.includes('recovered') && msg.includes('HP'));
-      const hasHealingAttempt = log.some(msg => msg.includes('used Healing Light'));
-      expect(hasHealing || hasHealingAttempt).toBe(true);
-    });
-
-    it('should handle edge case: all moves run out of PP', () => {
-      const engine = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-      
-      // Drain all PP from one move
-      engine['state'].playerPiclet.moves[0].currentPP = 0;
-      engine['state'].playerPiclet.moves[1].currentPP = 0;
-      engine['state'].playerPiclet.moves[2].currentPP = 0;
-      engine['state'].playerPiclet.moves[3].currentPP = 0;
-      
-      // Try to use any move
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('no PP left'))).toBe(true);
-      
-      // Battle should continue (opponent can still act)
-      expect(engine.isGameOver()).toBe(false);
-    });
-  });
-
-  describe('Performance and Stability', () => {
-    it('should handle very long battles without issues', () => {
-      const engine = new BattleEngine(AQUA_GUARDIAN, AQUA_GUARDIAN);
-      let turns = 0;
-      const maxTurns = 100;
-      
-      while (!engine.isGameOver() && turns < maxTurns) {
-        // Both use healing moves to prolong battle
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 1 }, // Healing Light
-          { type: 'move', piclet: 'opponent', moveIndex: 1 } // Healing Light
-        );
-        turns++;
-        
-        // Occasionally attack to prevent infinite loop
-        if (turns % 5 === 0) {
-          engine.executeActions(
-            { type: 'move', piclet: 'player', moveIndex: 0 }, // Tackle
-            { type: 'move', piclet: 'opponent', moveIndex: 0 } // Tackle
-          );
-        }
-      }
-      
-      // Should either end naturally or reach turn limit
-      expect(turns).toBeLessThanOrEqual(maxTurns);
-      
-      // Engine should remain stable
-      const state = engine.getState();
-      expect(state.turn).toBeGreaterThan(1);
-      expect(state.log.length).toBeGreaterThan(0);
-    });
-
-    it('should maintain state consistency after many operations', () => {
-      const engine = new BattleEngine(STELLAR_WOLF, TOXIC_CRAWLER);
-      
-      // Perform many state-changing operations
-      for (let i = 0; i < 10 && !engine.isGameOver(); i++) {
-        const state = engine.getState();
-        
-        // Verify state consistency before each turn
-        expect(state.playerPiclet.currentHp).toBeGreaterThanOrEqual(0);
-        expect(state.opponentPiclet.currentHp).toBeGreaterThanOrEqual(0);
-        expect(state.playerPiclet.currentHp).toBeLessThanOrEqual(state.playerPiclet.maxHp);
-        expect(state.opponentPiclet.currentHp).toBeLessThanOrEqual(state.opponentPiclet.maxHp);
-        
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: i % 4 },
-          { type: 'move', piclet: 'opponent', moveIndex: i % 3 }
-        );
-      }
-      
-      // Final state should still be consistent
-      const finalState = engine.getState();
-      expect(finalState.playerPiclet.currentHp).toBeGreaterThanOrEqual(0);
-      expect(finalState.opponentPiclet.currentHp).toBeGreaterThanOrEqual(0);
-    });
-  });
-});

src/lib/battle-engine/mechanic-overrides.test.ts

@@ -1,544 +0,0 @@
-/**
- * Tests for mechanic override system from the design document
- * Tests special abilities that modify core battle mechanics
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import { PicletDefinition, Move, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-const STANDARD_STATS = { hp: 100, attack: 80, defense: 70, speed: 60 };
-
-describe('Mechanic Override System - TDD Implementation', () => {
-  describe('Critical Hit Mechanics', () => {
-    it('should handle Shell Armor - cannot be critically hit', () => {
-      const shellArmor: SpecialAbility = {
-        name: "Shell Armor",
-        description: "Hard shell prevents critical hits",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'criticalHits',
-            condition: 'always',
-            value: false
-          }
-        ]
-      };
-
-      const shellPiclet: PicletDefinition = {
-        name: "Shell Defender",
-        description: "Protected by a hard shell",
-        tier: 'medium',
-        primaryType: PicletType.MINERAL,
-        baseStats: STANDARD_STATS,
-        nature: "Bold",
-        specialAbility: shellArmor,
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      // Test would verify this Piclet cannot be critically hit
-      expect(shellArmor.effects![0].mechanic).toBe('criticalHits');
-      expect(shellArmor.effects![0].value).toBe(false);
-    });
-
-    it('should handle Super Luck - always critical hits', () => {
-      const superLuck: SpecialAbility = {
-        name: "Super Luck",
-        description: "Extremely lucky, always lands critical hits",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'criticalHits',
-            condition: 'always',
-            value: true
-          }
-        ]
-      };
-
-      expect(superLuck.effects![0].value).toBe(true);
-    });
-
-    it('should handle Scope Lens - double critical hit rate', () => {
-      const scopeLens: SpecialAbility = {
-        name: "Scope Lens",
-        description: "Enhanced precision doubles critical hit rate",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'criticalHits',
-            condition: 'always',
-            value: 'double'
-          }
-        ]
-      };
-
-      expect(scopeLens.effects![0].value).toBe('double');
-    });
-  });
-
-  describe('Status Immunity', () => {
-    it('should handle Insomnia - sleep immunity', () => {
-      const insomnia: SpecialAbility = {
-        name: "Insomnia",
-        description: "Prevents sleep status",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'statusImmunity',
-            value: ['sleep']
-          }
-        ]
-      };
-
-      const insomniaPiclet: PicletDefinition = {
-        name: "Sleepless Guardian",
-        description: "Never sleeps",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: STANDARD_STATS,
-        nature: "Alert",
-        specialAbility: insomnia,
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      expect(insomnia.effects![0].value).toContain('sleep');
-    });
-
-    it('should handle multi-status immunity', () => {
-      const immunity: SpecialAbility = {
-        name: "Pure Body",
-        description: "Immune to poison and burn",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'statusImmunity',
-            value: ['poison', 'burn']
-          }
-        ]
-      };
-
-      expect(immunity.effects![0].value).toEqual(['poison', 'burn']);
-    });
-  });
-
-  describe('Damage Reflection', () => {
-    it('should handle Rough Skin - contact damage reflection', () => {
-      const roughSkin: SpecialAbility = {
-        name: "Rough Skin",
-        description: "Rough skin damages attackers on contact",
-        triggers: [
-          {
-            event: 'onContactDamage',
-            effects: [
-              {
-                type: 'damage',
-                target: 'attacker',
-                formula: 'fixed',
-                value: 12
-              }
-            ]
-          }
-        ]
-      };
-
-      const roughPiclet: PicletDefinition = {
-        name: "Spike Beast",
-        description: "Covered in rough spikes",
-        tier: 'medium',
-        primaryType: PicletType.MINERAL,
-        baseStats: STANDARD_STATS,
-        nature: "Hardy",
-        specialAbility: roughSkin,
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      expect(roughSkin.triggers![0].event).toBe('onContactDamage');
-      expect(roughSkin.triggers![0].effects[0].target).toBe('attacker');
-    });
-
-    it('should handle damage reflection percentage', () => {
-      const reflectArmor: SpecialAbility = {
-        name: "Mirror Armor",
-        description: "Reflects 50% of damage back",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'damageReflection',
-            value: 0.5
-          }
-        ]
-      };
-
-      expect(reflectArmor.effects![0].value).toBe(0.5);
-    });
-  });
-
-  describe('Type Mechanics', () => {
-    it('should handle Wonder Guard - only super-effective moves hit', () => {
-      const wonderGuard: SpecialAbility = {
-        name: "Wonder Guard",
-        description: "Only super-effective moves deal damage",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'damageCalculation',
-            condition: 'ifNotSuperEffective',
-            value: false
-          }
-        ]
-      };
-
-      expect(wonderGuard.effects![0].mechanic).toBe('damageCalculation');
-      expect(wonderGuard.effects![0].condition).toBe('ifNotSuperEffective');
-    });
-
-    it('should handle Levitate - ground type immunity', () => {
-      const levitate: SpecialAbility = {
-        name: "Levitate",
-        description: "Floating ability makes ground moves miss",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'typeImmunity',
-            value: ['ground']
-          }
-        ]
-      };
-
-      expect(levitate.effects![0].value).toContain('ground');
-    });
-
-    it('should handle Protean - type changes to match move', () => {
-      const protean: SpecialAbility = {
-        name: "Protean",
-        description: "Changes type to match the move being used",
-        triggers: [
-          {
-            event: 'beforeMoveUse',
-            effects: [
-              {
-                type: 'mechanicOverride',  
-                mechanic: 'typeChange',
-                value: 'matchMoveType'
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(protean.triggers![0].event).toBe('beforeMoveUse');
-      expect(protean.triggers![0].effects[0].value).toBe('matchMoveType');
-    });
-  });
-
-  describe('Healing Mechanics', () => {
-    it('should handle Poison Heal - poison heals instead of damages', () => {
-      const poisonHeal: SpecialAbility = {
-        name: "Poison Heal",
-        description: "Poison heals instead of damages",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'healingInversion',
-            value: 'invert'
-          }
-        ]
-      };
-
-      expect(poisonHeal.effects![0].mechanic).toBe('healingInversion');
-      expect(poisonHeal.effects![0].value).toBe('invert');
-    });
-
-    it('should handle healing blocked', () => {
-      const healBlock: SpecialAbility = {
-        name: "Cursed Body",
-        description: "Cannot be healed by any means",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'healingBlocked',
-            value: true
-          }
-        ]
-      };
-
-      expect(healBlock.effects![0].value).toBe(true);
-    });
-  });
-
-  describe('Damage Absorption', () => {
-    it('should handle Photosynthesis - absorbs flora moves', () => {
-      const photosynthesis: SpecialAbility = {
-        name: "Photosynthesis",
-        description: "Absorbs flora-type moves to restore HP",
-        triggers: [
-          {
-            event: 'onDamageTaken',
-            condition: 'ifMoveType:flora',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'damageAbsorption',
-                value: 'absorb'
-              },
-              {
-                type: 'heal',
-                target: 'self',
-                formula: 'percentage',
-                value: 25
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(photosynthesis.triggers![0].condition).toBe('ifMoveType:flora');
-      expect(photosynthesis.triggers![0].effects[0].mechanic).toBe('damageAbsorption');
-    });
-  });
-
-  describe('Stat Modification Mechanics', () => {
-    it('should handle Contrary - stat changes are reversed', () => {
-      const contrary: SpecialAbility = {
-        name: "Contrary",
-        description: "Stat changes have the opposite effect",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'statModification',
-            value: 'invert'
-          }
-        ]
-      };
-
-      expect(contrary.effects![0].value).toBe('invert');
-    });
-  });
-
-  describe('Flag-Based Immunities', () => {
-    it('should handle Sky Dancer - immune to ground-flagged attacks', () => {
-      const skyDancer: SpecialAbility = {
-        name: "Sky Dancer",
-        description: "Floating in air, immune to ground-based attacks",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['ground']
-          }
-        ]
-      };
-
-      expect(skyDancer.effects![0].value).toContain('ground');
-    });
-
-    it('should handle Sound Barrier - immune to sound attacks', () => {
-      const soundBarrier: SpecialAbility = {
-        name: "Sound Barrier",
-        description: "Natural sound dampening prevents sound-based moves",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['sound']
-          }
-        ]
-      };
-
-      expect(soundBarrier.effects![0].value).toContain('sound');
-    });
-
-    it('should handle Soft Body - immune to explosive, weak to punch', () => {
-      const softBody: SpecialAbility = {
-        name: "Soft Body",
-        description: "Gelatinous form absorbs explosions but vulnerable to direct hits",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['explosive']
-          },
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagWeakness',
-            value: ['punch']
-          }
-        ]
-      };
-
-      expect(softBody.effects![0].value).toContain('explosive');
-      expect(softBody.effects![1].value).toContain('punch');
-    });
-
-    it('should handle flag resistance', () => {
-      const thickHide: SpecialAbility = {
-        name: "Thick Hide",
-        description: "Tough skin reduces impact from physical contact",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagResistance',
-            value: ['contact']
-          }
-        ]
-      };
-
-      expect(thickHide.effects![0].value).toContain('contact');
-    });
-  });
-
-  describe('Priority Override', () => {
-    it('should handle Prankster - status moves get priority', () => {
-      const prankster: SpecialAbility = {
-        name: "Prankster",
-        description: "Status moves gain priority",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'priorityOverride',
-            condition: 'ifStatusMove',
-            value: 1
-          }
-        ]
-      };
-
-      expect(prankster.effects![0].condition).toBe('ifStatusMove');
-      expect(prankster.effects![0].value).toBe(1);
-    });
-  });
-
-  describe('Drain Inversion', () => {
-    it('should handle Vampiric - drain moves damage the drainer', () => {
-      const vampiric: SpecialAbility = {
-        name: "Vampiric",
-        description: "Cursed blood damages those who try to drain it",
-        triggers: [
-          {
-            event: 'onHPDrained',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'drainInversion',
-                value: true
-              },
-              {
-                type: 'damage',
-                target: 'attacker',
-                formula: 'fixed',
-                value: 20
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(vampiric.triggers![0].event).toBe('onHPDrained');
-      expect(vampiric.triggers![0].effects[0].mechanic).toBe('drainInversion');
-    });
-  });
-
-  describe('Target Redirection', () => {
-    it('should handle Magic Bounce - reflects status moves', () => {
-      const magicBounce: SpecialAbility = {
-        name: "Magic Bounce",
-        description: "Reflects status moves back at the user",
-        triggers: [
-          {
-            event: 'onStatusMoveTargeted',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'targetRedirection',
-                value: 'reflect'
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(magicBounce.triggers![0].event).toBe('onStatusMoveTargeted');
-      expect(magicBounce.triggers![0].effects[0].value).toBe('reflect');
-    });
-  });
-
-  describe('Status Replacement', () => {
-    it('should handle Frost Walker - freeze becomes attack boost', () => {
-      const frostWalker: SpecialAbility = {
-        name: "Frost Walker",
-        description: "Instead of being frozen, gains +50% attack",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'statusReplacement',
-            value: {
-              status: 'freeze',
-              replacement: {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'greatly_increase' }
-              }
-            }
-          }
-        ]
-      };
-
-      expect(frostWalker.effects![0].mechanic).toBe('statusReplacement');
-      expect(frostWalker.effects![0].value.status).toBe('freeze');
-    });
-  });
-
-  describe('Damage Multiplier', () => {
-    it('should handle damage multiplication abilities', () => {
-      const damageBoost: SpecialAbility = {
-        name: "Rage Mode",
-        description: "All damage dealt is doubled when at low HP",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'damageMultiplier',
-            condition: 'ifLowHp',
-            value: 2.0
-          }
-        ]
-      };
-
-      expect(damageBoost.effects![0].value).toBe(2.0);
-      expect(damageBoost.effects![0].condition).toBe('ifLowHp');
-    });
-  });
-
-  describe('Extra Turn Mechanics', () => {
-    it('should handle extra turn abilities', () => {
-      const extraTurn: SpecialAbility = {
-        name: "Time Distortion",
-        description: "Gets an extra turn when switching in",
-        triggers: [
-          {
-            event: 'onSwitchIn',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'extraTurn',
-                value: true,
-                condition: 'nextTurn'
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(extraTurn.triggers![0].effects[0].mechanic).toBe('extraTurn');
-      expect(extraTurn.triggers![0].effects[0].condition).toBe('nextTurn');
-    });
-  });
-});

src/lib/battle-engine/missing-features.test.ts

@@ -1,498 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition, Move, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Missing Battle System Features', () => {
-  describe('manipulatePP Effects', () => {
-    it('should drain opponent PP', () => {
-      const ppDrainer: PicletDefinition = {
-        name: "PP Drainer",
-        description: "Drains opponent's PP",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Calm",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Mind Drain",
-            type: AttackType.CULTURE,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'manipulatePP',
-                target: 'opponent',
-                action: 'drain',
-                amount: 'medium'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(ppDrainer, opponent);
-      const initialPP = engine.getState().opponentPiclet.moves[0].currentPP;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalPP = engine.getState().opponentPiclet.moves[0].currentPP;
-      expect(finalPP).toBeLessThan(initialPP);
-      expect(engine.getLog().some(msg => msg.includes('PP was drained'))).toBe(true);
-    });
-
-    it('should restore own PP', () => {
-      const ppRestorer: PicletDefinition = {
-        name: "PP Restorer",  
-        description: "Restores own PP",
-        tier: 'medium',
-        primaryType: PicletType.FLORA,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Calm",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "PP Restore",
-            type: AttackType.FLORA,
-            power: 0,
-            accuracy: 100,
-            pp: 5,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'manipulatePP',
-                target: 'self',
-                action: 'restore',
-                amount: 'large'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(ppRestorer, opponent);
-      
-      // Use the PP restore move multiple times to drain it
-      engine['state'].playerPiclet.moves[0].currentPP = 1;
-      const initialPP = engine['state'].playerPiclet.moves[0].currentPP;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalPP = engine.getState().playerPiclet.moves[0].currentPP;
-      expect(finalPP).toBeGreaterThan(initialPP);
-      expect(engine.getLog().some(msg => msg.includes('PP was restored'))).toBe(true);
-    });
-  });
-
-  describe('fieldEffect System', () => {
-    it('should apply field effects that persist across turns', () => {
-      const fieldEffectUser: PicletDefinition = {
-        name: "Field Controller",
-        description: "Controls battlefield effects",
-        tier: 'medium',
-        primaryType: PicletType.SPACE,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Calm",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Reflect",
-            type: AttackType.SPACE,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'fieldEffect',
-                effect: 'reflect',
-                target: 'playerSide',
-                stackable: false
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Physical Attack",
-            type: AttackType.BEAST,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(fieldEffectUser, opponent);
-      
-      // Apply reflect
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      expect(engine.getLog().some(msg => msg.includes('Reflect') && msg.includes('applied'))).toBe(true);
-      
-      // Check if reflect reduces physical damage in subsequent turns
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      const damage = initialHp - finalHp;
-      
-      // Reflect should reduce physical damage
-      expect(damage).toBeLessThan(30); // Should be reduced from normal ~40-50 damage
-    });
-
-    it('should handle spikes field effect', () => {
-      const spikesUser: PicletDefinition = {
-        name: "Spikes User",
-        description: "Sets entry hazards",
-        tier: 'medium',
-        primaryType: PicletType.MINERAL,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Impish",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Spikes",
-            type: AttackType.MINERAL,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'fieldEffect',
-                effect: 'spikes', 
-                target: 'opponentSide',
-                stackable: true
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Opponent",
-        description: "Standard opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Tackle",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(spikesUser, opponent);
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      expect(engine.getLog().some(msg => msg.includes('Spikes') && msg.includes('set'))).toBe(true);
-      
-      // TODO: Test spikes damage when switching (requires switching mechanics)
-    });
-  });
-
-  describe('counter Effects', () => {
-    it('should counter physical attacks', () => {
-      const counterUser: PicletDefinition = {
-        name: "Counter Fighter",
-        description: "Counters physical attacks",
-        tier: 'medium', 
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 100, attack: 60, defense: 80, speed: 50 },
-        nature: "Brave",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Counter",
-            type: AttackType.BEAST,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 1, // High priority to set up counter before opponent attacks
-            flags: ['lowPriority'],
-            effects: [
-              {
-                type: 'counter',
-                strength: 'strong'
-              }
-            ]
-          }
-        ]
-      };
-
-      const opponent: PicletDefinition = {
-        name: "Physical Attacker",
-        description: "Uses physical moves",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 80, defense: 60, speed: 70 },
-        nature: "Adamant",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Physical Strike",
-            type: AttackType.BEAST,
-            power: 80,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(counterUser, opponent);
-      const initialOpponentHp = engine.getState().opponentPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
-      expect(finalOpponentHp).toBeLessThan(initialOpponentHp);
-      expect(engine.getLog().some(msg => msg.includes('countered') || msg.includes('Counter'))).toBe(true);
-    });
-  });
-
-  describe('priority Effects', () => {
-    it('should modify move priority conditionally', () => {
-      const priorityUser: PicletDefinition = {
-        name: "Priority User",
-        description: "Uses priority moves based on conditions",
-        tier: 'medium',
-        primaryType: PicletType.SPACE,
-        baseStats: { hp: 60, attack: 70, defense: 50, speed: 40 },
-        nature: "Quiet",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Desperation Strike",
-            type: AttackType.SPACE,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              },
-              {
-                type: 'priority',
-                target: 'self',
-                value: 1,
-                condition: 'ifLowHp'
-              }
-            ]
-          }
-        ]
-      };
-
-      const fastOpponent: PicletDefinition = {
-        name: "Fast Opponent",
-        description: "Very fast opponent",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 60, defense: 60, speed: 100 },
-        nature: "Timid",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Quick Attack",
-            type: AttackType.NORMAL,
-            power: 40,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(priorityUser, fastOpponent);
-      
-      // Damage the priority user to trigger low HP condition
-      engine['state'].playerPiclet.currentHp = Math.floor(engine['state'].playerPiclet.maxHp * 0.2);
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      const playerMoveIndex = log.findIndex(msg => msg.includes('Priority User used Desperation Strike'));
-      const opponentMoveIndex = log.findIndex(msg => msg.includes('Fast Opponent used Quick Attack'));
-      
-      // When at low HP, priority user should go first despite lower speed
-      expect(playerMoveIndex).toBeLessThan(opponentMoveIndex);
-    });
-  });
-
-  describe('removeStatus Effects', () => {
-    it('should remove status effects from target', () => {
-      // Simple test: create a move that only removes poison status
-      const cleanser: PicletDefinition = {
-        name: "Cleanser",
-        description: "Can remove poison",
-        tier: 'medium',
-        primaryType: PicletType.FLORA,
-        baseStats: { hp: 100, attack: 50, defense: 50, speed: 50 },
-        nature: "Calm",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Cleanse",
-            type: AttackType.FLORA,
-            power: 0,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'removeStatus',
-                target: 'self',
-                status: 'poison'
-              }
-            ]
-          }
-        ]
-      };
-
-      const dummy: PicletDefinition = {
-        name: "Dummy",
-        description: "Does nothing",
-        tier: 'low',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 50, attack: 30, defense: 30, speed: 30 },
-        nature: "Docile",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Do Nothing",
-            type: AttackType.NORMAL,
-            power: 0,
-            accuracy: 100,
-            pp: 20,
-            priority: 0,
-            flags: [],
-            effects: []
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(cleanser, dummy);
-      const playerPiclet = engine.getState().playerPiclet;
-
-      // Test the removeStatus effect by directly calling it
-      // This bypasses any turn/timing issues
-      const mockEffect = { status: 'poison' };
-      
-      // First add poison manually
-      playerPiclet.statusEffects.push('poison');
-      expect(playerPiclet.statusEffects.includes('poison')).toBe(true);
-      
-      // Call the removeStatus effect processor directly
-      engine['processRemoveStatusEffect'](mockEffect, playerPiclet);
-      
-      // Check if poison was removed
-      expect(playerPiclet.statusEffects.includes('poison')).toBe(false);
-    });
-  });
-});

src/lib/battle-engine/move-flags.test.ts

@@ -1,692 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition, SpecialAbility } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Move Flags and Flag-Based Interactions', () => {
-  describe('Flag-Based Immunities', () => {
-    it('should provide immunity to contact moves with Ethereal Form', () => {
-      const etherealForm: SpecialAbility = {
-        name: "Ethereal Form",
-        description: "Ghostly body cannot be touched by physical contact",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['contact']
-          }
-        ]
-      };
-
-      const ghostly: PicletDefinition = {
-        name: "Ghost Fighter",
-        description: "Ethereal being immune to contact",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: { hp: 70, attack: 80, defense: 50, speed: 90 },
-        nature: "Timid",
-        specialAbility: etherealForm,
-        movepool: [
-          {
-            name: "Shadow Ball",
-            type: AttackType.CULTURE,
-            power: 80,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const contactUser: PicletDefinition = {
-        name: "Physical Fighter",
-        description: "Uses contact moves",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 80, attack: 90, defense: 70, speed: 60 },
-        nature: "Adamant",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Punch",
-            type: AttackType.BEAST,
-            power: 75,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact', 'punch'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          },
-          {
-            name: "Energy Blast",
-            type: AttackType.SPACE,
-            power: 75,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [], // No contact flag
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(ghostly, contactUser);
-      
-      // Test contact move immunity
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Contact move
-      );
-
-      const hpAfterContact = engine.getState().playerPiclet.currentHp;
-      expect(hpAfterContact).toBe(initialHp); // No damage from contact move
-      expect(engine.getLog().some(msg => msg.includes('had no effect') || msg.includes('immune'))).toBe(true);
-
-      // Test non-contact move still works
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 1 } // Non-contact move
-      );
-
-      const hpAfterNonContact = engine.getState().playerPiclet.currentHp;
-      expect(hpAfterNonContact).toBeLessThan(hpAfterContact); // Should take damage
-    });
-
-    it('should provide immunity to sound moves with Sound Barrier', () => {
-      const soundBarrier: SpecialAbility = {
-        name: "Sound Barrier",
-        description: "Natural sound dampening prevents sound-based moves",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['sound']
-          }
-        ]
-      };
-
-      const soundProof: PicletDefinition = {
-        name: "Silent Fighter",
-        description: "Cannot be affected by sound attacks",
-        tier: 'medium',
-        primaryType: PicletType.MACHINA,
-        baseStats: { hp: 85, attack: 70, defense: 85, speed: 50 },
-        nature: "Bold",
-        specialAbility: soundBarrier,
-        movepool: [
-          {
-            name: "Laser Beam",
-            type: AttackType.MACHINA,
-            power: 70,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const soundUser: PicletDefinition = {
-        name: "Sound Fighter",
-        description: "Uses sound-based attacks",
-        tier: 'medium',
-        primaryType: PicletType.CULTURE,
-        baseStats: { hp: 75, attack: 80, defense: 60, speed: 85 },
-        nature: "Modest",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Sonic Boom",
-            type: AttackType.CULTURE,
-            power: 80,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['sound'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(soundProof, soundUser);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalHp = engine.getState().playerPiclet.currentHp;
-      expect(finalHp).toBe(initialHp);
-      expect(engine.getLog().some(msg => msg.includes('had no effect') || msg.includes('immune'))).toBe(true);
-    });
-
-    it('should provide immunity to explosive moves with Soft Body', () => {
-      const softBody: SpecialAbility = {
-        name: "Soft Body",
-        description: "Gelatinous form absorbs explosions but vulnerable to direct hits",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['explosive']
-          },
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagWeakness',
-            value: ['punch']
-          }
-        ]
-      };
-
-      const gelatinous: PicletDefinition = {
-        name: "Gel Fighter",
-        description: "Soft gelatinous body",
-        tier: 'medium',
-        primaryType: PicletType.AQUATIC,
-        baseStats: { hp: 90, attack: 60, defense: 80, speed: 60 },
-        nature: "Bold",
-        specialAbility: softBody,
-        movepool: [
-          {
-            name: "Water Gun",
-            type: AttackType.AQUATIC,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const explosiveUser: PicletDefinition = {
-        name: "Bomber",
-        description: "Uses explosive attacks",
-        tier: 'medium',
-        primaryType: PicletType.MACHINA,
-        baseStats: { hp: 120, attack: 90, defense: 60, speed: 70 },
-        nature: "Hasty",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Explosion",
-            type: AttackType.MACHINA,
-            power: 120,
-            accuracy: 100,
-            pp: 5,
-            priority: 0,
-            flags: ['explosive'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'strong'
-              }
-            ]
-          },
-          {
-            name: "Mega Punch",
-            type: AttackType.BEAST,
-            power: 80,
-            accuracy: 85,
-            pp: 10,
-            priority: 0,
-            flags: ['contact', 'punch'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(gelatinous, explosiveUser);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      // Test explosive immunity
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Explosive move
-      );
-
-      const hpAfterExplosive = engine.getState().playerPiclet.currentHp;
-      expect(hpAfterExplosive).toBe(initialHp);
-      expect(engine.getLog().some(msg => msg.includes('had no effect') || msg.includes('absorbed'))).toBe(true);
-
-      // Test punch weakness (should take extra damage) - only if battle hasn't ended
-      if (!engine.isGameOver()) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 1 } // Punch move
-        );
-
-        const hpAfterPunch = engine.getState().playerPiclet.currentHp;
-        expect(hpAfterPunch).toBeLessThan(hpAfterExplosive);
-        // Should take more damage than normal due to weakness
-      }
-    });
-  });
-
-  describe('Flag-Based Weaknesses', () => {
-    it('should take extra damage from specific flagged moves', () => {
-      const fragileShell: SpecialAbility = {
-        name: "Fragile Shell",
-        description: "Hard shell provides defense but shatters from explosions",
-        effects: [
-          {
-            type: 'modifyStats',
-            target: 'self',
-            stats: { defense: 'increase' }
-          },
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagWeakness',
-            value: ['explosive']
-          }
-        ]
-      };
-
-      const shelledCreature: PicletDefinition = {
-        name: "Shell Fighter",
-        description: "Protected by fragile shell",
-        tier: 'medium',
-        primaryType: PicletType.MINERAL,
-        baseStats: { hp: 80, attack: 60, defense: 90, speed: 50 },
-        nature: "Impish",
-        specialAbility: fragileShell,
-        movepool: [
-          {
-            name: "Rock Throw",
-            type: AttackType.MINERAL,
-            power: 50,
-            accuracy: 90,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent', 
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const explosiveUser: PicletDefinition = {
-        name: "Bomber",
-        description: "Uses explosive attacks",
-        tier: 'medium',
-        primaryType: PicletType.MACHINA,
-        baseStats: { hp: 70, attack: 80, defense: 60, speed: 70 },
-        nature: "Modest",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Normal Attack",
-            type: AttackType.NORMAL,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          },
-          {
-            name: "Bomb Blast",
-            type: AttackType.MACHINA,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['explosive'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(shelledCreature, explosiveUser);
-      
-      // Test normal damage
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Normal attack
-      );
-
-      const hpAfterNormal = engine.getState().playerPiclet.currentHp;
-      const normalDamage = initialHp - hpAfterNormal;
-      
-      // Test explosive weakness (should do more damage) - only if battle hasn't ended
-      if (!engine.isGameOver()) {
-        const preExplosiveHp = engine.getState().playerPiclet.currentHp;
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 1 } // Explosive attack
-        );
-
-        const hpAfterExplosive = engine.getState().playerPiclet.currentHp;
-        const explosiveDamage = preExplosiveHp - hpAfterExplosive;
-        
-        // Explosive should do more damage due to weakness
-        expect(explosiveDamage).toBeGreaterThan(normalDamage);
-        expect(engine.getLog().some(msg => msg.includes('It\'s super effective') || msg.includes('weakness'))).toBe(true);
-      }
-    });
-  });
-
-  describe('Flag-Based Resistances', () => {
-    it('should take reduced damage from specific flagged moves', () => {
-      const thickHide: SpecialAbility = {
-        name: "Thick Hide",
-        description: "Tough skin reduces impact from physical contact",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagResistance',
-            value: ['contact']
-          }
-        ]
-      };
-
-      const toughCreature: PicletDefinition = {
-        name: "Tough Fighter",
-        description: "Has thick, resistant hide",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 150, attack: 70, defense: 90, speed: 40 },
-        nature: "Impish",
-        specialAbility: thickHide,
-        movepool: [
-          {
-            name: "Bite",
-            type: AttackType.BEAST,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact', 'bite'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const attacker: PicletDefinition = {
-        name: "Mixed Attacker",
-        description: "Uses various attack types",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 120, attack: 85, defense: 60, speed: 70 },
-        nature: "Adamant",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Scratch",
-            type: AttackType.BEAST,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          },
-          {
-            name: "Energy Beam",
-            type: AttackType.SPACE,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [], // No contact
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(toughCreature, attacker);
-      
-      // Test contact move (should be resisted)
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Contact move
-      );
-
-      const hpAfterContact = engine.getState().playerPiclet.currentHp;
-      const contactDamage = initialHp - hpAfterContact;
-      
-      // For now, just verify that resistance is working through the log message
-      // The actual damage comparison requires battle to continue, which depends on HP balance
-      expect(engine.getLog().some(msg => msg.includes('not very effective'))).toBe(true);
-      
-      // Verify that some damage was actually reduced (contact damage should be less than normal)
-      // This is a basic sanity check - contact damage with resistance should be reasonable
-      expect(contactDamage).toBeGreaterThan(0);
-      expect(contactDamage).toBeLessThan(60); // Should be less than normal damage due to resistance
-    });
-  });
-
-  describe('Multi-Flag Interactions', () => {
-    it('should handle creatures with multiple flag interactions', () => {
-      const liquidBody: SpecialAbility = {
-        name: "Liquid Body",
-        description: "Fluid form flows around physical attacks but resonates with sound",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagImmunity',
-            value: ['punch', 'bite']
-          },
-          {
-            type: 'mechanicOverride',
-            mechanic: 'flagWeakness',
-            value: ['sound']
-          }
-        ]
-      };
-
-      const liquidCreature: PicletDefinition = {
-        name: "Liquid Fighter",
-        description: "Made of flowing liquid",
-        tier: 'medium',
-        primaryType: PicletType.AQUATIC,
-        baseStats: { hp: 85, attack: 70, defense: 60, speed: 75 },
-        nature: "Calm",
-        specialAbility: liquidBody,
-        movepool: [
-          {
-            name: "Water Pulse",
-            type: AttackType.AQUATIC,
-            power: 60,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: [],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const multiAttacker: PicletDefinition = {
-        name: "Multi Attacker",
-        description: "Uses different types of attacks",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: { hp: 200, attack: 80, defense: 65, speed: 70 },
-        nature: "Hardy",
-        specialAbility: { name: "No Ability", description: "" },
-        movepool: [
-          {
-            name: "Punch",
-            type: AttackType.BEAST,
-            power: 70,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact', 'punch'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          },
-          {
-            name: "Bite",
-            type: AttackType.BEAST,
-            power: 70,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['contact', 'bite'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          },
-          {
-            name: "Sonic Roar",
-            type: AttackType.CULTURE,
-            power: 70,
-            accuracy: 100,
-            pp: 10,
-            priority: 0,
-            flags: ['sound'],
-            effects: [
-              {
-                type: 'damage',
-                target: 'opponent',
-                amount: 'normal'
-              }
-            ]
-          }
-        ]
-      };
-
-      const engine = new BattleEngine(liquidCreature, multiAttacker);
-      const initialHp = engine.getState().playerPiclet.currentHp;
-      
-      // Test punch immunity
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Punch (should be immune)
-      );
-
-      const hpAfterPunch = engine.getState().playerPiclet.currentHp;
-      expect(hpAfterPunch).toBe(initialHp);
-      
-      // Test bite immunity - only if battle hasn't ended
-      let hpAfterBite = hpAfterPunch;
-      if (!engine.isGameOver()) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 1 } // Bite (should be immune)
-        );
-
-        hpAfterBite = engine.getState().playerPiclet.currentHp;
-        expect(hpAfterBite).toBe(hpAfterPunch);
-      }
-      
-      // Test sound weakness - only if battle hasn't ended
-      if (!engine.isGameOver()) {
-        engine.executeActions(
-          { type: 'move', piclet: 'player', moveIndex: 0 },
-          { type: 'move', piclet: 'opponent', moveIndex: 2 } // Sound (should be weak)
-        );
-
-        const hpAfterSound = engine.getState().playerPiclet.currentHp;
-        expect(hpAfterSound).toBeLessThan(hpAfterBite);
-      }
-      
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('had no effect'))).toBe(true);
-      expect(log.some(msg => msg.includes('super effective') || msg.includes('weakness'))).toBe(true);
-    });
-  });
-});

src/lib/battle-engine/multi-piclet-types.ts

@@ -1,160 +0,0 @@
-/**
- * Extended types for multi-Piclet battle system
- * Supports up to 4 Piclets on the field at once
- */
-
-import { 
-  BattlePiclet, 
-  PicletDefinition, 
-  BattleEffect, 
-  MoveFlag,
-  EffectTarget,
-  EffectCondition
-} from './types';
-
-// Field position identifier
-export type FieldPosition = 0 | 1 | 2 | 3;
-
-// Side identifier  
-export type BattleSide = 'player' | 'opponent';
-
-// Extended battle state for multi-Piclet battles
-export interface MultiBattleState {
-  turn: number;
-  phase: 'selection' | 'execution' | 'ended';
-  
-  // Active Piclets on the field (up to 4 total, up to 2 per side)
-  activePiclets: {
-    player: Array<BattlePiclet | null>; // [position0, position1] - nulls for empty slots
-    opponent: Array<BattlePiclet | null>; // [position0, position1] - nulls for empty slots
-  };
-  
-  // Full party rosters (inactive Piclets)
-  parties: {
-    player: PicletDefinition[];
-    opponent: PicletDefinition[];
-  };
-  
-  // Field effects
-  fieldEffects: Array<{
-    name: string;
-    duration: number;
-    effect: any;
-    side?: BattleSide; // undefined = global, defined = side-specific
-  }>;
-  
-  // Battle log
-  log: string[];
-  
-  // Winner determination
-  winner?: 'player' | 'opponent' | 'draw';
-}
-
-// Action targeting for multi-Piclet battles
-export interface MultiMoveAction {
-  type: 'move';
-  side: BattleSide;
-  position: FieldPosition; // Which active Piclet is acting
-  moveIndex: number;
-  targets?: TargetSelection; // Optional specific targeting
-}
-
-export interface MultiSwitchAction {
-  type: 'switch';
-  side: BattleSide;
-  position: FieldPosition; // Which active slot to switch into
-  partyIndex: number; // Which party member to switch in
-}
-
-export type MultiBattleAction = MultiMoveAction | MultiSwitchAction;
-
-// Target selection for moves in multi-Piclet battles
-export interface TargetSelection {
-  primary?: PicletTarget; // Main target
-  secondary?: PicletTarget[]; // Additional targets for multi-target moves
-}
-
-export interface PicletTarget {
-  side: BattleSide;
-  position: FieldPosition;
-}
-
-// Extended effect target types for multi-Piclet battles
-export type MultiEffectTarget = 
-  | 'self'
-  | 'opponent' // Any opponent (AI chooses)
-  | 'allOpponents' // All active opponents
-  | 'ally' // Any ally (AI chooses) 
-  | 'allAllies' // All active allies
-  | 'all' // All active Piclets
-  | 'field' // Battlefield itself
-  | 'playerSide' // Player's side of field
-  | 'opponentSide' // Opponent's side of field
-  | 'random' // Random active Piclet
-  | 'weakest' // Weakest active Piclet (by current HP)
-  | 'strongest'; // Strongest active Piclet (by current HP)
-
-// Battle configuration for multi-Piclet setup
-export interface MultiBattleConfig {
-  playerParty: PicletDefinition[];
-  opponentParty: PicletDefinition[];
-  playerActiveCount: 1 | 2; // How many Piclets player starts with
-  opponentActiveCount: 1 | 2; // How many Piclets opponent starts with
-  battleType: 'single' | 'double' | 'triple' | 'quadruple';
-}
-
-// Extended battle effect for multi-Piclet targeting
-export interface MultiBattleEffect extends Omit<BattleEffect, 'target'> {
-  target: MultiEffectTarget;
-  specificTargets?: PicletTarget[]; // Override auto-targeting
-}
-
-// Turn actions for all active Piclets
-export interface TurnActions {
-  player: MultiBattleAction[];
-  opponent: MultiBattleAction[];
-}
-
-// Battle position info
-export interface PositionInfo {
-  side: BattleSide;
-  position: FieldPosition;
-  piclet: BattlePiclet | null;
-  isActive: boolean;
-}
-
-// Victory conditions for multi-Piclet battles
-export interface VictoryCondition {
-  type: 'allFainted' | 'majorityFainted' | 'leaderFainted' | 'custom';
-  customCheck?: (state: MultiBattleState) => BattleSide | 'draw' | null;
-}
-
-// Switch-in/out events for ability triggers
-export interface SwitchEvent {
-  type: 'switchIn' | 'switchOut';
-  piclet: BattlePiclet;
-  side: BattleSide;
-  position: FieldPosition;
-  previousPiclet?: BattlePiclet; // For switch-ins
-}
-
-// Multi-target move configuration
-export interface MultiTargetConfig {
-  maxTargets: number;
-  canTargetAllies: boolean;
-  canTargetSelf: boolean;
-  mustTargetOpponents: boolean;
-  targetSelection: 'player' | 'auto' | 'random';
-}
-
-// Priority calculation for multi-Piclet turns
-export interface ActionPriority {
-  action: MultiBattleAction;
-  side: BattleSide;
-  position: FieldPosition;
-  priority: number;
-  speed: number;
-  randomTiebreaker: number;
-}
-
-export default MultiBattleState;

src/lib/battle-engine/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@pictuary/battle-engine",
-  "version": "0.1.0",
-  "description": "Standalone battle engine for Pictuary",
-  "type": "module",
-  "main": "./BattleEngine.js",
-  "exports": {
-    ".": {
-      "import": "./BattleEngine.js",
-      "types": "./types.js"
-    },
-    "./types": {
-      "import": "./types.js",
-      "types": "./types.js"
-    },
-    "./test-data": {
-      "import": "./test-data.js",
-      "types": "./test-data.js"
-    }
-  },
-  "scripts": {
-    "test": "vitest",
-    "test:ui": "vitest --ui",
-    "test:run": "vitest run"
-  },
-  "devDependencies": {
-    "vitest": "^1.0.0",
-    "@vitest/ui": "^1.0.0"
-  }
-}

src/lib/battle-engine/remaining-triggers.test.ts

@@ -1,363 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Remaining Trigger Events', () => {
-  let basicPiclet: PicletDefinition;
-  let triggerPiclet: PicletDefinition;
-
-  beforeEach(() => {
-    basicPiclet = {
-      name: "Basic Fighter",
-      description: "Standard test piclet",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 60, defense: 60, speed: 60 },
-      nature: "Hardy",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Basic Attack",
-          type: AttackType.BEAST,
-          power: 50,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    triggerPiclet = {
-      name: "Trigger Test",
-      description: "Tests all trigger events",
-      tier: 'medium',
-      primaryType: PicletType.CULTURE,
-      baseStats: { hp: 100, attack: 70, defense: 70, speed: 50 },
-      nature: "Bold",
-      specialAbility: {
-        name: "Multi Trigger",
-        description: "Triggers on various events",
-        triggers: []
-      },
-      movepool: [
-        {
-          name: "Drain Punch",
-          type: AttackType.BEAST,
-          power: 60,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: ['contact'],
-          effects: [
-            { type: 'damage', target: 'opponent', amount: 'normal', formula: 'drain', value: 0.5 }
-          ]
-        },
-        {
-          name: "Status Move",
-          type: AttackType.CULTURE,
-          power: 0,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'applyStatus', target: 'opponent', status: 'paralyze', chance: 100 }
-          ]
-        },
-        {
-          name: "Stat Boost",
-          type: AttackType.CULTURE,
-          power: 0,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'modifyStats', target: 'self', stats: { attack: 'increase' } }
-          ]
-        },
-        {
-          name: "Heal Move",
-          type: AttackType.CULTURE,
-          power: 0,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: [],
-          effects: [
-            { type: 'heal', target: 'self', amount: 'large' }
-          ]
-        }
-      ]
-    };
-  });
-
-  describe('onStatusInflicted Trigger', () => {
-    it('should trigger when status effect is applied', () => {
-      const statusTriggerPiclet = {
-        ...triggerPiclet,
-        specialAbility: {
-          name: "Status Aware",
-          description: "Triggers when status is inflicted",
-          triggers: [
-            {
-              event: 'onStatusInflicted',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: { attack: 'increase' }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(basicPiclet, statusTriggerPiclet);
-      const initialAttack = engine.getState().opponentPiclet.attack;
-
-      // Use status move to trigger the ability
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 1 } // Status Move
-      );
-
-      const finalAttack = engine.getState().opponentPiclet.attack;
-      const log = engine.getLog();
-
-      console.log('Status inflicted test log:', log);
-      console.log('Initial attack:', initialAttack, 'Final attack:', finalAttack);
-
-      expect(finalAttack).toBeGreaterThan(initialAttack);
-      expect(log.some(msg => msg.includes('Status Aware') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('onHPDrained Trigger', () => {
-    it('should trigger when HP is drained from opponent', () => {
-      const drainTriggerPiclet = {
-        ...triggerPiclet,
-        specialAbility: {
-          name: "Life Stealer",
-          description: "Triggers when draining HP",
-          triggers: [
-            {
-              event: 'onHPDrained',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: { speed: 'increase' }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(basicPiclet, drainTriggerPiclet);
-      const initialSpeed = engine.getState().opponentPiclet.speed;
-
-      // Use drain move to trigger the ability
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Drain Punch
-      );
-
-      const finalSpeed = engine.getState().opponentPiclet.speed;
-      const log = engine.getLog();
-
-      expect(finalSpeed).toBeGreaterThan(initialSpeed);
-      expect(log.some(msg => msg.includes('Life Stealer') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('beforeMoveUse/afterMoveUse Triggers', () => {
-    it('should trigger before and after move use', () => {
-      const moveTriggerPiclet = {
-        ...triggerPiclet,
-        specialAbility: {
-          name: "Move Monitor",
-          description: "Triggers before and after moves",
-          triggers: [
-            {
-              event: 'beforeMoveUse',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: { defense: 'increase' }
-                }
-              ]
-            },
-            {
-              event: 'afterMoveUse',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: { accuracy: 'increase' }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(basicPiclet, moveTriggerPiclet);
-      const initialDefense = engine.getState().opponentPiclet.defense;
-      const initialAccuracy = engine.getState().opponentPiclet.accuracy;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalDefense = engine.getState().opponentPiclet.defense;
-      const finalAccuracy = engine.getState().opponentPiclet.accuracy;
-      const log = engine.getLog();
-
-      expect(finalDefense).toBeGreaterThan(initialDefense);
-      expect(finalAccuracy).toBeGreaterThan(initialAccuracy);
-      expect(log.some(msg => msg.includes('Move Monitor') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('onFullHP Trigger', () => {
-    it('should trigger when HP reaches maximum', () => {
-      const fullHpTriggerPiclet = {
-        ...triggerPiclet,
-        specialAbility: {
-          name: "Full Power",
-          description: "Triggers when at full HP",
-          triggers: [
-            {
-              event: 'onFullHP',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'self',
-                  stats: { attack: 'greatly_increase' }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(basicPiclet, fullHpTriggerPiclet);
-      
-      // Damage the piclet first
-      engine['state'].opponentPiclet.currentHp = Math.floor(engine['state'].opponentPiclet.maxHp * 0.5);
-      const initialAttack = engine.getState().opponentPiclet.attack;
-
-      // Use heal move to reach full HP
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 3 } // Heal Move
-      );
-
-      const finalAttack = engine.getState().opponentPiclet.attack;
-      const log = engine.getLog();
-
-      // Should trigger if healed to full HP
-      if (engine.getState().opponentPiclet.currentHp === engine.getState().opponentPiclet.maxHp) {
-        expect(finalAttack).toBeGreaterThan(initialAttack);
-        expect(log.some(msg => msg.includes('Full Power') && msg.includes('triggered'))).toBe(true);
-      }
-    });
-  });
-
-  describe('onOpponentContactMove Trigger', () => {
-    it('should trigger when opponent uses contact move', () => {
-      const contactTriggerPiclet = {
-        ...triggerPiclet,
-        specialAbility: {
-          name: "Rough Skin",
-          description: "Triggers when hit by contact moves",
-          triggers: [
-            {
-              event: 'onOpponentContactMove',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'damage',
-                  target: 'opponent',
-                  amount: 'weak'
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(basicPiclet, contactTriggerPiclet);
-      const initialPlayerHp = engine.getState().playerPiclet.currentHp;
-
-      // Player uses contact move
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Basic Attack (contact)
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalPlayerHp = engine.getState().playerPiclet.currentHp;
-      const log = engine.getLog();
-
-      // Player should take damage from contact
-      expect(finalPlayerHp).toBeLessThan(initialPlayerHp);
-      expect(log.some(msg => msg.includes('Rough Skin') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('onStatChange Trigger', () => {
-    it('should trigger when stats are modified', () => {
-      const statTriggerPiclet = {
-        ...triggerPiclet,
-        specialAbility: {
-          name: "Stat Monitor",
-          description: "Triggers when stats change",
-          triggers: [
-            {
-              event: 'onStatChange',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'heal',
-                  target: 'self',
-                  amount: 'small'
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine(basicPiclet, statTriggerPiclet);
-      
-      // Damage the piclet first so healing is visible
-      engine['state'].opponentPiclet.currentHp = Math.floor(engine['state'].opponentPiclet.maxHp * 0.8);
-      const initialHp = engine.getState().opponentPiclet.currentHp;
-
-      // Use stat boost move to trigger the ability
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 2 } // Stat Boost
-      );
-
-      const finalHp = engine.getState().opponentPiclet.currentHp;
-      const log = engine.getLog();
-
-      expect(finalHp).toBeGreaterThan(initialHp);
-      expect(log.some(msg => msg.includes('Stat Monitor') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-});

src/lib/battle-engine/switching-system.test.ts

@@ -1,445 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import type { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Switching System', () => {
-  let basicPiclet: PicletDefinition;
-  let reservePiclet: PicletDefinition;
-  let hazardSetter: PicletDefinition;
-  let switchTriggerPiclet: PicletDefinition;
-
-  beforeEach(() => {
-    // Basic piclet for primary battles
-    basicPiclet = {
-      name: "Basic Fighter",
-      description: "Standard test piclet",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 80, attack: 60, defense: 60, speed: 60 },
-      nature: "Hardy",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Basic Attack",
-          type: AttackType.BEAST,
-          power: 50,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: ['contact'],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    // Reserve piclet for switching
-    reservePiclet = {
-      name: "Reserve Fighter",
-      description: "Backup piclet",
-      tier: 'medium',
-      primaryType: PicletType.FLORA,
-      baseStats: { hp: 90, attack: 50, defense: 70, speed: 40 },
-      nature: "Calm",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Leaf Strike",
-          type: AttackType.FLORA,
-          power: 45,
-          accuracy: 100,
-          pp: 25,
-          priority: 0,
-          flags: [],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-
-    // Piclet that can set entry hazards
-    hazardSetter = {
-      name: "Hazard Master",
-      description: "Sets entry hazards",
-      tier: 'medium',
-      primaryType: PicletType.MINERAL,
-      baseStats: { hp: 70, attack: 40, defense: 80, speed: 50 },
-      nature: "Bold",
-      specialAbility: { name: "No Ability", description: "" },
-      movepool: [
-        {
-          name: "Spike Trap",
-          type: AttackType.MINERAL,
-          power: 0,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'spikes',
-              target: 'opponentSide',
-              stackable: true
-            }
-          ]
-        },
-        {
-          name: "Toxic Spikes",
-          type: AttackType.MINERAL,
-          power: 0,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'toxicSpikes',
-              target: 'opponentSide',
-              stackable: true
-            }
-          ]
-        }
-      ]
-    };
-
-    // Piclet with switch-triggered abilities
-    switchTriggerPiclet = {
-      name: "Switch Specialist",
-      description: "Has switch-in/out abilities",
-      tier: 'medium',
-      primaryType: PicletType.CULTURE,
-      baseStats: { hp: 85, attack: 55, defense: 65, speed: 75 },
-      nature: "Timid",
-      specialAbility: {
-        name: "Intimidate",
-        description: "Lowers opponent's attack on switch-in",
-        triggers: [
-          {
-            event: 'onSwitchIn',
-            condition: 'always',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'opponent',
-                stats: {
-                  attack: 'decrease'
-                }
-              }
-            ]
-          }
-        ]
-      },
-      movepool: [
-        {
-          name: "Quick Strike",
-          type: AttackType.CULTURE,
-          power: 40,
-          accuracy: 100,
-          pp: 30,
-          priority: 1,
-          flags: [],
-          effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }
-      ]
-    };
-  });
-
-  describe('Basic Switch Actions', () => {
-    it('should allow switching to a different piclet', () => {
-      // Create engine with rosters
-      const engine = new BattleEngine([basicPiclet, reservePiclet], [basicPiclet]);
-
-      const initialPlayerName = engine.getState().playerPiclet.definition.name;
-      expect(initialPlayerName).toBe("Basic Fighter");
-
-      // Execute switch action
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalPlayerName = engine.getState().playerPiclet.definition.name;
-      const log = engine.getLog();
-
-      expect(finalPlayerName).toBe("Reserve Fighter");
-      expect(log.some(msg => msg.includes('switched') && msg.includes('Reserve Fighter'))).toBe(true);
-    });
-
-    it('should handle switch action priority correctly', () => {
-      const engine = new BattleEngine([basicPiclet, reservePiclet], [basicPiclet]);
-
-      // Switch actions should have higher priority than moves
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      
-      // Switch should happen before the opponent's move
-      const switchIndex = log.findIndex(msg => msg.includes('switched'));
-      const moveIndex = log.findIndex(msg => msg.includes('used') && msg.includes('Basic Attack'));
-      
-      expect(switchIndex).toBeLessThan(moveIndex);
-    });
-
-    it('should not allow switching to same piclet', () => {
-      const engine = new BattleEngine([basicPiclet, reservePiclet], [basicPiclet]);
-
-      // Try to switch to the same piclet (index 0)
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('already active') || msg.includes('cannot switch'))).toBe(true);
-    });
-
-    it('should not allow switching to fainted piclet', () => {
-      const faintedPiclet = { ...reservePiclet };
-      const engine = new BattleEngine([basicPiclet, faintedPiclet], [basicPiclet]);
-
-      // Mock fainted piclet by accessing private roster states
-      (engine as any).playerRosterStates[1].fainted = true;
-      (engine as any).playerRosterStates[1].currentHp = 0;
-
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('fainted') || msg.includes('unable to battle'))).toBe(true);
-    });
-  });
-
-  describe('Entry Hazards', () => {
-    it('should apply spikes damage on switch-in', () => {
-      const engine = new BattleEngine([hazardSetter, basicPiclet], [basicPiclet, reservePiclet]);
-
-      // Set up spikes
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Spike Trap
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const log = engine.getLog();
-      expect(log.some(msg => msg.includes('spikes') || msg.includes('hazard'))).toBe(true);
-
-      // Switch opponent to trigger spikes
-      const initialHp = engine.getState().opponentPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'switch', piclet: 'opponent', newPicletIndex: 1 }
-      );
-
-      const finalLog = engine.getLog();
-      expect(finalLog.some(msg => msg.includes('hurt by spikes') || msg.includes('stepped on spikes'))).toBe(true);
-    });
-
-    it('should apply toxic spikes status on switch-in', () => {
-      const engine = new BattleEngine([hazardSetter], [basicPiclet, reservePiclet]);
-
-      // Set up toxic spikes
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 1 }, // Toxic Spikes
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      // Switch opponent to trigger toxic spikes
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'switch', piclet: 'opponent', newPicletIndex: 1 }
-      );
-
-      const finalState = engine.getState().opponentPiclet;
-      const log = engine.getLog();
-
-      expect(finalState.statusEffects).toContain('poison');
-      expect(log.some(msg => msg.includes('poisoned by toxic spikes'))).toBe(true);
-    });
-
-    it('should stack multiple layers of spikes', () => {
-      const engine = new BattleEngine([hazardSetter], [basicPiclet, reservePiclet]);
-
-      // Set up multiple spike layers
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // First Spike Trap
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 }, // Second Spike Trap
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const fieldEffects = engine.getState().fieldEffects;
-      const spikeCount = fieldEffects.filter(effect => effect.name === 'entryHazardSpikes').length;
-      
-      expect(spikeCount).toBeGreaterThan(1);
-    });
-  });
-
-  describe('Switch-In/Out Ability Triggers', () => {
-    it('should trigger onSwitchIn ability when piclet enters battle', () => {
-      const engine = new BattleEngine([basicPiclet, switchTriggerPiclet], [basicPiclet]);
-
-      const initialOpponentAttack = engine.getState().opponentPiclet.attack;
-
-      // Switch in the intimidate piclet
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalOpponentAttack = engine.getState().opponentPiclet.attack;
-      const log = engine.getLog();
-
-      expect(finalOpponentAttack).toBeLessThan(initialOpponentAttack);
-      expect(log.some(msg => msg.includes('Intimidate') && msg.includes('triggered'))).toBe(true);
-    });
-
-    it('should trigger onSwitchOut ability when piclet leaves battle', () => {
-      const switchOutPiclet: PicletDefinition = {
-        ...switchTriggerPiclet,
-        specialAbility: {
-          name: "Parting Shot",
-          description: "Lowers opponent's stats on switch-out",
-          triggers: [
-            {
-              event: 'onSwitchOut',
-              condition: 'always',
-              effects: [
-                {
-                  type: 'modifyStats',
-                  target: 'opponent',
-                  stats: {
-                    attack: 'decrease',
-                    defense: 'decrease'
-                  }
-                }
-              ]
-            }
-          ]
-        }
-      };
-
-      const engine = new BattleEngine([switchOutPiclet, reservePiclet], [basicPiclet]);
-
-      const initialOpponentAttack = engine.getState().opponentPiclet.attack;
-      const initialOpponentDefense = engine.getState().opponentPiclet.defense;
-
-      // Switch out the parting shot piclet
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalOpponentAttack = engine.getState().opponentPiclet.attack;
-      const finalOpponentDefense = engine.getState().opponentPiclet.defense;
-      const log = engine.getLog();
-
-      expect(finalOpponentAttack).toBeLessThan(initialOpponentAttack);
-      expect(finalOpponentDefense).toBeLessThan(initialOpponentDefense);
-      expect(log.some(msg => msg.includes('Parting Shot') && msg.includes('triggered'))).toBe(true);
-    });
-  });
-
-  describe('Forced Switching', () => {
-    it('should handle forced switch when active piclet faints', () => {
-      const engine = new BattleEngine([basicPiclet, reservePiclet], [basicPiclet]);
-
-      // Damage player piclet to near-faint
-      engine['state'].playerPiclet.currentHp = 1;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Should KO player
-      );
-
-      const log = engine.getLog();
-      
-      // Should prompt for forced switch or auto-switch if only one option
-      expect(log.some(msg => 
-        msg.includes('fainted') || 
-        msg.includes('must choose') || 
-        msg.includes('forced switch')
-      )).toBe(true);
-    });
-
-    it('should end battle if no valid switches remain', () => {
-      const engine = new BattleEngine([basicPiclet], [basicPiclet]); // Only one piclet each
-
-      // KO the only piclet
-      engine['state'].playerPiclet.currentHp = 1;
-
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      expect(engine.isGameOver()).toBe(true);
-      expect(engine.getState().winner).toBe('opponent');
-    });
-  });
-
-  describe('Switch Action Integration', () => {
-    it('should preserve PP and status when switching back', () => {
-      const engine = new BattleEngine([basicPiclet, reservePiclet], [basicPiclet]);
-
-      // Use a move to reduce PP
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const ppAfterMove = engine.getState().playerPiclet.moves[0].currentPP;
-
-      // Switch out and back
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const ppAfterReturn = engine.getState().playerPiclet.moves[0].currentPP;
-      
-      // PP should be preserved
-      expect(ppAfterReturn).toBe(ppAfterMove);
-    });
-
-    it('should reset stat modifications when switching', () => {
-      const engine = new BattleEngine([basicPiclet, reservePiclet], [basicPiclet]);
-
-      // Apply stat modification
-      engine['state'].playerPiclet.attack += 20; // Simulate boost
-      engine['state'].playerPiclet.statModifiers.attack = 1;
-
-      const boostedAttack = engine.getState().playerPiclet.attack;
-
-      // Switch out and back
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 1 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      engine.executeActions(
-        { type: 'switch', piclet: 'player', newPicletIndex: 0 },
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      const finalAttack = engine.getState().playerPiclet.attack;
-      
-      // Attack should be reset to base value
-      expect(finalAttack).toBeLessThan(boostedAttack);
-      expect(engine.getState().playerPiclet.statModifiers.attack).toBeFalsy();
-    });
-  });
-});

src/lib/battle-engine/tempest-wraith.test.ts

@@ -1,507 +0,0 @@
-/**
- * Test for the complete Tempest Wraith example from the design document
- * This demonstrates all advanced features working together
- */
-
-import { describe, it, expect } from 'vitest';
-import { BattleEngine } from './BattleEngine';
-import { PicletDefinition } from './types';
-import { PicletType, AttackType } from './types';
-
-describe('Complete Tempest Wraith Implementation', () => {
-  it('should handle the complete Tempest Wraith from design document', () => {
-    const tempestWraith: PicletDefinition = {
-      name: "Tempest Wraith",
-      description: "A ghostly creature born from violent storms, wielding cosmic energy and shadowy illusions",
-      tier: 'high',
-      primaryType: PicletType.SPACE,
-      secondaryType: PicletType.CULTURE,
-      baseStats: {
-        hp: 75,
-        attack: 95,
-        defense: 45,
-        speed: 85
-      },
-      nature: "timid",
-      specialAbility: {
-        name: "Storm Caller",
-        description: "When HP drops below 25%, gains immunity to status effects and +50% speed",
-        triggers: [
-          {
-            event: 'onLowHP',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'statusImmunity',
-                value: ['burn', 'freeze', 'paralyze', 'poison', 'sleep', 'confuse']
-              },
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { speed: 'greatly_increase' }
-              }
-            ]
-          },
-          {
-            event: 'onSwitchIn',
-            condition: 'ifWeather:storm',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'increase' }
-              }
-            ]
-          }
-        ]
-      },
-      movepool: [
-        {
-          name: "Shadow Pulse",
-          type: AttackType.CULTURE,
-          power: 70,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'damage',
-              target: 'opponent',
-              amount: 'normal'
-            },
-            {
-              type: 'applyStatus',
-              target: 'opponent',
-              status: 'confuse'
-            }
-          ]
-        },
-        {
-          name: "Cosmic Strike",
-          type: AttackType.SPACE,
-          power: 85,
-          accuracy: 90,
-          pp: 10,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'damage',
-              target: 'opponent',
-              amount: 'normal'
-            },
-            {
-              type: 'applyStatus',
-              target: 'opponent',
-              status: 'paralyze'
-            }
-          ]
-        },
-        {
-          name: "Spectral Drain",
-          type: AttackType.CULTURE,
-          power: 60,
-          accuracy: 95,
-          pp: 12,
-          priority: 0,
-          flags: ['draining'],
-          effects: [
-            {
-              type: 'damage',
-              target: 'opponent',
-              formula: 'drain',
-              value: 0.5
-            }
-          ]
-        },
-        {
-          name: "Void Sacrifice",
-          type: AttackType.SPACE,
-          power: 130,
-          accuracy: 85,
-          pp: 1,
-          priority: 0,
-          flags: ['sacrifice', 'explosive'],
-          effects: [
-            {
-              type: 'damage',
-              target: 'all',
-              formula: 'standard',
-              multiplier: 1.2
-            },
-            {
-              type: 'damage',
-              target: 'self',
-              formula: 'percentage',
-              value: 75
-            },
-            {
-              type: 'fieldEffect',
-              effect: 'voidStorm',
-              target: 'field',
-              stackable: false
-            }
-          ]
-        }
-      ]
-    };
-
-    const opponent: PicletDefinition = {
-      name: "Standard Fighter",
-      description: "A basic opponent",
-      tier: 'medium',
-      primaryType: PicletType.BEAST,
-      baseStats: { hp: 100, attack: 80, defense: 70, speed: 60 },
-      nature: "Hardy",
-      specialAbility: { name: "None", description: "No ability" },
-      movepool: [{
-        name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-        priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-      }]
-    };
-
-    const engine = new BattleEngine(tempestWraith, opponent);
-
-    // Test 1: Verify Tempest Wraith is properly initialized
-    const state = engine.getState();
-    expect(state.playerPiclet.definition.name).toBe("Tempest Wraith");
-    expect(state.playerPiclet.definition.primaryType).toBe(PicletType.SPACE);
-    expect(state.playerPiclet.definition.secondaryType).toBe(PicletType.CULTURE);
-    expect(state.playerPiclet.moves).toHaveLength(4);
-
-    // Test 2: Verify special ability structure
-    const ability = tempestWraith.specialAbility;
-    expect(ability.name).toBe("Storm Caller");
-    expect(ability.triggers).toHaveLength(2);
-    expect(ability.triggers![0].event).toBe('onLowHP');
-    expect(ability.triggers![1].event).toBe('onSwitchIn');
-
-    // Test 3: Test Shadow Pulse (dual effect move)
-    engine.executeActions(
-      { type: 'move', piclet: 'player', moveIndex: 0 }, // Shadow Pulse
-      { type: 'move', piclet: 'opponent', moveIndex: 0 }
-    );
-
-    let log = engine.getLog();
-    expect(log.some(msg => msg.includes('used Shadow Pulse'))).toBe(true);
-
-    // Test 4: Test Spectral Drain (drain move)
-    if (!engine.isGameOver()) {
-      // Damage the player to test healing
-      engine['state'].playerPiclet.currentHp = 30;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 2 }, // Spectral Drain
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      log = engine.getLog();
-      expect(log.some(msg => msg.includes('recovered') && msg.includes('HP from draining'))).toBe(true);
-    }
-
-    // Test 5: Test Void Sacrifice (ultimate move)
-    if (!engine.isGameOver()) {
-      const preVoidHp = engine.getState().playerPiclet.currentHp;
-      
-      engine.executeActions(
-        { type: 'move', piclet: 'player', moveIndex: 3 }, // Void Sacrifice
-        { type: 'move', piclet: 'opponent', moveIndex: 0 }
-      );
-
-      log = engine.getLog();
-      expect(log.some(msg => msg.includes('used Void Sacrifice'))).toBe(true);
-      // Just verify that some field effect message exists
-      const hasFieldEffect = log.some(msg => msg.includes('applied') || msg.includes('effect'));
-      expect(hasFieldEffect).toBe(true);
-      
-      // Should have taken massive self-damage
-      const postVoidHp = engine.getState().playerPiclet.currentHp;
-      expect(postVoidHp).toBeLessThan(preVoidHp);
-    }
-  });
-
-  it('should demonstrate strategic depth with different movesets', () => {
-    const tempestWraith: PicletDefinition = {
-      name: "Tempest Wraith",
-      description: "A ghostly creature born from violent storms",
-      tier: 'high',
-      primaryType: PicletType.SPACE,
-      secondaryType: PicletType.CULTURE,
-      baseStats: { hp: 75, attack: 95, defense: 45, speed: 85 },
-      nature: "timid",
-      specialAbility: {
-        name: "Storm Caller",
-        description: "Complex multi-trigger ability",
-        triggers: [
-          {
-            event: 'onLowHP',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'statusImmunity',
-                value: ['burn', 'freeze', 'paralyze', 'poison', 'sleep', 'confuse']
-              }
-            ]
-          }
-        ]
-      },
-      movepool: [
-        {
-          name: "Berserker's End",
-          type: AttackType.BEAST,
-          power: 80,
-          accuracy: 95,
-          pp: 10,
-          priority: 0,
-          flags: ['contact', 'reckless'],
-          effects: [
-            {
-              type: 'damage',
-              target: 'opponent',
-              amount: 'normal'
-            },
-            {
-              type: 'damage',
-              target: 'opponent',
-              amount: 'strong',
-              condition: 'ifLowHp'
-            },
-            {
-              type: 'mechanicOverride',
-              target: 'self',
-              mechanic: 'healingBlocked',
-              value: true
-            }
-          ]
-        },
-        {
-          name: "Cursed Gambit",
-          type: AttackType.CULTURE,
-          power: 0,
-          accuracy: 100,
-          pp: 1,
-          priority: 0,
-          flags: ['gambling'],
-          effects: [
-            {
-              type: 'heal',
-              target: 'self',
-              formula: 'percentage',
-              value: 100,
-              condition: 'ifLucky50'
-            },
-            {
-              type: 'damage',
-              target: 'self',
-              formula: 'fixed',
-              value: 9999,
-              condition: 'ifUnlucky50'
-            }
-          ]
-        }
-      ]
-    };
-
-    const engine = new BattleEngine(tempestWraith, {
-      name: "Opponent", description: "Test opponent", tier: 'medium',
-      primaryType: PicletType.BEAST, baseStats: { hp: 100, attack: 80, defense: 70, speed: 60 },
-      nature: "Hardy", specialAbility: { name: "None", description: "No ability" },
-      movepool: [{ name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-        priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }] }]
-    });
-
-    // Test the moveset variety
-    const state = engine.getState();
-    expect(state.playerPiclet.moves[0].move.name).toBe("Berserker's End");
-    expect(state.playerPiclet.moves[1].move.name).toBe("Cursed Gambit");
-
-    // Test Berserker's End effects
-    const berserkersEnd = state.playerPiclet.moves[0].move;
-    expect(berserkersEnd.effects).toHaveLength(3);
-    expect(berserkersEnd.effects[1].condition).toBe('ifLowHp');
-
-    // Test Cursed Gambit effects
-    const cursedGambit = state.playerPiclet.moves[1].move;
-    expect(cursedGambit.effects).toHaveLength(2);
-    expect(cursedGambit.effects[0].condition).toBe('ifLucky50');
-    expect(cursedGambit.effects[1].condition).toBe('ifUnlucky50');
-  });
-
-  it('should handle complete battle with advanced mechanics', () => {
-    const advancedPiclet: PicletDefinition = {
-      name: "Master of All Trades",
-      description: "Demonstrates every major battle system feature",
-      tier: 'legendary',
-      primaryType: PicletType.SPACE,
-      secondaryType: PicletType.CULTURE,
-      baseStats: { hp: 100, attack: 100, defense: 80, speed: 90 },
-      nature: "Adaptive",
-      specialAbility: {
-        name: "Omni-Adaptation",
-        description: "Multiple triggers for different situations",
-        effects: [
-          {
-            type: 'mechanicOverride',
-            mechanic: 'criticalHits',
-            value: 'double'
-          }
-        ],
-        triggers: [
-          {
-            event: 'onDamageTaken',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'increase' }
-              }
-            ]
-          },
-          {
-            event: 'onSwitchIn',
-            effects: [
-              {
-                type: 'removeStatus',
-                target: 'self',
-                status: 'poison'
-              }
-            ]
-          },
-          {
-            event: 'endOfTurn',
-            condition: 'ifStatus:burn',
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                formula: 'percentage',
-                value: 10
-              }
-            ]
-          }
-        ]
-      },
-      movepool: [
-        {
-          name: "Adaptive Strike",
-          type: AttackType.NORMAL,
-          power: 70,
-          accuracy: 100,
-          pp: 20,
-          priority: 0,
-          flags: ['contact'],
-          effects: [
-            {
-              type: 'damage',
-              target: 'opponent',
-              amount: 'normal'
-            },
-            {
-              type: 'damage',
-              target: 'opponent',
-              amount: 'strong',
-              condition: 'ifStatus:burn'
-            }
-          ]
-        },
-        {
-          name: "Field Manipulator",
-          type: AttackType.SPACE,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: 1,
-          flags: ['priority'],
-          effects: [
-            {
-              type: 'fieldEffect',
-              effect: 'gravityField',
-              target: 'field',
-              stackable: false
-            },
-            {
-              type: 'modifyStats',
-              target: 'opponent',
-              stats: { speed: 'decrease' }
-            }
-          ]
-        },
-        {
-          name: "Status Cleanse",
-          type: AttackType.NORMAL,
-          power: 0,
-          accuracy: 100,
-          pp: 15,
-          priority: 0,
-          flags: [],
-          effects: [
-            {
-              type: 'removeStatus',
-              target: 'self',
-              status: 'poison'
-            },
-            {
-              type: 'removeStatus',
-              target: 'self',
-              status: 'burn'
-            },
-            {
-              type: 'heal',
-              target: 'self',
-              amount: 'medium'
-            }
-          ]
-        },
-        {
-          name: "Counter Protocol",
-          type: AttackType.NORMAL,
-          power: 0,
-          accuracy: 100,
-          pp: 10,
-          priority: -5,
-          flags: ['lowPriority'],
-          effects: [
-            {
-              type: 'counter',
-              strength: 'strong'
-            }
-          ]
-        }
-      ]
-    };
-
-    const engine = new BattleEngine(advancedPiclet, {
-      name: "Test Opponent", description: "Basic opponent", tier: 'medium',
-      primaryType: PicletType.BEAST, baseStats: { hp: 80, attack: 70, defense: 60, speed: 50 },
-      nature: "Hardy", specialAbility: { name: "None", description: "No ability" },
-      movepool: [{ name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-        priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }] }]
-    });
-
-    // Test complex special ability
-    const ability = advancedPiclet.specialAbility;
-    expect(ability.effects).toHaveLength(1);
-    expect(ability.triggers).toHaveLength(3);
-    expect(ability.triggers![0].event).toBe('onDamageTaken');
-    expect(ability.triggers![2].condition).toBe('ifStatus:burn');
-
-    // Test diverse moveset
-    const moves = advancedPiclet.movepool;
-    expect(moves).toHaveLength(4);
-    expect(moves[1].priority).toBe(1); // Priority move
-    expect(moves[3].priority).toBe(-5); // Low priority counter
-    expect(moves[2].effects).toHaveLength(3); // Multi-effect move
-
-    // Test battle execution
-    engine.executeActions(
-      { type: 'move', piclet: 'player', moveIndex: 1 }, // Field Manipulator
-      { type: 'move', piclet: 'opponent', moveIndex: 0 }
-    );
-
-    const log = engine.getLog();
-    const hasFieldEffect = log.some(msg => msg.includes('applied') || msg.includes('effect'));
-    expect(hasFieldEffect).toBe(true);
-    expect(log.some(msg => msg.includes('speed fell'))).toBe(true);
-  });
-});

src/lib/battle-engine/test-data.ts

@@ -1,234 +0,0 @@
-/**
- * Test data for battle engine testing
- * Contains example Piclets and moves following the design document
- */
-
-import { 
-  PicletDefinition, 
-  Move, 
-  BaseStats, 
-  SpecialAbility,
-  AttackType,
-  PicletType
-} from './types';
-
-// Example base stats for different tiers
-export const LOW_TIER_STATS: BaseStats = {
-  hp: 80,
-  attack: 65,
-  defense: 60,
-  speed: 55
-};
-
-export const MEDIUM_TIER_STATS: BaseStats = {
-  hp: 100,
-  attack: 80,
-  defense: 75,
-  speed: 70
-};
-
-export const HIGH_TIER_STATS: BaseStats = {
-  hp: 120,
-  attack: 100,
-  defense: 90,
-  speed: 85
-};
-
-// Example moves following the design document
-export const BASIC_TACKLE: Move = {
-  name: "Tackle",
-  type: AttackType.NORMAL,
-  power: 40,
-  accuracy: 100,
-  pp: 35,
-  priority: 0,
-  flags: ['contact'],
-  effects: [{
-    type: 'damage',
-    target: 'opponent',
-    amount: 'normal'
-  }]
-};
-
-export const FLAME_BURST: Move = {
-  name: "Flame Burst",
-  type: AttackType.SPACE,
-  power: 70,
-  accuracy: 100,
-  pp: 15,
-  priority: 0,
-  flags: ['explosive'],
-  effects: [{
-    type: 'damage',
-    target: 'opponent',
-    amount: 'normal'
-  }]
-};
-
-export const HEALING_LIGHT: Move = {
-  name: "Healing Light", 
-  type: AttackType.SPACE,
-  power: 0,
-  accuracy: 100,
-  pp: 10,
-  priority: 0,
-  flags: [],
-  effects: [{
-    type: 'heal',
-    target: 'self',
-    amount: 'medium'
-  }]
-};
-
-export const POWER_UP: Move = {
-  name: "Power Up",
-  type: AttackType.NORMAL,
-  power: 0,
-  accuracy: 100,
-  pp: 20,
-  priority: 0,
-  flags: [],
-  effects: [{
-    type: 'modifyStats',
-    target: 'self',
-    stats: { attack: 'increase' }
-  }]
-};
-
-export const BERSERKER_END: Move = {
-  name: "Berserker's End",
-  type: AttackType.BEAST,
-  power: 80,
-  accuracy: 90,
-  pp: 5,
-  priority: 0,
-  flags: ['contact', 'reckless', 'sacrifice'],
-  effects: [
-    {
-      type: 'damage',
-      target: 'opponent',
-      amount: 'normal'
-    },
-    {
-      type: 'damage',
-      target: 'opponent', 
-      amount: 'strong',
-      condition: 'ifLowHp'
-    },
-    {
-      type: 'modifyStats',
-      target: 'self',
-      stats: { defense: 'greatly_decrease' },
-      condition: 'ifLowHp'
-    }
-  ]
-};
-
-export const TOXIC_STING: Move = {
-  name: "Toxic Sting",
-  type: AttackType.BUG,
-  power: 30,
-  accuracy: 100,
-  pp: 20,
-  priority: 0,
-  flags: ['contact'],
-  effects: [
-    {
-      type: 'damage',
-      target: 'opponent',
-      amount: 'weak'
-    },
-    {
-      type: 'applyStatus',
-      target: 'opponent',
-      status: 'poison'
-    }
-  ]
-};
-
-// Example special abilities
-export const REGENERATOR: SpecialAbility = {
-  name: "Regenerator",
-  description: "Restores HP when switching out",
-  triggers: [{
-    event: "onSwitchOut",
-    effects: [{
-      type: 'heal',
-      target: 'self',
-      amount: 'small'
-    }]
-  }]
-};
-
-export const FLAME_BODY: SpecialAbility = {
-  name: "Flame Body", 
-  description: "Contact moves may burn the attacker",
-  triggers: [{
-    event: "onContactDamage",
-    condition: 'ifLucky50',
-    effects: [{
-      type: 'applyStatus',
-      target: 'attacker',
-      status: 'burn'
-    }]
-  }]
-};
-
-export const SPEED_BOOST: SpecialAbility = {
-  name: "Speed Boost",
-  description: "Speed increases each turn",
-  triggers: [{
-    event: "onTurnEnd",
-    effects: [{
-      type: 'modifyStats',
-      target: 'self',
-      stats: { speed: 'increase' }
-    }]
-  }]
-};
-
-// Example Piclet definitions
-export const STELLAR_WOLF: PicletDefinition = {
-  name: "Stellar Wolf",
-  description: "A cosmic predator that hunts among the stars",
-  tier: 'medium',
-  primaryType: PicletType.SPACE,
-  secondaryType: PicletType.BEAST,
-  baseStats: MEDIUM_TIER_STATS,
-  nature: "Brave",
-  specialAbility: FLAME_BODY,
-  movepool: [BASIC_TACKLE, FLAME_BURST, HEALING_LIGHT, POWER_UP]
-};
-
-export const TOXIC_CRAWLER: PicletDefinition = {
-  name: "Toxic Crawler",
-  description: "A venomous arthropod with deadly precision",
-  tier: 'low',
-  primaryType: PicletType.BUG,
-  baseStats: LOW_TIER_STATS,
-  nature: "Careful",
-  specialAbility: SPEED_BOOST,
-  movepool: [BASIC_TACKLE, TOXIC_STING, POWER_UP]
-};
-
-export const BERSERKER_BEAST: PicletDefinition = {
-  name: "Berserker Beast",
-  description: "A wild creature that fights with reckless abandon",
-  tier: 'high',
-  primaryType: PicletType.BEAST,
-  baseStats: HIGH_TIER_STATS,
-  nature: "Reckless",
-  specialAbility: REGENERATOR,
-  movepool: [BASIC_TACKLE, BERSERKER_END, HEALING_LIGHT, POWER_UP]
-};
-
-export const AQUA_GUARDIAN: PicletDefinition = {
-  name: "Aqua Guardian",
-  description: "A protective water spirit",
-  tier: 'medium',
-  primaryType: PicletType.AQUATIC,
-  baseStats: MEDIUM_TIER_STATS,
-  nature: "Calm",
-  specialAbility: REGENERATOR,
-  movepool: [BASIC_TACKLE, HEALING_LIGHT, POWER_UP]
-};

src/lib/battle-engine/types.ts

@@ -1,262 +0,0 @@
-/**
- * Core types for the Pictuary Battle System
- * Based on battle_system_design.md specification
- */
-
-import { PicletType, AttackType, type TypeEffectiveness } from '../types/picletTypes';
-
-export { PicletType, AttackType };
-export type { TypeEffectiveness };
-
-export type Tier = 'low' | 'medium' | 'high' | 'legendary';
-
-// Status Effects
-export type StatusEffect = 'burn' | 'freeze' | 'paralyze' | 'poison' | 'sleep' | 'confuse';
-
-// Effect System Types
-export type EffectTarget = 'self' | 'opponent' | 'allies' | 'all' | 'attacker' | 'field' | 'playerSide' | 'opponentSide';
-export type EffectCondition = 
-  | 'always' | 'onHit' | 'afterUse' | 'onCritical' | 'ifLowHp' | 'ifHighHp'
-  | 'thisTurn' | 'nextTurn' | 'turnAfterNext' | 'restOfBattle'
-  | 'onCharging' | 'afterCharging' | 'ifDamagedThisTurn' | 'ifNotSuperEffective'
-  | 'ifStatusMove' | 'ifLucky50' | 'ifUnlucky50' | 'whileFrozen'
-  | 'ifMoveType:flora' | 'ifMoveType:space' | 'ifMoveType:beast' | 'ifMoveType:bug'
-  | 'ifMoveType:aquatic' | 'ifMoveType:mineral' | 'ifMoveType:machina' | 'ifMoveType:structure'
-  | 'ifMoveType:culture' | 'ifMoveType:cuisine' | 'ifMoveType:normal'
-  | 'ifStatus:burn' | 'ifStatus:freeze' | 'ifStatus:paralyze' | 'ifStatus:poison'
-  | 'ifStatus:sleep' | 'ifStatus:confuse'
-  | 'ifWeather:storm' | 'ifWeather:rain' | 'ifWeather:sun' | 'ifWeather:snow'
-  | 'whenStatusAfflicted' | 'vsPhysical' | 'vsSpecial';
-
-export type DamageAmount = 'weak' | 'normal' | 'strong' | 'extreme';
-export type DamageFormula = 'standard' | 'recoil' | 'drain' | 'fixed' | 'percentage';
-export type StatModification = 'increase' | 'decrease' | 'greatly_increase' | 'greatly_decrease';
-export type HealAmount = 'small' | 'medium' | 'large' | 'full';
-export type PPAmount = 'small' | 'medium' | 'large';
-export type CounterStrength = 'weak' | 'normal' | 'strong';
-
-// Move Flags
-export type MoveFlag = 
-  | 'contact' | 'bite' | 'punch' | 'sound' | 'explosive' | 'draining' | 'ground'
-  | 'priority' | 'lowPriority' | 'charging' | 'recharge' | 'multiHit' | 'twoTurn'
-  | 'sacrifice' | 'gambling' | 'reckless' | 'reflectable' | 'snatchable'
-  | 'copyable' | 'protectable' | 'bypassProtect';
-
-// Base Stats
-export interface BaseStats {
-  hp: number;
-  attack: number;
-  defense: number;
-  speed: number;
-}
-
-// Battle Effects
-export interface DamageEffect {
-  type: 'damage';
-  target: EffectTarget;
-  amount?: DamageAmount;
-  formula?: DamageFormula;
-  value?: number;
-  multiplier?: number;
-  condition?: EffectCondition;
-}
-
-export interface ModifyStatsEffect {
-  type: 'modifyStats';
-  target: EffectTarget;
-  stats: Partial<Record<keyof BaseStats | 'accuracy', StatModification>>;
-  condition?: EffectCondition;
-}
-
-export interface ApplyStatusEffect {
-  type: 'applyStatus';
-  target: EffectTarget;
-  status: StatusEffect;
-  chance?: number;
-  condition?: EffectCondition;
-}
-
-export interface HealEffect {
-  type: 'heal';
-  target: EffectTarget;
-  amount?: HealAmount;
-  formula?: 'percentage' | 'fixed';
-  value?: number;
-  condition?: EffectCondition;
-}
-
-export interface ManipulatePPEffect {
-  type: 'manipulatePP';
-  target: EffectTarget;
-  action: 'drain' | 'restore' | 'disable';
-  amount?: PPAmount;
-  value?: number;
-  targetMove?: 'random' | 'lastUsed' | 'specific';
-  condition?: EffectCondition;
-}
-
-export interface FieldEffect {
-  type: 'fieldEffect';
-  effect: string;
-  target: EffectTarget;
-  stackable: boolean;
-  condition?: EffectCondition;
-}
-
-export interface CounterEffect {
-  type: 'counter';
-  strength: CounterStrength;
-  condition?: EffectCondition;
-}
-
-export interface PriorityEffect {
-  type: 'priority';
-  target: EffectTarget;
-  value: number; // -5 to +5
-  condition?: EffectCondition;
-}
-
-export interface RemoveStatusEffect {
-  type: 'removeStatus';
-  target: EffectTarget;
-  status: StatusEffect;
-  condition?: EffectCondition;
-}
-
-export interface MechanicOverrideEffect {
-  type: 'mechanicOverride';
-  mechanic: 'criticalHits' | 'statusImmunity' | 'statusReplacement' | 'damageReflection' 
-          | 'damageAbsorption' | 'damageCalculation' | 'damageMultiplier' | 'healingInversion'
-          | 'healingBlocked' | 'priorityOverride' | 'accuracyBypass' | 'typeImmunity'
-          | 'typeChange' | 'contactDamage' | 'drainInversion' | 'weatherImmunity'
-          | 'flagImmunity' | 'flagWeakness' | 'flagResistance' | 'statModification'
-          | 'targetRedirection' | 'extraTurn';
-  value: any;
-  condition?: EffectCondition;
-}
-
-export type BattleEffect = 
-  | DamageEffect | ModifyStatsEffect | ApplyStatusEffect | HealEffect
-  | ManipulatePPEffect | FieldEffect | CounterEffect | PriorityEffect
-  | RemoveStatusEffect | MechanicOverrideEffect;
-
-// Move Definition
-export interface Move {
-  name: string;
-  type: AttackType;
-  power: number;
-  accuracy: number;
-  pp: number;
-  priority: number;
-  flags: MoveFlag[];
-  effects: BattleEffect[];
-}
-
-// Special Ability
-export interface Trigger {
-  event: 'onDamageTaken' | 'onDamageDealt' | 'onContactDamage' | 'onStatusInflicted' 
-        | 'onStatusMove' | 'onStatusMoveTargeted' | 'onCriticalHit' | 'onHPDrained' 
-        | 'onKO' | 'onSwitchIn' | 'onSwitchOut' | 'onWeatherChange' | 'beforeMoveUse' 
-        | 'afterMoveUse' | 'onLowHP' | 'onFullHP' | 'endOfTurn' | 'onOpponentContactMove'
-        | 'onStatChange' | 'onTypeChange';
-  condition?: EffectCondition;
-  effects: BattleEffect[];
-}
-
-export interface SpecialAbility {
-  name: string;
-  description: string;
-  effects?: BattleEffect[];
-  triggers?: Trigger[];
-}
-
-// Piclet Definition
-export interface PicletDefinition {
-  name: string;
-  description: string;
-  tier: Tier;
-  primaryType: PicletType;
-  secondaryType?: PicletType;
-  baseStats: BaseStats;
-  nature: string;
-  specialAbility: SpecialAbility;
-  movepool: Move[];
-}
-
-// Battle State Types
-export interface BattlePiclet {
-  definition: PicletDefinition;
-  currentHp: number;
-  maxHp: number;
-  level: number;
-  
-  // Current battle stats (modified by effects)
-  attack: number;
-  defense: number;
-  speed: number;
-  accuracy: number;
-  
-  // Status conditions
-  statusEffects: StatusEffect[];
-  
-  // Move state
-  moves: Array<{
-    move: Move;
-    currentPP: number;
-  }>;
-  
-  // Battle state
-  statModifiers: Partial<Record<keyof BaseStats | 'accuracy' | 'priority', number>>;
-  temporaryEffects: Array<{
-    effect: BattleEffect;
-    duration: number;
-  }>;
-}
-
-export interface BattleState {
-  turn: number;
-  phase: 'selection' | 'execution' | 'ended';
-  
-  playerPiclet: BattlePiclet;
-  opponentPiclet: BattlePiclet;
-  
-  // Field effects
-  fieldEffects: Array<{
-    name: string;
-    duration: number;
-    effect: any;
-  }>;
-  
-  // Battle log for testing/debugging
-  log: string[];
-  
-  winner?: 'player' | 'opponent' | 'draw';
-  
-  // Capture result (for wild battles)
-  captureResult?: {
-    success: boolean;
-    shakes: number;
-    odds: number;
-    capturePercentage: number;
-  };
-}
-
-// Action Types
-export interface MoveAction {
-  type: 'move';
-  piclet: 'player' | 'opponent';
-  moveIndex: number;
-}
-
-export interface SwitchAction {
-  type: 'switch';
-  piclet: 'player' | 'opponent';
-  newPicletIndex: number;
-}
-
-export interface CaptureAction {
-  type: 'capture';
-  piclet: 'player'; // Only player can capture
-}
-
-export type BattleAction = MoveAction | SwitchAction | CaptureAction;

src/lib/components/Battle/ActionViewSelector.svelte

@@ -1,5 +1,5 @@
 <script context="module" lang="ts">
-  export type ActionView = 'main' | 'moves' | 'piclets' | 'items' | 'stats' | 'forcedSwap';
+  export type ActionView = 'main' | 'moves' | 'piclets' | 'stats' | 'forcedSwap';
 </script>
 
 <script lang="ts">
@@ -34,7 +34,6 @@
   const actions = [
     { title: 'Act', icon: '⚔️', view: 'moves' as ActionView },
     { title: 'Piclets', icon: '🔄', view: 'piclets' as ActionView },
-    { title: 'Items', icon: '🎒', view: 'items' as ActionView },
     // { title: 'Stats', icon: '📊', view: 'stats' as ActionView }, // Debug only
   ];
   
@@ -165,28 +164,6 @@
               {/each}
             {/if}
           </div>
-        {:else if currentView === 'items'}
-          <div class="sub-view-list">
-            {#if isWildBattle && enemyPiclet}
-              <button 
-                class="sub-item item-item"
-                on:click={onCaptureAttempt}
-                disabled={processingTurn}
-              >
-                <span class="item-icon">📸</span>
-                <div class="item-info">
-                  <div class="item-name">Capture ({capturePercentage.toFixed(1)}%)</div>
-                  <div class="item-desc">{getCaptureDescription(capturePercentage)} - {enemyPiclet.nickname}</div>
-                </div>
-              </button>
-            {:else}
-              <div class="empty-message">
-                <span class="empty-icon">🎒</span>
-                <div>Items coming soon!</div>
-                <div class="empty-subtitle">This feature is currently under development.</div>
-              </div>
-            {/if}
-          </div>
         {/if}
       </div>
     </div>
@@ -499,29 +476,6 @@
     white-space: nowrap;
   }
   
-  /* Item items */
-  .item-icon {
-    font-size: 24px;
-    margin-right: 12px;
-    width: 32px;
-    text-align: center;
-  }
-  
-  .item-info {
-    flex: 1;
-  }
-  
-  .item-name {
-    font-size: 16px;
-    font-weight: 500;
-    color: #000;
-    margin-bottom: 2px;
-  }
-  
-  .item-desc {
-    font-size: 13px;
-    color: #8e8e93;
-  }
   
   /* Empty states */
   .empty-message {

src/lib/components/Battle/BattleControls.svelte

@@ -1,136 +0,0 @@
-<script lang="ts">
-  import type { PicletInstance } from '$lib/db/schema';
-  import type { BattleState } from '$lib/battle-engine/types';
-  import ActionButtons from './ActionButtons.svelte';
-  import TypewriterText from './TypewriterText.svelte';
-  
-  export let currentMessage: string;
-  export let battlePhase: 'intro' | 'main' | 'moveSelect' | 'picletSelect' | 'ended';
-  export let processingTurn: boolean;
-  export let battleEnded: boolean;
-  export let isWildBattle: boolean;
-  export let playerPiclet: PicletInstance;
-  export let enemyPiclet: PicletInstance;
-  export let rosterPiclets: PicletInstance[] = [];
-  export let battleState: BattleState | undefined = undefined;
-  export let capturePercentage: number = 0;
-  export let onAction: (action: string) => void;
-  export let onMoveSelect: (move: any) => void;
-  export let onPicletSelect: (piclet: PicletInstance) => void;
-  export let onBack: () => void;
-  export let waitingForContinue: boolean = false;
-  export let onContinueTap: () => void;
-  
-  // Use the roster passed from parent instead of loading it here
-  $: availablePiclets = rosterPiclets;
-</script>
-
-<div class="battle-controls">
-  <!-- Message Bar -->
-  <div class="message-bar {battleEnded ? 'special' : ''}">
-    <p><TypewriterText text={currentMessage} speed={25} /></p>
-  </div>
-  
-  <!-- Action Area -->
-  <div class="action-area">
-    {#if waitingForContinue}
-      <!-- Tap to continue overlay -->
-      <div class="tap-continue-overlay" role="button" tabindex="0" onclick={onContinueTap} onkeydown={(e) => e.key === 'Enter' || e.key === ' ' ? onContinueTap() : null}>
-        <div class="tap-indicator">
-          <span>Tap to continue</span>
-        </div>
-      </div>
-    {:else if battlePhase === 'main' && !processingTurn && !battleEnded}
-      <ActionButtons 
-        {isWildBattle}
-        {playerPiclet}
-        {enemyPiclet}
-        {availablePiclets}
-        {processingTurn}
-        {battleState}
-        {capturePercentage}
-        {onAction}
-        {onMoveSelect}
-        {onPicletSelect}
-        {onBack}
-      />
-    {/if}
-  </div>
-</div>
-
-<style>
-  .battle-controls {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    background: white;
-    border-top: 1px solid #e0e0e0;
-  }
-  
-  .message-bar {
-    min-height: 60px;
-    padding: 1rem;
-    background: #f8f9fa;
-    border-bottom: 1px solid #e0e0e0;
-    text-align: left;
-    display: flex;
-    align-items: center;
-    justify-content: flex-start;
-  }
-  
-  .message-bar.special {
-    background: rgba(255, 152, 0, 0.1);
-    border-color: rgba(255, 152, 0, 0.3);
-  }
-  
-  .message-bar p {
-    margin: 0;
-    font-size: 1rem;
-    color: #333;
-    line-height: 1.4;
-  }
-  
-  .action-area {
-    flex: 1;
-    padding: 1rem;
-    display: flex;
-    flex-direction: column;
-    position: relative;
-  }
-  
-  .tap-continue-overlay {
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background: rgba(0, 0, 0, 0.05);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    cursor: pointer;
-    border-radius: 8px;
-  }
-  
-  .tap-indicator {
-    background: rgba(0, 0, 0, 0.15);
-    color: #666;
-    padding: 6px 12px;
-    border-radius: 16px;
-    font-size: 12px;
-    font-weight: 400;
-    border: 1px solid rgba(0, 0, 0, 0.1);
-    animation: subtlePulse 3s infinite;
-  }
-  
-  @keyframes subtlePulse {
-    0%, 100% {
-      opacity: 0.7;
-      transform: scale(1);
-    }
-    50% {
-      opacity: 0.9;
-      transform: scale(1.02);
-    }
-  }
-</style>

src/lib/components/Battle/BattleEffects.svelte

@@ -1,522 +0,0 @@
-<script lang="ts">
-  import { fade } from 'svelte/transition';
-  import { onMount } from 'svelte';
-
-  export let effects: Array<{type: string, emoji: string, duration: number}> = [];
-  export let flash: boolean = false;
-  export let faint: boolean = false;
-  
-  // GBA-style flicker animation parameters (matching original Snaplings timing)
-  const flickerCount = 19;
-  const frameDelay = 2;
-  const flickerDuration = 1000; // milliseconds - matches Snaplings original
-  
-  // Flicker state management
-  let isFlickering = false;
-  let flickerVisible = true;
-  let flickerFrame = 0;
-  let flickerInterval: number;
-  
-  // Faint animation state management
-  let isFainting = false;
-  let faintProgress = 0;
-  let faintAnimationId: number;
-  let hasFainted = false;
-  
-  // Particle system configuration
-  const PARTICLES_PER_EFFECT = 6; // Number of emoji particles per effect
-  const SPAWN_RADIUS = 45; // Radius around piclet where particles spawn (reduced for better containment)
-  
-  // Generate multiple particles for each effect
-  $: particleList = effects.flatMap((effect, effectIndex) => {
-    const particles = [];
-    for (let i = 0; i < PARTICLES_PER_EFFECT; i++) {
-      // More varied spawn positions for better coverage
-      const angle = (Math.PI * 2 * i) / PARTICLES_PER_EFFECT + (Math.random() - 0.5) * 1.2;
-      const distance = SPAWN_RADIUS * (0.4 + Math.random() * 0.6); // Tighter distance variation for better containment
-      const x = Math.cos(angle) * distance;
-      const y = Math.sin(angle) * distance;
-      
-      // Enhanced animation properties for more dynamic effects (no rotation)
-      const scale = 0.7 + Math.random() * 0.5; // 0.7x to 1.2x initial size
-      const duration = Math.max(effect.duration * 1.8, 1800) + (Math.random() - 0.5) * 400; // Longer base duration
-      const delay = Math.random() * 200; // More staggered animation starts
-      
-      // Additional movement properties for more dynamic motion (reduced range)
-      const moveDistance = 20 + Math.random() * 30; // Further reduced movement distance for better containment
-      const moveAngle = angle + (Math.random() - 0.5) * Math.PI * 0.4; // Further reduced movement angle variation
-      
-      particles.push({
-        id: `${effectIndex}-${i}`,
-        type: effect.type,
-        emoji: effect.emoji,
-        x,
-        y,
-        scale,
-        duration,
-        delay,
-        moveDistance,
-        moveAngle
-      });
-    }
-    return particles;
-  });
-  
-  // Watch for flash changes to trigger flicker animation
-  $: if (flash && !isFlickering) {
-    startFlickerAnimation();
-  }
-  
-  // Watch for faint changes to trigger faint animation
-  $: if (faint && !isFainting && !hasFainted) {
-    startFaintAnimation();
-  }
-  
-  function startFlickerAnimation() {
-    isFlickering = true;
-    flickerFrame = 0;
-    
-    // Calculate frame duration based on total duration and frame count
-    const totalFrames = flickerCount * (frameDelay + 1);
-    const frameDuration = flickerDuration / totalFrames;
-    
-    flickerInterval = setInterval(() => {
-      if (flickerFrame >= totalFrames) {
-        // Animation finished, always visible
-        clearInterval(flickerInterval);
-        isFlickering = false;
-        flickerVisible = true;
-        return;
-      }
-      
-      // Toggle visibility every frameDelay frames
-      const flickerCycle = Math.floor(flickerFrame / (frameDelay + 1));
-      flickerVisible = flickerCycle % 2 === 0;
-      
-      flickerFrame++;
-    }, frameDuration);
-  }
-  
-  function startFaintAnimation() {
-    isFainting = true;
-    faintProgress = 0;
-    
-    const faintDuration = 1200; // milliseconds - matches Snaplings original
-    const startTime = performance.now();
-    
-    function updateFaintAnimation(currentTime: number) {
-      const elapsed = currentTime - startTime;
-      const progress = Math.min(elapsed / faintDuration, 1);
-      
-      // Use easeIn curve for acceleration as it falls away
-      faintProgress = progress * progress;
-      
-      if (progress < 1) {
-        faintAnimationId = requestAnimationFrame(updateFaintAnimation);
-      } else {
-        // Animation completed
-        isFainting = false;
-        faintProgress = 1; // Keep final state
-        hasFainted = true; // Mark as permanently fainted
-      }
-    }
-    
-    faintAnimationId = requestAnimationFrame(updateFaintAnimation);
-  }
-  
-  onMount(() => {
-    return () => {
-      if (flickerInterval) {
-        clearInterval(flickerInterval);
-      }
-      if (faintAnimationId) {
-        cancelAnimationFrame(faintAnimationId);
-      }
-    };
-  });
-</script>
-
-<!-- Effects wrapper with relative positioning for particles -->
-<div class="effects-wrapper">
-  <!-- GBA-style flicker effect with faint animation -->
-  <div 
-    class="effects-container" 
-    class:is-fainting={faint}
-    style="
-      opacity: {(flash && isFlickering) ? (flickerVisible ? 1 : 0) : (hasFainted || (faint && faintProgress >= 1) ? 0 : 1)};
-      {faint || hasFainted ? `
-        transform: 
-          scale(1, ${Math.max(0, 1 - faintProgress)})
-          matrix(1, 0, ${-faintProgress * 0.5}, 1, 0, 0);
-        transform-origin: bottom center;
-      ` : ''}
-    "
-  >
-    <slot />
-  </div>
-
-  <!-- Multi-particle effects -->
-  {#each particleList as particle (particle.id)}
-    <div 
-      class="effect-particle {particle.type}" 
-      style="
-        left: calc(50% + {particle.x}px); 
-        top: calc(50% + {particle.y}px);
-        animation-duration: {particle.duration}ms;
-        animation-delay: {particle.delay}ms;
-        --initial-scale: {particle.scale};
-        --move-x: {Math.cos(particle.moveAngle) * particle.moveDistance}px;
-        --move-y: {Math.sin(particle.moveAngle) * particle.moveDistance}px;
-      "
-    >
-      <span class="effect-emoji">{particle.emoji}</span>
-    </div>
-  {/each}
-</div>
-
-<style>
-  .effects-wrapper {
-    position: relative;
-    display: inline-block;
-    /* Ensure wrapper contains particles even during resize */
-    overflow: visible;
-    /* Create a proper containing block for particles */
-    width: 100%;
-    height: 100%;
-  }
-  
-  .effects-container {
-    position: relative;
-    display: inline-block;
-    transition: opacity 0.05s ease;
-    z-index: 2; /* Ensure effects appear above platform (z-index: 0) */
-  }
-  
-  .effect-particle {
-    position: absolute;
-    pointer-events: none;
-    z-index: 10;
-    animation-fill-mode: forwards;
-    transform-origin: center center;
-    /* Position relative to the Piclet center */
-  }
-  
-  .effect-emoji {
-    font-size: 24px;
-    display: block;
-    filter: drop-shadow(0 0 6px rgba(0, 0, 0, 0.5));
-    transform: scale(var(--initial-scale, 1));
-    /* Remove rotation - emojis stay upright */
-  }
-  
-  /* Status effects - floating with rotation */
-  .effect-particle.burn {
-    animation: statusBurn ease-in-out;
-  }
-  
-  .effect-particle.poison {
-    animation: statusPoison ease-in-out;
-  }
-  
-  .effect-particle.paralyze {
-    animation: statusParalyze linear;
-  }
-  
-  .effect-particle.sleep {
-    animation: statusSleep ease-in-out;
-  }
-  
-  .effect-particle.freeze {
-    animation: statusFreeze ease-out;
-  }
-  
-  /* Stat increases - rising with spin */
-  .effect-particle.attackUp,
-  .effect-particle.defenseUp,
-  .effect-particle.speedUp,
-  .effect-particle.accuracyUp {
-    animation: statIncrease ease-out;
-  }
-  
-  /* Stat decreases - falling with wobble */
-  .effect-particle.attackDown,
-  .effect-particle.defenseDown,
-  .effect-particle.speedDown,
-  .effect-particle.accuracyDown {
-    animation: statDecrease ease-in;
-  }
-  
-  /* Special effects */
-  .effect-particle.critical,
-  .effect-particle.superEffective {
-    animation: criticalBurst ease-out;
-  }
-  
-  .effect-particle.notVeryEffective,
-  .effect-particle.miss {
-    animation: missSwirl ease-in-out;
-  }
-  
-  .effect-particle.heal {
-    animation: healRise ease-out;
-  }
-  
-  /* Complex multi-property animations */
-  @keyframes statusBurn {
-    0% {
-      transform: translate(-50%, -50%) scale(0.2);
-      opacity: 0;
-    }
-    10% {
-      transform: translate(-50%, -50%) scale(1.8);
-      opacity: 1;
-    }
-    25% {
-      transform: translate(calc(-50% + var(--move-x) * 0.3), calc(-50% + var(--move-y) * 0.3)) scale(var(--initial-scale));
-      opacity: 0.95;
-    }
-    50% {
-      transform: translate(calc(-50% + var(--move-x) * 0.6), calc(-50% + var(--move-y) * 0.6)) scale(calc(var(--initial-scale) * 1.3));
-      opacity: 0.8;
-    }
-    75% {
-      transform: translate(calc(-50% + var(--move-x) * 0.9), calc(-50% + var(--move-y) * 0.9)) scale(calc(var(--initial-scale) * 0.7));
-      opacity: 0.5;
-    }
-    100% {
-      transform: translate(calc(-50% + var(--move-x)), calc(-50% + var(--move-y))) scale(0.3);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes statusPoison {
-    0% {
-      transform: translate(-50%, -50%) scale(0.4);
-      opacity: 0;
-    }
-    20% {
-      transform: translate(-50%, -50%) scale(1.1);
-      opacity: 1;
-    }
-    40% {
-      transform: translate(-50%, -50%) scale(0.9);
-      opacity: 0.8;
-    }
-    60% {
-      transform: translate(-50%, -50%) scale(1.0);
-      opacity: 0.6;
-    }
-    80% {
-      transform: translate(-50%, -50%) scale(0.7);
-      opacity: 0.3;
-    }
-    100% {
-      transform: translate(-50%, -50%) scale(0.5);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes statusParalyze {
-    0% {
-      transform: translate(-50%, -50%) scale(0.2);
-      opacity: 0;
-    }
-    10% {
-      transform: translate(-50%, -50%) scale(1.3);
-      opacity: 1;
-    }
-    20% {
-      transform: translate(-50%, -50%) scale(1.1);
-      opacity: 0.9;
-    }
-    30% {
-      transform: translate(-50%, -50%) scale(1.2);
-      opacity: 0.8;
-    }
-    40% {
-      transform: translate(-50%, -50%) scale(1.0);
-      opacity: 0.7;
-    }
-    50% {
-      transform: translate(-50%, -50%) scale(0.9);
-      opacity: 0.6;
-    }
-    100% {
-      transform: translate(-50%, -50%) scale(0.3);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes statusSleep {
-    0% {
-      transform: translate(-50%, -50%) scale(0.5);
-      opacity: 0;
-    }
-    25% {
-      transform: translate(-50%, -55%) scale(1.1);
-      opacity: 1;
-    }
-    50% {
-      transform: translate(-50%, -45%) scale(1.0);
-      opacity: 0.9;
-    }
-    75% {
-      transform: translate(-50%, -55%) scale(0.9);
-      opacity: 0.5;
-    }
-    100% {
-      transform: translate(-50%, -60%) scale(0.4);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes statusFreeze {
-    0% {
-      transform: translate(-50%, -50%) scale(0.3);
-      opacity: 0;
-    }
-    30% {
-      transform: translate(-50%, -50%) scale(1.4);
-      opacity: 1;
-    }
-    60% {
-      transform: translate(-50%, -50%) scale(1.2);
-      opacity: 0.8;
-    }
-    90% {
-      transform: translate(-50%, -50%) scale(0.8);
-      opacity: 0.3;
-    }
-    100% {
-      transform: translate(-50%, -50%) scale(0.6);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes statIncrease {
-    0% {
-      transform: translate(-50%, -50%) scale(0.3);
-      opacity: 0;
-    }
-    15% {
-      transform: translate(-50%, -50%) scale(1.6);
-      opacity: 1;
-    }
-    30% {
-      transform: translate(calc(-50% + var(--move-x) * 0.2), calc(-50% + var(--move-y) * 0.2 - 20px)) scale(calc(var(--initial-scale) * 1.2));
-      opacity: 0.95;
-    }
-    60% {
-      transform: translate(calc(-50% + var(--move-x) * 0.7), calc(-50% + var(--move-y) * 0.7 - 60px)) scale(calc(var(--initial-scale) * 1.0));
-      opacity: 0.7;
-    }
-    85% {
-      transform: translate(calc(-50% + var(--move-x)), calc(-50% + var(--move-y) - 90px)) scale(calc(var(--initial-scale) * 0.6));
-      opacity: 0.3;
-    }
-    100% {
-      transform: translate(calc(-50% + var(--move-x)), calc(-50% + var(--move-y) - 120px)) scale(0.2);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes statDecrease {
-    0% {
-      transform: translate(-50%, -50%) scale(0.4);
-      opacity: 0;
-    }
-    25% {
-      transform: translate(-50%, -30%) scale(1.2);
-      opacity: 1;
-    }
-    50% {
-      transform: translate(-50%, -10%) scale(1.0);
-      opacity: 0.8;
-    }
-    75% {
-      transform: translate(-50%, 10%) scale(0.8);
-      opacity: 0.4;
-    }
-    100% {
-      transform: translate(-50%, 30%) scale(0.6);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes criticalBurst {
-    0% {
-      transform: translate(-50%, -50%) scale(0.1);
-      opacity: 0;
-    }
-    8% {
-      transform: translate(-50%, -50%) scale(2.2);
-      opacity: 1;
-    }
-    20% {
-      transform: translate(calc(-50% + var(--move-x) * 0.1), calc(-50% + var(--move-y) * 0.1)) scale(calc(var(--initial-scale) * 1.8));
-      opacity: 0.95;
-    }
-    40% {
-      transform: translate(calc(-50% + var(--move-x) * 0.4), calc(-50% + var(--move-y) * 0.4)) scale(calc(var(--initial-scale) * 1.5));
-      opacity: 0.8;
-    }
-    70% {
-      transform: translate(calc(-50% + var(--move-x) * 0.8), calc(-50% + var(--move-y) * 0.8)) scale(calc(var(--initial-scale) * 1.1));
-      opacity: 0.4;
-    }
-    100% {
-      transform: translate(calc(-50% + var(--move-x)), calc(-50% + var(--move-y))) scale(0.2);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes missSwirl {
-    0% {
-      transform: translate(-50%, -50%) scale(0.6);
-      opacity: 0;
-    }
-    25% {
-      transform: translate(-50%, -50%) scale(1.2);
-      opacity: 0.7;
-    }
-    50% {
-      transform: translate(-50%, -50%) scale(1.0);
-      opacity: 0.5;
-    }
-    75% {
-      transform: translate(-50%, -50%) scale(0.8);
-      opacity: 0.3;
-    }
-    100% {
-      transform: translate(-50%, -50%) scale(0.4);
-      opacity: 0;
-    }
-  }
-  
-  @keyframes healRise {
-    0% {
-      transform: translate(-50%, -30%) scale(0.4);
-      opacity: 0;
-    }
-    12% {
-      transform: translate(-50%, -35%) scale(1.5);
-      opacity: 1;
-    }
-    25% {
-      transform: translate(calc(-50% + var(--move-x) * 0.2), calc(-50% + var(--move-y) * 0.2 - 40px)) scale(calc(var(--initial-scale) * 1.3));
-      opacity: 0.95;
-    }
-    50% {
-      transform: translate(calc(-50% + var(--move-x) * 0.5), calc(-50% + var(--move-y) * 0.5 - 70px)) scale(calc(var(--initial-scale) * 1.1));
-      opacity: 0.8;
-    }
-    75% {
-      transform: translate(calc(-50% + var(--move-x) * 0.8), calc(-50% + var(--move-y) * 0.8 - 100px)) scale(calc(var(--initial-scale) * 0.8));
-      opacity: 0.5;
-    }
-    100% {
-      transform: translate(calc(-50% + var(--move-x)), calc(-50% + var(--move-y) - 130px)) scale(0.3);
-      opacity: 0;
-    }
-  }
-</style>

src/lib/components/Battle/BattleField.svelte

@@ -1,536 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import { fade } from 'svelte/transition';
-  import type { PicletInstance } from '$lib/db/schema';
-  import type { BattleState } from '$lib/battle-engine/types';
-  import PicletInfo from './PicletInfo.svelte';
-  import StatusEffectIndicator from './StatusEffectIndicator.svelte';
-  import FieldEffectIndicator from './FieldEffectIndicator.svelte';
-  import BattleEffects from './BattleEffects.svelte';
-  
-  export let playerPiclet: PicletInstance;
-  export let enemyPiclet: PicletInstance;
-  export let playerHpPercentage: number;
-  export let enemyHpPercentage: number;
-  export let showIntro: boolean = false;
-  export let battleState: BattleState | undefined = undefined;
-  export let playerEffects: Array<{type: string, emoji: string, duration: number}> = [];
-  export let enemyEffects: Array<{type: string, emoji: string, duration: number}> = [];
-  export let playerFlash: boolean = false;
-  export let enemyFlash: boolean = false;
-  export let playerFaint: boolean = false;
-  export let enemyFaint: boolean = false;
-  export let playerLunge: boolean = false;
-  export let enemyLunge: boolean = false;
-  export let isWildBattle: boolean = true;
-  export let showWhiteFlash: boolean = false;
-  export let playerTrainerVisible: boolean = false;
-  export let enemyTrainerVisible: boolean = false;
-  export let playerTrainerSlideOut: boolean = false;
-  export let enemyTrainerSlideOut: boolean = false;
-  
-  // Animation states
-  let playerVisible = false;
-  let enemyVisible = false;
-  
-  // Trainer animation states
-  let playerTrainerSliding = false;
-  let enemyTrainerSliding = false;
-  
-  
-  onMount(() => {
-    if (!showIntro) {
-      // Skip intro - show everything immediately
-      playerVisible = true;
-      enemyVisible = true;
-    } else {
-      // In wild battles, enemy Piclet should be visible from start
-      if (isWildBattle) {
-        enemyVisible = true;
-      }
-      // For trainer battles, enemy will appear when enemyTrainerSlideOut triggers
-      // For all battles, player will appear when playerTrainerSlideOut triggers
-    }
-  });
-  
-  // Watch for trainer slide-out triggers
-  $: if (playerTrainerSlideOut && !playerTrainerSliding) {
-    playerTrainerSliding = true;
-    // Show trainer and let CSS handle slide-out animation
-    playerTrainerVisible = true;
-    
-    // After slide animation completes, hide trainer and show Piclet
-    setTimeout(() => {
-      playerTrainerVisible = false;
-      // Trigger white flash then show player monster
-      showWhiteFlash = true;
-      setTimeout(() => {
-        showWhiteFlash = false;
-        playerVisible = true;
-      }, 300);
-    }, 600); // Time for slide-out animation
-  }
-  
-  $: if (enemyTrainerSlideOut && !enemyTrainerSliding) {
-    enemyTrainerSliding = true;
-    // Show trainer and let CSS handle slide-out animation
-    enemyTrainerVisible = true;
-    
-    // After slide animation completes, hide trainer and show Piclet
-    setTimeout(() => {
-      enemyTrainerVisible = false;
-      // Trigger white flash then show enemy monster
-      showWhiteFlash = true;
-      setTimeout(() => {
-        showWhiteFlash = false;
-        enemyVisible = true;
-      }, 300);
-    }, 600); // Time for slide-out animation
-  }
-</script>
-
-<div class="battle-field">
-  <!-- White flash overlay -->
-  {#if showWhiteFlash}
-    <div class="white-flash" transition:fade={{ duration: 300 }}></div>
-  {/if}
-  
-  
-  <!-- Player Trainer -->
-  {#if playerTrainerVisible}
-    <div class="player-trainer" class:slide-out-left={playerTrainerSlideOut}>
-      <img src="/assets/default_trainer.png" alt="Player Trainer" />
-    </div>
-  {/if}
-  
-  <!-- Enemy Trainer (only for trainer battles) -->
-  {#if !isWildBattle && enemyTrainerVisible}
-    <div class="enemy-trainer" class:slide-out-right={enemyTrainerSlideOut}>
-      <img src="/assets/default_trainer.png" alt="Enemy Trainer" />
-    </div>
-  {/if}
-  
-  <div class="battle-content">
-    <!-- Field Effects Display -->
-    {#if battleState?.fieldEffects}
-      <FieldEffectIndicator fieldEffects={battleState.fieldEffects} />
-    {/if}
-    
-    <!-- Enemy Row -->
-    <div class="enemy-row">
-      <div class="enemy-stack" class:intro-animations={showIntro}>
-        <PicletInfo 
-          piclet={enemyPiclet}
-          hpPercentage={enemyHpPercentage}
-          isPlayer={false}
-        />
-        
-        <!-- Static Enemy Platform (always visible) -->
-        <img 
-          class="platform enemy-platform" 
-          src="/assets/grass.PNG" 
-          alt="Platform"
-          on:error={(e) => {
-            const target = e.currentTarget as HTMLImageElement;
-            const nextSibling = target.nextElementSibling as HTMLElement;
-            target.style.display = 'none';
-            if (nextSibling) nextSibling.style.display = 'block';
-          }}
-        />
-        <div class="platform-fallback enemy-platform-fallback" style="display: none;"></div>
-        
-        {#if enemyVisible}
-          <div class="enemy-piclet-wrapper" class:animate-in={showIntro} class:lunge={enemyLunge}>
-            <!-- Enemy Battle Effects wrap the image for flicker animation -->
-            <BattleEffects effects={enemyEffects} flash={enemyFlash} faint={enemyFaint}>
-              <img 
-                class="piclet-image enemy-image"
-                src={enemyPiclet.imageData || enemyPiclet.imageUrl} 
-                alt={enemyPiclet.nickname}
-                on:error={(e) => {
-                  const target = e.currentTarget as HTMLImageElement;
-                  target.src = 'https://via.placeholder.com/120x120?text=Piclet';
-                }}
-              />
-            </BattleEffects>
-            
-            <!-- Enemy Status Effects -->
-            {#if battleState?.opponentPiclet?.statusEffects}
-              <div class="enemy-status-effects">
-                <StatusEffectIndicator statusEffects={battleState.opponentPiclet.statusEffects.map(effect => ({ type: effect, turnsLeft: 3 }))} />
-              </div>
-            {/if}
-          </div>
-        {/if}
-      </div>
-    </div>
-    
-    <div class="spacer"></div>
-    
-    <!-- Player Row -->
-    <div class="player-row">
-      <div class="player-stack" class:intro-animations={showIntro}>
-        
-        <!-- Static Player Platform (always visible) -->
-        <img 
-          class="platform player-platform" 
-          src="/assets/grass.PNG" 
-          alt="Platform"
-          on:error={(e) => {
-            const target = e.currentTarget as HTMLImageElement;
-            const nextSibling = target.nextElementSibling as HTMLElement;
-            target.style.display = 'none';
-            if (nextSibling) nextSibling.style.display = 'block';
-          }}
-        />
-        <div class="platform-fallback player-platform-fallback" style="display: none;"></div>
-        
-        {#if playerVisible}
-          <div class="player-piclet-wrapper" class:animate-in={showIntro} class:lunge={playerLunge}>
-            <!-- Player Battle Effects wrap the image for flicker animation -->
-            <BattleEffects effects={playerEffects} flash={playerFlash} faint={playerFaint}>
-              <img 
-                class="piclet-image player-image"
-                src={playerPiclet.imageData || playerPiclet.imageUrl} 
-                alt={playerPiclet.nickname}
-                on:error={(e) => {
-                  const target = e.currentTarget as HTMLImageElement;
-                  target.src = 'https://via.placeholder.com/120x120?text=Piclet';
-                }}
-              />
-            </BattleEffects>
-            
-            <!-- Player Status Effects -->
-            {#if battleState?.playerPiclet?.statusEffects}
-              <div class="player-status-effects">
-                <StatusEffectIndicator statusEffects={battleState.playerPiclet.statusEffects.map(effect => ({ type: effect, turnsLeft: 3 }))} />
-              </div>
-            {/if}
-          </div>
-        {/if}
-        
-        <PicletInfo 
-          piclet={playerPiclet}
-          hpPercentage={playerHpPercentage}
-          isPlayer={true}
-        />
-      </div>
-    </div>
-  </div>
-</div>
-
-<style>
-  .battle-field {
-    height: 280px;
-    position: relative;
-    overflow: hidden;
-    background: repeating-linear-gradient(
-      to bottom,
-      rgba(76, 175, 80, 0.2) 0px,
-      rgba(76, 175, 80, 0.2) 5px,
-      rgba(76, 175, 80, 0.1) 5px,
-      rgba(76, 175, 80, 0.1) 10px
-    );
-  }
-  
-  .white-flash {
-    position: fixed;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background: white;
-    z-index: 50;
-  }
-  
-  
-  .player-trainer {
-    position: absolute;
-    bottom: 20px;
-    left: 20px;
-    z-index: 10;
-    transition: transform 0.6s ease-in-out;
-  }
-  
-  .player-trainer img {
-    width: 120px;
-    height: auto;
-  }
-  
-  .player-trainer.slide-out-left {
-    transform: translateX(-200px);
-  }
-  
-  .enemy-trainer {
-    position: absolute;
-    top: 20px;
-    right: 20px;
-    z-index: 10;
-    transition: transform 0.6s ease-in-out;
-  }
-  
-  .enemy-trainer img {
-    width: 120px;
-    height: auto;
-  }
-  
-  .enemy-trainer.slide-out-right {
-    transform: translateX(200px);
-  }
-  
-  
-  .battle-content {
-    display: flex;
-    flex-direction: column;
-    height: 100%;
-  }
-  
-  /* Enemy Row */
-  .enemy-row {
-    flex: 1;
-    position: relative;
-  }
-  
-  .enemy-stack {
-    position: absolute;
-    top: 0;
-    right: 0;
-    left: 0;
-    bottom: 0;
-  }
-  
-  .enemy-piclet-wrapper {
-    position: absolute;
-    right: 40px;
-    top: 0;
-  }
-  
-  .enemy-image {
-    width: 120px;
-    height: 120px;
-    object-fit: contain;
-    display: block;
-  }
-  
-  .enemy-platform {
-    width: 160px;
-    height: 160px;
-    position: absolute;
-    right: 20px; /* Align with enemy-piclet-wrapper position */
-    z-index: 0;
-    object-fit: cover;
-  }
-  
-  /* Player Row */
-  .player-row {
-    height: 140px;
-    position: relative;
-  }
-  
-  .player-stack {
-    position: relative;
-    width: 100%;
-    height: 100%;
-  }
-  
-  .player-piclet-wrapper {
-    position: absolute;
-    left: 40px;
-    bottom: -6px;
-  }
-  
-  .player-image {
-    width: 120px;
-    height: 120px;
-    object-fit: contain;
-    display: block;
-  }
-  
-  .player-platform {
-    width: 160px;
-    height: 160px;
-    position: absolute;
-    bottom: -80px;
-    left: 20px; /* Align with player-piclet-wrapper position */
-    z-index: 0;
-    object-fit: cover;
-  }
-  
-  /* Platform fallbacks */
-  .platform-fallback {
-    position: absolute;
-    background: rgba(76, 175, 80, 0.3);
-    border-radius: 50%;
-  }
-  
-  .enemy-platform-fallback {
-    width: 160px;
-    height: 160px;
-    bottom: -60px;
-    right: 20px;
-  }
-  
-  .player-platform-fallback {
-    width: 160px;
-    height: 160px;
-    bottom: -80px;
-    left: 20px;
-  }
-  
-  /* Piclet images */
-  .piclet-image {
-    image-rendering: auto;
-    filter: drop-shadow(-2px 0 4px rgba(0, 0, 0, 0.1));
-    position: relative;
-    z-index: 1;
-  }
-  
-  .spacer {
-    flex: 1;
-  }
-  
-  /* Status Effects Positioning */
-  .enemy-status-effects {
-    position: absolute;
-    top: -10px;
-    right: -10px;
-    z-index: 5;
-  }
-  
-  .player-status-effects {
-    position: absolute;
-    bottom: 117px;
-    left: 13px;
-    z-index: 5;
-  }
-
-  /* Animations */
-  .enemy-piclet-wrapper {
-    animation-fill-mode: both;
-    transition: transform 0.6s cubic-bezier(0.25, 0.46, 0.45, 0.94);
-  }
-  
-  .enemy-piclet-wrapper.animate-in {
-    animation: enemySlideIn 0.8s cubic-bezier(0.175, 0.885, 0.32, 1.275);
-  }
-  
-  .enemy-piclet-wrapper.lunge {
-    animation: enemyLunge 0.6s cubic-bezier(0.25, 0.46, 0.45, 0.94);
-  }
-  
-  .player-piclet-wrapper {
-    animation-fill-mode: both;
-    transition: transform 0.6s cubic-bezier(0.25, 0.46, 0.45, 0.94);
-  }
-  
-  .player-piclet-wrapper.animate-in {
-    animation: playerSlideIn 0.8s cubic-bezier(0.175, 0.885, 0.32, 1.275);
-  }
-  
-  .player-piclet-wrapper.lunge {
-    animation: playerLunge 0.6s cubic-bezier(0.25, 0.46, 0.45, 0.94);
-  }
-  
-  @keyframes enemySlideIn {
-    0% {
-      transform: translateX(150px) translateY(-50px) scale(1.5);
-      opacity: 0;
-    }
-    50% {
-      opacity: 1;
-    }
-    100% {
-      transform: translateX(0) translateY(0) scale(1);
-      opacity: 1;
-    }
-  }
-  
-  @keyframes playerSlideIn {
-    0% {
-      transform: translateX(-150px) translateY(50px) scale(0.5);
-      opacity: 0;
-    }
-    50% {
-      opacity: 1;
-    }
-    100% {
-      transform: translateX(0) translateY(0) scale(1);
-      opacity: 1;
-    }
-  }
-  
-  @keyframes enemyLunge {
-    0% {
-      transform: translateX(0) translateY(0) scale(1);
-    }
-    40% {
-      transform: translateX(-60px) translateY(10px) scale(1.1);
-    }
-    100% {
-      transform: translateX(0) translateY(0) scale(1);
-    }
-  }
-  
-  @keyframes playerLunge {
-    0% {
-      transform: translateX(0) translateY(0) scale(1);
-    }
-    40% {
-      transform: translateX(60px) translateY(-10px) scale(1.1);
-    }
-    100% {
-      transform: translateX(0) translateY(0) scale(1);
-    }
-  }
-  
-  /* Info box animations */
-  .enemy-stack.intro-animations :global(.piclet-info-wrapper) {
-    animation: fadeSlideDown 0.5s ease-out 0.3s both;
-  }
-  
-  .player-stack.intro-animations :global(.piclet-info-wrapper) {
-    animation: fadeSlideUp 0.5s ease-out 0.3s both;
-  }
-  
-  @keyframes fadeSlideDown {
-    0% {
-      opacity: 0;
-      transform: translateY(-20px);
-    }
-    100% {
-      opacity: 1;
-      transform: translateY(0);
-    }
-  }
-  
-  @keyframes fadeSlideUp {
-    0% {
-      opacity: 0;
-      transform: translateY(20px);
-    }
-    100% {
-      opacity: 1;
-      transform: translateY(0);
-    }
-  }
-  
-  @media (max-width: 768px) {
-    .enemy-image {
-      width: 120px;
-      height: 120px;
-    }
-    
-    .player-image {
-      width: 120px;
-      height: 120px;
-    }
-    
-    .enemy-piclet-wrapper {
-      right: 40px;
-    }
-    
-    .player-piclet-wrapper {
-      left: 40px;
-    }
-  }
-</style>

src/lib/components/Battle/LLMBattleEngine.svelte

@@ -0,0 +1,455 @@
+<script lang="ts">
+  import type { PicletInstance } from '$lib/db/schema';
+  import type { GradioClient } from '$lib/types';
+
+  interface BattleUpdate {
+    battle_updates: string[];
+    player_pokemon_status: string;
+    player_pokemon_hp: 'Empty' | 'Very Low' | 'Low' | 'Medium' | 'High' | 'Very High' | 'Full';
+    enemy_pokemon_status: string;
+    enemy_pokemon_hp: 'Empty' | 'Very Low' | 'Low' | 'Medium' | 'High' | 'Very High' | 'Full';
+    next_to_act: 'player' | 'enemy';
+    available_actions: string[];
+  }
+
+  interface Props {
+    playerPiclet: PicletInstance;
+    enemyPiclet: PicletInstance;
+    commandClient: GradioClient;
+    onBattleEnd: (winner: 'player' | 'enemy') => void;
+    rosterPiclets?: PicletInstance[]; // Optional roster for switching
+  }
+
+  let { playerPiclet, enemyPiclet, commandClient, onBattleEnd, rosterPiclets }: Props = $props();
+
+  // Battle state
+  let battleState: BattleUpdate = $state({
+    battle_updates: [],
+    player_pokemon_status: 'Ready for battle',
+    player_pokemon_hp: 'Full',
+    enemy_pokemon_status: 'Ready for battle', 
+    enemy_pokemon_hp: 'Full',
+    next_to_act: 'player',
+    available_actions: []
+  });
+
+  let battleHistory: string[] = $state([]);
+  let isProcessing: boolean = $state(false);
+  let currentPlayerPiclet: PicletInstance = $state(playerPiclet);
+  let showPicletSelector: boolean = $state(false);
+
+  // Dice rolling system
+  function rollDice(): number {
+    return Math.floor(Math.random() * 20) + 1; // D20 roll
+  }
+
+  function getActionEffectiveness(roll: number): { success: string; description: string } {
+    if (roll === 20) return { success: 'Critical Success', description: 'The action succeeds spectacularly!' };
+    if (roll >= 15) return { success: 'Success', description: 'The action succeeds well!' };
+    if (roll >= 10) return { success: 'Partial Success', description: 'The action has some effect.' };
+    if (roll >= 5) return { success: 'Failure', description: 'The action fails but something minor happens.' };
+    if (roll === 1) return { success: 'Critical Failure', description: 'The action backfires!' };
+    return { success: 'Failure', description: 'The action fails.' };
+  }
+
+  // Generate text using Command client
+  async function generateBattleUpdate(prompt: string): Promise<BattleUpdate> {
+    const message = {
+      text: prompt,
+      files: []
+    };
+
+    const result = await commandClient.predict("/chat", {
+      message: message,
+      max_new_tokens: 1000
+    });
+
+    const responseText = result.data || '';
+    console.log('LLM Response:', responseText);
+
+    // Extract JSON from response
+    try {
+      const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) throw new Error('No JSON found in response');
+      
+      const battleUpdate: BattleUpdate = JSON.parse(jsonMatch[0]);
+      return battleUpdate;
+    } catch (error) {
+      console.error('Failed to parse battle response:', error);
+      // Fallback response
+      return {
+        battle_updates: ['The battle continues...'],
+        player_pokemon_status: battleState.player_pokemon_status,
+        player_pokemon_hp: battleState.player_pokemon_hp,
+        enemy_pokemon_status: battleState.enemy_pokemon_status,
+        enemy_pokemon_hp: battleState.enemy_pokemon_hp,
+        next_to_act: battleState.next_to_act === 'player' ? 'enemy' : 'player',
+        available_actions: ['Attack', 'Defend', 'Special Move']
+      };
+    }
+  }
+
+  // Initialize battle
+  async function startBattle() {
+    isProcessing = true;
+    
+    const initialPrompt = `Let's role play a Pokemon game using my custom Pokemon, the player will use ${currentPlayerPiclet.typeId} and the enemy will use ${enemyPiclet.typeId}.
+You will return a brief description on what happens because of the action.
+I will send you an update of the enemy or players move and the success of the action (in a DnD style). Be sure to be as creative and engaging as possible when defining battle updates and available actions.
+
+Player Pokemon: ${currentPlayerPiclet.typeId}
+${currentPlayerPiclet.description}
+
+Enemy Pokemon: ${enemyPiclet.typeId}
+${enemyPiclet.description}
+
+Each response should be a json object with fields:
+\`\`\`json
+{
+    "battle_updates": [list with 1 sentence per entry describing what just happened in battle],
+    "player_pokemon_status": "1 sentence description of how the Pokemon is doing",
+    "player_pokemon_hp": "enum Empty, Very Low, Low, Medium, High, Very High, Full",
+    "enemy_pokemon_status": "1 sentence description of how the Pokemon is doing",
+    "enemy_pokemon_hp": "enum Empty, Very Low, Low, Medium, High, Very High, Full",
+    "next_to_act": "enum player/enemy",
+    "available_actions": ["short list of 1 sentence actions of what to have the next_to_act Pokemon do next"]
+}
+\`\`\`
+Start with just some intro updates describing both monsters being on the battlefield.`;
+
+    try {
+      const update = await generateBattleUpdate(initialPrompt);
+      battleState = update;
+      battleHistory.push(initialPrompt);
+    } catch (error) {
+      console.error('Failed to start battle:', error);
+    }
+    
+    isProcessing = false;
+  }
+
+  // Execute player action
+  async function executeAction(actionDescription: string) {
+    if (isProcessing) return;
+    
+    isProcessing = true;
+    
+    const roll = rollDice();
+    const effectiveness = getActionEffectiveness(roll);
+    
+    const prompt = `Player chooses: "${actionDescription}"
+Dice roll: ${roll}/20 (${effectiveness.success})
+Effect: ${effectiveness.description}
+
+Update the battle state based on this action and its effectiveness. Then have the enemy take their turn if appropriate.`;
+
+    try {
+      const update = await generateBattleUpdate(prompt);
+      battleState = update;
+      battleHistory.push(prompt);
+      
+      // Check for battle end conditions
+      if (battleState.player_pokemon_hp === 'Empty') {
+        onBattleEnd('enemy');
+      } else if (battleState.enemy_pokemon_hp === 'Empty') {
+        onBattleEnd('player');
+      }
+    } catch (error) {
+      console.error('Failed to execute action:', error);
+    }
+    
+    isProcessing = false;
+  }
+  
+  // Switch Piclet function
+  async function switchPiclet(newPiclet: PicletInstance) {
+    if (isProcessing) return;
+    
+    isProcessing = true;
+    showPicletSelector = false;
+    
+    const switchPrompt = `Player switches from ${currentPlayerPiclet.typeId} to ${newPiclet.typeId}!
+    
+New Pokemon: ${newPiclet.typeId}
+${newPiclet.description}
+
+Update the battle to show the switch and have the enemy react accordingly.`;
+    
+    try {
+      currentPlayerPiclet = newPiclet;
+      const update = await generateBattleUpdate(switchPrompt);
+      battleState = update;
+      battleHistory.push(switchPrompt);
+    } catch (error) {
+      console.error('Failed to switch Piclet:', error);
+    }
+    
+    isProcessing = false;
+  }
+
+  // Auto-start battle when component mounts
+  $effect(() => {
+    startBattle();
+  });
+
+  // Export functions for parent component
+  export { executeAction, switchPiclet };
+</script>
+
+<div class="llm-battle-engine">
+  <!-- Battle Narrative Display -->
+  <div class="battle-narrative">
+    <h3>Battle Progress</h3>
+    {#each battleState.battle_updates as update}
+      <div class="battle-update">{update}</div>
+    {/each}
+  </div>
+  
+  <!-- Pokemon Status -->
+  <div class="pokemon-status">
+    <div class="player-status">
+      <h4>{currentPlayerPiclet.typeId}</h4>
+      <div class="hp-indicator hp-{battleState.player_pokemon_hp.toLowerCase().replace(' ', '-')}">{battleState.player_pokemon_hp}</div>
+      <p>{battleState.player_pokemon_status}</p>
+    </div>
+    
+    <div class="enemy-status">
+      <h4>{enemyPiclet.typeId}</h4>
+      <div class="hp-indicator hp-{battleState.enemy_pokemon_hp.toLowerCase().replace(' ', '-')}">{battleState.enemy_pokemon_hp}</div>
+      <p>{battleState.enemy_pokemon_status}</p>
+    </div>
+  </div>
+  
+  <!-- Available Actions (when it's player's turn) -->
+  {#if battleState.next_to_act === 'player' && !isProcessing}
+    <div class="available-actions">
+      <h4>Choose Your Action:</h4>
+      
+      <!-- Battle Actions -->
+      {#each battleState.available_actions as action}
+        <button 
+          class="action-button" 
+          onclick={() => executeAction(action)}
+        >
+          {action}
+        </button>
+      {/each}
+      
+      <!-- Piclet Switching -->
+      {#if rosterPiclets && rosterPiclets.length > 1}
+        <button 
+          class="switch-button" 
+          onclick={() => showPicletSelector = !showPicletSelector}
+        >
+          🔄 Switch Piclet
+        </button>
+      {/if}
+    </div>
+    
+    <!-- Piclet Selector -->
+    {#if showPicletSelector && rosterPiclets}
+      <div class="piclet-selector">
+        <h4>Choose Piclet:</h4>
+        <div class="piclet-grid">
+          {#each rosterPiclets as piclet}
+            {#if piclet.id !== currentPlayerPiclet.id}
+              <button 
+                class="piclet-option" 
+                onclick={() => switchPiclet(piclet)}
+              >
+                <img src={piclet.imageUrl} alt={piclet.typeId} />
+                <span>{piclet.typeId}</span>
+                <span class="tier tier-{piclet.tier}">{piclet.tier}</span>
+              </button>
+            {/if}
+          {/each}
+        </div>
+      </div>
+    {/if}
+  {:else if isProcessing}
+    <div class="processing">
+      <div class="spinner"></div>
+      <p>Processing battle turn...</p>
+    </div>
+  {:else}
+    <div class="enemy-turn">
+      <p>Enemy is deciding their move...</p>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .llm-battle-engine {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    padding: 1rem;
+  }
+  
+  .battle-narrative {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 1rem;
+    max-height: 200px;
+    overflow-y: auto;
+  }
+  
+  .battle-update {
+    margin-bottom: 0.5rem;
+    padding: 0.5rem;
+    background: white;
+    border-radius: 4px;
+    border-left: 3px solid #007bff;
+  }
+  
+  .pokemon-status {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1rem;
+  }
+  
+  .player-status, .enemy-status {
+    padding: 1rem;
+    border-radius: 8px;
+    text-align: center;
+  }
+  
+  .player-status {
+    background: rgba(0, 123, 255, 0.1);
+    border: 2px solid #007bff;
+  }
+  
+  .enemy-status {
+    background: rgba(220, 53, 69, 0.1);
+    border: 2px solid #dc3545;
+  }
+  
+  .hp-indicator {
+    font-weight: bold;
+    padding: 0.25rem 0.5rem;
+    border-radius: 16px;
+    margin: 0.5rem 0;
+    display: inline-block;
+  }
+  
+  .hp-full { background: #28a745; color: white; }
+  .hp-very-high { background: #40c757; color: white; }
+  .hp-high { background: #6bc267; color: white; }
+  .hp-medium { background: #ffc107; color: black; }
+  .hp-low { background: #fd7e14; color: white; }
+  .hp-very-low { background: #dc3545; color: white; }
+  .hp-empty { background: #6c757d; color: white; }
+  
+  .available-actions {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+  
+  .action-button {
+    padding: 0.75rem 1rem;
+    background: #007bff;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+    font-size: 1rem;
+    transition: background-color 0.2s;
+  }
+  
+  .action-button:hover {
+    background: #0056b3;
+  }
+  
+  .switch-button {
+    padding: 0.75rem 1rem;
+    background: #28a745;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+    font-size: 1rem;
+    transition: background-color 0.2s;
+    margin-top: 0.5rem;
+  }
+  
+  .switch-button:hover {
+    background: #1e7e34;
+  }
+  
+  .piclet-selector {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 1rem;
+    margin-top: 1rem;
+  }
+  
+  .piclet-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 0.5rem;
+    margin-top: 0.5rem;
+  }
+  
+  .piclet-option {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.5rem;
+    background: white;
+    border: 2px solid #dee2e6;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: all 0.2s;
+  }
+  
+  .piclet-option:hover {
+    border-color: #007bff;
+    background: #f0f7ff;
+  }
+  
+  .piclet-option img {
+    width: 40px;
+    height: 40px;
+    object-fit: cover;
+    border-radius: 4px;
+  }
+  
+  .piclet-option span {
+    font-size: 0.8rem;
+    text-align: center;
+  }
+  
+  .tier {
+    padding: 0.1rem 0.3rem;
+    border-radius: 8px;
+    font-size: 0.7rem;
+    font-weight: bold;
+    text-transform: uppercase;
+  }
+  
+  .tier-low { background: #6c757d; color: white; }
+  .tier-medium { background: #28a745; color: white; }
+  .tier-high { background: #fd7e14; color: white; }
+  .tier-legendary { background: #dc3545; color: white; }
+  
+  .processing, .enemy-turn {
+    text-align: center;
+    padding: 2rem;
+  }
+  
+  .spinner {
+    width: 40px;
+    height: 40px;
+    border: 4px solid #f3f3f3;
+    border-top: 4px solid #007bff;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 1rem;
+  }
+  
+  @keyframes spin {
+    to { transform: rotate(360deg); }
+  }
+</style>

src/lib/components/Pages/Battle.svelte

@@ -1,1036 +1,177 @@
 <script lang="ts">
-  import { onMount } from 'svelte';
   import { fade } from 'svelte/transition';
-  import type { PicletInstance, BattleMove } from '$lib/db/schema';
-  import BattleField from '../Battle/BattleField.svelte';
-  import BattleControls from '../Battle/BattleControls.svelte';
-  import { BattleEngine } from '$lib/battle-engine/BattleEngine';
-  import type { BattleState, MoveAction, SwitchAction } from '$lib/battle-engine/types';
-  import { picletInstanceToBattleDefinition, battlePicletToInstance, stripBattlePrefix } from '$lib/utils/battleConversion';
-  import { calculateBattleXp, processAllLevelUps } from '$lib/services/levelingService';
-  import { db } from '$lib/db/index';
-  import { getEffectivenessText, getEffectivenessColor } from '$lib/types/picletTypes';
-  import { getCaptureDescription } from '$lib/services/captureService';
-  
-  export let playerPiclet: PicletInstance;
-  export let enemyPiclet: PicletInstance;
-  export let isWildBattle: boolean = true;
-  export let onBattleEnd: (result: any) => void = () => {};
-  export let rosterPiclets: PicletInstance[] = []; // All roster piclets passed from parent
-  
-  // Initialize battle engine
-  let battleEngine: BattleEngine;
-  let battleState: BattleState;
-  let currentPlayerPiclet = playerPiclet;
-  let currentEnemyPiclet = enemyPiclet;
-  
-  // Calculate capture percentage for UI display
-  $: capturePercentage = battleEngine && isWildBattle ? battleEngine.getCapturePercentage() : 0;
-  
-  // Battle state
-  let currentMessage = isWildBattle 
-    ? `A wild ${enemyPiclet.nickname} appeared!` 
-    : `Trainer wants to battle!`;
-  let battlePhase: 'intro' | 'main' | 'moveSelect' | 'picletSelect' | 'ended' = 'intro';  
-  let processingTurn = false;
-  let battleEnded = false;
-  
-  // Trainer animation states
-  let showWhiteFlash = false;
-  let playerTrainerVisible = false;
-  let enemyTrainerVisible = false;
-  let playerTrainerSlideOut = false;
-  let enemyTrainerSlideOut = false;
-  
-  // Message progression system
-  let waitingForContinue = false;
-  let messageQueue: string[] = [];
-  let currentMessageIndex = 0;
-  let continueCallback: (() => void) | null = null;
-  
-  // HP animation states  
-  let playerHpPercentage = playerPiclet.currentHp / playerPiclet.maxHp;
-  let enemyHpPercentage = enemyPiclet.currentHp / enemyPiclet.maxHp;
-  
-  // Visual effects state
-  let playerEffects: Array<{type: string, emoji: string, duration: number}> = [];
-  let enemyEffects: Array<{type: string, emoji: string, duration: number}> = [];
-  let playerFlash = false;
-  let enemyFlash = false;
-  let playerFaint = false;
-  let enemyFaint = false;
-  let playerLunge = false;
-  let enemyLunge = false;
-  
-  // Battle results state
-  let battleResultsVisible = false;
-  let battleResults = {
-    victory: false,
-    xpGained: 0,
-    levelUps: [],
-    newLevel: 0
-  };
-  
-  
-  onMount(() => {
-    // Initialize battle engine with converted piclet definitions
-    // Convert full roster for switching support
-    const playerRosterDefinitions = rosterPiclets.map(p => picletInstanceToBattleDefinition(p));
-    const enemyDefinition = picletInstanceToBattleDefinition(enemyPiclet);
-    
-    // Find the starting player piclet index in the roster
-    const startingPlayerIndex = rosterPiclets.findIndex(p => p.id === playerPiclet.id);
-    
-    // Initialize with full rosters (player roster vs single enemy)
-    battleEngine = new BattleEngine(playerRosterDefinitions, enemyDefinition, playerPiclet.level, enemyPiclet.level);
-    
-    // If starting piclet is not the first in roster, switch to it
-    if (startingPlayerIndex > 0) {
-      const initialSwitchAction: SwitchAction = {
-        type: 'switch',
-        piclet: 'player',
-        newPicletIndex: startingPlayerIndex
-      };
-      battleEngine.executeAction(initialSwitchAction, 'player');
-    }
-    
-    battleState = battleEngine.getState();
-    
-    // Start intro sequence
-    setTimeout(() => {
-      if (!isWildBattle) {
-        // Enemy trainer sends out first
-        currentMessage = `Go, ${enemyPiclet.nickname}!`;
-        enemyTrainerSlideOut = true;
-        setTimeout(() => {
-          currentMessage = `Go, ${playerPiclet.nickname}!`;
-          playerTrainerSlideOut = true;
-          setTimeout(() => {
-            currentMessage = `What will ${playerPiclet.nickname} do?`;
-            battlePhase = 'main';
-          }, 2000); // Wait for trainer slide + flash + monster appear
-        }, 2000); // Wait for enemy trainer sequence
-      } else {
-        // Wild battle - player sends out
-        currentMessage = `Go, ${playerPiclet.nickname}!`;
-        playerTrainerSlideOut = true;
-        setTimeout(() => {
-          currentMessage = `What will ${playerPiclet.nickname} do?`;
-          battlePhase = 'main';
-        }, 2000); // Wait for trainer slide + flash + monster appear
-      }
-    }, 2000);
-  });
-  
-  function handleAction(action: string) {
-    if (processingTurn || battleEnded) return;
-    
-    switch (action) {
-      case 'catch':
-        if (isWildBattle && battleEngine) {
-          processingTurn = true;
-          
-          // Get capture percentage to show to player
-          const capturePercentage = battleEngine.getCapturePercentage();
-          const captureDescription = getCaptureDescription(capturePercentage);
-          
-          console.log(`📸 Capture attempt: ${capturePercentage.toFixed(1)}% chance (${captureDescription})`);
-          
-          try {
-            // Create capture action
-            const captureAction = { type: 'capture' as const, piclet: 'player' as const };
-            // Get proper enemy action (same as normal turns)
-            const enemyAction = selectEnemyMove();
-            if (!enemyAction) {
-              processingTurn = false;
-              return;
-            }
-            
-            // Get log entries before action to track new messages
-            const logBefore = battleEngine.getLog();
-            
-            // Execute capture attempt
-            battleEngine.executeActions(captureAction, enemyAction);
-            battleState = battleEngine.getState();
-            
-            // Update UI state (HP bars, etc.) after the actions
-            updateUIFromBattleState();
-            
-            // Get capture result and new log entries
-            const captureResult = battleState.captureResult;
-            const logAfter = battleEngine.getLog();
-            const newLogEntries = logAfter.slice(logBefore.length);
-            
-            // Show log messages with proper timing and visual effects
-            if (newLogEntries.length > 0) {
-              let messageIndex = 0;
-              
-              const showNextMessage = () => {
-                if (messageIndex < newLogEntries.length) {
-                  currentMessage = newLogEntries[messageIndex];
-                  // Trigger visual effects for this message
-                  triggerVisualEffectsFromMessage(newLogEntries[messageIndex]);
-                  messageIndex++;
-                  setTimeout(showNextMessage, 1500); // 1.5s between messages
-                } else {
-                  // All messages shown, check final result
-                  if (captureResult?.success) {
-                    // Capture successful - end battle and add to roster
-                    setTimeout(() => {
-                      battleEnded = true;
-                      onBattleEnd(currentEnemyPiclet); // Pass captured Piclet to add to roster
-                    }, 1000);
-                  } else if (battleState.winner) {
-                    // Battle ended (player probably fainted from enemy attack)
-                    battleEnded = true;
-                    const defeatedPiclet = battleState.winner === 'player' ? currentEnemyPiclet : currentPlayerPiclet;
-                    
-                    // Show the faint message and trigger animation
-                    currentMessage = `${defeatedPiclet.nickname} fainted!`;
-                    
-                    // Trigger faint animation for the defeated Piclet
-                    if (battleState.winner === 'player') {
-                      enemyFaint = true;
-                    } else {
-                      playerFaint = true;
-                    }
-                    
-                    // Wait for faint message, then process battle results
-                    setTimeout(async () => {
-                      await handleBattleResults(battleState.winner === 'player');
-                    }, 2500); // Wait time for faint message and animation
-                  } else {
-                    // Capture failed - continue battle
-                    setTimeout(() => {
-                      processingTurn = false;
-                      currentMessage = `What will ${currentPlayerPiclet.nickname} do?`;
-                    }, 1000);
-                  }
-                }
-              };
-              
-              showNextMessage();
-            } else {
-              // No messages, fall back to basic handling
-              currentMessage = 'The capture attempt failed!';
-              setTimeout(() => {
-                processingTurn = false;
-              }, 2000);
-            }
-            
-          } catch (error) {
-            console.error('Capture error:', error);
-            currentMessage = 'Something went wrong with the capture attempt!';
-            processingTurn = false;
-          }
-        } else if (!isWildBattle) {
-          currentMessage = "You can't capture a trainer's Piclet!";
-        }
-        break;
-      case 'run':
-        if (isWildBattle) {
-          currentMessage = 'Got away safely!';
-          battleEnded = true;
-          setTimeout(() => onBattleEnd(false), 1500);
-        } else {
-          currentMessage = "You can't run from a trainer battle!";
-        }
-        break;
-    }
-  }
-  
-  function handleMoveSelect(move: BattleMove) {
-    if (!battleEngine) return;
-    
-    battlePhase = 'main';
-    processingTurn = true;
-    
-    // Find the corresponding move in the battle engine
-    const battleMove = battleState.playerPiclet.moves.find(m => m.move.name === move.name);
-    if (!battleMove) return;
-    
-    const moveAction: MoveAction = {
-      type: 'move',
-      piclet: 'player',
-      moveIndex: battleState.playerPiclet.moves.indexOf(battleMove)
-    };
-    
-    try {
-      // Select enemy move (wild Piclets always random, trainers could use AI)
-      const enemyAction = selectEnemyMove();
-      if (!enemyAction) {
-        processingTurn = false;
-        return;
-      }
-      
-      // Get log entries before action to track new messages
-      const logBefore = battleEngine.getLog();
-      
-      // Execute the turn - battle engine handles priority automatically
-      battleEngine.executeActions(moveAction, enemyAction);
-      battleState = battleEngine.getState();
-      
-      // Get only the new log entries from this turn
-      const logAfter = battleEngine.getLog();
-      const newLogEntries = logAfter.slice(logBefore.length);
-      // Filter out faint messages since we handle them manually for proper sequencing
-      const filteredLogEntries = newLogEntries.filter(message => !message.includes('fainted'));
-      const result = { log: filteredLogEntries };
-      
-      // Show battle messages with tap-to-continue system
-      if (result.log && result.log.length > 0) {
-        showMessageSequence(result.log, finalizeTurn);
-      } else {
-        finalizeTurn();
-      }
-      
-      function finalizeTurn() {
-        // Update UI state from battle engine
-        updateUIFromBattleState();
-        
-        // Check for battle end - only show faint message
-        if (battleState.winner) {
-          battleEnded = true;
-          const defeatedPiclet = battleState.winner === 'player' ? currentEnemyPiclet : currentPlayerPiclet;
-          
-          // Show the faint message and trigger animation
-          currentMessage = `${defeatedPiclet.nickname} fainted!`;
-          
-          // Trigger faint animation for the defeated Piclet
-          if (battleState.winner === 'player') {
-            enemyFaint = true;
-          } else {
-            playerFaint = true;
-          }
-          
-          // Wait for faint message, then process battle results
-          setTimeout(async () => {
-            await handleBattleResults(battleState.winner === 'player');
-          }, 2500); // Wait time for faint message and animation
-        } else {
-          // Check if player Piclet switched due to fainting
-          const newPlayerPiclet = battlePicletToInstance(battleState.playerPiclet, currentPlayerPiclet);
-          const playerPicletChanged = currentPlayerPiclet.id !== newPlayerPiclet.id;
-          
-          if (playerPicletChanged) {
-            // Player Piclet fainted and auto-switched - show faint message first
-            const faintedPiclet = currentPlayerPiclet;
-            currentMessage = `${faintedPiclet.nickname} fainted!`;
-            playerFaint = true;
-            
-            // Wait for faint message, then show switch and continue
-            setTimeout(() => {
-              currentMessage = `Go, ${newPlayerPiclet.nickname}!`;
-              // updateUIFromBattleState will handle the white flash transition
-              setTimeout(() => {
-                currentMessage = `What will ${currentPlayerPiclet.nickname} do?`;
-                processingTurn = false;
-              }, 1000);
-            }, 2500);
-          } else {
-            // Normal turn end - no faint or switch
-            setTimeout(() => {
-              currentMessage = `What will ${currentPlayerPiclet.nickname} do?`;
-              processingTurn = false;
-            }, 1000);
-          }
-        }
-      }
-    } catch (error) {
-      console.error('Battle engine error:', error);
-      currentMessage = 'Something went wrong in battle!';
-      processingTurn = false;
-    }
-  }
-  
-  
-  function triggerVisualEffectsFromMessage(message: string) {
-    // Use stripped names since battle messages no longer have prefixes
-    const playerName = stripBattlePrefix(battleState?.playerPiclet?.definition?.name || '');
-    const enemyName = stripBattlePrefix(battleState?.opponentPiclet?.definition?.name || '');
-    
-    // Track who is the current attacker for effects that should appear on the defender
-    let currentAttacker: 'player' | 'enemy' | null = null;
-    
-    // Attack lunge effects - trigger immediately when a Piclet uses a move
-    if (message.includes(' used ')) {
-      if (message.includes(playerName)) {
-        triggerLungeAnimation('player');
-        currentAttacker = 'player';
-      } else if (message.includes(enemyName)) {
-        triggerLungeAnimation('enemy');
-        currentAttacker = 'enemy';
-      }
-    }
-    
-    // Damage flash effects - trigger when damage is taken
-    if (message.includes('took') && message.includes('damage')) {
-      if (message.includes(playerName)) {
-        triggerDamageFlash('player');
-        updateUIFromBattleState();
-      } else if (message.includes(enemyName)) {
-        triggerDamageFlash('enemy');
-        updateUIFromBattleState();
-      }
-    }
-    
-    // Critical hit effects - show on the target that was hit
-    if (message.includes('critical hit')) {
-      // Critical hits appear after damage, so check who took damage
-      const target = message.includes(`${enemyName} took`) ? 'enemy' : 
-                    message.includes(`${playerName} took`) ? 'player' :
-                    // Fallback: if player used move, enemy is target and vice versa
-                    message.includes(`${playerName} used`) ? 'enemy' : 'player';
-      triggerEffect(target, 'critical', '💥', 1000);
-    }
-    
-    // Effectiveness messages - show on the target that was hit
-    if (message.includes("It's super effective")) {
-      // Super effective appears after the move, determine target based on attacker
-      const target = message.includes(`${playerName} used`) ? 'enemy' : 
-                    message.includes(`${enemyName} used`) ? 'player' :
-                    // Fallback based on damage message
-                    message.includes(`${enemyName} took`) ? 'enemy' : 'player';
-      triggerEffect(target, 'superEffective', '⚡', 800);
-    } else if (message.includes("not very effective")) {
-      // Not very effective appears after the move, determine target based on attacker
-      const target = message.includes(`${playerName} used`) ? 'enemy' : 
-                    message.includes(`${enemyName} used`) ? 'player' :
-                    // Fallback based on damage message
-                    message.includes(`${enemyName} took`) ? 'enemy' : 'player';
-      triggerEffect(target, 'notVeryEffective', '💨', 800);
-    }
-    
-    // Status effects
-    if (message.includes('was burned')) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      triggerEffect(target, 'burn', '🔥', 1200);
-    } else if (message.includes('was poisoned')) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      triggerEffect(target, 'poison', '☠️', 1200);
-    } else if (message.includes('was paralyzed')) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      triggerEffect(target, 'paralyze', '⚡', 1200);
-    } else if (message.includes('fell asleep')) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      triggerEffect(target, 'sleep', '😴', 1200);
-    } else if (message.includes('was frozen')) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      triggerEffect(target, 'freeze', '❄️', 1200);
-    }
-    
-    // Stat changes
-    if (message.includes("'s") && (message.includes('rose') || message.includes('fell'))) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      const isIncrease = message.includes('rose');
-      
-      if (message.includes('attack')) {
-        triggerEffect(target, isIncrease ? 'attackUp' : 'attackDown', isIncrease ? '⚔️' : '🔻', 1000);
-      } else if (message.includes('defense')) {
-        triggerEffect(target, isIncrease ? 'defenseUp' : 'defenseDown', isIncrease ? '🛡️' : '🔻', 1000);
-      } else if (message.includes('speed')) {
-        triggerEffect(target, isIncrease ? 'speedUp' : 'speedDown', isIncrease ? '💨' : '🐌', 1000);
-      } else if (message.includes('accuracy')) {
-        triggerEffect(target, isIncrease ? 'accuracyUp' : 'accuracyDown', isIncrease ? '🎯' : '👁️', 1000);
-      }
-    }
-    
-    // Healing effects
-    if (message.includes('recovered') && message.includes('HP')) {
-      const target = message.includes(playerName) ? 'player' : 'enemy';
-      triggerEffect(target, 'heal', '💚', 1000);
-      // Update HP bar immediately for healing animation sync
-      updateUIFromBattleState();
-    }
-    
-    // Miss effects - show on the attacker who missed
-    if (message.includes('missed')) {
-      const target = message.includes(`${playerName}'s attack`) || message.includes(`${playerName} used`) ? 'player' : 
-                    message.includes(`${enemyName}'s attack`) || message.includes(`${enemyName} used`) ? 'enemy' : 
-                    'player'; // Fallback
-      triggerEffect(target, 'miss', '💫', 800);
-    }
-    
-    // Faint effects - only trigger when we see the faint message from battle log
-    // Don't trigger here since we handle it in finalizeTurn for proper sequencing
-  }
-  
-  function triggerDamageFlash(target: 'player' | 'enemy') {
-    if (target === 'player') {
-      playerFlash = true;
-      setTimeout(() => playerFlash = false, 1000); // Match original Snaplings flicker duration
-    } else {
-      enemyFlash = true;
-      setTimeout(() => enemyFlash = false, 1000); // Match original Snaplings flicker duration
-    }
-  }
-  
-  function triggerFaintAnimation(target: 'player' | 'enemy') {
-    if (target === 'player') {
-      playerFaint = true;
-      // Don't reset - faint animation should persist until battle ends
-    } else {
-      enemyFaint = true;
-      // Don't reset - faint animation should persist until battle ends
-    }
-  }
-  
-  function triggerLungeAnimation(target: 'player' | 'enemy') {
-    if (target === 'player') {
-      playerLunge = true;
-      setTimeout(() => playerLunge = false, 600); // Reset after animation
-    } else {
-      enemyLunge = true;
-      setTimeout(() => enemyLunge = false, 600); // Reset after animation
-    }
-  }
-  
-  function triggerEffect(target: 'player' | 'enemy' | 'both', type: string, emoji: string, duration: number) {
-    const effect = { type, emoji, duration };
-    
-    if (target === 'player' || target === 'both') {
-      playerEffects = [...playerEffects, effect];
-      setTimeout(() => {
-        playerEffects = playerEffects.filter(e => e !== effect);
-      }, duration);
-    }
-    
-    if (target === 'enemy' || target === 'both') {
-      enemyEffects = [...enemyEffects, effect];
-      setTimeout(() => {
-        enemyEffects = enemyEffects.filter(e => e !== effect);
-      }, duration);
-    }
+  import type { PicletInstance } from '$lib/db/schema';
+  import LLMBattleEngine from '../Battle/LLMBattleEngine.svelte';
+  import type { GradioClient } from '$lib/types';
+  
+  interface Props {
+    playerPiclet: PicletInstance;
+    enemyPiclet: PicletInstance;
+    isWildBattle: boolean;
+    rosterPiclets?: PicletInstance[];
+    onBattleEnd: (result: { winner: 'player' | 'enemy'; capturedPiclet?: PicletInstance }) => void;
+    commandClient: GradioClient;
   }
 
-  function showMessageSequence(messages: string[], callback: () => void) {
-    if (!messages || messages.length === 0) {
-      callback();
-      return;
-    }
-    
-    messageQueue = messages;
-    currentMessageIndex = 0;
-    continueCallback = callback;
-    
-    // Show first message and trigger its effects
-    currentMessage = messageQueue[0];
-    waitingForContinue = true;
-    
-    // Trigger visual effects automatically after text appears (with small delay for text animation)
-    setTimeout(() => {
-      triggerVisualEffectsFromMessage(currentMessage);
-    }, 500); // Allow time for typewriter text to complete
-  }
-  
-  function selectEnemyMove(): MoveAction | null {
-    const availableEnemyMoves = battleState.opponentPiclet.moves.filter(m => m.currentPP > 0);
-    
-    if (availableEnemyMoves.length === 0) {
-      currentMessage = `${currentEnemyPiclet.nickname} has no moves left!`;
-      return null;
-    }
-    
-    if (isWildBattle) {
-      // Wild Piclets always use completely random moves (no trainer strategy)
-      const randomEnemyMove = availableEnemyMoves[Math.floor(Math.random() * availableEnemyMoves.length)];
-      const enemyMoveIndex = battleState.opponentPiclet.moves.indexOf(randomEnemyMove);
-      
-      return {
-        type: 'move',
-        piclet: 'opponent',
-        moveIndex: enemyMoveIndex
-      };
-    } else {
-      // Trainer battles - currently also random, but could be enhanced with AI later
-      const randomEnemyMove = availableEnemyMoves[Math.floor(Math.random() * availableEnemyMoves.length)];
-      const enemyMoveIndex = battleState.opponentPiclet.moves.indexOf(randomEnemyMove);
-      
-      return {
-        type: 'move',
-        piclet: 'opponent',
-        moveIndex: enemyMoveIndex
-      };
-    }
-  }
+  let { playerPiclet, enemyPiclet, isWildBattle, rosterPiclets, onBattleEnd, commandClient }: Props = $props();
 
-  function handleContinueTap() {
-    if (!waitingForContinue || !messageQueue.length) return;
-    
-    currentMessageIndex++;
-    
-    if (currentMessageIndex >= messageQueue.length) {
-      // Sequence finished
-      waitingForContinue = false;
-      messageQueue = [];
-      currentMessageIndex = 0;
-      
-      if (continueCallback) {
-        continueCallback();
-        continueCallback = null;
-      }
-    } else {
-      // Show next message
-      currentMessage = messageQueue[currentMessageIndex];
-      
-      // Trigger visual effects automatically after text appears
-      setTimeout(() => {
-        triggerVisualEffectsFromMessage(currentMessage);
-      }, 500); // Allow time for typewriter text to complete
-    }
-  }
+  // Simple battle state
+  let battleEnded = $state(false);
+  let battleResult: { winner: 'player' | 'enemy'; capturedPiclet?: PicletInstance } | null = $state(null);
 
-  function updateUIFromBattleState() {
-    if (!battleState) return;
-    
-    // Check if player Piclet has changed (indicating auto-switch due to fainting)
-    const newPlayerPiclet = battlePicletToInstance(battleState.playerPiclet, currentPlayerPiclet);
-    const playerPicletChanged = currentPlayerPiclet.id !== newPlayerPiclet.id;
-    
-    if (playerPicletChanged) {
-      // Player Piclet auto-switched due to fainting - show transition
-      showWhiteFlash = true;
-      setTimeout(() => {
-        currentPlayerPiclet = newPlayerPiclet;
-        playerHpPercentage = battleState.playerPiclet.currentHp / battleState.playerPiclet.maxHp;
-        showWhiteFlash = false;
-      }, 300);
-    } else {
-      // Normal update without switch
-      currentPlayerPiclet = newPlayerPiclet;
-      playerHpPercentage = battleState.playerPiclet.currentHp / battleState.playerPiclet.maxHp;
-    }
-    
-    // Update enemy piclet state  
-    currentEnemyPiclet = battlePicletToInstance(battleState.opponentPiclet, currentEnemyPiclet);
-    enemyHpPercentage = battleState.opponentPiclet.currentHp / battleState.opponentPiclet.maxHp;
-  }
-  
-  function handlePicletSelect(piclet: PicletInstance) {
-    if (!battleEngine) return;
+  // Handle battle end
+  function handleBattleEnd(winner: 'player' | 'enemy') {
+    battleEnded = true;
     
-    battlePhase = 'main';
-    processingTurn = true;
+    // Simplified: no capture mechanics since Piclets are auto-captured when scanned
+    battleResult = { winner };
     
-    // Find the index of the selected piclet in the roster
-    const picletIndex = rosterPiclets.findIndex(p => p.id === piclet.id);
-    if (picletIndex === -1) {
-      console.error('Selected piclet not found in roster');
-      processingTurn = false;
-      return;
-    }
-    
-    // Show the switch message and trigger white flash animation
-    currentMessage = `Go, ${piclet.nickname}!`;
-    showWhiteFlash = true;
-    
-    // After flash, update display
+    // Give time for final battle messages, then call parent handler
     setTimeout(() => {
-      currentPlayerPiclet = piclet;
-      playerHpPercentage = piclet.currentHp / piclet.maxHp;
-      showWhiteFlash = false;
-    }, 300);
-    
-    const switchAction: SwitchAction = {
-      type: 'switch',
-      piclet: 'player',
-      newPicletIndex: picletIndex
-    };
-    
-    try {
-      // Select enemy move (wild Piclets always random, trainers could use AI)
-      const enemyAction = selectEnemyMove();
-      if (!enemyAction) {
-        processingTurn = false;
-        return;
-      }
-      
-      // Allow time for the visual switch to be seen before processing the turn
-      setTimeout(() => {
-        // Get log entries before action to track new messages
-        const logBefore = battleEngine.getLog();
-        
-        // Execute the turn - switching vs enemy move
-        battleEngine.executeActions(switchAction, enemyAction);
-        battleState = battleEngine.getState();
-        
-        processAfterSwitchTurn(logBefore);
-      }, 1000); // 1 second delay to show the switch visually
-    } catch (error) {
-      console.error('Battle engine error:', error);
-      currentMessage = 'Unable to switch Piclets!';
-      processingTurn = false;
-    }
-  }
-  
-  function processAfterSwitchTurn(logBefore: string[]) {
-    try {
-      
-      // Get only the new log entries from this turn
-      const logAfter = battleEngine.getLog();
-      const newLogEntries = logAfter.slice(logBefore.length);
-      // Filter out faint messages since we handle them manually for proper sequencing
-      const filteredLogEntries = newLogEntries.filter(message => !message.includes('fainted'));
-      const result = { log: filteredLogEntries };
-      
-      // Show battle messages with tap-to-continue system
-      if (result.log && result.log.length > 0) {
-        showMessageSequence(result.log, finalizeSwitchTurn);
-      } else {
-        finalizeSwitchTurn();
-      }
-      
-      function finalizeSwitchTurn() {
-        // Update UI state from battle engine
-        updateUIFromBattleState();
-        
-        // Check for battle end - only show faint message
-        if (battleState.winner) {
-          battleEnded = true;
-          const defeatedPiclet = battleState.winner === 'player' ? currentEnemyPiclet : currentPlayerPiclet;
-          
-          // Show the faint message and trigger animation
-          currentMessage = `${defeatedPiclet.nickname} fainted!`;
-          
-          // Trigger faint animation for the defeated Piclet
-          if (battleState.winner === 'player') {
-            enemyFaint = true;
-          } else {
-            playerFaint = true;
-          }
-          
-          // Wait for faint message, then process battle results
-          setTimeout(async () => {
-            await handleBattleResults(battleState.winner === 'player');
-          }, 2500); // Wait time for faint message and animation
-        } else {
-          setTimeout(() => {
-            currentMessage = `What will ${currentPlayerPiclet.nickname} do?`;
-            processingTurn = false;
-          }, 1000);
-        }
-      }
-    } catch (error) {
-      console.error('Switch error:', error);
-      currentMessage = 'Unable to switch Piclets!';
-      processingTurn = false;
-    }
-  }
-  
-  function handleBack() {
-    battlePhase = 'main';
-  }
-  
-  async function handleBattleResults(playerWon: boolean) {
-    console.log('🏆 handleBattleResults called:', { playerWon });
-    
-    if (playerWon) {
-      // Calculate XP gained from defeating the enemy
-      console.log('💰 Calculating XP for enemy:', {
-        enemyName: currentEnemyPiclet.nickname,
-        enemyLevel: currentEnemyPiclet.level
-      });
-      const xpGained = calculateBattleXp(currentEnemyPiclet, 1);
-      console.log('�� XP calculation result:', xpGained);
-      
-      if (xpGained > 0) {
-        console.log('✅ XP > 0, processing XP gain...');
-        // Animate XP gain by updating UI first
-        const updatedPlayerPiclet = {
-          ...currentPlayerPiclet,
-          xp: currentPlayerPiclet.xp + xpGained
-        };
-        currentPlayerPiclet = updatedPlayerPiclet;
-        
-        // Wait a moment for XP bar animation
-        await new Promise(resolve => setTimeout(resolve, 1500));
-        
-        // Process any level ups
-        const { newInstance, levelUpInfo } = processAllLevelUps(updatedPlayerPiclet);
-        
-        // Save updated Piclet to database
-        if (newInstance.id) {
-          console.log('💾 Saving XP to database:', {
-            picletId: newInstance.id,
-            oldXP: currentPlayerPiclet.xp,
-            newXP: newInstance.xp,
-            xpGained: xpGained
-          });
-          await db.picletInstances.update(newInstance.id, newInstance);
-          console.log('✅ Database update completed');
-        } else {
-          console.log('❌ No piclet ID, cannot save to database');
-        }
-        
-        // Update local state with final leveled instance
-        currentPlayerPiclet = newInstance;
-        console.log('🔄 Updated currentPlayerPiclet with new XP:', currentPlayerPiclet.xp);
-        
-        // Show level up results if any occurred
-        if (levelUpInfo.length > 0) {
-          battleResults = {
-            victory: true,
-            xpGained,
-            levelUps: levelUpInfo,
-            newLevel: newInstance.level
-          };
-          
-          battleResultsVisible = true;
-          
-          // Auto-dismiss after showing level up
-          setTimeout(() => {
-            battleResultsVisible = false;
-            onBattleEnd(true);
-          }, 4000);
-        } else {
-          // No level up, just end battle
-          console.log('📈 No level up, ending battle with XP gain');
-          onBattleEnd(true);
-        }
-      } else {
-        console.log('❌ XP is 0 or negative, ending battle without XP');
-        onBattleEnd(true);
-      }
-    } else {
-      // Player lost - no XP gained
-      onBattleEnd(false);
-    }
+      onBattleEnd(battleResult!);
+    }, 2000);
   }
 </script>
 
-<div class="battle-page" transition:fade={{ duration: 300 }}>
-  <nav class="battle-nav">
-    <button class="back-button" on:click={() => onBattleEnd('cancelled')} style="display: none;">
-      ← Back
-    </button>
-    <h1>{isWildBattle ? 'Wild Battle' : 'Battle'}</h1>
-    <div class="nav-spacer"></div>
-  </nav>
-  
-  <div class="battle-content">
-    <BattleField 
-      playerPiclet={currentPlayerPiclet}
-      enemyPiclet={currentEnemyPiclet}
-      {playerHpPercentage}
-      {enemyHpPercentage}
-      showIntro={battlePhase === 'intro'}
-      {battleState}
-      {playerEffects}
-      {enemyEffects}
-      {playerFlash}
-      {enemyFlash}
-      {playerFaint}
-      {enemyFaint}
-      {playerLunge}
-      {enemyLunge}
-      {isWildBattle}
-      {showWhiteFlash}
-      {playerTrainerVisible}
-      {enemyTrainerVisible}
-      {playerTrainerSlideOut}
-      {enemyTrainerSlideOut}
-    />
-    
-    <BattleControls
-      {currentMessage}
-      {battlePhase}
-      {processingTurn}
-      {battleEnded}
-      {isWildBattle}
-      playerPiclet={currentPlayerPiclet}
-      enemyPiclet={currentEnemyPiclet}
-      {rosterPiclets}
-      {battleState}
-      {capturePercentage}
-      {waitingForContinue}
-      onAction={handleAction}
-      onMoveSelect={handleMoveSelect}
-      onPicletSelect={handlePicletSelect}
-      onBack={handleBack}
-      onContinueTap={handleContinueTap}
-    />
+<div class="battle-page" transition:fade>
+  <!-- Header -->
+  <div class="battle-header">
+    <h2>{isWildBattle ? 'Wild Battle' : 'Trainer Battle'}</h2>
+    <div class="battle-participants">
+      <div class="participant player">
+        <img src={playerPiclet.imageUrl} alt={playerPiclet.typeId} />
+        <h3>{playerPiclet.typeId}</h3>
+        <span class="tier tier-{playerPiclet.tier}">{playerPiclet.tier}</span>
+      </div>
+      
+      <div class="vs-indicator">
+        <span>VS</span>
+      </div>
+      
+      <div class="participant enemy">
+        <img src={enemyPiclet.imageUrl} alt={enemyPiclet.typeId} />
+        <h3>{enemyPiclet.typeId}</h3>
+        <span class="tier tier-{enemyPiclet.tier}">{enemyPiclet.tier}</span>
+      </div>
+    </div>
   </div>
-  
-  <!-- Battle Results Overlay -->
-  {#if battleResultsVisible}
-    <div class="battle-results-overlay" transition:fade={{ duration: 300 }}>
-      <div class="battle-results-card">
-        <h2>{battleResults.victory ? 'Victory!' : 'Defeat!'}</h2>
-        
+
+  <!-- Main Battle Area -->
+  <div class="battle-main">
+    {#if !battleEnded}
+      <LLMBattleEngine
+        {playerPiclet}
+        {enemyPiclet}
+        {rosterPiclets}
+        {commandClient}
+        onBattleEnd={handleBattleEnd}
+      />
+    {:else}
+      <div class="battle-results">
+        <h2>{battleResult?.winner === 'player' ? '🎉 Victory!' : '💀 Defeat!'}</h2>
         
-        {#if battleResults.levelUps.length > 0}
-          {#each battleResults.levelUps as levelUp}
-            <div class="level-up" transition:fade={{ duration: 500 }}>
-              <h3>🎉 Level Up! 🎉</h3>
-              <p><strong>{currentPlayerPiclet.nickname}</strong> grew to level <strong>{levelUp.newLevel}</strong>!</p>
-              
-              <div class="stat-changes">
-                {#if levelUp.statChanges.hp > 0}
-                  <div class="stat-change">HP +{levelUp.statChanges.hp}</div>
-                {/if}
-                {#if levelUp.statChanges.attack > 0}
-                  <div class="stat-change">Attack +{levelUp.statChanges.attack}</div>
-                {/if}
-                {#if levelUp.statChanges.defense > 0}
-                  <div class="stat-change">Defense +{levelUp.statChanges.defense}</div>
-                {/if}
-                {#if levelUp.statChanges.speed > 0}
-                  <div class="stat-change">Speed +{levelUp.statChanges.speed}</div>
-                {/if}
-              </div>
-            </div>
-          {/each}
+        {#if battleResult?.winner === 'player'}
+          <p>You defeated {enemyPiclet.typeId}!</p>
+        {:else}
+          <p>{playerPiclet.typeId} was defeated by {enemyPiclet.typeId}...</p>
+          <p>Better luck next time!</p>
         {/if}
       </div>
-    </div>
-  {/if}
+    {/if}
+  </div>
 </div>
 
 <style>
   .battle-page {
-    position: fixed;
-    inset: 0;
-    z-index: 1000;
     height: 100vh;
     display: flex;
     flex-direction: column;
-    background: #f8f9fa;
-    overflow: hidden;
-    padding-top: env(safe-area-inset-top);
-  }
-  
-  @media (max-width: 768px) {
-    .battle-page {
-      background: white;
-    }
-    
-    .battle-page::before {
-      content: '';
-      position: absolute;
-      top: 0;
-      left: 0;
-      right: 0;
-      height: env(safe-area-inset-top);
-      background: white;
-      z-index: 1;
-    }
-  }
-  
-  .battle-nav {
-    display: none; /* Hide navigation in battle */
-  }
-  
-  .back-button {
-    background: none;
-    border: none;
-    color: #007bff;
-    font-size: 1rem;
-    cursor: pointer;
-    padding: 0.5rem;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
   }
   
-  .battle-nav h1 {
-    margin: 0;
-    font-size: 1.25rem;
-    font-weight: 600;
-    color: #1a1a1a;
-    position: absolute;
-    left: 50%;
-    transform: translateX(-50%);
-  }
-  
-  .nav-spacer {
-    width: 60px;
+  .battle-header {
+    padding: 1rem;
+    text-align: center;
+    background: rgba(0, 0, 0, 0.1);
+    backdrop-filter: blur(10px);
   }
   
-  .battle-content {
-    flex: 1;
+  .battle-participants {
     display: flex;
-    flex-direction: column;
-    overflow: hidden;
-    position: relative;
-    background: #f8f9fa;
+    align-items: center;
+    justify-content: center;
+    gap: 2rem;
+    margin-top: 1rem;
   }
   
-  /* Battle Results Overlay */
-  .battle-results-overlay {
-    position: fixed;
-    inset: 0;
-    background: rgba(0, 0, 0, 0.8);
+  .participant {
     display: flex;
+    flex-direction: column;
     align-items: center;
-    justify-content: center;
-    z-index: 2000;
+    gap: 0.5rem;
   }
   
-  .battle-results-card {
-    background: white;
-    border-radius: 16px;
-    padding: 2rem;
-    max-width: 400px;
-    width: 90%;
-    text-align: center;
-    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+  .participant img {
+    width: 80px;
+    height: 80px;
+    object-fit: cover;
+    border-radius: 50%;
+    border: 3px solid rgba(255, 255, 255, 0.3);
   }
   
-  .battle-results-card h2 {
-    margin: 0 0 1rem 0;
-    font-size: 1.8rem;
-    font-weight: 700;
-    color: #1a1a1a;
+  .participant.player img {
+    border-color: #007bff;
   }
   
+  .participant.enemy img {
+    border-color: #dc3545;
+  }
   
-  .level-up {
-    background: linear-gradient(135deg, #fff3e0 0%, #ffcc02 100%);
+  .tier {
+    padding: 0.25rem 0.5rem;
     border-radius: 12px;
-    padding: 1.5rem;
-    margin: 1rem 0;
-    border: 3px solid #ff6f00;
-    animation: levelUpPulse 0.6s ease-in-out;
+    font-size: 0.8rem;
+    font-weight: bold;
+    text-transform: uppercase;
   }
   
-  .level-up h3 {
-    margin: 0 0 0.5rem 0;
-    font-size: 1.4rem;
-    color: #e65100;
-    text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.1);
+  .tier-low { background: #6c757d; }
+  .tier-medium { background: #28a745; }
+  .tier-high { background: #fd7e14; }
+  .tier-legendary { background: #dc3545; }
+  
+  .vs-indicator {
+    font-size: 2rem;
+    font-weight: bold;
+    color: #ffd700;
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
   }
   
-  .level-up p {
-    margin: 0 0 1rem 0;
-    font-size: 1.2rem;
-    color: #bf360c;
+  .battle-main {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: white;
+    color: #333;
+    border-radius: 20px 20px 0 0;
+    overflow: hidden;
   }
   
-  .stat-changes {
+  .battle-results {
+    flex: 1;
     display: flex;
-    flex-wrap: wrap;
-    gap: 0.5rem;
+    flex-direction: column;
+    align-items: center;
     justify-content: center;
+    text-align: center;
+    padding: 2rem;
+    gap: 1rem;
   }
   
-  .stat-change {
-    background: rgba(76, 175, 80, 0.2);
-    border: 1px solid #4caf50;
-    border-radius: 20px;
-    padding: 0.25rem 0.75rem;
-    font-size: 0.9rem;
-    font-weight: 600;
-    color: #2e7d32;
+  .battle-results h2 {
+    font-size: 2.5rem;
+    margin: 0;
   }
   
-  @keyframes levelUpPulse {
-    0% {
-      transform: scale(0.9);
-      opacity: 0;
-    }
-    50% {
-      transform: scale(1.05);
-    }
-    100% {
-      transform: scale(1);
-      opacity: 1;
-    }
-  }
 </style>

src/lib/components/Pages/Encounters.svelte

@@ -5,8 +5,7 @@
   import { EncounterType } from '$lib/db/schema';
   import { EncounterService } from '$lib/db/encounterService';
   import { getOrCreateGameState, incrementCounter, addProgressPoints } from '$lib/db/gameState';
-  import { calculateStat, calculateHp } from '$lib/services/levelingService';
-  import { db } from '$lib/db';
+    import { db } from '$lib/db';
   import { uiStore } from '$lib/stores/ui';
   import Battle from './Battle.svelte';
   import PullToRefresh from '../UI/PullToRefresh.svelte';
@@ -110,36 +109,9 @@
     } else if (encounter.type === EncounterType.WILD_PICLET && encounter.picletTypeId) {
       // Regular wild encounter - start battle
       await startBattle(encounter);
-    } else if (encounter.type === EncounterType.SHOP) {
-      await handleShopEncounter();
-    } else if (encounter.type === EncounterType.HEALTH_CENTER) {
-      await handleHealthCenterEncounter();
-    } else if (encounter.type === EncounterType.TRAINER_BATTLE) {
-      alert('Trainer battles coming soon!');
     }
   }
   
-  async function handleShopEncounter() {
-    alert('Shop features coming soon!');
-    await forceEncounterRefresh();
-  }
-  
-  async function handleHealthCenterEncounter() {
-    try {
-      // Heal all piclets
-      const piclets = await db.picletInstances.toArray();
-      for (const piclet of piclets) {
-        await db.picletInstances.update(piclet.id!, {
-          currentHp: piclet.maxHp
-        });
-      }
-      
-      alert('All your piclets have been healed to full health!');
-      await forceEncounterRefresh();
-    } catch (error) {
-      console.error('Error at health center:', error);
-    }
-  }
 
   async function handleFirstPicletEncounter(encounter: Encounter) {
     try {
@@ -195,12 +167,6 @@
   
   function getEncounterIcon(encounter: Encounter): string {
     switch (encounter.type) {
-      case EncounterType.SHOP:
-        return '🛍️';
-      case EncounterType.HEALTH_CENTER:
-        return '❤️';
-      case EncounterType.TRAINER_BATTLE:
-        return '🏆';
       case EncounterType.FIRST_PICLET:
         return '✨';
       case EncounterType.WILD_PICLET:
@@ -215,12 +181,6 @@
         return '#4caf50';
       case EncounterType.FIRST_PICLET:
         return '#ffd700';
-      case EncounterType.TRAINER_BATTLE:
-        return '#ff9800';
-      case EncounterType.SHOP:
-        return '#2196f3';
-      case EncounterType.HEALTH_CENTER:
-        return '#9c27b0';
       default:
         return '#607d8b';
     }
@@ -242,11 +202,8 @@
       // Sort by roster position
       rosterPiclets.sort((a, b) => (a.rosterPosition ?? 0) - (b.rosterPosition ?? 0));
       
-      // Get healthy piclets
-      const healthyPiclets = rosterPiclets.filter(p => p.currentHp > 0);
-      
-      if (healthyPiclets.length === 0) {
-        alert('You need at least one healthy piclet in your roster to battle!');
+      if (rosterPiclets.length === 0) {
+        alert('You need at least one piclet in your roster to battle!');
         return;
       }
       
@@ -262,7 +219,7 @@
       if (!enemyPiclet) return;
       
       // Set up battle
-      battlePlayerPiclet = healthyPiclets[0];
+      battlePlayerPiclet = rosterPiclets[0];
       battleEnemyPiclet = enemyPiclet;
       battleIsWild = true;
       battleRosterPiclets = rosterPiclets; // Pass all roster piclets
@@ -290,31 +247,11 @@
     // Calculate stats based on template's base stats and encounter level
     const level = encounter.enemyLevel;
     
-    // Calculate current stats based on level (using template's base stats)
-    
-    const maxHp = calculateHp(templatePiclet.baseHp, level);
-    
-    // Create enemy piclet instance based on template
+    // Create enemy piclet instance based on template (simplified)
     const enemyPiclet: PicletInstance = {
       ...templatePiclet,
       id: -1, // Temporary ID for enemy
       
-      level: level,
-      xp: 0,
-      currentHp: maxHp,
-      maxHp: maxHp,
-      attack: calculateStat(templatePiclet.baseAttack, level),
-      defense: calculateStat(templatePiclet.baseDefense, level),
-      fieldAttack: calculateStat(templatePiclet.baseFieldAttack, level),
-      fieldDefense: calculateStat(templatePiclet.baseFieldDefense, level),
-      speed: calculateStat(templatePiclet.baseSpeed, level),
-      
-      // Reset move PP to full
-      moves: templatePiclet.moves.map(move => ({
-        ...move,
-        currentPp: move.pp
-      })),
-      
       isInRoster: false,
       caughtAt: new Date()
     };
@@ -361,9 +298,7 @@
         caught: true,
         caughtAt: new Date(),
         isInRoster: true,
-        rosterPosition: nextPosition,
-        // Ensure level is valid (battle enemies might have invalid levels)
-        level: Math.max(1, Math.min(100, capturedPiclet.level || 5))
+        rosterPosition: nextPosition
       };
       
       // Add the captured piclet to the database
@@ -382,13 +317,11 @@
         console.log(`Added captured Piclet ${createdPiclet.nickname} to roster position ${nextPosition}`);
       } else {
         console.error('Could not retrieve newly created piclet from database');
-        // Fix the level issue and use fallback data
+        // Use fallback data
         const fallbackPiclet = {
           ...capturedPiclet,
-          level: Math.max(1, Math.min(100, capturedPiclet.level || 5)),
           id: newPicletId
         };
-        console.log('Using fallback with fixed level:', fallbackPiclet.level);
         newlyCaughtPiclet = fallbackPiclet;
         showNewlyCaught = true;
       }

src/lib/components/Pages/Pictuary.svelte

@@ -140,7 +140,6 @@
             typeId: piclet.typeId,
             nickname: piclet.nickname,
             primaryType: piclet.primaryType,
-            secondaryType: piclet.secondaryType,
             
             // Current Stats
             currentHp: piclet.currentHp,

src/lib/components/PicletGenerator/PicletGenerator.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
   import type { PicletGeneratorProps, PicletWorkflowState, CaptionType, CaptionLength, PicletStats } from '$lib/types';
-  import { Nature } from '$lib/types';
   import type { PicletInstance } from '$lib/db/schema';
   import UploadStep from './UploadStep.svelte';
   import WorkflowProgress from './WorkflowProgress.svelte';
@@ -230,8 +229,8 @@ Focus on: colors, body shape, eyes, limbs, mouth, and key visual features. Omit
       await generateConcept();
       await new Promise(resolve => setTimeout(resolve, 100)); // Small delay for workflowState update
       
-      // Step 3: Generate structured monster stats based on both caption and concept
-      await generateStats();
+      // Step 3: Extract simple stats from enhanced concept
+      await extractSimpleStats();
       await new Promise(resolve => setTimeout(resolve, 100)); // Small delay for workflowState update
       
       // Step 4: Generate image prompt with qwen3
@@ -241,8 +240,8 @@ Focus on: colors, body shape, eyes, limbs, mouth, and key visual features. Omit
       // Step 5: Generate monster image
       await generateMonsterImage();
       
-      // Step 6: Auto-save the piclet as uncaught
-      await autoSavePiclet();
+      // Step 6: Auto-save the piclet as caught (since scanning now auto-captures)
+      await autoSavePicletAsCaught();
       
       workflowState.currentStep = 'complete';
       
@@ -348,8 +347,11 @@ Format your response exactly as follows:
 # Monster Name
 {Creative name that hints at the original object, 11 letters max}
 
+# Primary Type
+{Based on the object, choose the most fitting primary type: beast, bug, aquatic, flora, mineral, space, machina, structure, culture, or cuisine}
+
 # Monster Description
-{Detailed physical description showing how the object becomes a creature. Ensure the creature uses all the unique attributes of the object. Include colors, shapes, materials, eyes, limbs, mouth, and distinctive features. This section will be used for stats generation and lore.}
+{Detailed physical description showing how the object becomes a creature. Ensure the creature uses all the unique attributes of the object. Include colors, shapes, materials, eyes, limbs, mouth, and distinctive features. This section will be used for battle narratives and lore.}
 
 # Monster Image Prompt
 {Extensive visual description of the Pokémon style monster for image generation. Focus on key visual elements: body shape, colors, distinctive features, pose. Keep this optimized for AI image generation.}
@@ -501,408 +503,63 @@ Create a concise visual description (1-3 sentences, max 100 words). Focus only o
     }
   }
   
-  async function generateStats() {
+  async function extractSimpleStats() {
     workflowState.currentStep = 'statsGenerating';
     
-    const activeClient = getActiveTextClient();
-    if (!activeClient || !workflowState.picletConcept || !workflowState.imageCaption) {
-      throw new Error(`${currentTextClient} service not available or no concept/caption available for stats generation`);
-    }
-    
-    // Default tier (will be set from the generated stats)
-    let tier: 'low' | 'medium' | 'high' | 'legendary' = 'medium';
-    
-    // Extract monster name and rarity from the structured concept
-    const monsterNameMatch = workflowState.picletConcept.match(/# Monster Name\s*\n([\s\S]*?)(?=^#|$)/m);
-    let monsterName = monsterNameMatch ? monsterNameMatch[1].trim() : 'Unknown Monster';
-    
-    // Truncate name at first comma if present
-    if (monsterName.includes(',')) {
-      monsterName = monsterName.split(',')[0].trim();
-    }
-    
-    // Cap name length to 12 characters
-    if (monsterName.length > 12) {
-      monsterName = monsterName.substring(0, 12);
-    }
-    
-    const rarityMatch = workflowState.picletConcept.match(/# Object Rarity\s*\n([\s\S]*?)(?=^#)/m);
-    const objectRarity = rarityMatch ? rarityMatch[1].trim().toLowerCase() : 'common';
-    
-    // Create comprehensive battle-ready monster prompt
-    const statsPrompt = `Based on this detailed object description and monster concept, create a complete battle-ready monster for the Pictuary Battle System:
-
-ORIGINAL OBJECT DESCRIPTION:
-"${workflowState.imageCaption}"
-
-MONSTER CONCEPT:
-"${workflowState.picletConcept}"
-
-The object rarity has been assessed as: ${objectRarity}
-
-## BATTLE SYSTEM OVERVIEW
-This monster will be used in a turn-based battle system with composable effects. You must create:
-1. **Base Stats**: Core combat statistics  
-2. **Special Ability**: Passive trait with triggers and effects
-3. **Movepool**: 4 battle moves with complex effect combinations
-
-## TYPE SYSTEM
-Choose the primary type (and optional secondary type) based on the object:
-• **beast**: Vertebrate wildlife — mammals, birds, reptiles. Raw physicality, instincts
-• **bug**: Arthropods — butterflies, beetles, mantises. Agile swarms, precision strikes  
-• **aquatic**: Life that swims, dives, sloshes — fish, octopus, sentient puddles. Tides, pressure
-• **flora**: Plants and fungi — blooming or decaying. Growth, spores, vines, seasonal shifts
-• **mineral**: Stones, crystals, metals — earth's depths. Durability, reflective armor, seismic shocks
-• **space**: Stars, moon, cosmic objects — not of this world. Celestial energy, gravitational effects
-• **machina**: Engineered devices — gadgets to machinery. Gears, circuits, drones, power surges
-• **structure**: Buildings, bridges, monuments — architectural titans. Fortification, terrain shaping
-• **culture**: Art, fashion, toys, symbols — creative expressions. Buffs, debuffs, illusion, stories
-• **cuisine**: Dishes, drinks, culinary art — flavors and aromas. Temperature, restorative effects
-
-## EFFECT SYSTEM
-All abilities and moves use these **atomic building blocks**:
-
-### **Effect Types:**
-1. **damage**: Deal damage (weak/normal/strong/extreme) with formulas (standard/recoil/drain/fixed/percentage)
-2. **modifyStats**: Change stats (increase/decrease/greatly_increase/greatly_decrease) for hp/attack/defense/speed/accuracy  
-3. **applyStatus**: Apply status effects (burn/freeze/paralyze/poison/sleep/confuse) with chance percentage
-4. **heal**: Restore HP (small/medium/large/full) or by percentage/fixed amounts
-5. **manipulatePP**: Drain, restore, or disable PP from moves
-6. **fieldEffect**: Persistent battlefield modifications (reflect/lightScreen for defense, spikes for entry damage, mist for stat protection, healingField for regeneration, etc.)
-7. **counter**: Reflect damage
-8. **priority**: Modify move priority (-5 to +5)
-9. **removeStatus**: Cure specific status conditions
-10. **mechanicOverride**: Modify core game mechanics (immunity, type changes, etc.)
-
-### **Targets:**
-- **self**: The move user
-- **opponent**: The target opponent  
-- **all**: All combatants
-- **allies**: Allied creatures (team battles)
-- **field**: Entire battlefield
-
-### **Conditions:**
-- **always**: Effect always applies
-- **onHit**: Only if move hits successfully  
-- **afterUse**: After move execution regardless of hit/miss
-- **onCritical**: Only on critical hits
-- **ifLowHp**: If user's HP < 25%
-- **ifHighHp**: If user's HP > 75%
-
-### **Move Flags:**
-Moves can have flags affecting interactions:
-- **contact**: Makes physical contact (triggers contact abilities)
-- **explosive**: Explosive move (affected by explosion-related abilities)
-- **draining**: Drains HP from target
-- **priority**: Natural priority move (+1 to +5)
-- **sacrifice**: Involves self-sacrifice or major cost
-- **reckless**: High power with drawbacks
-
-## SPECIAL ABILITY TRIGGERS
-Special abilities activate on specific events:
-- **onSwitchIn**: When entering battle
-- **onDamageTaken**: When this monster takes damage
-- **onContactDamage**: When hit by a contact move
-- **endOfTurn**: At the end of each turn
-- **onLowHP**: When HP drops below 25%
-- **onStatusInflicted**: When a status is applied
-
-## BALANCING GUIDELINES
-**Stat Ranges by Rarity:**
-- **common**: 45-80 total stats, individual stats 10-25
-- **uncommon**: 80-120 total stats, individual stats 15-35  
-- **rare**: 120-160 total stats, individual stats 25-45
-- **legendary**: 160-200+ total stats, individual stats 35-50
-
-**Design Philosophy:**
-- **Risk-Reward**: Powerful moves must have meaningful drawbacks
-- **Type Synergy**: Moves should match the monster's type and concept
-- **Strategic Depth**: Abilities should create interesting decision points
-- **No Strictly Better**: Every powerful effect has a cost or condition
-
-The output should be formatted as a JSON instance that conforms to the schema below.
-
-\`\`\`json
-{
-  "type": "object",
-  "properties": {
-    "name": {"type": "string", "description": "Creative name for the monster that hints at the original object"},
-    "description": {"type": "string", "description": "Flavor text describing the monster (2-3 sentences)"},
-    "tier": {"type": "string", "enum": ["low", "medium", "high", "legendary"], "description": "Power tier based on rarity: common=low, uncommon=medium, rare=high, legendary=legendary"},
-    "primaryType": {"type": "string", "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine"], "description": "Primary type based on object characteristics"},
-    "secondaryType": {"type": ["string", "null"], "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine", null], "description": "Optional secondary type for dual-type monsters"},
-    "baseStats": {
-      "type": "object",
-      "properties": {
-        "hp": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Hit points"},
-        "attack": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Attack power"},
-        "defense": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Defensive capability"},
-        "speed": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Speed and agility"}
-      },
-      "required": ["hp", "attack", "defense", "speed"],
-      "additionalProperties": false
-    },
-    "nature": {
-      "type": "string", 
-      "enum": ["hardy", "docile", "serious", "bashful", "quirky", "lonely", "brave", "adamant", "naughty", "bold", "relaxed", "impish", "lax", "timid", "hasty", "jolly", "naive", "modest", "mild", "quiet", "gentle", "sassy", "careful", "calm", "reckless"],
-      "description": "Personality trait affecting behavior and battle style"
-    },
-    "specialAbility": {
-      "type": "object",
-      "properties": {
-        "name": {"type": "string", "description": "Name of the special ability"},
-        "triggers": {
-          "type": "array",
-          "items": {"$ref": "#/definitions/Trigger"},
-          "minItems": 1,
-          "maxItems": 1,
-          "description": "Single trigger effect for the special ability"
-        }
-      },
-      "required": ["name"],
-      "additionalProperties": false
-    },
-    "movepool": {
-      "type": "array",
-      "items": {"$ref": "#/definitions/Move"},
-      "minItems": 4,
-      "maxItems": 4,
-      "description": "Exactly 4 battle moves"
-    }
-  },
-  "required": ["name", "description", "tier", "primaryType", "baseStats", "nature", "specialAbility", "movepool"],
-  "additionalProperties": false,
-  "definitions": {
-    "Effect": {
-      "type": "object",
-      "properties": {
-        "type": {"type": "string", "enum": ["damage", "modifyStats", "applyStatus", "heal", "manipulatePP", "fieldEffect", "counter", "priority", "removeStatus", "mechanicOverride"]},
-        "target": {"type": "string", "enum": ["self", "opponent", "allies", "all", "attacker", "field", "playerSide", "opponentSide"]},
-        "condition": {"type": "string", "enum": ["always", "onHit", "afterUse", "onCritical", "ifLowHp", "ifHighHp", "thisTurn", "nextTurn", "restOfBattle"]}
-      },
-      "required": ["type"],
-      "allOf": [
-        {"if": {"properties": {"type": {"const": "damage"}}}, "then": {"properties": {"amount": {"enum": ["weak", "normal", "strong", "extreme"]}, "formula": {"enum": ["standard", "recoil", "drain", "fixed", "percentage"]}, "value": {"type": "number"}}}},
-        {"if": {"properties": {"type": {"const": "modifyStats"}}}, "then": {"properties": {"stats": {"type": "object", "properties": {"hp": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "attack": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "defense": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "speed": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "accuracy": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}}}}}},
-        {"if": {"properties": {"type": {"const": "applyStatus"}}}, "then": {"properties": {"status": {"enum": ["burn", "freeze", "paralyze", "poison", "sleep", "confuse"]}, "chance": {"type": "number", "minimum": 1, "maximum": 100}}}},
-        {"if": {"properties": {"type": {"const": "heal"}}}, "then": {"properties": {"amount": {"enum": ["small", "medium", "large", "full"]}, "formula": {"enum": ["percentage", "fixed"]}, "value": {"type": "number"}}}},
-        {"if": {"properties": {"type": {"const": "fieldEffect"}}}, "then": {"properties": {"effect": {"enum": ["reflect", "lightScreen", "spikes", "healingMist", "toxicSpikes"]}, "stackable": {"type": "boolean"}}}},
-        {"if": {"properties": {"type": {"const": "manipulatePP"}}}, "then": {"properties": {"action": {"enum": ["drain", "restore", "disable"]}, "amount": {"enum": ["small", "medium", "large"]}}}},
-        {"if": {"properties": {"type": {"const": "counter"}}}, "then": {"properties": {"strength": {"enum": ["weak", "normal", "strong"]}}}},
-        {"if": {"properties": {"type": {"const": "priority"}}}, "then": {"properties": {"value": {"type": "integer", "minimum": -5, "maximum": 5}}}},
-        {"if": {"properties": {"type": {"const": "removeStatus"}}}, "then": {"properties": {"status": {"enum": ["burn", "freeze", "paralyze", "poison", "sleep", "confuse"]}}}},
-        {"if": {"properties": {"type": {"const": "mechanicOverride"}}}, "then": {"properties": {"mechanic": {"enum": ["criticalHits", "statusImmunity", "damageReflection", "damageAbsorption", "damageCalculation", "damageMultiplier", "healingInversion", "healingBlocked", "priorityOverride", "accuracyBypass", "typeImmunity", "typeChange", "contactDamage", "drainInversion", "weatherImmunity", "flagImmunity", "flagWeakness", "flagResistance", "statModification", "targetRedirection", "extraTurn"]}, "value": {}}}}
-      ]
-    },
-    "Trigger": {
-      "type": "object",
-      "properties": {
-        "event": {"type": "string", "enum": ["onSwitchIn", "onDamageTaken", "onContactDamage", "endOfTurn", "onLowHP", "onStatusInflicted", "beforeMoveUse", "afterMoveUse"]},
-        "condition": {"type": "string", "enum": ["always", "ifLowHp", "ifHighHp", "ifStatus:burn", "ifStatus:freeze", "ifStatus:paralyze", "ifStatus:poison", "ifStatus:sleep", "ifStatus:confuse"]},
-        "effects": {"type": "array", "items": {"$ref": "#/definitions/Effect"}, "minItems": 1}
-      },
-      "required": ["event", "effects"]
-    },
-    "Move": {
-      "type": "object",
-      "properties": {
-        "name": {"type": "string", "description": "Name of the move"},
-        "description": {"type": "string", "description": "Description of what the move does"},
-        "type": {"type": "string", "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine", "normal"], "description": "Move type for STAB and effectiveness"},
-        "power": {"type": "integer", "minimum": 0, "maximum": 250, "description": "Base power (0 for status moves)"},
-        "accuracy": {"type": "integer", "minimum": 30, "maximum": 100, "description": "Hit chance percentage"},
-        "pp": {"type": "integer", "minimum": 1, "maximum": 40, "description": "Power points (uses per battle)"},
-        "priority": {"type": "integer", "minimum": -5, "maximum": 5, "description": "Priority bracket"},
-        "flags": {"type": "array", "items": {"enum": ["contact", "explosive", "draining", "priority", "sacrifice", "reckless", "bite", "punch", "sound", "ground"]}, "description": "Move characteristics"},
-        "effects": {"type": "array", "items": {"$ref": "#/definitions/Effect"}, "minItems": 1, "description": "What the move does"}
-      },
-      "required": ["name", "type", "power", "accuracy", "pp", "priority", "flags", "effects"],
-      "additionalProperties": false
+    if (!workflowState.picletConcept) {
+      throw new Error('No concept available for stats extraction');
     }
-  }
-}
-\`\`\`
-
-**STAT GUIDELINES:**
-Base the tier and stats on the object rarity:
-- **common → low tier**: hp/attack/defense/speed should be 10-25 (total ~40-80)
-- **uncommon → medium tier**: hp/attack/defense/speed should be 15-35 (total ~80-120)
-- **rare → high tier**: hp/attack/defense/speed should be 25-45 (total ~120-160)
-- **legendary → legendary tier**: hp/attack/defense/speed should be 35-50 (total ~160-200)
-
-**CREATIVITY & DIVERSITY REQUIREMENTS:**
-🎲 **CRITICAL**: Make this monster unique! Avoid generic patterns and create something distinctive.
-
-**SPECIAL ABILITY CREATIVITY:**
-- Draw inspiration from the SPECIFIC object description and monster concept
-- Avoid overused triggers like "onSwitchIn with healingMist" 
-- Use diverse triggers: onContactDamage, onLowHP, onStatusInflicted, onCriticalHit, etc.
-- Create unique effects that match the monster's nature and appearance
-
-**MOVEPOOL DIVERSITY REQUIREMENTS:**
-- Each of the 4 moves MUST use different primary effect types
-- Vary the mechanics: one utility, one status, one damage, one defensive/field effect
-- Use different status effects if applying status (avoid repeating burn/sleep/paralyze)
-- Vary power/accuracy/PP patterns - don't use template values
-- Reference specific visual elements from the monster description in move names
-
-**FORBIDDEN REPETITIVE PATTERNS:**
-❌ Do NOT use these overused combinations:
-- "healingMist" field effect on switch-in (find alternatives!)
-- Defense boost + small percentage heal combo moves
-- High power + self-recoil damage as the only "ultimate" move pattern
-- All moves having same status effect (sleep/paralyze)
-- Generic move names like "Basic Attack" or "Status Move"
-
-**ORIGINALITY GUIDELINES:**
-- Connect abilities to the original object's unique properties
-- Use unconventional effect combinations and mechanics
-- Experiment with mechanicOverride, priority manipulation, counter effects
-- Create moves that tell a story about how this creature fights
-
-Write your response within \`\`\`json\`\`\``;
-    
-    console.log('Generating monster stats');
     
     try {
-      const responseText = await generateText(statsPrompt);
+      // Extract monster name
+      const monsterNameMatch = workflowState.picletConcept.match(/# Monster Name\s*\n([\s\S]*?)(?=^#|$)/m);
+      let monsterName = monsterNameMatch ? monsterNameMatch[1].trim() : 'Unknown Monster';
       
-      if (!responseText || responseText.trim() === '') {
-        throw new Error('Failed to generate monster stats');
+      // Clean and truncate name
+      if (monsterName.includes(',')) {
+        monsterName = monsterName.split(',')[0].trim();
       }
-      
-      console.log('Stats output:', responseText);
-      let jsonString = responseText;
-      
-      // Extract JSON from the response (remove markdown if present)
-      let cleanJson = jsonString;
-      if (jsonString.includes('```')) {
-        const matches = jsonString.match(/```(?:json)?\s*([\s\S]*?)```/);
-        if (matches) {
-          cleanJson = matches[1];
-        } else {
-          // If no closing ```, just remove the opening ```json
-          cleanJson = jsonString.replace(/^```(?:json)?\s*/, '').replace(/```\s*$/, '');
-        }
+      if (monsterName.length > 12) {
+        monsterName = monsterName.substring(0, 12);
       }
+      monsterName = monsterName.replace(/\*/g, ''); // Remove markdown asterisks
+      
+      // Extract rarity and convert to tier
+      const rarityMatch = workflowState.picletConcept.match(/# Object Rarity\s*\n([\s\S]*?)(?=^#)/m);
+      const objectRarity = rarityMatch ? rarityMatch[1].trim().toLowerCase() : 'common';
+      
+      let tier: 'low' | 'medium' | 'high' | 'legendary' = 'medium';
+      if (objectRarity.includes('common')) tier = 'low';
+      else if (objectRarity.includes('uncommon')) tier = 'medium';
+      else if (objectRarity.includes('rare')) tier = 'high';
+      else if (objectRarity.includes('legendary') || objectRarity.includes('mythical')) tier = 'legendary';
+      
+      // Extract primary type
+      const primaryTypeMatch = workflowState.picletConcept.match(/# Primary Type\s*\n([\s\S]*?)(?=^#|$)/m);
+      let primaryType: any = primaryTypeMatch ? primaryTypeMatch[1].trim().toLowerCase() : 'beast';
+      
+      // Extract description
+      const descriptionMatch = workflowState.picletConcept.match(/# Monster Description\s*\n([\s\S]*?)(?=^#|$)/m);
+      let description = descriptionMatch ? descriptionMatch[1].trim() : workflowState.imageCaption || 'A mysterious creature';
+      
+      // Create simplified stats
+      const stats: PicletStats = {
+        name: monsterName,
+        description: description,
+        tier: tier,
+        primaryType: primaryType
+      };
+      
+      workflowState.picletStats = stats;
+      console.log('Simple stats extracted:', stats);
       
-      try {
-        // Extract JSON by properly balancing braces instead of using regex
-        const startIndex = cleanJson.indexOf('{');
-        if (startIndex !== -1) {
-          let braceCount = 0;
-          let endIndex = -1;
-          
-          // Find the matching closing brace by counting
-          for (let i = startIndex; i < cleanJson.length; i++) {
-            if (cleanJson[i] === '{') braceCount++;
-            if (cleanJson[i] === '}') {
-              braceCount--;
-              if (braceCount === 0) {
-                endIndex = i;
-                break;
-              }
-            }
-          }
-          
-          if (endIndex !== -1) {
-            cleanJson = cleanJson.substring(startIndex, endIndex + 1);
-            console.log('Balanced JSON extracted, length:', cleanJson.length);
-          } else {
-            throw new Error('JSON appears to be truncated - unable to balance braces');
-          }
-        } else {
-          throw new Error('No JSON object found in response');
-        }
-        
-        console.log('Final JSON to parse (length: ' + cleanJson.length + '):', cleanJson.substring(0, 500) + '...');
-        
-        // Fix invalid priority values like "priority": +1 to "priority": 1
-        cleanJson = cleanJson.replace(/"priority":\s*\+(\d+)/g, '"priority": $1');
-        
-        // Fix unescaped newlines in string values
-        cleanJson = cleanJson.replace(/"([^"\\]*)(?:\\.|[^"\\])*"/g, (match) => {
-          // Only process if this looks like a string value (not a property name)
-          if (match.includes('\n')) {
-            return match.replace(/\n/g, '\\n').replace(/\r/g, '\\r');
-          }
-          return match;
-        });
-        
-        const parsedStats = JSON.parse(cleanJson.trim());
-        
-        // Validate the battle-ready monster structure
-        console.log('Parsed battle monster:', parsedStats);
-        
-        // Ensure required fields exist
-        if (!parsedStats.name || !parsedStats.baseStats || !parsedStats.specialAbility || !parsedStats.movepool) {
-          throw new Error('Generated monster is missing required battle system fields');
-        }
-        
-        // Validate movepool has exactly 4 moves
-        if (!Array.isArray(parsedStats.movepool) || parsedStats.movepool.length !== 4) {
-          throw new Error('Monster movepool must contain exactly 4 moves');
-        }
-        
-        // Ensure all moves have required effect arrays
-        for (const move of parsedStats.movepool) {
-          if (!move.effects || !Array.isArray(move.effects) || move.effects.length === 0) {
-            throw new Error(`Move "${move.name}" is missing effects array`);
-          }
-        }
-        
-        // Use tier from the JSON response
-        tier = parsedStats.tier || 'medium';
-        
-        // Clean asterisks from JSON-parsed name (qwen3 often adds them for markdown bold)
-        if (parsedStats.name) {
-          parsedStats.name = parsedStats.name.replace(/\*/g, '');
-        }
-        
-        // Clean asterisks from special ability name
-        if (parsedStats.specialAbility?.name) {
-          parsedStats.specialAbility.name = parsedStats.specialAbility.name.replace(/\*/g, '');
-        }
-        
-        // Clean asterisks from move names
-        if (parsedStats.movepool) {
-          for (const move of parsedStats.movepool) {
-            if (move.name) {
-              move.name = move.name.replace(/\*/g, '');
-            }
-          }
-        }
-        
-        // Ensure the name from structured concept is used if available
-        if (monsterName && monsterName !== 'Unknown Monster') {
-          // Remove asterisk characters used for markdown bold formatting
-          parsedStats.name = monsterName.replace(/\*/g, '');
-        }
-        
-        // Ensure baseStats are numbers within reasonable ranges
-        if (parsedStats.baseStats) {
-          const statFields = ['hp', 'attack', 'defense', 'speed'];
-          for (const field of statFields) {
-            if (parsedStats.baseStats[field] !== undefined) {
-              parsedStats.baseStats[field] = Math.max(10, Math.min(50, parseInt(parsedStats.baseStats[field])));
-            }
-          }
-        }
-        
-        const stats: PicletStats = parsedStats;
-        workflowState.picletStats = stats;
-        console.log('Monster stats generated:', stats);
-        console.log('Monster stats JSON:', JSON.stringify(stats, null, 2));
-      } catch (parseError) {
-        console.error('Failed to parse JSON:', parseError, 'Raw output:', cleanJson);
-        throw new Error('Failed to parse monster stats JSON');
-      }
     } catch (error) {
+      console.error('Failed to extract simple stats:', error);
       handleAPIError(error);
     }
   }
   
-  async function autoSavePiclet() {
+  async function autoSavePicletAsCaught() {
     if (!workflowState.picletImage || !workflowState.imageCaption || !workflowState.picletConcept || !workflowState.imagePrompt || !workflowState.picletStats) {
       console.error('Cannot auto-save: missing required data');
       return;
@@ -933,10 +590,15 @@ Write your response within \`\`\`json\`\`\``;
       console.log('- imagePrompt type:', typeof picletData.imagePrompt);
       console.log('- stats:', cleanStats);
       
-      // Convert to PicletInstance format and save
+      // Convert to PicletInstance format and save as caught
       const picletInstance = await generatedDataToPicletInstance(picletData);
+      
+      // Override the caught status to auto-capture scanned Piclets
+      picletInstance.caught = true;
+      picletInstance.caughtAt = new Date();
+      
       const picletId = await savePicletInstance(picletInstance);
-      console.log('Piclet auto-saved as uncaught with ID:', picletId);
+      console.log('Piclet auto-saved as caught with ID:', picletId);
       
       // If in trainer mode, notify completion
       if (isTrainerMode && onTrainerImageCompleted && trainerImagePaths[currentImageIndex]) {

src/lib/components/Piclets/NewlyCaughtPicletDetail.svelte

@@ -2,11 +2,6 @@
   import { onMount } from 'svelte';
   import type { PicletInstance } from '$lib/db/schema';
   import { TYPE_DATA } from '$lib/types/picletTypes';
-  import AbilityDisplay from './AbilityDisplay.svelte';
-  import MoveDisplay from './MoveDisplay.svelte';
-  import { picletInstanceToBattleDefinition } from '$lib/utils/battleConversion';
-  import { recalculatePicletStats, getXpProgress, getXpTowardsNextLevel } from '$lib/services/levelingService';
-  import { isSpecialAbilityUnlocked } from '$lib/services/unlockLevels';
   
   interface Props {
     instance: PicletInstance;

src/lib/components/Piclets/PicletCard.svelte

@@ -1,7 +1,6 @@
 <script lang="ts">
   import type { PicletInstance } from '$lib/db/schema';
   import { TYPE_DATA } from '$lib/types/picletTypes';
-  import { picletInstanceToBattleDefinition } from '$lib/utils/battleConversion';
   
   interface Props {
     piclet: PicletInstance;
@@ -11,19 +10,8 @@
   
   let { piclet, size = 100, onClick }: Props = $props();
   
-  const hpPercentage = $derived(piclet.currentHp / piclet.maxHp);
-  const hpColor = $derived(
-    hpPercentage > 0.5 ? '#34c759' : 
-    hpPercentage > 0.25 ? '#ffcc00' : 
-    '#ff3b30'
-  );
-  
-  const typeColor = $derived(TYPE_DATA[piclet.primaryType].color);
+  const typeColor = $derived(TYPE_DATA[piclet.primaryType]?.color || '#6c757d');
   const softTypeColor = $derived(`${typeColor}20`); // Add 20% opacity for soft background
-  
-  // Get battle definition for enhanced ability info
-  const battleDefinition = $derived(picletInstanceToBattleDefinition(piclet));
-  const ability = $derived(battleDefinition.specialAbility);
 </script>
 
 <button 
@@ -35,25 +23,19 @@
   <div class="image-container">
     <img 
       src={piclet.imageData || piclet.imageUrl} 
-      alt={piclet.nickname || 'Piclet'}
+      alt={piclet.typeId || 'Piclet'}
       class="piclet-image"
       style="width: {size * 0.8}px; height: {size * 0.8}px;"
     />
-    <div class="level-badge">
-      Lv.{piclet.level}
+    <div class="tier-badge tier-{piclet.tier}">
+      {piclet.tier}
     </div>
   </div>
   
   <div class="details-section">
-    <p class="nickname">{piclet.nickname || 'Unknown'}</p>
-    <div class="hp-section">
-      <span class="hp-text">HP: {piclet.currentHp}/{piclet.maxHp}</span>
-      <div class="hp-bar">
-        <div 
-          class="hp-fill" 
-          style="width: {hpPercentage * 100}%; background-color: {hpColor};"
-        ></div>
-      </div>
+    <p class="nickname">{piclet.typeId}</p>
+    <div class="types-section">
+      <span class="type primary">{piclet.primaryType}</span>
     </div>
   </div>
 </button>
@@ -92,18 +74,22 @@
     object-fit: contain;
   }
   
-  .level-badge {
+  .tier-badge {
     position: absolute;
     top: 4px;
     right: 4px;
-    background: rgba(255, 255, 255, 0.9);
     padding: 2px 6px;
     border-radius: 8px;
-    font-size: 10px;
+    font-size: 9px;
     font-weight: bold;
-    color: black;
+    text-transform: uppercase;
   }
   
+  .tier-low { background: #6c757d; color: white; }
+  .tier-medium { background: #28a745; color: white; }
+  .tier-high { background: #fd7e14; color: white; }
+  .tier-legendary { background: #dc3545; color: white; }
+  
   .details-section {
     height: 50px;
     padding: 6px 8px;
@@ -116,8 +102,8 @@
   }
   
   .nickname {
-    margin: 0 0 2px 0;
-    font-size: 10px;
+    margin: 0 0 4px 0;
+    font-size: 11px;
     font-weight: 600;
     text-align: center;
     overflow: hidden;
@@ -126,29 +112,27 @@
     color: #333;
   }
   
-  .hp-section {
+  .types-section {
     display: flex;
-    flex-direction: column;
-    gap: 1px;
+    gap: 4px;
+    justify-content: center;
   }
   
-  .hp-text {
+  .type {
     font-size: 8px;
+    padding: 1px 4px;
+    border-radius: 4px;
     font-weight: 500;
-    text-align: center;
-    color: #666;
+    text-transform: uppercase;
   }
   
-  .hp-bar {
-    height: 3px;
-    background: #f0f0f0;
-    border-radius: 1.5px;
-    overflow: hidden;
+  .type.primary {
+    background: var(--type-color);
+    color: white;
   }
   
-  .hp-fill {
-    height: 100%;
-    border-radius: 1.5px;
-    transition: width 0.3s ease;
+  .type.secondary {
+    background: rgba(0, 0, 0, 0.1);
+    color: #666;
   }
 </style>

src/lib/components/Piclets/PicletDetail.svelte

@@ -1,14 +1,8 @@
 <script lang="ts">
-  import { onMount } from 'svelte';
   import type { PicletInstance } from '$lib/db/schema';
   import { deletePicletInstance } from '$lib/db/piclets';
   import { uiStore } from '$lib/stores/ui';
   import { TYPE_DATA } from '$lib/types/picletTypes';
-  import AbilityDisplay from './AbilityDisplay.svelte';
-  import MoveDisplay from './MoveDisplay.svelte';
-  import { picletInstanceToBattleDefinition } from '$lib/utils/battleConversion';
-  import { recalculatePicletStats, getXpProgress, getXpTowardsNextLevel } from '$lib/services/levelingService';
-  import { isSpecialAbilityUnlocked } from '$lib/services/unlockLevels';
   
   interface Props {
     instance: PicletInstance;
@@ -17,792 +11,261 @@
   }
   
   let { instance, onClose, onDeleted }: Props = $props();
-  let selectedTab = $state<'about' | 'abilities'>('about');
   
-  // Ensure stats are up-to-date with current level and nature
-  const updatedInstance = $derived(recalculatePicletStats(instance));
-  
-  // Convert to battle definition to get enhanced ability data
-  const battleDefinition = $derived(picletInstanceToBattleDefinition(updatedInstance));
-  
-  // XP and level calculations
-  const xpProgress = $derived(getXpProgress(updatedInstance.xp, updatedInstance.level, updatedInstance.tier));
-  const xpTowardsNext = $derived(getXpTowardsNextLevel(updatedInstance.xp, updatedInstance.level, updatedInstance.tier));
-  
-  // Type-based styling
-  const typeData = $derived(TYPE_DATA[instance.primaryType]);
-  const typeColor = $derived(typeData.color);
-  const typeLogoPath = $derived(`/classes/${instance.primaryType}.png`);
-  
-  onMount(() => {
-    uiStore.openDetailPage();
-    return () => {
-      uiStore.closeDetailPage();
-    };
-  });
+  const typeColor = $derived(TYPE_DATA[instance.primaryType]?.color || '#007bff');
   
   async function handleDelete() {
-    if (!instance.id) return;
-    
-    const confirmed = confirm(`Are you sure you want to release ${instance.nickname || instance.typeId}? This action cannot be undone.`);
-    if (!confirmed) return;
-    
-    try {
-      await deletePicletInstance(instance.id);
-      onDeleted?.();
-      onClose();
-    } catch (err) {
-      console.error('Failed to delete piclet:', err);
-    }
-  }
-  
-  function getStatPercentage(value: number, max: number = 255): number {
-    return Math.round((value / max) * 100);
-  }
-  
-  function getHpColor(current: number, max: number): string {
-    const ratio = current / max;
-    if (ratio < 0.2) return '#ff3b30';
-    if (ratio < 0.5) return '#ff9500';
-    return '#34c759';
-  }
-  
-  
-  function handleDownloadJSON() {
-    try {
-      // Create comprehensive export data
-      const exportData = {
-        exportVersion: "1.0",
-        exportedAt: new Date().toISOString(),
-        piclet: {
-          name: updatedInstance.nickname || updatedInstance.typeId,
-          typeId: updatedInstance.typeId,
-          imageData: updatedInstance.imageData,
-          stats: {
-            // Core identification
-            id: updatedInstance.id,
-            typeId: updatedInstance.typeId,
-            nickname: updatedInstance.nickname,
-            
-            // Type information
-            primaryType: updatedInstance.primaryType,
-            secondaryType: updatedInstance.secondaryType,
-            
-            // Current stats
-            currentHp: updatedInstance.currentHp,
-            maxHp: updatedInstance.maxHp,
-            level: updatedInstance.level,
-            xp: updatedInstance.xp,
-            attack: updatedInstance.attack,
-            defense: updatedInstance.defense,
-            fieldAttack: updatedInstance.fieldAttack,
-            fieldDefense: updatedInstance.fieldDefense,
-            speed: updatedInstance.speed,
-            
-            // Base stats
-            baseHp: updatedInstance.baseHp,
-            baseAttack: updatedInstance.baseAttack,
-            baseDefense: updatedInstance.baseDefense,
-            baseFieldAttack: updatedInstance.baseFieldAttack,
-            baseFieldDefense: updatedInstance.baseFieldDefense,
-            baseSpeed: updatedInstance.baseSpeed,
-            
-            // Additional properties
-            nature: updatedInstance.nature,
-            tier: updatedInstance.tier,
-            bst: updatedInstance.bst,
-            caught: updatedInstance.caught,
-            caughtAt: updatedInstance.caughtAt,
-            isInRoster: updatedInstance.isInRoster,
-            rosterPosition: updatedInstance.rosterPosition
-          },
-          battleData: {
-            moves: updatedInstance.moves,
-            specialAbility: updatedInstance.specialAbility,
-            specialAbilityUnlockLevel: updatedInstance.specialAbilityUnlockLevel,
-            types: [updatedInstance.primaryType, updatedInstance.secondaryType].filter(Boolean)
-          },
-          generationData: {
-            imageUrl: updatedInstance.imageUrl,
-            imageCaption: updatedInstance.imageCaption || null,
-            concept: updatedInstance.concept || null,
-            imagePrompt: updatedInstance.imagePrompt || null
-          },
-          metadata: {
-            level: updatedInstance.level,
-            tier: updatedInstance.tier,
-            createdAt: updatedInstance.caughtAt || new Date().toISOString(),
-            exportSource: "Pictuary Game"
-          }
-        }
-      };
-      
-      // Create and download JSON file
-      const jsonString = JSON.stringify(exportData, null, 2);
-      const blob = new Blob([jsonString], { type: 'application/json' });
-      const url = URL.createObjectURL(blob);
-      
-      // Create temporary download link
-      const link = document.createElement('a');
-      link.href = url;
-      link.download = `piclet-${(updatedInstance.nickname || updatedInstance.typeId).replace(/[^a-zA-Z0-9-_]/g, '_')}-${Date.now()}.json`;
-      
-      // Trigger download
-      document.body.appendChild(link);
-      link.click();
-      document.body.removeChild(link);
-      
-      // Clean up the blob URL
-      URL.revokeObjectURL(url);
-      
-      console.log('Piclet JSON exported successfully');
-    } catch (error) {
-      console.error('Failed to export Piclet JSON:', error);
-      alert('Failed to export Piclet data. Please try again.');
+    if (confirm(`Are you sure you want to delete ${instance.typeId}?`)) {
+      try {
+        await deletePicletInstance(instance.id!);
+        onDeleted?.();
+        onClose();
+      } catch (error) {
+        console.error('Failed to delete piclet:', error);
+        alert('Failed to delete piclet');
+      }
     }
   }
 </script>
 
-<div class="detail-page">
-    <div class="content-scroll">
-      <!-- Header Card -->
-      <div class="header-card">
-        <div class="card-background" style="--type-color: {typeColor}; --type-logo: url('{typeLogoPath}')">
-          <!-- Faded Logo Background -->
-          <div class="logo-background"></div>
-          
-          <!-- Card Header -->
-          <div class="card-header">
-            <button 
-              class="back-btn-card" 
-              onclick={onClose} 
-              aria-label="Go back"
-            >
-              <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                <path d="M19 12H5m0 0l7 7m-7-7l7-7"></path>
-              </svg>
-            </button>
-            <h1 class="card-title">{updatedInstance.nickname || updatedInstance.typeId}</h1>
-            <button 
-              class="download-button" 
-              onclick={handleDownloadJSON} 
-              aria-label="Download JSON"
-            >
-              <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path>
-                <polyline points="7,10 12,15 17,10"></polyline>
-                <line x1="12" y1="15" x2="12" y2="3"></line>
-              </svg>
-            </button>
-          </div>
-
-          <!-- Large Image Section -->
-          <div class="large-image-section">
-            <div class="large-image-container">
-              <img 
-                src={updatedInstance.imageData || updatedInstance.imageUrl} 
-                alt={updatedInstance.nickname || updatedInstance.typeId}
-                class="large-piclet-image"
-              />
-            </div>
-          </div>
-        </div>
+<div class="piclet-detail-overlay" onclick={onClose}>
+  <div class="piclet-detail" onclick={(e) => e.stopPropagation()}>
+    <!-- Header -->
+    <div class="header" style="--type-color: {typeColor}">
+      <button class="close-button" onclick={onClose}>×</button>
+      <div class="tier-badge tier-{instance.tier}">{instance.tier}</div>
+    </div>
+    
+    <!-- Main Content -->
+    <div class="content">
+      <!-- Image Section -->
+      <div class="image-section">
+        <img 
+          src={instance.imageData || instance.imageUrl} 
+          alt={instance.typeId}
+          class="piclet-image"
+        />
       </div>
       
-      <!-- Level and Status Progress -->
-      <div class="level-xp-section">
-        <div class="level-info">
-          <span class="level-label">Level {updatedInstance.level}</span>
-          {#if updatedInstance.level < 100}
-            <span class="xp-label">{xpTowardsNext.current}/{xpTowardsNext.needed} to next level</span>
-          {:else}
-            <span class="xp-label">MAX LEVEL</span>
-          {/if}
+      <!-- Info Section -->
+      <div class="info-section">
+        <h2 class="name">{instance.typeId}</h2>
+        
+        <div class="types">
+          <span class="type primary" style="background-color: {typeColor}">
+            {instance.primaryType}
+          </span>
         </div>
         
-        <!-- HP Section -->
-        <div class="stat-row">
-          <div class="stat-label">HP</div>
-          <div class="hp-bar">
-            <div 
-              class="hp-fill" 
-              style="width: {(updatedInstance.currentHp / updatedInstance.maxHp) * 100}%; background-color: {getHpColor(updatedInstance.currentHp, updatedInstance.maxHp)}"
-            ></div>
-          </div>
-          <div class="stat-value">{updatedInstance.currentHp}/{updatedInstance.maxHp}</div>
+        <div class="description">
+          <h3>Description</h3>
+          <p>{instance.description}</p>
         </div>
         
-        <!-- XP Section -->
-        {#if updatedInstance.level < 100}
-          <div class="stat-row">
-            <div class="stat-label">XP</div>
-            <div class="xp-bar">
-              <div 
-                class="xp-fill" 
-                style="width: {xpTowardsNext.percentage}%"
-              ></div>
-            </div>
-            <div class="stat-value">{xpTowardsNext.current}/{xpTowardsNext.needed}</div>
+        <div class="metadata">
+          <div class="meta-item">
+            <strong>Caught:</strong> 
+            {instance.caught ? 'Yes' : 'No'}
           </div>
-        {:else}
-          <div class="stat-row">
-            <div class="stat-label">XP</div>
-            <div class="max-level-indicator">MAX LEVEL</div>
-          </div>
-        {/if}
-      </div>
-      
-      <!-- Tab Bar -->
-      <div class="tab-bar" style="--type-color: {typeColor}">
-        <button 
-          class="tab-button" 
-          class:active={selectedTab === 'about'}
-          onclick={() => selectedTab = 'about'}
-        >
-          About
-        </button>
-        <button 
-          class="tab-button" 
-          class:active={selectedTab === 'abilities'}
-          onclick={() => selectedTab = 'abilities'}
-        >
-          Abilities
-        </button>
-      </div>
-      
-      <!-- Tab Content -->
-      <div class="tab-content">
-        {#if selectedTab === 'about'}
-          <div class="content-card">
-            <p class="description">{instance.description}</p>
-            
-            <div class="divider"></div>
-            
-            <h3 class="section-heading">Stats</h3>
-            <div class="stats-list">
-              <div class="stat-row">
-                <span>Attack</span>
-                <span class="stat-value">{updatedInstance.attack}</span>
-              </div>
-              <div class="stat-row">
-                <span>Defense</span>
-                <span class="stat-value">{updatedInstance.defense}</span>
-              </div>
-              <div class="stat-row">
-                <span>Field Attack</span>
-                <span class="stat-value">{updatedInstance.fieldAttack}</span>
-              </div>
-              <div class="stat-row">
-                <span>Field Defense</span>
-                <span class="stat-value">{updatedInstance.fieldDefense}</span>
-              </div>
-              <div class="stat-row">
-                <span>Speed</span>
-                <span class="stat-value">{updatedInstance.speed}</span>
-              </div>
+          {#if instance.caughtAt}
+            <div class="meta-item">
+              <strong>Caught on:</strong> 
+              {new Date(instance.caughtAt).toLocaleDateString()}
             </div>
-            
-            <div class="divider"></div>
-            
-            <div class="stat-summary">
-              <div class="summary-item">
-                <span class="summary-label">BST</span>
-                <span class="summary-value">{updatedInstance.bst}</span>
-              </div>
-              <div class="summary-item">
-                <span class="summary-label">Tier</span>
-                <span class="summary-value">{updatedInstance.tier.toUpperCase()}</span>
-              </div>
-            </div>
-          </div>
-        {:else if selectedTab === 'abilities'}
-          <div class="content-card">
-            <h3 class="section-heading">Special Ability</h3>
-            {#if isSpecialAbilityUnlocked(updatedInstance.specialAbilityUnlockLevel, updatedInstance.level)}
-              <AbilityDisplay 
-                ability={updatedInstance.specialAbility}
-                expanded={true}
-              />
-            {:else}
-              <div class="locked-ability">
-                <div class="lock-header">
-                  <span class="lock-icon">🔒</span>
-                  <span class="lock-text">Unlocks at Level {updatedInstance.specialAbilityUnlockLevel}</span>
-                </div>
-                <div class="locked-content">
-                  <h4>{updatedInstance.specialAbility.name}</h4>
-                  <p>This special ability will be unlocked when {updatedInstance.nickname} reaches level {updatedInstance.specialAbilityUnlockLevel}.</p>
-                </div>
-              </div>
-            {/if}
-            
-            <div class="divider"></div>
-            
-            <h3 class="section-heading">Moves</h3>
-            <div class="moves-list">
-              {#each updatedInstance.moves as move, index}
-                {#if move.unlockLevel <= updatedInstance.level}
-                  <MoveDisplay 
-                    {move}
-                    expanded={true}
-                  />
-                {:else}
-                  <div class="locked-move">
-                    <div class="lock-header">
-                      <span class="lock-icon">🔒</span>
-                      <span class="lock-text">Unlocks at Level {move.unlockLevel}</span>
-                    </div>
-                    <div class="locked-content">
-                      <h4>{move.name}</h4>
-                      <p>This move will be unlocked when {updatedInstance.nickname} reaches level {move.unlockLevel}.</p>
-                    </div>
-                  </div>
-                {/if}
-              {/each}
+          {/if}
+          {#if instance.isInRoster}
+            <div class="meta-item">
+              <strong>Status:</strong> 
+              <span class="roster-badge">In Battle Roster</span>
             </div>
-          </div>
-        {/if}
-      </div>
-      
-      <!-- Actions -->
-      <div class="bottom-actions">
-        <button class="btn btn-danger" onclick={handleDelete}>Release Piclet</button>
+          {/if}
+        </div>
       </div>
     </div>
+    
+    <!-- Actions -->
+    <div class="actions">
+      <button class="delete-button" onclick={handleDelete}>
+        🗑️ Delete
+      </button>
+    </div>
+  </div>
 </div>
 
 <style>
-  .detail-page {
+  .piclet-detail-overlay {
     position: fixed;
     top: 0;
     left: 0;
     right: 0;
     bottom: 0;
-    background: #f2f2f7;
-    z-index: 1000;
+    background: rgba(0, 0, 0, 0.5);
     display: flex;
-    flex-direction: column;
-  }
-  
-  /* Content Scroll */
-  .content-scroll {
-    flex: 1;
-    overflow-y: auto;
-    -webkit-overflow-scrolling: touch;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+    padding: 1rem;
   }
   
-  /* Header Card */
-  .header-card {
-    margin-bottom: 16px;
+  .piclet-detail {
+    background: white;
+    border-radius: 16px;
+    width: 100%;
+    max-width: 400px;
+    max-height: 80vh;
     overflow: hidden;
-    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
-    position: relative;
+    display: flex;
+    flex-direction: column;
   }
   
-  .card-background {
-    background: linear-gradient(135deg, var(--type-color, #4CAF50) 0%, color-mix(in srgb, var(--type-color, #4CAF50) 80%, white) 100%);
-    padding: 24px;
-    padding-top: calc(24px + env(safe-area-inset-top, 0));
+  .header {
+    background: var(--type-color, #007bff);
+    color: white;
+    padding: 1rem;
     position: relative;
-    overflow: hidden;
-  }
-  
-  .logo-background {
-    position: absolute;
-    bottom: 5px;
-    right: 5px;
-    width: 120px;
-    height: 120px;
-    background-image: var(--type-logo);
-    background-size: contain;
-    background-repeat: no-repeat;
-    background-position: center;
-    opacity: 0.15;
-    pointer-events: none;
-    z-index: 1;
-  }
-  
-  .card-header {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    margin-bottom: 20px;
-    position: relative;
-    z-index: 2;
   }
   
-  .card-title {
-    margin: 0;
-    font-size: 24px;
-    font-weight: bold;
-    color: white;
-    text-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
-    flex: 1;
-    text-align: center;
-  }
-  
-  .back-btn-card {
-    background: rgba(255, 255, 255, 0.2);
+  .close-button {
+    background: none;
     border: none;
     color: white;
+    font-size: 1.5rem;
     cursor: pointer;
-    padding: 8px;
-    border-radius: 12px;
+    padding: 0;
+    width: 32px;
+    height: 32px;
     display: flex;
     align-items: center;
     justify-content: center;
-    transition: all 0.2s;
+    border-radius: 50%;
+    transition: background 0.2s;
   }
   
-  .back-btn-card:hover {
-    background: rgba(255, 255, 255, 0.3);
-  }
-  
-  .download-button {
+  .close-button:hover {
     background: rgba(255, 255, 255, 0.2);
-    border: none;
-    color: white;
-    cursor: pointer;
-    padding: 8px;
-    border-radius: 12px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    transition: all 0.2s;
-  }
-  
-  .download-button:hover {
-    background: rgba(255, 255, 255, 0.3);
-    transform: scale(1.05);
-  }
-  
-  .download-button:active {
-    transform: scale(0.95);
   }
   
-  .download-button:disabled {
-    opacity: 0.5;
-    cursor: not-allowed;
-  }
-  
-  .download-button svg {
-    width: 20px;
-    height: 20px;
-  }
-  
-  .large-image-section {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    position: relative;
-    z-index: 2;
-  }
-  
-  .large-image-container {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    width: 360px;
-    height: 360px;
-  }
-  
-  .large-piclet-image {
-    width: 360px;
-    height: 360px;
-    object-fit: contain;
-    filter: drop-shadow(0 4px 8px rgba(0, 0, 0, 0.2));
+  .tier-badge {
+    padding: 0.5rem 1rem;
+    border-radius: 20px;
+    font-size: 0.8rem;
+    font-weight: bold;
+    text-transform: uppercase;
   }
   
+  .tier-low { background: #6c757d; }
+  .tier-medium { background: #28a745; }
+  .tier-high { background: #fd7e14; }
+  .tier-legendary { background: #dc3545; }
   
-  /* Tab Bar */
-  .tab-bar {
-    margin: 0 16px 16px;
-    height: 36px;
-    background: #e5e5ea;
-    border-radius: 12px;
-    display: flex;
-    padding: 2px;
-  }
-  
-  .tab-button {
+  .content {
     flex: 1;
-    background: none;
-    border: none;
-    border-radius: 10px;
-    font-size: 14px;
-    font-weight: 500;
-    color: #8e8e93;
-    cursor: pointer;
-    transition: all 0.2s;
-  }
-  
-  .tab-button.active {
-    background: var(--type-color, #4CAF50);
-    color: white;
-    box-shadow: 0 2px 4px color-mix(in srgb, var(--type-color, #4CAF50) 30%, transparent);
+    overflow-y: auto;
+    padding: 1.5rem;
   }
   
-  /* Tab Content */
-  .tab-content {
-    margin: 0 16px 16px;
+  .image-section {
+    text-align: center;
+    margin-bottom: 1.5rem;
   }
   
-  .content-card {
-    background: white;
+  .piclet-image {
+    width: 150px;
+    height: 150px;
+    object-fit: contain;
     border-radius: 12px;
-    padding: 16px;
-    border: 0.5px solid #c6c6c8;
-  }
-  
-  .description {
-    margin: 0 0 16px;
-    font-size: 16px;
-    line-height: 1.4;
-    color: #000;
+    background: rgba(0, 0, 0, 0.05);
   }
   
-  
-  /* Stats Tab */
-  
-  .stats-list {
+  .info-section {
     display: flex;
     flex-direction: column;
-    gap: 12px;
-  }
-  
-  .stat-row {
-    display: flex;
-    justify-content: space-between;
-    font-size: 15px;
-  }
-  
-  .stat-value {
-    font-weight: 600;
-  }
-  
-  .divider {
-    height: 1px;
-    background: #e5e5ea;
-    margin: 16px 0;
-  }
-  
-  .stat-summary {
-    display: flex;
-    justify-content: space-around;
+    gap: 1rem;
   }
   
-  .summary-item {
-    text-align: center;
-  }
-  
-  .summary-label {
-    display: block;
-    font-size: 14px;
-    color: #8e8e93;
-    margin-bottom: 4px;
-  }
-  
-  .summary-value {
-    font-size: 16px;
+  .name {
+    margin: 0;
+    font-size: 1.5rem;
     font-weight: bold;
-    color: #000;
-  }
-  
-  
-  /* Bottom Actions */
-  .bottom-actions {
-    padding: 16px;
-    background: white;
-    border-top: 0.5px solid #c6c6c8;
     text-align: center;
+    color: var(--type-color, #007bff);
   }
   
-  .section-heading {
-    font-size: 18px;
-    font-weight: 600;
-    color: #495057;
-    margin: 0 0 12px 0;
-  }
-  
-  .btn {
-    padding: 0.75rem 1.5rem;
-    border: none;
-    border-radius: 8px;
-    font-size: 16px;
-    font-weight: 600;
-    cursor: pointer;
-    transition: transform 0.2s;
-  }
-  
-  .btn:active {
-    transform: scale(0.95);
-  }
-  
-  .btn-danger {
-    background: #ff3b30;
-    color: white;
-    width: 100%;
-  }
-  
-  /* Enhanced ability and move display styles */
-  .moves-list {
+  .types {
     display: flex;
-    flex-direction: column;
-    gap: 4px;
-  }
-  
-  /* Locked content styles */
-  .locked-ability,
-  .locked-move {
-    background: #f8f9fa;
-    border: 1px dashed #dee2e6;
-    border-radius: 8px;
-    padding: 12px;
-    margin-bottom: 8px;
-    opacity: 0.7;
-  }
-  
-  .lock-header {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    margin-bottom: 8px;
-  }
-  
-  .lock-icon {
-    font-size: 16px;
+    gap: 0.5rem;
+    justify-content: center;
   }
   
-  .lock-text {
-    font-size: 12px;
+  .type {
+    padding: 0.5rem 1rem;
+    border-radius: 20px;
+    font-size: 0.9rem;
     font-weight: 600;
-    color: #6c757d;
     text-transform: uppercase;
-    letter-spacing: 0.5px;
+    color: white;
   }
   
-  .locked-content h4 {
-    margin: 0 0 4px 0;
-    font-size: 16px;
-    font-weight: 600;
-    color: #495057;
+  .type.secondary {
+    background: #6c757d;
   }
   
-  .locked-content p {
-    margin: 0;
-    font-size: 14px;
-    color: #6c757d;
-    font-style: italic;
+  .description h3 {
+    margin: 0 0 0.5rem 0;
+    color: #333;
+    font-size: 1.1rem;
   }
   
-  /* Level and Status Section */
-  .level-xp-section {
-    background: white;
-    margin: 0 16px 16px;
-    border-radius: 12px;
-    padding: 16px;
-    border: 0.5px solid #c6c6c8;
+  .description p {
+    margin: 0;
+    line-height: 1.5;
+    color: #666;
   }
   
-  .level-info {
+  .metadata {
     display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 16px;
-  }
-  
-  .level-label {
-    font-size: 18px;
-    font-weight: 700;
-    color: #1a1a1a;
-  }
-  
-  .xp-label {
-    font-size: 14px;
-    font-weight: 500;
-    color: #8e8e93;
+    flex-direction: column;
+    gap: 0.5rem;
   }
   
-  /* Stat Rows (HP and XP bars) */
-  .stat-row {
+  .meta-item {
     display: flex;
     align-items: center;
-    gap: 8px;
-    margin-bottom: 8px;
+    gap: 0.5rem;
+    font-size: 0.9rem;
   }
   
-  .stat-row:last-child {
-    margin-bottom: 0;
-  }
-  
-  .stat-label {
-    font-size: 12px;
+  .roster-badge {
+    background: #28a745;
+    color: white;
+    padding: 0.25rem 0.5rem;
+    border-radius: 12px;
+    font-size: 0.8rem;
     font-weight: 600;
-    color: #666;
-    text-transform: uppercase;
-    letter-spacing: 0.3px;
-    width: 24px;
-    flex-shrink: 0;
-  }
-  
-  /* HP Bar */
-  .hp-bar {
-    height: 8px;
-    background: #e0e0e0;
-    border-radius: 4px;
-    overflow: hidden;
-    flex: 1;
-    min-width: 80px;
   }
   
-  .hp-fill {
-    height: 100%;
-    transition: width 0.5s ease, background-color 0.3s ease;
-  }
-  
-  /* XP Bar */
-  .xp-bar {
-    height: 8px;
-    background: #e0e0e0;
-    border-radius: 4px;
-    overflow: hidden;
-    flex: 1;
-    min-width: 80px;
-  }
-  
-  .xp-fill {
-    height: 100%;
-    background: #2196f3;
-    transition: width 1.2s ease-out;
+  .actions {
+    padding: 1rem 1.5rem;
+    border-top: 1px solid #eee;
+    display: flex;
+    justify-content: center;
   }
   
-  .stat-value {
-    font-size: 12px;
+  .delete-button {
+    background: #dc3545;
+    color: white;
+    border: none;
+    padding: 0.75rem 1.5rem;
+    border-radius: 8px;
     font-weight: 600;
-    color: #666;
-    min-width: 60px;
-    text-align: right;
-    flex-shrink: 0;
+    cursor: pointer;
+    transition: background 0.2s;
   }
   
-  .max-level-indicator {
-    font-size: 12px;
-    font-weight: 600;
-    color: #ff6f00;
-    background: rgba(255, 111, 0, 0.1);
-    border: 1px solid #ff6f00;
-    border-radius: 4px;
-    padding: 2px 8px;
-    flex: 1;
-    text-align: center;
-  }
-
-  @media (min-width: 768px) {
-    .detail-page {
-      position: relative;
-      max-width: 600px;
-      margin: 0 auto;
-      box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
-    }
+  .delete-button:hover {
+    background: #c82333;
   }
 </style>

src/lib/db/battleService.ts

@@ -1,170 +0,0 @@
-import type { PicletInstance, BattleState, BattlePhase, BattleMove } from './schema';
-import { db } from './index';
-import { getEffectivenessMultiplier, AttackType } from '../types/picletTypes';
-
-export class BattleService {
-  // Initialize a new battle
-  static createBattleState(
-    playerPiclet: PicletInstance,
-    enemyPiclet: PicletInstance,
-    isWildBattle: boolean = true
-  ): BattleState {
-    return {
-      phase: 'intro' as BattlePhase,
-      currentTurn: 0,
-      playerPiclet,
-      enemyPiclet,
-      isWildBattle,
-      processingTurn: false,
-      battleEnded: false
-    };
-  }
-
-  // Calculate damage with type effectiveness
-  static calculateDamage(
-    attacker: PicletInstance,
-    defender: PicletInstance,
-    move: BattleMove
-  ): { damage: number; effectiveness: number } {
-    const baseDamage = move.power || 50;
-    const attackStat = move.power > 0 ? attacker.attack : attacker.fieldAttack;
-    const defenseStat = move.power > 0 ? defender.defense : defender.fieldDefense;
-    
-    // Type effectiveness
-    const effectiveness = getEffectivenessMultiplier(
-      move.type,
-      defender.primaryType,
-      defender.secondaryType
-    );
-    
-    // STAB (Same Type Attack Bonus) - 1.5x if move type matches attacker's type
-    const stab = (move.type === attacker.primaryType as unknown as AttackType || move.type === attacker.secondaryType as unknown as AttackType) ? 1.5 : 1;
-    
-    // Simple damage formula
-    let damage = Math.floor((baseDamage * (attackStat / defenseStat) * 0.5) + 10);
-    
-    // Apply type effectiveness and STAB
-    damage = Math.floor(damage * effectiveness * stab);
-    
-    // Add some randomness (85-100% of calculated damage)
-    const randomFactor = 0.85 + Math.random() * 0.15;
-    damage = Math.floor(damage * randomFactor);
-    
-    // Minimum 1 damage for non-immune moves
-    if (effectiveness > 0 && damage < 1) {
-      damage = 1;
-    }
-    
-    return { damage, effectiveness };
-  }
-
-  // Check if move hits (based on accuracy)
-  static doesMoveHit(accuracy: number): boolean {
-    return Math.random() * 100 < accuracy;
-  }
-
-  // Calculate capture rate for wild piclets
-  static calculateCaptureRate(
-    targetPiclet: PicletInstance,
-    targetMaxHp: number
-  ): number {
-    const hpFactor = (targetMaxHp - targetPiclet.currentHp) / targetMaxHp;
-    const levelFactor = Math.max(0.5, 1 - (targetPiclet.level / 100));
-    
-    // Base capture rate increases with damage and lower level
-    const baseRate = 0.3; // 30% base rate
-    const captureRate = baseRate + (hpFactor * 0.4) + (levelFactor * 0.3);
-    
-    return Math.min(0.95, captureRate); // Cap at 95%
-  }
-
-  // Attempt to catch a wild piclet
-  static attemptCapture(
-    targetPiclet: PicletInstance
-  ): { success: boolean; shakes: number } {
-    const captureRate = this.calculateCaptureRate(targetPiclet, targetPiclet.maxHp);
-    const roll = Math.random();
-    
-    // Calculate shakes (0-3)
-    let shakes = 0;
-    if (roll < captureRate * 0.9) shakes = 1;
-    if (roll < captureRate * 0.7) shakes = 2;
-    if (roll < captureRate * 0.5) shakes = 3;
-    
-    return {
-      success: roll < captureRate,
-      shakes
-    };
-  }
-
-  // Create a caught piclet instance
-  static async createCaughtPiclet(
-    wildPiclet: PicletInstance
-  ): Promise<PicletInstance> {
-    const caughtPiclet: Omit<PicletInstance, 'id'> = {
-      ...wildPiclet,
-      isInRoster: false, // Goes to storage initially
-      rosterPosition: undefined,
-      caughtAt: new Date()
-    };
-    
-    const id = await db.picletInstances.add(caughtPiclet);
-    return { ...caughtPiclet, id };
-  }
-
-  // Calculate experience gain
-  static calculateExpGain(
-    defeatedPiclet: PicletInstance,
-    isWild: boolean
-  ): number {
-    const baseExp = 50 + (defeatedPiclet.level * 10);
-    const wildModifier = isWild ? 1 : 1.5; // Trainer piclets give more exp
-    
-    return Math.floor(baseExp * wildModifier);
-  }
-
-  // Check if piclet should level up
-  static checkLevelUp(
-    piclet: PicletInstance,
-    expGained: number
-  ): { leveledUp: boolean; newLevel: number } {
-    const newExp = piclet.xp + expGained;
-    const expForNextLevel = this.getExpForLevel(piclet.level + 1);
-    
-    if (newExp >= expForNextLevel) {
-      return {
-        leveledUp: true,
-        newLevel: piclet.level + 1
-      };
-    }
-    
-    return {
-      leveledUp: false,
-      newLevel: piclet.level
-    };
-  }
-
-  // Get experience required for a level
-  static getExpForLevel(level: number): number {
-    // Simple exponential growth formula
-    return Math.floor(Math.pow(level, 2.5) * 10);
-  }
-
-  // Apply stat boosts for level up
-  static applyLevelUpStats(piclet: PicletInstance): PicletInstance {
-    // Simple stat growth (5-10% increase per level)
-    const growthFactor = 1.07;
-    
-    return {
-      ...piclet,
-      level: piclet.level + 1,
-      maxHp: Math.floor(piclet.maxHp * growthFactor),
-      currentHp: Math.floor(piclet.currentHp * growthFactor),
-      attack: Math.floor(piclet.attack * growthFactor),
-      defense: Math.floor(piclet.defense * growthFactor),
-      fieldAttack: Math.floor(piclet.fieldAttack * growthFactor),
-      fieldDefense: Math.floor(piclet.fieldDefense * growthFactor),
-      speed: Math.floor(piclet.speed * growthFactor)
-    };
-  }
-}

src/lib/db/encounterService.ts

@@ -2,14 +2,12 @@ import { db } from './index';
 import type { Encounter, PicletInstance } from './schema';
 import { EncounterType } from './schema';
 import { getOrCreateGameState, markEncountersRefreshed } from './gameState';
-import { getCaughtPiclets, getUncaughtPiclets } from './piclets';
-import { calculateStat, calculateHp } from '../services/levelingService';
+import { getCaughtPiclets } from './piclets';
 
 // Configuration
 const ENCOUNTER_REFRESH_HOURS = 2;
 const MIN_WILD_ENCOUNTERS = 2;
-const MAX_WILD_ENCOUNTERS = 3;
-const LEVEL_VARIANCE = 2;
+const MAX_WILD_ENCOUNTERS = 4;
 
 export class EncounterService {
   // Check if encounters should be refreshed
@@ -38,61 +36,25 @@ export class EncounterService {
     await db.encounters.clear();
   }
 
-
-  // Generate new encounters
+  // Generate new encounters - simplified to only wild battles
   static async generateEncounters(): Promise<Encounter[]> {
     const encounters: Omit<Encounter, 'id'>[] = [];
     
-    // Check for "Your First Piclet" scenario first
+    // Check if player has any Piclets
     const caughtPiclets = await getCaughtPiclets();
-    const uncaughtPiclets = await getUncaughtPiclets();
     
     if (caughtPiclets.length === 0) {
-      // Player has no caught piclets
-      if (uncaughtPiclets.length > 0) {
-        // Player has scanned piclets but hasn't caught any - create first piclet encounter
-        console.log('Player has scanned piclets but no caught ones - creating first piclet encounter');
-        const firstPicletEncounter = await this.createFirstCatchEncounter(uncaughtPiclets);
-        encounters.push(firstPicletEncounter);
-      } else {
-        // Player has no piclets at all - return empty encounters
-        console.log('Player has no piclets at all - returning empty encounters');
-        await db.encounters.clear();
-        await markEncountersRefreshed();
-        return [];
-      }
-      
-      // Save the first piclet encounter and return
+      // No Piclets yet - show empty state, they need to scan first
+      console.log('Player has no caught piclets - returning empty encounters');
       await db.encounters.clear();
-      for (const encounter of encounters) {
-        await db.encounters.add(encounter);
-      }
       await markEncountersRefreshed();
-      return await this.getCurrentEncounters();
+      return [];
     }
     
-    // Player has caught piclets - generate normal encounters
-    console.log('Generating normal encounters for player with caught piclets');
-    
-    // Generate wild piclet encounters FIRST to ensure they're included
-    const wildEncounters = await this.generateWildEncounters();
-    console.log('Wild encounters generated:', wildEncounters.length);
+    // Player has Piclets - generate wild battle encounters
+    console.log('Generating wild battle encounters');
+    const wildEncounters = await this.generateWildBattleEncounters();
     encounters.push(...wildEncounters);
-    
-    // Always add shop and health center
-    encounters.push({
-      type: EncounterType.SHOP,
-      title: 'Piclet Shop',
-      description: 'Buy items and supplies for your journey',
-      createdAt: new Date()
-    });
-
-    encounters.push({
-      type: EncounterType.HEALTH_CENTER,
-      title: 'Health Center',
-      description: 'Heal your piclets back to full health',
-      createdAt: new Date()
-    });
 
     // Clear existing encounters and add new ones
     await db.encounters.clear();
@@ -104,182 +66,50 @@ export class EncounterService {
     return await this.getCurrentEncounters();
   }
 
-  // Create first catch encounter
-  private static async createFirstCatchEncounter(uncaughtPiclets: PicletInstance[]): Promise<Omit<Encounter, 'id'>> {
-    // Use the most recently scanned (last in array) uncaught piclet
-    const latestPiclet = uncaughtPiclets[uncaughtPiclets.length - 1];
-    
-    // Use the piclet's nickname or typeId for display
-    const displayName = latestPiclet.nickname || latestPiclet.typeId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
-    
-    return {
-      type: EncounterType.FIRST_PICLET,
-      title: 'Your First Piclet!',
-      description: `A friendly ${displayName} appears! This one seems easy to catch.`,
-      picletInstanceId: latestPiclet.id, // Reference to the specific piclet instance
-      picletTypeId: latestPiclet.typeId,
-      enemyLevel: 5, // Easy level for first encounter
-      createdAt: new Date()
-    };
-  }
-
-  // Generate wild piclet encounters
-  private static async generateWildEncounters(): Promise<Omit<Encounter, 'id'>[]> {
+  // Generate wild battle encounters using existing caught Piclets
+  private static async generateWildBattleEncounters(): Promise<Omit<Encounter, 'id'>[]> {
     const encounters: Omit<Encounter, 'id'>[] = [];
     
-    // Get player's average level
-    const avgLevel = await this.getPlayerAverageLevel();
-    
-    // Get uncaught piclets (these can appear as wild encounters to be caught)
-    const uncaughtPiclets = await getUncaughtPiclets();
-    console.log('Uncaught piclets for wild encounters:', uncaughtPiclets.length);
+    // Get all caught piclets to use as potential opponents
+    const caughtPiclets = await getCaughtPiclets();
     
-    if (uncaughtPiclets.length === 0) {
-      console.log('No uncaught piclets - returning empty wild encounters');
+    if (caughtPiclets.length === 0) {
       return encounters;
     }
+
+    // Generate 2-4 random wild encounters
+    const numEncounters = Math.floor(Math.random() * (MAX_WILD_ENCOUNTERS - MIN_WILD_ENCOUNTERS + 1)) + MIN_WILD_ENCOUNTERS;
     
-    // Use uncaught piclets as templates for wild encounters
-    const availablePiclets = uncaughtPiclets;
-    console.log('Available piclets for encounters:', availablePiclets.map(p => p.typeId));
-    
-    const encounterCount = MIN_WILD_ENCOUNTERS + Math.floor(Math.random() * (MAX_WILD_ENCOUNTERS - MIN_WILD_ENCOUNTERS + 1));
-    console.log('Generating', encounterCount, 'wild encounters');
-    
-    for (let i = 0; i < encounterCount; i++) {
-      // Pick a random piclet from available ones
-      const piclet = availablePiclets[Math.floor(Math.random() * availablePiclets.length)];
-      
-      const levelVariance = Math.floor(Math.random() * (LEVEL_VARIANCE * 2 + 1)) - LEVEL_VARIANCE;
-      const enemyLevel = Math.max(1, avgLevel + levelVariance);
+    for (let i = 0; i < numEncounters; i++) {
+      // Pick a random Piclet from caught ones to use as opponent
+      const randomPiclet = caughtPiclets[Math.floor(Math.random() * caughtPiclets.length)];
       
-      // Use the piclet's nickname or typeId for display
-      const displayName = piclet.nickname || piclet.typeId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+      // Use the piclet's name for display
+      const displayName = randomPiclet.typeId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
       
-      const wildEncounter = {
+      const encounter: Omit<Encounter, 'id'> = {
         type: EncounterType.WILD_PICLET,
-        title: `Wild ${displayName} Appeared!`,
-        description: `A level ${enemyLevel} ${displayName} blocks your path!`,
-        picletTypeId: piclet.typeId,
-        enemyLevel,
+        title: `Wild ${displayName}`,
+        description: `A wild ${displayName} appears! Ready for battle?`,
+        picletInstanceId: randomPiclet.id,
+        picletTypeId: randomPiclet.typeId,
+        enemyLevel: 5, // Simplified - no level variance needed
         createdAt: new Date()
       };
       
-      console.log('Created wild encounter:', wildEncounter.title, 'with typeId:', wildEncounter.picletTypeId);
-      encounters.push(wildEncounter);
+      encounters.push(encounter);
     }
-    
-    console.log('Generated', encounters.length, 'wild encounters');
+
     return encounters;
   }
 
-  // Get player's average piclet level
-  private static async getPlayerAverageLevel(): Promise<number> {
-    const rosterPiclets = await db.picletInstances
-      .where('isInRoster')
-      .equals(1) // Dexie uses 1 for true in indexed fields
-      .toArray();
-    
-    if (rosterPiclets.length === 0) {
-      const caughtPiclets = await getCaughtPiclets();
-      if (caughtPiclets.length === 0) return 5; // Default starting level
-      
-      const totalLevel = caughtPiclets.reduce((sum, p) => sum + p.level, 0);
-      return Math.round(totalLevel / caughtPiclets.length);
-    }
-    
-    const totalLevel = rosterPiclets.reduce((sum, p) => sum + p.level, 0);
-    return Math.round(totalLevel / rosterPiclets.length);
+  // Get a specific encounter by ID
+  static async getEncounter(id: number): Promise<Encounter | undefined> {
+    return await db.encounters.get(id);
   }
 
-
-  // Catch a wild piclet (marks uncaught piclet as caught, or creates new instance for recatches)
-  static async catchWildPiclet(encounter: Encounter): Promise<PicletInstance> {
-    if (!encounter.picletTypeId) throw new Error('No piclet type specified');
-    
-    // First check if this is an uncaught piclet that can be directly marked as caught
-    const uncaughtPiclets = await getUncaughtPiclets();
-    const uncaughtPiclet = uncaughtPiclets.find(p => p.typeId === encounter.picletTypeId);
-    
-    if (uncaughtPiclet) {
-      // This is the first time catching this type - mark the existing uncaught piclet as caught
-      const newLevel = encounter.enemyLevel || uncaughtPiclet.level;
-      
-      // Update the existing uncaught piclet
-      const updates = {
-        caught: true,
-        caughtAt: new Date(),
-        level: newLevel,
-        xp: 0,
-        currentHp: calculateHp(uncaughtPiclet.baseHp, newLevel),
-        maxHp: calculateHp(uncaughtPiclet.baseHp, newLevel),
-        attack: calculateStat(uncaughtPiclet.baseAttack, newLevel),
-        defense: calculateStat(uncaughtPiclet.baseDefense, newLevel),
-        fieldAttack: calculateStat(uncaughtPiclet.baseFieldAttack, newLevel),
-        fieldDefense: calculateStat(uncaughtPiclet.baseFieldDefense, newLevel),
-        speed: calculateStat(uncaughtPiclet.baseSpeed, newLevel),
-        
-        // Reset move PP to full
-        moves: uncaughtPiclet.moves.map(move => ({
-          ...move,
-          currentPp: move.pp
-        }))
-      };
-      
-      // Set roster position 0 if this is the first caught piclet
-      const existingCaughtPiclets = await getCaughtPiclets();
-      if (existingCaughtPiclets.length === 0) {
-        Object.assign(updates, {
-          rosterPosition: 0,
-          isInRoster: true
-        });
-      }
-      
-      // Update the existing piclet
-      await db.picletInstances.update(uncaughtPiclet.id!, updates);
-      
-      // Return the updated piclet
-      return { ...uncaughtPiclet, ...updates };
-    }
-    
-    // If no uncaught piclet found, this is a recatch - create a new instance using caught piclet as template
-    const caughtPiclets = await getCaughtPiclets();
-    const templatePiclet = caughtPiclets.find(p => p.typeId === encounter.picletTypeId);
-    
-    if (!templatePiclet) {
-      throw new Error(`Piclet type not found: ${encounter.picletTypeId}`);
-    }
-    
-    // Create a new piclet instance for recatch
-    const newLevel = encounter.enemyLevel || 5;
-    
-    const newPiclet: Omit<PicletInstance, 'id'> = {
-      ...templatePiclet,
-      level: newLevel,
-      xp: 0,
-      currentHp: calculateHp(templatePiclet.baseHp, newLevel),
-      maxHp: calculateHp(templatePiclet.baseHp, newLevel),
-      attack: calculateStat(templatePiclet.baseAttack, newLevel),
-      defense: calculateStat(templatePiclet.baseDefense, newLevel),
-      fieldAttack: calculateStat(templatePiclet.baseFieldAttack, newLevel),
-      fieldDefense: calculateStat(templatePiclet.baseFieldDefense, newLevel),
-      speed: calculateStat(templatePiclet.baseSpeed, newLevel),
-      
-      // Reset move PP to full
-      moves: templatePiclet.moves.map(move => ({
-        ...move,
-        currentPp: move.pp
-      })),
-      
-      // Clear roster info for new catch
-      isInRoster: false,
-      rosterPosition: undefined,
-      caught: true,
-      caughtAt: new Date()
-    };
-    
-    // Save the new piclet
-    const id = await db.picletInstances.add(newPiclet);
-    return { ...newPiclet, id };
+  // Delete an encounter (after it's been completed)
+  static async deleteEncounter(id: number): Promise<void> {
+    await db.encounters.delete(id);
   }
 }

src/lib/db/piclets.ts

@@ -1,9 +1,7 @@
 import { db } from './index';
-import type { PicletInstance, BattleMove } from './schema';
-import { PicletType, getTypeFromConcept } from '../types/picletTypes';
+import type { PicletInstance } from './schema';
+import { PicletType } from '../types/picletTypes';
 import type { PicletStats } from '../types';
-import type { Move as BattleEngineMove } from '../battle-engine/types';
-import { generateUnlockLevels } from '../services/unlockLevels';
 
 // Interface for generated piclet data (from PicletResult component)
 interface GeneratedPicletData {
@@ -18,140 +16,34 @@ interface GeneratedPicletData {
 }
 
 // Convert generated piclet data to a PicletInstance
-export async function generatedDataToPicletInstance(data: GeneratedPicletData, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
+export async function generatedDataToPicletInstance(data: GeneratedPicletData): Promise<Omit<PicletInstance, 'id'>> {
   if (!data.stats) {
     throw new Error('Generated data must have stats to create PicletInstance');
   }
 
-  // All generated data must now have the battle-ready format
   const stats = data.stats as PicletStats;
   
-  if (!stats.baseStats || !stats.specialAbility || !stats.movepool) {
-    throw new Error('Generated stats must be in battle-ready format with baseStats, specialAbility, and movepool');
-  }
-  
-  // Calculate base stats from battle-ready format
-  const baseHp = Math.floor(stats.baseStats.hp * 2 + 50);
-  const baseAttack = Math.floor(stats.baseStats.attack * 1.5 + 30);
-  const baseDefense = Math.floor(stats.baseStats.defense * 1.5 + 30);
-  const baseSpeed = Math.floor(stats.baseStats.speed * 1.5 + 30);
-  
-  // Determine primary type from battle stats
-  const normalizedPrimaryType = stats.primaryType.toLowerCase();
-  const validPrimaryType = Object.values(PicletType).find(type => type === normalizedPrimaryType);
-  const primaryType = validPrimaryType || getTypeFromConcept(data.concept, data.imageCaption);
-  
-  if (!validPrimaryType) {
-    console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
-  }
-
-  // Handle secondary type
-  let secondaryType: PicletType | undefined = undefined;
-  if (stats.secondaryType && stats.secondaryType !== null) {
-    const normalizedSecondaryType = stats.secondaryType.toLowerCase();
-    const validSecondaryType = Object.values(PicletType).find(type => type === normalizedSecondaryType);
-    secondaryType = validSecondaryType;
-    if (!validSecondaryType) {
-      console.warn(`Invalid secondaryType "${stats.secondaryType}" from stats, ignoring`);
-    }
-  }
-
-  // Create moves from battle-ready format preserving all data
-  // Convert from PicletStats.BattleMove (loose types) to schema.BattleMove (strict types)
-  const baseMoves: BattleMove[] = stats.movepool.map(move => ({
-    name: move.name,
-    type: move.type as any, // Type conversion from string union to AttackType enum
-    power: move.power,
-    accuracy: move.accuracy,
-    pp: move.pp,
-    priority: move.priority,
-    flags: move.flags as any, // Type conversion from string[] to MoveFlag[]
-    effects: move.effects as any, // Type conversion between BattleEffect types
-    currentPp: move.pp,
-    unlockLevel: 1 // Temporary, will be set below
-  }));
-  
-  // Generate unlock levels for moves and special ability
-  // Convert from PicletStats.SpecialAbility to battle-engine.SpecialAbility
-  const convertedSpecialAbility = {
-    name: stats.specialAbility.name,
-    description: `Special ability of ${stats.name}`, // Generate a generic description since it's removed from stats
-    effects: stats.specialAbility.effects as any,
-    triggers: stats.specialAbility.triggers as any
-  };
-  const { movesWithUnlocks, abilityUnlockLevel } = generateUnlockLevels(baseMoves, convertedSpecialAbility);
-  const moves = movesWithUnlocks;
-  
-  // Field stats are variations of regular stats
-  const baseFieldAttack = Math.floor(baseAttack * 0.8);
-  const baseFieldDefense = Math.floor(baseDefense * 0.8);
-  
-  // Use Pokemon-accurate stat calculations (matching levelingService)
-  const calculateStat = (base: number, level: number) => {
-    if (level === 1) {
-      return Math.max(1, Math.floor(base / 10) + 5);
-    }
-    return Math.floor((2 * base * level) / 100) + 5;
-  };
-  
-  const calculateHp = (base: number, level: number) => {
-    if (level === 1) {
-      return Math.max(1, Math.floor(base / 10) + 11);
-    }
-    return Math.floor((2 * base * level) / 100) + level + 10;
-  };
-  
-  const maxHp = calculateHp(baseHp, level);
-  
-  const bst = baseHp + baseAttack + baseDefense + baseFieldAttack + baseFieldDefense + baseSpeed;
+  // Map tier from stats
+  let tier: string = stats.tier || 'medium';
   
   // Check if this is the first piclet (no existing piclets in database)
   const existingPiclets = await db.picletInstances.count();
   const isFirstPiclet = existingPiclets === 0;
   
   return {
-    // Type Info
-    typeId: data.name.toLowerCase().replace(/\s+/g, '-'),
-    nickname: stats.name || data.name, // Use stats.name if available, fallback to data.name
-    primaryType: primaryType,
-    secondaryType: secondaryType,
-    
-    // Current Stats
-    currentHp: maxHp,
-    maxHp,
-    level,
-    xp: 0,
-    attack: calculateStat(baseAttack, level),
-    defense: calculateStat(baseDefense, level),
-    fieldAttack: calculateStat(baseFieldAttack, level),
-    fieldDefense: calculateStat(baseFieldDefense, level),
-    speed: calculateStat(baseSpeed, level),
-    
-    // Base Stats
-    baseHp,
-    baseAttack,
-    baseDefense,
-    baseFieldAttack,
-    baseFieldDefense,
-    baseSpeed,
+    // Basic Info
+    typeId: stats.name || data.name,
+    nickname: stats.name || data.name,
+    primaryType: stats.primaryType as PicletType,
+    tier: tier,
     
-    // Battle
-    moves,
-    nature: stats.nature,
-    specialAbility: convertedSpecialAbility,
-    specialAbilityUnlockLevel: abilityUnlockLevel,
-    
-    // Roster
+    // Roster Management
     isInRoster: isFirstPiclet,
     rosterPosition: isFirstPiclet ? 0 : undefined,
     
     // Metadata
     caught: isFirstPiclet, // First piclet is automatically caught
     caughtAt: isFirstPiclet ? new Date() : undefined,
-    bst,
-    tier: stats.tier, // Use tier from stats
-    role: 'balanced', // Could be enhanced based on stat distribution
-    variance: 0,
     
     // Original generation data
     imageUrl: data.imageUrl,
@@ -163,112 +55,65 @@ export async function generatedDataToPicletInstance(data: GeneratedPicletData, l
   };
 }
 
-
-// Save a new PicletInstance
-export async function savePicletInstance(piclet: Omit<PicletInstance, 'id'>): Promise<number> {
-  return await db.picletInstances.add(piclet);
+// Save a piclet instance to the database
+export async function savePicletInstance(picletInstance: Omit<PicletInstance, 'id'>): Promise<number> {
+  const id = await db.picletInstances.add(picletInstance as any);
+  return id;
 }
 
-// Mark a Piclet as caught
-export async function catchPiclet(picletId: number): Promise<void> {
-  await db.picletInstances.update(picletId, {
-    caught: true,
-    caughtAt: new Date()
-  });
+// Update a piclet instance in the database
+export async function updatePicletInstance(id: number, updates: Partial<PicletInstance>): Promise<void> {
+  await db.picletInstances.update(id, updates);
 }
 
-// Get only caught Piclets (for Pictuary and battle roster)
-export async function getCaughtPiclets(): Promise<PicletInstance[]> {
-  const allPiclets = await db.picletInstances.toArray();
-  return allPiclets.filter(p => p.caught === true);
-}
-
-// Get uncaught Piclets (for encounters)
-export async function getUncaughtPiclets(): Promise<PicletInstance[]> {
-  const allPiclets = await db.picletInstances.toArray();
-  return allPiclets.filter(p => p.caught === false);
+// Delete a piclet instance from the database
+export async function deletePicletInstance(id: number): Promise<void> {
+  await db.picletInstances.delete(id);
 }
 
-// Get all PicletInstances
+// Get all piclet instances
 export async function getAllPicletInstances(): Promise<PicletInstance[]> {
   return await db.picletInstances.toArray();
 }
 
-// Get roster PicletInstances
+// Get a single piclet instance by ID
+export async function getPicletInstance(id: number): Promise<PicletInstance | undefined> {
+  return await db.picletInstances.get(id);
+}
+
+// Get roster piclets (those currently in battle roster)
 export async function getRosterPiclets(): Promise<PicletInstance[]> {
-  const allPiclets = await db.picletInstances.toArray();
-  return allPiclets
-    .filter(p => 
-      p.caught === true && // Only caught Piclets can be in roster
-      p.rosterPosition !== undefined && 
-      p.rosterPosition !== null && 
-      p.rosterPosition >= 0 && 
-      p.rosterPosition <= 5
-    )
-    .sort((a, b) => (a.rosterPosition ?? 0) - (b.rosterPosition ?? 0));
+  return await db.picletInstances.where('isInRoster').equals(1).toArray();
 }
 
-// Update roster position
-export async function updateRosterPosition(id: number, position: number | undefined): Promise<void> {
-  await db.picletInstances.update(id, {
-    isInRoster: position !== undefined,
-    rosterPosition: position
-  });
+// Get caught piclets (those that have been captured)
+export async function getCaughtPiclets(): Promise<PicletInstance[]> {
+  return await db.picletInstances.where('caught').equals(1).toArray();
 }
 
-// Move piclet to roster
-export async function moveToRoster(id: number, position: number): Promise<void> {
-  // Check if position is already occupied
-  const existingPiclet = await db.picletInstances
-    .where('rosterPosition')
-    .equals(position)
-    .and(item => item.isInRoster)
-    .first();
-    
-  if (existingPiclet) {
-    // Move existing piclet to storage
-    await db.picletInstances.update(existingPiclet.id!, {
-      isInRoster: false,
-      rosterPosition: undefined
-    });
-  }
-  
-  // Move new piclet to roster
-  await db.picletInstances.update(id, {
+// Move a piclet to roster (simplified version)
+export async function moveToRoster(picletId: number, position: number): Promise<void> {
+  await db.picletInstances.update(picletId, {
     isInRoster: true,
     rosterPosition: position
   });
 }
 
-// Swap roster positions
+// Get uncaught piclets
+export async function getUncaughtPiclets(): Promise<PicletInstance[]> {
+  return await db.picletInstances.where('caught').equals(0).toArray();
+}
+
+// Swap roster positions (simplified version)
 export async function swapRosterPositions(id1: number, position1: number, id2: number, position2: number): Promise<void> {
-  await db.transaction('rw', db.picletInstances, async () => {
-    await db.picletInstances.update(id1, { rosterPosition: position2 });
-    await db.picletInstances.update(id2, { rosterPosition: position1 });
-  });
+  await db.picletInstances.update(id1, { rosterPosition: position2 });
+  await db.picletInstances.update(id2, { rosterPosition: position1 });
 }
 
-// Move piclet to storage
-export async function moveToStorage(id: number): Promise<void> {
-  await db.picletInstances.update(id, {
+// Move to storage (simplified version)
+export async function moveToStorage(picletId: number): Promise<void> {
+  await db.picletInstances.update(picletId, {
     isInRoster: false,
     rosterPosition: undefined
   });
-}
-
-// Get storage piclets
-export async function getStoragePiclets(): Promise<PicletInstance[]> {
-  const allPiclets = await db.picletInstances.toArray();
-  return allPiclets.filter(p => 
-    p.caught === true && // Only caught Piclets can be in storage
-    (p.rosterPosition === undefined || 
-     p.rosterPosition === null ||
-     p.rosterPosition < 0 ||
-     p.rosterPosition > 5)
-  );
-}
-
-// Delete a PicletInstance
-export async function deletePicletInstance(id: number): Promise<void> {
-  await db.picletInstances.delete(id);
 }

src/lib/db/schema.ts

@@ -1,74 +1,36 @@
-import type { PicletType, AttackType } from '../types/picletTypes';
-import type { SpecialAbility, Move } from '../battle-engine/types';
+import type { PicletType } from '../types/picletTypes';
 
 // Enums
 export enum EncounterType {
   WILD_PICLET = 'wildPiclet',
-  TRAINER_BATTLE = 'trainerBattle',
-  SHOP = 'shop',
-  HEALTH_CENTER = 'healthCenter',
   FIRST_PICLET = 'firstPiclet'
 }
 
-// Battle Move with unlock level - extends the complete Move interface
-export interface BattleMove extends Move {
-  currentPp: number;
-  unlockLevel: number; // Level at which this move is unlocked
-}
 
 // PicletInstance - Individual monster instances owned by the player
 export interface PicletInstance {
   id?: number;
   
-  // Type Info
+  // Basic Info
   typeId: string;
   nickname?: string;
   primaryType: PicletType;
-  secondaryType?: PicletType;
-  
-  // Current Stats
-  currentHp: number;
-  maxHp: number;
-  level: number;
-  xp: number;
-  attack: number;
-  defense: number;
-  fieldAttack: number;
-  fieldDefense: number;
-  speed: number;
-  
-  // Base Stats (from generation)
-  baseHp: number;
-  baseAttack: number;
-  baseDefense: number;
-  baseFieldAttack: number;
-  baseFieldDefense: number;
-  baseSpeed: number;
+  tier: string; // 'low' | 'medium' | 'high' | 'legendary'
   
-  // Battle
-  moves: BattleMove[];
-  nature: string;
-  specialAbility: SpecialAbility;
-  specialAbilityUnlockLevel: number; // Level at which special ability is unlocked
-  
-  // Roster
+  // Roster Management
   isInRoster: boolean;
   rosterPosition?: number; // 0-5 when in roster
   
   // Metadata
   caught: boolean; // Whether this Piclet has been caught by the player
   caughtAt?: Date; // When this Piclet was caught (undefined if not caught)
-  bst: number; // Base Stat Total
-  tier: string;
-  role: string;
-  variance: number;
   
   // Original generation data
   imageUrl: string;
   imageData?: string; // Base64 encoded image with transparency
   imageCaption: string;
   concept: string;
-  description: string; // Generated monster description from stats
+  description: string; // Generated monster description
   imagePrompt: string;
 }
 
@@ -105,35 +67,6 @@ export interface GameState {
   battlesLost: number;
 }
 
-// Battle System Types
-export enum BattlePhase {
-  INTRO = 'intro',
-  MAIN = 'main',
-  MOVE_SELECT = 'moveSelect',
-  PICLET_SELECT = 'picletSelect',
-  FORCED_SWAP = 'forcedSwap',
-  BATTLE_END = 'battleEnd'
-}
-
-export enum ActionView {
-  MAIN = 'main',
-  MOVES = 'moves',
-  PICLETS = 'piclets',
-  ITEMS = 'items',
-  FORCED_SWAP = 'forcedSwap'
-}
-
-export interface BattleState {
-  phase: BattlePhase;
-  currentTurn: number;
-  playerPiclet: PicletInstance;
-  enemyPiclet: PicletInstance;
-  isWildBattle: boolean;
-  processingTurn: boolean;
-  battleEnded: boolean;
-  winner?: 'player' | 'enemy';
-  capturedPiclet?: PicletInstance;
-}
 
 // Trainer Scanning Progress - Track automated trainer piclet generation
 export interface TrainerScanProgress {

src/lib/services/captureService.ts

@@ -1,212 +0,0 @@
-/**
- * Pokemon-style Capture Mechanics for Pictuary
- * Based on Pokemon Emerald's capture formula from POKEMON_CAPTURE_MECHANICS.md
- */
-
-export interface CaptureResult {
-  success: boolean;
-  shakes: number; // 0-3 shakes before success/failure
-  odds: number; // Internal capture odds for debugging
-}
-
-export interface CaptureAttemptParams {
-  // Target Piclet stats
-  maxHp: number;
-  currentHp: number;
-  baseCatchRate: number; // Species-specific catch rate (3-255)
-  
-  // Status effects (optional)
-  statusEffect?: 'sleep' | 'freeze' | 'poison' | 'burn' | 'paralysis' | 'toxic' | null;
-  
-  // Battle context (optional - for future specialty ball mechanics)
-  battleTurn?: number;
-  picletLevel?: number;
-}
-
-/**
- * Get the catch rate multiplier for a given tier
- * Maps Pictuary tiers to Pokemon-style catch rates
- */
-export function getCatchRateForTier(tier: string): number {
-  switch (tier.toLowerCase()) {
-    case 'legendary': return 3;   // Hardest to catch (like legendary Pokemon)
-    case 'high': return 25;       // Hard to catch (like pseudolegendaries)
-    case 'medium': return 75;     // Standard catch rate
-    case 'low': return 150;       // Easy to catch (like common Pokemon)
-    default: return 75;           // Default to medium
-  }
-}
-
-/**
- * Get status condition multiplier for capture rate
- */
-function getStatusMultiplier(status: string | null | undefined): number {
-  switch (status) {
-    case 'sleep':
-    case 'freeze':
-      return 2.0; // Best status conditions for catching
-    case 'poison':
-    case 'burn':
-    case 'paralysis':
-    case 'toxic':
-      return 1.5; // Good status conditions
-    default:
-      return 1.0; // No status effect
-  }
-}
-
-/**
- * Calculate initial capture odds using Pokemon formula
- * Formula: odds = (catchRate × ballMultiplier ÷ 10) × (maxHP × 3 - currentHP × 2) ÷ (maxHP × 3) × statusMultiplier
- */
-function calculateCaptureOdds(params: CaptureAttemptParams): number {
-  const { maxHp, currentHp, baseCatchRate, statusEffect } = params;
-  
-  // Ball multiplier - since we don't have different camera types, use baseline 1.0x (10 in Pokemon terms)
-  const ballMultiplier = 10;
-  
-  // HP factor: (maxHP × 3 - currentHP × 2) ÷ (maxHP × 3)
-  // This creates the 3x capture boost when HP is at 1
-  const hpFactor = (maxHp * 3 - currentHp * 2) / (maxHp * 3);
-  
-  // Status multiplier
-  const statusMultiplier = getStatusMultiplier(statusEffect);
-  
-  // Core formula
-  const odds = (baseCatchRate * ballMultiplier / 10) * hpFactor * statusMultiplier;
-  
-  return Math.max(0, Math.floor(odds));
-}
-
-/**
- * Calculate shake probability when capture odds <= 254
- * Formula: shakeOdds = 1048560 ÷ sqrt(sqrt(16711680 ÷ odds))
- */
-function calculateShakeOdds(captureOdds: number): number {
-  if (captureOdds === 0) return 0;
-  
-  const shakeOdds = 1048560 / Math.sqrt(Math.sqrt(16711680 / captureOdds));
-  return Math.floor(shakeOdds);
-}
-
-/**
- * Simulate individual shake success
- * Each shake has a (shakeOdds / 65536) chance of success
- */
-function simulateShake(shakeOdds: number): boolean {
-  const randomValue = Math.floor(Math.random() * 65536);
-  return randomValue < shakeOdds;
-}
-
-/**
- * Attempt to capture a Piclet using Pokemon mechanics
- * Returns detailed results including number of shakes
- */
-export function attemptCapture(params: CaptureAttemptParams): CaptureResult {
-  const odds = calculateCaptureOdds(params);
-  
-  // Immediate capture if odds > 254
-  if (odds > 254) {
-    return {
-      success: true,
-      shakes: 3,
-      odds
-    };
-  }
-  
-  // If odds are 0, capture fails immediately
-  if (odds === 0) {
-    return {
-      success: false,
-      shakes: 0,
-      odds
-    };
-  }
-  
-  // Calculate shake probability
-  const shakeOdds = calculateShakeOdds(odds);
-  
-  // Simulate up to 3 shakes
-  let shakes = 0;
-  for (let i = 0; i < 3; i++) {
-    if (simulateShake(shakeOdds)) {
-      shakes++;
-    } else {
-      // Shake failed, capture fails
-      return {
-        success: false,
-        shakes,
-        odds
-      };
-    }
-  }
-  
-  // All 3 shakes succeeded - capture success!
-  return {
-    success: true,
-    shakes: 3,
-    odds
-  };
-}
-
-/**
- * Calculate capture rate percentage for display purposes
- * This gives players an approximate idea of their chances
- */
-export function calculateCapturePercentage(params: CaptureAttemptParams): number {
-  const odds = calculateCaptureOdds(params);
-  
-  // Immediate capture
-  if (odds > 254) return 100;
-  
-  // No chance
-  if (odds === 0) return 0;
-  
-  // For odds <= 254, we need to calculate the probability of getting 3 successful shakes
-  const shakeOdds = calculateShakeOdds(odds);
-  const shakeSuccessRate = shakeOdds / 65536;
-  
-  // Probability of 3 consecutive successful shakes
-  const captureRate = Math.pow(shakeSuccessRate, 3) * 100;
-  
-  return Math.min(100, Math.max(0.1, captureRate)); // At least 0.1% to show something
-}
-
-/**
- * Get a user-friendly description of capture difficulty based on percentage
- */
-export function getCaptureDescription(percentage: number): string {
-  if (percentage >= 95) return "Almost certain";
-  if (percentage >= 75) return "Very likely";
-  if (percentage >= 50) return "Good chance";
-  if (percentage >= 25) return "Moderate chance";
-  if (percentage >= 10) return "Low chance";
-  if (percentage >= 5) return "Very low chance";
-  return "Extremely difficult";
-}
-
-/**
- * Simulate multiple capture attempts to get average results (for testing/balancing)
- */
-export function simulateMultipleCaptures(params: CaptureAttemptParams, attempts: number = 1000): {
-  successRate: number;
-  averageShakes: number;
-  distribution: { [key: number]: number };
-} {
-  let successes = 0;
-  let totalShakes = 0;
-  const shakeDistribution: { [key: number]: number } = { 0: 0, 1: 0, 2: 0, 3: 0 };
-  
-  for (let i = 0; i < attempts; i++) {
-    const result = attemptCapture(params);
-    if (result.success) successes++;
-    totalShakes += result.shakes;
-    shakeDistribution[result.shakes]++;
-  }
-  
-  return {
-    successRate: (successes / attempts) * 100,
-    averageShakes: totalShakes / attempts,
-    distribution: shakeDistribution
-  };
-}

src/lib/services/levelingService.ts

@@ -1,332 +0,0 @@
-/**
- * Pokemon-style Leveling and Stat Calculation Service
- * Implements accurate Pokemon stat formulas based on pokemon_stat_calculation.md
- */
-
-import type { PicletInstance } from '$lib/db/schema';
-
-// Pokemon nature effects: [boosted_stat, lowered_stat] or [null, null] for neutral
-export const NATURES = {
-  'Hardy': [null, null],           // Neutral
-  'Lonely': ['attack', 'defense'],
-  'Brave': ['attack', 'speed'],
-  'Adamant': ['attack', 'sp_attack'],
-  'Naughty': ['attack', 'sp_defense'],
-  'Bold': ['defense', 'attack'],
-  'Docile': [null, null],          // Neutral
-  'Relaxed': ['defense', 'speed'],
-  'Impish': ['defense', 'sp_attack'],
-  'Lax': ['defense', 'sp_defense'],
-  'Timid': ['speed', 'attack'],
-  'Hasty': ['speed', 'defense'],
-  'Serious': [null, null],         // Neutral
-  'Jolly': ['speed', 'sp_attack'],
-  'Naive': ['speed', 'sp_defense'],
-  'Modest': ['sp_attack', 'attack'],
-  'Mild': ['sp_attack', 'defense'],
-  'Quiet': ['sp_attack', 'speed'],
-  'Bashful': [null, null],         // Neutral
-  'Rash': ['sp_attack', 'sp_defense'],
-  'Calm': ['sp_defense', 'attack'],
-  'Gentle': ['sp_defense', 'defense'],
-  'Sassy': ['sp_defense', 'speed'],
-  'Careful': ['sp_defense', 'sp_attack'],
-  'Quirky': [null, null],          // Neutral
-} as const;
-
-export type NatureName = keyof typeof NATURES;
-
-// Growth rate multipliers for different tiers
-const TIER_XP_MULTIPLIERS = {
-  'low': 0.8,        // 20% less XP required (faster leveling)
-  'medium': 1.0,     // Base XP requirements
-  'high': 1.4,       // 40% more XP required (slower leveling)
-  'legendary': 1.8   // 80% more XP required (much slower leveling)
-} as const;
-
-type TierType = keyof typeof TIER_XP_MULTIPLIERS;
-
-/**
- * Convert string tier to TierType, defaulting to 'medium' for unknown values
- */
-function normalizeTier(tier: string): TierType {
-  if (tier in TIER_XP_MULTIPLIERS) {
-    return tier as TierType;
-  }
-  return 'medium'; // Default fallback
-}
-
-// Base experience requirements for Medium Fast growth rate (level³)
-// Other tiers will use multipliers of this base
-const BASE_XP_REQUIREMENTS: number[] = [];
-for (let level = 1; level <= 100; level++) {
-  BASE_XP_REQUIREMENTS[level] = level * level * level;
-}
-
-export interface LevelUpInfo {
-  oldLevel: number;
-  newLevel: number;
-  statChanges: {
-    hp: number;
-    attack: number;
-    defense: number;
-    speed: number;
-  };
-}
-
-export interface NatureModifiers {
-  attack: number;
-  defense: number;
-  speed: number;
-}
-
-/**
- * Calculate HP using Pokemon's HP formula
- * Formula: floor((2 * base_hp * level) / 100) + level + 10
- */
-export function calculateHp(baseHp: number, level: number): number {
-  if (level === 1) {
-    return Math.max(1, Math.floor(baseHp / 10) + 11); // Special case for level 1
-  }
-  
-  return Math.floor((2 * baseHp * level) / 100) + level + 10;
-}
-
-/**
- * Calculate non-HP stat using Pokemon's standard formula
- * Formula: floor((floor((2 * base_stat * level) / 100) + 5) * nature_modifier)
- */
-export function calculateStat(baseStat: number, level: number, natureModifier: number = 1.0): number {
-  if (level === 1) {
-    return Math.max(1, Math.floor(baseStat / 10) + 5); // Special case for level 1
-  }
-  
-  const baseValue = Math.floor((2 * baseStat * level) / 100) + 5;
-  return Math.floor(baseValue * natureModifier);
-}
-
-/**
- * Get nature modifiers for all stats
- */
-export function getNatureModifiers(nature: string): NatureModifiers {
-  const natureName = nature as NatureName;
-  const [boosted, lowered] = NATURES[natureName] || NATURES['Hardy'];
-  
-  const modifiers: NatureModifiers = {
-    attack: 1.0,
-    defense: 1.0,  
-    speed: 1.0,
-  };
-  
-  if (boosted) {
-    (modifiers as any)[boosted] = 1.1; // +10%
-  }
-  if (lowered) {
-    (modifiers as any)[lowered] = 0.9; // -10%
-  }
-  
-  return modifiers;
-}
-
-/**
- * Get XP required to reach a specific level
- */
-/**
- * Get XP required for a specific level based on tier
- */
-export function getXpForLevel(level: number, tier: string = 'medium'): number {
-  if (level < 1 || level > 100) {
-    throw new Error('Level must be between 1 and 100');
-  }
-  const normalizedTier = normalizeTier(tier);
-  const baseXp = BASE_XP_REQUIREMENTS[level];
-  const multiplier = TIER_XP_MULTIPLIERS[normalizedTier];
-  return Math.floor(baseXp * multiplier);
-}
-
-/**
- * Get XP required for next level
- */
-/**
- * Get XP required for next level based on tier
- */
-export function getXpForNextLevel(currentLevel: number, tier: string = 'medium'): number {
-  if (currentLevel >= 100) return 0; // Max level
-  return getXpForLevel(currentLevel + 1, tier);
-}
-
-/**
- * Calculate XP progress percentage for current level
- */
-/**
- * Get XP progress percentage towards next level based on tier
- */
-export function getXpProgress(currentXp: number, currentLevel: number, tier: string = 'medium'): number {
-  if (currentLevel >= 100) return 100;
-  
-  const currentLevelXp = getXpForLevel(currentLevel, tier);
-  const nextLevelXp = getXpForLevel(currentLevel + 1, tier);
-  const xpIntoLevel = currentXp - currentLevelXp;
-  const xpNeededForLevel = nextLevelXp - currentLevelXp;
-  
-  return Math.min(100, Math.max(0, (xpIntoLevel / xpNeededForLevel) * 100));
-}
-
-/**
- * Get current XP towards next level in X/Y format
- */
-export function getXpTowardsNextLevel(currentXp: number, currentLevel: number, tier: string = 'medium'): {
-  current: number;
-  needed: number;
-  percentage: number;
-} {
-  if (currentLevel >= 100) {
-    return { current: 0, needed: 0, percentage: 100 };
-  }
-  
-  const currentLevelXp = getXpForLevel(currentLevel, tier);
-  const nextLevelXp = getXpForLevel(currentLevel + 1, tier);
-  const xpIntoLevel = Math.max(0, currentXp - currentLevelXp);
-  const xpNeededForLevel = nextLevelXp - currentLevelXp;
-  const percentage = Math.min(100, Math.max(0, (xpIntoLevel / xpNeededForLevel) * 100));
-  
-  return {
-    current: xpIntoLevel,
-    needed: xpNeededForLevel,
-    percentage
-  };
-}
-
-/**
- * Recalculate all stats for a Piclet based on current level and nature
- */
-export function recalculatePicletStats(instance: PicletInstance): PicletInstance {
-  const natureModifiers = getNatureModifiers(instance.nature);
-  
-  // Calculate new stats
-  const newMaxHp = calculateHp(instance.baseHp, instance.level);
-  const newAttack = calculateStat(instance.baseAttack, instance.level, natureModifiers.attack);
-  const newDefense = calculateStat(instance.baseDefense, instance.level, natureModifiers.defense);
-  const newSpeed = calculateStat(instance.baseSpeed, instance.level, natureModifiers.speed);
-  
-  // Field stats are 80% of main stats (existing logic)
-  const newFieldAttack = Math.floor(newAttack * 0.8);
-  const newFieldDefense = Math.floor(newDefense * 0.8);
-  
-  // Maintain current HP ratio when stats change
-  const hpRatio = instance.maxHp > 0 ? instance.currentHp / instance.maxHp : 1;
-  const newCurrentHp = Math.ceil(newMaxHp * hpRatio);
-  
-  return {
-    ...instance,
-    maxHp: newMaxHp,
-    currentHp: newCurrentHp,
-    attack: newAttack,
-    defense: newDefense,
-    speed: newSpeed,
-    fieldAttack: newFieldAttack,
-    fieldDefense: newFieldDefense
-  };
-}
-
-/**
- * Process potential level up and return results
- */
-export function processLevelUp(instance: PicletInstance): {
-  newInstance: PicletInstance;
-  levelUpInfo: LevelUpInfo | null;
-} {
-  const requiredXp = getXpForNextLevel(instance.level, instance.tier);
-  
-  // Check if level up is possible
-  if (instance.level >= 100 || instance.xp < requiredXp) {
-    return { newInstance: instance, levelUpInfo: null };
-  }
-  
-  // Calculate old stats for comparison
-  const oldStats = {
-    hp: instance.maxHp,
-    attack: instance.attack,
-    defense: instance.defense,
-    speed: instance.speed
-  };
-  
-  // Level up the Piclet
-  const leveledUpInstance = {
-    ...instance,
-    level: instance.level + 1
-  };
-  
-  // Recalculate stats with new level
-  const newInstance = recalculatePicletStats(leveledUpInstance);
-  
-  // Heal to full HP on level up (Pokemon tradition)
-  const finalInstance = {
-    ...newInstance,
-    currentHp: newInstance.maxHp
-  };
-  
-  // Calculate stat changes
-  const statChanges = {
-    hp: finalInstance.maxHp - oldStats.hp,
-    attack: finalInstance.attack - oldStats.attack,
-    defense: finalInstance.defense - oldStats.defense,
-    speed: finalInstance.speed - oldStats.speed
-  };
-  
-  const levelUpInfo: LevelUpInfo = {
-    oldLevel: instance.level,
-    newLevel: finalInstance.level,
-    statChanges
-  };
-  
-  return { newInstance: finalInstance, levelUpInfo };
-}
-
-/**
- * Calculate XP gained from defeating a Piclet in battle
- * Based on Pokemon formula: (baseExpYield * level) / 7
- */
-export function calculateBattleXp(defeatedPiclet: PicletInstance, participantCount: number = 1): number {
-  // Use BST as basis for exp yield (common Pokemon approach)
-  const bst = defeatedPiclet.baseHp + defeatedPiclet.baseAttack + defeatedPiclet.baseDefense + 
-             defeatedPiclet.baseSpeed + defeatedPiclet.baseFieldAttack + defeatedPiclet.baseFieldDefense;
-  
-  // Convert BST to exp yield (roughly BST/4, minimum 50)
-  const baseExpYield = Math.max(50, Math.floor(bst / 4));
-  
-  // Pokemon formula
-  const baseXp = Math.floor((baseExpYield * defeatedPiclet.level) / 7);
-  
-  // Divide among participants
-  return Math.max(1, Math.floor(baseXp / participantCount));
-}
-
-/**
- * Check if a level up should occur and process it recursively
- * (Handles multiple level ups from large XP gains)
- */
-export function processAllLevelUps(instance: PicletInstance): {
-  newInstance: PicletInstance;
-  levelUpInfo: LevelUpInfo[];
-} {
-  const levelUps: LevelUpInfo[] = [];
-  let currentInstance = instance;
-  
-  // Process level ups until no more are possible
-  while (currentInstance.level < 100) {
-    const result = processLevelUp(currentInstance);
-    
-    if (result.levelUpInfo) {
-      levelUps.push(result.levelUpInfo);
-      currentInstance = result.newInstance;
-    } else {
-      break;
-    }
-  }
-  
-  return {
-    newInstance: currentInstance,
-    levelUpInfo: levelUps
-  };
-}

src/lib/services/picletMetadata.ts

@@ -70,7 +70,6 @@ export async function embedPicletMetadata(imageBlob: Blob, piclet: PicletInstanc
       typeId: piclet.typeId,
       nickname: piclet.nickname,
       primaryType: piclet.primaryType,
-      secondaryType: piclet.secondaryType,
       currentHp: piclet.maxHp, // Reset to full HP for sharing
       maxHp: piclet.maxHp,
       level: piclet.level,

src/lib/services/unlockLevels.ts

@@ -1,119 +0,0 @@
-/**
- * Utility functions for calculating unlock levels for moves and abilities
- */
-
-import type { BattleMove } from '$lib/db/schema';
-import type { SpecialAbility } from '$lib/battle-engine/types';
-
-/**
- * Calculate unlock level for a move based on its power and characteristics
- * First 2 moves are always unlocked, moves 3-4 unlock at levels 9-14
- */
-export function calculateMoveUnlockLevel(move: BattleMove, moveIndex: number): number {
-  // First two moves are always available at level 1
-  if (moveIndex === 0 || moveIndex === 1) {
-    return 1;
-  }
-  
-  // Third and fourth moves unlock at levels 9-14
-  if (moveIndex === 2) {
-    // Third move unlocks between level 9-11
-    return Math.floor(Math.random() * 3) + 9; // Level 9, 10, or 11
-  }
-  
-  if (moveIndex === 3) {
-    // Fourth move unlocks between level 12-14
-    return Math.floor(Math.random() * 3) + 12; // Level 12, 13, or 14
-  }
-  
-  // For any additional moves beyond the 4th (shouldn't normally happen)
-  // They unlock at higher levels
-  return 15 + (moveIndex - 4) * 5;
-}
-
-/**
- * Calculate unlock level for special ability based on its power and effects
- */
-export function calculateSpecialAbilityUnlockLevel(ability: SpecialAbility): number {
-  // Base level based on ability impact
-  let baseLevel = 15; // Default mid-level unlock
-  
-  // Analyze ability effects to determine power level
-  const effects = ability.effects || [];
-  let powerScore = 0;
-  
-  for (const effect of effects) {
-    switch (effect.type) {
-      case 'damage':
-        powerScore += effect.amount === 'strong' ? 3 : effect.amount === 'normal' ? 2 : 1;
-        break;
-      case 'heal':
-        powerScore += effect.amount === 'large' ? 3 : effect.amount === 'medium' ? 2 : 1;
-        break;
-      case 'modifyStats':
-        // Stat modifications are powerful
-        powerScore += 2;
-        break;
-      case 'applyStatus':
-        powerScore += 2;
-        break;
-      case 'removeStatus':
-        powerScore += 1;
-        break;
-      case 'manipulatePP':
-        powerScore += 1;
-        break;
-      default:
-        powerScore += 1;
-    }
-  }
-  
-  // Convert power score to unlock level
-  if (powerScore <= 2) {
-    baseLevel = Math.floor(Math.random() * 20) + 10; // Level 10-30
-  } else if (powerScore <= 4) {
-    baseLevel = Math.floor(Math.random() * 25) + 20; // Level 20-45
-  } else if (powerScore <= 6) {
-    baseLevel = Math.floor(Math.random() * 25) + 30; // Level 30-55
-  } else {
-    baseLevel = Math.floor(Math.random() * 25) + 40; // Level 40-65
-  }
-  
-  // Cap at level 80
-  return Math.min(baseLevel, 80);
-}
-
-/**
- * Get all unlocked moves for a Piclet at a given level
- */
-export function getUnlockedMoves(moves: BattleMove[], currentLevel: number): BattleMove[] {
-  return moves.filter(move => move.unlockLevel <= currentLevel);
-}
-
-/**
- * Check if special ability is unlocked at given level
- */
-export function isSpecialAbilityUnlocked(unlockLevel: number, currentLevel: number): boolean {
-  return currentLevel >= unlockLevel;
-}
-
-/**
- * Generate unlock levels for a new Piclet's moves and ability
- * This should be called when a Piclet is first generated
- */
-export function generateUnlockLevels(moves: BattleMove[], specialAbility: SpecialAbility): {
-  movesWithUnlocks: BattleMove[];
-  abilityUnlockLevel: number;
-} {
-  const movesWithUnlocks = moves.map((move, index) => ({
-    ...move,
-    unlockLevel: calculateMoveUnlockLevel(move, index)
-  }));
-  
-  const abilityUnlockLevel = calculateSpecialAbilityUnlockLevel(specialAbility);
-  
-  return {
-    movesWithUnlocks,
-    abilityUnlockLevel
-  };
-}

src/lib/types/index.ts

@@ -152,51 +152,6 @@ export interface PicletStats {
   description: string;
   tier: 'low' | 'medium' | 'high' | 'legendary';
   primaryType: 'beast' | 'bug' | 'aquatic' | 'flora' | 'mineral' | 'space' | 'machina' | 'structure' | 'culture' | 'cuisine';
-  secondaryType?: 'beast' | 'bug' | 'aquatic' | 'flora' | 'mineral' | 'space' | 'machina' | 'structure' | 'culture' | 'cuisine' | null;
-  baseStats: {
-    hp: number;
-    attack: number;
-    defense: number;
-    speed: number;
-  };
-  nature: Nature;
-  specialAbility: {
-    name: string;
-    effects?: BattleEffect[];
-    triggers?: AbilityTrigger[];
-  };
-  movepool: BattleMove[];
 }
 
-// Battle system effect types for PicletStats
-export interface BattleEffect {
-  type: 'damage' | 'modifyStats' | 'applyStatus' | 'heal' | 'manipulatePP' | 'fieldEffect' | 'counter' | 'priority' | 'removeStatus' | 'mechanicOverride';
-  target: 'self' | 'opponent' | 'allies' | 'all' | 'attacker' | 'field' | 'playerSide' | 'opponentSide';
-  condition?: string;
-  // Additional properties based on effect type
-  amount?: string;
-  formula?: string;
-  value?: number;
-  stats?: { [key: string]: string };
-  status?: string;
-  chance?: number;
-  [key: string]: any; // Allow additional properties for different effect types
-}
 
-export interface AbilityTrigger {
-  event: string;
-  condition?: string;
-  effects: BattleEffect[];
-}
-
-export interface BattleMove {
-  name: string;
-  description: string;
-  type: 'beast' | 'bug' | 'aquatic' | 'flora' | 'mineral' | 'space' | 'machina' | 'structure' | 'culture' | 'cuisine' | 'normal';
-  power: number;
-  accuracy: number;
-  pp: number;
-  priority: number;
-  flags: string[];
-  effects: BattleEffect[];
-}

src/lib/types/picletTypes.ts

@@ -253,23 +253,15 @@ export function getTypeEffectiveness(attackType: AttackType, defenseType: Piclet
   return TYPE_EFFECTIVENESS[attackType][defenseType];
 }
 
-export function getEffectivenessMultiplier(attackType: AttackType, defenseType: PicletType, secondaryType?: PicletType): number {
+export function getEffectivenessMultiplier(attackType: AttackType, defenseType: PicletType): number {
   console.log('🔍 Type effectiveness lookup:', {
     attackType,
-    defenseType, 
-    secondaryType,
+    defenseType,
     attackTypeValid: Object.values(AttackType).includes(attackType),
-    defenseTypeValid: Object.values(PicletType).includes(defenseType),
-    secondaryTypeValid: secondaryType ? Object.values(PicletType).includes(secondaryType) : 'N/A'
+    defenseTypeValid: Object.values(PicletType).includes(defenseType)
   });
   
-  let multiplier = getTypeEffectiveness(attackType, defenseType);
-  
-  if (secondaryType && secondaryType !== defenseType) {
-    multiplier *= getTypeEffectiveness(attackType, secondaryType);
-  }
-  
-  return multiplier;
+  return getTypeEffectiveness(attackType, defenseType);
 }
 
 export function getEffectivenessText(effectiveness: number): string {

src/lib/utils/battleConversion.ts

@@ -1,168 +0,0 @@
-/**
- * Conversion utilities for transforming database types to battle engine types
- */
-
-import type { PicletInstance } from '$lib/db/schema';
-import type { PicletDefinition, Move, BaseStats, SpecialAbility } from '$lib/battle-engine/types';
-import type { PicletStats } from '$lib/types';
-import { PicletType } from '$lib/types/picletTypes';
-import { recalculatePicletStats } from '$lib/services/levelingService';
-import { getUnlockedMoves, isSpecialAbilityUnlocked } from '$lib/services/unlockLevels';
-
-/**
- * Convert PicletInstance to PicletDefinition for battle engine use
- * Uses levelingService to ensure stats are properly calculated for current level
- */
-export function picletInstanceToBattleDefinition(instance: PicletInstance): PicletDefinition {
-  // First ensure stats are up-to-date for current level and nature
-  const updatedInstance = recalculatePicletStats(instance);
-  
-  // Use the calculated stats directly (no need for complex reverse formulas)
-  const baseStats: BaseStats = {
-    hp: updatedInstance.maxHp,        // Pokemon-calculated HP
-    attack: updatedInstance.attack,   // Includes level scaling and nature modifiers
-    defense: updatedInstance.defense, // Includes level scaling and nature modifiers  
-    speed: updatedInstance.speed      // Includes level scaling and nature modifiers
-  };
-
-  // Only include unlocked moves - BattleMove now contains complete Move data
-  const unlockedMoves = getUnlockedMoves(instance.moves, updatedInstance.level);
-  const movepool: Move[] = unlockedMoves.map(move => ({
-    name: move.name,
-    type: move.type,
-    power: move.power,
-    accuracy: move.accuracy,
-    pp: move.pp,
-    priority: move.priority,
-    flags: move.flags,
-    effects: move.effects
-  }));
-  
-  // Ensure at least two moves are available (first two moves should always be unlocked at level 1)
-  if (movepool.length === 0) {
-    console.warn(`Piclet ${instance.nickname} has no unlocked moves at level ${updatedInstance.level}!`);
-    // Emergency fallback - unlock first two moves
-    const movesToUnlock = Math.min(2, instance.moves.length);
-    for (let i = 0; i < movesToUnlock; i++) {
-      const move = instance.moves[i];
-      movepool.push({
-        name: move.name,
-        type: move.type,
-        power: move.power,
-        accuracy: move.accuracy,
-        pp: move.pp,
-        priority: move.priority,
-        flags: move.flags,
-        effects: move.effects
-      });
-    }
-  } else if (movepool.length === 1 && instance.moves.length > 1) {
-    // Ensure we have at least 2 moves if possible
-    const secondMove = instance.moves[1];
-    if (secondMove && secondMove.unlockLevel > updatedInstance.level) {
-      movepool.push({
-        name: secondMove.name,
-        type: secondMove.type,
-        power: secondMove.power,
-        accuracy: secondMove.accuracy,
-        pp: secondMove.pp,
-        priority: secondMove.priority,
-        flags: secondMove.flags,
-        effects: secondMove.effects
-      });
-    }
-  }
-
-  // All Piclets must now have special abilities
-  if (!instance.specialAbility) {
-    throw new Error('Piclet must have a special ability.');
-  }
-  
-  // Only include special ability if unlocked
-  let specialAbility: SpecialAbility | undefined;
-  if (isSpecialAbilityUnlocked(instance.specialAbilityUnlockLevel, updatedInstance.level)) {
-    specialAbility = instance.specialAbility;
-  } else {
-    // Create a placeholder ability for locked special abilities
-    specialAbility = {
-      name: "Locked Ability",
-      description: `Unlocks at level ${instance.specialAbilityUnlockLevel}`,
-      effects: []
-    };
-  }
-
-  // Determine tier based on BST (Base Stat Total)
-  const bst = baseStats.hp + baseStats.attack + baseStats.defense + baseStats.speed;
-  let tier: 'low' | 'medium' | 'high' | 'legendary';
-  if (bst <= 300) tier = 'low';
-  else if (bst <= 400) tier = 'medium';
-  else if (bst <= 500) tier = 'high';
-  else tier = 'legendary';
-
-  return {
-    name: instance.nickname || instance.typeId, // Keep original name - we'll add prefixes in battle engine
-    description: instance.concept,
-    tier,
-    primaryType: instance.primaryType,
-    secondaryType: instance.secondaryType,
-    baseStats,
-    nature: instance.nature,
-    specialAbility: specialAbility!,
-    movepool
-  };
-}
-
-
-
-/**
- * Convert battle engine BattlePiclet back to PicletInstance for state updates
- */
-export function battlePicletToInstance(battlePiclet: any, originalInstance: PicletInstance): PicletInstance {
-  return {
-    ...originalInstance,
-    currentHp: battlePiclet.currentHp,
-    level: battlePiclet.level,
-    attack: battlePiclet.attack,
-    defense: battlePiclet.defense,
-    speed: battlePiclet.speed,
-    // Update moves with current PP
-    moves: battlePiclet.moves.map((moveData: any, index: number) => ({
-      ...originalInstance.moves[index],
-      currentPp: moveData.currentPP
-    }))
-  };
-}
-
-/**
- * Convert PicletStats (from generation) to PicletDefinition for battle engine
- */
-export function picletStatsToBattleDefinition(stats: PicletStats, name: string, concept: string): PicletDefinition {
-  return {
-    name: stats.name || name,
-    description: stats.description || concept,
-    tier: stats.tier,
-    primaryType: stats.primaryType as PicletType,
-    secondaryType: stats.secondaryType as PicletType || undefined,
-    baseStats: stats.baseStats,
-    nature: stats.nature,
-    specialAbility: {
-      ...stats.specialAbility,
-      description: `Special ability of ${stats.name || name}` // Add description since it's removed from generation
-    } as any,
-    movepool: stats.movepool as any
-  };
-}
-
-/**
- * Strip internal battle prefixes from piclet names for display purposes
- * Removes "player-" and "enemy-" prefixes that are used internally for animation targeting
- */
-export function stripBattlePrefix(name: string): string {
-  if (name.startsWith('player-')) {
-    return name.substring('player-'.length);
-  }
-  if (name.startsWith('enemy-')) {
-    return name.substring('enemy-'.length);
-  }
-  return name;
-}