small fixes or smth

Author: DuckySoLucky

API/constants/leveling.js

@@ -1,65 +1,183 @@
-//CREDIT: https://github.com/SkyCrypt/SkyCryptWebsite (Modified)
-const xp_tables = require("./xp_tables.js");
-
-module.exports = function calcSkill(skill, experience, type) {
-  let table = "normal";
-  if (skill === "runecrafting") table = "runecrafting";
-  if (skill === "social") table = "social";
-  if (skill === "dungeoneering") table = "catacombs";
-  if (skill === "hotm") table = "hotm";
-
-  if (experience <= 0) {
-    return {
-      totalXp: 0,
-      xp: 0,
-      level: 0,
-      xpCurrent: 0,
-      xpForNext: xp_tables[table][0],
-      progress: 0
-    };
+const { cropTables, skillTables } = require("./leveling.js");
+
+/**
+ * Gets the xp table for the given type.
+ * @param {string} [type='default'] The skill table type. Defaults to the "default" table for skills.
+ * @returns {number[]} xp table
+ */
+function getXpTable(type = "default") {
+  return cropTables[type] ?? skillTables[type] ?? skillTables.default;
+}
+
+/**
+ * Gets the level and some other information from an xp amount.
+ * @param {number} xp The experience points to calculate level information from.
+ * @param {Object} [extra={}] Additional options for level calculation.
+ * @param {string} [extra.type] The ID of the skill (used to determine xp table and default cap).
+ * @param {number} [extra.cap] Override for the highest level the player can reach.
+ */
+function getLevelByXp(xp, extra = {}) {
+  const xpTable = getXpTable(extra.type);
+
+  if (typeof xp !== "number" || isNaN(xp)) {
+    xp = 0;
   }
-  let xp = 0;
-  let level = 0;
-  let xpForNext = 0;
-  let progress = 0;
-  let maxLevel = 0;
 
-  if (xp_tables.max_levels[skill]) maxLevel = xp_tables.max_levels[skill];
+  /** the level that this player is caped at */
+  const levelCap =
+    extra.cap ?? skillTables.defaultSkillCaps[extra.type] ?? Math.max(...Object.keys(xpTable).map(Number));
+
+  /** the level ignoring the cap and using only the table */
+  let uncappedLevel = 0;
 
-  for (let i = 1; i <= maxLevel; i++) {
-    xp += xp_tables[table][i - 1];
+  /** the amount of xp over the amount required for the level (used for calculation progress to next level) */
+  let xpCurrent = xp;
 
-    if (xp > experience) {
-      xp -= xp_tables[table][i - 1];
-    } else {
-      if (i <= maxLevel) level = i;
+  /** like xpCurrent but ignores cap */
+  let xpRemaining = xp;
+
+  while (xpTable[uncappedLevel + 1] <= xpRemaining) {
+    uncappedLevel++;
+    xpRemaining -= xpTable[uncappedLevel];
+    if (uncappedLevel <= levelCap) {
+      xpCurrent = xpRemaining;
     }
   }
 
-  if (skill === "dungeoneering") {
-    level += Math.floor((experience - xp) / 200_000_000);
-    xp += Math.floor((experience - xp) / 200_000_000) * 200_000_000;
+  /** Whether the skill has infinite leveling (dungeoneering and skyblock level) */
+  const isInfiniteLevelable = skillTables.infiniteLeveling.includes(extra.type);
+
+  /** adds support for infinite leveling (dungeoneering and skyblock level) */
+  if (isInfiniteLevelable) {
+    const maxExperience = Object.values(xpTable).at(-1);
 
-    xpForNext = 200000000;
+    uncappedLevel += Math.floor(xpRemaining / maxExperience);
+    xpRemaining %= maxExperience;
+    xpCurrent = xpRemaining;
   }
 
-  const xpCurrent = Math.floor(experience - xp);
+  /** the maximum level that any player can achieve (used for gold progress bars) */
+  const maxLevel = isInfiniteLevelable
+    ? Math.max(uncappedLevel, levelCap)
+    : skillTables.maxedSkillCaps[extra.type] ?? levelCap;
 
-  const totalXp = experience;
+  /** the level as displayed by in game UI */
+  const level = isInfiniteLevelable ? uncappedLevel : Math.min(levelCap, uncappedLevel);
 
-  if (level < maxLevel) {
-    xpForNext = Math.ceil(xp_tables[table][level] || 200000000);
-  }
+  /** the amount amount of xp needed to reach the next level (used for calculation progress to next level) */
+  const xpForNext =
+    level < maxLevel
+      ? Math.ceil(xpTable[level + 1] ?? Object.values(xpTable).at(-1))
+      : isInfiniteLevelable
+        ? Object.values(xpTable).at(-1)
+        : Infinity;
 
-  progress = level >= maxLevel && skill !== "dungeoneering" ? 0 : Math.max(0, Math.min(xpCurrent / xpForNext, 1));
+  /** the fraction of the way toward the next level */
+  const progress = level >= maxLevel && !isInfiniteLevelable ? 0 : Math.max(0, Math.min(xpCurrent / xpForNext, 1));
+
+  /** a floating point value representing the current level for example if you are half way to level 5 it would be 4.5 */
+  const levelWithProgress = isInfiniteLevelable
+    ? uncappedLevel + progress
+    : Math.min(uncappedLevel + progress, levelCap);
+
+  /** a floating point value representing the current level ignoring the in-game unlockable caps for example if you are half way to level 5 it would be 4.5 */
+  const unlockableLevelWithProgress = extra.cap ? Math.min(uncappedLevel + progress, maxLevel) : levelWithProgress;
+
+  /** the amount of xp needed to max out the skill */
+  const maxExperience = getSkillExperience(extra.type, levelCap);
 
   return {
-    totalXp,
     xp,
     level,
+    maxLevel,
     xpCurrent,
     xpForNext,
     progress,
-    levelWithProgress: level + progress || 0
+    levelCap,
+    uncappedLevel,
+    levelWithProgress,
+    unlockableLevelWithProgress,
+    maxExperience
   };
+}
+
+/**
+ * Calculates the average skill level for a player's profile data.
+ *
+ * @param {Object} profileData The player's profile data.
+ * @param {Object} hypixelPlayer The player's Hypixel data.
+ * @param {Object} [options] Additional options for calculating the average.
+ * @param {number} [options.decimals=2] The number of decimal places to round the average to. Default is 1.
+ * @param {boolean} [options.progress=false] Whether to include progress towards the next level in the calculation. Default is false.
+ * @param {boolean} [options.cosmetic=false] Whether to include cosmetic skills in the calculation. Default is false.
+ * @returns {string} The average skill level rounded to the specified number of decimal places.
+ */
+function getSkillAverage(profileData, hypixelPlayer, options = { decimals: 2, progress: false, cosmetic: false }) {
+  const skillLevelCaps = getSkillLevelCaps(profileData, hypixelPlayer);
+
+  let totalLevel = 0;
+  for (const skillId of skillTables.skills) {
+    if (!options.cosmetic && skillTables.cosmeticSkills.includes(skillId)) {
+      continue;
+    }
+
+    const skill = getLevelByXp(profileData.player_data?.experience?.[`SKILL_${skillId.toUpperCase()}`], {
+      type: skillId,
+      cap: skillLevelCaps[skillId]
+    });
+
+    totalLevel += options.progress ? skill.levelWithProgress : skill.level;
+  }
+
+  const average =
+    totalLevel /
+    skillTables.skills.filter((skill) => !(!options.cosmetic && skillTables.cosmeticSkills.includes(skill))).length;
+
+  return average.toFixed(options.decimals);
+}
+
+/**
+ * Calculates the skill level caps for different skills based on the profile data and Hypixel player data.
+ * @param {Object} profileData The profile data containing information about the player's skills.
+ * @param {Object} hypixelPlayer The Hypixel player data containing information about the player's achievements.
+ * @returns {Object} An object containing the skill level caps for farming, taming, and runecrafting.
+ */
+function getSkillLevelCaps(profileData, hypixelPlayer) {
+  return {
+    farming: 50 + (profileData.jacobs_contest?.perks?.farming_level_cap || 0),
+    taming: 50 + (profileData.pets_data?.pet_care?.pet_types_sacrificed?.length || 0),
+    runecrafting: 25 // hypixelPlayer?.newPackageRank ? 25 : 3
+  };
+}
+
+/**
+ * Calculates the total experience required to reach a certain level in a skill.
+ * @param {string} skill The ID of the skill used to determine the xp table.
+ * @param {number} level The target level.
+ * @returns {number} The total experience required.
+ */
+function getSkillExperience(skill, level) {
+  const skillTable = getXpTable(skill);
+
+  return Object.entries(skillTable).reduce((acc, [key, value]) => (key <= level ? acc + value : acc), 0);
+}
+
+/**
+ * Calculates the total social skill experience for a given profile.
+ * @param {Object} profile The profile object containing skill data.
+ * @returns {number} The total social skill experience.
+ */
+function getSocialSkillExperience(profile) {
+  return Object.keys(profile.members).reduce((acc, member) => {
+    return acc + (profile.members[member]?.player_data?.experience?.SKILL_SOCIAL || 0);
+  }, 0);
+}
+
+module.exports = {
+  getSkillAverage,
+  getLevelByXp,
+  getXpTable,
+  getSkillLevelCaps,
+  getSkillExperience,
+  getSocialSkillExperience
 };

API/constants/skills.js

@@ -32,7 +32,7 @@ module.exports = (profile) => {
           forgeItem.timeStarted = item.startTime;
           forgeItem.timeFinished = timeFinished;
           forgeItem.timeFinishedText =
-            timeFinished < Date.now() ? "Finished" : `ending ${moment(timeFinished).fromNow()}`;
+            timeFinished < Date.now() ? "(FINISHED)" : ` (${moment(timeFinished).fromNow()})`;
         } else {
           console.error(item);
           forgeItem.name = "Unknown Item";
@@ -62,7 +62,7 @@ module.exports = (profile) => {
         }
       },
       level: calcSkill("hotm", profile?.mining_core?.experience || 0),
-      ability: titleCase(profile?.mining_core?.selected_pickaxe_ability || "none", true),
+      ability: miningConst.hotm.perks[profile?.mining_core?.selected_pickaxe_ability]?.name || "None",
       forge: forgeItems
     };
   } catch (error) {

API/stats/hotm.js

@@ -1,31 +1,20 @@
-const calcSkill = require("../constants/skills.js");
+const { getSkillLevelCaps, getSocialSkillExperience, getLevelByXp } = require("../constants/skills.js");
 
-module.exports = function getSkills(profile) {
-  const skill_experience = {
-    farming: profile?.player_data?.experience?.SKILL_FARMING || 0,
-    mining: profile?.player_data?.experience?.SKILL_MINING || 0,
-    combat: profile?.player_data?.experience?.SKILL_COMBAT || 0,
-    foraging: profile?.player_data?.experience?.SKILL_FORAGING || 0,
-    fishing: profile?.player_data?.experience?.SKILL_FISHING || 0,
-    enchanting: profile?.player_data?.experience?.SKILL_ENCHANTING || 0,
-    alchemy: profile?.player_data?.experience?.SKILL_ALCHEMY || 0,
-    carpentry: profile?.player_data?.experience?.SKILL_CARPENTRY || 0,
-    runecrafting: profile?.player_data?.experience?.SKILL_RUNECRAFTING || 0,
-    social: profile?.player_data?.experience?.SKILL_SOCIAL || 0,
-    taming: profile?.player_data?.experience?.SKILL_TAMING || 0
-  };
+module.exports = function getSkills(profile, profileData) {
+  const skillLevelCaps = getSkillLevelCaps(profile);
+  const totalSocialXp = getSocialSkillExperience(profileData);
 
-  return {
-    farming: calcSkill("farming", skill_experience["farming"]),
-    mining: calcSkill("mining", skill_experience["mining"]),
-    combat: calcSkill("combat", skill_experience["combat"]),
-    foraging: calcSkill("foraging", skill_experience["foraging"]),
-    fishing: calcSkill("fishing", skill_experience["fishing"]),
-    enchanting: calcSkill("enchanting", skill_experience["enchanting"]),
-    alchemy: calcSkill("alchemy", skill_experience["alchemy"]),
-    carpentry: calcSkill("carpentry", skill_experience["carpentry"]),
-    runecrafting: calcSkill("runecrafting", skill_experience["runecrafting"]),
-    social: calcSkill("social", skill_experience["social"]),
-    taming: calcSkill("taming", skill_experience["taming"])
-  };
+  const skills = {};
+  for (const skill in profile.player_data?.experience || {}) {
+    if (skill === "SKILL_DUNGEONEERING") {
+      continue;
+    }
+
+    const xp = skill === "SKILL_SOCIAL" ? totalSocialXp : profile.player_data?.experience[skill];
+    const type = skill.split("_").at(1).toLowerCase();
+
+    skills[type] = getLevelByXp(xp, { type: type, cap: skillLevelCaps[type] });
+  }
+
+  return skills;
 };

API/stats/skills.js

@@ -6,7 +6,7 @@ const getSlayer = require("../stats/slayer.js");
 
 module.exports = (profile) => {
   const { skills_levels, skills_experience } = formatLilySkills(getSkills(profile));
-  const { catacombs_experience, catacombs, master_mode } = formatLilyDungeons(getDungeons(profile));
+  const { catacombs_experience, catacombs, master_mode } = formatLilyDungeons(getDungeons(profile) ?? {});
   const { slayer_experience } = formatLilySlayer(getSlayer(profile));
 
   const lily = getWeightRaw(

API/stats/weight.js

@@ -107,7 +107,7 @@
     "unverifiedRole": "UNVERIFIED_ROLE_ID",
     "removeVerificationRole": true,
     "guildMemberRole": "GUILD_MEMBER_ROLE_ID",
-    "autoUpdater": true,
+    "autoUpdater": false,
     "autoUpdaterInterval": 24,
     "name": "{username}",
     "levelRoles": [

config.example.json

@@ -279,6 +279,15 @@ function getTimestamp(unixTimestamp = Date.now()) {
   });
 }
 
+function splitMessage(message, amount) {
+  const messages = [];
+  for (let i = 0; i < message.length; i += amount) {
+    messages.push(message.slice(i, i + amount));
+  }
+
+  return messages;
+}
+
 module.exports = {
   replaceAllRanks,
   addNotation,
@@ -295,5 +304,6 @@ module.exports = {
   formatUsername,
   formatNumber,
   replaceVariables,
-  getTimestamp
+  getTimestamp,
+  splitMessage
 };