fix enc

src/lib/db/encounterService.ts

@@ -77,20 +77,38 @@ export class EncounterService {
   static async generateEncounters(): Promise<Encounter[]> {
     const encounters: Omit<Encounter, 'id'>[] = [];
     
-    // Check if player has caught any piclets first
-    const playerPiclets = await db.picletInstances.toArray();
+    // Check for "Your First Piclet" scenario first
+    const caughtPiclets = await getCaughtPiclets();
+    const uncaughtPiclets = await getUncaughtPiclets();
     
-    if (playerPiclets.length === 0) {
-      // No piclets caught yet - this shouldn't happen in normal flow since we use picletInstances
-      // But just in case, return empty encounters
-      console.log('No piclet instances found - returning empty encounters');
+    if (caughtPiclets.length === 0 && uncaughtPiclets.length > 0) {
+      // Player has no caught piclets but has uncaught ones - return ONLY first piclet encounters
+      console.log('Player has uncaught piclets but no caught ones - checking for first piclet encounters');
+      
+      // Check if there are already first piclet encounters
+      const existingEncounters = await this.getCurrentEncounters();
+      const firstPicletEncounters = existingEncounters.filter(e => e.type === EncounterType.FIRST_PICLET);
+      
+      if (firstPicletEncounters.length > 0) {
+        console.log('First piclet encounters already exist:', firstPicletEncounters.length);
+        return existingEncounters; // Return existing encounters without clearing
+      } else {
+        console.log('No first piclet encounters found - this should have been created during generation');
+        // Don't generate normal encounters - return existing (should be empty)
+        return existingEncounters;
+      }
+    }
+    
+    if (caughtPiclets.length === 0 && uncaughtPiclets.length === 0) {
+      // No piclets at all - return empty encounters
+      console.log('No piclets found - returning empty encounters');
       await db.encounters.clear();
       await markEncountersRefreshed();
       return [];
     }
     
-    // Player has piclets - generate normal encounters
-    console.log('Generating encounters for player with piclets');
+    // Player has caught piclets - generate normal encounters
+    console.log('Generating normal encounters for player with caught piclets');
     
     // Generate wild piclet encounters FIRST to ensure they're included
     const wildEncounters = await this.generateWildEncounters();
@@ -143,17 +161,17 @@ export class EncounterService {
     // Get player's average level
     const avgLevel = await this.getPlayerAverageLevel();
     
-    // Get all piclet instances (these represent "discovered" piclets)
-    const allPiclets = await db.picletInstances.toArray();
-    console.log('Total piclet instances for wild encounters:', allPiclets.length);
+    // Get caught piclets only (these can appear as wild encounters)
+    const caughtPiclets = await getCaughtPiclets();
+    console.log('Caught piclets for wild encounters:', caughtPiclets.length);
     
-    if (allPiclets.length === 0) {
-      console.log('No piclet instances - returning empty wild encounters');
+    if (caughtPiclets.length === 0) {
+      console.log('No caught piclets - returning empty wild encounters');
       return encounters;
     }
     
-    // Get unique piclet types for encounters (allow duplicates)
-    const availablePiclets = allPiclets;
+    // Use caught piclets as templates for wild encounters
+    const availablePiclets = caughtPiclets;
     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));
@@ -194,11 +212,11 @@ export class EncounterService {
       .toArray();
     
     if (rosterPiclets.length === 0) {
-      const allPiclets = await db.picletInstances.toArray();
-      if (allPiclets.length === 0) return 5; // Default starting level
+      const caughtPiclets = await getCaughtPiclets();
+      if (caughtPiclets.length === 0) return 5; // Default starting level
       
-      const totalLevel = allPiclets.reduce((sum, p) => sum + p.level, 0);
-      return Math.round(totalLevel / allPiclets.length);
+      const totalLevel = caughtPiclets.reduce((sum, p) => sum + p.level, 0);
+      return Math.round(totalLevel / caughtPiclets.length);
     }
     
     const totalLevel = rosterPiclets.reduce((sum, p) => sum + p.level, 0);
@@ -243,11 +261,9 @@ export class EncounterService {
   static async catchWildPiclet(encounter: Encounter): Promise<PicletInstance> {
     if (!encounter.picletTypeId) throw new Error('No piclet type specified');
     
-    // Find an existing piclet instance with this typeId to use as a template
-    const templatePiclet = await db.picletInstances
-      .where('typeId')
-      .equals(encounter.picletTypeId)
-      .first();
+    // Find a caught piclet instance with this typeId to use as a 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}`);
@@ -284,9 +300,12 @@ export class EncounterService {
       caughtAt: new Date()
     };
     
-    // Set roster position 0 if this is the first piclet
-    const existingPiclets = await db.picletInstances.toArray();
-    if (existingPiclets.length === 1) { // Only the template exists
+    // 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 === 1) { // Only one caught piclet exists (the template)
       newPiclet.rosterPosition = 0;
       newPiclet.isInRoster = true;
     }