complex piclet

src/lib/components/PicletGenerator/PicletGenerator.svelte

@@ -455,8 +455,8 @@ Create a concise visual description (1-3 sentences, max 100 words). Focus only o
     const rarityMatch = state.picletConcept.match(/# Object Rarity\s*\n([\s\S]*?)(?=^#)/m);
     const objectRarity = rarityMatch ? rarityMatch[1].trim().toLowerCase() : 'common';
     
-    // Create stats prompt using both the detailed object description and monster concept
-    const statsPrompt = `Based on this detailed object description and monster concept, generate a JSON object with battle stats and abilities:
+    // Create comprehensive battle-ready monster prompt
+    const statsPrompt = `Based on this detailed object description and monster concept, create a complete battle-ready monster for the Pictuary Battle System:
 
 ORIGINAL OBJECT DESCRIPTION:
 "${state.imageCaption}"
@@ -466,54 +466,194 @@ MONSTER CONCEPT:
 
 The object rarity has been assessed as: ${objectRarity}
 
-Use this rarity level to determine appropriate stats:
+## BATTLE SYSTEM OVERVIEW
+This monster will be used in a turn-based battle system with composable effects. You must create:
+1. **Base Stats**: Core combat statistics  
+2. **Special Ability**: Passive trait with triggers and effects
+3. **Movepool**: 4 battle moves with complex effect combinations
 
-Next, determine the monster's type based on its concept and appearance. Choose the most appropriate type from these options:
-• BEAST: Vertebrate wildlife — mammals, birds, reptiles. Raw physicality, instincts, region-based variants.
-• BUG: Arthropods — butterflies, beetles, mantises. Agile swarms, precision strikes, metamorph evolutions.
-• AQUATIC: Life that swims, dives, sloshes, seeps — fish, octopus, sentient puddles. Tides, mist, pressure.
-• FLORA: Plants and fungi — blooming or decaying. Growth, spores, vines, seasonal shifts.
-• MINERAL: Stones, crystals, metals — earth's depths. Durability, reflective armor, seismic shocks.
-• SPACE: Stars, moon, cosmic objects — not of this world. Celestial energy and cosmic forces.
-• MACHINA: Engineered devices — gadgets to machinery. Gears, circuits, drones, power surges.
-• STRUCTURE: Buildings, bridges, monuments — architectural titans. Fortification, terrain shaping.
-• CULTURE: Art, fashion, toys, symbols — creative expressions. Buffs, debuffs, illusion, stories.
-• CUISINE: Dishes, drinks, culinary art — flavors and aromas. Temperature, restorative, spicy offense.
+## TYPE SYSTEM
+Choose the primary type (and optional secondary type) based on the object:
+• **beast**: Vertebrate wildlife — mammals, birds, reptiles. Raw physicality, instincts
+• **bug**: Arthropods — butterflies, beetles, mantises. Agile swarms, precision strikes  
+• **aquatic**: Life that swims, dives, sloshes — fish, octopus, sentient puddles. Tides, pressure
+• **flora**: Plants and fungi — blooming or decaying. Growth, spores, vines, seasonal shifts
+• **mineral**: Stones, crystals, metals — earth's depths. Durability, reflective armor, seismic shocks
+• **space**: Stars, moon, cosmic objects — not of this world. Celestial energy, gravitational effects
+• **machina**: Engineered devices — gadgets to machinery. Gears, circuits, drones, power surges
+• **structure**: Buildings, bridges, monuments — architectural titans. Fortification, terrain shaping
+• **culture**: Art, fashion, toys, symbols — creative expressions. Buffs, debuffs, illusion, stories
+• **cuisine**: Dishes, drinks, culinary art — flavors and aromas. Temperature, restorative effects
 
-The output should be formatted as a JSON instance that conforms to the JSON schema below.
+## EFFECT SYSTEM
+All abilities and moves use these **atomic building blocks**:
+
+### **Effect Types:**
+1. **damage**: Deal damage (weak/normal/strong/extreme) with formulas (standard/recoil/drain/fixed/percentage)
+2. **modifyStats**: Change stats (increase/decrease/greatly_increase/greatly_decrease) for hp/attack/defense/speed/accuracy  
+3. **applyStatus**: Apply status effects (burn/freeze/paralyze/poison/sleep/confuse) with chance percentage
+4. **heal**: Restore HP (small/medium/large/full) or by percentage/fixed amounts
+5. **manipulatePP**: Drain, restore, or disable PP from moves
+6. **fieldEffect**: Battlefield modifications (reflect, lightScreen, spikes, etc.)
+7. **counter**: Reflect damage based on attack type (physical/special/any)
+8. **priority**: Modify move priority (-5 to +5)
+9. **removeStatus**: Cure specific status conditions
+10. **mechanicOverride**: Modify core game mechanics (immunity, type changes, etc.)
+
+### **Targets:**
+- **self**: The move user
+- **opponent**: The target opponent  
+- **all**: All combatants
+- **allies**: Allied creatures (team battles)
+- **field**: Entire battlefield
+
+### **Conditions:**
+- **always**: Effect always applies
+- **onHit**: Only if move hits successfully  
+- **afterUse**: After move execution regardless of hit/miss
+- **onCritical**: Only on critical hits
+- **ifLowHp**: If user's HP < 25%
+- **ifHighHp**: If user's HP > 75%
+
+### **Move Flags:**
+Moves can have flags affecting interactions:
+- **contact**: Makes physical contact (triggers contact abilities)
+- **explosive**: Explosive move (affected by explosion-related abilities)
+- **draining**: Drains HP from target
+- **priority**: Natural priority move (+1 to +5)
+- **sacrifice**: Involves self-sacrifice or major cost
+- **reckless**: High power with drawbacks
+
+## SPECIAL ABILITY TRIGGERS
+Special abilities activate on specific events:
+- **onSwitchIn**: When entering battle
+- **onDamageTaken**: When this monster takes damage
+- **onContactDamage**: When hit by a contact move
+- **endOfTurn**: At the end of each turn
+- **onLowHP**: When HP drops below 25%
+- **onStatusInflicted**: When a status is applied
+
+## BALANCING GUIDELINES
+**Stat Ranges by Rarity:**
+- **common**: 45-80 total stats, individual stats 10-25
+- **uncommon**: 80-120 total stats, individual stats 15-35  
+- **rare**: 120-160 total stats, individual stats 25-45
+- **legendary**: 160-200+ total stats, individual stats 35-50
+
+**Design Philosophy:**
+- **Risk-Reward**: Powerful moves must have meaningful drawbacks
+- **Type Synergy**: Moves should match the monster's type and concept
+- **Strategic Depth**: Abilities should create interesting decision points
+- **No Strictly Better**: Every powerful effect has a cost or condition
+
+The output should be formatted as a JSON instance that conforms to the schema below.
 
 \`\`\`json
 {
+  "type": "object",
   "properties": {
     "name": {"type": "string", "description": "Creative name for the monster that hints at the original object"},
-    "rarity": {"type": "string", "enum": ["common", "uncommon", "rare", "legendary"], "description": "Rarity of the original object based on real-world availability and value"},
-    "picletType": {"type": "string", "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine"], "description": "The type that best matches this monster's concept, appearance, and nature"},
-    "height": {"type": "number", "minimum": 0.1, "maximum": 50.0, "description": "Height of the piclet in meters (e.g., 1.2, 0.5, 10.0)"},
-    "weight": {"type": "number", "minimum": 0.1, "maximum": 10000.0, "description": "Weight of the piclet in kilograms (e.g., 25.4, 150.0, 0.8)"},
-    "HP": {"type": "integer", "minimum": 0, "maximum": 100, "description": "Health/vitality stat (0=fragile, 100=incredibly tanky)"},
-    "defence": {"type": "integer", "minimum": 0, "maximum": 100, "description": "Defensive/armor stat (0=paper thin, 100=impenetrable fortress)"},
-    "attack": {"type": "integer", "minimum": 0, "maximum": 100, "description": "Physical attack power (0=harmless, 100=devastating force)"},
-    "speed": {"type": "integer", "minimum": 0, "maximum": 100, "description": "Movement and reaction speed (0=immobile, 100=lightning fast)"},
-    "monsterLore": {"type": "string", "description": "Write a background story for this monster including its personality, habitat, behavior, and lore (2-3 sentences)"},
-    "specialPassiveTraitDescription": {"type": "string", "description": "Describe a passive ability that gives this monster a unique advantage in battle"},
-    "attackActionName": {"type": "string", "description": "Name of the monster's primary damage-dealing attack (e.g., 'Flame Burst', 'Toxic Bite')"},
-    "attackActionDescription": {"type": "string", "description": "Describe how this attack damages the opponent and any special effects"},
-    "buffActionName": {"type": "string", "description": "Name of the monster's self-enhancement ability (e.g., 'Iron Defense', 'Speed Boost')"},
-    "buffActionDescription": {"type": "string", "description": "Describe which stats are boosted and how this improves the monster's battle performance"},
-    "debuffActionName": {"type": "string", "description": "Name of the monster's enemy-weakening ability (e.g., 'Intimidate', 'Slow Poison')"},
-    "debuffActionDescription": {"type": "string", "description": "Describe which enemy stats are lowered and how this weakens the opponent"},
-    "specialActionName": {"type": "string", "description": "Name of the monster's ultimate move (one use per battle)"},
-    "specialActionDescription": {"type": "string", "description": "Describe this powerful finishing move and its dramatic effects in battle"}
+    "description": {"type": "string", "description": "Flavor text describing the monster (2-3 sentences)"},
+    "tier": {"type": "string", "enum": ["low", "medium", "high", "legendary"], "description": "Power tier based on rarity: common=low, uncommon=medium, rare=high, legendary=legendary"},
+    "primaryType": {"type": "string", "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine"], "description": "Primary type based on object characteristics"},
+    "secondaryType": {"type": ["string", "null"], "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine", null], "description": "Optional secondary type for dual-type monsters"},
+    "baseStats": {
+      "type": "object",
+      "properties": {
+        "hp": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Hit points"},
+        "attack": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Attack power"},
+        "defense": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Defensive capability"},
+        "speed": {"type": "integer", "minimum": 10, "maximum": 50, "description": "Speed and agility"}
+      },
+      "required": ["hp", "attack", "defense", "speed"],
+      "additionalProperties": false
+    },
+    "nature": {"type": "string", "description": "Personality trait affecting behavior (e.g., 'bold', 'timid', 'hasty')"},
+    "specialAbility": {
+      "type": "object",
+      "properties": {
+        "name": {"type": "string", "description": "Name of the special ability"},
+        "description": {"type": "string", "description": "Description of what the ability does"},
+        "effects": {
+          "type": "array",
+          "items": {"$ref": "#/definitions/Effect"},
+          "description": "Passive effects that are always active"
+        },
+        "triggers": {
+          "type": "array",
+          "items": {"$ref": "#/definitions/Trigger"},
+          "description": "Effects that trigger on specific events"
+        }
+      },
+      "required": ["name", "description"],
+      "additionalProperties": false
+    },
+    "movepool": {
+      "type": "array",
+      "items": {"$ref": "#/definitions/Move"},
+      "minItems": 4,
+      "maxItems": 4,
+      "description": "Exactly 4 battle moves"
+    }
   },
-  "required": ["name", "rarity", "picletType", "height", "weight", "HP", "defence", "attack", "speed", "monsterLore", "specialPassiveTraitDescription", "attackActionName", "attackActionDescription", "buffActionName", "buffActionDescription", "debuffActionName", "debuffActionDescription", "specialActionName", "specialActionDescription"]
+  "required": ["name", "description", "tier", "primaryType", "baseStats", "nature", "specialAbility", "movepool"],
+  "additionalProperties": false,
+  "definitions": {
+    "Effect": {
+      "type": "object",
+      "properties": {
+        "type": {"type": "string", "enum": ["damage", "modifyStats", "applyStatus", "heal", "manipulatePP", "fieldEffect", "counter", "priority", "removeStatus", "mechanicOverride"]},
+        "target": {"type": "string", "enum": ["self", "opponent", "allies", "all", "attacker", "field", "playerSide", "opponentSide"]},
+        "condition": {"type": "string", "enum": ["always", "onHit", "afterUse", "onCritical", "ifLowHp", "ifHighHp", "thisTurn", "nextTurn", "restOfBattle"]}
+      },
+      "required": ["type"],
+      "allOf": [
+        {"if": {"properties": {"type": {"const": "damage"}}}, "then": {"properties": {"amount": {"enum": ["weak", "normal", "strong", "extreme"]}, "formula": {"enum": ["standard", "recoil", "drain", "fixed", "percentage"]}, "value": {"type": "number"}}}},
+        {"if": {"properties": {"type": {"const": "modifyStats"}}}, "then": {"properties": {"stats": {"type": "object", "properties": {"hp": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "attack": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "defense": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "speed": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}, "accuracy": {"enum": ["increase", "decrease", "greatly_increase", "greatly_decrease"]}}}}}},
+        {"if": {"properties": {"type": {"const": "applyStatus"}}}, "then": {"properties": {"status": {"enum": ["burn", "freeze", "paralyze", "poison", "sleep", "confuse"]}, "chance": {"type": "number", "minimum": 1, "maximum": 100}}}},
+        {"if": {"properties": {"type": {"const": "heal"}}}, "then": {"properties": {"amount": {"enum": ["small", "medium", "large", "full"]}, "formula": {"enum": ["percentage", "fixed"]}, "value": {"type": "number"}}}}
+      ]
+    },
+    "Trigger": {
+      "type": "object",
+      "properties": {
+        "event": {"type": "string", "enum": ["onSwitchIn", "onDamageTaken", "onContactDamage", "endOfTurn", "onLowHP", "onStatusInflicted", "beforeMoveUse", "afterMoveUse"]},
+        "condition": {"type": "string", "enum": ["always", "ifLowHp", "ifHighHp", "ifStatus:burn", "ifStatus:freeze", "ifStatus:paralyze", "ifStatus:poison", "ifStatus:sleep", "ifStatus:confuse"]},
+        "effects": {"type": "array", "items": {"$ref": "#/definitions/Effect"}, "minItems": 1}
+      },
+      "required": ["event", "effects"]
+    },
+    "Move": {
+      "type": "object",
+      "properties": {
+        "name": {"type": "string", "description": "Name of the move"},
+        "type": {"type": "string", "enum": ["beast", "bug", "aquatic", "flora", "mineral", "space", "machina", "structure", "culture", "cuisine", "normal"], "description": "Move type for STAB and effectiveness"},
+        "power": {"type": "integer", "minimum": 0, "maximum": 250, "description": "Base power (0 for status moves)"},
+        "accuracy": {"type": "integer", "minimum": 30, "maximum": 100, "description": "Hit chance percentage"},
+        "pp": {"type": "integer", "minimum": 1, "maximum": 40, "description": "Power points (uses per battle)"},
+        "priority": {"type": "integer", "minimum": -5, "maximum": 5, "description": "Priority bracket"},
+        "flags": {"type": "array", "items": {"enum": ["contact", "explosive", "draining", "priority", "sacrifice", "reckless", "bite", "punch", "sound", "ground"]}, "description": "Move characteristics"},
+        "effects": {"type": "array", "items": {"$ref": "#/definitions/Effect"}, "minItems": 1, "description": "What the move does"}
+      },
+      "required": ["name", "type", "power", "accuracy", "pp", "priority", "flags", "effects"],
+      "additionalProperties": false
+    }
+  }
 }
 \`\`\`
 
-Base the HP, defence, attack, and speed stats on the rarity level:
-- common: stats should be 10-40
-- uncommon: stats should be 30-60
-- rare: stats should be 50-80
-- legendary: stats should be 70-100
+**STAT GUIDELINES:**
+Base the tier and stats on the object rarity:
+- **common → low tier**: hp/attack/defense/speed should be 10-25 (total ~40-80)
+- **uncommon → medium tier**: hp/attack/defense/speed should be 15-35 (total ~80-120)
+- **rare → high tier**: hp/attack/defense/speed should be 25-45 (total ~120-160)
+- **legendary → legendary tier**: hp/attack/defense/speed should be 35-50 (total ~160-200)
+
+**MOVE DESIGN EXAMPLES:**
+- **Basic Attack**: {"type": "damage", "target": "opponent", "amount": "normal"}
+- **Status Move**: {"type": "applyStatus", "target": "opponent", "status": "burn", "chance": 30}
+- **Self-Buff**: {"type": "modifyStats", "target": "self", "stats": {"attack": "increase"}}
+- **Risk-Reward**: High power + {"type": "damage", "target": "self", "formula": "recoil", "value": 0.25}
 
 Write your response within \`\`\`json\`\`\``;
     
@@ -605,73 +745,42 @@ Write your response within \`\`\`json\`\`\``;
         
         const parsedStats = JSON.parse(cleanJson.trim());
         
-        // Remove any extra fields not in our schema
-        const allowedFields = ['name', 'rarity', 'picletType', 'height', 'weight', 'HP', 'defence', 'attack', 'speed',
-          'monsterLore', 'specialPassiveTraitDescription', 'attackActionName', 'attackActionDescription',
-          'buffActionName', 'buffActionDescription', 'debuffActionName', 'debuffActionDescription',
-          'specialActionName', 'specialActionDescription', 'boostActionName', 'boostActionDescription',
-          'disparageActionName', 'disparageActionDescription'];
+        // Validate the battle-ready monster structure
+        console.log('Parsed battle monster:', parsedStats);
         
-        for (const key in parsedStats) {
-          if (!allowedFields.includes(key)) {
-            delete parsedStats[key];
-          }
+        // Ensure required fields exist
+        if (!parsedStats.name || !parsedStats.baseStats || !parsedStats.specialAbility || !parsedStats.movepool) {
+          throw new Error('Generated monster is missing required battle system fields');
         }
         
-        // Map rarity to tier
-        if (parsedStats.rarity) {
-          const tierMap: { [key: string]: 'low' | 'medium' | 'high' | 'legendary' } = {
-            'common': 'low',
-            'uncommon': 'medium',
-            'rare': 'high',
-            'legendary': 'legendary'
-          };
-          tier = tierMap[parsedStats.rarity.toLowerCase()] || 'medium';
-        }
-        
-        // Add the description and tier that we extracted/mapped
-        // Use the name from the structured concept, or fall back to JSON response
-        if (!parsedStats.name) {
-          parsedStats.name = monsterName;
+        // Validate movepool has exactly 4 moves
+        if (!Array.isArray(parsedStats.movepool) || parsedStats.movepool.length !== 4) {
+          throw new Error('Monster movepool must contain exactly 4 moves');
         }
-        parsedStats.description = parsedStats.monsterLore || 'A mysterious creature with unknown origins.';
-        parsedStats.tier = tier;
         
-        // Ensure numeric fields are actually numbers
-        const numericFields = ['HP', 'defence', 'attack', 'speed'];
-        
-        for (const field of numericFields) {
-          if (parsedStats[field] !== undefined) {
-            // Convert string numbers to actual numbers
-            parsedStats[field] = parseInt(parsedStats[field]);
-            
-            // Clamp to 0-100 range
-            parsedStats[field] = Math.max(0, Math.min(100, parsedStats[field]));
+        // Ensure all moves have required effect arrays
+        for (const move of parsedStats.movepool) {
+          if (!move.effects || !Array.isArray(move.effects) || move.effects.length === 0) {
+            throw new Error(`Move "${move.name}" is missing effects array`);
           }
         }
         
-        // Map field names from schema to interface
-        if (parsedStats.specialPassiveTraitDescription) {
-          parsedStats.specialPassiveTrait = parsedStats.specialPassiveTraitDescription;
-          delete parsedStats.specialPassiveTraitDescription;
-        }
+        // Use tier from the JSON response
+        tier = parsedStats.tier || 'medium';
         
-        // Handle potential old field names from LLM
-        if (parsedStats.boostActionName) {
-          parsedStats.buffActionName = parsedStats.boostActionName;
-          delete parsedStats.boostActionName;
-        }
-        if (parsedStats.boostActionDescription) {
-          parsedStats.buffActionDescription = parsedStats.boostActionDescription;
-          delete parsedStats.boostActionDescription;
-        }
-        if (parsedStats.disparageActionName) {
-          parsedStats.debuffActionName = parsedStats.disparageActionName;
-          delete parsedStats.disparageActionName;
+        // Ensure the name from structured concept is used if available
+        if (monsterName && monsterName !== 'Unknown Monster') {
+          parsedStats.name = monsterName;
         }
-        if (parsedStats.disparageActionDescription) {
-          parsedStats.debuffActionDescription = parsedStats.disparageActionDescription;
-          delete parsedStats.disparageActionDescription;
+        
+        // Ensure baseStats are numbers within reasonable ranges
+        if (parsedStats.baseStats) {
+          const statFields = ['hp', 'attack', 'defense', 'speed'];
+          for (const field of statFields) {
+            if (parsedStats.baseStats[field] !== undefined) {
+              parsedStats.baseStats[field] = Math.max(10, Math.min(50, parseInt(parsedStats.baseStats[field])));
+            }
+          }
         }
         
         const stats: PicletStats = parsedStats;

src/lib/db/piclets.ts

@@ -1,6 +1,7 @@
 import { db } from './index';
 import type { PicletInstance, Monster, BattleMove } from './schema';
 import { PicletType, AttackType, getTypeFromConcept } from '../types/picletTypes';
+import type { PicletStats } from '../types';
 
 // Convert a generated Monster to a PicletInstance
 export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
@@ -8,13 +9,13 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     throw new Error('Monster must have stats to create PicletInstance');
   }
 
-  const stats = monster.stats;
+  const stats = monster.stats as PicletStats;
   
-  // 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);
+  // Calculate base stats from battle-ready format
+  const baseHp = Math.floor(stats.baseStats.hp * 2 + 50);
+  const baseAttack = Math.floor(stats.baseStats.attack * 1.5 + 30);
+  const baseDefense = Math.floor(stats.baseStats.defense * 1.5 + 30);
+  const baseSpeed = Math.floor(stats.baseStats.speed * 1.5 + 30);
   
   // Field stats are variations of regular stats
   const baseFieldAttack = Math.floor(baseAttack * 0.8);
@@ -26,65 +27,27 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
   
   const maxHp = calculateHp(baseHp, level);
   
-  // Determine primary type - use picletType from stats if available, otherwise auto-detect
-  let primaryType: PicletType;
-  if (monster.stats && (monster.stats as any).picletType) {
-    // Use the type determined during stat generation, but validate it
-    const statsType = (monster.stats as any).picletType as string;
-    const normalizedType = statsType.toLowerCase();
-    
-    // Validate that the type exists in our enum
-    const validType = Object.values(PicletType).find(type => type === normalizedType);
-    if (validType) {
-      primaryType = validType;
-    } else {
-      console.warn(`Invalid picletType "${statsType}" from stats, falling back to concept detection`);
-      primaryType = getTypeFromConcept(monster.concept, monster.imageCaption);
-    }
-  } else {
-    // Fallback to concept-based detection
-    primaryType = getTypeFromConcept(monster.concept, monster.imageCaption);
+  // Determine primary type from battle stats
+  const normalizedType = stats.primaryType.toLowerCase();
+  
+  // Validate that the type exists in our enum
+  const validType = Object.values(PicletType).find(type => type === normalizedType);
+  const primaryType = validType || getTypeFromConcept(monster.concept, monster.imageCaption);
+  
+  if (!validType) {
+    console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
   }
   
-  // Create moves based on monster's abilities
-  const moves: BattleMove[] = [
-    {
-      name: stats.attackActionName,
-      type: primaryType as unknown as AttackType,
-      power: 50,
-      accuracy: 95,
-      pp: 20,
-      currentPp: 20,
-      description: stats.attackActionDescription
-    },
-    {
-      name: stats.buffActionName,
-      type: AttackType.NORMAL,
-      power: 0,
-      accuracy: 100,
-      pp: 15,
-      currentPp: 15,
-      description: stats.buffActionDescription
-    },
-    {
-      name: stats.debuffActionName,
-      type: AttackType.NORMAL,
-      power: 0,
-      accuracy: 85,
-      pp: 15,
-      currentPp: 15,
-      description: stats.debuffActionDescription
-    },
-    {
-      name: stats.specialActionName,
-      type: primaryType as unknown as AttackType,
-      power: 80,
-      accuracy: 90,
-      pp: 5,
-      currentPp: 5,
-      description: stats.specialActionDescription
-    }
-  ];
+  // Create moves from battle-ready format
+  const moves: BattleMove[] = stats.movepool.map(move => ({
+    name: move.name,
+    type: move.type as unknown as AttackType,
+    power: move.power,
+    accuracy: move.accuracy,
+    pp: move.pp,
+    currentPp: move.pp,
+    description: `${move.effects.length} effects` // Simplified description for now
+  }));
   
   const bst = baseHp + baseAttack + baseDefense + baseFieldAttack + baseFieldDefense + baseSpeed;
   
@@ -125,7 +88,7 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     // Metadata
     caughtAt: new Date(),
     bst,
-    tier: (stats as any).tier || 'medium', // Use tier from stats, default to medium
+    tier: stats.tier, // Use tier from battle-ready stats
     role: 'balanced', // Could be enhanced based on stat distribution
     variance: 0,
     

src/lib/types/index.ts

@@ -103,22 +103,57 @@ export interface PicletGeneratorProps {
   qwenClient: GradioClient | null;
 }
 
-// Piclet Stats Types
+// Piclet Stats Types - now compatible with battle engine
 export interface PicletStats {
   name: string;
   description: string;
   tier: 'low' | 'medium' | 'high' | 'legendary';
-  HP: number; // 0-100
-  defence: number; // 0-100
-  attack: number; // 0-100
-  speed: number; // 0-100
-  specialPassiveTrait: string;
-  attackActionName: string;
-  attackActionDescription: string;
-  buffActionName: string;
-  buffActionDescription: string;
-  debuffActionName: string;
-  debuffActionDescription: string;
-  specialActionName: string;
-  specialActionDescription: string;
+  primaryType: 'beast' | 'bug' | 'aquatic' | 'flora' | 'mineral' | 'space' | 'machina' | 'structure' | 'culture' | 'cuisine';
+  secondaryType?: 'beast' | 'bug' | 'aquatic' | 'flora' | 'mineral' | 'space' | 'machina' | 'structure' | 'culture' | 'cuisine' | null;
+  baseStats: {
+    hp: number;
+    attack: number;
+    defense: number;
+    speed: number;
+  };
+  nature: string;
+  specialAbility: {
+    name: string;
+    description: string;
+    effects?: BattleEffect[];
+    triggers?: AbilityTrigger[];
+  };
+  movepool: BattleMove[];
+}
+
+// Battle system effect types for PicletStats
+export interface BattleEffect {
+  type: 'damage' | 'modifyStats' | 'applyStatus' | 'heal' | 'manipulatePP' | 'fieldEffect' | 'counter' | 'priority' | 'removeStatus' | 'mechanicOverride';
+  target: 'self' | 'opponent' | 'allies' | 'all' | 'attacker' | 'field' | 'playerSide' | 'opponentSide';
+  condition?: string;
+  // Additional properties based on effect type
+  amount?: string;
+  formula?: string;
+  value?: number;
+  stats?: { [key: string]: string };
+  status?: string;
+  chance?: number;
+  [key: string]: any; // Allow additional properties for different effect types
+}
+
+export interface AbilityTrigger {
+  event: string;
+  condition?: string;
+  effects: BattleEffect[];
+}
+
+export interface BattleMove {
+  name: string;
+  type: 'beast' | 'bug' | 'aquatic' | 'flora' | 'mineral' | 'space' | 'machina' | 'structure' | 'culture' | 'cuisine' | 'normal';
+  power: number;
+  accuracy: number;
+  pp: number;
+  priority: number;
+  flags: string[];
+  effects: BattleEffect[];
 }