better gen

src/lib/components/MonsterGenerator/MonsterGenerator.svelte

@@ -33,19 +33,22 @@ Guidelines:
 - Add eyes (can be glowing, mechanical, multiple, etc.) positioned where they make sense
 - Include limbs (legs, arms, wings, tentacles) that grow from or replace parts of the object
 - Add a mouth, beak, or feeding apparatus if appropriate
-- Add creature elements like tail, fins, claws, or horns where fitting
+- Add creature elements like tail, fins, claws, horns, etc where fitting
 
 Include:
 - A creative name that hints at the original object
 - Physical description showing how the object becomes a creature
-- Special abilities derived from the object's function
 - Personality traits based on the object's purpose
 
 Format your response as:
 \`\`\`
+# Object Caption
+{object description, also assess how rare the object is, the rarer the object the stronger the monster}
+# Transformation Brainstorm
+{think through how to transform the object into a Pokémon-like creature}
 # {monster name}
 ## Monster Visual Description
-...
+{ensure the creature uses all the unique attributes of the object}
 ## Monster Lore
 ...
 \`\`\``;

src/lib/components/Pages/Battle.svelte

@@ -1,9 +1,11 @@
 <script lang="ts">
   import { onMount } from 'svelte';
   import { fade } from 'svelte/transition';
-  import type { PicletInstance } from '$lib/db/schema';
+  import type { PicletInstance, BattleMove } from '$lib/db/schema';
   import BattleField from '../Battle/BattleField.svelte';
   import BattleControls from '../Battle/BattleControls.svelte';
+  import { BattleService } from '$lib/db/battleService';
+  import { getEffectivenessText, getEffectivenessColor } from '$lib/types/picletTypes';
   
   export let playerPiclet: PicletInstance;
   export let enemyPiclet: PicletInstance;
@@ -60,39 +62,85 @@
     }
   }
   
-  function handleMoveSelect(move: any) {
+  function handleMoveSelect(move: BattleMove) {
     battlePhase = 'main';
     processingTurn = true;
     currentMessage = `${playerPiclet.nickname} used ${move.name}!`;
     
-    // Mock damage
     setTimeout(() => {
-      enemyHpPercentage = Math.max(0, enemyHpPercentage - 0.2);
+      if (!BattleService.doesMoveHit(move.accuracy)) {
+        currentMessage = `${playerPiclet.nickname}'s attack missed!`;
+        setTimeout(() => enemyTurn(), 1500);
+        return;
+      }
+      
+      // Calculate damage with type effectiveness
+      const { damage, effectiveness } = BattleService.calculateDamage(playerPiclet, enemyPiclet, move);
       
-      if (enemyHpPercentage <= 0) {
-        currentMessage = `${enemyPiclet.nickname} fainted!`;
-        battleEnded = true;
-        setTimeout(() => onBattleEnd(true), 2000);
-      } else {
-        // Enemy turn
+      // Update enemy HP
+      const newHp = Math.max(0, enemyPiclet.currentHp - damage);
+      enemyPiclet.currentHp = newHp;
+      enemyHpPercentage = newHp / enemyPiclet.maxHp;
+      
+      // Show effectiveness message if applicable
+      const effectivenessMessage = getEffectivenessText(effectiveness);
+      if (effectivenessMessage) {
         setTimeout(() => {
-          const enemyMove = enemyPiclet.moves[0];
-          currentMessage = `${enemyPiclet.nickname} used ${enemyMove.name}!`;
-          
-          setTimeout(() => {
-            playerHpPercentage = Math.max(0, playerHpPercentage - 0.15);
-            
-            if (playerHpPercentage <= 0) {
-              currentMessage = `${playerPiclet.nickname} fainted!`;
-              battleEnded = true;
-              setTimeout(() => onBattleEnd(false), 2000);
-            } else {
-              currentMessage = `What will ${playerPiclet.nickname} do?`;
-              processingTurn = false;
-            }
-          }, 1500);
+          currentMessage = effectivenessMessage;
+        }, 1000);
+      }
+      
+      setTimeout(() => {
+        if (enemyHpPercentage <= 0) {
+          currentMessage = `${enemyPiclet.nickname} fainted!`;
+          battleEnded = true;
+          setTimeout(() => onBattleEnd(true), 2000);
+        } else {
+          enemyTurn();
+        }
+      }, effectivenessMessage ? 2500 : 1500);
+    }, 1500);
+  }
+  
+  function enemyTurn() {
+    const enemyMove = enemyPiclet.moves[Math.floor(Math.random() * enemyPiclet.moves.length)];
+    currentMessage = `${enemyPiclet.nickname} used ${enemyMove.name}!`;
+    
+    setTimeout(() => {
+      if (!BattleService.doesMoveHit(enemyMove.accuracy)) {
+        currentMessage = `${enemyPiclet.nickname}'s attack missed!`;
+        setTimeout(() => {
+          currentMessage = `What will ${playerPiclet.nickname} do?`;
+          processingTurn = false;
         }, 1500);
+        return;
       }
+      
+      const { damage, effectiveness } = BattleService.calculateDamage(enemyPiclet, playerPiclet, enemyMove);
+      
+      // Update player HP
+      const newHp = Math.max(0, playerPiclet.currentHp - damage);
+      playerPiclet.currentHp = newHp;
+      playerHpPercentage = newHp / playerPiclet.maxHp;
+      
+      // Show effectiveness message if applicable
+      const effectivenessMessage = getEffectivenessText(effectiveness);
+      if (effectivenessMessage) {
+        setTimeout(() => {
+          currentMessage = effectivenessMessage;
+        }, 1000);
+      }
+      
+      setTimeout(() => {
+        if (playerHpPercentage <= 0) {
+          currentMessage = `${playerPiclet.nickname} fainted!`;
+          battleEnded = true;
+          setTimeout(() => onBattleEnd(false), 2000);
+        } else {
+          currentMessage = `What will ${playerPiclet.nickname} do?`;
+          processingTurn = false;
+        }
+      }, effectivenessMessage ? 2500 : 1500);
     }, 1500);
   }
   

src/lib/components/Pages/Encounters.svelte

@@ -277,7 +277,7 @@
       id: -1, // Temporary ID for enemy
       typeId: encounter.picletTypeId,
       nickname: monster.name,
-      primaryTypeString: 'normal', // Default type
+      primaryType: 'beast' as any, // Default type
       
       level: level,
       xp: 0,
@@ -299,7 +299,7 @@
       moves: [
         {
           name: stats.attackActionName,
-          type: 'normal',
+          type: 'normal' as any,
           power: 50,
           accuracy: 95,
           pp: 20,
@@ -308,7 +308,7 @@
         },
         {
           name: stats.buffActionName,
-          type: 'status',
+          type: 'normal' as any,
           power: 0,
           accuracy: 100,
           pp: 15,
@@ -317,7 +317,7 @@
         },
         {
           name: stats.debuffActionName,
-          type: 'status',
+          type: 'normal' as any,
           power: 0,
           accuracy: 85,
           pp: 15,
@@ -326,7 +326,7 @@
         },
         {
           name: stats.specialActionName,
-          type: 'special',
+          type: 'normal' as any,
           power: 80,
           accuracy: 90,
           pp: 5,

src/lib/components/Piclets/PicletCard.svelte

@@ -1,5 +1,7 @@
 <script lang="ts">
   import type { PicletInstance } from '$lib/db/schema';
+  import { TYPE_DATA } from '$lib/types/picletTypes';
+  import TypeBadge from '$lib/components/UI/TypeBadge.svelte';
   
   interface Props {
     instance: PicletInstance;
@@ -17,8 +19,7 @@
     '#ff3b30'
   );
   
-  // Default type color - we'll enhance this later with a proper type system
-  const typeColor = '#007bff';
+  const typeColor = $derived(TYPE_DATA[instance.primaryType].color);
 </script>
 
 <button 
@@ -37,6 +38,12 @@
     <div class="level-badge">
       Lv.{instance.level}
     </div>
+    <div class="type-badge-container">
+      <TypeBadge type={instance.primaryType} size="small" />
+      {#if instance.secondaryType}
+        <TypeBadge type={instance.secondaryType} size="small" />
+      {/if}
+    </div>
   </div>
   
   {#if showDetails}
@@ -96,6 +103,14 @@
     font-weight: bold;
   }
   
+  .type-badge-container {
+    position: absolute;
+    bottom: 4px;
+    left: 4px;
+    display: flex;
+    gap: 2px;
+  }
+  
   .details-section {
     height: 40px;
     padding: 4px 6px;

src/lib/components/UI/TypeBadge.svelte

@@ -0,0 +1,82 @@
+<script lang="ts">
+  import type { PicletType } from '$lib/types/picletTypes';
+  import { TYPE_DATA } from '$lib/types/picletTypes';
+  
+  interface Props {
+    type: PicletType;
+    size?: 'small' | 'medium' | 'large';
+    showIcon?: boolean;
+    showLabel?: boolean;
+  }
+  
+  let { type, size = 'medium', showIcon = true, showLabel = false }: Props = $props();
+  
+  const typeInfo = $derived(TYPE_DATA[type]);
+  const sizeClass = $derived(`size-${size}`);
+</script>
+
+<div class="type-badge {sizeClass}" style="--type-color: {typeInfo.color}">
+  {#if showIcon}
+    <span class="type-icon">{typeInfo.icon}</span>
+  {/if}
+  {#if showLabel}
+    <span class="type-label">{typeInfo.name}</span>
+  {/if}
+</div>
+
+<style>
+  .type-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 2px;
+    background-color: var(--type-color);
+    color: white;
+    border-radius: 12px;
+    font-weight: 600;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2);
+    border: 1px solid color-mix(in srgb, var(--type-color) 80%, black);
+  }
+  
+  .size-small {
+    padding: 2px 4px;
+    font-size: 10px;
+    border-radius: 8px;
+  }
+  
+  .size-medium {
+    padding: 3px 6px;
+    font-size: 11px;
+    border-radius: 10px;
+  }
+  
+  .size-large {
+    padding: 4px 8px;
+    font-size: 12px;
+    border-radius: 12px;
+  }
+  
+  .type-icon {
+    line-height: 1;
+    filter: drop-shadow(0 1px 1px rgba(0, 0, 0, 0.5));
+  }
+  
+  .type-label {
+    line-height: 1;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+  }
+  
+  .size-small .type-icon {
+    font-size: 8px;
+  }
+  
+  .size-medium .type-icon {
+    font-size: 10px;
+  }
+  
+  .size-large .type-icon {
+    font-size: 12px;
+  }
+</style>

src/lib/db/battleService.ts

@@ -1,5 +1,6 @@
-import type { PicletInstance, BattleState, BattlePhase } from './schema';
+import type { PicletInstance, BattleState, BattlePhase, BattleMove } from './schema';
 import { db } from './index';
+import { getEffectivenessMultiplier, AttackType } from '../types/picletTypes';
 
 export class BattleService {
   // Initialize a new battle
@@ -19,23 +20,42 @@ export class BattleService {
     };
   }
 
-  // Calculate damage (simplified formula)
+  // Calculate damage with type effectiveness
   static calculateDamage(
     attacker: PicletInstance,
     defender: PicletInstance,
-    move: any
-  ): number {
+    move: BattleMove
+  ): { damage: number; effectiveness: number } {
     const baseDamage = move.power || 50;
-    const attackStat = move.type === 'physical' ? attacker.attack : attacker.fieldAttack;
-    const defenseStat = move.type === 'physical' ? defender.defense : defender.fieldDefense;
+    const attackStat = move.power > 0 ? attacker.attack : attacker.fieldAttack;
+    const defenseStat = move.power > 0 ? defender.defense : defender.fieldDefense;
+    
+    // Type effectiveness
+    const effectiveness = getEffectivenessMultiplier(
+      move.type,
+      defender.primaryType,
+      defender.secondaryType
+    );
+    
+    // STAB (Same Type Attack Bonus) - 1.5x if move type matches attacker's type
+    const stab = (move.type === attacker.primaryType as unknown as AttackType || move.type === attacker.secondaryType as unknown as AttackType) ? 1.5 : 1;
     
     // Simple damage formula
-    const damage = Math.floor((baseDamage * (attackStat / defenseStat) * 0.5) + 10);
+    let damage = Math.floor((baseDamage * (attackStat / defenseStat) * 0.5) + 10);
+    
+    // Apply type effectiveness and STAB
+    damage = Math.floor(damage * effectiveness * stab);
     
     // Add some randomness (85-100% of calculated damage)
     const randomFactor = 0.85 + Math.random() * 0.15;
+    damage = Math.floor(damage * randomFactor);
+    
+    // Minimum 1 damage for non-immune moves
+    if (effectiveness > 0 && damage < 1) {
+      damage = 1;
+    }
     
-    return Math.floor(damage * randomFactor);
+    return { damage, effectiveness };
   }
 
   // Check if move hits (based on accuracy)

src/lib/db/piclets.ts

@@ -1,5 +1,6 @@
 import { db } from './index';
 import type { PicletInstance, Monster, BattleMove } from './schema';
+import { PicletType, AttackType, getTypeFromConcept } from '../types/picletTypes';
 
 // Convert a generated Monster to a PicletInstance
 export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
@@ -25,11 +26,14 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
   
   const maxHp = calculateHp(baseHp, level);
   
+  // Determine primary type based on concept and caption
+  const primaryType = getTypeFromConcept(monster.concept, monster.imageCaption);
+  
   // Create moves based on monster's abilities
   const moves: BattleMove[] = [
     {
       name: stats.attackActionName,
-      type: 'normal',
+      type: primaryType as unknown as AttackType,
       power: 50,
       accuracy: 95,
       pp: 20,
@@ -38,7 +42,7 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     },
     {
       name: stats.buffActionName,
-      type: 'status',
+      type: AttackType.NORMAL,
       power: 0,
       accuracy: 100,
       pp: 15,
@@ -47,7 +51,7 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     },
     {
       name: stats.debuffActionName,
-      type: 'status',
+      type: AttackType.NORMAL,
       power: 0,
       accuracy: 85,
       pp: 15,
@@ -56,7 +60,7 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     },
     {
       name: stats.specialActionName,
-      type: 'special',
+      type: primaryType as unknown as AttackType,
       power: 80,
       accuracy: 90,
       pp: 5,
@@ -71,8 +75,8 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     // Type Info
     typeId: monster.name.toLowerCase().replace(/\s+/g, '-'),
     nickname: monster.name,
-    primaryTypeString: 'normal', // Default type, could be enhanced based on concept
-    secondaryTypeString: undefined,
+    primaryType: primaryType,
+    secondaryType: undefined,
     
     // Current Stats
     currentHp: maxHp,

src/lib/db/schema.ts

@@ -1,3 +1,5 @@
+import type { PicletType, AttackType } from '../types/picletTypes';
+
 // Enums
 export enum EncounterType {
   WILD_PICLET = 'wildPiclet',
@@ -9,7 +11,7 @@ export enum EncounterType {
 // Battle Move embedded object
 export interface BattleMove {
   name: string;
-  type: string;
+  type: AttackType;
   power: number;
   accuracy: number;
   pp: number;
@@ -24,8 +26,8 @@ export interface PicletInstance {
   // Type Info
   typeId: string;
   nickname?: string;
-  primaryTypeString: string;
-  secondaryTypeString?: string;
+  primaryType: PicletType;
+  secondaryType?: PicletType;
   
   // Current Stats
   currentHp: number;

src/lib/services/picletMetadata.ts

@@ -69,8 +69,8 @@ export async function embedPicletMetadata(imageBlob: Blob, piclet: PicletInstanc
     data: {
       typeId: piclet.typeId,
       nickname: piclet.nickname,
-      primaryTypeString: piclet.primaryTypeString,
-      secondaryTypeString: piclet.secondaryTypeString,
+      primaryType: piclet.primaryType,
+      secondaryType: piclet.secondaryType,
       currentHp: piclet.maxHp, // Reset to full HP for sharing
       maxHp: piclet.maxHp,
       level: piclet.level,

src/lib/types/picletTypes.ts

@@ -0,0 +1,307 @@
+export enum PicletType {
+  BEAST = 'beast',
+  BUG = 'bug', 
+  AQUATIC = 'aquatic',
+  FLORA = 'flora',
+  MINERAL = 'mineral',
+  SPACE = 'space',
+  MACHINA = 'machina',
+  STRUCTURE = 'structure',
+  CULTURE = 'culture',
+  CUISINE = 'cuisine'
+}
+
+export interface TypeInfo {
+  name: string;
+  icon: string;
+  color: string;
+  description: string;
+}
+
+export const TYPE_DATA: Record<PicletType, TypeInfo> = {
+  [PicletType.BEAST]: {
+    name: 'Beast',
+    icon: '🐾',
+    color: '#8B4513',
+    description: 'Vertebrate wildlife — mammals, birds, reptiles. Brings raw physicality, instincts, and region-based variants.'
+  },
+  [PicletType.BUG]: {
+    name: 'Bug', 
+    icon: '🐛',
+    color: '#9ACD32',
+    description: 'Arthropods great and small: butterflies, beetles, mantises. Agile swarms, precision strikes, and metamorph-style evolutions.'
+  },
+  [PicletType.AQUATIC]: {
+    name: 'Aquatic',
+    icon: '🌊', 
+    color: '#1E90FF',
+    description: 'Life that swims, dives, sloshes, or seeps: fish, octopus, ink-creatures, sentient puddles. Masters of tides, mist, and pressure.'
+  },
+  [PicletType.FLORA]: {
+    name: 'Flora',
+    icon: '🌿',
+    color: '#228B22',
+    description: 'Plants and fungi captured in bloom or decay. Harness growth, spores, vines, and seasonal shifts to entangle foes or heal allies.'
+  },
+  [PicletType.MINERAL]: {
+    name: 'Mineral',
+    icon: '🪨',
+    color: '#696969',
+    description: 'Stones, crystals, and metals shaped by earth\'s depths. High durability, reflective armor, seismic shocks, and gem-beam attacks.'
+  },
+  [PicletType.SPACE]: {
+    name: 'Space',
+    icon: '✨',
+    color: '#4B0082',
+    description: 'Stars, moon, and other cosmic objects not on this world.'
+  },
+  [PicletType.MACHINA]: {
+    name: 'Machina',
+    icon: '⚙️',
+    color: '#C0C0C0',
+    description: 'Engineered devices from pocket gadgets to heavy machinery. Deploy gears, circuits, drones, and overclocked power surges.'
+  },
+  [PicletType.STRUCTURE]: {
+    name: 'Structure',
+    icon: '🏛️',
+    color: '#A0522D',
+    description: 'Buildings, bridges, monuments, and ruins re-imagined as titans. Excel at fortification, terrain shaping, and zone denial.'
+  },
+  [PicletType.CULTURE]: {
+    name: 'Culture',
+    icon: '🎨',
+    color: '#FF69B4',
+    description: 'Art, fashion, toys, and written symbols. Specialises in buffs, debuffs, illusion, and story-driven move interactions.'
+  },
+  [PicletType.CUISINE]: {
+    name: 'Cuisine',
+    icon: '🍣',
+    color: '#FF6347',
+    description: 'Dishes, drinks, and culinary artistry. Uses flavours, aromas, and temperature shifts for restorative support or spicy offense.'
+  }
+};
+
+export enum AttackType {
+  NORMAL = 'normal',
+  BEAST = 'beast',
+  BUG = 'bug',
+  AQUATIC = 'aquatic', 
+  FLORA = 'flora',
+  MINERAL = 'mineral',
+  SPACE = 'space',
+  MACHINA = 'machina',
+  STRUCTURE = 'structure',
+  CULTURE = 'culture',
+  CUISINE = 'cuisine'
+}
+
+export type TypeEffectiveness = 0 | 0.5 | 1 | 2;
+
+export const TYPE_EFFECTIVENESS: Record<AttackType, Record<PicletType, TypeEffectiveness>> = {
+  [AttackType.NORMAL]: {
+    [PicletType.BEAST]: 1,
+    [PicletType.BUG]: 1,
+    [PicletType.AQUATIC]: 1,
+    [PicletType.FLORA]: 1,
+    [PicletType.MINERAL]: 1,
+    [PicletType.SPACE]: 0,
+    [PicletType.MACHINA]: 1,
+    [PicletType.STRUCTURE]: 1,
+    [PicletType.CULTURE]: 1,
+    [PicletType.CUISINE]: 1
+  },
+  [AttackType.BEAST]: {
+    [PicletType.BEAST]: 1,
+    [PicletType.BUG]: 2,
+    [PicletType.AQUATIC]: 1,
+    [PicletType.FLORA]: 1,
+    [PicletType.MINERAL]: 0.5,
+    [PicletType.SPACE]: 0,
+    [PicletType.MACHINA]: 0.5,
+    [PicletType.STRUCTURE]: 0.5,
+    [PicletType.CULTURE]: 2,
+    [PicletType.CUISINE]: 2
+  },
+  [AttackType.BUG]: {
+    [PicletType.BEAST]: 2,
+    [PicletType.BUG]: 1,
+    [PicletType.AQUATIC]: 1,
+    [PicletType.FLORA]: 2,
+    [PicletType.MINERAL]: 0.5,
+    [PicletType.SPACE]: 0.5,
+    [PicletType.MACHINA]: 1,
+    [PicletType.STRUCTURE]: 0,
+    [PicletType.CULTURE]: 0.5,
+    [PicletType.CUISINE]: 0.5
+  },
+  [AttackType.AQUATIC]: {
+    [PicletType.BEAST]: 1,
+    [PicletType.BUG]: 1,
+    [PicletType.AQUATIC]: 1,
+    [PicletType.FLORA]: 0.5,
+    [PicletType.MINERAL]: 2,
+    [PicletType.SPACE]: 2,
+    [PicletType.MACHINA]: 2,
+    [PicletType.STRUCTURE]: 1,
+    [PicletType.CULTURE]: 0.5,
+    [PicletType.CUISINE]: 0.5
+  },
+  [AttackType.FLORA]: {
+    [PicletType.BEAST]: 1,
+    [PicletType.BUG]: 2,
+    [PicletType.AQUATIC]: 2,
+    [PicletType.FLORA]: 1,
+    [PicletType.MINERAL]: 2,
+    [PicletType.SPACE]: 0.5,
+    [PicletType.MACHINA]: 0,
+    [PicletType.STRUCTURE]: 2,
+    [PicletType.CULTURE]: 1,
+    [PicletType.CUISINE]: 0.5
+  },
+  [AttackType.MINERAL]: {
+    [PicletType.BEAST]: 2,
+    [PicletType.BUG]: 2,
+    [PicletType.AQUATIC]: 0.5,
+    [PicletType.FLORA]: 0.5,
+    [PicletType.MINERAL]: 1,
+    [PicletType.SPACE]: 0.5,
+    [PicletType.MACHINA]: 2,
+    [PicletType.STRUCTURE]: 1,
+    [PicletType.CULTURE]: 1,
+    [PicletType.CUISINE]: 0
+  },
+  [AttackType.SPACE]: {
+    [PicletType.BEAST]: 0,
+    [PicletType.BUG]: 2,
+    [PicletType.AQUATIC]: 0.5,
+    [PicletType.FLORA]: 2,
+    [PicletType.MINERAL]: 2,
+    [PicletType.SPACE]: 1,
+    [PicletType.MACHINA]: 0.5,
+    [PicletType.STRUCTURE]: 2,
+    [PicletType.CULTURE]: 0.5,
+    [PicletType.CUISINE]: 0.5
+  },
+  [AttackType.MACHINA]: {
+    [PicletType.BEAST]: 2,
+    [PicletType.BUG]: 0.5,
+    [PicletType.AQUATIC]: 0.5,
+    [PicletType.FLORA]: 2,
+    [PicletType.MINERAL]: 0.5,
+    [PicletType.SPACE]: 0.5,
+    [PicletType.MACHINA]: 1,
+    [PicletType.STRUCTURE]: 2,
+    [PicletType.CULTURE]: 1,
+    [PicletType.CUISINE]: 1
+  },
+  [AttackType.STRUCTURE]: {
+    [PicletType.BEAST]: 0.5,
+    [PicletType.BUG]: 0.5,
+    [PicletType.AQUATIC]: 1,
+    [PicletType.FLORA]: 1,
+    [PicletType.MINERAL]: 1,
+    [PicletType.SPACE]: 0.5,
+    [PicletType.MACHINA]: 2,
+    [PicletType.STRUCTURE]: 1,
+    [PicletType.CULTURE]: 2,
+    [PicletType.CUISINE]: 2
+  },
+  [AttackType.CULTURE]: {
+    [PicletType.BEAST]: 0.5,
+    [PicletType.BUG]: 0.5,
+    [PicletType.AQUATIC]: 1,
+    [PicletType.FLORA]: 1,
+    [PicletType.MINERAL]: 0,
+    [PicletType.SPACE]: 2,
+    [PicletType.MACHINA]: 2,
+    [PicletType.STRUCTURE]: 2,
+    [PicletType.CULTURE]: 1,
+    [PicletType.CUISINE]: 0.5
+  },
+  [AttackType.CUISINE]: {
+    [PicletType.BEAST]: 2,
+    [PicletType.BUG]: 0.5,
+    [PicletType.AQUATIC]: 0.5,
+    [PicletType.FLORA]: 1,
+    [PicletType.MINERAL]: 0,
+    [PicletType.SPACE]: 2,
+    [PicletType.MACHINA]: 1,
+    [PicletType.STRUCTURE]: 0.5,
+    [PicletType.CULTURE]: 2,
+    [PicletType.CUISINE]: 1
+  }
+};
+
+export function getTypeEffectiveness(attackType: AttackType, defenseType: PicletType): TypeEffectiveness {
+  return TYPE_EFFECTIVENESS[attackType][defenseType];
+}
+
+export function getEffectivenessMultiplier(attackType: AttackType, defenseType: PicletType, secondaryType?: PicletType): number {
+  let multiplier = getTypeEffectiveness(attackType, defenseType);
+  
+  if (secondaryType && secondaryType !== defenseType) {
+    multiplier *= getTypeEffectiveness(attackType, secondaryType);
+  }
+  
+  return multiplier;
+}
+
+export function getEffectivenessText(effectiveness: number): string {
+  if (effectiveness === 0) return "It had no effect!";
+  if (effectiveness > 1) return "It's super effective!";
+  if (effectiveness < 1) return "It's not very effective...";
+  return "";
+}
+
+export function getEffectivenessColor(effectiveness: number): string {
+  if (effectiveness === 0) return "#666666";
+  if (effectiveness > 1) return "#4CAF50"; 
+  if (effectiveness < 1) return "#FF6B6B";
+  return "#333333";
+}
+
+export function getTypeFromConcept(concept: string, imageCaption?: string): PicletType {
+  const text = `${concept} ${imageCaption || ''}`.toLowerCase();
+  
+  if (text.includes('beast') || text.includes('animal') || text.includes('mammal') || text.includes('bird') || text.includes('reptile') || text.includes('wolf') || text.includes('cat') || text.includes('dog') || text.includes('tiger') || text.includes('lion') || text.includes('bear') || text.includes('eagle') || text.includes('dragon')) {
+    return PicletType.BEAST;
+  }
+  
+  if (text.includes('bug') || text.includes('insect') || text.includes('spider') || text.includes('beetle') || text.includes('butterfly') || text.includes('ant') || text.includes('mantis') || text.includes('bee') || text.includes('wasp')) {
+    return PicletType.BUG;
+  }
+  
+  if (text.includes('water') || text.includes('aquatic') || text.includes('fish') || text.includes('ocean') || text.includes('sea') || text.includes('swim') || text.includes('tentacle') || text.includes('octopus') || text.includes('squid') || text.includes('jellyfish') || text.includes('whale') || text.includes('shark')) {
+    return PicletType.AQUATIC;
+  }
+  
+  if (text.includes('plant') || text.includes('tree') || text.includes('flower') || text.includes('vine') || text.includes('leaf') || text.includes('root') || text.includes('mushroom') || text.includes('fungus') || text.includes('moss') || text.includes('seed') || text.includes('petal') || text.includes('thorn')) {
+    return PicletType.FLORA;
+  }
+  
+  if (text.includes('rock') || text.includes('stone') || text.includes('crystal') || text.includes('metal') || text.includes('iron') || text.includes('steel') || text.includes('gold') || text.includes('silver') || text.includes('gem') || text.includes('diamond') || text.includes('mineral') || text.includes('ore')) {
+    return PicletType.MINERAL;
+  }
+  
+  if (text.includes('star') || text.includes('space') || text.includes('cosmic') || text.includes('celestial') || text.includes('moon') || text.includes('sun') || text.includes('planet') || text.includes('galaxy') || text.includes('nebula') || text.includes('comet') || text.includes('asteroid')) {
+    return PicletType.SPACE;
+  }
+  
+  if (text.includes('machine') || text.includes('robot') || text.includes('mechanical') || text.includes('gear') || text.includes('engine') || text.includes('circuit') || text.includes('wire') || text.includes('electronic') || text.includes('computer') || text.includes('device') || text.includes('gadget')) {
+    return PicletType.MACHINA;
+  }
+  
+  if (text.includes('building') || text.includes('house') || text.includes('castle') || text.includes('tower') || text.includes('bridge') || text.includes('monument') || text.includes('statue') || text.includes('pillar') || text.includes('wall') || text.includes('fortress') || text.includes('temple') || text.includes('ruins')) {
+    return PicletType.STRUCTURE;
+  }
+  
+  if (text.includes('art') || text.includes('paint') || text.includes('music') || text.includes('dance') || text.includes('book') || text.includes('story') || text.includes('poem') || text.includes('fashion') || text.includes('toy') || text.includes('game') || text.includes('symbol') || text.includes('letter') || text.includes('word')) {
+    return PicletType.CULTURE;
+  }
+  
+  if (text.includes('food') || text.includes('cook') || text.includes('dish') || text.includes('meal') || text.includes('bread') || text.includes('fruit') || text.includes('vegetable') || text.includes('meat') || text.includes('drink') || text.includes('beverage') || text.includes('soup') || text.includes('cake') || text.includes('spice') || text.includes('flavor') || text.includes('taste')) {
+    return PicletType.CUISINE;
+  }
+  
+  return PicletType.BEAST;
+}

src/tests/encounterService.test.ts

@@ -60,7 +60,7 @@ describe('EncounterService', () => {
       const testPiclet: Omit<PicletInstance, 'id'> = {
         typeId: 'test-001',
         nickname: 'Testy',
-        primaryTypeString: 'normal',
+        primaryType: 'beast' as any,
         level: 5,
         xp: 0,
         currentHp: 20,