osrs-tools 2.8.0 → 2.9.0

package/dist/runescape/model/leagues/DemonicPactPlanningData.d.ts

@@ -0,0 +1,4 @@
+import { DemonicPactPlanningData, DemonicPactTree } from "./DemonicPact.model";
+export declare function buildDemonicPactPlanningData(tree: DemonicPactTree): DemonicPactPlanningData;
+export declare const DEMONIC_PACTS_LEAGUES_7_PLANNING_DATA: DemonicPactPlanningData;
+//# sourceMappingURL=DemonicPactPlanningData.d.ts.map

package/dist/runescape/model/leagues/DemonicPactPlanningData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DemonicPactPlanningData.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/leagues/DemonicPactPlanningData.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,uBAAuB,EAEvB,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAU7B,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,eAAe,GAAG,uBAAuB,CA6B3F;AAED,eAAO,MAAM,qCAAqC,yBAAwD,CAAC"}

package/dist/runescape/model/leagues/DemonicPactPlanningData.js

@@ -0,0 +1,174 @@
+import { CombatStyle, PactNodeSize, } from "./DemonicPact.model";
+import { DEMONIC_PACTS_LEAGUES_7 } from "./DemonicPacts";
+const STYLE_VALUES = [
+    CombatStyle.Universal,
+    CombatStyle.Melee,
+    CombatStyle.Ranged,
+    CombatStyle.Magic,
+];
+export function buildDemonicPactPlanningData(tree) {
+    const pathingByPactId = buildPathingByPactId(tree);
+    const pactsById = new Map(tree.pacts.map((pact) => [pact.id, pact]));
+    const capstonePactIds = tree.pacts.filter((pact) => pact.nodeSize === PactNodeSize.Capstone).map((pact) => pact.id);
+    const leafPactIds = tree.pacts
+        .filter((pact) => pact.id !== tree.rootNodeId && pact.linkedNodeIds.length <= 1)
+        .map((pact) => pact.id);
+    const junctionPactIds = tree.pacts.filter((pact) => pact.linkedNodeIds.length >= 3).map((pact) => pact.id);
+    const styleSummaries = Object.freeze(STYLE_VALUES.reduce((acc, style) => {
+        acc[style] = buildStyleSummary(tree, style, pathingByPactId, pactsById);
+        return acc;
+    }, {}));
+    return {
+        totalPacts: tree.pacts.length,
+        totalPointsAvailable: tree.totalPointsAvailable,
+        rootPactId: tree.rootNodeId,
+        capstonePactIds,
+        leafPactIds,
+        junctionPactIds,
+        pathingByPactId,
+        styleSummaries,
+    };
+}
+export const DEMONIC_PACTS_LEAGUES_7_PLANNING_DATA = buildDemonicPactPlanningData(DEMONIC_PACTS_LEAGUES_7);
+function buildPathingByPactId(tree) {
+    const pactsById = new Map(tree.pacts.map((pact) => [pact.id, pact]));
+    const hops = computeMinimumHops(tree, pactsById);
+    const weighted = computeMinimumPointSpend(tree, pactsById);
+    const entries = tree.pacts.map((pact) => {
+        const hopInfo = hops.get(pact.id);
+        const weightedInfo = weighted.get(pact.id);
+        if (!hopInfo || !weightedInfo) {
+            throw new Error(`Unable to resolve pathing information for pact ${pact.id}`);
+        }
+        const pathingInfo = {
+            pactId: pact.id,
+            minimumUnlockHopsFromRoot: hopInfo.hops,
+            minimumPointSpendFromRoot: weightedInfo.cost,
+            minimumUnlockPathPactIds: weightedInfo.path,
+        };
+        return [pact.id, pathingInfo];
+    });
+    return Object.freeze(Object.fromEntries(entries));
+}
+function computeMinimumHops(tree, pactsById) {
+    const queue = [tree.rootNodeId];
+    const results = new Map();
+    results.set(tree.rootNodeId, { hops: 0, path: [tree.rootNodeId] });
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (!currentId) {
+            continue;
+        }
+        const current = pactsById.get(currentId);
+        const currentInfo = results.get(currentId);
+        if (!current || !currentInfo) {
+            continue;
+        }
+        const sortedNeighbors = [...current.linkedNodeIds].sort();
+        for (const neighborId of sortedNeighbors) {
+            if (!pactsById.has(neighborId) || results.has(neighborId)) {
+                continue;
+            }
+            results.set(neighborId, {
+                hops: currentInfo.hops + 1,
+                path: [...currentInfo.path, neighborId],
+            });
+            queue.push(neighborId);
+        }
+    }
+    return results;
+}
+function computeMinimumPointSpend(tree, pactsById) {
+    const unvisited = new Set(tree.pacts.map((pact) => pact.id));
+    const costs = new Map();
+    const paths = new Map();
+    for (const pact of tree.pacts) {
+        costs.set(pact.id, Number.POSITIVE_INFINITY);
+        paths.set(pact.id, []);
+    }
+    const rootPact = pactsById.get(tree.rootNodeId);
+    if (!rootPact) {
+        throw new Error(`Root pact ${tree.rootNodeId} was not found in pact tree`);
+    }
+    costs.set(rootPact.id, rootPact.pointCost);
+    paths.set(rootPact.id, [rootPact.id]);
+    while (unvisited.size > 0) {
+        let currentId;
+        let currentCost = Number.POSITIVE_INFINITY;
+        for (const pactId of unvisited) {
+            const pactCost = costs.get(pactId) ?? Number.POSITIVE_INFINITY;
+            if (pactCost < currentCost) {
+                currentCost = pactCost;
+                currentId = pactId;
+            }
+        }
+        if (!currentId || !Number.isFinite(currentCost)) {
+            break;
+        }
+        unvisited.delete(currentId);
+        const currentPact = pactsById.get(currentId);
+        const currentPath = paths.get(currentId) ?? [currentId];
+        if (!currentPact) {
+            continue;
+        }
+        const sortedNeighbors = [...currentPact.linkedNodeIds].sort();
+        for (const neighborId of sortedNeighbors) {
+            if (!unvisited.has(neighborId)) {
+                continue;
+            }
+            const neighborPact = pactsById.get(neighborId);
+            if (!neighborPact) {
+                continue;
+            }
+            const nextCost = currentCost + neighborPact.pointCost;
+            const prevCost = costs.get(neighborId) ?? Number.POSITIVE_INFINITY;
+            const nextPath = [...currentPath, neighborId];
+            const prevPath = paths.get(neighborId) ?? [];
+            if (nextCost < prevCost || (nextCost === prevCost && comparePaths(nextPath, prevPath) < 0)) {
+                costs.set(neighborId, nextCost);
+                paths.set(neighborId, nextPath);
+            }
+        }
+    }
+    const results = new Map();
+    for (const pact of tree.pacts) {
+        results.set(pact.id, {
+            cost: costs.get(pact.id) ?? Number.POSITIVE_INFINITY,
+            path: paths.get(pact.id) ?? [],
+        });
+    }
+    return results;
+}
+function comparePaths(left, right) {
+    if (left.length !== right.length) {
+        return left.length - right.length;
+    }
+    return left.join("|").localeCompare(right.join("|"));
+}
+function buildStyleSummary(tree, style, pathingByPactId, pactsById) {
+    const stylePacts = tree.pacts.filter((pact) => pact.style === style);
+    if (stylePacts.length === 0) {
+        throw new Error(`Expected at least one pact for style ${style}`);
+    }
+    let cheapestPact = stylePacts[0];
+    let cheapestCost = pathingByPactId[cheapestPact.id].minimumPointSpendFromRoot;
+    for (const pact of stylePacts.slice(1)) {
+        const pactCost = pathingByPactId[pact.id].minimumPointSpendFromRoot;
+        if (pactCost < cheapestCost || (pactCost === cheapestCost && pact.id.localeCompare(cheapestPact.id) < 0)) {
+            cheapestPact = pact;
+            cheapestCost = pactCost;
+        }
+    }
+    const totalPointCost = stylePacts.reduce((sum, pact) => {
+        const pactFromMap = pactsById.get(pact.id);
+        return sum + (pactFromMap?.pointCost ?? pact.pointCost);
+    }, 0);
+    return {
+        style,
+        pactCount: stylePacts.length,
+        capstonePactIds: stylePacts.filter((pact) => pact.nodeSize === PactNodeSize.Capstone).map((pact) => pact.id),
+        totalPointCost,
+        cheapestAccessPactId: cheapestPact.id,
+        cheapestAccessPointSpend: cheapestCost,
+    };
+}

package/dist/runescape/model/leagues/DemonicPacts.d.ts

@@ -0,0 +1,4 @@
+import { DemonicPactTree } from "./DemonicPact.model";
+export declare const DEMONIC_PACTS_LEAGUES_7: DemonicPactTree;
+export declare const LEAGUES_7_COMBAT_MASTERY_TREE: DemonicPactTree;
+//# sourceMappingURL=DemonicPacts.d.ts.map

package/dist/runescape/model/leagues/DemonicPacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DemonicPacts.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/leagues/DemonicPacts.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,eAAe,EAKhB,MAAM,qBAAqB,CAAC;AA0C7B,eAAO,MAAM,uBAAuB,EAAE,eAOrC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAAyC,CAAC"}

package/dist/runescape/model/leagues/DemonicPacts.js

@@ -0,0 +1,66 @@
+import demonicPactsResource from '../../resources/leagues/demonicPacts.leagues7.json';
+import { CombatStyle, LeaguesSeason, PactNodeSize } from "./DemonicPact.model";
+const STYLE_MAP = {
+    universal: CombatStyle.Universal,
+    melee: CombatStyle.Melee,
+    ranged: CombatStyle.Ranged,
+    magic: CombatStyle.Magic,
+};
+const NODE_SIZE_MAP = {
+    node_minor: PactNodeSize.Minor,
+    node_major: PactNodeSize.Major,
+    node_capstone: PactNodeSize.Capstone,
+};
+const RESOURCE = demonicPactsResource;
+export const DEMONIC_PACTS_LEAGUES_7 = {
+    season: LeaguesSeason.Leagues7,
+    displayName: RESOURCE.displayName,
+    totalPointsAvailable: RESOURCE.totalPointsAvailable,
+    rootNodeId: RESOURCE.rootNodeId,
+    source: RESOURCE.source,
+    pacts: RESOURCE.nodes.map(mapResourceNode),
+};
+export const LEAGUES_7_COMBAT_MASTERY_TREE = DEMONIC_PACTS_LEAGUES_7;
+function mapResourceNode(resourceNode) {
+    const description = normalizeDescription(resourceNode.description, resourceNode.effectValue);
+    const effect = {
+        key: resourceNode.effectName,
+        value: resourceNode.effectValue,
+        description,
+    };
+    return {
+        id: resourceNode.id,
+        name: createPactName(resourceNode.effectName, description),
+        description,
+        rawDescription: resourceNode.description,
+        style: STYLE_MAP[resourceNode.style],
+        nodeSize: NODE_SIZE_MAP[resourceNode.nodeSize],
+        pointCost: resourceNode.pointCost,
+        linkedNodeIds: [...resourceNode.linkedNodeIds],
+        effect,
+        drawCoord: { ...resourceNode.drawCoord },
+        icon: resourceNode.nodeSprite,
+    };
+}
+function normalizeDescription(rawDescription, effectValue) {
+    const placeholderValue = effectValue === null ? '' : String(effectValue);
+    const resolvedDescription = rawDescription.replace(/#/g, placeholderValue);
+    return resolvedDescription
+        .replace(/<[^>]+>/g, '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line, index, lines) => line.length > 0 || (index > 0 && lines[index - 1].length > 0))
+        .join('\n');
+}
+function createPactName(effectName, description) {
+    if (effectName) {
+        return effectName
+            .replace(/^talent_/, '')
+            .split('_')
+            .filter((segment) => segment.length > 0)
+            .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+            .join(' ');
+    }
+    const [firstLine] = description.split('\n');
+    return firstLine.trim();
+}

package/dist/runescape/model/leagues/DemonicPactsLeague/DemonicPactsLeagueAreas.d.ts

@@ -0,0 +1,23 @@
+import { LeagueRegion, NotableDrop } from '../model';
+/**
+ * Represents an area in the Demonic Pacts League, which is a specific region of the game world that has its own unique content, mechanics, and rewards during the league. Each area includes information about its name, description, whether it is a starting area, its accessibility, any tasks required to unlock it, notable settlements and activities within the area, any echo bosses that can be found there, quests and achievements that are automatically completed upon entering the area, and notable drops that can be obtained from activities within the area. This type is used to organize and reference the different areas of the Demonic Pacts League in a structured way.
+ */
+export interface DemonicPactsLeagueArea {
+    name: string;
+    description: string;
+    isStarting: boolean;
+    isAccessible: boolean;
+    unlocksAfterTasks?: number;
+    notableSettlements: string[];
+    notableActivities: string[];
+    echoBoss?: string;
+    autoCompletedQuests: string[];
+    autoCompletedAchievements: string[];
+    notableDrops?: NotableDrop[];
+}
+/**
+ * A record of the different areas in the Demonic Pacts League, keyed by a unique identifier for each area (e.g., "varlamore", "karamja", "asgarnia"). Each entry in the record contains all the relevant information about that area, as defined by the DemonicPactsLeagueArea interface. This structure allows for easy retrieval and reference of area information throughout the application, particularly when displaying league content or calculating rewards and progress for players participating in the Demonic Pacts League.
+ */
+export declare const DEMONIC_PACTS_LEAGUE_AREAS: Record<string, DemonicPactsLeagueArea>;
+export declare const DemonicPactsLeagueRegions: Record<string, LeagueRegion>;
+//# sourceMappingURL=DemonicPactsLeagueAreas.d.ts.map

package/dist/runescape/model/leagues/DemonicPactsLeague/DemonicPactsLeagueAreas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DemonicPactsLeagueAreas.d.ts","sourceRoot":"","sources":["../../../../../source/runescape/model/leagues/DemonicPactsLeague/DemonicPactsLeagueAreas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGrD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CA+Y7E,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAkDlE,CAAC"}