farming-weight 0.1.2 → 0.1.3

package/lib/constants/crops.d.ts

@@ -15,6 +15,7 @@ export interface CropInfo {
     name: string;
     npc: number;
     drops: number;
+    breaks?: number;
 }
 export declare const CROP_INFO: Record<Crop, CropInfo>;
 export declare const MAX_CROP_FORTUNE: Record<Crop, number>;

package/lib/constants/crops.js

@@ -20,6 +20,7 @@ exports.CROP_INFO = {
         name: 'Cactus',
         npc: 3,
         drops: 2,
+        breaks: 2,
     },
     [Crop.Carrot]: {
         name: 'Carrot',
@@ -58,8 +59,9 @@ exports.CROP_INFO = {
     },
     [Crop.SugarCane]: {
         name: 'Sugar Cane',
-        npc: 2,
-        drops: 4,
+        npc: 4,
+        drops: 2,
+        breaks: 2,
     },
     [Crop.Wheat]: {
         name: 'Wheat',
@@ -76,7 +78,7 @@ exports.CROP_INFO = {
 exports.MAX_CROP_FORTUNE = {
     [Crop.Cactus]: 1575,
     [Crop.Carrot]: 1784,
-    [Crop.CocoaBeans]: 1584,
+    [Crop.CocoaBeans]: 1584.5,
     [Crop.Melon]: 1567.8,
     [Crop.Mushroom]: 1603,
     [Crop.NetherWart]: 1772,

package/lib/constants/specialcrops.d.ts

@@ -0,0 +1,24 @@
+import { Crop } from './crops';
+export declare enum SpecialCrop {
+    Cropie = "Cropie",
+    Squash = "Squash",
+    Fermento = "Fermento"
+}
+export declare const SPECIAL_CROP_INFO: {
+    Cropie: {
+        name: string;
+        npc: number;
+        rates: number[];
+    };
+    Squash: {
+        name: string;
+        npc: number;
+        rates: number[];
+    };
+    Fermento: {
+        name: string;
+        npc: number;
+        rates: number[];
+    };
+};
+export declare const MATCHING_SPECIAL_CROP: Record<Crop, SpecialCrop>;

package/lib/constants/specialcrops.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATCHING_SPECIAL_CROP = exports.SPECIAL_CROP_INFO = exports.SpecialCrop = void 0;
+const crops_1 = require("./crops");
+var SpecialCrop;
+(function (SpecialCrop) {
+    SpecialCrop["Cropie"] = "Cropie";
+    SpecialCrop["Squash"] = "Squash";
+    SpecialCrop["Fermento"] = "Fermento";
+})(SpecialCrop || (exports.SpecialCrop = SpecialCrop = {}));
+exports.SPECIAL_CROP_INFO = {
+    [SpecialCrop.Cropie]: {
+        name: 'Cropie',
+        npc: 25_000,
+        rates: [0.0003, 0.0003, 0.0004, 0.0005],
+    },
+    [SpecialCrop.Squash]: {
+        name: 'Squash',
+        npc: 75_000,
+        rates: [0.0001, 0.0001, 0.0002, 0.0003],
+    },
+    [SpecialCrop.Fermento]: {
+        name: 'Fermento',
+        npc: 250_000,
+        rates: [0.00005, 0.00005, 0.00006, 0.00007],
+    },
+};
+exports.MATCHING_SPECIAL_CROP = {
+    [crops_1.Crop.Wheat]: SpecialCrop.Cropie,
+    [crops_1.Crop.Carrot]: SpecialCrop.Cropie,
+    [crops_1.Crop.Potato]: SpecialCrop.Cropie,
+    [crops_1.Crop.CocoaBeans]: SpecialCrop.Squash,
+    [crops_1.Crop.Melon]: SpecialCrop.Squash,
+    [crops_1.Crop.Pumpkin]: SpecialCrop.Squash,
+    [crops_1.Crop.Cactus]: SpecialCrop.Fermento,
+    [crops_1.Crop.Mushroom]: SpecialCrop.Fermento,
+    [crops_1.Crop.NetherWart]: SpecialCrop.Fermento,
+    [crops_1.Crop.SugarCane]: SpecialCrop.Fermento,
+    [crops_1.Crop.Seeds]: SpecialCrop.Fermento,
+};

package/lib/constants/weight.d.ts

@@ -1,2 +1,13 @@
 import { Crop } from './crops';
 export declare const CROP_WEIGHT: Record<Crop, number>;
+export declare const TIER_12_MINIONS: readonly string[];
+export declare const BONUS_WEIGHT: {
+    readonly Farming60Bonus: 250;
+    readonly Farming50Bonus: 100;
+    readonly AnitaBuffBonusMultiplier: 2;
+    readonly MaxMedalsCounted: 1000;
+    readonly GoldMedalRewardInterval: 50;
+    readonly WeightPerGoldMedal: 0.5;
+    readonly MinionRewardTier: 12;
+    readonly MinionRewardWeight: 5;
+};

package/lib/constants/weight.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CROP_WEIGHT = void 0;
+exports.BONUS_WEIGHT = exports.TIER_12_MINIONS = exports.CROP_WEIGHT = void 0;
 const crops_1 = require("./crops");
 // https://api.elitebot.dev/weights
 exports.CROP_WEIGHT = {
@@ -16,3 +16,25 @@ exports.CROP_WEIGHT = {
     [crops_1.Crop.Wheat]: 100_000,
     [crops_1.Crop.Seeds]: 0, // Byproduct of wheat farming, not counted
 };
+exports.TIER_12_MINIONS = [
+    'WHEAT_12',
+    'CARROT_12',
+    'POTATO_12',
+    'PUMPKIN_12',
+    'MELON_12',
+    'MUSHROOM_12',
+    'COCOA_12',
+    'CACTUS_12',
+    'SUGAR_CANE_12',
+    'NETHER_WARTS_12',
+];
+exports.BONUS_WEIGHT = {
+    Farming60Bonus: 250,
+    Farming50Bonus: 100,
+    AnitaBuffBonusMultiplier: 2,
+    MaxMedalsCounted: 1000,
+    GoldMedalRewardInterval: 50,
+    WeightPerGoldMedal: 0.5,
+    MinionRewardTier: 12,
+    MinionRewardWeight: 5,
+};

package/lib/crops/special.d.ts

@@ -0,0 +1,6 @@
+import { Crop } from '../constants/crops';
+export declare function CalculateAverageSpecialCrops(blocksBroken: number, crop: Crop, armor: 1 | 2 | 3 | 4): {
+    type: import("../constants/specialcrops").SpecialCrop;
+    amount: number;
+    npc: number;
+};

package/lib/crops/special.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculateAverageSpecialCrops = void 0;
+const specialcrops_1 = require("../constants/specialcrops");
+function CalculateAverageSpecialCrops(blocksBroken, crop, armor) {
+    const type = specialcrops_1.MATCHING_SPECIAL_CROP[crop];
+    const { rates, npc } = specialcrops_1.SPECIAL_CROP_INFO[type];
+    const chance = rates[armor - 1] ?? 0;
+    const amount = blocksBroken * chance;
+    return {
+        type,
+        amount: amount,
+        npc: npc * amount,
+    };
+}
+exports.CalculateAverageSpecialCrops = CalculateAverageSpecialCrops;

package/lib/index.d.ts

@@ -1,3 +1,6 @@
-import { CalculateExpectedDrops, CalculateAverageDrops, GetCropInfo } from './ratecalc';
+import { CalculateExpectedDrops, CalculateAverageDrops, GetCropInfo, GetNPCProfit, CalculateDetailedAverageDrops, CalculateDetailedDrops } from './ratecalc';
 import { CropInfo, Crop, MAX_CROP_FORTUNE } from './constants/crops';
-export { CalculateExpectedDrops, CalculateAverageDrops, GetCropInfo, CropInfo, Crop, MAX_CROP_FORTUNE };
+import { CropDisplayName } from './util/names';
+import { CreateFarmingWeightCalculator } from './weight/weightcalc';
+import { FormatJacobContests, CalculateJacobContestMedal } from './util/jacob';
+export { CalculateExpectedDrops, CalculateAverageDrops, CalculateDetailedAverageDrops, CalculateDetailedDrops, GetCropInfo, CropInfo, Crop, MAX_CROP_FORTUNE, CropDisplayName, GetNPCProfit, CreateFarmingWeightCalculator, FormatJacobContests, CalculateJacobContestMedal, };

package/lib/index.js

@@ -1,10 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CROP_FORTUNE = exports.Crop = exports.GetCropInfo = exports.CalculateAverageDrops = exports.CalculateExpectedDrops = void 0;
+exports.CalculateJacobContestMedal = exports.FormatJacobContests = exports.CreateFarmingWeightCalculator = exports.GetNPCProfit = exports.CropDisplayName = exports.MAX_CROP_FORTUNE = exports.Crop = exports.GetCropInfo = exports.CalculateDetailedDrops = exports.CalculateDetailedAverageDrops = exports.CalculateAverageDrops = exports.CalculateExpectedDrops = void 0;
 const ratecalc_1 = require("./ratecalc");
 Object.defineProperty(exports, "CalculateExpectedDrops", { enumerable: true, get: function () { return ratecalc_1.CalculateExpectedDrops; } });
 Object.defineProperty(exports, "CalculateAverageDrops", { enumerable: true, get: function () { return ratecalc_1.CalculateAverageDrops; } });
 Object.defineProperty(exports, "GetCropInfo", { enumerable: true, get: function () { return ratecalc_1.GetCropInfo; } });
+Object.defineProperty(exports, "GetNPCProfit", { enumerable: true, get: function () { return ratecalc_1.GetNPCProfit; } });
+Object.defineProperty(exports, "CalculateDetailedAverageDrops", { enumerable: true, get: function () { return ratecalc_1.CalculateDetailedAverageDrops; } });
+Object.defineProperty(exports, "CalculateDetailedDrops", { enumerable: true, get: function () { return ratecalc_1.CalculateDetailedDrops; } });
 const crops_1 = require("./constants/crops");
 Object.defineProperty(exports, "Crop", { enumerable: true, get: function () { return crops_1.Crop; } });
 Object.defineProperty(exports, "MAX_CROP_FORTUNE", { enumerable: true, get: function () { return crops_1.MAX_CROP_FORTUNE; } });
+const names_1 = require("./util/names");
+Object.defineProperty(exports, "CropDisplayName", { enumerable: true, get: function () { return names_1.CropDisplayName; } });
+const weightcalc_1 = require("./weight/weightcalc");
+Object.defineProperty(exports, "CreateFarmingWeightCalculator", { enumerable: true, get: function () { return weightcalc_1.CreateFarmingWeightCalculator; } });
+const jacob_1 = require("./util/jacob");
+Object.defineProperty(exports, "FormatJacobContests", { enumerable: true, get: function () { return jacob_1.FormatJacobContests; } });
+Object.defineProperty(exports, "CalculateJacobContestMedal", { enumerable: true, get: function () { return jacob_1.CalculateJacobContestMedal; } });

package/lib/ratecalc.d.ts

@@ -4,10 +4,28 @@ interface CalculateDropsOptions {
     blocksBroken: number;
 }
 export declare function CalculateAverageDrops(options: CalculateDropsOptions): Record<Crop, number>;
+interface CalculateDetailedDropsOptions extends CalculateDropsOptions {
+    bountiful: boolean;
+    mooshroom: boolean;
+}
+interface DetailedDrops {
+    collection: number;
+    npcCoins: number;
+    fortune: number;
+    coinSources: Record<string, number>;
+    otherCollection: Record<string, number>;
+}
+export declare function CalculateDetailedAverageDrops(options: CalculateDetailedDropsOptions): Record<Crop, DetailedDrops>;
 interface CalculateExpectedDropsOptions extends CalculateDropsOptions {
     blocksBroken: number;
     crop: Crop;
 }
+interface CalculateCropDetailedDropsOptions extends CalculateDetailedDropsOptions {
+    blocksBroken: number;
+    crop: Crop;
+}
 export declare function CalculateExpectedDrops(options: CalculateExpectedDropsOptions): number;
+export declare function CalculateDetailedDrops(options: CalculateCropDetailedDropsOptions): DetailedDrops;
+export declare function GetNPCProfit(crop: Crop, amount: number): number;
 export declare function GetCropInfo(crop: Crop): CropInfo;
 export {};

package/lib/ratecalc.js

@@ -1,34 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetCropInfo = exports.CalculateExpectedDrops = exports.CalculateAverageDrops = void 0;
+exports.GetCropInfo = exports.GetNPCProfit = exports.CalculateDetailedDrops = exports.CalculateExpectedDrops = exports.CalculateDetailedAverageDrops = exports.CalculateAverageDrops = void 0;
 const crops_1 = require("./constants/crops");
 const melon_1 = require("./crops/melon");
 const pumpkin_1 = require("./crops/pumpkin");
+const special_1 = require("./crops/special");
+const crops = [
+    crops_1.Crop.Cactus,
+    crops_1.Crop.Carrot,
+    crops_1.Crop.CocoaBeans,
+    crops_1.Crop.Melon,
+    crops_1.Crop.Mushroom,
+    crops_1.Crop.NetherWart,
+    crops_1.Crop.Potato,
+    crops_1.Crop.Pumpkin,
+    crops_1.Crop.SugarCane,
+    crops_1.Crop.Wheat,
+    crops_1.Crop.Seeds,
+];
 function CalculateAverageDrops(options) {
-    const { farmingFortune, blocksBroken } = options;
-    const result = {
-        [crops_1.Crop.Cactus]: 0,
-        [crops_1.Crop.Carrot]: 0,
-        [crops_1.Crop.CocoaBeans]: 0,
-        [crops_1.Crop.Melon]: 0,
-        [crops_1.Crop.Mushroom]: 0,
-        [crops_1.Crop.NetherWart]: 0,
-        [crops_1.Crop.Potato]: 0,
-        [crops_1.Crop.Pumpkin]: 0,
-        [crops_1.Crop.SugarCane]: 0,
-        [crops_1.Crop.Wheat]: 0,
-        [crops_1.Crop.Seeds]: 0,
-    };
-    for (const crop of Object.keys(result)) {
+    const result = {};
+    for (const crop of crops) {
         result[crop] = CalculateExpectedDrops({
-            farmingFortune,
             crop: crop,
-            blocksBroken,
+            ...options,
         });
     }
     return result;
 }
 exports.CalculateAverageDrops = CalculateAverageDrops;
+function CalculateDetailedAverageDrops(options) {
+    const result = {};
+    for (const crop of crops) {
+        result[crop] = CalculateDetailedDrops({
+            crop: crop,
+            ...options,
+        });
+    }
+    const wheat = result[crops_1.Crop.Wheat];
+    const seeds = result[crops_1.Crop.Seeds];
+    wheat.otherCollection['Seeds'] = seeds.collection;
+    wheat.coinSources['Seeds'] = seeds.collection * crops_1.CROP_INFO[crops_1.Crop.Seeds].npc;
+    if (options.bountiful) {
+        wheat.coinSources['Bountiful (Seeds)'] = seeds.coinSources['Bountiful'];
+    }
+    wheat.npcCoins = Object.values(wheat.coinSources).reduce((a, b) => a + b, 0);
+    return result;
+}
+exports.CalculateDetailedAverageDrops = CalculateDetailedAverageDrops;
 function CalculateExpectedDrops(options) {
     const { farmingFortune, blocksBroken, crop } = options;
     const fortune = farmingFortune ?? crops_1.MAX_CROP_FORTUNE[crop] ?? 0;
@@ -37,27 +56,97 @@ function CalculateExpectedDrops(options) {
     const { drops } = GetCropInfo(crop);
     if (!drops)
         return 0;
-    const normal = blocksBroken * drops * (fortune * 0.1);
+    const baseDrops = blocksBroken * drops * (fortune * 0.01);
     switch (crop) {
         case crops_1.Crop.Cactus:
+        case crops_1.Crop.Wheat:
+        case crops_1.Crop.Mushroom:
+        case crops_1.Crop.SugarCane:
+            return Math.round(baseDrops);
         case crops_1.Crop.Carrot:
         case crops_1.Crop.CocoaBeans:
-        case crops_1.Crop.Mushroom:
         case crops_1.Crop.NetherWart:
         case crops_1.Crop.Potato:
-        case crops_1.Crop.SugarCane:
-        case crops_1.Crop.Wheat:
         case crops_1.Crop.Seeds:
-            return normal;
+            return Math.round(baseDrops - blocksBroken); // Replenish takes away one drop per block broken
         case crops_1.Crop.Pumpkin:
-            return normal + (0, pumpkin_1.PumpkinPerkBonus)(blocksBroken);
+            return Math.round(baseDrops + (0, pumpkin_1.PumpkinPerkBonus)(blocksBroken));
         case crops_1.Crop.Melon:
-            return normal + (0, melon_1.MelonPerkBonus)(blocksBroken);
+            return Math.round(baseDrops + (0, melon_1.MelonPerkBonus)(blocksBroken));
         default:
             return 0;
     }
 }
 exports.CalculateExpectedDrops = CalculateExpectedDrops;
+function CalculateDetailedDrops(options) {
+    const result = {
+        collection: 0,
+        npcCoins: 0,
+        fortune: 0,
+        coinSources: {},
+        otherCollection: {},
+    };
+    const { farmingFortune, blocksBroken, crop, bountiful } = options;
+    let fortune = farmingFortune ?? crops_1.MAX_CROP_FORTUNE[crop] ?? 0;
+    if (fortune <= 0 || blocksBroken < 0)
+        return result;
+    if (!bountiful && !farmingFortune) {
+        fortune += 5;
+    }
+    result.fortune = fortune;
+    const { drops, npc, breaks = 1 } = GetCropInfo(crop);
+    if (!drops)
+        return result;
+    const baseDrops = blocksBroken * drops * (fortune * 0.01);
+    // Coin sources
+    result.coinSources['Collection'] = Math.round(baseDrops * npc);
+    if (bountiful) {
+        result.coinSources['Bountiful'] = Math.round(baseDrops * 0.2);
+    }
+    if (options.mooshroom) {
+        result.coinSources['Mooshroom'] = Math.round(blocksBroken * breaks * crops_1.CROP_INFO[crops_1.Crop.Mushroom].npc);
+        result.otherCollection['Mushroom'] = Math.round(blocksBroken * breaks);
+    }
+    const specialCrops = (0, special_1.CalculateAverageSpecialCrops)(blocksBroken, crop, 4);
+    result.otherCollection[specialCrops.type] = Math.round(specialCrops.amount);
+    result.coinSources[specialCrops.type] = Math.round(specialCrops.npc);
+    let extraDrops = 0;
+    switch (crop) {
+        case crops_1.Crop.Cactus:
+        case crops_1.Crop.Wheat:
+        case crops_1.Crop.Mushroom:
+        case crops_1.Crop.SugarCane:
+            result.collection = Math.round(baseDrops);
+            break;
+        case crops_1.Crop.Carrot:
+        case crops_1.Crop.CocoaBeans:
+        case crops_1.Crop.NetherWart:
+        case crops_1.Crop.Potato:
+        case crops_1.Crop.Seeds:
+            result.collection = Math.round(baseDrops - blocksBroken); // Replenish takes away one drop per block broken
+            break;
+        case crops_1.Crop.Pumpkin:
+            extraDrops = Math.round((0, pumpkin_1.PumpkinPerkBonus)(blocksBroken));
+            result.coinSources['Dicer RNG'] = Math.round(extraDrops * npc);
+            result.collection = Math.round(baseDrops + extraDrops);
+            break;
+        case crops_1.Crop.Melon:
+            extraDrops = Math.round((0, melon_1.MelonPerkBonus)(blocksBroken));
+            result.coinSources['Dicer RNG'] = Math.round(extraDrops * npc);
+            result.collection = Math.round(baseDrops + extraDrops);
+            break;
+    }
+    result.npcCoins = Object.values(result.coinSources).reduce((a, b) => a + b, 0);
+    return result;
+}
+exports.CalculateDetailedDrops = CalculateDetailedDrops;
+function GetNPCProfit(crop, amount) {
+    const { npc } = GetCropInfo(crop);
+    if (!npc)
+        return 0;
+    return npc * amount;
+}
+exports.GetNPCProfit = GetNPCProfit;
 function GetCropInfo(crop) {
     return crops_1.CROP_INFO[crop] ?? {};
 }

package/lib/util/jacob.d.ts

@@ -0,0 +1,16 @@
+export type JacobContestMedal = 'bronze' | 'silver' | 'gold';
+export interface RawJacobContest {
+    collected: number;
+    claimed_rewards?: boolean;
+    claimed_position?: number;
+    claimed_participants?: number;
+    claimed_medal?: JacobContestMedal;
+}
+export interface JacobContest {
+    collected: number;
+    position?: number;
+    participants?: number;
+    medal?: JacobContestMedal;
+}
+export declare function FormatJacobContests(contests: RawJacobContest[]): JacobContest[];
+export declare function CalculateJacobContestMedal(contest: RawJacobContest): JacobContestMedal | undefined;

package/lib/util/jacob.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculateJacobContestMedal = exports.FormatJacobContests = void 0;
+function FormatJacobContests(contests) {
+    return contests.map((contest) => {
+        return {
+            collected: contest.collected,
+            position: contest.claimed_position,
+            participants: contest.claimed_participants,
+            medal: CalculateJacobContestMedal(contest),
+        };
+    });
+}
+exports.FormatJacobContests = FormatJacobContests;
+function CalculateJacobContestMedal(contest) {
+    if (contest.claimed_medal) {
+        return contest.claimed_medal;
+    }
+    const { claimed_position: position, claimed_participants: participants } = contest;
+    if (position === undefined || participants === undefined) {
+        return undefined;
+    }
+    if (position <= participants * 0.05 + 1)
+        return 'gold';
+    if (position <= participants * 0.25 + 1)
+        return 'silver';
+    if (position <= participants * 0.6 + 1)
+        return 'bronze';
+    return undefined;
+}
+exports.CalculateJacobContestMedal = CalculateJacobContestMedal;

package/lib/util/names.d.ts

@@ -0,0 +1,2 @@
+import { Crop } from '../constants/crops';
+export declare function CropDisplayName(crop: Crop): string;

package/lib/util/names.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CropDisplayName = void 0;
+const crops_1 = require("../constants/crops");
+const CROP_DISPLAY_NAMES = {
+    [crops_1.Crop.Cactus]: 'Cactus',
+    [crops_1.Crop.Carrot]: 'Carrot',
+    [crops_1.Crop.CocoaBeans]: 'Cocoa Beans',
+    [crops_1.Crop.Melon]: 'Melon',
+    [crops_1.Crop.Mushroom]: 'Mushroom',
+    [crops_1.Crop.NetherWart]: 'Nether Wart',
+    [crops_1.Crop.Potato]: 'Potato',
+    [crops_1.Crop.Pumpkin]: 'Pumpkin',
+    [crops_1.Crop.SugarCane]: 'Sugar Cane',
+    [crops_1.Crop.Wheat]: 'Wheat',
+    [crops_1.Crop.Seeds]: 'Seeds',
+};
+function CropDisplayName(crop) {
+    return CROP_DISPLAY_NAMES[crop] ?? 'Unknown Crop';
+}
+exports.CropDisplayName = CropDisplayName;

package/lib/weight/weightcalc.d.ts

@@ -0,0 +1,49 @@
+import { Crop } from '../constants/crops';
+export declare function CreateFarmingWeightCalculator(info?: FarmingWeightInfo): FarmingWeight;
+interface FarmingWeightInfo {
+    collection?: Record<string, number>;
+    farmingXp?: number;
+    levelCapUpgrade?: number;
+    anitaBonusFarmingFortuneLevel?: number;
+    minions?: string[];
+    contests?: {
+        collected: number;
+        claimed_position?: number;
+        claimed_participants?: number;
+        claimed_medal?: 'bronze' | 'silver' | 'gold';
+    }[];
+}
+declare class FarmingWeight {
+    collection: Record<Crop, number>;
+    levelCapUpgrade: number;
+    farmingXp: number;
+    anitaBonusFarmingFortuneLevel: number;
+    tier12MinionCount: number;
+    earnedGoldMedals: number;
+    cropWeights: Record<Crop, number>;
+    bonusSources: Record<string, number>;
+    constructor(info?: FarmingWeightInfo);
+    /**
+     * Expectes a dictionary of collections and amounts with the default Hypixel SkyBlock IDs
+     * @param {Record<string, number>} collections
+     * @returns {FarmingWeight}
+     */
+    setCropsFromCollections(collections: Record<string, number>): FarmingWeight;
+    setCrop: (crop: Crop, collection: number) => this;
+    setLevelCap: (levelCap: number) => this;
+    setFarmingXp: (farmingXp: number) => this;
+    setAnitaBonusLevel: (anitaBonusFarmingFortuneLevel: number) => this;
+    addMinions: (minions: string[]) => this;
+    setTier12MinionCount: (count: number) => this;
+    setContests: (contests: FarmingWeightInfo['contests']) => this;
+    getWeightInfo: () => {
+        totalWeight: number;
+        bonusWeight: number;
+        cropWeight: number;
+        bonusSources: Record<string, number>;
+    };
+    getBonusWeights: () => Record<string, number>;
+    getCropWeights: () => Record<Crop, number>;
+    getCropWeight: (crop: Crop) => void;
+}
+export {};

package/lib/weight/weightcalc.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateFarmingWeightCalculator = void 0;
+const crops_1 = require("../constants/crops");
+const weight_1 = require("../constants/weight");
+function CreateFarmingWeightCalculator(info) {
+    return new FarmingWeight(info);
+}
+exports.CreateFarmingWeightCalculator = CreateFarmingWeightCalculator;
+const crops = [
+    crops_1.Crop.Cactus,
+    crops_1.Crop.Carrot,
+    crops_1.Crop.CocoaBeans,
+    crops_1.Crop.Melon,
+    crops_1.Crop.Mushroom,
+    crops_1.Crop.NetherWart,
+    crops_1.Crop.Potato,
+    crops_1.Crop.Pumpkin,
+    crops_1.Crop.SugarCane,
+    crops_1.Crop.Wheat,
+];
+class FarmingWeight {
+    constructor(info) {
+        this.collection = {};
+        this.levelCapUpgrade = info?.levelCapUpgrade ?? 0;
+        this.anitaBonusFarmingFortuneLevel = info?.anitaBonusFarmingFortuneLevel ?? 0;
+        this.farmingXp = info?.farmingXp ?? 0;
+        this.earnedGoldMedals = 0;
+        this.tier12MinionCount = 0;
+        this.setCropsFromCollections(info?.collection ?? {});
+        this.addMinions(info?.minions ?? []);
+    }
+    /**
+     * Expectes a dictionary of collections and amounts with the default Hypixel SkyBlock IDs
+     * @param {Record<string, number>} collections
+     * @returns {FarmingWeight}
+     */
+    setCropsFromCollections(collections) {
+        for (const crop of crops) {
+            this.collection[crop] = collections[crop] ?? 0;
+        }
+        this.getCropWeights();
+        return this;
+    }
+    setCrop = (crop, collection) => {
+        this.collection[crop] = collection;
+        this.getCropWeights();
+        return this;
+    };
+    setLevelCap = (levelCap) => {
+        this.levelCapUpgrade = levelCap;
+        return this;
+    };
+    setFarmingXp = (farmingXp) => {
+        this.farmingXp = farmingXp;
+        return this;
+    };
+    setAnitaBonusLevel = (anitaBonusFarmingFortuneLevel) => {
+        this.anitaBonusFarmingFortuneLevel = anitaBonusFarmingFortuneLevel;
+        return this;
+    };
+    addMinions = (minions) => {
+        for (const minion of minions) {
+            if (!minion.endsWith('_12'))
+                continue;
+            if (!weight_1.TIER_12_MINIONS.includes(minion))
+                continue;
+            this.tier12MinionCount++;
+        }
+        return this;
+    };
+    setTier12MinionCount = (count) => {
+        this.tier12MinionCount = count;
+        return this;
+    };
+    setContests = (contests) => {
+        if (!contests?.length)
+            return this;
+        for (const contest of contests) {
+            if (contest.claimed_medal === 'gold') {
+                this.earnedGoldMedals++;
+                continue;
+            }
+            const position = contest.claimed_position;
+            const participants = contest.claimed_participants;
+            if (position === undefined || participants === undefined)
+                continue;
+            if (position <= participants * 0.05 + 1) {
+                this.earnedGoldMedals++;
+            }
+        }
+        return this;
+    };
+    getWeightInfo = () => {
+        const bonus = this.getBonusWeights();
+        const crops = this.getCropWeights();
+        const bonusTotal = Object.values(bonus).reduce((a, b) => a + b, 0);
+        const cropTotal = Object.values(crops).reduce((a, b) => a + b, 0);
+        return {
+            totalWeight: bonusTotal + cropTotal,
+            bonusWeight: bonusTotal,
+            cropWeight: cropTotal,
+            bonusSources: bonus,
+        };
+    };
+    getBonusWeights = () => {
+        if (this.farmingXp >= 111_672_425 && this.levelCapUpgrade >= 10) {
+            // Farming 60 bonus
+            this.bonusSources['Farming 60'] = weight_1.BONUS_WEIGHT.Farming60Bonus;
+        }
+        else if (this.farmingXp >= 55_172_425) {
+            // Farming 50 bonus
+            this.bonusSources['Farming 50'] = weight_1.BONUS_WEIGHT.Farming50Bonus;
+        }
+        // Tier 12 minion bonus
+        if (this.tier12MinionCount > 0) {
+            this.bonusSources['Tier 12 Minions'] = this.tier12MinionCount * weight_1.BONUS_WEIGHT.MinionRewardWeight;
+        }
+        // Anita bonus
+        if (this.anitaBonusFarmingFortuneLevel > 0) {
+            this.bonusSources['Anita Bonus'] =
+                this.anitaBonusFarmingFortuneLevel * weight_1.BONUS_WEIGHT.AnitaBuffBonusMultiplier;
+        }
+        if (this.earnedGoldMedals > weight_1.BONUS_WEIGHT.MaxMedalsCounted) {
+            this.bonusSources['Gold Medals'] = Math.floor(weight_1.BONUS_WEIGHT.WeightPerGoldMedal * weight_1.BONUS_WEIGHT.MaxMedalsCounted);
+        }
+        else {
+            const rewardCount = Math.floor((this.earnedGoldMedals / 50) * 50);
+            if (rewardCount > 0) {
+                this.bonusSources['Gold Medals'] = Math.floor(weight_1.BONUS_WEIGHT.WeightPerGoldMedal * rewardCount);
+            }
+        }
+        return this.bonusSources;
+    };
+    getCropWeights = () => {
+        const cropWeight = {};
+        let totalWeight = 0;
+        let doubleBreakWeight = 0;
+        for (const crop of crops) {
+            const collected = this.collection[crop] ?? 0;
+            const weight = collected / weight_1.CROP_WEIGHT[crop];
+            totalWeight += weight;
+            if (crop === crops_1.Crop.Cactus || crop === crops_1.Crop.SugarCane) {
+                doubleBreakWeight += weight;
+            }
+            cropWeight[crop] = weight;
+        }
+        // Mushroom is a special case, it needs to be calculated dynamically based on the
+        // ratio between the farmed crops that give two mushrooms per break with cow pet
+        // and the farmed crops that give one mushroom per break with cow pet
+        const mushroomCollection = this.collection[crops_1.Crop.Mushroom] ?? 0;
+        const mushroomWeightNumber = weight_1.CROP_WEIGHT[crops_1.Crop.Mushroom];
+        const doubleBreakRatio = doubleBreakWeight / totalWeight;
+        const normalCropRatio = (totalWeight - doubleBreakWeight) / totalWeight;
+        const mushroomWeight = doubleBreakRatio * (mushroomCollection / (mushroomWeightNumber * 2)) +
+            normalCropRatio * (mushroomCollection / mushroomWeightNumber);
+        cropWeight[crops_1.Crop.Mushroom] = mushroomWeight;
+        return cropWeight;
+    };
+    getCropWeight = (crop) => {
+        weight_1.CROP_WEIGHT[crop];
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "farming-weight",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Tools for calculating farming weight and fortune in Hypixel Skyblock",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",