farming-weight 0.10.7 → 0.11.0

package/dist/player/player.js

@@ -1,7 +1,8 @@
-import { FARMING_ATTRIBUTE_SHARDS, getShardFortune } from '../constants/attributes.js';
+import { FARMING_ATTRIBUTE_SHARDS, getShardStat } from '../constants/attributes.js';
 import { CROP_INFO, Crop, EXPORTABLE_CROP_FORTUNE } from '../constants/crops.js';
 import { fortuneFromPersonalBestContest } from '../constants/personalbests.js';
-import { ANITA_FORTUNE_UPGRADE, COCOA_FORTUNE_UPGRADE, COMMUNITY_CENTER_UPGRADE, FARMING_LEVEL, GARDEN_CROP_UPGRADES, UNLOCKED_PLOTS, } from '../constants/specific.js';
+import { ANITA_FORTUNE_UPGRADE, COCOA_FORTUNE_UPGRADE, COMMUNITY_CENTER_UPGRADE, FARMING_LEVEL, GARDEN_CROP_UPGRADES, UNLOCKED_PLOTS, WRIGGLING_LARVA_SOURCE, } from '../constants/specific.js';
+import { Stat } from '../constants/stats.js';
 import { TEMPORARY_FORTUNE } from '../constants/tempfortune.js';
 import { UpgradeAction, UpgradeCategory } from '../constants/upgrades.js';
 import { FarmingAccessory } from '../fortune/farmingaccessory.js';
@@ -16,6 +17,7 @@ import { getSourceProgress } from '../upgrades/getsourceprogress.js';
 import { getFakeItem } from '../upgrades/itemregistry.js';
 import { CROP_FORTUNE_SOURCES } from '../upgrades/sources/cropsources.js';
 import { GENERAL_FORTUNE_SOURCES } from '../upgrades/sources/generalsources.js';
+import { filterAndSortUpgrades } from '../upgrades/upgradeutils.js';
 import { getCropDisplayName, getItemIdFromCrop } from '../util/names.js';
 import { fortuneFromPestBestiary } from '../util/pests.js';
 import { calculateDetailedDrops } from '../util/ratecalc.js';
@@ -31,70 +33,96 @@ export class FarmingPlayer {
         return this.options.attributes ?? {};
     }
     constructor(options) {
+        this.setOptions(options);
+    }
+    setOptions(options) {
         this.options = options;
-        options.pets ??= [];
-        if (options.pets[0] instanceof FarmingPet) {
-            this.pets = options.pets.sort((a, b) => b.fortune - a.fortune);
+        this.populatePets();
+        this.populateTools();
+        this.populateArmor();
+        this.populateEquipment();
+        this.populateActiveAccessories();
+        this.permFortune = this.getGeneralFortune();
+        this.tempFortune = this.getTempFortune();
+    }
+    populatePets() {
+        this.options.pets ??= [];
+        if (this.options.pets[0] instanceof FarmingPet) {
+            this.pets = this.options.pets.sort((a, b) => b.fortune - a.fortune);
             for (const pet of this.pets)
-                pet.setOptions(options);
+                pet.setOptions(this.options);
         }
         else {
-            this.pets = FarmingPet.fromArray(options.pets, options);
+            this.pets = FarmingPet.fromArray(this.options.pets, this.options);
         }
         this.selectedPet = this.options.selectedPet;
-        options.tools ??= [];
-        if (options.tools[0] instanceof FarmingTool) {
-            this.tools = options.tools;
+    }
+    populateTools() {
+        this.options.tools ??= [];
+        if (this.options.tools[0] instanceof FarmingTool) {
+            this.tools = this.options.tools;
             for (const tool of this.tools)
-                tool.setOptions(options);
+                tool.setOptions(this.options);
             this.tools.sort((a, b) => b.fortune - a.fortune);
         }
         else {
-            this.tools = FarmingTool.fromArray(options.tools, options);
+            this.tools = FarmingTool.fromArray(this.options.tools, this.options);
         }
         this.selectedTool = this.options.selectedTool ?? this.tools[0];
-        options.armor ??= [];
-        if (options.armor instanceof ArmorSet) {
-            this.armorSet = options.armor;
+    }
+    populateArmor() {
+        this.options.armor ??= [];
+        if (this.options.armor instanceof ArmorSet) {
+            this.armorSet = this.options.armor;
             this.armor = this.armorSet.pieces;
             this.armor.sort((a, b) => b.potential - a.potential);
             this.equipment = this.armorSet.equipmentPieces;
             this.equipment.sort((a, b) => b.fortune - a.fortune);
-            this.armorSet.setOptions(options);
+            this.armorSet.setOptions(this.options);
         }
-        else if (options.armor[0] instanceof FarmingArmor) {
-            this.armor = options.armor.sort((a, b) => b.potential - a.potential);
+        else if (this.options.armor[0] instanceof FarmingArmor) {
+            this.armor = this.options.armor.sort((a, b) => b.potential - a.potential);
             for (const a of this.armor)
-                a.setOptions(options);
+                a.setOptions(this.options);
             this.armorSet = new ArmorSet(this.armor);
         }
         else {
-            this.armor = FarmingArmor.fromArray(options.armor, options);
+            this.armor = FarmingArmor.fromArray(this.options.armor, this.options);
             this.armorSet = new ArmorSet(this.armor);
         }
-        options.equipment ??= [];
-        if (options.equipment[0] instanceof FarmingEquipment) {
-            this.equipment = options.equipment.sort((a, b) => b.fortune - a.fortune);
+    }
+    populateEquipment() {
+        this.options.equipment ??= [];
+        // If equipment was already set by populateArmor (from ArmorSet), don't overwrite it
+        if (this.equipment && this.equipment.length > 0) {
+            // Load in equipment to armor set if it's empty
+            if (this.armorSet.equipment.filter((e) => e).length === 0) {
+                this.armorSet.setEquipment(this.equipment);
+            }
+            return;
+        }
+        if (this.options.equipment[0] instanceof FarmingEquipment) {
+            this.equipment = this.options.equipment.sort((a, b) => b.fortune - a.fortune);
             for (const e of this.equipment)
-                e.setOptions(options);
+                e.setOptions(this.options);
         }
         else {
-            this.equipment = FarmingEquipment.fromArray(options.equipment, options);
+            this.equipment = FarmingEquipment.fromArray(this.options.equipment, this.options);
         }
         // Load in equipment to armor set if it's empty
         if (this.armorSet.equipment.filter((e) => e).length === 0) {
             this.armorSet.setEquipment(this.equipment);
         }
-        options.accessories ??= [];
+    }
+    populateActiveAccessories() {
+        this.options.accessories ??= [];
         this.activeAccessories = [];
-        if (options.accessories[0] instanceof FarmingAccessory) {
-            this.accessories = options.accessories.sort((a, b) => b.fortune - a.fortune);
+        if (this.options.accessories[0] instanceof FarmingAccessory) {
+            this.accessories = this.options.accessories.sort((a, b) => b.fortune - a.fortune);
         }
         else {
-            this.accessories = FarmingAccessory.fromArray(options.accessories);
+            this.accessories = FarmingAccessory.fromArray(this.options.accessories);
         }
-        this.permFortune = this.getGeneralFortune();
-        this.tempFortune = this.getTempFortune();
     }
     changeArmor(armor) {
         this.armorSet = new ArmorSet(armor.sort((a, b) => b.fortune - a.fortune));
@@ -114,17 +142,17 @@ export class FarmingPlayer {
         }
         this.permFortune = this.getGeneralFortune();
     }
-    getProgress() {
-        return getSourceProgress(this, GENERAL_FORTUNE_SOURCES);
+    getProgress(stats) {
+        return getSourceProgress(this, GENERAL_FORTUNE_SOURCES, false, stats);
     }
-    getUpgrades() {
-        const upgrades = getSourceProgress(this, GENERAL_FORTUNE_SOURCES).flatMap((source) => source.upgrades ?? []);
-        const armorSetUpgrades = this.armorSet.getUpgrades();
+    getUpgrades(options) {
+        const stats = options?.stat ? [options.stat] : undefined;
+        const upgrades = getSourceProgress(this, GENERAL_FORTUNE_SOURCES, false, stats).flatMap((source) => source.upgrades ?? []);
+        const armorSetUpgrades = this.armorSet.getUpgrades(options);
         if (armorSetUpgrades.length > 0) {
             upgrades.push(...armorSetUpgrades);
         }
-        upgrades.sort((a, b) => b.increase - a.increase);
-        return upgrades;
+        return filterAndSortUpgrades(upgrades, options);
     }
     getCropUpgrades(crop, tool) {
         const upgrades = [];
@@ -166,111 +194,160 @@ export class FarmingPlayer {
         return upgrades;
     }
     getGeneralFortune() {
+        const { value, breakdown } = this.getStatBreakdown(Stat.FarmingFortune);
+        this.breakdown = breakdown;
+        return value;
+    }
+    getStat(stat) {
+        return this.getStatBreakdown(stat).value;
+    }
+    getStatBreakdown(stat) {
         let sum = 0;
         const breakdown = {};
         // Plots
-        const plots = getFortune(this.options.plots?.length ?? this.options.plotsUnlocked, UNLOCKED_PLOTS);
+        const plots = getFortune(this.options.plots?.length ?? this.options.plotsUnlocked, UNLOCKED_PLOTS, stat);
         if (plots > 0) {
             breakdown['Unlocked Plots'] = plots;
             sum += plots;
         }
         // Farming Level
-        const level = getFortune(this.options.farmingLevel, FARMING_LEVEL);
+        const level = getFortune(this.options.farmingLevel, FARMING_LEVEL, stat);
         if (level > 0) {
             breakdown['Farming Level'] = level;
             sum += level;
         }
         // Bestiary
-        if (this.options.bestiaryKills) {
+        if (stat === Stat.FarmingFortune && this.options.bestiaryKills) {
             const bestiary = fortuneFromPestBestiary(this.options.bestiaryKills);
             if (bestiary > 0) {
                 breakdown['Pest Bestiary'] = bestiary;
                 sum += bestiary;
             }
         }
-        // Armor Set
-        const armorSet = this.armorSet.armorFortune;
-        if (armorSet > 0) {
-            breakdown['Armor Set'] = armorSet;
-            sum += armorSet;
+        // Armor pieces
+        for (const piece of this.armorSet.armor) {
+            if (!piece)
+                continue;
+            const val = piece.getStat(stat);
+            if (val > 0) {
+                breakdown[piece.item.name ?? 'Armor Piece'] = val;
+                sum += val;
+            }
+        }
+        // Armor Set Bonuses
+        for (const { bonus, count } of this.armorSet.setBonuses) {
+            if (count < 2 || count > 4)
+                continue;
+            const val = bonus.stats?.[count]?.[stat] ?? 0;
+            if (val > 0) {
+                breakdown[bonus.name] = val;
+                sum += val;
+            }
+        }
+        // Equipment pieces
+        for (const piece of this.armorSet.equipment) {
+            if (!piece)
+                continue;
+            const val = piece.getStat(stat);
+            if (val > 0) {
+                breakdown[piece.item.name ?? 'Equipment Piece'] = val;
+                sum += val;
+            }
         }
-        // Eqiupment
-        const equipment = this.armorSet.equipmentFortune;
-        if (equipment > 0) {
-            breakdown['Equipment'] = equipment;
-            sum += equipment;
+        // Equipment Set Bonuses
+        for (const { bonus, count } of this.armorSet.equipmentSetBonuses) {
+            if (count < 2 || count > 4)
+                continue;
+            const val = bonus.stats?.[count]?.[stat] ?? 0;
+            if (val > 0) {
+                breakdown[bonus.name] = val;
+                sum += val;
+            }
         }
         // Anita Bonus
-        const anitaBonus = getFortune(this.options.anitaBonus, ANITA_FORTUNE_UPGRADE);
+        const anitaBonus = getFortune(this.options.anitaBonus, ANITA_FORTUNE_UPGRADE, stat);
         if (anitaBonus > 0) {
             breakdown['Anita Bonus Drops'] = anitaBonus;
             sum += anitaBonus;
         }
         // Community Center
-        const communityCenter = getFortune(this.options.communityCenter, COMMUNITY_CENTER_UPGRADE);
+        const communityCenter = getFortune(this.options.communityCenter, COMMUNITY_CENTER_UPGRADE, stat);
         if (communityCenter > 0) {
             breakdown['Community Center'] = communityCenter;
             sum += communityCenter;
         }
         // Selected Pet
         const pet = this.selectedPet;
-        if (pet && pet.fortune > 0) {
-            breakdown[pet.info.name ?? 'Selected Pet'] = pet.fortune;
-            sum += pet.fortune;
+        if (pet) {
+            const val = pet.getFortune(stat);
+            if (val > 0) {
+                breakdown[pet.info.name ?? 'Selected Pet'] = val;
+                sum += val;
+            }
         }
-        // Accessories, only count highest fortune from each family
+        // Accessories
         const families = new Map();
-        this.activeAccessories = [];
-        for (const accessory of this.accessories.filter((a) => a.fortune > 0).sort((a, b) => b.fortune - a.fortune)) {
-            if (!accessory.info.family)
+        const activeAccessories = [];
+        const sortedAccessories = [...this.accessories]
+            .map((a) => ({ acc: a, val: a.getStat(stat) }))
+            .filter((item) => item.val > 0)
+            .sort((a, b) => b.val - a.val);
+        for (const { acc, val } of sortedAccessories) {
+            if (!acc.info.family)
                 continue;
-            const existing = families.get(accessory.info.family);
+            const existing = families.get(acc.info.family);
             if (!existing) {
-                families.set(accessory.info.family, accessory);
-                this.activeAccessories.push(accessory);
-            }
-            else if (accessory.info.familyOrder && accessory.info.familyOrder > (existing.info.familyOrder ?? 0)) {
-                families.set(accessory.info.family, accessory);
-                this.activeAccessories.push(accessory);
-                this.activeAccessories = this.activeAccessories.filter((a) => a !== existing);
+                families.set(acc.info.family, acc);
+                activeAccessories.push(acc);
+                breakdown[acc.item.name ?? acc.item.skyblockId ?? 'Accessory'] = val;
+                sum += val;
             }
         }
-        for (const accessory of this.activeAccessories) {
-            if (accessory.info.crops)
-                continue;
-            breakdown[accessory.item.name ?? accessory.item.skyblockId ?? 'Accessory [Error]'] = accessory.fortune;
-            sum += accessory.fortune;
+        if (stat === Stat.FarmingFortune) {
+            this.activeAccessories = activeAccessories;
         }
         // Refined Truffles
-        const truffles = Math.min(5, this.options.refinedTruffles ?? 0);
-        if (truffles > 0) {
-            breakdown['Refined Truffles'] = truffles;
-            sum += truffles;
+        if (stat === Stat.FarmingFortune) {
+            const truffles = Math.min(5, this.options.refinedTruffles ?? 0);
+            if (truffles > 0) {
+                breakdown['Refined Truffles'] = truffles;
+                sum += truffles;
+            }
+        }
+        // Wriggling Larva
+        if (stat === Stat.BonusPestChance) {
+            const used = Math.min(5, this.options.wrigglingLarva ?? 0);
+            const val = getFortune(used, WRIGGLING_LARVA_SOURCE, stat);
+            if (val > 0) {
+                breakdown['Wriggling Larva'] = val;
+                sum += val;
+            }
         }
         // Attribute Shards
         for (const [shardId, value] of Object.entries(this.attributes)) {
             const shard = FARMING_ATTRIBUTE_SHARDS[shardId];
             if (!shard || value <= 0)
                 continue;
-            const fortune = getShardFortune(shard, this);
-            if (fortune <= 0)
+            const val = getShardStat(shard, this, stat);
+            if (val <= 0)
                 continue;
-            breakdown[shard.name] = fortune;
-            sum += fortune;
+            breakdown[shard.name] = val;
+            sum += val;
         }
         // Extra Fortune
-        for (const extra of this.options.extraFortune ?? []) {
-            if (extra.crop)
-                continue;
-            breakdown[extra.name ?? 'Extra Fortune'] = extra.fortune;
-            sum += extra.fortune;
-        }
-        const temp = this.getTempFortune();
-        if (temp > 0) {
-            breakdown['Temporary Fortune'] = temp;
+        if (stat === Stat.FarmingFortune) {
+            for (const extra of this.options.extraFortune ?? []) {
+                if (extra.crop)
+                    continue;
+                breakdown[extra.name ?? 'Extra Fortune'] = extra.fortune;
+                sum += extra.fortune;
+            }
+            const temp = this.getTempFortune();
+            if (temp > 0) {
+                breakdown['Temporary Fortune'] = temp;
+            }
         }
-        this.breakdown = breakdown;
-        return sum;
+        return { value: sum, breakdown };
     }
     getTempFortune() {
         let sum = 0;
@@ -360,8 +437,8 @@ export class FarmingPlayer {
             breakdown: breakdown,
         };
     }
-    getCropProgress(crop) {
-        return getSourceProgress({ crop, player: this }, CROP_FORTUNE_SOURCES);
+    getCropProgress(crop, stats) {
+        return getSourceProgress({ crop, player: this }, CROP_FORTUNE_SOURCES, false, stats);
     }
     getRates(crop, blocksBroken) {
         const tool = this.getBestTool(crop);
@@ -390,5 +467,554 @@ export class FarmingPlayer {
     getSelectedCropTool(crop) {
         return this.selectedTool?.crop === crop ? this.selectedTool : this.getBestTool(crop);
     }
+    applyUpgrade(upgrade) {
+        if (!upgrade.meta)
+            return;
+        const { type, itemUuid, key, value, id } = upgrade.meta;
+        if (itemUuid) {
+            const candidates = [...this.tools, ...this.armor, ...this.equipment, ...this.accessories];
+            const target = candidates.find((i) => i.item.uuid === itemUuid);
+            if (target) {
+                if (type === 'enchant' && key) {
+                    target.item.enchantments ??= {};
+                    target.item.enchantments[key] = Number(value);
+                    // Re-instantiate to update enchantment-based logic
+                    if (target instanceof FarmingTool) {
+                        const idx = this.tools.indexOf(target);
+                        if (idx >= 0) {
+                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                        }
+                    }
+                    else if (target instanceof FarmingArmor) {
+                        const idx = this.armor.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingArmor(target.item, this.options);
+                            this.armor[idx] = updatedPiece;
+                            this.armorSet.updateArmorSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingEquipment) {
+                        const idx = this.equipment.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingEquipment(target.item, this.options);
+                            this.equipment[idx] = updatedPiece;
+                            this.armorSet.updateEquipmentSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingAccessory) {
+                        const idx = this.accessories.indexOf(target);
+                        if (idx >= 0) {
+                            this.accessories[idx] = new FarmingAccessory(target.item, this.options);
+                        }
+                    }
+                }
+                else if (type === 'reforge' && id) {
+                    target.item.attributes ??= {};
+                    target.item.attributes.modifier = id;
+                    // Re-initialize to update logic
+                    if (target instanceof FarmingTool) {
+                        const idx = this.tools.indexOf(target);
+                        if (idx >= 0) {
+                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                        }
+                    }
+                    else if (target instanceof FarmingArmor) {
+                        const idx = this.armor.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingArmor(target.item, this.options);
+                            this.armor[idx] = updatedPiece;
+                            this.armorSet.updateArmorSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingEquipment) {
+                        const idx = this.equipment.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingEquipment(target.item, this.options);
+                            this.equipment[idx] = updatedPiece;
+                            this.armorSet.updateEquipmentSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingAccessory) {
+                        const idx = this.accessories.indexOf(target);
+                        if (idx >= 0) {
+                            this.accessories[idx] = new FarmingAccessory(target.item, this.options);
+                        }
+                    }
+                }
+                else if (type === 'item' && id === 'farming_for_dummies_count') {
+                    target.item.attributes ??= {};
+                    target.item.attributes.farming_for_dummies_count = String(value);
+                    // Re-instantiate so getUpgrades reflects the updated FFD count
+                    if (target instanceof FarmingTool) {
+                        const idx = this.tools.indexOf(target);
+                        if (idx >= 0) {
+                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                        }
+                    }
+                }
+                else if (type === 'gem' && upgrade.meta.slot && value) {
+                    target.item.gems ??= {};
+                    target.item.gems[upgrade.meta.slot] = String(value);
+                    // Re-instantiate so getUpgrades reflects the updated gem
+                    if (target instanceof FarmingTool) {
+                        const idx = this.tools.indexOf(target);
+                        if (idx >= 0) {
+                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                        }
+                    }
+                    else if (target instanceof FarmingArmor) {
+                        const idx = this.armor.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingArmor(target.item, this.options);
+                            this.armor[idx] = updatedPiece;
+                            this.armorSet.updateArmorSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingEquipment) {
+                        const idx = this.equipment.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingEquipment(target.item, this.options);
+                            this.equipment[idx] = updatedPiece;
+                            this.armorSet.updateEquipmentSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingAccessory) {
+                        const idx = this.accessories.indexOf(target);
+                        if (idx >= 0) {
+                            this.accessories[idx] = new FarmingAccessory(target.item, this.options);
+                        }
+                    }
+                }
+                else if (type === 'item' && id === 'rarity_upgrades' && value) {
+                    target.item.attributes ??= {};
+                    target.item.attributes.rarity_upgrades = String(value);
+                    // Recomb affects rarity, which affects stats. Need to reload tool.
+                    if (target instanceof FarmingTool) {
+                        const idx = this.tools.indexOf(target);
+                        if (idx >= 0) {
+                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                        }
+                    }
+                    else if (target instanceof FarmingArmor) {
+                        const idx = this.armor.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingArmor(target.item, this.options);
+                            this.armor[idx] = updatedPiece;
+                            this.armorSet.updateArmorSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingEquipment) {
+                        const idx = this.equipment.indexOf(target);
+                        if (idx >= 0) {
+                            const updatedPiece = new FarmingEquipment(target.item, this.options);
+                            this.equipment[idx] = updatedPiece;
+                            this.armorSet.updateEquipmentSlot(updatedPiece);
+                        }
+                    }
+                    else if (target instanceof FarmingAccessory) {
+                        const idx = this.accessories.indexOf(target);
+                        if (idx >= 0) {
+                            this.accessories[idx] = new FarmingAccessory(target.item, this.options);
+                        }
+                    }
+                }
+                else if (type === 'buy_item' && id) {
+                    // Tier upgrade: replace the old item with a new one
+                    const newItem = getFakeItem(id);
+                    if (newItem) {
+                        // Transfer enchantments, attributes, gems from old item
+                        newItem.item.enchantments = {
+                            ...newItem.item.enchantments,
+                            ...target.item.enchantments,
+                        };
+                        newItem.item.attributes = {
+                            ...newItem.item.attributes,
+                            ...target.item.attributes,
+                        };
+                        newItem.item.gems = {
+                            ...newItem.item.gems,
+                            ...target.item.gems,
+                        };
+                        // Preserve the old item's UUID so the item remains trackable
+                        newItem.item.uuid = target.item.uuid;
+                        if (target instanceof FarmingTool && newItem instanceof FarmingTool) {
+                            const idx = this.tools.indexOf(target);
+                            if (idx >= 0) {
+                                this.tools[idx] = new FarmingTool(newItem.item, this.options);
+                            }
+                        }
+                        else if (target instanceof FarmingArmor && newItem instanceof FarmingArmor) {
+                            const idx = this.armor.indexOf(target);
+                            if (idx >= 0) {
+                                const updatedPiece = new FarmingArmor(newItem.item, this.options);
+                                this.armor[idx] = updatedPiece;
+                                this.armorSet.updateArmorSlot(updatedPiece);
+                            }
+                        }
+                        else if (target instanceof FarmingEquipment && newItem instanceof FarmingEquipment) {
+                            const idx = this.equipment.indexOf(target);
+                            if (idx >= 0) {
+                                const updatedPiece = new FarmingEquipment(newItem.item, this.options);
+                                this.equipment[idx] = updatedPiece;
+                                this.armorSet.updateEquipmentSlot(updatedPiece);
+                            }
+                        }
+                        else if (target instanceof FarmingAccessory && newItem instanceof FarmingAccessory) {
+                            const idx = this.accessories.indexOf(target);
+                            if (idx >= 0) {
+                                this.accessories[idx] = new FarmingAccessory(newItem.item, this.options);
+                            }
+                        }
+                        this.permFortune = this.getGeneralFortune();
+                    }
+                }
+            }
+        }
+        else if (type === 'skill') {
+            if (key === 'farmingLevel' && value) {
+                this.options.farmingLevel = Number(value);
+            }
+            else if (key === 'anitaBonus' && value) {
+                this.options.anitaBonus = Number(value);
+            }
+            else if (key === 'communityCenter' && value) {
+                this.options.communityCenter = Number(value);
+            }
+            this.permFortune = this.getGeneralFortune();
+        }
+        else if (type === 'plot' && (value || id)) {
+            this.options.plotsUnlocked = Number(value);
+            // Also add to plots array if using id (the plot name)
+            if (id) {
+                this.options.plots ??= [];
+                if (!this.options.plots.includes(id)) {
+                    this.options.plots.push(id);
+                }
+            }
+            this.permFortune = this.getGeneralFortune();
+        }
+        else if (type === 'attribute' && key && value) {
+            this.options.attributes ??= {};
+            this.options.attributes[key] = Number(value);
+            this.permFortune = this.getGeneralFortune();
+        }
+        else if (type === 'crop_upgrade' && key && value) {
+            this.options.cropUpgrades ??= {};
+            // @ts-ignore
+            this.options.cropUpgrades[key] = Number(value);
+            this.permFortune = this.getGeneralFortune();
+        }
+        else if (type === 'setting' && key && value) {
+            if (key === 'cocoaFortuneUpgrade') {
+                this.options.cocoaFortuneUpgrade = Number(value);
+            }
+            this.permFortune = this.getGeneralFortune();
+        }
+        else if (type === 'unlock' && id) {
+            if (id === 'personal_best') {
+                this.options.personalBestsUnlocked = true;
+            }
+            this.permFortune = this.getGeneralFortune();
+        }
+        else if (type === 'buy_item' && id) {
+            const newItem = getFakeItem(id);
+            if (newItem) {
+                if (newItem instanceof FarmingTool) {
+                    const oldIdx = itemUuid ? this.tools.findIndex((t) => t.item.uuid === itemUuid) : -1;
+                    if (oldIdx >= 0) {
+                        const oldItem = this.tools[oldIdx];
+                        // Transfer enchantments, attributes, gems from old item
+                        newItem.item.enchantments = {
+                            ...newItem.item.enchantments,
+                            ...oldItem.item.enchantments,
+                        };
+                        newItem.item.attributes = {
+                            ...newItem.item.attributes,
+                            ...oldItem.item.attributes,
+                        };
+                        newItem.item.gems = { ...newItem.item.gems, ...oldItem.item.gems };
+                        // Re-instantiate to recalculate fortune with transferred properties
+                        this.tools[oldIdx] = new FarmingTool(newItem.item, this.options);
+                    }
+                    else {
+                        this.tools.push(newItem);
+                    }
+                }
+                else if (newItem instanceof FarmingArmor) {
+                    const oldIdx = itemUuid ? this.armor.findIndex((a) => a.item.uuid === itemUuid) : -1;
+                    if (oldIdx >= 0) {
+                        const oldItem = this.armor[oldIdx];
+                        newItem.item.enchantments = {
+                            ...newItem.item.enchantments,
+                            ...oldItem.item.enchantments,
+                        };
+                        newItem.item.attributes = {
+                            ...newItem.item.attributes,
+                            ...oldItem.item.attributes,
+                        };
+                        newItem.item.gems = { ...newItem.item.gems, ...oldItem.item.gems };
+                        this.armor[oldIdx] = new FarmingArmor(newItem.item, this.options);
+                    }
+                    else {
+                        this.armor.push(newItem);
+                    }
+                }
+                else if (newItem instanceof FarmingEquipment) {
+                    const oldIdx = itemUuid ? this.equipment.findIndex((e) => e.item.uuid === itemUuid) : -1;
+                    if (oldIdx >= 0) {
+                        const oldItem = this.equipment[oldIdx];
+                        newItem.item.enchantments = {
+                            ...newItem.item.enchantments,
+                            ...oldItem.item.enchantments,
+                        };
+                        newItem.item.attributes = {
+                            ...newItem.item.attributes,
+                            ...oldItem.item.attributes,
+                        };
+                        newItem.item.gems = { ...newItem.item.gems, ...oldItem.item.gems };
+                        this.equipment[oldIdx] = new FarmingEquipment(newItem.item, this.options);
+                    }
+                    else {
+                        this.equipment.push(newItem);
+                    }
+                }
+                else if (newItem instanceof FarmingAccessory) {
+                    const oldIdx = itemUuid ? this.accessories.findIndex((a) => a.item.uuid === itemUuid) : -1;
+                    if (oldIdx >= 0) {
+                        const oldItem = this.accessories[oldIdx];
+                        newItem.item.enchantments = {
+                            ...newItem.item.enchantments,
+                            ...oldItem.item.enchantments,
+                        };
+                        newItem.item.attributes = {
+                            ...newItem.item.attributes,
+                            ...oldItem.item.attributes,
+                        };
+                        newItem.item.gems = { ...newItem.item.gems, ...oldItem.item.gems };
+                        this.accessories[oldIdx] = new FarmingAccessory(newItem.item, this.options);
+                    }
+                    else {
+                        this.accessories.push(newItem);
+                    }
+                }
+                this.permFortune = this.getGeneralFortune();
+            }
+        }
+    }
+    /**
+     * Creates a deep clone of this FarmingPlayer that can be modified without affecting the original.
+     */
+    clone() {
+        const cloneItems = (items) => {
+            return items.map((item) => ({
+                ...item.item,
+                enchantments: { ...item.item.enchantments },
+                attributes: { ...item.item.attributes },
+                gems: { ...item.item.gems },
+                lore: [...(item.item.lore ?? [])],
+            }));
+        };
+        const clonedOptions = {
+            ...this.options,
+            tools: cloneItems(this.tools),
+            armor: cloneItems(this.armor),
+            equipment: cloneItems(this.equipment),
+            accessories: cloneItems(this.accessories),
+            pets: this.pets.map((p) => ({ ...p.pet })),
+            cropUpgrades: { ...this.options.cropUpgrades },
+            milestones: { ...this.options.milestones },
+            exportableCrops: { ...this.options.exportableCrops },
+            personalBests: { ...this.options.personalBests },
+            collection: { ...this.options.collection },
+            bestiaryKills: { ...this.options.bestiaryKills },
+            attributes: { ...this.options.attributes },
+            plots: [...(this.options.plots ?? [])],
+        };
+        return new FarmingPlayer(clonedOptions);
+    }
+    /**
+     * Expands an upgrade into a tree of follow-up upgrades.
+     * This applies the upgrade on a cloned player and recursively finds upgrades
+     * for the same target item.
+     *
+     * @param upgrade - The upgrade to expand
+     * @param options.maxDepth - Maximum recursion depth (default: 10)
+     * @param options.crop - Crop for crop-specific fortune calculations
+     * @param options.stats - Stats to track (default: [Stat.FarmingFortune])
+     * @param options.includeAllTierUpgradeChildren - If true, first-level children of tier upgrades include ALL available upgrades for the new item (default: false)
+     */
+    expandUpgrade(upgrade, options) {
+        const { maxDepth = 10, crop, stats = [Stat.FarmingFortune], includeAllTierUpgradeChildren = false, } = options ?? {};
+        const visited = new Set();
+        const usedConflictKeys = new Set();
+        return this.buildUpgradeTree(upgrade, 0, maxDepth, crop, visited, usedConflictKeys, stats, includeAllTierUpgradeChildren);
+    }
+    buildUpgradeTree(upgrade, depth, maxDepth, crop, visited, usedConflictKeys, stats, includeAllTierUpgradeChildren) {
+        // Create unique key for this upgrade to detect cycles
+        const upgradeKey = this.getUpgradeKey(upgrade);
+        if (visited.has(upgradeKey)) {
+            // Return a leaf node if we've seen this exact upgrade before
+            const currentStats = this.getAllStats(stats, crop);
+            return {
+                upgrade,
+                statsBefore: currentStats,
+                statsAfter: currentStats,
+                statsGained: {},
+                totalCost: upgrade.cost,
+                children: [],
+            };
+        }
+        visited.add(upgradeKey);
+        // Clone player and apply upgrade
+        const clonedPlayer = this.clone();
+        const statsBefore = clonedPlayer.getAllStats(stats, crop);
+        clonedPlayer.applyUpgrade(upgrade);
+        const statsAfter = clonedPlayer.getAllStats(stats, crop);
+        const statsGained = this.computeStatsDiff(statsBefore, statsAfter);
+        const node = {
+            upgrade,
+            statsBefore,
+            statsAfter,
+            statsGained,
+            totalCost: upgrade.cost,
+            children: [],
+        };
+        // Stop recursion at max depth
+        if (depth >= maxDepth) {
+            return node;
+        }
+        // Add current upgrade's conflict key for children to prevent duplicates in siblings
+        const childConflictKeys = new Set(usedConflictKeys);
+        if (upgrade.conflictKey) {
+            childConflictKeys.add(upgrade.conflictKey);
+        }
+        // For buy_item (tier) upgrades, also add conflict keys from the original item's available upgrades.
+        // This prevents duplicate suggestions - if Squash has Pesterminator 1 available,
+        // Fermento's children shouldn't also suggest Pesterminator 1 (do it on Squash instead, it carries over).
+        // When includeAllTierUpgradeChildren is true and depth is 0, skip this filtering to show ALL upgrades.
+        const skipTierFiltering = includeAllTierUpgradeChildren && depth === 0;
+        if (!skipTierFiltering && upgrade.meta?.type === 'buy_item' && upgrade.meta?.itemUuid) {
+            const originalItem = this.tools.find((t) => t.item.uuid === upgrade.meta?.itemUuid) ??
+                this.armor.find((a) => a.item.uuid === upgrade.meta?.itemUuid) ??
+                this.equipment.find((e) => e.item.uuid === upgrade.meta?.itemUuid) ??
+                this.accessories.find((a) => a.item.uuid === upgrade.meta?.itemUuid);
+            if (originalItem && 'getUpgrades' in originalItem && typeof originalItem.getUpgrades === 'function') {
+                for (const originalUpgrade of originalItem.getUpgrades()) {
+                    if (originalUpgrade.conflictKey) {
+                        childConflictKeys.add(originalUpgrade.conflictKey);
+                    }
+                }
+            }
+        }
+        // Find follow-up upgrades for the same target, excluding those with already-used conflict keys
+        const primaryStat = stats[0] ?? Stat.FarmingFortune;
+        const followUpUpgrades = this.getFollowUpUpgrades(clonedPlayer, upgrade, crop, primaryStat).filter((u) => !u.conflictKey || !childConflictKeys.has(u.conflictKey));
+        // Build children (using the cloned player's state)
+        for (const followUp of followUpUpgrades) {
+            const childNode = clonedPlayer.buildUpgradeTree(followUp, depth + 1, maxDepth, crop, new Set(visited), childConflictKeys, stats, includeAllTierUpgradeChildren);
+            node.children.push(childNode);
+        }
+        // Sort children by primary stat gained (highest first)
+        node.children.sort((a, b) => {
+            const aGain = a.statsGained[primaryStat] ?? 0;
+            const bGain = b.statsGained[primaryStat] ?? 0;
+            return bGain - aGain;
+        });
+        return node;
+    }
+    getAllStats(stats, crop) {
+        const result = {};
+        for (const stat of stats) {
+            let value = this.getStat(stat);
+            // Add crop-specific fortune if applicable
+            if (crop && stat === Stat.FarmingFortune) {
+                value += this.getCropFortune(crop).fortune;
+            }
+            if (value !== 0) {
+                result[stat] = value;
+            }
+        }
+        return result;
+    }
+    computeStatsDiff(before, after) {
+        const result = {};
+        const allStats = new Set([...Object.keys(before), ...Object.keys(after)]);
+        for (const stat of allStats) {
+            const beforeVal = before[stat] ?? 0;
+            const afterVal = after[stat] ?? 0;
+            const diff = afterVal - beforeVal;
+            if (diff !== 0) {
+                result[stat] = diff;
+            }
+        }
+        return result;
+    }
+    getUpgradeKey(upgrade) {
+        const meta = upgrade.meta;
+        if (!meta)
+            return `${upgrade.title}`;
+        const parts = [meta.type ?? '', meta.id ?? '', meta.itemUuid ?? '', meta.key ?? '', String(meta.value ?? '')];
+        return parts.join(':');
+    }
+    getFollowUpUpgrades(player, appliedUpgrade, crop, primaryStat) {
+        const meta = appliedUpgrade.meta;
+        if (!meta)
+            return [];
+        const itemUuid = meta.itemUuid;
+        const upgrades = [];
+        // Handle buy_item specially - these are item tier upgrades
+        // After applying, we want ALL upgrades for the new item, not filtered by type
+        // The new item preserves the old UUID, but we search by skyblockId to find the upgraded tier
+        if (meta.type === 'buy_item' && meta.id) {
+            const newItemId = meta.id;
+            const target = player.tools.find((t) => t.item.skyblockId === newItemId) ??
+                player.armor.find((a) => a.item.skyblockId === newItemId) ??
+                player.equipment.find((e) => e.item.skyblockId === newItemId) ??
+                player.accessories.find((a) => a.item.skyblockId === newItemId);
+            if (target && 'getUpgrades' in target && typeof target.getUpgrades === 'function') {
+                upgrades.push(...target.getUpgrades({ stat: primaryStat }));
+            }
+        }
+        else if (itemUuid) {
+            // Item-specific upgrade - find upgrades for the same item
+            const target = player.tools.find((t) => t.item.uuid === itemUuid) ??
+                player.armor.find((a) => a.item.uuid === itemUuid) ??
+                player.equipment.find((e) => e.item.uuid === itemUuid) ??
+                player.accessories.find((a) => a.item.uuid === itemUuid);
+            if (target && 'getUpgrades' in target && typeof target.getUpgrades === 'function') {
+                const itemUpgrades = target.getUpgrades({ stat: primaryStat });
+                // Filter to only include upgrades of the same type (enchant chains, tier upgrades, etc.)
+                // For gem upgrades, also match on slot to only show follow-ups for that specific slot
+                for (const u of itemUpgrades) {
+                    if (u.meta?.type === meta.type && u.meta?.key === meta.key) {
+                        // For gem upgrades, also require matching slot
+                        if (meta.type === 'gem' && meta.slot && u.meta?.slot !== meta.slot) {
+                            continue;
+                        }
+                        upgrades.push(u);
+                    }
+                }
+            }
+        }
+        else if (meta.type === 'skill' || meta.type === 'plot' || meta.type === 'attribute') {
+            // General upgrades - find the next level of the same upgrade type
+            const generalUpgrades = player.getUpgrades({ stat: primaryStat });
+            for (const u of generalUpgrades) {
+                if (u.meta?.type === meta.type && u.meta?.key === meta.key) {
+                    upgrades.push(u);
+                }
+            }
+        }
+        else if (meta.type === 'crop_upgrade' && crop) {
+            // Crop-specific upgrades
+            const cropUpgrades = player.getCropUpgrades(crop);
+            for (const u of cropUpgrades) {
+                if (u.meta?.type === meta.type && u.meta?.key === meta.key) {
+                    upgrades.push(u);
+                }
+            }
+        }
+        return upgrades;
+    }
 }
 //# sourceMappingURL=player.js.map