fix encounters

src/lib/components/Pages/Encounters.svelte

@@ -5,6 +5,7 @@
   import { EncounterType } from '$lib/db/schema';
   import { EncounterService } from '$lib/db/encounterService';
   import { getOrCreateGameState, incrementCounter, addProgressPoints } from '$lib/db/gameState';
+  import { calculateStat, calculateHp } from '$lib/services/levelingService';
   import { db } from '$lib/db';
   import { uiStore } from '$lib/stores/ui';
   import Battle from './Battle.svelte';
@@ -290,8 +291,6 @@
     const level = encounter.enemyLevel;
     
     // Calculate current stats based on level (using template's base stats)
-    const calculateStat = (base: number, level: number) => Math.floor((base * level) / 50 + 5);
-    const calculateHp = (base: number, level: number) => Math.floor((base * level) / 50 + level + 10);
     
     const maxHp = calculateHp(templatePiclet.baseHp, level);
     

src/lib/db/encounterService.ts

@@ -3,6 +3,7 @@ import type { Encounter, PicletInstance } from './schema';
 import { EncounterType } from './schema';
 import { getOrCreateGameState, markEncountersRefreshed } from './gameState';
 import { getCaughtPiclets, getUncaughtPiclets } from './piclets';
+import { calculateStat, calculateHp } from '../services/levelingService';
 
 // Configuration
 const ENCOUNTER_REFRESH_HOURS = 2;
@@ -129,17 +130,17 @@ export class EncounterService {
     // Get player's average level
     const avgLevel = await this.getPlayerAverageLevel();
     
-    // Get caught piclets only (these can appear as wild encounters)
-    const caughtPiclets = await getCaughtPiclets();
-    console.log('Caught piclets for wild encounters:', caughtPiclets.length);
+    // Get uncaught piclets (these can appear as wild encounters to be caught)
+    const uncaughtPiclets = await getUncaughtPiclets();
+    console.log('Uncaught piclets for wild encounters:', uncaughtPiclets.length);
     
-    if (caughtPiclets.length === 0) {
-      console.log('No caught piclets - returning empty wild encounters');
+    if (uncaughtPiclets.length === 0) {
+      console.log('No uncaught piclets - returning empty wild encounters');
       return encounters;
     }
     
-    // Use caught piclets as templates for wild encounters
-    const availablePiclets = caughtPiclets;
+    // Use uncaught piclets as templates for wild encounters
+    const availablePiclets = uncaughtPiclets;
     console.log('Available piclets for encounters:', availablePiclets.map(p => p.typeId));
     
     const encounterCount = MIN_WILD_ENCOUNTERS + Math.floor(Math.random() * (MAX_WILD_ENCOUNTERS - MIN_WILD_ENCOUNTERS + 1));
@@ -192,31 +193,66 @@ export class EncounterService {
   }
 
 
-  // Catch a wild piclet (creates a new instance based on existing piclet type)
+  // Catch a wild piclet (marks uncaught piclet as caught, or creates new instance for recatches)
   static async catchWildPiclet(encounter: Encounter): Promise<PicletInstance> {
     if (!encounter.picletTypeId) throw new Error('No piclet type specified');
     
-    // First try to find a caught piclet instance with this typeId to use as a template
-    const caughtPiclets = await getCaughtPiclets();
-    let templatePiclet = caughtPiclets.find(p => p.typeId === encounter.picletTypeId);
+    // First check if this is an uncaught piclet that can be directly marked as caught
+    const uncaughtPiclets = await getUncaughtPiclets();
+    const uncaughtPiclet = uncaughtPiclets.find(p => p.typeId === encounter.picletTypeId);
     
-    // If no caught template found, try uncaught piclets (for first catch scenario)
-    if (!templatePiclet) {
-      const uncaughtPiclets = await getUncaughtPiclets();
-      templatePiclet = uncaughtPiclets.find(p => p.typeId === encounter.picletTypeId);
+    if (uncaughtPiclet) {
+      // This is the first time catching this type - mark the existing uncaught piclet as caught
+      const newLevel = encounter.enemyLevel || uncaughtPiclet.level;
+      
+      // Update the existing uncaught piclet
+      const updates = {
+        caught: true,
+        caughtAt: new Date(),
+        level: newLevel,
+        xp: 0,
+        currentHp: calculateHp(uncaughtPiclet.baseHp, newLevel),
+        maxHp: calculateHp(uncaughtPiclet.baseHp, newLevel),
+        attack: calculateStat(uncaughtPiclet.baseAttack, newLevel),
+        defense: calculateStat(uncaughtPiclet.baseDefense, newLevel),
+        fieldAttack: calculateStat(uncaughtPiclet.baseFieldAttack, newLevel),
+        fieldDefense: calculateStat(uncaughtPiclet.baseFieldDefense, newLevel),
+        speed: calculateStat(uncaughtPiclet.baseSpeed, newLevel),
+        
+        // Reset move PP to full
+        moves: uncaughtPiclet.moves.map(move => ({
+          ...move,
+          currentPp: move.pp
+        }))
+      };
+      
+      // Set roster position 0 if this is the first caught piclet
+      const existingCaughtPiclets = await getCaughtPiclets();
+      if (existingCaughtPiclets.length === 0) {
+        Object.assign(updates, {
+          rosterPosition: 0,
+          isInRoster: true
+        });
+      }
+      
+      // Update the existing piclet
+      await db.picletInstances.update(uncaughtPiclet.id!, updates);
+      
+      // Return the updated piclet
+      return { ...uncaughtPiclet, ...updates };
     }
     
+    // If no uncaught piclet found, this is a recatch - create a new instance using caught piclet as template
+    const caughtPiclets = await getCaughtPiclets();
+    const templatePiclet = caughtPiclets.find(p => p.typeId === encounter.picletTypeId);
+    
     if (!templatePiclet) {
       throw new Error(`Piclet type not found: ${encounter.picletTypeId}`);
     }
     
-    // Create a new piclet instance based on the template but with different stats/level
+    // Create a new piclet instance for recatch
     const newLevel = encounter.enemyLevel || 5;
     
-    // Calculate new stats based on level (using template's base stats)
-    const calculateStat = (base: number, level: number) => Math.floor((base * level) / 50 + 5);
-    const calculateHp = (base: number, level: number) => Math.floor((base * level) / 50 + level + 10);
-    
     const newPiclet: Omit<PicletInstance, 'id'> = {
       ...templatePiclet,
       level: newLevel,
@@ -235,22 +271,13 @@ export class EncounterService {
         currentPp: move.pp
       })),
       
-      // Clear roster info for wild catch
+      // Clear roster info for new catch
       isInRoster: false,
       rosterPosition: undefined,
+      caught: true,
       caughtAt: new Date()
     };
     
-    // Wild piclets are always caught
-    newPiclet.caught = true;
-    
-    // Set roster position 0 if this is the first caught piclet
-    const existingCaughtPiclets = await getCaughtPiclets();
-    if (existingCaughtPiclets.length === 0) { // This will be the first caught piclet
-      newPiclet.rosterPosition = 0;
-      newPiclet.isInRoster = true;
-    }
-    
     // Save the new piclet
     const id = await db.picletInstances.add(newPiclet);
     return { ...newPiclet, id };