battle battle

src/lib/battle-engine/BattleEngine.ts

@@ -9,32 +9,70 @@ import type {
   PicletDefinition, 
   BattleAction, 
   MoveAction,
+  SwitchAction,
   BattleEffect,
   DamageAmount,
   StatModification,
   HealAmount,
   StatusEffect,
   BaseStats,
-  Move
+  Move,
+  Trigger
 } from './types';
 import { getEffectivenessMultiplier } from '../types/picletTypes';
 
 export class BattleEngine {
   private state: BattleState;
-
-  constructor(playerPiclet: PicletDefinition, opponentPiclet: PicletDefinition, playerLevel = 50, opponentLevel = 50) {
+  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
+    this.playerRoster = Array.isArray(playerPiclet) ? playerPiclet : [playerPiclet];
+    this.opponentRoster = Array.isArray(opponentPiclet) ? opponentPiclet : [opponentPiclet];
+    
+    // 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(playerPiclet, playerLevel),
-      opponentPiclet: this.createBattlePiclet(opponentPiclet, opponentLevel),
+      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');
+
     this.log('Battle started!');
-    this.log(`${playerPiclet.name} vs ${opponentPiclet.name}`);
+    this.log(`${this.playerRoster[0].name} vs ${this.opponentRoster[0].name}`);
+  }
+
+  private initializeRosterStates(roster: PicletDefinition[], level: number): Array<{ currentHp: number; maxHp: number; fainted: boolean; moves: Array<{move: Move; currentPP: number}> }> {
+    return roster.map(piclet => {
+      const statMultiplier = 1 + (level - 50) * 0.02;
+      const hp = Math.floor(piclet.baseStats.hp * statMultiplier);
+      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 {
@@ -112,6 +150,12 @@ export class BattleEngine {
       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();
 
@@ -183,13 +227,18 @@ export class BattleEngine {
     if (action.type === 'move') {
       this.executeMove(action);
     } else if (action.type === 'switch') {
-      this.log(`${action.executor} attempted to switch (not implemented)`);
+      this.executeSwitch(action as SwitchAction & { executor: 'player' | 'opponent' });
     }
   }
 
   private executeMove(action: MoveAction & { executor: 'player' | 'opponent' }): void {
     const attacker = action.executor === 'player' ? this.state.playerPiclet : this.state.opponentPiclet;
     const defender = action.executor === 'player' ? this.state.opponentPiclet : this.state.playerPiclet;
+    
+    // Check if attacker can act due to status effects
+    if (!this.canPicletAct(attacker)) {
+      return; // Skip this action
+    }
 
     const moveData = attacker.moves[action.moveIndex];
     if (!moveData || moveData.currentPP <= 0) {
@@ -198,17 +247,26 @@ export class BattleEngine {
     }
 
     const move = moveData.move;
+    
+    // Trigger before move use
+    this.triggerBeforeMoveUse(attacker, move);
+    
     this.log(`${attacker.definition.name} used ${move.name}!`);
 
     // Consume PP
     moveData.currentPP--;
 
     // Check if move hits
-    if (!this.checkMoveHits(move, attacker, defender)) {
+    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;
     
@@ -216,6 +274,127 @@ export class BattleEngine {
     for (const effect of move.effects) {
       this.processEffect(effect, attacker, defender, move, luckyRoll);
     }
+    
+    // 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 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 {
@@ -400,12 +579,20 @@ export class BattleEngine {
     // 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);
-    if (critMod === 'always' || (critMod === 'normal' && Math.random() < 0.0625)) { // 1/16 base crit rate
+    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
@@ -413,6 +600,14 @@ export class BattleEngine {
       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);
     }
@@ -423,6 +618,7 @@ export class BattleEngine {
       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));
@@ -544,30 +740,12 @@ export class BattleEngine {
         (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 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;
-    }
-
-    if (!target.statusEffects.includes(effect.status)) {
-      target.statusEffects.push(effect.status);
-      this.log(`${target.definition.name} was ${effect.status}ed!`);
-    }
-  }
 
   private processHealEffect(effect: { amount?: HealAmount; formula?: string; value?: number }, target: BattlePiclet): void {
     let healAmount = 0;
@@ -605,6 +783,7 @@ export class BattleEngine {
       
       if (actualHeal > 0) {
         this.log(`${target.definition.name} recovered ${actualHeal} HP!`);
+        this.triggerOnFullHP(target);
       }
     }
   }
@@ -644,16 +823,27 @@ export class BattleEngine {
     this.processStatusEffects(this.state.playerPiclet);
     this.processStatusEffects(this.state.opponentPiclet);
     
-    // Process field effects
+    // 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 {
-    for (const status of piclet.statusEffects) {
+    // 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':
@@ -661,7 +851,56 @@ export class BattleEngine {
           piclet.currentHp = Math.max(0, piclet.currentHp - damage);
           this.log(`${piclet.definition.name} was hurt by ${status}!`);
           break;
-        // Other status effects can be implemented later
+          
+        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);
       }
     }
   }
@@ -675,52 +914,209 @@ export class BattleEngine {
   }
 
   private processFieldEffects(): void {
-    // Process field effects at end of turn
-    for (const fieldEffect of this.state.fieldEffects) {
-      switch (fieldEffect.name) {
-        case 'spikes':
-          // Spikes damage any piclet that switches in (for now, just log)
-          this.log('Spikes are scattered on the battlefield!');
-          break;
-        case 'stealth_rock':
-          // Stealth Rock damages based on type effectiveness
-          this.log('Pointed stones float in the air!');
-          break;
-        case 'reflect':
-          // Reduce physical damage
-          this.log('A barrier reflects physical attacks!');
-          break;
-        case 'light_screen':
-          // Reduce special damage
-          this.log('A barrier weakens special attacks!');
-          break;
-      }
-    }
+    // Field effects are processed at end of turn for duration management
+    // Their actual mechanics are applied during relevant battle phases
     
-    // Decrement field effect durations
+    // Decrement field effect durations and remove expired ones
     this.state.fieldEffects = this.state.fieldEffects.filter(effect => {
       effect.duration--;
       if (effect.duration <= 0) {
-        this.log(`${effect.name} faded away!`);
+        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 {
-    if (this.state.playerPiclet.currentHp <= 0 && this.state.opponentPiclet.currentHp <= 0) {
+    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 (this.state.playerPiclet.currentHp <= 0) {
+    } else if (!playerHasViablePiclets) {
       this.state.winner = 'opponent';
       this.state.phase = 'ended';
       this.log(`${this.state.opponentPiclet.definition.name} wins!`);
-    } else if (this.state.opponentPiclet.currentHp <= 0) {
+    } else if (!opponentHasViablePiclets) {
       this.state.winner = 'player';
       this.state.phase = 'ended';
       this.log(`${this.state.playerPiclet.definition.name} wins!`);
+    } 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
+      }
     }
   }
 
@@ -784,34 +1180,50 @@ export class BattleEngine {
   }
 
   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: effect.effect,
+      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 !== effect.effect);
+      this.state.fieldEffects = this.state.fieldEffects.filter(fe => fe.name !== mappedName);
     }
     
     this.state.fieldEffects.push(fieldEffect);
-    switch (effect.effect) {
-      case 'spikes':
-        this.log('Spikes were set on the field!');
+    
+    // Log effect application with clear descriptions
+    switch (mappedName) {
+      case 'entryHazardSpikes':
+        this.log('Entry spikes were scattered on the battlefield!');
         break;
-      case 'reflect':
-        this.log('Reflect was applied to the field!');
+      case 'contactDamageReduction':
+        this.log('A barrier was raised to reduce contact move damage!');
         break;
-      case 'lightScreen':
-        this.log('Light Screen was applied to the field!');
+      case 'nonContactDamageReduction':
+        this.log('A barrier was raised to reduce non-contact move damage!');
         break;
-      case 'stealthRock':
-        this.log('Stealth Rock was applied to the field!');
+      case 'healingField':
+        this.log('A healing field was created!');
+        break;
+      case 'poisonousField':
+        this.log('A poisonous field was created!');
         break;
       default:
-        this.log(`${effect.effect.charAt(0).toUpperCase() + effect.effect.slice(1)} was applied to the field!`);
+        this.log(`${mappedName} was applied to the field!`);
     }
   }
 
@@ -989,4 +1401,265 @@ export class BattleEngine {
       }
     }
   }
+
+  // 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/ability-triggers.test.ts

@@ -1,681 +1,388 @@
-/**
- * Tests for special ability trigger system from the design document
- * Tests all the different trigger events and their implementations
- */
-
 import { describe, it, expect, beforeEach } from 'vitest';
 import { BattleEngine } from './BattleEngine';
-import { PicletDefinition, Move, SpecialAbility } from './types';
+import type { PicletDefinition, SpecialAbility } from './types';
 import { PicletType, AttackType } from './types';
 
-const STANDARD_STATS = { hp: 100, attack: 80, defense: 70, speed: 60 };
-
-describe('Special Ability Trigger System - TDD Implementation', () => {
-  describe('Damage Triggers', () => {
-    it('should handle onDamageTaken triggers', () => {
-      const berserkAbility: SpecialAbility = {
-        name: "Berserker",
-        description: "Attack increases when taking damage",
+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' }
-              }
-            ]
-          }
-        ]
-      };
-
-      const berserkerPiclet: PicletDefinition = {
-        name: "Rage Beast",
-        description: "Gets stronger when hurt",
-        tier: 'medium',
-        primaryType: PicletType.BEAST,
-        baseStats: STANDARD_STATS,
-        nature: "Brave",
-        specialAbility: berserkAbility,
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      expect(berserkAbility.triggers![0].event).toBe('onDamageTaken');
-    });
-
-    it('should handle onDamageDealt triggers', () => {
-      const lifeStealAbility: SpecialAbility = {
-        name: "Life Steal",
-        description: "Heals when dealing damage",
-        triggers: [
-          {
-            event: 'onDamageDealt',
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                amount: 'small'
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(lifeStealAbility.triggers![0].event).toBe('onDamageDealt');
-    });
-
-    it('should handle onContactDamage triggers', () => {
-      const toxicSkin: SpecialAbility = {
-        name: "Toxic Skin",
-        description: "Physical contact poisons the attacker",
-        triggers: [
-          {
-            event: 'onContactDamage',
-            effects: [
-              {
-                type: 'applyStatus',
-                target: 'attacker',
-                status: 'poison',
-                chance: 50
+                stats: {
+                  attack: 'increase'
+                }
               }
             ]
           }
         ]
-      };
-
-      expect(toxicSkin.triggers![0].event).toBe('onContactDamage');
-      expect(toxicSkin.triggers![0].effects[0].target).toBe('attacker');
-    });
+      },
+      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('Status Triggers', () => {
-    it('should handle onStatusInflicted triggers', () => {
-      const burnBoost: SpecialAbility = {
-        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' }
-              }
-            ]
-          }
-        ]
-      };
+  describe('onDamageTaken Trigger', () => {
+    it('should trigger when piclet takes damage', () => {
+      const engine = new BattleEngine(abilityPiclet, basicPiclet);
+      const initialAttack = engine.getState().playerPiclet.attack;
 
-      expect(burnBoost.triggers![0].event).toBe('onStatusInflicted');
-      expect(burnBoost.triggers![0].condition).toBe('ifStatus:burn');
-    });
+      // 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
+      );
 
-    it('should handle onStatusMove triggers', () => {
-      const statusReflect: SpecialAbility = {
-        name: "Status Shield",
-        description: "Reflects status moves back to user",
-        triggers: [
-          {
-            event: 'onStatusMove',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'targetRedirection',
-                value: 'reflect'
-              }
-            ]
-          }
-        ]
-      };
+      const finalAttack = engine.getState().playerPiclet.attack;
+      const log = engine.getLog();
 
-      expect(statusReflect.triggers![0].event).toBe('onStatusMove');
-    });
-
-    it('should handle onStatusMoveTargeted triggers', () => {
-      const statusCounter: SpecialAbility = {
-        name: "Status Counter",
-        description: "When targeted by status moves, counter with damage",
-        triggers: [
-          {
-            event: 'onStatusMoveTargeted',
-            effects: [
-              {
-                type: 'damage',
-                target: 'attacker',
-                formula: 'fixed',
-                value: 30
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(statusCounter.triggers![0].event).toBe('onStatusMoveTargeted');
+      // 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('Critical Hit Triggers', () => {
-    it('should handle onCriticalHit triggers', () => {
-      const criticalMomentum: SpecialAbility = {
-        name: "Critical Momentum",
-        description: "Critical hits increase speed",
-        triggers: [
-          {
-            event: 'onCriticalHit',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { speed: 'increase' }
-              }
-            ]
-          }
-        ]
+  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'
+                }
+              ]
+            }
+          ]
+        }
       };
 
-      expect(criticalMomentum.triggers![0].event).toBe('onCriticalHit');
+      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('HP Drain Triggers', () => {
-    it('should handle onHPDrained triggers', () => {
-      const drainPunish: SpecialAbility = {
-        name: "Drain Punishment",
-        description: "Damages opponents who try to drain HP",
-        triggers: [
-          {
-            event: 'onHPDrained',
-            effects: [
-              {
-                type: 'damage',
-                target: 'attacker',
-                formula: 'fixed',
-                value: 25
-              }
-            ]
-          }
-        ]
+  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'
+                  }
+                }
+              ]
+            }
+          ]
+        }
       };
 
-      expect(drainPunish.triggers![0].event).toBe('onHPDrained');
-    });
-  });
+      const engine = new BattleEngine(damageDealer, basicPiclet);
+      const initialSpeed = engine.getState().playerPiclet.speed;
 
-  describe('KO Triggers', () => {
-    it('should handle onKO triggers', () => {
-      const koBoost: SpecialAbility = {
-        name: "Victory Rush",
-        description: "Gets stronger after knocking out an opponent",
-        triggers: [
-          {
-            event: 'onKO',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'greatly_increase', speed: 'increase' }
-              }
-            ]
-          }
-        ]
-      };
+      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(koBoost.triggers![0].event).toBe('onKO');
+      expect(finalSpeed).toBeGreaterThan(initialSpeed);
+      expect(log.some(msg => msg.includes('Combat High') && msg.includes('triggered'))).toBe(true);
     });
   });
 
-  describe('Switch Triggers', () => {
-    it('should handle onSwitchIn triggers', () => {
-      const intimidate: SpecialAbility = {
-        name: "Intimidate",
-        description: "Lowers opponent's attack when entering battle",
-        triggers: [
-          {
-            event: 'onSwitchIn',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'opponent',
-                stats: { attack: 'decrease' }
-              }
-            ]
-          }
-        ]
+  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'
+                  }
+                }
+              ]
+            }
+          ]
+        }
       };
 
-      expect(intimidate.triggers![0].event).toBe('onSwitchIn');
-      expect(intimidate.triggers![0].effects[0].target).toBe('opponent');
-    });
+      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)
 
-    it('should handle onSwitchOut triggers', () => {
-      const regenerator: SpecialAbility = {
-        name: "Regenerator",
-        description: "Restores HP when switching out",
-        triggers: [
-          {
-            event: 'onSwitchOut',
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                amount: 'small'
-              }
-            ]
-          }
-        ]
-      };
+      const initialAttack = engine.getState().playerPiclet.attack;
 
-      expect(regenerator.triggers![0].event).toBe('onSwitchOut');
-    });
+      engine.executeActions(
+        { type: 'move', piclet: 'player', moveIndex: 0 }, // Should crit and trigger ability
+        { type: 'move', piclet: 'opponent', moveIndex: 0 }
+      );
 
-    it('should handle conditional switch-in triggers', () => {
-      const stormCaller: SpecialAbility = {
-        name: "Storm Caller",
-        description: "Boosts attack when entering during storm weather",
-        triggers: [
-          {
-            event: 'onSwitchIn',
-            condition: 'ifWeather:storm',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'increase' }
-              }
-            ]
-          }
-        ]
-      };
+      // Restore original Math.random
+      Math.random = originalRandom;
 
-      expect(stormCaller.triggers![0].condition).toBe('ifWeather:storm');
-    });
-  });
+      const finalAttack = engine.getState().playerPiclet.attack;
+      const log = engine.getLog();
 
-  describe('Weather Triggers', () => {
-    it('should handle onWeatherChange triggers', () => {
-      const weatherAdapt: SpecialAbility = {
-        name: "Weather Adaptation",
-        description: "Adapts stats based on weather changes",
-        triggers: [
-          {
-            event: 'onWeatherChange',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { speed: 'increase' }
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(weatherAdapt.triggers![0].event).toBe('onWeatherChange');
+      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('Move Use Triggers', () => {
-    it('should handle beforeMoveUse triggers', () => {
-      const movePrep: SpecialAbility = {
-        name: "Move Preparation",
-        description: "Boosts accuracy before using moves",
-        triggers: [
-          {
-            event: 'beforeMoveUse',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { accuracy: 'increase' }
-              }
-            ]
-          }
-        ]
+  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'
+                }
+              ]
+            }
+          ]
+        }
       };
 
-      expect(movePrep.triggers![0].event).toBe('beforeMoveUse');
-    });
+      const engine = new BattleEngine(contactSensitive, basicPiclet);
+      const initialOpponentHp = engine.getState().opponentPiclet.currentHp;
 
-    it('should handle afterMoveUse triggers', () => {
-      const moveRecovery: SpecialAbility = {
-        name: "Move Recovery",
-        description: "Heals slightly after using any move",
-        triggers: [
-          {
-            event: 'afterMoveUse',
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                formula: 'fixed',
-                value: 5
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(moveRecovery.triggers![0].event).toBe('afterMoveUse');
-    });
-  });
-
-  describe('HP Threshold Triggers', () => {
-    it('should handle onLowHP triggers', () => {
-      const emergencyMode: SpecialAbility = {
-        name: "Emergency Mode",
-        description: "Activates emergency protocols when HP is low",
-        triggers: [
-          {
-            event: 'onLowHP',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { speed: 'greatly_increase', attack: 'increase' }
-              },
-              {
-                type: 'mechanicOverride',
-                mechanic: 'statusImmunity',
-                value: ['burn', 'poison', 'paralyze']
-              }
-            ]
-          }
-        ]
-      };
+      engine.executeActions(
+        { type: 'move', piclet: 'player', moveIndex: 0 },
+        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Contact move should trigger Spiky Skin
+      );
 
-      expect(emergencyMode.triggers![0].event).toBe('onLowHP');
-      expect(emergencyMode.triggers![0].effects).toHaveLength(2);
-    });
-
-    it('should handle onFullHP triggers', () => {
-      const fullPower: SpecialAbility = {
-        name: "Full Power",
-        description: "Maximum power when at full health",
-        triggers: [
-          {
-            event: 'onFullHP',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'greatly_increase' }
-              }
-            ]
-          }
-        ]
-      };
+      const finalOpponentHp = engine.getState().opponentPiclet.currentHp;
+      const log = engine.getLog();
 
-      expect(fullPower.triggers![0].event).toBe('onFullHP');
+      // 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('Turn-Based Triggers', () => {
-    it('should handle endOfTurn triggers', () => {
-      const turnRegeneration: SpecialAbility = {
-        name: "Slow Regeneration",
-        description: "Heals at the end of each turn",
-        triggers: [
-          {
-            event: 'endOfTurn',
-            effects: [
-              {
-                type: 'heal',
-                target: 'self',
-                formula: 'percentage',
-                value: 10
-              }
-            ]
-          }
-        ]
+  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'
+                  }
+                }
+              ]
+            }
+          ]
+        }
       };
 
-      expect(turnRegeneration.triggers![0].event).toBe('endOfTurn');
-    });
+      const engine = new BattleEngine(conditionalAbility, basicPiclet);
+      const initialAttack = engine.getState().playerPiclet.attack;
 
-    it('should handle conditional turn triggers', () => {
-      const sleepHeal: SpecialAbility = {
-        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',
-                formula: 'percentage',
-                value: 15
-              }
-            ]
-          }
-        ]
-      };
+      // At high HP, condition should not be met
+      engine.executeActions(
+        { type: 'move', piclet: 'player', moveIndex: 0 },
+        { type: 'move', piclet: 'opponent', moveIndex: 0 }
+      );
 
-      expect(sleepHeal.triggers![0].condition).toBe('ifStatus:sleep');
-    });
-  });
+      const midAttack = engine.getState().playerPiclet.attack;
+      expect(midAttack).toBe(initialAttack); // No trigger due to condition
 
-  describe('Opponent Move Triggers', () => {
-    it('should handle onOpponentContactMove triggers', () => {
-      const contactPunish: SpecialAbility = {
-        name: "Contact Punishment",
-        description: "Damages opponents who use contact moves",
-        triggers: [
-          {
-            event: 'onOpponentContactMove',
-            effects: [
-              {
-                type: 'damage',
-                target: 'attacker',
-                formula: 'fixed',
-                value: 15
-              }
-            ]
-          }
-        ]
-      };
+      // 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);
 
-      expect(contactPunish.triggers![0].event).toBe('onOpponentContactMove');
-    });
+      lowHpEngine.executeActions(
+        { type: 'move', piclet: 'player', moveIndex: 0 },
+        { type: 'move', piclet: 'opponent', moveIndex: 0 }
+      );
 
-    it('should handle wind currents ability from design doc', () => {
-      const windCurrents: SpecialAbility = {
-        name: "Wind Currents",
-        description: "Gains +25% speed when opponent uses a contact move",
-        triggers: [
-          {
-            event: 'onOpponentContactMove',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { speed: 'increase' }
-              }
-            ]
-          }
-        ]
-      };
+      const finalAttack = lowHpEngine.getState().playerPiclet.attack;
+      const log = lowHpEngine.getLog();
 
-      const zephyrSprite: PicletDefinition = {
-        name: "Zephyr Sprite",
-        description: "A mysterious floating creature that manipulates wind currents",
-        tier: 'medium',
-        primaryType: PicletType.SPACE,
-        baseStats: { hp: 65, attack: 85, defense: 40, speed: 90 },
-        nature: "hasty",
-        specialAbility: windCurrents,
-        movepool: [{
-          name: "Tackle", type: AttackType.NORMAL, power: 40, accuracy: 100, pp: 35,
-          priority: 0, flags: [], effects: [{ type: 'damage', target: 'opponent', amount: 'normal' }]
-        }]
-      };
-
-      expect(windCurrents.triggers![0].event).toBe('onOpponentContactMove');
-      expect(zephyrSprite.specialAbility.name).toBe('Wind Currents');
+      expect(finalAttack).toBeGreaterThan(initialAttack);
+      expect(log.some(msg => msg.includes('Desperation') && msg.includes('triggered'))).toBe(true);
     });
   });
 
-  describe('Complex Multi-Trigger Abilities', () => {
-    it('should handle abilities with multiple triggers', () => {
-      const complexAbility: SpecialAbility = {
-        name: "Adaptive Guardian",
-        description: "Complex ability with multiple trigger conditions",
-        triggers: [
-          {
-            event: 'onSwitchIn',
-            effects: [
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { defense: 'increase' }
-              }
-            ]
-          },
-          {
-            event: 'onDamageTaken',
-            condition: 'ifLowHp',
-            effects: [
-              {
-                type: 'mechanicOverride',
-                mechanic: 'damageReflection',
-                value: 0.3
-              }
-            ]
-          },
-          {
-            event: 'endOfTurn',
-            condition: 'ifStatus:burn',
-            effects: [
-              {
-                type: 'removeStatus',
-                target: 'self',
-                status: 'burn'
-              },
-              {
-                type: 'modifyStats',
-                target: 'self',
-                stats: { attack: 'increase' }
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(complexAbility.triggers).toHaveLength(3);
-      expect(complexAbility.triggers![1].condition).toBe('ifLowHp');
-      expect(complexAbility.triggers![2].effects).toHaveLength(2);
-    });
-  });
-
-  describe('Status-Specific Ability Examples', () => {
-    it('should handle Glacial Birth - starts battle frozen', () => {
-      const glacialBirth: SpecialAbility = {
-        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'
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(glacialBirth.triggers![0].effects[0].status).toBe('freeze');
-      expect(glacialBirth.triggers![0].effects[1].condition).toBe('whileFrozen');
-    });
-
-    it('should handle Cryogenic Touch - freezes on contact', () => {
-      const cryogenicTouch: SpecialAbility = {
-        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
-              }
-            ]
-          }
-        ]
+  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'
+                  }
+                }
+              ]
+            }
+          ]
+        }
       };
 
-      expect(cryogenicTouch.triggers![0].effects[0].chance).toBe(30);
-    });
+      const engine = new BattleEngine(multiTriggerAbility, basicPiclet);
+      const initialAttack = engine.getState().playerPiclet.attack;
+      const initialDefense = engine.getState().playerPiclet.defense;
 
-    it('should handle Paralytic Aura - paralyzes on entry', () => {
-      const paralyticAura: SpecialAbility = {
-        name: "Paralytic Aura",
-        description: "Intimidating presence paralyzes the opponent upon entry",
-        triggers: [
-          {
-            event: 'onSwitchIn',
-            effects: [
-              {
-                type: 'applyStatus',
-                target: 'opponent',
-                status: 'paralyze',
-                chance: 75
-              }
-            ]
-          }
-        ]
-      };
-
-      expect(paralyticAura.triggers![0].effects[0].target).toBe('opponent');
-      expect(paralyticAura.triggers![0].effects[0].chance).toBe(75);
-    });
+      engine.executeActions(
+        { type: 'move', piclet: 'player', moveIndex: 0 }, // Should trigger onDamageDealt
+        { type: 'move', piclet: 'opponent', moveIndex: 0 } // Should trigger onDamageTaken
+      );
 
-    it('should handle Confusion Clarity - team status removal', () => {
-      const confusionClarity: SpecialAbility = {
-        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'
-              }
-            ]
-          }
-        ]
-      };
+      const finalAttack = engine.getState().playerPiclet.attack;
+      const finalDefense = engine.getState().playerPiclet.defense;
+      const log = engine.getLog();
 
-      expect(confusionClarity.effects![0].value).toContain('confuse');
-      expect(confusionClarity.triggers![0].effects[0].target).toBe('allies');
+      // 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-status-effects.test.ts

@@ -0,0 +1,369 @@
+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

@@ -0,0 +1,101 @@
+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/field-effects.test.ts

@@ -0,0 +1,493 @@
+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/remaining-triggers.test.ts

@@ -0,0 +1,363 @@
+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

@@ -0,0 +1,445 @@
+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/types.ts

@@ -157,7 +157,8 @@ export interface Trigger {
   event: 'onDamageTaken' | 'onDamageDealt' | 'onContactDamage' | 'onStatusInflicted' 
         | 'onStatusMove' | 'onStatusMoveTargeted' | 'onCriticalHit' | 'onHPDrained' 
         | 'onKO' | 'onSwitchIn' | 'onSwitchOut' | 'onWeatherChange' | 'beforeMoveUse' 
-        | 'afterMoveUse' | 'onLowHP' | 'onFullHP' | 'endOfTurn' | 'onOpponentContactMove';
+        | 'afterMoveUse' | 'onLowHP' | 'onFullHP' | 'endOfTurn' | 'onOpponentContactMove'
+        | 'onStatChange' | 'onTypeChange';
   condition?: EffectCondition;
   effects: BattleEffect[];
 }