/// \file  k_menudraw.c
/// \brief SRB2Kart's menu drawer functions

#ifdef __GNUC__
#include <unistd.h>
#endif

#include "k_menu.h"

#include "doomdef.h"
#include "d_main.h"
#include "d_netcmd.h"
#include "console.h"
#include "r_local.h"
#include "hu_stuff.h"
#include "g_game.h"
#include "g_input.h"
#include "m_argv.h"

// Data.
#include "sounds.h"
#include "s_sound.h"
#include "i_system.h"

// Addfile
#include "filesrch.h"

#include "v_video.h"
#include "i_video.h"
#include "keys.h"
#include "z_zone.h"
#include "w_wad.h"
#include "p_local.h"
#include "p_setup.h"
#include "f_finale.h"

#ifdef HWRENDER
#include "hardware/hw_main.h"
#endif

#include "d_net.h"
#include "mserv.h"
#include "m_misc.h"
#include "m_anigif.h"
#include "byteptr.h"
#include "st_stuff.h"
#include "i_sound.h"
#include "k_kart.h"
#include "k_hud.h"
#include "k_follower.h"
#include "d_player.h" // KITEM_ constants
#include "doomstat.h" // MAXSPLITSCREENPLAYERS
#include "k_grandprix.h" // K_CanChangeRules
#include "k_rank.h" // K_GetGradeColor
#include "k_zvote.h" // K_GetMidVoteLabel
#include "k_boss.h"

#include "y_inter.h" // Y_RoundQueueDrawer

#include "i_joy.h" // for joystick menu controls

// Condition Sets
#include "m_cond.h"

// Sound Test
#include "music.h"

// And just some randomness for the exits.
#include "m_random.h"

#include "i_time.h"
#include "m_easing.h"
#include "sanitize.h"

#ifdef PC_DOS
#include <stdio.h> // for snprintf
int	snprintf(char *str, size_t n, const char *fmt, ...);
//int	vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
#endif

#ifdef HAVE_DISCORDRPC
#include "discord.h"
#endif

fixed_t M_TimeFrac(tic_t tics, tic_t duration)
{
	return tics < duration ? (tics * FRACUNIT + rendertimefrac_unpaused) / duration : FRACUNIT;
}

fixed_t M_ReverseTimeFrac(tic_t tics, tic_t duration)
{
	return FRACUNIT - M_TimeFrac(duration - tics, duration);
}

fixed_t M_DueFrac(tic_t start, tic_t duration)
{
	tic_t t = I_GetTime();
	tic_t n = t - start;
	return M_TimeFrac(min(n, duration), duration);
}

#define SKULLXOFF -32
#define LINEHEIGHT 13
#define STRINGHEIGHT 9
#define FONTBHEIGHT 20
#define SMALLLINEHEIGHT 9
#define SLIDER_RANGE 10
#define SLIDER_WIDTH (8*SLIDER_RANGE+6)
#define SERVERS_PER_PAGE 11


// horizontally centered text
static void M_CentreText(INT32 xoffs, INT32 y, const char *string)
{
	INT32 x;
	//added : 02-02-98 : centre on 320, because V_DrawString centers on vid.width...
	x = ((BASEVIDWIDTH - V_MenuStringWidth(string, 0))>>1) + xoffs;
	V_DrawMenuString(x,y,0,string);
}

static INT32 M_SliderX(INT32 range)
{
	if (range < 0)
		range = 0;
	if (range > 100)
		range = 100;

	return -4 + (((SLIDER_RANGE)*8 + 4)*range)/100;
}

//  A smaller 'Thermo', with range given as percents (0-100)
static void M_DrawSlider(INT32 x, INT32 y, const consvar_t *cv, boolean ontop)
{
	x = BASEVIDWIDTH - x - SLIDER_WIDTH;
	V_DrawFill(x - 5, y + 3, SLIDER_WIDTH + 3, 5, 31);
	V_DrawFill(x - 4, y + 4, SLIDER_WIDTH, 2, orangemap[0]);

	if (ontop)
	{
		V_DrawMenuString(x - 16 - (skullAnimCounter/5), y,
			highlightflags, "\x1C"); // left arrow
		V_DrawMenuString(x+(SLIDER_RANGE*8) + 8 + (skullAnimCounter/5), y,
			highlightflags, "\x1D"); // right arrow
	}

	INT32 range = cv->PossibleValue[1].value - cv->PossibleValue[0].value;
	INT32 val = atoi(cv->defaultvalue);

	val = (val - cv->PossibleValue[0].value) * 100 / range;
	// draw the default tick
	V_DrawFill(x + M_SliderX(val), y + 2, 3, 4, 31);

	val = (cv->value - cv->PossibleValue[0].value) * 100 / range;
	INT32 px = x + M_SliderX(val);

	// draw the slider cursor
	V_DrawFill(px - 1, y - 1, 5, 11, 31);
	V_DrawFill(px, y, 2, 8, aquamap[0]);
}

void M_DrawCursorHand(INT32 x, INT32 y)
{
	V_DrawScaledPatch(x - 24 - (I_GetTime() % 16 < 8), y, 0, W_CachePatchName("M_CURSOR", PU_CACHE));
}

void M_DrawUnderline(INT32 left, INT32 right, INT32 y)
{
	if (menutransition.tics == menutransition.dest)
		V_DrawFill(left - 1, y + 5, (right - left) + 11, 2, 31);
}

static patch_t *addonsp[NUM_EXT+5];

static INT16 bgMapID = NEXTMAP_INVALID;
void M_PickMenuBGMap(void)
{
	UINT16 *allowedMaps;
	size_t allowedMapsCount = 0;
	UINT16 ret = 0;
	INT32 i;

	allowedMaps = Z_Malloc(nummapheaders * sizeof(UINT16), PU_STATIC, NULL);

	for (i = 0; i < nummapheaders; i++)
	{
		if (mapheaderinfo[i] == NULL || mapheaderinfo[i]->lumpnum == LUMPERROR)
		{
			// Doesn't exist?
			continue;
		}

		if (mapheaderinfo[i]->thumbnailPic == NULL)
		{
			// No image...
			continue;
		}

		if ((mapheaderinfo[i]->typeoflevel & (TOL_SPECIAL|TOL_VERSUS)) != 0)
		{
			// Don't spoil Special or Versus.
			continue;
		}

		if ((mapheaderinfo[i]->menuflags & LF2_HIDEINMENU) == LF2_HIDEINMENU)
		{
			// "Hide in menu"... geddit?!
			continue;
		}

		if (!(mapheaderinfo[i]->menuflags & LF2_NOVISITNEEDED)
		&& !(mapheaderinfo[i]->records.mapvisited & MV_VISITED)
		&& !(
			mapheaderinfo[i]->cup
			&& mapheaderinfo[i]->cup->cachedlevels[0] == i
		))
		{
			// Not visited OR head of cup
			continue;
		}

		if (M_MapLocked(i + 1) == true)
		{
			// We haven't earned this one.
			continue;
		}

		// Got past the gauntlet, so we can allow this one.
		allowedMaps[ allowedMapsCount++ ] = i;
	}

	if (allowedMapsCount > 0)
	{
		ret = allowedMaps[ M_RandomKey(allowedMapsCount) ];
	}
	Z_Free(allowedMaps);

	bgMapID = ret;
}

static fixed_t bgText1Scroll = 0;
static fixed_t bgText2Scroll = 0;
static fixed_t bgImageScroll = 0;
static char bgImageName[9];

#define MENUBG_TEXTSCROLL 6
#define MENUBG_IMAGESCROLL 36

void M_UpdateMenuBGImage(boolean forceReset)
{
	char oldName[9];

	memcpy(oldName, bgImageName, 9);

	if (currentMenu->menuitems[itemOn].patch)
	{
		sprintf(bgImageName, "%s", currentMenu->menuitems[itemOn].patch);
	}
	else
	{
		sprintf(bgImageName, "MENUI000");
	}

	if (forceReset == false && strcmp(bgImageName, oldName))
	{
		bgImageScroll = (3 * BASEVIDWIDTH) * (FRACUNIT / 4);
	}

	if (forceReset == true)
	{
		M_PickMenuBGMap();
	}
}

void M_DrawMenuBackground(void)
{
	patch_t *text1 = W_CachePatchName("MENUBGT1", PU_CACHE);
	patch_t *text2 = W_CachePatchName("MENUBGT2", PU_CACHE);

	fixed_t text1loop = SHORT(text1->height)*FRACUNIT;
	fixed_t text2loop = SHORT(text2->width)*FRACUNIT;

	if (bgMapID >= nummapheaders)
	{
		M_PickMenuBGMap();
	}

	patch_t *bgMapImage = mapheaderinfo[bgMapID]->thumbnailPic;
	if (bgMapImage == NULL)
	{
		bgMapImage = W_CachePatchName("MENUBG4", PU_CACHE);
	}

	V_DrawFixedPatch(0, 0, FRACUNIT, 0, bgMapImage, R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_SLATE, GTC_MENUCACHE));
	V_DrawFixedPatch(0, 0, FRACUNIT, V_ADD, W_CachePatchName("MENUCUTD", PU_CACHE), NULL);
	V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("MENUCUT", PU_CACHE), NULL);

	V_DrawFixedPatch(-bgImageScroll, 0, FRACUNIT, 0, W_CachePatchName("MENUBG1", PU_CACHE), NULL);
	V_DrawFixedPatch(-bgImageScroll, 0, FRACUNIT, 0, W_CachePatchName(bgImageName, PU_CACHE), NULL);

	V_DrawFixedPatch(0, (BASEVIDHEIGHT + 16) * FRACUNIT, FRACUNIT, V_SUBTRACT, W_CachePatchName("MENUBG2", PU_CACHE), NULL);

	V_DrawFixedPatch(8 * FRACUNIT, -bgText1Scroll,
		FRACUNIT, V_SUBTRACT, text1, NULL);
	V_DrawFixedPatch(8 * FRACUNIT, -bgText1Scroll + text1loop,
		FRACUNIT, V_SUBTRACT, text1, NULL);

	V_DrawFixedPatch(-bgText2Scroll, (BASEVIDHEIGHT-8) * FRACUNIT,
		FRACUNIT, V_ADD, text2, NULL);
	V_DrawFixedPatch(-bgText2Scroll + text2loop, (BASEVIDHEIGHT-8) * FRACUNIT,
		FRACUNIT, V_ADD, text2, NULL);

	if (renderdeltatics > 2*FRACUNIT)
		return; // wipe hitch...

	bgText1Scroll += (MENUBG_TEXTSCROLL*renderdeltatics);
	while (bgText1Scroll > text1loop)
		bgText1Scroll -= text1loop;

	bgText2Scroll += (MENUBG_TEXTSCROLL*renderdeltatics);
	while (bgText2Scroll > text2loop)
		bgText2Scroll -= text2loop;

	if (bgImageScroll > 0)
	{
		bgImageScroll -= (MENUBG_IMAGESCROLL*renderdeltatics);
		if (bgImageScroll < 0)
		{
			bgImageScroll = 0;
		}
	}
}

void M_DrawExtrasBack(void)
{
	patch_t *bg = W_CachePatchName("M_XTRABG", PU_CACHE);
	V_DrawFixedPatch(0, 0, FRACUNIT, 0, bg, NULL);
}

UINT16 M_GetCvPlayerColor(UINT8 pnum)
{
	if (pnum >= MAXSPLITSCREENPLAYERS)
		return SKINCOLOR_NONE;

	UINT16 color = cv_playercolor[pnum].value;
	if (color != SKINCOLOR_NONE)
		return color;

	INT32 skin = R_SkinAvailableEx(cv_skin[pnum].string, false);
	if (skin == -1)
		return SKINCOLOR_NONE;

	return skins[skin].prefcolor;
}

static void M_DrawMenuParty(void)
{
	const INT32 PLATTER_WIDTH = 19;
	const INT32 PLATTER_STAGGER = 6;
	const INT32 PLATTER_OFFSET = (PLATTER_WIDTH - PLATTER_STAGGER);

	patch_t *small = W_CachePatchName("MENUPLRA", PU_CACHE);
	patch_t *large = W_CachePatchName("MENUPLRB", PU_CACHE);

	INT32 x, y;
	INT32 skin;
	UINT16 color;
	UINT8 *colormap;

	if (setup_numplayers == 0 || currentMenu == &PLAY_CharSelectDef || currentMenu == &MISC_ChallengesDef)
	{
		return;
	}

	x = 2;
	y = BASEVIDHEIGHT - small->height - 2;

	// Despite the work put into it, can't use M_GetCvPlayerColor directly - we need to reference skin always.
	#define grab_skin_and_colormap(pnum) \
	{ \
		skin = R_SkinAvailableEx(cv_skin[pnum].string, false); \
		color = cv_playercolor[pnum].value; \
		if (skin == -1) \
			skin = 0; \
		if (color == SKINCOLOR_NONE) \
			color = skins[skin].prefcolor; \
		colormap = R_GetTranslationColormap(skin, color, GTC_MENUCACHE); \
	}

	switch (setup_numplayers)
	{
		case 1:
		{
			x -= 8;
			V_DrawScaledPatch(x, y, 0, small);

			grab_skin_and_colormap(0);

			V_DrawMappedPatch(x + 22, y + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);
			break;
		}
		case 2:
		{
			x -= 8;
			V_DrawScaledPatch(x, y, 0, small);
			V_DrawScaledPatch(x + PLATTER_OFFSET, y - PLATTER_STAGGER, 0, small);

			grab_skin_and_colormap(1);

			V_DrawMappedPatch(x + PLATTER_OFFSET + 22, y - PLATTER_STAGGER + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);

			grab_skin_and_colormap(0);

			V_DrawMappedPatch(x + 22, y + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);
			break;
		}
		case 3:
		{
			V_DrawScaledPatch(x, y, 0, large);
			V_DrawScaledPatch(x + PLATTER_OFFSET, y - PLATTER_STAGGER, 0, small);

			grab_skin_and_colormap(1);

			V_DrawMappedPatch(x + PLATTER_OFFSET + 22, y - PLATTER_STAGGER + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);

			grab_skin_and_colormap(0);

			V_DrawMappedPatch(x + 12, y - 2, 0, faceprefix[skin][FACE_MINIMAP], colormap);

			grab_skin_and_colormap(2);

			V_DrawMappedPatch(x + 22, y + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);
			break;
		}
		case 4:
		{
			V_DrawScaledPatch(x, y, 0, large);
			V_DrawScaledPatch(x + PLATTER_OFFSET, y - PLATTER_STAGGER, 0, large);

			grab_skin_and_colormap(1);

			V_DrawMappedPatch(x + PLATTER_OFFSET + 12, y - PLATTER_STAGGER - 2, 0, faceprefix[skin][FACE_MINIMAP], colormap);

			grab_skin_and_colormap(0);

			V_DrawMappedPatch(x + 12, y - 2, 0, faceprefix[skin][FACE_MINIMAP], colormap);

			grab_skin_and_colormap(3);

			V_DrawMappedPatch(x + PLATTER_OFFSET + 22, y - PLATTER_STAGGER + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);

			grab_skin_and_colormap(2);

			V_DrawMappedPatch(x + 22, y + 8, 0, faceprefix[skin][FACE_MINIMAP], colormap);
			break;
		}
		default:
		{
			return;
		}
	}

	#undef grab_skin_and_color

	x += PLATTER_WIDTH;
	y += small->height;
	V_DrawScaledPatch(x + 16, y - 12, 0, W_CachePatchName(va("OPPRNK0%d", setup_numplayers % 10), PU_CACHE));
}

void M_DrawMenuForeground(void)
{
	if (gamestate == GS_MENU)
	{
		M_DrawMenuParty();
	}

	// draw non-green resolution border
	if ((!menuactive || currentMenu != &PAUSE_PlaybackMenuDef) && // this obscures replay menu and I want to put in minimal effort to fix that
		((vid.width % BASEVIDWIDTH != 0) || (vid.height % BASEVIDHEIGHT != 0)))
	{
		V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("WEIRDRES", PU_CACHE), NULL);
	}
}

//
// M_DrawMenuTooltips
//
// Draw a banner across the top of the screen, with a description of the current option displayed
//
static void M_DrawMenuTooltips(void)
{
	if (currentMenu->menuitems[itemOn].tooltip != NULL)
	{
		V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("MENUHINT", PU_CACHE), NULL);
		V_DrawCenteredThinString(BASEVIDWIDTH/2, 12, 0, currentMenu->menuitems[itemOn].tooltip);
	}
}

static const char *M_MenuTypingCroppedString(void)
{
	static char buf[36];
	const char *p = menutyping.cache;
	size_t n = strlen(p);
	if (n > sizeof buf)
	{
		p += n - sizeof buf;
		n = sizeof buf;
	}
	memcpy(buf, p, n);
	buf[n] = '\0';
	return buf;
}

// Draws the typing submenu
static void M_DrawMenuTyping(void)
{
	const UINT8 pid = 0;

	INT32 i, j;

	INT32 x, y;

	char buf[8];	// We write there to use drawstring for convenience.

	V_DrawFadeScreen(31, (menutyping.menutypingfade+1)/2);

	// Draw the string we're editing at the top.

	const INT32 boxwidth = (8*(MAXSTRINGLENGTH + 1)) + 7;
	x = (BASEVIDWIDTH - boxwidth)/2;
	y = 80;
	if (menutyping.menutypingfade < 9)
		y += floor(pow(2, (double)(9 - menutyping.menutypingfade)));
	else
		y += (9-menutyping.menutypingfade);

	if (currentMenu->menuitems[itemOn].text)
	{
		V_DrawThinString(x + 5, y - 2, highlightflags, currentMenu->menuitems[itemOn].text);
	}

	M_DrawMenuTooltips();

	//M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);
	V_DrawFill(x + 5, y + 4 + 5, boxwidth - 8, 8+6, 159);

	V_DrawFill(x + 4, y + 4 + 4, boxwidth - 6, 1, 121);
	V_DrawFill(x + 4, y + 4 + 5 + 8 + 6, boxwidth - 6, 1, 121);

	V_DrawFill(x + 4, y + 4 + 5, 1, 8+6, 121);
	V_DrawFill(x + 5 + boxwidth - 8, y + 4 + 5, 1, 8+6, 121);

	INT32 textwidth = M_DrawCaretString(x + 8, y + 12, M_MenuTypingCroppedString(), true);
	if (skullAnimCounter < 4
		&& menutyping.menutypingclose == false
		&& menutyping.menutypingfade == (menutyping.keyboardtyping ? 9 : 18))
	{
		V_DrawCharacter(x + 8 + textwidth, y + 12 + 1, '_', false);
	}

	const INT32 buttonwidth = ((boxwidth + 1)/NUMVIRTUALKEYSINROW);
#define BUTTONHEIGHT (11)

	// Now the keyboard itself
	x += 5;
	INT32 returnx = x;

	if (menutyping.menutypingfade > 9)
	{
		y += 26;

		if (menutyping.menutypingfade < 18)
		{
			y += floor(pow(2, (double)(18 - menutyping.menutypingfade))); // double yoffs for animation
		}

		INT32 tempkeyboardx = menutyping.keyboardx;

		while (virtualKeyboard[menutyping.keyboardy][tempkeyboardx] == 1
		&& tempkeyboardx > 0)
			tempkeyboardx--;

		for (i = 0; i < 5; i++)
		{
			j = 0;
			while (j < NUMVIRTUALKEYSINROW)
			{
				INT32 mflag = 0;
				INT16 c = virtualKeyboard[i][j];

				INT32 buttonspacing = 1;

				UINT8 col = 27;

				INT32 arrowoffset = 0;

				while (j + buttonspacing < NUMVIRTUALKEYSINROW
				&& virtualKeyboard[i][j + buttonspacing] == 1)
				{
					buttonspacing++;
				}

				if (menutyping.keyboardshift ^ menutyping.keyboardcapslock)
					c = shift_virtualKeyboard[i][j];

				if (i < 4 && j < NUMVIRTUALKEYSINROW-2)
				{
					col = 25;
				}

				boolean canmodifycol = (menutyping.menutypingfade == 18);

				if (c == KEY_BACKSPACE)
				{
					arrowoffset = 1;
					buf[0] = '\x1C'; // left arrow
					buf[1] = '\0';

					if (canmodifycol && M_MenuBackHeld(pid))
					{
						col -= 4;
						canmodifycol = false;
					}
				}
				else if (c == KEY_RSHIFT)
				{
					arrowoffset = 2;
					buf[0] = '\x1A'; // up arrow
					buf[1] = '\0';

					if (menutyping.keyboardcapslock || menutyping.keyboardshift)
					{
						col = 22;
					}

					if (canmodifycol && M_MenuExtraHeld(pid))
					{
						col -= 4;
						canmodifycol = false;
					}
				}
				else if (c == KEY_ENTER)
				{
					strcpy(buf, "OK");

					if (menutyping.menutypingclose)
					{
						col -= 4;
						canmodifycol = false;
					}
				}
				else if (c == KEY_SPACE)
				{
					strcpy(buf, "Space");
				}
				else
				{
					buf[0] = c;
					buf[1] = '\0';
				}

				INT32 width = (buttonwidth * buttonspacing) - 1;

				// highlight:
				/*if (menutyping.keyboardtyping)
				{
					mflag |= V_TRANSLUCENT;	// grey it out if we can't use it.
				}
				else*/
				{
					if (tempkeyboardx == j && menutyping.keyboardy == i)
					{
						if (canmodifycol && M_MenuConfirmHeld(pid))
						{
							col -= 4;
							canmodifycol = false;
						}

						V_DrawFill(x + 1, y + 1, width - 2, BUTTONHEIGHT - 2, col - 3);

						V_DrawFill(x, y,                    width, 1, 121);
						V_DrawFill(x, y + BUTTONHEIGHT - 1, width, 1, 121);

						V_DrawFill(x,             y + 1, 1, BUTTONHEIGHT - 2, 121);
						V_DrawFill(x + width - 1, y + 1, 1, BUTTONHEIGHT - 2, 121);

						mflag |= highlightflags;
					}
					else
					{
						V_DrawFill(x, y, width, BUTTONHEIGHT, col);
					}
				}

				if (arrowoffset != 0)
				{
					if (c == KEY_RSHIFT)
					{
						V_DrawFill(x + width - 5, y + 1, 4, 4, 31);

						if (menutyping.keyboardcapslock)
						{
							V_DrawFill(x + width - 4, y + 2, 2, 2, 121);
						}
					}

					V_DrawCenteredString(x + (width/2), y + 1 + arrowoffset, mflag, buf);
				}
				else
				{
					V_DrawCenteredThinString(x + (width/2), y + 1, mflag, buf);
				}

				x += width + 1;
				j += buttonspacing;
			}
			x = returnx;
			y += BUTTONHEIGHT + 1;
		}
	}

#undef BUTTONHEIGHT

	y = 187;

	if (menutyping.menutypingfade < 9)
	{
		y += 3 * (9 - menutyping.menutypingfade);
	}

	// Some contextual stuff
	if (menutyping.keyboardtyping)
	{
		V_DrawThinString(returnx, y, V_GRAYMAP,
			"Type using your keyboard. Press Enter to confirm & exit."
			//"\nPress any button on your controller to use the Virtual Keyboard."
		);
	}
	else
	{
		V_DrawThinString(returnx, y, V_GRAYMAP,
			"Type using the Virtual Keyboard. Use the \'OK\' button to confirm & exit."
			//"\nPress any keyboard key to type normally."
		);
	}

}

static void M_DrawMediocreKeyboardKey(const char *text, INT32 *workx, INT32 worky, boolean push, boolean rightaligned)
{
	INT32 buttonwidth = V_StringWidth(text, 0) + 2;

	if (rightaligned)
	{
		(*workx) -= buttonwidth;
	}

	if (push)
	{
		worky += 2;
	}
	else
	{
		V_DrawFill((*workx)-1, worky+10, buttonwidth, 2, 24);
	}

	V_DrawFill((*workx)-1, worky, buttonwidth, 10, 16);
	V_DrawString(
		(*workx), worky + 1,
		0, text
	);
}

// Draw the message popup submenu
void M_DrawMenuMessage(void)
{
	if (!menumessage.active)
		return;

	INT32 x = (BASEVIDWIDTH - menumessage.x)/2;
	INT32 y = (BASEVIDHEIGHT - menumessage.y)/2 + floor(pow(2, (double)(9 - menumessage.fadetimer)));
	size_t i, start = 0;
	char string[MAXMENUMESSAGE];
	const char *msg = menumessage.message;

	V_DrawFadeScreen(31, menumessage.fadetimer);

	V_DrawFill(0, y, BASEVIDWIDTH, menumessage.y, 159);

	if (menumessage.header != NULL)
	{
		V_DrawThinString(x, y - 10, highlightflags, menumessage.header);
	}

	if (menumessage.defaultstr)
	{
		INT32 workx = x + menumessage.x;
		INT32 worky = y + menumessage.y;

		boolean standardbuttons = (
			cv_currprofile.value != -1 || G_GetNumAvailableGamepads()
		);

		boolean push;

		if (menumessage.closing)
			push = (menumessage.answer != MA_YES);
		else
		{
			const UINT8 anim_duration = 16;
			push = ((menumessage.timer % (anim_duration * 2)) < anim_duration);
		}

		workx -= V_ThinStringWidth(menumessage.defaultstr, 0);
		V_DrawThinString(
			workx, worky + 1,
			((push && (menumessage.closing & MENUMESSAGECLOSE))
				? highlightflags : 0),
			menumessage.defaultstr
		);

		workx -= 2;

		if (standardbuttons)
		{
			workx -= SHORT(kp_button_x[1][0]->width);
			K_drawButton(
				workx * FRACUNIT, worky * FRACUNIT,
				0, kp_button_x[1],
				push
			);

			workx -= SHORT(kp_button_b[1][0]->width);
			K_drawButton(
				workx * FRACUNIT, worky * FRACUNIT,
				0, kp_button_b[1],
				push
			);
		}
		else
		{
			M_DrawMediocreKeyboardKey("ESC", &workx, worky, push, true);
		}

		if (menumessage.confirmstr)
		{
			workx -= 12;

			if (menumessage.closing)
				push = !push;

			workx -= V_ThinStringWidth(menumessage.confirmstr, 0);
			V_DrawThinString(
				workx, worky + 1,
				((push && (menumessage.closing & MENUMESSAGECLOSE))
					? highlightflags : 0),
				menumessage.confirmstr
			);

			workx -= 2;
		}

		if (standardbuttons)
		{
			workx -= SHORT(kp_button_a[1][0]->width);
			K_drawButton(
				workx * FRACUNIT, worky * FRACUNIT,
				0, kp_button_a[1],
				push
			);
		}
		else
		{
			M_DrawMediocreKeyboardKey("ENTER", &workx, worky, push, true);
		}
	}

	x -= 4;
	y += 4;

	while (*(msg+start))
	{
		size_t len = strlen(msg+start);

		for (i = 0; i < len; i++)
		{
			if (*(msg+start+i) == '\n')
			{
				memset(string, 0, MAXMENUMESSAGE);
				if (i >= MAXMENUMESSAGE)
				{
					CONS_Printf("M_DrawMenuMessage: too long segment in %s\n", msg);
					return;
				}
				else
				{
					strncpy(string,msg+start, i);
					string[i] = '\0';
					start += i;
					i = (size_t)-1; //added : 07-02-98 : damned!
					start++;
				}
				break;
			}
		}

		if (i == strlen(msg+start))
		{
			if (i >= MAXMENUMESSAGE)
			{
				CONS_Printf("M_DrawMenuMessage: too long segment in %s\n", msg);
				return;
			}
			else
			{
				strcpy(string, msg + start);
				start += i;
			}
		}

		V_DrawString((BASEVIDWIDTH - V_StringWidth(string, 0))/2, y, 0, string);
		y += 8;
	}
}

// PAUSE
static void M_DrawPausedText(INT32 x)
{
	patch_t *pausebg = W_CachePatchName("M_STRIPU", PU_CACHE);
	patch_t *pausetext = W_CachePatchName("M_PAUSET", PU_CACHE);

	INT32 snapFlags = menuactive ? 0 : (V_SNAPTOLEFT|V_SNAPTOTOP);

	V_DrawFixedPatch(x, -5*FRACUNIT, FRACUNIT, snapFlags|V_ADD, pausebg,   NULL);
	V_DrawFixedPatch(x, -5*FRACUNIT, FRACUNIT, snapFlags,       pausetext, NULL);
}

//
// M_Drawer
// Called after the view has been rendered,
// but before it has been blitted.
//

void M_Drawer(void)
{
	if (menuwipe)
		F_WipeStartScreen();

	// background layer
	if (menuactive)
	{
		boolean drawbgroutine = false;
		boolean trulystarted = M_GameTrulyStarted();

		if (gamestate == GS_MENU && trulystarted)
		{
			if (currentMenu->bgroutine)
				drawbgroutine = true;
			else
				M_DrawMenuBackground();
		}
		else
		{
			if (currentMenu->bgroutine
			&& (currentMenu->behaviourflags & MBF_DRAWBGWHILEPLAYING))
				drawbgroutine = true;

			if (!Playing() && !trulystarted)
			{
				M_DrawGonerBack();
			}
			else if (!WipeInAction && currentMenu != &PAUSE_PlaybackMenuDef)
			{
				V_DrawFadeScreen(122, 3);
			}
		}

		if (drawbgroutine)
			currentMenu->bgroutine();
	}

	// draw pause pic
	if (paused && !demo.playback && (menuactive || cv_showhud.value))
	{
		M_DrawPausedText(0);
	}

	// foreground layer
	if (menuactive)
	{
		if (currentMenu->drawroutine)
			currentMenu->drawroutine(); // call current menu Draw routine

		M_DrawMenuForeground();

		// Draw version down in corner
		// ... but only in the MAIN MENU.  I'm a picky bastard.
		if (currentMenu == &MainDef)
		{
			F_VersionDrawer();
		}

		// Draw typing overlay when needed, above all other menu elements.
		if (menutyping.active)
			M_DrawMenuTyping();

		// Draw message overlay when needed
		M_DrawMenuMessage();
	}

	if (menuwipe)
	{
		F_WipeEndScreen();
		F_RunWipe(wipe_menu_final, wipedefs[wipe_menu_final], false, "FADEMAP0", true, false);
		menuwipe = false;
	}

	if (netgame && Playing())
	{
		boolean mainpause_open = menuactive && currentMenu == &PAUSE_MainDef;

		ST_DrawServerSplash(!mainpause_open);
	}

	// focus lost notification goes on top of everything, even the former everything
	if (window_notinfocus && cv_showfocuslost.value)
	{
		M_DrawTextBox((BASEVIDWIDTH/2) - (60), (BASEVIDHEIGHT/2) - (16), 13, 2);
		V_DrawCenteredString(BASEVIDWIDTH/2, (BASEVIDHEIGHT/2) - (4), highlightflags|V_FORCEUPPERCASE, "Focus Lost");
	}
}

// ==========================================================================
// GENERIC MENUS
// ==========================================================================

// Converts a string into question marks.
// Used for the secrets menu, to hide yet-to-be-unlocked stuff.
static const char *M_CreateSecretMenuOption(const char *str)
{
#if 1
	(void)str;
	return "???";
#else
	static char qbuf[64];
	int i;

	for (i = 0; i < 63; ++i)
	{
		if (!str[i])
		{
			qbuf[i] = '\0';
			return qbuf;
		}
		else if (str[i] != ' ')
			qbuf[i] = '?';
		else
			qbuf[i] = ' ';
	}

	qbuf[63] = '\0';
	return qbuf;
#endif
}

//
// M_DrawGenericMenu
//
// Default, generic text-based list menu, used for Options
//
void M_DrawGenericMenu(void)
{
	INT32 x = currentMenu->x, y = currentMenu->y, w, i, cursory = 0;

	M_DrawMenuTooltips();

	for (i = 0; i < currentMenu->numitems; i++)
	{
		if (i == itemOn)
			cursory = y;

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_PATCH:
				if (currentMenu->menuitems[i].patch && currentMenu->menuitems[i].patch[0])
				{
					if (currentMenu->menuitems[i].status & IT_CENTER)
					{
						patch_t *p;
						p = W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE);
						V_DrawScaledPatch((BASEVIDWIDTH - SHORT(p->width))/2, y, 0, p);
					}
					else
					{
						V_DrawScaledPatch(x, y, 0,
							W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE));
					}
				}
				/* FALLTHRU */
			case IT_NOTHING:
			case IT_DYBIGSPACE:
				y = currentMenu->y + currentMenu->menuitems[i].mvar1;//+= LINEHEIGHT;
				break;
#if 0
			case IT_BIGSLIDER:
				M_DrawThermo(x, y, currentMenu->menuitems[i].itemaction.cvar);
				y += LINEHEIGHT;
				break;
#endif
			case IT_STRING:
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;
				if (i == itemOn)
					cursory = y;

				if ((currentMenu->menuitems[i].status & IT_DISPLAY)==IT_STRING)
					V_DrawMenuString(x, y, 0, currentMenu->menuitems[i].text);
				else
					V_DrawMenuString(x, y, highlightflags, currentMenu->menuitems[i].text);

				// Cvar specific handling
				switch (currentMenu->menuitems[i].status & IT_TYPE)
					case IT_CVAR:
					{
						consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;
						switch (currentMenu->menuitems[i].status & IT_CVARTYPE)
						{
#if 0
							case IT_CV_SLIDER:
								M_DrawSlider(x, y, cv, (i == itemOn));
							case IT_CV_NOPRINT: // color use this
							case IT_CV_INVISSLIDER: // monitor toggles use this
								break;
#endif
							case IT_CV_STRING:
								{
									M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);

									INT32 xoffs = 0;
									if (itemOn == i)
									{
										xoffs += 8;
										V_DrawMenuString(x + (skullAnimCounter/5) + 6, y + 12, highlightflags, "\x1D");
									}

									V_DrawString(x + xoffs + 8, y + 12, 0, cv->string);

									y += 16;
								}
								break;
							default:
								w = V_MenuStringWidth(cv->string, 0);
								V_DrawMenuString(BASEVIDWIDTH - x - w, y,
									((cv->flags & CV_CHEAT) && !CV_IsSetToDefault(cv) ? warningflags : highlightflags), cv->string);
								if (i == itemOn)
								{
									V_DrawMenuString(BASEVIDWIDTH - x - 10 - w - (skullAnimCounter/5), y,
											highlightflags, "\x1C"); // left arrow
									V_DrawMenuString(BASEVIDWIDTH - x + 2 + (skullAnimCounter/5), y,
											highlightflags, "\x1D"); // right arrow
								}
								break;
						}
						break;
					}
					y += STRINGHEIGHT;
					break;
			case IT_STRING2:
				V_DrawMenuString(x, y, 0, currentMenu->menuitems[i].text);
				/* FALLTHRU */
			case IT_DYLITLSPACE:
				y += SMALLLINEHEIGHT;
				break;
			case IT_GRAYPATCH:
				if (currentMenu->menuitems[i].patch && currentMenu->menuitems[i].patch[0])
					V_DrawMappedPatch(x, y, 0,
						W_CachePatchName(currentMenu->menuitems[i].patch,PU_CACHE), graymap);
				y += LINEHEIGHT;
				break;
			case IT_TRANSTEXT:
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;
				/* FALLTHRU */
			case IT_TRANSTEXT2:
				V_DrawMenuString(x, y, V_TRANSLUCENT, currentMenu->menuitems[i].text);
				y += SMALLLINEHEIGHT;
				break;
			case IT_QUESTIONMARKS:
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;

				V_DrawMenuString(x, y, V_TRANSLUCENT|V_OLDSPACING, M_CreateSecretMenuOption(currentMenu->menuitems[i].text));
				y += SMALLLINEHEIGHT;
				break;
			case IT_HEADERTEXT: // draws 16 pixels to the left, in yellow text
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;

				V_DrawMenuString(x-16, y, highlightflags, currentMenu->menuitems[i].text);
				y += SMALLLINEHEIGHT;
				break;
		}
	}

	if ((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == 0)
		cursory = 300;	// Put the cursor off screen if we can't even display that option and we're on it, it makes no sense otherwise...

	// DRAW THE SKULL CURSOR
	if (((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == IT_PATCH)
		|| ((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == IT_NOTHING))
	{
		V_DrawScaledPatch(currentMenu->x + SKULLXOFF, cursory - 5, 0,
			W_CachePatchName("M_CURSOR", PU_CACHE));
	}
	else
	{
		V_DrawScaledPatch(currentMenu->x - 24, cursory, 0,
			W_CachePatchName("M_CURSOR", PU_CACHE));
		V_DrawMenuString(currentMenu->x, cursory, highlightflags, currentMenu->menuitems[itemOn].text);
	}
}

#define GM_STARTX 128
#define GM_STARTY 80
#define GM_XOFFSET 17
#define GM_YOFFSET 34
#define GM_FLIPTIME 5

static tic_t gm_flipStart;

static INT32 M_DrawRejoinIP(INT32 x, INT32 y, INT32 tx)
{
	extern consvar_t cv_dummyipselect;
	char (*ip)[MAX_LOGIP] = joinedIPlist[cv_dummyipselect.value];
	if (!*ip[0])
		return 0;

	INT16 shift = 20;
	x -= shift;

	INT16 j = 0;
	for (j=0; j <= (GM_YOFFSET + 10) / 2; j++)
	{
		// Draw rectangles that look like the current selected item starting from the top of the actual selection graphic and going up to where it's supposed to go.
		// With colour 169 (that's the index of the shade of black the plague colourization gives us. ...No I don't like using a magic number either.
		V_DrawFill((x-1) + j, y + (2*j), 226, 2, 169);
	}

	x += GM_XOFFSET + 14;
	y += GM_YOFFSET;

	const char *text = ip[0];
	INT32 w = V_ThinStringWidth(text, 0);
	INT32 f = highlightflags;
	V_DrawMenuString(x - 10 - (skullAnimCounter/5), y, f, "\x1C"); // left arrow
	V_DrawMenuString(x + w + 2+ (skullAnimCounter/5), y, f, "\x1D"); // right arrow
	V_DrawThinString(x, y, f, text);
	V_DrawRightAlignedThinString(BASEVIDWIDTH + 4 + tx, y, V_ORANGEMAP, "\xAC Rejoin");

	return shift;
}

//
// M_DrawKartGamemodeMenu
//
// Huge gamemode-selection list for main menu
//
void M_DrawKartGamemodeMenu(void)
{
	UINT8 n = 0;
	INT32 i, x, y;
	INT32 tx = M_EaseWithTransition(Easing_Linear, 5 * 48);

	for (i = 0; i < currentMenu->numitems; i++)
	{
		if (currentMenu->menuitems[i].status == IT_DISABLED)
		{
			continue;
		}

		n++;
	}

	n--;
	x = GM_STARTX - ((GM_XOFFSET / 2) * (n-1)) + tx;
	y = GM_STARTY - ((GM_YOFFSET / 2) * (n-1));

	M_DrawMenuTooltips();

	for (i = 0; i < currentMenu->numitems; i++)
	{
		INT32 type;

		if (currentMenu->menuitems[i].status == IT_DISABLED)
		{
			continue;
		}

		if (i >= currentMenu->numitems-1)
		{
			x = GM_STARTX + (GM_XOFFSET * 5 / 2) + tx;
			y = GM_STARTY + (GM_YOFFSET * 5 / 2);

		}

		INT32 cx = x;
		boolean selected = (i == itemOn && menutransition.tics == menutransition.dest);

		if (selected)
		{
			fixed_t f = M_DueFrac(gm_flipStart, GM_FLIPTIME);
			cx -= Easing_OutSine(f, 0, (GM_XOFFSET / 2));

			// Direct Join
			if (currentMenu == &PLAY_MP_OptSelectDef && i == mp_directjoin)
			{
				INT32 shift = M_DrawRejoinIP(cx, y, cx - x);
				cx -= Easing_OutSine(f, 0, shift);
			}
		}

		type = (currentMenu->menuitems[i].status & IT_DISPLAY);

		switch (type)
		{
			case IT_STRING:
			case IT_TRANSTEXT2:
				{
					UINT8 *colormap = NULL;

					if (selected)
					{
						colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);
					}
					else
					{
						colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_MOSS, GTC_CACHE);
					}

					V_DrawFixedPatch(cx*FRACUNIT, y*FRACUNIT, FRACUNIT, 0, W_CachePatchName("MENUPLTR", PU_CACHE), colormap);
					V_DrawGamemodeString(cx + 16, y - 3,
						(type == IT_TRANSTEXT2
							? V_TRANSLUCENT
							: 0
						),
						colormap,
						currentMenu->menuitems[i].text);
				}
				break;
		}

		x += GM_XOFFSET;
		y += GM_YOFFSET;
	}
}

void M_FlipKartGamemodeMenu(boolean slide)
{
	gm_flipStart = slide ? I_GetTime() : 0;
}

void M_DrawHorizontalMenu(void)
{
	INT32 x, y, i, final = currentMenu->extra2-1, showflags;

	const INT32 width = 80;

	y = currentMenu->y;

	V_DrawFadeFill(0, y-2, BASEVIDWIDTH, 24, 0, 31, 5);

	x = (BASEVIDWIDTH - 8*final)/2;
	for (i = 0; i < currentMenu->extra2; i++, x += 8)
	{
		if (i == itemOn)
		{
			V_DrawFill(x-2, y + 16, 4, 4, 0);
		}
		else if (i >= currentMenu->numitems)
		{
			V_DrawFill(x-1, y + 17, 2, 2, 20);
		}
		else
		{
			V_DrawFill(x-1, y + 17, 2, 2,
				(i == final && skullAnimCounter/5) ? 73 : 10
			);
		}
	}

	i = itemOn;
	x = BASEVIDWIDTH/2;

	do
	{
		if (i == 0)
			break;
		i--;
		x -= width;
	}
	while (x > -width/2);

	while (x < BASEVIDWIDTH + (width/2))
	{
		showflags = 0;
		if (i == final)
		{
			showflags |= V_STRINGDANCE;
			if (itemOn == i)
				showflags |= V_YELLOWMAP;
		}
		else if (i == itemOn)
		{
			showflags |= highlightflags;
		}

		V_DrawCenteredThinString(
			x, y,
			showflags,
			currentMenu->menuitems[i].text
		);

		if (++i == currentMenu->numitems)
			break;
		x += width;
	}

	if (itemOn != 0)
		V_DrawMenuString((BASEVIDWIDTH - width)/2 + 3 - (skullAnimCounter/5), y + 1,
			highlightflags, "\x1C"); // left arrow

	if (itemOn != currentMenu->numitems-1)
		V_DrawMenuString((BASEVIDWIDTH + width)/2 - 10 + (skullAnimCounter/5), y + 1,
			highlightflags, "\x1D"); // right arrow
}

#define MAXMSGLINELEN 256

//
//  Draw a textbox, like Quake does, because sometimes it's difficult
//  to read the text with all the stuff in the background...
//
void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines)
{
	// Solid color textbox.
	V_DrawFill(x+5, y+5, width*8+6, boxlines*8+6, 159);
	//V_DrawFill(x+8, y+8, width*8, boxlines*8, 31);
}

//
// M_DrawMessageMenu
//
// Generic message prompt
//
void M_DrawMessageMenu(void)
{
	INT32 y = currentMenu->y;
	size_t i, start = 0;
	INT16 max;
	char string[MAXMENUMESSAGE];
	INT32 mlines;
	const char *msg = currentMenu->menuitems[0].text;

	mlines = currentMenu->lastOn>>8;
	max = (INT16)((UINT8)(currentMenu->lastOn & 0xFF)*8);

	M_DrawTextBox(currentMenu->x, y - 8, (max+7)>>3, mlines);

	while (*(msg+start))
	{
		size_t len = strlen(msg+start);

		for (i = 0; i < len; i++)
		{
			if (*(msg+start+i) == '\n')
			{
				memset(string, 0, MAXMENUMESSAGE);
				if (i >= MAXMENUMESSAGE)
				{
					CONS_Printf("M_DrawMessageMenu: too long segment in %s\n", msg);
					return;
				}
				else
				{
					strncpy(string,msg+start, i);
					string[i] = '\0';
					start += i;
					i = (size_t)-1; //added : 07-02-98 : damned!
					start++;
				}
				break;
			}
		}

		if (i == strlen(msg+start))
		{
			if (i >= MAXMENUMESSAGE)
			{
				CONS_Printf("M_DrawMessageMenu: too long segment in %s\n", msg);
				return;
			}
			else
			{
				strcpy(string, msg + start);
				start += i;
			}
		}

		V_DrawMenuString((BASEVIDWIDTH - V_MenuStringWidth(string, 0))/2,y,0,string);
		y += 8; //SHORT(hu_font[0]->height);
	}
}

// Draw an Image Def.  Aka, Help images.
// Defines what image is used in (menuitem_t)->patch.
// You can even put multiple images in one menu!
void M_DrawImageDef(void)
{
	patch_t *patch = W_CachePatchName(currentMenu->menuitems[itemOn].text, PU_CACHE);

	if (patch->width <= BASEVIDWIDTH)
	{
		V_DrawScaledPatch(0, 0, 0, patch);
	}
	else
	{
		V_DrawSmallScaledPatch(0, 0, 0, patch);
	}

	if (currentMenu->menuitems[itemOn].mvar1)
	{
		V_DrawString(2,BASEVIDHEIGHT-10, V_YELLOWMAP, va("%d", (itemOn<<1)-1)); // intentionally not highlightflags, unlike below
		V_DrawRightAlignedString(BASEVIDWIDTH-2,BASEVIDHEIGHT-10, V_YELLOWMAP, va("%d", itemOn<<1)); // ditto
	}
	else
	{
		INT32 x = BASEVIDWIDTH>>1, y = (BASEVIDHEIGHT>>1) - 4;
		x += (itemOn ? 1 : -1)*((BASEVIDWIDTH>>2) + 10);
		V_DrawCenteredString(x, y-10, highlightflags, "USE ARROW KEYS");
		V_DrawCharacter(x - 10 - (skullAnimCounter/5), y,
			'\x1C' | highlightflags, false); // left arrow
		V_DrawCharacter(x + 2 + (skullAnimCounter/5), y,
			'\x1D' | highlightflags, false); // right arrow
		V_DrawCenteredString(x, y+10, highlightflags, "TO LEAF THROUGH");
	}
}

//
// PLAY MENUS
//

static void M_DrawCharSelectCircle(setup_player_t *p, INT16 x, INT16 y)
{
	angle_t angamt = ANGLE_MAX;
	UINT16 i, numoptions = 0;
	INT16 l = 0, r = 0;
	INT16 subtractcheck;

	switch (p->mdepth)
	{
		case CSSTEP_ALTS:
			numoptions = setup_chargrid[p->gridx][p->gridy].numskins;
			break;
		case CSSTEP_COLORS:
		case CSSTEP_FOLLOWERCOLORS:
			numoptions = p->colors.listLen;
			break;
		case CSSTEP_FOLLOWERCATEGORY:
			numoptions = setup_numfollowercategories+1;
			break;
		case CSSTEP_FOLLOWER:
			numoptions = setup_followercategories[p->followercategory][0];
			break;
		default:
			return;
	}

	if (numoptions == 0)
	{
		return;
	}

	subtractcheck = 1 ^ (numoptions & 1);

	angamt /= numoptions;

	for (i = 0; i < numoptions; i++)
	{
		fixed_t cx = x << FRACBITS, cy = y << FRACBITS;
		boolean subtract = (i & 1) == subtractcheck;
		angle_t ang = ((i+1)/2) * angamt;
		patch_t *patch = NULL;
		UINT8 *colormap = NULL;
		fixed_t radius = 28<<FRACBITS;
		INT16 n = 0;

		switch (p->mdepth)
		{
			case CSSTEP_ALTS:
			{
				INT16 skin;

				n = (p->clonenum) + numoptions/2;
				if (subtract)
					n -= ((i+1)/2);
				else
					n += ((i+1)/2);
				n = (n + numoptions) % numoptions;

				skin = setup_chargrid[p->gridx][p->gridy].skinlist[n];
				patch = faceprefix[skin][FACE_RANK];
				colormap = R_GetTranslationColormap(skin, skins[skin].prefcolor, GTC_MENUCACHE);
				radius = 24<<FRACBITS;

				cx -= (SHORT(patch->width) << FRACBITS) >> 1;
				cy -= (SHORT(patch->height) << FRACBITS) >> 1;
				break;
			}

			case CSSTEP_COLORS:
			{
				INT16 diff;

				if (i == 0)
				{
					n = l = r = M_GetColorBefore(&p->colors, p->color, (numoptions/2) - (numoptions & 1));
				}
				else if (subtract)
				{
					n = l = M_GetColorBefore(&p->colors, l, 1);
				}
				else
				{
					n = r = M_GetColorAfter(&p->colors, r, 1);
				}

				colormap = R_GetTranslationColormap(TC_DEFAULT, (n == SKINCOLOR_NONE) ? skins[p->skin].prefcolor : n, GTC_MENUCACHE);

				diff = (numoptions - i) / 2;  // only 0 when i == numoptions-1

				if (diff == 0)
					patch = W_CachePatchName("COLORSP2", PU_CACHE);
				else if (abs(diff) < 25)
					patch = W_CachePatchName("COLORSP1", PU_CACHE);
				else
					patch = W_CachePatchName("COLORSP0", PU_CACHE);

				cx -= (SHORT(patch->width) << FRACBITS) >> 1;
				break;
			}

			case CSSTEP_FOLLOWERCATEGORY:
			{
				followercategory_t *fc = NULL;

				n = (p->followercategory + 1) + numoptions/2;
				if (subtract)
					n -= ((i+1)/2);
				else
					n += ((i+1)/2);
				n = (n + numoptions) % numoptions;

				if (n == 0)
				{
					patch = W_CachePatchName("K_NOBLNS", PU_CACHE);
				}
				else
				{
					fc = &followercategories[setup_followercategories[n - 1][1]];
					patch = W_CachePatchName(fc->icon, PU_CACHE);
				}

				radius = 24<<FRACBITS;

				cx -= (SHORT(patch->width) << FRACBITS) >> 1;
				cy -= (SHORT(patch->height) << FRACBITS) >> 1;
				break;
			}

			case CSSTEP_FOLLOWER:
			{
				follower_t *fl = NULL;
				INT16 startfollowern = p->followern;

				if (i == 0)
				{
					n = p->followern;
					r = (numoptions+1)/2;
					while (r)
					{
						n--;
						if (n < 0)
							n = numfollowers-1;
						if (n == startfollowern)
							break;
						if (followers[n].category == setup_followercategories[p->followercategory][1]
							&& K_FollowerUsable(n))
							r--;
					}
					l = r = n;
				}
				else if (subtract)
				{
					do
					{
						l--;
						if (l < 0)
							l = numfollowers-1;
						if (l == startfollowern)
							break;
					}
					while (followers[l].category != setup_followercategories[p->followercategory][1]
						|| !K_FollowerUsable(l));
					n = l;
				}
				else
				{
					do
					{
						r++;
						if (r >= numfollowers)
							r = 0;
						if (r == startfollowern)
							break;
					}
					while (followers[r].category != setup_followercategories[p->followercategory][1]
						|| !K_FollowerUsable(r));
					n = r;
				}

				{
					fl = &followers[n];
					patch = W_CachePatchName(fl->icon, PU_CACHE);

					colormap = R_GetTranslationColormap(TC_DEFAULT,
						K_GetEffectiveFollowerColor(fl->defaultcolor, fl, p->color, &skins[p->skin]),
						GTC_MENUCACHE
					);
				}

				radius = 24<<FRACBITS;

				cx -= (SHORT(patch->width) << FRACBITS) >> 1;
				cy -= (SHORT(patch->height) << FRACBITS) >> 1;
				break;
			}

			case CSSTEP_FOLLOWERCOLORS:
			{
				INT16 diff;
				UINT16 col;

				if (i == 0)
				{
					n = l = r = M_GetColorBefore(&p->colors, p->followercolor, (numoptions/2) - (numoptions & 1));
				}
				else if (subtract)
				{
					n = l = M_GetColorBefore(&p->colors, l, 1);
				}
				else
				{
					n = r = M_GetColorAfter(&p->colors, r, 1);
				}

				col = K_GetEffectiveFollowerColor(n, &followers[p->followern], p->color, &skins[p->skin]);

				colormap = R_GetTranslationColormap(TC_DEFAULT, col, GTC_MENUCACHE);

				diff = (numoptions - i)/2;  // only 0 when i == numoptions-1

				if (diff == 0)
					patch = W_CachePatchName("COLORSP2", PU_CACHE);
				else if (abs(diff) < 25)
					patch = W_CachePatchName("COLORSP1", PU_CACHE);
				else
					patch = W_CachePatchName("COLORSP0", PU_CACHE);

				cx -= (SHORT(patch->width) << FRACBITS) >> 1;
				break;
			}

			default:
				break;
		}

		if (subtract)
			ang = (signed)(ANGLE_90 - ang);
		else
			ang = ANGLE_90 + ang;

		if (numoptions & 1)
			ang = (signed)(ang - (angamt/2));

		if (p->rotate)
		{
			SINT8 rotate = p->rotate;
			if ((p->hitlag == true) && (setup_animcounter & 1))
				rotate = -rotate;
			ang = (signed)(ang + ((angamt / CSROTATETICS) * rotate));
		}

		cx += FixedMul(radius, FINECOSINE(ang >> ANGLETOFINESHIFT));
		cy -= FixedMul(radius, FINESINE(ang >> ANGLETOFINESHIFT)) / 3;

		V_DrawFixedPatch(cx, cy, FRACUNIT, 0, patch, colormap);
		if (p->mdepth == CSSTEP_ALTS && n != p->clonenum)
			V_DrawFixedPatch(cx, cy, FRACUNIT, V_TRANSLUCENT, W_CachePatchName("ICONDARK", PU_CACHE), NULL);
	}
}

// returns false if the character couldn't be rendered
boolean M_DrawCharacterSprite(INT16 x, INT16 y, INT16 skin, UINT8 spr2, UINT8 rotation, UINT32 frame, INT32 addflags, UINT8 *colormap)
{
	UINT8 spr;
	spritedef_t *sprdef;
	spriteframe_t *sprframe;
	patch_t *sprpatch;

	spr = P_GetSkinSprite2(&skins[skin], spr2, NULL);
	sprdef = &skins[skin].sprites[spr];

	if (!sprdef->numframes) // No frames ??
		return false; // Can't render!

	frame %= sprdef->numframes;

	sprframe = &sprdef->spriteframes[frame];
	sprpatch = W_CachePatchNum(sprframe->lumppat[rotation], PU_CACHE);

	if (sprframe->flip & (1<<rotation)) // Only for first sprite
	{
		addflags ^= V_FLIP; // This sprite is left/right flipped!
	}

	if (skins[skin].highresscale != FRACUNIT)
	{
		V_DrawFixedPatch(x<<FRACBITS,
					y<<FRACBITS,
					skins[skin].highresscale,
					addflags, sprpatch, colormap);
	}
	else
		V_DrawMappedPatch(x, y, addflags, sprpatch, colormap);

	return true;
}

// Returns false is the follower shouldn't be rendered.
// 'num' can be used to directly specify the follower number, but doing this will not animate it.
// if a setup_player_t is specified instead, its data will be used to animate the follower sprite.
static boolean M_DrawFollowerSprite(INT16 x, INT16 y, INT32 num, boolean charflip, INT32 addflags, UINT8 *colormap, setup_player_t *p)
{
	spritedef_t *sprdef;
	spriteframe_t *sprframe;
	patch_t *patch;
	INT32 followernum;
	state_t *usestate;
	UINT32 useframe;
	follower_t *fl;
	UINT8 rotation = (charflip ? 1 : 7);

	if (p != NULL)
		followernum = p->followern;
	else
		followernum = num;

	// Don't draw if we're outta bounds.
	if (followernum < 0 || followernum >= numfollowers)
		return false;

	fl = &followers[followernum];

	if (p != NULL)
	{
		usestate = p->follower_state;
		useframe = p->follower_frame;
	}
	else
	{
		usestate = &states[followers[followernum].followstate];
		useframe = usestate->frame & FF_FRAMEMASK;
	}

	sprdef = &sprites[usestate->sprite];

	// draw the follower

	if (useframe >= sprdef->numframes)
		useframe = 0;	// frame doesn't exist, we went beyond it... what?

	sprframe = &sprdef->spriteframes[useframe];
	patch = W_CachePatchNum(sprframe->lumppat[rotation], PU_CACHE);

	if (sprframe->flip & (1<<rotation)) // Only for first sprite
	{
		addflags ^= V_FLIP; // This sprite is left/right flipped!
	}

	fixed_t sine = 0;

	if (p != NULL)
	{
		UINT16 color = K_GetEffectiveFollowerColor(
			(p->mdepth < CSSTEP_FOLLOWERCOLORS && p->mdepth != CSSTEP_ASKCHANGES) ? fl->defaultcolor : p->followercolor,
			fl,
			p->color,
			&skins[p->skin]
		);
		sine = FixedMul(fl->bobamp, FINESINE(((FixedMul(4 * M_TAU_FIXED, fl->bobspeed) * p->follower_timer)>>ANGLETOFINESHIFT) & FINEMASK));
		colormap = R_GetTranslationColormap(TC_DEFAULT, color, GTC_MENUCACHE);
	}

	V_DrawFixedPatch((x*FRACUNIT), ((y-12)*FRACUNIT) + sine, fl->scale, addflags, patch, colormap);

	return true;
}

static void M_DrawCharSelectSprite(UINT8 num, INT16 x, INT16 y, boolean charflip)
{
	setup_player_t *p = &setup_player[num];
	UINT8 color;
	UINT8 *colormap;

	if (p->skin < 0)
	{
		return;
	}

	if (p->mdepth < CSSTEP_COLORS && p->mdepth != CSSTEP_ASKCHANGES)
	{
		color = skins[p->skin].prefcolor;
	}
	else
	{
		color = p->color;
	}

	if (color == SKINCOLOR_NONE)
	{
		color = skins[p->skin].prefcolor;
	}

	colormap = R_GetTranslationColormap(p->skin, color, GTC_MENUCACHE);

	M_DrawCharacterSprite(x, y, p->skin, SPR2_STIN, (charflip ? 1 : 7), ((p->mdepth == CSSTEP_READY) ? setup_animcounter : 0),
		p->mdepth == CSSTEP_ASKCHANGES ? V_TRANSLUCENT : 0, colormap);
}

static void M_DrawCharSelectPreview(UINT8 num)
{
	INT16 x = 11, y = 5;
	char letter = 'A' + num;
	setup_player_t *p = &setup_player[num];
	boolean charflip = !!(num & 1);

	if (num & 1)
		x += 233;

	if (num > 1)
		y += 99;

	V_DrawScaledPatch(x, y+6, V_TRANSLUCENT, W_CachePatchName("PREVBACK", PU_CACHE));

	if (p->mdepth >= CSSTEP_CHARS || p->mdepth == CSSTEP_ASKCHANGES)
	{
		M_DrawCharSelectSprite(num, x+32, y+75, charflip);
		M_DrawCharSelectCircle(p, x+32, y+64);
	}

	if (p->showextra == false)
	{
		INT32 backx = x + ((num & 1) ? -1 : 11);
		V_DrawScaledPatch(backx, y+2, 0, W_CachePatchName("FILEBACK", PU_CACHE));

		V_DrawScaledPatch(x + ((num & 1) ? 44 : 0), y+2, 0, W_CachePatchName(va("CHARSEL%c", letter), PU_CACHE));

		profile_t *pr = NULL;
		if (p->mdepth > CSSTEP_PROFILE)
		{
			pr = PR_GetProfile(p->profilen);
		}
		V_DrawCenteredFileString(backx+26, y+2, 0, pr ? pr->profilename : "PLAYER");
	}

	if (p->mdepth >= CSSTEP_FOLLOWER || p->mdepth == CSSTEP_ASKCHANGES)
	{
		M_DrawFollowerSprite(x+32+((charflip ? 1 : -1)*16), y+75, -1, charflip, p->mdepth == CSSTEP_ASKCHANGES ? V_TRANSLUCENT : 0, NULL, p);
	}

	if ((setup_animcounter/10) & 1)
	{
		if (p->mdepth == CSSTEP_NONE && num == setup_numplayers && gamestate == GS_MENU)
		{
			V_DrawScaledPatch(x+1, y+36, 0, W_CachePatchName("4PSTART", PU_CACHE));
		}
		else if (p->mdepth >= CSSTEP_READY)
		{
			V_DrawScaledPatch(x+1, y+36, 0, W_CachePatchName("4PREADY", PU_CACHE));
		}
	}

	// Profile selection
	if (p->mdepth == CSSTEP_PROFILE)
	{
		INT16 px = x+12;
		INT16 py = y+48 - p->profilen*12 +
			Easing_OutSine(
				M_DueFrac(p->profilen_slide.start, 5),
				p->profilen_slide.dist*12,
				0
			);
		UINT8 maxp = PR_GetNumProfiles();

		UINT8 i = 0;
		UINT8 j;

		V_SetClipRect(0, (y+25)*FRACUNIT, BASEVIDWIDTH*FRACUNIT, (5*12)*FRACUNIT, 0);


		for (i = 0; i < maxp; i++)
		{
			profile_t *pr = PR_GetProfile(i);
			INT16 dist = abs(p->profilen - i);
			INT32 notSelectable = 0;
			SINT8 belongsTo = -1;

			if (i != PROFILE_GUEST)
			{
				for (j = 0; j < setup_numplayers; j++)
				{
					if (setup_player[j].mdepth > CSSTEP_PROFILE
						&& setup_player[j].profilen == i)
					{
						belongsTo = j;
						break;
					}
				}
			}

			if (belongsTo != -1 && belongsTo != num)
			{
				notSelectable |= V_TRANSLUCENT;
			}

			if (dist > 3)
			{
				py += 12;
				continue;
			}

			if (dist > 1)
			{
				V_DrawCenteredFileString(px+26, py, notSelectable, pr->version ? pr->profilename : "NEW");
				V_DrawScaledPatch(px, py, V_TRANSLUCENT, W_CachePatchName("FILEBACK", PU_CACHE));
			}
			else
			{
				V_DrawScaledPatch(px, py, 0, W_CachePatchName("FILEBACK", PU_CACHE));

				if (i != p->profilen || ((setup_animcounter/10) & 1))
				{
					const char *txt = pr->version ? pr->profilename : "NEW";

					fixed_t w = V_StringScaledWidth(
						FRACUNIT,
						FRACUNIT,
						FRACUNIT,
						notSelectable,
						FILE_FONT,
						txt
					);

					V_DrawStringScaled(
						((px+26) * FRACUNIT) - (w/2),
						py * FRACUNIT,
						FRACUNIT,
						FRACUNIT,
						FRACUNIT,
						notSelectable,
						i == p->profilen ? R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_SAPPHIRE, GTC_CACHE) : NULL,
						FILE_FONT,
						txt
					);
				}
			}
			py += 12;
		}

		V_ClearClipRect();
	}
	// "Changes?"
	else if (p->mdepth == CSSTEP_ASKCHANGES)
	{
		UINT8 i;
		char choices[2][9] = {"ALL GOOD", "CHANGE"};
		INT32 xpos = x+8;
		INT32 ypos = y+38;

		V_DrawFileString(xpos, ypos, 0, "READY?");

		for (i = 0; i < 2; i++)
		{
			UINT8 cy = ypos+16 + (i*10);

			if (p->changeselect == i)
				M_DrawCursorHand(xpos + 20, cy);

			V_DrawThinString(xpos+16, cy, (p->changeselect == i ? highlightflags : 0), choices[i]);
		}
	}

	if (p->showextra == true)
	{
		INT32 randomskin = 0;
		switch (p->mdepth)
		{
			case CSSTEP_ALTS: // Select clone
			case CSSTEP_READY:
				if (p->clonenum < setup_chargrid[p->gridx][p->gridy].numskins
					&& setup_chargrid[p->gridx][p->gridy].skinlist[p->clonenum] < numskins)
				{
					V_DrawThinString(x-3, y+12, 0,
						skins[setup_chargrid[p->gridx][p->gridy].skinlist[p->clonenum]].name);
					randomskin = (skins[setup_chargrid[p->gridx][p->gridy].skinlist[p->clonenum]].flags & SF_IRONMAN);
				}
				else
				{
					V_DrawThinString(x-3, y+12, 0, va("BAD CLONENUM %u", p->clonenum));
				}
				/* FALLTHRU */
			case CSSTEP_CHARS: // Character Select grid
				V_DrawThinString(x-3, y+2, 0, va("Class %c (s %c - w %c)",
					('A' + R_GetEngineClass(p->gridx+1, p->gridy+1, randomskin)),
					(randomskin
						? '?' : ('1'+p->gridx)),
					(randomskin
						? '?' : ('1'+p->gridy))
					));
				break;
			case CSSTEP_COLORS: // Select color
				if (p->color < numskincolors)
				{
					V_DrawThinString(x-3, y+2, 0, skincolors[p->color].name);
				}
				else
				{
					V_DrawThinString(x-3, y+2, 0, va("BAD COLOR %u", p->color));
				}
				break;
			case CSSTEP_FOLLOWERCATEGORY:
				if (p->followercategory == -1)
				{
					V_DrawThinString(x-3, y+2, 0, "None");
				}
				else
				{
					V_DrawThinString(x-3, y+2, 0,
						followercategories[setup_followercategories[p->followercategory][1]].name);
				}
				break;
			case CSSTEP_FOLLOWER:
				if (p->followern == -1)
				{
					V_DrawThinString(x-3, y+2, 0, "None");
				}
				else
				{
					V_DrawThinString(x-3, y+2, 0,
						followers[p->followern].name);
				}
				break;
			case CSSTEP_FOLLOWERCOLORS:
				if (p->followercolor == FOLLOWERCOLOR_MATCH)
				{
					V_DrawThinString(x-3, y+2, 0, "Match");
				}
				else if (p->followercolor == FOLLOWERCOLOR_OPPOSITE)
				{
					V_DrawThinString(x-3, y+2, 0, "Opposite");
				}
				else if (p->followercolor < numskincolors)
				{
					V_DrawThinString(x-3, y+2, 0, skincolors[p->followercolor].name);
				}
				else
				{
					V_DrawThinString(x-3, y+2, 0, va("BAD FOLLOWERCOLOR %u", p->followercolor));
				}
				break;
			default:
				V_DrawThinString(x-3, y+2, 0, "[extrainfo mode]");
				break;
		}
	}
}

static void M_DrawCharSelectExplosions(boolean charsel, INT16 basex, INT16 basey)
{
	UINT8 i;
	INT16 quadx = 2, quady = 2, mul = 22;

	for (i = 0; i < CSEXPLOSIONS; i++)
	{
		UINT8 *colormap;
		UINT8 frame;

		if (setup_explosions[i].tics == 0 || setup_explosions[i].tics > 5)
			continue;

		frame = 6 - setup_explosions[i].tics;

		if (charsel)
		{
			quadx = 4 * (setup_explosions[i].x / 3);
			quady = 4 * (setup_explosions[i].y / 3);
			mul = 16;
		}

		colormap = R_GetTranslationColormap(TC_DEFAULT, setup_explosions[i].color, GTC_MENUCACHE);

		V_DrawMappedPatch(
			basex + (setup_explosions[i].x*mul) + quadx - 6,
			basey + (setup_explosions[i].y*mul) + quady - 6,
			0, W_CachePatchName(va("CHCNFRM%d", frame), PU_CACHE),
			colormap
		);
	}
}

#define IDLELEN 8
#define SELECTLEN (8 + IDLELEN + 7 + IDLELEN)

static void M_DrawCharSelectCursor(UINT8 num)
{
	static const char *idleframes[IDLELEN] = {
		"CHHOV1", "CHHOV1", "CHHOV1", "CHHOV2", "CHHOV1", "CHHOV3", "CHHOV1", "CHHOV2"
	};
	static const char *selectframesa[SELECTLEN] = {
		"CHHOV1", "CHPIKA1", "CHHOV2", "CHPIKA2", "CHHOV3", "CHPIKA3", "CHHOV2", "CHPIKA4",
		"CHHOV1", "CHHOV1", "CHHOV1", "CHHOV2", "CHHOV1", "CHHOV3", "CHHOV1", "CHHOV2",
		"CHPIKA5", "CHHOV2", "CHPIKA6", "CHHOV3", "CHPIKA7", "CHHOV2", "CHPIKA8",
		"CHHOV1", "CHHOV1", "CHHOV1", "CHHOV2", "CHHOV1", "CHHOV3", "CHHOV1", "CHHOV2"
	};
	static const char *selectframesb[SELECTLEN] = {
		NULL, "CHPIKB1", NULL, "CHPIKB2", NULL, "CHPIKB3", NULL, "CHPIKB4",
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
		"CHPIKB5", NULL, "CHPIKB6", NULL, "CHPIKB7", NULL, "CHPIKB8",
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
	};

	setup_player_t *p = &setup_player[num];
	char letter = 'A' + num;
	UINT16 color = SKINCOLOR_NONE;
	UINT8 *colormap;
	INT16 x, y;
	INT16 quadx, quady;

	if (p->mdepth < CSSTEP_ASKCHANGES)
		return;

	quadx = 4 * (p->gridx / 3);
	quady = 4 * (p->gridy / 3);

	x = 82 + (p->gridx*16) + quadx - 13;
	y = 22 + (p->gridy*16) + quady - 12;

	// profiles skew the graphic to the right slightly
	if (optionsmenu.profile)
		x += 64;

	color = p->color;
	if (color == SKINCOLOR_NONE)
	{
		if (p->skin >= 0)
		{
			color = skins[p->skin].prefcolor;
		}
		else
		{
			color = SKINCOLOR_GREY;
		}
	}

	colormap = R_GetTranslationColormap(TC_DEFAULT, color, GTC_MENUCACHE);

	if (p->mdepth >= CSSTEP_READY)
	{
		V_DrawMappedPatch(x, y, 0, W_CachePatchName("CHCNFRM0", PU_CACHE), colormap);
	}
	else if (p->mdepth > CSSTEP_CHARS)
	{
		V_DrawMappedPatch(x, y, 0, W_CachePatchName(selectframesa[setup_animcounter % SELECTLEN], PU_CACHE), colormap);
		if (selectframesb[(setup_animcounter-1) % SELECTLEN] != NULL)
			V_DrawMappedPatch(x, y, V_TRANSLUCENT, W_CachePatchName(selectframesb[(setup_animcounter-1) % SELECTLEN], PU_CACHE), colormap);
	}
	else
	{
		V_DrawMappedPatch(x, y, 0, W_CachePatchName(idleframes[setup_animcounter % IDLELEN], PU_CACHE), colormap);
	}

	if (p->mdepth < CSSTEP_READY)
		V_DrawMappedPatch(x, y, 0, W_CachePatchName(va("CSELH%c", letter), PU_CACHE), colormap);
}

#undef IDLE
#undef IDLELEN
#undef SELECTLEN

// Draw character profile card.
// Moved here because in the case of profile edition this is drawn in the charsel menu.
void M_DrawProfileCard(INT32 x, INT32 y, boolean greyedout, profile_t *p)
{
	setup_player_t *sp = &setup_player[0];	// When editing profile character, we'll always be checking for what P1 is doing.
	patch_t *card = W_CachePatchName("PR_CARD", PU_CACHE);
	patch_t *cardbot = W_CachePatchName("PR_CARDB", PU_CACHE);
	patch_t *pwrlv = W_CachePatchName("PR_PWR", PU_CACHE);
	UINT16 truecol = SKINCOLOR_BLACK;
	UINT8 *colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_BLACK, GTC_CACHE);
	INT32 skinnum = -1;

	char pname[PROFILENAMELEN+1] = "NEW";

	if (p != NULL && p->version)
	{
		truecol = p->color;
		skinnum = R_SkinAvailableEx(p->skinname, false);
		strcpy(pname, p->profilename);
	}

	if (sp->mdepth >= CSSTEP_CHARS)
	{
		truecol = sp->color;
		skinnum = setup_chargrid[sp->gridx][sp->gridy].skinlist[sp->clonenum];
	}

	if (truecol == SKINCOLOR_NONE)
	{
		if (skinnum >= 0)
		{
			truecol = skins[skinnum].prefcolor;
		}
		else
		{
			truecol = SKINCOLOR_RED;
		}
	}

	// Card
	{
		colormap = R_GetTranslationColormap(TC_DEFAULT, truecol, GTC_CACHE);
		V_DrawFixedPatch(x*FRACUNIT, y*FRACUNIT, FRACUNIT, greyedout ? V_TRANSLUCENT : 0, card, colormap);
	}

	if (greyedout)
		return;	// only used for profiles we can't select.

	if (p != NULL)
	{
		V_DrawFixedPatch((x+30)*FRACUNIT, (y+84)*FRACUNIT, FRACUNIT, 0, pwrlv, colormap);
		V_DrawCenteredTimerString(x+30, y+87, 0, va("%d", p->wins));
	}


	// check what setup_player is doing in priority.
	if (sp->mdepth >= CSSTEP_CHARS)
	{
		if (skinnum >= 0)
		{
			UINT8 *ccolormap = R_GetTranslationColormap(skinnum, truecol, GTC_MENUCACHE);

			if (M_DrawCharacterSprite(x-22, y+119, skinnum, SPR2_STIN, 7, 0, 0, ccolormap))
				V_DrawMappedPatch(x+14, y+66, 0, faceprefix[skinnum][FACE_RANK], ccolormap);
		}

		M_DrawCharSelectCircle(sp, x-22, y+104);

		if (sp->mdepth >= CSSTEP_FOLLOWER)
		{
			if (M_DrawFollowerSprite(x-22 - 16, y+119, 0, false, 0, 0, sp))
			{
				UINT16 col = K_GetEffectiveFollowerColor(sp->followercolor, &followers[sp->followern], sp->color, &skins[sp->skin]);
				patch_t *ico = W_CachePatchName(followers[sp->followern].icon, PU_CACHE);
				UINT8 *fcolormap = R_GetTranslationColormap(TC_DEFAULT, col, GTC_MENUCACHE);
				V_DrawMappedPatch(x+14+18, y+66, 0, ico, fcolormap);
			}
		}
	}
	else if (skinnum > -1)	// otherwise, read from profile.
	{
		UINT8 *ccolormap;
		INT32 fln = K_FollowerAvailable(p->follower);

		if (R_SkinUsable(g_localplayers[0], skinnum, false))
			ccolormap = R_GetTranslationColormap(skinnum, truecol, GTC_MENUCACHE);
		else
			ccolormap = R_GetTranslationColormap(TC_BLINK, truecol, GTC_MENUCACHE);

		if (M_DrawCharacterSprite(x-22, y+119, skinnum, SPR2_STIN, 7, 0, 0, ccolormap))
		{
			V_DrawMappedPatch(x+14, y+66, 0, faceprefix[skinnum][FACE_RANK], ccolormap);
		}

		if (fln >= 0)
		{
			UINT16 fcol = K_GetEffectiveFollowerColor(
				p->followercolor,
				&followers[fln],
				p->color,
				&skins[skinnum]
			);
			UINT8 *fcolormap = R_GetTranslationColormap(
			(K_FollowerUsable(fln) ? TC_DEFAULT : TC_BLINK),
				fcol, GTC_MENUCACHE);

			if (M_DrawFollowerSprite(x-22 - 16, y+119, fln, false, 0, fcolormap, NULL))
			{
				patch_t *ico = W_CachePatchName(followers[fln].icon, PU_CACHE);
				V_DrawMappedPatch(x+14+18, y+66, 0, ico, fcolormap);
			}
		}
	}

	V_DrawCenteredGamemodeString(x, y+24, 0, 0, pname);

	// Card bottom to overlay the skin preview
	V_DrawFixedPatch(x*FRACUNIT, y*FRACUNIT, FRACUNIT, 0, cardbot, colormap);

	// Profile number & player name

	if (p != NULL)
	{
		V_DrawProfileNum(x + 37 + 10, y + 131, 0, PR_GetProfileNum(p));
		V_DrawCenteredThinString(x, y + 141, V_GRAYMAP, p->playername);
		V_DrawCenteredThinString(x, y + 151, V_GRAYMAP, GetPrettyRRID(p->public_key, true));
	}
}

void M_DrawCharacterSelect(void)
{
	const UINT8 pid = 0;

	UINT8 i, j, k;
	UINT8 priority = 0;
	INT16 quadx, quady;
	INT16 skin;
	INT32 basex = optionsmenu.profile ? (64 + M_EaseWithTransition(Easing_InSine, 5 * 48)) : 0;
	boolean forceskin = M_CharacterSelectForceInAction();

	if (setup_numplayers > 0)
	{
		priority = setup_animcounter % setup_numplayers;
	}

	{
		const int kLeft = 76;
		const int kTop = 6;
		const int kButtonWidth = 16;
		INT32 x = basex + kLeft;

		if (!optionsmenu.profile) // Does nothing on this screen
		{
			K_drawButton((x += 22) * FRACUNIT, (kTop - 3) * FRACUNIT, 0, kp_button_r, M_MenuButtonPressed(pid, MBT_R));
			V_DrawThinString((x += kButtonWidth), kTop, 0, "Info");
		}

		K_drawButton((x += 58) * FRACUNIT, (kTop - 1) * FRACUNIT, 0, kp_button_c[1], M_MenuButtonPressed(pid, MBT_C));
		V_DrawThinString((x += kButtonWidth), kTop, 0, "Default");
	}

	// We have to loop twice -- first time to draw the drop shadows, a second time to draw the icons.
	if (forceskin == false)
	{
		for (i = 0; i < 9; i++)
		{
			for (j = 0; j < 9; j++)
			{
				skin = setup_chargrid[i][j].skinlist[setup_page];
				quadx = 4 * (i / 3);
				quady = 4 * (j / 3);

				// Here's a quick little cheat to save on drawing time!
				// Don't draw a shadow if it'll get covered by another icon
				if ((i % 3 < 2) && (j % 3 < 2))
				{
					if ((setup_chargrid[i+1][j].skinlist[setup_page] != -1)
					&& (setup_chargrid[i][j+1].skinlist[setup_page] != -1)
					&& (setup_chargrid[i+1][j+1].skinlist[setup_page] != -1))
						continue;
				}

				if (skin != -1)
					V_DrawScaledPatch(basex+ 82 + (i*16) + quadx + 1, 22 + (j*16) + quady + 1, 0, W_CachePatchName("ICONBACK", PU_CACHE));
			}
		}
	}

	// Draw this inbetween. These drop shadows should be covered by the stat graph, but the icons shouldn't.
	V_DrawScaledPatch(basex+ 3, 2, 0, W_CachePatchName((optionsmenu.profile ? "PR_STGRPH" : "STATGRPH"), PU_CACHE));

	// Draw the icons now
	for (i = 0; i < 9; i++)
	{
		if ((forceskin == true) && (i != skins[cv_forceskin.value].kartspeed-1))
			continue;

		for (j = 0; j < 9; j++)
		{
			if (forceskin == true)
			{
				if (j != skins[cv_forceskin.value].kartweight-1)
					continue;
				skin = cv_forceskin.value;
			}
			else
			{
				skin = setup_chargrid[i][j].skinlist[setup_page];
			}

			for (k = 0; k < setup_numplayers; k++)
			{
				if (setup_player[k].mdepth < CSSTEP_ASKCHANGES)
					continue;
				if (setup_player[k].gridx != i || setup_player[k].gridy != j)
					continue;
				break; // k == setup_numplayers means no one has it selected
			}

			quadx = 4 * (i / 3);
			quady = 4 * (j / 3);

			if (skin != -1)
			{
				UINT8 *colormap;

				if (k == setup_numplayers)
					colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_GREY, GTC_MENUCACHE);
				else
					colormap = R_GetTranslationColormap(skin, skins[skin].prefcolor, GTC_MENUCACHE);

				V_DrawMappedPatch(basex + 82 + (i*16) + quadx, 22 + (j*16) + quady, 0, faceprefix[skin][FACE_RANK], colormap);

				// draw dot if there are more alts behind there!
				if (forceskin == false && setup_page+1 < setup_chargrid[i][j].numskins)
					V_DrawScaledPatch(basex + 82 + (i*16) + quadx, 22 + (j*16) + quady + 11, 0, W_CachePatchName("ALTSDOT", PU_CACHE));
			}
		}
	}

	// Explosions when you've made your final selection
	M_DrawCharSelectExplosions(true, 82, 22);

	for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
	{
		// Draw a preview for each player
		if (optionsmenu.profile == NULL)
		{
			M_DrawCharSelectPreview(i);
		}
		else if (i == 0)
		{
			M_DrawProfileCard(optionsmenu.optx, optionsmenu.opty, false, optionsmenu.profile);
		}

		if (i >= setup_numplayers)
			continue;

		// Draw the cursors
		if (i != priority)
			M_DrawCharSelectCursor(i);
	}

	if (setup_numplayers > 0)
	{
		// Draw the priority player over the other ones
		M_DrawCharSelectCursor(priority);
	}
}

// DIFFICULTY SELECT
// This is a mix of K_DrawKartGamemodeMenu and the generic menu drawer depending on what we need.
// This is only ever used here (I hope because this is starting to pile up on hacks to look like the old m_menu.c lol...)

void M_DrawRaceDifficulty(void)
{
	patch_t *box = W_CachePatchName("M_DBOX", PU_CACHE);

	INT32 i;
	INT32 tx = M_EaseWithTransition(Easing_Linear, 5 * 48);
	INT32 x = 120 + tx;
	INT32 y = 48;

	M_DrawMenuTooltips();

	// Draw the box for difficulty...
	V_DrawFixedPatch((111 + tx)*FRACUNIT, 33*FRACUNIT, FRACUNIT, 0, box, NULL);

	for (i = 0; i < currentMenu->numitems; i++)
	{
		if (i >= currentMenu->extra1)
		{
			x = GM_STARTX + (GM_XOFFSET * 5 / 2);
			y = GM_STARTY + (GM_YOFFSET * 5 / 2);

			if (i < currentMenu->numitems-1)
			{
				x -= GM_XOFFSET;
				y -= GM_YOFFSET;
			}

			x += tx;
		}

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			// This is HACKY......

			case IT_STRING2:
			{

				INT32 f = (i == itemOn) ? highlightflags : 0;

				if (currentMenu->menuitems[i].status & IT_CVAR)
				{
					// implicitely we'll only take care of normal cvars
					INT32 cx = 190 + tx;
					consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;

					if (i == itemOn)
					{

						INT32 w = V_MenuStringWidth(cv->string, 0)/2;

						M_DrawUnderline(124, 190 + w, y);

						V_DrawMenuString(cx - 10 - w - (skullAnimCounter/5), y, highlightflags, "\x1C"); // left arrow
						V_DrawMenuString(cx + w + 2 + (skullAnimCounter/5), y, highlightflags, "\x1D"); // right arrow
					}

					V_DrawCenteredMenuString(cx, y, f, cv->string);
				}

				V_DrawMenuString(124 + tx + (i == itemOn ? 1 : 0), y, f, currentMenu->menuitems[i].text);

				if (i == itemOn)
				{
					M_DrawCursorHand(124 + tx, y);
				}

				y += 14;

				break;
			}

			case IT_STRING:
			{

				INT32 cx = x;
				UINT8 *colormap = NULL;

				if (i == itemOn)
				{
					colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);

					if (i >= currentMenu->extra1)
					{
						cx -= Easing_OutSine(M_DueFrac(gm_flipStart, GM_FLIPTIME), 0, GM_XOFFSET / 2);
					}
				}
				else
				{
					colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_MOSS, GTC_CACHE);
				}


				if (currentMenu->menuitems[i].status & (IT_CVAR | IT_ARROWS))
				{

					INT32 fx = (cx - tx);
					INT32 centx = fx + (320-fx)/2 + (tx);	// undo the menutransition movement to redo it here otherwise the text won't move at the same speed lole.

					const char *val = currentMenu->menuitems[i].text;
					if (currentMenu->menuitems[i].status & IT_CVAR)
					{
						consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;
						val = cv->string;
					}

					V_DrawFixedPatch(cx*FRACUNIT, y*FRACUNIT, FRACUNIT, 0, W_CachePatchName("MENUSHRT", PU_CACHE), colormap);
					V_DrawCenteredGamemodeString(centx, y - 3, 0, colormap, val);

					if (i == itemOn)
					{
						patch_t *arr_r = W_CachePatchName("GM_ARRL", PU_CACHE);
						patch_t *arr_l = W_CachePatchName("GM_ARRR", PU_CACHE);

						V_DrawFixedPatch((centx-54 - arr_r->width - (skullAnimCounter/5))*FRACUNIT, (y-3)*FRACUNIT, FRACUNIT, 0, arr_r, colormap);
						V_DrawFixedPatch((centx+54 + (skullAnimCounter/5))*FRACUNIT, (y-3)*FRACUNIT, FRACUNIT, 0, arr_l, colormap);
					}

				}
				else	// not a cvar
				{
					V_DrawFixedPatch(cx*FRACUNIT, y*FRACUNIT, FRACUNIT, 0, W_CachePatchName("MENUPLTR", PU_CACHE), colormap);
					V_DrawGamemodeString(cx + 16, y - 3, 0, colormap, currentMenu->menuitems[i].text);
				}
				x += GM_XOFFSET;
				y += GM_YOFFSET;

				if (i < currentMenu->extra1)
				{
					y += 2; // extra spacing for Match Race options
				}

				break;
			}

			case IT_PATCH:
			{
				extern menu_anim_t g_drace_timer;
				const menuitem_t *it = &currentMenu->menuitems[i];
				boolean activated = g_drace_timer.dist == i;
				boolean flicker = activated && (I_GetTime() - g_drace_timer.start) % 2 < 1;

				INT32 cx = it->mvar1 + tx;
				INT32 cy = 79;

				const char *pat = i == drace_mritems && cv_thunderdome.value ? "RBOXTOGG" : it->patch;

				V_DrawMappedPatch(cx, cy, 0, W_CachePatchName(pat, PU_CACHE),
					flicker ? R_GetTranslationColormap(TC_HITLAG, 0, GTC_MENUCACHE) : NULL);

				if (it->itemaction.cvar && !it->itemaction.cvar->value)
				{
					V_DrawMappedPatch(cx, cy, 0, W_CachePatchName("OFF_TOGG", PU_CACHE), NULL);
				}

				patch_t **bt = NULL;
				switch (it->mvar2)
				{
					case MBT_Y:
						bt = kp_button_y[1];
						break;

					case MBT_Z:
						bt = kp_button_z[1];
						break;
				}
				if (bt)
				{
					K_drawButton((cx + 24) * FRACUNIT, (cy + 22) * FRACUNIT, 0, bt, activated);
				}
				break;
			}
		}
	}
}

// LEVEL SELECT

static void M_DrawCupPreview(INT16 y, levelsearch_t *baselevelsearch)
{
	levelsearch_t locklesslevelsearch = *baselevelsearch; // full copy
	locklesslevelsearch.checklocked = false;

	UINT8 i = 0;
	INT16 maxlevels = M_CountLevelsToShowInList(&locklesslevelsearch);
	const fixed_t step = (82 * FRACUNIT);
	fixed_t previewanimwork = (cupgrid.previewanim * FRACUNIT) + rendertimefrac_unpaused;
	fixed_t x = -(previewanimwork % step);
	INT16 map, start = M_GetFirstLevelInList(&i, &locklesslevelsearch);
	UINT8 starti = i;

	patch_t *staticpat = unvisitedlvl[cupgrid.previewanim % 4];

	if (baselevelsearch->cup && maxlevels > 0)
	{
		INT16 add = (previewanimwork / step) % maxlevels;
		map = start;
		while (add > 0)
		{
			map = M_GetNextLevelInList(map, &i, &locklesslevelsearch);

			if (map >= nummapheaders)
			{
				break;
			}

			add--;
		}
		while (x < BASEVIDWIDTH * FRACUNIT)
		{
			if (map >= nummapheaders)
			{
				map = start;
				i = starti;
			}

			if (M_CanShowLevelInList(map, baselevelsearch))
			{
				K_DrawMapThumbnail(
					x + FRACUNIT, (y+2)<<FRACBITS,
					80<<FRACBITS,
					0,
					map,
					NULL);
			}
			else
			{
				V_DrawFixedPatch(
					x + FRACUNIT, (y+2) * FRACUNIT,
					FRACUNIT,
					0,
					staticpat,
					NULL);
			}

			x += step;

			map = M_GetNextLevelInList(map, &i, &locklesslevelsearch);
		}
	}
	else
	{
		while (x < BASEVIDWIDTH * FRACUNIT)
		{
			V_DrawFixedPatch(x + FRACUNIT, (y+2) * FRACUNIT, FRACUNIT, 0, staticpat, NULL);
			x += step;
		}
	}
}

static void M_DrawCupTitle(INT16 y, levelsearch_t *levelsearch)
{
	UINT8 temp = 0;

	V_DrawScaledPatch(0, y, 0, W_CachePatchName("MENUHINT", PU_CACHE));

	if (levelsearch->cup == &dummy_lostandfound)
	{
		V_DrawCenteredLSTitleLowString(BASEVIDWIDTH/2, y+6, 0, "Lost & Found");
	}
	else if (levelsearch->cup)
	{
		boolean unlocked = (M_GetFirstLevelInList(&temp, levelsearch) != NEXTMAP_INVALID);
		UINT8 *colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_GREY, GTC_MENUCACHE);
		patch_t *icon = W_CachePatchName(levelsearch->cup->icon, PU_CACHE);
		const char *str = (unlocked ? va("%s Cup", levelsearch->cup->realname) : "???");
		INT16 offset = V_LSTitleLowStringWidth(str, 0) / 2;

		V_DrawLSTitleLowString(BASEVIDWIDTH/2 - offset, y+6, 0, str);

		if (unlocked)
		{
			V_DrawMappedPatch(BASEVIDWIDTH/2 - offset - 24, y+5, 0, icon, colormap);
			V_DrawMappedPatch(BASEVIDWIDTH/2 + offset + 3, y+5, 0, icon, colormap);
		}
	}
	else
	{
		if (currentMenu == &PLAY_LevelSelectDef)
		{
			UINT8 namedgt = (levellist.guessgt != MAXGAMETYPES) ? levellist.guessgt : levellist.newgametype;
			V_DrawCenteredLSTitleLowString(BASEVIDWIDTH/2, y+6, 0, va("%s Mode", gametypes[namedgt]->name));
		}
	}
}

fixed_t M_DrawCupWinData(INT32 rankx, INT32 ranky, cupheader_t *cup, UINT8 difficulty, boolean flash, boolean statsmode)
{
	INT32 rankw = 14 + 1 + 12 + 1 + 12;

	if (!cup)
		return 0;

	boolean noemerald = (!gamedata->everseenspecial || difficulty == KARTSPEED_EASY);

	if (statsmode)
	{
		rankw += 10 + 1;

		if (noemerald)
		{
			rankw -= (12 + 1);
			rankx += 7; // vibes-based maths, as tyron puts it
		}
	}

	rankx += 19 - (rankw / 2);

	cupwindata_t *windata = &(cup->windata[difficulty]);
	UINT8 emeraldnum = UINT8_MAX;

	if (!noemerald)
	{
		if (gamedata->sealedswaps[GDMAX_SEALEDSWAPS-1] != NULL // all found
		|| cup->id >= basenumkartcupheaders // custom content
		|| M_SecretUnlocked(SECRET_SPECIALATTACK, true)) // true order
		{
			// Standard order.
			if (windata->got_emerald == true)
			{
				emeraldnum = cup->emeraldnum;
			}
		}
		else
		{
			// Determine order from sealedswaps.
			UINT8 i;
			for (i = 0; (i < GDMAX_SEALEDSWAPS && gamedata->sealedswaps[i]); i++)
			{
				if (gamedata->sealedswaps[i] != cup)
					continue;

				break;
			}

			// If there's pending stars, get them from the associated cup order.
			if (i < GDMAX_SEALEDSWAPS)
			{
				cupheader_t *emeraldcup = kartcupheaders;
				while (emeraldcup)
				{
					if (emeraldcup->id >= basenumkartcupheaders)
					{
						emeraldcup = NULL;
						break;
					}

					if (emeraldcup->emeraldnum == i+1)
					{
						if (emeraldcup->windata[difficulty].got_emerald == true)
							emeraldnum = i+1;
						break;
					}

					emeraldcup = emeraldcup->next;
				}
			}
		}
	}

	if (windata->best_placement == 0)
	{
		if (statsmode)
		{
			V_DrawCharacter((10-4)/2 + rankx, ranky, '.' | V_GRAYMAP, false);
			rankx += 10 + 1;
			V_DrawCharacter((14-4)/2 + rankx, ranky, '.' | V_GRAYMAP, false);
			rankx += 14 + 1;
			V_DrawCharacter((12-4)/2 + rankx, ranky, '.' | V_GRAYMAP, false);
		}
		else
		{
			rankx += 14 + 1;
		}

		goto windataemeraldmaybe;
	}

	UINT8 *colormap = NULL;

	if (statsmode)
	{
		const char monitorletter = (cup->monitor < 10) ? ('0' + cup->monitor) : ('A' + (cup->monitor - 10));
		patch_t *monPat = W_CachePatchName(va("CUPMON%c%c", monitorletter, 'C'), PU_CACHE);
		UINT16 moncolor = SKINCOLOR_NONE;

		switch (windata->best_placement)
		{
			case 1:
				moncolor = SKINCOLOR_GOLD;
				break;
			case 2:
				moncolor = SKINCOLOR_SILVER;
				break;
			case 3:
				moncolor = SKINCOLOR_BRONZE;
				break;
			default:
				moncolor = SKINCOLOR_BEIGE;
				break;
		}

		if (moncolor != SKINCOLOR_NONE)
			colormap = R_GetTranslationColormap(TC_RAINBOW, moncolor, GTC_MENUCACHE);

		if (monPat)
			V_DrawFixedPatch((rankx)*FRACUNIT, (ranky)*FRACUNIT, FRACUNIT, 0, monPat, colormap);

		rankx += 10 + 1;

		colormap = NULL;
	}

	const gp_rank_e grade = windata->best_grade; // (cupgrid.previewanim/TICRATE) % (GRADE_S + 1); -- testing
	patch_t *gradePat = NULL;
	UINT16 gradecolor = K_GetGradeColor(grade);

	if (gradecolor != SKINCOLOR_NONE)
		colormap = R_GetTranslationColormap(TC_DEFAULT, gradecolor, GTC_MENUCACHE);

	switch (grade)
	{
		case GRADE_E:
			gradePat = W_CachePatchName("R_CUPRNE", PU_CACHE);
			break;
		case GRADE_D:
			gradePat = W_CachePatchName("R_CUPRND", PU_CACHE);
			break;
		case GRADE_C:
			gradePat = W_CachePatchName("R_CUPRNC", PU_CACHE);
			break;
		case GRADE_B:
			gradePat = W_CachePatchName("R_CUPRNB", PU_CACHE);
			break;
		case GRADE_A:
			gradePat = W_CachePatchName("R_CUPRNA", PU_CACHE);
			break;
		case GRADE_S:
			gradePat = W_CachePatchName("R_CUPRNS", PU_CACHE);
			break;
		default:
			break;
	}

	if (gradePat)
		V_DrawFixedPatch((rankx)*FRACUNIT, (ranky)*FRACUNIT, FRACUNIT, 0, gradePat, colormap);

	rankx += 14 + 1;

	patch_t *charPat = NULL;

	if ((windata->best_skin.unloaded != NULL)
		|| (windata->best_skin.id > numskins))
	{
		colormap = NULL;

		charPat = W_CachePatchName("HUHMAP", PU_CACHE);
	}
	else
	{
		UINT8 skin = windata->best_skin.id;

		colormap = R_GetTranslationColormap(skin, skins[skin].prefcolor, GTC_MENUCACHE);

		charPat = faceprefix[skin][FACE_MINIMAP];
	}

	if (charPat)
		V_DrawFixedPatch((rankx)*FRACUNIT, (ranky)*FRACUNIT, FRACUNIT, 0, charPat, colormap);

windataemeraldmaybe:

	rankx += 12 + 1;

	if (noemerald)
		;
	else if (emeraldnum != UINT8_MAX)
	{
		if (emeraldnum == 0)
			V_DrawCharacter(rankx+2, ranky+2, '+', false);
		else
		{
			colormap = NULL;

			if (!flash)
			{
				UINT16 col = SKINCOLOR_CHAOSEMERALD1 + (emeraldnum-1) % 7;

				colormap = R_GetTranslationColormap(TC_DEFAULT, col, GTC_MENUCACHE);
			}

			const char *emname = va(
				"%sMAP%c",
				(emeraldnum > 7) ? "SUP" : "EME",
				colormap ? '\0' : 'B'
			);

			V_DrawFixedPatch((rankx)*FRACUNIT, (ranky)*FRACUNIT, FRACUNIT, 0, W_CachePatchName(emname, PU_CACHE), colormap);
		}
	}
	else if (statsmode)
	{
		V_DrawCharacter((12-4)/2 + rankx, ranky, '.' | V_GRAYMAP, false);
	}

	return rankw;
}

void M_DrawCup(cupheader_t *cup, fixed_t x, fixed_t y, INT32 lockedTic, boolean isTrophy, UINT8 placement)
{
	patch_t *patch = NULL;
	UINT8 *colormap = NULL;
	INT16 icony = 7;
	char status = 'A';
	char monitor = '0';

	if (isTrophy)
	{
		UINT16 col = SKINCOLOR_NONE;

		switch (placement)
		{
			case 0:
				break;
			case 1:
				col = SKINCOLOR_GOLD;
				status = 'B';
				break;
			case 2:
				col = SKINCOLOR_SILVER;
				status = 'B';
				break;
			case 3:
				col = SKINCOLOR_BRONZE;
				status = 'B';
				break;
			default:
				col = SKINCOLOR_BEIGE;
				break;
		}

		if (col != SKINCOLOR_NONE)
			colormap = R_GetTranslationColormap(TC_RAINBOW, col, GTC_MENUCACHE);
		else
			colormap = NULL;
	}

	if (cup == &dummy_lostandfound)
	{
		// No cup? Lost and found!
		monitor = '0';
	}
	else
	{
		if (cup->monitor < 10)
		{
			monitor = '0' + cup->monitor;

			if (monitor == '2')
			{
				icony = 5; // by default already 7px down, so this is really 2px further up
			}
			else if (monitor == '3')
			{
				icony = 6;
			}
		}
		else
		{
			monitor = 'A' + (cup->monitor - 10);
			if (monitor == 'X')
			{
				icony = 11;
			}
		}
	}

	patch = W_CachePatchName(va("CUPMON%c%c", monitor, status), PU_CACHE);
	V_DrawFixedPatch(x, y, FRACUNIT, 0, patch, colormap);

	if (cup == &dummy_lostandfound)
	{
		; // Only ever placed on the list if valid
	}
	else if (lockedTic != 0)
	{
		patch_t *st = W_CachePatchName(va("ICONST0%d", (lockedTic % 4) + 1), PU_CACHE);
		V_DrawFixedPatch(x + (8 * FRACUNIT), y + (icony * FRACUNIT), FRACUNIT, 0, st, NULL);
	}
	else
	{
		V_DrawFixedPatch(x + (8 * FRACUNIT), y + (icony * FRACUNIT), FRACUNIT, 0, W_CachePatchName(cup->icon, PU_CACHE), NULL);
		V_DrawFixedPatch(x + (8 * FRACUNIT), y + (icony * FRACUNIT), FRACUNIT, 0, W_CachePatchName("CUPBOX", PU_CACHE), NULL);
	}
}

void M_DrawCupSelect(void)
{
	UINT8 i, j, temp = 0;
	INT16 x, y;
	INT16 cy = M_EaseWithTransition(Easing_Linear, 5 * 30);
	cupwindata_t *windata = NULL;
	levelsearch_t templevelsearch = levellist.levelsearch; // full copy

	for (i = 0; i < CUPMENU_COLUMNS; i++)
	{
		x = 14 + (i*42);

		for (j = 0; j < (cupgrid.cache_secondrowlocked ? 1 : CUPMENU_ROWS); j++)
		{
			size_t id = (i + (j * CUPMENU_COLUMNS)) + (cupgrid.pageno * (CUPMENU_COLUMNS * CUPMENU_ROWS));

			if (!cupgrid.builtgrid[id])
				break;

			templevelsearch.cup = cupgrid.builtgrid[id];

			y = 20 + (j*44) - cy;
			if (cupgrid.cache_secondrowlocked == true)
				y += 28;

			const boolean isGP = (cupgrid.grandprix && (cv_dummygpdifficulty.value >= 0 && cv_dummygpdifficulty.value < KARTGP_MAX));
			if (isGP)
			{
				windata = &templevelsearch.cup->windata[cv_dummygpdifficulty.value];
			}

			M_DrawCup(
				templevelsearch.cup,
				x * FRACUNIT, y * FRACUNIT,
				(M_GetFirstLevelInList(&temp, &templevelsearch) == NEXTMAP_INVALID) ? ((cupgrid.previewanim % 4) + 1) : 0,
				isGP,
				windata ? windata->best_placement : 0
			);

			if (cupgrid.grandprix == true
				&& templevelsearch.cup == cupsavedata.cup
				&& id != CUPMENU_CURSORID)
			{
				V_DrawScaledPatch(x + 32, y + 32, 0, W_CachePatchName("CUPBKUP1", PU_CACHE));
			}

			// used to be 8 + (j*100) - (30*menutransition.tics)
			// but one-row mode means y has to be changed
			// this is the difference between y and that
			if (j == 0)
			{
				y -= 12; // (8) - (20)
			}
			else
			{
				y += 44; //(8 + 100) - (20 + 44)
			}

			if (windata)
			{
				M_DrawCupWinData(
					x,
					y,
					templevelsearch.cup,
					cv_dummygpdifficulty.value,
					(cupgrid.previewanim & 1),
					false
				);
			}
		}
	}

	{
		fixed_t tx = Easing_Linear(M_DueFrac(cupgrid.xslide.start, CUPMENU_SLIDETIME), cupgrid.xslide.dist * FRACUNIT, 0);
		fixed_t ty = Easing_Linear(M_DueFrac(cupgrid.yslide.start, CUPMENU_SLIDETIME), cupgrid.yslide.dist * FRACUNIT, 0);

		x = 14 + (cupgrid.x*42*FRACUNIT - tx) / FRACUNIT;
		y = 20 + (cupgrid.y*44*FRACUNIT - ty) / FRACUNIT - cy;
	}

	if (cupgrid.cache_secondrowlocked == true)
		y += 28;

	V_DrawScaledPatch(x - 4, y - 1, 0, W_CachePatchName("CUPCURS", PU_CACHE));

	templevelsearch.cup = cupgrid.builtgrid[CUPMENU_CURSORID];

	if (cupgrid.grandprix == true
	&& templevelsearch.cup != NULL
	&& templevelsearch.cup == cupsavedata.cup)
	{
		V_DrawScaledPatch(
			14 + (cupgrid.x*42) + 32,
			20 + (cupgrid.y*44) + 32
				+ ((cupgrid.cache_secondrowlocked == true) ? 28 : 0),
			0,
			W_CachePatchName("CUPBKUP2", PU_CACHE)
		);
	}

	INT16 ty = M_EaseWithTransition(Easing_Linear, 5 * 24);
	V_DrawFill(0, 146 + ty, BASEVIDWIDTH, 54, 31);
	M_DrawCupPreview(146 + ty, &templevelsearch);

	M_DrawCupTitle(120 - ty, &templevelsearch);

	if (cupgrid.numpages > 1)
	{
		x = 3 - (skullAnimCounter/5);
		y = 20 + (44 - 1) - cy;

		patch_t *cuparrow = W_CachePatchName("CUPARROW", PU_CACHE);

		if (cupgrid.pageno != 0)
			V_DrawScaledPatch(x, y, 0, cuparrow);

		if (cupgrid.pageno != cupgrid.numpages-1)
			V_DrawScaledPatch(BASEVIDWIDTH-x, y, V_FLIP, cuparrow);
	}
}

static void M_DrawHighLowLevelTitle(INT16 x, INT16 y, INT16 map)
{
	char word1[22];
	char word2[22 + 2]; // actnum
	UINT8 word1len = 0;
	UINT8 word2len = 0;
	INT16 x2 = x;
	UINT8 i;

	if (!mapheaderinfo[map]
		|| (
			!mapheaderinfo[map]->menuttl[0]
			&& !mapheaderinfo[map]->lvlttl[0]
		)
	)
		return;

	if (!mapheaderinfo[map]->menuttl[0]
		&& mapheaderinfo[map]->zonttl[0])
	{
		boolean one = true;
		boolean two = true;

		for (i = 0; i < 22; i++)
		{
			if (!one && !two)
				break;

			if (mapheaderinfo[map]->lvlttl[i] && one)
			{
				word1[word1len] = mapheaderinfo[map]->lvlttl[i];
				word1len++;
			}
			else
				one = false;

			if (mapheaderinfo[map]->zonttl[i] && two)
			{
				word2[word2len] = mapheaderinfo[map]->zonttl[i];
				word2len++;
			}
			else
				two = false;
		}
	}
	else
	{
		char *ttlsource =
			mapheaderinfo[map]->menuttl[0]
			? mapheaderinfo[map]->menuttl
			: mapheaderinfo[map]->lvlttl;

		// If there are 2 or more words:
		// - Last word goes on word2
		// - Everything else on word1
		char *p = strrchr(ttlsource, ' ');
		if (p)
		{
			word2len = strlen(p + 1);
			memcpy(word2, p + 1, word2len);
		}
		else
			p = ttlsource + strlen(ttlsource);

		word1len = p - ttlsource;
		memcpy(word1, ttlsource, word1len);
	}

	if (!mapheaderinfo[map]->menuttl[0] && mapheaderinfo[map]->actnum)
	{
		word2[word2len] = ' ';
		word2len++;

		word2[word2len] = '0' + mapheaderinfo[map]->actnum;
		word2len++;
	}

	word1[word1len] = '\0';
	word2[word2len] = '\0';

	{
		char addlen[3];

		for (i = 0; i < 2; i++)
		{
			if (!word1[i])
				break;

			addlen[i] = word1[i];
		}

		addlen[i] = '\0';
		x2 += V_LSTitleLowStringWidth(addlen, 0);
	}


	if (word1len)
		V_DrawLSTitleHighString(x, y, 0, word1);
	if (word2len)
		V_DrawLSTitleLowString(x2, y+28, 0, word2);
}

static void M_DrawLevelSelectBlock(INT16 x, INT16 y, UINT16 map, boolean redblink, boolean greyscale)
{
	UINT8 *colormap = NULL;

	if (greyscale)
		colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_GREY, GTC_MENUCACHE);

	if (redblink)
		V_DrawScaledPatch(3+x, y, 0, W_CachePatchName("LVLSEL2", PU_CACHE));
	else
		V_DrawScaledPatch(3+x, y, 0, W_CachePatchName("LVLSEL", PU_CACHE));

	K_DrawMapThumbnail(
		(9+x)<<FRACBITS, (y+6)<<FRACBITS,
		80<<FRACBITS,
		0,
		map,
		colormap);
	M_DrawHighLowLevelTitle(98+x, y+8, map);

	if (levellist.levelsearch.tutorial && !(mapheaderinfo[map]->records.mapvisited & MV_BEATEN))
	{
		V_DrawScaledPatch(
			x + 80 + 3, y + 50, 0,
			W_CachePatchName(
				va(
					"CUPBKUP%c",
					(greyscale ? '1' : '2')
				),
				PU_CACHE
			)
		);
	}
}

void M_DrawLevelSelect(void)
{
	INT16 i = 0;
	UINT8 j = 0;
	INT16 map = M_GetFirstLevelInList(&j, &levellist.levelsearch);
	INT16 t = M_EaseWithTransition(Easing_Linear, 5 * 64), tay = 0;
	INT16 y = 80 - levellist.y +
		Easing_OutSine(
			M_DueFrac(levellist.slide.start, 4),
			levellist.slide.dist,
			0
		);
	boolean tatransition = ((menutransition.startmenu == &PLAY_TimeAttackDef || menutransition.endmenu == &PLAY_TimeAttackDef) && menutransition.tics != menutransition.dest);

	if (tatransition)
	{
		t = -t;
		tay = t/2;
	}

	while (true)
	{
		INT16 lvlx = t, lvly = y;

		if (map >= nummapheaders)
			break;

		if (i == levellist.cursor && tatransition)
		{
			lvlx = 0;
			lvly = max(2, y+tay);
		}

		M_DrawLevelSelectBlock(lvlx, lvly, map,
			(i == levellist.cursor && (((skullAnimCounter / 4) & 1) || tatransition)),
			(i != levellist.cursor)
		);

		y += 72;
		i++;
		map = M_GetNextLevelInList(map, &j, &levellist.levelsearch);
	}

	M_DrawCupTitle(tay, &levellist.levelsearch);
}

static boolean M_LevelSelectHasBG(menu_t *check)
{
	if (check == NULL)
		check = currentMenu;

	return (check == &PLAY_LevelSelectDef
	|| check == &PLAY_CupSelectDef);
}

static boolean M_LevelSelectToTimeAttackTransitionHelper(void)
{
	return (M_LevelSelectHasBG(menutransition.startmenu))
		!= M_LevelSelectHasBG(menutransition.endmenu);
}

void M_DrawSealedBack(void)
{
	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);

	if (M_LevelSelectHasBG(currentMenu) == false)
		return;

	INT32 translucencylevel = 7;
	if (M_LevelSelectToTimeAttackTransitionHelper())
	{
		translucencylevel += menutransition.tics/3;

		if (translucencylevel >= 10)
			return;
	}

	V_DrawFixedPatch(
		0, 0,
		FRACUNIT,
		translucencylevel << V_ALPHASHIFT,
		W_CachePatchName("MENUI008", PU_CACHE),
		R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_BLACK, GTC_CACHE)
	);
}

void M_DrawTimeAttack(void)
{
	UINT16 map = levellist.choosemap;
	INT16 t = M_EaseWithTransition(Easing_Linear, 5 * 48);
	INT16 leftedge = 149+t+16;
	INT16 rightedge = 149+t+155;
	INT16 opty = 140;
	INT32 w;
	UINT8 i;

	V_DrawScaledPatch(149+t, 70, 0, W_CachePatchName("BESTTIME", PU_CACHE));

	if (!mapheaderinfo[map])
	{
		V_DrawRightAlignedMenuString(rightedge-12, opty, 0, "No map!?");
		return;
	}

	{
		patch_t *minimap = NULL;
		INT32 minimapx = 76, minimapy = 130;

		if (M_LevelSelectToTimeAttackTransitionHelper())
			minimapx -= t;

		if (levellist.newgametype == GT_SPECIAL)
		{
			// Star Within The Seal

#define SEAL_PULSELEN ((6*TICRATE)/5) // The rate of O_SSTAR3
			INT32 crossfade = (timeattackmenu.ticker % (2*SEAL_PULSELEN)) - SEAL_PULSELEN;
			if (crossfade < 0)
				crossfade = -crossfade;
			crossfade = (crossfade * 10)/SEAL_PULSELEN;
#undef SEAL_PULSELEN

			if (crossfade != 10)
			{
				minimap = W_CachePatchName(
					"K_FINB05",
					PU_CACHE
				);

				V_DrawScaledPatch(
					minimapx, minimapy,
					0, minimap
				);
			}

			if (crossfade != 0)
			{
				minimap = W_CachePatchName(
					"K_FINB04",
					PU_CACHE
				);

				V_DrawScaledPatch(
					minimapx, minimapy,
					(10-crossfade)<<V_ALPHASHIFT,
					minimap
				);
			}
		}
		else if (levellist.newgametype == GT_VERSUS)
		{
			const INT32 teaserh = 56;
			minimapy -= 1; // tiny adjustment

			V_DrawScaledPatch(
				minimapx, minimapy - teaserh,
				V_TRANSLUCENT, W_CachePatchName("K_TEASR2", PU_CACHE)
			);
			V_DrawScaledPatch(
				minimapx, minimapy + teaserh,
				V_TRANSLUCENT, W_CachePatchName("K_TEASR4", PU_CACHE)
			);
			V_DrawScaledPatch(
				minimapx, minimapy,
				0, W_CachePatchName("K_TEASR3", PU_CACHE)
			);
		}
		else if ((minimap = mapheaderinfo[map]->minimapPic))
		{
			V_DrawScaledPatch(
				minimapx - (SHORT(minimap->width)/2),
				minimapy - (SHORT(minimap->height)/2),
				0, minimap
			);
		}
	}

	if (currentMenu == &PLAY_TimeAttackDef)
	{
		recorddata_t *rcp = &mapheaderinfo[map]->records;
		recordtimes_t *record = cv_dummyspbattack.value ? &rcp->spbattack : &rcp->timeattack;
		tic_t timerec = record->time;
		tic_t laprec = record->lap;
		UINT32 timeheight = 82;

		if ((gametypes[levellist.newgametype]->rules & GTR_CIRCUIT)
			&& (mapheaderinfo[map]->numlaps != 1))
		{
			V_DrawRightAlignedMenuString(rightedge-12, timeheight, M_ALTCOLOR, "BEST LAP:");
			K_drawKartTimestamp(laprec, 162+t, timeheight+6, 0, 2);
			timeheight += 30;
		}
		else
		{
			timeheight += 15;
		}

		V_DrawRightAlignedMenuString(rightedge-12, timeheight, M_ALTCOLOR, "BEST TIME:");
		K_drawKartTimestamp(timerec, 162+t, timeheight+6, 0, 1);

		// SPB Attack control hint + menu overlay
		{
			INT32 buttonx = 162 + t;
			INT32 buttony = timeheight;

			if (M_EncoreAttackTogglePermitted())
			{
				K_drawButtonAnim(buttonx + 35, buttony - 3, 0, kp_button_r, timeattackmenu.ticker);
			}

			if ((timeattackmenu.spbflicker == 0 || timeattackmenu.ticker % 2) == (cv_dummyspbattack.value == 1))
			{
				V_DrawMappedPatch(buttonx + 7, buttony - 1, 0, W_CachePatchName("K_SPBATK", PU_CACHE), R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_RED, GTC_MENUCACHE));
			}
		}
	}
	else
		opty = 80;

	// Done after to overlay material
	M_DrawLevelSelectBlock(0, 2, map, true, false);

	for (i = 0; i < currentMenu->numitems; i++)
	{
		UINT32 f = (i == itemOn) ? highlightflags : 0;

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{

			case IT_HEADERTEXT:

				V_DrawMenuString(leftedge, opty, M_ALTCOLOR, currentMenu->menuitems[i].text);
				opty += 10;
				break;

			case IT_STRING:

				if (i >= currentMenu->numitems-1)
				{
					V_DrawRightAlignedMenuString(rightedge, opty, f, currentMenu->menuitems[i].text);

					if (i == itemOn)
						M_DrawCursorHand(rightedge - V_MenuStringWidth(currentMenu->menuitems[i].text, 0), opty);
				}
				else
				{
					V_DrawMenuString(leftedge, opty, f, currentMenu->menuitems[i].text);

					if (i == itemOn)
						M_DrawCursorHand(leftedge, opty);
				}
				opty += 10;

				// Cvar specific handling
				{
					const char *str = NULL;
					INT32 optflags = f;
					boolean drawarrows = (i == itemOn);

					if ((currentMenu->menuitems[i].status & IT_TYPE) == IT_ARROWS)
					{
						// Currently assumes M_HandleStaffReplay
						if (mapheaderinfo[levellist.choosemap]->ghostCount <= 1)
							drawarrows = false;

						if (mapheaderinfo[levellist.choosemap] == NULL)
							str = "Invalid map";
						else if (cv_dummystaff.value > mapheaderinfo[levellist.choosemap]->ghostCount)
							str = va("%u - Invalid ID", cv_dummystaff.value+1);
						else if (mapheaderinfo[levellist.choosemap]->ghostBrief[cv_dummystaff.value] == NULL)
							str = va("%u - Invalid brief", cv_dummystaff.value+1);
						else
						{
							const char *th = "th";
							if (cv_dummystaff.value+1 == 1)
								th = "st";
							else if (cv_dummystaff.value+1 == 2)
								th = "nd";
							else if (cv_dummystaff.value+1 == 3)
								th = "rd";
							str = va("%u%s - %s",
								cv_dummystaff.value+1,
								th,
								mapheaderinfo[levellist.choosemap]->ghostBrief[cv_dummystaff.value]->name
							);
						}
					}
					else if ((currentMenu->menuitems[i].status & IT_TYPE) == IT_CVAR)
					{
						str = currentMenu->menuitems[i].itemaction.cvar->string;
					}

					if (str)
					{
						w = V_MenuStringWidth(str, optflags);
						V_DrawMenuString(leftedge+12, opty, optflags, str);
						if (drawarrows)
						{
							V_DrawMenuString(leftedge+12 - 10 - (skullAnimCounter/5), opty, f, "\x1C"); // left arrow
							V_DrawMenuString(leftedge+12 + w + 2+ (skullAnimCounter/5), opty, f, "\x1D"); // right arrow
						}
						opty += 10;
					}
				}

				break;
			case IT_SPACE:
				opty += 4;
				break;
		}
	}
}

// This draws the options of a given menu in a fashion specific to the multiplayer option select screen (host game / server browser etc)
// First argument is the menu to draw the options from, the 2nd one is a table that contains which option is to be "extendded"
// Format for each option: {extended? (only used by the ticker), max extension (likewise),  # of lines to extend}

// NOTE: This is pretty rigid and only intended for use with the multiplayer options menu which has *3* choices.

void M_DrawMasterServerReminder(void)
{
	// Did you change the Server Browser address? Have a little reminder.

	INT32 mservflags = 0;
	if (CV_IsSetToDefault(&cv_masterserver))
		mservflags = highlightflags;
	else
		mservflags = warningflags;

	INT32 y = BASEVIDHEIGHT - 10;

	V_DrawFadeFill(0, y-1, BASEVIDWIDTH, 10+1, 0, 31, 5);
	V_DrawCenteredThinString(BASEVIDWIDTH/2, y,
		mservflags, va("List via \"%s\"", cv_masterserver.string));
}

static void M_MPOptDrawer(menu_t *m, INT16 extend[3][3])
{
	// This is a copypaste of the generic gamemode menu code with a few changes.
	// TODO: Allow specific options to "expand" into smaller ones.

	patch_t *buttback = W_CachePatchName("M_PLAT2", PU_CACHE);
	INT32 i, x = 132, y = 32;	// Dirty magic numbers for now but they work out.

	for (i = 0; i < m->numitems; i++)
	{

		switch (m->menuitems[i].status & IT_DISPLAY)
		{
			case IT_STRING:
				{
					UINT8 *colormap = NULL;
					INT16 j = 0;

					if ((currentMenu == m && i == itemOn) || extend[i][0])	// Selected / unfolded
					{
						colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);
					}
					else
					{
						colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_MOSS, GTC_CACHE);
					}

					if (extend[i][2])
					{
						for (j=0; j <= extend[i][2]/2; j++)
						{
							// Draw rectangles that look like the current selected item starting from the top of the actual selection graphic and going up to where it's supposed to go.
							// With colour 169 (that's the index of the shade of black the plague colourization gives us. ...No I don't like using a magic number either.
							V_DrawFill((x-1) + (extend[i][2]/2) - j - (buttback->width/2), (y + extend[i][2]) - (2*j), 226, 2, 169);
						}
					}
					V_DrawFixedPatch((x + (extend[i][2]/2)) *FRACUNIT, (y + extend[i][2])*FRACUNIT, FRACUNIT, 0, buttback, colormap);
					V_DrawCenteredGamemodeString(x, y - 3, 0, colormap, m->menuitems[i].text);
				}
				break;
		}

		x += GM_XOFFSET;
		y += GM_YOFFSET + extend[i][2];
	}
}

// Draws the EGGA CHANNEL background.
void M_DrawEggaChannel(void)
{
	patch_t *background = W_CachePatchName("M_EGGACH", PU_CACHE);

	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 25);
	V_DrawFixedPatch((menuactive ? 75 : 160)<<FRACBITS, 104<<FRACBITS, FRACUNIT, 0, background, NULL);
	V_DrawVhsEffect(false);	// VHS the background! (...sorry OGL my love)
}

// Multiplayer mode option select
void M_DrawMPOptSelect(void)
{
	M_DrawMenuTooltips();
	M_MPOptDrawer(&PLAY_MP_OptSelectDef, mpmenu.modewinextend);
	M_DrawMasterServerReminder();
}

// Multiplayer mode option select: HOST GAME!
// A rehash of the generic menu drawer adapted to fit into that cramped space. ...A small sacrifice for utility
void M_DrawMPHost(void)
{
	patch_t *gobutt = W_CachePatchName("M_BUTTGO", PU_CACHE);	// I'm very mature
	INT32 xp = 40, yp = 64, i = 0, w = 0;	// Starting position for the text drawing.

	M_DrawMPOptSelect();	// Draw the Multiplayer option select menu first

	// Now draw our host options...
	for (i = 0; i < currentMenu->numitems; i++)
	{
		if (i == currentMenu->numitems-1)
		{
			xp = 202;
			yp = 100;

			UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_MOSS, GTC_CACHE);
			if (i == itemOn)
				colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);

			// Ideally we'd calculate this but it's not worth it for a 1-off menu probably.....
			V_DrawFixedPatch(xp<<FRACBITS, yp<<FRACBITS, FRACUNIT, 0, gobutt, colormap);
			V_DrawCenteredGamemodeString(xp + (gobutt->width/2), yp -3, 0, colormap, currentMenu->menuitems[i].text);
		}
		else
		{
			switch (currentMenu->menuitems[i].status & IT_DISPLAY)
			{
				case IT_TRANSTEXT2:
				{
					V_DrawThinString(xp, yp, V_TRANSLUCENT, currentMenu->menuitems[i].text);
					xp += 5;
					yp += 11;
					break;
				}
				case IT_STRING:
				{
					V_DrawThinString(xp, yp, (i == itemOn ? highlightflags : 0), currentMenu->menuitems[i].text);

					// Cvar specific handling
					switch (currentMenu->menuitems[i].status & IT_TYPE)
					{
						case IT_CVAR:
						{
							consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;
							switch (currentMenu->menuitems[i].status & IT_CVARTYPE)
							{
								case IT_CV_STRING:
									{
										INT32 xoffs = 0;
										if (itemOn == i)
										{
											xoffs += 8;
											V_DrawString(xp + (skullAnimCounter/5) + 94, yp+1, highlightflags, "\x1D");
										}

										V_DrawThinString(xp + xoffs + 96, yp, 0, cv->string);
									}

									break;

								default:
									w = V_ThinStringWidth(cv->string, 0);
									V_DrawThinString(xp + 138 - w, yp, ((cv->flags & CV_CHEAT) && !CV_IsSetToDefault(cv) ? warningflags : highlightflags), cv->string);
									if (i == itemOn)
									{
										V_DrawCharacter(xp + 138 - 10 - w - (skullAnimCounter/5), yp, '\x1C' | highlightflags, false); // left arrow
										V_DrawCharacter(xp + 138 + 2 + (skullAnimCounter/5), yp, '\x1D' | highlightflags, false); // right arrow
									}
									break;
							}
							break;
						}
						case IT_ARROWS:
						{
							if (currentMenu->menuitems[i].itemaction.routine != M_HandleHostMenuGametype)
								break;

							w = V_ThinStringWidth(gametypes[menugametype]->name, 0);
							V_DrawThinString(xp + 138 - w, yp, highlightflags, gametypes[menugametype]->name);
							if (i == itemOn)
							{
								V_DrawCharacter(xp + 138 - 10 - w - (skullAnimCounter/5), yp, '\x1C' | highlightflags, false); // left arrow
								V_DrawCharacter(xp + 138 + 2 + (skullAnimCounter/5), yp, '\x1D' | highlightflags, false); // right arrow
							}
							break;
						}
					}

					xp += 5;
					yp += 11;

					break;
				}
			break;
			}

		}

	}
}

// Multiplayer mode option select: JOIN BY IP
// Once again we'll copypaste 1 bit of the generic menu handler we used for hosting but we only need it for IT_CV_STRING since that's all we got :)
// (I don't like duplicating code but I rather this than some horrible all-in-one function with too many options...)
void M_DrawMPJoinIP(void)
{
	//patch_t *minibutt = W_CachePatchName("M_SBUTT", PU_CACHE);
	// There is no such things as mini butts, only thick thighs to rest your head on.
	//patch_t *minigo = W_CachePatchName("M_SGO", PU_CACHE);
	patch_t *typebar = W_CachePatchName("M_TYPEB", PU_CACHE);

	//UINT8 *colormap = NULL;
	UINT8 *colormapc = NULL;

	INT32 xp = 73, yp = 133, i = 0;	// Starting position for the text drawing.
	M_DrawMPOptSelect();	// Draw the Multiplayer option select menu first


	// Now draw our host options...
	for (i = 0; i < currentMenu->numitems; i++)
	{

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_STRING:
			{

				char str[MAX_LOGIP];
				strcpy(str, currentMenu->menuitems[i].text);

				// The last 3 options of this menu are to be the joined IP addresses...
				if (currentMenu->numitems - i <= NUMLOGIP)
				{
					UINT8 index = NUMLOGIP - (currentMenu->numitems - i);
					if (index == 0)
					{
						xp += 8;
					}

					if (joinedIPlist[index][1][0])	// Try drawing server name
						strlcpy(str, joinedIPlist[index][1], MAX_LOGIP);
					else if (joinedIPlist[index][0][0])	// If that fails, get the address
						strlcpy(str, joinedIPlist[index][0], MAX_LOGIP);
					else
						strcpy(str, "---");		// If that fails too then there's nothing!
				}

				V_DrawThinString(xp, yp, ((i == itemOn || currentMenu->menuitems[i].status & IT_SPACE) ? highlightflags : 0), str);

				// Cvar specific handling
				switch (currentMenu->menuitems[i].status & IT_TYPE)
				{
					case IT_CVAR:
					{
						consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;
						switch (currentMenu->menuitems[i].status & IT_CVARTYPE)
						{
							case IT_CV_STRING:

								//colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_MOSS, GTC_CACHE);
								colormapc = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);

								V_DrawFixedPatch((xp + 12)<<FRACBITS, (yp-2)<<FRACBITS, FRACUNIT, 0, typebar, colormapc);	// Always consider that this is selected otherwise it clashes.

								{
									INT32 xoffs = 0;
									if (itemOn == i)
									{
										xoffs += 8;
										V_DrawString(xp + (skullAnimCounter/5) + 17, yp+1, highlightflags, "\x1D");
									}

									V_DrawThinString(xp + xoffs + 18, yp, 0, cv->string);
								}

								/*// On this specific menu the only time we'll ever see this is for the connect by IP typefield.
								// Draw the small GO button here (and the text which is a separate graphic)
								V_DrawFixedPatch((xp + 20 + typebar->width -4)<<FRACBITS, (yp-3)<<FRACBITS, FRACUNIT, 0, minibutt, i == itemOn ? colormapc : colormap);
								V_DrawFixedPatch((xp + 20 + typebar->width -4 + (minibutt->width/2))<<FRACBITS, (yp-3-5)<<FRACBITS, FRACUNIT, 0, minigo, i == itemOn ? colormapc : NULL);*/

								break;

							default:
								break;
						}
						break;
					}
				}

				xp += 5;
				yp += 11;

				break;
			}
		break;
		}

	}
}

// Multiplayer room select
void M_DrawMPRoomSelect(void)
{
	// Greyscale colormaps for the option that's not selected's background
	UINT8 *colormap_l = NULL;
	UINT8 *colormap_r = NULL;

	patch_t *bg_l = W_CachePatchName("BG_MPS21", PU_CACHE);
	patch_t *bg_r = W_CachePatchName("BG_MPS22", PU_CACHE);

	patch_t *split = W_CachePatchName("MPSPLIT1", PU_CACHE);

	patch_t *butt1[] = {W_CachePatchName("MP_B1", PU_CACHE), W_CachePatchName("MP_B12", PU_CACHE)};
	patch_t *butt2[] = {W_CachePatchName("MP_B2", PU_CACHE), W_CachePatchName("MP_B22", PU_CACHE)};

	patch_t *scrollp[] = {W_CachePatchName("MP_SCR1", PU_CACHE), W_CachePatchName("MP_SCR2", PU_CACHE)};
	patch_t *drawp = scrollp[mpmenu.room];

	fixed_t scrollposx[] = {(BASEVIDWIDTH/4)<<FRACBITS, (BASEVIDWIDTH/2 + BASEVIDWIDTH/4)<<FRACBITS};
	UINT8 i;
	INT32 soffy = 0;

	if (mpmenu.room)
		colormap_l = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_GREY, GTC_CACHE);
	else
		colormap_r = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_GREY, GTC_CACHE);

	// Draw the 2 sides of the background
	V_DrawFixedPatch(0, 0, FRACUNIT, 0, bg_l, colormap_l);
	V_DrawFixedPatch(0, 0, FRACUNIT, 0, bg_r, colormap_r);


	// Draw the black split:
	V_DrawFixedPatch(160<<FRACBITS, 0, FRACUNIT, 0, split, NULL);

	// Vertical scrolling stuff
	for (i = 0; i < 3; i++)
	{
		V_DrawFixedPatch(scrollposx[mpmenu.room], ((-((mpmenu.ticker*2) % drawp->height)) + soffy)*FRACUNIT , FRACUNIT, V_ADD, drawp, NULL);
		soffy += scrollp[mpmenu.room]->height;
	}


	// Draw buttons:

	V_DrawFixedPatch(160<<FRACBITS, 90<<FRACBITS, FRACUNIT, mpmenu.room ? (5<<V_ALPHASHIFT) : 0, butt1[(mpmenu.room) ? 1 : 0], NULL);

	V_DrawFixedPatch(160<<FRACBITS, 90<<FRACBITS, FRACUNIT, (!mpmenu.room) ? (5<<V_ALPHASHIFT) : 0, butt2[(!mpmenu.room) ? 1 : 0], NULL);

	V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("MENUHINT", PU_CACHE), NULL);

	V_DrawCenteredMenuString(BASEVIDWIDTH/2, 24, 0, "\xA3  Select a Room  \xA2");

	V_DrawCenteredThinString(BASEVIDWIDTH/2, 12, 0, (mpmenu.room) ? "Play with community maps, characters, and gametypes. (Expect additional downloads!)" : "Jump into a standard game of Ring Racers.");

	M_DrawMasterServerReminder();
}

// SERVER BROWSER
static void M_DrawServerCountAndHorizontalBar(void)
{
	const char *text;
	INT32 y = currentMenu->y+STRINGHEIGHT;

	const char throbber[4] = {'-', '\\', '|', '/'};
	UINT8 throbindex = (mpmenu.ticker/4) % 4;

	switch (M_GetWaitingMode())
	{
		case M_WAITING_VERSION:
			text = "Checking for updates...";
			break;

		case M_WAITING_SERVERS:
			text = "Loading server list...";
			break;

		default:
			if (serverlistultimatecount > serverlistcount)
			{
				text = va("%d/%d server%s found...",
						serverlistcount,
						serverlistultimatecount,
						serverlistultimatecount == 1 ? "" : "s"
				);
			}
			else
			{
				throbindex = UINT8_MAX; // No throbber!
				text = va("%d server%s found",
					serverlistcount,
					serverlistcount == 1 ? "" : "s"
				);
			}
	}

	if (throbindex == UINT8_MAX)
	{
		V_DrawRightAlignedString(
			BASEVIDWIDTH - currentMenu->x,
			y,
			highlightflags,
			text
		);
	}
	else
	{
		V_DrawRightAlignedString(
			BASEVIDWIDTH - currentMenu->x - 12, y,
			highlightflags,
			text
		);

		V_DrawCenteredString( // Only clean way to center the throbber without exposing character width
			BASEVIDWIDTH - currentMenu->x - 4, y,
			highlightflags,
			va("%c", throbber[throbindex])
		);
	}
}

void M_DrawMPServerBrowser(void)
{
	const char *header[3][2] = {
		{"Server Browser", "BG_MPS1"},
		{"Core Servers", "BG_MPS1"},
		{"Modded Servers", "BG_MPS2"},
	};
	int mode = M_SecretUnlocked(SECRET_ADDONS, true) ? (mpmenu.room ? 2 : 1) : 0;

	patch_t *text1 = W_CachePatchName("MENUBGT1", PU_CACHE);
	patch_t *text2 = W_CachePatchName("MENUBGT2", PU_CACHE);

	patch_t *raceh = W_CachePatchName("M_SERV1", PU_CACHE);
	patch_t *batlh = W_CachePatchName("M_SERV2", PU_CACHE);

	patch_t *racehs = W_CachePatchName("M_SERV12", PU_CACHE);
	patch_t *batlhs = W_CachePatchName("M_SERV22", PU_CACHE);

	fixed_t text1loop = SHORT(text1->height)*FRACUNIT;
	fixed_t text2loop = SHORT(text2->width)*FRACUNIT;

	const UINT8 startx = 18;
	const UINT8 basey = 56;
	const INT32 starty = basey - 18*mpmenu.scrolln + mpmenu.slide;
	INT32 ypos = 0;
	UINT8 i;

	// background stuff
	V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName(header[mode][1], PU_CACHE), NULL);

	V_DrawFixedPatch(0, (BASEVIDHEIGHT + 16) * FRACUNIT, FRACUNIT, V_TRANSLUCENT, W_CachePatchName("MENUBG2", PU_CACHE), NULL);

	V_DrawFixedPatch(-bgText2Scroll, (BASEVIDHEIGHT-8) * FRACUNIT,
		FRACUNIT, V_TRANSLUCENT, text2, NULL);
	V_DrawFixedPatch(-bgText2Scroll + text2loop, (BASEVIDHEIGHT-8) * FRACUNIT,
		FRACUNIT, V_TRANSLUCENT, text2, NULL);

	V_DrawFixedPatch(8 * FRACUNIT, -bgText1Scroll,
		FRACUNIT, V_TRANSLUCENT, text1, NULL);
	V_DrawFixedPatch(8 * FRACUNIT, -bgText1Scroll + text1loop,
		FRACUNIT, V_TRANSLUCENT, text1, NULL);

	// bgText<x>Scroll is already handled by the menu background.

	// the actual server list.
	for (i = 0; i < serverlistcount; i++)
	{

		boolean racegt = strcmp(serverlist[i].info.gametypename, "Race") == 0;
		INT32 transflag = 0;
		INT32 basetransflag = 0;

		if (serverlist[i].info.numberofplayer >= serverlist[i].info.maxplayer)
			basetransflag = 5;

		/*if (i < mpmenu.servernum)
			// if slide > 0, then we went DOWN in the list and have to fade that server out.
			if (mpmenu.slide > 0)
				transflag = basetransflag + (18-mpmenu.slide)/2;
			else if (mpmenu.slide < 0)
				transflag = 10 - basetransflag - (18-mpmenu.slide)/2;*/

		transflag = basetransflag;

		if (transflag >= 0 && transflag < 10)
		{
			transflag = transflag << V_ALPHASHIFT;	// shift the translucency flag.

			if (itemOn == 2 && mpmenu.servernum == i)
				V_DrawFixedPatch(startx*FRACUNIT, (starty + ypos)*FRACUNIT, FRACUNIT, transflag, racegt ? racehs : batlhs, NULL);
			else
				V_DrawFixedPatch(startx*FRACUNIT, (starty + ypos)*FRACUNIT, FRACUNIT, transflag, racegt ? raceh : batlh, NULL);

			// Server name:
			V_DrawString(startx+11, starty + ypos + 6, transflag, serverlist[i].info.servername);

			// Ping:
			V_DrawThinString(startx + 191, starty + ypos + 7, transflag, va("%03d", serverlist[i].info.time));

			// Playercount
			V_DrawThinString(startx + 214, starty + ypos + 7, transflag, va("%02d/%02d", serverlist[i].info.numberofplayer, serverlist[i].info.maxplayer));

			// Power Level
			V_DrawThinString(startx + 248, starty + ypos, transflag, va("%04d PLv", serverlist[i].info.avgpwrlv));

			// game speed if applicable:
			if (racegt)
			{
				UINT8 speed = serverlist[i].info.kartvars & SV_SPEEDMASK;
				patch_t *pp = W_CachePatchName(va("M_SDIFF%d", speed), PU_CACHE);

				V_DrawFixedPatch((startx + 251)*FRACUNIT, (starty + ypos + 9)*FRACUNIT, FRACUNIT, transflag, pp, NULL);
			}
		}
		ypos += SERVERSPACE;
	}

	// Draw genericmenu ontop!
	V_DrawFill(0, 0, 320, 52, 31);
	V_DrawFill(0, 53, 320, 1, 31);
	V_DrawFill(0, 55, 320, 1, 31);

	V_DrawCenteredGamemodeString(160, 2, 0, 0, header[mode][0]);

	// normal menu options
	M_DrawGenericMenu();

	// And finally, the overlay bar!
	M_DrawServerCountAndHorizontalBar();
	M_DrawMasterServerReminder();
}

// OPTIONS MENU

// Draws the cogs and also the options background!
void M_DrawOptionsCogs(void)
{
	boolean trulystarted = M_GameTrulyStarted();
	UINT32 tick = ((optionsmenu.ticker/10) % 3) + 1;

	// the background isn't drawn outside of being in the main menu state.
	if (gamestate == GS_MENU && trulystarted)
	{
		patch_t *back = W_CachePatchName(va("OPT_BG%u", tick), PU_CACHE);
		INT32 tflag = 0;
		UINT8 *c;
		UINT8 *c2;	// colormap for the one we're changing

		if (optionsmenu.fade)
		{
			c2 = R_GetTranslationColormap(TC_DEFAULT, optionsmenu.lastcolour, GTC_CACHE);
			V_DrawFixedPatch(0, 0, FRACUNIT, 0, back, c2);

			// prepare fade flag:
			tflag = min(V_90TRANS, (optionsmenu.fade)<<V_ALPHASHIFT);

		}
		c = R_GetTranslationColormap(TC_DEFAULT, optionsmenu.currcolour, GTC_CACHE);
		V_DrawFixedPatch(0, 0, FRACUNIT, tflag, back, c);
	}
	else
	{
		patch_t *back_pause = W_CachePatchName(va("OPT_BAK%u", tick), PU_CACHE);
		V_DrawFixedPatch(0, 0, FRACUNIT, V_MODULATE, back_pause, NULL);

		if (!trulystarted)
		{
			V_DrawFixedPatch(0, 0, FRACUNIT, (V_ADD|V_70TRANS), back_pause, NULL);
		}
	}
}

void M_DrawOptionsMovingButton(void)
{
	patch_t *butt = W_CachePatchName("OPT_BUTT", PU_CACHE);
	UINT8 *c = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);
	fixed_t t = M_DueFrac(optionsmenu.topt_start, M_OPTIONS_OFSTIME);
	fixed_t z = Easing_OutSine(M_DueFrac(optionsmenu.offset.start, M_OPTIONS_OFSTIME), optionsmenu.offset.dist * FRACUNIT, 0);
	fixed_t tx = Easing_OutQuad(t, optionsmenu.optx * FRACUNIT, optionsmenu.toptx * FRACUNIT) + z;
	fixed_t ty = Easing_OutQuad(t, optionsmenu.opty * FRACUNIT, optionsmenu.topty * FRACUNIT) + z;

	V_DrawFixedPatch(tx, ty, FRACUNIT, 0, butt, c);

	const char *s = OPTIONS_MainDef.menuitems[OPTIONS_MainDef.lastOn].text;
	fixed_t w = V_StringScaledWidth(
		FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		0,
		GM_FONT,
		s
	);
	V_DrawStringScaled(
		tx - 3*FRACUNIT - (w/2),
		ty - 16*FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		0,
		c,
		GM_FONT,
		s
	);
}

void M_DrawOptions(void)
{
	UINT8 i;
	fixed_t t = Easing_OutSine(M_DueFrac(optionsmenu.offset.start, M_OPTIONS_OFSTIME), optionsmenu.offset.dist * FRACUNIT, 0);
	fixed_t x = (140 - (48*itemOn))*FRACUNIT + t;
	fixed_t y = 70*FRACUNIT + t;
	fixed_t tx = M_EaseWithTransition(Easing_InQuart, 5 * 64 * FRACUNIT);
	patch_t *buttback = W_CachePatchName("OPT_BUTT", PU_CACHE);

	UINT8 *c = NULL;

	for (i=0; i < currentMenu->numitems; i++)
	{
		fixed_t py = y - (itemOn*48)*FRACUNIT;
		fixed_t px = x - tx;
		INT32 tflag = 0;

		if (i == itemOn)
			c = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);
		else
			c = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_BLACK, GTC_CACHE);

		if (currentMenu->menuitems[i].status & IT_TRANSTEXT)
			tflag = V_TRANSLUCENT;

		if (!(menutransition.tics != menutransition.dest && i == itemOn))
		{
			V_DrawFixedPatch(px, py, FRACUNIT, 0, buttback, c);

			const char *s = currentMenu->menuitems[i].text;
			fixed_t w = V_StringScaledWidth(
				FRACUNIT,
				FRACUNIT,
				FRACUNIT,
				0,
				GM_FONT,
				s
			);
			V_DrawStringScaled(
				px - 3*FRACUNIT - (w/2),
				py - 16*FRACUNIT,
				FRACUNIT,
				FRACUNIT,
				FRACUNIT,
				tflag,
				(i == itemOn ? c : NULL),
				GM_FONT,
				s
			);
		}

		y += 48*FRACUNIT;
		x += 48*FRACUNIT;
	}

	M_DrawMenuTooltips();

	if (menutransition.tics != menutransition.dest)
		M_DrawOptionsMovingButton();

}

static void M_DrawOptionsBoxTerm(INT32 x, INT32 top, INT32 bottom)
{
	INT32 px = x - 20;

	V_DrawFill(px, top + 4, 2, bottom - top, orangemap[0]);
	V_DrawFill(px + 1, top + 5, 2, bottom - top, 31);

	V_DrawFill(BASEVIDWIDTH - px - 2, top + 4, 2, bottom - top, orangemap[0]);
	V_DrawFill(BASEVIDWIDTH - px, top + 5, 1, bottom - top, 31);

	V_DrawFill(px, bottom + 2, BASEVIDWIDTH - (2 * px), 2, orangemap[0]);
	V_DrawFill(px, bottom + 3, BASEVIDWIDTH - (2 * px), 2, 31);
}

static void M_DrawLinkArrow(INT32 x, INT32 y, INT32 i)
{
	UINT8 ch = currentMenu->menuitems[i].text[0];

	V_DrawMenuString(
		x + (i == itemOn ? 1 + skullAnimCounter/5 : 0),
		y - 1,
		// Use color of first character in text label
		i == itemOn ? highlightflags : (((max(ch, 0x80) - 0x80) & 15) << V_CHARCOLORSHIFT),
		"\x1D"
	);
}

void M_DrawGenericOptions(void)
{
	INT32 x = currentMenu->x - M_EaseWithTransition(Easing_Linear, 5 * 48), y = currentMenu->y, w, i, cursory = -100;
	INT32 expand = -1;
	INT32 boxy = 0;
	boolean collapse = false;
	boolean opening = false;
	fixed_t boxt = 0;

	M_DrawMenuTooltips();
	M_DrawOptionsMovingButton();

	for (i = itemOn; i >= 0; --i)
	{
		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_DYBIGSPACE:
				goto box_found;

			case IT_HEADERTEXT:
				expand = i;
				goto box_found;
		}
	}
box_found:
	if (optionsmenu.box.dist != expand)
	{
		optionsmenu.box.dist = expand;
		optionsmenu.box.start = I_GetTime();
	}

	for (i = 0; i < currentMenu->numitems; i++)
	{
		boolean term = false;

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_DYBIGSPACE:
				collapse = false;
				term = (boxy != 0);
				break;

			case IT_HEADERTEXT:
				if (i != expand)
				{
					collapse = true;
					term = (boxy != 0);
				}
				else
				{
					if (collapse)
						y += 2;

					collapse = false;

					if (menutransition.tics == menutransition.dest)
					{
						INT32 px = x - 20;
						V_DrawFill(px, y + 4, BASEVIDWIDTH - (2 * px), 2, orangemap[0]);
						V_DrawFill(px + 1, y + 5, BASEVIDWIDTH - (2 * px), 2, 31);
					}

					boxy = y;

					boxt = optionsmenu.box.dist == expand ? M_DueFrac(optionsmenu.box.start, 5) : FRACUNIT;
					opening = boxt < FRACUNIT;
				}
				break;

			default:
				if (collapse)
					continue;
		}

		if (term)
		{
			if (menutransition.tics == menutransition.dest)
				M_DrawOptionsBoxTerm(x, boxy, Easing_Linear(boxt, boxy, y));

			y += SMALLLINEHEIGHT;
			boxy = 0;
			opening = false;
		}

		if (i == itemOn && !opening)
		{
			cursory = y;
			M_DrawUnderline(x, BASEVIDWIDTH - x, y);
		}

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_PATCH:
				if (currentMenu->menuitems[i].patch && currentMenu->menuitems[i].patch[0])
				{
					if (currentMenu->menuitems[i].status & IT_CENTER)
					{
						patch_t *p;
						p = W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE);
						V_DrawScaledPatch((BASEVIDWIDTH - SHORT(p->width))/2, y, 0, p);
					}
					else
					{
						V_DrawScaledPatch(x, y, 0,
							W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE));
					}
				}
				/* FALLTHRU */
			case IT_NOTHING:
				y += SMALLLINEHEIGHT;
				break;

			case IT_DYBIGSPACE:
				y += SMALLLINEHEIGHT/2;
				break;
#if 0
			case IT_BIGSLIDER:
				M_DrawThermo(x, y, currentMenu->menuitems[i].itemaction.cvar);
				y += LINEHEIGHT;
				break;
#endif
			case IT_STRING:
			case IT_LINKTEXT: {
				boolean textBox = (currentMenu->menuitems[i].status & IT_TYPE) == IT_CVAR &&
					(currentMenu->menuitems[i].status & IT_CVARTYPE) == IT_CV_STRING;

				if (textBox)
				{
					if (opening)
						y += LINEHEIGHT;
					else
						V_DrawFill(x+5, y+5, MAXSTRINGLENGTH*7+6, 9+6, 159);
				}

				if (opening)
				{
					y += STRINGHEIGHT;
					break;
				}

				INT32 px = x + ((currentMenu->menuitems[i].status & IT_TYPE) == IT_SUBMENU
					|| (currentMenu->menuitems[i].status & IT_DISPLAY) == IT_LINKTEXT ? 8 : 0);

				if (i == itemOn)
					cursory = y;

				if (i == itemOn)
					V_DrawMenuString(px + 1, y, highlightflags, currentMenu->menuitems[i].text);
				else
					V_DrawMenuString(px, y, textBox ? V_GRAYMAP : 0, currentMenu->menuitems[i].text);

				if ((currentMenu->menuitems[i].status & IT_DISPLAY) == IT_LINKTEXT)
					M_DrawLinkArrow(x, y, i);

				// Cvar specific handling
				switch (currentMenu->menuitems[i].status & IT_TYPE)
				{
					case IT_SUBMENU: {
						if ((currentMenu->menuitems[i].status & IT_DISPLAY) != IT_LINKTEXT)
							M_DrawLinkArrow(x, y, i);
						break;
					}

					case IT_CVAR: {
						consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;
						switch (currentMenu->menuitems[i].status & IT_CVARTYPE)
						{
							case IT_CV_SLIDER:
								M_DrawSlider(x, y, cv, (i == itemOn));
							case IT_CV_NOPRINT: // color use this
							case IT_CV_INVISSLIDER: // monitor toggles use this
								break;
							case IT_CV_STRING:
								{
									INT32 xoffs = 6;
									if (itemOn == i)
									{
										xoffs = 8;
										V_DrawMenuString(x + (skullAnimCounter/5) + 7, y + 9, highlightflags, "\x1D");
									}

									M_DrawCaretString(x + xoffs + 8, y + 9, cv->string, false);

									y += LINEHEIGHT;
								}
								break;
							default: {
								boolean isDefault = CV_IsSetToDefault(cv);
								w = V_MenuStringWidth(cv->string, 0);
								V_DrawMenuString(BASEVIDWIDTH - x - w, y,
									(!isDefault ? warningflags : highlightflags), cv->string);
								if (i == itemOn)
								{
									V_DrawMenuString(BASEVIDWIDTH - x - 10 - w - (skullAnimCounter/5), y - 1,
											highlightflags, "\x1C"); // left arrow
									V_DrawMenuString(BASEVIDWIDTH - x + 2 + (skullAnimCounter/5), y - 1,
											highlightflags, "\x1D"); // right arrow
								}
								if (!isDefault)
								{
									V_DrawMenuString(BASEVIDWIDTH - x + (i == itemOn ? 13 : 5), y - 2, warningflags, ".");
								}
								break;
							}
						}
						break;
					}
				}

				y += STRINGHEIGHT;
				break;
			}
			case IT_STRING2:
				V_DrawMenuString(x, y, 0, currentMenu->menuitems[i].text);
				/* FALLTHRU */
			case IT_DYLITLSPACE:
			case IT_SPACE:
				y += (currentMenu->menuitems[i].mvar1 ? currentMenu->menuitems[i].mvar1 : SMALLLINEHEIGHT);
				break;
			case IT_GRAYPATCH:
				if (currentMenu->menuitems[i].patch && currentMenu->menuitems[i].patch[0])
					V_DrawMappedPatch(x, y, 0,
						W_CachePatchName(currentMenu->menuitems[i].patch,PU_CACHE), graymap);
				y += (currentMenu->menuitems[i].mvar1 ? currentMenu->menuitems[i].mvar1 : SMALLLINEHEIGHT);
				break;
			case IT_TRANSTEXT:
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;
				/* FALLTHRU */
			case IT_TRANSTEXT2:
				V_DrawMenuString(x, y, V_TRANSLUCENT, currentMenu->menuitems[i].text);
				y += SMALLLINEHEIGHT;
				break;
			case IT_QUESTIONMARKS:
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;

				V_DrawMenuString(x + 8, y, V_TRANSLUCENT|V_OLDSPACING, M_CreateSecretMenuOption(currentMenu->menuitems[i].text));
				y += SMALLLINEHEIGHT;
				break;
			case IT_HEADERTEXT: // draws 16 pixels to the left, in yellow text
				if (currentMenu->menuitems[i].mvar1)
					y = currentMenu->y+currentMenu->menuitems[i].mvar1;

				V_DrawMenuString(x - (collapse ? 0 : 16), y, M_ALTCOLOR, currentMenu->menuitems[i].text);
				y += SMALLLINEHEIGHT + 1;
				break;
		}
	}

	if (boxy && menutransition.tics == menutransition.dest)
		M_DrawOptionsBoxTerm(x, boxy, Easing_Linear(boxt, boxy, y));

	// DRAW THE SKULL CURSOR
	if (((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == IT_PATCH)
		|| ((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == IT_NOTHING))
	{
		V_DrawScaledPatch(x + SKULLXOFF, cursory - 5, 0,
			W_CachePatchName("M_CURSOR", PU_CACHE));
	}
	else
	{
		M_DrawCursorHand(x, cursory);
	}
}

// *Heavily* simplified version of the generic options menu, cattered only towards erasing profiles.
void M_DrawProfileErase(void)
{
	INT32 x = currentMenu->x - M_EaseWithTransition(Easing_Linear, 5 * 48), y = currentMenu->y-SMALLLINEHEIGHT, i, cursory = 0;
	UINT8 np = PR_GetNumProfiles();

	M_DrawMenuTooltips();
	M_DrawOptionsMovingButton();

	for (i = 1; i < np; i++)
	{

		profile_t *pr = PR_GetProfile(i);

		if (i == optionsmenu.eraseprofilen)
		{
			cursory = y;
			M_DrawCursorHand(x, cursory);
		}

		V_DrawMenuString(x, y,
			(i == optionsmenu.eraseprofilen ? highlightflags : 0),
			va("%sPRF%03d - %s (%s)",
			(cv_currprofile.value == i) ? "[In use] " : "",
			i, pr->profilename, pr->playername));
		y += SMALLLINEHEIGHT;
	}
}

// Draws profile selection
void M_DrawProfileSelect(void)
{
	INT32 i;
	const INT32 maxp = PR_GetNumProfiles();
	INT32 x = 160 - optionsmenu.profilen*(128 + 128/8) + Easing_OutSine(M_DueFrac(optionsmenu.offset.start, M_OPTIONS_OFSTIME), optionsmenu.offset.dist, 0);
	INT32 y = 35 + M_EaseWithTransition(Easing_Linear, 5 * 32);

	M_DrawMenuTooltips();

	// This shouldn't be drawn when a profile is selected as optx/opty are used to move the card.
	if (optionsmenu.profile == NULL && menutransition.tics)
		M_DrawOptionsMovingButton();

	for (i=0; i < MAXPROFILES+1; i++)	// +1 because the default profile does not count
	{
		profile_t *p = PR_GetProfile(i);

		// don't draw the card in this specific scenario
		if (!(optionsmenu.profile != NULL && optionsmenu.profilen == i))
			M_DrawProfileCard(x, y, i > maxp, p);

		x += 128 + 128/8;
	}

	// needs to be drawn since it happens on the transition
	if (optionsmenu.profile != NULL)
	{
		fixed_t t = M_DueFrac(optionsmenu.topt_start, M_OPTIONS_OFSTIME);
		M_DrawProfileCard(
			Easing_OutQuad(t, optionsmenu.optx, optionsmenu.toptx),
			Easing_OutQuad(t, optionsmenu.opty, optionsmenu.topty),
			false,
			optionsmenu.profile
		);
	}
}

void M_DrawEditProfileTooltips(void)
{
	// Tooltip
	// The text is slightly shifted hence why we don't just use M_DrawMenuTooltips()
	V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("MENUHINT", PU_CACHE), NULL);
	if (currentMenu->menuitems[itemOn].tooltip != NULL)
	{
		V_DrawCenteredThinString(224, 12, 0, currentMenu->menuitems[itemOn].tooltip);
	}
}

// Profile edition menu
void M_DrawEditProfile(void)
{

	INT32 y = 34;
	INT32 x = (145 + M_EaseWithTransition(Easing_InSine, 5 * 48));
	INT32 i;

	M_DrawEditProfileTooltips();

	// Draw the menu options...
	for (i = 0; i < currentMenu->numitems; i++)
	{

		UINT8 *colormap = NULL;
		INT32 tflag = (currentMenu->menuitems[i].status & IT_TRANSTEXT) ? V_TRANSLUCENT : 0;
		INT32 cx = x;

		y = currentMenu->menuitems[i].mvar2;

		// Background -- 169 is the plague colourization
		V_DrawFill(0, y, 400 - M_EaseWithTransition(Easing_InQuad, 5 * 128), 10, itemOn == i ? 169 : 30);

		if (i == itemOn)
		{
			colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);

			cx += Easing_OutSine(M_DueFrac(optionsmenu.offset.start, 2), 0, 5);
			V_DrawMenuString(cx - 10 - (skullAnimCounter/5), y+1, highlightflags, "\x1C"); // left arrow
		}

		// Text
		//V_DrawGamemodeString(cx, y - 6, tflag, colormap, currentMenu->menuitems[i].text);
		V_DrawStringScaled(
			cx * FRACUNIT,
			(y - 3) * FRACUNIT,
			FRACUNIT,
			FRACUNIT,
			FRACUNIT,
			tflag,
			colormap,
			KART_FONT,
			currentMenu->menuitems[i].text
		);

		//y += 32 + 2;
	}

	// Finally, draw the card ontop
	if (optionsmenu.profile != NULL)
	{
		fixed_t t = M_DueFrac(optionsmenu.topt_start, M_OPTIONS_OFSTIME);
		M_DrawProfileCard(
			Easing_OutQuad(t, optionsmenu.optx, optionsmenu.toptx),
			Easing_OutQuad(t, optionsmenu.opty, optionsmenu.topty),
			false,
			optionsmenu.profile
		);
	}
}

// Controller offsets to center on each button.
INT16 controlleroffsets[][2] = {
	{0, 0},			// gc_none
	{69, 142},		// gc_up
	{69, 182},		// gc_down
	{49, 162},		// gc_left
	{89, 162},		// gc_right
	{208, 200},		// gc_a
	{237, 181},		// gc_b
	{267, 166},		// gc_c
	{191, 164},		// gc_x
	{215, 149},		// gc_y
	{242, 137},		// gc_z
	{55, 102},		// gc_l
	{253, 102},		// gc_r
	{149, 187},		// gc_start
};

static void M_DrawBindBen(INT32 x, INT32 y, INT32 scroll_remaining)
{
	// optionsmenu.bindben_swallow
	const int pose_time = 30;
	const int swallow_time = pose_time + 14;

	// Lid closed
	int state = 'A';
	int frame = 0;

	if (optionsmenu.bindben_swallow > 100)
	{
		// Quick swallow (C button)
		state = 'C';

		int t = 106 - optionsmenu.bindben_swallow;
		if (t < 3)
			frame = 0;
		else
			frame = t - 3;
	}
	else if (scroll_remaining <= 0)
	{
		// Chewing (text done scrolling)
		state = 'B';
		frame = I_GetTime() / 2 % 4;

		// When state changes from 'lid open' to 'chewing',
		// play chomp sound.
		if (!optionsmenu.bindben_swallow)
			S_StartSound(NULL, sfx_monch);

		// Ready to swallow when button is released.
		optionsmenu.bindben_swallow = swallow_time + 1;
	}
	else if (optionsmenu.bindben)
	{
		// Lid open (text scrolling)
		frame = 1;
	}
	else if (optionsmenu.bindben_swallow)
	{
		if (optionsmenu.bindben_swallow > pose_time)
		{
			// Swallow
			state = 'C';

			int t = swallow_time - optionsmenu.bindben_swallow;
			if (t < 8)
				frame = 0;
			else
				frame = 1 + (t - 8) / 2 % 3;
		}
		else
		{
			// Pose
			state = 'D';

			int t = pose_time - optionsmenu.bindben_swallow;
			if (t < 10)
				frame = 0;
			else
				frame = 1 + (t - 10) / 4 % 5;
		}
	}

	V_DrawMappedPatch(x-30, y, 0, W_CachePatchName(va("PR_BIN%c%c", state, '1' + frame), PU_CACHE), aquamap);
}

static void M_DrawBindMediumString(INT32 y, INT32 flags, const char *string)
{
	fixed_t w = V_StringScaledWidth(FRACUNIT, FRACUNIT, FRACUNIT, flags, MED_FONT, string);
	fixed_t x = BASEVIDWIDTH/2 * FRACUNIT - w/2;
	V_DrawStringScaled(
		x,
		y * FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		flags,
		NULL,
		MED_FONT,
		string
	);
}

static INT32 M_DrawProfileLegend(INT32 x, INT32 y, const char *legend, const char *mediocre_key)
{
	INT32 w = V_ThinStringWidth(legend, 0);
	V_DrawThinString(x - w, y, 0, legend);
	x -= w + 2;
	if (mediocre_key)
		M_DrawMediocreKeyboardKey(mediocre_key, &x, y, false, true);
	return x;
}

// the control stuff.
// Dear god.
void M_DrawProfileControls(void)
{
	const UINT8 spacing = 34;
	INT32 y = 16 - (optionsmenu.controlscroll*spacing);
	INT32 x = 8;
	INT32 i, j, k;
	const UINT8 pid = 0;
	patch_t *hint = W_CachePatchName("MENUHINT", PU_CACHE);
	INT32 hintofs = 3;

	K_DrawInputDisplay(BASEVIDWIDTH*2/3 - optionsmenu.contx, BASEVIDHEIGHT/2 - optionsmenu.conty, 0, '_', pid, true, false);

	if (optionsmenu.trycontroller)
	{
		optionsmenu.tcontx = BASEVIDWIDTH*2/3 - 10;
		optionsmenu.tconty = BASEVIDHEIGHT/2 +70;

		V_DrawCenteredLSTitleLowString(160, 164, 0, "TRY BUTTONS");

		const char *msg = va("Press nothing for %d sec to go back", (optionsmenu.trycontroller + (TICRATE-1)) / TICRATE);
		fixed_t w = V_StringScaledWidth(FRACUNIT, FRACUNIT, FRACUNIT, highlightflags, MED_FONT, msg);
		V_DrawStringScaled(
			160*FRACUNIT - w/2,
			186*FRACUNIT,
			FRACUNIT,
			FRACUNIT,
			FRACUNIT,
			highlightflags,
			NULL,
			MED_FONT,
			msg
		);
		return;	// Don't draw the rest if we're trying the controller.
	}

	V_DrawFill(0, 0, 138, 200, 31);	// Black border

	V_SetClipRect(
		0,
		0,
		BASEVIDWIDTH * FRACUNIT,
		(BASEVIDHEIGHT - SHORT(hint->height) + hintofs) * FRACUNIT,
		0
	);

	// Draw the menu options...
	for (i = 0; i < currentMenu->numitems; i++)
	{
		char buf[256];
		char buf2[256];
		INT32 keys[MAXINPUTMAPPING];

		// cursor
		if (i == itemOn)
		{
			for (j=0; j < 24; j++)
				V_DrawFill(0, (y)+j, 128+j, 1, 73);
		}

		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_HEADERTEXT:
				V_DrawFill(0, y+18, 124, 1, 0);	// underline
				V_DrawMenuString(x, y+8, 0, currentMenu->menuitems[i].text);
				y += spacing;
				break;

			case IT_STRING:
				V_DrawMenuString(x, y+2, (i == itemOn ? highlightflags : 0), currentMenu->menuitems[i].text);
				y += spacing;
				break;

			case IT_STRING2:
			{
				boolean drawnpatch = false;

				if (currentMenu->menuitems[i].patch)
				{
					V_DrawScaledPatch(x-4, y+1, 0, W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE));
					V_DrawMenuString(x+12, y+2, (i == itemOn ? highlightflags : 0), currentMenu->menuitems[i].text);
					drawnpatch = true;
				}
				else
					V_DrawMenuString(x, y+2, (i == itemOn ? highlightflags : 0), currentMenu->menuitems[i].text);

				if (currentMenu->menuitems[i].status & IT_CVAR)	// not the proper way to check but this menu only has normal onoff cvars.
				{
					INT32 w;
					consvar_t *cv = currentMenu->menuitems[i].itemaction.cvar;

					w = V_MenuStringWidth(cv->string, 0);
					V_DrawMenuString(x + 12, y + 13, ((cv->flags & CV_CHEAT) && !CV_IsSetToDefault(cv) ? warningflags : highlightflags), cv->string);
					if (i == itemOn)
					{
						V_DrawMenuString(x - (skullAnimCounter/5), y+12, highlightflags, "\x1C"); // left arrow
						V_DrawMenuString(x + 12 + w + 2 + (skullAnimCounter/5) , y+13, highlightflags, "\x1D"); // right arrow
					}
				}
				else if (currentMenu->menuitems[i].status & IT_CONTROL)
				{
					UINT32 vflags = V_FORCEUPPERCASE;
					INT32 gc = currentMenu->menuitems[i].mvar1;

					UINT8 available = 0, set = 0;

					if (i != itemOn)
						vflags |= V_GRAYMAP;

					// Get userbound controls...
					for (k = 0; k < MAXINPUTMAPPING; k++)
					{
						int device;
						keys[k] = optionsmenu.tempcontrols[gc][k];
						if (keys[k] == KEY_NULL)
							continue;
						set++;

						device = G_GetDeviceForPlayer(0);
						if (device == -1)
						{
							device = 0;
						}
						if (!G_KeyIsAvailable(keys[k], device))
							continue;
						available++;
					};

					buf[0] = '\0';
					buf2[0] = '\0';


					// Cool as is this, this doesn't actually help show accurate info because of how some players would set inputs with keyboard and controller at once in a volatile way...
					// @TODO: Address that mess, somehow?

					// Can't reach any of them?
					/*if (available == 0)
					{
						if (((3*optionsmenu.ticker)/(2*TICRATE)) & 1) // 1.5 seconds
						{
							vflags |= V_ORANGEMAP;
#ifdef SHOWCONTROLDEFAULT
							if (G_KeyBindIsNecessary(gc))
							{
								// Get the defaults for essential keys.
								// Went through all the trouble of making this look cool,
								// then realised defaulting should only apply to menus.
								// Too much opportunity for confusion if kept.
								for (k = 0; k < MAXINPUTMAPPING; k++)
								{
									keys[k] = gamecontroldefault[gc][k];
									if (keys[k] == KEY_NULL)
										continue;
									available++;
								}
								set = available;
							}
							else if (set)
#else
							if (!set)
							{
								if (!G_KeyBindIsNecessary(gc))
									vflags = V_REDMAP;
							}
							else
#endif
							{
								strcpy(buf, "CURRENTLY UNAVAILABLE");
							}
						}
						else
						{
							vflags |= V_REDMAP;
						}
					}*/

					char *p = buf;
					if (buf[0])
						;
					else if (!set)
					{
						vflags &= ~V_CHARCOLORMASK;
						vflags |= V_REDMAP;
						strcpy(buf, "NOT BOUND");
					}
					else
					{
						for (k = 0; k < MAXINPUTMAPPING; k++)
						{
							if (keys[k] == KEY_NULL)
								continue;

							if (k > 0)
								strcat(p," / ");

							if (k == 2)   // hacky...
								p = buf2;

							strcat(p, G_KeynumToString (keys[k]));
						}
					}

					INT32 bindx = x;
					INT32 benx = 142;
					INT32 beny = y - 8;
					if (i == itemOn)
					{
						// Extend yellow wedge down behind
						// extra line.
						if (buf2[0])
						{
							for (j=24; j < 34; j++)
								V_DrawFill(0, (y)+j, 128+j, 1, 73);
							benx += 10;
							beny += 10;
						}

						// Scroll text into Bind Ben.
						bindx += optionsmenu.bindben * 3;

						if (buf2[0])
						{
							// Bind Ben: suck characters off
							// the end of the first line onto
							// the beginning of the second
							// line.
							UINT16 n = strlen(buf);
							UINT16 t = min(optionsmenu.bindben, n);
							memmove(&buf2[t], buf2, t + 1);
							memcpy(buf2, &buf[n - t], t);
							buf[n - t] = '\0';
						}
					}

					{
						cliprect_t clip;
						V_SaveClipRect(&clip); // preserve cliprect for tooltip

						// Clip text as it scrolls into Bind Ben.
						V_SetClipRect(0, 0, (benx-14)*FRACUNIT, 200*FRACUNIT, 0);

						if (i != itemOn || !optionsmenu.bindben_swallow)
						{
							// don't shift the text if we didn't draw a patch.
							V_DrawThinString(bindx + (drawnpatch ? 13 : 1), y + 12, vflags, buf);
							V_DrawThinString(bindx + (drawnpatch ? 13 : 1), y + 22, vflags, buf2);
						}

						V_RestoreClipRect(&clip);
					}

					if (i == itemOn)
						M_DrawBindBen(benx, beny, (benx-14) - bindx);

					// controller dest coords:
					if (itemOn == i && gc > 0 && gc <= gc_start)
					{
						optionsmenu.tcontx = controlleroffsets[gc][0];
						optionsmenu.tconty = controlleroffsets[gc][1];
					}
				}


				y += spacing;
				break;
			}
		}
	}

	V_ClearClipRect();

	// Tooltip
	// Draw it at the bottom of the screen
	{
		static UINT8 blue[256];
		blue[31] = 253;
		V_DrawMappedPatch(0, BASEVIDHEIGHT + hintofs, V_VFLIP, hint, blue);
	}
	if (currentMenu->menuitems[itemOn].tooltip != NULL)
	{
		INT32 ypos = BASEVIDHEIGHT + hintofs - 9 - 12;
		V_DrawThinString(12, ypos, V_YELLOWMAP, currentMenu->menuitems[itemOn].tooltip);

		boolean standardbuttons = gamedata->gonerlevel > GDGONER_PROFILE;
		INT32 xpos = BASEVIDWIDTH - 12;
		xpos = standardbuttons ?
			M_DrawProfileLegend(xpos, ypos, "\xB2 / \xBC  Clear", NULL) :
			M_DrawProfileLegend(xpos, ypos, "Clear", "BKSP");
	}

	// Overlay for control binding
	if (optionsmenu.bindtimer)
	{
		INT16 reversetimer = TICRATE*5 - optionsmenu.bindtimer;
		INT32 fade = reversetimer;
		INT32 ypos;

		if (fade > 9)
			fade = 9;

		ypos = (BASEVIDHEIGHT/2) - 20 +16*(9 - fade);
		V_DrawFadeScreen(31, fade);

		M_DrawTextBox((BASEVIDWIDTH/2) - (120), ypos - 12, 30, 8);

		V_DrawCenteredMenuString(BASEVIDWIDTH/2, ypos, V_GRAYMAP, "Hold and release inputs for");
		V_DrawCenteredMenuString(BASEVIDWIDTH/2, ypos + 10, V_GRAYMAP, va("\"%s\"", currentMenu->menuitems[itemOn].text));

		if (optionsmenu.bindtimer > 0)
		{
			M_DrawBindMediumString(
				ypos + 50,
				highlightflags,
				va("(WAIT %d SEC TO SKIP)", (optionsmenu.bindtimer + (TICRATE-1)) / TICRATE)
			);
		}
		else
		{
			for (i = 0; i < MAXINPUTMAPPING && optionsmenu.bindinputs[i]; ++i)
			{
				M_DrawBindMediumString(
					ypos + (2 + i)*10,
					highlightflags | V_FORCEUPPERCASE,
					G_KeynumToString(optionsmenu.bindinputs[i])
				);
			}
		}
	}
}

// Draw the video modes list, a-la-Quake
void M_DrawVideoModes(void)
{
	INT32 i, j, row, col;
	INT32 t = M_EaseWithTransition(Easing_Linear, 5 * 64);

	M_DrawMenuTooltips();
	M_DrawOptionsMovingButton();

	V_DrawCenteredMenuString(BASEVIDWIDTH/2 + t, currentMenu->y,
		highlightflags, "Choose mode, reselect to change default");

	row = 41 + t;
	col = currentMenu->y + 14;
	for (i = 0; i < optionsmenu.vidm_nummodes; i++)
	{
		INT32 colorflag = 0;
		boolean isdefault = !strcmp(optionsmenu.modedescs[i].desc, va("%dx%d", cv_scr_width.value, cv_scr_height.value));

		if (i == optionsmenu.vidm_selected)
			colorflag = highlightflags;
		else if (isdefault)
			colorflag = V_ORANGEMAP;
		else if (optionsmenu.modedescs[i].goodratio)
			colorflag = recommendedflags; // Show multiples of 320x200 as green.

		if (isdefault)
			V_DrawScaledPatch(row + 2 + V_MenuStringWidth(optionsmenu.modedescs[i].desc, colorflag), col - 2, 0, W_CachePatchName("RHFAV", PU_CACHE));

		V_DrawMenuString(row, col, colorflag, optionsmenu.modedescs[i].desc);

		col += 9;
		if ((i % optionsmenu.vidm_column_size) == (optionsmenu.vidm_column_size-1))
		{
			row += 7*13;
			col = currentMenu->y + 14;
		}
	}

	if (optionsmenu.vidm_testingmode > 0)
	{
		INT32 testtime = (optionsmenu.vidm_testingmode/TICRATE) + 1;

		M_CentreText(t, currentMenu->y + 75,
			va("Previewing mode %c%dx%d",
				(SCR_IsAspectCorrect(vid.width, vid.height)) ? 0x83 : 0x80,
				vid.width, vid.height));
		M_CentreText(t, currentMenu->y + 75+9,
			"Press ENTER again to keep this mode");
		M_CentreText(t, currentMenu->y + 75+18,
			va("Wait %d second%s", testtime, (testtime > 1) ? "s" : ""));
		M_CentreText(t, currentMenu->y + 75+27,
			"or press ESC to return");

	}
	else
	{
		M_CentreText(t, currentMenu->y + 75,
			va("Current mode is %c%dx%d",
				(SCR_IsAspectCorrect(vid.width, vid.height)) ? 0x83 : 0x80,
				vid.width, vid.height));
		M_CentreText(t, currentMenu->y + 75+9,
			va("\x87" "Default mode is %dx%d",
				cv_scr_width.value, cv_scr_height.value));

		

		if (vid.width > 1280 || vid.height > 800)
			V_DrawCenteredMenuString(BASEVIDWIDTH/2 + t, currentMenu->y + 75+24,
				(I_GetTime() % 20 >= 10) ? V_REDMAP : V_YELLOWMAP, va("High resolutions will impact performance. Careful!"));
		else
			V_DrawCenteredMenuString(BASEVIDWIDTH/2 + t, currentMenu->y + 75+24,
				recommendedflags, "Modes marked in GREEN are recommended.");
		/*
		V_DrawCenteredString(BASEVIDWIDTH/2 + t, currentMenu->y + 75+16,
			highlightflags, "High resolutions stress your PC more, but will");
		V_DrawCenteredString(BASEVIDWIDTH/2 + t, currentMenu->y + 75+24,
			highlightflags, "look sharper. Balance visual quality and FPS!");
		*/
	}

	// Draw the cursor for the VidMode menu
	i = 41 - 10 + ((optionsmenu.vidm_selected / optionsmenu.vidm_column_size)*7*13) + t;
	j = currentMenu->y + 14 + ((optionsmenu.vidm_selected % optionsmenu.vidm_column_size)*9);

	M_DrawCursorHand(i + 14, j);
}

// Gameplay Item Tggles:
tic_t shitsfree = 0;

static void DrawMappedString(INT32 x, INT32 y, INT32 option, int font, const char *text, const UINT8 *colormap)
{
	V_DrawStringScaled(
		x * FRACUNIT,
		y * FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		FRACUNIT,
		option,
		colormap,
		font,
		text
	);
}

void M_DrawItemToggles(void)
{
	static UINT8 black[256];
	memset(black, 16, 256);

	const INT32 edges = 8;
	const INT32 height = 4;
	const INT32 spacing = 35;
	const INT32 column = itemOn/height;
	//const INT32 row = itemOn%height;
	INT32 leftdraw, rightdraw, totaldraw;
	INT32 x = currentMenu->x + M_EaseWithTransition(Easing_Linear, 5 * 64), y = currentMenu->y;
	INT32 onx = 0, ony = 0;
	consvar_t *cv;
	INT32 i, drawnum;
	patch_t *pat;

	M_DrawMenuTooltips();
	M_DrawOptionsMovingButton();

	// Find the available space around column
	leftdraw = rightdraw = column;
	totaldraw = 0;
	for (i = 0; (totaldraw < edges*2 && i < edges*4); i++)
	{
		if (rightdraw+1 < (currentMenu->numitems/height)+1)
		{
			rightdraw++;
			totaldraw++;
		}
		if (leftdraw-1 >= 0)
		{
			leftdraw--;
			totaldraw++;
		}
	}

	patch_t *isbg = W_CachePatchName("K_ISBG", PU_CACHE);
	patch_t *isbgd = W_CachePatchName("K_ISBGD", PU_CACHE);
	patch_t *ismul = W_CachePatchName("K_ISMUL", PU_CACHE);
	patch_t *isstrk = W_CachePatchName("K_ISSTRK", PU_CACHE);

	for (i = leftdraw; i <= rightdraw; i++)
	{
		INT32 j;

		for (j = 0; j < height; j++)
		{
			const INT32 thisitem = (i*height)+j;

			if (thisitem >= currentMenu->numitems)
				break;

			if (thisitem == itemOn)
			{
				onx = x;
				ony = y;
				y += spacing;
				continue;
			}

			if (currentMenu->menuitems[thisitem].mvar1 == 0)
			{
				V_DrawScaledPatch(x, y, 0, isbg);
				V_DrawScaledPatch(x, y, 0, W_CachePatchName("K_ISTOGL", PU_CACHE));
				y += spacing;
				continue;
			}

			if (currentMenu->menuitems[thisitem].mvar1 == 255)
			{
				V_DrawScaledPatch(x, y, 0, isbgd);
				y += spacing;
				continue;
			}

			cv = &cv_items[currentMenu->menuitems[thisitem].mvar1-1];

			drawnum = K_ItemResultToAmount(currentMenu->menuitems[thisitem].mvar1);

			V_DrawScaledPatch(x, y, 0, cv->value ? isbg : isbgd);

			if (drawnum > 1)
				V_DrawScaledPatch(x, y, 0, ismul);

			pat = W_CachePatchName(K_GetItemPatch(currentMenu->menuitems[thisitem].mvar1, true), PU_CACHE);

			V_DrawScaledPatch(x, y, 0, pat);

			if (!cv->value)
				V_DrawMappedPatch(x, y, V_MODULATE, pat, black);

			if (drawnum > 1)
			{
				V_DrawString(x+24, y+31, 0, va("x%d", drawnum));

				if (!cv->value)
					DrawMappedString(x+24, y+31, V_MODULATE, HU_FONT, va("x%d", drawnum), black);
			}

			if (!cv->value)
				V_DrawScaledPatch(x, y, 0, isstrk);

			y += spacing;
		}

		x += spacing;
		y = currentMenu->y;
	}

	{
		if (currentMenu->menuitems[itemOn].mvar1 == 0)
		{
			V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITBG", PU_CACHE));
			V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITTOGL", PU_CACHE));
		}
		else if (currentMenu->menuitems[itemOn].mvar1 == 255)
		{
			V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITBGD", PU_CACHE));
			if (shitsfree)
			{
				INT32 trans = V_TRANSLUCENT;
				if (shitsfree-1 > TICRATE-5)
					trans = ((10-TICRATE)+shitsfree-1)<<V_ALPHASHIFT;
				else if (shitsfree < 5)
					trans = (10-shitsfree)<<V_ALPHASHIFT;
				V_DrawScaledPatch(onx-1, ony-2, trans, W_CachePatchName("K_ITFREE", PU_CACHE));
			}
		}
		else
		{
			cv = &cv_items[currentMenu->menuitems[itemOn].mvar1-1];

			drawnum = K_ItemResultToAmount(currentMenu->menuitems[itemOn].mvar1);

			if (cv->value)
				V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITBG", PU_CACHE));
			else
				V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITBGD", PU_CACHE));

			if (drawnum > 1)
				V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITMUL", PU_CACHE));

			pat = W_CachePatchName(K_GetItemPatch(currentMenu->menuitems[itemOn].mvar1, false), PU_CACHE);

			V_DrawScaledPatch(onx-1, ony-2, 0, pat);

			if (!cv->value)
				V_DrawMappedPatch(onx-1, ony-2, V_MODULATE, pat, black);

			if (drawnum > 1)
			{
				V_DrawScaledPatch(onx+27, ony+39, 0, W_CachePatchName("K_ITX", PU_CACHE));
				V_DrawTimerString(onx+37, ony+34, 0, va("%d", drawnum));

				if (!cv->value)
				{
					V_DrawMappedPatch(onx+27, ony+39, V_MODULATE, W_CachePatchName("K_ITX", PU_CACHE), black);
					DrawMappedString(onx+37, ony+34, V_MODULATE, TIMER_FONT, va("%d", drawnum), black);
				}
			}

			if (!cv->value)
			{
				V_DrawScaledPatch(onx-1, ony-2, 0, W_CachePatchName("K_ITSTRK", PU_CACHE));
			}
		}
	}
}


// EXTRAS:
// Copypasted from options but separate either way in case we want it to look more unique later down the line.
void M_DrawExtrasMovingButton(void)
{
	patch_t *butt = W_CachePatchName("OPT_BUTT", PU_CACHE);
	UINT8 *c = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);

	V_DrawFixedPatch((extrasmenu.extx)*FRACUNIT, (extrasmenu.exty)*FRACUNIT, FRACUNIT, 0, butt, c);
	V_DrawCenteredGamemodeString((extrasmenu.extx)-3, (extrasmenu.exty) - 16, 0, c, EXTRAS_MainDef.menuitems[EXTRAS_MainDef.lastOn].text);
}

void M_DrawExtras(void)
{
	UINT8 i;
	INT32 t = Easing_OutSine(M_DueFrac(extrasmenu.offset.start, M_EXTRAS_OFSTIME), extrasmenu.offset.dist, 0);
	INT32 x = 140 - (48*itemOn) + t;
	INT32 y = 70 + t;
	patch_t *buttback = W_CachePatchName("OPT_BUTT", PU_CACHE);

	UINT8 *c = NULL;

	for (i=0; i < currentMenu->numitems; i++)
	{
		INT32 py = y - (itemOn*48);
		INT32 px = x - menutransition.tics*64;
		INT32 tflag = 0;

		if (i == itemOn)
			c = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_CACHE);
		else
			c = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_BLACK, GTC_CACHE);

		if (currentMenu->menuitems[i].status & IT_TRANSTEXT)
			tflag = V_TRANSLUCENT;

		if (!(menutransition.tics && i == itemOn))
		{
			V_DrawFixedPatch(px*FRACUNIT, py*FRACUNIT, FRACUNIT, 0, buttback, c);
			V_DrawCenteredGamemodeString(px-3, py - 16, tflag, (i == itemOn ? c : NULL), currentMenu->menuitems[i].text);
		}

		y += 48;
		x += 48;
	}

	M_DrawMenuTooltips();

	if (menutransition.tics)
		M_DrawExtrasMovingButton();

}

//
// INGAME / PAUSE MENUS
//

static char *M_GetGameplayMode(void)
{
	if (grandprixinfo.gp == true)
	{
		if (grandprixinfo.masterbots)
			return va("Master");
		if (grandprixinfo.gamespeed == KARTSPEED_HARD)
			return va("Hard");
		if (grandprixinfo.gamespeed == KARTSPEED_NORMAL)
			return va("Normal");
		return va("Easy");
	}

	if (cv_4thgear.value)
		return va("4th Gear!");

	return va("Gear %d\n", gamespeed+1);
}

// PAUSE MAIN MENU
void M_DrawPause(void)
{

	SINT8 i;
	SINT8 itemsdrawn = 0;
	SINT8 countdown = 0;
	INT16 ypos = -50;	// Draw 3 items from selected item (y=100 - 3 items spaced by 50 px each... you get the idea.)
	INT16 dypos;

	fixed_t mt = M_DueFrac(pausemenu.openoffset.start, 6);

	if (pausemenu.openoffset.dist)
		mt = FRACUNIT - mt;

	INT16 offset = menutransition.tics ? floor(pow(2, (double)menutransition.tics)) : Easing_OutQuad(mt, 256, 0);
	INT16 arrxpos = 150 + 2*offset;	// To draw the background arrow.

	INT16 j = 0;

	patch_t *vertbg = W_CachePatchName("M_STRIPV", PU_CACHE);
	patch_t *arrstart = W_CachePatchName("M_PTIP", PU_CACHE);
	patch_t *arrfill = W_CachePatchName("M_PFILL", PU_CACHE);

	fixed_t t = M_DueFrac(pausemenu.offset.start, 3);

	UINT8 splitspectatestate = 0;
	if (G_GametypeHasSpectators() && pausemenu.splitscreenfocusid <= splitscreen)
	{
		// Identify relevant spectator state of pausemenu.splitscreenfocusid.
		// See also M_HandleSpectatorToggle.

		const UINT8 splitspecid =
			g_localplayers[pausemenu.splitscreenfocusid];

		if (players[splitspecid].spectator)
		{
			splitspectatestate =
				(players[splitspecid].pflags & PF_WANTSTOJOIN)
					? UINT8_MAX
					: 1;
		}
	}

	//V_DrawFadeScreen(0xFF00, 16);

	{
		INT32 x = Easing_OutQuad(mt, -BASEVIDWIDTH, 0);
		INT32 y = 56;

		if (g_realsongcredit && !S_MusicDisabled())
		{
			V_DrawThinString(x + 2, y, 0, g_realsongcredit);
		}

		if (gamestate == GS_LEVEL)
		{
			const char *name = bossinfo.valid && bossinfo.enemyname ?
				bossinfo.enemyname : mapheaderinfo[gamemap-1]->menuttl;
			char *buf = NULL;

			if (!name[0])
			{
				buf = G_BuildMapTitle(gamemap);
				name = buf;
			}

			INT32 width = V_StringScaledWidth(
				FRACUNIT,
				FRACUNIT,
				FRACUNIT,
				0,
				MED_FONT,
				name
			) / FRACUNIT;

			y += 11;

			V_DrawFill(x + 1, y + 8, width + 20, 3, 31);

			V_DrawStringScaled(
				(x + 19) * FRACUNIT,
				y * FRACUNIT,
				FRACUNIT,
				FRACUNIT,
				FRACUNIT,
				V_AQUAMAP,
				NULL,
				MED_FONT,
				name
			);

			K_DrawMapThumbnail(
				(x + 1) * FRACUNIT,
				(y - 1) * FRACUNIT,
				16 * FRACUNIT,
				0,
				gamemap - 1,
				NULL
			);

			Z_Free(buf);
		}
	}

	// "PAUSED"
	if (!paused && !demo.playback && !modeattacking && !netgame) // as close to possible as P_AutoPause, but not dependent on menuactive
	{
		M_DrawPausedText(-offset*FRACUNIT);
	}

	// Vertical Strip:
	V_DrawFixedPatch((230 + offset)<<FRACBITS, 0, FRACUNIT, V_ADD, vertbg, NULL);

	// Okay that's cool but which icon do we draw first? let's roll back from itemOn!
	// At most we'll draw 7 items, 1 in the center, 3 above, 3 below.
	// Which means... let's count down from itemOn
	for (i = itemOn; countdown < 3; countdown++)
	{
		i--;
		if (i < 0)
			i = currentMenu->numitems-1;

		while (currentMenu->menuitems[i].status == IT_DISABLED)
		{
			i--;

			if (i < 0)
				i = currentMenu->numitems-1;
		}
	}

	// Aaaaand now we can start drawing!
	// Reminder that we set the patches of the options to the description since we're not using that. I'm smart, I know...

	// Draw the background arrow
	V_DrawFixedPatch(arrxpos<<FRACBITS, 100<<FRACBITS, FRACUNIT, 0, arrstart, NULL);

	while ((arrxpos - arrfill->width) < BASEVIDWIDTH)
	{
		V_DrawFixedPatch(arrxpos<<FRACBITS, 100<<FRACBITS, FRACUNIT, 0, arrfill, NULL);
		arrxpos += arrfill->width;
	}

	while (itemsdrawn < 7)
	{
		switch (currentMenu->menuitems[i].status & IT_DISPLAY)
		{
			case IT_STRING:
			{
				patch_t *pp;
				UINT8 *colormap = NULL;

				if (i == itemOn && (i == mpause_restartmap || i == mpause_tryagain))
				{
					pp = W_CachePatchName(
						va("M_ICOR2%c", ('A'+(pausemenu.ticker & 1))),
						PU_CACHE);
				}
				else if (i == mpause_spectatetoggle)
				{
					pp = W_CachePatchName(
						((splitspectatestate == 1)
							? "M_ICOENT"
							: "M_ICOSPC"
						), PU_CACHE
					);
					if (i == itemOn)
						colormap = yellowmap;
				}
				else
				{
					pp = W_CachePatchName(currentMenu->menuitems[i].tooltip, PU_CACHE);
					if (i == itemOn)
						colormap = yellowmap;
				}

				// 294 - 261 = 33
				// We need to move 33 px in 50 tics which means we move 33/50 = 0.66 px every tic = 2/3 of the offset.
				// trust me i graduated highschool!!!!

				// Multiply by -1 or 1 depending on whether we're below or above 100 px.
				// This double ternary is awful, yes.

				INT32 yofs = Easing_InQuad(t, pausemenu.offset.dist, 0);
				dypos = ypos + yofs;
				V_DrawFixedPatch( ((i == itemOn ? (294 - yofs*2/3 * (dypos > 100 ? 1 : -1)) : 261) + offset) << FRACBITS, (dypos)*FRACUNIT, FRACUNIT, 0, pp, colormap);

				ypos += 50;
				itemsdrawn++;	// We drew that!
				break;
			}
		}

		i++;	// Regardless of whether we drew or not, go to the next item in the menu.
		if (i >= currentMenu->numitems)
		{
			i = 0;
			while (!(currentMenu->menuitems[i].status & IT_DISPLAY))
				i++;
		}
	}

	// Draw the string!

	const char *maintext = NULL;
	const char *selectableheadertext = NULL;
	const char *selectabletext = NULL;
	INT32 mainflags = 0, selectableflags = 0;

	if (itemOn == mpause_changegametype)
	{
		selectableheadertext = currentMenu->menuitems[itemOn].text;
		selectabletext = gametypes[menugametype]->name;
	}
	else if (itemOn == mpause_addons)
	{
		selectableheadertext = "ADDONS";
		selectabletext = menuaddonoptions ? "LOAD..." : "SETTINGS";
	}
	else if (itemOn == mpause_callvote)
	{
		selectableheadertext = currentMenu->menuitems[itemOn].text;
		selectabletext = K_GetMidVoteLabel(menucallvote);

		if (K_MinimalCheckNewMidVote(menucallvote) == false)
		{
			if (g_midVote.active == true)
			{
				maintext = "ACTIVE...";
			}
			else if (g_midVote.delay > 0)
			{
				if (g_midVote.delay != 1)
					maintext = va("%u", ((g_midVote.delay - 1) / TICRATE) + 1);
			}
			else if (K_PlayerIDAllowedInMidVote(consoleplayer) == false)
			{
				maintext = "SPECTATING";
			}
			else
			{
				maintext = "INVALID!?";
			}

			if (maintext != NULL)
			{
				mainflags |= V_YELLOWMAP;
				selectableflags |= V_MODULATE;
			}
		}
	}
	else if (itemOn == mpause_spectatetoggle)
	{
		const char *spectatetext = NULL;
		INT32 spectateflags = 0;

		if (splitspectatestate == 0)
			spectatetext = "SPECTATE";
		else if (splitspectatestate == 1)
		{
			spectatetext = "ENTER GAME";

			if (!cv_allowteamchange.value)
			{
				spectateflags |= V_MODULATE;
			}
		}
		else
			spectatetext = "CANCEL JOIN";

		if (splitscreen)
		{
			selectableheadertext = spectatetext;
			selectabletext = va("PLAYER %c", 'A' + pausemenu.splitscreenfocusid);
			selectableflags |= spectateflags;
		}
		else
		{
			maintext = spectatetext;
			mainflags |= spectateflags;
		}
	}
	else
	{
		maintext = currentMenu->menuitems[itemOn].text;
	}

	if (selectableheadertext != NULL)
	{
		// For selections, show the full menu text on top.
		V_DrawCenteredLSTitleHighString(220 + offset*2, 75, selectableflags, selectableheadertext);
	}

	if (selectabletext != NULL)
	{
		// The selectable text is shown below.
		selectableflags |= V_YELLOWMAP;

		INT32 w = V_LSTitleLowStringWidth(selectabletext, selectableflags)/2;
		V_DrawLSTitleLowString(220-w + offset*2, 103, selectableflags, selectabletext);

		V_DrawMenuString(220-w + offset*2 - 8 - (skullAnimCounter/5), 103+6, selectableflags, "\x1C"); // left arrow
		V_DrawMenuString(220+w + offset*2 + (skullAnimCounter/5), 103+6, selectableflags, "\x1D"); // right arrow
	}

	if (maintext != NULL)
	{
		// This is a regular menu option. Try to break it onto two lines.

		char word1[MAXSTRINGLENGTH];
		INT16 word1len = 0;
		char word2[MAXSTRINGLENGTH];
		INT16 word2len = 0;
		boolean sok = false;

		while (maintext[j] && j < MAXSTRINGLENGTH)
		{
			if (maintext[j] == ' ' && !sok)
			{
				sok = true;
				j++;
				continue;	// We don't care about this :moyai:
			}

			if (sok)
			{
				word2[word2len] = maintext[j];
				word2len++;
			}
			else
			{
				word1[word1len] = maintext[j];
				word1len++;
			}

			j++;
		}

		word1[word1len] = '\0';
		word2[word2len] = '\0';

		// If there's no 2nd word, take this opportunity to center this line of text.
		if (word1len)
			V_DrawCenteredLSTitleHighString(220 + offset*2, 75 + (!word2len ? 10 : 0), mainflags, word1);

		if (word2len)
			V_DrawCenteredLSTitleLowString(220 + offset*2, 103, mainflags, word2);
	}

	if (gamestate != GS_INTERMISSION && roundqueue.size > 0)
	{
		y_data_t standings;
		memset(&standings, 0, sizeof (standings));

		standings.mainplayer = (demo.playback ? displayplayers[0] : consoleplayer);

		// See also G_GetNextMap, Y_CalculateMatchData
		if (
			grandprixinfo.gp == true
			&& netgame == false // TODO netgame Special Mode support
			&& grandprixinfo.gamespeed >= KARTSPEED_NORMAL
			&& roundqueue.size > 1
			&& roundqueue.entries[roundqueue.size - 1].rankrestricted == true
			&& (
				gamedata->everseenspecial == true
				|| roundqueue.position == roundqueue.size
			)
		)
		{
			// Additional cases in which it should always be shown.
			standings.showrank = true;
		}

		if (roundqueue.position > 0 && roundqueue.position <= roundqueue.size)
		{
			patch_t *smallroundpatch = ST_getRoundPicture(true);

			if (smallroundpatch != NULL)
			{
				V_DrawMappedPatch(
					24, 145 + offset/2,
					0,
					smallroundpatch,
					NULL);
			}
		}

		V_DrawCenteredMenuString(24, 167 + offset/2, V_YELLOWMAP, M_GetGameplayMode());

		Y_RoundQueueDrawer(&standings, offset/2, false, false);
	}
	else
	{
		V_DrawMenuString(4, 188 + offset/2, V_YELLOWMAP, M_GetGameplayMode());
	}
}

void M_DrawKickHandler(void)
{
	// fake round queue drawer simply to make release
	INT32 x = 29 + 4, y = 70, returny = y;
	INT32 pokeamount = playerkickmenu.poke ? ((playerkickmenu.poke & 1) ? -playerkickmenu.poke/2 : playerkickmenu.poke/2) : (I_GetTime() % 16 < 8);
	INT32 x2 = x + pokeamount - 9 - 8 - 2;

	boolean datarightofcolumn = false;

	patch_t *resbar = W_CachePatchName("R_RESBAR", PU_CACHE); // Results bars for players

	UINT8 i;

	for (i = 0; i < MAXPLAYERS; i++)
	{
		V_DrawMappedPatch(
			x, y,
			(playeringame[i] == true)
				? ((players[i].spectator == true) ? V_TRANSLUCENT : 0)
				: V_MODULATE,
			resbar, NULL
		);

		V_DrawRightAlignedThinString(
			x+13, y-2,
				((i == playerkickmenu.player)
					? highlightflags
					: 0
				),
			va("%u", i)
		);

		if (playeringame[i] == true)
		{
			if (players[i].skincolor != SKINCOLOR_NONE)
			{
				UINT8 *charcolormap;
				if ((players[i].pflags & PF_NOCONTEST) && players[i].bot)
				{
					// RETIRED !!
					charcolormap = R_GetTranslationColormap(TC_DEFAULT, players[i].skincolor, GTC_CACHE);
					V_DrawMappedPatch(x+14, y-5, 0, W_CachePatchName("MINIDEAD", PU_CACHE), charcolormap);
				}
				else
				{
					charcolormap = R_GetTranslationColormap(players[i].skin, players[i].skincolor, GTC_CACHE);
					V_DrawMappedPatch(x+14, y-5, 0, faceprefix[players[i].skin][FACE_MINIMAP], charcolormap);
				}
			}

			V_DrawThinString(
				x+27, y-2,
				(
					P_IsMachineLocalPlayer(&players[i])
						? highlightflags
						: 0
				),
				player_names[i]
			);

			V_DrawRightAlignedThinString(
				x+118, y-2,
				0,
				(players[i].spectator) ? "SPECTATOR" : "PLAYING"
			);
		}

		if (i == playerkickmenu.player)
		{
			V_DrawScaledPatch(
				x2, y-1,
				(datarightofcolumn ? V_FLIP : 0),
				W_CachePatchName("M_CURSOR", PU_CACHE)
			);
		}

		y += 13;

		if (i == (MAXPLAYERS-1)/2)
		{
			x = 169 - 6;
			y = returny;

			datarightofcolumn = true;
			x2 = x + 118 + 9 + 8 + 8 - pokeamount;
		}
	}

	//V_DrawFill(32 + (playerkickmenu.player & 8), 32 + (playerkickmenu.player & 7)*8, 8, 8, playeringame[playerkickmenu.player] ? 0 : 16);

	V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("MENUHINT", PU_CACHE), NULL);
	V_DrawCenteredThinString(
		BASEVIDWIDTH/2, 12,
		0,
		(playerkickmenu.adminpowered)
			? "You are using ""\x85""Admin Tools""\x80"", ""\x83""(A)""\x80"" to kick and ""\x84""(C)""\x80"" to ban"
			: K_GetMidVoteLabel(menucallvote)
	);
}

void M_DrawPlaybackMenu(void)
{
	INT16 i;
	patch_t *icon = NULL;
	UINT8 *activemap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_GOLD, GTC_MENUCACHE);
	UINT32 transmap = max(0, (INT32)(leveltime - playback_last_menu_interaction_leveltime - 4*TICRATE)) / 5;
	transmap = min(8, transmap) << V_ALPHASHIFT;

	// wip
	//M_DrawTextBox(currentMenu->x-68, currentMenu->y-7, 15, 15);
	//M_DrawCenteredMenu();

	for (i = 0; i < currentMenu->numitems; i++)
	{
		UINT8 *inactivemap = NULL;

		if (i >= playback_view1 && i <= playback_view4)
		{
			if (modeattacking) continue;

			if (r_splitscreen >= i - playback_view1)
			{
				INT32 ply = displayplayers[i - playback_view1];

				icon = faceprefix[players[ply].skin][FACE_RANK];
				if (i != itemOn)
					inactivemap = R_GetTranslationColormap(players[ply].skin, players[ply].skincolor, GTC_MENUCACHE);
			}
			else if (currentMenu->menuitems[i].patch && W_CheckNumForName(currentMenu->menuitems[i].patch) != LUMPERROR)
				icon = W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE);
		}
		else if (currentMenu->menuitems[i].status == IT_DISABLED)
			continue;
		else if (currentMenu->menuitems[i].patch && W_CheckNumForName(currentMenu->menuitems[i].patch) != LUMPERROR)
			icon = W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE);

		if ((i == playback_fastforward && cv_playbackspeed.value > 1) || (i == playback_rewind && demo.rewinding))
			V_DrawMappedPatch(currentMenu->x + currentMenu->menuitems[i].mvar1, currentMenu->y, V_SNAPTOTOP, icon, R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_JAWZ, GTC_MENUCACHE));
		else
			V_DrawMappedPatch(currentMenu->x + currentMenu->menuitems[i].mvar1, currentMenu->y, V_SNAPTOTOP, icon, (i == itemOn) ? activemap : inactivemap);

		if (i == itemOn)
		{
			V_DrawMenuString(currentMenu->x + currentMenu->menuitems[i].mvar1 + 4, currentMenu->y + 14,
				V_SNAPTOTOP|highlightflags, "\x1A");

			V_DrawCenteredMenuString(BASEVIDWIDTH/2, currentMenu->y + 19, V_SNAPTOTOP, currentMenu->menuitems[i].text);

			if ((currentMenu->menuitems[i].status & IT_TYPE) == IT_ARROWS)
			{
				char *str;

				if (!(i == playback_viewcount && r_splitscreen == 3))
					V_DrawMenuString(BASEVIDWIDTH/2 - 4, currentMenu->y + 28 - (skullAnimCounter/5),
						V_SNAPTOTOP|highlightflags, "\x1A"); // up arrow

				if (!(i == playback_viewcount && r_splitscreen == 0))
					V_DrawMenuString(BASEVIDWIDTH/2 - 4, currentMenu->y + 48 + (skullAnimCounter/5),
						V_SNAPTOTOP|highlightflags, "\x1B"); // down arrow

				switch (i)
				{
				case playback_viewcount:
					str = va("%d", r_splitscreen+1);
					break;

				case playback_view1:
				case playback_view2:
				case playback_view3:
				case playback_view4:
					str = player_names[displayplayers[i - playback_view1]]; // 0 to 3
					break;

				default: // shouldn't ever be reached but whatever
					continue;
				}

				V_DrawCenteredMenuString(BASEVIDWIDTH/2, currentMenu->y + 38, V_SNAPTOTOP|highlightflags, str);
			}
		}
	}
}


// Draw misc menus:

// Addons

#define lsheadingheight 16

// Just do this here instead.
static void M_CacheAddonPatches(void)
{
	addonsp[EXT_FOLDER] = W_CachePatchName("M_FFLDR", PU_STATIC);
	addonsp[EXT_UP] = W_CachePatchName("M_FBACK", PU_STATIC);
	addonsp[EXT_NORESULTS] = W_CachePatchName("M_FNOPE", PU_STATIC);
	addonsp[EXT_TXT] = W_CachePatchName("M_FTXT", PU_STATIC);
	addonsp[EXT_CFG] = W_CachePatchName("M_FCFG", PU_STATIC);
	addonsp[EXT_WAD] = W_CachePatchName("M_FWAD", PU_STATIC);
	#ifdef USE_KART
	addonsp[EXT_KART] = W_CachePatchName("M_FKART", PU_STATIC);
	#endif
	addonsp[EXT_PK3] = W_CachePatchName("M_FPK3", PU_STATIC);
	addonsp[EXT_SOC] = W_CachePatchName("M_FSOC", PU_STATIC);
	addonsp[EXT_LUA] = W_CachePatchName("M_FLUA", PU_STATIC);
	addonsp[NUM_EXT] = W_CachePatchName("M_FUNKN", PU_STATIC);
	addonsp[NUM_EXT+1] = W_CachePatchName("M_FSEL", PU_STATIC);
	addonsp[NUM_EXT+2] = W_CachePatchName("M_FLOAD", PU_STATIC);
	addonsp[NUM_EXT+3] = W_CachePatchName("M_FSRCH", PU_STATIC);
	addonsp[NUM_EXT+4] = W_CachePatchName("M_FSAVE", PU_STATIC);
}

#define addonsseperation 16

void M_DrawAddons(void)
{
	INT32 x, y;
	ssize_t i, m;
	const UINT8 *flashcol = NULL;
	UINT8 hilicol;

	M_CacheAddonPatches();

	if (Playing())
		V_DrawCenteredMenuString(BASEVIDWIDTH/2, 4, warningflags, "Adding files mid-game may cause problems.");
	else
		V_DrawCenteredMenuString(BASEVIDWIDTH/2, 4, 0,
		LOCATIONSTRING1);

	// DRAW MENU
	x = currentMenu->x;
	y = currentMenu->y - 1;

	hilicol = V_GetStringColormap(highlightflags)[0];

	y -= 16;

	V_DrawString(x-21, y + (lsheadingheight - 12), highlightflags, M_AddonsHeaderPath());
	V_DrawFill(x-21, y + (lsheadingheight - 3), MAXSTRINGLENGTH*8+6, 1, hilicol);
	//V_DrawFill(x-21, y + (lsheadingheight - 2), MAXSTRINGLENGTH*8+6, 1, 30);

	y += 10;

	M_DrawTextBox(x - (21 + 5), y, MAXSTRINGLENGTH, 1);
	{
		const char *str = (menusearch[0] ? cv_dummyaddonsearch.string : "Search...");
		INT32 tflag = (menusearch[0] ? 0 : V_TRANSLUCENT);
		INT32 xoffs = 0;
		if (itemOn == 0)
		{
			xoffs += 8;
			V_DrawMenuString(x + (skullAnimCounter/5) - 20, y+8, highlightflags, "\x1D");
		}
		V_DrawString(x + xoffs - 18, y+8, tflag, str);
	}

	V_DrawSmallScaledPatch(x - (21 + 5 + 16), y+4, (menusearch[0] ? 0 : V_TRANSLUCENT), addonsp[NUM_EXT+3]);

	y += 21;

	m = (addonsseperation*(2*numaddonsshown + 1)) + 1 + 2*(16-addonsseperation);
	V_DrawFill(x - 21, y - 1, MAXSTRINGLENGTH*8+6, m, 159);

	// scrollbar!
	if (sizedirmenu <= (2*numaddonsshown + 1))
		i = 0;
	else
	{
		ssize_t q = m;
		m = ((2*numaddonsshown + 1) * m)/sizedirmenu;
		if (dir_on[menudepthleft] <= numaddonsshown) // all the way up
			i = 0;
		else if (sizedirmenu <= (dir_on[menudepthleft] + numaddonsshown + 1)) // all the way down
			i = q-m;
		else
			i = ((dir_on[menudepthleft] - numaddonsshown) * (q-m))/(sizedirmenu - (2*numaddonsshown + 1));
	}

	V_DrawFill(x + MAXSTRINGLENGTH*8+5 - 21, (y - 1) + i, 1, m, hilicol);

	// get bottom...
	m = dir_on[menudepthleft] + numaddonsshown + 1;
	if (m > (ssize_t)sizedirmenu)
		m = sizedirmenu;

	// then compute top and adjust bottom if needed!
	if (m < (2*numaddonsshown + 1))
	{
		m = min(sizedirmenu, 2*numaddonsshown + 1);
		i = 0;
	}
	else
		i = m - (2*numaddonsshown + 1);

	if (i != 0)
		V_DrawMenuString(19, y+4 - (skullAnimCounter/5), highlightflags, "\x1A");

	if (skullAnimCounter < 4)
		flashcol = V_GetStringColormap(highlightflags);

	y -= (16-addonsseperation);

	for (; i < m; i++)
	{
		UINT32 flags = 0;
		if (y > BASEVIDHEIGHT) break;
		if (dirmenu[i])
#define type (UINT8)(dirmenu[i][DIR_TYPE])
		{
			if (type & EXT_LOADED)
			{
				flags |= V_TRANSLUCENT;
				V_DrawSmallScaledPatch(x-(16+4), y, V_TRANSLUCENT, addonsp[(type & ~EXT_LOADED)]);
				V_DrawSmallScaledPatch(x-(16+4), y, 0, addonsp[NUM_EXT+2]);
			}
			else
				V_DrawSmallScaledPatch(x-(16+4), y, 0, addonsp[(type & ~EXT_LOADED)]);

			if (itemOn == 1 && (size_t)i == dir_on[menudepthleft])
			{
				V_DrawFixedPatch((x-(16+4))<<FRACBITS, (y)<<FRACBITS, FRACUNIT/2, 0, addonsp[NUM_EXT+1], flashcol);
				flags = highlightflags;
			}

#define charsonside 14
			if (dirmenu[i][DIR_LEN] > (charsonside*2 + 3))
				V_DrawString(x, y+4, flags, va("%.*s...%s", charsonside, dirmenu[i]+DIR_STRING, dirmenu[i]+DIR_STRING+dirmenu[i][DIR_LEN]-(charsonside+1)));
#undef charsonside
			else
				V_DrawString(x, y+4, flags, dirmenu[i]+DIR_STRING);
		}
#undef type
		y += addonsseperation;
	}

	if (m != (ssize_t)sizedirmenu)
		V_DrawMenuString(19, y-12 + (skullAnimCounter/5), highlightflags, "\x1B");

	if (m < (2*numaddonsshown + 1))
	{
		y += ((2*numaddonsshown + 1)-m)*addonsseperation;
	}

	y -= 2;

	V_DrawSmallScaledPatch(x, y, ((!majormods) ? 0 : V_TRANSLUCENT), addonsp[NUM_EXT+4]);
	if (modifiedgame)
		V_DrawSmallScaledPatch(x, y, 0, addonsp[NUM_EXT+2]);

	m = numwadfiles-(mainwads+musicwads+1);

	V_DrawCenteredMenuString(BASEVIDWIDTH/2, y+4, (majormods ? highlightflags : V_TRANSLUCENT), va("%ld ADD-ON%s LOADED", (long)m, (m == 1) ? "" : "S")); //+2 for music, sounds, +1 for bios.pk3
}

#undef addonsseperation

// Challenges Menu

static void M_DrawChallengeTile(INT16 i, INT16 j, INT32 x, INT32 y, UINT8 *flashmap, boolean hili)
{
#ifdef DEVELOP
	extern consvar_t cv_debugchallenges;
#endif
	unlockable_t *ref = NULL;
	patch_t *pat = missingpat;
	UINT8 *colormap = NULL, *bgmap = NULL;
	INT32 tileflags = 0;
	fixed_t siz, accordion;
	UINT16 id, num;
	boolean unlockedyet;
	boolean categoryside;

	id = (i * CHALLENGEGRIDHEIGHT) + j;
	num = gamedata->challengegrid[id];

	// Empty spots in the grid are always unconnected.
	if (num >= MAXUNLOCKABLES)
	{
		goto drawborder;
	}

	// Okay, this is what we want to draw.
	ref = &unlockables[num];

#ifdef DEVELOP
	if (cv_debugchallenges.value > 0 &&
		cv_debugchallenges.value != ref->conditionset)
	{
		// Searching for a conditionset, fade out any tiles
		// that don't match.
		tileflags = V_80TRANS;
	}
#endif

	unlockedyet = !((gamedata->unlocked[num] == false)
		|| (challengesmenu.pending && num == challengesmenu.currentunlock && challengesmenu.unlockanim <= UNLOCKTIME));

	// If we aren't unlocked yet, return early.
	if (!unlockedyet)
	{
		UINT32 flags = 0;
		boolean hint = !!(challengesmenu.extradata[id].flags & CHE_HINT);

		pat = W_CachePatchName(
			va("UN_OUTL%c",
				ref->majorunlock ? 'B' : 'A'
			),
			PU_CACHE);

		V_DrawFixedPatch(
			x*FRACUNIT, y*FRACUNIT,
			FRACUNIT,
			(hint ? V_ADD : V_SUBTRACT)|V_90TRANS,
			pat,
			colormap
		);

		if (!hint)
		{
			colormap = R_GetTranslationColormap(TC_BLINK, SKINCOLOR_BLACK, GTC_CACHE);
			flags = V_SUBTRACT|V_90TRANS;
		}

		pat = W_CachePatchName(
			va("UN_HNT%c%c",
				(hili && !colormap) ? '1' : '2',
				ref->majorunlock ? 'B' : 'A'
			),
			PU_CACHE);

		V_DrawFixedPatch(
			x*FRACUNIT, y*FRACUNIT,
			FRACUNIT,
			flags, pat,
			colormap
		);

		pat = missingpat;
		colormap = NULL;

		goto drawborder;
	}

	accordion = FRACUNIT;

	if (challengesmenu.extradata[id].flip != 0
		&& challengesmenu.extradata[id].flip != (TILEFLIP_MAX/2))
	{
		angle_t bad = (FixedAngle(FixedMul(challengesmenu.extradata[id].flip * FRACUNIT + rendertimefrac, 360*FRACUNIT/TILEFLIP_MAX)) >> ANGLETOFINESHIFT) & FINEMASK;
		accordion = FINECOSINE(bad);
		if (accordion < 0)
			accordion = -accordion;
	}

	pat = W_CachePatchName(
		(ref->majorunlock ? "UN_BORDB" : "UN_BORDA"),
		PU_CACHE);

	bgmap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_SILVER, GTC_MENUCACHE);

	V_DrawStretchyFixedPatch(
		(x*FRACUNIT) + (SHORT(pat->width)*(FRACUNIT-accordion)/2), y*FRACUNIT,
		accordion,
		FRACUNIT,
		tileflags, pat,
		bgmap
	);

	pat = missingpat;

	categoryside = (challengesmenu.extradata[id].flip <= TILEFLIP_MAX/4
		|| challengesmenu.extradata[id].flip > (3*TILEFLIP_MAX)/4);

#ifdef DEVELOP
	if (cv_debugchallenges.value)
	{
		// Show the content of every tile without needing to
		// flip them.
		categoryside = false;
	}
#endif

	if (categoryside)
	{
		char categoryid = '0';
		colormap = bgmap;
		switch (ref->type)
		{
			case SECRET_SKIN:
				categoryid = '1';
				break;
			case SECRET_FOLLOWER:
				categoryid = '2';
				break;
			case SECRET_COLOR:
				categoryid = '3';
				break;
			case SECRET_CUP:
				categoryid = '4';
				break;
			case SECRET_MAP:
				categoryid = '8';
				break;
			case SECRET_HARDSPEED:
			case SECRET_MASTERMODE:
			case SECRET_ENCORE:
				categoryid = '5';
				break;
			case SECRET_ONLINE:
			case SECRET_ADDONS:
			case SECRET_EGGTV:
			case SECRET_SOUNDTEST:
			case SECRET_ALTTITLE:
			case SECRET_MEMETAUNTS:
				categoryid = '6';
				break;
			case SECRET_TIMEATTACK:
			case SECRET_PRISONBREAK:
			case SECRET_SPECIALATTACK:
			case SECRET_SPBATTACK:
				categoryid = '7';
				break;
			case SECRET_ALTMUSIC:
				categoryid = '9';
				break;
		}
		pat = challengesmenu.tile_category[categoryid - '0'][ref->majorunlock ? 1 : 0];
		if (pat == missingpat)
		{
			pat = challengesmenu.tile_category[categoryid - '0'][ref->majorunlock ? 0 : 1];
		}
	}
	else if (ref->icon != NULL && ref->icon[0])
	{
		pat = W_CachePatchName(ref->icon, PU_CACHE);
		if (ref->color != SKINCOLOR_NONE && ref->color < numskincolors)
		{
			colormap = R_GetTranslationColormap(TC_DEFAULT, ref->color, GTC_MENUCACHE);
		}
	}
	else
	{
		UINT8 iconid = 0;
		switch (ref->type)
		{
			case SECRET_SKIN:
			{
				INT32 skin = M_UnlockableSkinNum(ref);
				if (skin != -1)
				{
					colormap = R_GetTranslationColormap(skin, skins[skin].prefcolor, GTC_MENUCACHE);
					pat = faceprefix[skin][(ref->majorunlock) ? FACE_WANTED : FACE_RANK];
				}
				break;
			}
			case SECRET_FOLLOWER:
			{
				INT32 skin = M_UnlockableFollowerNum(ref);
				if (skin != -1)
				{
					INT32 psk = R_SkinAvailableEx(cv_skin[0].string, false);
					UINT16 col = K_GetEffectiveFollowerColor(followers[skin].defaultcolor, &followers[skin], cv_playercolor[0].value, (psk != -1) ? &skins[psk] : &skins[0]);
					colormap = R_GetTranslationColormap(TC_DEFAULT, col, GTC_MENUCACHE);
					pat = W_CachePatchName(followers[skin].icon, PU_CACHE);
				}
				break;
			}
			case SECRET_COLOR:
			{
				INT32 colorid = M_UnlockableColorNum(ref);
				if (colorid != SKINCOLOR_NONE)
				{
					colormap = R_GetTranslationColormap(TC_DEFAULT, colorid, GTC_MENUCACHE);
				}
				iconid = 2;
				break;
			}

			case SECRET_MAP:
				iconid = 14;
				break;
			case SECRET_ALTMUSIC:
				iconid = 16;
				break;

			case SECRET_HARDSPEED:
				iconid = 3;
				break;
			case SECRET_MASTERMODE:
				iconid = 4;
				break;
			case SECRET_ENCORE:
				iconid = 5;
				break;

			case SECRET_ONLINE:
				iconid = 10;
				break;
			case SECRET_ADDONS:
				iconid = 12;
				break;
			case SECRET_EGGTV:
				iconid = 11;
				break;
			case SECRET_SOUNDTEST:
				iconid = 1;
				break;
			case SECRET_ALTTITLE:
				iconid = 6;
				break;
			case SECRET_MEMETAUNTS:
				iconid = 13;
				break;

			case SECRET_TIMEATTACK:
				iconid = 7;
				break;
			case SECRET_PRISONBREAK:
				iconid = 8;
				break;
			case SECRET_SPECIALATTACK:
				iconid = 9;
				break;
			case SECRET_SPBATTACK:
				iconid = 15;
				break;

			default:
			{
				if (!colormap && ref->color != SKINCOLOR_NONE && ref->color < numskincolors)
				{
					colormap = R_GetTranslationColormap(TC_RAINBOW, ref->color, GTC_MENUCACHE);
				}
				break;
			}
		}

		if (pat == missingpat)
		{
			pat = W_CachePatchName(va("UN_IC%02u%c",
				iconid,
				ref->majorunlock ? 'B' : 'A'),
				PU_CACHE);
			if (pat == missingpat)
			{
				pat = W_CachePatchName(va("UN_IC%02u%c",
					iconid,
					ref->majorunlock ? 'A' : 'B'),
					PU_CACHE);
			}
		}
	}

	siz = (SHORT(pat->width) << FRACBITS);

	if (!siz)
		; // prevent div/0
	else if (ref->majorunlock)
	{
		V_DrawStretchyFixedPatch(
			((x + 5)*FRACUNIT) + (32*(FRACUNIT-accordion)/2), (y + 5)*FRACUNIT,
			FixedDiv(32*accordion, siz),
			FixedDiv(32 << FRACBITS, siz),
			tileflags, pat,
			colormap
		);
	}
	else
	{
		V_DrawStretchyFixedPatch(
			((x + 2)*FRACUNIT) + (16*(FRACUNIT-accordion)/2), (y + 2)*FRACUNIT,
			FixedDiv(16*accordion, siz),
			FixedDiv(16 << FRACBITS, siz),
			tileflags, pat,
			colormap
		);
	}

drawborder:

	if (num < MAXUNLOCKABLES && gamedata->unlockpending[num])
	{
		INT32 area = (ref->majorunlock) ? 42 : 20;
		V_DrawFadeFill(x, y, area, area, 0, flashmap[(skullAnimCounter/5) ? 99 : 101], 2);
	}

	if (hili)
	{
		boolean maj = (ref != NULL && ref->majorunlock);
		char buffer[9];
		sprintf(buffer, "UN_RETA1");
		buffer[6] = maj ? 'B' : 'A';
		buffer[7] = (skullAnimCounter/5) ? '2' : '1';
		pat = W_CachePatchName(buffer, PU_CACHE);

		V_DrawFixedPatch(
			x*FRACUNIT, y*FRACUNIT,
			FRACUNIT,
			0, pat,
			flashmap
		);
	}

#ifdef DEVELOP
	if (cv_debugchallenges.value == -2 ||
		cv_debugchallenges.value > 0)
	{
		// Display the conditionset for this tile.
		V_DrawThinString(x, y,
			ref->conditionset == cv_debugchallenges.value ? V_AQUAMAP : V_GRAYMAP,
			va("%u", ref->conditionset));
	}
#endif
}

#define challengetransparentstrength 8

void M_DrawCharacterIconAndEngine(INT32 x, INT32 y, UINT8 skin, UINT8 *colormap, boolean dot)
{
	V_DrawFixedPatch(x*FRACUNIT, y*FRACUNIT,
		FRACUNIT,
		0, faceprefix[skin][FACE_RANK],
		colormap);

	if (dot)
	{
		V_DrawScaledPatch(x, y + 11, 0, W_CachePatchName("ALTSDOT", PU_CACHE));
	}

	V_DrawFadeFill(x+16, y, 16, 16, 0, 31, challengetransparentstrength);

	V_DrawFill(x+16+5,   y+1,    1, 14,  0);
	V_DrawFill(x+16+5+5, y+1,    1, 14,  0);
	V_DrawFill(x+16+1,   y+5,   14,  1,  0);
	V_DrawFill(x+16+1,   y+5+5, 14,  1,  0);

	// The following is a partial duplication of R_GetEngineClass
	{
		INT32 s = (skins[skin].kartspeed - 1)/3;
		INT32 w = (skins[skin].kartweight - 1)/3;

		#define LOCKSTAT(stat) \
			if (stat < 0) { stat = 0; } \
			if (stat > 2) { stat = 2; }
			LOCKSTAT(s);
			LOCKSTAT(w);
		#undef LOCKSTAT

		V_DrawFill(x+16 + (s*5), y + (w*5), 6, 6, 0);
	}
}

static void M_DrawChallengePreview(INT32 x, INT32 y)
{
	unlockable_t *ref = NULL;
	UINT8 *colormap = NULL;
	UINT16 specialmap = NEXTMAP_INVALID;

	if (challengesmenu.currentunlock >= MAXUNLOCKABLES)
	{
		return;
	}

	// Okay, this is what we want to draw.
	ref = &unlockables[challengesmenu.currentunlock];

	// Funny question mark?
	if (!gamedata->unlocked[challengesmenu.currentunlock])
	{
		spritedef_t *sprdef = &sprites[SPR_UQMK];
		spriteframe_t *sprframe;
		patch_t *patch;
		UINT32 useframe;
		UINT32 addflags = 0;

		if (!sprdef->numframes)
		{
			return;
		}

		useframe = (challengesmenu.ticker / 2) % sprdef->numframes;

		sprframe = &sprdef->spriteframes[useframe];
		patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);

		if (sprframe->flip & 1) // Only for first sprite
		{
			addflags ^= V_FLIP; // This sprite is left/right flipped!
		}

		V_DrawFixedPatch(x*FRACUNIT, (y+2)*FRACUNIT, FRACUNIT, addflags, patch, NULL);
		return;
	}

	switch (ref->type)
	{
		case SECRET_SKIN:
		{
			INT32 skin = M_UnlockableSkinNum(ref), i;
			// Draw our character!
			if (skin != -1)
			{
				colormap = R_GetTranslationColormap(skin, skins[skin].prefcolor, GTC_MENUCACHE);
				M_DrawCharacterSprite(x, y, skin, SPR2_STIN, 7, 0, 0, colormap);

				for (i = 0; i < skin; i++)
				{
					if (!R_SkinUsable(-1, i, false))
						continue;
					if (skins[i].kartspeed != skins[skin].kartspeed)
						continue;
					if (skins[i].kartweight != skins[skin].kartweight)
						continue;

					colormap = R_GetTranslationColormap(i, skins[i].prefcolor, GTC_MENUCACHE);
					break;
				}

				M_DrawCharacterIconAndEngine(4, BASEVIDHEIGHT-(4+16), i, colormap, (i != skin));
			}
			break;
		}
		case SECRET_FOLLOWER:
		{
			INT32 skin = R_SkinAvailableEx(cv_skin[0].string, false);
			INT32 fskin = M_UnlockableFollowerNum(ref);

			// Draw proximity reference for character
			if (skin == -1)
				skin = 0;
			colormap = R_GetTranslationColormap(TC_BLINK, SKINCOLOR_BLACK, GTC_MENUCACHE);
			M_DrawCharacterSprite(x, y, skin, SPR2_STIN, 7, 0, 0, colormap);

			// Draw follower next to them
			if (fskin != -1)
			{
				UINT16 col = K_GetEffectiveFollowerColor(followers[fskin].defaultcolor, &followers[fskin], cv_playercolor[0].value, &skins[skin]);
				colormap = R_GetTranslationColormap(TC_DEFAULT, col, GTC_MENUCACHE);
				M_DrawFollowerSprite(x - 16, y, fskin, false, 0, colormap, NULL);

				if (followers[fskin].category < numfollowercategories)
				{
					V_DrawFixedPatch(4*FRACUNIT, (BASEVIDHEIGHT-(4+16))*FRACUNIT,
						FRACUNIT,
						0, W_CachePatchName(followercategories[followers[fskin].category].icon, PU_CACHE),
						NULL);
				}
			}
			break;
		}
		case SECRET_COLOR:
		{
			INT32 colorid = M_UnlockableColorNum(ref);
			if (colorid == SKINCOLOR_NONE)
				break;
			INT32 skin = R_SkinAvailableEx(cv_skin[0].string, false);
			if (skin == -1)
				skin = 0;
			colormap = R_GetTranslationColormap(skin, colorid, GTC_MENUCACHE);

			// Draw reference for character bathed in coloured slime
			M_DrawCharacterSprite(x, y, skin, SPR2_STIN, 7, 0, 0, colormap);
			break;
		}
		case SECRET_CUP:
		{
			levelsearch_t templevelsearch;
			UINT32 i, id, maxid, offset;
			cupheader_t *temp = M_UnlockableCup(ref);

			if (!temp)
				break;

			templevelsearch.cup = temp;
			templevelsearch.typeoflevel = G_TOLFlag(GT_RACE)|G_TOLFlag(GT_BATTLE);
			templevelsearch.cupmode = true;
			templevelsearch.timeattack = false;
			templevelsearch.tutorial = false;
			templevelsearch.checklocked = true;

			M_DrawCupPreview(146, &templevelsearch);

			maxid = id = (temp->id % (CUPMENU_COLUMNS * CUPMENU_ROWS));
			offset = (temp->id - id) * 2;
			while (temp && maxid < (CUPMENU_COLUMNS * CUPMENU_ROWS))
			{
				maxid++;
				temp = temp->next;
			}

			y = (BASEVIDHEIGHT-(4+16));
			if (challengesmenu.cache_secondrowlocked == true)
				y += 8;

			V_DrawFadeFill(
				4,
				y,
				28 + offset,
				(challengesmenu.cache_secondrowlocked ? 8 : 16),
				0,
				31,
				challengetransparentstrength
			);

			for (i = 0; i < offset; i += 4)
			{
				V_DrawFill(4+1 + i, y+3,   2, 2, 15);

				if (challengesmenu.cache_secondrowlocked == false)
					V_DrawFill(4+1 + i, y+8+3, 2, 2, 15);
			}

			for (i = 0; i < CUPMENU_COLUMNS; i++)
			{
				if (templevelsearch.cup && id == i)
				{
					V_DrawFill(offset + 4   + (i*4), y,     4, 8, 0);
				}
				else if (i < maxid)
				{
					V_DrawFill(offset + 4+1 + (i*4), y+3, 2, 2, 0);
				}

				if (templevelsearch.cup && id == i+CUPMENU_COLUMNS)
				{
					V_DrawFill(offset + 4 + (i*4), y+8, 4, 8, 0);
				}
				else if (challengesmenu.cache_secondrowlocked == true)
					;
				else if (i+CUPMENU_COLUMNS < maxid)
				{
					V_DrawFill(offset + 4+1 + (i*4), y+8+3, 2, 2, 0);
				}
			}

			break;
		}
		case SECRET_MAP:
		{
			boolean validdraw = false;
			const char *gtname = "Find your prize...";
			UINT16 mapnum = M_UnlockableMapNum(ref);

			if (mapnum >= nummapheaders
				|| mapheaderinfo[mapnum] == NULL
				|| mapheaderinfo[mapnum]->menuflags & LF2_HIDEINMENU)
			{
				gtname = "INVALID HEADER";
			}
			else if (
				( // Check for visitation
					(mapheaderinfo[mapnum]->menuflags & LF2_NOVISITNEEDED)
					|| (mapheaderinfo[mapnum]->records.mapvisited & MV_VISITED)
				) && ( // Check for completion
					!(mapheaderinfo[mapnum]->menuflags & LF2_FINISHNEEDED)
					|| (mapheaderinfo[mapnum]->records.mapvisited & MV_BEATEN)
				)
			)
			{
				validdraw = true;
			}

			if (validdraw)
			{
				K_DrawMapThumbnail(
					(x-50)<<FRACBITS, (146+2)<<FRACBITS,
					80<<FRACBITS,
					0,
					mapnum,
					NULL);

				INT32 guessgt = G_GuessGametypeByTOL(mapheaderinfo[mapnum]->typeoflevel);

				if (guessgt == -1)
				{
					// No Time Attack support, so specify...
					gtname = "Match Race/Online";
				}
				else
				{
					if (guessgt == GT_VERSUS)
					{
						// Fudge since there's no Versus-specific menu right now...
						guessgt = GT_SPECIAL;
					}

					if (guessgt == GT_SPECIAL && !M_SecretUnlocked(SECRET_SPECIALATTACK, true))
					{
						gtname = "???";
					}
					else
					{
						gtname = gametypes[guessgt]->name;
					}
				}
			}
			else
			{
				V_DrawFixedPatch(
					(x-50)<<FRACBITS, (146+2)<<FRACBITS,
					FRACUNIT,
					0,
					unvisitedlvl[challengesmenu.ticker % 4],
					NULL);
			}

			V_DrawThinString(1, BASEVIDHEIGHT-(9+3), 0, gtname);

			break;
		}
		case SECRET_ENCORE:
		{
			static UINT16 encoremapcache = NEXTMAP_INVALID;
			if (encoremapcache > nummapheaders)
			{
				encoremapcache = G_RandMap(G_TOLFlag(GT_RACE), UINT16_MAX, true, false, NULL);
			}
			specialmap = encoremapcache;
			break;
		}
		case SECRET_TIMEATTACK:
		{
			static UINT16 tamapcache = NEXTMAP_INVALID;
			if (tamapcache > nummapheaders)
			{
				tamapcache = G_RandMap(G_TOLFlag(GT_RACE), UINT16_MAX, true, false, NULL);
			}
			specialmap = tamapcache;
			break;
		}
		case SECRET_PRISONBREAK:
		{
			static UINT16 btcmapcache = NEXTMAP_INVALID;
			if (btcmapcache > nummapheaders)
			{
				btcmapcache = G_RandMap(G_TOLFlag(GT_BATTLE), UINT16_MAX, true, false, NULL);
			}
			specialmap = btcmapcache;
			break;
		}
		case SECRET_SPECIALATTACK:
		{
			static UINT16 sscmapcache = NEXTMAP_INVALID;
			if (sscmapcache > nummapheaders)
			{
				sscmapcache = G_RandMap(G_TOLFlag(GT_SPECIAL), UINT16_MAX, true, false, NULL);
			}
			specialmap = sscmapcache;
			break;
		}
		case SECRET_SPBATTACK:
		{
			static UINT16 spbmapcache = NEXTMAP_INVALID;
			if (spbmapcache > nummapheaders)
			{
				spbmapcache = G_RandMap(G_TOLFlag(GT_RACE), UINT16_MAX, true, false, NULL);
			}
			specialmap = spbmapcache;
			break;
		}
		case SECRET_HARDSPEED:
		{
			static UINT16 hardmapcache = NEXTMAP_INVALID;
			if (hardmapcache > nummapheaders)
			{
				hardmapcache = G_RandMap(G_TOLFlag(GT_RACE), UINT16_MAX, true, false, NULL);
			}
			specialmap = hardmapcache;
			break;
		}
		case SECRET_MASTERMODE:
		{
			static UINT16 mastermapcache = NEXTMAP_INVALID;
			if (mastermapcache > nummapheaders)
			{
				mastermapcache = G_RandMap(G_TOLFlag(GT_RACE), UINT16_MAX, true, false, NULL);
			}
			specialmap = mastermapcache;
			break;
		}
		case SECRET_ONLINE:
		{
			V_DrawFixedPatch(-3*FRACUNIT, (y-40)*FRACUNIT,
				FRACUNIT,
				0, W_CachePatchName("EGGASTLA", PU_CACHE),
				NULL);
			break;
		}
		case SECRET_ALTTITLE:
		{
			x = 8;
			y = BASEVIDHEIGHT-16;
			V_DrawGamemodeString(x, y - 33, 0, R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PLAGUE, GTC_MENUCACHE), M_UseAlternateTitleScreen() ? "On" : "Off");

			K_drawButtonAnim(x, y, 0, kp_button_a[1], challengesmenu.ticker);
			x += SHORT(kp_button_a[1][0]->width);
			V_DrawThinString(x, y + 1, highlightflags, "Toggle");


			break;
		}
		case SECRET_ALTMUSIC:
		{
			UINT16 map = M_UnlockableMapNum(ref);
			if (map >= nummapheaders
				|| !mapheaderinfo[map])
			{
				return;
			}

			UINT8 musicid;
			for (musicid = 1; musicid < MAXMUSNAMES; musicid++)
			{
				if (mapheaderinfo[map]->cache_muslock[musicid - 1] == challengesmenu.currentunlock)
					break;
			}

			if (musicid == MAXMUSNAMES)
			{
				return;
			}

			spritedef_t *sprdef = &sprites[SPR_ALTM];
			spriteframe_t *sprframe;
			patch_t *patch;
			UINT32 addflags = 0;

			x -= 10;
			y += 15;

			if (sprdef->numframes)
			{
				sprframe = &sprdef->spriteframes[0];
				patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);

				if (sprframe->flip & 1) // Only for first sprite
				{
					addflags ^= V_FLIP; // This sprite is left/right flipped!
				}

				V_DrawFixedPatch(x*FRACUNIT, (y+2)*FRACUNIT, FRACUNIT/2, addflags, patch, NULL);
			}

			x = 8;
			y = BASEVIDHEIGHT-16;

			const boolean thismusplaying = Music_Playing("challenge_altmusic");
			boolean pushed = false;
			const char *song = NULL;

			if (M_SecretUnlocked(SECRET_ENCORE, true)
				&& musicid < mapheaderinfo[map]->encoremusname_size)
			{
				if (thismusplaying)
				{
					song = Music_Song("challenge_altmusic");
					pushed = strcmp(song, mapheaderinfo[map]->encoremusname[musicid]) == 0;
				}

				K_drawButton(x&FRACUNIT, y*FRACUNIT, 0, kp_button_l, pushed);
				x += SHORT(kp_button_l[0]->width);
				V_DrawThinString(x, y + 1, (pushed ? V_GRAYMAP : highlightflags), "E Side");

				x = 8;
				y -= 10;
			}

			if (musicid < mapheaderinfo[map]->musname_size)
			{
				if (pushed || !thismusplaying)
				{
					pushed = false;
				}
				else
				{
					if (!song)
						song = Music_Song("challenge_altmusic");
					pushed = strcmp(song, mapheaderinfo[map]->musname[musicid]) == 0;
				}

				K_drawButton(x*FRACUNIT, y*FRACUNIT, 0, kp_button_a[1], pushed);
				x += SHORT(kp_button_a[1][0]->width);
				V_DrawThinString(x, y + 1, (pushed ? V_GRAYMAP : highlightflags), "Play CD");
			}
		}
		default:
		{
			break;
		}
	}

	if (specialmap == NEXTMAP_INVALID || !ref)
		return;

	x -= 50;
	y = 146+2;

	K_DrawMapThumbnail(
		(x)<<FRACBITS, (y)<<FRACBITS,
		80<<FRACBITS,
		(ref->type == SECRET_ENCORE) ? V_FLIP : 0,
		specialmap,
		NULL);

	if (ref->type == SECRET_ENCORE)
	{
		static angle_t rubyfloattime = 0;
		const fixed_t rubyheight = FINESINE(rubyfloattime>>ANGLETOFINESHIFT);
		V_DrawFixedPatch((x+40)<<FRACBITS, ((y+25)<<FRACBITS) - (rubyheight<<1), FRACUNIT, 0, W_CachePatchName("RUBYICON", PU_CACHE), NULL);
		rubyfloattime += FixedMul(ANGLE_MAX/NEWTICRATE, renderdeltatics);
	}
	else if (ref->type == SECRET_SPBATTACK)
	{
		V_DrawFixedPatch((x+40-25)<<FRACBITS, ((y+25-25)<<FRACBITS),
			FRACUNIT, 0,
			W_CachePatchName(K_GetItemPatch(KITEM_SPB, false), PU_CACHE),
			NULL);
	}
	else if (ref->type == SECRET_HARDSPEED)
	{
		V_DrawFixedPatch((x+40-25)<<FRACBITS, ((y+25-25)<<FRACBITS),
			FRACUNIT, 0,
			W_CachePatchName(K_GetItemPatch(KITEM_ROCKETSNEAKER, false), PU_CACHE),
			NULL);
	}
	else if (ref->type == SECRET_MASTERMODE)
	{
		V_DrawFixedPatch((x+40-25)<<FRACBITS, ((y+25-25)<<FRACBITS),
			FRACUNIT, 0,
			W_CachePatchName(K_GetItemPatch(KITEM_JAWZ, false), PU_CACHE),
			NULL);
	}
	else
	{
		colormap = R_GetTranslationColormap(TC_DEFAULT, M_GetCvPlayerColor(0), GTC_MENUCACHE);
		V_DrawFixedPatch((x+40)<<FRACBITS, ((y+25)<<FRACBITS),
			FRACUNIT/2, 0,
			W_CachePatchName("K_LAPE02", PU_CACHE),
			colormap);
	}
}

#define challengesgridstep 22

static void M_DrawChallengeKeys(INT32 tilex, INT32 tiley)
{
	const UINT8 pid = 0;

	patch_t *key = W_CachePatchName("UN_CHA00", PU_CACHE);
	INT32 offs = challengesmenu.unlockcount[CMC_CHAONOPE];
	if (offs & 1)
		offs = -offs;
	offs /= 2;

	fixed_t keyx = (8+offs)*FRACUNIT, keyy = 0;

	const boolean keybuttonpress = (menumessage.active == false && M_MenuExtraHeld(pid) == true);

	// Button prompt
	K_drawButton(
		24 << FRACBITS,
		16 << FRACBITS,
		0, kp_button_c[1],
		keybuttonpress
	);

	// Metyr of rounds played that contribute to Chao Key generation
	{
		const INT32 keybarlen = 32, keybary = 28;

		offs = keybarlen;
		if (gamedata->chaokeys < GDMAX_CHAOKEYS)
		{
		#if (GDCONVERT_ROUNDSTOKEY != 32)
			offs = ((gamedata->pendingkeyroundoffset * keybarlen)/GDCONVERT_ROUNDSTOKEY);
		#else
			offs = gamedata->pendingkeyroundoffset;
		#endif
		}

		if (offs > 0)
			V_DrawFill(1+2, keybary, offs, 1, 0);
		if (offs < keybarlen)
			V_DrawFadeFill(1+2+offs, keybary, keybarlen-offs, 1, 0, 31, challengetransparentstrength);
	}

	// Counter
	{
		INT32 textx = 4, texty = 20-challengesmenu.unlockcount[CMC_CHAOANIM];
		UINT8 numbers[4];
		numbers[0] = ((gamedata->chaokeys / 100) % 10);
		numbers[1] = ((gamedata->chaokeys / 10) % 10);
		numbers[2] = (gamedata->chaokeys % 10);

		numbers[3] = ((gamedata->chaokeys / 1000) % 10);
		if (numbers[3] != 0)
		{
			V_DrawScaledPatch(textx - 4, texty, 0, kp_facenum[numbers[3]]);
			textx += 2;
		}

		UINT8 i = 0;
		while (i < 3)
		{
			V_DrawScaledPatch(textx, texty, 0, kp_facenum[numbers[i]]);
			textx += 6;
			i++;
		}
	}

	// Hand
	if (challengesmenu.keywasadded == true)
	{
		INT32 handx = 32 + 16;
		if (keybuttonpress == false)
		{
			// Only animate if it's the focus
			handx -= (skullAnimCounter/5);
		}

		V_DrawScaledPatch(handx, 8, V_FLIP,
			W_CachePatchName("M_CURSOR", PU_CACHE));
	}

	UINT8 keysbeingused = 0;

	// The Chao Key swooping animation
	if (challengesmenu.currentunlock < MAXUNLOCKABLES && challengesmenu.chaokeyhold)
	{
		fixed_t baseradius = challengesgridstep;

		boolean major = false, ending = false;
		if (unlockables[challengesmenu.currentunlock].majorunlock == true)
		{
			major = true;
			tilex += challengesgridstep/2;
			tiley += challengesgridstep/2;
			baseradius = (7*baseradius)/4;
		}

		const INT32 chaohold_duration =
			CHAOHOLD_PADDING
			+ (major
				? CHAOHOLD_MAJOR
				: CHAOHOLD_STANDARD
			);

		if (challengesmenu.chaokeyhold >= chaohold_duration - CHAOHOLD_END)
		{
			ending = true;
			baseradius = ((chaohold_duration - challengesmenu.chaokeyhold)*baseradius)*(FRACUNIT/CHAOHOLD_END);
		}

		INT16 specifickeyholdtime = challengesmenu.chaokeyhold;

		for (; keysbeingused < (major ? 10 : 1); keysbeingused++, specifickeyholdtime -= (CHAOHOLD_STANDARD/10))
		{
			fixed_t radius = baseradius;
			fixed_t thiskeyx, thiskeyy;
			fixed_t keyholdrotation = 0;

			if (specifickeyholdtime < CHAOHOLD_BEGIN)
			{
				if (specifickeyholdtime <= 0)
				{
					// Nothing following will be relevant
					break;
				}

				radius = (specifickeyholdtime*radius)*(FRACUNIT/CHAOHOLD_BEGIN);
				thiskeyx = keyx + specifickeyholdtime*((tilex*FRACUNIT) - keyx)/CHAOHOLD_BEGIN;
				thiskeyy = keyy + specifickeyholdtime*((tiley*FRACUNIT) - keyy)/CHAOHOLD_BEGIN;
			}
			else
			{
				keyholdrotation = (-36 * keysbeingused) * FRACUNIT; // 360/10

				if (ending == false)
				{
					radius <<= FRACBITS;

					keyholdrotation += 360 * ((challengesmenu.chaokeyhold - CHAOHOLD_BEGIN))
						* (FRACUNIT/(CHAOHOLD_STANDARD)); // intentionally not chaohold_duration

					if (keysbeingused == 0)
					{
						INT32 time = (major ? 5 : 3) - (keyholdrotation - 1) / (90 * FRACUNIT);
						if (time <= 5 && time >= 0)
							V_DrawScaledPatch(tilex + 2, tiley - 2, 0, kp_eggnum[time]);
					}
				}

				thiskeyx = tilex*FRACUNIT;
				thiskeyy = tiley*FRACUNIT;
			}

			if (radius != 0)
			{
				angle_t ang = (FixedAngle(
					keyholdrotation
					) >> ANGLETOFINESHIFT) & FINEMASK;

				thiskeyx += FixedMul(radius, FINESINE(ang));
				thiskeyy -= FixedMul(radius, FINECOSINE(ang));
			}

			V_DrawFixedPatch(thiskeyx, thiskeyy, FRACUNIT, 0, key, NULL);
		}
	}

	// The final Chao Key on the stack
	{
		UINT8 *lastkeycolormap = NULL;

		if (gamedata->chaokeys <= keysbeingused)
		{
			// Greyed out if there's going to be none left
			lastkeycolormap = R_GetTranslationColormap(TC_BLINK, SKINCOLOR_BLACK, GTC_MENUCACHE);
		}

		V_DrawFixedPatch(keyx, keyy, FRACUNIT, 0, key, lastkeycolormap);

		// Extra glowverlay if you can use a Chao Key
		if (keysbeingused == 0 && M_CanKeyHiliTile())
		{
			INT32 trans = (((challengesmenu.ticker/5) % 6) - 3);
			if (trans)
			{
				trans = ((trans < 0)
					? (10 + trans)
					: (10 - trans)
				) << V_ALPHASHIFT;

				V_DrawFixedPatch(keyx, keyy, FRACUNIT, trans, key,
					R_GetTranslationColormap(TC_ALLWHITE, 0, GTC_MENUCACHE)
				);
			}
		}
	}
}

void M_DrawChallenges(void)
{
	INT32 x = currentMenu->x, explodex, selectx = 0, selecty = 0;
	INT32 y;
	INT16 i, j;
	const char *str;
	INT16 offset;

	{
#define questionslow 4 // slows down the scroll by this factor
#define questionloop (questionslow*100) // modulo
		INT32 questionoffset;
		double questionoffset_f;
		patch_t *bg = W_CachePatchName("BGUNLCKG", PU_CACHE);
		patch_t *qm = W_CachePatchName("BGUNLSC", PU_CACHE);

		questionoffset_f = fmod(challengesmenu.ticker + FixedToFloat(rendertimefrac), questionloop);
		questionoffset = floor(questionoffset_f);

		// Background gradient
		V_DrawFixedPatch(0, 0, FRACUNIT, 0, bg, NULL);

		// Scrolling question mark overlay
		V_DrawFixedPatch(
			-((160 + questionoffset)*FRACUNIT)/questionslow,
			-(4*FRACUNIT) - (245*(FixedDiv((questionloop - questionoffset)*FRACUNIT, questionloop*FRACUNIT))),
			FRACUNIT,
			V_MODULATE,
			qm,
			NULL);
#undef questionslow
#undef questionloop
	}

	// Do underlay for everything else early so the bottom of the reticule doesn't get shaded over.
	if (challengesmenu.currentunlock < MAXUNLOCKABLES)
	{
		y = 120;

		V_DrawScaledPatch(0, y,
			(10-challengetransparentstrength)<<V_ALPHASHIFT,
			W_CachePatchName("MENUHINT", PU_CACHE));

		V_DrawFadeFill(0, y+27, BASEVIDWIDTH, BASEVIDHEIGHT - (y+27), 0, 31, challengetransparentstrength);
	}

	if (gamedata->challengegrid == NULL || challengesmenu.extradata == NULL)
	{
		V_DrawCenteredMenuString(x, y, V_REDMAP, "No challenges available!?");
		goto challengedesc;
	}

	UINT8 *flashmap = R_GetTranslationColormap(TC_DEFAULT, M_GetCvPlayerColor(0), GTC_MENUCACHE);

	y = currentMenu->y;

	V_DrawFadeFill(0, y-2, BASEVIDWIDTH, (challengesgridstep * CHALLENGEGRIDHEIGHT) + 2, 0, 31, challengetransparentstrength);

	x -= (challengesgridstep-1);

	x += challengesmenu.offset;

	x += Easing_OutQuad(M_DueFrac(challengesmenu.move.start, 4), challengesgridstep * challengesmenu.move.dist, 0);

	if (challengegridloops)
	{
		if (!challengesmenu.col && challengesmenu.hilix)
			x -= gamedata->challengegridwidth*challengesgridstep;
		i = challengesmenu.col + challengesmenu.focusx;
		explodex = x - (i*challengesgridstep);

		while (x < BASEVIDWIDTH-challengesgridstep)
		{
			i = (i + 1) % gamedata->challengegridwidth;
			x += challengesgridstep;
		}
	}
	else
	{
		if (gamedata->challengegridwidth & 1)
			x += (challengesgridstep/2);

		i = gamedata->challengegridwidth-1;
		explodex = x - (i*challengesgridstep)/2;
		x += (i*challengesgridstep)/2;
	}

	selectx = explodex + (challengesmenu.hilix*challengesgridstep);
	selecty = currentMenu->y + (challengesmenu.hiliy*challengesgridstep);

	while (i >= 0 && x >= -(challengesgridstep*2))
	{
		y = currentMenu->y-challengesgridstep;
		for (j = 0; j < CHALLENGEGRIDHEIGHT; j++)
		{
			y += challengesgridstep;

			if (challengesmenu.extradata[(i * CHALLENGEGRIDHEIGHT) + j].flags & CHE_DONTDRAW)
			{
				continue;
			}

			if (x == selectx && j == challengesmenu.hiliy)
			{
				continue;
			}

			M_DrawChallengeTile(i, j, x, y, flashmap, false);
		}

		x -= challengesgridstep;
		i--;
		if (challengegridloops && i < 0)
		{
			i = (i + gamedata->challengegridwidth)
				% gamedata->challengegridwidth;
		}
	}

	if (challengesmenu.fade)
		V_DrawFadeScreen(31, challengesmenu.fade);

	M_DrawChallengeTile(
		challengesmenu.hilix,
		challengesmenu.hiliy,
		selectx,
		selecty,
		flashmap,
		true);
	M_DrawCharSelectExplosions(false, explodex, currentMenu->y);

challengedesc:

	// Name bar
	{
		y = 120;

		if (challengesmenu.currentunlock < MAXUNLOCKABLES)
		{
			str = unlockables[challengesmenu.currentunlock].name;
			if (!gamedata->unlocked[challengesmenu.currentunlock])
			{
				str = "???"; //M_CreateSecretMenuOption(str);
			}

			offset = V_LSTitleLowStringWidth(str, 0) / 2;
			V_DrawLSTitleLowString(BASEVIDWIDTH/2 - offset, y+6, 0, str);
		}
	}

	// Wings
	{
		const INT32 endy = 18, endlen = 38;
		patch_t *endwing = W_CachePatchName("K_BOSB01", PU_CACHE);

		V_DrawFill(0, endy, endlen, 11, 24);
		V_DrawFixedPatch(endlen*FRACUNIT, endy*FRACUNIT, FRACUNIT, V_FLIP, endwing, NULL);

		V_DrawFill(BASEVIDWIDTH - endlen, endy, endlen, 11, 24);
		V_DrawFixedPatch((BASEVIDWIDTH - endlen)*FRACUNIT, endy*FRACUNIT, FRACUNIT, 0, endwing, NULL);
	}

	// Percentage
	{
		patch_t *medal = W_CachePatchName(
			va("UN_MDL%c", '0' + challengesmenu.unlockcount[CMC_MEDALID]),
			PU_CACHE
		);

		fixed_t medalchopy = 1;

		for (i = CMC_MEDALBLANK; i <= CMC_MEDALFILLED; i++)
		{
			if (challengesmenu.unlockcount[i] == 0)
				continue;

			V_SetClipRect(
				0,
				medalchopy << FRACBITS,
				BASEVIDWIDTH << FRACBITS,
				(medalchopy + challengesmenu.unlockcount[i]) << FRACBITS,
				0
			);

			UINT8 *medalcolormap = NULL;
			if (i == CMC_MEDALBLANK)
			{
				medalcolormap = R_GetTranslationColormap(TC_BLINK, SKINCOLOR_BLACK, GTC_MENUCACHE);
			}
			else if (challengesmenu.unlockcount[CMC_MEDALID] == 0)
			{
				medalcolormap = R_GetTranslationColormap(TC_DEFAULT, M_GetCvPlayerColor(0), GTC_MENUCACHE);
			}

			V_DrawFixedPatch((BASEVIDWIDTH - 31)*FRACUNIT, 1*FRACUNIT, FRACUNIT, 0, medal, medalcolormap);

			V_ClearClipRect();

			medalchopy += challengesmenu.unlockcount[i];
		}

		INT32 textx = BASEVIDWIDTH - 21, texty = 20-challengesmenu.unlockcount[CMC_ANIM];
		UINT8 numbers[3];
		numbers[0] = ((challengesmenu.unlockcount[CMC_PERCENT] / 100) % 10);
		numbers[1] = ((challengesmenu.unlockcount[CMC_PERCENT] / 10) % 10);
		numbers[2] = (challengesmenu.unlockcount[CMC_PERCENT] % 10);

		patch_t *percent = W_CachePatchName("K_SPDML1", PU_CACHE);

		V_DrawScaledPatch(textx + 2, texty, 0, percent);

		i = 3;
		while (i)
		{
			i--;
			textx -= 6;
			V_DrawScaledPatch(textx, texty, 0, kp_facenum[numbers[i]]);
		}
	}

	// Chao Key information
	M_DrawChallengeKeys(selectx, selecty);

	// Derived from M_DrawCharSelectPreview
	x = 40;
	y = BASEVIDHEIGHT-16;

	// Unlock preview
	M_DrawChallengePreview(x, y);

	// Conditions for unlock
	i = (challengesmenu.hilix * CHALLENGEGRIDHEIGHT) + challengesmenu.hiliy;

	if (challengesmenu.unlockcondition != NULL
	&& challengesmenu.currentunlock < MAXUNLOCKABLES
	&& ((gamedata->unlocked[challengesmenu.currentunlock] == true)
		|| ((challengesmenu.extradata != NULL)
		&& (challengesmenu.extradata[i].flags & CHE_HINT))
		)
	)
	{
		V_DrawCenteredThinString(BASEVIDWIDTH/2, 120 + 32, 0, challengesmenu.unlockcondition);
	}
}

#undef challengetransparentstrength
#undef challengesgridstep

// Statistics menu

#define STATSSTEP 10

static void M_DrawMapMedals(INT32 mapnum, INT32 x, INT32 y)
{
	UINT8 lasttype = UINT8_MAX, curtype;

	// M_GetLevelEmblems is ONE-indexed, urgh
	mapnum++;

	emblem_t *emblem = M_GetLevelEmblems(mapnum);

	boolean hasmedals = (emblem != NULL);

	while (emblem)
	{
		switch (emblem->type)
		{
			case ET_TIME:
				curtype = 1;
				break;
			case ET_GLOBAL:
			{
				if (emblem->flags & GE_NOTMEDAL)
				{
					emblem = M_GetLevelEmblems(-1);
					continue;
				}
				curtype = 2;
				break;
			}
			case ET_MAP:
			{
				if (((emblem->flags & ME_ENCORE) && !M_SecretUnlocked(SECRET_ENCORE, true))
					|| ((emblem->flags & ME_SPBATTACK) && !M_SecretUnlocked(SECRET_SPBATTACK, true)))
				{
					emblem = M_GetLevelEmblems(-1);
					continue;
				}
				curtype = 0;
				break;
			}
			default:
				curtype = 0;
				break;
		}

		// Shift over if emblem is of a different discipline
		if (lasttype != UINT8_MAX && lasttype != curtype)
			x -= 4;
		lasttype = curtype;

		if (gamedata->collected[emblem-emblemlocations])
			V_DrawMappedPatch(x, y, 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_CACHE),
				R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_MENUCACHE));
		else
			V_DrawScaledPatch(x, y, 0, W_CachePatchName("NEEDIT", PU_CACHE));

		emblem = M_GetLevelEmblems(-1);
		x -= 8;
	}

	// Undo offset
	mapnum--;

	if (hasmedals)
		x -= 4;

	if (mapheaderinfo[mapnum]->cache_spraycan < gamedata->numspraycans)
	{
		UINT16 col = gamedata->spraycans[mapheaderinfo[mapnum]->cache_spraycan].col;

		if (col < numskincolors)
		{
			V_DrawMappedPatch(x, y, 0, W_CachePatchName("GOTCAN", PU_CACHE),
				R_GetTranslationColormap(TC_DEFAULT, col, GTC_MENUCACHE));
			//V_DrawRightAlignedThinString(x - 2, y, 0, skincolors[col].name);
		}
		x -= 8;
	}

	if (mapheaderinfo[mapnum]->records.mapvisited & MV_MYSTICMELODY)
	{
		V_DrawScaledPatch(x, y, 0, W_CachePatchName("GOTMEL", PU_CACHE));
		x -= 8;
	}
}

static void M_DrawStatsMaps(void)
{
	INT32 y = 70, i;
	INT16 mnum;
	boolean dotopname = true, dobottomarrow = (statisticsmenu.location < statisticsmenu.maxscroll);
	INT32 location = statisticsmenu.location;

	tic_t besttime = 0;

	if (!statisticsmenu.maplist)
	{
		V_DrawCenteredThinString(BASEVIDWIDTH/2, 70, 0, "No maps!?");
		return;
	}

	INT32 mapsunfinished = 0;

	V_DrawThinString(30, 60, 0, va("x %d/%d", statisticsmenu.gotmedals, statisticsmenu.nummedals));
	V_DrawMappedPatch(20, 60, 0, W_CachePatchName("GOTITA", PU_CACHE),
				                       R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_GOLD, GTC_MENUCACHE));

	INT32 medalspos = BASEVIDWIDTH - 20;

	boolean timeattack[3];
	timeattack[0] = M_SecretUnlocked(SECRET_TIMEATTACK, true);
	timeattack[1] = M_SecretUnlocked(SECRET_PRISONBREAK, true);
	timeattack[2] = M_SecretUnlocked(SECRET_SPECIALATTACK, true);

	if (timeattack[0] || timeattack[1] || timeattack[2])
	{
		medalspos -= 64;

		for (i = 0; i < nummapheaders; i++)
		{
			// Check for no visibility
			if (!mapheaderinfo[i] || (mapheaderinfo[i]->menuflags & (LF2_NOTIMEATTACK|LF2_HIDEINMENU)))
				continue;

			// Has to be accessible via time attack
			if (!(mapheaderinfo[i]->typeoflevel & (TOL_RACE|TOL_BATTLE|TOL_SPECIAL|TOL_VERSUS)))
				continue;

			if (mapheaderinfo[i]->records.timeattack.time <= 0)
			{
				mapsunfinished++;
				continue;
			}

			besttime += mapheaderinfo[i]->records.timeattack.time;
		}

		V_DrawRightAlignedThinString(BASEVIDWIDTH-20, 60, 0,
			va(
				"Combined time: %c%i:%02i:%02i.%02i (%s)",
				(mapsunfinished ? '\x85' : '\x80'),
				G_TicsToHours(besttime),
				G_TicsToMinutes(besttime, false),
				G_TicsToSeconds(besttime),
				G_TicsToCentiseconds(besttime),
				(mapsunfinished ? "incomplete" : "complete")
			)
		);
	}

	if (location)
		V_DrawMenuString(10, 80-(skullAnimCounter/5),
			highlightflags, "\x1A"); // up arrow

	i = -1;

	while ((mnum = statisticsmenu.maplist[++i]) != NEXTMAP_INVALID)
	{
		if (location)
		{
			--location;
			continue;
		}

		if (dotopname || mnum >= nummapheaders)
		{
			if (mnum >= nummapheaders)
			{
				mnum = statisticsmenu.maplist[1+i];
				if (mnum >= nummapheaders)
					mnum = statisticsmenu.maplist[i-1];
			}

			if (mnum < nummapheaders)
			{
				const char *str;

				if (mapheaderinfo[mnum]->typeoflevel & TOL_TUTORIAL)
					str = "TUTORIAL MODE";
				else if (mapheaderinfo[mnum]->cup)
					str = va("%s CUP", mapheaderinfo[mnum]->cup->realname);
				else
					str = "LOST & FOUND";

				V_DrawThinString(20,  y, highlightflags, str);
			}

			if (dotopname)
			{
				V_DrawRightAlignedThinString(medalspos, y, highlightflags, "MEDALS");

				if (timeattack[0] || timeattack[1] || timeattack[2])
					V_DrawRightAlignedThinString((BASEVIDWIDTH-20), y, highlightflags, "TIME");

				dotopname = false;
			}

			y += STATSSTEP;
			if (y >= BASEVIDHEIGHT-STATSSTEP)
				goto bottomarrow;

			continue;
		}

		V_DrawFadeFill(24, y + 5, (BASEVIDWIDTH - 24) - 24, 3, 0, 31, 8 - (i & 1)*2);

		if (!(mapheaderinfo[mnum]->menuflags & LF2_NOTIMEATTACK)
		&& (
				(timeattack[0] && (mapheaderinfo[mnum]->typeoflevel & TOL_RACE))
			|| (timeattack[1] && (mapheaderinfo[mnum]->typeoflevel & TOL_BATTLE))
			|| (timeattack[2] && (mapheaderinfo[mnum]->typeoflevel & (TOL_SPECIAL|TOL_VERSUS)))
			)
		)
		{
			besttime = mapheaderinfo[mnum]->records.timeattack.time;

			if (besttime)
			{
				V_DrawRightAlignedString((BASEVIDWIDTH-24), y+1, 0,
					va("%02d'%02d\"%02d",
						G_TicsToMinutes(besttime, true),
						G_TicsToSeconds(besttime),
						G_TicsToCentiseconds(besttime)
					)
				);
			}
			else
			{
				V_DrawRightAlignedString((BASEVIDWIDTH-24), y+1, V_GRAYMAP, "--'--\"--");
			}
		}

		M_DrawMapMedals(mnum, medalspos - 8, y);

		if (mapheaderinfo[mnum]->menuttl[0])
		{
			V_DrawThinString(24, y, V_FORCEUPPERCASE, mapheaderinfo[mnum]->menuttl);
		}
		else
		{
			char *title = G_BuildMapTitle(mnum+1);
			V_DrawThinString(24, y, V_FORCEUPPERCASE, title);
			Z_Free(title);
		}

		y += STATSSTEP;

		if (y >= BASEVIDHEIGHT-STATSSTEP)
			goto bottomarrow;
	}
	if (location)
		--location;

	if (statisticsmenu.numextramedals == 0)
		goto bottomarrow;

	// Extra Emblem headers
	for (i = 0; i < 2; ++i)
	{
		if (i == 1)
		{
			V_DrawThinString(20, y, highlightflags, "EXTRA MEDALS");
			if (location)
			{
				y += STATSSTEP;
				location++;
			}
		}
		if (location)
		{
			--location;
			continue;
		}

		y += STATSSTEP;

		if (y >= BASEVIDHEIGHT-STATSSTEP)
			goto bottomarrow;
	}

	// Extra Emblems
	for (i = 0; i < MAXUNLOCKABLES; i++)
	{
		if (unlockables[i].type != SECRET_EXTRAMEDAL)
		{
			continue;
		}

		if (location)
		{
			--location;
			continue;
		}

		{
			if (gamedata->unlocked[i])
			{
				UINT16 color = min(unlockables[i].color, numskincolors-1);
				if (!color)
					color = SKINCOLOR_GOLD;
				V_DrawMappedPatch(291, y+1, 0, W_CachePatchName("GOTITA", PU_CACHE),
				                       R_GetTranslationColormap(TC_DEFAULT, color, GTC_MENUCACHE));
			}
			else
			{
				V_DrawScaledPatch(291, y+1, 0, W_CachePatchName("NEEDIT", PU_CACHE));
			}

			V_DrawThinString(24, y, 0, va("%s", unlockables[i].name));
		}

		y += STATSSTEP;

		if (y >= BASEVIDHEIGHT-STATSSTEP)
			goto bottomarrow;
	}
bottomarrow:
	if (dobottomarrow)
		V_DrawMenuString(10, BASEVIDHEIGHT-20 + (skullAnimCounter/5),
			highlightflags, "\x1B"); // down arrow
}

#undef STATSSTEP
#define STATSSTEP 18

static void M_DrawStatsChars(void)
{
	INT32 y = 80, i, j;
	INT16 skin;
	boolean dobottomarrow = (statisticsmenu.location < statisticsmenu.maxscroll);
	INT32 location = statisticsmenu.location;

	if (!statisticsmenu.maplist || !statisticsmenu.nummaps)
	{
		V_DrawCenteredThinString(BASEVIDWIDTH/2, 70, 0, "No chars!?");
		return;
	}

	if (location)
		V_DrawMenuString(10, y-(skullAnimCounter/5),
			highlightflags, "\x1A"); // up arrow

	i = -1;

	V_DrawThinString(20, y - 10, highlightflags, "CHARACTER");
	V_DrawRightAlignedThinString(BASEVIDWIDTH/2 + 34, y - 10, highlightflags, "WINS");

	while ((skin = statisticsmenu.maplist[++i]) < numskins)
	{
		if (location)
		{
			--location;
			continue;
		}

		{
			UINT8 *colormap = R_GetTranslationColormap(skin, skins[skin].prefcolor, GTC_MENUCACHE);

			M_DrawCharacterIconAndEngine(24, y, skin, colormap, false);
		}

		V_DrawThinString(24+32+2, y+3, 0, skins[skin].realname);

		V_DrawRightAlignedThinString(BASEVIDWIDTH/2 + 30, y+3, 0, va("%d", skins[skin].records.wins));

		y += STATSSTEP;

		if (y >= BASEVIDHEIGHT-STATSSTEP)
			goto bottomarrow;
	}

bottomarrow:
	if (dobottomarrow)
		V_DrawMenuString(10, BASEVIDHEIGHT-20 + (skullAnimCounter/5),
			highlightflags, "\x1B"); // down arrow

	UINT32 x = BASEVIDWIDTH - 20 - 90;
	y = 88;

	V_DrawCenteredThinString(x + 45, y - 10, highlightflags, "HEATMAP");

	V_DrawFadeFill(x, y, 91, 91, 0, 31, 8); // challengetransparentstrength

	V_DrawFill(x+30, y+1,  1, 89,  0);
	V_DrawFill(x+60, y+1,  1, 89,  0);
	V_DrawFill(x+1,  y+30, 89, 1,  0);
	V_DrawFill(x+1,  y+60, 89, 1,  0);

	x++;
	y++;

	for (i = 0; i < 9; i++)
	{
		for (j = 0; j < 9; j++)
		{
			if (statisticsmenu.statgridplayed[i][j] == 0)
				continue;

			V_DrawFill(
				x + (i * 10),
				y + (j * 10),
				9,
				9,
				31 - ((statisticsmenu.statgridplayed[i][j] - 1) * 32) / FRACUNIT
			);
		}
	}
}

#undef STATSSTEP
#define STATSSTEP 21

static void M_DrawStatsGP(void)
{
	INT32 y = 80, i, x, j, endj;
	INT16 id;
	boolean dobottomarrow = (statisticsmenu.location < statisticsmenu.maxscroll);
	INT32 location = statisticsmenu.location;

	if (!statisticsmenu.maplist || !statisticsmenu.nummaps)
	{
		V_DrawCenteredThinString(BASEVIDWIDTH/2, 70, 0, "No cups!?");
		return;
	}

	if (location)
		V_DrawMenuString(10, y-(skullAnimCounter/5),
			highlightflags, "\x1A"); // up arrow

	const INT32 width = 53;

	endj = KARTSPEED_NORMAL;
	if (M_SecretUnlocked(SECRET_HARDSPEED, true))
	{
		endj = M_SecretUnlocked(SECRET_MASTERMODE, true)
			? KARTGP_MASTER
			: KARTSPEED_HARD;
	}

	const INT32 h = (21 * min(5, statisticsmenu.nummaps)) - 1;

	x = 7 + BASEVIDWIDTH - 20 - width;
	for (j = endj; j >= KARTSPEED_EASY; j--, x -= width)
	{
		if (j == KARTSPEED_EASY || !gamedata->everseenspecial)
		{
			V_DrawFadeFill(x + 6, y + 1, width - (12 + 1), h, 0, 31, 6 + (j & 1)*2);
			V_DrawCenteredThinString(x + 19 + 7, y - 10, highlightflags|V_FORCEUPPERCASE, gpdifficulty_cons_t[j].strvalue);
			x += (12 + 1);
		}
		else
		{
			V_DrawFadeFill(x - 7, y + 1, width, h, 0, 31, 6 + (j & 1)*2);
			V_DrawCenteredThinString(x + 19, y - 10, highlightflags|V_FORCEUPPERCASE, gpdifficulty_cons_t[j].strvalue);
		}
	}

	i = -1;

	V_DrawThinString(20, y - 10, highlightflags, "CUP");

	cupheader_t *cup = kartcupheaders;

	while ((id = statisticsmenu.maplist[++i]) < numkartcupheaders)
	{
		if (location)
		{
			--location;
			continue;
		}

		// If we have ANY sort of sorting other than instantiation, this won't work
		while (cup && cup->id != id)
		{
			cup = cup->next;
		}

		if (!cup)
		{
			goto bottomarrow;
		}

		V_DrawFill(24, y+1, 21, 20, 31);

		V_DrawScaledPatch(24-1, y, 0, W_CachePatchName(cup->icon, PU_CACHE));
		V_DrawScaledPatch(24-1, y, 0, W_CachePatchName("CUPBOX", PU_CACHE));

		V_DrawThinString(24+21+2, y + 7, 0, cup->realname);

		x = 7 + BASEVIDWIDTH - 20 - width;
		for (j = endj; j >= KARTSPEED_EASY; j--)
		{
			x -= (M_DrawCupWinData(x, y + 5, cup, j, false, true) + 2);
		}

		y += STATSSTEP;

		if (y >= BASEVIDHEIGHT-STATSSTEP)
			goto bottomarrow;
	}

bottomarrow:
	if (dobottomarrow)
		V_DrawMenuString(10, BASEVIDHEIGHT-20 + (skullAnimCounter/5),
			highlightflags, "\x1B"); // down arrow
}

#undef STATSSTEP

void M_DrawStatistics(void)
{
	char beststr[256];
	tic_t besttime = 0;

	{
		const char *pagename = NULL;
		INT32 pagenamewidth = 0;

		V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("MENUHINT", PU_CACHE), NULL);

		switch (statisticsmenu.page)
		{

			case statisticspage_gp:
			{
				pagename = gamedata->everseenspecial
					? "GRAND PRIX & EMERALDS"
					: "GRAND PRIX";
				M_DrawStatsGP();
				break;
			}

			case statisticspage_maps:
			{
				pagename = "COURSES & MEDALS";
				M_DrawStatsMaps();
				break;
			}

			case statisticspage_chars:
			{
				pagename = "CHARACTERS & ENGINE CLASSES";
				M_DrawStatsChars();
				break;
			}

			default:
				break;
		}

		if (pagename)
		{
			pagenamewidth = V_ThinStringWidth(pagename, 0);
			V_DrawThinString((BASEVIDWIDTH - pagenamewidth)/2, 12, 0, pagename);
		}

		V_DrawMenuString((BASEVIDWIDTH - pagenamewidth)/2 - 10 - (skullAnimCounter/5), 12,
			0, "\x1C"); // left arrow

		V_DrawMenuString((BASEVIDWIDTH + pagenamewidth)/2 + 2 + (skullAnimCounter/5), 12,
			0, "\x1D"); // right arrow
	}

	beststr[0] = 0;
	V_DrawThinString(20, 30, highlightflags, "Total Play Time:");
	besttime = G_TicsToHours(gamedata->totalplaytime);
	if (besttime)
	{
		if (besttime >= 24)
		{
			strcat(beststr, va("%u day%s, ", besttime/24, (besttime < 48 ? "" : "s")));
			besttime %= 24;
		}

		strcat(beststr, va("%u hour%s, ", besttime, (besttime == 1 ? "" : "s")));
	}
	besttime = G_TicsToMinutes(gamedata->totalplaytime, false);
	if (besttime)
	{
		strcat(beststr, va("%u minute%s, ", besttime, (besttime == 1 ? "" : "s")));
	}
	besttime = G_TicsToSeconds(gamedata->totalplaytime);
	strcat(beststr, va("%i second%s", besttime, (besttime == 1 ? "" : "s")));
	V_DrawRightAlignedThinString(BASEVIDWIDTH-20, 30, 0, beststr);
	beststr[0] = 0;

	V_DrawThinString(20, 40, highlightflags, "Total Rings:");
	if (gamedata->totalrings > GDMAX_RINGS)
	{
		sprintf(beststr, "%c999,999,999+", '\x82');
	}
	else if (gamedata->totalrings >= 1000000)
	{
		sprintf(beststr, "%u,%03u,%03u", (gamedata->totalrings/1000000), (gamedata->totalrings/1000)%1000, (gamedata->totalrings%1000));
	}
	else if (gamedata->totalrings >= 1000)
	{
		sprintf(beststr, "%u,%03u", (gamedata->totalrings/1000), (gamedata->totalrings%1000));
	}
	else
	{
		sprintf(beststr, "%u", gamedata->totalrings);
	}
	V_DrawRightAlignedThinString(BASEVIDWIDTH-20, 40, 0, va("%s collected", beststr));

	beststr[0] = 0;
	V_DrawThinString(20, 50, highlightflags, "Total Rounds:");

	strcat(beststr, va("%u Race", gamedata->roundsplayed[GDGT_RACE]));

	if (gamedata->roundsplayed[GDGT_PRISONS] > 0)
	{
		strcat(beststr, va(", %u Prisons", gamedata->roundsplayed[GDGT_PRISONS]));
	}

	strcat(beststr, va(", %u Battle", gamedata->roundsplayed[GDGT_BATTLE]));

	if (gamedata->roundsplayed[GDGT_SPECIAL] > 0)
	{
		strcat(beststr, va(", %u Special", gamedata->roundsplayed[GDGT_SPECIAL]));
	}

	if (gamedata->roundsplayed[GDGT_CUSTOM] > 0)
	{
		strcat(beststr, va(", %u Custom", gamedata->roundsplayed[GDGT_CUSTOM]));
	}

	V_DrawRightAlignedThinString(BASEVIDWIDTH-20, 50, 0, beststr);
}

static void M_DrawWrongPlayer(UINT8 i)
{
#define wrongpl wrongwarp.wrongplayers[i]
	if (wrongpl.skin >= numskins)
		return;

	UINT8 *colormap = R_GetTranslationColormap(wrongpl.skin, skins[wrongpl.skin].prefcolor, GTC_MENUCACHE);

	M_DrawCharacterSprite(
		wrongpl.across,
		160 - ((i & 1) ? 0 : 32),
		wrongpl.skin,
		wrongpl.spinout ? SPR2_SPIN : SPR2_SLWN,
		wrongpl.spinout ? ((wrongpl.across/8) & 7) : 6,
		(wrongwarp.ticker+i),
		0, colormap
	);
#undef wrongpl
}

void M_DrawWrongWarp(void)
{
	INT32 titleoffset = 0, titlewidth, x, y;
	const char *titletext = "WRONG GAME? WRONG GAME! ";

	if (wrongwarp.ticker < 2*TICRATE/3)
		return;

	V_DrawFadeScreen(31, min((wrongwarp.ticker - 2*TICRATE/3), 5));

	// SMK title screen recreation!?

	if (wrongwarp.ticker >= 2*TICRATE)
	{
		// Done as four calls and not a loop for the sake of render order
		M_DrawWrongPlayer(0);
		M_DrawWrongPlayer(2);
		M_DrawWrongPlayer(1);
		M_DrawWrongPlayer(3);
	}

	y = 20;

	x = BASEVIDWIDTH - 8;

	if (wrongwarp.ticker < TICRATE)
	{
		INT32 adjust = floor(pow(2, (double)(TICRATE - wrongwarp.ticker)));
		x += adjust/2;
		y += adjust;
	}

	titlewidth = V_LSTitleHighStringWidth(titletext, 0);
	titleoffset = (-wrongwarp.ticker) % titlewidth;

	while (titleoffset < BASEVIDWIDTH)
	{
		V_DrawLSTitleHighString(titleoffset, y, 0, titletext);
		titleoffset += titlewidth;
	}

	patch_t *bumper = W_CachePatchName((M_UseAlternateTitleScreen() ? "MTSJUMPR1" : "MTSBUMPR1"), PU_CACHE);
	V_DrawScaledPatch(x-(SHORT(bumper->width)), (BASEVIDHEIGHT-8)-(SHORT(bumper->height)), 0, bumper);
}

void M_DrawSoundTest(void)
{
	const UINT8 pid = 0;

	INT32 x, y, i, cursorx = 0;
	INT32 titleoffset = 0, titlewidth;
	const char *titletext;

	patch_t *btn = W_CachePatchName("STER_BTN", PU_CACHE);

	const char *tune = S_SoundTestTune(0);

	V_DrawFixedPatch(0, 0, FRACUNIT, 0, W_CachePatchName("STER_BG", PU_CACHE), NULL);

	x = 24;
	y = 18;

	V_SetClipRect(
		x << FRACBITS, y << FRACBITS,
		272 << FRACBITS, 106 << FRACBITS,
		0
	);

	y += 32;

	if (soundtest.current != NULL)
	{
		if (soundtest.current->sequence.map < nummapheaders)
		{
			K_DrawMapThumbnail(
				0, 0,
				BASEVIDWIDTH<<FRACBITS,
				V_20TRANS|V_ADD,
				soundtest.current->sequence.map,
				NULL);

			V_DrawFixedPatch(
				0, 0,
				FRACUNIT,
				V_60TRANS|V_SUBTRACT,
				W_CachePatchName("STER_DOT", PU_CACHE),
				NULL
			);
		}

		titletext = soundtest.current->title;
		if (!titletext)
			titletext = "Untitled"; // Har har.

		V_DrawThinString(x+1, y, 0, titletext);
		if (soundtest.current->numtracks > 1)
			V_DrawThinString(x+1, (y += 10), 0, va("Track %c", 'A'+soundtest.currenttrack));
		if (soundtest.current->author)
			V_DrawThinString(x+1, (y += 10), 0, soundtest.current->author);
		if (soundtest.current->source)
			V_DrawThinString(x+1, (y += 10), 0, soundtest.current->source);
		if (soundtest.current->composers)
			V_DrawThinString(x+1, (y += 10), 0, soundtest.current->composers);
	}
	else
	{
		const char *sfxstr = (cv_soundtest.value) ? S_sfx[cv_soundtest.value].name : "N/A";

		titletext = "Sound Test";

		V_DrawThinString(x+1, y, 0, "Track ");
		V_DrawThinString(
			x+1 + V_ThinStringWidth("Track ", 0),
			y,
			0,
			va("%04X - %s", cv_soundtest.value, sfxstr)
		);
	}

	titletext = va("%s - ", titletext);
	titlewidth = V_LSTitleHighStringWidth(titletext, 0);
	titleoffset = (-soundtest.menutick) % titlewidth;

	while (titleoffset < 272)
	{
		V_DrawLSTitleHighString(x + titleoffset, 18+1, 0, titletext);
		titleoffset += titlewidth;
	}

	{
		UINT32 currenttime = min(Music_Elapsed(tune), Music_TotalDuration(tune));

		V_DrawRightAlignedThinString(x + 272-1, 18+32, 0,
			va("%02u:%02u",
				G_TicsToMinutes(currenttime, true),
				G_TicsToSeconds(currenttime)
			)
		);
	}

	if ((soundtest.playing && soundtest.current)
		&& (soundtest.current->basenoloop[soundtest.currenttrack] == true
		|| soundtest.autosequence == true))
	{
		UINT32 exittime = Music_TotalDuration(tune);

		V_DrawRightAlignedThinString(x + 272-1, 18+32+10, 0,
			va("%02u:%02u",
				G_TicsToMinutes(exittime, true),
				G_TicsToSeconds(exittime)
			)
		);
	}

	V_ClearClipRect();

	x = currentMenu->x;

	for (i = 0; i < currentMenu->numitems; i++)
	{
		if (currentMenu->menuitems[i].status == IT_SPACE)
		{
			if (currentMenu->menuitems[i].mvar2 != 0)
			{
				x = currentMenu->menuitems[i].mvar2;
			}

			x += currentMenu->menuitems[i].mvar1;

			continue;
		}

		y = currentMenu->y;

		if (i == itemOn)
		{
			cursorx = x + 13;
		}

		if (currentMenu->menuitems[i].tooltip)
		{
			V_SetClipRect(
				x << FRACBITS, y << FRACBITS,
				27 << FRACBITS, 22 << FRACBITS,
				0
			);

			// Special cases
			if (currentMenu->menuitems[i].mvar2 == stereospecial_back) // back
			{
				if (!soundtest.justopened && M_MenuBackHeld(pid))
				{
					y = currentMenu->y + 7;
				}
			}
			// The following are springlocks.
			else if (currentMenu->menuitems[i].mvar2 == stereospecial_pause) // pause
			{
				if (Music_Paused(tune) == true)
					y = currentMenu->y + 6;
			}
			else if (currentMenu->menuitems[i].mvar2 == stereospecial_play) // play
			{
				if (soundtest.playing == true && Music_Paused(tune) == false)
					y = currentMenu->y + 6;
			}
			else if (currentMenu->menuitems[i].mvar2 == stereospecial_seq) // seq
			{
				if (soundtest.autosequence == true)
					y = currentMenu->y + 6;
			}
			else if (currentMenu->menuitems[i].mvar2 == stereospecial_shf) // shf
			{
				if (soundtest.shuffle == true)
					y = currentMenu->y + 6;
			}

			// Button is being pressed
			if (i == itemOn && !soundtest.justopened && M_MenuConfirmHeld(pid))
			{
				y = currentMenu->y + 7;
			}

			// Button itself
			V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, btn, NULL);

			// Icon
			V_DrawFixedPatch(x << FRACBITS, y << FRACBITS,
				FRACUNIT, 0,
				W_CachePatchName(currentMenu->menuitems[i].tooltip, PU_CACHE),
				NULL
			);

			// Text
			V_DrawCenteredThinString(x + 13, y + 1, 0, currentMenu->menuitems[i].text);

			V_ClearClipRect();

			V_DrawFill(x+2, currentMenu->y + 22, 23, 1, 30);
		}
		else if (currentMenu->menuitems[i].mvar2 == stereospecial_vol) // Vol
		{
			consvar_t *voltoadjust = M_GetSoundTestVolumeCvar();
			INT32 j = 0, vol = 0;
			const INT32 barheight = 22;
			patch_t *knob = NULL;
			INT32 knobflags = 0;

			if (i == itemOn)
			{
				if ((menucmd[pid].dpad_ud < 0 && (soundtest.menutick & 2)) || M_MenuConfirmPressed(pid))
				{
					knob = W_CachePatchName("STER_KNT", PU_CACHE);
					knobflags = V_FLIP;
					j = 24;
				}
				else if (menucmd[pid].dpad_ud > 0 && (soundtest.menutick & 2))
				{
					knob = W_CachePatchName("STER_KNT", PU_CACHE);
				}
			}

			if (knob == NULL)
				knob = W_CachePatchName("STER_KNB", PU_CACHE);

			V_DrawFixedPatch((x+1+j) << FRACBITS, y << FRACBITS,
				FRACUNIT, knobflags,
				knob,
				NULL
			);

			V_DrawFill(x+1+24, y+1, 5, barheight, 30);

			if (voltoadjust != NULL)
			{
				vol = (barheight*voltoadjust->value)/(MAX_SOUND_VOLUME*3);
			}

			for (j = 0; j <= barheight/3; j++)
			{
				UINT8 col = 130;

				if (j == 0)
				{
					continue;
				}

				if (j > vol)
				{
					col = 20;
				}
				else if (j > (barheight/3)-2)
				{
					col = 34;
				}

				V_DrawFill(x+1+24+2, y+1 + (barheight-(j*3)), 1, 2, col);
			}

			x += 5;
		}
		else if (currentMenu->menuitems[i].mvar2 == stereospecial_track) // Track
		{
			if (i == itemOn)
			{
				if (menucmd[pid].dpad_ud < 0 || M_MenuConfirmPressed(pid))
				{
					y--;
				}
				else if (menucmd[pid].dpad_ud > 0)
				{
					y++;
				}
			}

			V_DrawFixedPatch(x << FRACBITS, (y-1) << FRACBITS,
				FRACUNIT, 0,
				W_CachePatchName("STER_WH0", PU_CACHE),
				NULL
			);
		}
		else
		{
			V_DrawCenteredThinString(x + 13, y + 1, 0, currentMenu->menuitems[i].text);
		}

		x += 25;
	}

	V_DrawMenuString(cursorx - 4, currentMenu->y - 8 - (skullAnimCounter/5),
		V_SNAPTOTOP|highlightflags, "\x1B"); // up arrow
}

#ifdef HAVE_DISCORDRPC
void M_DrawDiscordRequests(void)
{
	discordRequest_t *curRequest = discordRequestList;
	UINT8 *colormap;
	patch_t *hand = NULL;

	const char *wantText = "...would like to join!";
	const char *acceptText = "Accept" ;
	const char *declineText = "Decline";

	INT32 x = 100;
	INT32 y = 133;

	INT32 slide = 0;
	INT32 maxYSlide = 18;

	if (discordrequestmenu.confirmDelay > 0)
	{
		if (discordrequestmenu.confirmAccept == true)
		{
			colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_GREEN, GTC_MENUCACHE);
			hand = W_CachePatchName("K_LAPH02", PU_CACHE);
		}
		else
		{
			colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_RED, GTC_MENUCACHE);
			hand = W_CachePatchName("K_LAPH03", PU_CACHE);
		}

		slide = discordrequestmenu.confirmLength - discordrequestmenu.confirmDelay;
	}
	else
	{
		colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_GREY, GTC_MENUCACHE);
	}

	V_DrawFixedPatch(56*FRACUNIT, 150*FRACUNIT, FRACUNIT, 0, W_CachePatchName("K_LAPE01", PU_CACHE), colormap);

	if (hand != NULL)
	{
		fixed_t handoffset = (4 - abs((signed)(skullAnimCounter - 4))) * FRACUNIT;
		V_DrawFixedPatch(56*FRACUNIT, 150*FRACUNIT + handoffset, FRACUNIT, 0, hand, NULL);
	}

	K_DrawSticker(x + (slide * 32), y - 2, V_ThinStringWidth(M_GetDiscordName(curRequest), 0), 0, false);
	V_DrawThinString(x + (slide * 32), y - 1, V_YELLOWMAP, M_GetDiscordName(curRequest));

	K_DrawSticker(x, y + 12, V_ThinStringWidth(wantText, 0), 0, true);
	V_DrawThinString(x, y + 10, 0, wantText);

	INT32 confirmButtonWidth = SHORT(kp_button_a[1][0]->width);
	INT32 declineButtonWidth = SHORT(kp_button_b[1][0]->width);
	INT32 altDeclineButtonWidth = SHORT(kp_button_x[1][0]->width);
	INT32 acceptTextWidth =  V_ThinStringWidth(acceptText, 0);
	INT32 declineTextWidth = V_ThinStringWidth(declineText, 0);
	INT32 stickerWidth = (confirmButtonWidth + declineButtonWidth + altDeclineButtonWidth + acceptTextWidth + declineTextWidth);

	K_DrawSticker(x, y + 26, stickerWidth, 0, true);
	K_drawButtonAnim(x, y + 22, V_SNAPTORIGHT, kp_button_a[1], discordrequestmenu.ticker);

	INT32 xoffs = confirmButtonWidth;

	V_DrawThinString((x + xoffs), y + 24, 0, acceptText);
	xoffs += acceptTextWidth;

	K_drawButtonAnim((x + xoffs), y + 22, V_SNAPTORIGHT, kp_button_b[1], discordrequestmenu.ticker);
	xoffs += declineButtonWidth;

	K_drawButtonAnim((x + xoffs), y + 22, V_SNAPTORIGHT, kp_button_x[1], discordrequestmenu.ticker);
	xoffs += altDeclineButtonWidth;

	V_DrawThinString((x + xoffs), y + 24, 0, declineText);

	y -= 18;

	while (curRequest->next != NULL)
	{
		INT32 ySlide = min(slide * 4, maxYSlide);

		curRequest = curRequest->next;

		const char *discordname = M_GetDiscordName(curRequest);

		K_DrawSticker(x, y - 1 + ySlide, V_ThinStringWidth(discordname, 0), 0, false);
		V_DrawThinString(x, y + ySlide, 0, discordname);

		y -= 12;
		maxYSlide = 12;
	}
}
#endif