fix: relic refinement drop rates (#796)

Author: BUSTheid

build/parser.mjs

@@ -199,7 +199,7 @@ class Parser {
     this.addIsPrime(result);
     this.addVaultData(result, data.vaultData, category, data.wikia);
     this.addResistanceData(result, category);
-    this.addRelics(result, data.relics);
+    this.addRelics(result, data.relics, data.drops);
     this.applyMasterable(result);
     this.applyOverrides(result);
     return result;
@@ -1069,8 +1069,9 @@ class Parser {
    * - market data on relics (urlName, id)
    * @param {Item} item to have relics applied to
    * @param {Array<module:@wfcd/relics.TitaniaRelic>} relics relic array to search
+   * @param {Array<DropRate>} drops drop rate data for refinement-specific chances
    */
-  addRelics(item, relics) {
+  addRelics(item, relics, drops) {
     const hasRelicDrop = item.components?.some((c) => c.drops?.some((d) => d.location?.includes('Relic')));
     if (item.type !== 'Relic' && !hasRelicDrop) return;
 
@@ -1085,7 +1086,36 @@ class Parser {
         [relicItem.uniqueName] = Array.from(new Set(related.map((relic) => relic.uniqueName).flat()));
       } else {
         relicItem.locations = Array.from(new Set(related.map((relic) => relic.locations).flat()));
-        relicItem.rewards = Array.from(new Set(related.map((relic) => relic.rewards).flat()));
+
+        // Get base rewards structure from relics package (has item metadata)
+        const baseRewards = Array.from(new Set(related.map((relic) => relic.rewards).flat()));
+
+        // Build the correct "place" name for drops API lookup
+        const dropPlaceName = name.endsWith('Intact')
+          ? name.replace(/\sIntact$/, ' Relic')
+          : name.replace(/\s(\w+)$/, ' Relic ($1)');
+
+        // Find drops that match this relic refinement level
+        const dropsForRelic = drops?.filter((d) => d.place === dropPlaceName) ?? [];
+
+        // Update reward chances from drops data (keep other metadata from relics)
+        // Track used drops by index to handle duplicate item names correctly
+        const usedDropIndices = new Set();
+        relicItem.rewards = baseRewards.map((reward) => {
+          if (!reward.item?.name) return reward;
+
+          // Find first unused drop matching this item name
+          const dropIndex = dropsForRelic.findIndex(
+            (d, idx) => d.item === reward.item.name && !usedDropIndices.has(idx)
+          );
+
+          if (dropIndex !== -1) {
+            usedDropIndices.add(dropIndex);
+            return { ...reward, chance: dropsForRelic[dropIndex].chance };
+          }
+          return reward;
+        });
+
         [relicItem.marketInfo] = Array.from(new Set(related.map((relic) => relic.warframeMarket)));
 
         const [vaultInfo] = Array.from(new Set(related.map((relic) => relic.vaultInfo)));

test/index.spec.mjs

@@ -365,6 +365,43 @@ const test = (base) => {
         });
       });
     });
+    describe('relics', async () => {
+      it('should have correct drop rates for each refinement level', async () => {
+        const relics = await wrapConstr({ category: ['Relics'] });
+
+        // Expected patterns for each refinement level
+        const expectedPatterns = {
+          Intact: { 25.33: 3, 11: 2, 2: 1 },
+          Exceptional: { 23.33: 3, 13: 2, 4: 1 },
+          Flawless: { 20: 3, 17: 2, 6: 1 },
+          Radiant: { 16.67: 3, 20: 2, 10: 1 },
+        };
+
+        Object.entries(expectedPatterns).forEach(([level, expected]) => {
+          const relicsAtLevel = relics.filter((r) => r.name.endsWith(level));
+          relicsAtLevel.forEach((relic) => {
+            // BUG: Skip Axi S19 - has no rewards (doesn't exist in game)
+            if (!relic.rewards || relic.rewards.length === 0) {
+              return;
+            }
+            // Group rewards by percentage
+            const chanceGroups = {};
+            relic.rewards.forEach((reward) => {
+              if (!chanceGroups[reward.chance]) {
+                chanceGroups[reward.chance] = 0;
+              }
+              chanceGroups[reward.chance] += 1;
+            });
+
+            assert.deepStrictEqual(
+              chanceGroups,
+              expected,
+              `${relic.name} should have exact distribution: ${JSON.stringify(expected)}`
+            );
+          });
+        });
+      });
+    });
   });
 };