roguelike-cli 1.3.3 → 1.3.4

package/src/data/loot.ts

@@ -0,0 +1,177 @@
+import { getDictionary, Dictionary } from './dictionaries';
+
+export type Rarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+
+export interface LootItem {
+  name: string;
+  rarity: Rarity;
+  droppedAt: string;
+  source: 'task' | 'levelup' | 'achievement' | 'boss';
+}
+
+export interface LootDropResult {
+  dropped: boolean;
+  item?: LootItem;
+}
+
+// Rarity drop chances by player level
+// Higher level = higher chance for rare items, but overall drop rate decreases
+function getDropChances(level: number): { dropRate: number; rarityWeights: Record<Rarity, number> } {
+  // Base drop rate decreases with level (starts at 30%, min 5%)
+  const baseDropRate = Math.max(0.05, 0.30 - (level * 0.01));
+  
+  // Rarity weights shift toward rarer items at higher levels
+  const legendaryWeight = Math.min(0.05, level * 0.002);
+  const epicWeight = Math.min(0.10, level * 0.004);
+  const rareWeight = Math.min(0.20, 0.05 + level * 0.005);
+  const uncommonWeight = Math.min(0.30, 0.15 + level * 0.005);
+  const commonWeight = 1 - legendaryWeight - epicWeight - rareWeight - uncommonWeight;
+  
+  return {
+    dropRate: baseDropRate,
+    rarityWeights: {
+      common: commonWeight,
+      uncommon: uncommonWeight,
+      rare: rareWeight,
+      epic: epicWeight,
+      legendary: legendaryWeight,
+    },
+  };
+}
+
+// Bonus multipliers for different sources
+const SOURCE_MULTIPLIERS: Record<string, number> = {
+  task: 1.0,
+  levelup: 3.0,      // 3x chance on level up
+  achievement: 2.5,  // 2.5x chance on achievement
+  boss: 2.0,         // 2x chance on boss
+};
+
+// Select random rarity based on weights
+function selectRarity(weights: Record<Rarity, number>): Rarity {
+  const roll = Math.random();
+  let cumulative = 0;
+  
+  const rarities: Rarity[] = ['common', 'uncommon', 'rare', 'epic', 'legendary'];
+  for (const rarity of rarities) {
+    cumulative += weights[rarity];
+    if (roll < cumulative) {
+      return rarity;
+    }
+  }
+  
+  return 'common';
+}
+
+// Select random item from rarity pool
+function selectItem(rarity: Rarity, dict: Dictionary): string {
+  const pool = dict.loot[rarity];
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
+// Main function to roll for loot
+export function rollForLoot(
+  level: number,
+  source: 'task' | 'levelup' | 'achievement' | 'boss',
+  rulesPreset?: string
+): LootDropResult {
+  const dict = getDictionary(rulesPreset);
+  const { dropRate, rarityWeights } = getDropChances(level);
+  
+  // Apply source multiplier
+  const adjustedDropRate = Math.min(0.95, dropRate * (SOURCE_MULTIPLIERS[source] || 1.0));
+  
+  // Roll for drop
+  if (Math.random() > adjustedDropRate) {
+    return { dropped: false };
+  }
+  
+  // Select rarity and item
+  const rarity = selectRarity(rarityWeights);
+  const name = selectItem(rarity, dict);
+  
+  return {
+    dropped: true,
+    item: {
+      name,
+      rarity,
+      droppedAt: new Date().toISOString(),
+      source,
+    },
+  };
+}
+
+// Format loot drop message
+export function formatLootDrop(item: LootItem, dict: Dictionary): string {
+  const rarityName = dict.rarities[item.rarity];
+  const raritySymbol = getRaritySymbol(item.rarity);
+  
+  return `
+=== ${dict.messages.lootDropped} ===
+
+${raritySymbol} [${rarityName}] ${item.name}
+`.trim();
+}
+
+// Get rarity symbol/color indicator
+function getRaritySymbol(rarity: Rarity): string {
+  switch (rarity) {
+    case 'common': return '[.]';
+    case 'uncommon': return '[+]';
+    case 'rare': return '[*]';
+    case 'epic': return '[#]';
+    case 'legendary': return '[!]';
+  }
+}
+
+// Format inventory display
+export function formatInventory(inventory: LootItem[], dict: Dictionary): string {
+  if (!inventory || inventory.length === 0) {
+    return `${dict.stats.inventory}: (empty)`;
+  }
+  
+  // Group by rarity
+  const byRarity: Record<Rarity, LootItem[]> = {
+    legendary: [],
+    epic: [],
+    rare: [],
+    uncommon: [],
+    common: [],
+  };
+  
+  for (const item of inventory) {
+    byRarity[item.rarity].push(item);
+  }
+  
+  const lines: string[] = [`=== ${dict.stats.inventory} (${inventory.length} items) ===`, ''];
+  
+  for (const rarity of ['legendary', 'epic', 'rare', 'uncommon', 'common'] as Rarity[]) {
+    const items = byRarity[rarity];
+    if (items.length > 0) {
+      const symbol = getRaritySymbol(rarity);
+      const rarityName = dict.rarities[rarity];
+      lines.push(`${rarityName}:`);
+      for (const item of items) {
+        lines.push(`  ${symbol} ${item.name}`);
+      }
+      lines.push('');
+    }
+  }
+  
+  return lines.join('\n').trim();
+}
+
+// Calculate inventory value (for stats)
+export function calculateInventoryValue(inventory: LootItem[]): number {
+  if (!inventory) return 0;
+  
+  const values: Record<Rarity, number> = {
+    common: 1,
+    uncommon: 5,
+    rare: 25,
+    epic: 100,
+    legendary: 500,
+  };
+  
+  return inventory.reduce((sum, item) => sum + values[item.rarity], 0);
+}

package/src/interactive/commands.ts

@@ -473,16 +473,27 @@ export async function processCommand(
   
   // Stats command
   if (command === 'stats') {
-    return wrapResult({ output: formatStats() });
+    return wrapResult({ output: formatStats(config.rulesPreset) });
+  }
+  
+  // Inventory command
+  if (command === 'inventory' || command === 'inv' || command === 'loot') {
+    const { formatInventoryDisplay } = await import('../storage/profile');
+    return wrapResult({ output: formatInventoryDisplay(config.rulesPreset) });
   }
   
   // Achievements command
   if (command === 'achievements' || command === 'ach') {
-    return wrapResult({ output: formatAchievements() });
+    return wrapResult({ output: formatAchievements(config.rulesPreset) });
   }
   
   // Done command - mark current node as completed
   if (command === 'done') {
+    const { getDictionary } = await import('../data/dictionaries');
+    const { formatLootDrop } = await import('../data/loot');
+    const { getAchievementInfo } = await import('../storage/profile');
+    const dict = getDictionary(config.rulesPreset);
+    
     const nodeConfig = readNodeConfig(currentPath);
     
     if (!nodeConfig) {
@@ -502,7 +513,8 @@ export async function processCommand(
       result.xpGained,
       nodeConfig.isBoss || false,
       depth,
-      nodeConfig.createdAt
+      nodeConfig.createdAt,
+      config.rulesPreset
     );
     
     // Save to undo history
@@ -513,27 +525,33 @@ export async function processCommand(
       timestamp: new Date().toISOString(),
     });
     
-    let output = `\n=== TASK COMPLETED ===\n`;
-    output += `\nTasks completed: ${result.tasksCompleted}`;
+    let output = `\n=== ${dict.messages.questCompleted} ===\n`;
+    output += `\nTasks: ${result.tasksCompleted}`;
     if (result.bossesDefeated > 0) {
-      output += `\nBosses defeated: ${result.bossesDefeated}`;
+      output += ` | Bosses: ${result.bossesDefeated}`;
     }
     output += `\n+${result.xpGained} XP`;
     
     if (taskResult.levelUp) {
-      output += `\n\n*** LEVEL UP! ***`;
-      output += `\nYou are now level ${taskResult.newLevel}!`;
+      output += `\n\n*** ${dict.messages.levelUp} ***`;
+      output += `\n${dict.stats.level} ${taskResult.newLevel}!`;
     }
     
     if (taskResult.newAchievements.length > 0) {
-      output += `\n\n=== NEW ACHIEVEMENTS ===`;
-      for (const ach of taskResult.newAchievements) {
-        output += `\n[x] ${ach.name}: ${ach.description}`;
+      output += `\n\n=== ${dict.messages.newAchievement} ===`;
+      for (const achId of taskResult.newAchievements) {
+        const achInfo = getAchievementInfo(achId, dict);
+        if (achInfo) {
+          output += `\n[x] ${achInfo.name}: ${achInfo.desc}`;
+        }
       }
     }
     
-    output += '\n';
-    output += '[Type "undo" to revert]';
+    if (taskResult.lootDropped) {
+      output += `\n\n${formatLootDrop(taskResult.lootDropped, dict)}`;
+    }
+    
+    output += '\n\n[Type "undo" to revert]';
     
     return wrapResult({ output });
   }
@@ -1191,7 +1209,8 @@ Tasks:
 
 Gamification:
   stats                 XP, level, streaks
-  achievements          Achievement list
+  achievements          Achievement list (infinite)
+  inventory             Loot collection
   map                   Dungeon map
   map --ai              AI-generated map
 
@@ -1242,17 +1261,17 @@ www.rlc.rocks
       
       return wrapResult({ output: `Created todo folder: ${safeName}/` });
     } else {
-      const schemaPath = saveSchemaFile(
-        currentPath,
+    const schemaPath = saveSchemaFile(
+      currentPath,
         pending.title,
         pending.content
-      );
-      const filename = path.basename(schemaPath);
-      
-      sessionState.pending = null;
-      sessionState.history = [];
-      
-      return wrapResult({ output: `Saved: ${filename}` });
+    );
+    const filename = path.basename(schemaPath);
+    
+    sessionState.pending = null;
+    sessionState.history = [];
+    
+    return wrapResult({ output: `Saved: ${filename}` });
     }
   }
   

package/src/interactive/startup.ts

@@ -18,7 +18,7 @@ const ASCII_ART = [
   '╚═════════════════════════╝',
   '',
   '  Tasks: done, undo, dl <date>, boss, block',
-  '  Stats: stats, achievements, map --ai',
+  '  Stats: stats, achievements, inventory, map',
   '',
   '  Rules: fantasy, space, starwars, cyberpunk',
   '  Config: init, config -R="<rules>"',