osrs-tools 0.1.1 → 0.2.0

package/src/model/quest/Quest.ts

@@ -0,0 +1,44 @@
+
+
+// SkillRequirement interface
+interface SkillRequirement {
+    level: number;        // Required skill level
+    isBoostable: boolean; // Flag to indicate if the skill is boostable
+}
+
+
+// Quest interface
+interface Quest {
+    id: number;                // Unique identifier
+    name: string;              // Quest name
+    difficulty: string; // Difficulty level
+    skillRequirements: { [skill: string]: SkillRequirement };  // Skill level requirements with boostable flag
+    status: 'Not Started' | 'In Progress' | 'Completed'; // Quest status
+    miniquest: boolean; // Is this a miniquest?
+    shortName: string; // Short name for the quest
+    url: string; // URL to the quest guide
+    series: string; // Series of the quest (e.g. 'Elf', 'Mahjarrat')
+    members: boolean; // Is this a members-only quest?  
+    questPoints: number; // Quest points rewarded
+    length: string; // Length of the quest
+    age: string; // Age of the quest
+    startLocation: string; // Starting location
+    difficultyLevel: string; // Difficulty level
+    officialDifficulty: string; // Official difficulty level
+    officialLength: string; // Official length
+    officialAge: string; // Official age
+    itemRequirements: string[]; // Item requirements
+    recommendedItems: string[]; // Recommended items
+    recommendedSkills: { [skill: string]: number }; // Recommended skills
+    recommendedPrayers: string[]; // Recommended prayers
+    questRequirements: string[];  // Names of quests that need to be completed before
+    rewards: {
+        experience?: { [skill: string]: number }; // Experience rewards per skill
+        items?: string[];  // List of items rewarded
+        areas?: string[];  // List of items rewarded
+    };
+}
+
+
+
+export { Quest };

package/src/model/quest/QuestTool.ts

@@ -0,0 +1,96 @@
+import { OsrsAccount } from '../account/OsrsAccount';
+import { Quest } from './Quest';
+
+class QuestTool {
+    private questObject: any;
+    private questArray: any;
+    private subQuestArray: any;
+    private osrsAccount: OsrsAccount | undefined;
+
+    constructor() {
+        // todo need to import these data from a typescript file where its defined/stored
+        this.questObject = [];
+        this.questArray = [];
+        this.subQuestArray = [];
+    }
+
+    /**
+     * to string func
+     * @todo    Implement this function
+     * @return  {String} The string representation of the class object. 
+     */
+    toString(): string {
+        return 'QuestTool :) WIP';
+    }
+
+    /**
+     * Get the data for a quest
+     * @param  {String} questName The name of the quest
+     * @return {Object} The data for the input quest in a JSON object.
+     * */
+    getQuest(questName: string): Quest | undefined {
+        if (typeof questName === 'string' && this.questObject[questName]) {
+            // return new Quest(this.questObject[questName]); TODO
+        }
+        return undefined;
+    }
+
+    /**
+     * Get the data for a quest
+     * @param  {String} questName The name of the quest
+     * @return {Object} The data for the input quest in a JSON object.
+     * */
+    getQuestByName(questName: string): Quest | undefined {
+        return this.getQuest(questName);
+    }
+
+    /**
+     * Get the data for a quest
+     * @param  {String} subQuestName The name of the subquest
+     * @return {Object} The data for the input subquest in a JSON object.
+     * */
+    getSubQuest(subQuestName: string): any | undefined {
+        return this.subQuestArray.find((x: any) => x.name === subQuestName);
+    }
+
+    // Define highestBoost method, switch case omitted for brevity
+
+    /**
+     * Add two numbers together
+     * @todo Need to implement Recipe for disaster functionality
+     * @param  {String} quest The either string or quest object of the quest to be determined completeable or not.
+     * @return {Boolean}  If the account currently tied to the tool can complete the quest.
+     * */
+    canCompleteQuest(quest: string | Quest | undefined): boolean {
+        // Implementation omitted for brevity
+        return true; // Placeholder return value
+    }
+
+    // Define completableQuests method, implementation omitted for brevity
+
+    /**
+     * Set the account to be used in this quest tool
+     * @param  {OsrsAccount} acc1 The osrs Account to be associated with this class object.
+     * */
+    setOsrsAccount(acc1: OsrsAccount): boolean {
+        if (acc1) {
+            // this.osrsAccount = new OsrsAccount(acc1); TODO
+            return true;
+        }
+        return false;
+    }
+
+    // Define other methods, implementation omitted for brevity
+
+    /**
+     * Get the osrs account associated with this quest tool
+     * @return  {OsrsAccount | undefined} The osrs Account associated with this class object.
+     * */
+    getOsrsAccount(): OsrsAccount | undefined {
+        return this.osrsAccount;
+    }
+
+    // Define other getters, implementation omitted for brevity
+}
+
+export { QuestTool };

package/src/model/slayer/Assignment.ts

@@ -0,0 +1,40 @@
+import { Requirement } from '../Requirement';
+import { Task } from './Task';
+
+// A Class that represents an assignment of a task to a player.
+// An assignment is a specific instance of a task, with a specific quantity and requirements.
+// The assignment is the actual task given to a player, which is based on the Task.
+export class Assignment {
+  name: string;
+  quantity: number;
+  requirements: Requirement[];
+  extendedAmountMin?: number | null;
+  extendedAmountMax?: number | null;
+
+  constructor(
+    name: string,
+    quantity: number,
+    requirements: Requirement[],
+    extendedAmountMin?: number | null,
+    extendedAmountMax?: number | null
+  ) {
+    this.name = name;
+    this.quantity = quantity;
+    this.requirements = requirements;
+    this.extendedAmountMin = extendedAmountMin ?? null;
+    this.extendedAmountMax = extendedAmountMax ?? null;
+  }
+  /**
+   * Get the task name
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * Get the quantity of the task
+   */
+  getQuantity(): number {
+    return this.quantity;
+  }
+}

package/src/model/slayer/SlayerMaster.ts

@@ -0,0 +1,137 @@
+import { Assignment } from './Assignment';
+import { Task } from './Task';
+
+/**
+ * SlayerMaster class represents a Slayer Master in the game.
+ * It encapsulates the properties and methods related to a Slayer Master,
+ * including the tasks they assign, their location, level requirements,
+ * and the ability to generate random assignments.
+ * Reference: https://oldschool.runescape.wiki/w/Duradel
+ *
+ */
+class SlayerMaster {
+  name: string; // Name of the Slayer Master
+  totalWeight: number; // Total weight of the tasks assigned to this Slayer Master. This is used to determine the likelihood of each task being assigned.
+  location: string = ''; // Location of the Slayer Master (optional, can be set later if needed)
+  minimumCombatLevel: number = 0; // Level requirement to access this Slayer Master (optional, can be set later if needed)
+  tasks: Task[]; // Array of tasks assigned to this Slayer Master. This holds the actual tasks that players can be assigned to kill.
+  wikiUrl: string = ''; // URL for the Slayer Master (optional, can be set later if needed)
+  taskPoints: Record<number, number>; // Mapping of task intervals to points
+  eliteDiaryTaskPoints?: Record<number, number>; // Mapping of task intervals to points
+
+  // Constructor for the SlayerMaster class
+  constructor(
+    name: string,
+    tasks: Task[],
+    location: string,
+    levelRequirement: number,
+    url: string,
+    taskPoints: Record<number, number>, // Pass the task points mapping in the constructor
+    eliteDiaryTaskPoints?: Record<number, number> // Optional mapping for elite diary task points
+  ) {
+    this.name = name;
+    this.tasks = tasks; // Array of tasks assigned to this Slayer Master
+    this.tasks.forEach((task) => {
+      task.weight = task.weight || 0; // Default weight to 0 if not provided
+    }); // Initialize the tasks array
+    this.totalWeight = this.calculateTotalWeight(); // Calculate the total weight of the tasks
+    this.location = location; // Default to an empty string if not provided
+    this.minimumCombatLevel = levelRequirement; // Default to 0 if not provided
+    this.wikiUrl = url; // Default to an empty string if not provided
+    this.taskPoints = taskPoints; // Initialize the task points mapping
+    this.eliteDiaryTaskPoints = eliteDiaryTaskPoints; // Optional mapping for elite diary task points
+  }
+
+  /**
+   *  Calculate the total weight of all tasks assigned to this Slayer Master.
+   * @returns {number} The total weight of all tasks assigned to this Slayer Master.
+   */
+  calculateTotalWeight(): number {
+    if (this.tasks.length === 0) return 0; // Return 0 if there are no tasks
+    return this.tasks.reduce((total, task) => {
+      return total + (task.weight || 0); // Sum up the weights of all tasks
+    }, 0);
+    throw new Error('Method not implemented.');
+  }
+
+  /**
+   * Get the points awarded for completing a task based on the interval.
+   * @param {number} taskInterval - The interval of the task (e.g., 1 for every task, 10 for every 10th task, etc.).
+   * @returns {number} The points awarded for the given task interval.
+   */
+  getPointsForTaskInterval(taskInterval: number): number {
+    return this.taskPoints[taskInterval] || 0; // Return the points for the interval or 0 if not defined
+  }
+
+  /**
+   * Get the location of the Slayer Master
+   */
+  getLocation(): string {
+    return this.location;
+  }
+
+  /**
+   * Get the minimum combat level of the Slayer Master
+   */
+  getMinimumCombatLevel(): number {
+    return this.minimumCombatLevel;
+  }
+
+  /**
+   * Get the wiki URL of the Slayer Master
+   */
+  getWikiUrl(): string {
+    return this.wikiUrl;
+  }
+
+  /**
+   * Get a random task based on the weighting system of the tasks.
+   * Tasks with higher weights have a higher chance of being selected.
+   * @returns {Task | null} A randomly selected task or null if no tasks are available.
+   */
+  getRandomTask(): Task | null {
+    if (this.tasks.length === 0) return null; // Return null if there are no tasks
+
+    const randomWeight = Math.random() * this.totalWeight; // Generate a random number between 0 and totalWeight
+    let cumulativeWeight = 0;
+
+    for (const task of this.tasks) {
+      cumulativeWeight += task.weight || 0; // Add the task's weight to the cumulative weight
+      if (randomWeight <= cumulativeWeight) {
+        return task; // Return the task if the random weight falls within its range
+      }
+    }
+
+    return null; // Fallback in case no task is selected (shouldn't happen if weights are correct)
+  }
+
+  /**
+   * Get the total weight of tasks
+   */
+  getTotalWeight(): number {
+    return this.totalWeight;
+  }
+
+  /**
+   * Get Name of Slayer Master
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * Get Tasks
+   */
+  getTasks(): Task[] {
+    return this.tasks;
+  }
+
+  /**
+   * toString function
+   */
+  toString(): string {
+    return `SlayerMaster :) WIP SlayerMaster:{\nname: ${this.name}\n}`;
+  }
+}
+
+export { SlayerMaster };

package/src/model/slayer/SlayerReward.ts

@@ -0,0 +1,39 @@
+class SlayerUnlock {
+  name: string;
+  cost: number;
+  description: string;
+
+  constructor({ name, cost, description }: { name: string; cost: number; description: string }) {
+    this.name = name;
+    this.cost = cost;
+    this.description = description;
+  }
+}
+
+class SlayerExtend {
+  name: string;
+  cost: number;
+  notes: string;
+
+  constructor({ name, cost, notes }: { name: string; cost: number; notes: string }) {
+    this.name = name;
+    this.cost = cost;
+    this.notes = notes;
+  }
+}
+
+class SlayerBuy {
+  item: string;
+  priceSoldAt: number;
+  notes: string;
+
+  constructor({ item, priceSoldAt, notes }: { item: string; priceSoldAt: number; notes: string }) {
+    this.item = item;
+    this.priceSoldAt = priceSoldAt;
+    this.notes = notes;
+  }
+}
+
+class SlayerReward { }
+
+export { SlayerUnlock, SlayerReward, SlayerExtend, SlayerBuy };

package/src/model/slayer/Task.ts

@@ -0,0 +1,168 @@
+import { Requirement } from '../Requirement';
+
+/**
+ * Represents a Slayer task in the game. This class encapsulates all the properties and methods related to a Slayer task.
+ * A Slayer task defines the monsters that players can be assigned to kill, the amount of those monsters, and various other attributes.
+ * A Task is not an assignment, but rather a template for an assignment.
+ * The assignment is the actual task given to a player, which is based on the Task.
+ */
+class Task {
+  name: string; // Name of the task
+  weight: number; // Weight of the task, used to determine the likelihood of being assigned this task
+  amountMin: number; // Minimum amount of monsters to kill for this task
+  amountMax: number; // Maximum amount of monsters to kill for this task
+  requirements: Requirement[]; // Array of requirements for this task
+  extendedAmountMin?: number | null; // Minimum amount for extended tasks (optional)
+  extendedAmountMax?: number | null; // Maximum amount for extended tasks (optional)
+  alternatives?: any[] | null; // Array of alternatives for this task (optional)
+  CombatLevels: number[]; // Array of combat levels for this task
+  SlayerExp: number; // Slayer experience gained from this task
+  locations: string[]; // Array of locations where this task can be found
+  WildernessLevels: number[]; // Array of wilderness levels for this task
+  bosses: string[]; // Array of bosses for this task
+
+  /**
+   * Constructor for the Task class.
+   * @param name - Name of the task
+   * @param amountMin - Minimum amount of monsters to kill for this task
+   * @param amountMax - Maximum amount of monsters to kill for this task
+   * @param requirements - Array of requirements for this task
+   * @param extendedAmountMin - Minimum amount for extended tasks (optional)
+   * @param extendedAmountMax - Maximum amount for extended tasks (optional)
+   * @param weight - Weight of the task (default is 1)
+   * @param alternatives - Array of alternatives for this task (optional)
+   * @param CombatLevels - Array of combat levels for this task
+   * @param SlayerExp - Slayer experience gained from this task
+   * @param locations - Array of locations where this task can be found
+   * @param WildernessLevels - Array of wilderness levels for this task
+   * @param bosses - Array of bosses for this task
+   */
+  constructor(
+    name: string,
+    amountMin: number,
+    amountMax: number,
+    requirements: Requirement[],
+    extendedAmountMin?: number | null,
+    extendedAmountMax?: number | null,
+    alternatives: string[] = [],
+    weight: number = 1,
+    CombatLevels: number[] = [],
+    SlayerExp: number = 0,
+    locations: string[] = [],
+    WildernessLevels: number[] = [],
+    bosses: string[] = []
+  ) {
+    this.name = name;
+    this.weight = weight;
+    this.amountMin = amountMin;
+    this.amountMax = amountMax;
+    this.requirements = requirements;
+    this.extendedAmountMin = extendedAmountMin ?? null;
+    this.extendedAmountMax = extendedAmountMax ?? null;
+    this.alternatives = alternatives ?? [];
+    this.CombatLevels = CombatLevels;
+    this.SlayerExp = SlayerExp;
+    this.locations = locations;
+    this.WildernessLevels = WildernessLevels;
+    this.bosses = bosses;
+  }
+
+  static fromJSON(json: any): Task {
+    return new Task(
+      json.name,
+      json.amountMin,
+      json.amountMax,
+      json.extendedAmountMin,
+      json.extendedAmountMax,
+      json.requirements,
+      json.alternatives,
+      json.weight,
+      json.CombatLevels,
+      json.SlayerExp,
+      json.locations,
+      json.WildernessLevels,
+      json.bosses
+    );
+  }
+
+  /**
+   * Get the name of the task.
+   * @example
+   * const task = new Task("Goblin", 10, 20, [], 0, null, [], 1);
+   * console.log(task.getName()); // "Goblin"
+   * @returns
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * Get the weight of the task. The weight is used to determine the likelihood of being assigned this task compared to others.
+   * @returns {number} The weight of the task, which can be used to determine the likelihood of being assigned this task compared to others.
+   */
+  getWeight(): number {
+    return this.weight;
+  }
+
+  /**
+   * Get the minimum and maximum amount of monsters to kill for this task.
+   * The amountMin and amountMax properties define the range of monsters that can be assigned for this task.
+   * @returns {number} The minimum amount of monsters to kill for this task.
+   */
+  getAmountMin(): number {
+    return this.amountMin;
+  }
+
+  /**
+   * Get the maximum amount of monsters to kill for this task.
+   * @returns {number} The maximum amount of monsters to kill for this task.
+   */
+  getAmountMax(): number {
+    return this.amountMax;
+  }
+
+  /**
+   *
+   */
+  getRequirements(): Requirement[] {
+    return this.requirements;
+  }
+
+  /**
+   *
+   * @returns {any[]} An array of alternatives for this task. If alternatives are defined as an object, it flattens the values into a single array.
+   */
+  getAlternatives(): any[] {
+    return this.alternatives
+      ? Array.isArray(this.alternatives)
+        ? this.alternatives
+        : Object.values(this.alternatives).flat()
+      : [];
+  }
+
+  /**
+   *
+   * @returns
+   */
+  toJSON(): any {
+    return {
+      name: this.name,
+      weight: this.weight,
+      amountMin: this.amountMin,
+      amountMax: this.amountMax,
+      unlockRequirements: this.requirements,
+      alternatives: this.alternatives,
+    };
+  }
+
+  /**
+   * Returns a string representation of the Task object.
+   * This method is useful for debugging and logging purposes, providing a quick overview of the task's name and other properties.
+   * @returns {string} A string representation of the Task object, useful for debugging and logging purposes.
+   */
+  toString(): string {
+    return `Task{ name: ${this.name} }`;
+  }
+}
+
+export { Task };