pre ide

src/lib/battle-engine/BattleEngine.ts

@@ -310,6 +310,19 @@ export class BattleEngine {
   private processDamageEffect(effect: { amount?: DamageAmount; formula?: string; value?: number; multiplier?: number }, attacker: BattlePiclet, target: BattlePiclet, move: Move): void {
     let damage = 0;
 
+    // Check type immunity first
+    if (this.checkTypeImmunity(target, move.type)) {
+      this.log(`${target.definition.name} is immune to ${move.type} type moves!`);
+      return;
+    }
+
+    // Check flag interactions
+    const flagInteraction = this.checkFlagInteraction(target, move.flags);
+    if (flagInteraction === 'immune') {
+      this.log(`${target.definition.name} is immune to this move!`);
+      return;
+    }
+
     // Handle different damage formulas
     if (effect.formula) {
       damage = this.calculateDamageByFormula(effect, attacker, target, move);
@@ -317,6 +330,26 @@ export class BattleEngine {
       damage = this.calculateStandardDamage(effect.amount, attacker, target, move);
     }
 
+    // Apply flag interaction modifiers
+    if (flagInteraction === 'weak') {
+      damage = Math.floor(damage * 1.5);
+      this.log("It's super effective!");
+    } else if (flagInteraction === 'resist') {
+      damage = Math.floor(damage * 0.5);
+      this.log("It's not very effective...");
+    }
+
+    // Apply damage multiplier from abilities
+    const damageMultiplier = this.getDamageMultiplier(attacker);
+    damage = Math.floor(damage * damageMultiplier);
+
+    // Check for critical hits
+    const critMod = this.checkCriticalHitModification(attacker, target);
+    if (critMod === 'always' || (critMod === 'normal' && Math.random() < 0.0625)) { // 1/16 base crit rate
+      damage = Math.floor(damage * 1.5);
+      this.log("A critical hit!");
+    }
+
     // Apply damage
     if (damage > 0) {
       target.currentHp = Math.max(0, target.currentHp - damage);
@@ -420,6 +453,12 @@ export class BattleEngine {
       }
     }
 
+    // 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!`);
@@ -590,8 +629,86 @@ export class BattleEngine {
   }
 
   private processMechanicOverrideEffect(effect: { mechanic: string; value: any; condition?: string }, target: BattlePiclet): void {
-    // Store mechanic override for processing
-    // This is a placeholder - full implementation would be complex
+    // Store mechanic override as temporary effect for processing during relevant calculations
+    target.temporaryEffects.push({
+      effect: { 
+        type: 'mechanicOverride',
+        mechanic: effect.mechanic,
+        value: effect.value,
+        condition: effect.condition,
+        target: 'self'
+      } as any,
+      duration: effect.condition === 'restOfBattle' ? 999 : 1
+    });
+    
     this.log(`Mechanic override '${effect.mechanic}' applied to ${target.definition.name}!`);
   }
+
+  // Helper methods for checking mechanic overrides
+  private hasMechanicOverride(piclet: BattlePiclet, mechanic: string): any {
+    const override = piclet.temporaryEffects.find(
+      effect => effect.effect.type === 'mechanicOverride' && 
+                (effect.effect as any).mechanic === mechanic
+    );
+    return override ? (override.effect as any).value : null;
+  }
+
+  private checkCriticalHitModification(attacker: BattlePiclet, target: BattlePiclet): 'always' | 'never' | 'normal' {
+    // Check attacker's critical hit modifiers
+    const attackerOverride = this.hasMechanicOverride(attacker, 'criticalHits');
+    if (attackerOverride === true) return 'always';
+    
+    // Check target's critical hit immunity
+    const targetOverride = this.hasMechanicOverride(target, 'criticalHits');
+    if (targetOverride === false) return 'never';
+    
+    return 'normal';
+  }
+
+  private checkStatusImmunity(target: BattlePiclet, status: string): boolean {
+    const immunity = this.hasMechanicOverride(target, 'statusImmunity');
+    if (Array.isArray(immunity)) {
+      return immunity.includes(status);
+    }
+    return false;
+  }
+
+  private checkTypeImmunity(target: BattlePiclet, attackType: string): boolean {
+    const immunity = this.hasMechanicOverride(target, 'typeImmunity');
+    if (Array.isArray(immunity)) {
+      return immunity.includes(attackType);
+    }
+    return false;
+  }
+
+  private checkFlagInteraction(target: BattlePiclet, flags: string[]): 'immune' | 'weak' | 'resist' | 'normal' {
+    // Check immunities first
+    const immunity = this.hasMechanicOverride(target, 'flagImmunity');
+    if (Array.isArray(immunity) && flags.some(flag => immunity.includes(flag))) {
+      return 'immune';
+    }
+    
+    // Check weaknesses
+    const weakness = this.hasMechanicOverride(target, 'flagWeakness');
+    if (Array.isArray(weakness) && flags.some(flag => weakness.includes(flag))) {
+      return 'weak';
+    }
+    
+    // Check resistances
+    const resistance = this.hasMechanicOverride(target, 'flagResistance');
+    if (Array.isArray(resistance) && flags.some(flag => resistance.includes(flag))) {
+      return 'resist';
+    }
+    
+    return 'normal';
+  }
+
+  private getDamageMultiplier(piclet: BattlePiclet): number {
+    const multiplier = this.hasMechanicOverride(piclet, 'damageMultiplier');
+    return typeof multiplier === 'number' ? multiplier : 1.0;
+  }
+
+  private shouldInvertHealing(target: BattlePiclet): boolean {
+    return !!this.hasMechanicOverride(target, 'healingInversion');
+  }
 }

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

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

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

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

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

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

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

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