hypixel-api-reborn 11.3.4 → 12.0.0-0

package/src/structures/MiniGames/MegaWalls.ts

@@ -0,0 +1,197 @@
+import divide from '../../utils/divide';
+
+class MegaWallsModeStats {
+  kills: number;
+  assists: number;
+  deaths: number;
+  KDR: number;
+  wins: number;
+  losses: number;
+  WLR: number;
+  finalKills: number;
+  finalAssists: number;
+  finalDeaths: number;
+  FKDR: number;
+  playedGames: number;
+  witherDamage: number;
+  defenderKills: number;
+  walked: number;
+  blocksPlaced: number;
+  blocksBroken: number;
+  meleeKills: number;
+  damageDealt: number;
+  constructor(data: Record<string, any>, mode: string, kit?: string) {
+    if (kit) kit = `${kit}_`;
+    this.kills = data[`${kit}kills_${mode}`] || 0;
+    this.assists = data[`${kit}assists_${mode}`] || 0;
+    this.deaths = data[`${kit}deaths_${mode}`] || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.wins = data[`${kit}wins_${mode}`] || 0;
+    this.losses = data[`${kit}losses_${mode}`] || 0;
+    this.WLR = divide(this.wins, this.losses);
+    this.finalKills = data[`${kit}final_kills_${mode}`] || 0;
+    this.finalAssists = data[`${kit}final_assists_${mode}`] || 0;
+    this.finalDeaths = data[`${kit}final_deaths_${mode}`] || 0;
+    this.FKDR = divide(this.finalKills, this.finalDeaths);
+    this.playedGames = data[`${kit}games_played_${mode}`] || 0;
+    this.witherDamage = data[`${kit}wither_damage_${mode}`] || 0;
+    this.defenderKills = data[`${kit}defender_kills_${mode}`] || 0;
+    this.walked = data[`${kit}meters_walked_${mode}`] || 0;
+    this.blocksPlaced = data[`${kit}blocks_placed_${mode}`] || 0;
+    this.blocksBroken = data[`${kit}blocks_broken_${mode}`] || 0;
+    this.meleeKills = data[`${kit}kills_melee_${mode}`] || 0;
+    this.damageDealt = data[`${kit}damage_dealt_${mode}`] || 0;
+  }
+}
+
+class MegaWallsKitStats {
+  kills: number;
+  assists: number;
+  deaths: number;
+  KDR: number;
+  wins: number;
+  losses: number;
+  WLR: number;
+  finalKills: number;
+  finalAssists: number;
+  finalDeaths: number;
+  FKDR: number;
+  playedGames: number;
+  witherDamage: number;
+  defenderKills: number;
+  walked: number;
+  blocksPlaced: number;
+  blocksBroken: number;
+  meleeKills: number;
+  damageDealt: number;
+  faceOff: MegaWallsModeStats;
+  casualBrawl: MegaWallsModeStats;
+  constructor(data: Record<string, any>, kit: string) {
+    this.kills = data[`${kit}_kills`] || 0;
+    this.assists = data[`${kit}_assists`] || 0;
+    this.deaths = data[`${kit}_deaths`] || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.wins = data[`${kit}_wins`] || 0;
+    this.losses = data[`${kit}_losses`] || 0;
+    this.WLR = divide(this.wins, this.losses);
+    this.finalKills = data[`${kit}_final_kills`] || 0;
+    this.finalAssists = data[`${kit}_final_assists`] || 0;
+    this.finalDeaths = data[`${kit}_final_deaths`] || 0;
+    this.FKDR = divide(this.finalKills, this.finalDeaths);
+    this.playedGames = data[`${kit}_games_played`] || 0;
+    this.witherDamage = data[`${kit}_wither_damage`] || 0;
+    this.defenderKills = data[`${kit}_defender_kills`] || 0;
+    this.walked = data[`${kit}_meters_walked`] || 0;
+    this.blocksPlaced = data[`${kit}_blocks_placed`] || 0;
+    this.blocksBroken = data[`${kit}_blocks_broken`] || 0;
+    this.meleeKills = data[`${kit}_kills_melee`] || 0;
+    this.damageDealt = data[`${kit}_damage_dealt`] || 0;
+    this.faceOff = new MegaWallsModeStats(data, 'face_off', kit);
+    this.casualBrawl = new MegaWallsModeStats(data, 'gvg', kit);
+  }
+}
+
+class MegaWalls {
+  selectedClass: string | null;
+  coins: number;
+  kills: number;
+  assists: number;
+  deaths: number;
+  KDR: number;
+  wins: number;
+  losses: number;
+  WLR: number;
+  finalKills: number;
+  finalAssists: number;
+  finalDeaths: number;
+  FKDR: number;
+  playedGames: number;
+  witherDamage: number;
+  defenderKills: number;
+  walked: number;
+  blocksPlaced: number;
+  blocksBroken: number;
+  meleeKills: number;
+  damageDealt: number;
+  faceOff: MegaWallsModeStats;
+  casualBrawl: MegaWallsModeStats;
+  cow: MegaWallsKitStats;
+  hunter: MegaWallsKitStats;
+  shark: MegaWallsKitStats;
+  arcanist: MegaWallsKitStats;
+  deadlord: MegaWallsKitStats;
+  golem: MegaWallsKitStats;
+  herobrine: MegaWallsKitStats;
+  pigman: MegaWallsKitStats;
+  zombie: MegaWallsKitStats;
+  blaze: MegaWallsKitStats;
+  enderman: MegaWallsKitStats;
+  shaman: MegaWallsKitStats;
+  squid: MegaWallsKitStats;
+  creeper: MegaWallsKitStats;
+  pirate: MegaWallsKitStats;
+  sheep: MegaWallsKitStats;
+  skeleton: MegaWallsKitStats;
+  spider: MegaWallsKitStats;
+  werewolf: MegaWallsKitStats;
+  angel: MegaWallsKitStats;
+  assassin: MegaWallsKitStats;
+  automaton: MegaWallsKitStats;
+  moleman: MegaWallsKitStats;
+  phoenix: MegaWallsKitStats;
+  renegade: MegaWallsKitStats;
+  snowman: MegaWallsKitStats;
+  constructor(data: Record<string, any>) {
+    this.selectedClass = data.chosen_class || null;
+    this.coins = data.coins || 0;
+    this.kills = data.kills || 0;
+    this.assists = data.assists || 0;
+    this.deaths = data.deaths || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.wins = data.wins || 0;
+    this.losses = data.losses || 0;
+    this.WLR = divide(this.wins, this.losses);
+    this.finalKills = (data.final_kills || 0) + (data.finalkills || 0);
+    this.finalAssists = (data.final_assists || 0) + (data.finalassists || 0);
+    this.finalDeaths = (data.final_deaths || 0) + (data.finalDeaths || 0);
+    this.FKDR = divide(this.finalKills, this.finalDeaths);
+    this.playedGames = data.games_played || 0;
+    this.witherDamage = (data.wither_damage || 0) + (data.witherDamager || 0);
+    this.defenderKills = data.defender_kills || 0;
+    this.walked = data.meters_walked || 0;
+    this.blocksPlaced = data.blocks_placed || 0;
+    this.blocksBroken = data.blocks_broken || 0;
+    this.meleeKills = data.kills_melee || 0;
+    this.damageDealt = data.damage_dealt || 0;
+    this.faceOff = new MegaWallsModeStats(data, 'face_off');
+    this.casualBrawl = new MegaWallsModeStats(data, 'gvg');
+    this.cow = new MegaWallsKitStats(data, 'cow');
+    this.hunter = new MegaWallsKitStats(data, 'hunter');
+    this.shark = new MegaWallsKitStats(data, 'shark');
+    this.arcanist = new MegaWallsKitStats(data, 'arcanist');
+    this.deadlord = new MegaWallsKitStats(data, 'deadlord');
+    this.golem = new MegaWallsKitStats(data, 'golem');
+    this.herobrine = new MegaWallsKitStats(data, 'herobrine');
+    this.pigman = new MegaWallsKitStats(data, 'pigman');
+    this.zombie = new MegaWallsKitStats(data, 'zombie');
+    this.blaze = new MegaWallsKitStats(data, 'blaze');
+    this.enderman = new MegaWallsKitStats(data, 'enderman');
+    this.shaman = new MegaWallsKitStats(data, 'shaman');
+    this.squid = new MegaWallsKitStats(data, 'squid');
+    this.creeper = new MegaWallsKitStats(data, 'creeper');
+    this.pirate = new MegaWallsKitStats(data, 'pirate');
+    this.sheep = new MegaWallsKitStats(data, 'sheep');
+    this.skeleton = new MegaWallsKitStats(data, 'skeleton');
+    this.spider = new MegaWallsKitStats(data, 'spider');
+    this.werewolf = new MegaWallsKitStats(data, 'werewolf');
+    this.angel = new MegaWallsKitStats(data, 'angel');
+    this.assassin = new MegaWallsKitStats(data, 'assassin');
+    this.automaton = new MegaWallsKitStats(data, 'automaton');
+    this.moleman = new MegaWallsKitStats(data, 'moleman');
+    this.phoenix = new MegaWallsKitStats(data, 'phoenix');
+    this.renegade = new MegaWallsKitStats(data, 'renegade');
+    this.snowman = new MegaWallsKitStats(data, 'snowman');
+  }
+}
+
+export default MegaWalls;

package/src/structures/MiniGames/MurderMystery.ts

@@ -0,0 +1,87 @@
+import divide from '../../utils/divide';
+
+class MurderMysteryModeStats {
+  goldPickedUp: number;
+  kills: number;
+  thrownKnifeKills: number;
+  knifeKills: number;
+  bowKills: number;
+  trapKills: number;
+  deaths: number;
+  suicides: number;
+  KDR: number;
+  wins: number;
+  winsAsDetective: number;
+  winsAsMurderer: number;
+  winsAsHero: number;
+  playedGames: number;
+  constructor(data: Record<string, any>, gamemode: string) {
+    this.goldPickedUp = data[`coins_pickedup_${gamemode}`] || 0;
+    this.kills = data[`kills_${gamemode}`] || 0;
+    this.thrownKnifeKills = data[`thrown_knife_kills_${gamemode}`] || 0;
+    this.knifeKills = data[`knife_kills_${gamemode}`] || 0;
+    this.bowKills = data[`bow_kills_${gamemode}`] || 0;
+    this.trapKills = data[`trap_kills_${gamemode}`] || 0;
+    this.deaths = data[`deaths_${gamemode}`] || 0;
+    this.suicides = data[`suicides_${gamemode}`] || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.wins = data[`wins_${gamemode}`] || 0;
+    this.winsAsDetective = data[`detective_wins_${gamemode}`] || 0;
+    this.winsAsMurderer = data[`murderer_wins_${gamemode}`] || 0;
+    this.winsAsHero = data[`was_hero_${gamemode}`] || 0;
+    this.playedGames = data[`games_${gamemode}`] || 0;
+  }
+}
+
+class MurderMystery {
+  tokens: number;
+  goldPickedUp: number;
+  playedGames: number;
+  kills: number;
+  thrownKnifeKills: number;
+  knifeKills: number;
+  trapKills: number;
+  bowKills: number;
+  killsAsMurderer: number;
+  deaths: number;
+  KDR: number;
+  winsAsMurderer: number;
+  winsAsDetective: number;
+  winsAsHero: number;
+  fastestWinAsMurderer: number;
+  fastestWinAsDetective: number;
+  totalTimeSurvived: number;
+  wins: number;
+  suicides: number;
+  classic: MurderMysteryModeStats;
+  assassins: MurderMysteryModeStats;
+  doubleUp: MurderMysteryModeStats;
+  infection: MurderMysteryModeStats;
+  constructor(data: Record<string, any>) {
+    this.tokens = data.coins || 0;
+    this.goldPickedUp = data.coins_pickedup || 0;
+    this.playedGames = data.games || 0;
+    this.kills = data.kills || 0;
+    this.thrownKnifeKills = data.thrown_knife_kills || 0;
+    this.knifeKills = data.knife_kills || 0;
+    this.trapKills = data.trap_kills || 0;
+    this.bowKills = data.bow_kills || 0;
+    this.killsAsMurderer = data.kills_as_murderer || 0;
+    this.deaths = data.deaths || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.winsAsMurderer = data.murderer_wins || 0;
+    this.winsAsDetective = data.detective_wins || 0;
+    this.winsAsHero = data.was_hero || 0;
+    this.fastestWinAsMurderer = data.quickest_murderer_win_time_seconds || 0;
+    this.fastestWinAsDetective = data.quickest_detective_win_time_seconds || 0;
+    this.totalTimeSurvived = data.total_time_survived_seconds || 0;
+    this.wins = data.wins || 0;
+    this.suicides = data.suicides || 0;
+    this.classic = new MurderMysteryModeStats(data, 'MURDER_CLASSIC');
+    this.assassins = new MurderMysteryModeStats(data, 'MURDER_ASSASSINS');
+    this.doubleUp = new MurderMysteryModeStats(data, 'MURDER_DOUBLE_UP');
+    this.infection = new MurderMysteryModeStats(data, 'MURDER_INFECTION');
+  }
+}
+
+export default MurderMystery;

package/src/structures/MiniGames/Paintball.ts

@@ -0,0 +1,38 @@
+import divide from '../../utils/divide';
+
+class Paintball {
+  coins: number;
+  kills: number;
+  deaths: number;
+  KDR: number;
+  wins: number;
+  shotsFired: number;
+  killstreaks: number;
+  forceFieldTime: number;
+  hat: string;
+  adrenaline: number;
+  endurance: number;
+  fortune: number;
+  godfather: number;
+  superluck: number;
+  transfusion: number;
+  constructor(data: Record<string, any>) {
+    this.coins = data.coins || 0;
+    this.kills = data.kills || 0;
+    this.deaths = data.deaths || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.wins = data.wins || 0;
+    this.shotsFired = data.shots_fired || 0;
+    this.killstreaks = data.killstreaks || 0;
+    this.forceFieldTime = data.forcefieldTime || 0;
+    this.hat = data.hat || 'None';
+    this.adrenaline = data.adrenaline || 0;
+    this.endurance = data.endurance || 0;
+    this.fortune = data.fortune || 0;
+    this.godfather = data.godfather || 0;
+    this.superluck = data.superluck || 0;
+    this.transfusion = data.transfusion || 0;
+  }
+}
+
+export default Paintball;

package/src/structures/MiniGames/Pit.ts

@@ -0,0 +1,139 @@
+import Constants from '../../utils/Constants';
+import PitInventoryItem from './PitInventoryItem';
+import divide from '../../utils/divide';
+import { decode } from '../../utils/SkyblockUtils';
+
+export interface PitArmor {
+  helmet: PitInventoryItem | null;
+  chestplate: PitInventoryItem | null;
+  leggings: PitInventoryItem | null;
+  boots: PitInventoryItem | null;
+}
+
+class Pit {
+  prestige: number;
+  xp: number;
+  level: number;
+  kills: number;
+  deaths: number;
+  KDR: number;
+  assists: number;
+  maxKillStreak: number;
+  playtime: number;
+  joins: number;
+  damageReceived: number;
+  damageDealt: number;
+  damageRatio: number;
+  meleeDamageReceived: number;
+  meleeDamageDealt: number;
+  swordHits: number;
+  leftClicks: number;
+  meleeAccuracy: number;
+  meleeDamageRatio: number;
+  bowDamageReceived: number;
+  bowDamageDealt: number;
+  arrowsHit: number;
+  arrowsFired: number;
+  bowAccuracy: number;
+  bowDamageRatio: number;
+  goldenHeadsEaten: number;
+  getInventory: () => Promise<PitInventoryItem[]>;
+  getEnterChest: () => Promise<PitInventoryItem[]>;
+  getArmor: () => Promise<PitArmor>;
+  constructor(data: Record<string, any>) {
+    this.prestige = data.profile?.prestiges?.[data.profile?.prestiges?.length - 1].index || 0;
+    this.xp = data.profile?.xp || 0;
+    this.level =
+      this.calcLevel(
+        this.prestige,
+        0 < this.prestige ? this.xp - Constants.pit.Prestiges[this.prestige - 1].SumXp : this.xp
+      ) ?? 0;
+    this.kills = data.pit_stats_ptl?.kills || 0;
+    this.deaths = data.pit_stats_ptl?.deaths || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.assists = data.pit_stats_ptl?.assists || 0;
+    this.maxKillStreak = data.pit_stats_ptl?.max_streak || 0;
+    this.playtime = (data.pit_stats_ptl?.playtime_minutes || 0) * 60;
+    this.joins = data.pit_stats_ptl?.joins || 0;
+    this.damageReceived = data.pit_stats_ptl?.damage_received || 0;
+    this.damageDealt = data.pit_stats_ptl?.damage_dealt || 0;
+    this.damageRatio = divide(this.damageDealt, this.damageReceived);
+    this.meleeDamageReceived = data.pit_stats_ptl?.melee_damage_received || 0;
+    this.meleeDamageDealt = data.pit_stats_ptl?.melee_damage_dealt || 0;
+    this.swordHits = data.pit_stats_ptl?.sword_hits || 0;
+    this.leftClicks = data.pit_stats_ptl?.left_clicks || 0;
+    this.meleeAccuracy = divide(this.swordHits, this.leftClicks);
+    this.meleeDamageRatio = divide(this.meleeDamageDealt, this.meleeDamageReceived);
+    this.bowDamageReceived = data.pit_stats_ptl?.bow_damage_received || 0;
+    this.bowDamageDealt = data.pit_stats_ptl?.bow_damage_dealt || 0;
+    this.arrowsHit = data.pit_stats_ptl?.arrow_hits || 0;
+    this.arrowsFired = data.pit_stats_ptl?.arrows_fired || 0;
+    this.bowAccuracy = divide(this.arrowsHit, this.arrowsFired);
+    this.bowDamageRatio = divide(this.bowDamageDealt, this.bowDamageReceived);
+    this.goldenHeadsEaten = data.pit_stats_ptl?.ghead_eaten || 0;
+    this.getInventory = async (): Promise<PitInventoryItem[]> => {
+      let inventory = data.profile.inv_contents;
+      if (!inventory) return [];
+      try {
+        inventory = await decode(inventory.data);
+        const edited = [];
+        for (let i = 1; i < inventory.length; i++) {
+          if (!inventory[i].id) {
+            continue;
+          }
+          edited.push(new PitInventoryItem(inventory[i]));
+        }
+        return edited;
+      } catch {
+        return [];
+      }
+    };
+    this.getEnterChest = async () => {
+      let chest = data.profile.inv_enderchest;
+      if (!chest) return [];
+      try {
+        chest = await decode(chest.data);
+        const edited = [];
+        for (let i = 1; i < chest.length; i++) {
+          if (!chest[i].id) {
+            continue;
+          }
+          edited.push(new PitInventoryItem(chest[i]));
+        }
+        return edited;
+      } catch {
+        return [];
+      }
+    };
+    this.getArmor = async () => {
+      const base64 = data.profile.inv_armor;
+      const decoded = await decode(base64.data);
+      const armor = {
+        helmet: decoded[3].id ? new PitInventoryItem(decoded[3]) : null,
+        chestplate: decoded[2].id ? new PitInventoryItem(decoded[2]) : null,
+        leggings: decoded[1].id ? new PitInventoryItem(decoded[1]) : null,
+        boots: decoded[0].id ? new PitInventoryItem(decoded[0]) : null
+      };
+      return armor;
+    };
+  }
+  // Credit https://github.com/PitPanda/PitPandaProduction/blob/b1971f56ea1aa8c829b722cbb33247c96591c0cb/structures/Pit.js
+  private calcLevel(prestige: number, xp: number): number {
+    const multiplier = Constants.pit.Prestiges[prestige].Multiplier;
+    let level = 0;
+    while (0 < xp && 120 > level) {
+      const levelXp = Constants.pit.Levels[Math.floor(level / 10)].Xp * multiplier;
+      if (xp >= levelXp * 10) {
+        xp -= levelXp * 10;
+        level += 10;
+      } else {
+        const gain = Math.floor(xp / levelXp);
+        level += gain;
+        xp = 0;
+      }
+    }
+    return level;
+  }
+}
+
+export default Pit;

package/src/structures/MiniGames/PitInventoryItem.ts

@@ -0,0 +1,18 @@
+class PitInventoryItem {
+  itemId: number;
+  count: number;
+  name: string | null;
+  lore: string | null;
+  loreArray: string[];
+  extraAttributes: object | null;
+  constructor(data: Record<string, any>) {
+    this.itemId = data.id || 0;
+    this.count = data.Count || 0;
+    this.name = data?.tag?.display?.Name ? data.tag.display.Name.toString().replace(/§([1-9]|[a-f])|§/gm, '') : null;
+    this.lore = data?.tag?.display?.Lore ? data.tag.display.Lore.join('\n') : null;
+    this.loreArray = data?.tag?.display?.Lore ?? [];
+    this.extraAttributes = data?.tag?.ExtraAttributes ?? null;
+  }
+}
+
+export default PitInventoryItem;

package/src/structures/MiniGames/Quakecraft.ts

@@ -0,0 +1,70 @@
+import divide from '../../utils/divide';
+
+class QuakecraftMode {
+  wins: number;
+  kills: number;
+  deaths: number;
+  KDR: number;
+  killstreaks: number;
+  distanceTravelled: number;
+  shotsFired: number;
+  headshots: number;
+  constructor(data: Record<string, any>, gamemode?: string) {
+    if (gamemode) gamemode = `_${gamemode}`;
+    this.wins = data[`wins${gamemode}`] || 0;
+    this.kills = data[`kills${gamemode}`] || 0;
+    this.deaths = data[`deaths${gamemode}`] || 0;
+    this.KDR = divide(this.kills, this.deaths);
+    this.killstreaks = data[`killstreaks${gamemode}`] || 0;
+    this.distanceTravelled = data[`distance_travelled${gamemode}`] || 0;
+    this.shotsFired = data[`shots_fired${gamemode}`] || 0;
+    this.headshots = data[`headshots${gamemode}`] || 0;
+  }
+}
+
+class Quakecraft {
+  coins: number;
+  solo: QuakecraftMode;
+  teams: QuakecraftMode;
+  wins: number;
+  kills: number;
+  deaths: number;
+  KDR: number;
+  killstreaks: number;
+  distanceTravelled: number;
+  shotsFired: number;
+  headshots: number;
+  instantRespawn: boolean;
+  killPrefixColor: string;
+  showPrefix: boolean;
+  killSound: string;
+  barrel: string;
+  case: string;
+  muzzle: string;
+  sight: string;
+  trigger: string;
+  constructor(data: Record<string, any>) {
+    this.coins = data.coins || 0;
+    this.solo = new QuakecraftMode(data);
+    this.teams = new QuakecraftMode(data, 'teams');
+    this.wins = this.solo.wins + this.teams.wins;
+    this.kills = this.solo.kills + this.teams.kills;
+    this.deaths = this.solo.deaths + this.teams.deaths;
+    this.KDR = divide(this.kills, this.deaths);
+    this.killstreaks = this.solo.killstreaks + this.teams.killstreaks;
+    this.distanceTravelled = this.solo.distanceTravelled + this.teams.distanceTravelled;
+    this.shotsFired = this.solo.shotsFired + this.teams.shotsFired;
+    this.headshots = this.solo.headshots + this.teams.headshots;
+    this.instantRespawn = data.instantRespawn || false;
+    this.killPrefixColor = data.selectedKillPrefix || '';
+    this.showPrefix = data.showKillPrefix || false;
+    this.killSound = data.killsound || '';
+    this.barrel = data.barrel || '';
+    this.case = data.case || '';
+    this.muzzle = data.muzzle || '';
+    this.sight = data.sight || '';
+    this.trigger = data.trigger || '';
+  }
+}
+
+export default Quakecraft;