more stats

src/lib/db/gameState.ts

@@ -0,0 +1,89 @@
+import { db } from './index';
+import type { GameState, Encounter, EncounterType } from './schema';
+
+// Initialize or get game state
+export async function getOrCreateGameState(): Promise<GameState> {
+  const states = await db.gameState.toArray();
+  
+  if (states.length > 0) {
+    // Update last played
+    await db.gameState.update(states[0].id!, { lastPlayed: new Date() });
+    return states[0];
+  }
+  
+  // Create initial game state
+  const newState: Omit<GameState, 'id'> = {
+    lastEncounterRefresh: new Date(),
+    lastPlayed: new Date(),
+    progressPoints: 0,
+    trainersDefeated: 0,
+    picletsCapured: 0,
+    battlesLost: 0
+  };
+  
+  const id = await db.gameState.add(newState);
+  return { ...newState, id };
+}
+
+// Update progress
+export async function updateProgress(updates: Partial<GameState>): Promise<void> {
+  const state = await getOrCreateGameState();
+  await db.gameState.update(state.id!, updates);
+}
+
+// Increment specific counters
+export async function incrementCounter(counter: 'trainersDefeated' | 'picletsCapured' | 'battlesLost'): Promise<void> {
+  const state = await getOrCreateGameState();
+  await db.gameState.update(state.id!, {
+    [counter]: state[counter] + 1
+  });
+}
+
+// Add progress points
+export async function addProgressPoints(points: number): Promise<void> {
+  const state = await getOrCreateGameState();
+  const newPoints = Math.min(1000, state.progressPoints + points);
+  await db.gameState.update(state.id!, {
+    progressPoints: newPoints
+  });
+}
+
+// Create a new encounter
+export async function createEncounter(encounter: Omit<Encounter, 'id' | 'createdAt'>): Promise<number> {
+  return await db.encounters.add({
+    ...encounter,
+    createdAt: new Date()
+  });
+}
+
+// Get recent encounters
+export async function getRecentEncounters(limit: number = 10): Promise<Encounter[]> {
+  return await db.encounters
+    .orderBy('createdAt')
+    .reverse()
+    .limit(limit)
+    .toArray();
+}
+
+// Get encounters by type
+export async function getEncountersByType(type: EncounterType): Promise<Encounter[]> {
+  return await db.encounters
+    .where('type')
+    .equals(type)
+    .toArray();
+}
+
+// Check if should refresh encounters (e.g., every hour)
+export async function shouldRefreshEncounters(): Promise<boolean> {
+  const state = await getOrCreateGameState();
+  const hoursSinceRefresh = (Date.now() - state.lastEncounterRefresh.getTime()) / (1000 * 60 * 60);
+  return hoursSinceRefresh >= 1;
+}
+
+// Mark encounters as refreshed
+export async function markEncountersRefreshed(): Promise<void> {
+  const state = await getOrCreateGameState();
+  await db.gameState.update(state.id!, {
+    lastEncounterRefresh: new Date()
+  });
+}

src/lib/db/index.ts

@@ -1,11 +1,17 @@
 import Dexie, { type Table } from 'dexie';
-import type { Monster } from './schema';
+import type { Monster, PicletInstance, Encounter, GameState } from './schema';
 
-export class MonsterDatabase extends Dexie {
+export class PicletDatabase extends Dexie {
+  // Legacy table
   monsters!: Table<Monster>;
+  
+  // New game tables
+  picletInstances!: Table<PicletInstance>;
+  encounters!: Table<Encounter>;
+  gameState!: Table<GameState>;
 
   constructor() {
-    super('MonsterGeneratorDB');
+    super('PicletGameDB');
     
     this.version(1).stores({
       monsters: '++id, name, createdAt'
@@ -30,7 +36,15 @@ export class MonsterDatabase extends Dexie {
         monster.stats = monster.stats || null;
       });
     });
+    
+    // Version 4: Add new game tables
+    this.version(4).stores({
+      monsters: '++id, name, createdAt',
+      picletInstances: '++id, typeId, nickname, isInRoster, rosterPosition, caughtAt',
+      encounters: '++id, type, createdAt',
+      gameState: '++id, lastPlayed'
+    });
   }
 }
 
-export const db = new MonsterDatabase();
+export const db = new PicletDatabase();

src/lib/db/monsters.ts

@@ -1,13 +1,26 @@
 import { db } from './index';
 import type { Monster } from './schema';
+import { monsterToPicletInstance, savePicletInstance } from './piclets';
 
-export async function saveMonster(monsterData: Omit<Monster, 'id' | 'createdAt'>): Promise<number> {
+export async function saveMonster(monsterData: Omit<Monster, 'id' | 'createdAt'>, createPiclet: boolean = true): Promise<number> {
   const monster: Omit<Monster, 'id'> = {
     ...monsterData,
     createdAt: new Date()
   };
   
-  return await db.monsters.add(monster);
+  const monsterId = await db.monsters.add(monster);
+  
+  // Also create a PicletInstance if requested and stats are available
+  if (createPiclet && monster.stats) {
+    try {
+      const picletData = await monsterToPicletInstance({ ...monster, id: monsterId }, 5);
+      await savePicletInstance(picletData);
+    } catch (err) {
+      console.error('Failed to create PicletInstance:', err);
+    }
+  }
+  
+  return monsterId;
 }
 
 export async function getAllMonsters(): Promise<Monster[]> {

src/lib/db/piclets.ts

@@ -0,0 +1,149 @@
+import { db } from './index';
+import type { PicletInstance, Monster, BattleMove } from './schema';
+
+// Convert a generated Monster to a PicletInstance
+export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
+  if (!monster.stats) {
+    throw new Error('Monster must have stats to create PicletInstance');
+  }
+
+  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);
+  
+  // Field stats are variations of regular stats
+  const baseFieldAttack = Math.floor(baseAttack * 0.8);
+  const baseFieldDefense = Math.floor(baseDefense * 0.8);
+  
+  // Calculate current stats based on level
+  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);
+  
+  // Create moves based on monster's abilities
+  const moves: BattleMove[] = [
+    {
+      name: stats.attackActionName,
+      type: 'normal',
+      power: 50,
+      accuracy: 95,
+      pp: 20,
+      currentPp: 20,
+      description: stats.attackActionDescription
+    },
+    {
+      name: stats.buffActionName,
+      type: 'status',
+      power: 0,
+      accuracy: 100,
+      pp: 15,
+      currentPp: 15,
+      description: stats.buffActionDescription
+    },
+    {
+      name: stats.debuffActionName,
+      type: 'status',
+      power: 0,
+      accuracy: 85,
+      pp: 15,
+      currentPp: 15,
+      description: stats.debuffActionDescription
+    },
+    {
+      name: stats.specialActionName,
+      type: 'special',
+      power: 80,
+      accuracy: 90,
+      pp: 5,
+      currentPp: 5,
+      description: stats.specialActionDescription
+    }
+  ];
+  
+  const bst = baseHp + baseAttack + baseDefense + baseFieldAttack + baseFieldDefense + baseSpeed;
+  
+  return {
+    // Type Info
+    typeId: monster.name.toLowerCase().replace(/\s+/g, '-'),
+    nickname: monster.name,
+    primaryTypeString: 'normal', // Default type, could be enhanced based on concept
+    secondaryTypeString: undefined,
+    
+    // Current Stats
+    currentHp: maxHp,
+    maxHp,
+    level,
+    xp: 0,
+    attack: calculateStat(baseAttack, level),
+    defense: calculateStat(baseDefense, level),
+    fieldAttack: calculateStat(baseFieldAttack, level),
+    fieldDefense: calculateStat(baseFieldDefense, level),
+    speed: calculateStat(baseSpeed, level),
+    
+    // Base Stats
+    baseHp,
+    baseAttack,
+    baseDefense,
+    baseFieldAttack,
+    baseFieldDefense,
+    baseSpeed,
+    
+    // Battle
+    moves,
+    nature: 'hardy', // Default nature
+    
+    // Roster
+    isInRoster: false,
+    rosterPosition: undefined,
+    
+    // Metadata
+    caughtAt: new Date(),
+    bst,
+    tier: stats.rarity > 80 ? 'legendary' : stats.rarity > 60 ? 'rare' : stats.rarity > 40 ? 'uncommon' : 'common',
+    role: 'balanced', // Could be enhanced based on stat distribution
+    variance: 0,
+    
+    // Original generation data
+    imageUrl: monster.imageUrl,
+    imageData: monster.imageData,
+    imageCaption: monster.imageCaption,
+    concept: monster.concept,
+    imagePrompt: monster.imagePrompt
+  };
+}
+
+// Save a new PicletInstance
+export async function savePicletInstance(piclet: Omit<PicletInstance, 'id'>): Promise<number> {
+  return await db.picletInstances.add(piclet);
+}
+
+// Get all PicletInstances
+export async function getAllPicletInstances(): Promise<PicletInstance[]> {
+  return await db.picletInstances.toArray();
+}
+
+// Get roster PicletInstances
+export async function getRosterPiclets(): Promise<PicletInstance[]> {
+  return await db.picletInstances
+    .where('isInRoster')
+    .equals(1)
+    .sortBy('rosterPosition');
+}
+
+// Update roster position
+export async function updateRosterPosition(id: number, position: number | undefined): Promise<void> {
+  await db.picletInstances.update(id, {
+    isInRoster: position !== undefined,
+    rosterPosition: position
+  });
+}
+
+// Delete a PicletInstance
+export async function deletePicletInstance(id: number): Promise<void> {
+  await db.picletInstances.delete(id);
+}

src/lib/db/schema.ts

@@ -1,13 +1,132 @@
-import type { MonsterStats } from '$lib/types';
+// Enums
+export enum EncounterType {
+  WILD_PICLET = 'wildPiclet',
+  TRAINER_BATTLE = 'trainerBattle',
+  SHOP = 'shop',
+  HEALTH_CENTER = 'healthCenter'
+}
 
+// Battle Move embedded object
+export interface BattleMove {
+  name: string;
+  type: string;
+  power: number;
+  accuracy: number;
+  pp: number;
+  currentPp: number;
+  description: string;
+}
+
+// PicletInstance - Individual monster instances owned by the player
+export interface PicletInstance {
+  id?: number;
+  
+  // Type Info
+  typeId: string;
+  nickname?: string;
+  primaryTypeString: string;
+  secondaryTypeString?: string;
+  
+  // Current Stats
+  currentHp: number;
+  maxHp: number;
+  level: number;
+  xp: number;
+  attack: number;
+  defense: number;
+  fieldAttack: number;
+  fieldDefense: number;
+  speed: number;
+  
+  // Base Stats (from generation)
+  baseHp: number;
+  baseAttack: number;
+  baseDefense: number;
+  baseFieldAttack: number;
+  baseFieldDefense: number;
+  baseSpeed: number;
+  
+  // Battle
+  moves: BattleMove[];
+  nature: string;
+  
+  // Roster
+  isInRoster: boolean;
+  rosterPosition?: number; // 0-5 when in roster
+  
+  // Metadata
+  caughtAt: Date;
+  bst: number; // Base Stat Total
+  tier: string;
+  role: string;
+  variance: number;
+  
+  // Original generation data
+  imageUrl: string;
+  imageData?: string; // Base64 encoded image with transparency
+  imageCaption: string;
+  concept: string;
+  imagePrompt: string;
+}
+
+// Encounter - Game encounters
+export interface Encounter {
+  id?: number;
+  
+  // Type
+  type: EncounterType;
+  
+  // Details
+  title: string;
+  description: string;
+  picletTypeId?: string; // For wild piclet encounters
+  enemyLevel?: number;
+  
+  // Timing
+  createdAt: Date;
+}
+
+// GameState - Overall game progress
+export interface GameState {
+  id?: number;
+  
+  // Timing
+  lastEncounterRefresh: Date;
+  lastPlayed: Date;
+  
+  // Progress (0-1000)
+  progressPoints: number;
+  trainersDefeated: number;
+  picletsCapured: number;
+  battlesLost: number;
+}
+
+// Legacy Monster interface for backward compatibility
 export interface Monster {
   id?: number;
   name: string;
   imageUrl: string;
-  imageData?: string; // Base64 encoded image with transparency
+  imageData?: string;
   imageCaption: string;
   concept: string;
   imagePrompt: string;
-  stats?: MonsterStats; // JSON stats object
+  stats?: {
+    name: string;
+    description: string;
+    rarity: number;
+    HP: number;
+    defence: number;
+    attack: number;
+    speed: number;
+    specialPassiveTrait: string;
+    attackActionName: string;
+    attackActionDescription: string;
+    buffActionName: string;
+    buffActionDescription: string;
+    debuffActionName: string;
+    debuffActionDescription: string;
+    specialActionName: string;
+    specialActionDescription: string;
+  };
   createdAt: Date;
 }