4918 lines
142 KiB
C
4918 lines
142 KiB
C
// 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};
|
|
|
|
static CV_PossibleValue_t minihead_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Others"}, {0, NULL}};
|
|
consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, minihead_cons_t, 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};
|
|
|
|
static CV_PossibleValue_t posanim_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Smooth"}, {0, NULL}};
|
|
consvar_t cv_posanim = {"postitionanimation", "On", CV_SAVE, posanim_cons_t, 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];
|
|
|
|
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 = (UINT8)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(R_GetTimeFrac(RTF_CAMERA), !cv_uncappedhud.value);
|
|
}
|
|
|
|
void K_KartPlayerHUDUpdate(player_t *player)
|
|
{
|
|
if (player->kartstuff[k_lapanimation])
|
|
player->kartstuff[k_lapanimation]--;
|
|
|
|
if (player->kartstuff[k_yougotem])
|
|
player->kartstuff[k_yougotem]--;
|
|
|
|
if (G_BattleGametype() && (player->exiting || player->kartstuff[k_comebacktimer]))
|
|
{
|
|
if (player->exiting)
|
|
{
|
|
if (player->exiting < 6*TICRATE)
|
|
player->kartstuff[k_cardanimation] += ((164-player->kartstuff[k_cardanimation])/8)+1;
|
|
else if (player->exiting == 6*TICRATE)
|
|
player->kartstuff[k_cardanimation] = 0;
|
|
else if (player->kartstuff[k_cardanimation] < 2*TICRATE)
|
|
player->kartstuff[k_cardanimation]++;
|
|
}
|
|
else
|
|
{
|
|
if (player->kartstuff[k_comebacktimer] < 6*TICRATE)
|
|
player->kartstuff[k_cardanimation] -= ((164-player->kartstuff[k_cardanimation])/8)+1;
|
|
else if (player->kartstuff[k_comebacktimer] < 9*TICRATE)
|
|
player->kartstuff[k_cardanimation] += ((164-player->kartstuff[k_cardanimation])/8)+1;
|
|
}
|
|
|
|
if (player->kartstuff[k_cardanimation] > 164)
|
|
player->kartstuff[k_cardanimation] = 164;
|
|
if (player->kartstuff[k_cardanimation] < 0)
|
|
player->kartstuff[k_cardanimation] = 0;
|
|
}
|
|
else if (G_RaceGametype() && player->exiting)
|
|
{
|
|
if (player->kartstuff[k_cardanimation] < 2*TICRATE)
|
|
player->kartstuff[k_cardanimation]++;
|
|
}
|
|
else
|
|
{
|
|
player->kartstuff[k_cardanimation] = 0;
|
|
}
|
|
}
|
|
|
|
UINT8 K_GetHudColor(void)
|
|
{
|
|
if (cv_colorizedhud.value && cv_colorizedhudcolor.value)
|
|
return (UINT8)cv_colorizedhudcolor.value;
|
|
|
|
return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : (UINT8)cv_playercolor.value);
|
|
}
|
|
|
|
boolean K_UseColorHud(void)
|
|
{
|
|
return (cv_colorizedhud.value && clr_hud);
|
|
}
|
|
|
|
// Since all our extra Saturn things are in optional files
|
|
// we gotta do a bunch of extra checks to determine
|
|
// if the according Assets are actually loaded
|
|
// see D_CheckSaturnExtraFiles in d_main.c
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
enum
|
|
{
|
|
GAUGE_DEFAULT = 1,
|
|
GAUGE_SMALL,
|
|
GAUGE_BIGNUM,
|
|
GAUGE_NUMONLY,
|
|
GAUGE_EXTRA,
|
|
};
|
|
|
|
static SINT8 K_GetDriftgaugeStyle(void)
|
|
{
|
|
if (driftgaugegfx)
|
|
{
|
|
if (cv_driftgaugestyle.value == 1)
|
|
return GAUGE_DEFAULT;
|
|
else if (cv_driftgaugestyle.value == 2)
|
|
return GAUGE_SMALL;
|
|
else if (cv_driftgaugestyle.value == 3)
|
|
return GAUGE_BIGNUM;
|
|
else if (cv_driftgaugestyle.value == 5 && xtra_speedo3)
|
|
return GAUGE_EXTRA;
|
|
}
|
|
|
|
// Fallback
|
|
return GAUGE_NUMONLY; // (cv_driftgaugestyle.value == 4)
|
|
}
|
|
|
|
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 patch
|
|
// 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)<<FF_TRANSSHIFT;
|
|
|
|
if (timeinmap <= 105)
|
|
return -1;
|
|
|
|
if (timeinmap <= 113)
|
|
minimaptrans = ((((INT32)timeinmap) - 105)*minimaptrans)/(113-105);
|
|
|
|
if (!minimaptrans)
|
|
return -1;
|
|
|
|
return (10-minimaptrans)<<FF_TRANSSHIFT;
|
|
}
|
|
|
|
patch_t *K_getItemBoxPatch(boolean small, boolean dark)
|
|
{
|
|
UINT8 ofs = (cv_darkitembox.value && dark ? 1 : 0) + (small ? 2 : 0);
|
|
return (cv_colorizeditembox.value && K_UseColorHud()) ? kp_itembgclr[ofs] : kp_itembg[ofs];
|
|
}
|
|
|
|
patch_t *K_getItemMulPatch(boolean small)
|
|
{
|
|
UINT8 ofs = small ? 1 : 0;
|
|
return K_UseColorHud() ? kp_itemmulstickerclr[ofs] : kp_itemmulsticker[ofs];
|
|
}
|
|
|
|
static void K_drawKartStats(void)
|
|
{
|
|
INT32 x, y, spdxoffset, spdoffset, flags;
|
|
|
|
// For 1-player display
|
|
x = 15;
|
|
y = 150;
|
|
spdxoffset = 0;
|
|
spdoffset = 0;
|
|
|
|
if (!LUA_HudEnabled(hud_statdisplay))
|
|
return;
|
|
|
|
flags = V_SNAPTOBOTTOM|V_SNAPTOLEFT;
|
|
|
|
//Internal offset for speedometer
|
|
|
|
const UINT8 speedostyle = K_GetSpeedometerStyle();
|
|
|
|
if (cv_kartspeedometer.value && (!splitscreen))
|
|
{
|
|
switch (speedostyle)
|
|
{
|
|
case SPEEDO_EXTRA:
|
|
case SPEEDO_ACHII:
|
|
case SPEEDO_EXTRA3:
|
|
spdoffset = -10;
|
|
break;
|
|
case SPEEDO_DIAL:
|
|
spdxoffset = 11;
|
|
spdoffset = 14;
|
|
break;
|
|
default:
|
|
spdoffset = -14;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen))
|
|
spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8));
|
|
|
|
// Customizations c:
|
|
if (!splitscreen)
|
|
{
|
|
skin_t *fakeskin;
|
|
INT32 flags2;
|
|
|
|
x += 18 + cv_stat_xoffset.value + spdxoffset;
|
|
y += cv_stat_yoffset.value + spdoffset;
|
|
|
|
flags |= V_HUDTRANS;
|
|
flags2 = flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor);
|
|
|
|
fakeskin = K_GetPlayerSkin(stplyr);
|
|
|
|
// Skin name
|
|
if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel
|
|
{
|
|
V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname);
|
|
}
|
|
else
|
|
{
|
|
V_DrawThinString(x+20, y+7, flags2, 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));
|
|
|
|
return;
|
|
}
|
|
|
|
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 (stplyrnum == 0)
|
|
{
|
|
y /= 2;
|
|
flags = V_SNAPTOLEFT;
|
|
}
|
|
else
|
|
{
|
|
// Can move it down a bit
|
|
y += 45;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (stplyrnum == 0 || stplyrnum == 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|((stplyrnum == 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|((stplyrnum == 3) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P4 to the bottom
|
|
}
|
|
}
|
|
|
|
flags |= V_HUDTRANS;
|
|
|
|
// 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 = K_RainbowColor();
|
|
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<<FRACBITS;
|
|
INT32 fancyflags = V_HUDTRANS|fflags;
|
|
|
|
if (cv_fancyroulette.value && stplyr->kartstuff[k_itemroulette] && !stplyr->deadtimer)
|
|
{
|
|
fixed_t frac = R_GetTimeFrac(RTF_LEVEL);
|
|
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<<FRACBITS, fy<<FRACBITS, FRACUNIT, V_HUDTRANS|fflags, localpatch, colmap);
|
|
|
|
if (offset)
|
|
{
|
|
const INT32 xofs = flipamount ? 2 : 24; // reminder that this is for 3/4p's right end of the screen.
|
|
V_DrawString(fx+xofs, fy+31, V_ALLOWLOWERCASE|V_HUDTRANS|fflags, va("x%d", stplyr->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<<FRACBITS, rfy, FRACUNIT, fancyflags, localpatch, colmap);
|
|
|
|
// Extensible meter, currently only used for rocket sneaker...
|
|
if (itembar && hudtrans)
|
|
{
|
|
const INT32 fill = ((itembar*barlength)/maxl);
|
|
const INT32 length = min(barlength, fill);
|
|
const INT32 height = (offset ? 1 : 2);
|
|
const INT32 x = (offset ? 17 : 11), y = (offset ? 27 : 35);
|
|
|
|
V_DrawScaledPatch(fx+x, fy+y, V_HUDTRANS|fflags, kp_itemtimer[offset]);
|
|
// The left dark "AA" edge
|
|
V_DrawFill(fx+x+1, fy+y+1, (length == 2 ? 2 : 1), height, 12|fflags);
|
|
// The bar itself
|
|
if (length > 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]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define POS_DELAY_TIME 10
|
|
|
|
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 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 ((cv_posanim.value && stplyr->kartstuff[k_positiondelay]) || stplyr->exiting)
|
|
{
|
|
if (cv_posanim.value == 2)
|
|
{
|
|
const UINT8 delay = (stplyr->exiting) ? POS_DELAY_TIME : stplyr->kartstuff[k_positiondelay];
|
|
const fixed_t add = (scale * 3) >> ((splitscreen == 1) ? 1 : 2);
|
|
scale = (scale + min((add * (delay * delay)) / (POS_DELAY_TIME * POS_DELAY_TIME), add));
|
|
}
|
|
else
|
|
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, scale)>>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)
|
|
{
|
|
V_DrawFixedPatch(fx<<FRACBITS, fy<<FRACBITS, scale, V_HUDTRANSHALF|fflags, kp_positionnum[0][0], NULL);
|
|
return;
|
|
}
|
|
|
|
I_Assert(num >= 0); // This function does not draw negative numbers
|
|
|
|
// Draw the number
|
|
while (num)
|
|
{
|
|
if (win) // 1st place winner? You get rainbows!!
|
|
{
|
|
localpatch = kp_winnernum[(leveltime % (NUMWINFRAMES*3)) / 3];
|
|
}
|
|
else if (stplyr->laps+1 >= cv_numlaps.value || stplyr->exiting) // Check for the final lap, or won
|
|
{
|
|
// Alternate frame every three frames
|
|
switch (leveltime % 9)
|
|
{
|
|
case 1: case 2: case 3:
|
|
if (K_IsPlayerLosing(stplyr))
|
|
localpatch = kp_positionnum[num % 10][4];
|
|
else
|
|
localpatch = kp_positionnum[num % 10][1];
|
|
break;
|
|
case 4: case 5: case 6:
|
|
if (K_IsPlayerLosing(stplyr))
|
|
localpatch = kp_positionnum[num % 10][5];
|
|
else
|
|
localpatch = kp_positionnum[num % 10][2];
|
|
break;
|
|
case 7: case 8: case 9:
|
|
if (K_IsPlayerLosing(stplyr))
|
|
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_DrawFixedPatch((fx<<FRACBITS) + ((overtake && flipdraw) ? (localpatch->width*scale/2) : 0), (fy<<FRACBITS) + ((overtake && flipvdraw) ? (localpatch->height*scale/2) : 0), scale, V_HUDTRANSHALF|fflags, localpatch, NULL);
|
|
// ^ 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 || !player->mo)
|
|
continue;
|
|
|
|
const UINT8 mocolor = player->mo->color;
|
|
|
|
bumperx = FACE_X+19;
|
|
|
|
if (mocolor)
|
|
{
|
|
if (player->mo->colorized)
|
|
colormap = R_GetTranslationColormap(TC_RAINBOW, mocolor, GTC_CACHE);
|
|
else
|
|
colormap = R_GetTranslationColormap(player->skin, 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.scaledwidth, 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.dup;
|
|
|
|
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 fixed_t spd = FixedDiv(speed, divisor);
|
|
const angle_t speedangle =
|
|
FixedAngle(((min(135 * FRACUNIT, spd) - (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)<<FRACBITS, (SPDM_Y + 5)<<FRACBITS, XTRA3PSCALE, XTRA3VSCALE, V_HUDTRANS|splitflags, skp_smallstickerclr3, colormap, 0);
|
|
}
|
|
else
|
|
V_DrawStretchyFixedPatch((SPDM_X-1)<<FRACBITS, (SPDM_Y + 5)<<FRACBITS, XTRA3PSCALE, XTRA3VSCALE, V_HUDTRANS|splitflags, skp_smallsticker3, NULL, 0);
|
|
|
|
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]);
|
|
}
|
|
// Kart Z speedo bullshit...
|
|
// Draw the Speed counter.
|
|
else if ((speedostyle == SPEEDO_PMETER) || (speedostyle == SPEEDO_PMETERSMOL))
|
|
{
|
|
fixed_t fuspeed = 0;
|
|
INT32 spdpatch = 0;
|
|
static const INT32 speedIntervals[22] = {2, 5, 7, 10, 12, 15, 17,
|
|
20, 22, 25, 27, 30, 32,
|
|
35, 37, 40, 42, 45, 47,
|
|
50, 52, 55};
|
|
|
|
fuspeed = FixedDiv(stplyr->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(R_GetTimeFrac(RTF_LEVEL), 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 = (fixed_t)(viewangle - 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;
|
|
|
|
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);
|
|
|
|
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 = vid.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;
|
|
|
|
#ifdef HWRENDER
|
|
// Needs extra offset. Not perfect but this will do for now
|
|
if (rendermode == render_opengl && !cv_glshearing.value && cv_smallnametags.value)
|
|
namey -= vid.dup*6;
|
|
#endif
|
|
|
|
if (cv_smallnametags.value || !nametaggfx)
|
|
{
|
|
if (flipped)
|
|
namey += vid.dup*5;
|
|
else // small offset
|
|
namey -= vid.dup*3;
|
|
|
|
if (nametaggfx && cv_smallnametags.value == 1)
|
|
{
|
|
if (cv_nametagfacerank.value)
|
|
tagwidthsmall += icon->width - vid.dup;
|
|
|
|
// Have to draw the nametag using patches here since drawfill can't draw at this scale...
|
|
if (!flipped)
|
|
V_DrawFixedPatch(namex<<FRACBITS, namey<<FRACBITS, FRACUNIT/2, vflags, nametagline, cm);
|
|
|
|
V_DrawStretchyFixedPatch(((namex+vid.dup*3)<<FRACBITS), namey<<FRACBITS,
|
|
tagwidthsmall<<FRACBITS, FRACUNIT/2, vflags, nametagpic, cm, 0);
|
|
|
|
namex += vid.dup*2;
|
|
namey -= vid.dup*4;
|
|
}
|
|
|
|
if (cv_nametagfacerank.value)
|
|
{
|
|
V_DrawFixedPatch(namex<<FRACBITS, (namey - icon->height/2)<<FRACBITS, FRACUNIT/2, vflags, icon, cm);
|
|
namex += vid.dup*(1+icon->width/2); // add offset to other stuff
|
|
}
|
|
|
|
//Name
|
|
V_DrawSmallString(namex, namey, V_ALLOWLOWERCASE | vflags, tag);
|
|
|
|
if (usenametagrestat)
|
|
{
|
|
V_DrawSmallString(namex, namey - vid.dup*5, vflags, va("\x84S%d ", players[i].kartspeed));
|
|
V_DrawSmallString(namex + vid.dup*10, namey - vid.dup*5, vflags, va("\x87W%d ", players[i].kartweight));
|
|
}
|
|
|
|
if (cv_nametagscore.value)
|
|
{
|
|
INT32 yofs = usenametagrestat ? 10 : 5;
|
|
V_DrawSmallString(namex, namey - vid.dup*yofs, V_ALLOWLOWERCASE | vflags, va("\x8A%d ", players[i].score));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (cv_nametagfacerank.value)
|
|
tagwidth += vid.dup*(icon->width+1);
|
|
|
|
if (flipped)
|
|
{
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
V_DrawFill(namex, namey, vid.dup*3, vid.dup*4, 31 | vflags);
|
|
V_DrawFill(namex+vid.dup, namey, vid.dup, vid.dup*4, tagcolor | vflags);
|
|
namey += vid.dup*4;
|
|
namex += vid.dup;
|
|
}
|
|
|
|
namey -= vid.dup*3;
|
|
V_DrawFill(namex, namey+vid.dup*2, vid.dup, vid.dup, 31 | vflags); // a single black pixel
|
|
V_DrawFill(namex+vid.dup, namey, tagwidth, vid.dup*3, 31 | vflags);
|
|
V_DrawFill(namex+vid.dup, namey+vid.dup, tagwidth - vid.dup, vid.dup, tagcolor | vflags);
|
|
namex += vid.dup*2;
|
|
}
|
|
else
|
|
{
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
namey -= vid.dup*4;
|
|
V_DrawFill(namex, namey, vid.dup*3, vid.dup*4, 31 | vflags);
|
|
V_DrawFill(namex+vid.dup, namey, vid.dup, vid.dup*4, tagcolor | vflags);
|
|
namex += vid.dup;
|
|
}
|
|
|
|
V_DrawFill(namex, namey, vid.dup, vid.dup, 31 | vflags);
|
|
V_DrawFill(namex+vid.dup, namey, tagwidth - vid.dup*2, vid.dup*3, 31 | vflags);
|
|
V_DrawFill(namex+vid.dup, namey+vid.dup, tagwidth - vid.dup*3, vid.dup, tagcolor | vflags);
|
|
}
|
|
|
|
if (cv_nametagfacerank.value)
|
|
{
|
|
V_DrawMappedPatch(namex, namey - vid.dup*(icon->height+1), vflags, icon, cm);
|
|
namex += vid.dup*(icon->height+1); // add offset to other stuff
|
|
}
|
|
|
|
V_DrawThinString(namex, namey - vid.dup*10, V_ALLOWLOWERCASE | vflags, tag);
|
|
|
|
if (usenametagrestat)
|
|
{
|
|
V_DrawScaledPatch(namex, namey - vid.dup*20, vflags, nametagspeed);
|
|
V_DrawScaledPatch(namex + vid.dup*18, namey - vid.dup*20, vflags, nametagweight);
|
|
V_DrawString(namex + vid.dup*9, namey - vid.dup*19, V_ALLOWLOWERCASE | vflags, va("\x84%d ", players[i].kartspeed));
|
|
V_DrawString(namex + vid.dup*27, namey - vid.dup*19, V_ALLOWLOWERCASE | vflags, va("\x87%d ", players[i].kartweight));
|
|
}
|
|
|
|
if (cv_nametagscore.value)
|
|
{
|
|
INT32 yofs = usenametagrestat ? 25 : 15;
|
|
V_DrawSmallString(namex, namey - vid.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;
|
|
int i;
|
|
UINT8 *colormap = NULL;
|
|
|
|
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 const 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);
|
|
const SINT8 gaugestyle = K_GetDriftgaugeStyle();
|
|
|
|
basex = pos.x>>FRACBITS;
|
|
basey = pos.y>>FRACBITS;
|
|
|
|
switch (gaugestyle)
|
|
{
|
|
case GAUGE_DEFAULT:
|
|
case GAUGE_SMALL:
|
|
case GAUGE_EXTRA:
|
|
case GAUGE_BIGNUM:
|
|
{
|
|
patch_t *driftpatch = NULL;
|
|
|
|
if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM || gaugestyle == GAUGE_EXTRA)
|
|
{
|
|
barx = basex - vid.dup*23;
|
|
BAR_WIDTH = vid.dup*47;
|
|
}
|
|
else
|
|
{
|
|
barx = basex - vid.dup*12;
|
|
BAR_WIDTH = vid.dup*23;
|
|
}
|
|
|
|
bary = basey - vid.dup*2;
|
|
|
|
if (gaugestyle == GAUGE_EXTRA) // 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)) // We reuse the extra speedometer patch hence this check
|
|
{
|
|
colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
|
|
driftpatch = skp_smallstickerclr3;
|
|
}
|
|
else
|
|
driftpatch = skp_smallsticker3;
|
|
|
|
V_DrawStretchyFixedPatch((basex - vid.dup*30)<<FRACBITS, ((basey<<FRACBITS) - FixedMul(vid.dup<<FRACBITS, 21*FRACUNIT/10)), XTRA3PSCALE, XTRA3VSCALE, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap, 0);
|
|
}
|
|
else
|
|
{
|
|
if (K_UseColorHud()) // Colourized hud
|
|
{
|
|
colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
|
|
driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmallcolor : driftgaugecolor);
|
|
}
|
|
else
|
|
driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmall : driftgauge);
|
|
|
|
V_DrawMappedPatch(gaugestyle == GAUGE_SMALL ? basex + vid.dup*11 : basex, basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap);
|
|
}
|
|
|
|
if (driftcharge >= driftval*4) // rainbow sparks
|
|
{
|
|
colormap = R_GetTranslationColormap(TC_RAINBOW, K_RainbowColor(), GTC_CACHE);
|
|
|
|
for (i = 0; i < 4; i++)
|
|
V_DrawFill(barx, bary+vid.dup*1+vid.dup*i, BAR_WIDTH, vid.dup, (driftrainbow[min((leveltime % 18) + 1, 17)] + 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;
|
|
|
|
colormap = R_GetTranslationColormap(TC_RAINBOW, driftskins[driftlevel], GTC_CACHE);
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if (driftcharge >= driftval)
|
|
V_DrawFill(barx, bary+vid.dup*1+vid.dup*i, BAR_WIDTH, vid.dup, driftcolors[driftlevel-1][i] | V_NOSCALESTART|drifttrans);
|
|
|
|
V_DrawFill(barx, bary+vid.dup*1+vid.dup*i, width, vid.dup, driftcolors[driftlevel][i] | V_NOSCALESTART|drifttrans);
|
|
}
|
|
}
|
|
|
|
// right, also draw a cool number
|
|
if (gaugestyle == GAUGE_BIGNUM)
|
|
V_DrawPaddedTallColorNum(basex + (vid.dup*32), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, 3, colormap);
|
|
else
|
|
V_DrawPingNum((gaugestyle == GAUGE_SMALL ? basex + (vid.dup*22) : basex + (vid.dup*32)), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, colormap);
|
|
}
|
|
break;
|
|
case GAUGE_NUMONLY:
|
|
{
|
|
if (driftcharge >= driftval*4)
|
|
colormap = R_GetTranslationColormap(TC_RAINBOW, K_RainbowColor(), GTC_CACHE);
|
|
else
|
|
colormap = R_GetTranslationColormap(TC_RAINBOW, driftskins[driftlevel], GTC_CACHE);
|
|
|
|
V_DrawPaddedTallColorNum(basex + (vid.dup*16), basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftcharge*100 / driftval, 3, colormap);
|
|
}
|
|
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) + (160<<FRACBITS))>>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<<FRACBITS, basey<<FRACBITS, FRACUNIT, V_HUDTRANS|(splitscreen < 3 ? V_SNAPTORIGHT : 0)|V_SNAPTOBOTTOM, (splitscreen > 1 ? kp_wantedsplit : kp_wanted), colormap);
|
|
/*if (basey2)
|
|
V_DrawFixedPatch(basex<<FRACBITS, basey2<<FRACBITS, FRACUNIT, V_HUDTRANS|V_SNAPTOTOP, (splitscreen == 3 ? kp_wantedsplit : kp_wanted), colormap); // < used for 4p splits.*/
|
|
|
|
for (i = 0; i < numwanted; i++)
|
|
{
|
|
INT32 x = basex+(splitscreen > 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<<FRACBITS, y<<FRACBITS, FRACUNIT, V_HUDTRANS|(splitscreen < 3 ? V_SNAPTORIGHT : 0)|V_SNAPTOBOTTOM, (scale == FRACUNIT ? R_GetSkinFaceWant(p) : R_GetSkinFaceRank(p)), colormap);
|
|
/*if (basey2) // again with 4p stuff
|
|
V_DrawFixedPatch(x<<FRACBITS, (y - (basey-basey2))<<FRACBITS, FRACUNIT, V_HUDTRANS|V_SNAPTOTOP, (scale == FRACUNIT ? facewantprefix[p->skin] : facerankprefix[p->skin]), colormap);*/
|
|
}
|
|
}
|
|
}
|
|
|
|
static void K_drawKartPlayerCheck(void)
|
|
{
|
|
INT32 i;
|
|
UINT8 *colormap;
|
|
INT32 x;
|
|
|
|
if (!stplyr->mo || stplyr->spectator || stplyr->awayviewtics)
|
|
return;
|
|
|
|
if (camspin[0])
|
|
return;
|
|
|
|
const INT32 splitflags = K_calcSplitFlags(V_SNAPTOBOTTOM);
|
|
|
|
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 boolean K_useSmallMinimapHead(player_t *player)
|
|
{
|
|
return cv_minihead.value == 1 || (cv_minihead.value == 2 && !(player && P_IsDisplayPlayer(player)));
|
|
}
|
|
|
|
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 = NULL;
|
|
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)<<FRACBITS);
|
|
amypos = amnumypos + ((hudy + (AutomapPic->height-h)/2)<<FRACBITS);
|
|
|
|
if (cv_minihead.value && (scaleme))
|
|
{
|
|
amxpos += (w / 4)<<FRACBITS;
|
|
amypos += (h / 4)<<FRACBITS;
|
|
scale /= 2;
|
|
}
|
|
|
|
V_DrawBlendingFixedPatch(amxpos, amypos, scale, flags, icon, colormap, blend);
|
|
}
|
|
|
|
static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
|
|
{
|
|
// 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. Without
|
|
// it, they wouldn't 'spawn' on the top-right side of the HUD.
|
|
|
|
const skin_t *skin;
|
|
player_t *player = mo->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)];
|
|
|
|
if (minimaphead == NULL)
|
|
return;
|
|
|
|
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)<<FRACBITS);
|
|
amypos = amnumypos + ((y + (minimapinfo.minimap_pic->height-minimaphead->height) / 2)<<FRACBITS);
|
|
|
|
if (cv_showminimapnames.value && player && !(modeattacking || gamestate == GS_TIMEATTACK))
|
|
{
|
|
V_DrawCenteredSmallStringAtFixed(amxpos + (4*FRACUNIT), amypos - (3*FRACUNIT), V_ALLOWLOWERCASE|flags|V_SkinColorToHighlightcolor(mo->color), player_names[player - players]);
|
|
}
|
|
|
|
const boolean minihead = K_useSmallMinimapHead(mo->player);
|
|
|
|
// thx wanted reticle for having weird offsets very cool
|
|
wntdamxpos = minihead ? amxpos + (1<<FRACBITS) : amxpos - (4<<FRACBITS);
|
|
wntdamypos = minihead ? amypos + (1<<FRACBITS) : amypos - (4<<FRACBITS);
|
|
|
|
if (minihead)
|
|
{
|
|
amxpos += (minimaphead->width / 4)<<FRACBITS;
|
|
amypos += (minimaphead->height / 4)<<FRACBITS;
|
|
scale /= 2;
|
|
}
|
|
|
|
#ifdef ROTSPRITE
|
|
if (cv_spinoutroll.value && player && player->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 == 1) && !cv_showminimapnames.value) ? 8 : 10;
|
|
patch_t* minipatch = NULL;
|
|
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 = NULL;
|
|
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->color)
|
|
{
|
|
if (mobj->colorized)
|
|
{
|
|
colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
|
|
}
|
|
else
|
|
{
|
|
const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
|
|
|
|
// special case if startcolor is not the default (160 / Green)
|
|
if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
|
|
{
|
|
colormap = R_GetTranslationColormap(TC_DEFAULT, 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 = (patch_t *)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<<FRACBITS)/vid.dup);
|
|
xval = (kp_racefinish[pnum]->width<<FRACBITS);
|
|
x = (FixedMul(((TICRATE - stplyr->kartstuff[k_cardanimation])<<FRACBITS) - R_GetTimeFrac(RTF_LEVEL), xval > x ? xval : x))/TICRATE;
|
|
|
|
if (splitscreen && stplyrnum == 1)
|
|
x = -x;
|
|
|
|
V_DrawFixedPatch(x + (STCD_X<<FRACBITS) - (xval>>1),
|
|
(STCD_Y<<FRACBITS) - (kp_racefinish[pnum]->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_GetTimeFrac(RTF_LEVEL) * ((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<<FRACBITS, y, scale, splitflags, kp_battlewin, NULL);
|
|
else
|
|
V_DrawFixedPatch(x<<FRACBITS, y, scale, splitflags, (K_IsPlayerLosing(stplyr) ? kp_battlelose : kp_battlecool), NULL);
|
|
}
|
|
else
|
|
K_drawKartFinish();
|
|
}
|
|
else if (stplyr->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<<FRACBITS, y, scale, splitflags, kp_battleinfo, NULL);
|
|
else
|
|
V_DrawFixedPatch(x<<FRACBITS, y, scale, splitflags, kp_battlewait, NULL);
|
|
|
|
if (splitscreen > 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<<FRACBITS, ty<<FRACBITS, scale, 0, kp_timeoutstickerclr, colormap);
|
|
}
|
|
else
|
|
V_DrawFixedPatch(x<<FRACBITS, ty<<FRACBITS, scale, 0, kp_timeoutsticker, NULL);
|
|
|
|
V_DrawKartString(x-txoff, ty, 0, va("%d", stplyr->kartstuff[k_comebacktimer]/TICRATE));
|
|
}
|
|
}
|
|
|
|
if (netgame && cv_showfreeplay.value && !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.dup; // 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;
|
|
}
|
|
|
|
const INT32 driftcharge = stplyr->kartstuff[k_driftcharge];
|
|
|
|
// drift sparks!
|
|
if ((leveltime & 1) && driftcharge)
|
|
{
|
|
if (driftcharge >= dsthree)
|
|
colmap = R_GetTranslationColormap(TC_RAINBOW, K_RainbowColor(), GTC_CACHE);
|
|
else if (driftcharge >= dstwo)
|
|
colmap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_KETCHUP, GTC_CACHE);
|
|
else if (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][7];
|
|
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_GetTimeFrac(RTF_LEVEL) << (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)/200)+1; // was 125, do we need another toggle for this? Zzz...
|
|
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 = 32*(((progress - 76)*FRACUNIT) + R_GetTimeFrac(RTF_LEVEL));
|
|
slideout = max(0, slideout);
|
|
fixed_t slidein = 32*(((stplyr->kartstuff[k_lapanimation] - 76)*FRACUNIT) - R_GetTimeFrac(RTF_LEVEL));
|
|
slidein = max(0, slidein);
|
|
|
|
// 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_GetTimeFrac(RTF_LEVEL) - 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);
|
|
const size_t laplength = strlen(lapnum);
|
|
|
|
for (int i = 0; i < (int)laplength; 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 ((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_GetTimeFrac(RTF_LEVEL) << 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 && cv_showfreeplay.value && !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<<FRACBITS, y<<FRACBITS, FRACUNIT>>1, 0, facewantprefix[stplyr->skin], cm);
|
|
|
|
x += 16;
|
|
if (x > BASEVIDWIDTH-16)
|
|
{
|
|
x = 0;
|
|
y += 16;
|
|
}
|
|
}
|
|
}
|
|
}
|