battling

src/lib/components/Battle/ActionButtons.svelte

@@ -2,6 +2,7 @@
   import ActionViewSelector, { type ActionView } from './ActionViewSelector.svelte';
   import type { PicletInstance, BattleMove } from '$lib/db/schema';
   import type { BattleState } from '$lib/battle-engine/types';
+  import { getUnlockedMoves } from '$lib/services/unlockLevels';
   
   export let isWildBattle: boolean;
   export let playerPiclet: PicletInstance;
@@ -15,6 +16,9 @@
   
   let currentView: ActionView = 'main';
   
+  // Only show unlocked moves in battle
+  $: unlockedMoves = getUnlockedMoves(playerPiclet.moves, playerPiclet.level);
+  
   function handleViewChange(view: ActionView) {
     currentView = view;
   }
@@ -44,7 +48,7 @@
   <ActionViewSelector 
     {currentView}
     onViewChange={handleViewChange}
-    moves={playerPiclet.moves}
+    moves={unlockedMoves}
     {availablePiclets}
     {enemyPiclet}
     {isWildBattle}

src/lib/components/Pages/Battle.svelte

@@ -160,21 +160,13 @@
     };
     
     try {
-      // Choose random enemy move (could be improved with AI)
-      const availableEnemyMoves = battleState.opponentPiclet.moves.filter(m => m.currentPP > 0);
-      if (availableEnemyMoves.length === 0) {
-        currentMessage = `${currentEnemyPiclet.nickname} has no moves left!`;
+      // Select enemy move (wild Piclets always random, trainers could use AI)
+      const enemyAction = selectEnemyMove();
+      if (!enemyAction) {
         processingTurn = false;
         return;
       }
       
-      const randomEnemyMove = availableEnemyMoves[Math.floor(Math.random() * availableEnemyMoves.length)];
-      const enemyMoveIndex = battleState.opponentPiclet.moves.indexOf(randomEnemyMove);
-      const enemyAction: MoveAction = {
-        type: 'move', 
-        moveIndex: enemyMoveIndex
-      };
-      
       // Get log entries before action to track new messages
       const logBefore = battleEngine.getLog();
       
@@ -412,6 +404,35 @@
     }, 500); // Allow time for typewriter text to complete
   }
   
+  function selectEnemyMove(): MoveAction | null {
+    const availableEnemyMoves = battleState.opponentPiclet.moves.filter(m => m.currentPP > 0);
+    
+    if (availableEnemyMoves.length === 0) {
+      currentMessage = `${currentEnemyPiclet.nickname} has no moves left!`;
+      return null;
+    }
+    
+    if (isWildBattle) {
+      // Wild Piclets always use completely random moves (no trainer strategy)
+      const randomEnemyMove = availableEnemyMoves[Math.floor(Math.random() * availableEnemyMoves.length)];
+      const enemyMoveIndex = battleState.opponentPiclet.moves.indexOf(randomEnemyMove);
+      
+      return {
+        type: 'move', 
+        moveIndex: enemyMoveIndex
+      };
+    } else {
+      // Trainer battles - currently also random, but could be enhanced with AI later
+      const randomEnemyMove = availableEnemyMoves[Math.floor(Math.random() * availableEnemyMoves.length)];
+      const enemyMoveIndex = battleState.opponentPiclet.moves.indexOf(randomEnemyMove);
+      
+      return {
+        type: 'move', 
+        moveIndex: enemyMoveIndex
+      };
+    }
+  }
+
   function handleContinueTap() {
     if (!waitingForContinue || !messageQueue.length) return;
     
@@ -496,21 +517,13 @@
     };
     
     try {
-      // Choose random enemy move (AI continues to act)
-      const availableEnemyMoves = battleState.opponentPiclet.moves.filter(m => m.currentPP > 0);
-      if (availableEnemyMoves.length === 0) {
-        currentMessage = `${currentEnemyPiclet.nickname} has no moves left!`;
+      // Select enemy move (wild Piclets always random, trainers could use AI)
+      const enemyAction = selectEnemyMove();
+      if (!enemyAction) {
         processingTurn = false;
         return;
       }
       
-      const randomEnemyMove = availableEnemyMoves[Math.floor(Math.random() * availableEnemyMoves.length)];
-      const enemyMoveIndex = battleState.opponentPiclet.moves.indexOf(randomEnemyMove);
-      const enemyAction: MoveAction = {
-        type: 'move', 
-        moveIndex: enemyMoveIndex
-      };
-      
       // Allow time for the visual switch to be seen before processing the turn
       setTimeout(() => {
         // Get log entries before action to track new messages

src/lib/components/Piclets/PicletDetail.svelte

@@ -9,6 +9,7 @@
   import MoveDisplay from './MoveDisplay.svelte';
   import { picletInstanceToBattleDefinition } from '$lib/utils/battleConversion';
   import { recalculatePicletStats, getXpProgress, getXpTowardsNextLevel } from '$lib/services/levelingService';
+  import { isSpecialAbilityUnlocked } from '$lib/services/unlockLevels';
   
   interface Props {
     instance: PicletInstance;
@@ -240,20 +241,46 @@
         {:else if selectedTab === 'abilities'}
           <div class="content-card">
             <h3 class="section-heading">Special Ability</h3>
-            <AbilityDisplay 
-              ability={battleDefinition.specialAbility}
-              expanded={true}
-            />
+            {#if isSpecialAbilityUnlocked(updatedInstance.specialAbilityUnlockLevel, updatedInstance.level)}
+              <AbilityDisplay 
+                ability={updatedInstance.specialAbility}
+                expanded={true}
+              />
+            {:else}
+              <div class="locked-ability">
+                <div class="lock-header">
+                  <span class="lock-icon">🔒</span>
+                  <span class="lock-text">Unlocks at Level {updatedInstance.specialAbilityUnlockLevel}</span>
+                </div>
+                <div class="locked-content">
+                  <h4>{updatedInstance.specialAbility.name}</h4>
+                  <p>This special ability will be unlocked when {updatedInstance.nickname} reaches level {updatedInstance.specialAbilityUnlockLevel}.</p>
+                </div>
+              </div>
+            {/if}
             
             <div class="divider"></div>
             
             <h3 class="section-heading">Moves</h3>
             <div class="moves-list">
               {#each updatedInstance.moves as move, index}
-                <MoveDisplay 
-                  {move}
-                  expanded={true}
-                />
+                {#if move.unlockLevel <= updatedInstance.level}
+                  <MoveDisplay 
+                    {move}
+                    expanded={true}
+                  />
+                {:else}
+                  <div class="locked-move">
+                    <div class="lock-header">
+                      <span class="lock-icon">🔒</span>
+                      <span class="lock-text">Unlocks at Level {move.unlockLevel}</span>
+                    </div>
+                    <div class="locked-content">
+                      <h4>{move.name}</h4>
+                      <p>This move will be unlocked when {updatedInstance.nickname} reaches level {move.unlockLevel}.</p>
+                    </div>
+                  </div>
+                {/if}
               {/each}
             </div>
           </div>
@@ -547,6 +574,50 @@
     gap: 4px;
   }
   
+  /* Locked content styles */
+  .locked-ability,
+  .locked-move {
+    background: #f8f9fa;
+    border: 1px dashed #dee2e6;
+    border-radius: 8px;
+    padding: 12px;
+    margin-bottom: 8px;
+    opacity: 0.7;
+  }
+  
+  .lock-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+  }
+  
+  .lock-icon {
+    font-size: 16px;
+  }
+  
+  .lock-text {
+    font-size: 12px;
+    font-weight: 600;
+    color: #6c757d;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+  }
+  
+  .locked-content h4 {
+    margin: 0 0 4px 0;
+    font-size: 16px;
+    font-weight: 600;
+    color: #495057;
+  }
+  
+  .locked-content p {
+    margin: 0;
+    font-size: 14px;
+    color: #6c757d;
+    font-style: italic;
+  }
+  
   /* Level and Status Section */
   .level-xp-section {
     background: white;

src/lib/db/piclets.ts

@@ -2,6 +2,7 @@ import { db } from './index';
 import type { PicletInstance, Monster, BattleMove } from './schema';
 import { PicletType, AttackType, getTypeFromConcept } from '../types/picletTypes';
 import type { PicletStats } from '../types';
+import { generateUnlockLevels } from '../services/unlockLevels';
 
 // Convert a generated Monster to a PicletInstance
 export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
@@ -31,17 +32,22 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
   }
 
-  // Create moves from battle-ready format
-  const moves: BattleMove[] = stats.movepool.map(move => ({
+  // Create moves from battle-ready format (without unlock levels initially)
+  const baseMoves: BattleMove[] = stats.movepool.map(move => ({
     name: move.name,
     type: move.type as unknown as AttackType,
     power: move.power,
     accuracy: move.accuracy,
     pp: move.pp,
     currentPp: move.pp,
-    description: move.description
+    description: move.description,
+    unlockLevel: 1 // Temporary, will be set below
   }));
   
+  // Generate unlock levels for moves and special ability
+  const { movesWithUnlocks, abilityUnlockLevel } = generateUnlockLevels(baseMoves, stats.specialAbility);
+  const moves = movesWithUnlocks;
+  
   // Field stats are variations of regular stats
   const baseFieldAttack = Math.floor(baseAttack * 0.8);
   const baseFieldDefense = Math.floor(baseDefense * 0.8);
@@ -96,6 +102,7 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     moves,
     nature: stats.nature,
     specialAbility: stats.specialAbility,
+    specialAbilityUnlockLevel: abilityUnlockLevel,
     
     // Roster
     isInRoster: false,

src/lib/db/schema.ts

@@ -18,6 +18,7 @@ export interface BattleMove {
   pp: number;
   currentPp: number;
   description: string;
+  unlockLevel: number; // Level at which this move is unlocked
 }
 
 // PicletInstance - Individual monster instances owned by the player
@@ -53,6 +54,7 @@ export interface PicletInstance {
   moves: BattleMove[];
   nature: string;
   specialAbility: SpecialAbility;
+  specialAbilityUnlockLevel: number; // Level at which special ability is unlocked
   
   // Roster
   isInRoster: boolean;

src/lib/services/unlockLevels.ts

@@ -0,0 +1,131 @@
+/**
+ * Utility functions for calculating unlock levels for moves and abilities
+ */
+
+import type { BattleMove } from '$lib/db/schema';
+import type { SpecialAbility } from '$lib/battle-engine/types';
+
+/**
+ * Calculate unlock level for a move based on its power and characteristics
+ * More powerful moves unlock later, with some randomness
+ */
+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
+  }
+  
+  // 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;
+  
+  // Ensure first move is always available at level 1
+  if (moveIndex === 0) {
+    baseLevel = 1;
+  }
+  
+  // Cap at level 80 (everything must be unlocked by then)
+  return Math.min(baseLevel, 80);
+}
+
+/**
+ * Calculate unlock level for special ability based on its power and effects
+ */
+export function calculateSpecialAbilityUnlockLevel(ability: SpecialAbility): number {
+  // Base level based on ability impact
+  let baseLevel = 15; // Default mid-level unlock
+  
+  // Analyze ability effects to determine power level
+  const effects = ability.effects || [];
+  let powerScore = 0;
+  
+  for (const effect of effects) {
+    switch (effect.type) {
+      case 'damage':
+        powerScore += effect.amount === 'strong' ? 3 : effect.amount === 'normal' ? 2 : 1;
+        break;
+      case 'heal':
+        powerScore += effect.amount === 'large' ? 3 : effect.amount === 'medium' ? 2 : 1;
+        break;
+      case 'modifyStats':
+        // Stat modifications are powerful
+        powerScore += 2;
+        break;
+      case 'applyStatus':
+        powerScore += 2;
+        break;
+      case 'removeStatus':
+        powerScore += 1;
+        break;
+      case 'manipulatePP':
+        powerScore += 1;
+        break;
+      default:
+        powerScore += 1;
+    }
+  }
+  
+  // Convert power score to unlock level
+  if (powerScore <= 2) {
+    baseLevel = Math.floor(Math.random() * 20) + 10; // Level 10-30
+  } else if (powerScore <= 4) {
+    baseLevel = Math.floor(Math.random() * 25) + 20; // Level 20-45
+  } else if (powerScore <= 6) {
+    baseLevel = Math.floor(Math.random() * 25) + 30; // Level 30-55
+  } else {
+    baseLevel = Math.floor(Math.random() * 25) + 40; // Level 40-65
+  }
+  
+  // Cap at level 80
+  return Math.min(baseLevel, 80);
+}
+
+/**
+ * Get all unlocked moves for a Piclet at a given level
+ */
+export function getUnlockedMoves(moves: BattleMove[], currentLevel: number): BattleMove[] {
+  return moves.filter(move => move.unlockLevel <= currentLevel);
+}
+
+/**
+ * Check if special ability is unlocked at given level
+ */
+export function isSpecialAbilityUnlocked(unlockLevel: number, currentLevel: number): boolean {
+  return currentLevel >= unlockLevel;
+}
+
+/**
+ * Generate unlock levels for a new Piclet's moves and ability
+ * This should be called when a Piclet is first generated
+ */
+export function generateUnlockLevels(moves: BattleMove[], specialAbility: SpecialAbility): {
+  movesWithUnlocks: BattleMove[];
+  abilityUnlockLevel: number;
+} {
+  const movesWithUnlocks = moves.map((move, index) => ({
+    ...move,
+    unlockLevel: calculateMoveUnlockLevel(move, index)
+  }));
+  
+  const abilityUnlockLevel = calculateSpecialAbilityUnlockLevel(specialAbility);
+  
+  return {
+    movesWithUnlocks,
+    abilityUnlockLevel
+  };
+}

src/lib/utils/battleConversion.ts

@@ -7,6 +7,7 @@ import type { PicletDefinition, Move, BaseStats, SpecialAbility } from '$lib/bat
 import type { PicletStats, BattleEffect, AbilityTrigger } from '$lib/types';
 import { PicletType, AttackType } from '$lib/types/picletTypes';
 import { recalculatePicletStats } from '$lib/services/levelingService';
+import { getUnlockedMoves, isSpecialAbilityUnlocked } from '$lib/services/unlockLevels';
 
 /**
  * Convert PicletInstance to PicletDefinition for battle engine use
@@ -24,15 +25,38 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
     speed: updatedInstance.speed      // Includes level scaling and nature modifiers
   };
 
-  // Convert simple moves to full battle moves
-  const movepool: Move[] = instance.moves.map(move => convertBattleMoveToMove(move, instance.primaryType));
+  // Only include unlocked moves
+  const unlockedMoves = getUnlockedMoves(instance.moves, updatedInstance.level);
+  const movepool: Move[] = unlockedMoves.map(move => convertBattleMoveToMove(move, instance.primaryType));
+  
+  // Ensure at least one move is available (first move 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 = convertBattleMoveToMove(instance.moves[0], instance.primaryType);
+      movepool.push(firstMove);
+    }
+  }
 
   // All Piclets must now have special abilities
   if (!instance.specialAbility) {
     throw new Error('Piclet must have a special ability. Legacy Piclets are no longer supported.');
   }
   
-  const specialAbility: SpecialAbility = instance.specialAbility;
+  // Only include special ability if unlocked
+  let specialAbility: SpecialAbility | undefined;
+  if (isSpecialAbilityUnlocked(instance.specialAbilityUnlockLevel, updatedInstance.level)) {
+    specialAbility = instance.specialAbility;
+  } else {
+    // Create a placeholder ability for locked special abilities
+    specialAbility = {
+      name: "Locked Ability",
+      description: `Unlocks at level ${instance.specialAbilityUnlockLevel}`,
+      trigger: "onBattleStart" as any,
+      effects: []
+    };
+  }
 
   // Determine tier based on BST (Base Stat Total)
   const bst = baseStats.hp + baseStats.attack + baseStats.defense + baseStats.speed;