osrs-tools 0.2.0 → 0.2.1

package/src/model/quest/Quest.ts

@@ -1,44 +0,0 @@
-
-
-// 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/slayer/Assignment.ts

@@ -1,40 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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 };