osrs-tools 2.8.1 → 2.9.1

package/dist/runescape/model/guilds/Rumours.js

@@ -0,0 +1,303 @@
+import { HunterRumour } from "./HunterRumour";
+import { RumourLocation } from "./RumourLocation";
+import { HunterGuildMasterName } from "./HunterGuildMaster";
+import { HunterRumourMethods, HunterLeagueRegions } from "./types";
+// Common location name constants to avoid repeated literal strings
+const FELDIP_HUNTER_AREA = 'Feldip Hunter area';
+const PISCATORIS_HUNTER_AREA = 'Piscatoris Hunter area';
+const RELLEKKA_HUNTER_AREA = 'Rellekka Hunter area';
+const THE_GREAT_CONCH = 'The Great Conch';
+const TLATI_RAINFOREST = 'Tlati Rainforest';
+const FARMING_GUILD = 'Farming Guild';
+const PISCATORIS_FALCONRY_AREA = 'Piscatoris falconry area';
+const AVIUM_SAVANNAH = 'Avium Savannah';
+const MONS_GRATIA = 'Mons Gratia';
+const NEYPOTZLI = 'Neypotzli';
+const THE_BURROW = 'The Burrow';
+const { BIRD_SNARE, DEADFALL, BUTTERFLY_NET, NET_TRAP, SPIKED_PIT, BOX_TRAP, FALCONRY, TRACKING, } = HunterRumourMethods;
+const { KANDARIN, VARLAMORE, FREMENNIK, KOUREND, MORYTANIA, KARAMJA, DESERT, MISHTHALIN, TIRANNWN, } = HunterLeagueRegions;
+export const HUNTER_RUMOUR_REGISTRY = [
+    new HunterRumour({
+        id: 'tropical-wagtail',
+        creature: 'Tropical wagtail',
+        method: 'Bird snare',
+        locations: [new RumourLocation(FELDIP_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Tropical_wagtail'), new RumourLocation(THE_GREAT_CONCH, 'https://oldschool.runescape.wiki/w/Tropical_wagtail'), new RumourLocation(TLATI_RAINFOREST, 'https://oldschool.runescape.wiki/w/Tropical_wagtail')],
+        requiredHunterLevel: 19,
+        tier: 'Novice',
+        masterNames: [HunterGuildMasterName.GILMAN],
+        leagueRegions: ["Kandarin", "Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'wild-kebbit',
+        creature: 'Wild kebbit',
+        method: 'Deadfall',
+        locations: [new RumourLocation(PISCATORIS_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Wild_kebbit'), new RumourLocation('Auburnvale', 'https://oldschool.runescape.wiki/w/Wild_kebbit')],
+        requiredHunterLevel: 23,
+        tier: 'Novice',
+        masterNames: [HunterGuildMasterName.GILMAN],
+        leagueRegions: ["Kandarin", "Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'sapphire-glacialis',
+        creature: 'Sapphire glacialis',
+        method: 'Butterfly net',
+        locations: [new RumourLocation(RELLEKKA_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Sapphire_glacialis'), new RumourLocation(FARMING_GUILD, 'https://oldschool.runescape.wiki/w/Sapphire_glacialis'), new RumourLocation(MONS_GRATIA, 'https://oldschool.runescape.wiki/w/Sapphire_glacialis')],
+        requiredHunterLevel: 25,
+        tier: 'Novice',
+        masterNames: [HunterGuildMasterName.GILMAN],
+        leagueRegions: ["Fremennik", "Kourend", "Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'swamp-lizard',
+        creature: 'Swamp lizard',
+        method: 'Net trap',
+        locations: [new RumourLocation('Canifis Hunter area', 'https://oldschool.runescape.wiki/w/Swamp_lizard'), new RumourLocation('North-west of Slepe', 'https://oldschool.runescape.wiki/w/Swamp_lizard')],
+        requiredHunterLevel: 29,
+        tier: 'Adept',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus'],
+        leagueRegions: ["Morytania"],
+    }),
+    new HunterRumour({
+        id: 'spined-larupia',
+        creature: 'Spined larupia',
+        method: 'Spiked pit',
+        locations: [new RumourLocation(FELDIP_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Spined_larupia')],
+        requiredHunterLevel: 31,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Aco'],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'barb-tailed-kebbit',
+        creature: 'Barb-tailed kebbit',
+        method: 'Deadfall',
+        locations: [new RumourLocation(FELDIP_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Barb-tailed_kebbit')],
+        requiredHunterLevel: 33,
+        tier: 'Novice',
+        masterNames: [HunterGuildMasterName.GILMAN],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'snowy-knight',
+        creature: 'Snowy knight',
+        method: 'Butterfly net',
+        locations: [new RumourLocation(RELLEKKA_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Snowy_knight'), new RumourLocation('Weiss', 'https://oldschool.runescape.wiki/w/Snowy_knight'), new RumourLocation(FARMING_GUILD, 'https://oldschool.runescape.wiki/w/Snowy_knight'), new RumourLocation(MONS_GRATIA, 'https://oldschool.runescape.wiki/w/Snowy_knight')],
+        requiredHunterLevel: 35,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Aco'],
+        leagueRegions: ["Fremennik", "Kandarin", "Kourend", "Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'prickly-kebbit',
+        creature: 'Prickly kebbit',
+        method: 'Deadfall',
+        locations: [new RumourLocation(PISCATORIS_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Prickly_kebbit')],
+        requiredHunterLevel: 37,
+        tier: 'Novice',
+        masterNames: [HunterGuildMasterName.GILMAN],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'embertailed-jerboa',
+        creature: 'Embertailed jerboa',
+        method: 'Box trap',
+        locations: [new RumourLocation('West of Hunter Guild', 'https://oldschool.runescape.wiki/w/Embertailed_jerboa'), new RumourLocation('North-west of the Locus Oasis', 'https://oldschool.runescape.wiki/w/Embertailed_jerboa')],
+        requiredHunterLevel: 39,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Aco'],
+        leagueRegions: ["Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'horned-graahk',
+        creature: 'Horned graahk',
+        method: 'Spiked pit',
+        locations: [new RumourLocation('Karamja Hunter area', 'https://oldschool.runescape.wiki/w/Horned_graahk')],
+        requiredHunterLevel: 41,
+        tier: 'Adept',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus'],
+        leagueRegions: ["Karamja"],
+    }),
+    new HunterRumour({
+        id: 'spotted-kebbit',
+        creature: 'Spotted kebbit',
+        method: 'Falconry',
+        locations: [new RumourLocation(PISCATORIS_FALCONRY_AREA, 'https://oldschool.runescape.wiki/w/Spotted_kebbit')],
+        requiredHunterLevel: 43,
+        tier: 'Adept',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Ornus'],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'black-warlock',
+        creature: 'Black warlock',
+        method: 'Butterfly net',
+        locations: [new RumourLocation(FELDIP_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Black_warlock'), new RumourLocation(FARMING_GUILD, 'https://oldschool.runescape.wiki/w/Black_warlock'), new RumourLocation('Crypt of Tonali hunter area', 'https://oldschool.runescape.wiki/w/Black_warlock'), new RumourLocation(TLATI_RAINFOREST, 'https://oldschool.runescape.wiki/w/Black_warlock'), new RumourLocation('Shimmering Atoll', 'https://oldschool.runescape.wiki/w/Black_warlock')],
+        requiredHunterLevel: 45,
+        tier: 'Adept',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus'],
+        leagueRegions: ["Kandarin", "Kourend", "Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'orange-salamander',
+        creature: 'Orange salamander',
+        method: 'Net trap',
+        locations: [new RumourLocation(THE_GREAT_CONCH, 'https://oldschool.runescape.wiki/w/Orange_salamander'), new RumourLocation('Uzer Hunter area', 'https://oldschool.runescape.wiki/w/Orange_salamander'), new RumourLocation('Necropolis Hunter area', 'https://oldschool.runescape.wiki/w/Orange_salamander')],
+        requiredHunterLevel: 47,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Ornus'],
+        leagueRegions: ["Desert"],
+    }),
+    new HunterRumour({
+        id: 'razor-backed-kebbit',
+        creature: 'Razor-backed kebbit',
+        method: 'Tracking',
+        locations: [new RumourLocation(PISCATORIS_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Razor-backed_kebbit')],
+        requiredHunterLevel: 49,
+        tier: 'Adept',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus'],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'sabre-toothed-kebbit',
+        creature: 'Sabre-toothed kebbit',
+        method: 'Deadfall',
+        locations: [new RumourLocation(RELLEKKA_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Sabre-toothed_kebbit')],
+        requiredHunterLevel: 51,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Ornus'],
+        leagueRegions: ["Fremennik"],
+    }),
+    new HunterRumour({
+        id: 'grey-chinchompa',
+        creature: 'Grey chinchompa',
+        method: 'Box trap',
+        locations: [new RumourLocation(PISCATORIS_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Grey_chinchompa'), new RumourLocation('Kourend Woodland', 'https://oldschool.runescape.wiki/w/Grey_chinchompa'), new RumourLocation('Isle of Souls', 'https://oldschool.runescape.wiki/w/Grey_chinchompa')],
+        requiredHunterLevel: 53,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Aco', 'Teco'],
+        leagueRegions: ["Kandarin", "Kourend", "Misthalin"],
+    }),
+    new HunterRumour({
+        id: 'sabre-toothed-kyatt',
+        creature: 'Sabre-toothed kyatt',
+        method: 'Spiked pit',
+        locations: [new RumourLocation(RELLEKKA_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Sabre-toothed_kyatt')],
+        requiredHunterLevel: 55,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Ornus', 'Aco', 'Teco'],
+        leagueRegions: ["Fremennik"],
+    }),
+    new HunterRumour({
+        id: 'dark-kebbit',
+        creature: 'Dark kebbit',
+        method: 'Falconry',
+        locations: [new RumourLocation(PISCATORIS_FALCONRY_AREA, 'https://oldschool.runescape.wiki/w/Dark_kebbit')],
+        requiredHunterLevel: 57,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Aco', 'Teco'],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'pyre-fox',
+        creature: 'Pyre fox',
+        method: 'Deadfall',
+        locations: [new RumourLocation(AVIUM_SAVANNAH, 'https://oldschool.runescape.wiki/w/Pyre_fox')],
+        requiredHunterLevel: 57,
+        tier: 'Expert',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Ornus'],
+        leagueRegions: ["Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'red-salamander',
+        creature: 'Red salamander',
+        method: 'Net trap',
+        locations: [new RumourLocation('Ourania Hunter area', 'https://oldschool.runescape.wiki/w/Red_salamander'), new RumourLocation('Charred Island', 'https://oldschool.runescape.wiki/w/Red_salamander')],
+        requiredHunterLevel: 59,
+        tier: 'Master',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Aco', 'Teco', 'Wolf'],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'red-chinchompa',
+        creature: 'Red chinchompa',
+        method: 'Box trap',
+        locations: [new RumourLocation('Chinchompa Island', 'https://oldschool.runescape.wiki/w/Red_chinchompa'), new RumourLocation(FELDIP_HUNTER_AREA, 'https://oldschool.runescape.wiki/w/Red_chinchompa'), new RumourLocation(THE_GREAT_CONCH, 'https://oldschool.runescape.wiki/w/Red_chinchompa'), new RumourLocation('Gwenith Hunter area', 'https://oldschool.runescape.wiki/w/Red_chinchompa'), new RumourLocation('Red chinchompa hunting ground', 'https://oldschool.runescape.wiki/w/Red_chinchompa'), new RumourLocation(TLATI_RAINFOREST, 'https://oldschool.runescape.wiki/w/Red_chinchompa')],
+        requiredHunterLevel: 63,
+        tier: 'Master',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Ornus', 'Aco', 'Teco', 'Wolf'],
+        leagueRegions: ["Kandarin", "Tirannwn", "Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'dashing-kebbit',
+        creature: 'Dashing kebbit',
+        method: 'Falconry',
+        locations: [new RumourLocation(PISCATORIS_FALCONRY_AREA, 'https://oldschool.runescape.wiki/w/Dashing_kebbit')],
+        requiredHunterLevel: 69,
+        tier: 'Master',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Aco', 'Teco', 'Wolf'],
+        leagueRegions: ["Kandarin"],
+    }),
+    new HunterRumour({
+        id: 'sunlight-antelope',
+        creature: 'Sunlight antelope',
+        method: 'Spiked pit',
+        locations: [new RumourLocation(AVIUM_SAVANNAH, 'https://oldschool.runescape.wiki/w/Sunlight_antelope')],
+        requiredHunterLevel: 72,
+        tier: 'Master',
+        masterNames: ['Aco', 'Teco', 'Wolf'],
+        leagueRegions: ["Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'sunlight-moth',
+        creature: 'Sunlight moth',
+        method: 'Butterfly net',
+        locations: [new RumourLocation(AVIUM_SAVANNAH, 'https://oldschool.runescape.wiki/w/Sunlight_moth'), new RumourLocation(NEYPOTZLI, 'https://oldschool.runescape.wiki/w/Sunlight_moth')],
+        requiredHunterLevel: 75,
+        tier: 'Master',
+        masterNames: [HunterGuildMasterName.GILMAN, 'Cervus', 'Teco'],
+        leagueRegions: ["Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'tecu-salamander',
+        creature: 'Tecu salamander',
+        method: 'Net trap',
+        locations: [new RumourLocation("Ralos' Rise", 'https://oldschool.runescape.wiki/w/Tecu_salamander')],
+        requiredHunterLevel: 79,
+        tier: 'Master',
+        masterNames: ['Aco', 'Wolf'],
+        leagueRegions: ["Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'herbiboar',
+        creature: 'Herbiboar',
+        method: 'Tracking',
+        locations: [new RumourLocation('Mushroom Forest on Fossil Island', 'https://oldschool.runescape.wiki/w/Herbiboar')],
+        requiredHunterLevel: 80,
+        tier: 'Master',
+        masterNames: ['Teco', 'Wolf'],
+        questRequirements: ['Bone Voyage'],
+        notes: 'Also requires Herblore 31',
+        leagueRegions: ["Misthalin"],
+    }),
+    new HunterRumour({
+        id: 'moonlight-moth',
+        creature: 'Moonlight moth',
+        method: 'Butterfly net',
+        locations: [new RumourLocation(THE_BURROW, 'https://oldschool.runescape.wiki/w/Moonlight_moth'), new RumourLocation(NEYPOTZLI, 'https://oldschool.runescape.wiki/w/Moonlight_moth'), new RumourLocation('Ruins of Tapoyauik', 'https://oldschool.runescape.wiki/w/Moonlight_moth'), new RumourLocation('Tonali Cavern', 'https://oldschool.runescape.wiki/w/Moonlight_moth')],
+        requiredHunterLevel: 85,
+        tier: 'Master',
+        masterNames: ['Aco', 'Wolf'],
+        leagueRegions: ["Varlamore"],
+    }),
+    new HunterRumour({
+        id: 'moonlight-antelope',
+        creature: 'Moonlight antelope',
+        method: 'Spiked pit',
+        locations: [new RumourLocation(THE_BURROW, 'https://oldschool.runescape.wiki/w/Moonlight_antelope')],
+        requiredHunterLevel: 91,
+        tier: 'Master',
+        masterNames: ['Wolf'],
+        questRequirements: ['At First Light'],
+        leagueRegions: ["Varlamore"],
+    }),
+];

package/dist/runescape/model/guilds/hunter/HunterGuild.d.ts

@@ -0,0 +1,33 @@
+import { HunterRumourAssignment } from './types';
+import { HunterRumour } from './HunterRumour';
+import { HunterGuildMaster } from './HunterGuildMaster';
+/**
+ * The Hunter Guild module encapsulates all data and logic related to the Hunter Guild, including its masters, rumours, and player progress. It provides methods to retrieve masters and rumours, determine eligibility, and assign rumours to players based on their level, completed quests, and current progress.
+ * Note: The rumours are defined in a separate module to avoid circular dependencies, as HunterRumour references HunterGuildMaster and vice versa.
+ */
+export declare class HunterGuild {
+    wikiUrl: string;
+    private gilman;
+    private cervus;
+    private ornus;
+    private aco;
+    private teco;
+    private wolf;
+    private completedQuests;
+    constructor(completedQuests?: string[]);
+    get Gilman(): HunterGuildMaster;
+    get Cervus(): HunterGuildMaster;
+    get Ornus(): HunterGuildMaster;
+    get Aco(): HunterGuildMaster;
+    get Teco(): HunterGuildMaster;
+    get Wolf(): HunterGuildMaster;
+    getMasterByName(masterName: string): HunterGuildMaster | undefined;
+    getAllMasters(): HunterGuildMaster[];
+    getRumourById(rumourId: string): HunterRumour | undefined;
+    doesAnyMasterHaveRumour(rumourId: string): boolean;
+    setMasterCurrentRumour(masterName: string, rumourId: string): void;
+    assignRumourToMaster(masterName: string, rumourId: string): void;
+    getEligibleRumours(masterName: string, hunterLevel: number, completedQuests?: string[]): HunterRumour[];
+    assignRumour(masterName: string, hunterLevel: number, completedQuests?: string[], randomizer?: () => number): HunterRumourAssignment | null;
+}
+//# sourceMappingURL=HunterGuild.d.ts.map

package/dist/runescape/model/guilds/hunter/HunterGuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HunterGuild.d.ts","sourceRoot":"","sources":["../../../../../source/runescape/model/guilds/hunter/HunterGuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAyB,MAAM,qBAAqB,CAAC;AAgB/E;;;GAGG;AACH,qBAAa,WAAW;IACf,OAAO,SAA2C;IAEzD,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,GAAG,CAAoB;IAC/B,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,IAAI,CAAoB;IAEhC,OAAO,CAAC,eAAe,CAAgB;gBAE3B,eAAe,GAAE,MAAM,EAAO;IAY1C,IAAI,MAAM,IAAI,iBAAiB,CAE9B;IAED,IAAI,MAAM,IAAI,iBAAiB,CAE9B;IAED,IAAI,KAAK,IAAI,iBAAiB,CAE7B;IAED,IAAI,GAAG,IAAI,iBAAiB,CAE3B;IAED,IAAI,IAAI,IAAI,iBAAiB,CAE5B;IAED,IAAI,IAAI,IAAI,iBAAiB,CAE5B;IAMD,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIlE,aAAa,IAAI,iBAAiB,EAAE;IAIpC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAKzD,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlD,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAQ3D,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOhE,kBAAkB,CAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,eAAe,GAAE,MAAM,EAAO,GAC7B,YAAY,EAAE;IAejB,YAAY,CACV,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,eAAe,GAAE,MAAM,EAAO,EAC9B,UAAU,GAAE,MAAM,MAAoB,GACrC,sBAAsB,GAAG,IAAI;CAqBjC"}

package/dist/runescape/model/guilds/hunter/HunterGuild.js

@@ -0,0 +1,107 @@
+import { HunterGuildMaster } from './HunterGuildMaster';
+import { HUNTER_RUMOUR_REGISTRY } from './Rumours';
+/**
+ * Defines the Hunter Guild Masters and their properties, including the minimum Hunter level required to receive rumours from them, whether they require the completion of "At First Light" to assign rumours, and the tier of rumours they provide. The HunterGuild class provides methods to retrieve masters by name, get all masters, retrieve rumours by ID, determine eligible rumours for a player based on their level and completed quests, and assign a rumour to a player while ensuring all eligibility criteria are met. The Hunter Guild module serves as the central hub for all logic related to the Hunter Guild, its masters, and the assignment of rumours to players.
+ * Note: The rumours are defined in a separate module to avoid circular dependencies, as HunterRumour references HunterGuildMaster and vice versa.
+ */
+const HUNTER_GUILD_MASTERS = [
+    new HunterGuildMaster('Gilman', 'Novice', 46),
+    new HunterGuildMaster('Cervus', 'Adept', 57),
+    new HunterGuildMaster('Ornus', 'Adept', 57),
+    new HunterGuildMaster('Aco', 'Expert', 72),
+    new HunterGuildMaster('Teco', 'Expert', 72),
+    new HunterGuildMaster('Wolf', 'Master', 91, true),
+];
+/**
+ * The Hunter Guild module encapsulates all data and logic related to the Hunter Guild, including its masters, rumours, and player progress. It provides methods to retrieve masters and rumours, determine eligibility, and assign rumours to players based on their level, completed quests, and current progress.
+ * Note: The rumours are defined in a separate module to avoid circular dependencies, as HunterRumour references HunterGuildMaster and vice versa.
+ */
+export class HunterGuild {
+    wikiUrl = 'https://runescape.wiki/w/Hunter_Guild';
+    gilman;
+    cervus;
+    ornus;
+    aco;
+    teco;
+    wolf;
+    completedQuests = [];
+    constructor(completedQuests = []) {
+        this.completedQuests = completedQuests ?? [];
+        this.gilman = HUNTER_GUILD_MASTERS.find((master) => master.name === 'Gilman');
+        this.cervus = HUNTER_GUILD_MASTERS.find((master) => master.name === 'Cervus');
+        this.ornus = HUNTER_GUILD_MASTERS.find((master) => master.name === 'Ornus');
+        this.aco = HUNTER_GUILD_MASTERS.find((master) => master.name === 'Aco');
+        this.teco = HUNTER_GUILD_MASTERS.find((master) => master.name === 'Teco');
+        this.wolf = HUNTER_GUILD_MASTERS.find((master) => master.name === 'Wolf');
+    }
+    /* Getters Start */
+    get Gilman() {
+        return this.gilman;
+    }
+    get Cervus() {
+        return this.cervus;
+    }
+    get Ornus() {
+        return this.ornus;
+    }
+    get Aco() {
+        return this.aco;
+    }
+    get Teco() {
+        return this.teco;
+    }
+    get Wolf() {
+        return this.wolf;
+    }
+    /* Getters end */
+    getMasterByName(masterName) {
+        return HUNTER_GUILD_MASTERS.find((master) => master.name === masterName);
+    }
+    getAllMasters() {
+        return [...HUNTER_GUILD_MASTERS];
+    }
+    getRumourById(rumourId) {
+        return HUNTER_RUMOUR_REGISTRY.find((rumour) => rumour.id === rumourId);
+    }
+    doesAnyMasterHaveRumour(rumourId) {
+        return HUNTER_GUILD_MASTERS.some((master) => master.currentRumourId === rumourId);
+    }
+    setMasterCurrentRumour(masterName, rumourId) {
+        const master = this.getMasterByName(masterName);
+        if (master) {
+            master.currentRumourId = rumourId;
+        }
+    }
+    assignRumourToMaster(masterName, rumourId) {
+        const master = this.getMasterByName(masterName);
+        if (master) {
+            master.assignRumour(rumourId);
+        }
+    }
+    getEligibleRumours(masterName, hunterLevel, completedQuests = []) {
+        const master = this.getMasterByName(masterName);
+        if (!master || !master.canAssignRumour(hunterLevel, completedQuests)) {
+            return [];
+        }
+        return HUNTER_RUMOUR_REGISTRY.filter((rumour) => rumour.canBeAssignedByMaster(masterName) &&
+            rumour.isEligible(hunterLevel, completedQuests) &&
+            !this.doesAnyMasterHaveRumour(rumour.id));
+    }
+    assignRumour(masterName, hunterLevel, completedQuests = [], randomizer = Math.random) {
+        const eligibleRumours = this.getEligibleRumours(masterName, hunterLevel, completedQuests);
+        if (eligibleRumours.length === 0) {
+            // cannot assign a rumour if there are no eligible rumours available for the master, which can happen if the player does not meet the requirements for any of the rumours or if all eligible rumours are currently assigned to other masters. In this case, the method returns null to indicate that no assignment could be made.
+            return null;
+        }
+        const index = Math.floor(randomizer() * eligibleRumours.length);
+        const selectedRumour = eligibleRumours[index];
+        const assignment = {
+            id: `${masterName}-${selectedRumour.id}-${Date.now()}`,
+            masterName,
+            rumourId: selectedRumour.id,
+            assignedAt: new Date(),
+        };
+        return assignment;
+    }
+}
+;

package/dist/runescape/model/guilds/hunter/HunterGuildMaster.d.ts

@@ -0,0 +1,52 @@
+import type { HunterRumour } from './HunterRumour';
+import { HunterRumourTier } from './types';
+export declare const HunterGuildMasterName: {
+    GILMAN: {
+        name: string;
+    };
+    CERVUS: {
+        name: string;
+    };
+    ORNUS: {
+        name: string;
+    };
+    ACO: {
+        name: string;
+    };
+    TECO: {
+        name: string;
+    };
+};
+/**
+ * Represents a Hunter Guild Master, who can assign rumours to players based on their
+ * Hunter level,
+ * completed quests, and the tier of the rumour.
+ * Each master has specific requirements for assigning rumours,
+ * and some may require the completion of certain quests (e.g., "At First Light")
+ * to unlock higher-tier rumours.
+ * The HunterGuildMaster class encapsulates the properties and logic related to each master,
+ * allowing for easy retrieval and eligibility checks when assigning rumours to players.
+ */
+export declare class HunterGuildMaster {
+    readonly name: string;
+    readonly tier: HunterRumourTier;
+    readonly minimumLevel: number;
+    readonly requiresAtFirstLight: boolean;
+    currentRumourId: string;
+    constructor(name: string, tier: HunterRumourTier, minimumLevel: number, requiresAtFirstLight?: boolean);
+    canAssignRumour(hunterLevel: number, completedQuests?: string[]): boolean;
+    get wikiUrl(): string;
+    get isAssigned(): boolean;
+    assignRumour(rumourId: string): void;
+    get rumoursThatCanBeAssigned(): HunterRumour[];
+    /**
+     * When having a master assign a Hunter Rumour, it needs to check all the current assigned rumours from the other masters;
+     * It cannot give a rumour that is already assigned from another master, even if it is eligible for assignment.
+     * This method takes in the list of eligible rumours for this master and the list of currently assigned rumours from the other masters,
+     * and returns a random rumour ID that can be assigned to this master without conflicts.
+     * @param eligibleRumours
+     * @param otherMasterRumours
+     */
+    getRandomRumour(eligibleRumours: HunterRumour[], otherMasterRumours: HunterRumour[]): HunterRumour;
+}
+//# sourceMappingURL=HunterGuildMaster.d.ts.map

package/dist/runescape/model/guilds/hunter/HunterGuildMaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HunterGuildMaster.d.ts","sourceRoot":"","sources":["../../../../../source/runescape/model/guilds/hunter/HunterGuildMaster.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;CAMjC,CAAA;AAGD;;;;;;;;;GASG;AACH,qBAAa,iBAAiB;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC;gBAGtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,gBAAgB,EACtB,YAAY,EAAE,MAAM,EACpB,oBAAoB,UAAQ;IAUvB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,GAAE,MAAM,EAAO,GAAG,OAAO;IAUpF,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAGD,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIpC,IAAI,wBAAwB,IAAI,YAAY,EAAE,CAE7C;IAGD;;;;;;;OAOG;IACI,eAAe,CAAC,eAAe,EAAE,YAAY,EAAE,EAAE,kBAAkB,EAAE,YAAY,EAAE,GAAG,YAAY;CAe1G"}

package/dist/runescape/model/guilds/hunter/HunterGuildMaster.js

@@ -0,0 +1,71 @@
+import { HUNTER_RUMOUR_REGISTRY } from './Rumours';
+export const HunterGuildMasterName = {
+    GILMAN: { name: 'Gilman' },
+    CERVUS: { name: 'Cervus' },
+    ORNUS: { name: 'Ornus' },
+    ACO: { name: 'Aco' },
+    TECO: { name: 'Teco' }
+};
+/**
+ * Represents a Hunter Guild Master, who can assign rumours to players based on their
+ * Hunter level,
+ * completed quests, and the tier of the rumour.
+ * Each master has specific requirements for assigning rumours,
+ * and some may require the completion of certain quests (e.g., "At First Light")
+ * to unlock higher-tier rumours.
+ * The HunterGuildMaster class encapsulates the properties and logic related to each master,
+ * allowing for easy retrieval and eligibility checks when assigning rumours to players.
+ */
+export class HunterGuildMaster {
+    name; //name of the master
+    tier; // the tier of rumour they give
+    minimumLevel; // required level for it to be assigned by this master
+    requiresAtFirstLight; // whether the master requires completion of "At First Light" to assign their rumours
+    currentRumourId; // the ID of the currently assigned rumour, if any
+    constructor(name, tier, minimumLevel, requiresAtFirstLight = false) {
+        this.name = name;
+        this.tier = tier;
+        this.minimumLevel = minimumLevel;
+        this.requiresAtFirstLight = requiresAtFirstLight;
+        this.currentRumourId = '';
+    }
+    canAssignRumour(hunterLevel, completedQuests = []) {
+        if (hunterLevel < this.minimumLevel) {
+            return false;
+        }
+        if (this.requiresAtFirstLight && !completedQuests.includes('At First Light')) {
+            return false;
+        }
+        return true;
+    }
+    get wikiUrl() {
+        return `https://runescape.wiki/w/${this.name}`;
+    }
+    get isAssigned() {
+        return this.currentRumourId !== '';
+    }
+    // Assigns a rumour to this master by setting the currentRumourId. This method can be called when a new rumour is assigned to the master, allowing us to track which rumour is currently active for that master. When a rumour is completed, the currentRumourId can be cleared to indicate that the master is ready for a new assignment.
+    assignRumour(rumourId) {
+        this.currentRumourId = rumourId;
+    }
+    get rumoursThatCanBeAssigned() {
+        return HUNTER_RUMOUR_REGISTRY.filter((rumour) => rumour.canBeAssignedByMaster(this.name));
+    }
+    /**
+     * When having a master assign a Hunter Rumour, it needs to check all the current assigned rumours from the other masters;
+     * It cannot give a rumour that is already assigned from another master, even if it is eligible for assignment.
+     * This method takes in the list of eligible rumours for this master and the list of currently assigned rumours from the other masters,
+     * and returns a random rumour ID that can be assigned to this master without conflicts.
+     * @param eligibleRumours
+     * @param otherMasterRumours
+     */
+    getRandomRumour(eligibleRumours, otherMasterRumours) {
+        const otherAssignedRumourIds = new Set(otherMasterRumours.map((rumour) => rumour.id));
+        const assignableRumours = eligibleRumours.filter((rumour) => !otherAssignedRumourIds.has(rumour.id));
+        if (assignableRumours.length === 0) {
+            throw new Error(`No assignable rumours available for master ${this.name}`);
+        }
+        const randomIndex = Math.floor(Math.random() * assignableRumours.length);
+        return assignableRumours[randomIndex];
+    }
+}

package/dist/runescape/model/guilds/hunter/HunterGuildMasterName.d.ts

@@ -0,0 +1,21 @@
+export declare const HunterGuildMasterName: {
+    GILMAN: {
+        name: string;
+    };
+    CERVUS: {
+        name: string;
+    };
+    ORNUS: {
+        name: string;
+    };
+    ACO: {
+        name: string;
+    };
+    TECO: {
+        name: string;
+    };
+    WOLF: {
+        name: string;
+    };
+};
+//# sourceMappingURL=HunterGuildMasterName.d.ts.map

package/dist/runescape/model/guilds/hunter/HunterGuildMasterName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HunterGuildMasterName.d.ts","sourceRoot":"","sources":["../../../../../source/runescape/model/guilds/hunter/HunterGuildMasterName.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;CAOjC,CAAC"}

package/dist/runescape/model/guilds/hunter/HunterGuildMasterName.js

@@ -0,0 +1,8 @@
+export const HunterGuildMasterName = {
+    GILMAN: { name: 'Gilman' },
+    CERVUS: { name: 'Cervus' },
+    ORNUS: { name: 'Ornus' },
+    ACO: { name: 'Aco' },
+    TECO: { name: 'Teco' },
+    WOLF: { name: 'Wolf' },
+};

package/dist/runescape/model/guilds/hunter/HunterRumour.d.ts

@@ -0,0 +1,33 @@
+import { HunterRumourDefinition, HunterRumourTier } from './types';
+import { RumourLocation } from './RumourLocation';
+/**
+ * Represents a Hunter Rumour that can be assigned by a Hunter Guild Master. Contains all the necessary information about the rumour, including the creature, method, locations, required hunter level, tier, and any quest requirements. Provides methods to check if the rumour can be assigned to a specific master and if a player is eligible for the rumour based on their hunter level and completed quests.
+ */
+export declare class HunterRumour {
+    readonly id: string;
+    readonly creature: string;
+    readonly method: string;
+    readonly locations: RumourLocation[];
+    readonly requiredHunterLevel: number;
+    readonly tier: HunterRumourTier;
+    readonly masterNames: string[];
+    readonly questRequirements: string[];
+    readonly notes?: string;
+    readonly leagueRegions: string[];
+    constructor(definition: HunterRumourDefinition);
+    get wikiUrls(): string[];
+    /**
+     * Checks if this rumour can be assigned by the specified master based on the masterNames property, which lists the names of masters that can assign this rumour. This method is used to determine if a particular rumour is eligible to be assigned by a given Hunter Guild Master when players are looking for available rumours.
+     * @param masterName The name of the Hunter Guild Master to check against the masterNames list for this rumour.
+     * @returns A boolean indicating whether this rumour can be assigned by the specified master.
+     */
+    canBeAssignedByMaster(masterName: string): boolean;
+    /**
+     * Checks if a player is eligible for this rumour based on their hunter level and completed quests. This method verifies that the player's hunter level meets or exceeds the requiredHunterLevel for the rumour, and that they have completed all quests listed in the questRequirements property. This is used to ensure that players only receive rumours that they are qualified to pursue, based on their in-game progress and achievements.
+     * @param hunterLevel The Hunter level of the player, which must meet or exceed the requiredHunterLevel for this rumour.
+     * @param completedQuests An array of quest names that the player has completed, which must include all quests listed in the questRequirements for this rumour.
+     * @returns A boolean indicating whether the player is eligible for this rumour.
+     */
+    isEligible(hunterLevel: number, completedQuests?: string[]): boolean;
+}
+//# sourceMappingURL=HunterRumour.d.ts.map

package/dist/runescape/model/guilds/hunter/HunterRumour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HunterRumour.d.ts","sourceRoot":"","sources":["../../../../../source/runescape/model/guilds/hunter/HunterRumour.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMlD;;GAEG;AACH,qBAAa,YAAY;IAGvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAGpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAG1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,QAAQ,CAAC,SAAS,EAAE,cAAc,EAAE,CAAC;IAErC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IAErC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEhC,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAE/B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAErC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;gBAGrB,UAAU,EAAE,sBAAsB;IAa9C,IAAI,QAAQ,IAAI,MAAM,EAAE,CAEvB;IAGD;;;;OAIG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIlD;;;;;OAKG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,GAAE,MAAM,EAAO,GAAG,OAAO;CAKzE"}