256 lines
8.1 KiB
TypeScript
256 lines
8.1 KiB
TypeScript
import { MODES, PRESTIGE_ICONS, PRESTIGES, SLUMBER_ROOMS, SLUMBER_WALLETS } from "@/data/hypixel/bedwars"
|
|
import { getColorFromCode } from "@/lib/colors"
|
|
import { formatNumber } from "@/lib/formatters"
|
|
import { NonNullStats } from "@/lib/schema/player"
|
|
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 getBedwarsPrestige(level: number) {
|
|
const floored = floorLevel(level, 100)
|
|
|
|
if (level > 5000) {
|
|
const pres = PRESTIGES.at(-1)!
|
|
|
|
return {
|
|
color: pres.color,
|
|
name: pres.name,
|
|
colormap: pres.colormap.split("").map(v => {
|
|
return getColorFromCode(v)
|
|
})
|
|
}
|
|
}
|
|
|
|
if (level >= 1000) {
|
|
const pres = PRESTIGES.find(p => p.level === floored)!
|
|
return {
|
|
color: pres.color,
|
|
name: pres.name,
|
|
colormap: pres.colormap.split("").map(v => {
|
|
return getColorFromCode(v)
|
|
})
|
|
}
|
|
}
|
|
|
|
const pres = PRESTIGES.find(l => l.level === floored)!
|
|
return {
|
|
color: pres.color,
|
|
name: pres.name,
|
|
colormap: getColorFromCode(pres.colormap)
|
|
}
|
|
}
|
|
|
|
export function getBedwarsWalletMax(name?: string) {
|
|
if (!name) return 25
|
|
|
|
const wallets = SLUMBER_WALLETS as Record<string, number>
|
|
|
|
if (!wallets[name]) return 25
|
|
|
|
return wallets[name]
|
|
}
|
|
|
|
export function getBedwarsLatestRoom(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
|
|
}
|
|
|
|
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: NonNullable<NonNullStats["Bedwars"]>): "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: NonNullable<NonNullStats["Bedwars"]>, raw: true): BedwarsModeStats
|
|
export function getBedwarsModeStats(mode: Mode, stats: NonNullable<NonNullStats["Bedwars"]>, raw?: false): (string | number)[]
|
|
export function getBedwarsModeStats(mode: Mode, stats: NonNullable<NonNullStats["Bedwars"]>, 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: Exclude<typeof MODES[number]["id"], "">, stats: NonNullable<NonNullStats["Bedwars"]>, 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`],
|
|
formatNumber(devide(stats[`${prefix}_kills_bedwars`], stats[`${prefix}_deaths_bedwars`])),
|
|
stats[`${prefix}_final_kills_bedwars`],
|
|
stats[`${prefix}_final_deaths_bedwars`],
|
|
formatNumber(devide(stats[`${prefix}_final_kills_bedwars`], stats[`${prefix}_final_deaths_bedwars`])),
|
|
stats[`${prefix}_wins_bedwars`],
|
|
stats[`${prefix}_losses_bedwars`],
|
|
formatNumber(devide(stats[`${prefix}_wins_bedwars`], stats[`${prefix}_losses_bedwars`])),
|
|
stats[`${prefix}_winstreak`] ?? "?",
|
|
stats[`${prefix}_beds_broken_bedwars`],
|
|
stats[`${prefix}_beds_lost_bedwars`],
|
|
formatNumber(devide(stats[`${prefix}_beds_broken_bedwars`], stats[`${prefix}_beds_lost_bedwars`]))
|
|
]
|
|
}
|