EZ

src/lib/components/Pages/Battle.svelte

@@ -349,12 +349,17 @@
     const playerName = stripBattlePrefix(battleState?.playerPiclet?.definition?.name || '');
     const enemyName = stripBattlePrefix(battleState?.opponentPiclet?.definition?.name || '');
     
+    // Track who is the current attacker for effects that should appear on the defender
+    let currentAttacker: 'player' | 'enemy' | null = null;
+    
     // Attack lunge effects - trigger immediately when a Piclet uses a move
     if (message.includes(' used ')) {
       if (message.includes(playerName)) {
         triggerLungeAnimation('player');
+        currentAttacker = 'player';
       } else if (message.includes(enemyName)) {
         triggerLungeAnimation('enemy');
+        currentAttacker = 'enemy';
       }
     }
     
@@ -369,16 +374,31 @@
       }
     }
     
-    // Critical hit effects
+    // Critical hit effects - show on the target that was hit
     if (message.includes('critical hit')) {
-      triggerEffect('both', 'critical', '💥', 1000);
+      // Critical hits appear after damage, so check who took damage
+      const target = message.includes(`${enemyName} took`) ? 'enemy' : 
+                    message.includes(`${playerName} took`) ? 'player' :
+                    // Fallback: if player used move, enemy is target and vice versa
+                    message.includes(`${playerName} used`) ? 'enemy' : 'player';
+      triggerEffect(target, 'critical', '💥', 1000);
     }
     
-    // Effectiveness messages
+    // Effectiveness messages - show on the target that was hit
     if (message.includes("It's super effective")) {
-      triggerEffect('both', 'superEffective', '⚡', 800);
+      // Super effective appears after the move, determine target based on attacker
+      const target = message.includes(`${playerName} used`) ? 'enemy' : 
+                    message.includes(`${enemyName} used`) ? 'player' :
+                    // Fallback based on damage message
+                    message.includes(`${enemyName} took`) ? 'enemy' : 'player';
+      triggerEffect(target, 'superEffective', '⚡', 800);
     } else if (message.includes("not very effective")) {
-      triggerEffect('both', 'notVeryEffective', '💨', 800);
+      // Not very effective appears after the move, determine target based on attacker
+      const target = message.includes(`${playerName} used`) ? 'enemy' : 
+                    message.includes(`${enemyName} used`) ? 'player' :
+                    // Fallback based on damage message
+                    message.includes(`${enemyName} took`) ? 'enemy' : 'player';
+      triggerEffect(target, 'notVeryEffective', '💨', 800);
     }
     
     // Status effects
@@ -423,9 +443,12 @@
       updateUIFromBattleState();
     }
     
-    // Miss effects
+    // Miss effects - show on the attacker who missed
     if (message.includes('missed')) {
-      triggerEffect('both', 'miss', '💫', 800);
+      const target = message.includes(`${playerName}'s attack`) || message.includes(`${playerName} used`) ? 'player' : 
+                    message.includes(`${enemyName}'s attack`) || message.includes(`${enemyName} used`) ? 'enemy' : 
+                    'player'; // Fallback
+      triggerEffect(target, 'miss', '💫', 800);
     }
     
     // Faint effects - only trigger when we see the faint message from battle log

src/lib/services/unlockLevels.ts

@@ -7,40 +7,28 @@ import type { SpecialAbility } from '$lib/battle-engine/types';
 
 /**
  * Calculate unlock level for a move based on its power and characteristics
- * More powerful moves unlock later, with some randomness
+ * First 2 moves are always unlocked, moves 3-4 unlock at levels 9-14
  */
 export function calculateMoveUnlockLevel(move: BattleMove, moveIndex: number): number {
-  // Base unlock level based on power
-  let baseLevel = 1;
-  
-  if (move.power === 0) {
-    // Status/support moves - unlock early to mid game
-    baseLevel = Math.floor(Math.random() * 20) + 5; // Level 5-25
-  } else if (move.power <= 40) {
-    // Weak moves - unlock early
-    baseLevel = Math.floor(Math.random() * 15) + 1; // Level 1-15
-  } else if (move.power <= 60) {
-    // Medium moves - unlock early to mid
-    baseLevel = Math.floor(Math.random() * 25) + 10; // Level 10-35
-  } else if (move.power <= 80) {
-    // Strong moves - unlock mid to late
-    baseLevel = Math.floor(Math.random() * 30) + 25; // Level 25-55
-  } else {
-    // Very powerful moves - unlock late
-    baseLevel = Math.floor(Math.random() * 25) + 40; // Level 40-65
+  // First two moves are always available at level 1
+  if (moveIndex === 0 || moveIndex === 1) {
+    return 1;
   }
   
-  // Adjust based on move position (later moves tend to be more powerful)
-  const positionBonus = moveIndex * 5; // 0, 5, 10, 15 for moves 1-4
-  baseLevel += positionBonus;
+  // Third and fourth moves unlock at levels 9-14
+  if (moveIndex === 2) {
+    // Third move unlocks between level 9-11
+    return Math.floor(Math.random() * 3) + 9; // Level 9, 10, or 11
+  }
   
-  // Ensure first move is always available at level 1
-  if (moveIndex === 0) {
-    baseLevel = 1;
+  if (moveIndex === 3) {
+    // Fourth move unlocks between level 12-14
+    return Math.floor(Math.random() * 3) + 12; // Level 12, 13, or 14
   }
   
-  // Cap at level 80 (everything must be unlocked by then)
-  return Math.min(baseLevel, 80);
+  // For any additional moves beyond the 4th (shouldn't normally happen)
+  // They unlock at higher levels
+  return 15 + (moveIndex - 4) * 5;
 }
 
 /**

src/lib/utils/battleConversion.ts

@@ -38,21 +38,37 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
     effects: move.effects
   }));
   
-  // Ensure at least one move is available (first move should always be unlocked at level 1)
+  // Ensure at least two moves are available (first two moves should always be unlocked at level 1)
   if (movepool.length === 0) {
     console.warn(`Piclet ${instance.nickname} has no unlocked moves at level ${updatedInstance.level}!`);
-    // Emergency fallback - unlock first move
-    if (instance.moves.length > 0) {
-      const firstMove = instance.moves[0];
+    // Emergency fallback - unlock first two moves
+    const movesToUnlock = Math.min(2, instance.moves.length);
+    for (let i = 0; i < movesToUnlock; i++) {
+      const move = instance.moves[i];
       movepool.push({
-        name: firstMove.name,
-        type: firstMove.type,
-        power: firstMove.power,
-        accuracy: firstMove.accuracy,
-        pp: firstMove.pp,
-        priority: firstMove.priority,
-        flags: firstMove.flags,
-        effects: firstMove.effects
+        name: move.name,
+        type: move.type,
+        power: move.power,
+        accuracy: move.accuracy,
+        pp: move.pp,
+        priority: move.priority,
+        flags: move.flags,
+        effects: move.effects
+      });
+    }
+  } else if (movepool.length === 1 && instance.moves.length > 1) {
+    // Ensure we have at least 2 moves if possible
+    const secondMove = instance.moves[1];
+    if (secondMove && secondMove.unlockLevel > updatedInstance.level) {
+      movepool.push({
+        name: secondMove.name,
+        type: secondMove.type,
+        power: secondMove.power,
+        accuracy: secondMove.accuracy,
+        pp: secondMove.pp,
+        priority: secondMove.priority,
+        flags: secondMove.flags,
+        effects: secondMove.effects
       });
     }
   }