osrs-tools/dist/runescape/model/Requirement.js

A comprehensive TypeScript library for Old School RuneScape (OSRS) data and utilities, including quest data, skill requirements, and game item information

import { SKILL_METADATA } from './account/Skill';
/**
 * Level requirement for a specific skill.
 * Automatically determines boostability from skill metadata.
 * Supports both Skill enum and string skill names for backwards compatibility.
 */
class LevelRequirement {
    type = RequirementType.Level;
    skillName;
    level;
    boostable;
    constructor(skillName, level, boostable) {
        this.skillName = skillName;
        this.level = level;
        // If boostable is not explicitly provided, use metadata
        if (boostable !== undefined) {
            this.boostable = boostable;
        }
        else {
            // Try to infer from metadata, default to false if skill not found
            const meta = SKILL_METADATA[this.skillName];
            this.boostable = meta?.isBoostable ?? false;
        }
    }
    get description() {
        return `Level ${this.level}`;
    }
    /**
     * Get the expected max level for this skill from metadata.
     * Useful for validation and display purposes.
     */
    getMaxLevel() {
        const meta = SKILL_METADATA[this.skillName];
        return meta?.maxLevel ?? 99;
    }
}
// Enum for requirement types
var RequirementType;
(function (RequirementType) {
    RequirementType["SlayerLevel"] = "SlayerLevel";
    RequirementType["Level"] = "Level";
    RequirementType["CombatLevel"] = "CombatLevel";
    RequirementType["Quest"] = "Quest";
    RequirementType["Item"] = "Item";
    RequirementType["QuestPoint"] = "QuestPoint";
    RequirementType["Location"] = "Location";
    RequirementType["SlayerUnlock"] = "SlayerUnlock";
})(RequirementType || (RequirementType = {}));
// Slayer Unlock requirement
class SlayerUnlockRequirement {
    type = RequirementType.SlayerUnlock;
    name;
    constructor(name) {
        this.name = name;
    }
    get description() {
        return `Slayer unlock: ${this.name}`;
    }
}
// Slayer level requirement
class SlayerLevelRequirement {
    type = RequirementType.SlayerLevel;
    level;
    constructor(level) {
        this.level = level;
    }
    get description() {
        return `Slayer level ${this.level}`;
    }
}
// Combat level requirement
class CombatLevelRequirement {
    type = RequirementType.CombatLevel;
    level;
    constructor(level) {
        this.level = level;
    }
    get description() {
        return `Combat level ${this.level}`;
    }
}
// Quest requirement
class QuestRequirement {
    static fromQuestName(arg0) {
        throw new Error("Method not implemented.");
    }
    type = RequirementType.Quest;
    questName;
    constructor(questName) {
        this.questName = questName;
    }
    get description() {
        return `Completed quest: ${this.questName}`;
    }
    get completionDescription() {
        return `Completion of ${this.questName}`;
    }
}
class QuestPointRequirement {
    type = RequirementType.QuestPoint;
    amount;
    constructor(amount) {
        this.amount = amount;
    }
    get description() {
        return `Quest Points Needed: ${this.amount}`;
    }
}
// Item requirement
class ItemRequirement {
    type = RequirementType.Item;
    itemName;
    quantity;
    /** Whether the item is consumed during the quest */
    consumed;
    /** Alternative items that can be used instead */
    alternatives;
    /** Whether the item must be noted */
    noted;
    /** Whether the item can be banked and withdrawn during the quest */
    bankable;
    /** Any additional notes about the item requirement */
    notes;
    constructor(itemName, quantity = 1, options = {}) {
        this.itemName = itemName;
        this.quantity = quantity;
        this.consumed = options.consumed ?? true;
        this.alternatives = options.alternatives;
        this.noted = options.noted;
        this.bankable = options.bankable;
        this.notes = options.notes;
    }
    get description() {
        let desc = `${this.quantity}x ${this.itemName}`;
        if (this.noted)
            desc += ' (noted)';
        if (!this.consumed)
            desc += ' (not consumed)';
        if (this.alternatives?.length) {
            desc += ` (or ${this.alternatives.join(' or ')})`;
        }
        if (this.notes)
            desc += ` (${this.notes})`;
        return desc;
    }
}
// Location requirement
class LocationRequirement {
    type = RequirementType.Location;
    locationName;
    constructor(locationName) {
        this.locationName = locationName;
    }
    get description() {
        return `Access to location: ${this.locationName}`;
    }
}
export { CombatLevelRequirement, ItemRequirement, LevelRequirement, LocationRequirement, QuestPointRequirement, QuestRequirement, RequirementType, SlayerLevelRequirement, SlayerUnlockRequirement, };