hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/structures/MiniGames/ArenaBrawl.js

@@ -0,0 +1,48 @@
+import divide from '../../utils/divide';
+export class ArenaBrawlMode {
+    damage;
+    kills;
+    deaths;
+    KDR;
+    healed;
+    wins;
+    losses;
+    WLR;
+    games;
+    winstreak;
+    constructor(data, mode) {
+        this.damage = data?.[`damage_${mode}`] || 0;
+        this.kills = data?.[`kills_${mode}`] || 0;
+        this.deaths = data?.[`deaths_${mode}`] || 0;
+        this.KDR = divide(this.kills, this.deaths);
+        this.healed = data?.[`healed_${mode}`] || 0;
+        this.wins = data?.[`wins_${mode}`] || 0;
+        this.losses = data?.[`losses_${mode}`] || 0;
+        this.WLR = divide(this.wins, this.losses);
+        this.games = data?.[`games_${mode}`] || 0;
+        this.winstreak = data?.[`win_streaks_${mode}`] || 0;
+    }
+}
+class ArenaBrawl {
+    coins;
+    coinsSpent;
+    wins;
+    keys;
+    chests;
+    rune;
+    '1v1';
+    '2v2';
+    '4v4';
+    constructor(data) {
+        this.coins = data?.coins || 0;
+        this.coinsSpent = data?.coins_spent || 0;
+        this.wins = data?.wins || 0;
+        this.keys = data?.keys || 0;
+        this.chests = data?.magical_chest || 0;
+        this.rune = data?.active_rune || '';
+        this['1v1'] = new ArenaBrawlMode(data, '1v1');
+        this['2v2'] = new ArenaBrawlMode(data, '2v2');
+        this['4v4'] = new ArenaBrawlMode(data, '4v4');
+    }
+}
+export default ArenaBrawl;

package/dist/src/structures/MiniGames/ArenaBrawl.test.js

@@ -0,0 +1,120 @@
+import ArenaBrawl from './ArenaBrawl';
+import { expect, expectTypeOf, test } from 'vitest';
+test('ArenaBrawl', () => {
+    const data = new ArenaBrawl({ stats: 'meow' });
+    expect(data).toBeInstanceOf(ArenaBrawl);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.coins).toBeDefined();
+    expect(data.coins).greaterThanOrEqual(0);
+    expectTypeOf(data.coins).toEqualTypeOf();
+    expect(data.coinsSpent).toBeDefined();
+    expect(data.coinsSpent).greaterThanOrEqual(0);
+    expectTypeOf(data.coinsSpent).toEqualTypeOf();
+    expect(data.wins).toBeDefined();
+    expect(data.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.wins).toEqualTypeOf();
+    expect(data.keys).toBeDefined();
+    expect(data.keys).greaterThanOrEqual(0);
+    expectTypeOf(data.keys).toEqualTypeOf();
+    expect(data.chests).toBeDefined();
+    expect(data.chests).greaterThanOrEqual(0);
+    expectTypeOf(data.chests).toEqualTypeOf();
+    expect(data.rune).toBeDefined();
+    expectTypeOf(data.rune).toEqualTypeOf();
+    expect(data['1v1']).toBeDefined();
+    expectTypeOf(data['1v1']).toEqualTypeOf();
+    expect(data['1v1'].damage).toBeDefined();
+    expect(data['1v1'].damage).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].damage).toEqualTypeOf();
+    expect(data['1v1'].kills).toBeDefined();
+    expect(data['1v1'].kills).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].kills).toEqualTypeOf();
+    expect(data['1v1'].deaths).toBeDefined();
+    expect(data['1v1'].deaths).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].deaths).toEqualTypeOf();
+    expect(data['1v1'].KDR).toBeDefined();
+    expect(data['1v1'].KDR).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].KDR).toEqualTypeOf();
+    expect(data['1v1'].healed).toBeDefined();
+    expect(data['1v1'].healed).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].healed).toEqualTypeOf();
+    expect(data['1v1'].wins).toBeDefined();
+    expect(data['1v1'].wins).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].wins).toEqualTypeOf();
+    expect(data['1v1'].losses).toBeDefined();
+    expect(data['1v1'].losses).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].losses).toEqualTypeOf();
+    expect(data['1v1'].WLR).toBeDefined();
+    expect(data['1v1'].WLR).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].WLR).toEqualTypeOf();
+    expect(data['1v1'].games).toBeDefined();
+    expect(data['1v1'].games).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].games).toEqualTypeOf();
+    expect(data['1v1'].winstreak).toBeDefined();
+    expect(data['1v1'].winstreak).greaterThanOrEqual(0);
+    expectTypeOf(data['1v1'].winstreak).toEqualTypeOf();
+    expect(data['2v2']).toBeDefined();
+    expectTypeOf(data['2v2']).toEqualTypeOf();
+    expect(data['2v2'].damage).toBeDefined();
+    expect(data['2v2'].damage).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].damage).toEqualTypeOf();
+    expect(data['2v2'].kills).toBeDefined();
+    expect(data['2v2'].kills).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].kills).toEqualTypeOf();
+    expect(data['2v2'].deaths).toBeDefined();
+    expect(data['2v2'].deaths).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].deaths).toEqualTypeOf();
+    expect(data['2v2'].KDR).toBeDefined();
+    expect(data['2v2'].KDR).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].KDR).toEqualTypeOf();
+    expect(data['2v2'].healed).toBeDefined();
+    expect(data['2v2'].healed).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].healed).toEqualTypeOf();
+    expect(data['2v2'].wins).toBeDefined();
+    expect(data['2v2'].wins).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].wins).toEqualTypeOf();
+    expect(data['2v2'].losses).toBeDefined();
+    expect(data['2v2'].losses).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].losses).toEqualTypeOf();
+    expect(data['2v2'].WLR).toBeDefined();
+    expect(data['2v2'].WLR).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].WLR).toEqualTypeOf();
+    expect(data['2v2'].games).toBeDefined();
+    expect(data['2v2'].games).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].games).toEqualTypeOf();
+    expect(data['2v2'].winstreak).toBeDefined();
+    expect(data['2v2'].winstreak).greaterThanOrEqual(0);
+    expectTypeOf(data['2v2'].winstreak).toEqualTypeOf();
+    expect(data['4v4']).toBeDefined();
+    expectTypeOf(data['4v4']).toEqualTypeOf();
+    expect(data['4v4'].damage).toBeDefined();
+    expect(data['4v4'].damage).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].damage).toEqualTypeOf();
+    expect(data['4v4'].kills).toBeDefined();
+    expect(data['4v4'].kills).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].kills).toEqualTypeOf();
+    expect(data['4v4'].deaths).toBeDefined();
+    expect(data['4v4'].deaths).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].deaths).toEqualTypeOf();
+    expect(data['4v4'].KDR).toBeDefined();
+    expect(data['4v4'].KDR).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].KDR).toEqualTypeOf();
+    expect(data['4v4'].healed).toBeDefined();
+    expect(data['4v4'].healed).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].healed).toEqualTypeOf();
+    expect(data['4v4'].wins).toBeDefined();
+    expect(data['4v4'].wins).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].wins).toEqualTypeOf();
+    expect(data['4v4'].losses).toBeDefined();
+    expect(data['4v4'].losses).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].losses).toEqualTypeOf();
+    expect(data['4v4'].WLR).toBeDefined();
+    expect(data['4v4'].WLR).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].WLR).toEqualTypeOf();
+    expect(data['4v4'].games).toBeDefined();
+    expect(data['4v4'].games).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].games).toEqualTypeOf();
+    expect(data['4v4'].winstreak).toBeDefined();
+    expect(data['4v4'].winstreak).greaterThanOrEqual(0);
+    expectTypeOf(data['4v4'].winstreak).toEqualTypeOf();
+});

package/dist/src/structures/MiniGames/BedWars.js

@@ -0,0 +1,299 @@
+import divide from '../../utils/divide';
+export class BedwarsMode {
+    winstreak;
+    playedGames;
+    kills;
+    deaths;
+    wins;
+    losses;
+    finalKills;
+    finalDeaths;
+    beds;
+    KDR;
+    WLR;
+    FKDR;
+    constructor(data, mode) {
+        this.winstreak = data?.[`${mode}_winstreak`] || 0;
+        this.playedGames = data?.[`${mode}_games_played_bedwars`] || 0;
+        this.kills = data?.[`${mode}_kills_bedwars`] || 0;
+        this.deaths = data?.[`${mode}_deaths_bedwars`] || 0;
+        this.wins = data?.[`${mode}_wins_bedwars`] || 0;
+        this.losses = data?.[`${mode}_losses_bedwars`] || 0;
+        this.finalKills = data?.[`${mode}_final_kills_bedwars`] || 0;
+        this.finalDeaths = data?.[`${mode}_final_deaths_bedwars`] || 0;
+        this.beds = {
+            broken: data?.[`${mode}_beds_broken_bedwars`] || 0,
+            lost: data?.[`${mode}_beds_lost_bedwars`] || 0,
+            BLRatio: divide(data?.[`${mode}_beds_broken_bedwars`], data?.[`${mode}_beds_lost_bedwars`])
+        };
+        this.KDR = divide(data?.[`${mode}_kills_bedwars`], data?.[`${mode}_deaths_bedwars`]);
+        this.WLR = divide(data?.[`${mode}_wins_bedwars`], data?.[`${mode}_losses_bedwars`]);
+        this.FKDR = divide(data?.[`${mode}_final_kills_bedwars`], data?.[`${mode}_final_deaths_bedwars`]);
+    }
+}
+export class BedwarsDreamMode {
+    doubles;
+    fours;
+    constructor(data, mode) {
+        this.doubles = new BedwarsMode(data, `eight_two_${mode}`);
+        this.fours = new BedwarsMode(data, `four_four_${mode}`);
+    }
+}
+export function getBedWarsPrestige(level) {
+    if (5000 <= level)
+        return 'Eternal';
+    return ([
+        'Stone',
+        'Iron',
+        'Gold',
+        'Diamond',
+        'Emerald',
+        'Sapphire',
+        'Ruby',
+        'Crystal',
+        'Opal',
+        'Amethyst',
+        'Rainbow',
+        'Iron Prime',
+        'Gold Prime',
+        'Diamond Prime',
+        'Emerald Prime',
+        'Sapphire Prime',
+        'Ruby Prime',
+        'Crystal Prime',
+        'Opal Prime',
+        'Amethyst Prime',
+        'Mirror',
+        'Light',
+        'Dawn',
+        'Dusk',
+        'Air',
+        'Wind',
+        'Nebula',
+        'Thunder',
+        'Earth',
+        'Water',
+        'Fire',
+        'Sunrise',
+        'Eclipse',
+        'Gamma',
+        'Majestic',
+        'Andesine',
+        'Marine',
+        'Element',
+        'Galaxy',
+        'Atomic',
+        'Sunset',
+        'Time',
+        'Winter',
+        'Obsidian',
+        'Spring',
+        'Ice',
+        'Summer',
+        'Spinel',
+        'Autumn',
+        'Mystic',
+        'Eternal'
+    ][Math.floor(level / 100)] || 'Eternal');
+}
+const EASY_LEVELS = 4;
+const EASY_LEVELS_XP = 7000;
+const XP_PER_PRESTIGE = 96 * 5000 + EASY_LEVELS_XP;
+const LEVELS_PER_PRESTIGE = 100;
+const HIGHEST_PRESTIGE = 10;
+function getLevelRespectingPrestige(level) {
+    if (level > HIGHEST_PRESTIGE * LEVELS_PER_PRESTIGE) {
+        return level - HIGHEST_PRESTIGE * LEVELS_PER_PRESTIGE;
+    }
+    return level % LEVELS_PER_PRESTIGE;
+}
+export function getExpForLevel(level) {
+    if (0 === level)
+        return 0;
+    switch (getLevelRespectingPrestige(level)) {
+        case 1:
+            return 500;
+        case 2:
+            return 1000;
+        case 3:
+            return 2000;
+        case 4:
+            return 3500;
+        default:
+            return 5000;
+    }
+}
+function getLevelForExp(exp) {
+    const prestiges = Math.floor(exp / XP_PER_PRESTIGE);
+    let level = prestiges * LEVELS_PER_PRESTIGE;
+    let expWithoutPrestiges = exp - prestiges * XP_PER_PRESTIGE;
+    for (let i = 1; i <= EASY_LEVELS; ++i) {
+        const expForEasyLevel = getExpForLevel(i);
+        if (expWithoutPrestiges < expForEasyLevel) {
+            break;
+        }
+        level++;
+        expWithoutPrestiges -= expForEasyLevel;
+    }
+    return level + Math.floor(expWithoutPrestiges / 5000);
+}
+function generateStatsForPractice(data) {
+    return {
+        selected: data?.practice?.selected || 'NONE',
+        bridging: {
+            blocksPlaced: data?.practice?.bridging?.blocks_placed ?? 0,
+            attempts: {
+                failed: data?.practice?.bridging?.failed_attempts ?? 0,
+                successful: data?.practice?.bridging?.successful_attempts ?? 0,
+                total: data?.practice?.bridging?.failed_attempts + data?.practice?.bridging?.successful_attempts
+            },
+            records: {
+                blocks30: {
+                    elevation: {
+                        none: {
+                            straight: data?.practice?.records?.['bridging_distance_30:elevation_NONE:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_30:elevation_NONE:angle_DIAGONAL:'] ?? 0
+                        },
+                        slight: {
+                            straight: data?.practice?.records?.['bridging_distance_30:elevation_SLIGHT:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_30:elevation_SLIGHT:angle_DIAGONAL:'] ?? 0
+                        },
+                        staircase: {
+                            straight: data?.practice?.records?.['bridging_distance_30:elevation_STAIRCASE:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_30:elevation_STAIRCASE:angle_DIAGONAL:'] ?? 0
+                        }
+                    }
+                },
+                blocks50: {
+                    elevation: {
+                        none: {
+                            straight: data?.practice?.records?.['bridging_distance_50:elevation_NONE:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_50:elevation_NONE:angle_DIAGONAL:'] ?? 0
+                        },
+                        slight: {
+                            straight: data?.practice?.records?.['bridging_distance_50:elevation_SLIGHT:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_50:elevation_SLIGHT:angle_DIAGONAL:'] ?? 0
+                        },
+                        staircase: {
+                            straight: data?.practice?.records?.['bridging_distance_50:elevation_STAIRCASE:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_50:elevation_STAIRCASE:angle_DIAGONAL:'] ?? 0
+                        }
+                    }
+                },
+                blocks100: {
+                    elevation: {
+                        none: {
+                            straight: data?.practice?.records?.['bridging_distance_100:elevation_NONE:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_100:elevation_NONE:angle_DIAGONAL:'] ?? 0
+                        },
+                        slight: {
+                            straight: data?.practice?.records?.['bridging_distance_100:elevation_SLIGHT:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_100:elevation_SLIGHT:angle_DIAGONAL:'] ?? 0
+                        },
+                        staircase: {
+                            straight: data?.practice?.records?.['bridging_distance_100:elevation_STAIRCASE:angle_STRAIGHT:'] ?? 0,
+                            diagonal: data?.practice?.records?.['bridging_distance_100:elevation_STAIRCASE:angle_DIAGONAL:'] ?? 0
+                        }
+                    }
+                }
+            }
+        },
+        fireballJumping: {
+            blocksPlaced: data?.practice?.fireball_jumping?.blocks_placed ?? 0,
+            attempts: {
+                failed: data?.practice?.fireball_jumping?.failed_attempts ?? 0,
+                successful: data?.practice?.fireball_jumping?.successful_attempts ?? 0,
+                total: data?.practice?.fireball_jumping?.failed_attempts + data?.practice?.fireball_jumping?.successful_attempts
+            }
+        },
+        pearlClutching: {
+            attempts: {
+                failed: data?.practice?.pearl_clutching?.failed_attempts ?? 0,
+                successful: data?.practice?.pearl_clutching?.successful_attempts ?? 0,
+                total: data?.practice?.pearl_clutching?.failed_attempts + data?.practice?.pearl_clutching?.successful_attempts
+            }
+        },
+        mlg: {
+            blocksPlaced: data?.practice?.mlg?.blocks_placed ?? 0,
+            attempts: {
+                failed: data?.practice?.mlg?.failed_attempts ?? 0,
+                successful: data?.practice?.mlg?.successful_attempts ?? 0,
+                total: data?.practice?.mlg?.failed_attempts + data?.practice?.mlg?.successful_attempts
+            }
+        }
+    };
+}
+class BedWars {
+    tokens;
+    level;
+    experience;
+    prestige;
+    playedGames;
+    wins;
+    winstreak;
+    kills;
+    finalKills;
+    losses;
+    deaths;
+    finalDeaths;
+    collectedItemsTotal;
+    beds;
+    KDR;
+    FKDR;
+    WLR;
+    solo;
+    doubles;
+    threes;
+    fours;
+    '4v4';
+    dream;
+    castle;
+    practice;
+    slumberTickets;
+    totalSlumberTicket;
+    constructor(data) {
+        this.tokens = data?.coins || 0;
+        this.level = data?.Experience ? getLevelForExp(data?.Experience) : 0;
+        this.experience = data?.Experience || 0;
+        this.prestige = getBedWarsPrestige(getLevelForExp(data?.Experience));
+        this.playedGames = data?.games_played_bedwars || 0;
+        this.wins = data?.wins_bedwars || 0;
+        this.winstreak = data?.winstreak || 0;
+        this.kills = data?.kills_bedwars || 0;
+        this.finalKills = data?.final_kills_bedwars || 0;
+        this.losses = data?.losses_bedwars || 0;
+        this.deaths = data?.deaths_bedwars || 0;
+        this.finalDeaths = data?.final_deaths_bedwars || 0;
+        this.collectedItemsTotal = {
+            iron: data?.iron_resources_collected_bedwars || 0,
+            gold: data?.gold_resources_collected_bedwars || 0,
+            diamond: data?.diamond_resources_collected_bedwars || 0,
+            emerald: data?.emerald_resources_collected_bedwars || 0
+        };
+        this.beds = {
+            lost: data?.beds_lost_bedwars || 0,
+            broken: data?.beds_broken_bedwars || 0,
+            BLRatio: divide(data?.beds_broken_bedwars, data?.beds_lost_bedwars)
+        };
+        this.KDR = divide(this.kills, this.deaths);
+        this.FKDR = divide(this.finalKills, this.finalDeaths);
+        this.WLR = divide(this.wins, this.losses);
+        this.solo = new BedwarsMode(data, 'eight_one');
+        this.doubles = new BedwarsMode(data, 'eight_two');
+        this.threes = new BedwarsMode(data, 'four_three');
+        this.fours = new BedwarsMode(data, 'four_four');
+        this['4v4'] = new BedwarsMode(data, 'two_four');
+        this.dream = {
+            ultimate: new BedwarsDreamMode(data, 'ultimate'),
+            rush: new BedwarsDreamMode(data, 'rush'),
+            armed: new BedwarsDreamMode(data, 'armed'),
+            lucky: new BedwarsDreamMode(data, 'lucky'),
+            voidless: new BedwarsDreamMode(data, 'voidless')
+        };
+        this.castle = new BedwarsMode(data, 'castle');
+        this.practice = generateStatsForPractice(data);
+        this.slumberTickets = data?.slumber?.tickets || 0;
+        this.totalSlumberTicket = data?.slumber?.total_tickets || 0;
+    }
+}
+export default BedWars;