capture

src/lib/battle-engine/BattleEngine.ts

@@ -10,6 +10,7 @@ import type {
   BattleAction, 
   MoveAction,
   SwitchAction,
+  CaptureAction,
   BattleEffect,
   DamageAmount,
   StatModification,
@@ -20,6 +21,7 @@ import type {
   Trigger
 } from './types';
 import { getEffectivenessMultiplier } from '../types/picletTypes';
+import { attemptCapture, getCatchRateForTier, calculateCapturePercentage } from '../services/captureService';
 
 export class BattleEngine {
   private state: BattleState;
@@ -123,6 +125,30 @@ export class BattleEngine {
     return this.state.winner;
   }
 
+  public getCapturePercentage(): number {
+    const targetPiclet = this.state.opponentPiclet;
+    
+    // Get capture parameters
+    const maxHp = targetPiclet.maxHp;
+    const currentHp = targetPiclet.currentHp;
+    const tier = targetPiclet.definition.tier;
+    const baseCatchRate = getCatchRateForTier(tier);
+    
+    // Get status effect for capture bonus
+    let statusEffect: string | null = null;
+    if (targetPiclet.statusEffects.length > 0) {
+      statusEffect = targetPiclet.statusEffects[0];
+    }
+
+    return calculateCapturePercentage({
+      maxHp,
+      currentHp,
+      baseCatchRate,
+      statusEffect,
+      picletLevel: targetPiclet.level
+    });
+  }
+
   public executeActions(playerAction: BattleAction, opponentAction: BattleAction): void {
     if (this.state.phase !== 'selection') {
       throw new Error('Cannot execute actions - battle is not in selection phase');
@@ -226,6 +252,8 @@ export class BattleEngine {
       this.executeMove(action);
     } else if (action.type === 'switch') {
       this.executeSwitch(action as SwitchAction & { executor: 'player' | 'opponent' });
+    } else if (action.type === 'capture') {
+      this.executeCapture(action as CaptureAction & { executor: 'player' | 'opponent' });
     }
   }
 
@@ -357,6 +385,90 @@ export class BattleEngine {
     this.triggerOnSwitchIn(newPiclet);
   }
 
+  private executeCapture(action: CaptureAction & { executor: 'player' | 'opponent' }): void {
+    // Only player can capture (wild battles only)
+    if (action.executor !== 'player') {
+      this.log('Only the player can capture Piclets!');
+      return;
+    }
+
+    // Can't capture in trainer battles (this would be determined by battle context)
+    // For now, we'll assume this is a wild battle
+
+    const targetPiclet = this.state.opponentPiclet;
+    
+    // Get capture parameters
+    const maxHp = targetPiclet.maxHp;
+    const currentHp = targetPiclet.currentHp;
+    const tier = targetPiclet.definition.tier;
+    const baseCatchRate = getCatchRateForTier(tier);
+    
+    // Get status effect for capture bonus
+    let statusEffect: string | null = null;
+    if (targetPiclet.statusEffects.length > 0) {
+      // Use the first status effect (most Pokemon games only allow one)
+      statusEffect = targetPiclet.statusEffects[0];
+    }
+
+    // Calculate capture percentage for display
+    const capturePercentage = calculateCapturePercentage({
+      maxHp,
+      currentHp,
+      baseCatchRate,
+      statusEffect,
+      picletLevel: targetPiclet.level
+    });
+
+    // Attempt the capture
+    const result = attemptCapture({
+      maxHp,
+      currentHp,
+      baseCatchRate,
+      statusEffect,
+      picletLevel: targetPiclet.level
+    });
+
+    // Store capture result in battle state
+    this.state.captureResult = {
+      success: result.success,
+      shakes: result.shakes,
+      odds: result.odds,
+      capturePercentage
+    };
+
+    // Log the attempt
+    this.log(`Player threw a camera at ${targetPiclet.definition.name}!`);
+    
+    // Log shakes
+    if (result.shakes === 0) {
+      this.log('The camera broke immediately!');
+    } else {
+      const shakeText = result.shakes === 1 ? 'once' : result.shakes === 2 ? 'twice' : 'three times';
+      this.log(`The camera shook ${shakeText}...`);
+    }
+
+    if (result.success) {
+      this.log(`${targetPiclet.definition.name} was captured!`);
+      // Set winner to player (capture ends the battle)
+      this.state.winner = 'player';
+      this.state.phase = 'ended';
+    } else {
+      this.log(`${targetPiclet.definition.name} broke free!`);
+      // Capture failed, battle continues
+      // The opponent gets a turn after a failed capture attempt
+    }
+
+    console.log('📸 Capture attempt:', {
+      target: targetPiclet.definition.name,
+      hp: `${currentHp}/${maxHp}`,
+      status: statusEffect,
+      catchRate: baseCatchRate,
+      percentage: capturePercentage.toFixed(1) + '%',
+      result: result.success ? 'SUCCESS' : 'FAILED',
+      shakes: result.shakes
+    });
+  }
+
   private getCurrentPicletIndex(executor: 'player' | 'opponent'): number {
     const isPlayer = executor === 'player';
     const roster = isPlayer ? this.playerRoster : this.opponentRoster;

src/lib/battle-engine/types.ts

@@ -231,6 +231,14 @@ export interface BattleState {
   log: string[];
   
   winner?: 'player' | 'opponent' | 'draw';
+  
+  // Capture result (for wild battles)
+  captureResult?: {
+    success: boolean;
+    shakes: number;
+    odds: number;
+    capturePercentage: number;
+  };
 }
 
 // Action Types
@@ -246,4 +254,9 @@ export interface SwitchAction {
   newPicletIndex: number;
 }
 
-export type BattleAction = MoveAction | SwitchAction;
+export interface CaptureAction {
+  type: 'capture';
+  piclet: 'player'; // Only player can capture
+}
+
+export type BattleAction = MoveAction | SwitchAction | CaptureAction;

src/lib/components/Battle/ActionButtons.svelte

@@ -10,6 +10,7 @@
   export let availablePiclets: PicletInstance[] = [];
   export let processingTurn: boolean = false;
   export let battleState: BattleState | undefined = undefined;
+  export let capturePercentage: number = 0;
   export let onAction: (action: string) => void;
   export let onMoveSelect: (move: BattleMove) => void = () => {};
   export let onPicletSelect: (piclet: PicletInstance) => void = () => {};
@@ -53,6 +54,7 @@
     {enemyPiclet}
     {isWildBattle}
     {battleState}
+    {capturePercentage}
     onMoveSelected={handleMoveSelected}
     onPicletSelected={handlePicletSelected}
     onCaptureAttempt={handleCaptureAttempt}

src/lib/components/Battle/ActionViewSelector.svelte

@@ -6,6 +6,7 @@
   import type { PicletInstance, BattleMove } from '$lib/db/schema';
   import type { BattleState } from '$lib/battle-engine/types';
   import { generateMoveDescription } from '$lib/utils/moveDescriptions';
+  import { getCaptureDescription } from '$lib/services/captureService';
   
   export let currentView: ActionView = 'main';
   export let onViewChange: (view: ActionView) => void;
@@ -14,6 +15,7 @@
   export let enemyPiclet: PicletInstance | null = null;
   export let isWildBattle: boolean = false;
   export let battleState: BattleState | undefined = undefined;
+  export let capturePercentage: number = 0;
   export let onMoveSelected: (move: BattleMove) => void = () => {};
   export let onPicletSelected: (piclet: PicletInstance) => void = () => {};
   export let onCaptureAttempt: () => void = () => {};
@@ -173,8 +175,8 @@
               >
                 <span class="item-icon">📸</span>
                 <div class="item-info">
-                  <div class="item-name">Capture</div>
-                  <div class="item-desc">Snap to capture {enemyPiclet.nickname}</div>
+                  <div class="item-name">Capture ({capturePercentage.toFixed(1)}%)</div>
+                  <div class="item-desc">{getCaptureDescription(capturePercentage)} - {enemyPiclet.nickname}</div>
                 </div>
               </button>
             {:else}

src/lib/components/Battle/BattleControls.svelte

@@ -13,6 +13,7 @@
   export let enemyPiclet: PicletInstance;
   export let rosterPiclets: PicletInstance[] = [];
   export let battleState: BattleState | undefined = undefined;
+  export let capturePercentage: number = 0;
   export let onAction: (action: string) => void;
   export let onMoveSelect: (move: any) => void;
   export let onPicletSelect: (piclet: PicletInstance) => void;
@@ -47,6 +48,7 @@
         {availablePiclets}
         {processingTurn}
         {battleState}
+        {capturePercentage}
         {onAction}
         {onMoveSelect}
         {onPicletSelect}

src/lib/components/Pages/Battle.svelte

@@ -10,6 +10,7 @@
   import { calculateBattleXp, processAllLevelUps } from '$lib/services/levelingService';
   import { db } from '$lib/db/index';
   import { getEffectivenessText, getEffectivenessColor } from '$lib/types/picletTypes';
+  import { getCaptureDescription } from '$lib/services/captureService';
   
   export let playerPiclet: PicletInstance;
   export let enemyPiclet: PicletInstance;
@@ -23,6 +24,9 @@
   let currentPlayerPiclet = playerPiclet;
   let currentEnemyPiclet = enemyPiclet;
   
+  // Calculate capture percentage for UI display
+  $: capturePercentage = battleEngine && isWildBattle ? battleEngine.getCapturePercentage() : 0;
+  
   // Battle state
   let currentMessage = isWildBattle 
     ? `A wild ${enemyPiclet.nickname} appeared!` 
@@ -123,13 +127,76 @@
     
     switch (action) {
       case 'catch':
-        if (isWildBattle) {
+        if (isWildBattle && battleEngine) {
           processingTurn = true;
-          currentMessage = 'You took a Pic-ture!';
-          setTimeout(() => {
-            currentMessage = 'The wild piclet broke free!';
+          
+          // Get capture percentage to show to player
+          const capturePercentage = battleEngine.getCapturePercentage();
+          const captureDescription = getCaptureDescription(capturePercentage);
+          
+          console.log(`📸 Capture attempt: ${capturePercentage.toFixed(1)}% chance (${captureDescription})`);
+          
+          try {
+            // Create capture action
+            const captureAction = { type: 'capture' as const, piclet: 'player' as const };
+            // Create a no-op enemy action
+            const enemyAction = { type: 'move' as const, piclet: 'opponent' as const, moveIndex: 0 };
+            
+            // Get log entries before action to track new messages
+            const logBefore = battleEngine.getLog();
+            
+            // Execute capture attempt
+            battleEngine.executeActions(captureAction, enemyAction);
+            battleState = battleEngine.getState();
+            
+            // Get capture result and new log entries
+            const captureResult = battleState.captureResult;
+            const logAfter = battleEngine.getLog();
+            const newLogEntries = logAfter.slice(logBefore.length);
+            
+            // Show log messages with proper timing
+            if (newLogEntries.length > 0) {
+              let messageIndex = 0;
+              
+              const showNextMessage = () => {
+                if (messageIndex < newLogEntries.length) {
+                  currentMessage = newLogEntries[messageIndex];
+                  messageIndex++;
+                  setTimeout(showNextMessage, 1500); // 1.5s between messages
+                } else {
+                  // All messages shown, check final result
+                  if (captureResult?.success) {
+                    // Capture successful - end battle and add to roster
+                    setTimeout(() => {
+                      battleEnded = true;
+                      onBattleEnd(true, 'captured'); // Pass special 'captured' result
+                    }, 1000);
+                  } else {
+                    // Capture failed - continue battle
+                    setTimeout(() => {
+                      processingTurn = false;
+                      currentMessage = `What will ${currentPlayerPiclet.nickname} do?`;
+                    }, 1000);
+                  }
+                }
+              };
+              
+              showNextMessage();
+            } else {
+              // No messages, fall back to basic handling
+              currentMessage = 'The capture attempt failed!';
+              setTimeout(() => {
+                processingTurn = false;
+              }, 2000);
+            }
+            
+          } catch (error) {
+            console.error('Capture error:', error);
+            currentMessage = 'Something went wrong with the capture attempt!';
             processingTurn = false;
-          }, 2000);
+          }
+        } else if (!isWildBattle) {
+          currentMessage = "You can't capture a trainer's Piclet!";
         }
         break;
       case 'run':
@@ -723,6 +790,7 @@
       enemyPiclet={currentEnemyPiclet}
       {rosterPiclets}
       {battleState}
+      {capturePercentage}
       {waitingForContinue}
       onAction={handleAction}
       onMoveSelect={handleMoveSelect}

src/lib/services/captureService.ts

@@ -0,0 +1,212 @@
+/**
+ * Pokemon-style Capture Mechanics for Pictuary
+ * Based on Pokemon Emerald's capture formula from POKEMON_CAPTURE_MECHANICS.md
+ */
+
+export interface CaptureResult {
+  success: boolean;
+  shakes: number; // 0-3 shakes before success/failure
+  odds: number; // Internal capture odds for debugging
+}
+
+export interface CaptureAttemptParams {
+  // Target Piclet stats
+  maxHp: number;
+  currentHp: number;
+  baseCatchRate: number; // Species-specific catch rate (3-255)
+  
+  // Status effects (optional)
+  statusEffect?: 'sleep' | 'freeze' | 'poison' | 'burn' | 'paralysis' | 'toxic' | null;
+  
+  // Battle context (optional - for future specialty ball mechanics)
+  battleTurn?: number;
+  picletLevel?: number;
+}
+
+/**
+ * Get the catch rate multiplier for a given tier
+ * Maps Pictuary tiers to Pokemon-style catch rates
+ */
+export function getCatchRateForTier(tier: string): number {
+  switch (tier.toLowerCase()) {
+    case 'legendary': return 3;   // Hardest to catch (like legendary Pokemon)
+    case 'high': return 25;       // Hard to catch (like pseudolegendaries)
+    case 'medium': return 75;     // Standard catch rate
+    case 'low': return 150;       // Easy to catch (like common Pokemon)
+    default: return 75;           // Default to medium
+  }
+}
+
+/**
+ * Get status condition multiplier for capture rate
+ */
+function getStatusMultiplier(status: string | null | undefined): number {
+  switch (status) {
+    case 'sleep':
+    case 'freeze':
+      return 2.0; // Best status conditions for catching
+    case 'poison':
+    case 'burn':
+    case 'paralysis':
+    case 'toxic':
+      return 1.5; // Good status conditions
+    default:
+      return 1.0; // No status effect
+  }
+}
+
+/**
+ * Calculate initial capture odds using Pokemon formula
+ * Formula: odds = (catchRate × ballMultiplier ÷ 10) × (maxHP × 3 - currentHP × 2) ÷ (maxHP × 3) × statusMultiplier
+ */
+function calculateCaptureOdds(params: CaptureAttemptParams): number {
+  const { maxHp, currentHp, baseCatchRate, statusEffect } = params;
+  
+  // Ball multiplier - since we don't have different camera types, use baseline 1.0x (10 in Pokemon terms)
+  const ballMultiplier = 10;
+  
+  // HP factor: (maxHP × 3 - currentHP × 2) ÷ (maxHP × 3)
+  // This creates the 3x capture boost when HP is at 1
+  const hpFactor = (maxHp * 3 - currentHp * 2) / (maxHp * 3);
+  
+  // Status multiplier
+  const statusMultiplier = getStatusMultiplier(statusEffect);
+  
+  // Core formula
+  const odds = (baseCatchRate * ballMultiplier / 10) * hpFactor * statusMultiplier;
+  
+  return Math.max(0, Math.floor(odds));
+}
+
+/**
+ * Calculate shake probability when capture odds <= 254
+ * Formula: shakeOdds = 1048560 ÷ sqrt(sqrt(16711680 ÷ odds))
+ */
+function calculateShakeOdds(captureOdds: number): number {
+  if (captureOdds === 0) return 0;
+  
+  const shakeOdds = 1048560 / Math.sqrt(Math.sqrt(16711680 / captureOdds));
+  return Math.floor(shakeOdds);
+}
+
+/**
+ * Simulate individual shake success
+ * Each shake has a (shakeOdds / 65536) chance of success
+ */
+function simulateShake(shakeOdds: number): boolean {
+  const randomValue = Math.floor(Math.random() * 65536);
+  return randomValue < shakeOdds;
+}
+
+/**
+ * Attempt to capture a Piclet using Pokemon mechanics
+ * Returns detailed results including number of shakes
+ */
+export function attemptCapture(params: CaptureAttemptParams): CaptureResult {
+  const odds = calculateCaptureOdds(params);
+  
+  // Immediate capture if odds > 254
+  if (odds > 254) {
+    return {
+      success: true,
+      shakes: 3,
+      odds
+    };
+  }
+  
+  // If odds are 0, capture fails immediately
+  if (odds === 0) {
+    return {
+      success: false,
+      shakes: 0,
+      odds
+    };
+  }
+  
+  // Calculate shake probability
+  const shakeOdds = calculateShakeOdds(odds);
+  
+  // Simulate up to 3 shakes
+  let shakes = 0;
+  for (let i = 0; i < 3; i++) {
+    if (simulateShake(shakeOdds)) {
+      shakes++;
+    } else {
+      // Shake failed, capture fails
+      return {
+        success: false,
+        shakes,
+        odds
+      };
+    }
+  }
+  
+  // All 3 shakes succeeded - capture success!
+  return {
+    success: true,
+    shakes: 3,
+    odds
+  };
+}
+
+/**
+ * Calculate capture rate percentage for display purposes
+ * This gives players an approximate idea of their chances
+ */
+export function calculateCapturePercentage(params: CaptureAttemptParams): number {
+  const odds = calculateCaptureOdds(params);
+  
+  // Immediate capture
+  if (odds > 254) return 100;
+  
+  // No chance
+  if (odds === 0) return 0;
+  
+  // For odds <= 254, we need to calculate the probability of getting 3 successful shakes
+  const shakeOdds = calculateShakeOdds(odds);
+  const shakeSuccessRate = shakeOdds / 65536;
+  
+  // Probability of 3 consecutive successful shakes
+  const captureRate = Math.pow(shakeSuccessRate, 3) * 100;
+  
+  return Math.min(100, Math.max(0.1, captureRate)); // At least 0.1% to show something
+}
+
+/**
+ * Get a user-friendly description of capture difficulty based on percentage
+ */
+export function getCaptureDescription(percentage: number): string {
+  if (percentage >= 95) return "Almost certain";
+  if (percentage >= 75) return "Very likely";
+  if (percentage >= 50) return "Good chance";
+  if (percentage >= 25) return "Moderate chance";
+  if (percentage >= 10) return "Low chance";
+  if (percentage >= 5) return "Very low chance";
+  return "Extremely difficult";
+}
+
+/**
+ * Simulate multiple capture attempts to get average results (for testing/balancing)
+ */
+export function simulateMultipleCaptures(params: CaptureAttemptParams, attempts: number = 1000): {
+  successRate: number;
+  averageShakes: number;
+  distribution: { [key: number]: number };
+} {
+  let successes = 0;
+  let totalShakes = 0;
+  const shakeDistribution: { [key: number]: number } = { 0: 0, 1: 0, 2: 0, 3: 0 };
+  
+  for (let i = 0; i < attempts; i++) {
+    const result = attemptCapture(params);
+    if (result.success) successes++;
+    totalShakes += result.shakes;
+    shakeDistribution[result.shakes]++;
+  }
+  
+  return {
+    successRate: (successes / attempts) * 100,
+    averageShakes: totalShakes / attempts,
+    distribution: shakeDistribution
+  };
+}