OH GOT THE STATS AREN'T ACTUALLY STORED NOOOOOOOOO

src/lib/db/index.ts

@@ -39,6 +39,15 @@ export class PicletDatabase extends Dexie {
       gameState: '++id, lastPlayed',
       trainerScanProgress: 'imagePath, trainerName, status, completedAt'
     });
+    
+    // Version 7: Move schema updated to include complete Move data (priority, flags, effects)
+    // No schema changes needed - just expanded interfaces, data will be preserved
+    this.version(7).stores({
+      picletInstances: '++id, typeId, nickname, isInRoster, rosterPosition, caughtAt',
+      encounters: '++id, type, createdAt',
+      gameState: '++id, lastPlayed',
+      trainerScanProgress: 'imagePath, trainerName, status, completedAt'
+    });
   }
 }
 

src/lib/db/piclets.ts

@@ -1,7 +1,8 @@
 import { db } from './index';
 import type { PicletInstance, BattleMove } from './schema';
-import { PicletType, AttackType, getTypeFromConcept } from '../types/picletTypes';
+import { PicletType, getTypeFromConcept } from '../types/picletTypes';
 import type { PicletStats } from '../types';
+import type { Move as BattleEngineMove } from '../battle-engine/types';
 import { generateUnlockLevels } from '../services/unlockLevels';
 
 // Interface for generated piclet data (from PicletResult component)
@@ -36,28 +37,49 @@ export async function generatedDataToPicletInstance(data: GeneratedPicletData, l
   const baseSpeed = Math.floor(stats.baseStats.speed * 1.5 + 30);
   
   // Determine primary type from battle stats
-  const normalizedType = stats.primaryType.toLowerCase();
-  const validType = Object.values(PicletType).find(type => type === normalizedType);
-  const primaryType = validType || getTypeFromConcept(data.concept, data.imageCaption);
+  const normalizedPrimaryType = stats.primaryType.toLowerCase();
+  const validPrimaryType = Object.values(PicletType).find(type => type === normalizedPrimaryType);
+  const primaryType = validPrimaryType || getTypeFromConcept(data.concept, data.imageCaption);
   
-  if (!validType) {
+  if (!validPrimaryType) {
     console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
   }
 
-  // Create moves from battle-ready format (without unlock levels initially)
+  // Handle secondary type
+  let secondaryType: PicletType | undefined = undefined;
+  if (stats.secondaryType && stats.secondaryType !== null) {
+    const normalizedSecondaryType = stats.secondaryType.toLowerCase();
+    const validSecondaryType = Object.values(PicletType).find(type => type === normalizedSecondaryType);
+    secondaryType = validSecondaryType;
+    if (!validSecondaryType) {
+      console.warn(`Invalid secondaryType "${stats.secondaryType}" from stats, ignoring`);
+    }
+  }
+
+  // Create moves from battle-ready format preserving all data
+  // Convert from PicletStats.BattleMove (loose types) to schema.BattleMove (strict types)
   const baseMoves: BattleMove[] = stats.movepool.map(move => ({
     name: move.name,
-    type: move.type as unknown as AttackType,
+    type: move.type as any, // Type conversion from string union to AttackType enum
     power: move.power,
     accuracy: move.accuracy,
     pp: move.pp,
+    priority: move.priority,
+    flags: move.flags as any, // Type conversion from string[] to MoveFlag[]
+    effects: move.effects as any, // Type conversion between BattleEffect types
     currentPp: move.pp,
-    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);
+  // Convert from PicletStats.SpecialAbility to battle-engine.SpecialAbility
+  const convertedSpecialAbility = {
+    name: stats.specialAbility.name,
+    description: stats.specialAbility.description,
+    effects: stats.specialAbility.effects as any,
+    triggers: stats.specialAbility.triggers as any
+  };
+  const { movesWithUnlocks, abilityUnlockLevel } = generateUnlockLevels(baseMoves, convertedSpecialAbility);
   const moves = movesWithUnlocks;
   
   // Field stats are variations of regular stats
@@ -90,9 +112,9 @@ export async function generatedDataToPicletInstance(data: GeneratedPicletData, l
   return {
     // Type Info
     typeId: data.name.toLowerCase().replace(/\s+/g, '-'),
-    nickname: data.name,
+    nickname: stats.name || data.name, // Use stats.name if available, fallback to data.name
     primaryType: primaryType,
-    secondaryType: undefined,
+    secondaryType: secondaryType,
     
     // Current Stats
     currentHp: maxHp,
@@ -116,7 +138,7 @@ export async function generatedDataToPicletInstance(data: GeneratedPicletData, l
     // Battle
     moves,
     nature: stats.nature,
-    specialAbility: stats.specialAbility,
+    specialAbility: convertedSpecialAbility,
     specialAbilityUnlockLevel: abilityUnlockLevel,
     
     // Roster

src/lib/db/schema.ts

@@ -1,5 +1,5 @@
 import type { PicletType, AttackType } from '../types/picletTypes';
-import type { SpecialAbility } from '../battle-engine/types';
+import type { SpecialAbility, Move } from '../battle-engine/types';
 
 // Enums
 export enum EncounterType {
@@ -10,15 +10,9 @@ export enum EncounterType {
   FIRST_PICLET = 'firstPiclet'
 }
 
-// Battle Move embedded object
-export interface BattleMove {
-  name: string;
-  type: AttackType;
-  power: number;
-  accuracy: number;
-  pp: number;
+// Battle Move with unlock level - extends the complete Move interface
+export interface BattleMove extends Move {
   currentPp: number;
-  description: string;
   unlockLevel: number; // Level at which this move is unlocked
 }
 

src/lib/utils/battleConversion.ts

@@ -2,10 +2,10 @@
  * Conversion utilities for transforming database types to battle engine types
  */
 
-import type { PicletInstance, BattleMove } from '$lib/db/schema';
+import type { PicletInstance } from '$lib/db/schema';
 import type { PicletDefinition, Move, BaseStats, SpecialAbility } from '$lib/battle-engine/types';
-import type { PicletStats, BattleEffect, AbilityTrigger } from '$lib/types';
-import { PicletType, AttackType } from '$lib/types/picletTypes';
+import type { PicletStats } from '$lib/types';
+import { PicletType } from '$lib/types/picletTypes';
 import { recalculatePicletStats } from '$lib/services/levelingService';
 import { getUnlockedMoves, isSpecialAbilityUnlocked } from '$lib/services/unlockLevels';
 
@@ -25,17 +25,35 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
     speed: updatedInstance.speed      // Includes level scaling and nature modifiers
   };
 
-  // Only include unlocked moves
+  // Only include unlocked moves - BattleMove now contains complete Move data
   const unlockedMoves = getUnlockedMoves(instance.moves, updatedInstance.level);
-  const movepool: Move[] = unlockedMoves.map(move => convertBattleMoveToMove(move, instance.primaryType));
+  const movepool: Move[] = unlockedMoves.map(move => ({
+    name: move.name,
+    type: move.type,
+    power: move.power,
+    accuracy: move.accuracy,
+    pp: move.pp,
+    priority: move.priority,
+    flags: move.flags,
+    effects: move.effects
+  }));
   
   // 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);
+      const firstMove = instance.moves[0];
+      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
+      });
     }
   }
 
@@ -53,7 +71,6 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
     specialAbility = {
       name: "Locked Ability",
       description: `Unlocks at level ${instance.specialAbilityUnlockLevel}`,
-      trigger: "onBattleStart" as any,
       effects: []
     };
   }
@@ -74,47 +91,11 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
     secondaryType: instance.secondaryType,
     baseStats,
     nature: instance.nature,
-    specialAbility,
+    specialAbility: specialAbility!,
     movepool
   };
 }
 
-/**
- * Convert BattleMove to full Move for battle engine
- */
-function convertBattleMoveToMove(battleMove: BattleMove, primaryType: PicletType): Move {
-  // Create basic effects based on move properties
-  const effects: any[] = [];
-  
-  if (battleMove.power > 0) {
-    effects.push({
-      type: 'damage',
-      target: 'opponent',
-      amount: battleMove.power >= 80 ? 'strong' : 
-              battleMove.power >= 60 ? 'normal' : 'weak'
-    });
-  }
-
-  // Add status or stat effects for non-damaging moves
-  if (battleMove.power === 0) {
-    effects.push({
-      type: 'modifyStats',
-      target: 'self',
-      stats: { attack: 'increase' }
-    });
-  }
-
-  return {
-    name: battleMove.name,
-    type: battleMove.type,
-    power: battleMove.power,
-    accuracy: battleMove.accuracy,
-    pp: battleMove.pp,
-    priority: 0,
-    flags: battleMove.power > 0 && battleMove.name.toLowerCase().includes('tackle') ? ['contact'] : [],
-    effects
-  };
-}
 
 
 /**
@@ -144,12 +125,12 @@ export function picletStatsToBattleDefinition(stats: PicletStats, name: string,
     name: stats.name || name,
     description: stats.description || concept,
     tier: stats.tier,
-    primaryType: stats.primaryType,
-    secondaryType: stats.secondaryType || undefined,
+    primaryType: stats.primaryType as PicletType,
+    secondaryType: stats.secondaryType as PicletType || undefined,
     baseStats: stats.baseStats,
     nature: stats.nature,
-    specialAbility: stats.specialAbility,
-    movepool: stats.movepool
+    specialAbility: stats.specialAbility as any,
+    movepool: stats.movepool as any
   };
 }