From 2cd5d4f8a8c981ec17cc9936f5c8eb9bd3570ac6 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 1 Jul 2025 18:26:54 +0200 Subject: [PATCH] move kart hud stuff into k_hud hope i got everything lol --- src/Sourcefile | 1 + src/d_main.c | 1 + src/hu_stuff.c | 1 + src/k_hud.c | 4800 +++++++++++++++++++++++++++++++++++++++++++++ src/k_hud.h | 81 + src/k_kart.c | 4776 +------------------------------------------- src/k_kart.h | 47 +- src/lua_baselib.c | 1 + src/lua_hudlib.c | 1 + src/m_menu.c | 1 + src/st_stuff.c | 1 + src/w_wad.c | 1 + src/y_inter.c | 1 + 13 files changed, 4896 insertions(+), 4817 deletions(-) create mode 100644 src/k_hud.c create mode 100644 src/k_hud.h diff --git a/src/Sourcefile b/src/Sourcefile index 463ebb198..1cfae5634 100644 --- a/src/Sourcefile +++ b/src/Sourcefile @@ -79,6 +79,7 @@ p_tick.c p_user.c k_director.c k_kart.c +k_hud.c k_stats.c lua_baselib.c lua_blockmaplib.c diff --git a/src/d_main.c b/src/d_main.c index f111c49dd..45d1145e6 100644 --- a/src/d_main.c +++ b/src/d_main.c @@ -73,6 +73,7 @@ #include "d_protocol.h" #include "m_perfstats.h" #include "k_kart.h" +#include "k_hud.h" #include "core/memory.h" diff --git a/src/hu_stuff.c b/src/hu_stuff.c index 69a6616ec..acc787394 100644 --- a/src/hu_stuff.c +++ b/src/hu_stuff.c @@ -50,6 +50,7 @@ #include "s_sound.h" // song credits #include "k_kart.h" +#include "k_hud.h" #include "m_textinput.h" diff --git a/src/k_hud.c b/src/k_hud.c new file mode 100644 index 000000000..6c0488aae --- /dev/null +++ b/src/k_hud.c @@ -0,0 +1,4800 @@ +// SONIC ROBO BLAST 2 KART +//----------------------------------------------------------------------------- +// Copyright (C) 2018-2020 by Kart Krew +// +// This program is free software distributed under the +// terms of the GNU General Public License, version 2. +// See the 'LICENSE' file for more details. +//----------------------------------------------------------------------------- +/// \file k_hud.c +/// \brief HUD drawing functions exclusive to Kart + +#include "doomdef.h" +#include "doomstat.h" +#include "doomtype.h" +#include "command.h" +#include "d_netcmd.h" +#include "d_player.h" +#include "hu_stuff.h" +#include "g_game.h" +#include "i_joy.h" +#include "m_fixed.h" +#include "m_menu.h" // ffdhidshfuisduifigergho9igj89dgodhfih AAAAAAAAAA +#include "p_local.h" +#include "p_setup.h" +#include "r_defs.h" +#include "r_draw.h" +#include "r_state.h" +#include "r_fps.h" +#include "s_sound.h" +#include "screen.h" +#include "st_stuff.h" +#include "tables.h" +#include "v_video.h" +#include "z_zone.h" +#include "m_cond.h" +#include "k_director.h" +#include "k_kart.h" +#include "lua_hud.h" // For Lua hud checks +#include "d_main.h" // found_extra_kart +#include "i_video.h" + +#include "k_hud.h" + +#ifdef ROTSPRITE +#include "r_patchrotation.h" +#endif + +#ifdef HWRENDER +#include "hardware/hw_main.h" +#endif + +#define XTRA3PSCALE 50135 //0.765 +#define XTRA3VSCALE 35344 //0.55 + +// Hud offset cvars +#define IMPL_HUD_OFFSET_X(name)\ +consvar_t cv_##name##_xoffset = {"hud_" #name "_xoffset", "0", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL}; + +#define IMPL_HUD_OFFSET_Y(name)\ +consvar_t cv_##name##_yoffset = {"hud_" #name "_yoffset", "0", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL}; + +#define IMPL_HUD_OFFSET(name)\ +IMPL_HUD_OFFSET_X(name)\ +IMPL_HUD_OFFSET_Y(name) + +IMPL_HUD_OFFSET(item); // Item box +IMPL_HUD_OFFSET(time); // Time +IMPL_HUD_OFFSET(laps); // Number of laps +IMPL_HUD_OFFSET(dnft); // Countdown (did not finish timer) +IMPL_HUD_OFFSET(speed); // Speedometer +IMPL_HUD_OFFSET(posi); // Position in race +IMPL_HUD_OFFSET(wheel); // RA Wheel +IMPL_HUD_OFFSET(face); // Mini rankings +IMPL_HUD_OFFSET(stcd); // Starting countdown +IMPL_HUD_OFFSET_Y(chek); // Check gfx +IMPL_HUD_OFFSET(mini); // Minimap +IMPL_HUD_OFFSET(want); // Wanted +IMPL_HUD_OFFSET(stat); // Stats + +#undef IMPL_HUD_OFFSET +#undef IMPL_HUD_OFFSET_X +#undef IMPL_HUD_OFFSET_Y + +// extra hud things +consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + +consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead + +CV_PossibleValue_t inputdisplay_cons_t[NUMINPUTDISPLAYSTUFF]; +consvar_t cv_showinput = {"showinput", "Off", CV_SAVE, inputdisplay_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; + +CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF]; +consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; + +consvar_t cv_posanim = {"postitionanimation", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_smallposnum = {"smallpositionnumber", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + +consvar_t cv_showlapemblem = {"showlapemblem", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + +static CV_PossibleValue_t huditemamount_cons_t[] = {{0, "Vanilla"}, {1, "Multiple"}, {2, "Always"},{0, NULL}}; +consvar_t cv_huditemamount = {"showitemamountnumber", "Vanilla", CV_SAVE, huditemamount_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_fancyroulette = {"animatedroulette", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_darkitembox = {"darkitembox", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // itembox gets a dark border with specific items +consvar_t cv_multiitemicon = {"multiitemicon", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + +consvar_t cv_showlaptimes = {"showlaptimes", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + +consvar_t cv_biglaps = {"biglaphud", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // here for ppl who dont want to make 2 more patches for their custom hud + +// Speedometer +CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF]; +consvar_t cv_newspeedometer = {"newspeedometer", "Default", CV_SAVE, speedo_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_battlespeedo = {"battlespeedo", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // toggle for showing the speedometer in battlemode + +// Colourized HUD +consvar_t cv_colorizedhud = {"colorizedhud", "Off", CV_SAVE|CV_CALL, CV_OnOff, SaturnHud_menu_Onchange, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_colorizeditembox = {"colorizeditembox", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + +static CV_PossibleValue_t HudColor_cons_t[MAXSKINCOLORS+1]; +consvar_t cv_colorizedhudcolor = {"colorizedhudcolor", "Skin Color", CV_SAVE, HudColor_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; + +// Driftgauge +static CV_PossibleValue_t driftgaugeoffset_cons_t[] = { + {-FRACUNIT*128, "MIN"}, {FRACUNIT*128, "MAX"}, {0, NULL}}; +CV_PossibleValue_t driftgaugestyle_cons_t[NUMDGAUGESTUFF]; + +consvar_t cv_driftgauge = {"kartdriftgauge", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_driftgaugeofs = {"kartdriftgaugeoffset", "-20", CV_FLOAT|CV_SAVE, driftgaugeoffset_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_driftgaugetrans = {"kartdriftgaugetransparency", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_driftgaugestyle = {"kartdriftgaugestyle", "1", CV_SAVE, driftgaugestyle_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; + +// Nametags +static CV_PossibleValue_t nametagtrans_cons_t[] = { + {0, "Never"}, {1, "Far only"}, {2, "Dynamic"}, {3, "Always"}, {4, "HUD Trans."}, {0, NULL}}; +static CV_PossibleValue_t nametagdistance_cons_t[] = { + {0, "MIN"}, {640, "MAX"}, {0, NULL}}; +static CV_PossibleValue_t nametagmaxplayer_cons_t[] = { + {1, "MIN"}, {MAXPLAYERS, "MAX"}, {0, NULL}}; +static CV_PossibleValue_t nametagsize_cons_t[] = { + {0, "Off"}, {1, "Small"}, {2, "Minimal"}, {0, NULL}}; +static CV_PossibleValue_t nametagrestat_cons_t[] = { + {0, "Off"}, {1, "Restat"}, {2, "Always"}, {0, NULL}}; + +consvar_t cv_nametag = {"kartnametag", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagtrans = {"kartnametagtransparency", "Dynamic", CV_SAVE, nametagtrans_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagfacerank = {"kartnametagfacerank", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagrestat = {"kartnametagrestat", "Restat", CV_SAVE, nametagrestat_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagdist = {"kartnametagdist", "320", CV_SAVE, nametagdistance_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagmaxplayers = {"kartnametagmaxplayers", "3", CV_SAVE, nametagmaxplayer_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagmaxlenght = {"kartnametagmaxlenght", "12", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_showownnametag = {"kartnametagshowown", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_smallnametags = {"kartnametagsmall", "Off", CV_SAVE, nametagsize_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_nametagscore = {"kartnametagscore", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_shownametagspectator = {"kartshownametagspectator", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL}; + +// Registers kart client commands and variables. +// Nothing needed for a dedicated server should be registered here. +void K_RegisterKartHudStuff(void) +{ + HudColor_cons_t[0].value = 0; + HudColor_cons_t[0].strvalue = "Skin Color"; + + for (INT32 i = 1; i < MAXSKINCOLORS; i++) + { + HudColor_cons_t[i].value = i; + HudColor_cons_t[i].strvalue = KartColor_Names[i]; // SRB2kart + } + HudColor_cons_t[MAXSKINCOLORS].value = 0; + HudColor_cons_t[MAXSKINCOLORS].strvalue = NULL; + +#define REG_HUD_OFFSET_X(name)\ + CV_RegisterVar(&cv_##name##_xoffset); + +#define REG_HUD_OFFSET_Y(name)\ + CV_RegisterVar(&cv_##name##_yoffset); + +#define REG_HUD_OFFSET(name)\ + REG_HUD_OFFSET_X(name)\ + REG_HUD_OFFSET_Y(name) + + REG_HUD_OFFSET(item); // Item box + REG_HUD_OFFSET(time); // Time + REG_HUD_OFFSET(laps); // Number of laps + REG_HUD_OFFSET(dnft); // Countdown (did not finish timer) + REG_HUD_OFFSET(speed); // Speedometer + REG_HUD_OFFSET(posi); // Position in race + REG_HUD_OFFSET(wheel); // Position in race + REG_HUD_OFFSET(face); // Mini rankings + REG_HUD_OFFSET(stcd); // Starting countdown + REG_HUD_OFFSET_Y(chek); // Check gfx + REG_HUD_OFFSET(mini); // Minimap + REG_HUD_OFFSET(want); // Wanted + REG_HUD_OFFSET(stat); // Stats + +#undef REG_HUD_OFFSET +#undef REG_HUD_OFFSET_X +#undef REG_HUD_OFFSET_Y + + CV_RegisterVar(&cv_kartminimap); + CV_RegisterVar(&cv_kartcheck); + + CV_RegisterVar(&cv_kartspeedometer); + + CV_RegisterVar(&cv_showstats); + CV_RegisterVar(&cv_showinput); + + CV_RegisterVar(&cv_posanim); + CV_RegisterVar(&cv_smallposnum); + + CV_RegisterVar(&cv_fancyroulette); + + CV_RegisterVar(&cv_showlaptimes); + CV_RegisterVar(&cv_newspeedometer); + + CV_RegisterVar(&cv_battlespeedo); + + CV_RegisterVar(&cv_minihead); + CV_RegisterVar(&cv_showminimapnames); + CV_RegisterVar(&cv_showminimapangle); + + CV_RegisterVar(&cv_showlapemblem); + + CV_RegisterVar(&cv_stagetitle); + + // Colourized HUD + CV_RegisterVar(&cv_colorizedhud); + CV_RegisterVar(&cv_colorizedhudcolor); + CV_RegisterVar(&cv_colorizeditembox); + + CV_RegisterVar(&cv_biglaps); + + CV_RegisterVar(&cv_darkitembox); + + CV_RegisterVar(&cv_multiitemicon); + CV_RegisterVar(&cv_huditemamount); + + CV_RegisterVar(&cv_highresportrait); + + CV_RegisterVar(&cv_nametag); + CV_RegisterVar(&cv_nametagtrans); + CV_RegisterVar(&cv_nametagfacerank); + CV_RegisterVar(&cv_nametagmaxplayers); + CV_RegisterVar(&cv_nametagmaxlenght); + CV_RegisterVar(&cv_nametagdist); + CV_RegisterVar(&cv_showownnametag); + CV_RegisterVar(&cv_smallnametags); + CV_RegisterVar(&cv_nametagrestat); + CV_RegisterVar(&cv_nametagscore); + CV_RegisterVar(&cv_shownametagspectator); + + CV_RegisterVar(&cv_driftgauge); + CV_RegisterVar(&cv_driftgaugeofs); + CV_RegisterVar(&cv_driftgaugetrans); + CV_RegisterVar(&cv_driftgaugestyle); + + CV_RegisterVar(&cv_lessflicker); +} + +//{ Patch Definitions + +// --Saturn patches-- +// dont leave those unitialized incase we missed a check somewhere + +// -Speedometers- + +// Smol speedo +static patch_t *skp_smallsticker = NULL; +static patch_t *skp_smallsticker3 = NULL; + +static patch_t *skp_speedpatches[5] = {NULL}; + +// Achii speedo +static patch_t *skp_smallstickerachi = NULL; +static patch_t *skp_speedpatchesachi[5] = {NULL}; +static patch_t *skp_smallstickerachiclr = NULL; +static patch_t *skp_speedpatchesachiclr[5] = {NULL}; + +// Kartz speedo +static patch_t *kp_kartzspeedo[25] = {NULL}; +static patch_t *kp_kartzspeedo_smol[25] = {NULL}; + +// dial speedometer +static patch_t *skp_rankfinish = NULL; +static patch_t *skp_dialbase[2] = {NULL}; +static patch_t *skp_speedpatchesdial[5] = {NULL}; +static patch_t *skp_dialnum[10] = {NULL}; +//static patch_t *skp_dialclr = NULL; +static patch_t *skp_dialbaseclr[2] = {NULL}; +static patch_t *skp_speedpatchesdialclr[5] = {NULL}; +static patch_t *skp_dialnumclr[10] = {NULL}; + +// -Colourized hud- + +static patch_t *kp_timestickerclr = NULL; +static patch_t *kp_timestickerwideclr = NULL; +static patch_t *kp_lapstickerclr = NULL; +static patch_t *kp_lapstickerbigclr = NULL; +static patch_t *kp_lapstickerbig2clr = NULL; +static patch_t *kp_lapstickerwideclr = NULL; +//static patch_t *kp_lapstickernarrowclr = NULL; +static patch_t *kp_bumperstickerclr = NULL; +static patch_t *kp_bumperstickerwideclr = NULL; +static patch_t *kp_karmastickerclr = NULL; +static patch_t *kp_timeoutstickerclr = NULL; +static patch_t *skp_smallstickerclr = NULL; +static patch_t *skp_smallstickerclr3 = NULL; +static patch_t *kp_itemmulstickerclr[2] = {NULL}; +static patch_t *kp_itembgclr[4] = {NULL}; + +// -Misc.- + +static patch_t *kp_lapstickerbig = NULL; +static patch_t *kp_lapstickerbig2 = NULL; + +static patch_t *nametagpic = NULL; +static patch_t *nametagline = NULL; +static patch_t *nametagspeed = NULL; +static patch_t *nametagweight = NULL; + +static patch_t *driftgauge = NULL; +static patch_t *driftgaugecolor = NULL; +static patch_t *driftgaugesmall = NULL; +static patch_t *driftgaugesmallcolor = NULL; + +static patch_t *kp_minimapdot = NULL; + +static patch_t *joybacking = NULL; +static patch_t *joyknob = NULL; +static patch_t *joyshadow = NULL; + +static patch_t *kp_multjawz = NULL; +static patch_t *kp_multsneaker[2] = {NULL}; +static patch_t *kp_multbanana[3] = {NULL}; + +static void K_LoadSaturnHUDGraphics(void) +{ + INT32 i; + char buffer[9]; + + if (found_extra_kart) + { + if (xtra_speedo) // smol speedometer + { + skp_smallsticker = (patch_t *)W_CachePatchName("SP_SMSTC", PU_HUDGFX); + skp_speedpatches[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd + skp_speedpatches[1] = (patch_t *)W_CachePatchName("SP_MKMH", PU_HUDGFX); + skp_speedpatches[2] = (patch_t *)W_CachePatchName("SP_MMPH", PU_HUDGFX); + skp_speedpatches[3] = (patch_t *)W_CachePatchName("SP_MFRAC", PU_HUDGFX); + skp_speedpatches[4] = (patch_t *)W_CachePatchName("SP_MPERC", PU_HUDGFX); + } + + if (achi_speedo) + { + skp_smallstickerachi = (patch_t *)W_CachePatchName("SP_AMSTC", PU_HUDGFX); + skp_speedpatchesachi[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd + skp_speedpatchesachi[1] = (patch_t *)W_CachePatchName("SP_AKMH", PU_HUDGFX); + skp_speedpatchesachi[2] = (patch_t *)W_CachePatchName("SP_AMPH", PU_HUDGFX); + skp_speedpatchesachi[3] = (patch_t *)W_CachePatchName("SP_AFRAC", PU_HUDGFX); + skp_speedpatchesachi[4] = (patch_t *)W_CachePatchName("SP_APERC", PU_HUDGFX); + } + + if (dial_speedo) + { + skp_rankfinish = (patch_t *)W_CachePatchName("RANKFIN", PU_HUDGFX); + skp_dialbase[0] = (patch_t *)W_CachePatchName("K_DSPBS1", PU_HUDGFX); + skp_dialbase[1] = (patch_t *)W_CachePatchName("K_DSPBS2", PU_HUDGFX); + + skp_speedpatchesdial[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd + skp_speedpatchesdial[1] = (patch_t *)W_CachePatchName("SP_DKMH", PU_HUDGFX); + skp_speedpatchesdial[2] = (patch_t *)W_CachePatchName("SP_DMPH", PU_HUDGFX); + skp_speedpatchesdial[3] = (patch_t *)W_CachePatchName("SP_DFRAC", PU_HUDGFX); + skp_speedpatchesdial[4] = (patch_t *)W_CachePatchName("SP_DPERC", PU_HUDGFX); + + sprintf(buffer, "K_DSPNMx"); + for (i = 0; i < 10; i++) + { + buffer[7] = '0'+(i%10); + skp_dialnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + } + + // KartZ speedo + if (kartz_speedo) + { + const char* patchNames[] = { + "K_KZSP1", "K_KZSP2", "K_KZSP3", "K_KZSP4", "K_KZSP5", + "K_KZSP6", "K_KZSP7", "K_KZSP8", "K_KZSP9", "K_KZSP10", + "K_KZSP11", "K_KZSP12", "K_KZSP13", "K_KZSP14", "K_KZSP15", + "K_KZSP16", "K_KZSP17", "K_KZSP18", "K_KZSP19", "K_KZSP20", + "K_KZSP21", "K_KZSP22", "K_KZSP23", "K_KZSP24", "K_KZSP25" + }; + + for (size_t m = 0; m < sizeof(patchNames) / sizeof(patchNames[0]); ++m) + { + kp_kartzspeedo[m] = (patch_t *)W_CachePatchName(patchNames[m], PU_HUDGFX); + } + } + + if (kartz_speedo_smol) + { + const char* patchNames[] = { + "K_KZSS1", "K_KZSS2", "K_KZSS3", "K_KZSS4", "K_KZSS5", + "K_KZSS6", "K_KZSS7", "K_KZSS8", "K_KZSS9", "K_KZSS10", + "K_KZSS11", "K_KZSS12", "K_KZSS13", "K_KZSS14", "K_KZSS15", + "K_KZSS16", "K_KZSS17", "K_KZSS18", "K_KZSS19", "K_KZSS20", + "K_KZSS21", "K_KZSS22", "K_KZSS23", "K_KZSS24", "K_KZSS25" + }; + + for (size_t m = 0; m < sizeof(patchNames) / sizeof(patchNames[0]); ++m) + { + kp_kartzspeedo_smol[m] = (patch_t *)W_CachePatchName(patchNames[m], PU_HUDGFX); + } + } + + if (big_lap) + { + kp_lapstickerbig = (patch_t *)W_CachePatchName("K_STLAPB", PU_HUDGFX); + kp_lapstickerbig2 = (patch_t *)W_CachePatchName("K_STLA2B", PU_HUDGFX); + } + + // Nametags + if (nametaggfx) + { + nametagpic = (patch_t *)W_CachePatchName("NTLINE", PU_HUDGFX); + nametagline = (patch_t *)W_CachePatchName("NTLINEV", PU_HUDGFX); + nametagspeed = (patch_t *)W_CachePatchName("NTSP", PU_HUDGFX); + nametagweight = (patch_t *)W_CachePatchName("NTWH", PU_HUDGFX); + } + + if (driftgaugegfx) + { + driftgauge = (patch_t *)W_CachePatchName("K_DGAU", PU_HUDGFX); + driftgaugesmall = (patch_t *)W_CachePatchName("K_DGSU", PU_HUDGFX); + + if (driftgaugegfx_clr) + { + driftgaugecolor = (patch_t *)W_CachePatchName("K_DCAU", PU_HUDGFX); + driftgaugesmallcolor = (patch_t *)W_CachePatchName("K_DCSU", PU_HUDGFX); + } + } + + if (joystickicon) + { + joybacking = (patch_t *)W_CachePatchName("JOYBCK", PU_HUDGFX); + joyknob = (patch_t *)W_CachePatchName("JOYKNB", PU_HUDGFX); + joyshadow = (patch_t *)W_CachePatchName("JOYSHD", PU_HUDGFX); + } + + if (minidoticon) + { + kp_minimapdot = (patch_t *)W_CachePatchName("MMAPDOT", PU_HUDGFX); + } + + if (multiitem_icon) + { + kp_multsneaker[0] = (patch_t *)W_CachePatchName("K_ITSHO2", PU_HUDGFX); + kp_multsneaker[1] = (patch_t *)W_CachePatchName("K_ITSHO3", PU_HUDGFX); + kp_multbanana[0] = (patch_t *)W_CachePatchName("K_ITBAN2", PU_HUDGFX); + kp_multbanana[1] = (patch_t *)W_CachePatchName("K_ITBAN3", PU_HUDGFX); + kp_multbanana[2] = (patch_t *)W_CachePatchName("K_ITBAN4", PU_HUDGFX); + kp_multjawz = (patch_t *)W_CachePatchName("K_ITJAW2", PU_HUDGFX); + } + } + + if (found_extra2_kart) + { + if (xtra_speedo_clr) + { + skp_smallstickerclr = (patch_t *)W_CachePatchName("SC_SMSTC", PU_HUDGFX); + } + + if (xtra_speedo_clr3) + { + skp_smallstickerclr3 = (patch_t *)W_CachePatchName("SC_SM3TC", PU_HUDGFX); + } + + if (achi_speedo_clr) + { + skp_smallstickerachiclr = (patch_t *)W_CachePatchName("SC_AMSTC", PU_HUDGFX); + skp_speedpatchesachiclr[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd + skp_speedpatchesachiclr[1] = (patch_t *)W_CachePatchName("SC_AKMH", PU_HUDGFX); + skp_speedpatchesachiclr[2] = (patch_t *)W_CachePatchName("SC_AMPH", PU_HUDGFX); + skp_speedpatchesachiclr[3] = (patch_t *)W_CachePatchName("SC_AFRAC", PU_HUDGFX); + skp_speedpatchesachiclr[4] = (patch_t *)W_CachePatchName("SC_APERC", PU_HUDGFX); + } + + if (dial_speedo_clr) + { + skp_dialbaseclr[0] = (patch_t *)W_CachePatchName("K_DSPBC1", PU_HUDGFX); + skp_dialbaseclr[1] = (patch_t *)W_CachePatchName("K_DSPBC2", PU_HUDGFX); + + skp_speedpatchesdialclr[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd + skp_speedpatchesdialclr[1] = (patch_t *)W_CachePatchName("SC_DKMH", PU_HUDGFX); + skp_speedpatchesdialclr[2] = (patch_t *)W_CachePatchName("SC_DMPH", PU_HUDGFX); + skp_speedpatchesdialclr[3] = (patch_t *)W_CachePatchName("SC_DFRAC", PU_HUDGFX); + skp_speedpatchesdialclr[4] = (patch_t *)W_CachePatchName("SC_DPERC", PU_HUDGFX); + + sprintf(buffer, "K_DSPNCx"); + for (i = 0; i < 10; i++) + { + buffer[7] = '0'+(i%10); + skp_dialnumclr[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + } + + if (big_lap_color) + { + kp_lapstickerbigclr = (patch_t *)W_CachePatchName("K_SCLAPB", PU_HUDGFX); + kp_lapstickerbig2clr = (patch_t *)W_CachePatchName("K_SCLA2B", PU_HUDGFX); + } + + // Colourized hud + if (clr_hud) + { + kp_timestickerclr = (patch_t *)W_CachePatchName("K_SCTIME", PU_HUDGFX); + kp_timestickerwideclr = (patch_t *)W_CachePatchName("K_SCTIMW", PU_HUDGFX); + kp_lapstickerclr = (patch_t *)W_CachePatchName("K_SCLAPS", PU_HUDGFX); + kp_lapstickerwideclr = (patch_t *)W_CachePatchName("K_SCLAPW", PU_HUDGFX); + kp_bumperstickerclr = (patch_t *)W_CachePatchName("K_SCBALN", PU_HUDGFX); + kp_bumperstickerwideclr = (patch_t *)W_CachePatchName("K_SCBALW", PU_HUDGFX); + kp_karmastickerclr = (patch_t *)W_CachePatchName("K_SCKARM", PU_HUDGFX); + kp_timeoutstickerclr = (patch_t *)W_CachePatchName("K_SCTOUT", PU_HUDGFX); + kp_itembgclr[0] = (patch_t *)W_CachePatchName("K_ITBC" , PU_HUDGFX); + kp_itembgclr[1] = (patch_t *)W_CachePatchName("K_ITBCD" , PU_HUDGFX); + kp_itembgclr[2] = (patch_t *)W_CachePatchName("K_ISBC" , PU_HUDGFX); + kp_itembgclr[3] = (patch_t *)W_CachePatchName("K_ISBCD" , PU_HUDGFX); + kp_itemmulstickerclr[1] = (patch_t *)W_CachePatchName("K_ISMULC", PU_HUDGFX); + kp_itemmulstickerclr[0] = (patch_t *)W_CachePatchName("K_ITMULC", PU_HUDGFX); + } + } + + if (found_extra3_kart) + { + if (xtra_speedo3) // 80x11 patch scaled to size + { + skp_smallsticker3 = (patch_t *)W_CachePatchName("SP_SM3TC", PU_HUDGFX); + } + } +} + +// -- Kart patches -- + +#define NUMPOSNUMS 10 +#define NUMPOSFRAMES 7 // White, three blues, three reds +#define NUMWINFRAMES 6 // Red, yellow, green, cyan, blue, purple + +static patch_t *kp_nodraw; +static patch_t *kp_timesticker; +static patch_t *kp_timestickerwide; +static patch_t *kp_lapsticker; +static patch_t *kp_lapstickerwide; +//static patch_t *kp_lapstickernarrow; +static patch_t *kp_splitlapflag; +static patch_t *kp_bumpersticker; +static patch_t *kp_bumperstickerwide; +static patch_t *kp_karmasticker; +static patch_t *kp_splitkarmabomb; +static patch_t *kp_timeoutsticker; + +static patch_t *kp_startcountdown[16]; +static patch_t *kp_racefinish[6]; + +static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES]; +static patch_t *kp_winnernum[NUMPOSFRAMES]; + +static patch_t *kp_facenum[MAXPLAYERS+1]; +static patch_t *kp_facehighlight[8]; + +static patch_t *kp_rankbumper; +static patch_t *kp_tinybumper[2]; +static patch_t *kp_ranknobumpers; + +static patch_t *kp_battlewin; +static patch_t *kp_battlecool; +static patch_t *kp_battlelose; +static patch_t *kp_battlewait; +static patch_t *kp_battleinfo; +static patch_t *kp_wanted; +static patch_t *kp_wantedsplit; +static patch_t *kp_wantedreticle; + +static patch_t *kp_itembg[4]; +static patch_t *kp_itemtimer[2]; +static patch_t *kp_itemmulsticker[2]; +static patch_t *kp_itemx; + +static patch_t *kp_sneaker[2]; +static patch_t *kp_rocketsneaker[2]; +static patch_t *kp_invincibility[13]; +static patch_t *kp_banana[2]; +static patch_t *kp_eggman[2]; +static patch_t *kp_orbinaut[5]; +static patch_t *kp_jawz[2]; +static patch_t *kp_mine[2]; +static patch_t *kp_ballhog[2]; +static patch_t *kp_selfpropelledbomb[2]; +static patch_t *kp_grow[2]; +static patch_t *kp_shrink[2]; +static patch_t *kp_thundershield[2]; +static patch_t *kp_hyudoro[2]; +static patch_t *kp_pogospring[2]; +static patch_t *kp_kitchensink[2]; +static patch_t *kp_sadface[2]; + +static patch_t *kp_check[6]; + +static patch_t *kp_eggnum[4]; + +static patch_t *kp_fpview[3]; +static patch_t *kp_inputwheel[5]; + +static patch_t *kp_challenger[25]; + +static patch_t *kp_lapanim_lap[7]; +static patch_t *kp_lapanim_final[11]; +static patch_t *kp_lapanim_number[10][3]; +static patch_t *kp_lapanim_emblem[2]; +static patch_t *kp_lapanim_hand[3]; + +static patch_t *kp_yougotem; + +void K_LoadKartHUDGraphics(void) +{ + INT32 i, j; + char buffer[9]; + + // Null Stuff + kp_nodraw = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); + + // Stickers + kp_timesticker = (patch_t *)W_CachePatchName("K_STTIME", PU_HUDGFX); + kp_timestickerwide = (patch_t *)W_CachePatchName("K_STTIMW", PU_HUDGFX); + kp_lapsticker = (patch_t *)W_CachePatchName("K_STLAPS", PU_HUDGFX); + kp_lapstickerwide = (patch_t *)W_CachePatchName("K_STLAPW", PU_HUDGFX); + //kp_lapstickernarrow = (patch_t *)W_CachePatchName("K_STLAPN", PU_HUDGFX); + kp_splitlapflag = (patch_t *)W_CachePatchName("K_SPTLAP", PU_HUDGFX); + kp_bumpersticker = (patch_t *)W_CachePatchName("K_STBALN", PU_HUDGFX); + kp_bumperstickerwide = (patch_t *)W_CachePatchName("K_STBALW", PU_HUDGFX); + kp_karmasticker = (patch_t *)W_CachePatchName("K_STKARM", PU_HUDGFX); + kp_splitkarmabomb = (patch_t *)W_CachePatchName("K_SPTKRM", PU_HUDGFX); + kp_timeoutsticker = (patch_t *)W_CachePatchName("K_STTOUT", PU_HUDGFX); + + // Starting countdown + kp_startcountdown[0] = (patch_t *)W_CachePatchName("K_CNT3A", PU_HUDGFX); + kp_startcountdown[1] = (patch_t *)W_CachePatchName("K_CNT2A", PU_HUDGFX); + kp_startcountdown[2] = (patch_t *)W_CachePatchName("K_CNT1A", PU_HUDGFX); + kp_startcountdown[3] = (patch_t *)W_CachePatchName("K_CNTGOA", PU_HUDGFX); + kp_startcountdown[4] = (patch_t *)W_CachePatchName("K_CNT3B", PU_HUDGFX); + kp_startcountdown[5] = (patch_t *)W_CachePatchName("K_CNT2B", PU_HUDGFX); + kp_startcountdown[6] = (patch_t *)W_CachePatchName("K_CNT1B", PU_HUDGFX); + kp_startcountdown[7] = (patch_t *)W_CachePatchName("K_CNTGOB", PU_HUDGFX); + + // Splitscreen + kp_startcountdown[8] = (patch_t *)W_CachePatchName("K_SMC3A", PU_HUDGFX); + kp_startcountdown[9] = (patch_t *)W_CachePatchName("K_SMC2A", PU_HUDGFX); + kp_startcountdown[10] = (patch_t *)W_CachePatchName("K_SMC1A", PU_HUDGFX); + kp_startcountdown[11] = (patch_t *)W_CachePatchName("K_SMCGOA", PU_HUDGFX); + kp_startcountdown[12] = (patch_t *)W_CachePatchName("K_SMC3B", PU_HUDGFX); + kp_startcountdown[13] = (patch_t *)W_CachePatchName("K_SMC2B", PU_HUDGFX); + kp_startcountdown[14] = (patch_t *)W_CachePatchName("K_SMC1B", PU_HUDGFX); + kp_startcountdown[15] = (patch_t *)W_CachePatchName("K_SMCGOB", PU_HUDGFX); + + // Finish + kp_racefinish[0] = (patch_t *)W_CachePatchName("K_FINA", PU_HUDGFX); + kp_racefinish[1] = (patch_t *)W_CachePatchName("K_FINB", PU_HUDGFX); + + // Splitscreen + kp_racefinish[2] = (patch_t *)W_CachePatchName("K_SMFINA", PU_HUDGFX); + kp_racefinish[3] = (patch_t *)W_CachePatchName("K_SMFINB", PU_HUDGFX); + + // 2P splitscreen + kp_racefinish[4] = (patch_t *)W_CachePatchName("K_2PFINA", PU_HUDGFX); + kp_racefinish[5] = (patch_t *)W_CachePatchName("K_2PFINB", PU_HUDGFX); + + // Position numbers + sprintf(buffer, "K_POSNxx"); + for (i = 0; i < NUMPOSNUMS; i++) + { + buffer[6] = '0'+i; + for (j = 0; j < NUMPOSFRAMES; j++) + { + buffer[7] = '0'+j; + kp_positionnum[i][j] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + } + + sprintf(buffer, "K_POSNWx"); + for (i = 0; i < NUMWINFRAMES; i++) + { + buffer[7] = '0'+i; + kp_winnernum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "OPPRNKxx"); + for (i = 0; i <= MAXPLAYERS; i++) + { + buffer[6] = '0'+(i/10); + buffer[7] = '0'+(i%10); + kp_facenum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "K_CHILIx"); + for (i = 0; i < 8; i++) + { + buffer[7] = '0'+(i+1); + kp_facehighlight[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + // Extra ranking icons + kp_rankbumper = (patch_t *)W_CachePatchName("K_BLNICO", PU_HUDGFX); + kp_tinybumper[0] = (patch_t *)W_CachePatchName("K_BLNA", PU_HUDGFX); + kp_tinybumper[1] = (patch_t *)W_CachePatchName("K_BLNB", PU_HUDGFX); + kp_ranknobumpers = (patch_t *)W_CachePatchName("K_NOBLNS", PU_HUDGFX); + + // Battle graphics + kp_battlewin = (patch_t *)W_CachePatchName("K_BWIN", PU_HUDGFX); + kp_battlecool = (patch_t *)W_CachePatchName("K_BCOOL", PU_HUDGFX); + kp_battlelose = (patch_t *)W_CachePatchName("K_BLOSE", PU_HUDGFX); + kp_battlewait = (patch_t *)W_CachePatchName("K_BWAIT", PU_HUDGFX); + kp_battleinfo = (patch_t *)W_CachePatchName("K_BINFO", PU_HUDGFX); + kp_wanted = (patch_t *)W_CachePatchName("K_WANTED", PU_HUDGFX); + kp_wantedsplit = (patch_t *)W_CachePatchName("4PWANTED", PU_HUDGFX); + kp_wantedreticle = (patch_t *)W_CachePatchName("MMAPWANT", PU_HUDGFX); + + // Kart Item Windows + kp_itembg[0] = (patch_t *)W_CachePatchName("K_ITBG", PU_HUDGFX); + kp_itembg[1] = (patch_t *)W_CachePatchName("K_ITBGD", PU_HUDGFX); + kp_itemtimer[0] = (patch_t *)W_CachePatchName("K_ITIMER", PU_HUDGFX); + kp_itemmulsticker[0] = (patch_t *)W_CachePatchName("K_ITMUL", PU_HUDGFX); + kp_itemx = (patch_t *)W_CachePatchName("K_ITX", PU_HUDGFX); + // Splitscreen + kp_itembg[2] = (patch_t *)W_CachePatchName("K_ISBG", PU_HUDGFX); + kp_itembg[3] = (patch_t *)W_CachePatchName("K_ISBGD", PU_HUDGFX); + kp_itemtimer[1] = (patch_t *)W_CachePatchName("K_ISIMER", PU_HUDGFX); + kp_itemmulsticker[1] = (patch_t *)W_CachePatchName("K_ISMUL", PU_HUDGFX); + + // Kart Items + kp_sneaker[0] = (patch_t *)W_CachePatchName("K_ITSHOE", PU_HUDGFX); + kp_rocketsneaker[0] = (patch_t *)W_CachePatchName("K_ITRSHE", PU_HUDGFX); + kp_banana[0] = (patch_t *)W_CachePatchName("K_ITBANA", PU_HUDGFX); + kp_eggman[0] = (patch_t *)W_CachePatchName("K_ITEGGM", PU_HUDGFX); + kp_jawz[0] = (patch_t *)W_CachePatchName("K_ITJAWZ", PU_HUDGFX); + kp_mine[0] = (patch_t *)W_CachePatchName("K_ITMINE", PU_HUDGFX); + kp_ballhog[0] = (patch_t *)W_CachePatchName("K_ITBHOG", PU_HUDGFX); + kp_selfpropelledbomb[0] = (patch_t *)W_CachePatchName("K_ITSPB", PU_HUDGFX); + kp_grow[0] = (patch_t *)W_CachePatchName("K_ITGROW", PU_HUDGFX); + kp_shrink[0] = (patch_t *)W_CachePatchName("K_ITSHRK", PU_HUDGFX); + kp_thundershield[0] = (patch_t *)W_CachePatchName("K_ITTHNS", PU_HUDGFX); + kp_hyudoro[0] = (patch_t *)W_CachePatchName("K_ITHYUD", PU_HUDGFX); + kp_pogospring[0] = (patch_t *)W_CachePatchName("K_ITPOGO", PU_HUDGFX); + kp_kitchensink[0] = (patch_t *)W_CachePatchName("K_ITSINK", PU_HUDGFX); + kp_sadface[0] = (patch_t *)W_CachePatchName("K_ITSAD", PU_HUDGFX); + // Splitscreen + kp_sneaker[1] = (patch_t *)W_CachePatchName("K_ISSHOE", PU_HUDGFX); + kp_rocketsneaker[1] = (patch_t *)W_CachePatchName("K_ISRSHE", PU_HUDGFX); + kp_banana[1] = (patch_t *)W_CachePatchName("K_ISBANA", PU_HUDGFX); + kp_eggman[1] = (patch_t *)W_CachePatchName("K_ISEGGM", PU_HUDGFX); + kp_orbinaut[4] = (patch_t *)W_CachePatchName("K_ISORBN", PU_HUDGFX); + kp_jawz[1] = (patch_t *)W_CachePatchName("K_ISJAWZ", PU_HUDGFX); + kp_mine[1] = (patch_t *)W_CachePatchName("K_ISMINE", PU_HUDGFX); + kp_ballhog[1] = (patch_t *)W_CachePatchName("K_ISBHOG", PU_HUDGFX); + kp_selfpropelledbomb[1] = (patch_t *)W_CachePatchName("K_ISSPB", PU_HUDGFX); + kp_grow[1] = (patch_t *)W_CachePatchName("K_ISGROW", PU_HUDGFX); + kp_shrink[1] = (patch_t *)W_CachePatchName("K_ISSHRK", PU_HUDGFX); + kp_thundershield[1] = (patch_t *)W_CachePatchName("K_ISTHNS", PU_HUDGFX); + kp_hyudoro[1] = (patch_t *)W_CachePatchName("K_ISHYUD", PU_HUDGFX); + kp_pogospring[1] = (patch_t *)W_CachePatchName("K_ISPOGO", PU_HUDGFX); + kp_kitchensink[1] = (patch_t *)W_CachePatchName("K_ISSINK", PU_HUDGFX); + kp_sadface[1] = (patch_t *)W_CachePatchName("K_ISSAD", PU_HUDGFX); + + sprintf(buffer, "K_ITINVx"); + for (i = 0; i < 7; i++) + { + buffer[7] = '1'+i; + kp_invincibility[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "K_ITORBx"); + for (i = 0; i < 4; i++) + { + buffer[7] = '1'+i; + kp_orbinaut[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "K_ISINVx"); + for (i = 0; i < 6; i++) + { + buffer[7] = '1'+i; + kp_invincibility[i+7] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + // CHECK indicators + sprintf(buffer, "K_CHECKx"); + for (i = 0; i < 6; i++) + { + buffer[7] = '1'+i; + kp_check[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + // Eggman warning numbers + sprintf(buffer, "K_EGGNx"); + for (i = 0; i < 4; i++) + { + buffer[6] = '0'+i; + kp_eggnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + // First person mode + kp_fpview[0] = (patch_t *)W_CachePatchName("VIEWA0", PU_HUDGFX); + kp_fpview[1] = (patch_t *)W_CachePatchName("VIEWB0D0", PU_HUDGFX); + kp_fpview[2] = (patch_t *)W_CachePatchName("VIEWC0E0", PU_HUDGFX); + + // Input UI Wheel + sprintf(buffer, "K_WHEELx"); + for (i = 0; i < 5; i++) + { + buffer[7] = '0'+i; + kp_inputwheel[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + // HERE COMES A NEW CHALLENGER + sprintf(buffer, "K_CHALxx"); + for (i = 0; i < 25; i++) + { + buffer[6] = '0'+((i+1)/10); + buffer[7] = '0'+((i+1)%10); + kp_challenger[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + // Lap start animation + sprintf(buffer, "K_LAP0x"); + for (i = 0; i < 7; i++) + { + buffer[6] = '0'+(i+1); + kp_lapanim_lap[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "K_LAPFxx"); + for (i = 0; i < 11; i++) + { + buffer[6] = '0'+((i+1)/10); + buffer[7] = '0'+((i+1)%10); + kp_lapanim_final[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "K_LAPNxx"); + for (i = 0; i < 10; i++) + { + buffer[6] = '0'+i; + for (j = 0; j < 3; j++) + { + buffer[7] = '0'+(j+1); + kp_lapanim_number[i][j] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + } + + sprintf(buffer, "K_LAPE0x"); + for (i = 0; i < 2; i++) + { + buffer[7] = '0'+(i+1); + kp_lapanim_emblem[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + sprintf(buffer, "K_LAPH0x"); + for (i = 0; i < 3; i++) + { + buffer[7] = '0'+(i+1); + kp_lapanim_hand[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); + } + + kp_yougotem = (patch_t *)W_CachePatchName("YOUGOTEM", PU_HUDGFX); + + if (found_extra_kart || found_extra2_kart || found_extra3_kart) + K_LoadSaturnHUDGraphics(); +} + +// For the item toggle menu +const char *K_GetItemPatch(UINT8 item, boolean tiny) +{ + switch (item) + { + case KITEM_SNEAKER: + case KRITEM_TRIPLESNEAKER: + return (tiny ? "K_ISSHOE" : "K_ITSHOE"); + case KITEM_ROCKETSNEAKER: + return (tiny ? "K_ISRSHE" : "K_ITRSHE"); + case KITEM_INVINCIBILITY: + return (tiny ? "K_ISINV1" : "K_ITINV1"); + case KITEM_BANANA: + case KRITEM_TRIPLEBANANA: + case KRITEM_TENFOLDBANANA: + return (tiny ? "K_ISBANA" : "K_ITBANA"); + case KITEM_EGGMAN: + return (tiny ? "K_ISEGGM" : "K_ITEGGM"); + case KITEM_ORBINAUT: + return (tiny ? "K_ISORBN" : "K_ITORB1"); + case KITEM_JAWZ: + case KRITEM_DUALJAWZ: + return (tiny ? "K_ISJAWZ" : "K_ITJAWZ"); + case KITEM_MINE: + return (tiny ? "K_ISMINE" : "K_ITMINE"); + case KITEM_BALLHOG: + return (tiny ? "K_ISBHOG" : "K_ITBHOG"); + case KITEM_SPB: + return (tiny ? "K_ISSPB" : "K_ITSPB"); + case KITEM_GROW: + return (tiny ? "K_ISGROW" : "K_ITGROW"); + case KITEM_SHRINK: + return (tiny ? "K_ISSHRK" : "K_ITSHRK"); + case KITEM_THUNDERSHIELD: + return (tiny ? "K_ISTHNS" : "K_ITTHNS"); + case KITEM_HYUDORO: + return (tiny ? "K_ISHYUD" : "K_ITHYUD"); + case KITEM_POGOSPRING: + return (tiny ? "K_ISPOGO" : "K_ITPOGO"); + case KITEM_KITCHENSINK: + return (tiny ? "K_ISSINK" : "K_ITSINK"); + case KRITEM_TRIPLEORBINAUT: + return (tiny ? "K_ISORBN" : "K_ITORB3"); + case KRITEM_QUADORBINAUT: + return (tiny ? "K_ISORBN" : "K_ITORB4"); + default: + return (tiny ? "K_ISSAD" : "K_ITSAD"); + } +} + +//} + +INT32 ITEM_X, ITEM_Y; // Item Window +INT32 TIME_X, TIME_Y; // Time Sticker +INT32 LAPS_X, LAPS_Y; // Lap Sticker +INT32 SPDM_X, SPDM_Y; // Speedometer +INT32 POSI_X, POSI_Y; // Position Number +INT32 FACE_X, FACE_Y; // Top-four Faces +INT32 STCD_X, STCD_Y; // Starting countdown +INT32 CHEK_Y; // CHECK graphic +INT32 MINI_X, MINI_Y; // Minimap +INT32 WANT_X, WANT_Y; // Battle WANTED poster + +// This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN. +INT32 ITEM2_X, ITEM2_Y; +INT32 LAPS2_X, LAPS2_Y; +INT32 POSI2_X, POSI2_Y; + +static void K_initKartHUD(void) +{ + /* + BASEVIDWIDTH = 320 + BASEVIDHEIGHT = 200 + + Item window graphic is 41 x 33 + + Time Sticker graphic is 116 x 11 + Time Font is a solid block of (8 x [12) x 14], equal to 96 x 14 + Therefore, timestamp is 116 x 14 altogether + + Lap Sticker is 80 x 11 + Lap flag is 22 x 20 + Lap Font is a solid block of (3 x [12) x 14], equal to 36 x 14 + Therefore, lapstamp is 80 x 20 altogether + + Position numbers are 43 x 53 + + Faces are 32 x 32 + Faces draw downscaled at 16 x 16 + Therefore, the allocated space for them is 16 x 67 altogether + + ---- + + ORIGINAL CZ64 SPLITSCREEN: + + Item window: + if (!splitscreen) { ICONX = 139; ICONY = 20; } + else { ICONX = BASEVIDWIDTH-315; ICONY = 60; } + + Time: 236, STRINGY( 12) + Lap: BASEVIDWIDTH-304, STRINGY(BASEVIDHEIGHT-189) + + */ + + // Single Screen (defaults) + // Item Window + ITEM_X = 5 + cv_item_xoffset.value; // 5 + ITEM_Y = 5 + cv_item_yoffset.value; // 5 + // Level Timer + TIME_X = BASEVIDWIDTH - 148 + cv_time_xoffset.value; // 172 + TIME_Y = 9 + cv_time_yoffset.value; // 9 + // Level Laps + LAPS_X = 9 + cv_laps_xoffset.value; // 9 + LAPS_Y = BASEVIDHEIGHT - 29 + cv_laps_yoffset.value; // 171 + // Speedometer + SPDM_X = 9 + cv_speed_xoffset.value; // 9 + SPDM_Y = BASEVIDHEIGHT - 45 + cv_speed_yoffset.value; // 155 + // Position Number + POSI_X = BASEVIDWIDTH - 9 + cv_posi_xoffset.value; // 268 + POSI_Y = BASEVIDHEIGHT - 9 + cv_posi_yoffset.value; // 138 + // Top-Four Faces + FACE_X = 9 + cv_face_xoffset.value; // 9 + FACE_Y = 92 + cv_face_yoffset.value; // 92 + // Starting countdown + STCD_X = BASEVIDWIDTH/2 + cv_stcd_xoffset.value; // 9 + STCD_Y = BASEVIDHEIGHT/2 + cv_stcd_yoffset.value; // 92 + // CHECK graphic + CHEK_Y = BASEVIDHEIGHT + cv_chek_yoffset.value; // 200 + // Minimap + MINI_X = BASEVIDWIDTH - 50 + cv_mini_xoffset.value; // 270 + MINI_Y = (BASEVIDHEIGHT/2)-16 + cv_mini_yoffset.value; // 84 + // Battle WANTED poster + WANT_X = BASEVIDWIDTH - 55 + cv_want_xoffset.value; // 270 + WANT_Y = BASEVIDHEIGHT- 71 + cv_want_yoffset.value; // 176 + + if (splitscreen) // Splitscreen + { + ITEM_X = 5; + ITEM_Y = 3; + + LAPS_Y = (BASEVIDHEIGHT/2)-24; + + POSI_Y = (BASEVIDHEIGHT/2)- 2; + + STCD_Y = BASEVIDHEIGHT/4; + + MINI_Y = (BASEVIDHEIGHT/2); + + if (splitscreen > 1) // 3P/4P Small Splitscreen + { + // 1P (top left) + ITEM_X = -9; + ITEM_Y = -8; + + LAPS_X = 3; + LAPS_Y = (BASEVIDHEIGHT/2)-13; + + POSI_X = 24; + POSI_Y = (BASEVIDHEIGHT/2)- 16; + + // 2P (top right) + ITEM2_X = BASEVIDWIDTH-39; + ITEM2_Y = -8; + + LAPS2_X = BASEVIDWIDTH-3; + LAPS2_Y = (BASEVIDHEIGHT/2)-13; + + POSI2_X = BASEVIDWIDTH -4; + POSI2_Y = (BASEVIDHEIGHT/2)- 16; + + // Reminder that 3P and 4P are just 1P and 2P splitscreen'd to the bottom. + + STCD_X = BASEVIDWIDTH/4; + + MINI_X = (3*BASEVIDWIDTH/4); + MINI_Y = (3*BASEVIDHEIGHT/4); + + if (splitscreen > 2) // 4P-only + { + MINI_X = (BASEVIDWIDTH/2); + MINI_Y = (BASEVIDHEIGHT/2); + } + } + } + + if (timeinmap > 113 || forceshowhud) + hudtrans = cv_translucenthud.value; + else if (timeinmap > 105) + hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105); + else + hudtrans = 0; + + // K_GetScreenCoords needs the right view* variables + R_SetViewContext(stplyrnum); + R_InterpolateView(rendertimefrac_unpaused, !cv_uncappedhud.value); +} + +UINT8 K_GetHudColor(void) +{ + if (cv_colorizedhud.value && cv_colorizedhudcolor.value) + return cv_colorizedhudcolor.value; + + return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : cv_playercolor.value); +} + +boolean K_UseColorHud(void) +{ + return (cv_colorizedhud.value && clr_hud); +} + +enum +{ + SPEEDO_VANILLA, + SPEEDO_EXTRA, + SPEEDO_ACHII, + SPEEDO_DIAL, + SPEEDO_PMETER, + SPEEDO_PMETERSMOL, + SPEEDO_EXTRA3, +}; + +static SINT8 K_GetSpeedometerStyle(void) +{ + if (cv_newspeedometer.value == 2 && xtra_speedo) + return SPEEDO_EXTRA; + else if (cv_newspeedometer.value == 3 && achi_speedo) + return SPEEDO_ACHII; + else if (cv_newspeedometer.value == 4 && dial_speedo) + return SPEEDO_DIAL; + else if (cv_newspeedometer.value == 5 && kartz_speedo) + return SPEEDO_PMETER; + else if (cv_newspeedometer.value == 6 && kartz_speedo_smol) + return SPEEDO_PMETERSMOL; + else if (cv_newspeedometer.value == 7 && xtra_speedo3) + return SPEEDO_EXTRA3; + else + return SPEEDO_VANILLA; +} + +static boolean K_UseColorSpeedo(int speedostyle) +{ + if (!K_UseColorHud()) + return false; + + switch (speedostyle) + { + case SPEEDO_EXTRA: + return xtra_speedo_clr; + case SPEEDO_ACHII: + return achi_speedo_clr; + case SPEEDO_DIAL: + return dial_speedo_clr; + case SPEEDO_EXTRA3: + return xtra_speedo_clr3; + default: + return false; + } +} + +static boolean K_IsHighResolution(void) +{ + return (vid.width >= 640 && vid.height >= 400); +} + +boolean K_UseHighResPortraits(void) +{ + return (cv_highresportrait.value && K_IsHighResolution()); +} + +// returns the players faceprefix +// accounts for localskins +patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum) +{ + if (!player->skinlocal) + return (K_UseHighResPortraits() ? facewantprefix[skinnum] : facerankprefix[skinnum]); + else + return (K_UseHighResPortraits() ? localfacewantprefix[skinnum] : localfacerankprefix[skinnum]); +} + +INT32 K_calcSplitFlags(INT32 snapflags) +{ + INT32 splitflags = 0; + + if (splitscreen == 0) + return snapflags; + + if (stplyrnum != 0) + { + if (splitscreen == 1 && stplyrnum == 1) + { + splitflags |= V_SPLITSCREEN; + } + else if (splitscreen > 1) + { + if (stplyrnum == 2 || (splitscreen == 3 && stplyrnum == 3)) + splitflags |= V_SPLITSCREEN; + if (stplyrnum == 1 || (splitscreen == 3 && stplyrnum == 3)) + splitflags |= V_HORZSCREEN; + } + } + + if (splitflags & V_SPLITSCREEN) + snapflags &= ~V_SNAPTOTOP; + else + snapflags &= ~V_SNAPTOBOTTOM; + + if (splitscreen > 1) + { + if (splitflags & V_HORZSCREEN) + snapflags &= ~V_SNAPTOLEFT; + else + snapflags &= ~V_SNAPTORIGHT; + } + + return (splitflags|snapflags); +} + +void K_getItemBoxDrawinfo(drawinfo_t *out) +{ + INT32 fx, fy, fflags; + + // pain and suffering defined below + if (splitscreen < 2) // don't change shit for THIS splitscreen. + { + fx = ITEM_X; + fy = ITEM_Y; + fflags = K_calcSplitFlags(V_SNAPTOTOP|V_SNAPTOLEFT); + } + else // now we're having a fun game. + { + if (!(stplyrnum & 1)) // If we are P1 or P3... + { + fx = ITEM_X; + fy = ITEM_Y; + fflags = V_SNAPTOLEFT|(stplyrnum & 2 ? V_SPLITSCREEN : V_SNAPTOTOP); // flip P3 to the bottom. + } + else // else, that means we're P2 or P4. + { + fx = ITEM2_X; + fy = ITEM2_Y; + fflags = V_SNAPTORIGHT|(stplyrnum & 2 ? V_SPLITSCREEN : V_SNAPTOTOP); // flip P4 to the bottom + } + } + + out->x = fx; + out->y = fy; + out->flags = fflags; +} + +void K_getLapsDrawinfo(drawinfo_t *out) +{ + INT32 fx, fy, fflags; + + // pain and suffering defined below + if (splitscreen < 2) // don't change shit for THIS splitscreen. + { + fx = LAPS_X; + fy = LAPS_Y; + fflags = K_calcSplitFlags(V_SNAPTOBOTTOM|V_SNAPTOLEFT); + } + else + { + if (!(stplyrnum & 1)) // If we are P1 or P3... + { + fx = LAPS_X; + fy = LAPS_Y; + fflags = V_SNAPTOLEFT|(stplyrnum & 2 ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. + } + else // else, that means we're P2 or P4. + { + fx = LAPS2_X; + fy = LAPS2_Y; + fflags = V_SNAPTORIGHT|(stplyrnum & 2 ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom + } + } + + out->x = fx; + out->y = fy; + out->flags = fflags; +} + +void K_getMinimapDrawinfo(drawinfo_t *out) +{ + INT32 fx = MINI_X, fy = MINI_Y, fflags = (splitscreen == 3 ? 0 : V_SNAPTORIGHT); // flags should only be 0 when it's centered (4p split) + + out->x = fx; + out->y = fy; + out->flags = fflags; +} + +INT32 K_getMinimapTrans(void) +{ + INT32 minimaptrans = cv_kartminimap.value; + + if (!minimaptrans) + return -1; + + if (forceshowhud) + return (10-minimaptrans)<kartstuff[k_bumper] ? -5 : -8) : 0); + + // Customizations c: + if (!splitscreen) + { + x += 18 + cv_stat_xoffset.value + spdxoffset; + y += cv_stat_yoffset.value + spdoffset; + } + else if (splitscreen == 1) // I tried my best, but this is still mess :/ < :Blobcatpats: c: + { + x -= 10; + y -= 40; + y += spdoffset; + + // If we are in 2-player splitscreen, for player 1 we move hud to up and remove snapping + // to bottom + if (splitnum == 0) + { + y /= 2; + flags = V_SNAPTOLEFT; + } + else + { + // Can move it down a bit + y += 45; + } + } + else + { + if (splitnum == 0 || splitnum == 2) // If we are P1 or P3... + { + // ye i just align it to position number lol + x = POSI_X + 19; + y = POSI_Y - 6; + flags = V_SNAPTOLEFT|((splitnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. + } + else // else, that means we're P2 or P4. + { + x = POSI2_X - 75; + y = POSI2_Y - 6; + flags = V_SNAPTORIGHT|((splitnum == 3) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom + } + } + + flags |= V_HUDTRANS; + + skin_t *fakeskin; + fakeskin = K_GetPlayerSkin(stplyr); + + if (!splitscreen) + { + // Skin name + if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel + { + V_DrawSmallString(x+20, y+12, flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor), fakeskin->realname); + } + else + { + V_DrawThinString(x+20, y+7, flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor), fakeskin->realname); + } + + // Icon and stats + if (K_UseHighResPortraits()) + V_DrawSmallMappedPatch(x, y, flags, R_GetSkinFaceWant(stplyr), R_GetLocalTranslationColormap(fakeskin, fakeskin, stplyr->skincolor, GTC_CACHE, stplyr->skinlocal)); + else + V_DrawMappedPatch(x, y, flags, R_GetSkinFaceRank(stplyr), R_GetLocalTranslationColormap(fakeskin, fakeskin, stplyr->skincolor, GTC_CACHE, stplyr->skinlocal)); + + V_DrawMappedPatch(x-3, y-2, flags, kp_facenum[min(9, max(1, stplyr->kartspeed))], R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_BLUEBERRY, GTC_CACHE)); + V_DrawMappedPatch(x+10, y+10, flags, kp_facenum[min(9, max(1, stplyr->kartweight))], R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_BURGUNDY, GTC_CACHE)); + } + else + { + // In splitscreen, just draw a string with stats + V_DrawString(x, y+10, flags, va("\x84%dS \x87%dW", stplyr->kartspeed, stplyr->kartweight)); + } +} + +static void K_drawKartItem(void) +{ + // ITEM_X = BASEVIDWIDTH-50; // 270 + // ITEM_Y = 24; // 24 + + // Why write V_DrawScaledPatch calls over and over when they're all the same? + // Set to 'no item' just in case. + const UINT8 offset = ((splitscreen > 1) ? 1 : 0); + patch_t *localpatch = kp_nodraw; + patch_t *localbg; + boolean dark = false; + + patch_t *localinv = ((offset) ? kp_invincibility[((leveltime % (6*3)) / 3) + 7] : kp_invincibility[(leveltime % (7*3)) / 3]); + INT32 fx = 0, fy = 0, fflags = 0; // final coords for hud and flags... + INT32 numberdisplaymin = cv_huditemamount.value == 2 ? 1 : 2; // No longer a constant so other things can modify this value + INT32 itembar = 0; + INT32 maxl = 0; // itembar's normal highest value + const INT32 barlength = (splitscreen > 1 ? 12 : 26); + UINT8 localcolor = SKINCOLOR_NONE; + SINT8 colormode = TC_RAINBOW; + UINT8 *colmap = NULL; + UINT8 *colormap = NULL; + + if (stplyr->kartstuff[k_itemroulette]) + { + localcolor = K_GetHudColor(); + + switch((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3) + { + // Each case is handled in threes, to give three frames of in-game time to see the item on the roulette + case 0: // Sneaker + localpatch = kp_sneaker[offset]; + //localcolor = SKINCOLOR_RASPBERRY; + break; + case 1: // Banana + localpatch = kp_banana[offset]; + //localcolor = SKINCOLOR_YELLOW; + break; + case 2: // Orbinaut + localpatch = kp_orbinaut[3+offset]; + //localcolor = SKINCOLOR_STEEL; + break; + case 3: // Mine + localpatch = kp_mine[offset]; + //localcolor = SKINCOLOR_JET; + break; + case 4: // Grow + localpatch = kp_grow[offset]; + //localcolor = SKINCOLOR_TEAL; + break; + case 5: // Hyudoro + localpatch = kp_hyudoro[offset]; + //localcolor = SKINCOLOR_STEEL; + break; + case 6: // Rocket Sneaker + localpatch = kp_rocketsneaker[offset]; + //localcolor = SKINCOLOR_TANGERINE; + break; + case 7: // Jawz + localpatch = kp_jawz[offset]; + //localcolor = SKINCOLOR_JAWZ; + break; + case 8: // Self-Propelled Bomb + localpatch = kp_selfpropelledbomb[offset]; + //localcolor = SKINCOLOR_JET; + break; + case 9: // Shrink + localpatch = kp_shrink[offset]; + //localcolor = SKINCOLOR_ORANGE; + break; + case 10: // Invincibility + localpatch = localinv; + //localcolor = SKINCOLOR_GREY; + break; + case 11: // Eggman Monitor + localpatch = kp_eggman[offset]; + //localcolor = SKINCOLOR_ROSE; + break; + case 12: // Ballhog + localpatch = kp_ballhog[offset]; + //localcolor = SKINCOLOR_LILAC; + break; + case 13: // Thunder Shield + localpatch = kp_thundershield[offset]; + //localcolor = SKINCOLOR_CYAN; + break; + /*case 14: // Pogo Spring + localpatch = kp_pogospring[offset]; + localcolor = SKINCOLOR_TANGERINE; + break; + case 15: // Kitchen Sink + localpatch = kp_kitchensink[offset]; + localcolor = SKINCOLOR_STEEL; + break;*/ + default: + break; + } + } + else + { + // I'm doing this a little weird and drawing mostly in reverse order + // The only actual reason is to make sneakers line up this way in the code below + // This shouldn't have any actual baring over how it functions + // Hyudoro is first, because we're drawing it on top of the player's current item + if (stplyr->kartstuff[k_stolentimer] > 0) + { + if (leveltime & 2) + localpatch = kp_hyudoro[offset]; + else + localpatch = kp_nodraw; + } + else if ((stplyr->kartstuff[k_stealingtimer] > 0) && (leveltime & 2)) + { + localpatch = kp_hyudoro[offset]; + } + else if (stplyr->kartstuff[k_eggmanexplode] > 1) + { + if (leveltime & 1) + localpatch = kp_eggman[offset]; + else + localpatch = kp_nodraw; + } + else if (stplyr->kartstuff[k_rocketsneakertimer] > 1) + { + itembar = stplyr->kartstuff[k_rocketsneakertimer]; + maxl = (itemtime*3) - barlength; + + if (leveltime & 1) + localpatch = kp_rocketsneaker[offset]; + else + localpatch = kp_nodraw; + } + else if (stplyr->kartstuff[k_growshrinktimer] > 0) + { + if (stplyr->kartstuff[k_growcancel] > 0) + { + itembar = stplyr->kartstuff[k_growcancel]; + maxl = 26; + } + + if (leveltime & 1) + localpatch = kp_grow[offset]; + else + localpatch = kp_nodraw; + } + else if (stplyr->kartstuff[k_sadtimer] > 0) + { + if (leveltime & 2) + localpatch = kp_sadface[offset]; + else + localpatch = kp_nodraw; + } + else + { + if (stplyr->kartstuff[k_itemamount] <= 0) + return; + + const boolean usemultiicon = (multiitem_icon && cv_multiitemicon.value && !offset); + + switch (stplyr->kartstuff[k_itemtype]) + { + case KITEM_SNEAKER: + if (usemultiicon) + { + if (!cv_huditemamount.value) + numberdisplaymin = 4; + switch(stplyr->kartstuff[k_itemamount]) + { + case 1: + localpatch = kp_sneaker[offset]; + break; + case 2: + localpatch = kp_multsneaker[0]; + break; + default: + localpatch = kp_multsneaker[1]; + break; + } + } + else + { + localpatch = kp_sneaker[offset]; + } + break; + case KITEM_ROCKETSNEAKER: + localpatch = kp_rocketsneaker[offset]; + break; + case KITEM_INVINCIBILITY: + localpatch = localinv; + dark = true; + break; + case KITEM_BANANA: + if (usemultiicon) + { + if (!cv_huditemamount.value) + numberdisplaymin = 4; + switch(stplyr->kartstuff[k_itemamount]) + { + case 1: + localpatch = kp_banana[offset]; + break; + case 2: + localpatch = kp_multbanana[0]; + break; + case 3: + localpatch = kp_multbanana[1]; + break; + default: + localpatch = kp_multbanana[2]; + break; + } + } + else + { + localpatch = kp_banana[offset]; + } + break; + case KITEM_EGGMAN: + localpatch = kp_eggman[offset]; + break; + case KITEM_ORBINAUT: + if (!cv_huditemamount.value) + numberdisplaymin = offset ? 2 : 5; + localpatch = kp_orbinaut[(offset ? 4 : min(stplyr->kartstuff[k_itemamount]-1, 3))]; + break; + case KITEM_JAWZ: + if (usemultiicon) + { + if (!cv_huditemamount.value) + numberdisplaymin = 3; + localpatch = ((stplyr->kartstuff[k_itemamount] == 1) ? kp_jawz[offset] : kp_multjawz); + } + else + { + localpatch = kp_jawz[offset]; + } + break; + case KITEM_MINE: + localpatch = kp_mine[offset]; + break; + case KITEM_BALLHOG: + localpatch = kp_ballhog[offset]; + break; + case KITEM_SPB: + localpatch = kp_selfpropelledbomb[offset]; + dark = true; + break; + case KITEM_GROW: + localpatch = kp_grow[offset]; + break; + case KITEM_SHRINK: + localpatch = kp_shrink[offset]; + break; + case KITEM_THUNDERSHIELD: + localpatch = kp_thundershield[offset]; + dark = true; + break; + case KITEM_HYUDORO: + localpatch = kp_hyudoro[offset]; + break; + case KITEM_POGOSPRING: + localpatch = kp_pogospring[offset]; + break; + case KITEM_KITCHENSINK: + localpatch = kp_kitchensink[offset]; + break; + case KITEM_SAD: + localpatch = kp_sadface[offset]; + break; + default: + return; + } + + if (stplyr->kartstuff[k_itemheld] && !(leveltime & 1)) + localpatch = kp_nodraw; + } + + if (stplyr->kartstuff[k_itemblink] && (leveltime & 1)) + { + colormode = TC_BLINK; + + switch (stplyr->kartstuff[k_itemblinkmode]) + { + case 2: + localcolor = (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1))); + break; + case 1: + localcolor = SKINCOLOR_RED; + break; + default: + localcolor = SKINCOLOR_WHITE; + break; + } + } + } + + localbg = K_getItemBoxPatch((boolean)offset, dark); + drawinfo_t info; + K_getItemBoxDrawinfo(&info); + fx = info.x; + fy = info.y; + fflags = info.flags; + + boolean flipamount = splitscreen > 1 && stplyrnum & 1; // Used for 3P/4P splitscreen to flip item amount stuff + + if (K_UseColorHud()) + colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + + V_DrawMappedPatch(fx, fy, V_HUDTRANS|fflags, localbg, cv_colorizeditembox.value ? colormap : NULL); + + fixed_t rfy = fy<kartstuff[k_itemroulette] && !stplyr->deadtimer) + { + fixed_t frac = R_GetHudUncap(); + UINT8 fancystep = (offset ? 6 : 10); + fixed_t fancyoffset = (stplyr->kartstuff[k_itemroulette] % 3)-1; + + if (fancyoffset != 0) + { + fancyflags &= ~V_HUDTRANS; + fancyflags |=V_HUDTRANSHALF; + } + + rfy += (fancystep * fancyoffset * FRACUNIT) + FixedMul(fancystep*FRACUNIT, frac) - fancystep/2*FRACUNIT; + } + + if (localcolor != SKINCOLOR_NONE) + colmap = R_GetTranslationColormap(colormode, localcolor, GTC_CACHE); + + // Then, the numbers: + if (stplyr->kartstuff[k_itemamount] >= numberdisplaymin && !stplyr->kartstuff[k_itemroulette]) + { + localbg = K_getItemMulPatch((boolean)offset); + + V_DrawMappedPatch(fx + (flipamount ? 48 : 0), fy, V_HUDTRANS|fflags|(flipamount ? V_FLIP : 0), localbg, colormap); // flip this graphic for p2 and p4 in split and shift it. + V_DrawFixedPatch(fx<kartstuff[k_itemamount])); + } + else + { + V_DrawScaledPatch(fx+28, fy+41, V_HUDTRANS|fflags, kp_itemx); + V_DrawKartString(fx+38, fy+36, V_HUDTRANS|fflags, va("%d", stplyr->kartstuff[k_itemamount])); + } + } + else + V_DrawFixedPatch(fx< 2) + { + V_DrawFill(fx+x+length, fy+y+1, 1, height, 12|fflags); // the right one + if (height == 2) + V_DrawFill(fx+x+2, fy+y+2, length-2, 1, 8|fflags); // the dulled underside + V_DrawFill(fx+x+2, fy+y+1, length-2, 1, 120|fflags); // the shine + } + } + + // Quick Eggman numbers + if (stplyr->kartstuff[k_eggmanexplode] > 1 /*&& stplyr->kartstuff[k_eggmanexplode] <= 3*TICRATE*/) + V_DrawScaledPatch(fx+17, fy+13-offset, V_HUDTRANS|fflags, kp_eggnum[min(3, G_TicsToSeconds(stplyr->kartstuff[k_eggmanexplode]))]); +} + +void K_drawKartTimestamp(tic_t drawtime, INT32 TX, INT32 TY, INT16 emblemmap, UINT8 mode) +{ + // TIME_X = BASEVIDWIDTH-124; // 196 + // TIME_Y = 6; // 6 + + INT32 splitflags = 0; + + if (!mode) + { + splitflags = V_HUDTRANS|K_calcSplitFlags(V_SNAPTOTOP|V_SNAPTORIGHT); + if (cv_timelimit.value && timelimitintics > 0) + { + if (drawtime >= timelimitintics) + drawtime = 0; + else + drawtime = timelimitintics - drawtime; + } + } + + if (K_UseColorHud()) // Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + V_DrawMappedPatch(TX, TY, splitflags, ((mode == 2) ? kp_lapstickerwideclr : kp_timestickerwideclr), colormap); + } + else + V_DrawScaledPatch(TX, TY, splitflags, ((mode == 2) ? kp_lapstickerwide : kp_timestickerwide)); + + TX += 33; + + if (drawtime == UINT32_MAX) + ; + else if (mode && !drawtime) + { + V_DrawKartString(TX, TY+3, splitflags, va("--'--\"--")); + } + else + { + tic_t worktime = drawtime/(60*TICRATE); + + if (cv_timelimit.value && cv_overtime.value && G_BattleGametype() && !players[consoleplayer].exiting && (leveltime > (timelimitintics + starttime + TICRATE/2))) // i hate this so much + { + V_DrawKartString(TX, TY+3, splitflags, va("OVERTIME")); + } + else if (worktime < 100) + { + // minutes time 00 __ __ + V_DrawKartString(TX, TY+3, splitflags, va("%d", worktime/10)); + V_DrawKartString(TX+12, TY+3, splitflags, va("%d", worktime%10)); + + // apostrophe location _'__ __ + V_DrawKartString(TX+24, TY+3, splitflags, va("'")); + + worktime = (drawtime/TICRATE % 60); + + // seconds time _ 00 __ + V_DrawKartString(TX+36, TY+3, splitflags, va("%d", worktime/10)); + V_DrawKartString(TX+48, TY+3, splitflags, va("%d", worktime%10)); + + // quotation mark location _ __"__ + V_DrawKartString(TX+60, TY+3, splitflags, va("\"")); + + worktime = G_TicsToCentiseconds(drawtime); + + // tics _ __ 00 + V_DrawKartString(TX+72, TY+3, splitflags, va("%d", worktime/10)); + V_DrawKartString(TX+84, TY+3, splitflags, va("%d", worktime%10)); + } + else if ((drawtime/TICRATE) & 1) + V_DrawKartString(TX, TY+3, splitflags, va("99'59\"99")); + } + + if (emblemmap && (modeattacking || (mode == 1)) && !demo.playback) // emblem time! + { + INT32 workx = TX + 96, worky = TY+18; + SINT8 curemb = 0; + patch_t *emblempic[3] = {NULL, NULL, NULL}; + UINT8 *emblemcol[3] = {NULL, NULL, NULL}; + + emblem_t *emblem = M_GetLevelEmblems(emblemmap); + while (emblem) + { + char targettext[9]; + + switch (emblem->type) + { + case ET_TIME: + { + static boolean canplaysound = true; + tic_t timetoreach = emblem->var; + + if (emblem->collected) + { + emblempic[curemb] = W_CachePatchName(M_GetEmblemPatch(emblem), PU_PATCH); + emblemcol[curemb] = R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE); + if (++curemb == 3) + break; + goto bademblem; + } + + snprintf(targettext, 9, "%i'%02i\"%02i", + G_TicsToMinutes(timetoreach, false), + G_TicsToSeconds(timetoreach), + G_TicsToCentiseconds(timetoreach)); + + if (!mode) + { + if (stplyr->realtime > timetoreach) + { + splitflags = (splitflags &~ V_HUDTRANS)|V_HUDTRANSHALF; + if (canplaysound) + { + S_StartSound(NULL, sfx_s3k72); //sfx_s26d); -- you STOLE fizzy lifting drinks + canplaysound = false; + } + } + else if (!canplaysound) + canplaysound = true; + } + + targettext[8] = 0; + } + break; + default: + goto bademblem; + } + + V_DrawRightAlignedString(workx, worky, splitflags, targettext); + workx -= 67; + V_DrawSmallScaledPatch(workx + 4, worky, splitflags, W_CachePatchName("NEEDIT", PU_PATCH)); + + break; + + bademblem: + emblem = M_GetLevelEmblems(-1); + } + + if (!mode) + splitflags = (splitflags &~ V_HUDTRANSHALF)|V_HUDTRANS; + + while (curemb--) + { + workx -= 12; + V_DrawSmallMappedPatch(workx + 4, worky, splitflags, emblempic[curemb], emblemcol[curemb]); + } + } +} + +static void K_DrawKartPositionNum(INT32 num) +{ + // POSI_X = BASEVIDWIDTH - 51; // 269 + // POSI_Y = BASEVIDHEIGHT- 64; // 136 + + const boolean wheeloffs = (cv_showinput.value && cv_posi_xoffset.value == 0 && cv_posi_yoffset.value == 0 && cv_wheel_xoffset.value == 0 && cv_wheel_yoffset.value == 0); + const boolean win = (stplyr->exiting && num == 1); + INT32 W = kp_positionnum[0][0]->width; + fixed_t scale = FRACUNIT; + patch_t *localpatch = kp_positionnum[0][0]; + INT32 addOrSub = B_SUBTRACT; + INT32 fx = 0, fy = 0, fflags = 0; + const INT32 xoffs = wheeloffs ? -48 : 0; + boolean flipdraw = false; // flip the order we draw it in for MORE splitscreen bs. fun. + boolean flipvdraw = false; // used only for 2p splitscreen so overtaking doesn't make 1P's position fly off the screen. + boolean overtake = false; + + if ((mapheaderinfo[gamemap - 1]->levelflags & LF_SUBTRACTNUM) == LF_SUBTRACTNUM) + { + addOrSub = B_ADD; + } + + if ((cv_posanim.value && stplyr->kartstuff[k_positiondelay]) || stplyr->exiting) + { + scale *= 2; + overtake = true; // this is used for splitscreen stuff in conjunction with flipdraw. + } + + if (splitscreen || cv_smallposnum.value || wheeloffs) + { + scale /= 2; + } + + W = FixedMul(W<>FRACBITS; + + // pain and suffering defined below + if (!splitscreen) + { + fx = POSI_X + xoffs; + fy = BASEVIDHEIGHT - 8 + cv_posi_yoffset.value; + fflags = V_SNAPTOBOTTOM|V_SNAPTORIGHT; + } + else if (splitscreen == 1) // for this splitscreen, we'll use case by case because it's a bit different. + { + fx = POSI_X; + if (stplyrnum == 0) // for player 1: display this at the top right, above the minimap. + { + fy = 30 + cv_posi_yoffset.value; + fflags = V_SNAPTOTOP|V_SNAPTORIGHT; + if (overtake) + flipvdraw = true; // make sure overtaking doesn't explode us + } + else // if we're not p1, that means we're p2. display this at the bottom right, below the minimap. + { + fy = BASEVIDHEIGHT - 8 + cv_posi_yoffset.value; + fflags = V_SNAPTOBOTTOM|V_SNAPTORIGHT; + } + } + else + { + if (!(stplyrnum & 1)) // If we are P1 or P3... + { + fx = POSI_X; + fy = POSI_Y; + fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. + flipdraw = true; + if (num && num >= 10) + fx += W; // this seems dumb, but we need to do this in order for positions above 10 going off screen. + } + else // else, that means we're P2 or P4. + { + fx = POSI2_X; + fy = POSI2_Y; + fflags = V_SNAPTORIGHT|((stplyrnum == 3) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom + } + } + + // Special case for 0 + if (num <= 0) + { + V_DrawBlendingFixedPatch(fx<laps+1 >= cv_numlaps.value || stplyr->exiting) // Check for the final lap, or won + { + boolean useRedNums = K_IsPlayerLosing(stplyr); + + if (addOrSub == B_SUBTRACT) + { + // Subtracting RED will look BLUE, and vice versa. + useRedNums = !useRedNums; + } + + // Alternate frame every three frames + switch ((leveltime % 9) / 3) + { + case 0: + if (useRedNums == true) + localpatch = kp_positionnum[num % 10][4]; + else + localpatch = kp_positionnum[num % 10][1]; + break; + case 1: + if (useRedNums == true) + localpatch = kp_positionnum[num % 10][5]; + else + localpatch = kp_positionnum[num % 10][2]; + break; + case 2: + if (useRedNums == true) + localpatch = kp_positionnum[num % 10][6]; + else + localpatch = kp_positionnum[num % 10][3]; + break; + default: + localpatch = kp_positionnum[num % 10][0]; + break; + } + } + else + { + localpatch = kp_positionnum[num % 10][0]; + } + + V_DrawBlendingFixedPatch((fx<width*scale/2) : 0), (fy<height*scale/2) : 0), scale, V_HUDTRANSHALF|fflags, localpatch, NULL, addOrSub); + // ^ if we overtake as p1 or p3 in splitscren, we shift it so that it doesn't go off screen. + // ^ if we overtake as p1 in 2p splits, shift vertically so that this doesn't happen either. + + fx -= W; + num /= 10; + } +} + +static boolean K_drawKartPositionFaces(void) +{ + // FACE_X = 15; // 15 + // FACE_Y = 72; // 72 + + INT32 Y = FACE_Y+9; // +9 to offset where it's being drawn if there are more than one + INT32 i, j, ranklines, strank = -1; + boolean completed[MAXPLAYERS]; + INT32 rankplayer[MAXPLAYERS]; + INT32 bumperx, numplayersingame = 0; + UINT8 *colormap; + + ranklines = 0; + memset(completed, 0, sizeof (completed)); + memset(rankplayer, 0, sizeof (rankplayer)); + + for (i = 0; i < MAXPLAYERS; i++) + { + rankplayer[i] = -1; + + if (!playeringame[i] || players[i].spectator || !players[i].mo) + continue; + + numplayersingame++; + } + + if (numplayersingame <= 1) + return true; + + if (!LUA_HudEnabled(hud_minirankings)) + return false; // Don't proceed but still return true for free play above if HUD is disabled. + + for (j = 0; j < numplayersingame; j++) + { + UINT8 lowestposition = MAXPLAYERS+1; + for (i = 0; i < MAXPLAYERS; i++) + { + if (completed[i] || !playeringame[i] || players[i].spectator || !players[i].mo) + continue; + + if (players[i].kartstuff[k_position] >= lowestposition) + continue; + + rankplayer[ranklines] = i; + lowestposition = players[i].kartstuff[k_position]; + } + + i = rankplayer[ranklines]; + + completed[i] = true; + + if (players+i == stplyr) + strank = ranklines; + + ranklines++; + } + + if (ranklines < 5) + Y -= (9*ranklines); + else + Y -= (9*5); + + if (G_BattleGametype() || strank <= 2) // too close to the top, or playing battle, or a spectator? would have had (strank == -1) called out, but already caught by (strank <= 2) + { + i = 0; + if (ranklines > 5) // could be both... + ranklines = 5; + } + else if (strank+3 > ranklines) // too close to the bottom? + { + i = ranklines - 5; + if (i < 0) + i = 0; + } + else + { + i = strank-2; + ranklines = strank+3; + } + + for (; i < ranklines; i++) + { + player_t *player; + player = &players[rankplayer[i]]; + + if (!playeringame[rankplayer[i]]) + continue; + if (player->spectator) + continue; + if (!player->mo) + continue; + + const UINT8 mocolor = player->mo->color; + + bumperx = FACE_X+19; + + if (mocolor) + { + colormap = R_GetTranslationColormap(player->skin, mocolor, GTC_CACHE); + if (player->mo->colorized) + colormap = R_GetTranslationColormap(TC_RAINBOW, mocolor, GTC_CACHE); + + if (K_UseHighResPortraits()) + V_DrawSmallMappedPatch(FACE_X, Y, V_HUDTRANS|V_SNAPTOLEFT, R_GetSkinFaceWant(player), colormap); + else + V_DrawMappedPatch(FACE_X, Y, V_HUDTRANS|V_SNAPTOLEFT, R_GetSkinFaceRank(player), colormap); + + if (LUA_HudEnabled(hud_battlebumpers)) + { + if (G_BattleGametype() && player->kartstuff[k_bumper] > 0) + { + V_DrawMappedPatch(bumperx-2, Y, V_HUDTRANS|V_SNAPTOLEFT, kp_tinybumper[0], colormap); + for (j = 1; j < player->kartstuff[k_bumper]; j++) + { + bumperx += 5; + V_DrawMappedPatch(bumperx, Y, V_HUDTRANS|V_SNAPTOLEFT, kp_tinybumper[1], colormap); + } + } + } // A new level of stupidity: checking if lua is enabled to close a bracket. :Fascinating: + } + + if (i == strank) + V_DrawScaledPatch(FACE_X, Y, V_HUDTRANS|V_SNAPTOLEFT, kp_facehighlight[(leveltime / 4) % 8]); + + if (G_BattleGametype() && player->kartstuff[k_bumper] <= 0) + V_DrawScaledPatch(FACE_X-4, Y-3, V_HUDTRANS|V_SNAPTOLEFT, kp_ranknobumpers); + else + { + INT32 pos = player->kartstuff[k_position]; + if (pos < 0 || pos > MAXPLAYERS) + pos = 0; + // Draws the little number over the face + V_DrawScaledPatch(FACE_X-5, Y+10, V_HUDTRANS|V_SNAPTOLEFT, kp_facenum[pos]); + } + + Y += 18; + } + + return false; +} + +// +// HU_DrawTabRankings -- moved here to take advantage of kart stuff! +// +void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 hilicol) +{ + INT32 i, rightoffset = 240; + const UINT8 *colormap; + const INT32 dupadjust = cv_betainterscreen.value ? 314 : (vid.width/vid.dupx), duptweak = cv_betainterscreen.value ? -3 : (dupadjust - BASEVIDWIDTH)/2; + + boolean (*_isHighlightedPlayer)(const player_t *) = (demo.playback ? P_IsDisplayPlayer : P_IsLocalPlayer); + + //this function is designed for 9 or less score lines only + //I_Assert(scorelines <= 9); -- not today bitch, kart fixed it up + + V_DrawFill(1-duptweak, 26, dupadjust-2, 1, 0); // Draw a horizontal line because it looks nice! + if (scorelines > 8) + { + V_DrawFill(160, 26, 1, 147, 0); // Draw a vertical line to separate the two sides. + V_DrawFill(1-duptweak, 173, dupadjust-2, 1, 0); // And a horizontal line near the bottom. + rightoffset = (BASEVIDWIDTH/2) - 4 - x; + } + + for (i = 0; i < scorelines; i++) + { + char strtime[MAXPLAYERNAME+1]; + const UINT8 pnum = tab[i].num; + player_t *player = &players[pnum]; + + if (player->spectator || !player->mo) + continue; //ignore them. + + const boolean whiteplayer = _isHighlightedPlayer(player); + const INT32 philicol = (whiteplayer ? V_SkinColorToHighlightcolor(player->skincolor) : 0); + + if ((netgame && pnum != serverplayer) || (cv_mindelay.value && P_IsLocalPlayer(player))) + { + HU_drawPlayerPing(x + ((i < 8) ? -17 : rightoffset + 11), y-4, pnum, 0); + } + + STRBUFCPY(strtime, tab[i].name); + + if (scorelines > 8) + V_DrawThinString(x + 20, y, philicol|V_ALLOWLOWERCASE|V_6WIDTHSPACE, strtime); + else + V_DrawString(x + 20, y, philicol|V_ALLOWLOWERCASE, strtime); + + if (player->mo->color) + { + if (player->mo->colorized) + colormap = R_GetTranslationColormap(TC_RAINBOW, player->mo->color, GTC_CACHE); + else + colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE); + + if (K_UseHighResPortraits()) + V_DrawSmallMappedPatch(x, y-4, 0, R_GetSkinFaceWant(player), colormap); + else + V_DrawMappedPatch(x, y-4, 0, R_GetSkinFaceRank(player), colormap); + + /*if (G_BattleGametype() && player->kartstuff[k_bumper] > 0) -- not enough space for this + { + INT32 bumperx = x+19; + V_DrawMappedPatch(bumperx-2, y-4, 0, kp_tinybumper[0], colormap); + for (j = 1; j < player->kartstuff[k_bumper]; j++) + { + bumperx += 5; + V_DrawMappedPatch(bumperx, y-4, 0, kp_tinybumper[1], colormap); + } + }*/ + } + + if (whiteplayer) + V_DrawScaledPatch(x, y-4, 0, kp_facehighlight[(leveltime / 4) % 8]); + + if (G_BattleGametype() && player->kartstuff[k_bumper] <= 0) + V_DrawScaledPatch(x-4, y-7, 0, kp_ranknobumpers); + else + { + INT32 pos = player->kartstuff[k_position]; + if (pos < 0 || pos > MAXPLAYERS) + pos = 0; + // Draws the little number over the face + V_DrawScaledPatch(x-5, y+6, 0, kp_facenum[pos]); + } + + if (G_RaceGametype()) + { +#define timestring(time) va("%i'%02i\"%02i", G_TicsToMinutes(time, true), G_TicsToSeconds(time), G_TicsToCentiseconds(time)) + if (scorelines > 8) + { + if (player->exiting) + V_DrawRightAlignedThinString(x+rightoffset, y-1, hilicol|V_6WIDTHSPACE, timestring(player->realtime)); + else if (player->pflags & PF_TIMEOVER) + V_DrawRightAlignedThinString(x+rightoffset, y-1, V_6WIDTHSPACE, "NO CONTEST."); + else if (circuitmap) + V_DrawRightAlignedThinString(x+rightoffset, y-1, V_6WIDTHSPACE, va("Lap %d", tab[i].count)); + } + else + { + if (player->exiting) + V_DrawRightAlignedString(x+rightoffset, y, hilicol, timestring(player->realtime)); + else if (player->pflags & PF_TIMEOVER) + V_DrawRightAlignedThinString(x+rightoffset, y-1, 0, "NO CONTEST."); + else if (circuitmap) + V_DrawRightAlignedString(x+rightoffset, y, 0, va("Lap %d", tab[i].count)); + } +#undef timestring + } + else + V_DrawRightAlignedString(x+rightoffset, y, 0, va("%u", tab[i].count)); + + y += 18; + if (i == 7) + { + y = 33; + x = (BASEVIDWIDTH/2) + 4; + } + } +} + +static boolean K_BigLap(void) +{ + return (cv_biglaps.value && (cv_numlaps.value > 9) && (K_UseColorHud() ? big_lap_color : big_lap) && (!stplyr->exiting)); +} + +static void K_drawKartLaps(void) +{ + const INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM|V_SNAPTOLEFT); + INT32 fx = 0, fy = 0, fflags = 0; // stuff for 3p / 4p splitscreen. + const boolean flipstring = splitscreen > 1 && stplyrnum & 1; // used for 3p or 4p + INT32 stringw = 0; // used with the above + const char *laps; + + drawinfo_t info; + K_getLapsDrawinfo(&info); + fx = info.x; + fy = info.y; + fflags = info.flags; + + laps = (stplyr->exiting ? "FIN" : va("%d/%d", stplyr->laps+1, cv_numlaps.value)); + + // draw stuff as god intended. + if (splitscreen > 1) + { + if (flipstring) + { + stringw = V_StringWidth(laps, 0); + + V_DrawScaledPatch(fx-stringw-13, fy, V_HUDTRANS|fflags, kp_splitlapflag); + V_DrawRightAlignedString(fx, fy+1, V_HUDTRANS|fflags, laps); + } + else // draw stuff NORMALLY. + { + V_DrawScaledPatch(fx, fy, V_HUDTRANS|fflags, kp_splitlapflag); + V_DrawString(fx+13, fy+1, V_HUDTRANS|fflags, laps); + } + } + else + { + if (K_UseColorHud()) // Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + patch_t *biglapclr = (K_BigLap() ? ((stplyr->laps + 1 > 9) ? kp_lapstickerbig2clr : kp_lapstickerbigclr) : kp_lapstickerclr); + V_DrawMappedPatch(fx, fy, V_HUDTRANS|splitflags, biglapclr, colormap); + } + else + { + patch_t *biglap = (K_BigLap() ? ((stplyr->laps + 1 > 9) ? kp_lapstickerbig2 : kp_lapstickerbig) : kp_lapsticker); + V_DrawScaledPatch(fx, fy, V_HUDTRANS|splitflags, biglap); + } + + V_DrawKartString(fx+33, fy+3, V_HUDTRANS|splitflags, laps); + } +} + +#ifdef ROTSPRITE + +#define DIALSPDDIV 97090 // 1.48148; converts 200 to 135 +#define MPHDIV 68283 // 1.04192; converts 141 to 135 + +static void K_DrawDialNum(INT32 x, INT32 y, boolean colorized, INT32 flags, INT32 num, INT32 digits, const UINT8 *colormap) +{ + INT32 w; + + if (colorized) + w = skp_dialnumclr[0]->width; + else + w = skp_dialnum[0]->width; + + if (flags & V_NOSCALESTART) + w *= vid.dupx; + + if (num < 0) + num = -num; + + // draw the number + do + { + x -= (w); + + if (colorized) + V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, flags, skp_dialnumclr[num % 10], colormap); + else + V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, flags, skp_dialnum[num % 10], colormap); + + num /= 10; + } while (--digits); +} + +static void K_DrawDialLaps(INT32 x, INT32 y, INT32 num, INT32 total, INT32 flags) +{ + INT32 fx; + fx = x + ((num < 10) ? 0 : 6); + V_DrawRankNum(fx, y, flags, num, (num < 10) ? 1 : 2, NULL); + V_DrawScaledPatch(fx + 2, y, flags, frameslash); + V_DrawRankNum(fx + 13 + ((total < 10) ? 0 : 6), y, flags, total, (total < 10) ? 1 : 2, NULL); +} + +static void K_DrawDialSpeedometer(fixed_t speed, + fixed_t divisor, + INT32 splitflags, + boolean battlemode, + boolean infoactive, + boolean colorized) +{ + const UINT8* colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + + INT32 rot = 0; + const UINT8 infoidx = (infoactive) ? 1 : 0; + patch_t* dialpatch; + + const angle_t speedangle = + FixedAngle(((min(135 * FRACUNIT, FixedDiv(speed, divisor)) - (45 * FRACUNIT)))); + + rot = R_GetRollAngle(speedangle); + + if (rot) + { + dialpatch = W_CachePatchNameRotated("K_DSDIAL", rot, PU_PATCH); + } + else + { + dialpatch = W_CachePatchName("K_DSDIAL", PU_PATCH); + } + + if (colorized) // Colourized hud + { + V_DrawMappedPatch( + SPDM_X, SPDM_Y - 9, (V_HUDTRANS | splitflags), skp_dialbaseclr[infoidx], colormap); + V_DrawMappedPatch(SPDM_X, + SPDM_Y + 30, + V_HUDTRANS | splitflags, + skp_speedpatchesdialclr[cv_kartspeedometer.value], + colormap); + } + else + { + V_DrawScaledPatch(SPDM_X, SPDM_Y - 9, (V_HUDTRANS | splitflags), skp_dialbase[infoidx]); + V_DrawScaledPatch(SPDM_X, + SPDM_Y + 30, + V_HUDTRANS | splitflags, + skp_speedpatchesdial[cv_kartspeedometer.value]); + } + + K_DrawDialNum(SPDM_X + 10, + SPDM_Y + 25, + colorized, + V_HUDTRANS | splitflags, + speed / FRACUNIT, + 3, + colormap); + + // gotta center the dial manually + V_DrawMappedPatch(SPDM_X - 19, SPDM_Y + 15, (V_HUDTRANS | splitflags), (dialpatch), colormap); + + if (!infoactive) + { + // no need to draw info if we're not supposed to + return; + } + + // draw the info + if (battlemode) + { + if (stplyr->kartstuff[k_bumper] <= 0) + { + V_DrawMappedPatch( + SPDM_X + 28, SPDM_Y + 27, V_HUDTRANS | splitflags, kp_splitkarmabomb, colormap); + K_DrawDialLaps(SPDM_X + 46, + SPDM_Y + 29, + stplyr->kartstuff[k_comebackpoints], + 2, + V_HUDTRANS | splitflags); + } + else // the above doesn't need to account for weird stuff since the max amount of karma + // necessary is always 2 ^^^^ + { + V_DrawMappedPatch( + SPDM_X + 28, SPDM_Y + 27, V_HUDTRANS | splitflags, kp_rankbumper, colormap); + K_DrawDialLaps(SPDM_X + 46, + SPDM_Y + 29, + stplyr->kartstuff[k_bumper], + cv_kartbumpers.value, + V_HUDTRANS | splitflags); + } + } + else + { + V_DrawScaledPatch(SPDM_X + 28, SPDM_Y + 27, V_HUDTRANS | splitflags, kp_splitlapflag); + + if (stplyr->exiting) + V_DrawScaledPatch(SPDM_X + 39, SPDM_Y + 29, V_HUDTRANS | splitflags, skp_rankfinish); + else + K_DrawDialLaps(SPDM_X + 46, + SPDM_Y + 29, + stplyr->laps + 1, + cv_numlaps.value, + V_HUDTRANS | splitflags); + } +} + +#endif + +static void K_drawKartSpeedometer(void) +{ + // why? + if (cv_kartspeedometer.value == 0) + return; + + // index 0 is the raw value, index 1 is the converted value + fixed_t convSpeed[2] = {0,0}; +#ifdef ROTSPRITE + fixed_t dial_divisor = DIALSPDDIV; +#endif + + INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM|V_SNAPTOLEFT); + + // man. + const UINT8 speedostyle = K_GetSpeedometerStyle(); + + switch (cv_kartspeedometer.value) + { + case 1: + convSpeed[0] = FixedDiv(FixedMul(stplyr->speed, 142371), mapobjectscale); // 2.172409058 + convSpeed[1] = convSpeed[0] / FRACUNIT; + break; + case 2: + convSpeed[0] = FixedDiv(FixedMul(stplyr->speed, 88465), mapobjectscale); // 1.349868774 + convSpeed[1] = convSpeed[0] / FRACUNIT; +#ifdef ROTSPRITE + dial_divisor = MPHDIV; +#endif + break; + case 3: + convSpeed[0] = FixedDiv(stplyr->speed, mapobjectscale); + convSpeed[1] = convSpeed[0] / FRACUNIT; +#ifdef ROTSPRITE + dial_divisor = MPHDIV; +#endif + break; + case 4: + if (stplyr->mo) + { + convSpeed[0] = (FixedDiv(stplyr->speed, FixedMul(K_GetKartSpeed(stplyr, false), ORIG_FRICTION))*100); + convSpeed[1] = convSpeed[0] >> FRACBITS; + } + break; + default: + break; + } + + if (speedostyle == SPEEDO_VANILLA) + { + const char *metric = ""; + + switch (cv_kartspeedometer.value) + { + case 1: + metric = va("%3d km/h", convSpeed[1]); + break; + case 2: + metric = va("%3d mph", convSpeed[1]); + break; + case 3: + metric = va("%3d fu/t", convSpeed[1]); + break; + case 4: + // if extra.kart is found, use its included % symbol + if (!xtra_speedo) + metric = va("%4d P", convSpeed[1]); + else + metric = va("%4d %%", convSpeed[1]); + break; + default: + break; + } + + V_DrawKartString(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, metric); + } + else if (speedostyle == SPEEDO_EXTRA) // why bother if we dont? + { + if (K_UseColorSpeedo(SPEEDO_EXTRA)) //Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerclr, colormap); + } + else + V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallsticker); + + V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); + V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatches[cv_kartspeedometer.value]); + } + else if (speedostyle == SPEEDO_ACHII) // why bother if we dont? + { + if (K_UseColorSpeedo(SPEEDO_ACHII)) //Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachiclr, colormap); + V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); + V_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachiclr[cv_kartspeedometer.value], colormap); + } + else + { + V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachi); + V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); + V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachi[cv_kartspeedometer.value]); + } + } +#ifdef ROTSPRITE + else if (speedostyle == SPEEDO_DIAL) // why bother if we dont? + { + K_DrawDialSpeedometer(convSpeed[0], + dial_divisor, + splitflags, + (boolean)(G_BattleGametype()), + (LUA_HudEnabled(hud_gametypeinfo)), + (K_UseColorSpeedo(SPEEDO_DIAL))); + } +#endif + else if (speedostyle == SPEEDO_EXTRA3) // why bother if we dont? + { + if (K_UseColorSpeedo(SPEEDO_EXTRA3)) //Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + V_DrawStretchyFixedPatch((SPDM_X-1)<speed, mapobjectscale)/FRACUNIT; + + for (INT32 i = 0; i < 22; ++i) + { + if (fuspeed < speedIntervals[i]) + { + spdpatch = i; + break; + } + } + + if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && (leveltime & 4)) + spdpatch = 24; + else if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && !(leveltime & 4)) + spdpatch = 23; + + V_DrawScaledPatch(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, (speedostyle == SPEEDO_PMETER) ? kp_kartzspeedo[spdpatch] : kp_kartzspeedo_smol[spdpatch]); + } +} + +#ifdef ROTSPRITE +#undef DIALSPDDIV +#undef MPHDIV +#endif + +static void K_drawKartBumpersOrKarma(void) +{ + const UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + INT32 fx, fy, fflags; + const boolean flipstring = splitscreen > 1 && stplyrnum & 1; // same as laps, used for splitscreen + INT32 stringw = 0; // used with the above + const char *bumpval = ""; + + drawinfo_t info; + K_getLapsDrawinfo(&info); + fx = info.x; + fy = info.y; + fflags = info.flags; + + if (cv_battlespeedo.value && !splitscreen) + { + const UINT8 speedostyle = K_GetSpeedometerStyle(); + + if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII) || (speedostyle == SPEEDO_EXTRA3)) + fy += 5; + else + fy += 7; + } + + if (splitscreen > 1) + { + if (stplyr->kartstuff[k_bumper] <= 0) + { + bumpval = va("%d/2", stplyr->kartstuff[k_comebackpoints]); + + if (flipstring) + fx -= 37; + V_DrawMappedPatch(fx, fy-1, V_HUDTRANS|fflags, kp_splitkarmabomb, colormap); + V_DrawString(fx+13, fy+1, V_HUDTRANS|fflags, bumpval); + } + else // the above doesn't need to account for weird stuff since the max amount of karma necessary is always 2 ^^^^ + { + bumpval = va("%d/%d", stplyr->kartstuff[k_bumper], cv_kartbumpers.value); + + if (flipstring) // for p2 and p4, assume we can have more than 10 bumpers. It's retarded but who knows. + { + stringw = V_StringWidth(bumpval, 0); + + V_DrawMappedPatch(fx-stringw-13, fy-1, V_HUDTRANS|fflags, kp_rankbumper, colormap); + V_DrawRightAlignedString(fx, fy+1, V_HUDTRANS|fflags, bumpval); + } + else // draw bumpers normally. + { + V_DrawMappedPatch(fx, fy-1, V_HUDTRANS|fflags, kp_rankbumper, colormap); + V_DrawString(fx+13, fy+1, V_HUDTRANS|fflags, bumpval); + } + } + } + else + { + patch_t *patch; + + if (stplyr->kartstuff[k_bumper] <= 0) + { + patch = (K_UseColorHud() ? kp_karmastickerclr : kp_karmasticker); + bumpval = va("%d/2", stplyr->kartstuff[k_comebackpoints]); + } + else + { + if (stplyr->kartstuff[k_bumper] > 9 && cv_kartbumpers.value > 9) + patch = (K_UseColorHud() ? kp_bumperstickerwideclr : kp_bumperstickerwide); + else + patch = (K_UseColorHud() ? kp_bumperstickerclr : kp_bumpersticker); + + bumpval = va("%d/%d", stplyr->kartstuff[k_bumper], cv_kartbumpers.value); + } + + V_DrawMappedPatch(fx, fy, V_HUDTRANS|fflags, patch, colormap); + V_DrawKartString(fx+47, fy+3, V_HUDTRANS|fflags, bumpval); + } +} + +#define lerp(from, to) cv_uncappedhud.value ? from + FixedMul(rendertimefrac, to - from) : to + +// converts mobj coordinates into screen coordinates +// NOTE: use with V_NOSCALESTART! +// Code updated in Lua by GenericHeroGuy for libSG +// Badly ported to C by NepDisk and acutally made to work and fixed by Indev!(Thanks so much!) +// Badly uncapped in C by GenericHeroGuy +// original code by Lat' +static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *target, fixed_t hofs, boolean dontclip) +{ + fixed_t y, x; + fixed_t targx, targy, targz; + + fixed_t dist; + fixed_t distfact; + fixed_t offset; + + fixed_t yres, xres; + fixed_t fov; + + // this should never happen but its also kart so ¯\_(ツ)_/¯ + if (!player || P_MobjWasRemoved(target)) + return false; + + targx = lerp(target->old_x, target->x); + targy = lerp(target->old_y, target->y); + targz = lerp(target->old_z, target->z); + + // X coordinate + // get difference between camangle and angle towards target + x = (INT32)viewangle - (INT32)R_PointToAngle(targx, targy); + + distfact = FINECOSINE((x>>ANGLETOFINESHIFT) & FINEMASK); + if (!distfact) distfact = 1; + + if (encoremode) + x = -x; + if (x < (fixed_t)ANGLE_270 || x > (fixed_t)ANGLE_90) + return false; + + xres = vid.width<<(FRACBITS-1); + yres = vid.height<<(FRACBITS-1); + fov = FixedDiv(xres, FINETANGENT(((FixedAngle(cv_fov.value/2)+ANGLE_90)>>ANGLETOFINESHIFT) & 4095)); + + // flipping + const boolean targflip = target->eflags & MFE_VERTICALFLIP; + const boolean srcflip = player->pflags & PF_FLIPCAM && player->mo->eflags & MFE_VERTICALFLIP; + + // Y coordinate + // getting the angle difference here is a bit more involved... + // start by getting the height difference between the camera and target + y = viewz - targz - (targflip ? ((target->height * 2) / 3) : 0); // for some reason needs to be divided by "1.5" idk + + if (hofs) + y = y - (targflip ? -hofs : hofs); + + // then get the distance between camera and target + dist = R_PointToDist(targx, targy); + +#ifdef HWRENDER + // NOW we can get the angle differnce + if (rendermode == render_opengl && !cv_glshearing.value) + { + angle_t yang = R_PointToAngle2(0, 0, dist, y); // not perspective + x = FixedMul(x, FINECOSINE((yang>>ANGLETOFINESHIFT) & FINEMASK)); // perspective + y = -aimingangle - FixedDiv(yang, distfact); + + if (y < (fixed_t)ANGLE_270 || y > (fixed_t)ANGLE_90) // clip points behind the camera + return false; + if (splitscreen == 1) // multiply by 1.25 for 2P splitscreen + y = y + (y/4) ; + if (srcflip) // flipcam + y = -y; + + y = FixedMul(FINETANGENT((((angle_t)(-y)+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), fov) + yres; // project the angle to get our final Y coordinate + } + else +#endif + { + const fixed_t fovratio = FixedDiv(90*FRACUNIT, 180*FRACUNIT - FixedMul(cv_fov.value, 4*FRACUNIT/3)-FRACUNIT*-30); + + y = FixedDiv(y, FixedMul(dist, distfact)); + if (srcflip) + y = -y; // flipcam + if (y != INT32_MIN) // I_Error(): FixedDiv: divide by zero + y = FixedMul(FixedDiv(y, fovratio), xres) + yres; + //else print("NOPE!") + + offset = FixedMul(FINETANGENT(((aimingangle+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), xres); + + // this isn't fovtan... what am i even doing anymore + if (splitscreen == 1) + offset = 17*offset/120; + + // thanks fickle + offset = FixedDiv(offset, fovratio); + if (srcflip) + offset = -offset; // flipcam + y = y + offset; + } + + // project the angle to get our final X coordinate + x = FixedMul(FINETANGENT(((x+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), fov); + if (splitscreen == 1) // divide by 320/200 (1.6) on 2P splitscreen + x = (x/2) + (x/8); + x = x + xres; + + // now clip in screen-space + if (!dontclip && (x < 0 || x > xres*2 || y < 0 || y > yres*2)) + return false; + + // adjust coords for splitscreen + if (splitscreen == 1) // 2P + { + y = y>>1; + if (stplyrnum > 0) + y = y + yres; + } + if (splitscreen >= 2) // 3P or 4P + { + x = x>>1; + y = y>>1; + if (stplyrnum & 1) + x = x + xres; + if (stplyrnum >= 2) + y = y + yres; + } + + vec->y = y; + vec->x = x; + return true; +} + +//Slighty fixed by Alug and further rewritten by NepDisk +//Decided to port and highly modify sunflower version for the main nametag drawing with additions by NepDisk. My previous one was broken anyway due to the changed screencoords and noscalestart +static void K_drawNameTags(void) +{ + UINT8 i, j; + INT32 trans; + vector2_t pos = {0}; + fixed_t namex, namey; + int tagsdisplayed = 0; + fixed_t distance = 0; + fixed_t maxdistance = 0; + boolean flipped = false; + fixed_t z; + + char *tag; + patch_t *icon = NULL; + + INT32 dup; + UINT8 *cm = NULL; + UINT8 tagcolor = 0; + INT32 vflags = 0; + boolean usenametagrestat = false; + fixed_t tagwidthsmall; + fixed_t tagwidth; + + if (P_MobjWasRemoved(stplyr->mo) || (stplyr->spectator && !cv_shownametagspectator.value) || stplyr->exiting) + return; + + maxdistance = ((10*cv_nametagdist.value) * mapobjectscale); + + for (i = 0; i < MAXPLAYERS; i++) + { + distance = 0; + flipped = false; + + if (i > PLAYERSMASK) + continue; + if (players[i].spectator || !playeringame[i] || P_MobjWasRemoved(players[i].mo)) + continue; + if (i == displayplayers[stplyrnum] && !cv_showownnametag.value && !(leveltime < 130)) + continue; + if (i != displayplayers[stplyrnum] && leveltime < starttime) + continue; + if (players[i].kartstuff[k_hyudorotimer]) // player is invisible + continue; + if (maxdistance) + distance = R_PointToDist(players[i].mo->x, players[i].mo->y); + if (distance > maxdistance) + continue; + if (!P_CheckSightFast(stplyr->mo, players[i].mo)) + continue; + + z = players[i].mo->height; + + //Saltyhop hehe + z += lerp(players[i].mo->old_spriteyoffset, players[i].mo->spriteyoffset); + + if (!K_GetScreenCoords(&pos, stplyr, players[i].mo, z, false)) + continue; + + tagsdisplayed++; + + if (tagsdisplayed > cv_nametagmaxplayers.value) + break; + + trans = 0; + + switch (cv_nametagtrans.value) + { + case 1: + if (distance > (maxdistance*3/4)) + trans = V_60TRANS; + break; + case 2: + if (distance > (maxdistance*3/1)) + trans = V_90TRANS; + else if (distance > (maxdistance*3/2)) + trans = V_80TRANS; + else if (distance > (maxdistance*3/3)) + trans = V_60TRANS; + else if (distance > (maxdistance*3/4)) + trans = V_40TRANS; + else if (distance > (maxdistance*3/5)) + trans = V_20TRANS; + break; + case 3: + trans = V_40TRANS; + break; + case 4: + trans = V_LocalTransFlag(); + break; + case 0: + default: + break; + } + + namex = pos.x>>FRACBITS; + namey = pos.y>>FRACBITS; + + tag = va("%s%s ", HU_SkinColorToConsoleColor(players[i].mo->color), player_names[i]); + icon = R_GetSkinFaceMini(players[i].mo->player); + + dup = vid.dupx; + cm = R_GetTranslationColormap(players[i].skin, players[i].mo->color, GTC_CACHE); + tagcolor = colortranslations[players[i].mo->color][7]; + vflags = trans | V_NOSCALESTART; + usenametagrestat = ((cv_nametagrestat.value == 1 && (players[i].kartspeed != skins[players[i].skin].kartspeed || players[i].kartweight != skins[players[i].skin].kartweight)) || cv_nametagrestat.value == 2); + tagwidthsmall = cv_smallnametags.value ? V_SmallStringWidth(player_names[i], V_ALLOWLOWERCASE) : V_ThinStringWidth(player_names[i], V_ALLOWLOWERCASE); + tagwidth = dup*tagwidthsmall; + + // If flipcam is on, other player is flipped relative to us when we have different + // verticalflip flag value. Otherwise, they are simply flipped when verticalflip flag says so + if ((stplyr->pflags & PF_FLIPCAM) && (stplyr->mo->eflags & MFE_VERTICALFLIP)) + flipped = (players[i].mo->eflags & MFE_VERTICALFLIP) != (stplyr->mo->eflags & MFE_VERTICALFLIP); + else + flipped = players[i].mo->eflags & MFE_VERTICALFLIP; + + if (cv_smallnametags.value || !nametaggfx) + { + if (flipped) + namey += dup*5; + else // small offset + namey -= dup*3; + + if (nametaggfx && cv_smallnametags.value == 1) + { + if (cv_nametagfacerank.value) + tagwidthsmall += icon->width - dup; + + // Have to draw the nametag using patches here since drawfill can't draw at this scale... + if (!flipped) + V_DrawFixedPatch(namex<height/2)<width/2); // add offset to other stuff + } + + //Name + V_DrawSmallString(namex, namey, V_ALLOWLOWERCASE | vflags, tag); + + if (usenametagrestat) + { + V_DrawSmallString(namex, namey - dup*5, vflags, va("\x84S%d ", players[i].kartspeed)); + V_DrawSmallString(namex + dup*10, namey - dup*5, vflags, va("\x87W%d ", players[i].kartweight)); + } + + if (cv_nametagscore.value) + { + INT32 yofs = usenametagrestat ? 10 : 5; + V_DrawSmallString(namex, namey - dup*yofs, V_ALLOWLOWERCASE | vflags, va("\x8A%d ", players[i].score)); + } + } + else + { + if (cv_nametagfacerank.value) + tagwidth += dup*(icon->width+1); + + if (flipped) + { + for (j = 0; j < 4; j++) + { + V_DrawFill(namex, namey, dup*3, dup*4, 31 | vflags); + V_DrawFill(namex+dup, namey, dup, dup*4, tagcolor | vflags); + namey += dup*4; + namex += dup; + } + namey -= dup*3; + V_DrawFill(namex, namey+dup*2, dup, dup, 31 | vflags); // a single black pixel + V_DrawFill(namex+dup, namey, tagwidth, dup*3, 31 | vflags); + V_DrawFill(namex+dup, namey+dup, tagwidth - dup, dup, tagcolor | vflags); + namex += dup*2; + } + else + { + for (j = 0; j < 4; j++) + { + namey -= dup*4; + V_DrawFill(namex, namey, dup*3, dup*4, 31 | vflags); + V_DrawFill(namex+dup, namey, dup, dup*4, tagcolor | vflags); + namex += dup; + } + + V_DrawFill(namex, namey, dup, dup, 31 | vflags); + V_DrawFill(namex+dup, namey, tagwidth - dup*2, dup*3, 31 | vflags); + V_DrawFill(namex+dup, namey+dup, tagwidth - dup*3, dup, tagcolor | vflags); + } + + if (cv_nametagfacerank.value) + { + V_DrawMappedPatch(namex, namey - dup*(icon->height+1), vflags, icon, cm); + namex += dup*(icon->height+1); // add offset to other stuff + } + + V_DrawThinString(namex, namey - dup*10, V_ALLOWLOWERCASE | vflags, tag); + + if (usenametagrestat) + { + V_DrawScaledPatch(namex, namey - dup*20, vflags, nametagspeed); + V_DrawScaledPatch(namex + dup*18, namey - dup*20, vflags, nametagweight); + V_DrawString(namex + dup*9, namey - dup*19, V_ALLOWLOWERCASE | vflags, va("\x84%d ", players[i].kartspeed)); + V_DrawString(namex + dup*27, namey - dup*19, V_ALLOWLOWERCASE | vflags, va("\x87%d ", players[i].kartweight)); + } + + if (cv_nametagscore.value) + { + INT32 yofs = usenametagrestat ? 25 : 15; + V_DrawSmallString(namex, namey - dup*yofs, V_ALLOWLOWERCASE | vflags, va("\x8A%d ", players[i].score)); + } + } + } +} + +// Based on Driftgauge refactor by GenericHeroGuy ported from lua and expanded by NepDisk +static void K_drawDriftGauge(void) +{ + vector2_t pos = {0}; + fixed_t basex, basey; + const int dup = vid.dupx; + int i; + UINT8 *cmap; + + static const UINT8 driftcolors[3][4] = { + {0, 0, 10, 16}, // no drift + {215, 215, 204, 253}, // blue + {125, 125, 151, 159} // red + }; + + static const UINT8 driftskins[3] = { + SKINCOLOR_NONE, + SKINCOLOR_TEAL, + SKINCOLOR_SALMON, + }; + + static UINT8 driftrainbow[18] = { + 0, 31, 47, 63, 79, 95, 111, 119, 127, 143, 159, 175, 183, 191, 199, 207, 223, 247 + }; + + if (camera[stplyrnum].freecam) + return; + + if (!splitscreen && !camera->chase) + return; + + if (forceshowhud) + goto skipcrap; // i will skip the drift early return and you cant stop me! + + if (!stplyr->kartstuff[k_drift]) + return; + +skipcrap: + + if (P_MobjWasRemoved(stplyr->mo)) + return; + + if (!K_GetScreenCoords(&pos, stplyr, stplyr->mo, FixedMul(cv_driftgaugeofs.value, cv_driftgaugeofs.value > 0 ? stplyr->mo->scale : mapobjectscale), false)) + return; + + fixed_t barx; + fixed_t bary; + INT32 BAR_WIDTH; + + const INT32 driftval = K_GetKartDriftSparkValue(stplyr); + const INT32 driftcharge = min(driftval*4, stplyr->kartstuff[k_driftcharge]); + const INT32 driftlevel = min(driftcharge / driftval, 2); + const INT32 drifttrans = ((cv_driftgaugetrans.value) ? V_LocalTransFlag() : 0); + + basex = pos.x>>FRACBITS; + basey = pos.y>>FRACBITS; + + switch (cv_driftgaugestyle.value) + { + case 1: + case 2: + case 3: + case 5: + { + if (!driftgaugegfx) + break; + + const boolean usescaledpatch = (cv_driftgaugestyle.value == 5 && xtra_speedo3); + + if (cv_driftgaugestyle.value == 1 || cv_driftgaugestyle.value == 3 || usescaledpatch) + { + barx = basex - dup*23; + BAR_WIDTH = dup*47; + } + else + { + barx = basex - dup*12; + BAR_WIDTH = dup*23; + } + + bary = basey - dup*2; + + if (usescaledpatch) // i hate hud code i hate hud code i hate hud code i hate hud code i hate hud code..... + { + if (K_UseColorSpeedo(SPEEDO_EXTRA3)) // Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + V_DrawStretchyFixedPatch((basex - dup*30)<= driftval*4) // rainbow sparks + { + cmap = R_GetTranslationColormap(TC_RAINBOW, 1 + leveltime % (MAXSKINCOLORS-1),GTC_CACHE); + + for (i = 0; i < 4; i++) + V_DrawFill(barx, bary+dup*1+dup*i, BAR_WIDTH, dup, (driftrainbow[min((leveltime % 18) + 1, 18 - 1)] + i*2) | V_NOSCALESTART|drifttrans); + } + else // none/blue/red + { + const INT32 limit = (driftval * (driftcharge >= driftval*2 ? 2 : 1)); + const INT32 width = ((driftcharge - (driftcharge >= driftval ? limit : 0)) * BAR_WIDTH) / limit; + + cmap = R_GetTranslationColormap(TC_RAINBOW, driftskins[driftlevel],GTC_CACHE); + + for (i = 0; i < 4; i++) + { + if (driftcharge >= driftval) + V_DrawFill(barx, bary+dup*1+dup*i, BAR_WIDTH, dup, driftcolors[driftlevel-1][i] | V_NOSCALESTART|drifttrans); + + V_DrawFill(barx, bary+dup*1+dup*i, width, dup, driftcolors[driftlevel][i] | V_NOSCALESTART|drifttrans); + } + } + + // right, also draw a cool number + //SG_DrawPaddedNum(v, basex + (dup*32), basey, driftcharge*100 / driftval, 3, "PINGN", V_NOSCALESTART|V_OFFSET|drifttrans, cmap) + if (cv_driftgaugestyle.value == 3) + V_DrawPaddedTallColorNum(basex + (dup*32), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, 3, cmap); + else + V_DrawPingNum(cv_driftgaugestyle.value == 2 ? basex + (dup*22) : basex + (dup*32), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, cmap); + } + break; + case 4: + { + cmap = R_GetTranslationColormap(TC_RAINBOW, driftskins[driftlevel],GTC_CACHE); + + if (driftcharge >= driftval*4) + cmap = R_GetTranslationColormap(TC_RAINBOW, 1 + leveltime % (MAXSKINCOLORS-1),GTC_CACHE); + + V_DrawPaddedTallColorNum(basex + (dup*16), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, 3, cmap); + } + break; + default: + break; + } +} + +static fixed_t K_FindCheckX(fixed_t px, fixed_t py, angle_t ang, fixed_t mx, fixed_t my) +{ + fixed_t dist, x; + fixed_t range = RING_DIST/3; + angle_t diff; + + range *= gamespeed+1; + + dist = abs(R_PointToDist2(px, py, mx, my)); + if (dist > range) + return -BASEVIDWIDTH; + + diff = R_PointToAngle2(px, py, mx, my) - ang; + + if (diff < ANGLE_90 || diff > ANGLE_270) + return -BASEVIDWIDTH; + else + x = (FixedMul(FINETANGENT(((diff+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), 160<>FRACBITS; + + if (encoremode) + x = BASEVIDWIDTH-x; + + if (splitscreen > 1) + x /= 2; + + return x; +} + +static void K_drawKartWanted(void) +{ + UINT8 i, numwanted = 0; + UINT8 *colormap = NULL; + INT32 basex = 0, basey = 0; + + if (stplyrnum != 0) + return; + + for (i = 0; i < 4; i++) + { + if (battlewanted[i] == -1) + break; + numwanted++; + } + + if (numwanted <= 0) + return; + + // set X/Y coords depending on splitscreen. + if (splitscreen < 3) // 1P and 2P use the same code. + { + basex = WANT_X; + basey = WANT_Y; + if (splitscreen == 2) + { + basey += 16; // slight adjust for 3P + basex -= 6; + } + } + else if (splitscreen == 3) // 4P splitscreen... + { + basex = BASEVIDWIDTH/2 - (kp_wantedsplit->width/2); // center on screen + basey = BASEVIDHEIGHT - 55; + //basey2 = 4; + } + + if (battlewanted[0] != -1) + colormap = R_GetTranslationColormap(0, players[battlewanted[0]].skincolor, GTC_CACHE); + + V_DrawFixedPatch(basex< 1 ? kp_wantedsplit : kp_wanted), colormap); + /*if (basey2) + V_DrawFixedPatch(basex< 1 ? 13 : 8), y = basey+(splitscreen > 1 ? 16 : 21); + fixed_t scale = FRACUNIT/2; + + if (battlewanted[i] == -1) + break; + + player_t *p = &players[battlewanted[i]]; + + if (numwanted == 1) + scale = FRACUNIT; + else + { + if (i & 1) + x += 16; + if (i > 1) + y += 16; + } + + if (p->skincolor) + { + colormap = R_GetTranslationColormap(TC_RAINBOW, p->skincolor, GTC_CACHE); + V_DrawFixedPatch(x<skin] : facerankprefix[p->skin]), colormap);*/ + } + } +} + +static void K_drawKartPlayerCheck(void) +{ + INT32 i; + UINT8 *colormap; + INT32 x; + + const INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM); + + if (!stplyr->mo || stplyr->spectator) + return; + + if (stplyr->awayviewtics) + return; + + if (camspin[0]) + return; + + for (i = 0; i < MAXPLAYERS; i++) + { + UINT8 pnum = 0; + + if (&players[i] == stplyr) + continue; + if (!playeringame[i] || players[i].spectator) + continue; + if (!players[i].mo) + continue; + + if ((players[i].kartstuff[k_invincibilitytimer] <= 0) && (leveltime & 2)) + pnum++; // white frames + + if (players[i].kartstuff[k_itemtype] == KITEM_GROW || players[i].kartstuff[k_growshrinktimer] > 0) + pnum += 4; + else if (players[i].kartstuff[k_itemtype] == KITEM_INVINCIBILITY || players[i].kartstuff[k_invincibilitytimer]) + pnum += 2; + + x = K_FindCheckX(stplyr->mo->x, stplyr->mo->y, stplyr->mo->angle, players[i].mo->x, players[i].mo->y); + if (x <= 320 && x >= 0) + { + if (x < 14) + x = 14; + else if (x > 306) + x = 306; + + colormap = R_GetTranslationColormap(TC_DEFAULT, players[i].mo->color, GTC_CACHE); + V_DrawMappedPatch(x, CHEK_Y, V_HUDTRANS|splitflags, kp_check[pnum], colormap); + } + } +} + +static void K_drawKartMinimapIcon(fixed_t objx, fixed_t objy, INT32 hudx, INT32 hudy, INT32 flags, INT32 blend, patch_t *icon, UINT8 *colormap, drawinfo_t *dims, boolean scaleme) +{ + // amnum xpos & ypos are the icon's speed around the HUD. + // The number being divided by is for how fast it moves. + // The higher the number, the slower it moves. + + // am xpos & ypos are the icon's starting position. Withouht + // it, they wouldn't 'spawn' on the top-right side of the HUD. + + fixed_t amnumxpos, amnumypos; + INT32 amxpos, amypos; + fixed_t scale = FRACUNIT; + patch_t *AutomapPic; + INT16 w, h; + + AutomapPic = minimapinfo.minimap_pic; + + if (AutomapPic == NULL) + { + return; // no pic, just get outta here + } + + amnumxpos = (FixedMul(objx, minimapinfo.zoom) - minimapinfo.offs_x); + amnumypos = -(FixedMul(objy, minimapinfo.zoom) - minimapinfo.offs_y); + + if (encoremode) + amnumxpos = -amnumxpos; + + if (dims && (dims->x != 0) && (dims->y != 0)) + { + w = dims->x; + h = dims->y; + } + else + { + w = icon->width; + h = icon->height; + } + + amxpos = amnumxpos + ((hudx + (AutomapPic->width-w)/2)<height-h)/2)<player; + const boolean skinlocal = mo->skinlocal; + + fixed_t amnumxpos, amnumypos; + INT32 amxpos, amypos, wntdamxpos, wntdamypos; + fixed_t scale = FRACUNIT; + patch_t *minimaphead = NULL; + +#ifdef ROTSPRITE + angle_t rollangle = 0; + INT32 rot = 0; +#endif + + skin = K_GetMobjSkin(mo); + minimaphead = (skinlocal ? localfacemmapprefix : facemmapprefix)[K_GetMobjSkinNum(skin, skinlocal)]; + + amnumxpos = (FixedMul(lerp(mo->old_x, mo->x), minimapinfo.zoom) - minimapinfo.offs_x); + amnumypos = -(FixedMul(lerp(mo->old_y, mo->y), minimapinfo.zoom) - minimapinfo.offs_y); + + if (encoremode) + amnumxpos = -amnumxpos; + + amxpos = amnumxpos + ((x + (minimapinfo.minimap_pic->width-minimaphead->width) / 2)<height-minimaphead->height) / 2)<color), player_names[player - players]); + } + + // thx wanted reticle for having weird offsets very cool + wntdamxpos = cv_minihead.value ? amxpos + (1<width / 4)<height / 4)<spinoutrot) + { + // Rotate counterclockwise. + rollangle = FixedAngle(player->spinoutrot * -1); + rot = R_GetRollAngle(rollangle); + + if (rot) + { + minimaphead = W_CachePatchNameRotated(skin->facemmap, rot, PU_PATCH); + } + } +#endif + + if (!mo->color) // 'default' color + V_DrawSciencePatch(amxpos, amypos, flags, minimaphead, scale); + else + { + UINT8 *colormap; + + if (mo->colorized) + colormap = R_GetTranslationColormap(TC_RAINBOW, mo->color, GTC_CACHE); + else + colormap = R_GetLocalTranslationColormap(mo->skin, mo->localskin, mo->color, GTC_CACHE, skinlocal); + + V_DrawFixedPatch(amxpos, amypos, scale, flags, minimaphead, colormap); + + if (player + && ((G_RaceGametype() && player->kartstuff[k_position] == spbplace) + || (G_BattleGametype() && K_IsPlayerWanted(player)))) + { + V_DrawFixedPatch(wntdamxpos, wntdamypos, scale, flags, kp_wantedreticle, NULL); + } + } +} + +enum +{ + MINIANGLE_NONE = 0, + MINIANGLE_DOT, + MINIANGLE_LIGHT +}; + +static void K_drawKartMinimap(void) +{ + INT32 i = 0; + INT32 x, y; + INT32 minimaptrans, splitflags; + SINT8 localplayers[MAXSPLITSCREENPLAYERS]; + SINT8 numlocalplayers = 0; + patch_t *AutomapPic; + + // Draw the HUD only when playing in a level. + // hu_stuff needs this, unlike st_stuff. + if (gamestate != GS_LEVEL) + return; + + // Only draw for the first player + if (stplyrnum != 0) + return; + + AutomapPic = minimapinfo.minimap_pic; + + if (AutomapPic == NULL) + { + return; // no pic, just get outta here + } + + minimaptrans = K_getMinimapTrans(); + + // Exit early if it wouldn't draw anyway. + if (minimaptrans == -1) + return; + + drawinfo_t info; + K_getMinimapDrawinfo(&info); + x = info.x - (AutomapPic->width/2); + y = info.y - (AutomapPic->height/2); + splitflags = info.flags; + + splitflags |= minimaptrans; + + if (encoremode) + V_DrawScaledPatch(x+AutomapPic->width, y, splitflags|V_FLIP, AutomapPic); + else + V_DrawScaledPatch(x, y, splitflags, AutomapPic); + + if (!(splitscreen == 2)) + { + splitflags &= ~minimaptrans; + splitflags |= V_HUDTRANSHALF; + } + + // let offsets transfer to the heads, too! + if (encoremode) + x += AutomapPic->leftoffset; + else + x -= AutomapPic->leftoffset; + y -= AutomapPic->topoffset; + + // initialize + for (i = 0; i < MAXSPLITSCREENPLAYERS; i++) + localplayers[i] = -1; + + // Player's tiny icons on the Automap. (drawn opposite direction so player 1 is drawn last in splitscreen) + if (ghosts) + { + demoghost *g = ghosts; + while (g) + { + K_drawKartMinimapHead(g->mo, x, y, splitflags); + g = g->next; + } + + if (!stplyr->mo || stplyr->spectator) // do we need the latter..? + return; + + localplayers[numlocalplayers++] = stplyr-players; + } + else + { + for (i = MAXPLAYERS-1; i >= 0; i--) + { + if (!playeringame[i]) + continue; + + if (!players[i].mo || players[i].spectator) + continue; + + if (P_IsDisplayPlayer(&players[i])) + { + // Draw display players on top of everything else + localplayers[numlocalplayers++] = i; + continue; + } + + // Now we know it's not a display player, handle non-local player exceptions. + if (G_BattleGametype() && players[i].kartstuff[k_bumper] <= 0) + continue; + + if (players[i].kartstuff[k_hyudorotimer] > 0) + { + if (!((players[i].kartstuff[k_hyudorotimer] < 1*TICRATE/2 + || players[i].kartstuff[k_hyudorotimer] > hyudorotime-(1*TICRATE/2)) + && !(leveltime & 1))) + continue; + } + + K_drawKartMinimapHead(players[i].mo, x, y, splitflags); + } + } + + // draw our local players here, opaque. + splitflags &= ~V_HUDTRANSHALF; + splitflags |= V_HUDTRANS; + + const SINT8 icondotradius = (cv_minihead.value && !cv_showminimapnames.value) ? 8 : 10; + patch_t* minipatch; + INT32 rot; + INT32 blending; + + for (i = 0; i < numlocalplayers; i++) + { + if (localplayers[i] == -1) + continue; // this doesn't interest us + + mobj_t *mobj = players[localplayers[i]].mo; + + // dont draw for no contestants + boolean playertimedout = (mobj->health <= 0 && players[localplayers[i]].pflags & PF_TIMEOVER); + + if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout) + { + UINT8 *colormap; + drawinfo_t dims; + fixed_t interpx, interpy; + fixed_t xoff = 0, yoff = 0; + blending = 0; + + angle_t ang = R_InterpolateAngle(mobj->old_angle, mobj->angle); + + if (encoremode) + ang = ANGLE_180 - ang; + + if (mobj->colorized) + colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE); + else + colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal); + + interpx = lerp(mobj->old_x, mobj->x); + interpy = lerp(mobj->old_y, mobj->y); + + minipatch = kp_minimapdot; + + dims.x = 0; + dims.y = 0; + + if (cv_showminimapangle.value == MINIANGLE_DOT) + { + xoff = FixedMul(FCOS(ang), icondotradius); + yoff = -FixedMul(FSIN(ang), icondotradius); + } + else if (cv_showminimapangle.value == MINIANGLE_LIGHT) + { + rot = R_GetRollAngle(ang); + minipatch = W_CachePatchNameRotated("MMAPHDLT", rot, PU_PATCH); + + blending = B_ADD; + xoff = yoff = 0; + + dims.x = 48; + dims.y = 24; + } + + K_drawKartMinimapIcon( + interpx, + interpy, + x + xoff, + y + yoff, + splitflags, + blending, + minipatch, + colormap, + &dims, + false + ); + } + + // draw the minimap head after the nonsense above + K_drawKartMinimapHead(mobj, x, y, splitflags); + } +} + +#undef lerp + +static void K_drawKartStartCountdown(void) +{ + INT32 pnum = 0, splitflags = K_calcSplitFlags(0); // 3 + + if (leveltime >= starttime-(2*TICRATE)) // 2 + pnum++; + if (leveltime >= starttime-TICRATE) // 1 + pnum++; + if (leveltime >= starttime) // GO! + pnum++; + if ((leveltime % (2*5)) / 5) // blink + pnum += 4; + if (splitscreen) // splitscreen + pnum += 8; + + V_DrawScaledPatch(STCD_X - (kp_startcountdown[pnum]->width/2), STCD_Y - (kp_startcountdown[pnum]->height/2), splitflags, kp_startcountdown[pnum]); +} + +static void K_drawKartFinish(void) +{ + INT32 pnum = 0, splitflags = K_calcSplitFlags(0); + + if (!stplyr->kartstuff[k_cardanimation] || stplyr->kartstuff[k_cardanimation] >= 2*TICRATE) + return; + + if ((stplyr->kartstuff[k_cardanimation] % (2*5)) / 5) // blink + pnum = 1; + + if (splitscreen > 1) // 3/4p, stationary FIN + { + pnum += 2; + V_DrawScaledPatch(STCD_X - (kp_racefinish[pnum]->width/2), STCD_Y - (kp_racefinish[pnum]->height/2), splitflags, kp_racefinish[pnum]); + return; + } + + //else -- 1/2p, scrolling FINISH + { + INT32 x, xval; + + if (splitscreen) // wide splitscreen + pnum += 4; + + x = ((vid.width<width<kartstuff[k_cardanimation])< x ? xval : x))/TICRATE; + + if (splitscreen && stplyrnum == 1) + x = -x; + + V_DrawFixedPatch(x + (STCD_X<>1), + (STCD_Y<height<<(FRACBITS-1)), + FRACUNIT, + splitflags, kp_racefinish[pnum], NULL); + } +} + +static void K_drawBattleFullscreen(void) +{ + INT32 cardanim = stplyr->kartstuff[k_cardanimation] << FRACBITS; + + // fill in the fractional bits + if (cardanim && cardanim != 164*FRACUNIT) + { + INT32 frac = R_GetHudUncap() * ((164 - stplyr->kartstuff[k_cardanimation])/8 + 1); + if (stplyr->exiting) + cardanim += frac; + else + cardanim += stplyr->kartstuff[k_comebacktimer] < 6*TICRATE ? -frac : frac; + } + + INT32 x = BASEVIDWIDTH/2; + INT32 y = (-64*FRACUNIT) + cardanim; // card animation goes from 0 to 164, 164 is the middle of the screen + INT32 splitflags = V_SNAPTOTOP; // I don't feel like properly supporting non-green resolutions, so you can have a misuse of SNAPTO instead + fixed_t scale = FRACUNIT; + boolean drawcomebacktimer = true; // lazy hack because it's cleaner in the long run. + + if (!LUA_HudEnabled(hud_battlecomebacktimer)) + drawcomebacktimer = false; + + if (splitscreen) + { + if ((splitscreen == 1 && stplyrnum == 1) || (splitscreen > 1 && stplyrnum & 2)) + { + y = (232*FRACUNIT) - (cardanim/2); + splitflags = V_SNAPTOBOTTOM; + } + else + y = (-32*FRACUNIT) + (cardanim/2); + + if (splitscreen > 1) + { + scale /= 2; + + if (stplyrnum & 1) + x = 3*BASEVIDWIDTH/4; + else + x = BASEVIDWIDTH/4; + } + else + { + if (stplyr->exiting) + { + if (stplyrnum == 1) + x = BASEVIDWIDTH-96; + else + x = 96; + } + else + scale /= 2; + } + } + + if (stplyr->exiting) + { + if (stplyrnum == 0) + V_DrawFadeScreen(0xFF00, 16); + if (stplyr->exiting < 6*TICRATE && !stplyr->spectator) + { + if (stplyr->kartstuff[k_position] == 1) + V_DrawFixedPatch(x<kartstuff[k_bumper] <= 0 && stplyr->kartstuff[k_comebacktimer] && comeback && !stplyr->spectator && drawcomebacktimer) + { + UINT16 t = stplyr->kartstuff[k_comebacktimer]/(10*TICRATE); + INT32 txoff, adjust = (splitscreen > 1) ? 4 : 6; // normal string is 8, kart string is 12, half of that for ease + INT32 ty = (BASEVIDHEIGHT/2)+66; + + txoff = adjust; + + while (t) + { + txoff += adjust; + t /= 10; + } + + if (splitscreen) + { + if (splitscreen > 1) + ty = (BASEVIDHEIGHT/4)+33; + if ((splitscreen == 1 && stplyrnum == 1) || (splitscreen > 1 && stplyrnum & 2)) + ty += (BASEVIDHEIGHT/2); + } + else + V_DrawFadeScreen(0xFF00, 16); + + if (!comebackshowninfo) + V_DrawFixedPatch(x< 1) + V_DrawString(x-txoff, ty, 0, va("%d", stplyr->kartstuff[k_comebacktimer]/TICRATE)); + else + { + if (K_UseColorHud()) // Colourized hud + { + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + V_DrawFixedPatch(x<kartstuff[k_comebacktimer]/TICRATE)); + } + } + + if (netgame && !stplyr->spectator && timeinmap > 113) // FREE PLAY? + { + UINT8 i; + + // check to see if there's anyone else at all + for (i = 0; i < MAXPLAYERS; i++) + { + if (i == displayplayers[0]) + continue; + if (playeringame[i] && !stplyr->spectator) + return; + } + + if (LUA_HudEnabled(hud_freeplay)) + K_drawKartFreePlay(leveltime); + } +} + +static void K_drawKartFirstPerson(void) +{ + static INT32 pnum[4], turn[4], drift[4]; + INT32 pn = 0, tn = 0, dr = 0; + INT32 target = 0, splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM); + INT32 x = BASEVIDWIDTH/2, y = BASEVIDHEIGHT; + fixed_t scale; + UINT8 *colmap = NULL; + ticcmd_t *cmd = &stplyr->cmd; + + if (stplyr->spectator || !stplyr->mo || (stplyr->mo->flags2 & MF2_DONTDRAW)) + return; + + pn = pnum[stplyrnum]; + tn = turn[stplyrnum]; + dr = drift[stplyrnum]; + + if (splitscreen) + { + y >>= 1; + if (splitscreen > 1) + x >>= 1; + } + + { + if (stplyr->speed < (20*stplyr->mo->scale) && (leveltime & 1) && !splitscreen) + y++; + // the following isn't EXPLICITLY right, it just gets the result we want, but i'm too lazy to look up the right way to do it + if (stplyr->mo->flags2 & MF2_SHADOW) + splitflags |= FF_TRANS80; + else if (stplyr->mo->frame & FF_TRANSMASK) + splitflags |= (stplyr->mo->frame & FF_TRANSMASK); + } + + if (cmd->driftturn > 400) // strong left turn + target = 2; + else if (cmd->driftturn < -400) // strong right turn + target = -2; + else if (cmd->driftturn > 0) // weak left turn + target = 1; + else if (cmd->driftturn < 0) // weak right turn + target = -1; + else // forward + target = 0; + + if (encoremode) + target = -target; + + if (pn < target) + pn++; + else if (pn > target) + pn--; + + if (pn < 0) + splitflags |= V_FLIP; // right turn + + target = abs(pn); + if (target > 2) + target = 2; + + x <<= FRACBITS; + y <<= FRACBITS; + + if (tn != cmd->driftturn/50) + tn -= (tn - (cmd->driftturn/50))/8; + + if (dr != stplyr->kartstuff[k_drift]*16) + dr -= (dr - (stplyr->kartstuff[k_drift]*16))/8; + + if (splitscreen == 1) + { + scale = (2*FRACUNIT)/3; + y += FRACUNIT/(vid.dupx < vid.dupy ? vid.dupx : vid.dupy); // correct a one-pixel gap on the screen view (not the basevid view) + } + else if (splitscreen) + scale = FRACUNIT/2; + else + scale = FRACUNIT; + + if (stplyr->mo) + { + INT32 dsone = K_GetKartDriftSparkValue(stplyr); + INT32 dstwo = dsone*2; + INT32 dsthree = dstwo*2; + +#ifndef DONTLIKETOASTERSFPTWEAKS + { + const angle_t ang = R_PointToAngle2(0, 0, stplyr->rmomx, stplyr->rmomy) - stplyr->frameangle; + // yes, the following is correct. no, you do not need to swap the x and y. + fixed_t xoffs = -P_ReturnThrustY(stplyr->mo, ang, (BASEVIDWIDTH<<(FRACBITS-2))/2); + fixed_t yoffs = -(P_ReturnThrustX(stplyr->mo, ang, 4*FRACUNIT) - 4*FRACUNIT); + + if (splitscreen) + xoffs = FixedMul(xoffs, scale); + + xoffs -= (tn)*scale; + xoffs -= (dr)*scale; + + if (stplyr->frameangle == stplyr->mo->angle) + { + const fixed_t mag = FixedDiv(stplyr->speed, 10*stplyr->mo->scale); + + if (mag < FRACUNIT) + { + xoffs = FixedMul(xoffs, mag); + if (!splitscreen) + yoffs = FixedMul(yoffs, mag); + } + } + + if (stplyr->mo->momz > 0) // TO-DO: Draw more of the kart so we can remove this if! + yoffs += stplyr->mo->momz/3; + + if (encoremode) + x -= xoffs; + else + x += xoffs; + if (!splitscreen) + y += yoffs; + } + + // drift sparks! + if ((leveltime & 1) && (stplyr->kartstuff[k_driftcharge] >= dsthree)) + colmap = R_GetTranslationColormap(TC_RAINBOW, (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1))), GTC_CACHE); + else if ((leveltime & 1) && (stplyr->kartstuff[k_driftcharge] >= dstwo)) + colmap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_KETCHUP, GTC_CACHE); + else if ((leveltime & 1) && (stplyr->kartstuff[k_driftcharge] >= dsone)) + colmap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_SAPPHIRE, GTC_CACHE); + else +#endif + // invincibility/grow/shrink! + if (stplyr->mo->colorized && stplyr->mo->color) + colmap = R_GetTranslationColormap(TC_RAINBOW, stplyr->mo->color, GTC_CACHE); + } + + V_DrawFixedPatch(x, y, scale, splitflags, kp_fpview[target], colmap); + + pnum[stplyrnum] = pn; + turn[stplyrnum] = tn; + drift[stplyrnum] = dr; +} + +// doesn't need to ever support 4p +static void K_drawInput(void) +{ + INT32 offs, col; + static INT32 pn = 0; + + if (!cv_showinput.value || (timeinmap <= 105)) // dont bother + return; + + INT32 target = 0, splitflags = (V_SNAPTOBOTTOM|V_SNAPTORIGHT|V_HUDTRANS); + INT32 x = (BASEVIDWIDTH - 32 + cv_wheel_xoffset.value)*FRACUNIT, y = (BASEVIDHEIGHT - 24 + cv_wheel_yoffset.value)*FRACUNIT; + + const UINT8 hudcolor = K_GetHudColor(); + const INT32 accent1 = splitflags|colortranslations[hudcolor][5]; + const INT32 accent2 = splitflags|colortranslations[hudcolor][9]; + const UINT8 *hudcolormap = R_GetTranslationColormap(0, hudcolor, GTC_CACHE); + + const ticcmd_t *cmd = &stplyr->cmd; + + if (timeinmap < 113) + { + INT32 count = ((INT32)(timeinmap) - 105); + INT32 frac = count > 0 && count < 6 ? R_GetHudUncap() << (FRACBITS - count - 11) : 0; + + offs = 64*FRACUNIT; + while (count-- > 0) + offs >>= 1; + x += (offs < FRACUNIT ? 0 : offs) - frac; + } + +#define BUTTW 8 +#define BUTTH 11 + +#define drawbutt(xoffs, butt, symb)\ + if (cmd->buttons & butt)\ + {\ + offs = 2*FRACUNIT;\ + col = accent1;\ + }\ + else\ + {\ + offs = 0;\ + col = accent2;\ + V_DrawFill((x + xoffs*FRACUNIT)>>FRACBITS, (y + BUTTH*FRACUNIT)>>FRACBITS, BUTTW-1, 2, splitflags|31);\ + }\ + V_DrawFill((x + xoffs*FRACUNIT)>>FRACBITS, (y+offs)>>FRACBITS, BUTTW-1, BUTTH, col);\ + V_DrawFixedPatch(x + FRACUNIT + xoffs*FRACUNIT, y + offs + FRACUNIT, FRACUNIT, splitflags, tny_font[symb-HU_FONTSTART], NULL) + + drawbutt(-2*BUTTW, BT_ACCELERATE, 'A'); + drawbutt( -BUTTW, BT_BRAKE, 'B'); + drawbutt( 0, BT_DRIFT, 'D'); + drawbutt( BUTTW, BT_ATTACK, 'I'); + +#undef drawbutt + +#undef BUTTW +#undef BUTTH + + y -= FRACUNIT; + + if (cv_showinput.value == 2 || cv_showinput.value == 3) + { + INT32 axis; + INT32 hudforward = 0; // for the stick input display :chaosleep: + UINT8 *shadowcolormap = NULL; + const INT32 joyx = x>>FRACBITS; + const INT32 joyy = y>>FRACBITS; + static const INT32 joyxoffs = -8; + static const INT32 joyyoffs = -24; + const boolean usejoysprite = (cv_showinput.value == 3 && joystickicon); + + // O backing + if (usejoysprite) + { + shadowcolormap = R_GetTranslationColormap(0, SKINCOLOR_BLACK, GTC_CACHE); + V_DrawMappedPatch(joyx+joyxoffs, joyy+joyyoffs-1, splitflags, joybacking, hudcolormap); + } + else + { + V_DrawFill(joyx+joyxoffs, joyy+joyyoffs-1, 16, 16, splitflags|accent2); + V_DrawFill(joyx+joyxoffs, joyy+joyyoffs+15, 16, 1, splitflags|31); + } + + // time for pain and suffering + // kart does not have anything we can get analogue joystick y axis values from + // during normal gameplay, so replicate shit here + + // this is horrid but we cant get actual input in replays so uhh + if (demo.playback || !P_IsLocalPlayer(stplyr)) // yeah........... + { + hudforward = stplyr->kartstuff[k_throwdir] * KART_FULLTURN; + } + else + { + const boolean analogjoystickmove = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle; + const boolean gamepadjoystickmove = cv_usejoystick[stplyrnum].value && Joystick[stplyrnum].bGamepadStyle; + const UINT8 ssplayer = stplyrnum+1; + + axis = JoyAxis(AXISAIM, ssplayer); + + if (analogjoystickmove && axis != 0) + { + // JOYAXISRANGE is supposed to be 1023 (divide by 1024) + hudforward -= ((axis * KART_FULLTURN) / (JOYAXISRANGE-1)); + } + else + { + if (InputDown(gc_aimforward, ssplayer) || (gamepadjoystickmove && axis < 0)) + { + hudforward += KART_FULLTURN; + } + if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0)) + { + hudforward-= KART_FULLTURN; + } + } + + hudforward = CLAMP(hudforward, -KART_FULLTURN, KART_FULLTURN); + } + + if (cmd->driftturn || hudforward) + { + INT16 turning = encoremode ? -cmd->driftturn : cmd->driftturn; + + if (usejoysprite) + { + V_DrawMappedPatch(joyx+joyxoffs+3-turning/80, joyy+joyyoffs+2-hudforward/80, splitflags, joyknob, shadowcolormap); + V_DrawMappedPatch(joyx+joyxoffs+3-turning/64, joyy+joyyoffs+1-hudforward/64, splitflags, joyknob, hudcolormap); + } + else + { + // joystick hole + V_DrawFill(joyx+joyxoffs+5, joyy+joyyoffs+4, 6, 6, splitflags|accent1); + // joystick top and back + V_DrawFill(joyx+joyxoffs+3-turning/80, joyy+joyyoffs+2-hudforward/80, 10, 10, splitflags|31); + V_DrawFill(joyx+joyxoffs+3-turning/64, joyy+joyyoffs+1-hudforward/64, 10, 10, splitflags|accent1); + } + } + else + { + if (usejoysprite) + { + V_DrawMappedPatch(joyx+joyxoffs+3, joyy+joyyoffs+8, splitflags, joyshadow, shadowcolormap); + V_DrawMappedPatch(joyx+joyxoffs+3, joyy+joyyoffs+1, splitflags, joyknob, hudcolormap); + } + else + { + V_DrawFill(joyx+joyxoffs+3, joyy+joyyoffs+11, 10, 1, splitflags|accent2); + V_DrawFill(joyx+joyxoffs+3, joyy+joyyoffs+1, 10, 10,splitflags|accent1); + } + } + } + else + { + if (!cmd->driftturn) // no turn + target = 0; + else // turning of multiple strengths! + { + target = ((abs(cmd->driftturn) - 1)/125)+1; + if (target > 4) + target = 4; + if (cmd->driftturn < 0) + target = -target; + } + + if (pn != target) + { + if (abs(pn - target) == 1) + pn = target; + else if (pn < target) + pn += 2; + else //if (pn > target) + pn -= 2; + } + + if (pn < 0) + { + splitflags |= V_FLIP; // right turn + x -= FRACUNIT; + } + + target = abs(pn); + if (target > 4) + target = 4; + + V_DrawFixedPatch(x, y, FRACUNIT, splitflags, kp_inputwheel[target], hudcolormap); + } +} + +static void K_drawChallengerScreen(void) +{ + // This is an insanely complicated animation. + static const UINT8 anim[52] = { + 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13, // frame 1-14, 2 tics: HERE COMES A NEW slides in + 14,14,14,14,14,14, // frame 15, 6 tics: pause on the W + 15,16,17,18, // frame 16-19, 1 tic: CHALLENGER approaches screen + 19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact + 21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold + }; + const UINT8 offset = min(52-1, (3*TICRATE)-mapreset); + + V_DrawFadeScreen(0xFF00, 16); // Fade out + V_DrawScaledPatch(0, 0, 0, kp_challenger[anim[offset]]); +} + +static void K_drawLapStartAnim(void) +{ + // This is an EVEN MORE insanely complicated animation. + const UINT8 progress = 80-stplyr->kartstuff[k_lapanimation]; + UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); + INT32 vflags = V_SNAPTOTOP|V_HUDTRANS; + + fixed_t slideout = max(0, 32*(((progress - 76)*FRACUNIT) + R_GetHudUncap())); + fixed_t slidein = max(0, 32*(((stplyr->kartstuff[k_lapanimation] - 76)*FRACUNIT) - R_GetHudUncap())); + + // First, draw the emblem and hand + INT32 emblemx = (BASEVIDWIDTH << (FRACBITS - 1)) + slidein; + INT32 y = 48*FRACUNIT - slideout; + + V_DrawFixedPatch(emblemx, y, FRACUNIT, vflags, kp_lapanim_emblem[modeattacking ? 1 : 0], colormap); + + INT32 hand = stplyr->kartstuff[k_laphand]; + if (hand >= 1 && hand <= 3) + { + y += 4*FRACUNIT - abs((int)(leveltime % 8)*FRACUNIT + R_GetHudUncap() - 4*FRACUNIT); + V_DrawFixedPatch(emblemx, y, FRACUNIT, vflags, kp_lapanim_hand[hand - 1], NULL); + } + + // Then the text + INT32 leftx = 82*FRACUNIT - slideout; + INT32 rightx = 188*FRACUNIT + slideout; + y = 30*FRACUNIT; + + if (stplyr->laps == (UINT8)(cv_numlaps.value - 1)) + { + // FINAL + V_DrawFixedPatch(leftx - 20*FRACUNIT, y, FRACUNIT, vflags, kp_lapanim_final[min(progress/2, 10)], NULL); + + // LAP + if (progress/2 - 12 >= 0) + V_DrawFixedPatch(rightx, y, FRACUNIT, vflags, kp_lapanim_lap[min(progress/2 - 12, 6)], NULL); + } + else + { + // LAP + V_DrawFixedPatch(leftx, y, FRACUNIT, vflags, kp_lapanim_lap[min(progress/2, 6)], NULL); + + char *lapnum = va("%02d", stplyr->laps + 1); + for (int i = 0; i < (int)strlen(lapnum); i++) + { + int digit = lapnum[i] - '0'; + int frame = min(2, progress/2 - 8 - (i*2)); + if (frame >= 0) + V_DrawFixedPatch(rightx + (i*20*FRACUNIT), y, FRACUNIT, vflags, kp_lapanim_number[digit][frame], NULL); + } + } +} + +void K_drawKartFreePlay(UINT32 flashtime) +{ + // no splitscreen support because it's not FREE PLAY if you have more than one player in-game + + if (!cv_showfreeplay.value) + return; + + if ((flashtime % TICRATE) < TICRATE/2) + return; + + V_DrawKartString((BASEVIDWIDTH - (LAPS_X+1)) - (12*9), // mirror the laps thingy + LAPS_Y+3, V_SNAPTOBOTTOM|V_SNAPTORIGHT|V_HUDTRANS, "FREE PLAY"); +} + +static void K_drawDistributionDebugger(void) +{ + patch_t *items[NUMKARTRESULTS] = { + kp_sadface[1], + kp_sneaker[1], + kp_rocketsneaker[1], + kp_invincibility[7], + kp_banana[1], + kp_eggman[1], + kp_orbinaut[4], + kp_jawz[1], + kp_mine[1], + kp_ballhog[1], + kp_selfpropelledbomb[1], + kp_grow[1], + kp_shrink[1], + kp_thundershield[1], + kp_hyudoro[1], + kp_pogospring[1], + kp_kitchensink[1], + + kp_sneaker[1], + kp_banana[1], + kp_banana[1], + kp_orbinaut[4], + kp_orbinaut[4], + kp_jawz[1] + }; + INT32 useodds = 0; + INT32 pingame = 0, bestbumper = 0; + INT32 i; + INT32 x = -9, y = -9; + boolean dontforcespb = false; + boolean spbrush = false; + + if (stplyrnum != 0) // only for p1 + return; + + // The only code duplication from the Kart, just to avoid the actual item function from calculating pingame twice + for (i = 0; i < MAXPLAYERS; i++) + { + if (!playeringame[i] || players[i].spectator) + continue; + pingame++; + if (players[i].exiting) + dontforcespb = true; + if (players[i].kartstuff[k_bumper] > bestbumper) + bestbumper = players[i].kartstuff[k_bumper]; + } + + if (G_RaceGametype()) + spbrush = (spbplace != -1 && stplyr->kartstuff[k_position] == spbplace+1); + + useodds = K_FindUseodds(stplyr, 0, pingame, bestbumper, spbrush, dontforcespb); + + for (i = 1; i < NUMKARTRESULTS; i++) + { + const INT32 itemodds = K_KartGetItemOdds(useodds, i, 0, spbrush); + if (itemodds <= 0) + continue; + + V_DrawScaledPatch(x, y, V_HUDTRANS|V_SNAPTOTOP, items[i]); + V_DrawThinString(x+11, y+31, V_HUDTRANS|V_SNAPTOTOP, va("%d", itemodds)); + + // Display amount for multi-items + if (i >= NUMKARTITEMS) + { + INT32 amount; + switch (i) + { + case KRITEM_TENFOLDBANANA: + amount = 10; + break; + case KRITEM_QUADORBINAUT: + amount = 4; + break; + case KRITEM_DUALJAWZ: + amount = 2; + break; + default: + amount = 3; + break; + } + V_DrawString(x+24, y+31, V_ALLOWLOWERCASE|V_HUDTRANS|V_SNAPTOTOP, va("x%d", amount)); + } + + x += 32; + if (x >= 297) + { + x = -9; + y += 32; + } + } + + V_DrawString(0, 0, V_HUDTRANS|V_SNAPTOTOP, va("USEODDS %d", useodds)); +} + +static void K_drawCheckpointDebugger(void) +{ + if (stplyrnum != 0) // only for p1 + return; + + if (stplyr->starpostnum >= (numstarposts - (numstarposts/2))) + V_DrawString(8, 184, 0, va("Checkpoint: %d / %d (Can finish)", stplyr->starpostnum, numstarposts)); + else + V_DrawString(8, 184, 0, va("Checkpoint: %d / %d (Skip: %d)", stplyr->starpostnum, numstarposts, ((numstarposts/2) + stplyr->starpostnum))); + V_DrawString(8, 192, 0, va("Waypoint dist: Prev %d, Next %d", stplyr->kartstuff[k_prevcheck], stplyr->kartstuff[k_nextcheck])); +} + +// determines if gametype info (laps/bumpers) should be hidden +static boolean K_DisableGametypeInfo(void) +{ + if (!LUA_HudEnabled(hud_gametypeinfo)) + { + return true; + } + +#ifdef ROTSPRITE + if (splitscreen || (!cv_kartspeedometer.value)) + { + // don't need to run checks if we're in splitscreen, or not using the speedometer + return false; + } + + const UINT8 speedostyle = K_GetSpeedometerStyle(); + + if (G_RaceGametype()) + { + if (speedostyle == SPEEDO_DIAL) + return true; + } + else if (G_BattleGametype()) + { + if ((cv_battlespeedo.value) && (speedostyle == SPEEDO_DIAL)) + return true; + } +#endif + + return false; +} + +void K_drawKartHUD(void) +{ + boolean isfreeplay = false; + boolean battlefullscreen = false; + boolean freecam = camera[stplyrnum].freecam; //disable some hud elements w/ freecam + boolean gameinfovisible = false; + + // Define the X and Y for each drawn object + // This is handled by console/menu values + K_initKartHUD(); + + // Draw that fun first person HUD! Drawn ASAP so it looks more "real". + if (!camera[stplyrnum].chase && !freecam) + K_drawKartFirstPerson(); + + // Draw full screen stuff that turns off the rest of the HUD + if (mapreset && stplyrnum == 0) + { + K_drawChallengerScreen(); + return; + } + + battlefullscreen = ((G_BattleGametype()) + && (stplyr->exiting + || (stplyr->kartstuff[k_bumper] <= 0 + && stplyr->kartstuff[k_comebacktimer] + && comeback + && stplyr->playerstate == PST_LIVE))); + + if (!demo.title && (!battlefullscreen || splitscreen)) + { + // Draw the CHECK indicator before the other items, so it's overlapped by everything else + + if (LUA_HudEnabled(hud_check)) // delete lua when? + { + if (cv_kartcheck.value && !splitscreen && !players[displayplayers[0]].exiting && !freecam) + K_drawKartPlayerCheck(); + } + + // Draw WANTED status + if (G_BattleGametype()) + { + if (LUA_HudEnabled(hud_wanted)) + K_drawKartWanted(); + } + + if (cv_kartminimap.value) + { + if (LUA_HudEnabled(hud_minimap)) + K_drawKartMinimap(); + } + } + + if (battlefullscreen && !freecam) + { + if (LUA_HudEnabled(hud_battlefullscreen)) + K_drawBattleFullscreen(); + return; + } + + // Draw the item window + if (LUA_HudEnabled(hud_item) && !freecam) + K_drawKartItem(); + + if (cv_driftgauge.value && !modeattacking) + { + if (LUA_HudEnabled(hud_driftgauge)) + K_drawDriftGauge(); + } + + if (cv_nametag.value) + { + if (LUA_HudEnabled(hud_nametags)) + K_drawNameTags(); + } + + // If not splitscreen, draw... + if (!splitscreen && !demo.title) + { + tic_t realtime = stplyr->realtime; + + if (cv_showlaptimes.value + && stplyr->kartstuff[k_lapanimation] + && !stplyr->exiting + && stplyr->laptime[LAP_LAST] != 0 + && !midgamejoin) // due to vanilla compat, we cannot synch this oh well + { + if ((stplyr->kartstuff[k_lapanimation] / 5) & 1) + { + realtime = stplyr->laptime[LAP_LAST]; + } + else + { + realtime = UINT32_MAX; + } + } + + // Draw the timestamp + if (LUA_HudEnabled(hud_time)) + K_drawKartTimestamp(realtime, TIME_X, TIME_Y, gamemap, 0); + + if (!modeattacking) + { + // The top-four faces on the left + //if (LUA_HudEnabled(hud_minirankings)) + isfreeplay = K_drawKartPositionFaces(); + } + } + + if (!stplyr->spectator && !freecam) // Bottom of the screen elements, don't need in spectate mode + { + // get gametype info visibility ahead of time + gameinfovisible = (!K_DisableGametypeInfo()); + + if (!(splitscreen || demo.title)) + { + if (LUA_HudEnabled(hud_inputdisplay)) + K_drawInput(); + } + + if (!demo.title && cv_showstats.value) + { + if (LUA_HudEnabled(hud_statdisplay)) + K_drawKartStats(); + } + + if (demo.title) // Draw title logo instead in demo.titles + { + INT32 x = (BASEVIDWIDTH - 32)*FRACUNIT, y = 128*FRACUNIT, offs; + INT32 logoflags = V_SNAPTORIGHT|V_SNAPTOBOTTOM; + + if (splitscreen == 3) + { + x = BASEVIDWIDTH/2 + 10; + y = BASEVIDHEIGHT/2 - 30; + } + + if (timeinmap < 113) + { + INT32 count = ((INT32)(timeinmap) - 104); + INT32 frac = count > 0 ? R_GetHudUncap() << max(0, FRACBITS - count - 9) : 0; + + offs = 256*FRACUNIT; + while (count-- > 0) + offs >>= 1; + x += offs - frac; + } + + V_DrawSciencePatch(x - (54*FRACUNIT), y, logoflags, W_CachePatchName("TTKBANNR", PU_PATCH), FRACUNIT/4); + V_DrawSciencePatch(x - (54*FRACUNIT), y + (25*FRACUNIT), logoflags, W_CachePatchName("TTKART", PU_PATCH), FRACUNIT/4); + } + else if (G_RaceGametype()) // Race-only elements + { + // Draw the lap counter + if (gameinfovisible) + K_drawKartLaps(); + + if (!splitscreen) + { + // Draw the speedometer + // TODO: Make a better speedometer. << done :p + if (LUA_HudEnabled(hud_speedometer)) + K_drawKartSpeedometer(); + } + + if (isfreeplay) + ; + else if (!modeattacking) + { + // Draw the numerical position + if (LUA_HudEnabled(hud_position)) + K_DrawKartPositionNum(stplyr->kartstuff[k_position]); + } + } + else if (G_BattleGametype()) // Battle-only + { + // Draw the hits left! + if (gameinfovisible) + K_drawKartBumpersOrKarma(); + + if ((!splitscreen) && cv_battlespeedo.value) + { + // Draw the speedometer but in battle + // TODO: Make a better speedometer. << done :p + if (LUA_HudEnabled(hud_speedometer)) + K_drawKartSpeedometer(); + } + } + } + + // Draw the countdowns after everything else. + if (leveltime >= starttime-(3*TICRATE) + && leveltime < starttime+TICRATE) + K_drawKartStartCountdown(); + else if (racecountdown && (!splitscreen || !stplyr->exiting)) + { + char *countstr = va("%d", racecountdown/TICRATE); + + // Eeeh dunno if would be better to add another variable instead of LAPS_Y but this works too + int yoff = cv_dnft_yoffset.value - cv_laps_yoffset.value; + int xoff = cv_dnft_xoffset.value; + + if (splitscreen > 1) + V_DrawCenteredString(BASEVIDWIDTH/4+xoff, LAPS_Y+1+yoff, K_calcSplitFlags(V_SNAPTOBOTTOM), countstr); + else + { + INT32 karlen = strlen(countstr)*6; // half of 12 + V_DrawKartString((BASEVIDWIDTH/2)-karlen+xoff, LAPS_Y+3+yoff, K_calcSplitFlags(V_SNAPTOBOTTOM), countstr); + } + } + + // Race overlays + if (G_RaceGametype() && !freecam) + { + if (stplyr->exiting) + K_drawKartFinish(); + else if (stplyr->kartstuff[k_lapanimation] && !splitscreen && cv_showlapemblem.value) + K_drawLapStartAnim(); + } + + if (modeattacking || freecam) // everything after here is MP and debug only + return; + + if (G_BattleGametype() && !splitscreen && (stplyr->kartstuff[k_yougotem] % 2)) // * YOU GOT EM * + V_DrawScaledPatch(BASEVIDWIDTH/2 - (kp_yougotem->width/2), 32, V_HUDTRANS, kp_yougotem); + + // Draw FREE PLAY. + if (isfreeplay && !stplyr->spectator && timeinmap > 113) + { + if (LUA_HudEnabled(hud_freeplay)) + K_drawKartFreePlay(leveltime); + } + + if (cv_kartdebugdistribution.value) + K_drawDistributionDebugger(); + + if (cv_kartdebugcheckpoint.value) + K_drawCheckpointDebugger(); + + if (cv_kartdebugdirector.value) + K_DrawDirectorDebugger(); + + if (cv_kartdebugnodes.value) + { + UINT8 p; + for (p = 0; p < MAXPLAYERS; p++) + V_DrawString(8, 64+(8*p), V_YELLOWMAP, va("%d - %d (%dl)", p, playernode[p], players[p].cmd.latency)); + } + + if (cv_kartdebugcolorize.value && stplyr->mo && stplyr->mo->skin) + { + INT32 x = 0, y = 0; + UINT8 c; + + for (c = 1; c < MAXSKINCOLORS; c++) + { + UINT8 *cm = R_GetTranslationColormap(TC_RAINBOW, c, GTC_CACHE); + V_DrawFixedPatch(x<>1, 0, facewantprefix[stplyr->skin], cm); + + x += 16; + if (x > BASEVIDWIDTH-16) + { + x = 0; + y += 16; + } + } + } +} diff --git a/src/k_hud.h b/src/k_hud.h new file mode 100644 index 000000000..3d2e478a7 --- /dev/null +++ b/src/k_hud.h @@ -0,0 +1,81 @@ +// SONIC ROBO BLAST 2 KART +//----------------------------------------------------------------------------- +// Copyright (C) 2018-2020 by Kart Krew +// +// This program is free software distributed under the +// terms of the GNU General Public License, version 2. +// See the 'LICENSE' file for more details. +//----------------------------------------------------------------------------- +/// \file k_hud.h +/// \brief HUD drawing functions exclusive to Kart + +#ifndef __K_HUD__ +#define __K_HUD__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "doomdef.h" +#include "d_player.h" // Need for player_t +#include "command.h" +#include "r_defs.h" + +UINT8 K_GetHudColor(void); +boolean K_UseColorHud(void); +boolean K_UseHighResPortraits(void); +patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum); + +void K_RegisterKartHudStuff(void); + +extern consvar_t cv_colorizedhud, + cv_colorizeditembox, + cv_colorizedhudcolor; + +extern consvar_t cv_darkitembox; +extern consvar_t cv_biglaps; +extern consvar_t cv_highresportrait; +extern consvar_t cv_stat_xoffset, cv_stat_yoffset; +extern consvar_t cv_showstats; +extern consvar_t cv_fancyroulette; +extern consvar_t cv_showlaptimes; +extern consvar_t cv_battlespeedo; +extern consvar_t cv_multiitemicon; +extern consvar_t cv_huditemamount; + +#define NUMSPEEDOSTUFF 8 +extern CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF]; +#define NUMDGAUGESTUFF 6 +extern CV_PossibleValue_t driftgaugestyle_cons_t[NUMDGAUGESTUFF]; +#define NUMINPUTDISPLAYSTUFF 5 +extern CV_PossibleValue_t inputdisplay_cons_t[NUMINPUTDISPLAYSTUFF]; +#define NUMMINIMAPDOTSTUFF 5 +extern CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF]; + +const char *K_GetItemPatch(UINT8 item, boolean tiny); +INT32 K_calcSplitFlags(INT32 snapflags); +void K_LoadKartHUDGraphics(void); +void K_drawKartHUD(void); +void K_drawKartFreePlay(UINT32 flashtime); +void K_drawKartTimestamp(tic_t drawtime, INT32 TX, INT32 TY, INT16 emblemmap, UINT8 mode); + +typedef struct +{ + INT32 x; + INT32 y; + INT32 flags; +} drawinfo_t; + +patch_t *K_getItemBoxPatch(boolean small, boolean dark); +patch_t *K_getItemMulPatch(boolean small); +void K_getItemBoxDrawinfo(drawinfo_t *out); +INT32 K_getMinimapTrans(void); +void K_getLapsDrawinfo(drawinfo_t *out); +void K_getMinimapDrawinfo(drawinfo_t *out); + +#ifdef __cplusplus +} // extern "C" +#endif + +// ========================================================================= +#endif // __K_HUD__ diff --git a/src/k_kart.c b/src/k_kart.c index 65560edd2..62ab77d03 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -10,48 +10,28 @@ #include "command.h" #include "d_netcmd.h" #include "d_player.h" -#include "hu_stuff.h" +#include "k_hud.h" #include "g_game.h" -#include "i_joy.h" #include "m_fixed.h" #include "m_random.h" #include "m_menu.h" // ffdhidshfuisduifigergho9igj89dgodhfih AAAAAAAAAA #include "p_local.h" -#include "p_setup.h" #include "p_slopes.h" #include "r_defs.h" #include "r_draw.h" -#include "r_local.h" #include "r_state.h" #include "r_things.h" -#include "r_fps.h" #include "s_sound.h" -#include "screen.h" -#include "st_stuff.h" #include "tables.h" #include "v_video.h" -#include "z_zone.h" #include "m_misc.h" #include "m_cond.h" #include "k_director.h" #include "k_kart.h" #include "k_stats.h" -#include "f_finale.h" -#include "lua_hud.h" // For Lua hud checks #include "lua_hook.h" // For MobjDamage and ShouldDamage -#include "d_main.h" // found_extra_kart - - #include "i_video.h" -#ifdef HWRENDER -#include "hardware/hw_main.h" -#endif - -#ifdef ROTSPRITE -#include "r_patchrotation.h" -#endif - // Not sure if thats best place for that static mobjtype_t stardust = 0; static mobjtype_t watertrailunderlay = 0, watertrail = 0; @@ -96,35 +76,6 @@ static inline angle_t K_MomentumAngle(const mobj_t *mo, const fixed_t threshold) } } -// Hud offset cvars -#define IMPL_HUD_OFFSET_X(name)\ -consvar_t cv_##name##_xoffset = {"hud_" #name "_xoffset", "0", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL}; - -#define IMPL_HUD_OFFSET_Y(name)\ -consvar_t cv_##name##_yoffset = {"hud_" #name "_yoffset", "0", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL}; - -#define IMPL_HUD_OFFSET(name)\ -IMPL_HUD_OFFSET_X(name)\ -IMPL_HUD_OFFSET_Y(name) - -IMPL_HUD_OFFSET(item); // Item box -IMPL_HUD_OFFSET(time); // Time -IMPL_HUD_OFFSET(laps); // Number of laps -IMPL_HUD_OFFSET(dnft); // Countdown (did not finish timer) -IMPL_HUD_OFFSET(speed); // Speedometer -IMPL_HUD_OFFSET(posi); // Position in race -IMPL_HUD_OFFSET(wheel); // RA Wheel -IMPL_HUD_OFFSET(face); // Mini rankings -IMPL_HUD_OFFSET(stcd); // Starting countdown -IMPL_HUD_OFFSET_Y(chek); // Check gfx -IMPL_HUD_OFFSET(mini); // Minimap -IMPL_HUD_OFFSET(want); // Wanted -IMPL_HUD_OFFSET(stat); // Stats - -#undef IMPL_HUD_OFFSET -#undef IMPL_HUD_OFFSET_X -#undef IMPL_HUD_OFFSET_Y - // extra colourisation stuff static CV_PossibleValue_t colorspeedlines_cons_t[] = {{0, "Off"}, {1, "Normal"}, {2, "+Driftcharge"}, {3, "Drift only"}, {0, NULL}}; consvar_t cv_coloredspeedlines = {"colorizedspeedlines", "Off", CV_SAVE, colorspeedlines_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; @@ -137,36 +88,6 @@ consvar_t cv_bananthrowroll = {"bananthrowroll", "0", CV_SAVE, bananthrowroll_co consvar_t cv_airsparks = {"airdriftsparks", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -//extra hud things -consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -CV_PossibleValue_t inputdisplay_cons_t[NUMINPUTDISPLAYSTUFF]; -consvar_t cv_showinput = {"showinput", "Off", CV_SAVE, inputdisplay_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_showlaptimes = {"showlaptimes", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; - -consvar_t cv_posanim = {"postitionanimation", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_smallposnum = {"smallpositionnumber", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; - -consvar_t cv_fancyroulette = {"animatedroulette", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; - -consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF]; -consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; - -consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead - -consvar_t cv_showlapemblem = {"showlapemblem", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_biglaps = {"biglaphud", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // here for ppl who dont want to make 2 more patches for their custom hud - -consvar_t cv_darkitembox = {"darkitembox", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // itembox gets a dark border with specific items -consvar_t cv_multiitemicon = {"multiitemicon", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -static CV_PossibleValue_t huditemamount_cons_t[] = {{0, "Vanilla"}, {1, "Multiple"}, {2, "Always"},{0, NULL}}; -consvar_t cv_huditemamount = {"showitemamountnumber", "Vanilla", CV_SAVE, huditemamount_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; - -CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF]; -consvar_t cv_newspeedometer = {"newspeedometer", "Default", CV_SAVE, speedo_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_battlespeedo = {"battlespeedo", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // toggle for showing the speedometer in battlemode - consvar_t cv_playerblendeffects = {"playerblendeffects", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // funn-E streeetch @@ -226,50 +147,6 @@ static void saltyhop_onchange(void) } } -// Colourized HUD -consvar_t cv_colorizedhud = {"colorizedhud", "Off", CV_SAVE|CV_CALL, CV_OnOff, SaturnHud_menu_Onchange, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_colorizeditembox = {"colorizeditembox", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; - -static CV_PossibleValue_t HudColor_cons_t[MAXSKINCOLORS+1]; -consvar_t cv_colorizedhudcolor = {"colorizedhudcolor", "Skin Color", CV_SAVE, HudColor_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; - -// driftgauge stuffs -static CV_PossibleValue_t driftgaugeoffset_cons_t[] = { - {-FRACUNIT*128, "MIN"}, {FRACUNIT*128, "MAX"}, {0, NULL}}; -CV_PossibleValue_t driftgaugestyle_cons_t[NUMDGAUGESTUFF]; - -consvar_t cv_driftgauge = {"kartdriftgauge", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_driftgaugeofs = {"kartdriftgaugeoffset", "-20", CV_FLOAT|CV_SAVE, driftgaugeoffset_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_driftgaugetrans = {"kartdriftgaugetransparency", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_driftgaugestyle = {"kartdriftgaugestyle", "1", CV_SAVE, driftgaugestyle_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; - -// nametags -static CV_PossibleValue_t nametagtrans_cons_t[] = { - {0, "Never"}, {1, "Far only"}, {2, "Dynamic"}, {3, "Always"}, {4, "HUD Trans."}, {0, NULL}}; -/*static CV_PossibleValue_t nametagscaling_cons_t[] = { - {0, "MIN"}, {320, "MAX"}, {0, NULL}};*/ -static CV_PossibleValue_t nametagdistance_cons_t[] = { - {0, "MIN"}, {640, "MAX"}, {0, NULL}}; -static CV_PossibleValue_t nametagmaxplayer_cons_t[] = { - {1, "MIN"}, {MAXPLAYERS, "MAX"}, {0, NULL}}; -static CV_PossibleValue_t nametagsize_cons_t[] = { - {0, "Off"}, {1, "Small"}, {2, "Minimal"}, {0, NULL}}; -static CV_PossibleValue_t nametagrestat_cons_t[] = { - {0, "Off"}, {1, "Restat"}, {2, "Always"}, {0, NULL}}; - -consvar_t cv_nametag = {"kartnametag", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagtrans = {"kartnametagtransparency", "Dynamic", CV_SAVE, nametagtrans_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagfacerank = {"kartnametagfacerank", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagrestat = {"kartnametagrestat", "Restat", CV_SAVE, nametagrestat_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagdist = {"kartnametagdist", "320", CV_SAVE, nametagdistance_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagmaxplayers = {"kartnametagmaxplayers", "3", CV_SAVE, nametagmaxplayer_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagmaxlenght = {"kartnametagmaxlenght", "12", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NULL, 0, 0, NULL}; -//consvar_t cv_nametagscaling = {"nametagscaling", "160", CV_SAVE, nametagscaling_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_showownnametag = {"kartnametagshowown", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_smallnametags = {"kartnametagsmall", "Off", CV_SAVE, nametagsize_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_nametagscore = {"kartnametagscore", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; -consvar_t cv_shownametagspectator = {"kartshownametagspectator", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL}; - static boolean K_SpeedLinesShouldBlend(player_t *player); // SOME IMPORTANT VARIABLES DEFINED IN DOOMDEF.H: @@ -282,9 +159,6 @@ static boolean K_SpeedLinesShouldBlend(player_t *player); // mapreset is set when enough players fill an empty server // nospectategrief is the players in-game needed to eliminate the person in last -#define XTRA3PSCALE 50135 //0.765 -#define XTRA3VSCALE 35344 //0.55 - //{ SRB2kart Color Code #define SKIN_RAMP_LENGTH 16 @@ -818,78 +692,6 @@ UINT8 K_GetKartColorByName(const char *name) return 0; } -UINT8 K_GetHudColor(void) -{ - if (cv_colorizedhud.value && cv_colorizedhudcolor.value) - return cv_colorizedhudcolor.value; - - return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : cv_playercolor.value); -} - -boolean K_UseColorHud(void) -{ - return (cv_colorizedhud.value && clr_hud); -} - -enum -{ - SPEEDO_VANILLA, - SPEEDO_EXTRA, - SPEEDO_ACHII, - SPEEDO_DIAL, - SPEEDO_PMETER, - SPEEDO_PMETERSMOL, - SPEEDO_EXTRA3, -}; - -static SINT8 K_GetSpeedometerStyle(void) -{ - if (cv_newspeedometer.value == 2 && xtra_speedo) - return SPEEDO_EXTRA; - else if (cv_newspeedometer.value == 3 && achi_speedo) - return SPEEDO_ACHII; - else if (cv_newspeedometer.value == 4 && dial_speedo) - return SPEEDO_DIAL; - else if (cv_newspeedometer.value == 5 && kartz_speedo) - return SPEEDO_PMETER; - else if (cv_newspeedometer.value == 6 && kartz_speedo_smol) - return SPEEDO_PMETERSMOL; - else if (cv_newspeedometer.value == 7 && xtra_speedo3) - return SPEEDO_EXTRA3; - else - return SPEEDO_VANILLA; -} - -static boolean K_UseColorSpeedo(int speedostyle) -{ - if (!K_UseColorHud()) - return false; - - switch (speedostyle) - { - case SPEEDO_EXTRA: - return xtra_speedo_clr; - case SPEEDO_ACHII: - return achi_speedo_clr; - case SPEEDO_DIAL: - return dial_speedo_clr; - case SPEEDO_EXTRA3: - return xtra_speedo_clr3; - default: - return false; - } -} - -static boolean K_IsHighResolution(void) -{ - return (vid.width >= 640 && vid.height >= 400); -} - -boolean K_UseHighResPortraits(void) -{ - return (cv_highresportrait.value && K_IsHighResolution()); -} - // returns the players skinnumber // accounts for localskins INT32 K_GetSkinNum(player_t *player) @@ -925,16 +727,6 @@ skin_t *K_GetPlayerSkin(player_t *player) return &K_GetSkinArray(player->skinlocal)[K_GetSkinNum(player)]; } -// returns the players faceprefix -// accounts for localskins -patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum) -{ - if (!player->skinlocal) - return (K_UseHighResPortraits() ? facewantprefix[skinnum] : facerankprefix[skinnum]); - else - return (K_UseHighResPortraits() ? localfacewantprefix[skinnum] : localfacerankprefix[skinnum]); -} - //} //{ SRB2kart Net Variables @@ -965,8 +757,6 @@ void K_RegisterServerKartStuff(void) CV_RegisterVar(&cv_quadorbinaut); CV_RegisterVar(&cv_dualjawz); - CV_RegisterVar(&cv_kartminimap); - CV_RegisterVar(&cv_kartcheck); CV_RegisterVar(&cv_kartinvinsfx); CV_RegisterVar(&cv_kartspeed); CV_RegisterVar(&cv_kartbumpers); @@ -975,7 +765,6 @@ void K_RegisterServerKartStuff(void) CV_RegisterVar(&cv_kartencore); CV_RegisterVar(&cv_kartvoterulechanges); CV_RegisterVar(&cv_kartgametypepreference); - CV_RegisterVar(&cv_kartspeedometer); CV_RegisterVar(&cv_kartvoices); CV_RegisterVar(&cv_karthitemdialog); CV_RegisterVar(&cv_karteliminatelast); @@ -996,44 +785,7 @@ void K_RegisterServerKartStuff(void) // Nothing needed for a dedicated server should be registered here. void K_RegisterClientKartStuff(void) { - HudColor_cons_t[0].value = 0; - HudColor_cons_t[0].strvalue = "Skin Color"; - - for (INT32 i = 1; i < MAXSKINCOLORS; i++) - { - HudColor_cons_t[i].value = i; - HudColor_cons_t[i].strvalue = KartColor_Names[i]; // SRB2kart - } - HudColor_cons_t[MAXSKINCOLORS].value = 0; - HudColor_cons_t[MAXSKINCOLORS].strvalue = NULL; - -#define REG_HUD_OFFSET_X(name)\ - CV_RegisterVar(&cv_##name##_xoffset); - -#define REG_HUD_OFFSET_Y(name)\ - CV_RegisterVar(&cv_##name##_yoffset); - -#define REG_HUD_OFFSET(name)\ - REG_HUD_OFFSET_X(name)\ - REG_HUD_OFFSET_Y(name) - - REG_HUD_OFFSET(item); // Item box - REG_HUD_OFFSET(time); // Time - REG_HUD_OFFSET(laps); // Number of laps - REG_HUD_OFFSET(dnft); // Countdown (did not finish timer) - REG_HUD_OFFSET(speed); // Speedometer - REG_HUD_OFFSET(posi); // Position in race - REG_HUD_OFFSET(wheel); // Position in race - REG_HUD_OFFSET(face); // Mini rankings - REG_HUD_OFFSET(stcd); // Starting countdown - REG_HUD_OFFSET_Y(chek); // Check gfx - REG_HUD_OFFSET(mini); // Minimap - REG_HUD_OFFSET(want); // Wanted - REG_HUD_OFFSET(stat); // Stats - -#undef REG_HUD_OFFSET -#undef REG_HUD_OFFSET_X -#undef REG_HUD_OFFSET_Y + K_RegisterKartHudStuff(); // Colored speedlines CV_RegisterVar(&cv_coloredspeedlines); @@ -1046,61 +798,8 @@ void K_RegisterClientKartStuff(void) CV_RegisterVar(&cv_airsparks); - CV_RegisterVar(&cv_showstats); - CV_RegisterVar(&cv_showinput); - - CV_RegisterVar(&cv_posanim); - CV_RegisterVar(&cv_smallposnum); - - CV_RegisterVar(&cv_fancyroulette); - - CV_RegisterVar(&cv_showlaptimes); - CV_RegisterVar(&cv_newspeedometer); - - CV_RegisterVar(&cv_battlespeedo); - - CV_RegisterVar(&cv_minihead); - CV_RegisterVar(&cv_showminimapnames); - CV_RegisterVar(&cv_showminimapangle); - - CV_RegisterVar(&cv_showlapemblem); - - CV_RegisterVar(&cv_stagetitle); - CV_RegisterVar(&cv_playerblendeffects); - // Colourized HUD - CV_RegisterVar(&cv_colorizedhud); - CV_RegisterVar(&cv_colorizedhudcolor); - CV_RegisterVar(&cv_colorizeditembox); - - CV_RegisterVar(&cv_biglaps); - - CV_RegisterVar(&cv_darkitembox); - - CV_RegisterVar(&cv_multiitemicon); - CV_RegisterVar(&cv_huditemamount); - - CV_RegisterVar(&cv_highresportrait); - - CV_RegisterVar(&cv_nametag); - CV_RegisterVar(&cv_nametagtrans); - CV_RegisterVar(&cv_nametagfacerank); - CV_RegisterVar(&cv_nametagmaxplayers); - CV_RegisterVar(&cv_nametagmaxlenght); - //CV_RegisterVar(&cv_nametagscaling); - CV_RegisterVar(&cv_nametagdist); - CV_RegisterVar(&cv_showownnametag); - CV_RegisterVar(&cv_smallnametags); - CV_RegisterVar(&cv_nametagrestat); - CV_RegisterVar(&cv_nametagscore); - CV_RegisterVar(&cv_shownametagspectator); - - CV_RegisterVar(&cv_driftgauge); - CV_RegisterVar(&cv_driftgaugeofs); - CV_RegisterVar(&cv_driftgaugetrans); - CV_RegisterVar(&cv_driftgaugestyle); - CV_RegisterVar(&cv_saltyhop); CV_RegisterVar(&cv_saltyhopsfx); CV_RegisterVar(&cv_saltysquish); @@ -1112,8 +811,6 @@ void K_RegisterClientKartStuff(void) CV_RegisterVar(&cv_squishdance); CV_RegisterVar(&cv_squishdancespeed); - CV_RegisterVar(&cv_lessflicker); - CV_RegisterVar(&cv_mouseturn); } @@ -1281,7 +978,7 @@ static void K_KartGetItemResult(player_t *player, SINT8 getitem) \return void */ -static INT32 K_KartGetItemOdds(UINT8 pos, SINT8 item, fixed_t mashed, boolean spbrush) +INT32 K_KartGetItemOdds(UINT8 pos, SINT8 item, fixed_t mashed, boolean spbrush) { const INT32 distvar = (64*14); INT32 newodds; @@ -1440,7 +1137,7 @@ static INT32 K_KartGetItemOdds(UINT8 pos, SINT8 item, fixed_t mashed, boolean sp //{ SRB2kart Roulette Code - Distance Based, no waypoints -static INT32 K_FindUseodds(player_t *player, fixed_t mashed, INT32 pingame, INT32 bestbumper, boolean spbrush, boolean dontforcespb) +INT32 K_FindUseodds(player_t *player, fixed_t mashed, INT32 pingame, INT32 bestbumper, boolean spbrush, boolean dontforcespb) { const INT32 distvar = (64*14); INT32 i; @@ -7852,4468 +7549,3 @@ void K_UpdateSpectateGrief(void) } //} - -//{ SRB2kart HUD Code - -#define NUMPOSNUMS 10 -#define NUMPOSFRAMES 7 // White, three blues, three reds -#define NUMWINFRAMES 6 // Red, yellow, green, cyan, blue, purple - -//{ Patch Definitions - -// --Saturn patches-- -// dont leave those unitialized incase we missed a check somewhere - -// -Speedometers- - -// Smol speedo -static patch_t *skp_smallsticker = NULL; -static patch_t *skp_smallsticker3 = NULL; - -static patch_t *skp_speedpatches[5] = {NULL}; - -// Achii speedo -static patch_t *skp_smallstickerachi = NULL; -static patch_t *skp_speedpatchesachi[5] = {NULL}; -static patch_t *skp_smallstickerachiclr = NULL; -static patch_t *skp_speedpatchesachiclr[5] = {NULL}; - -// Kartz speedo -static patch_t *kp_kartzspeedo[25] = {NULL}; -static patch_t *kp_kartzspeedo_smol[25] = {NULL}; - -// dial speedometer -static patch_t *skp_rankfinish = NULL; -static patch_t *skp_dialbase[2] = {NULL}; -static patch_t *skp_speedpatchesdial[5] = {NULL}; -static patch_t *skp_dialnum[10] = {NULL}; -//static patch_t *skp_dialclr = NULL; -static patch_t *skp_dialbaseclr[2] = {NULL}; -static patch_t *skp_speedpatchesdialclr[5] = {NULL}; -static patch_t *skp_dialnumclr[10] = {NULL}; - -// -Colourized hud- - -static patch_t *kp_timestickerclr = NULL; -static patch_t *kp_timestickerwideclr = NULL; -static patch_t *kp_lapstickerclr = NULL; -static patch_t *kp_lapstickerbigclr = NULL; -static patch_t *kp_lapstickerbig2clr = NULL; -static patch_t *kp_lapstickerwideclr = NULL; -//static patch_t *kp_lapstickernarrowclr = NULL; -static patch_t *kp_bumperstickerclr = NULL; -static patch_t *kp_bumperstickerwideclr = NULL; -static patch_t *kp_karmastickerclr = NULL; -static patch_t *kp_timeoutstickerclr = NULL; -static patch_t *skp_smallstickerclr = NULL; -static patch_t *skp_smallstickerclr3 = NULL; -static patch_t *kp_itemmulstickerclr[2] = {NULL}; -static patch_t *kp_itembgclr[4] = {NULL}; - -// -Misc.- - -static patch_t *kp_lapstickerbig = NULL; -static patch_t *kp_lapstickerbig2 = NULL; - -static patch_t *nametagpic = NULL; -static patch_t *nametagline = NULL; -static patch_t *nametagspeed = NULL; -static patch_t *nametagweight = NULL; - -static patch_t *driftgauge = NULL; -static patch_t *driftgaugecolor = NULL; -static patch_t *driftgaugesmall = NULL; -static patch_t *driftgaugesmallcolor = NULL; - -static patch_t *kp_minimapdot = NULL; - -static patch_t *joybacking = NULL; -static patch_t *joyknob = NULL; -static patch_t *joyshadow = NULL; - -static patch_t *kp_multjawz = NULL; -static patch_t *kp_multsneaker[2] = {NULL}; -static patch_t *kp_multbanana[3] = {NULL}; - -static void K_LoadSaturnHUDGraphics(void) -{ - INT32 i; - char buffer[9]; - - if (found_extra_kart) - { - if (xtra_speedo) // smol speedometer - { - skp_smallsticker = (patch_t *)W_CachePatchName("SP_SMSTC", PU_HUDGFX); - skp_speedpatches[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd - skp_speedpatches[1] = (patch_t *)W_CachePatchName("SP_MKMH", PU_HUDGFX); - skp_speedpatches[2] = (patch_t *)W_CachePatchName("SP_MMPH", PU_HUDGFX); - skp_speedpatches[3] = (patch_t *)W_CachePatchName("SP_MFRAC", PU_HUDGFX); - skp_speedpatches[4] = (patch_t *)W_CachePatchName("SP_MPERC", PU_HUDGFX); - } - - if (achi_speedo) - { - skp_smallstickerachi = (patch_t *)W_CachePatchName("SP_AMSTC", PU_HUDGFX); - skp_speedpatchesachi[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd - skp_speedpatchesachi[1] = (patch_t *)W_CachePatchName("SP_AKMH", PU_HUDGFX); - skp_speedpatchesachi[2] = (patch_t *)W_CachePatchName("SP_AMPH", PU_HUDGFX); - skp_speedpatchesachi[3] = (patch_t *)W_CachePatchName("SP_AFRAC", PU_HUDGFX); - skp_speedpatchesachi[4] = (patch_t *)W_CachePatchName("SP_APERC", PU_HUDGFX); - } - - if (dial_speedo) - { - skp_rankfinish = (patch_t *)W_CachePatchName("RANKFIN", PU_HUDGFX); - skp_dialbase[0] = (patch_t *)W_CachePatchName("K_DSPBS1", PU_HUDGFX); - skp_dialbase[1] = (patch_t *)W_CachePatchName("K_DSPBS2", PU_HUDGFX); - - skp_speedpatchesdial[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd - skp_speedpatchesdial[1] = (patch_t *)W_CachePatchName("SP_DKMH", PU_HUDGFX); - skp_speedpatchesdial[2] = (patch_t *)W_CachePatchName("SP_DMPH", PU_HUDGFX); - skp_speedpatchesdial[3] = (patch_t *)W_CachePatchName("SP_DFRAC", PU_HUDGFX); - skp_speedpatchesdial[4] = (patch_t *)W_CachePatchName("SP_DPERC", PU_HUDGFX); - - sprintf(buffer, "K_DSPNMx"); - for (i = 0; i < 10; i++) - { - buffer[7] = '0'+(i%10); - skp_dialnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - } - - // KartZ speedo - if (kartz_speedo) - { - const char* patchNames[] = { - "K_KZSP1", "K_KZSP2", "K_KZSP3", "K_KZSP4", "K_KZSP5", - "K_KZSP6", "K_KZSP7", "K_KZSP8", "K_KZSP9", "K_KZSP10", - "K_KZSP11", "K_KZSP12", "K_KZSP13", "K_KZSP14", "K_KZSP15", - "K_KZSP16", "K_KZSP17", "K_KZSP18", "K_KZSP19", "K_KZSP20", - "K_KZSP21", "K_KZSP22", "K_KZSP23", "K_KZSP24", "K_KZSP25" - }; - - for (size_t m = 0; m < sizeof(patchNames) / sizeof(patchNames[0]); ++m) - { - kp_kartzspeedo[m] = (patch_t *)W_CachePatchName(patchNames[m], PU_HUDGFX); - } - } - - if (kartz_speedo_smol) - { - const char* patchNames[] = { - "K_KZSS1", "K_KZSS2", "K_KZSS3", "K_KZSS4", "K_KZSS5", - "K_KZSS6", "K_KZSS7", "K_KZSS8", "K_KZSS9", "K_KZSS10", - "K_KZSS11", "K_KZSS12", "K_KZSS13", "K_KZSS14", "K_KZSS15", - "K_KZSS16", "K_KZSS17", "K_KZSS18", "K_KZSS19", "K_KZSS20", - "K_KZSS21", "K_KZSS22", "K_KZSS23", "K_KZSS24", "K_KZSS25" - }; - - for (size_t m = 0; m < sizeof(patchNames) / sizeof(patchNames[0]); ++m) - { - kp_kartzspeedo_smol[m] = (patch_t *)W_CachePatchName(patchNames[m], PU_HUDGFX); - } - } - - if (big_lap) - { - kp_lapstickerbig = (patch_t *)W_CachePatchName("K_STLAPB", PU_HUDGFX); - kp_lapstickerbig2 = (patch_t *)W_CachePatchName("K_STLA2B", PU_HUDGFX); - } - - // Nametags - if (nametaggfx) - { - nametagpic = (patch_t *)W_CachePatchName("NTLINE", PU_HUDGFX); - nametagline = (patch_t *)W_CachePatchName("NTLINEV", PU_HUDGFX); - nametagspeed = (patch_t *)W_CachePatchName("NTSP", PU_HUDGFX); - nametagweight = (patch_t *)W_CachePatchName("NTWH", PU_HUDGFX); - } - - if (driftgaugegfx) - { - driftgauge = (patch_t *)W_CachePatchName("K_DGAU", PU_HUDGFX); - driftgaugesmall = (patch_t *)W_CachePatchName("K_DGSU", PU_HUDGFX); - - if (driftgaugegfx_clr) - { - driftgaugecolor = (patch_t *)W_CachePatchName("K_DCAU", PU_HUDGFX); - driftgaugesmallcolor = (patch_t *)W_CachePatchName("K_DCSU", PU_HUDGFX); - } - } - - if (joystickicon) - { - joybacking = (patch_t *)W_CachePatchName("JOYBCK", PU_HUDGFX); - joyknob = (patch_t *)W_CachePatchName("JOYKNB", PU_HUDGFX); - joyshadow = (patch_t *)W_CachePatchName("JOYSHD", PU_HUDGFX); - } - - if (minidoticon) - { - kp_minimapdot = (patch_t *)W_CachePatchName("MMAPDOT", PU_HUDGFX); - } - - if (multiitem_icon) - { - kp_multsneaker[0] = (patch_t *)W_CachePatchName("K_ITSHO2", PU_HUDGFX); - kp_multsneaker[1] = (patch_t *)W_CachePatchName("K_ITSHO3", PU_HUDGFX); - kp_multbanana[0] = (patch_t *)W_CachePatchName("K_ITBAN2", PU_HUDGFX); - kp_multbanana[1] = (patch_t *)W_CachePatchName("K_ITBAN3", PU_HUDGFX); - kp_multbanana[2] = (patch_t *)W_CachePatchName("K_ITBAN4", PU_HUDGFX); - kp_multjawz = (patch_t *)W_CachePatchName("K_ITJAW2", PU_HUDGFX); - } - } - - if (found_extra2_kart) - { - if (xtra_speedo_clr) - { - skp_smallstickerclr = (patch_t *)W_CachePatchName("SC_SMSTC", PU_HUDGFX); - } - - if (xtra_speedo_clr3) - { - skp_smallstickerclr3 = (patch_t *)W_CachePatchName("SC_SM3TC", PU_HUDGFX); - } - - if (achi_speedo_clr) - { - skp_smallstickerachiclr = (patch_t *)W_CachePatchName("SC_AMSTC", PU_HUDGFX); - skp_speedpatchesachiclr[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd - skp_speedpatchesachiclr[1] = (patch_t *)W_CachePatchName("SC_AKMH", PU_HUDGFX); - skp_speedpatchesachiclr[2] = (patch_t *)W_CachePatchName("SC_AMPH", PU_HUDGFX); - skp_speedpatchesachiclr[3] = (patch_t *)W_CachePatchName("SC_AFRAC", PU_HUDGFX); - skp_speedpatchesachiclr[4] = (patch_t *)W_CachePatchName("SC_APERC", PU_HUDGFX); - } - - if (dial_speedo_clr) - { - skp_dialbaseclr[0] = (patch_t *)W_CachePatchName("K_DSPBC1", PU_HUDGFX); - skp_dialbaseclr[1] = (patch_t *)W_CachePatchName("K_DSPBC2", PU_HUDGFX); - - skp_speedpatchesdialclr[0] = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); // lolxd - skp_speedpatchesdialclr[1] = (patch_t *)W_CachePatchName("SC_DKMH", PU_HUDGFX); - skp_speedpatchesdialclr[2] = (patch_t *)W_CachePatchName("SC_DMPH", PU_HUDGFX); - skp_speedpatchesdialclr[3] = (patch_t *)W_CachePatchName("SC_DFRAC", PU_HUDGFX); - skp_speedpatchesdialclr[4] = (patch_t *)W_CachePatchName("SC_DPERC", PU_HUDGFX); - - sprintf(buffer, "K_DSPNCx"); - for (i = 0; i < 10; i++) - { - buffer[7] = '0'+(i%10); - skp_dialnumclr[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - } - - if (big_lap_color) - { - kp_lapstickerbigclr = (patch_t *)W_CachePatchName("K_SCLAPB", PU_HUDGFX); - kp_lapstickerbig2clr = (patch_t *)W_CachePatchName("K_SCLA2B", PU_HUDGFX); - } - - // Colourized hud - if (clr_hud) - { - kp_timestickerclr = (patch_t *)W_CachePatchName("K_SCTIME", PU_HUDGFX); - kp_timestickerwideclr = (patch_t *)W_CachePatchName("K_SCTIMW", PU_HUDGFX); - kp_lapstickerclr = (patch_t *)W_CachePatchName("K_SCLAPS", PU_HUDGFX); - kp_lapstickerwideclr = (patch_t *)W_CachePatchName("K_SCLAPW", PU_HUDGFX); - kp_bumperstickerclr = (patch_t *)W_CachePatchName("K_SCBALN", PU_HUDGFX); - kp_bumperstickerwideclr = (patch_t *)W_CachePatchName("K_SCBALW", PU_HUDGFX); - kp_karmastickerclr = (patch_t *)W_CachePatchName("K_SCKARM", PU_HUDGFX); - kp_timeoutstickerclr = (patch_t *)W_CachePatchName("K_SCTOUT", PU_HUDGFX); - kp_itembgclr[0] = (patch_t *)W_CachePatchName("K_ITBC" , PU_HUDGFX); - kp_itembgclr[1] = (patch_t *)W_CachePatchName("K_ITBCD" , PU_HUDGFX); - kp_itembgclr[2] = (patch_t *)W_CachePatchName("K_ISBC" , PU_HUDGFX); - kp_itembgclr[3] = (patch_t *)W_CachePatchName("K_ISBCD" , PU_HUDGFX); - kp_itemmulstickerclr[1] = (patch_t *)W_CachePatchName("K_ISMULC", PU_HUDGFX); - kp_itemmulstickerclr[0] = (patch_t *)W_CachePatchName("K_ITMULC", PU_HUDGFX); - } - } - - if (found_extra3_kart) - { - if (xtra_speedo3) // 80x11 patch scaled to size - { - skp_smallsticker3 = (patch_t *)W_CachePatchName("SP_SM3TC", PU_HUDGFX); - } - } -} - -// -- Kart patches -- - -static patch_t *kp_nodraw; -static patch_t *kp_timesticker; -static patch_t *kp_timestickerwide; -static patch_t *kp_lapsticker; -static patch_t *kp_lapstickerwide; -//static patch_t *kp_lapstickernarrow; -static patch_t *kp_splitlapflag; -static patch_t *kp_bumpersticker; -static patch_t *kp_bumperstickerwide; -static patch_t *kp_karmasticker; -static patch_t *kp_splitkarmabomb; -static patch_t *kp_timeoutsticker; - -static patch_t *kp_startcountdown[16]; -static patch_t *kp_racefinish[6]; - -static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES]; -static patch_t *kp_winnernum[NUMPOSFRAMES]; - -static patch_t *kp_facenum[MAXPLAYERS+1]; -static patch_t *kp_facehighlight[8]; - -static patch_t *kp_rankbumper; -static patch_t *kp_tinybumper[2]; -static patch_t *kp_ranknobumpers; - -static patch_t *kp_battlewin; -static patch_t *kp_battlecool; -static patch_t *kp_battlelose; -static patch_t *kp_battlewait; -static patch_t *kp_battleinfo; -static patch_t *kp_wanted; -static patch_t *kp_wantedsplit; -static patch_t *kp_wantedreticle; - -static patch_t *kp_itembg[4]; -static patch_t *kp_itemtimer[2]; -static patch_t *kp_itemmulsticker[2]; -static patch_t *kp_itemx; - -static patch_t *kp_sneaker[2]; -static patch_t *kp_rocketsneaker[2]; -static patch_t *kp_invincibility[13]; -static patch_t *kp_banana[2]; -static patch_t *kp_eggman[2]; -static patch_t *kp_orbinaut[5]; -static patch_t *kp_jawz[2]; -static patch_t *kp_mine[2]; -static patch_t *kp_ballhog[2]; -static patch_t *kp_selfpropelledbomb[2]; -static patch_t *kp_grow[2]; -static patch_t *kp_shrink[2]; -static patch_t *kp_thundershield[2]; -static patch_t *kp_hyudoro[2]; -static patch_t *kp_pogospring[2]; -static patch_t *kp_kitchensink[2]; -static patch_t *kp_sadface[2]; - -static patch_t *kp_check[6]; - -static patch_t *kp_eggnum[4]; - -static patch_t *kp_fpview[3]; -static patch_t *kp_inputwheel[5]; - -static patch_t *kp_challenger[25]; - -static patch_t *kp_lapanim_lap[7]; -static patch_t *kp_lapanim_final[11]; -static patch_t *kp_lapanim_number[10][3]; -static patch_t *kp_lapanim_emblem[2]; -static patch_t *kp_lapanim_hand[3]; - -static patch_t *kp_yougotem; - -void K_LoadKartHUDGraphics(void) -{ - INT32 i, j; - char buffer[9]; - - // Null Stuff - kp_nodraw = (patch_t *)W_CachePatchName("K_TRNULL", PU_HUDGFX); - - // Stickers - kp_timesticker = (patch_t *)W_CachePatchName("K_STTIME", PU_HUDGFX); - kp_timestickerwide = (patch_t *)W_CachePatchName("K_STTIMW", PU_HUDGFX); - kp_lapsticker = (patch_t *)W_CachePatchName("K_STLAPS", PU_HUDGFX); - kp_lapstickerwide = (patch_t *)W_CachePatchName("K_STLAPW", PU_HUDGFX); - //kp_lapstickernarrow = (patch_t *)W_CachePatchName("K_STLAPN", PU_HUDGFX); - kp_splitlapflag = (patch_t *)W_CachePatchName("K_SPTLAP", PU_HUDGFX); - kp_bumpersticker = (patch_t *)W_CachePatchName("K_STBALN", PU_HUDGFX); - kp_bumperstickerwide = (patch_t *)W_CachePatchName("K_STBALW", PU_HUDGFX); - kp_karmasticker = (patch_t *)W_CachePatchName("K_STKARM", PU_HUDGFX); - kp_splitkarmabomb = (patch_t *)W_CachePatchName("K_SPTKRM", PU_HUDGFX); - kp_timeoutsticker = (patch_t *)W_CachePatchName("K_STTOUT", PU_HUDGFX); - - // Starting countdown - kp_startcountdown[0] = (patch_t *)W_CachePatchName("K_CNT3A", PU_HUDGFX); - kp_startcountdown[1] = (patch_t *)W_CachePatchName("K_CNT2A", PU_HUDGFX); - kp_startcountdown[2] = (patch_t *)W_CachePatchName("K_CNT1A", PU_HUDGFX); - kp_startcountdown[3] = (patch_t *)W_CachePatchName("K_CNTGOA", PU_HUDGFX); - kp_startcountdown[4] = (patch_t *)W_CachePatchName("K_CNT3B", PU_HUDGFX); - kp_startcountdown[5] = (patch_t *)W_CachePatchName("K_CNT2B", PU_HUDGFX); - kp_startcountdown[6] = (patch_t *)W_CachePatchName("K_CNT1B", PU_HUDGFX); - kp_startcountdown[7] = (patch_t *)W_CachePatchName("K_CNTGOB", PU_HUDGFX); - - // Splitscreen - kp_startcountdown[8] = (patch_t *)W_CachePatchName("K_SMC3A", PU_HUDGFX); - kp_startcountdown[9] = (patch_t *)W_CachePatchName("K_SMC2A", PU_HUDGFX); - kp_startcountdown[10] = (patch_t *)W_CachePatchName("K_SMC1A", PU_HUDGFX); - kp_startcountdown[11] = (patch_t *)W_CachePatchName("K_SMCGOA", PU_HUDGFX); - kp_startcountdown[12] = (patch_t *)W_CachePatchName("K_SMC3B", PU_HUDGFX); - kp_startcountdown[13] = (patch_t *)W_CachePatchName("K_SMC2B", PU_HUDGFX); - kp_startcountdown[14] = (patch_t *)W_CachePatchName("K_SMC1B", PU_HUDGFX); - kp_startcountdown[15] = (patch_t *)W_CachePatchName("K_SMCGOB", PU_HUDGFX); - - // Finish - kp_racefinish[0] = (patch_t *)W_CachePatchName("K_FINA", PU_HUDGFX); - kp_racefinish[1] = (patch_t *)W_CachePatchName("K_FINB", PU_HUDGFX); - - // Splitscreen - kp_racefinish[2] = (patch_t *)W_CachePatchName("K_SMFINA", PU_HUDGFX); - kp_racefinish[3] = (patch_t *)W_CachePatchName("K_SMFINB", PU_HUDGFX); - - // 2P splitscreen - kp_racefinish[4] = (patch_t *)W_CachePatchName("K_2PFINA", PU_HUDGFX); - kp_racefinish[5] = (patch_t *)W_CachePatchName("K_2PFINB", PU_HUDGFX); - - // Position numbers - sprintf(buffer, "K_POSNxx"); - for (i = 0; i < NUMPOSNUMS; i++) - { - buffer[6] = '0'+i; - for (j = 0; j < NUMPOSFRAMES; j++) - { - buffer[7] = '0'+j; - kp_positionnum[i][j] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - } - - sprintf(buffer, "K_POSNWx"); - for (i = 0; i < NUMWINFRAMES; i++) - { - buffer[7] = '0'+i; - kp_winnernum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "OPPRNKxx"); - for (i = 0; i <= MAXPLAYERS; i++) - { - buffer[6] = '0'+(i/10); - buffer[7] = '0'+(i%10); - kp_facenum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "K_CHILIx"); - for (i = 0; i < 8; i++) - { - buffer[7] = '0'+(i+1); - kp_facehighlight[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - // Extra ranking icons - kp_rankbumper = (patch_t *)W_CachePatchName("K_BLNICO", PU_HUDGFX); - kp_tinybumper[0] = (patch_t *)W_CachePatchName("K_BLNA", PU_HUDGFX); - kp_tinybumper[1] = (patch_t *)W_CachePatchName("K_BLNB", PU_HUDGFX); - kp_ranknobumpers = (patch_t *)W_CachePatchName("K_NOBLNS", PU_HUDGFX); - - // Battle graphics - kp_battlewin = (patch_t *)W_CachePatchName("K_BWIN", PU_HUDGFX); - kp_battlecool = (patch_t *)W_CachePatchName("K_BCOOL", PU_HUDGFX); - kp_battlelose = (patch_t *)W_CachePatchName("K_BLOSE", PU_HUDGFX); - kp_battlewait = (patch_t *)W_CachePatchName("K_BWAIT", PU_HUDGFX); - kp_battleinfo = (patch_t *)W_CachePatchName("K_BINFO", PU_HUDGFX); - kp_wanted = (patch_t *)W_CachePatchName("K_WANTED", PU_HUDGFX); - kp_wantedsplit = (patch_t *)W_CachePatchName("4PWANTED", PU_HUDGFX); - kp_wantedreticle = (patch_t *)W_CachePatchName("MMAPWANT", PU_HUDGFX); - - // Kart Item Windows - kp_itembg[0] = (patch_t *)W_CachePatchName("K_ITBG", PU_HUDGFX); - kp_itembg[1] = (patch_t *)W_CachePatchName("K_ITBGD", PU_HUDGFX); - kp_itemtimer[0] = (patch_t *)W_CachePatchName("K_ITIMER", PU_HUDGFX); - kp_itemmulsticker[0] = (patch_t *)W_CachePatchName("K_ITMUL", PU_HUDGFX); - kp_itemx = (patch_t *)W_CachePatchName("K_ITX", PU_HUDGFX); - // Splitscreen - kp_itembg[2] = (patch_t *)W_CachePatchName("K_ISBG", PU_HUDGFX); - kp_itembg[3] = (patch_t *)W_CachePatchName("K_ISBGD", PU_HUDGFX); - kp_itemtimer[1] = (patch_t *)W_CachePatchName("K_ISIMER", PU_HUDGFX); - kp_itemmulsticker[1] = (patch_t *)W_CachePatchName("K_ISMUL", PU_HUDGFX); - - // Kart Items - kp_sneaker[0] = (patch_t *)W_CachePatchName("K_ITSHOE", PU_HUDGFX); - kp_rocketsneaker[0] = (patch_t *)W_CachePatchName("K_ITRSHE", PU_HUDGFX); - kp_banana[0] = (patch_t *)W_CachePatchName("K_ITBANA", PU_HUDGFX); - kp_eggman[0] = (patch_t *)W_CachePatchName("K_ITEGGM", PU_HUDGFX); - kp_jawz[0] = (patch_t *)W_CachePatchName("K_ITJAWZ", PU_HUDGFX); - kp_mine[0] = (patch_t *)W_CachePatchName("K_ITMINE", PU_HUDGFX); - kp_ballhog[0] = (patch_t *)W_CachePatchName("K_ITBHOG", PU_HUDGFX); - kp_selfpropelledbomb[0] = (patch_t *)W_CachePatchName("K_ITSPB", PU_HUDGFX); - kp_grow[0] = (patch_t *)W_CachePatchName("K_ITGROW", PU_HUDGFX); - kp_shrink[0] = (patch_t *)W_CachePatchName("K_ITSHRK", PU_HUDGFX); - kp_thundershield[0] = (patch_t *)W_CachePatchName("K_ITTHNS", PU_HUDGFX); - kp_hyudoro[0] = (patch_t *)W_CachePatchName("K_ITHYUD", PU_HUDGFX); - kp_pogospring[0] = (patch_t *)W_CachePatchName("K_ITPOGO", PU_HUDGFX); - kp_kitchensink[0] = (patch_t *)W_CachePatchName("K_ITSINK", PU_HUDGFX); - kp_sadface[0] = (patch_t *)W_CachePatchName("K_ITSAD", PU_HUDGFX); - // Splitscreen - kp_sneaker[1] = (patch_t *)W_CachePatchName("K_ISSHOE", PU_HUDGFX); - kp_rocketsneaker[1] = (patch_t *)W_CachePatchName("K_ISRSHE", PU_HUDGFX); - kp_banana[1] = (patch_t *)W_CachePatchName("K_ISBANA", PU_HUDGFX); - kp_eggman[1] = (patch_t *)W_CachePatchName("K_ISEGGM", PU_HUDGFX); - kp_orbinaut[4] = (patch_t *)W_CachePatchName("K_ISORBN", PU_HUDGFX); - kp_jawz[1] = (patch_t *)W_CachePatchName("K_ISJAWZ", PU_HUDGFX); - kp_mine[1] = (patch_t *)W_CachePatchName("K_ISMINE", PU_HUDGFX); - kp_ballhog[1] = (patch_t *)W_CachePatchName("K_ISBHOG", PU_HUDGFX); - kp_selfpropelledbomb[1] = (patch_t *)W_CachePatchName("K_ISSPB", PU_HUDGFX); - kp_grow[1] = (patch_t *)W_CachePatchName("K_ISGROW", PU_HUDGFX); - kp_shrink[1] = (patch_t *)W_CachePatchName("K_ISSHRK", PU_HUDGFX); - kp_thundershield[1] = (patch_t *)W_CachePatchName("K_ISTHNS", PU_HUDGFX); - kp_hyudoro[1] = (patch_t *)W_CachePatchName("K_ISHYUD", PU_HUDGFX); - kp_pogospring[1] = (patch_t *)W_CachePatchName("K_ISPOGO", PU_HUDGFX); - kp_kitchensink[1] = (patch_t *)W_CachePatchName("K_ISSINK", PU_HUDGFX); - kp_sadface[1] = (patch_t *)W_CachePatchName("K_ISSAD", PU_HUDGFX); - - sprintf(buffer, "K_ITINVx"); - for (i = 0; i < 7; i++) - { - buffer[7] = '1'+i; - kp_invincibility[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "K_ITORBx"); - for (i = 0; i < 4; i++) - { - buffer[7] = '1'+i; - kp_orbinaut[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "K_ISINVx"); - for (i = 0; i < 6; i++) - { - buffer[7] = '1'+i; - kp_invincibility[i+7] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - // CHECK indicators - sprintf(buffer, "K_CHECKx"); - for (i = 0; i < 6; i++) - { - buffer[7] = '1'+i; - kp_check[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - // Eggman warning numbers - sprintf(buffer, "K_EGGNx"); - for (i = 0; i < 4; i++) - { - buffer[6] = '0'+i; - kp_eggnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - // First person mode - kp_fpview[0] = (patch_t *)W_CachePatchName("VIEWA0", PU_HUDGFX); - kp_fpview[1] = (patch_t *)W_CachePatchName("VIEWB0D0", PU_HUDGFX); - kp_fpview[2] = (patch_t *)W_CachePatchName("VIEWC0E0", PU_HUDGFX); - - // Input UI Wheel - sprintf(buffer, "K_WHEELx"); - for (i = 0; i < 5; i++) - { - buffer[7] = '0'+i; - kp_inputwheel[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - // HERE COMES A NEW CHALLENGER - sprintf(buffer, "K_CHALxx"); - for (i = 0; i < 25; i++) - { - buffer[6] = '0'+((i+1)/10); - buffer[7] = '0'+((i+1)%10); - kp_challenger[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - // Lap start animation - sprintf(buffer, "K_LAP0x"); - for (i = 0; i < 7; i++) - { - buffer[6] = '0'+(i+1); - kp_lapanim_lap[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "K_LAPFxx"); - for (i = 0; i < 11; i++) - { - buffer[6] = '0'+((i+1)/10); - buffer[7] = '0'+((i+1)%10); - kp_lapanim_final[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "K_LAPNxx"); - for (i = 0; i < 10; i++) - { - buffer[6] = '0'+i; - for (j = 0; j < 3; j++) - { - buffer[7] = '0'+(j+1); - kp_lapanim_number[i][j] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - } - - sprintf(buffer, "K_LAPE0x"); - for (i = 0; i < 2; i++) - { - buffer[7] = '0'+(i+1); - kp_lapanim_emblem[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - sprintf(buffer, "K_LAPH0x"); - for (i = 0; i < 3; i++) - { - buffer[7] = '0'+(i+1); - kp_lapanim_hand[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX); - } - - kp_yougotem = (patch_t *)W_CachePatchName("YOUGOTEM", PU_HUDGFX); - - if (found_extra_kart || found_extra2_kart || found_extra3_kart) - K_LoadSaturnHUDGraphics(); -} - -// For the item toggle menu -const char *K_GetItemPatch(UINT8 item, boolean tiny) -{ - switch (item) - { - case KITEM_SNEAKER: - case KRITEM_TRIPLESNEAKER: - return (tiny ? "K_ISSHOE" : "K_ITSHOE"); - case KITEM_ROCKETSNEAKER: - return (tiny ? "K_ISRSHE" : "K_ITRSHE"); - case KITEM_INVINCIBILITY: - return (tiny ? "K_ISINV1" : "K_ITINV1"); - case KITEM_BANANA: - case KRITEM_TRIPLEBANANA: - case KRITEM_TENFOLDBANANA: - return (tiny ? "K_ISBANA" : "K_ITBANA"); - case KITEM_EGGMAN: - return (tiny ? "K_ISEGGM" : "K_ITEGGM"); - case KITEM_ORBINAUT: - return (tiny ? "K_ISORBN" : "K_ITORB1"); - case KITEM_JAWZ: - case KRITEM_DUALJAWZ: - return (tiny ? "K_ISJAWZ" : "K_ITJAWZ"); - case KITEM_MINE: - return (tiny ? "K_ISMINE" : "K_ITMINE"); - case KITEM_BALLHOG: - return (tiny ? "K_ISBHOG" : "K_ITBHOG"); - case KITEM_SPB: - return (tiny ? "K_ISSPB" : "K_ITSPB"); - case KITEM_GROW: - return (tiny ? "K_ISGROW" : "K_ITGROW"); - case KITEM_SHRINK: - return (tiny ? "K_ISSHRK" : "K_ITSHRK"); - case KITEM_THUNDERSHIELD: - return (tiny ? "K_ISTHNS" : "K_ITTHNS"); - case KITEM_HYUDORO: - return (tiny ? "K_ISHYUD" : "K_ITHYUD"); - case KITEM_POGOSPRING: - return (tiny ? "K_ISPOGO" : "K_ITPOGO"); - case KITEM_KITCHENSINK: - return (tiny ? "K_ISSINK" : "K_ITSINK"); - case KRITEM_TRIPLEORBINAUT: - return (tiny ? "K_ISORBN" : "K_ITORB3"); - case KRITEM_QUADORBINAUT: - return (tiny ? "K_ISORBN" : "K_ITORB4"); - default: - return (tiny ? "K_ISSAD" : "K_ITSAD"); - } -} - -//} - -INT32 ITEM_X, ITEM_Y; // Item Window -INT32 TIME_X, TIME_Y; // Time Sticker -INT32 LAPS_X, LAPS_Y; // Lap Sticker -INT32 SPDM_X, SPDM_Y; // Speedometer -INT32 POSI_X, POSI_Y; // Position Number -INT32 FACE_X, FACE_Y; // Top-four Faces -INT32 STCD_X, STCD_Y; // Starting countdown -INT32 CHEK_Y; // CHECK graphic -INT32 MINI_X, MINI_Y; // Minimap -INT32 WANT_X, WANT_Y; // Battle WANTED poster - -// This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN. -INT32 ITEM2_X, ITEM2_Y; -INT32 LAPS2_X, LAPS2_Y; -INT32 POSI2_X, POSI2_Y; - - -static void K_initKartHUD(void) -{ - /* - BASEVIDWIDTH = 320 - BASEVIDHEIGHT = 200 - - Item window graphic is 41 x 33 - - Time Sticker graphic is 116 x 11 - Time Font is a solid block of (8 x [12) x 14], equal to 96 x 14 - Therefore, timestamp is 116 x 14 altogether - - Lap Sticker is 80 x 11 - Lap flag is 22 x 20 - Lap Font is a solid block of (3 x [12) x 14], equal to 36 x 14 - Therefore, lapstamp is 80 x 20 altogether - - Position numbers are 43 x 53 - - Faces are 32 x 32 - Faces draw downscaled at 16 x 16 - Therefore, the allocated space for them is 16 x 67 altogether - - ---- - - ORIGINAL CZ64 SPLITSCREEN: - - Item window: - if (!splitscreen) { ICONX = 139; ICONY = 20; } - else { ICONX = BASEVIDWIDTH-315; ICONY = 60; } - - Time: 236, STRINGY( 12) - Lap: BASEVIDWIDTH-304, STRINGY(BASEVIDHEIGHT-189) - - */ - - // Single Screen (defaults) - // Item Window - ITEM_X = 5 + cv_item_xoffset.value; // 5 - ITEM_Y = 5 + cv_item_yoffset.value; // 5 - // Level Timer - TIME_X = BASEVIDWIDTH - 148 + cv_time_xoffset.value; // 172 - TIME_Y = 9 + cv_time_yoffset.value; // 9 - // Level Laps - LAPS_X = 9 + cv_laps_xoffset.value; // 9 - LAPS_Y = BASEVIDHEIGHT - 29 + cv_laps_yoffset.value; // 171 - // Speedometer - SPDM_X = 9 + cv_speed_xoffset.value; // 9 - SPDM_Y = BASEVIDHEIGHT - 45 + cv_speed_yoffset.value; // 155 - // Position Number - POSI_X = BASEVIDWIDTH - 9 + cv_posi_xoffset.value; // 268 - POSI_Y = BASEVIDHEIGHT - 9 + cv_posi_yoffset.value; // 138 - // Top-Four Faces - FACE_X = 9 + cv_face_xoffset.value; // 9 - FACE_Y = 92 + cv_face_yoffset.value; // 92 - // Starting countdown - STCD_X = BASEVIDWIDTH/2 + cv_stcd_xoffset.value; // 9 - STCD_Y = BASEVIDHEIGHT/2 + cv_stcd_yoffset.value; // 92 - // CHECK graphic - CHEK_Y = BASEVIDHEIGHT + cv_chek_yoffset.value; // 200 - // Minimap - MINI_X = BASEVIDWIDTH - 50 + cv_mini_xoffset.value; // 270 - MINI_Y = (BASEVIDHEIGHT/2)-16 + cv_mini_yoffset.value; // 84 - // Battle WANTED poster - WANT_X = BASEVIDWIDTH - 55 + cv_want_xoffset.value; // 270 - WANT_Y = BASEVIDHEIGHT- 71 + cv_want_yoffset.value; // 176 - - if (splitscreen) // Splitscreen - { - ITEM_X = 5; - ITEM_Y = 3; - - LAPS_Y = (BASEVIDHEIGHT/2)-24; - - POSI_Y = (BASEVIDHEIGHT/2)- 2; - - STCD_Y = BASEVIDHEIGHT/4; - - MINI_Y = (BASEVIDHEIGHT/2); - - if (splitscreen > 1) // 3P/4P Small Splitscreen - { - // 1P (top left) - ITEM_X = -9; - ITEM_Y = -8; - - LAPS_X = 3; - LAPS_Y = (BASEVIDHEIGHT/2)-13; - - POSI_X = 24; - POSI_Y = (BASEVIDHEIGHT/2)- 16; - - // 2P (top right) - ITEM2_X = BASEVIDWIDTH-39; - ITEM2_Y = -8; - - LAPS2_X = BASEVIDWIDTH-3; - LAPS2_Y = (BASEVIDHEIGHT/2)-13; - - POSI2_X = BASEVIDWIDTH -4; - POSI2_Y = (BASEVIDHEIGHT/2)- 16; - - // Reminder that 3P and 4P are just 1P and 2P splitscreen'd to the bottom. - - STCD_X = BASEVIDWIDTH/4; - - MINI_X = (3*BASEVIDWIDTH/4); - MINI_Y = (3*BASEVIDHEIGHT/4); - - if (splitscreen > 2) // 4P-only - { - MINI_X = (BASEVIDWIDTH/2); - MINI_Y = (BASEVIDHEIGHT/2); - } - } - } - - if (timeinmap > 113 || forceshowhud) - hudtrans = cv_translucenthud.value; - else if (timeinmap > 105) - hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105); - else - hudtrans = 0; - - // K_GetScreenCoords needs the right view* variables - R_SetViewContext(stplyrnum); - R_InterpolateView(rendertimefrac_unpaused, !cv_uncappedhud.value); -} - -INT32 K_calcSplitFlags(INT32 snapflags) -{ - INT32 splitflags = 0; - - if (splitscreen == 0) - return snapflags; - - if (stplyrnum != 0) - { - if (splitscreen == 1 && stplyrnum == 1) - { - splitflags |= V_SPLITSCREEN; - } - else if (splitscreen > 1) - { - if (stplyrnum == 2 || (splitscreen == 3 && stplyrnum == 3)) - splitflags |= V_SPLITSCREEN; - if (stplyrnum == 1 || (splitscreen == 3 && stplyrnum == 3)) - splitflags |= V_HORZSCREEN; - } - } - - if (splitflags & V_SPLITSCREEN) - snapflags &= ~V_SNAPTOTOP; - else - snapflags &= ~V_SNAPTOBOTTOM; - - if (splitscreen > 1) - { - if (splitflags & V_HORZSCREEN) - snapflags &= ~V_SNAPTOLEFT; - else - snapflags &= ~V_SNAPTORIGHT; - } - - return (splitflags|snapflags); -} - -void K_getItemBoxDrawinfo(drawinfo_t *out) -{ - INT32 fx, fy, fflags; - - // pain and suffering defined below - if (splitscreen < 2) // don't change shit for THIS splitscreen. - { - fx = ITEM_X; - fy = ITEM_Y; - fflags = K_calcSplitFlags(V_SNAPTOTOP|V_SNAPTOLEFT); - } - else // now we're having a fun game. - { - if (!(stplyrnum & 1)) // If we are P1 or P3... - { - fx = ITEM_X; - fy = ITEM_Y; - fflags = V_SNAPTOLEFT|(stplyrnum & 2 ? V_SPLITSCREEN : V_SNAPTOTOP); // flip P3 to the bottom. - } - else // else, that means we're P2 or P4. - { - fx = ITEM2_X; - fy = ITEM2_Y; - fflags = V_SNAPTORIGHT|(stplyrnum & 2 ? V_SPLITSCREEN : V_SNAPTOTOP); // flip P4 to the bottom - } - } - - out->x = fx; - out->y = fy; - out->flags = fflags; -} - -void K_getLapsDrawinfo(drawinfo_t *out) -{ - INT32 fx, fy, fflags; - - // pain and suffering defined below - if (splitscreen < 2) // don't change shit for THIS splitscreen. - { - fx = LAPS_X; - fy = LAPS_Y; - fflags = K_calcSplitFlags(V_SNAPTOBOTTOM|V_SNAPTOLEFT); - } - else - { - if (!(stplyrnum & 1)) // If we are P1 or P3... - { - fx = LAPS_X; - fy = LAPS_Y; - fflags = V_SNAPTOLEFT|(stplyrnum & 2 ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. - } - else // else, that means we're P2 or P4. - { - fx = LAPS2_X; - fy = LAPS2_Y; - fflags = V_SNAPTORIGHT|(stplyrnum & 2 ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom - } - } - - out->x = fx; - out->y = fy; - out->flags = fflags; -} - -void K_getMinimapDrawinfo(drawinfo_t *out) -{ - INT32 fx = MINI_X, fy = MINI_Y, fflags = (splitscreen == 3 ? 0 : V_SNAPTORIGHT); // flags should only be 0 when it's centered (4p split) - - out->x = fx; - out->y = fy; - out->flags = fflags; -} - -INT32 K_getMinimapTrans(void) -{ - INT32 minimaptrans = cv_kartminimap.value; - - if (!minimaptrans) - return -1; - - if (forceshowhud) - return (10-minimaptrans)<kartstuff[k_bumper] ? -5 : -8) : 0); - - // Customizations c: - if (!splitscreen) - { - x += 18 + cv_stat_xoffset.value + spdxoffset; - y += cv_stat_yoffset.value + spdoffset; - } - else if (splitscreen == 1) // I tried my best, but this is still mess :/ < :Blobcatpats: c: - { - x -= 10; - y -= 40; - y += spdoffset; - - // If we are in 2-player splitscreen, for player 1 we move hud to up and remove snapping - // to bottom - if (splitnum == 0) - { - y /= 2; - flags = V_SNAPTOLEFT; - } - else - { - // Can move it down a bit - y += 45; - } - } - else - { - if (splitnum == 0 || splitnum == 2) // If we are P1 or P3... - { - // ye i just align it to position number lol - x = POSI_X + 19; - y = POSI_Y - 6; - flags = V_SNAPTOLEFT|((splitnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. - } - else // else, that means we're P2 or P4. - { - x = POSI2_X - 75; - y = POSI2_Y - 6; - flags = V_SNAPTORIGHT|((splitnum == 3) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom - } - } - - flags |= V_HUDTRANS; - - skin_t *fakeskin; - fakeskin = K_GetPlayerSkin(stplyr); - - if (!splitscreen) - { - // Skin name - if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel - { - V_DrawSmallString(x+20, y+12, flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor), fakeskin->realname); - } - else - { - V_DrawThinString(x+20, y+7, flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor), fakeskin->realname); - } - - // Icon and stats - if (K_UseHighResPortraits()) - V_DrawSmallMappedPatch(x, y, flags, R_GetSkinFaceWant(stplyr), R_GetLocalTranslationColormap(fakeskin, fakeskin, stplyr->skincolor, GTC_CACHE, stplyr->skinlocal)); - else - V_DrawMappedPatch(x, y, flags, R_GetSkinFaceRank(stplyr), R_GetLocalTranslationColormap(fakeskin, fakeskin, stplyr->skincolor, GTC_CACHE, stplyr->skinlocal)); - - V_DrawMappedPatch(x-3, y-2, flags, kp_facenum[min(9, max(1, stplyr->kartspeed))], R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_BLUEBERRY, GTC_CACHE)); - V_DrawMappedPatch(x+10, y+10, flags, kp_facenum[min(9, max(1, stplyr->kartweight))], R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_BURGUNDY, GTC_CACHE)); - } - else - { - // In splitscreen, just draw a string with stats - V_DrawString(x, y+10, flags, va("\x84%dS \x87%dW", stplyr->kartspeed, stplyr->kartweight)); - } -} - -static void K_drawKartItem(void) -{ - // ITEM_X = BASEVIDWIDTH-50; // 270 - // ITEM_Y = 24; // 24 - - // Why write V_DrawScaledPatch calls over and over when they're all the same? - // Set to 'no item' just in case. - const UINT8 offset = ((splitscreen > 1) ? 1 : 0); - patch_t *localpatch = kp_nodraw; - patch_t *localbg; - boolean dark = false; - - patch_t *localinv = ((offset) ? kp_invincibility[((leveltime % (6*3)) / 3) + 7] : kp_invincibility[(leveltime % (7*3)) / 3]); - INT32 fx = 0, fy = 0, fflags = 0; // final coords for hud and flags... - INT32 numberdisplaymin = cv_huditemamount.value == 2 ? 1 : 2; // No longer a constant so other things can modify this value - INT32 itembar = 0; - INT32 maxl = 0; // itembar's normal highest value - const INT32 barlength = (splitscreen > 1 ? 12 : 26); - UINT8 localcolor = SKINCOLOR_NONE; - SINT8 colormode = TC_RAINBOW; - UINT8 *colmap = NULL; - UINT8 *colormap = NULL; - - if (stplyr->kartstuff[k_itemroulette]) - { - localcolor = K_GetHudColor(); - - switch((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3) - { - // Each case is handled in threes, to give three frames of in-game time to see the item on the roulette - case 0: // Sneaker - localpatch = kp_sneaker[offset]; - //localcolor = SKINCOLOR_RASPBERRY; - break; - case 1: // Banana - localpatch = kp_banana[offset]; - //localcolor = SKINCOLOR_YELLOW; - break; - case 2: // Orbinaut - localpatch = kp_orbinaut[3+offset]; - //localcolor = SKINCOLOR_STEEL; - break; - case 3: // Mine - localpatch = kp_mine[offset]; - //localcolor = SKINCOLOR_JET; - break; - case 4: // Grow - localpatch = kp_grow[offset]; - //localcolor = SKINCOLOR_TEAL; - break; - case 5: // Hyudoro - localpatch = kp_hyudoro[offset]; - //localcolor = SKINCOLOR_STEEL; - break; - case 6: // Rocket Sneaker - localpatch = kp_rocketsneaker[offset]; - //localcolor = SKINCOLOR_TANGERINE; - break; - case 7: // Jawz - localpatch = kp_jawz[offset]; - //localcolor = SKINCOLOR_JAWZ; - break; - case 8: // Self-Propelled Bomb - localpatch = kp_selfpropelledbomb[offset]; - //localcolor = SKINCOLOR_JET; - break; - case 9: // Shrink - localpatch = kp_shrink[offset]; - //localcolor = SKINCOLOR_ORANGE; - break; - case 10: // Invincibility - localpatch = localinv; - //localcolor = SKINCOLOR_GREY; - break; - case 11: // Eggman Monitor - localpatch = kp_eggman[offset]; - //localcolor = SKINCOLOR_ROSE; - break; - case 12: // Ballhog - localpatch = kp_ballhog[offset]; - //localcolor = SKINCOLOR_LILAC; - break; - case 13: // Thunder Shield - localpatch = kp_thundershield[offset]; - //localcolor = SKINCOLOR_CYAN; - break; - /*case 14: // Pogo Spring - localpatch = kp_pogospring[offset]; - localcolor = SKINCOLOR_TANGERINE; - break; - case 15: // Kitchen Sink - localpatch = kp_kitchensink[offset]; - localcolor = SKINCOLOR_STEEL; - break;*/ - default: - break; - } - } - else - { - // I'm doing this a little weird and drawing mostly in reverse order - // The only actual reason is to make sneakers line up this way in the code below - // This shouldn't have any actual baring over how it functions - // Hyudoro is first, because we're drawing it on top of the player's current item - if (stplyr->kartstuff[k_stolentimer] > 0) - { - if (leveltime & 2) - localpatch = kp_hyudoro[offset]; - else - localpatch = kp_nodraw; - } - else if ((stplyr->kartstuff[k_stealingtimer] > 0) && (leveltime & 2)) - { - localpatch = kp_hyudoro[offset]; - } - else if (stplyr->kartstuff[k_eggmanexplode] > 1) - { - if (leveltime & 1) - localpatch = kp_eggman[offset]; - else - localpatch = kp_nodraw; - } - else if (stplyr->kartstuff[k_rocketsneakertimer] > 1) - { - itembar = stplyr->kartstuff[k_rocketsneakertimer]; - maxl = (itemtime*3) - barlength; - - if (leveltime & 1) - localpatch = kp_rocketsneaker[offset]; - else - localpatch = kp_nodraw; - } - else if (stplyr->kartstuff[k_growshrinktimer] > 0) - { - if (stplyr->kartstuff[k_growcancel] > 0) - { - itembar = stplyr->kartstuff[k_growcancel]; - maxl = 26; - } - - if (leveltime & 1) - localpatch = kp_grow[offset]; - else - localpatch = kp_nodraw; - } - else if (stplyr->kartstuff[k_sadtimer] > 0) - { - if (leveltime & 2) - localpatch = kp_sadface[offset]; - else - localpatch = kp_nodraw; - } - else - { - if (stplyr->kartstuff[k_itemamount] <= 0) - return; - - const boolean usemultiicon = (multiitem_icon && cv_multiitemicon.value && !offset); - - switch (stplyr->kartstuff[k_itemtype]) - { - case KITEM_SNEAKER: - if (usemultiicon) - { - if (!cv_huditemamount.value) - numberdisplaymin = 4; - switch(stplyr->kartstuff[k_itemamount]) - { - case 1: - localpatch = kp_sneaker[offset]; - break; - case 2: - localpatch = kp_multsneaker[0]; - break; - default: - localpatch = kp_multsneaker[1]; - break; - } - } - else - { - localpatch = kp_sneaker[offset]; - } - break; - case KITEM_ROCKETSNEAKER: - localpatch = kp_rocketsneaker[offset]; - break; - case KITEM_INVINCIBILITY: - localpatch = localinv; - dark = true; - break; - case KITEM_BANANA: - if (usemultiicon) - { - if (!cv_huditemamount.value) - numberdisplaymin = 4; - switch(stplyr->kartstuff[k_itemamount]) - { - case 1: - localpatch = kp_banana[offset]; - break; - case 2: - localpatch = kp_multbanana[0]; - break; - case 3: - localpatch = kp_multbanana[1]; - break; - default: - localpatch = kp_multbanana[2]; - break; - } - } - else - { - localpatch = kp_banana[offset]; - } - break; - case KITEM_EGGMAN: - localpatch = kp_eggman[offset]; - break; - case KITEM_ORBINAUT: - if (!cv_huditemamount.value) - numberdisplaymin = offset ? 2 : 5; - localpatch = kp_orbinaut[(offset ? 4 : min(stplyr->kartstuff[k_itemamount]-1, 3))]; - break; - case KITEM_JAWZ: - if (usemultiicon) - { - if (!cv_huditemamount.value) - numberdisplaymin = 3; - localpatch = ((stplyr->kartstuff[k_itemamount] == 1) ? kp_jawz[offset] : kp_multjawz); - } - else - { - localpatch = kp_jawz[offset]; - } - break; - case KITEM_MINE: - localpatch = kp_mine[offset]; - break; - case KITEM_BALLHOG: - localpatch = kp_ballhog[offset]; - break; - case KITEM_SPB: - localpatch = kp_selfpropelledbomb[offset]; - dark = true; - break; - case KITEM_GROW: - localpatch = kp_grow[offset]; - break; - case KITEM_SHRINK: - localpatch = kp_shrink[offset]; - break; - case KITEM_THUNDERSHIELD: - localpatch = kp_thundershield[offset]; - dark = true; - break; - case KITEM_HYUDORO: - localpatch = kp_hyudoro[offset]; - break; - case KITEM_POGOSPRING: - localpatch = kp_pogospring[offset]; - break; - case KITEM_KITCHENSINK: - localpatch = kp_kitchensink[offset]; - break; - case KITEM_SAD: - localpatch = kp_sadface[offset]; - break; - default: - return; - } - - if (stplyr->kartstuff[k_itemheld] && !(leveltime & 1)) - localpatch = kp_nodraw; - } - - if (stplyr->kartstuff[k_itemblink] && (leveltime & 1)) - { - colormode = TC_BLINK; - - switch (stplyr->kartstuff[k_itemblinkmode]) - { - case 2: - localcolor = (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1))); - break; - case 1: - localcolor = SKINCOLOR_RED; - break; - default: - localcolor = SKINCOLOR_WHITE; - break; - } - } - } - - localbg = K_getItemBoxPatch((boolean)offset, dark); - drawinfo_t info; - K_getItemBoxDrawinfo(&info); - fx = info.x; - fy = info.y; - fflags = info.flags; - - boolean flipamount = splitscreen > 1 && stplyrnum & 1; // Used for 3P/4P splitscreen to flip item amount stuff - - if (K_UseColorHud()) - colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - - V_DrawMappedPatch(fx, fy, V_HUDTRANS|fflags, localbg, cv_colorizeditembox.value ? colormap : NULL); - - fixed_t rfy = fy<kartstuff[k_itemroulette] && !stplyr->deadtimer) - { - fixed_t frac = R_GetHudUncap(); - UINT8 fancystep = (offset ? 6 : 10); - fixed_t fancyoffset = (stplyr->kartstuff[k_itemroulette] % 3)-1; - - if (fancyoffset != 0) - { - fancyflags &= ~V_HUDTRANS; - fancyflags |=V_HUDTRANSHALF; - } - - rfy += (fancystep * fancyoffset * FRACUNIT) + FixedMul(fancystep*FRACUNIT, frac) - fancystep/2*FRACUNIT; - } - - if (localcolor != SKINCOLOR_NONE) - colmap = R_GetTranslationColormap(colormode, localcolor, GTC_CACHE); - - // Then, the numbers: - if (stplyr->kartstuff[k_itemamount] >= numberdisplaymin && !stplyr->kartstuff[k_itemroulette]) - { - localbg = K_getItemMulPatch((boolean)offset); - - V_DrawMappedPatch(fx + (flipamount ? 48 : 0), fy, V_HUDTRANS|fflags|(flipamount ? V_FLIP : 0), localbg, colormap); // flip this graphic for p2 and p4 in split and shift it. - V_DrawFixedPatch(fx<kartstuff[k_itemamount])); - } - else - { - V_DrawScaledPatch(fx+28, fy+41, V_HUDTRANS|fflags, kp_itemx); - V_DrawKartString(fx+38, fy+36, V_HUDTRANS|fflags, va("%d", stplyr->kartstuff[k_itemamount])); - } - } - else - V_DrawFixedPatch(fx< 2) - { - V_DrawFill(fx+x+length, fy+y+1, 1, height, 12|fflags); // the right one - if (height == 2) - V_DrawFill(fx+x+2, fy+y+2, length-2, 1, 8|fflags); // the dulled underside - V_DrawFill(fx+x+2, fy+y+1, length-2, 1, 120|fflags); // the shine - } - } - - // Quick Eggman numbers - if (stplyr->kartstuff[k_eggmanexplode] > 1 /*&& stplyr->kartstuff[k_eggmanexplode] <= 3*TICRATE*/) - V_DrawScaledPatch(fx+17, fy+13-offset, V_HUDTRANS|fflags, kp_eggnum[min(3, G_TicsToSeconds(stplyr->kartstuff[k_eggmanexplode]))]); -} - -void K_drawKartTimestamp(tic_t drawtime, INT32 TX, INT32 TY, INT16 emblemmap, UINT8 mode) -{ - // TIME_X = BASEVIDWIDTH-124; // 196 - // TIME_Y = 6; // 6 - - INT32 splitflags = 0; - - if (!mode) - { - splitflags = V_HUDTRANS|K_calcSplitFlags(V_SNAPTOTOP|V_SNAPTORIGHT); - if (cv_timelimit.value && timelimitintics > 0) - { - if (drawtime >= timelimitintics) - drawtime = 0; - else - drawtime = timelimitintics - drawtime; - } - } - - if (K_UseColorHud()) // Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - V_DrawMappedPatch(TX, TY, splitflags, ((mode == 2) ? kp_lapstickerwideclr : kp_timestickerwideclr), colormap); - } - else - V_DrawScaledPatch(TX, TY, splitflags, ((mode == 2) ? kp_lapstickerwide : kp_timestickerwide)); - - TX += 33; - - if (drawtime == UINT32_MAX) - ; - else if (mode && !drawtime) - { - V_DrawKartString(TX, TY+3, splitflags, va("--'--\"--")); - } - else - { - tic_t worktime = drawtime/(60*TICRATE); - - if (cv_timelimit.value && cv_overtime.value && G_BattleGametype() && !players[consoleplayer].exiting && (leveltime > (timelimitintics + starttime + TICRATE/2))) // i hate this so much - { - V_DrawKartString(TX, TY+3, splitflags, va("OVERTIME")); - } - else if (worktime < 100) - { - // minutes time 00 __ __ - V_DrawKartString(TX, TY+3, splitflags, va("%d", worktime/10)); - V_DrawKartString(TX+12, TY+3, splitflags, va("%d", worktime%10)); - - // apostrophe location _'__ __ - V_DrawKartString(TX+24, TY+3, splitflags, va("'")); - - worktime = (drawtime/TICRATE % 60); - - // seconds time _ 00 __ - V_DrawKartString(TX+36, TY+3, splitflags, va("%d", worktime/10)); - V_DrawKartString(TX+48, TY+3, splitflags, va("%d", worktime%10)); - - // quotation mark location _ __"__ - V_DrawKartString(TX+60, TY+3, splitflags, va("\"")); - - worktime = G_TicsToCentiseconds(drawtime); - - // tics _ __ 00 - V_DrawKartString(TX+72, TY+3, splitflags, va("%d", worktime/10)); - V_DrawKartString(TX+84, TY+3, splitflags, va("%d", worktime%10)); - } - else if ((drawtime/TICRATE) & 1) - V_DrawKartString(TX, TY+3, splitflags, va("99'59\"99")); - } - - if (emblemmap && (modeattacking || (mode == 1)) && !demo.playback) // emblem time! - { - INT32 workx = TX + 96, worky = TY+18; - SINT8 curemb = 0; - patch_t *emblempic[3] = {NULL, NULL, NULL}; - UINT8 *emblemcol[3] = {NULL, NULL, NULL}; - - emblem_t *emblem = M_GetLevelEmblems(emblemmap); - while (emblem) - { - char targettext[9]; - - switch (emblem->type) - { - case ET_TIME: - { - static boolean canplaysound = true; - tic_t timetoreach = emblem->var; - - if (emblem->collected) - { - emblempic[curemb] = W_CachePatchName(M_GetEmblemPatch(emblem), PU_PATCH); - emblemcol[curemb] = R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE); - if (++curemb == 3) - break; - goto bademblem; - } - - snprintf(targettext, 9, "%i'%02i\"%02i", - G_TicsToMinutes(timetoreach, false), - G_TicsToSeconds(timetoreach), - G_TicsToCentiseconds(timetoreach)); - - if (!mode) - { - if (stplyr->realtime > timetoreach) - { - splitflags = (splitflags &~ V_HUDTRANS)|V_HUDTRANSHALF; - if (canplaysound) - { - S_StartSound(NULL, sfx_s3k72); //sfx_s26d); -- you STOLE fizzy lifting drinks - canplaysound = false; - } - } - else if (!canplaysound) - canplaysound = true; - } - - targettext[8] = 0; - } - break; - default: - goto bademblem; - } - - V_DrawRightAlignedString(workx, worky, splitflags, targettext); - workx -= 67; - V_DrawSmallScaledPatch(workx + 4, worky, splitflags, W_CachePatchName("NEEDIT", PU_PATCH)); - - break; - - bademblem: - emblem = M_GetLevelEmblems(-1); - } - - if (!mode) - splitflags = (splitflags &~ V_HUDTRANSHALF)|V_HUDTRANS; - - while (curemb--) - { - workx -= 12; - V_DrawSmallMappedPatch(workx + 4, worky, splitflags, emblempic[curemb], emblemcol[curemb]); - } - } -} - -static void K_DrawKartPositionNum(INT32 num) -{ - // POSI_X = BASEVIDWIDTH - 51; // 269 - // POSI_Y = BASEVIDHEIGHT- 64; // 136 - - const boolean wheeloffs = (cv_showinput.value && cv_posi_xoffset.value == 0 && cv_posi_yoffset.value == 0 && cv_wheel_xoffset.value == 0 && cv_wheel_yoffset.value == 0); - const boolean win = (stplyr->exiting && num == 1); - INT32 W = kp_positionnum[0][0]->width; - fixed_t scale = FRACUNIT; - patch_t *localpatch = kp_positionnum[0][0]; - INT32 addOrSub = B_SUBTRACT; - INT32 fx = 0, fy = 0, fflags = 0; - const INT32 xoffs = wheeloffs ? -48 : 0; - boolean flipdraw = false; // flip the order we draw it in for MORE splitscreen bs. fun. - boolean flipvdraw = false; // used only for 2p splitscreen so overtaking doesn't make 1P's position fly off the screen. - boolean overtake = false; - - if ((mapheaderinfo[gamemap - 1]->levelflags & LF_SUBTRACTNUM) == LF_SUBTRACTNUM) - { - addOrSub = B_ADD; - } - - if ((cv_posanim.value && stplyr->kartstuff[k_positiondelay]) || stplyr->exiting) - { - scale *= 2; - overtake = true; // this is used for splitscreen stuff in conjunction with flipdraw. - } - - if (splitscreen || cv_smallposnum.value || wheeloffs) - { - scale /= 2; - } - - W = FixedMul(W<>FRACBITS; - - // pain and suffering defined below - if (!splitscreen) - { - fx = POSI_X + xoffs; - fy = BASEVIDHEIGHT - 8 + cv_posi_yoffset.value; - fflags = V_SNAPTOBOTTOM|V_SNAPTORIGHT; - } - else if (splitscreen == 1) // for this splitscreen, we'll use case by case because it's a bit different. - { - fx = POSI_X; - if (stplyrnum == 0) // for player 1: display this at the top right, above the minimap. - { - fy = 30 + cv_posi_yoffset.value; - fflags = V_SNAPTOTOP|V_SNAPTORIGHT; - if (overtake) - flipvdraw = true; // make sure overtaking doesn't explode us - } - else // if we're not p1, that means we're p2. display this at the bottom right, below the minimap. - { - fy = BASEVIDHEIGHT - 8 + cv_posi_yoffset.value; - fflags = V_SNAPTOBOTTOM|V_SNAPTORIGHT; - } - } - else - { - if (!(stplyrnum & 1)) // If we are P1 or P3... - { - fx = POSI_X; - fy = POSI_Y; - fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. - flipdraw = true; - if (num && num >= 10) - fx += W; // this seems dumb, but we need to do this in order for positions above 10 going off screen. - } - else // else, that means we're P2 or P4. - { - fx = POSI2_X; - fy = POSI2_Y; - fflags = V_SNAPTORIGHT|((stplyrnum == 3) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom - } - } - - // Special case for 0 - if (num <= 0) - { - V_DrawBlendingFixedPatch(fx<laps+1 >= cv_numlaps.value || stplyr->exiting) // Check for the final lap, or won - { - boolean useRedNums = K_IsPlayerLosing(stplyr); - - if (addOrSub == B_SUBTRACT) - { - // Subtracting RED will look BLUE, and vice versa. - useRedNums = !useRedNums; - } - - // Alternate frame every three frames - switch ((leveltime % 9) / 3) - { - case 0: - if (useRedNums == true) - localpatch = kp_positionnum[num % 10][4]; - else - localpatch = kp_positionnum[num % 10][1]; - break; - case 1: - if (useRedNums == true) - localpatch = kp_positionnum[num % 10][5]; - else - localpatch = kp_positionnum[num % 10][2]; - break; - case 2: - if (useRedNums == true) - localpatch = kp_positionnum[num % 10][6]; - else - localpatch = kp_positionnum[num % 10][3]; - break; - default: - localpatch = kp_positionnum[num % 10][0]; - break; - } - } - else - { - localpatch = kp_positionnum[num % 10][0]; - } - - V_DrawBlendingFixedPatch((fx<width*scale/2) : 0), (fy<height*scale/2) : 0), scale, V_HUDTRANSHALF|fflags, localpatch, NULL, addOrSub); - // ^ if we overtake as p1 or p3 in splitscren, we shift it so that it doesn't go off screen. - // ^ if we overtake as p1 in 2p splits, shift vertically so that this doesn't happen either. - - fx -= W; - num /= 10; - } -} - -static boolean K_drawKartPositionFaces(void) -{ - // FACE_X = 15; // 15 - // FACE_Y = 72; // 72 - - INT32 Y = FACE_Y+9; // +9 to offset where it's being drawn if there are more than one - INT32 i, j, ranklines, strank = -1; - boolean completed[MAXPLAYERS]; - INT32 rankplayer[MAXPLAYERS]; - INT32 bumperx, numplayersingame = 0; - UINT8 *colormap; - - ranklines = 0; - memset(completed, 0, sizeof (completed)); - memset(rankplayer, 0, sizeof (rankplayer)); - - for (i = 0; i < MAXPLAYERS; i++) - { - rankplayer[i] = -1; - - if (!playeringame[i] || players[i].spectator || !players[i].mo) - continue; - - numplayersingame++; - } - - if (numplayersingame <= 1) - return true; - - if (!LUA_HudEnabled(hud_minirankings)) - return false; // Don't proceed but still return true for free play above if HUD is disabled. - - for (j = 0; j < numplayersingame; j++) - { - UINT8 lowestposition = MAXPLAYERS+1; - for (i = 0; i < MAXPLAYERS; i++) - { - if (completed[i] || !playeringame[i] || players[i].spectator || !players[i].mo) - continue; - - if (players[i].kartstuff[k_position] >= lowestposition) - continue; - - rankplayer[ranklines] = i; - lowestposition = players[i].kartstuff[k_position]; - } - - i = rankplayer[ranklines]; - - completed[i] = true; - - if (players+i == stplyr) - strank = ranklines; - - ranklines++; - } - - if (ranklines < 5) - Y -= (9*ranklines); - else - Y -= (9*5); - - if (G_BattleGametype() || strank <= 2) // too close to the top, or playing battle, or a spectator? would have had (strank == -1) called out, but already caught by (strank <= 2) - { - i = 0; - if (ranklines > 5) // could be both... - ranklines = 5; - } - else if (strank+3 > ranklines) // too close to the bottom? - { - i = ranklines - 5; - if (i < 0) - i = 0; - } - else - { - i = strank-2; - ranklines = strank+3; - } - - for (; i < ranklines; i++) - { - player_t *player; - player = &players[rankplayer[i]]; - - if (!playeringame[rankplayer[i]]) - continue; - if (player->spectator) - continue; - if (!player->mo) - continue; - - const UINT8 mocolor = player->mo->color; - - bumperx = FACE_X+19; - - if (mocolor) - { - colormap = R_GetTranslationColormap(player->skin, mocolor, GTC_CACHE); - if (player->mo->colorized) - colormap = R_GetTranslationColormap(TC_RAINBOW, mocolor, GTC_CACHE); - - if (K_UseHighResPortraits()) - V_DrawSmallMappedPatch(FACE_X, Y, V_HUDTRANS|V_SNAPTOLEFT, R_GetSkinFaceWant(player), colormap); - else - V_DrawMappedPatch(FACE_X, Y, V_HUDTRANS|V_SNAPTOLEFT, R_GetSkinFaceRank(player), colormap); - - if (LUA_HudEnabled(hud_battlebumpers)) - { - if (G_BattleGametype() && player->kartstuff[k_bumper] > 0) - { - V_DrawMappedPatch(bumperx-2, Y, V_HUDTRANS|V_SNAPTOLEFT, kp_tinybumper[0], colormap); - for (j = 1; j < player->kartstuff[k_bumper]; j++) - { - bumperx += 5; - V_DrawMappedPatch(bumperx, Y, V_HUDTRANS|V_SNAPTOLEFT, kp_tinybumper[1], colormap); - } - } - } // A new level of stupidity: checking if lua is enabled to close a bracket. :Fascinating: - } - - if (i == strank) - V_DrawScaledPatch(FACE_X, Y, V_HUDTRANS|V_SNAPTOLEFT, kp_facehighlight[(leveltime / 4) % 8]); - - if (G_BattleGametype() && player->kartstuff[k_bumper] <= 0) - V_DrawScaledPatch(FACE_X-4, Y-3, V_HUDTRANS|V_SNAPTOLEFT, kp_ranknobumpers); - else - { - INT32 pos = player->kartstuff[k_position]; - if (pos < 0 || pos > MAXPLAYERS) - pos = 0; - // Draws the little number over the face - V_DrawScaledPatch(FACE_X-5, Y+10, V_HUDTRANS|V_SNAPTOLEFT, kp_facenum[pos]); - } - - Y += 18; - } - - return false; -} - -// -// HU_DrawTabRankings -- moved here to take advantage of kart stuff! -// -void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 hilicol) -{ - INT32 i, rightoffset = 240; - const UINT8 *colormap; - const INT32 dupadjust = cv_betainterscreen.value ? 314 : (vid.width/vid.dupx), duptweak = cv_betainterscreen.value ? -3 : (dupadjust - BASEVIDWIDTH)/2; - - boolean (*_isHighlightedPlayer)(const player_t *) = (demo.playback ? P_IsDisplayPlayer : P_IsLocalPlayer); - - //this function is designed for 9 or less score lines only - //I_Assert(scorelines <= 9); -- not today bitch, kart fixed it up - - V_DrawFill(1-duptweak, 26, dupadjust-2, 1, 0); // Draw a horizontal line because it looks nice! - if (scorelines > 8) - { - V_DrawFill(160, 26, 1, 147, 0); // Draw a vertical line to separate the two sides. - V_DrawFill(1-duptweak, 173, dupadjust-2, 1, 0); // And a horizontal line near the bottom. - rightoffset = (BASEVIDWIDTH/2) - 4 - x; - } - - for (i = 0; i < scorelines; i++) - { - char strtime[MAXPLAYERNAME+1]; - const UINT8 pnum = tab[i].num; - player_t *player = &players[pnum]; - - if (player->spectator || !player->mo) - continue; //ignore them. - - const boolean whiteplayer = _isHighlightedPlayer(player); - const INT32 philicol = (whiteplayer ? V_SkinColorToHighlightcolor(player->skincolor) : 0); - - if ((netgame && pnum != serverplayer) || (cv_mindelay.value && P_IsLocalPlayer(player))) - { - HU_drawPlayerPing(x + ((i < 8) ? -17 : rightoffset + 11), y-4, pnum, 0); - } - - STRBUFCPY(strtime, tab[i].name); - - if (scorelines > 8) - V_DrawThinString(x + 20, y, philicol|V_ALLOWLOWERCASE|V_6WIDTHSPACE, strtime); - else - V_DrawString(x + 20, y, philicol|V_ALLOWLOWERCASE, strtime); - - if (player->mo->color) - { - if (player->mo->colorized) - colormap = R_GetTranslationColormap(TC_RAINBOW, player->mo->color, GTC_CACHE); - else - colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE); - - if (K_UseHighResPortraits()) - V_DrawSmallMappedPatch(x, y-4, 0, R_GetSkinFaceWant(player), colormap); - else - V_DrawMappedPatch(x, y-4, 0, R_GetSkinFaceRank(player), colormap); - - /*if (G_BattleGametype() && player->kartstuff[k_bumper] > 0) -- not enough space for this - { - INT32 bumperx = x+19; - V_DrawMappedPatch(bumperx-2, y-4, 0, kp_tinybumper[0], colormap); - for (j = 1; j < player->kartstuff[k_bumper]; j++) - { - bumperx += 5; - V_DrawMappedPatch(bumperx, y-4, 0, kp_tinybumper[1], colormap); - } - }*/ - } - - if (whiteplayer) - V_DrawScaledPatch(x, y-4, 0, kp_facehighlight[(leveltime / 4) % 8]); - - if (G_BattleGametype() && player->kartstuff[k_bumper] <= 0) - V_DrawScaledPatch(x-4, y-7, 0, kp_ranknobumpers); - else - { - INT32 pos = player->kartstuff[k_position]; - if (pos < 0 || pos > MAXPLAYERS) - pos = 0; - // Draws the little number over the face - V_DrawScaledPatch(x-5, y+6, 0, kp_facenum[pos]); - } - - if (G_RaceGametype()) - { -#define timestring(time) va("%i'%02i\"%02i", G_TicsToMinutes(time, true), G_TicsToSeconds(time), G_TicsToCentiseconds(time)) - if (scorelines > 8) - { - if (player->exiting) - V_DrawRightAlignedThinString(x+rightoffset, y-1, hilicol|V_6WIDTHSPACE, timestring(player->realtime)); - else if (player->pflags & PF_TIMEOVER) - V_DrawRightAlignedThinString(x+rightoffset, y-1, V_6WIDTHSPACE, "NO CONTEST."); - else if (circuitmap) - V_DrawRightAlignedThinString(x+rightoffset, y-1, V_6WIDTHSPACE, va("Lap %d", tab[i].count)); - } - else - { - if (player->exiting) - V_DrawRightAlignedString(x+rightoffset, y, hilicol, timestring(player->realtime)); - else if (player->pflags & PF_TIMEOVER) - V_DrawRightAlignedThinString(x+rightoffset, y-1, 0, "NO CONTEST."); - else if (circuitmap) - V_DrawRightAlignedString(x+rightoffset, y, 0, va("Lap %d", tab[i].count)); - } -#undef timestring - } - else - V_DrawRightAlignedString(x+rightoffset, y, 0, va("%u", tab[i].count)); - - y += 18; - if (i == 7) - { - y = 33; - x = (BASEVIDWIDTH/2) + 4; - } - } -} - -static boolean K_BigLap(void) -{ - return (cv_biglaps.value && (cv_numlaps.value > 9) && (K_UseColorHud() ? big_lap_color : big_lap) && (!stplyr->exiting)); -} - -static void K_drawKartLaps(void) -{ - const INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM|V_SNAPTOLEFT); - INT32 fx = 0, fy = 0, fflags = 0; // stuff for 3p / 4p splitscreen. - const boolean flipstring = splitscreen > 1 && stplyrnum & 1; // used for 3p or 4p - INT32 stringw = 0; // used with the above - const char *laps; - - drawinfo_t info; - K_getLapsDrawinfo(&info); - fx = info.x; - fy = info.y; - fflags = info.flags; - - laps = (stplyr->exiting ? "FIN" : va("%d/%d", stplyr->laps+1, cv_numlaps.value)); - - // draw stuff as god intended. - if (splitscreen > 1) - { - if (flipstring) - { - stringw = V_StringWidth(laps, 0); - - V_DrawScaledPatch(fx-stringw-13, fy, V_HUDTRANS|fflags, kp_splitlapflag); - V_DrawRightAlignedString(fx, fy+1, V_HUDTRANS|fflags, laps); - } - else // draw stuff NORMALLY. - { - V_DrawScaledPatch(fx, fy, V_HUDTRANS|fflags, kp_splitlapflag); - V_DrawString(fx+13, fy+1, V_HUDTRANS|fflags, laps); - } - } - else - { - if (K_UseColorHud()) // Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - patch_t *biglapclr = (K_BigLap() ? ((stplyr->laps + 1 > 9) ? kp_lapstickerbig2clr : kp_lapstickerbigclr) : kp_lapstickerclr); - V_DrawMappedPatch(fx, fy, V_HUDTRANS|splitflags, biglapclr, colormap); - } - else - { - patch_t *biglap = (K_BigLap() ? ((stplyr->laps + 1 > 9) ? kp_lapstickerbig2 : kp_lapstickerbig) : kp_lapsticker); - V_DrawScaledPatch(fx, fy, V_HUDTRANS|splitflags, biglap); - } - - V_DrawKartString(fx+33, fy+3, V_HUDTRANS|splitflags, laps); - } -} - -#ifdef ROTSPRITE - -#define DIALSPDDIV 97090 // 1.48148; converts 200 to 135 -#define MPHDIV 68283 // 1.04192; converts 141 to 135 - -static void K_DrawDialNum(INT32 x, INT32 y, boolean colorized, INT32 flags, INT32 num, INT32 digits, const UINT8 *colormap) -{ - INT32 w; - - if (colorized) - w = skp_dialnumclr[0]->width; - else - w = skp_dialnum[0]->width; - - if (flags & V_NOSCALESTART) - w *= vid.dupx; - - if (num < 0) - num = -num; - - // draw the number - do - { - x -= (w); - - if (colorized) - V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, flags, skp_dialnumclr[num % 10], colormap); - else - V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, flags, skp_dialnum[num % 10], colormap); - - num /= 10; - } while (--digits); -} - -static void K_DrawDialLaps(INT32 x, INT32 y, INT32 num, INT32 total, INT32 flags) -{ - INT32 fx; - fx = x + ((num < 10) ? 0 : 6); - V_DrawRankNum(fx, y, flags, num, (num < 10) ? 1 : 2, NULL); - V_DrawScaledPatch(fx + 2, y, flags, frameslash); - V_DrawRankNum(fx + 13 + ((total < 10) ? 0 : 6), y, flags, total, (total < 10) ? 1 : 2, NULL); -} - -static void K_DrawDialSpeedometer(fixed_t speed, - fixed_t divisor, - INT32 splitflags, - boolean battlemode, - boolean infoactive, - boolean colorized) -{ - const UINT8* colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - - INT32 rot = 0; - const UINT8 infoidx = (infoactive) ? 1 : 0; - patch_t* dialpatch; - - const angle_t speedangle = - FixedAngle(((min(135 * FRACUNIT, FixedDiv(speed, divisor)) - (45 * FRACUNIT)))); - - rot = R_GetRollAngle(speedangle); - - if (rot) - { - dialpatch = W_CachePatchNameRotated("K_DSDIAL", rot, PU_PATCH); - } - else - { - dialpatch = W_CachePatchName("K_DSDIAL", PU_PATCH); - } - - if (colorized) // Colourized hud - { - V_DrawMappedPatch( - SPDM_X, SPDM_Y - 9, (V_HUDTRANS | splitflags), skp_dialbaseclr[infoidx], colormap); - V_DrawMappedPatch(SPDM_X, - SPDM_Y + 30, - V_HUDTRANS | splitflags, - skp_speedpatchesdialclr[cv_kartspeedometer.value], - colormap); - } - else - { - V_DrawScaledPatch(SPDM_X, SPDM_Y - 9, (V_HUDTRANS | splitflags), skp_dialbase[infoidx]); - V_DrawScaledPatch(SPDM_X, - SPDM_Y + 30, - V_HUDTRANS | splitflags, - skp_speedpatchesdial[cv_kartspeedometer.value]); - } - - K_DrawDialNum(SPDM_X + 10, - SPDM_Y + 25, - colorized, - V_HUDTRANS | splitflags, - speed / FRACUNIT, - 3, - colormap); - - // gotta center the dial manually - V_DrawMappedPatch(SPDM_X - 19, SPDM_Y + 15, (V_HUDTRANS | splitflags), (dialpatch), colormap); - - if (!infoactive) - { - // no need to draw info if we're not supposed to - return; - } - - // draw the info - if (battlemode) - { - if (stplyr->kartstuff[k_bumper] <= 0) - { - V_DrawMappedPatch( - SPDM_X + 28, SPDM_Y + 27, V_HUDTRANS | splitflags, kp_splitkarmabomb, colormap); - K_DrawDialLaps(SPDM_X + 46, - SPDM_Y + 29, - stplyr->kartstuff[k_comebackpoints], - 2, - V_HUDTRANS | splitflags); - } - else // the above doesn't need to account for weird stuff since the max amount of karma - // necessary is always 2 ^^^^ - { - V_DrawMappedPatch( - SPDM_X + 28, SPDM_Y + 27, V_HUDTRANS | splitflags, kp_rankbumper, colormap); - K_DrawDialLaps(SPDM_X + 46, - SPDM_Y + 29, - stplyr->kartstuff[k_bumper], - cv_kartbumpers.value, - V_HUDTRANS | splitflags); - } - } - else - { - V_DrawScaledPatch(SPDM_X + 28, SPDM_Y + 27, V_HUDTRANS | splitflags, kp_splitlapflag); - - if (stplyr->exiting) - V_DrawScaledPatch(SPDM_X + 39, SPDM_Y + 29, V_HUDTRANS | splitflags, skp_rankfinish); - else - K_DrawDialLaps(SPDM_X + 46, - SPDM_Y + 29, - stplyr->laps + 1, - cv_numlaps.value, - V_HUDTRANS | splitflags); - } -} - -#endif - -static void K_drawKartSpeedometer(void) -{ - // why? - if (cv_kartspeedometer.value == 0) - return; - - // index 0 is the raw value, index 1 is the converted value - fixed_t convSpeed[2] = {0,0}; -#ifdef ROTSPRITE - fixed_t dial_divisor = DIALSPDDIV; -#endif - - INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM|V_SNAPTOLEFT); - - // man. - const UINT8 speedostyle = K_GetSpeedometerStyle(); - - switch (cv_kartspeedometer.value) - { - case 1: - convSpeed[0] = FixedDiv(FixedMul(stplyr->speed, 142371), mapobjectscale); // 2.172409058 - convSpeed[1] = convSpeed[0] / FRACUNIT; - break; - case 2: - convSpeed[0] = FixedDiv(FixedMul(stplyr->speed, 88465), mapobjectscale); // 1.349868774 - convSpeed[1] = convSpeed[0] / FRACUNIT; -#ifdef ROTSPRITE - dial_divisor = MPHDIV; -#endif - break; - case 3: - convSpeed[0] = FixedDiv(stplyr->speed, mapobjectscale); - convSpeed[1] = convSpeed[0] / FRACUNIT; -#ifdef ROTSPRITE - dial_divisor = MPHDIV; -#endif - break; - case 4: - if (stplyr->mo) - { - convSpeed[0] = (FixedDiv(stplyr->speed, FixedMul(K_GetKartSpeed(stplyr, false), ORIG_FRICTION))*100); - convSpeed[1] = convSpeed[0] >> FRACBITS; - } - break; - default: - break; - } - - if (speedostyle == SPEEDO_VANILLA) - { - const char *metric = ""; - - switch (cv_kartspeedometer.value) - { - case 1: - metric = va("%3d km/h", convSpeed[1]); - break; - case 2: - metric = va("%3d mph", convSpeed[1]); - break; - case 3: - metric = va("%3d fu/t", convSpeed[1]); - break; - case 4: - // if extra.kart is found, use its included % symbol - if (!xtra_speedo) - metric = va("%4d P", convSpeed[1]); - else - metric = va("%4d %%", convSpeed[1]); - break; - default: - break; - } - - V_DrawKartString(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, metric); - } - else if (speedostyle == SPEEDO_EXTRA) // why bother if we dont? - { - if (K_UseColorSpeedo(SPEEDO_EXTRA)) //Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerclr, colormap); - } - else - V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallsticker); - - V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); - V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatches[cv_kartspeedometer.value]); - } - else if (speedostyle == SPEEDO_ACHII) // why bother if we dont? - { - if (K_UseColorSpeedo(SPEEDO_ACHII)) //Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachiclr, colormap); - V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); - V_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachiclr[cv_kartspeedometer.value], colormap); - } - else - { - V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachi); - V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); - V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachi[cv_kartspeedometer.value]); - } - } -#ifdef ROTSPRITE - else if (speedostyle == SPEEDO_DIAL) // why bother if we dont? - { - K_DrawDialSpeedometer(convSpeed[0], - dial_divisor, - splitflags, - (boolean)(G_BattleGametype()), - (LUA_HudEnabled(hud_gametypeinfo)), - (K_UseColorSpeedo(SPEEDO_DIAL))); - } -#endif - else if (speedostyle == SPEEDO_EXTRA3) // why bother if we dont? - { - if (K_UseColorSpeedo(SPEEDO_EXTRA3)) //Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - V_DrawStretchyFixedPatch((SPDM_X-1)<speed, mapobjectscale)/FRACUNIT; - - for (INT32 i = 0; i < 22; ++i) - { - if (fuspeed < speedIntervals[i]) - { - spdpatch = i; - break; - } - } - - if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && (leveltime & 4)) - spdpatch = 24; - else if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && !(leveltime & 4)) - spdpatch = 23; - - V_DrawScaledPatch(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, (speedostyle == SPEEDO_PMETER) ? kp_kartzspeedo[spdpatch] : kp_kartzspeedo_smol[spdpatch]); - } -} - -#ifdef ROTSPRITE -#undef DIALSPDDIV -#undef MPHDIV -#endif - -static void K_drawKartBumpersOrKarma(void) -{ - const UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - INT32 fx, fy, fflags; - const boolean flipstring = splitscreen > 1 && stplyrnum & 1; // same as laps, used for splitscreen - INT32 stringw = 0; // used with the above - const char *bumpval = ""; - - drawinfo_t info; - K_getLapsDrawinfo(&info); - fx = info.x; - fy = info.y; - fflags = info.flags; - - if (cv_battlespeedo.value && !splitscreen) - { - const UINT8 speedostyle = K_GetSpeedometerStyle(); - - if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII) || (speedostyle == SPEEDO_EXTRA3)) - fy += 5; - else - fy += 7; - } - - if (splitscreen > 1) - { - if (stplyr->kartstuff[k_bumper] <= 0) - { - bumpval = va("%d/2", stplyr->kartstuff[k_comebackpoints]); - - if (flipstring) - fx -= 37; - V_DrawMappedPatch(fx, fy-1, V_HUDTRANS|fflags, kp_splitkarmabomb, colormap); - V_DrawString(fx+13, fy+1, V_HUDTRANS|fflags, bumpval); - } - else // the above doesn't need to account for weird stuff since the max amount of karma necessary is always 2 ^^^^ - { - bumpval = va("%d/%d", stplyr->kartstuff[k_bumper], cv_kartbumpers.value); - - if (flipstring) // for p2 and p4, assume we can have more than 10 bumpers. It's retarded but who knows. - { - stringw = V_StringWidth(bumpval, 0); - - V_DrawMappedPatch(fx-stringw-13, fy-1, V_HUDTRANS|fflags, kp_rankbumper, colormap); - V_DrawRightAlignedString(fx, fy+1, V_HUDTRANS|fflags, bumpval); - } - else // draw bumpers normally. - { - V_DrawMappedPatch(fx, fy-1, V_HUDTRANS|fflags, kp_rankbumper, colormap); - V_DrawString(fx+13, fy+1, V_HUDTRANS|fflags, bumpval); - } - } - } - else - { - patch_t *patch; - - if (stplyr->kartstuff[k_bumper] <= 0) - { - patch = (K_UseColorHud() ? kp_karmastickerclr : kp_karmasticker); - bumpval = va("%d/2", stplyr->kartstuff[k_comebackpoints]); - } - else - { - if (stplyr->kartstuff[k_bumper] > 9 && cv_kartbumpers.value > 9) - patch = (K_UseColorHud() ? kp_bumperstickerwideclr : kp_bumperstickerwide); - else - patch = (K_UseColorHud() ? kp_bumperstickerclr : kp_bumpersticker); - - bumpval = va("%d/%d", stplyr->kartstuff[k_bumper], cv_kartbumpers.value); - } - - V_DrawMappedPatch(fx, fy, V_HUDTRANS|fflags, patch, colormap); - V_DrawKartString(fx+47, fy+3, V_HUDTRANS|fflags, bumpval); - } -} - -#define lerp(from, to) cv_uncappedhud.value ? from + FixedMul(rendertimefrac, to - from) : to - -// converts mobj coordinates into screen coordinates -// NOTE: use with V_NOSCALESTART! -// Code updated in Lua by GenericHeroGuy for libSG -// Badly ported to C by NepDisk and acutally made to work and fixed by Indev!(Thanks so much!) -// Badly uncapped in C by GenericHeroGuy -// original code by Lat' -static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *target, fixed_t hofs, boolean dontclip) -{ - fixed_t y, x; - fixed_t targx, targy, targz; - - fixed_t dist; - fixed_t distfact; - fixed_t offset; - - fixed_t yres, xres; - fixed_t fov; - - // this should never happen but its also kart so ¯\_(ツ)_/¯ - if (!player || P_MobjWasRemoved(target)) - return false; - - targx = lerp(target->old_x, target->x); - targy = lerp(target->old_y, target->y); - targz = lerp(target->old_z, target->z); - - // X coordinate - // get difference between camangle and angle towards target - x = (INT32)viewangle - (INT32)R_PointToAngle(targx, targy); - - distfact = FINECOSINE((x>>ANGLETOFINESHIFT) & FINEMASK); - if (!distfact) distfact = 1; - - if (encoremode) - x = -x; - if (x < (fixed_t)ANGLE_270 || x > (fixed_t)ANGLE_90) - return false; - - xres = vid.width<<(FRACBITS-1); - yres = vid.height<<(FRACBITS-1); - fov = FixedDiv(xres, FINETANGENT(((FixedAngle(cv_fov.value/2)+ANGLE_90)>>ANGLETOFINESHIFT) & 4095)); - - // flipping - const boolean targflip = target->eflags & MFE_VERTICALFLIP; - const boolean srcflip = player->pflags & PF_FLIPCAM && player->mo->eflags & MFE_VERTICALFLIP; - - // Y coordinate - // getting the angle difference here is a bit more involved... - // start by getting the height difference between the camera and target - y = viewz - targz - (targflip ? ((target->height * 2) / 3) : 0); // for some reason needs to be divided by "1.5" idk - - if (hofs) - y = y - (targflip ? -hofs : hofs); - - // then get the distance between camera and target - dist = R_PointToDist(targx, targy); - -#ifdef HWRENDER - // NOW we can get the angle differnce - if (rendermode == render_opengl && !cv_glshearing.value) - { - angle_t yang = R_PointToAngle2(0, 0, dist, y); // not perspective - x = FixedMul(x, FINECOSINE((yang>>ANGLETOFINESHIFT) & FINEMASK)); // perspective - y = -aimingangle - FixedDiv(yang, distfact); - - if (y < (fixed_t)ANGLE_270 || y > (fixed_t)ANGLE_90) // clip points behind the camera - return false; - if (splitscreen == 1) // multiply by 1.25 for 2P splitscreen - y = y + (y/4) ; - if (srcflip) // flipcam - y = -y; - - y = FixedMul(FINETANGENT((((angle_t)(-y)+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), fov) + yres; // project the angle to get our final Y coordinate - } - else -#endif - { - const fixed_t fovratio = FixedDiv(90*FRACUNIT, 180*FRACUNIT - FixedMul(cv_fov.value, 4*FRACUNIT/3)-FRACUNIT*-30); - - y = FixedDiv(y, FixedMul(dist, distfact)); - if (srcflip) - y = -y; // flipcam - if (y != INT32_MIN) // I_Error(): FixedDiv: divide by zero - y = FixedMul(FixedDiv(y, fovratio), xres) + yres; - //else print("NOPE!") - - offset = FixedMul(FINETANGENT(((aimingangle+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), xres); - - // this isn't fovtan... what am i even doing anymore - if (splitscreen == 1) - offset = 17*offset/120; - - // thanks fickle - offset = FixedDiv(offset, fovratio); - if (srcflip) - offset = -offset; // flipcam - y = y + offset; - } - - // project the angle to get our final X coordinate - x = FixedMul(FINETANGENT(((x+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), fov); - if (splitscreen == 1) // divide by 320/200 (1.6) on 2P splitscreen - x = (x/2) + (x/8); - x = x + xres; - - // now clip in screen-space - if (!dontclip && (x < 0 || x > xres*2 || y < 0 || y > yres*2)) - return false; - - // adjust coords for splitscreen - if (splitscreen == 1) // 2P - { - y = y>>1; - if (stplyrnum > 0) - y = y + yres; - } - if (splitscreen >= 2) // 3P or 4P - { - x = x>>1; - y = y>>1; - if (stplyrnum & 1) - x = x + xres; - if (stplyrnum >= 2) - y = y + yres; - } - - vec->y = y; - vec->x = x; - return true; -} - -//Slighty fixed by Alug and further rewritten by NepDisk -//Decided to port and highly modify sunflower version for the main nametag drawing with additions by NepDisk. My previous one was broken anyway due to the changed screencoords and noscalestart -static void K_drawNameTags(void) -{ - UINT8 i, j; - INT32 trans; - vector2_t pos = {0}; - fixed_t namex, namey; - int tagsdisplayed = 0; - fixed_t distance = 0; - fixed_t maxdistance = 0; - boolean flipped = false; - fixed_t z; - - char *tag; - patch_t *icon = NULL; - - INT32 dup; - UINT8 *cm = NULL; - UINT8 tagcolor = 0; - INT32 vflags = 0; - boolean usenametagrestat = false; - fixed_t tagwidthsmall; - fixed_t tagwidth; - - if (P_MobjWasRemoved(stplyr->mo) || (stplyr->spectator && !cv_shownametagspectator.value) || stplyr->exiting) - return; - - maxdistance = ((10*cv_nametagdist.value) * mapobjectscale); - - for (i = 0; i < MAXPLAYERS; i++) - { - distance = 0; - flipped = false; - - if (i > PLAYERSMASK) - continue; - if (players[i].spectator || !playeringame[i] || P_MobjWasRemoved(players[i].mo)) - continue; - if (i == displayplayers[stplyrnum] && !cv_showownnametag.value && !(leveltime < 130)) - continue; - if (i != displayplayers[stplyrnum] && leveltime < starttime) - continue; - if (players[i].kartstuff[k_hyudorotimer]) // player is invisible - continue; - if (maxdistance) - distance = R_PointToDist(players[i].mo->x, players[i].mo->y); - if (distance > maxdistance) - continue; - if (!P_CheckSightFast(stplyr->mo, players[i].mo)) - continue; - - z = players[i].mo->height; - - //Saltyhop hehe - z += lerp(players[i].mo->old_spriteyoffset, players[i].mo->spriteyoffset); - - if (!K_GetScreenCoords(&pos, stplyr, players[i].mo, z, false)) - continue; - - tagsdisplayed++; - - if (tagsdisplayed > cv_nametagmaxplayers.value) - break; - - trans = 0; - - switch (cv_nametagtrans.value) - { - case 1: - if (distance > (maxdistance*3/4)) - trans = V_60TRANS; - break; - case 2: - if (distance > (maxdistance*3/1)) - trans = V_90TRANS; - else if (distance > (maxdistance*3/2)) - trans = V_80TRANS; - else if (distance > (maxdistance*3/3)) - trans = V_60TRANS; - else if (distance > (maxdistance*3/4)) - trans = V_40TRANS; - else if (distance > (maxdistance*3/5)) - trans = V_20TRANS; - break; - case 3: - trans = V_40TRANS; - break; - case 4: - trans = V_LocalTransFlag(); - break; - case 0: - default: - break; - } - - namex = pos.x>>FRACBITS; - namey = pos.y>>FRACBITS; - - tag = va("%s%s ", HU_SkinColorToConsoleColor(players[i].mo->color), player_names[i]); - icon = R_GetSkinFaceMini(players[i].mo->player); - - dup = vid.dupx; - cm = R_GetTranslationColormap(players[i].skin, players[i].mo->color, GTC_CACHE); - tagcolor = colortranslations[players[i].mo->color][7]; - vflags = trans | V_NOSCALESTART; - usenametagrestat = ((cv_nametagrestat.value == 1 && (players[i].kartspeed != skins[players[i].skin].kartspeed || players[i].kartweight != skins[players[i].skin].kartweight)) || cv_nametagrestat.value == 2); - tagwidthsmall = cv_smallnametags.value ? V_SmallStringWidth(player_names[i], V_ALLOWLOWERCASE) : V_ThinStringWidth(player_names[i], V_ALLOWLOWERCASE); - tagwidth = dup*tagwidthsmall; - - // If flipcam is on, other player is flipped relative to us when we have different - // verticalflip flag value. Otherwise, they are simply flipped when verticalflip flag says so - if ((stplyr->pflags & PF_FLIPCAM) && (stplyr->mo->eflags & MFE_VERTICALFLIP)) - flipped = (players[i].mo->eflags & MFE_VERTICALFLIP) != (stplyr->mo->eflags & MFE_VERTICALFLIP); - else - flipped = players[i].mo->eflags & MFE_VERTICALFLIP; - - if (cv_smallnametags.value || !nametaggfx) - { - if (flipped) - namey += dup*5; - else // small offset - namey -= dup*3; - - if (nametaggfx && cv_smallnametags.value == 1) - { - if (cv_nametagfacerank.value) - tagwidthsmall += icon->width - dup; - - // Have to draw the nametag using patches here since drawfill can't draw at this scale... - if (!flipped) - V_DrawFixedPatch(namex<height/2)<width/2); // add offset to other stuff - } - - //Name - V_DrawSmallString(namex, namey, V_ALLOWLOWERCASE | vflags, tag); - - if (usenametagrestat) - { - V_DrawSmallString(namex, namey - dup*5, vflags, va("\x84S%d ", players[i].kartspeed)); - V_DrawSmallString(namex + dup*10, namey - dup*5, vflags, va("\x87W%d ", players[i].kartweight)); - } - - if (cv_nametagscore.value) - { - INT32 yofs = usenametagrestat ? 10 : 5; - V_DrawSmallString(namex, namey - dup*yofs, V_ALLOWLOWERCASE | vflags, va("\x8A%d ", players[i].score)); - } - } - else - { - if (cv_nametagfacerank.value) - tagwidth += dup*(icon->width+1); - - if (flipped) - { - for (j = 0; j < 4; j++) - { - V_DrawFill(namex, namey, dup*3, dup*4, 31 | vflags); - V_DrawFill(namex+dup, namey, dup, dup*4, tagcolor | vflags); - namey += dup*4; - namex += dup; - } - namey -= dup*3; - V_DrawFill(namex, namey+dup*2, dup, dup, 31 | vflags); // a single black pixel - V_DrawFill(namex+dup, namey, tagwidth, dup*3, 31 | vflags); - V_DrawFill(namex+dup, namey+dup, tagwidth - dup, dup, tagcolor | vflags); - namex += dup*2; - } - else - { - for (j = 0; j < 4; j++) - { - namey -= dup*4; - V_DrawFill(namex, namey, dup*3, dup*4, 31 | vflags); - V_DrawFill(namex+dup, namey, dup, dup*4, tagcolor | vflags); - namex += dup; - } - - V_DrawFill(namex, namey, dup, dup, 31 | vflags); - V_DrawFill(namex+dup, namey, tagwidth - dup*2, dup*3, 31 | vflags); - V_DrawFill(namex+dup, namey+dup, tagwidth - dup*3, dup, tagcolor | vflags); - } - - if (cv_nametagfacerank.value) - { - V_DrawMappedPatch(namex, namey - dup*(icon->height+1), vflags, icon, cm); - namex += dup*(icon->height+1); // add offset to other stuff - } - - V_DrawThinString(namex, namey - dup*10, V_ALLOWLOWERCASE | vflags, tag); - - if (usenametagrestat) - { - V_DrawScaledPatch(namex, namey - dup*20, vflags, nametagspeed); - V_DrawScaledPatch(namex + dup*18, namey - dup*20, vflags, nametagweight); - V_DrawString(namex + dup*9, namey - dup*19, V_ALLOWLOWERCASE | vflags, va("\x84%d ", players[i].kartspeed)); - V_DrawString(namex + dup*27, namey - dup*19, V_ALLOWLOWERCASE | vflags, va("\x87%d ", players[i].kartweight)); - } - - if (cv_nametagscore.value) - { - INT32 yofs = usenametagrestat ? 25 : 15; - V_DrawSmallString(namex, namey - dup*yofs, V_ALLOWLOWERCASE | vflags, va("\x8A%d ", players[i].score)); - } - } - } -} - -// Based on Driftgauge refactor by GenericHeroGuy ported from lua and expanded by NepDisk -static void K_drawDriftGauge(void) -{ - vector2_t pos = {0}; - fixed_t basex, basey; - const int dup = vid.dupx; - int i; - UINT8 *cmap; - - static const UINT8 driftcolors[3][4] = { - {0, 0, 10, 16}, // no drift - {215, 215, 204, 253}, // blue - {125, 125, 151, 159} // red - }; - - static const UINT8 driftskins[3] = { - SKINCOLOR_NONE, - SKINCOLOR_TEAL, - SKINCOLOR_SALMON, - }; - - static UINT8 driftrainbow[18] = { - 0, 31, 47, 63, 79, 95, 111, 119, 127, 143, 159, 175, 183, 191, 199, 207, 223, 247 - }; - - if (camera[stplyrnum].freecam) - return; - - if (!splitscreen && !camera->chase) - return; - - if (forceshowhud) - goto skipcrap; // i will skip the drift early return and you cant stop me! - - if (!stplyr->kartstuff[k_drift]) - return; - -skipcrap: - - if (P_MobjWasRemoved(stplyr->mo)) - return; - - if (!K_GetScreenCoords(&pos, stplyr, stplyr->mo, FixedMul(cv_driftgaugeofs.value, cv_driftgaugeofs.value > 0 ? stplyr->mo->scale : mapobjectscale), false)) - return; - - fixed_t barx; - fixed_t bary; - INT32 BAR_WIDTH; - - const INT32 driftval = K_GetKartDriftSparkValue(stplyr); - const INT32 driftcharge = min(driftval*4, stplyr->kartstuff[k_driftcharge]); - const INT32 driftlevel = min(driftcharge / driftval, 2); - const INT32 drifttrans = ((cv_driftgaugetrans.value) ? V_LocalTransFlag() : 0); - - basex = pos.x>>FRACBITS; - basey = pos.y>>FRACBITS; - - switch (cv_driftgaugestyle.value) - { - case 1: - case 2: - case 3: - case 5: - { - if (!driftgaugegfx) - break; - - const boolean usescaledpatch = (cv_driftgaugestyle.value == 5 && xtra_speedo3); - - if (cv_driftgaugestyle.value == 1 || cv_driftgaugestyle.value == 3 || usescaledpatch) - { - barx = basex - dup*23; - BAR_WIDTH = dup*47; - } - else - { - barx = basex - dup*12; - BAR_WIDTH = dup*23; - } - - bary = basey - dup*2; - - if (usescaledpatch) // i hate hud code i hate hud code i hate hud code i hate hud code i hate hud code..... - { - if (K_UseColorSpeedo(SPEEDO_EXTRA3)) // Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - V_DrawStretchyFixedPatch((basex - dup*30)<= driftval*4) // rainbow sparks - { - cmap = R_GetTranslationColormap(TC_RAINBOW, 1 + leveltime % (MAXSKINCOLORS-1),GTC_CACHE); - - for (i = 0; i < 4; i++) - V_DrawFill(barx, bary+dup*1+dup*i, BAR_WIDTH, dup, (driftrainbow[min((leveltime % 18) + 1, 18 - 1)] + i*2) | V_NOSCALESTART|drifttrans); - } - else // none/blue/red - { - const INT32 limit = (driftval * (driftcharge >= driftval*2 ? 2 : 1)); - const INT32 width = ((driftcharge - (driftcharge >= driftval ? limit : 0)) * BAR_WIDTH) / limit; - - cmap = R_GetTranslationColormap(TC_RAINBOW, driftskins[driftlevel],GTC_CACHE); - - for (i = 0; i < 4; i++) - { - if (driftcharge >= driftval) - V_DrawFill(barx, bary+dup*1+dup*i, BAR_WIDTH, dup, driftcolors[driftlevel-1][i] | V_NOSCALESTART|drifttrans); - - V_DrawFill(barx, bary+dup*1+dup*i, width, dup, driftcolors[driftlevel][i] | V_NOSCALESTART|drifttrans); - } - } - - // right, also draw a cool number - //SG_DrawPaddedNum(v, basex + (dup*32), basey, driftcharge*100 / driftval, 3, "PINGN", V_NOSCALESTART|V_OFFSET|drifttrans, cmap) - if (cv_driftgaugestyle.value == 3) - V_DrawPaddedTallColorNum(basex + (dup*32), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, 3, cmap); - else - V_DrawPingNum(cv_driftgaugestyle.value == 2 ? basex + (dup*22) : basex + (dup*32), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, cmap); - } - break; - case 4: - { - cmap = R_GetTranslationColormap(TC_RAINBOW, driftskins[driftlevel],GTC_CACHE); - - if (driftcharge >= driftval*4) - cmap = R_GetTranslationColormap(TC_RAINBOW, 1 + leveltime % (MAXSKINCOLORS-1),GTC_CACHE); - - V_DrawPaddedTallColorNum(basex + (dup*16), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, 3, cmap); - } - break; - default: - break; - } -} - -static fixed_t K_FindCheckX(fixed_t px, fixed_t py, angle_t ang, fixed_t mx, fixed_t my) -{ - fixed_t dist, x; - fixed_t range = RING_DIST/3; - angle_t diff; - - range *= gamespeed+1; - - dist = abs(R_PointToDist2(px, py, mx, my)); - if (dist > range) - return -BASEVIDWIDTH; - - diff = R_PointToAngle2(px, py, mx, my) - ang; - - if (diff < ANGLE_90 || diff > ANGLE_270) - return -BASEVIDWIDTH; - else - x = (FixedMul(FINETANGENT(((diff+ANGLE_90)>>ANGLETOFINESHIFT) & 4095), 160<>FRACBITS; - - if (encoremode) - x = BASEVIDWIDTH-x; - - if (splitscreen > 1) - x /= 2; - - return x; -} - -static void K_drawKartWanted(void) -{ - UINT8 i, numwanted = 0; - UINT8 *colormap = NULL; - INT32 basex = 0, basey = 0; - - if (stplyrnum != 0) - return; - - for (i = 0; i < 4; i++) - { - if (battlewanted[i] == -1) - break; - numwanted++; - } - - if (numwanted <= 0) - return; - - // set X/Y coords depending on splitscreen. - if (splitscreen < 3) // 1P and 2P use the same code. - { - basex = WANT_X; - basey = WANT_Y; - if (splitscreen == 2) - { - basey += 16; // slight adjust for 3P - basex -= 6; - } - } - else if (splitscreen == 3) // 4P splitscreen... - { - basex = BASEVIDWIDTH/2 - (kp_wantedsplit->width/2); // center on screen - basey = BASEVIDHEIGHT - 55; - //basey2 = 4; - } - - if (battlewanted[0] != -1) - colormap = R_GetTranslationColormap(0, players[battlewanted[0]].skincolor, GTC_CACHE); - - V_DrawFixedPatch(basex< 1 ? kp_wantedsplit : kp_wanted), colormap); - /*if (basey2) - V_DrawFixedPatch(basex< 1 ? 13 : 8), y = basey+(splitscreen > 1 ? 16 : 21); - fixed_t scale = FRACUNIT/2; - - if (battlewanted[i] == -1) - break; - - player_t *p = &players[battlewanted[i]]; - - if (numwanted == 1) - scale = FRACUNIT; - else - { - if (i & 1) - x += 16; - if (i > 1) - y += 16; - } - - if (p->skincolor) - { - colormap = R_GetTranslationColormap(TC_RAINBOW, p->skincolor, GTC_CACHE); - V_DrawFixedPatch(x<skin] : facerankprefix[p->skin]), colormap);*/ - } - } -} - -static void K_drawKartPlayerCheck(void) -{ - INT32 i; - UINT8 *colormap; - INT32 x; - - const INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM); - - if (!stplyr->mo || stplyr->spectator) - return; - - if (stplyr->awayviewtics) - return; - - if (camspin[0]) - return; - - for (i = 0; i < MAXPLAYERS; i++) - { - UINT8 pnum = 0; - - if (&players[i] == stplyr) - continue; - if (!playeringame[i] || players[i].spectator) - continue; - if (!players[i].mo) - continue; - - if ((players[i].kartstuff[k_invincibilitytimer] <= 0) && (leveltime & 2)) - pnum++; // white frames - - if (players[i].kartstuff[k_itemtype] == KITEM_GROW || players[i].kartstuff[k_growshrinktimer] > 0) - pnum += 4; - else if (players[i].kartstuff[k_itemtype] == KITEM_INVINCIBILITY || players[i].kartstuff[k_invincibilitytimer]) - pnum += 2; - - x = K_FindCheckX(stplyr->mo->x, stplyr->mo->y, stplyr->mo->angle, players[i].mo->x, players[i].mo->y); - if (x <= 320 && x >= 0) - { - if (x < 14) - x = 14; - else if (x > 306) - x = 306; - - colormap = R_GetTranslationColormap(TC_DEFAULT, players[i].mo->color, GTC_CACHE); - V_DrawMappedPatch(x, CHEK_Y, V_HUDTRANS|splitflags, kp_check[pnum], colormap); - } - } -} - -static void K_drawKartMinimapIcon(fixed_t objx, fixed_t objy, INT32 hudx, INT32 hudy, INT32 flags, INT32 blend, patch_t *icon, UINT8 *colormap, drawinfo_t *dims, boolean scaleme) -{ - // amnum xpos & ypos are the icon's speed around the HUD. - // The number being divided by is for how fast it moves. - // The higher the number, the slower it moves. - - // am xpos & ypos are the icon's starting position. Withouht - // it, they wouldn't 'spawn' on the top-right side of the HUD. - - fixed_t amnumxpos, amnumypos; - INT32 amxpos, amypos; - fixed_t scale = FRACUNIT; - patch_t *AutomapPic; - INT16 w, h; - - AutomapPic = minimapinfo.minimap_pic; - - if (AutomapPic == NULL) - { - return; // no pic, just get outta here - } - - amnumxpos = (FixedMul(objx, minimapinfo.zoom) - minimapinfo.offs_x); - amnumypos = -(FixedMul(objy, minimapinfo.zoom) - minimapinfo.offs_y); - - if (encoremode) - amnumxpos = -amnumxpos; - - if (dims && (dims->x != 0) && (dims->y != 0)) - { - w = dims->x; - h = dims->y; - } - else - { - w = icon->width; - h = icon->height; - } - - amxpos = amnumxpos + ((hudx + (AutomapPic->width-w)/2)<height-h)/2)<player; - const boolean skinlocal = mo->skinlocal; - - fixed_t amnumxpos, amnumypos; - INT32 amxpos, amypos, wntdamxpos, wntdamypos; - fixed_t scale = FRACUNIT; - patch_t *minimaphead = NULL; - -#ifdef ROTSPRITE - angle_t rollangle = 0; - INT32 rot = 0; -#endif - - skin = K_GetMobjSkin(mo); - minimaphead = (skinlocal ? localfacemmapprefix : facemmapprefix)[K_GetMobjSkinNum(skin, skinlocal)]; - - amnumxpos = (FixedMul(lerp(mo->old_x, mo->x), minimapinfo.zoom) - minimapinfo.offs_x); - amnumypos = -(FixedMul(lerp(mo->old_y, mo->y), minimapinfo.zoom) - minimapinfo.offs_y); - - if (encoremode) - amnumxpos = -amnumxpos; - - amxpos = amnumxpos + ((x + (minimapinfo.minimap_pic->width-minimaphead->width) / 2)<height-minimaphead->height) / 2)<color), player_names[player - players]); - } - - // thx wanted reticle for having weird offsets very cool - wntdamxpos = cv_minihead.value ? amxpos + (1<width / 4)<height / 4)<spinoutrot) - { - // Rotate counterclockwise. - rollangle = FixedAngle(player->spinoutrot * -1); - rot = R_GetRollAngle(rollangle); - - if (rot) - { - minimaphead = W_CachePatchNameRotated(skin->facemmap, rot, PU_PATCH); - } - } -#endif - - if (!mo->color) // 'default' color - V_DrawSciencePatch(amxpos, amypos, flags, minimaphead, scale); - else - { - UINT8 *colormap; - - if (mo->colorized) - colormap = R_GetTranslationColormap(TC_RAINBOW, mo->color, GTC_CACHE); - else - colormap = R_GetLocalTranslationColormap(mo->skin, mo->localskin, mo->color, GTC_CACHE, skinlocal); - - V_DrawFixedPatch(amxpos, amypos, scale, flags, minimaphead, colormap); - - if (player - && ((G_RaceGametype() && player->kartstuff[k_position] == spbplace) - || (G_BattleGametype() && K_IsPlayerWanted(player)))) - { - V_DrawFixedPatch(wntdamxpos, wntdamypos, scale, flags, kp_wantedreticle, NULL); - } - } -} - -enum -{ - MINIANGLE_NONE = 0, - MINIANGLE_DOT, - MINIANGLE_LIGHT -}; - -static void K_drawKartMinimap(void) -{ - INT32 i = 0; - INT32 x, y; - INT32 minimaptrans, splitflags; - SINT8 localplayers[MAXSPLITSCREENPLAYERS]; - SINT8 numlocalplayers = 0; - patch_t *AutomapPic; - - // Draw the HUD only when playing in a level. - // hu_stuff needs this, unlike st_stuff. - if (gamestate != GS_LEVEL) - return; - - // Only draw for the first player - if (stplyrnum != 0) - return; - - AutomapPic = minimapinfo.minimap_pic; - - if (AutomapPic == NULL) - { - return; // no pic, just get outta here - } - - minimaptrans = K_getMinimapTrans(); - - // Exit early if it wouldn't draw anyway. - if (minimaptrans == -1) - return; - - drawinfo_t info; - K_getMinimapDrawinfo(&info); - x = info.x - (AutomapPic->width/2); - y = info.y - (AutomapPic->height/2); - splitflags = info.flags; - - splitflags |= minimaptrans; - - if (encoremode) - V_DrawScaledPatch(x+AutomapPic->width, y, splitflags|V_FLIP, AutomapPic); - else - V_DrawScaledPatch(x, y, splitflags, AutomapPic); - - if (!(splitscreen == 2)) - { - splitflags &= ~minimaptrans; - splitflags |= V_HUDTRANSHALF; - } - - // let offsets transfer to the heads, too! - if (encoremode) - x += AutomapPic->leftoffset; - else - x -= AutomapPic->leftoffset; - y -= AutomapPic->topoffset; - - // initialize - for (i = 0; i < MAXSPLITSCREENPLAYERS; i++) - localplayers[i] = -1; - - // Player's tiny icons on the Automap. (drawn opposite direction so player 1 is drawn last in splitscreen) - if (ghosts) - { - demoghost *g = ghosts; - while (g) - { - K_drawKartMinimapHead(g->mo, x, y, splitflags); - g = g->next; - } - - if (!stplyr->mo || stplyr->spectator) // do we need the latter..? - return; - - localplayers[numlocalplayers++] = stplyr-players; - } - else - { - for (i = MAXPLAYERS-1; i >= 0; i--) - { - if (!playeringame[i]) - continue; - - if (!players[i].mo || players[i].spectator) - continue; - - if (P_IsDisplayPlayer(&players[i])) - { - // Draw display players on top of everything else - localplayers[numlocalplayers++] = i; - continue; - } - - // Now we know it's not a display player, handle non-local player exceptions. - if (G_BattleGametype() && players[i].kartstuff[k_bumper] <= 0) - continue; - - if (players[i].kartstuff[k_hyudorotimer] > 0) - { - if (!((players[i].kartstuff[k_hyudorotimer] < 1*TICRATE/2 - || players[i].kartstuff[k_hyudorotimer] > hyudorotime-(1*TICRATE/2)) - && !(leveltime & 1))) - continue; - } - - K_drawKartMinimapHead(players[i].mo, x, y, splitflags); - } - } - - // draw our local players here, opaque. - splitflags &= ~V_HUDTRANSHALF; - splitflags |= V_HUDTRANS; - - const SINT8 icondotradius = (cv_minihead.value && !cv_showminimapnames.value) ? 8 : 10; - patch_t* minipatch; - INT32 rot; - INT32 blending; - - for (i = 0; i < numlocalplayers; i++) - { - if (localplayers[i] == -1) - continue; // this doesn't interest us - - mobj_t *mobj = players[localplayers[i]].mo; - - // dont draw for no contestants - boolean playertimedout = (mobj->health <= 0 && players[localplayers[i]].pflags & PF_TIMEOVER); - - if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout) - { - UINT8 *colormap; - drawinfo_t dims; - fixed_t interpx, interpy; - fixed_t xoff = 0, yoff = 0; - blending = 0; - - angle_t ang = R_InterpolateAngle(mobj->old_angle, mobj->angle); - - if (encoremode) - ang = ANGLE_180 - ang; - - if (mobj->colorized) - colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE); - else - colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal); - - interpx = lerp(mobj->old_x, mobj->x); - interpy = lerp(mobj->old_y, mobj->y); - - minipatch = kp_minimapdot; - - dims.x = 0; - dims.y = 0; - - if (cv_showminimapangle.value == MINIANGLE_DOT) - { - xoff = FixedMul(FCOS(ang), icondotradius); - yoff = -FixedMul(FSIN(ang), icondotradius); - } - else if (cv_showminimapangle.value == MINIANGLE_LIGHT) - { - rot = R_GetRollAngle(ang); - minipatch = W_CachePatchNameRotated("MMAPHDLT", rot, PU_PATCH); - - blending = B_ADD; - xoff = yoff = 0; - - dims.x = 48; - dims.y = 24; - } - - K_drawKartMinimapIcon( - interpx, - interpy, - x + xoff, - y + yoff, - splitflags, - blending, - minipatch, - colormap, - &dims, - false - ); - } - - // draw the minimap head after the nonsense above - K_drawKartMinimapHead(mobj, x, y, splitflags); - } -} - -#undef lerp - -static void K_drawKartStartCountdown(void) -{ - INT32 pnum = 0, splitflags = K_calcSplitFlags(0); // 3 - - if (leveltime >= starttime-(2*TICRATE)) // 2 - pnum++; - if (leveltime >= starttime-TICRATE) // 1 - pnum++; - if (leveltime >= starttime) // GO! - pnum++; - if ((leveltime % (2*5)) / 5) // blink - pnum += 4; - if (splitscreen) // splitscreen - pnum += 8; - - V_DrawScaledPatch(STCD_X - (kp_startcountdown[pnum]->width/2), STCD_Y - (kp_startcountdown[pnum]->height/2), splitflags, kp_startcountdown[pnum]); -} - -static void K_drawKartFinish(void) -{ - INT32 pnum = 0, splitflags = K_calcSplitFlags(0); - - if (!stplyr->kartstuff[k_cardanimation] || stplyr->kartstuff[k_cardanimation] >= 2*TICRATE) - return; - - if ((stplyr->kartstuff[k_cardanimation] % (2*5)) / 5) // blink - pnum = 1; - - if (splitscreen > 1) // 3/4p, stationary FIN - { - pnum += 2; - V_DrawScaledPatch(STCD_X - (kp_racefinish[pnum]->width/2), STCD_Y - (kp_racefinish[pnum]->height/2), splitflags, kp_racefinish[pnum]); - return; - } - - //else -- 1/2p, scrolling FINISH - { - INT32 x, xval; - - if (splitscreen) // wide splitscreen - pnum += 4; - - x = ((vid.width<width<kartstuff[k_cardanimation])< x ? xval : x))/TICRATE; - - if (splitscreen && stplyrnum == 1) - x = -x; - - V_DrawFixedPatch(x + (STCD_X<>1), - (STCD_Y<height<<(FRACBITS-1)), - FRACUNIT, - splitflags, kp_racefinish[pnum], NULL); - } -} - -static void K_drawBattleFullscreen(void) -{ - INT32 cardanim = stplyr->kartstuff[k_cardanimation] << FRACBITS; - - // fill in the fractional bits - if (cardanim && cardanim != 164*FRACUNIT) - { - INT32 frac = R_GetHudUncap() * ((164 - stplyr->kartstuff[k_cardanimation])/8 + 1); - if (stplyr->exiting) - cardanim += frac; - else - cardanim += stplyr->kartstuff[k_comebacktimer] < 6*TICRATE ? -frac : frac; - } - - INT32 x = BASEVIDWIDTH/2; - INT32 y = (-64*FRACUNIT) + cardanim; // card animation goes from 0 to 164, 164 is the middle of the screen - INT32 splitflags = V_SNAPTOTOP; // I don't feel like properly supporting non-green resolutions, so you can have a misuse of SNAPTO instead - fixed_t scale = FRACUNIT; - boolean drawcomebacktimer = true; // lazy hack because it's cleaner in the long run. - - if (!LUA_HudEnabled(hud_battlecomebacktimer)) - drawcomebacktimer = false; - - if (splitscreen) - { - if ((splitscreen == 1 && stplyrnum == 1) || (splitscreen > 1 && stplyrnum & 2)) - { - y = (232*FRACUNIT) - (cardanim/2); - splitflags = V_SNAPTOBOTTOM; - } - else - y = (-32*FRACUNIT) + (cardanim/2); - - if (splitscreen > 1) - { - scale /= 2; - - if (stplyrnum & 1) - x = 3*BASEVIDWIDTH/4; - else - x = BASEVIDWIDTH/4; - } - else - { - if (stplyr->exiting) - { - if (stplyrnum == 1) - x = BASEVIDWIDTH-96; - else - x = 96; - } - else - scale /= 2; - } - } - - if (stplyr->exiting) - { - if (stplyrnum == 0) - V_DrawFadeScreen(0xFF00, 16); - if (stplyr->exiting < 6*TICRATE && !stplyr->spectator) - { - if (stplyr->kartstuff[k_position] == 1) - V_DrawFixedPatch(x<kartstuff[k_bumper] <= 0 && stplyr->kartstuff[k_comebacktimer] && comeback && !stplyr->spectator && drawcomebacktimer) - { - UINT16 t = stplyr->kartstuff[k_comebacktimer]/(10*TICRATE); - INT32 txoff, adjust = (splitscreen > 1) ? 4 : 6; // normal string is 8, kart string is 12, half of that for ease - INT32 ty = (BASEVIDHEIGHT/2)+66; - - txoff = adjust; - - while (t) - { - txoff += adjust; - t /= 10; - } - - if (splitscreen) - { - if (splitscreen > 1) - ty = (BASEVIDHEIGHT/4)+33; - if ((splitscreen == 1 && stplyrnum == 1) || (splitscreen > 1 && stplyrnum & 2)) - ty += (BASEVIDHEIGHT/2); - } - else - V_DrawFadeScreen(0xFF00, 16); - - if (!comebackshowninfo) - V_DrawFixedPatch(x< 1) - V_DrawString(x-txoff, ty, 0, va("%d", stplyr->kartstuff[k_comebacktimer]/TICRATE)); - else - { - if (K_UseColorHud()) // Colourized hud - { - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - V_DrawFixedPatch(x<kartstuff[k_comebacktimer]/TICRATE)); - } - } - - if (netgame && !stplyr->spectator && timeinmap > 113) // FREE PLAY? - { - UINT8 i; - - // check to see if there's anyone else at all - for (i = 0; i < MAXPLAYERS; i++) - { - if (i == displayplayers[0]) - continue; - if (playeringame[i] && !stplyr->spectator) - return; - } - - if (LUA_HudEnabled(hud_freeplay)) - K_drawKartFreePlay(leveltime); - } -} - -static void K_drawKartFirstPerson(void) -{ - static INT32 pnum[4], turn[4], drift[4]; - INT32 pn = 0, tn = 0, dr = 0; - INT32 target = 0, splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM); - INT32 x = BASEVIDWIDTH/2, y = BASEVIDHEIGHT; - fixed_t scale; - UINT8 *colmap = NULL; - ticcmd_t *cmd = &stplyr->cmd; - - if (stplyr->spectator || !stplyr->mo || (stplyr->mo->flags2 & MF2_DONTDRAW)) - return; - - pn = pnum[stplyrnum]; - tn = turn[stplyrnum]; - dr = drift[stplyrnum]; - - if (splitscreen) - { - y >>= 1; - if (splitscreen > 1) - x >>= 1; - } - - { - if (stplyr->speed < (20*stplyr->mo->scale) && (leveltime & 1) && !splitscreen) - y++; - // the following isn't EXPLICITLY right, it just gets the result we want, but i'm too lazy to look up the right way to do it - if (stplyr->mo->flags2 & MF2_SHADOW) - splitflags |= FF_TRANS80; - else if (stplyr->mo->frame & FF_TRANSMASK) - splitflags |= (stplyr->mo->frame & FF_TRANSMASK); - } - - if (cmd->driftturn > 400) // strong left turn - target = 2; - else if (cmd->driftturn < -400) // strong right turn - target = -2; - else if (cmd->driftturn > 0) // weak left turn - target = 1; - else if (cmd->driftturn < 0) // weak right turn - target = -1; - else // forward - target = 0; - - if (encoremode) - target = -target; - - if (pn < target) - pn++; - else if (pn > target) - pn--; - - if (pn < 0) - splitflags |= V_FLIP; // right turn - - target = abs(pn); - if (target > 2) - target = 2; - - x <<= FRACBITS; - y <<= FRACBITS; - - if (tn != cmd->driftturn/50) - tn -= (tn - (cmd->driftturn/50))/8; - - if (dr != stplyr->kartstuff[k_drift]*16) - dr -= (dr - (stplyr->kartstuff[k_drift]*16))/8; - - if (splitscreen == 1) - { - scale = (2*FRACUNIT)/3; - y += FRACUNIT/(vid.dupx < vid.dupy ? vid.dupx : vid.dupy); // correct a one-pixel gap on the screen view (not the basevid view) - } - else if (splitscreen) - scale = FRACUNIT/2; - else - scale = FRACUNIT; - - if (stplyr->mo) - { - INT32 dsone = K_GetKartDriftSparkValue(stplyr); - INT32 dstwo = dsone*2; - INT32 dsthree = dstwo*2; - -#ifndef DONTLIKETOASTERSFPTWEAKS - { - const angle_t ang = R_PointToAngle2(0, 0, stplyr->rmomx, stplyr->rmomy) - stplyr->frameangle; - // yes, the following is correct. no, you do not need to swap the x and y. - fixed_t xoffs = -P_ReturnThrustY(stplyr->mo, ang, (BASEVIDWIDTH<<(FRACBITS-2))/2); - fixed_t yoffs = -(P_ReturnThrustX(stplyr->mo, ang, 4*FRACUNIT) - 4*FRACUNIT); - - if (splitscreen) - xoffs = FixedMul(xoffs, scale); - - xoffs -= (tn)*scale; - xoffs -= (dr)*scale; - - if (stplyr->frameangle == stplyr->mo->angle) - { - const fixed_t mag = FixedDiv(stplyr->speed, 10*stplyr->mo->scale); - - if (mag < FRACUNIT) - { - xoffs = FixedMul(xoffs, mag); - if (!splitscreen) - yoffs = FixedMul(yoffs, mag); - } - } - - if (stplyr->mo->momz > 0) // TO-DO: Draw more of the kart so we can remove this if! - yoffs += stplyr->mo->momz/3; - - if (encoremode) - x -= xoffs; - else - x += xoffs; - if (!splitscreen) - y += yoffs; - } - - // drift sparks! - if ((leveltime & 1) && (stplyr->kartstuff[k_driftcharge] >= dsthree)) - colmap = R_GetTranslationColormap(TC_RAINBOW, (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1))), GTC_CACHE); - else if ((leveltime & 1) && (stplyr->kartstuff[k_driftcharge] >= dstwo)) - colmap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_KETCHUP, GTC_CACHE); - else if ((leveltime & 1) && (stplyr->kartstuff[k_driftcharge] >= dsone)) - colmap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_SAPPHIRE, GTC_CACHE); - else -#endif - // invincibility/grow/shrink! - if (stplyr->mo->colorized && stplyr->mo->color) - colmap = R_GetTranslationColormap(TC_RAINBOW, stplyr->mo->color, GTC_CACHE); - } - - V_DrawFixedPatch(x, y, scale, splitflags, kp_fpview[target], colmap); - - pnum[stplyrnum] = pn; - turn[stplyrnum] = tn; - drift[stplyrnum] = dr; -} - -// doesn't need to ever support 4p -static void K_drawInput(void) -{ - INT32 offs, col; - static INT32 pn = 0; - - if (!cv_showinput.value || (timeinmap <= 105)) // dont bother - return; - - INT32 target = 0, splitflags = (V_SNAPTOBOTTOM|V_SNAPTORIGHT|V_HUDTRANS); - INT32 x = (BASEVIDWIDTH - 32 + cv_wheel_xoffset.value)*FRACUNIT, y = (BASEVIDHEIGHT - 24 + cv_wheel_yoffset.value)*FRACUNIT; - - const UINT8 hudcolor = K_GetHudColor(); - const INT32 accent1 = splitflags|colortranslations[hudcolor][5]; - const INT32 accent2 = splitflags|colortranslations[hudcolor][9]; - const UINT8 *hudcolormap = R_GetTranslationColormap(0, hudcolor, GTC_CACHE); - - const ticcmd_t *cmd = &stplyr->cmd; - - if (timeinmap < 113) - { - INT32 count = ((INT32)(timeinmap) - 105); - INT32 frac = count > 0 && count < 6 ? R_GetHudUncap() << (FRACBITS - count - 11) : 0; - - offs = 64*FRACUNIT; - while (count-- > 0) - offs >>= 1; - x += (offs < FRACUNIT ? 0 : offs) - frac; - } - -#define BUTTW 8 -#define BUTTH 11 - -#define drawbutt(xoffs, butt, symb)\ - if (cmd->buttons & butt)\ - {\ - offs = 2*FRACUNIT;\ - col = accent1;\ - }\ - else\ - {\ - offs = 0;\ - col = accent2;\ - V_DrawFill((x + xoffs*FRACUNIT)>>FRACBITS, (y + BUTTH*FRACUNIT)>>FRACBITS, BUTTW-1, 2, splitflags|31);\ - }\ - V_DrawFill((x + xoffs*FRACUNIT)>>FRACBITS, (y+offs)>>FRACBITS, BUTTW-1, BUTTH, col);\ - V_DrawFixedPatch(x + FRACUNIT + xoffs*FRACUNIT, y + offs + FRACUNIT, FRACUNIT, splitflags, tny_font[symb-HU_FONTSTART], NULL) - - drawbutt(-2*BUTTW, BT_ACCELERATE, 'A'); - drawbutt( -BUTTW, BT_BRAKE, 'B'); - drawbutt( 0, BT_DRIFT, 'D'); - drawbutt( BUTTW, BT_ATTACK, 'I'); - -#undef drawbutt - -#undef BUTTW -#undef BUTTH - - y -= FRACUNIT; - - if (cv_showinput.value == 2 || cv_showinput.value == 3) - { - INT32 axis; - INT32 hudforward = 0; // for the stick input display :chaosleep: - UINT8 *shadowcolormap = NULL; - const INT32 joyx = x>>FRACBITS; - const INT32 joyy = y>>FRACBITS; - static const INT32 joyxoffs = -8; - static const INT32 joyyoffs = -24; - const boolean usejoysprite = (cv_showinput.value == 3 && joystickicon); - - // O backing - if (usejoysprite) - { - shadowcolormap = R_GetTranslationColormap(0, SKINCOLOR_BLACK, GTC_CACHE); - V_DrawMappedPatch(joyx+joyxoffs, joyy+joyyoffs-1, splitflags, joybacking, hudcolormap); - } - else - { - V_DrawFill(joyx+joyxoffs, joyy+joyyoffs-1, 16, 16, splitflags|accent2); - V_DrawFill(joyx+joyxoffs, joyy+joyyoffs+15, 16, 1, splitflags|31); - } - - // time for pain and suffering - // kart does not have anything we can get analogue joystick y axis values from - // during normal gameplay, so replicate shit here - - // this is horrid but we cant get actual input in replays so uhh - if (demo.playback || !P_IsLocalPlayer(stplyr)) // yeah........... - { - hudforward = stplyr->kartstuff[k_throwdir] * KART_FULLTURN; - } - else - { - const boolean analogjoystickmove = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle; - const boolean gamepadjoystickmove = cv_usejoystick[stplyrnum].value && Joystick[stplyrnum].bGamepadStyle; - const UINT8 ssplayer = stplyrnum+1; - - axis = JoyAxis(AXISAIM, ssplayer); - - if (analogjoystickmove && axis != 0) - { - // JOYAXISRANGE is supposed to be 1023 (divide by 1024) - hudforward -= ((axis * KART_FULLTURN) / (JOYAXISRANGE-1)); - } - else - { - if (InputDown(gc_aimforward, ssplayer) || (gamepadjoystickmove && axis < 0)) - { - hudforward += KART_FULLTURN; - } - if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0)) - { - hudforward-= KART_FULLTURN; - } - } - - hudforward = CLAMP(hudforward, -KART_FULLTURN, KART_FULLTURN); - } - - if (cmd->driftturn || hudforward) - { - INT16 turning = encoremode ? -cmd->driftturn : cmd->driftturn; - - if (usejoysprite) - { - V_DrawMappedPatch(joyx+joyxoffs+3-turning/80, joyy+joyyoffs+2-hudforward/80, splitflags, joyknob, shadowcolormap); - V_DrawMappedPatch(joyx+joyxoffs+3-turning/64, joyy+joyyoffs+1-hudforward/64, splitflags, joyknob, hudcolormap); - } - else - { - // joystick hole - V_DrawFill(joyx+joyxoffs+5, joyy+joyyoffs+4, 6, 6, splitflags|accent1); - // joystick top and back - V_DrawFill(joyx+joyxoffs+3-turning/80, joyy+joyyoffs+2-hudforward/80, 10, 10, splitflags|31); - V_DrawFill(joyx+joyxoffs+3-turning/64, joyy+joyyoffs+1-hudforward/64, 10, 10, splitflags|accent1); - } - } - else - { - if (usejoysprite) - { - V_DrawMappedPatch(joyx+joyxoffs+3, joyy+joyyoffs+8, splitflags, joyshadow, shadowcolormap); - V_DrawMappedPatch(joyx+joyxoffs+3, joyy+joyyoffs+1, splitflags, joyknob, hudcolormap); - } - else - { - V_DrawFill(joyx+joyxoffs+3, joyy+joyyoffs+11, 10, 1, splitflags|accent2); - V_DrawFill(joyx+joyxoffs+3, joyy+joyyoffs+1, 10, 10,splitflags|accent1); - } - } - } - else - { - if (!cmd->driftturn) // no turn - target = 0; - else // turning of multiple strengths! - { - target = ((abs(cmd->driftturn) - 1)/125)+1; - if (target > 4) - target = 4; - if (cmd->driftturn < 0) - target = -target; - } - - if (pn != target) - { - if (abs(pn - target) == 1) - pn = target; - else if (pn < target) - pn += 2; - else //if (pn > target) - pn -= 2; - } - - if (pn < 0) - { - splitflags |= V_FLIP; // right turn - x -= FRACUNIT; - } - - target = abs(pn); - if (target > 4) - target = 4; - - V_DrawFixedPatch(x, y, FRACUNIT, splitflags, kp_inputwheel[target], hudcolormap); - } -} - -static void K_drawChallengerScreen(void) -{ - // This is an insanely complicated animation. - static const UINT8 anim[52] = { - 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13, // frame 1-14, 2 tics: HERE COMES A NEW slides in - 14,14,14,14,14,14, // frame 15, 6 tics: pause on the W - 15,16,17,18, // frame 16-19, 1 tic: CHALLENGER approaches screen - 19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact - 21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold - }; - const UINT8 offset = min(52-1, (3*TICRATE)-mapreset); - - V_DrawFadeScreen(0xFF00, 16); // Fade out - V_DrawScaledPatch(0, 0, 0, kp_challenger[anim[offset]]); -} - -static void K_drawLapStartAnim(void) -{ - // This is an EVEN MORE insanely complicated animation. - const UINT8 progress = 80-stplyr->kartstuff[k_lapanimation]; - UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); - INT32 vflags = V_SNAPTOTOP|V_HUDTRANS; - - fixed_t slideout = max(0, 32*(((progress - 76)*FRACUNIT) + R_GetHudUncap())); - fixed_t slidein = max(0, 32*(((stplyr->kartstuff[k_lapanimation] - 76)*FRACUNIT) - R_GetHudUncap())); - - // First, draw the emblem and hand - INT32 emblemx = (BASEVIDWIDTH << (FRACBITS - 1)) + slidein; - INT32 y = 48*FRACUNIT - slideout; - - V_DrawFixedPatch(emblemx, y, FRACUNIT, vflags, kp_lapanim_emblem[modeattacking ? 1 : 0], colormap); - - INT32 hand = stplyr->kartstuff[k_laphand]; - if (hand >= 1 && hand <= 3) - { - y += 4*FRACUNIT - abs((int)(leveltime % 8)*FRACUNIT + R_GetHudUncap() - 4*FRACUNIT); - V_DrawFixedPatch(emblemx, y, FRACUNIT, vflags, kp_lapanim_hand[hand - 1], NULL); - } - - // Then the text - INT32 leftx = 82*FRACUNIT - slideout; - INT32 rightx = 188*FRACUNIT + slideout; - y = 30*FRACUNIT; - - if (stplyr->laps == (UINT8)(cv_numlaps.value - 1)) - { - // FINAL - V_DrawFixedPatch(leftx - 20*FRACUNIT, y, FRACUNIT, vflags, kp_lapanim_final[min(progress/2, 10)], NULL); - - // LAP - if (progress/2 - 12 >= 0) - V_DrawFixedPatch(rightx, y, FRACUNIT, vflags, kp_lapanim_lap[min(progress/2 - 12, 6)], NULL); - } - else - { - // LAP - V_DrawFixedPatch(leftx, y, FRACUNIT, vflags, kp_lapanim_lap[min(progress/2, 6)], NULL); - - char *lapnum = va("%02d", stplyr->laps + 1); - for (int i = 0; i < (int)strlen(lapnum); i++) - { - int digit = lapnum[i] - '0'; - int frame = min(2, progress/2 - 8 - (i*2)); - if (frame >= 0) - V_DrawFixedPatch(rightx + (i*20*FRACUNIT), y, FRACUNIT, vflags, kp_lapanim_number[digit][frame], NULL); - } - } -} - -void K_drawKartFreePlay(UINT32 flashtime) -{ - // no splitscreen support because it's not FREE PLAY if you have more than one player in-game - - if (!cv_showfreeplay.value) - return; - - if ((flashtime % TICRATE) < TICRATE/2) - return; - - V_DrawKartString((BASEVIDWIDTH - (LAPS_X+1)) - (12*9), // mirror the laps thingy - LAPS_Y+3, V_SNAPTOBOTTOM|V_SNAPTORIGHT|V_HUDTRANS, "FREE PLAY"); -} - -static void K_drawDistributionDebugger(void) -{ - patch_t *items[NUMKARTRESULTS] = { - kp_sadface[1], - kp_sneaker[1], - kp_rocketsneaker[1], - kp_invincibility[7], - kp_banana[1], - kp_eggman[1], - kp_orbinaut[4], - kp_jawz[1], - kp_mine[1], - kp_ballhog[1], - kp_selfpropelledbomb[1], - kp_grow[1], - kp_shrink[1], - kp_thundershield[1], - kp_hyudoro[1], - kp_pogospring[1], - kp_kitchensink[1], - - kp_sneaker[1], - kp_banana[1], - kp_banana[1], - kp_orbinaut[4], - kp_orbinaut[4], - kp_jawz[1] - }; - INT32 useodds = 0; - INT32 pingame = 0, bestbumper = 0; - INT32 i; - INT32 x = -9, y = -9; - boolean dontforcespb = false; - boolean spbrush = false; - - if (stplyrnum != 0) // only for p1 - return; - - // The only code duplication from the Kart, just to avoid the actual item function from calculating pingame twice - for (i = 0; i < MAXPLAYERS; i++) - { - if (!playeringame[i] || players[i].spectator) - continue; - pingame++; - if (players[i].exiting) - dontforcespb = true; - if (players[i].kartstuff[k_bumper] > bestbumper) - bestbumper = players[i].kartstuff[k_bumper]; - } - - if (G_RaceGametype()) - spbrush = (spbplace != -1 && stplyr->kartstuff[k_position] == spbplace+1); - - useodds = K_FindUseodds(stplyr, 0, pingame, bestbumper, spbrush, dontforcespb); - - for (i = 1; i < NUMKARTRESULTS; i++) - { - const INT32 itemodds = K_KartGetItemOdds(useodds, i, 0, spbrush); - if (itemodds <= 0) - continue; - - V_DrawScaledPatch(x, y, V_HUDTRANS|V_SNAPTOTOP, items[i]); - V_DrawThinString(x+11, y+31, V_HUDTRANS|V_SNAPTOTOP, va("%d", itemodds)); - - // Display amount for multi-items - if (i >= NUMKARTITEMS) - { - INT32 amount; - switch (i) - { - case KRITEM_TENFOLDBANANA: - amount = 10; - break; - case KRITEM_QUADORBINAUT: - amount = 4; - break; - case KRITEM_DUALJAWZ: - amount = 2; - break; - default: - amount = 3; - break; - } - V_DrawString(x+24, y+31, V_ALLOWLOWERCASE|V_HUDTRANS|V_SNAPTOTOP, va("x%d", amount)); - } - - x += 32; - if (x >= 297) - { - x = -9; - y += 32; - } - } - - V_DrawString(0, 0, V_HUDTRANS|V_SNAPTOTOP, va("USEODDS %d", useodds)); -} - -static void K_drawCheckpointDebugger(void) -{ - if (stplyrnum != 0) // only for p1 - return; - - if (stplyr->starpostnum >= (numstarposts - (numstarposts/2))) - V_DrawString(8, 184, 0, va("Checkpoint: %d / %d (Can finish)", stplyr->starpostnum, numstarposts)); - else - V_DrawString(8, 184, 0, va("Checkpoint: %d / %d (Skip: %d)", stplyr->starpostnum, numstarposts, ((numstarposts/2) + stplyr->starpostnum))); - V_DrawString(8, 192, 0, va("Waypoint dist: Prev %d, Next %d", stplyr->kartstuff[k_prevcheck], stplyr->kartstuff[k_nextcheck])); -} - -// determines if gametype info (laps/bumpers) should be hidden -static boolean K_DisableGametypeInfo(void) -{ - if (!LUA_HudEnabled(hud_gametypeinfo)) - { - return true; - } - -#ifdef ROTSPRITE - if (splitscreen || (!cv_kartspeedometer.value)) - { - // don't need to run checks if we're in splitscreen, or not using the speedometer - return false; - } - - const UINT8 speedostyle = K_GetSpeedometerStyle(); - - if (G_RaceGametype()) - { - if (speedostyle == SPEEDO_DIAL) - return true; - } - else if (G_BattleGametype()) - { - if ((cv_battlespeedo.value) && (speedostyle == SPEEDO_DIAL)) - return true; - } -#endif - - return false; -} - - -void K_drawKartHUD(void) -{ - boolean isfreeplay = false; - boolean battlefullscreen = false; - boolean freecam = camera[stplyrnum].freecam; //disable some hud elements w/ freecam - boolean gameinfovisible = false; - - // Define the X and Y for each drawn object - // This is handled by console/menu values - K_initKartHUD(); - - // Draw that fun first person HUD! Drawn ASAP so it looks more "real". - if (!camera[stplyrnum].chase && !freecam) - K_drawKartFirstPerson(); - - // Draw full screen stuff that turns off the rest of the HUD - if (mapreset && stplyrnum == 0) - { - K_drawChallengerScreen(); - return; - } - - battlefullscreen = ((G_BattleGametype()) - && (stplyr->exiting - || (stplyr->kartstuff[k_bumper] <= 0 - && stplyr->kartstuff[k_comebacktimer] - && comeback - && stplyr->playerstate == PST_LIVE))); - - if (!demo.title && (!battlefullscreen || splitscreen)) - { - // Draw the CHECK indicator before the other items, so it's overlapped by everything else - - if (LUA_HudEnabled(hud_check)) // delete lua when? - { - if (cv_kartcheck.value && !splitscreen && !players[displayplayers[0]].exiting && !freecam) - K_drawKartPlayerCheck(); - } - - // Draw WANTED status - if (G_BattleGametype()) - { - if (LUA_HudEnabled(hud_wanted)) - K_drawKartWanted(); - } - - if (cv_kartminimap.value) - { - if (LUA_HudEnabled(hud_minimap)) - K_drawKartMinimap(); - } - } - - if (battlefullscreen && !freecam) - { - if (LUA_HudEnabled(hud_battlefullscreen)) - K_drawBattleFullscreen(); - return; - } - - // Draw the item window - if (LUA_HudEnabled(hud_item) && !freecam) - K_drawKartItem(); - - if (cv_driftgauge.value && !modeattacking) - { - if (LUA_HudEnabled(hud_driftgauge)) - K_drawDriftGauge(); - } - - if (cv_nametag.value) - { - if (LUA_HudEnabled(hud_nametags)) - K_drawNameTags(); - } - - // If not splitscreen, draw... - if (!splitscreen && !demo.title) - { - tic_t realtime = stplyr->realtime; - - if (cv_showlaptimes.value - && stplyr->kartstuff[k_lapanimation] - && !stplyr->exiting - && stplyr->laptime[LAP_LAST] != 0 - && !midgamejoin) // due to vanilla compat, we cannot synch this oh well - { - if ((stplyr->kartstuff[k_lapanimation] / 5) & 1) - { - realtime = stplyr->laptime[LAP_LAST]; - } - else - { - realtime = UINT32_MAX; - } - } - - // Draw the timestamp - if (LUA_HudEnabled(hud_time)) - K_drawKartTimestamp(realtime, TIME_X, TIME_Y, gamemap, 0); - - if (!modeattacking) - { - // The top-four faces on the left - //if (LUA_HudEnabled(hud_minirankings)) - isfreeplay = K_drawKartPositionFaces(); - } - } - - if (!stplyr->spectator && !freecam) // Bottom of the screen elements, don't need in spectate mode - { - // get gametype info visibility ahead of time - gameinfovisible = (!K_DisableGametypeInfo()); - - if (!(splitscreen || demo.title)) - { - if (LUA_HudEnabled(hud_inputdisplay)) - K_drawInput(); - } - - if (!demo.title && cv_showstats.value) - { - if (LUA_HudEnabled(hud_statdisplay)) - K_drawKartStats(); - } - - if (demo.title) // Draw title logo instead in demo.titles - { - INT32 x = (BASEVIDWIDTH - 32)*FRACUNIT, y = 128*FRACUNIT, offs; - INT32 logoflags = V_SNAPTORIGHT|V_SNAPTOBOTTOM; - - if (splitscreen == 3) - { - x = BASEVIDWIDTH/2 + 10; - y = BASEVIDHEIGHT/2 - 30; - } - - if (timeinmap < 113) - { - INT32 count = ((INT32)(timeinmap) - 104); - INT32 frac = count > 0 ? R_GetHudUncap() << max(0, FRACBITS - count - 9) : 0; - - offs = 256*FRACUNIT; - while (count-- > 0) - offs >>= 1; - x += offs - frac; - } - - V_DrawSciencePatch(x - (54*FRACUNIT), y, logoflags, W_CachePatchName("TTKBANNR", PU_PATCH), FRACUNIT/4); - V_DrawSciencePatch(x - (54*FRACUNIT), y + (25*FRACUNIT), logoflags, W_CachePatchName("TTKART", PU_PATCH), FRACUNIT/4); - } - else if (G_RaceGametype()) // Race-only elements - { - // Draw the lap counter - if (gameinfovisible) - K_drawKartLaps(); - - if (!splitscreen) - { - // Draw the speedometer - // TODO: Make a better speedometer. << done :p - if (LUA_HudEnabled(hud_speedometer)) - K_drawKartSpeedometer(); - } - - if (isfreeplay) - ; - else if (!modeattacking) - { - // Draw the numerical position - if (LUA_HudEnabled(hud_position)) - K_DrawKartPositionNum(stplyr->kartstuff[k_position]); - } - } - else if (G_BattleGametype()) // Battle-only - { - // Draw the hits left! - if (gameinfovisible) - K_drawKartBumpersOrKarma(); - - if ((!splitscreen) && cv_battlespeedo.value) - { - // Draw the speedometer but in battle - // TODO: Make a better speedometer. << done :p - if (LUA_HudEnabled(hud_speedometer)) - K_drawKartSpeedometer(); - } - } - } - - // Draw the countdowns after everything else. - if (leveltime >= starttime-(3*TICRATE) - && leveltime < starttime+TICRATE) - K_drawKartStartCountdown(); - else if (racecountdown && (!splitscreen || !stplyr->exiting)) - { - char *countstr = va("%d", racecountdown/TICRATE); - - // Eeeh dunno if would be better to add another variable instead of LAPS_Y but this works too - int yoff = cv_dnft_yoffset.value - cv_laps_yoffset.value; - int xoff = cv_dnft_xoffset.value; - - if (splitscreen > 1) - V_DrawCenteredString(BASEVIDWIDTH/4+xoff, LAPS_Y+1+yoff, K_calcSplitFlags(V_SNAPTOBOTTOM), countstr); - else - { - INT32 karlen = strlen(countstr)*6; // half of 12 - V_DrawKartString((BASEVIDWIDTH/2)-karlen+xoff, LAPS_Y+3+yoff, K_calcSplitFlags(V_SNAPTOBOTTOM), countstr); - } - } - - // Race overlays - if (G_RaceGametype() && !freecam) - { - if (stplyr->exiting) - K_drawKartFinish(); - else if (stplyr->kartstuff[k_lapanimation] && !splitscreen && cv_showlapemblem.value) - K_drawLapStartAnim(); - } - - if (modeattacking || freecam) // everything after here is MP and debug only - return; - - if (G_BattleGametype() && !splitscreen && (stplyr->kartstuff[k_yougotem] % 2)) // * YOU GOT EM * - V_DrawScaledPatch(BASEVIDWIDTH/2 - (kp_yougotem->width/2), 32, V_HUDTRANS, kp_yougotem); - - // Draw FREE PLAY. - if (isfreeplay && !stplyr->spectator && timeinmap > 113) - { - if (LUA_HudEnabled(hud_freeplay)) - K_drawKartFreePlay(leveltime); - } - - if (cv_kartdebugdistribution.value) - K_drawDistributionDebugger(); - - if (cv_kartdebugcheckpoint.value) - K_drawCheckpointDebugger(); - - if (cv_kartdebugdirector.value) - K_DrawDirectorDebugger(); - - if (cv_kartdebugnodes.value) - { - UINT8 p; - for (p = 0; p < MAXPLAYERS; p++) - V_DrawString(8, 64+(8*p), V_YELLOWMAP, va("%d - %d (%dl)", p, playernode[p], players[p].cmd.latency)); - } - - if (cv_kartdebugcolorize.value && stplyr->mo && stplyr->mo->skin) - { - INT32 x = 0, y = 0; - UINT8 c; - - for (c = 1; c < MAXSKINCOLORS; c++) - { - UINT8 *cm = R_GetTranslationColormap(TC_RAINBOW, c, GTC_CACHE); - V_DrawFixedPatch(x<>1, 0, facewantprefix[stplyr->skin], cm); - - x += 16; - if (x > BASEVIDWIDTH-16) - { - x = 0; - y += 16; - } - } - } -} - -//} diff --git a/src/k_kart.h b/src/k_kart.h index d9d8fc7b0..e304b0f88 100644 --- a/src/k_kart.h +++ b/src/k_kart.h @@ -23,9 +23,6 @@ extern const UINT8 KartColor_Opposite[MAXSKINCOLORS*2]; void K_RainbowColormap(UINT8 *dest_colormap, UINT8 skincolor); void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, boolean local); UINT8 K_GetKartColorByName(const char *name); -UINT8 K_GetHudColor(void); -boolean K_UseColorHud(void); -boolean K_UseHighResPortraits(void); void K_RegisterServerKartStuff(void); void K_RegisterClientKartStuff(void); @@ -34,30 +31,11 @@ extern consvar_t cv_coloredspeedlines, cv_coloredsneakertrail; extern consvar_t cv_bananajitter; extern consvar_t cv_bananthrowroll; extern consvar_t cv_airsparks; -extern consvar_t cv_colorizedhud, cv_colorizeditembox, cv_colorizedhudcolor; -extern consvar_t cv_darkitembox; -extern consvar_t cv_biglaps; -extern consvar_t cv_highresportrait; -extern consvar_t cv_stat_xoffset, cv_stat_yoffset; -extern consvar_t cv_showstats; -extern consvar_t cv_fancyroulette; -extern consvar_t cv_showlaptimes; -extern consvar_t cv_battlespeedo; -extern consvar_t cv_multiitemicon; -extern consvar_t cv_huditemamount; - -#define NUMSPEEDOSTUFF 8 -extern CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF]; -#define NUMDGAUGESTUFF 6 -extern CV_PossibleValue_t driftgaugestyle_cons_t[NUMDGAUGESTUFF]; -#define NUMINPUTDISPLAYSTUFF 5 -extern CV_PossibleValue_t inputdisplay_cons_t[NUMINPUTDISPLAYSTUFF]; -#define NUMMINIMAPDOTSTUFF 5 -extern CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF]; - boolean K_IsPlayerLosing(player_t *player); boolean K_IsPlayerWanted(player_t *player); +INT32 K_KartGetItemOdds(UINT8 pos, SINT8 item, fixed_t mashed, boolean spbrush); +INT32 K_FindUseodds(player_t *player, fixed_t mashed, INT32 pingame, INT32 bestbumper, boolean spbrush, boolean dontforcespb); void K_KartBouncing(mobj_t *mobj1, mobj_t *mobj2, boolean bounce, boolean solid); void K_FlipFromObject(mobj_t *mo, mobj_t *master); void K_MatchGenericExtraFlags(mobj_t *mo, mobj_t *master); @@ -118,27 +96,6 @@ void K_PlayOvertakeSound(mobj_t *source); void K_PlayHitEmSound(mobj_t *source, mobj_t *victim); void K_PlayPowerGloatSound(mobj_t *source); -const char *K_GetItemPatch(UINT8 item, boolean tiny); -INT32 K_calcSplitFlags(INT32 snapflags); -void K_LoadKartHUDGraphics(void); -void K_drawKartHUD(void); -void K_drawKartFreePlay(UINT32 flashtime); -void K_drawKartTimestamp(tic_t drawtime, INT32 TX, INT32 TY, INT16 emblemmap, UINT8 mode); - -typedef struct -{ - INT32 x; - INT32 y; - INT32 flags; -} drawinfo_t; - -patch_t *K_getItemBoxPatch(boolean small, boolean dark); -patch_t *K_getItemMulPatch(boolean small); -void K_getItemBoxDrawinfo(drawinfo_t *out); -INT32 K_getMinimapTrans(void); -void K_getLapsDrawinfo(drawinfo_t *out); -void K_getMinimapDrawinfo(drawinfo_t *out); - #ifdef __cplusplus } // extern "C" #endif diff --git a/src/lua_baselib.c b/src/lua_baselib.c index 5b877e7ba..ff804d7a4 100644 --- a/src/lua_baselib.c +++ b/src/lua_baselib.c @@ -25,6 +25,7 @@ #include "hu_stuff.h" // HU_AddChatText #include "console.h" #include "k_kart.h" // SRB2Kart +#include "k_hud.h" // SRB2Kart #include "d_netcmd.h" // IsPlayerAdmin #include "d_main.h" diff --git a/src/lua_hudlib.c b/src/lua_hudlib.c index b0e68a76e..736c1ed77 100644 --- a/src/lua_hudlib.c +++ b/src/lua_hudlib.c @@ -24,6 +24,7 @@ #include "w_wad.h" #include "z_zone.h" #include "k_kart.h" +#include "k_hud.h" // SRB2kart #include "lua_script.h" #include "lua_libs.h" diff --git a/src/m_menu.c b/src/m_menu.c index b52d3477f..1d7a81194 100644 --- a/src/m_menu.c +++ b/src/m_menu.c @@ -70,6 +70,7 @@ #include "st_stuff.h" #include "i_sound.h" #include "k_kart.h" // SRB2kart +#include "k_hud.h" // SRB2kart #include "k_stats.h" // SRB2kart #include "d_player.h" // KITEM_ constants diff --git a/src/st_stuff.c b/src/st_stuff.c index 7e4dd8840..16a45ea59 100644 --- a/src/st_stuff.c +++ b/src/st_stuff.c @@ -34,6 +34,7 @@ #include "i_time.h" #include "k_kart.h" // SRB2kart +#include "k_hud.h" //random index #include "m_random.h" diff --git a/src/w_wad.c b/src/w_wad.c index 4214eb8c2..51fc22559 100644 --- a/src/w_wad.c +++ b/src/w_wad.c @@ -65,6 +65,7 @@ #include "st_stuff.h" #include "m_misc.h" // M_MapNumber #include "p_setup.h" // P_PartialAddFile mayb +#include "k_hud.h" #ifdef HWRENDER #include "r_data.h" diff --git a/src/y_inter.c b/src/y_inter.c index 28d256c8b..068115f4f 100644 --- a/src/y_inter.c +++ b/src/y_inter.c @@ -40,6 +40,7 @@ #include "m_random.h" // M_RandomKey #include "g_input.h" // PLAYER1INPUTDOWN #include "k_kart.h" // colortranslations +#include "k_hud.h" #include "console.h" // cons_menuhighlight #include "lua_hook.h" // IntermissionThinker hook #include "lua_hud.h" // intermission hud hook