rm db monsters

src/lib/components/Pages/Encounters.svelte

@@ -29,39 +29,32 @@
   async function loadEncounters() {
     isLoading = true;
     try {
-      // Check if we have discovered monsters first
-      const discoveredMonsters = await db.monsters.toArray();
+      // Check if we have any piclet instances
       const playerPiclets = await db.picletInstances.toArray();
       
-      if (discoveredMonsters.length === 0) {
-        // No monsters discovered - show empty state
+      if (playerPiclets.length === 0) {
+        // No piclets discovered/caught - show empty state
         encounters = [];
         isLoading = false;
         return;
       }
       
-      if (playerPiclets.length === 0) {
-        // First catch scenario - generate first catch encounter only
-        console.log('First catch scenario - generating first catch encounter');
-        encounters = await EncounterService.generateEncounters();
-      } else {
-        // Player has piclets - always generate fresh encounters with wild piclets
-        console.log('Player has piclets - generating fresh encounters with wild piclets');
-        await EncounterService.forceEncounterRefresh();
-        encounters = await EncounterService.generateEncounters();
-      }
+      // Player has piclets - always generate fresh encounters with wild piclets
+      console.log('Player has piclets - generating fresh encounters with wild piclets');
+      await EncounterService.forceEncounterRefresh();
+      encounters = await EncounterService.generateEncounters();
       
       console.log('Final encounters:', encounters.map(e => ({ type: e.type, title: e.title })));
       
-      // Load monster images for wild piclet encounters
-      await loadMonsterImages();
+      // Load piclet images for wild encounters
+      await loadPicletImages();
     } catch (error) {
       console.error('Error loading encounters:', error);
     }
     isLoading = false;
   }
   
-  async function loadMonsterImages() {
+  async function loadPicletImages() {
     const wildEncounters = encounters.filter(e => 
       e.type === EncounterType.WILD_PICLET && e.picletTypeId
     );
@@ -69,18 +62,14 @@
     for (const encounter of wildEncounters) {
       if (!encounter.picletTypeId) continue;
       
-      // Convert picletTypeId to monster name format
-      const monsterName = encounter.picletTypeId
-        .replace(/-/g, ' ')
-        .replace(/\b\w/g, l => l.toUpperCase());
-      
-      const monster = await db.monsters
-        .where('name')
-        .equals(monsterName)
+      // Find a piclet instance with this typeId
+      const piclet = await db.picletInstances
+        .where('typeId')
+        .equals(encounter.picletTypeId)
         .first();
       
-      if (monster && monster.imageData) {
-        monsterImages.set(encounter.picletTypeId, monster.imageData);
+      if (piclet && piclet.imageData) {
+        monsterImages.set(encounter.picletTypeId, piclet.imageData);
       }
     }
     // Trigger reactive update
@@ -94,8 +83,8 @@
       console.log('Force refreshing encounters...');
       encounters = await EncounterService.generateEncounters();
       
-      // Load monster images for new encounters
-      await loadMonsterImages();
+      // Load piclet images for new encounters
+      await loadPicletImages();
       
       // Update game state with new refresh time
       const gameState = await getOrCreateGameState();
@@ -167,7 +156,7 @@
     try {
       await EncounterService.forceEncounterRefresh();
       encounters = await EncounterService.generateEncounters();
-      await loadMonsterImages();
+      await loadPicletImages();
     } catch (error) {
       console.error('Error refreshing encounters:', error);
     }
@@ -253,111 +242,49 @@
   async function generateEnemyPiclet(encounter: Encounter): Promise<PicletInstance | null> {
     if (!encounter.picletTypeId || !encounter.enemyLevel) return null;
     
-    // Get the discovered monster data for this piclet type
-    const monster = await db.monsters
-      .where('name')
-      .equals(encounter.picletTypeId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()))
+    // Get a piclet instance with this typeId to use as a template
+    const templatePiclet = await db.picletInstances
+      .where('typeId')
+      .equals(encounter.picletTypeId)
       .first();
     
-    if (!monster || !monster.stats) {
-      console.error('Monster not found for typeId:', encounter.picletTypeId);
+    if (!templatePiclet) {
+      console.error('Piclet template not found for typeId:', encounter.picletTypeId);
       return null;
     }
     
-    // Calculate stats based on monster's base stats and encounter level
+    // Calculate stats based on template's base stats and encounter level
     const level = encounter.enemyLevel;
-    const stats = monster.stats;
-    
-    // Calculate base stats from the 0-100 scale
-    const baseHp = Math.floor(stats.HP * 2 + 50);
-    const baseAttack = Math.floor(stats.attack * 1.5 + 30);
-    const baseDefense = Math.floor(stats.defence * 1.5 + 30);
-    const baseSpeed = Math.floor(stats.speed * 1.5 + 30);
-    const baseFieldAttack = Math.floor(baseAttack * 0.8);
-    const baseFieldDefense = Math.floor(baseDefense * 0.8);
     
-    // Calculate current stats based on level
+    // 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(baseHp, level);
+    const maxHp = calculateHp(templatePiclet.baseHp, level);
     
-    // Create enemy piclet instance
+    // Create enemy piclet instance based on template
     const enemyPiclet: PicletInstance = {
+      ...templatePiclet,
       id: -1, // Temporary ID for enemy
-      typeId: encounter.picletTypeId,
-      nickname: monster.name,
-      primaryType: 'beast' as any, // Default type
       
       level: level,
       xp: 0,
       currentHp: maxHp,
       maxHp: maxHp,
-      attack: calculateStat(baseAttack, level),
-      defense: calculateStat(baseDefense, level),
-      fieldAttack: calculateStat(baseFieldAttack, level),
-      fieldDefense: calculateStat(baseFieldDefense, level),
-      speed: calculateStat(baseSpeed, level),
+      attack: calculateStat(templatePiclet.baseAttack, level),
+      defense: calculateStat(templatePiclet.baseDefense, level),
+      fieldAttack: calculateStat(templatePiclet.baseFieldAttack, level),
+      fieldDefense: calculateStat(templatePiclet.baseFieldDefense, level),
+      speed: calculateStat(templatePiclet.baseSpeed, level),
       
-      baseHp,
-      baseAttack,
-      baseDefense,
-      baseFieldAttack,
-      baseFieldDefense,
-      baseSpeed,
-      
-      moves: [
-        {
-          name: stats.attackActionName,
-          type: 'normal' as any,
-          power: 50,
-          accuracy: 95,
-          pp: 20,
-          currentPp: 20,
-          description: stats.attackActionDescription
-        },
-        {
-          name: stats.buffActionName,
-          type: 'normal' as any,
-          power: 0,
-          accuracy: 100,
-          pp: 15,
-          currentPp: 15,
-          description: stats.buffActionDescription
-        },
-        {
-          name: stats.debuffActionName,
-          type: 'normal' as any,
-          power: 0,
-          accuracy: 85,
-          pp: 15,
-          currentPp: 15,
-          description: stats.debuffActionDescription
-        },
-        {
-          name: stats.specialActionName,
-          type: 'normal' as any,
-          power: 80,
-          accuracy: 90,
-          pp: 5,
-          currentPp: 5,
-          description: stats.specialActionDescription
-        }
-      ],
-      nature: 'hardy',
+      // Reset move PP to full
+      moves: templatePiclet.moves.map(move => ({
+        ...move,
+        currentPp: move.pp
+      })),
       
       isInRoster: false,
-      caughtAt: new Date(),
-      bst: baseHp + baseAttack + baseDefense + baseFieldAttack + baseFieldDefense + baseSpeed,
-      tier: (stats as any).tier || 'medium',
-      role: 'balanced',
-      variance: 0,
-      
-      imageUrl: monster.imageUrl,
-      imageData: monster.imageData, // Use the transparent image data
-      imageCaption: monster.imageCaption,
-      concept: monster.concept,
-      imagePrompt: monster.imagePrompt
+      caughtAt: new Date()
     };
     
     return enemyPiclet;

src/lib/components/PicletGenerator/PicletGenerator.svelte

@@ -892,8 +892,8 @@ Write your response within \`\`\`json\`\`\``;
       
       // Convert to PicletInstance format and save
       const picletInstance = await monsterToPicletInstance(picletData);
-      const id = await savePicletInstance(picletInstance);
-      console.log('Piclet auto-saved with ID:', id);
+      const picletId = await savePicletInstance(picletInstance);
+      console.log('Piclet auto-saved with ID:', picletId);
     } catch (err) {
       console.error('Failed to auto-save piclet:', err);
       console.error('Piclet data that failed to save:', {

src/lib/db/encounterService.ts

@@ -44,34 +44,12 @@ export class EncounterService {
     const playerPiclets = await db.picletInstances.toArray();
     
     if (playerPiclets.length === 0) {
-      // No piclets caught yet - check for discovered piclets
-      // For now, we'll check the monsters collection as a proxy for discovered piclets
-      // In a real app, this would check a remote database for piclets discovered by scanning
-      const discoveredPiclets = await db.monsters.toArray();
-      
-      if (discoveredPiclets.length === 0) {
-        // No piclets discovered yet - return empty encounters
-        await db.encounters.clear();
-        await markEncountersRefreshed();
-        return [];
-      }
-      
-      // Player has discovered but not caught any piclets - show ONLY first catch encounter
-      const firstDiscovered = discoveredPiclets[0];
-      encounters.push({
-        type: EncounterType.WILD_PICLET,
-        title: 'Your First Piclet!',
-        description: 'A friendly piclet appears! This one seems easy to catch.',
-        picletTypeId: firstDiscovered.name.toLowerCase().replace(/\s+/g, '-'),
-        enemyLevel: 5,
-        createdAt: new Date()
-      });
-      
-      // IMPORTANT: Return here - don't add shop/health center for first catch
+      // 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');
       await db.encounters.clear();
-      await db.encounters.add(encounters[0]);
       await markEncountersRefreshed();
-      return await this.getCurrentEncounters();
+      return [];
     }
     
     // Player has piclets - generate normal encounters
@@ -128,34 +106,37 @@ export class EncounterService {
     // Get player's average level
     const avgLevel = await this.getPlayerAverageLevel();
     
-    // Get all discovered monsters
-    const discoveredMonsters = await db.monsters.toArray();
-    console.log('Discovered monsters for wild encounters:', discoveredMonsters.length);
+    // Get all piclet instances (these represent "discovered" piclets)
+    const allPiclets = await db.picletInstances.toArray();
+    console.log('Total piclet instances for wild encounters:', allPiclets.length);
     
-    if (discoveredMonsters.length === 0) {
-      console.log('No discovered monsters - returning empty wild encounters');
+    if (allPiclets.length === 0) {
+      console.log('No piclet instances - returning empty wild encounters');
       return encounters;
     }
     
-    // Always allow catching duplicates for more encounters
-    const availableMonsters = discoveredMonsters;
-    console.log('Available monsters for encounters:', availableMonsters.map(m => m.name));
+    // Get unique piclet types for encounters (allow duplicates)
+    const availablePiclets = allPiclets;
+    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));
     console.log('Generating', encounterCount, 'wild encounters');
     
     for (let i = 0; i < encounterCount; i++) {
-      // Pick a random monster from discovered ones
-      const monster = availableMonsters[Math.floor(Math.random() * availableMonsters.length)];
+      // Pick a random piclet from available ones
+      const piclet = availablePiclets[Math.floor(Math.random() * availablePiclets.length)];
       
       const levelVariance = Math.floor(Math.random() * (LEVEL_VARIANCE * 2 + 1)) - LEVEL_VARIANCE;
       const enemyLevel = Math.max(1, avgLevel + levelVariance);
       
+      // Use the piclet's nickname or typeId for display
+      const displayName = piclet.nickname || piclet.typeId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+      
       const wildEncounter = {
         type: EncounterType.WILD_PICLET,
-        title: `Wild ${monster.name} Appeared!`,
-        description: `A level ${enemyLevel} ${monster.name} blocks your path!`,
-        picletTypeId: monster.name.toLowerCase().replace(/\s+/g, '-'),
+        title: `Wild ${displayName} Appeared!`,
+        description: `A level ${enemyLevel} ${displayName} blocks your path!`,
+        picletTypeId: piclet.typeId,
         enemyLevel,
         createdAt: new Date()
       };
@@ -187,35 +168,60 @@ export class EncounterService {
     return Math.round(totalLevel / rosterPiclets.length);
   }
 
-  // Catch a wild piclet (for first encounter)
+  // Catch a wild piclet (creates a new instance based on existing piclet type)
   static async catchWildPiclet(encounter: Encounter): Promise<PicletInstance> {
     if (!encounter.picletTypeId) throw new Error('No piclet type specified');
     
-    // Import the conversion function
-    const { monsterToPicletInstance } = await import('./piclets');
-    
-    // Get the monster data by name (typeId is the lowercase hyphenated name)
-    const monsterName = encounter.picletTypeId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
-    const monster = await db.monsters
-      .where('name')
-      .equals(monsterName)
+    // Find an existing piclet instance with this typeId to use as a template
+    const templatePiclet = await db.picletInstances
+      .where('typeId')
+      .equals(encounter.picletTypeId)
       .first();
     
-    if (!monster) {
-      throw new Error(`Monster not found: ${monsterName}`);
+    if (!templatePiclet) {
+      throw new Error(`Piclet type not found: ${encounter.picletTypeId}`);
     }
     
-    // Convert monster to piclet instance
-    const picletData = await monsterToPicletInstance(monster, encounter.enemyLevel || 5);
+    // Create a new piclet instance based on the template but with different stats/level
+    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,
+      xp: 0,
+      currentHp: calculateHp(templatePiclet.baseHp, newLevel),
+      maxHp: calculateHp(templatePiclet.baseHp, newLevel),
+      attack: calculateStat(templatePiclet.baseAttack, newLevel),
+      defense: calculateStat(templatePiclet.baseDefense, newLevel),
+      fieldAttack: calculateStat(templatePiclet.baseFieldAttack, newLevel),
+      fieldDefense: calculateStat(templatePiclet.baseFieldDefense, newLevel),
+      speed: calculateStat(templatePiclet.baseSpeed, newLevel),
+      
+      // Reset move PP to full
+      moves: templatePiclet.moves.map(move => ({
+        ...move,
+        currentPp: move.pp
+      })),
+      
+      // Clear roster info for wild catch
+      isInRoster: false,
+      rosterPosition: undefined,
+      caughtAt: new Date()
+    };
     
     // Set roster position 0 if this is the first piclet
     const existingPiclets = await db.picletInstances.toArray();
-    if (existingPiclets.length === 0) {
-      picletData.rosterPosition = 0;
+    if (existingPiclets.length === 1) { // Only the template exists
+      newPiclet.rosterPosition = 0;
+      newPiclet.isInRoster = true;
     }
     
     // Save the new piclet
-    const id = await db.picletInstances.add(picletData);
-    return { ...picletData, id };
+    const id = await db.picletInstances.add(newPiclet);
+    return { ...newPiclet, id };
   }
 }