osrs-tools 2.8.1 → 2.9.0

package/dist/index.d.ts

@@ -25,6 +25,9 @@ export * from "./runescape/model/clue/ClueScrollHelper";
 export * from "./runescape/model/Item/Item";
 export * from "./runescape/model/Item/models";
 export { SlayerMaster, Task, Assignment, Turael, Spria, Mazchna, Vannaka, Chaeldar, KonarQuoMaten, Nieve, Duradel, Krystilia, SlayerUnlock, SlayerExtend, SlayerBuy, SLAYER_UNLOCKS, SLAYER_EXTENDS, SLAYER_BUYS, SlayerLocation, SlayerBoss, POINTS_TABLE, getMasterByName, getAllMasters, getMastersByMinimumLevel, getMastersByProgression, } from "./runescape/model/slayer";
+export * from "./runescape/model/guilds";
+export * from "./runescape/model/leagues";
+export * from "./runescape/model/skills";
 export * from "./runescape/model/Requirement";
 export * from "./runescape/errors";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yCAAyC,CAAC;AAGxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAG9C,OAAO,EACL,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,MAAM,EACN,KAAK,EACL,OAAO,EACP,OAAO,EACP,QAAQ,EACR,aAAa,EACb,KAAK,EACL,OAAO,EACP,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,cAAc,EACd,WAAW,EACX,cAAc,EACd,UAAU,EACV,YAAY,EACZ,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,0BAA0B,CAAC;AAGlC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yCAAyC,CAAC;AAGxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAG9C,OAAO,EACL,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,MAAM,EACN,KAAK,EACL,OAAO,EACP,OAAO,EACP,QAAQ,EACR,aAAa,EACb,KAAK,EACL,OAAO,EACP,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,cAAc,EACd,WAAW,EACX,cAAc,EACd,UAAU,EACV,YAAY,EACZ,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,0BAA0B,CAAC;AAGlC,cAAc,0BAA0B,CAAC;AAGzC,cAAc,2BAA2B,CAAC;AAG1C,cAAc,0BAA0B,CAAC;AAGzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -28,6 +28,12 @@ export * from "./runescape/model/Item/Item";
 export * from "./runescape/model/Item/models";
 // Slayer system (refactored exports)
 export { SlayerMaster, Task, Assignment, Turael, Spria, Mazchna, Vannaka, Chaeldar, KonarQuoMaten, Nieve, Duradel, Krystilia, SlayerUnlock, SlayerExtend, SlayerBuy, SLAYER_UNLOCKS, SLAYER_EXTENDS, SLAYER_BUYS, SlayerLocation, SlayerBoss, POINTS_TABLE, getMasterByName, getAllMasters, getMastersByMinimumLevel, getMastersByProgression, } from "./runescape/model/slayer";
+// Guilds system
+export * from "./runescape/model/guilds";
+// Leagues system
+export * from "./runescape/model/leagues";
+// Skills system
+export * from "./runescape/model/skills";
 // Core requirement types
 export * from "./runescape/model/Requirement";
 export * from "./runescape/errors";

package/dist/runescape/model/collection-log/CollectionLog.d.ts

@@ -0,0 +1,8 @@
+import { CollectionLogCategory, CollectionLogDataset, CollectionLogEntry, CollectionLogItem, CollectionLogProgressSummary } from "./CollectionLog.model";
+export declare const COLLECTION_LOG_DATASET: CollectionLogDataset;
+export declare function getCollectionLogEntries(dataset?: CollectionLogDataset): CollectionLogEntry[];
+export declare function getCollectionLogEntryById(entryId: string, dataset?: CollectionLogDataset): CollectionLogEntry | undefined;
+export declare function getCollectionLogEntriesByCategory(category: CollectionLogCategory, dataset?: CollectionLogDataset): CollectionLogEntry[];
+export declare function getMissingCollectionLogItems(obtainedItemIds: readonly string[], dataset?: CollectionLogDataset): CollectionLogItem[];
+export declare function calculateCollectionLogProgress(obtainedItemIds: readonly string[], dataset?: CollectionLogDataset): CollectionLogProgressSummary;
+//# sourceMappingURL=CollectionLog.d.ts.map

package/dist/runescape/model/collection-log/CollectionLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionLog.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/collection-log/CollectionLog.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EAErB,oBAAoB,EACpB,kBAAkB,EAElB,iBAAiB,EACjB,4BAA4B,EAC7B,MAAM,uBAAuB,CAAC;AAwB/B,eAAO,MAAM,sBAAsB,EAAE,oBA2CpC,CAAC;AAWF,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,oBAA6C,GAAG,kBAAkB,EAAE,CAEpH;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAA6C,GACrD,kBAAkB,GAAG,SAAS,CAGhC;AAED,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,GAAE,oBAA6C,GACrD,kBAAkB,EAAE,CAEtB;AAED,wBAAgB,4BAA4B,CAC1C,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,OAAO,GAAE,oBAA6C,GACrD,iBAAiB,EAAE,CAKrB;AAoCD,wBAAgB,8BAA8B,CAC5C,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,OAAO,GAAE,oBAA6C,GACrD,4BAA4B,CAgB9B"}

package/dist/runescape/model/collection-log/CollectionLog.js

@@ -0,0 +1,124 @@
+import { COLLECTION_LOG_CATEGORIES, CollectionLogCategory, } from "./CollectionLog.model";
+const COLLECTION_LOG_SOURCE = "https://oldschool.runescape.wiki/w/Collection_log";
+const item = (id, name) => ({
+    id,
+    name,
+    wikiUrl: COLLECTION_LOG_SOURCE,
+});
+const entry = (id, name, category, activity, items) => ({
+    id,
+    name,
+    category,
+    activity,
+    items,
+});
+export const COLLECTION_LOG_DATASET = {
+    source: COLLECTION_LOG_SOURCE,
+    entries: [
+        entry("cl-zulrah", "Zulrah", CollectionLogCategory.Bosses, "Zulrah", [
+            item("cl-zulrah-magic-fang", "Magic fang"),
+            item("cl-zulrah-serp-visage", "Serpentine visage"),
+            item("cl-zulrah-tanz-fang", "Tanzanite fang"),
+            item("cl-zulrah-pet", "Pet snakeling"),
+        ]),
+        entry("cl-vorkath", "Vorkath", CollectionLogCategory.Bosses, "Vorkath", [
+            item("cl-vorkath-draconic-visage", "Draconic visage"),
+            item("cl-vorkath-skeletal-visage", "Skeletal visage"),
+            item("cl-vorkath-dragonbone-necklace", "Dragonbone necklace"),
+            item("cl-vorkath-head", "Vorkath's head"),
+            item("cl-vorkath-pet", "Vorki"),
+        ]),
+        entry("cl-barrows", "Barrows Chests", CollectionLogCategory.Bosses, "Barrows", [
+            item("cl-barrows-dharok-helm", "Dharok's helm"),
+            item("cl-barrows-karil-top", "Karil's leathertop"),
+            item("cl-barrows-ahrim-top", "Ahrim's robetop"),
+            item("cl-barrows-guthan-spear", "Guthan's warspear"),
+        ]),
+        entry("cl-cox", "Chambers of Xeric", CollectionLogCategory.Raids, "Chambers of Xeric", [
+            item("cl-cox-twisted-bow", "Twisted bow"),
+            item("cl-cox-ancestral-top", "Ancestral robe top"),
+            item("cl-cox-dex-scroll", "Dexterous prayer scroll"),
+            item("cl-cox-kodai-insignia", "Kodai insignia"),
+            item("cl-cox-olmlet", "Olmlet"),
+        ]),
+        entry("cl-tob", "Theatre of Blood", CollectionLogCategory.Raids, "Theatre of Blood", [
+            item("cl-tob-scythe", "Scythe of vitur"),
+            item("cl-tob-rapier", "Ghrazi rapier"),
+            item("cl-tob-sanguinesti", "Sanguinesti staff"),
+            item("cl-tob-lil-zik", "Lil' zik"),
+        ]),
+        entry("cl-toa", "Tombs of Amascut", CollectionLogCategory.Raids, "Tombs of Amascut", [
+            item("cl-toa-shadow", "Tumeken's shadow"),
+            item("cl-toa-fang", "Osmumten's fang"),
+            item("cl-toa-ward", "Elidinis' ward"),
+            item("cl-toa-ics", "Icthlarin's shroud"),
+            item("cl-toa-pet", "Tumeken's guardian"),
+        ]),
+    ],
+};
+function normalizeIdSet(itemIds) {
+    return new Set(itemIds.map((itemId) => itemId.trim().toLowerCase()));
+}
+function percent(obtained, total) {
+    if (total === 0)
+        return 0;
+    return Number(((obtained / total) * 100).toFixed(2));
+}
+export function getCollectionLogEntries(dataset = COLLECTION_LOG_DATASET) {
+    return [...dataset.entries];
+}
+export function getCollectionLogEntryById(entryId, dataset = COLLECTION_LOG_DATASET) {
+    const normalizedEntryId = entryId.trim().toLowerCase();
+    return dataset.entries.find((logEntry) => logEntry.id.toLowerCase() === normalizedEntryId);
+}
+export function getCollectionLogEntriesByCategory(category, dataset = COLLECTION_LOG_DATASET) {
+    return dataset.entries.filter((logEntry) => logEntry.category === category);
+}
+export function getMissingCollectionLogItems(obtainedItemIds, dataset = COLLECTION_LOG_DATASET) {
+    const obtainedIds = normalizeIdSet(obtainedItemIds);
+    return dataset.entries
+        .flatMap((logEntry) => logEntry.items)
+        .filter((logItem) => !obtainedIds.has(logItem.id.toLowerCase()));
+}
+function entryProgress(logEntry, obtainedIds) {
+    const obtained = logEntry.items.filter((logItem) => obtainedIds.has(logItem.id.toLowerCase())).length;
+    const missingItemIds = logEntry.items
+        .filter((logItem) => !obtainedIds.has(logItem.id.toLowerCase()))
+        .map((logItem) => logItem.id);
+    return {
+        entryId: logEntry.id,
+        entryName: logEntry.name,
+        category: logEntry.category,
+        total: logEntry.items.length,
+        obtained,
+        completionPercent: percent(obtained, logEntry.items.length),
+        missingItemIds,
+    };
+}
+function categoryProgress(category, entrySummaries) {
+    const categoryEntries = entrySummaries.filter((entrySummary) => entrySummary.category === category);
+    const total = categoryEntries.reduce((runningTotal, entrySummary) => runningTotal + entrySummary.total, 0);
+    const obtained = categoryEntries.reduce((runningTotal, entrySummary) => runningTotal + entrySummary.obtained, 0);
+    return {
+        category,
+        total,
+        obtained,
+        completionPercent: percent(obtained, total),
+        missingItemIds: categoryEntries.flatMap((entrySummary) => entrySummary.missingItemIds),
+    };
+}
+export function calculateCollectionLogProgress(obtainedItemIds, dataset = COLLECTION_LOG_DATASET) {
+    const obtainedIds = normalizeIdSet(obtainedItemIds);
+    const byEntry = dataset.entries.map((logEntry) => entryProgress(logEntry, obtainedIds));
+    const byCategory = COLLECTION_LOG_CATEGORIES.map((category) => categoryProgress(category, byEntry));
+    const total = byEntry.reduce((runningTotal, entrySummary) => runningTotal + entrySummary.total, 0);
+    const obtained = byEntry.reduce((runningTotal, entrySummary) => runningTotal + entrySummary.obtained, 0);
+    return {
+        total,
+        obtained,
+        completionPercent: percent(obtained, total),
+        byEntry,
+        byCategory,
+        missingItemIds: byEntry.flatMap((entrySummary) => entrySummary.missingItemIds),
+    };
+}

package/dist/runescape/model/collection-log/CollectionLog.model.d.ts

@@ -0,0 +1,48 @@
+export declare enum CollectionLogCategory {
+    Bosses = "Bosses",
+    Raids = "Raids",
+    Minigames = "Minigames",
+    Clues = "Clues"
+}
+export interface CollectionLogItem {
+    id: string;
+    name: string;
+    wikiUrl: string;
+}
+export interface CollectionLogEntry {
+    id: string;
+    name: string;
+    category: CollectionLogCategory;
+    activity: string;
+    items: readonly CollectionLogItem[];
+}
+export interface CollectionLogDataset {
+    source: string;
+    entries: readonly CollectionLogEntry[];
+}
+export interface CollectionLogEntryProgress {
+    entryId: string;
+    entryName: string;
+    category: CollectionLogCategory;
+    total: number;
+    obtained: number;
+    completionPercent: number;
+    missingItemIds: string[];
+}
+export interface CollectionLogCategoryProgress {
+    category: CollectionLogCategory;
+    total: number;
+    obtained: number;
+    completionPercent: number;
+    missingItemIds: string[];
+}
+export interface CollectionLogProgressSummary {
+    total: number;
+    obtained: number;
+    completionPercent: number;
+    byEntry: CollectionLogEntryProgress[];
+    byCategory: CollectionLogCategoryProgress[];
+    missingItemIds: string[];
+}
+export declare const COLLECTION_LOG_CATEGORIES: readonly CollectionLogCategory[];
+//# sourceMappingURL=CollectionLog.model.d.ts.map

package/dist/runescape/model/collection-log/CollectionLog.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionLog.model.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/collection-log/CollectionLog.model.ts"],"names":[],"mappings":"AAAA,oBAAY,qBAAqB;IAC/B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,qBAAqB,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,qBAAqB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,qBAAqB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,0BAA0B,EAAE,CAAC;IACtC,UAAU,EAAE,6BAA6B,EAAE,CAAC;IAC5C,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,yBAAyB,EAAE,SAAS,qBAAqB,EAK5D,CAAC"}

package/dist/runescape/model/collection-log/CollectionLog.model.js

@@ -0,0 +1,13 @@
+export var CollectionLogCategory;
+(function (CollectionLogCategory) {
+    CollectionLogCategory["Bosses"] = "Bosses";
+    CollectionLogCategory["Raids"] = "Raids";
+    CollectionLogCategory["Minigames"] = "Minigames";
+    CollectionLogCategory["Clues"] = "Clues";
+})(CollectionLogCategory || (CollectionLogCategory = {}));
+export const COLLECTION_LOG_CATEGORIES = [
+    CollectionLogCategory.Bosses,
+    CollectionLogCategory.Raids,
+    CollectionLogCategory.Minigames,
+    CollectionLogCategory.Clues,
+];

package/dist/runescape/model/collection-log/index.d.ts

@@ -0,0 +1,4 @@
+export { COLLECTION_LOG_CATEGORIES, CollectionLogCategory } from "./CollectionLog.model";
+export type { CollectionLogItem, CollectionLogEntry, CollectionLogDataset, CollectionLogEntryProgress, CollectionLogCategoryProgress, CollectionLogProgressSummary, } from "./CollectionLog.model";
+export { COLLECTION_LOG_DATASET, getCollectionLogEntries, getCollectionLogEntryById, getCollectionLogEntriesByCategory, getMissingCollectionLogItems, calculateCollectionLogProgress, } from "./CollectionLog";
+//# sourceMappingURL=index.d.ts.map

package/dist/runescape/model/collection-log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/collection-log/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACzF,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,0BAA0B,EAC1B,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,yBAAyB,EACzB,iCAAiC,EACjC,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,iBAAiB,CAAC"}

package/dist/runescape/model/collection-log/index.js

@@ -0,0 +1,2 @@
+export { COLLECTION_LOG_CATEGORIES, CollectionLogCategory } from "./CollectionLog.model";
+export { COLLECTION_LOG_DATASET, getCollectionLogEntries, getCollectionLogEntryById, getCollectionLogEntriesByCategory, getMissingCollectionLogItems, calculateCollectionLogProgress, } from "./CollectionLog";

package/dist/runescape/model/combat-achievements/CombatAchievement.model.d.ts

@@ -0,0 +1,37 @@
+export declare enum CombatAchievementTier {
+    Easy = "Easy",
+    Medium = "Medium",
+    Hard = "Hard",
+    Elite = "Elite",
+    Master = "Master",
+    Grandmaster = "Grandmaster"
+}
+export interface CombatAchievementTask {
+    id: string;
+    name: string;
+    tier: CombatAchievementTier;
+    activity: string;
+    description: string;
+    wikiUrl: string;
+    requirements?: readonly string[];
+}
+export interface CombatAchievementsDataset {
+    seasonLabel: string;
+    source: string;
+    tasks: readonly CombatAchievementTask[];
+}
+export interface CompletionSummary {
+    total: number;
+    completed: number;
+    completionPercent: number;
+}
+export interface TierProgressSummary extends CompletionSummary {
+    tier: CombatAchievementTier;
+    missingTaskIds: string[];
+}
+export interface CombatAchievementsProgressSummary extends CompletionSummary {
+    byTier: TierProgressSummary[];
+    missingTaskIds: string[];
+}
+export declare const COMBAT_ACHIEVEMENT_TIERS: readonly CombatAchievementTier[];
+//# sourceMappingURL=CombatAchievement.model.d.ts.map

package/dist/runescape/model/combat-achievements/CombatAchievement.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CombatAchievement.model.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/combat-achievements/CombatAchievement.model.ts"],"names":[],"mappings":"AAAA,oBAAY,qBAAqB;IAC/B,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,WAAW,gBAAgB;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,qBAAqB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,IAAI,EAAE,qBAAqB,CAAC;IAC5B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,iCAAkC,SAAQ,iBAAiB;IAC1E,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,wBAAwB,EAAE,SAAS,qBAAqB,EAO3D,CAAC"}

package/dist/runescape/model/combat-achievements/CombatAchievement.model.js

@@ -0,0 +1,17 @@
+export var CombatAchievementTier;
+(function (CombatAchievementTier) {
+    CombatAchievementTier["Easy"] = "Easy";
+    CombatAchievementTier["Medium"] = "Medium";
+    CombatAchievementTier["Hard"] = "Hard";
+    CombatAchievementTier["Elite"] = "Elite";
+    CombatAchievementTier["Master"] = "Master";
+    CombatAchievementTier["Grandmaster"] = "Grandmaster";
+})(CombatAchievementTier || (CombatAchievementTier = {}));
+export const COMBAT_ACHIEVEMENT_TIERS = [
+    CombatAchievementTier.Easy,
+    CombatAchievementTier.Medium,
+    CombatAchievementTier.Hard,
+    CombatAchievementTier.Elite,
+    CombatAchievementTier.Master,
+    CombatAchievementTier.Grandmaster,
+];

package/dist/runescape/model/combat-achievements/CombatAchievements.d.ts

@@ -0,0 +1,8 @@
+import { CombatAchievementTask, CombatAchievementsDataset, CombatAchievementsProgressSummary, CombatAchievementTier } from "./CombatAchievement.model";
+export declare const COMBAT_ACHIEVEMENTS_DATASET: CombatAchievementsDataset;
+export declare function getAllCombatAchievementTasks(dataset?: CombatAchievementsDataset): CombatAchievementTask[];
+export declare function getCombatAchievementTaskById(taskId: string, dataset?: CombatAchievementsDataset): CombatAchievementTask | undefined;
+export declare function getCombatAchievementTasksByTier(tier: CombatAchievementTier, dataset?: CombatAchievementsDataset): CombatAchievementTask[];
+export declare function getMissingCombatAchievementTasks(completedTaskIds: readonly string[], dataset?: CombatAchievementsDataset): CombatAchievementTask[];
+export declare function calculateCombatAchievementProgress(completedTaskIds: readonly string[], dataset?: CombatAchievementsDataset): CombatAchievementsProgressSummary;
+//# sourceMappingURL=CombatAchievements.d.ts.map

package/dist/runescape/model/combat-achievements/CombatAchievements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CombatAchievements.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/combat-achievements/CombatAchievements.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EACrB,yBAAyB,EACzB,iCAAiC,EACjC,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AAqBnC,eAAO,MAAM,2BAA2B,EAAE,yBAiBzC,CAAC;AAWF,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,yBAAuD,GAAG,qBAAqB,EAAE,CAEtI;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,yBAAuD,GAC/D,qBAAqB,GAAG,SAAS,CAGnC;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,qBAAqB,EAC3B,OAAO,GAAE,yBAAuD,GAC/D,qBAAqB,EAAE,CAEzB;AAED,wBAAgB,gCAAgC,CAC9C,gBAAgB,EAAE,SAAS,MAAM,EAAE,EACnC,OAAO,GAAE,yBAAuD,GAC/D,qBAAqB,EAAE,CAGzB;AAED,wBAAgB,kCAAkC,CAChD,gBAAgB,EAAE,SAAS,MAAM,EAAE,EACnC,OAAO,GAAE,yBAAuD,GAC/D,iCAAiC,CA+BnC"}

package/dist/runescape/model/combat-achievements/CombatAchievements.js

@@ -0,0 +1,80 @@
+import { COMBAT_ACHIEVEMENT_TIERS, CombatAchievementTier, } from "./CombatAchievement.model";
+const COMBAT_ACHIEVEMENTS_SOURCE = "https://oldschool.runescape.wiki/w/Combat_Achievements";
+const task = (id, name, tier, activity, description, requirements) => ({
+    id,
+    name,
+    tier,
+    activity,
+    description,
+    wikiUrl: COMBAT_ACHIEVEMENTS_SOURCE,
+    requirements,
+});
+export const COMBAT_ACHIEVEMENTS_DATASET = {
+    seasonLabel: "OSRS Permanent",
+    source: COMBAT_ACHIEVEMENTS_SOURCE,
+    tasks: [
+        task("ca-easy-barrows-brothers", "Barrows Novice", CombatAchievementTier.Easy, "Barrows", "Defeat all six Barrows brothers at least once."),
+        task("ca-easy-zulrah-kill", "Snaketamer", CombatAchievementTier.Easy, "Zulrah", "Defeat Zulrah once."),
+        task("ca-medium-vorkath-5", "Dragon Hunter", CombatAchievementTier.Medium, "Vorkath", "Defeat Vorkath 5 times."),
+        task("ca-medium-gauntlet-complete", "Crystalline Combat", CombatAchievementTier.Medium, "The Gauntlet", "Complete the Gauntlet once."),
+        task("ca-hard-cg-complete", "Corrupted Challenger", CombatAchievementTier.Hard, "The Corrupted Gauntlet", "Complete the Corrupted Gauntlet once."),
+        task("ca-hard-zulrah-50", "Zulrah Veteran", CombatAchievementTier.Hard, "Zulrah", "Defeat Zulrah 50 times."),
+        task("ca-elite-cox-complete", "Xeric's Recruit", CombatAchievementTier.Elite, "Chambers of Xeric", "Complete a Chambers of Xeric raid.", ["Xeric's Talisman or team access"]),
+        task("ca-elite-tob-complete", "Theatre Initiate", CombatAchievementTier.Elite, "Theatre of Blood", "Complete a Theatre of Blood raid."),
+        task("ca-master-toa-expert", "Expert Invader", CombatAchievementTier.Master, "Tombs of Amascut", "Complete an Expert mode Tombs of Amascut raid.", ["Configured invocation level for Expert mode"]),
+        task("ca-master-inferno-complete", "Infernal Conqueror", CombatAchievementTier.Master, "The Inferno", "Complete the Inferno."),
+        task("ca-gm-colosseum-sol", "Sunfire Victor", CombatAchievementTier.Grandmaster, "Fortis Colosseum", "Defeat Sol Heredit in the Fortis Colosseum."),
+        task("ca-gm-speedrun-toa", "Desert Blitz", CombatAchievementTier.Grandmaster, "Tombs of Amascut", "Complete Tombs of Amascut under a strict speed target.", ["High-end gear and optimized raid route"]),
+    ],
+};
+function normalizeIdSet(taskIds) {
+    return new Set(taskIds.map((taskId) => taskId.trim().toLowerCase()));
+}
+function percent(completed, total) {
+    if (total === 0)
+        return 0;
+    return Number(((completed / total) * 100).toFixed(2));
+}
+export function getAllCombatAchievementTasks(dataset = COMBAT_ACHIEVEMENTS_DATASET) {
+    return [...dataset.tasks];
+}
+export function getCombatAchievementTaskById(taskId, dataset = COMBAT_ACHIEVEMENTS_DATASET) {
+    const normalizedTaskId = taskId.trim().toLowerCase();
+    return dataset.tasks.find((combatTask) => combatTask.id.toLowerCase() === normalizedTaskId);
+}
+export function getCombatAchievementTasksByTier(tier, dataset = COMBAT_ACHIEVEMENTS_DATASET) {
+    return dataset.tasks.filter((combatTask) => combatTask.tier === tier);
+}
+export function getMissingCombatAchievementTasks(completedTaskIds, dataset = COMBAT_ACHIEVEMENTS_DATASET) {
+    const completedIds = normalizeIdSet(completedTaskIds);
+    return dataset.tasks.filter((combatTask) => !completedIds.has(combatTask.id.toLowerCase()));
+}
+export function calculateCombatAchievementProgress(completedTaskIds, dataset = COMBAT_ACHIEVEMENTS_DATASET) {
+    const completedIds = normalizeIdSet(completedTaskIds);
+    const byTier = COMBAT_ACHIEVEMENT_TIERS.map((tier) => {
+        const tierTasks = getCombatAchievementTasksByTier(tier, dataset);
+        const completed = tierTasks.filter((combatTask) => completedIds.has(combatTask.id.toLowerCase())).length;
+        const missingTaskIds = tierTasks
+            .filter((combatTask) => !completedIds.has(combatTask.id.toLowerCase()))
+            .map((combatTask) => combatTask.id);
+        return {
+            tier,
+            total: tierTasks.length,
+            completed,
+            completionPercent: percent(completed, tierTasks.length),
+            missingTaskIds,
+        };
+    });
+    const total = dataset.tasks.length;
+    const completed = dataset.tasks.filter((combatTask) => completedIds.has(combatTask.id.toLowerCase())).length;
+    const missingTaskIds = dataset.tasks
+        .filter((combatTask) => !completedIds.has(combatTask.id.toLowerCase()))
+        .map((combatTask) => combatTask.id);
+    return {
+        total,
+        completed,
+        completionPercent: percent(completed, total),
+        byTier,
+        missingTaskIds,
+    };
+}

package/dist/runescape/model/combat-achievements/index.d.ts

@@ -0,0 +1,4 @@
+export { COMBAT_ACHIEVEMENT_TIERS, CombatAchievementTier } from "./CombatAchievement.model";
+export type { CombatAchievementTask, CombatAchievementsDataset, TierProgressSummary, CompletionSummary, CombatAchievementsProgressSummary, } from "./CombatAchievement.model";
+export { COMBAT_ACHIEVEMENTS_DATASET, getAllCombatAchievementTasks, getCombatAchievementTaskById, getCombatAchievementTasksByTier, getMissingCombatAchievementTasks, calculateCombatAchievementProgress, } from "./CombatAchievements";
+//# sourceMappingURL=index.d.ts.map

package/dist/runescape/model/combat-achievements/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/combat-achievements/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,YAAY,EACV,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,iCAAiC,GAClC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,+BAA+B,EAC/B,gCAAgC,EAChC,kCAAkC,GACnC,MAAM,sBAAsB,CAAC"}

package/dist/runescape/model/combat-achievements/index.js

@@ -0,0 +1,2 @@
+export { COMBAT_ACHIEVEMENT_TIERS, CombatAchievementTier } from "./CombatAchievement.model";
+export { COMBAT_ACHIEVEMENTS_DATASET, getAllCombatAchievementTasks, getCombatAchievementTaskById, getCombatAchievementTasksByTier, getMissingCombatAchievementTasks, calculateCombatAchievementProgress, } from "./CombatAchievements";

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

@@ -0,0 +1,18 @@
+import { HunterRumourAssignment } from './types';
+import { HunterRumour } from './HunterRumour';
+import { HunterGuildMaster, HunterGuildMasterName } from './HunterGuildMaster';
+import { HunterGuildProgress } from './HunterGuildProgress';
+/**
+ * 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 const HUNTER_GUILD: {
+    wikiUrl: string;
+    masters: HunterGuildMaster[];
+    getMasterByName(masterName: HunterGuildMasterName): HunterGuildMaster | undefined;
+    getAllMasters(): HunterGuildMaster[];
+    getRumourById(rumourId: string): HunterRumour | undefined;
+    getEligibleRumours(masterName: HunterGuildMasterName, hunterLevel: number, completedQuests?: string[], progress?: HunterGuildProgress): HunterRumour[];
+    assignRumour(masterName: HunterGuildMasterName, hunterLevel: number, completedQuests?: string[], progress?: HunterGuildProgress, randomizer?: () => number): HunterRumourAssignment | null;
+};
+//# sourceMappingURL=HunterGuild.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HunterGuild.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/guilds/HunterGuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAY5D;;;GAGG;AACH,eAAO,MAAM,YAAY;;;gCAKK,qBAAqB,GAAG,iBAAiB,GAAG,SAAS;qBAIhE,iBAAiB,EAAE;4BAIZ,MAAM,GAAG,YAAY,GAAG,SAAS;mCAK3C,qBAAqB,eACpB,MAAM,oBACF,MAAM,EAAE,aACf,mBAAmB,GAC5B,YAAY,EAAE;6BA4BH,qBAAqB,eACpB,MAAM,oBACF,MAAM,EAAE,aACf,mBAAmB,eACjB,MAAM,MAAM,GACvB,sBAAsB,GAAG,IAAI;CAoBjC,CAAC"}

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

@@ -0,0 +1,65 @@
+import { HunterGuildMaster } from './HunterGuildMaster';
+import { HunterGuildProgress } from './HunterGuildProgress';
+import { HUNTER_RUMOUR_REGISTRY } from './Rumours';
+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 const HUNTER_GUILD = {
+    wikiUrl: 'https://runescape.wiki/w/Hunter_Guild',
+    masters: [...HUNTER_GUILD_MASTERS],
+    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);
+    },
+    getEligibleRumours(masterName, hunterLevel, completedQuests = [], progress = new HunterGuildProgress()) {
+        const master = HUNTER_GUILD_MASTERS.find((entry) => entry.name === masterName);
+        if (!master || !master.canAssignAnswers(hunterLevel, completedQuests)) {
+            return [];
+        }
+        return HUNTER_RUMOUR_REGISTRY.filter((rumour) => {
+            if (!rumour.canBeAssignedByMaster(masterName)) {
+                return false;
+            }
+            if (!rumour.isEligible(hunterLevel, completedQuests)) {
+                return false;
+            }
+            if (progress.isAssigned(rumour.id)) {
+                return false;
+            }
+            if (!progress.backToBackEnabled && progress.lastCompletedRumourId === rumour.id) {
+                return false;
+            }
+            return true;
+        });
+    },
+    assignRumour(masterName, hunterLevel, completedQuests = [], progress = new HunterGuildProgress(), randomizer = Math.random) {
+        const eligibleRumours = this.getEligibleRumours(masterName, hunterLevel, completedQuests, progress);
+        if (eligibleRumours.length === 0) {
+            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(),
+        };
+        progress.addAssignment(assignment);
+        return assignment;
+    },
+};

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

@@ -0,0 +1,29 @@
+import { HunterRumourTier } from './types';
+export declare const HunterGuildMasterName: {
+    readonly GILMAN: "Gilman";
+    readonly CERVUS: "Cervus";
+    readonly ORNUS: "Ornus";
+    readonly ACO: "Aco";
+    readonly TECO: "Teco";
+    readonly WOLF: "Wolf";
+};
+export type HunterGuildMasterName = typeof HunterGuildMasterName[keyof typeof HunterGuildMasterName];
+/**
+ * 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;
+    constructor(name: string, tier: HunterRumourTier, minimumLevel: number, requiresAtFirstLight?: boolean);
+    canAssignAnswers(hunterLevel: number, completedQuests?: string[]): boolean;
+}
+//# sourceMappingURL=HunterGuildMaster.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HunterGuildMaster.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/guilds/HunterGuildMaster.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAC,MAAM,SAAS,CAAC;AAE1C,eAAO,MAAM,qBAAqB;;;;;;;CAOxB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAErG;;;;;;;;;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;gBAGrC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,gBAAgB,EACtB,YAAY,EAAE,MAAM,EACpB,oBAAoB,UAAQ;IAQ9B,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,GAAE,MAAM,EAAO,GAAG,OAAO;CAW/E"}

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

@@ -0,0 +1,39 @@
+export const HunterGuildMasterName = {
+    GILMAN: 'Gilman',
+    CERVUS: 'Cervus',
+    ORNUS: 'Ornus',
+    ACO: 'Aco',
+    TECO: 'Teco',
+    WOLF: 'Wolf',
+};
+/**
+ * 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;
+    tier;
+    minimumLevel;
+    requiresAtFirstLight;
+    constructor(name, tier, minimumLevel, requiresAtFirstLight = false) {
+        this.name = name;
+        this.tier = tier;
+        this.minimumLevel = minimumLevel;
+        this.requiresAtFirstLight = requiresAtFirstLight;
+    }
+    canAssignAnswers(hunterLevel, completedQuests = []) {
+        if (hunterLevel < this.minimumLevel) {
+            return false;
+        }
+        if (this.requiresAtFirstLight && !completedQuests.includes('At First Light')) {
+            return false;
+        }
+        return true;
+    }
+}

package/dist/runescape/model/guilds/HunterGuildProgress.d.ts

@@ -0,0 +1,12 @@
+import { HunterRumourAssignment } from './types';
+export declare class HunterGuildProgress {
+    activeAssignments: HunterRumourAssignment[];
+    lastCompletedRumourId?: string;
+    backToBackEnabled: boolean;
+    constructor(activeAssignments?: HunterRumourAssignment[], lastCompletedRumourId?: string, backToBackEnabled?: boolean);
+    isAssigned(rumourId: string): boolean;
+    addAssignment(assignment: HunterRumourAssignment): void;
+    completeRumour(rumourId: string): void;
+    clearAssignments(): void;
+}
+//# sourceMappingURL=HunterGuildProgress.d.ts.map

package/dist/runescape/model/guilds/HunterGuildProgress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HunterGuildProgress.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/guilds/HunterGuildProgress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEjD,qBAAa,mBAAmB;IAC9B,iBAAiB,EAAE,sBAAsB,EAAE,CAAC;IAC5C,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;gBAGzB,iBAAiB,GAAE,sBAAsB,EAAO,EAChD,qBAAqB,CAAC,EAAE,MAAM,EAC9B,iBAAiB,UAAQ;IAO3B,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIrC,aAAa,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;IAOvD,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKtC,gBAAgB,IAAI,IAAI;CAIzB"}

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

@@ -0,0 +1,27 @@
+export class HunterGuildProgress {
+    activeAssignments;
+    lastCompletedRumourId;
+    backToBackEnabled;
+    constructor(activeAssignments = [], lastCompletedRumourId, backToBackEnabled = false) {
+        this.activeAssignments = [...activeAssignments];
+        this.lastCompletedRumourId = lastCompletedRumourId;
+        this.backToBackEnabled = backToBackEnabled;
+    }
+    isAssigned(rumourId) {
+        return this.activeAssignments.some((assignment) => assignment.rumourId === rumourId);
+    }
+    addAssignment(assignment) {
+        if (this.isAssigned(assignment.rumourId)) {
+            return;
+        }
+        this.activeAssignments.push(assignment);
+    }
+    completeRumour(rumourId) {
+        this.activeAssignments = this.activeAssignments.filter((assignment) => assignment.rumourId !== rumourId);
+        this.lastCompletedRumourId = rumourId;
+    }
+    clearAssignments() {
+        this.activeAssignments = [];
+        this.lastCompletedRumourId = undefined;
+    }
+}