thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
RingRacers/src/st_stuff.c
Oni 71588f490f Merge branch 'queue-skin' into 'master' 
Queued skin/color changes

See merge request KartKrew/Kart!2452
2024-09-28 17:46:42 +00:00

1647 lines
41 KiB
C
Raw Blame History

// DR. ROBOTNIK'S RING RACERS
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Kart Krew.
// Copyright (C) 2020 by Sonic Team Junior.
// Copyright (C) 2000 by DooM Legacy Team.
// Copyright (C) 1996 by id Software, Inc.
//
// 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 st_stuff.c
/// \brief Status bar code
/// Does the face/direction indicator animatin.
/// Does palette indicators as well (red pain/berserk, bright pickup)
#include "doomdef.h"
#include "g_game.h"
#include "r_local.h"
#include "p_local.h"
#include "f_finale.h"
#include "st_stuff.h"
#include "i_video.h"
#include "v_video.h"
#include "z_zone.h"
#include "hu_stuff.h"
#include "console.h"
#include "s_sound.h"
#include "i_system.h"
#include "k_menu.h"
#include "m_cheat.h"
#include "m_misc.h" // moviemode
#include "m_anigif.h" // cv_gif_downscale
#include "p_setup.h" // NiGHTS grading
#include "r_fps.h"
#include "m_random.h" // random index
#include "m_cond.h" // item finder
#ifdef HWRENDER
#include "hardware/hw_main.h"
#endif
#include "lua_hudlib_drawlist.h"
#include "lua_hud.h"
#include "lua_hook.h"
// SRB2Kart
#include "k_hud.h" // SRB2kart
#include "v_video.h"
#include "r_skins.h" // NUMFACES
#include "k_grandprix.h" // we need to know grandprix status for titlecards
#include "k_boss.h"
#include "k_zvote.h"
#include "music.h"
#include "i_sound.h"
#include "k_dialogue.h"
#include "m_easing.h"
UINT16 objectsdrawn = 0;
//
// STATUS BAR DATA
//
patch_t *faceprefix[MAXSKINS][NUMFACES];
// ------------------------------------------
// status bar overlay
// ------------------------------------------
// Midnight Channel:
static patch_t *hud_tv1;
static patch_t *hud_tv2;
#ifdef HAVE_DISCORDRPC
// Discord Rich Presence
static patch_t *envelope;
#endif
static huddrawlist_h luahuddrawlist_game;
static huddrawlist_h luahuddrawlist_titlecard;
//
// STATUS BAR CODE
//
boolean ST_SameTeam(player_t *a, player_t *b)
{
// Spectator chat.
if (a->spectator && b->spectator)
{
return true;
}
// Team chat.
if (G_GametypeHasTeams() == true)
{
// You get team messages if you're on the same team.
return (a->team == b->team);
}
// Not that everyone's not on the same team, but team messages go to normal chat if everyone's not in the same team.
return true;
}
static boolean st_stopped = true;
void ST_Ticker(boolean run)
{
if (st_stopped)
return;
if (run)
ST_runTitleCard();
}
// 0 is default, any others are special palettes.
INT32 st_palette = 0;
UINT32 st_translucency = 10;
fixed_t st_fadein = 0;
void ST_doPaletteStuff(void)
{
INT32 palette;
if (stplyr && stplyr->flashcount && cv_reducevfx.value == 0)
palette = stplyr->flashpal;
else
palette = 0;
#ifdef HWRENDER
if (rendermode == render_opengl)
palette = 0; // No flashpals here in OpenGL
#endif
if (palette != st_palette)
{
st_palette = palette;
if (rendermode == render_soft)
{
//V_SetPaletteLump(GetPalette()); // Reset the palette -- is this needed?
if (!r_splitscreen)
V_SetPalette(palette);
}
}
}
void ST_UnloadGraphics(void)
{
Patch_FreeTag(PU_HUDGFX);
}
void ST_LoadGraphics(void)
{
// SRB2 border patch
// st_borderpatchnum = W_GetNumForName("GFZFLR01");
// scr_borderpatch = W_CacheLumpNum(st_borderpatchnum, PU_HUDGFX);
// the original Doom uses 'STF' as base name for all face graphics
// Graue 04-08-2004: face/name graphics are now indexed by skins
// but load them in R_AddSkins, that gets called
// first anyway
// cache the status bar overlay icons (fullscreen mode)
K_LoadKartHUDGraphics();
K_UpdateMidVotePatches();
// Midnight Channel:
HU_UpdatePatch(&hud_tv1, "HUD_TV1");
HU_UpdatePatch(&hud_tv2, "HUD_TV2");
#ifdef HAVE_DISCORDRPC
// Discord Rich Presence
HU_UpdatePatch(&envelope, "K_REQUES");
#endif
}
// made separate so that skins code can reload custom face graphics
void ST_LoadFaceGraphics(INT32 skinnum)
{
#define FACE_MAX (FACE_MINIMAP+1)
spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
spriteframe_t *sprframe;
UINT8 i = 0, maxer = min(sprdef->numframes, FACE_MAX);
while (i < maxer)
{
sprframe = &sprdef->spriteframes[i];
faceprefix[skinnum][i] = W_CachePatchNum(sprframe->lumppat[0], PU_HUDGFX);
i++;
}
if (i < FACE_MAX)
{
patch_t *missing = W_CachePatchName("MISSING", PU_HUDGFX);
while (i < FACE_MAX)
{
faceprefix[skinnum][i] = missing;
i++;
}
}
#undef FACE_MAX
}
void ST_ReloadSkinFaceGraphics(void)
{
INT32 i;
for (i = 0; i < numskins; i++)
ST_LoadFaceGraphics(i);
}
static inline void ST_InitData(void)
{
// 'link' the statusbar display to a player, which could be
// another player than consoleplayer, for example, when you
// change the view in a multiplayer demo with F12.
stplyr = &players[displayplayers[0]];
st_palette = -1;
}
static inline void ST_Stop(void)
{
if (st_stopped)
return;
#ifdef HWRENDER
if (rendermode != render_opengl)
#endif
V_SetPalette(0);
st_stopped = true;
}
void ST_Start(void)
{
if (!st_stopped)
ST_Stop();
ST_InitData();
if (!dedicated)
st_stopped = false;
}
//
// Initializes the status bar, sets the defaults border patch for the window borders.
//
// used by OpenGL mode, holds lumpnum of flat used to fill space around the viewwindow
lumpnum_t st_borderpatchnum;
void ST_Init(void)
{
if (dedicated)
return;
ST_LoadGraphics();
luahuddrawlist_game = LUA_HUD_CreateDrawList();
luahuddrawlist_titlecard = LUA_HUD_CreateDrawList();
}
// change the status bar too, when pressing F12 while viewing a demo.
void ST_changeDemoView(void)
{
// the same routine is called at multiplayer deathmatch spawn
// so it can be called multiple times
ST_Start();
}
// =========================================================================
// STATUS BAR OVERLAY
// =========================================================================
boolean st_overlay;
/*
static INT32 SCZ(INT32 z)
{
return FixedInt(FixedMul(z<<FRACBITS, vid.fdupy));
}
*/
/*
static INT32 SCY(INT32 y)
{
//31/10/99: fixed by Hurdler so it _works_ also in hardware mode
// do not scale to resolution for hardware accelerated
// because these modes always scale by default
y = SCZ(y); // scale to resolution
if (splitscreen)
{
y >>= 1;
if (stplyr != &players[displayplayers[0]])
y += vid.height / 2;
}
return y;
}
*/
/*
static INT32 STRINGY(INT32 y)
{
//31/10/99: fixed by Hurdler so it _works_ also in hardware mode
// do not scale to resolution for hardware accelerated
// because these modes always scale by default
if (splitscreen)
{
y >>= 1;
if (stplyr != &players[displayplayers[0]])
y += BASEVIDHEIGHT / 2;
}
return y;
}
*/
/*
static INT32 SPLITFLAGS(INT32 f)
{
// Pass this V_SNAPTO(TOP|BOTTOM) and it'll trim them to account for splitscreen! -Red
if (splitscreen)
{
if (stplyr != &players[displayplayers[0]])
f &= ~V_SNAPTOTOP;
else
f &= ~V_SNAPTOBOTTOM;
}
return f;
}
*/
/*
static INT32 SCX(INT32 x)
{
return FixedInt(FixedMul(x<<FRACBITS, vid.fdupx));
}
*/
#if 0
static INT32 SCR(INT32 r)
{
fixed_t y;
//31/10/99: fixed by Hurdler so it _works_ also in hardware mode
// do not scale to resolution for hardware accelerated
// because these modes always scale by default
y = FixedMul(r*FRACUNIT, vid.fdupy); // scale to resolution
if (splitscreen)
{
y >>= 1;
if (stplyr != &players[displayplayers[0]])
y += vid.height / 2;
}
return FixedInt(FixedDiv(y, vid.fdupy));
}
#endif
// =========================================================================
// INTERNAL DRAWING
// =========================================================================
// Devmode information
static void ST_pushRow(INT32 *height)
{
*height -= 4;
}
static void ST_pushDebugString(INT32 *height, const char *string)
{
V_DrawRightAlignedSmallString(319, *height, V_MONOSPACE, string);
ST_pushRow(height);
}
static void ST_pushDebugStringHighlighted(INT32 *height, const char *string)
{
V_DrawRightAlignedSmallString(319, *height, V_MONOSPACE | V_YELLOWMAP, string);
ST_pushRow(height);
}
static void ST_pushDebugTimeMS(INT32 *height, const char *label, UINT32 ms)
{
ST_pushDebugString(height, va("%s%02d:%05.2f", label,
ms / 60000, ms % 60000 / 1000.f));
}
static void ST_drawMusicDebug(INT32 *height)
{
const char *mname = Music_CurrentSong();
boolean looping = Music_CanLoop(Music_CurrentId());
UINT8 i = 0;
const musicdef_t *def;
const char *format;
ST_pushDebugString(height, va(" Tune: %8s", Music_CurrentId()));
ST_pushRow(height);
if (!strcmp(mname, ""))
{
ST_pushDebugString(height, "Song: <NOTHING>");
return;
}
def = S_FindMusicDef(mname, &i);
format = I_SongType();
ST_pushDebugTimeMS(height, " Elapsed: ", I_GetSongPosition());
ST_pushDebugTimeMS(height, looping
? " Loop B: "
: "Duration: ", I_GetSongLength());
if (looping)
{
ST_pushDebugTimeMS(height, " Loop A: ", I_GetSongLoopPoint());
}
ST_pushRow(height);
if (format)
{
ST_pushDebugString(height, va(" Format: %8s", I_SongType()));
}
ST_pushDebugString(height, va(" Song: %8s", mname));
if (def)
{
ST_pushRow(height);
if (def->debug_volume != 0)
{
ST_pushDebugStringHighlighted(height, va("Debug Volume: %4d/100", def->debug_volume));
}
ST_pushDebugString(height, va(" Volume: %4d/100", def->volume));
}
}
static void ST_drawRenderDebug(INT32 *height)
{
const struct RenderStats *i = &g_renderstats;
ST_pushDebugString(height, va(" Visplanes: %4s", sizeu1(i->visplanes)));
ST_pushDebugString(height, va(" Drawsegs: %4s", sizeu1(i->drawsegs)));
ST_pushRow(height);
ST_pushDebugString(height, va("Skybox Portals: %4s", sizeu1(i->skybox_portals)));
}
static void ST_drawDemoDebug(INT32 *height)
{
if (!demo.recording && !demo.playback)
return;
size_t needle = demo.buffer->p - demo.buffer->buffer;
size_t size = demo.buffer->size;
double percent = (double)needle / size * 100.0;
double avg = (double)needle / leveltime;
ST_pushDebugString(height, va("%s/%s bytes", sizeu1(needle), sizeu2(size)));
ST_pushDebugString(height, va(
"%.2f/%.2f MB %5.2f%%",
needle / (1024.0 * 1024.0),
size / (1024.0 * 1024.0),
percent
));
ST_pushDebugString(height, va(
"%.2f KB/s (ETA %.2f minutes)",
avg * TICRATE / 1024.0,
(size - needle) / (avg * TICRATE * 60.0)
));
ST_pushDebugString(height, va("Demo %04x (%s)", demo.version, demo.recording ? "recording" : "playback"));
}
void ST_drawDebugInfo(void)
{
INT32 height = 192;
const UINT8 screen = min(r_splitscreen, cv_devmode_screen.value - 1);
// devmode_screen = 1..4
stplyr = &players[displayplayers[screen]];
if (!stplyr->mo)
return;
if (cv_ticrate.value)
{
height -= 20;
}
// was cv_showping compensation
height -= 20;
if (cht_debug & DBG_BASIC)
{
camera_t *cam = &camera[screen];
if (stplyr->spectator || cam->freecam)
{
const fixed_t a = AngleFixed(cam->angle);
fixed_t p = AngleFixed(cam->aiming);
if (p > (180 * FRACUNIT))
{
p = -((360 * FRACUNIT) - p);
}
V_DrawRightAlignedString(320, height - 32, V_MONOSPACE, va("X: %6d", cam->x>>FRACBITS));
V_DrawRightAlignedString(320, height - 24, V_MONOSPACE, va("Y: %6d", cam->y>>FRACBITS));
V_DrawRightAlignedString(320, height - 16, V_MONOSPACE, va("Z: %6d", cam->z>>FRACBITS));
V_DrawRightAlignedString(320, height - 8, V_MONOSPACE, va("A: %6d", FixedInt(a)));
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("P: %6d", FixedInt(p)));
height -= 48;
}
else
{
const fixed_t d = AngleFixed(stplyr->mo->angle);
V_DrawRightAlignedString(320, height - 24, V_MONOSPACE, va("X: %6d", stplyr->mo->x>>FRACBITS));
V_DrawRightAlignedString(320, height - 16, V_MONOSPACE, va("Y: %6d", stplyr->mo->y>>FRACBITS));
V_DrawRightAlignedString(320, height - 8, V_MONOSPACE, va("Z: %6d", stplyr->mo->z>>FRACBITS));
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("A: %6d", FixedInt(d)));
height -= 40;
}
}
if (cht_debug & DBG_DETAILED)
{
//V_DrawRightAlignedString(320, height - 104, V_MONOSPACE, va("SHIELD: %5x", stplyr->powers[pw_shield]));
V_DrawRightAlignedString(320, height - 96, V_MONOSPACE, va("SCALE: %5d%%", (stplyr->mo->scale*100)/FRACUNIT));
//V_DrawRightAlignedString(320, height - 88, V_MONOSPACE, va("DASH: %3d/%3d", stplyr->dashspeed>>FRACBITS, FixedMul(stplyr->maxdash,stplyr->mo->scale)>>FRACBITS));
//V_DrawRightAlignedString(320, height - 80, V_MONOSPACE, va("AIR: %4d, %3d", stplyr->powers[pw_underwater], stplyr->powers[pw_spacetime]));
// Flags
//V_DrawRightAlignedString(304-64, height - 72, V_MONOSPACE, "Flags:");
//V_DrawString(304-60, height - 72, (stplyr->jumping) ? V_GREENMAP : V_REDMAP, "JM");
//V_DrawString(304-40, height - 72, (stplyr->pflags & PF_JUMPED) ? V_GREENMAP : V_REDMAP, "JD");
//V_DrawString(304-20, height - 72, (stplyr->pflags & PF_SPINNING) ? V_GREENMAP : V_REDMAP, "SP");
//V_DrawString(304, height - 72, (stplyr->pflags & PF_STARTDASH) ? V_GREENMAP : V_REDMAP, "ST");
V_DrawRightAlignedString(320, height - 64, V_MONOSPACE, va("CEILZ: %6d", stplyr->mo->ceilingz>>FRACBITS));
V_DrawRightAlignedString(320, height - 56, V_MONOSPACE, va("FLOORZ: %6d", stplyr->mo->floorz>>FRACBITS));
V_DrawRightAlignedString(320, height - 48, V_MONOSPACE, va("CNVX: %6d", stplyr->cmomx>>FRACBITS));
V_DrawRightAlignedString(320, height - 40, V_MONOSPACE, va("CNVY: %6d", stplyr->cmomy>>FRACBITS));
V_DrawRightAlignedString(320, height - 32, V_MONOSPACE, va("PLTZ: %6d", stplyr->mo->pmomz>>FRACBITS));
V_DrawRightAlignedString(320, height - 24, V_MONOSPACE, va("MOMX: %6d", stplyr->rmomx>>FRACBITS));
V_DrawRightAlignedString(320, height - 16, V_MONOSPACE, va("MOMY: %6d", stplyr->rmomy>>FRACBITS));
V_DrawRightAlignedString(320, height - 8, V_MONOSPACE, va("MOMZ: %6d", stplyr->mo->momz>>FRACBITS));
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("SPEED: %6d", stplyr->speed>>FRACBITS));
height -= 120;
}
if (cht_debug & DBG_RNG) // randomizer testing
{
// TODO: this only accounts for the undefined class,
// which should be phased out as much as possible anyway.
// Figure out some other way to display all of the RNG classes.
fixed_t peekres = P_RandomPeek(PR_UNDEFINED);
V_DrawRightAlignedString(320, height - 16, V_MONOSPACE, va("Init: %08x", P_GetInitSeed(PR_UNDEFINED)));
V_DrawRightAlignedString(320, height - 8, V_MONOSPACE, va("Seed: %08x", P_GetRandSeed(PR_UNDEFINED)));
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("== : %08x", peekres));
height -= 32;
}
if (cht_debug & DBG_MUSIC)
{
ST_drawMusicDebug(&height);
}
if (cht_debug & DBG_RENDER)
{
ST_drawRenderDebug(&height);
}
if (cht_debug & DBG_DEMO)
{
ST_drawDemoDebug(&height);
}
if (cht_debug & DBG_MEMORY)
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("Heap used: %7sKB", sizeu1(Z_TagsUsage(0, INT32_MAX)>>10)));
}
tic_t lt_ticker = 0, lt_lasttic = 0;
tic_t lt_exitticker = 0, lt_endtime = 0;
tic_t lt_fade = 0;
// SRB2KART: HUD shit for new titlecards:
static patch_t *tcchev1;
static patch_t *tcchev2;
static patch_t *tcol1;
static patch_t *tcol2;
static patch_t *tcroundbar;
static patch_t *tcround;
static patch_t *tcbonus;
static patch_t *tccircletop;
static patch_t *tccirclebottom;
static patch_t *tccirclebg;
static patch_t *tcbanner;
static patch_t *tcbanner2;
static patch_t *tcroundnum[10], *tsroundnum[10];
static patch_t *tcroundbonus, *tsroundbonus;
static patch_t *tcactnum[10];
static patch_t *tcact;
static patch_t *twarn[2];
static patch_t *ttext[2];
// some coordinates define to make my life easier....
#define FINAL_ROUNDX (24)
#define FINAL_EGGY (160)
#define FINAL_ROUNDY (16)
#define FINAL_BANNERY (160)
INT32 chev1x, chev1y, chev2x, chev2y, chevtflag;
INT32 roundx, roundy;
INT32 bannerx, bannery;
INT32 roundnumx, roundnumy;
INT32 eggx1, eggx2, eggy1, eggy2;
// These are all arbitrary values found by trial and error trying to align the hud lmao.
// But they'll work.
#define BASE_CHEV1X (252)
#define BASE_CHEV1Y (60)
#define BASE_CHEV2X (65)
#define BASE_CHEV2Y (135)
#define TTANIMTHRESHOLD (TICRATE)
#define TTFADESTART (TTANIMTHRESHOLD-4)
#define TTANIMSTART (TTANIMTHRESHOLD-16)
#define TTANIMENDTHRESHOLD (TICRATE*3)
#define TTANIMEND (TICRATE*4)
//
// Load the graphics for the title card.
// Don't let LJ see this
//
static void ST_cacheLevelTitle(void)
{
UINT8 i;
char buf[9];
// SRB2KART
tcchev1 = (patch_t *)W_CachePatchName("TCCHEV1W", PU_HUDGFX);
tcchev2 = (patch_t *)W_CachePatchName("TCCHEV2W", PU_HUDGFX);
tcol1 = (patch_t *)W_CachePatchName("TCCHOL1", PU_HUDGFX);
tcol2 = (patch_t *)W_CachePatchName("TCCHOL2", PU_HUDGFX);
tcroundbar = (patch_t *)W_CachePatchName("TCBB0", PU_HUDGFX);
tcround = (patch_t *)W_CachePatchName("TCROUND", PU_HUDGFX);
tcbonus = (patch_t *)W_CachePatchName("TCBONUS", PU_HUDGFX);
tccircletop = (patch_t *)W_CachePatchName("TCSN1", PU_HUDGFX);
tccirclebottom =(patch_t *)W_CachePatchName("TCSN2", PU_HUDGFX);
tccirclebg = (patch_t *)W_CachePatchName("TCEG3", PU_HUDGFX);
tcbanner = (patch_t *)W_CachePatchName("TCBSKA0", PU_HUDGFX);
tcbanner2 = (patch_t *)W_CachePatchName("TCBC0", PU_HUDGFX);
tcact = (patch_t *)W_CachePatchName("TT_ACT", PU_HUDGFX);
twarn[0] = (patch_t *)W_CachePatchName("K_BOSW01", PU_HUDGFX);
twarn[1] = (patch_t *)W_CachePatchName("K_BOSW02", PU_HUDGFX);
ttext[0] = (patch_t *)W_CachePatchName("K_BOST01", PU_HUDGFX);
ttext[1] = (patch_t *)W_CachePatchName("K_BOST02", PU_HUDGFX);
// Cache round #
for (i=1; i <= 10; i++)
{
sprintf(buf, "TT_RND%d", i);
tcroundnum[i-1] = (patch_t *)W_CachePatchName(buf, PU_HUDGFX);
}
tcroundbonus = (patch_t *)W_CachePatchName("TT_RNDX", PU_HUDGFX);
for (i=1; i <= 10; i++)
{
sprintf(buf, "TT_RNS%d", i);
tsroundnum[i-1] = (patch_t *)W_CachePatchName(buf, PU_HUDGFX);
}
tsroundbonus = (patch_t *)W_CachePatchName("TT_RNSX", PU_HUDGFX);
// Cache act #
for (i=0; i < 10; i++)
{
sprintf(buf, "TT_ACT%d", i);
tcactnum[i] = (patch_t *)W_CachePatchName(buf, PU_HUDGFX);
}
}
//
// Start the title card.
//
void ST_startTitleCard(void)
{
// cache every HUD patch used
ST_cacheLevelTitle();
// Set most elements to start off-screen, ST_runTitleCard will have them slide in afterwards
chev1x = BASE_CHEV1X +350; // start off-screen
chev1y = BASE_CHEV1Y;
chev2x = BASE_CHEV2X -350; // start off-screen
chev2y = BASE_CHEV2Y;
chevtflag = 0;
roundx = -999;
roundy = -999;
roundnumx = -999;
roundnumy = -999;
eggx1 = -999;
eggx2 = -999;
eggy1 = -999;
eggy2 = -999;
bannery = 300;
// initialize HUD variables
lt_ticker = lt_exitticker = lt_lasttic = 0;
lt_endtime = 4*TICRATE; // + (10*NEWTICRATERATIO);
lt_fade = 0;
}
//
// What happens before drawing the title card.
// Which is just setting the HUD translucency.
//
void ST_preDrawTitleCard(void)
{
if (!G_IsTitleCardAvailable())
return;
if (lt_ticker >= (lt_endtime + TICRATE))
return;
// Kart: nothing
}
patch_t *ST_getRoundPicture(boolean small)
{
patch_t *roundico = NULL;
if (roundqueue.position > 0 && roundqueue.position <= roundqueue.size)
{
if (roundqueue.entries[roundqueue.position-1].overridden == true)
{
roundico = small ? tsroundbonus : tcroundbonus;
}
else if (grandprixinfo.gp == true && grandprixinfo.eventmode != GPEVENT_NONE)
{
const char *gppic = (small ? gametypes[gametype]->gppicmini : gametypes[gametype]->gppic);
if (gppic[0])
roundico = W_CachePatchName(gppic, PU_PATCH);
else
roundico = tcroundbonus;
}
else if (roundqueue.roundnum > 0 && roundqueue.roundnum <= 10)
{
patch_t **source = small ? tsroundnum : tcroundnum;
roundico = source[roundqueue.roundnum-1];
}
}
return roundico;
}
//
// Run the title card.
// Called from ST_Ticker.
//
void ST_runTitleCard(void)
{
boolean run = !(paused || P_AutoPause() || g_fast_forward > 0);
INT32 auxticker;
boolean doroundicon = (ST_getRoundPicture(false) != NULL);
if (run && lt_fade < 16)
{
lt_fade++;
}
if (!G_IsTitleCardAvailable())
return;
if (lt_ticker >= (lt_endtime + TICRATE))
return;
if (run || (lt_ticker < PRELEVELTIME))
{
// tick
lt_ticker++;
// SRB2KART
// side Zig-Zag positions...
if (K_CheckBossIntro() == true)
{
// Handle name info...
if (bossinfo.enemyname)
{
UINT32 len = strlen(bossinfo.enemyname)+1;
if (len > 1 && bossinfo.titleshow < len)
{
len = (lt_endtime-(TICRATE/2))/len;
if (lt_ticker % len == 0)
{
char c = toupper(bossinfo.enemyname[bossinfo.titleshow]);
bossinfo.titleshow++;
c -= LT_FONTSTART;
if (c < 0 || c >= LT_FONTSIZE || !fontv[GTFN_FONT].font[(INT32)c] || !bossinfo.titlesound)
{
;
}
else
{
S_StartSound(NULL, bossinfo.titlesound);
}
}
}
}
// No matter the circumstances, scroll the WARN...
{
patch_t *localwarn = twarn[encoremode ? 1 : 0];
patch_t *localtext = ttext[encoremode ? 1 : 0];
if (localwarn->width)
{
bannerx = ((lt_ticker*2)%(localwarn->width));
}
if (localtext->width)
{
bannery = -((lt_ticker*4)%(localtext->width));
}
}
if (run && lt_ticker < PRELEVELTIME)
{
lt_fade--;
}
}
else
{
// LEVEL FADE
if (run && lt_ticker < TTFADESTART)
{
lt_fade--; // don't fade yet
}
// TITLECARD START
if (lt_ticker < TTANIMSTART)
{
chev1x = max(BASE_CHEV1X, (BASE_CHEV1X +350) - (INT32)(lt_ticker)*50);
chev2x = min(BASE_CHEV2X, (BASE_CHEV2X -350) + (INT32)(lt_ticker)*50);
}
// OPEN ZIG-ZAGS 1 SECOND IN
if (lt_ticker > TTANIMTHRESHOLD)
{
auxticker = (INT32)(lt_ticker) - TTANIMTHRESHOLD;
chev1x = min(320, BASE_CHEV1X + auxticker*16);
chev1y = max(0, BASE_CHEV1Y - auxticker*16);
chev2x = max(0, BASE_CHEV2X - auxticker*16);
chev2y = min(200, BASE_CHEV2Y + auxticker*16);
// translucent fade after opening up.
chevtflag = min(5, ((auxticker)/5)) << V_ALPHASHIFT;
// OPEN ZIG-ZAG: END OF ANIMATION (they leave the screen borders)
if (lt_ticker > TTANIMENDTHRESHOLD)
{
auxticker = (INT32)lt_ticker - TTANIMENDTHRESHOLD;
chev1x += auxticker*16;
chev1y -= auxticker*16;
chev2x -= auxticker*16;
chev2y += auxticker*16;
}
}
// ROUND BAR + EGG
eggy1 = FINAL_EGGY; // Make sure to reset that each call so that Y position doesn't go bonkers
// SLIDE BAR IN, SLIDE "ROUND" DOWNWARDS
if (lt_ticker <= TTANIMTHRESHOLD)
{
INT32 interptimer = (INT32)lt_ticker - TTANIMSTART;
// INT32 because tic_t is unsigned and we want this to be potentially negative
if (interptimer >= 0)
{
INT32 interpdiff = ((TTANIMTHRESHOLD-TTANIMSTART) - interptimer);
interpdiff *= interpdiff; // interpdiff^2
roundx = FINAL_ROUNDX - interpdiff;
roundy = FINAL_ROUNDY - interpdiff;
eggy1 = FINAL_EGGY + interpdiff;
}
}
// SLIDE BAR OUT, SLIDE "ROUND" DOWNWARDS FASTER
else if (lt_ticker >= TTANIMENDTHRESHOLD)
{
auxticker = (INT32)lt_ticker - TTANIMENDTHRESHOLD;
roundx = FINAL_ROUNDX - auxticker*24;
roundy = FINAL_ROUNDY + auxticker*48;
eggy1 = FINAL_EGGY + auxticker*48;
}
// follow the round bar.
eggx1 = roundx + tcroundbar->width/2;
// initially, both halves are on the same coordinates.
eggx2 = eggx1;
eggy2 = eggy1;
// same for the background (duh)
roundnumx = eggx1;
roundnumy = eggy1;
// split both halves of the egg, but only do that in grand prix!
if (doroundicon && lt_ticker > TTANIMTHRESHOLD + TICRATE/2)
{
auxticker = (INT32)lt_ticker - (TTANIMTHRESHOLD + TICRATE/2);
eggx1 -= auxticker*12;
eggy1 -= auxticker*12;
eggx2 += auxticker*12;
eggy2 += auxticker*12;
}
// SCROLLING BOTTOM BANNER
// SLIDE BANNER UPWARDS WITH A FUNNY BOUNCE (this requires trig :death:)
if (lt_ticker < TTANIMTHRESHOLD)
{
INT32 costimer = (INT32)lt_ticker - TTANIMSTART;
// INT32 because tic_t is unsigned and we want this to be potentially negative
if (costimer > 0)
{
// For this animation, we're going to do a tiny bit of stupid trigonometry.
// Admittedly all of this is going to look like magic numbers, and honestly? They are.
// start at angle 355 (where y = ~230 with our params)
// and go to angle 131 (where y = ~160 with our params)
UINT8 basey = 190;
UINT8 amplitude = 45;
fixed_t ang = (355 - costimer*14)*FRACUNIT;
bannery = basey + (amplitude * FINECOSINE(FixedAngle(ang)>>ANGLETOFINESHIFT)) / FRACUNIT;
}
}
// SLIDE BANNER DOWNWARDS OUT OF THE SCREEN AT THE END
else if (lt_ticker >= TTANIMENDTHRESHOLD)
{
auxticker = (INT32)lt_ticker - TTANIMENDTHRESHOLD;
bannery = FINAL_BANNERY + auxticker*16;
}
// No matter the circumstances, scroll the banner...
bannerx = -((lt_ticker*2)%(tcbanner->width));
}
// used for hud slidein
if (lt_ticker >= lt_endtime)
lt_exitticker++;
}
}
//
// Draw the title card itself.
//
void ST_drawTitleCard(void)
{
char *lvlttl = mapheaderinfo[gamemap-1]->lvlttl;
char *zonttl = mapheaderinfo[gamemap-1]->zonttl; // SRB2kart
UINT8 actnum = mapheaderinfo[gamemap-1]->actnum;
INT32 acttimer;
fixed_t actscale;
angle_t fakeangle;
INT32 pad = ((vid.width/vid.dupx) - BASEVIDWIDTH)/2;
INT32 bx = bannerx; // We need to make a copy of that otherwise pausing will cause problems.
if (!G_IsTitleCardAvailable())
return;
if (!LUA_HudEnabled(hud_stagetitle))
goto luahook;
if (lt_ticker >= (lt_endtime + TICRATE))
goto luahook;
if ((lt_ticker-lt_lasttic) > 1)
lt_ticker = lt_lasttic+1;
// Avoid HOMs while drawing the start of the titlecard
if (lt_ticker < TTANIMSTART)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, levelfadecol);
if (K_CheckBossIntro() == true)
{
// WARNING!
// https://twitter.com/matthewseiji/status/1485003284196716544
// the above tweet is directly responsible for the existence of bosses in this game at all
{
#define LOTIME 5
#define HITIME 15
patch_t *localwarn;
INT32 transp;
boolean encorehack = ((levelfadecol == 0) && lt_ticker <= PRELEVELTIME+4);
#define DRAWBOSSWARN(pat) \
localwarn = pat[encoremode ? 1 : 0];\
\
if ((localwarn->width > 0) && (lt_ticker + (HITIME-transp) <= lt_endtime)) \
{ \
if (transp > HITIME-1)\
{ \
transp = HITIME-1; \
} \
\
transp = (((10*transp)/HITIME)<<V_ALPHASHIFT) | (encorehack ? V_SUBTRACT : V_ADD); \
\
while (bx > -pad) \
bx -= localwarn->width; \
while (bx < BASEVIDWIDTH+pad) \
{ \
V_DrawFixedPatch(bx*FRACUNIT, 60*FRACUNIT, FRACUNIT, V_SNAPTOLEFT|transp, localwarn, NULL); \
bx += localwarn->width; \
} \
}
transp = (lt_ticker+HITIME) % (LOTIME+HITIME);
DRAWBOSSWARN(twarn);
transp = (lt_ticker+HITIME+3) % (LOTIME+HITIME);
bx = bannery;
DRAWBOSSWARN(ttext);
#undef DRAWBOSSWARN
#undef LOTIME
#undef HITIME
}
// Everything else...
if (bossinfo.enemyname)
{
bx = V_TitleCardStringWidth(bossinfo.enemyname, false);
// Name.
V_DrawTitleCardString((BASEVIDWIDTH - bx)/2, 80, bossinfo.enemyname, 0, true, bossinfo.titleshow, lt_exitticker, false);
// Under-bar.
{
angle_t fakeang = 0;
fixed_t scalex = FRACUNIT;
// Handle scaling.
if (lt_ticker <= 3)
{
fakeang = (lt_ticker*ANGLE_45)/2;
scalex = FINESINE(fakeang>>ANGLETOFINESHIFT);
}
else if (lt_exitticker > 1)
{
if (lt_exitticker <= 4)
{
fakeang = ((lt_exitticker-1)*ANGLE_45)/2;
scalex = FINECOSINE(fakeang>>ANGLETOFINESHIFT);
}
else
{
scalex = 0;
}
}
// Handle subtitle.
else if (bossinfo.subtitle && lt_ticker >= TICRATE/2)
{
INT32 by = 80+32;
if (lt_ticker == TICRATE/2 || lt_exitticker == 1)
{
;
}
else if (lt_ticker == (TICRATE/2)+1 || lt_ticker == lt_endtime)
{
by += 3;
}
else
{
by += 5;
}
V_DrawRightAlignedThinString((BASEVIDWIDTH+bx)/2, by, V_FORCEUPPERCASE, bossinfo.subtitle);
}
// Now draw the under-bar itself.
if (scalex > 0)
{
bx = FixedMul(bx, scalex);
V_DrawFill((BASEVIDWIDTH-(bx+2))/2, 80+32, bx+2, 3, 31);
V_DrawFill((BASEVIDWIDTH-(bx))/2, 80+32+1, bx, 1, 0);
}
}
}
lt_lasttic = lt_ticker;
goto luahook;
}
// Background zig-zags
V_DrawFixedPatch((chev1x)*FRACUNIT, (chev1y)*FRACUNIT, FRACUNIT, chevtflag, tcchev1, NULL);
V_DrawFixedPatch((chev2x)*FRACUNIT, (chev2y)*FRACUNIT, FRACUNIT, chevtflag, tcchev2, NULL);
patch_t *roundico = ST_getRoundPicture(false);
// Draw ROUND bar, scroll it downwards.
V_DrawFixedPatch(roundx*FRACUNIT, ((-32) + (lt_ticker%32))*FRACUNIT, FRACUNIT, V_SNAPTOTOP|V_SNAPTOLEFT, tcroundbar, NULL);
// Draw ROUND text
if (roundico)
{
V_DrawFixedPatch((roundx+10)*FRACUNIT, roundy*FRACUNIT, FRACUNIT, V_SNAPTOTOP|V_SNAPTOLEFT,
((grandprixinfo.gp && grandprixinfo.eventmode != GPEVENT_NONE) ? tcbonus : tcround),
NULL);
}
// round num background
V_DrawFixedPatch(roundnumx*FRACUNIT, roundnumy*FRACUNIT, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTOLEFT, tccirclebg, NULL);
// Scrolling banner
if (tcbanner->width > 0)
{
while (bx > -pad)
bx -= tcbanner->width;
while (bx < BASEVIDWIDTH+pad)
{
V_DrawFixedPatch(bx*FRACUNIT, (bannery)*FRACUNIT, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTOLEFT, tcbanner, NULL);
bx += tcbanner->width;
}
}
// If possible, draw round number/icon
if (roundico)
{
V_DrawFixedPatch(roundnumx*FRACUNIT, roundnumy*FRACUNIT, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTOLEFT, roundico, NULL);
}
// Draw both halves of the egg
V_DrawFixedPatch(eggx1*FRACUNIT, eggy1*FRACUNIT, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTOLEFT, tccircletop, NULL);
V_DrawFixedPatch(eggx2*FRACUNIT, eggy2*FRACUNIT, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTOLEFT, tccirclebottom, NULL);
// Now the level name.
V_DrawTitleCardString((actnum) ? 265 : 280, 60, lvlttl, V_SNAPTORIGHT, false, lt_ticker, TTANIMENDTHRESHOLD, false);
if (!(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
V_DrawTitleCardString((actnum) ? 265 : 280, 60+32, strlen(zonttl) ? zonttl : "ZONE", V_SNAPTORIGHT, false, lt_ticker - strlen(lvlttl), TTANIMENDTHRESHOLD, false);
// the act has a similar graphic animation, but we'll handle it here since it's only like 2 graphics lmfao.
if (actnum && actnum < 10)
{
// compute delay before the act should appear.
acttimer = lt_ticker - strlen(lvlttl);
if (!(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
acttimer -= strlen((strlen(zonttl)) ? (zonttl) : ("ZONE"));
actscale = 0;
fakeangle = 0;
if (acttimer >= 0)
{
if (acttimer < TTANIMENDTHRESHOLD) // spin in
{
fakeangle = min(360 + 90, acttimer*41) * ANG1;
actscale = FINESINE(fakeangle>>ANGLETOFINESHIFT);
}
else // spin out
{
// Make letters disappear...
acttimer -= TTANIMENDTHRESHOLD;
fakeangle = max(0, (360+90) - acttimer*41)*ANG1;
actscale = FINESINE(fakeangle>>ANGLETOFINESHIFT);
}
if (actscale)
{
// draw the top:
V_DrawStretchyFixedPatch(286*FRACUNIT, 76*FRACUNIT, abs(actscale), FRACUNIT, V_SNAPTORIGHT|(actscale < 0 ? V_FLIP : 0), tcact, NULL);
V_DrawStretchyFixedPatch(286*FRACUNIT, 123*FRACUNIT, abs(actscale), FRACUNIT, V_SNAPTORIGHT|(actscale < 0 ? V_FLIP : 0), tcactnum[actnum], NULL);
}
}
}
lt_lasttic = lt_ticker;
luahook:
if (renderisnewtic)
{
LUA_HUD_ClearDrawList(luahuddrawlist_titlecard);
LUA_HookHUD(luahuddrawlist_titlecard, HUD_HOOK(titlecard));
}
LUA_HUD_DrawList(luahuddrawlist_titlecard);
}
// Clear defined coordinates, we don't need them anymore
#undef FINAL_ROUNDX
#undef FINAL_EGGY
#undef FINAL_ROUNDY
#undef FINAL_BANNERY
#undef BASE_CHEV1X
#undef BASE_CHEV1Y
#undef BASE_CHEV2X
#undef BASE_CHEV2Y
#undef TTANIMTHRESHOLD
#undef TTANIMSTART
#undef TTANIMENDTHRESHOLD
#undef TTANIMEND
//
// Drawer for G_PreLevelTitleCard.
//
void ST_preLevelTitleCardDrawer(void)
{
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, levelfadecol);
ST_drawTitleCard();
I_OsPolling();
I_UpdateNoBlit();
}
//
// Draw the status bar overlay, customisable: the user chooses which
// kind of information to overlay
//
static void ST_overlayDrawer(void)
{
const UINT8 viewnum = R_GetViewNumber();
// hu_showscores = auto hide score/time/rings when tab rankings are shown
if (!(hu_showscores && (netgame || multiplayer)))
{
K_drawKartHUD();
if (renderisnewtic)
{
LUA_HookHUD(luahuddrawlist_game, HUD_HOOK(game));
}
if (cv_showviewpointtext.value)
{
if (!demo.attract && !P_IsPartyPlayer(stplyr) && !camera[viewnum].freecam)
{
if (r_splitscreen <= 1)
{
INT32 flags = V_SNAPTOBOTTOM | V_SPLITSCREEN | V_HUDTRANS;
INT32 x = BASEVIDWIDTH/2;
INT32 y = (BASEVIDHEIGHT / (r_splitscreen + 1)) - 34;
INT32 width = 50;
const char *text = player_names[stplyr-players];
int font = KART_FONT;
fixed_t textwidth = V_StringScaledWidth(FRACUNIT, FRACUNIT, FRACUNIT, flags, font, text);
fixed_t threshold = textwidth;
// k_drawKartHUD
if (gametyperules & GTR_CIRCUIT)
threshold = 200*FRACUNIT;
else if (gametyperules & GTR_BUMPERS)
threshold = 100*FRACUNIT;
if (LUA_HudEnabled(hud_gametypeinfo) && textwidth > threshold)
{
y += 5;
font = TINY_FONT;
textwidth = V_StringScaledWidth(FRACUNIT, FRACUNIT, FRACUNIT, flags, font, text);
}
if (r_splitscreen)
{
flags = (flags & ~V_ALPHAMASK) | V_HUDTRANSHALF;
y += 4;
}
else
{
V_DrawFill(x - width/2, y + 6, width, 2, flags | 31);
V_DrawCenteredThinString(x, y, flags | V_ORANGEMAP, "Watching");
}
V_DrawStringScaled(x*FRACUNIT - textwidth/2, (y+10)*FRACUNIT,
FRACUNIT, FRACUNIT, FRACUNIT, flags, NULL, font, text);
}
else
{
INT32 y = BASEVIDHEIGHT/2 - 12;
INT32 f = V_HUDTRANSHALF|V_SNAPTOBOTTOM|V_SPLITSCREEN;
const char *s = player_names[stplyr-players];
if (viewnum & 1)
V_DrawThinString(12, y, f|V_SNAPTOLEFT, s);
else
V_DrawRightAlignedThinString(BASEVIDWIDTH/2 - 12, y, f|V_SNAPTORIGHT, s);
}
}
}
}
K_DrawMidVote();
}
// MayonakaStatic: draw Midnight Channel's TV-like borders
static void ST_MayonakaStatic(void)
{
INT32 flag = (leveltime%2) ? V_90TRANS : V_70TRANS;
V_DrawFixedPatch(0, 0, FRACUNIT, V_SNAPTOTOP|V_SNAPTOLEFT|flag, hud_tv1, NULL);
V_DrawFixedPatch(320<<FRACBITS, 0, FRACUNIT, V_SNAPTOTOP|V_SNAPTORIGHT|V_FLIP|flag, hud_tv1, NULL);
V_DrawFixedPatch(0, 142<<FRACBITS, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTOLEFT|flag, hud_tv2, NULL);
V_DrawFixedPatch(320<<FRACBITS, 142<<FRACBITS, FRACUNIT, V_SNAPTOBOTTOM|V_SNAPTORIGHT|V_FLIP|flag, hud_tv2, NULL);
}
#ifdef HAVE_DISCORDRPC
void ST_AskToJoinEnvelope(void)
{
const tic_t freq = TICRATE/2;
if (menuactive)
return;
if ((leveltime % freq) < freq/2)
return;
V_DrawFixedPatch(296*FRACUNIT, 2*FRACUNIT, FRACUNIT, V_SNAPTOTOP|V_SNAPTORIGHT, envelope, NULL);
// maybe draw number of requests with V_DrawPingNum ?
}
#endif
static INT32 ST_ServerSplash_OpacityFlag(INT32 opacity)
{
if (opacity >= NUMTRANSMAPS)
{
return 0;
}
opacity = max(opacity, 1);
return (NUMTRANSMAPS - opacity) << V_ALPHASHIFT;
}
void ST_DrawServerSplash(boolean timelimited)
{
static const fixed_t SPLASH_LEN = (FRACUNIT * TICRATE) * 3;
static const fixed_t SPLASH_WAIT = (FRACUNIT * TICRATE) / 2;
static fixed_t splashTime = -SPLASH_WAIT;
static char prevContext[8] = {0};
if (memcmp(prevContext, server_context, 8) != 0)
{
// Context changed, we want to draw it again
splashTime = -SPLASH_WAIT;
memcpy(prevContext, server_context, 8);
}
if (lt_ticker < lt_endtime)
{
// Level title is running rn
return;
}
if (timelimited
&& splashTime >= SPLASH_LEN)
{
// We finished drawing it
return;
}
splashTime += renderdeltatics;
if (splashTime <= 0)
{
// We're waiting a tiny bit to draw it
return;
}
const INT32 splashTic = splashTime >> FRACBITS;
INT32 opacity = NUMTRANSMAPS;
if (splashTic < NUMTRANSMAPS)
{
opacity = splashTic;
}
else if (timelimited
&& splashTic > (SPLASH_LEN >> FRACBITS) - NUMTRANSMAPS)
{
opacity = (SPLASH_LEN >> FRACBITS) - splashTic;
}
INT32 opacityFlag = ST_ServerSplash_OpacityFlag(opacity);
patch_t *gridPatch = W_CachePatchName("MOTDBG", PU_CACHE);
if (gridPatch && gridPatch->width)
{
fixed_t gridX = -(splashTime / 3) % (gridPatch->width * FRACUNIT);
fixed_t gridY = (gridPatch->height) * FRACUNIT;
INT32 gridOpacity = ST_ServerSplash_OpacityFlag(opacity / 2);
fixed_t maxX = (vid.width * FRACUNIT) / vid.dupx;
while (gridX < maxX)
{
V_DrawFixedPatch(
gridX, gridY,
FRACUNIT,
(V_SNAPTOLEFT|V_SNAPTOTOP) | V_SUBTRACT | V_VFLIP | gridOpacity,
gridPatch,
NULL
);
gridX += (gridPatch->width * FRACUNIT);
}
}
// We're a bit crunched atm to do this but hopefully in the future
// the icon can be made a bmp file on the hard drive that the server
// sends on client join instead.
patch_t *iconPatch = W_CachePatchName("MOTDICON", PU_CACHE);
fixed_t iconX = (BASEVIDWIDTH - 16 - iconPatch->width) * FRACUNIT;
fixed_t iconY = (8) * FRACUNIT;
V_DrawFixedPatch(
iconX, iconY,
FRACUNIT,
(V_SNAPTORIGHT|V_SNAPTOTOP) | opacityFlag,
iconPatch,
NULL
);
fixed_t textX = (BASEVIDWIDTH - 16 - 36) * FRACUNIT;
fixed_t textY = (24 - 8) * FRACUNIT;
fixed_t textW = V_StringScaledWidth(
FRACUNIT, FRACUNIT, FRACUNIT,
(V_SNAPTORIGHT|V_SNAPTOTOP) | opacityFlag,
MED_FONT,
connectedservername
);
V_DrawStringScaled(
textX - textW, textY,
FRACUNIT, FRACUNIT, FRACUNIT,
(V_SNAPTORIGHT|V_SNAPTOTOP) | opacityFlag,
NULL,
MED_FONT,
connectedservername
);
textY += 10*FRACUNIT;
if (connectedservercontact[0] != 0)
{
V_DrawRightAlignedThinStringAtFixed(
textX, textY,
(V_SNAPTORIGHT|V_SNAPTOBOTTOM) | opacityFlag,
va("Contact @ %c%s", '\x80' + cv_shoutcolor.value, connectedservercontact)
);
}
}
void ST_DrawSaveReplayHint(INT32 flags)
{
K_DrawGameControl(
BASEVIDWIDTH - 2, 2, 0,
(demo.willsave && demo.titlename[0]) ? "Replay will be saved. <b> Change title" : "<b> or <x> Save replay",
2, 0, flags|V_YELLOWMAP
);
}
static fixed_t ST_CalculateFadeIn(player_t *player)
{
const tic_t length = TICRATE/4;
if (player->tally.hudSlide != 0)
{
tic_t timer = length - player->tally.hudSlide;
fixed_t f = timer * FRACUNIT;
// Not interpolated at very beginning or end
if (timer > 0 && timer < length)
{
f += FRACUNIT - rendertimefrac;
}
return f / length;
}
tic_t timer = lt_exitticker;
if (K_CheckBossIntro() == true || G_IsTitleCardAvailable() == false)
{
if (timeinmap <= 16)
timer = 0;
else
timer = timeinmap-16;
}
if (timer < length)
{
fixed_t f = timer * FRACUNIT;
// Not interpolated at very beginning
if (timer > 0)
{
f += rendertimefrac;
}
return f / length;
}
// Not interpolated at very end
return FRACUNIT;
}
void ST_Drawer(void)
{
boolean stagetitle = false; // Decide whether to draw the stage title or not
// Doom's status bar only updated if necessary.
// However, ours updates every frame regardless, so the "refresh" param was removed
//(void)refresh;
// force a set of the palette by using doPaletteStuff()
if (vid.recalc)
st_palette = -1;
// Do red-/gold-shifts from damage/items
#ifdef HWRENDER
//25/08/99: Hurdler: palette changes is done for all players,
// not only player1! That's why this part
// of code is moved somewhere else.
if (rendermode == render_soft)
#endif
if (rendermode != render_none) ST_doPaletteStuff();
fixed_t localfadein[MAXSPLITSCREENPLAYERS];
// HUD fading for anything not tied to a single player,
// i.e. the minimap. Since individual splitscreen
// players' HUDs may fade away before other's, use the
// the last one remaining.
{
fixed_t maxFade = 0;
UINT8 i;
for (i = 0; i <= r_splitscreen; i++)
{
localfadein[i] = ST_CalculateFadeIn(&players[displayplayers[i]]);
if (localfadein[i] > maxFade)
{
maxFade = localfadein[i];
}
}
st_translucency = FixedMul(10, maxFade);
}
// Check for a valid level title
// If the HUD is enabled
// And, if Lua is running, if the HUD library has the stage title enabled
if ((stagetitle = (G_IsTitleCardAvailable() && *mapheaderinfo[gamemap-1]->lvlttl != '\0' && !(hu_showscores && (netgame || multiplayer)))))
ST_preDrawTitleCard();
if (st_overlay)
{
UINT8 i;
if (renderisnewtic)
{
LUA_HUD_ClearDrawList(luahuddrawlist_game);
}
// No deadview!
for (i = 0; i <= r_splitscreen; i++)
{
stplyr = &players[displayplayers[i]];
st_fadein = localfadein[i];
R_SetViewContext(VIEWCONTEXT_PLAYER1 + i);
R_InterpolateView(rendertimefrac); // to assist with object tracking
ST_overlayDrawer();
}
LUA_HUD_DrawList(luahuddrawlist_game);
// draw Midnight Channel's overlay ontop
if (mapheaderinfo[gamemap-1]->typeoflevel & TOL_TV) // Very specific Midnight Channel stuff.
ST_MayonakaStatic();
}
// See d_main.c and V_DrawCustomFadeScreen for the hacks that prevents this being here
/*if (lt_fade < 16)
{
// Level fade-in
V_DrawCustomFadeScreen(((levelfadecol == 0) ? "FADEMAP1" : "FADEMAP0"), 31-(lt_fade*2));
}*/
if (stagetitle)
ST_drawTitleCard();
K_DrawDialogue();
// Replay manual-save stuff
if (demo.recording && multiplayer && demo.savebutton && demo.savebutton + 3*TICRATE < leveltime)
{
tic_t fadeLength = TICRATE;
tic_t t = leveltime - (demo.savebutton + 3*TICRATE);
INT32 flags = V_SNAPTOTOP | V_SNAPTORIGHT |
(Easing_Linear(min(t, fadeLength) * FRACUNIT / fadeLength, 9, 0) << V_ALPHASHIFT);
ST_DrawSaveReplayHint(flags);
}
}
Reference in a new issue View git blame Copy permalink