261 lines
8.1 KiB
TypeScript
261 lines
8.1 KiB
TypeScript
import { PRESTIGE_ICONS, PRESTIGES, SLUMBER_ROOMS, SLUMBER_WALLETS } from "@/data/hypixel/bedwars"
|
|
import { getColorFromCode } from "@/lib/colors"
|
|
import { concatStatsArray, devide, floorLevel } from "../general"
|
|
|
|
export function getBedwarsStar(level: number) {
|
|
if (level < 1100) {
|
|
return PRESTIGE_ICONS[0].symbol
|
|
}
|
|
|
|
if (level > 1100 && level < 2100) {
|
|
return PRESTIGE_ICONS[1].symbol
|
|
}
|
|
|
|
if (level > 2100 && level < 3100) {
|
|
return PRESTIGE_ICONS[2].symbol
|
|
}
|
|
|
|
return PRESTIGE_ICONS[3].symbol
|
|
}
|
|
|
|
export function concatBedwarsStats(...stats: BedwarsModeStats[]) {
|
|
if (stats.length === 0) return []
|
|
|
|
const summed = concatStatsArray<BedwarsModeStats>([
|
|
"kills_bedwars",
|
|
"deaths_bedwars",
|
|
"final_kills_bedwars",
|
|
"final_deaths_bedwars",
|
|
"wins_bedwars",
|
|
"losses_bedwars",
|
|
"beds_broken_bedwars",
|
|
"beds_lost_bedwars"
|
|
], ...stats)
|
|
|
|
let winstreak = -1
|
|
for (const s of stats) {
|
|
if (s.winstreak !== -1) winstreak = Math.max(winstreak, s.winstreak)
|
|
}
|
|
|
|
const ret = {
|
|
...summed,
|
|
winstreak: winstreak < 0 ? "?" : winstreak,
|
|
kd: devide(summed.kills_bedwars, summed.deaths_bedwars),
|
|
fkd: devide(summed.final_kills_bedwars, summed.final_deaths_bedwars),
|
|
wl: devide(summed.wins_bedwars, summed.losses_bedwars),
|
|
bbl: devide(summed.beds_broken_bedwars, summed.beds_lost_bedwars)
|
|
}
|
|
|
|
return [
|
|
ret.kills_bedwars,
|
|
ret.deaths_bedwars,
|
|
ret.kd,
|
|
ret.final_kills_bedwars,
|
|
ret.final_deaths_bedwars,
|
|
ret.fkd,
|
|
ret.wins_bedwars,
|
|
ret.losses_bedwars,
|
|
ret.wl,
|
|
ret.winstreak,
|
|
ret.beds_broken_bedwars,
|
|
ret.beds_lost_bedwars,
|
|
ret.bbl
|
|
]
|
|
}
|
|
|
|
export function getTextColor(level: number) {
|
|
const floored = floorLevel(level, 100)
|
|
|
|
if (level > 5000) {
|
|
return PRESTIGES[PRESTIGES.length - 1].color
|
|
}
|
|
|
|
return PRESTIGES.find(l => l.level === floored)!.color
|
|
}
|
|
|
|
export function bedwarsLevelColors(level: number) {
|
|
if (level < 0) return getColorFromCode()
|
|
|
|
const floored = floorLevel(level, 100)
|
|
|
|
if (floored < 1000) {
|
|
return getColorFromCode(PRESTIGES.find(v => v.level === floored)!.colormap)
|
|
}
|
|
|
|
if (floored > 5000) {
|
|
return PRESTIGES[PRESTIGES.length - 1].colormap.split("").map(v => {
|
|
return getColorFromCode(v)
|
|
})
|
|
}
|
|
|
|
return PRESTIGES.find(v => v.level === floored)!.colormap.split("").map(v => {
|
|
return getColorFromCode(v)
|
|
})
|
|
}
|
|
|
|
export function getPrestigeName(level: number) {
|
|
const floored = floorLevel(level, 100)
|
|
|
|
if (level > 5000) {
|
|
return PRESTIGES[PRESTIGES.length - 1].name
|
|
}
|
|
|
|
return PRESTIGES.find(p => p.level === floored)!.name
|
|
}
|
|
|
|
export function getWalletMax(name?: string) {
|
|
if (!name) return 25
|
|
|
|
const wallets = SLUMBER_WALLETS as Record<string, number>
|
|
|
|
if (!wallets[name]) return 25
|
|
|
|
return wallets[name]
|
|
}
|
|
|
|
export function getLatestRoom(rooms?: Record<string, boolean>) {
|
|
if (!rooms) return null
|
|
|
|
let latestRoom = null
|
|
|
|
for (const room of SLUMBER_ROOMS) {
|
|
if (rooms[room.id]) {
|
|
latestRoom = room.name
|
|
}
|
|
}
|
|
|
|
return latestRoom
|
|
}
|
|
|
|
export type _BedwarsStats = Record<string, number> & { [key: `${string}_winstreak`]: number | undefined }
|
|
type Mode =
|
|
| "solo"
|
|
| "doubles"
|
|
| "3s"
|
|
| "4s"
|
|
| "4v4"
|
|
| "rush_2s"
|
|
| "rush_4s"
|
|
| "ultimate_2s"
|
|
| "ultimate_4s"
|
|
| "lucky_2s"
|
|
| "lucky_4s"
|
|
| "voidless_2s"
|
|
| "voidless_4s"
|
|
| "armed_2s"
|
|
| "armed_4s"
|
|
| "swap_4s"
|
|
| "underworld_4s"
|
|
| "castle"
|
|
|
|
export type BedwarsModeStats = {
|
|
kills_bedwars: number
|
|
deaths_bedwars: number
|
|
final_kills_bedwars: number
|
|
final_deaths_bedwars: number
|
|
wins_bedwars: number
|
|
losses_bedwars: number
|
|
winstreak: number
|
|
beds_broken_bedwars: number
|
|
beds_lost_bedwars: number
|
|
}
|
|
|
|
export function getBestMode(stats: _BedwarsStats): "solo" | "doubles" | "3s" | "4s" | null {
|
|
const { wins_bedwars: solo } = getBedwarsModeStats("solo", stats, true)
|
|
const { wins_bedwars: doubles } = getBedwarsModeStats("doubles", stats, true)
|
|
const { wins_bedwars: threes } = getBedwarsModeStats("3s", stats, true)
|
|
const { wins_bedwars: fours } = getBedwarsModeStats("4s", stats, true)
|
|
|
|
const max = Math.max(solo, doubles, threes, fours)
|
|
|
|
switch (max) {
|
|
case solo:
|
|
return "solo"
|
|
case doubles:
|
|
return "doubles"
|
|
case threes:
|
|
return "3s"
|
|
case fours:
|
|
return "4s"
|
|
default:
|
|
return null
|
|
}
|
|
}
|
|
|
|
export function getBedwarsModeStats(mode: Mode, stats: _BedwarsStats, raw: true): BedwarsModeStats
|
|
export function getBedwarsModeStats(mode: Mode, stats: _BedwarsStats, raw?: false): (string | number)[]
|
|
export function getBedwarsModeStats(mode: Mode, stats: _BedwarsStats, raw = false) {
|
|
switch (mode) {
|
|
case "solo":
|
|
return bedwarsModeStats("eight_one", stats, raw)
|
|
case "doubles":
|
|
return bedwarsModeStats("eight_two", stats, raw)
|
|
case "3s":
|
|
return bedwarsModeStats("four_three", stats, raw)
|
|
case "4s":
|
|
return bedwarsModeStats("four_four", stats, raw)
|
|
case "4v4":
|
|
return bedwarsModeStats("two_four", stats, raw)
|
|
case "rush_2s":
|
|
return bedwarsModeStats("eight_two_rush", stats, raw)
|
|
case "rush_4s":
|
|
return bedwarsModeStats("four_four_rush", stats, raw)
|
|
case "ultimate_2s":
|
|
return bedwarsModeStats("eight_two_ultimate", stats, raw)
|
|
case "ultimate_4s":
|
|
return bedwarsModeStats("four_four_ultimate", stats, raw)
|
|
case "lucky_2s":
|
|
return bedwarsModeStats("eight_two_lucky", stats, raw)
|
|
case "lucky_4s":
|
|
return bedwarsModeStats("four_four_lucky", stats, raw)
|
|
case "voidless_2s":
|
|
return bedwarsModeStats("eight_two_voidless", stats, raw)
|
|
case "voidless_4s":
|
|
return bedwarsModeStats("four_four_voidless", stats, raw)
|
|
case "armed_2s":
|
|
return bedwarsModeStats("eight_two_armed", stats, raw)
|
|
case "armed_4s":
|
|
return bedwarsModeStats("four_four_armed", stats, raw)
|
|
case "swap_4s":
|
|
return bedwarsModeStats("four_four_swap", stats, raw)
|
|
case "underworld_4s":
|
|
return bedwarsModeStats("four_four_underworld", stats, raw)
|
|
case "castle":
|
|
return bedwarsModeStats("castle", stats, raw)
|
|
default:
|
|
throw new Error(`${mode satisfies never} does not exist`)
|
|
}
|
|
}
|
|
|
|
function bedwarsModeStats(prefix: string, stats: _BedwarsStats, raw = false) {
|
|
if (raw) {
|
|
return {
|
|
kills_bedwars: stats[`${prefix}_kills_bedwars`],
|
|
deaths_bedwars: stats[`${prefix}_deaths_bedwars`],
|
|
final_kills_bedwars: stats[`${prefix}_final_kills_bedwars`],
|
|
final_deaths_bedwars: stats[`${prefix}_final_deaths_bedwars`],
|
|
wins_bedwars: stats[`${prefix}_wins_bedwars`],
|
|
losses_bedwars: stats[`${prefix}_losses_bedwars`],
|
|
winstreak: stats[`${prefix}_winstreak`] ?? -1,
|
|
beds_broken_bedwars: stats[`${prefix}_beds_broken_bedwars`],
|
|
beds_lost_bedwars: stats[`${prefix}_beds_lost_bedwars`]
|
|
}
|
|
}
|
|
|
|
return [
|
|
stats[`${prefix}_kills_bedwars`],
|
|
stats[`${prefix}_deaths_bedwars`],
|
|
devide(stats[`${prefix}_kills_bedwars`], stats[`${prefix}_deaths_bedwars`]).toFixed(2),
|
|
stats[`${prefix}_final_kills_bedwars`],
|
|
stats[`${prefix}_final_deaths_bedwars`],
|
|
devide(stats[`${prefix}_final_kills_bedwars`], stats[`${prefix}_final_deaths_bedwars`]).toFixed(2),
|
|
stats[`${prefix}_wins_bedwars`],
|
|
stats[`${prefix}_losses_bedwars`],
|
|
devide(stats[`${prefix}_wins_bedwars`], stats[`${prefix}_losses_bedwars`]).toFixed(2),
|
|
stats[`${prefix}_winstreak`] ?? "?",
|
|
stats[`${prefix}_beds_broken_bedwars`],
|
|
stats[`${prefix}_beds_lost_bedwars`],
|
|
devide(stats[`${prefix}_beds_broken_bedwars`], stats[`${prefix}_beds_lost_bedwars`]).toFixed(2)
|
|
]
|
|
}
|