ensure skin models are ALWAYS initialized

if smth sets nomd2s those werent set up correctly and enabling models just ended up drawing nothing instead

ideally nomd2s == false should just completely disable the model system but im too lazy for that currently

src/CMakeLists.txt

@@ -257,7 +257,7 @@ set(SRB2_CONFIG_SATURNJOIN ON CACHE BOOL
 set(SRB2_CONFIG_SCREENFBO ON CACHE BOOL
 	"Enable hardware renderer (OpenGL) FBO downsampling support")
 
-set(SRB2_CONFIG_PHOBOS ON CACHE BOOL
+set(SRB2_CONFIG_PHOBOS OFF CACHE BOOL
 	" Compile the Phobos client. Which contains things not compatible with vanilla, such as raised skinlimits, 32 player support, bugfixes, etc.")
 
 if(${SRB2_CONFIG_DEDICATED})
@@ -586,7 +586,7 @@ if(${SRB2_CONFIG_SATURNJOIN})
 	add_definitions(-DDOSATURNJOIN)
 endif()
 
-if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_SCREENFBO})
+if(${SRB2_CONFIG_PHOBOS})
 	add_definitions(-DPHOBOS_BUILD)
 endif()
 

src/blua/ldo.c

@@ -55,8 +55,8 @@ struct lua_longjmp {
 
 void luaD_seterrorobj (lua_State *L, int lerrcode, StkId oldtop) {
   switch (lerrcode) {
-    case LUA_ERRMEM: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
+    case LUA_ERRMEM: {  /* memory error? */
+      setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
       break;
     }
     case LUA_ERRERR: {

src/blua/lmem.h

@@ -13,8 +13,6 @@
 #include "llimits.h"
 #include "lua.h"
 
-#define MEMERRMSG	"not enough memory"
-
 
 #define luaM_reallocv(L,b,on,n,e) \
 	((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ?  /* +1 to avoid warnings */ \

src/blua/lstate.c

@@ -64,6 +64,9 @@ static void freestack (lua_State *L, lua_State *L1) {
 }
 
 
+#define MEMERRMSG       "not enough memory"
+
+
 /*
 ** open parts that may cause memory-allocation errors
 */
@@ -76,7 +79,9 @@ static void f_luaopen (lua_State *L, void *ud) {
   luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
   luaT_init(L);
   luaX_init(L);
-  luaS_fix(luaS_newliteral(L, MEMERRMSG));
+  /* pre-create memory-error message */
+  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
+  luaS_fix(g->memerrmsg);  /* it should never be collected */
   g->GCthreshold = 4*g->totalbytes;
 }
 

src/blua/lstate.h

@@ -88,6 +88,7 @@ typedef struct global_State {
   lua_CFunction panic;  /* to be called in unprotected errors */
   TValue l_registry;
   struct lua_State *mainthread;
+  TString *memerrmsg;  /* memory-error message */
   UpVal uvhead;  /* head of double-linked list of all open upvalues */
   struct Table *mt[NUM_TAGS];  /* metatables for basic types */
   TString *tmname[TM_N];  /* array with tag-method names */

src/d_clisrv.c

@@ -811,7 +811,7 @@ static void resynch_read_player(resynch_pak *rsp)
 	players[i].mo->scalespeed = (fixed_t)LONG(rsp->scalespeed);
 
 	// And finally, SET THE MOBJ SKIN damn it.
-	players[i].mo->skin = &skins[players[i].skin];
+	players[i].mo->skin = skins[players[i].skin];
 	players[i].mo->color = players[i].skincolor;
 
 	P_SetThingPosition(players[i].mo);
@@ -1822,7 +1822,7 @@ static void SV_SendPlayerInfo(INT32 node)
 
 		// Extra data
 		// Kart has extra skincolors, so we can't use this
-		//netbuffer->u.playerinfo[i].data = 0; //netbuffer->u.playerinfo[i].data = players[i].skincolor;
+		//netbuffer->u.playerinfo[i].data = 0;
 
 		// well why not, we only got like 100 of these?
 		netbuffer->u.playerinfo[i].data = players[i].skincolor;
@@ -3347,6 +3347,7 @@ static void Command_connect(void)
 		return;
 	}
 
+	// StarManiaKG: allow us to join servers from anywhere at any time //
 	if (Playing() || demo.title || demo.playback)
 	{
 		if (demo.title || demo.playback)
@@ -3365,7 +3366,9 @@ static void Command_connect(void)
 		D_StartTitle();
 	}
 	else
+	{
 		M_ClearMenus(true); // close the menus
+	}
 
 	// modified game check: no longer handled
 	// we don't request a restart unless the filelist differs
@@ -3381,37 +3384,52 @@ static void Command_connect(void)
 	}
 	else
 	{
-		// used in menu to connect to a server in the list
-		if (netgame && fasticmp(COM_Argv(1), "node"))
+		// Get the server node.
+		if (netgame)
 		{
-			servernode = (SINT8)atoi(COM_Argv(2));
-		}
-		else if (netgame)
-		{
-			CONS_Printf(M_GetText("You cannot connect while in a game. End this game first.\n"));
-			return;
-		}
-		else if (I_NetOpenSocket)
-		{
-			I_NetOpenSocket();
-			netgame = true;
-			multiplayer = true;
-
-			if (fasticmp(COM_Argv(1), "any"))
-				servernode = BROADCASTADDR;
-			else if (I_NetMakeNodewPort && COM_Argc() >= 3)
-				servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
-			else if (I_NetMakeNodewPort)
-				servernode = I_NetMakeNode(COM_Argv(1));
+			// used in menu to connect to a server in the list
+			if (fasticmp(COM_Argv(1), "node"))
+			{
+				servernode = (SINT8)atoi(COM_Argv(2));
+			}
 			else
 			{
-				CONS_Alert(CONS_ERROR, M_GetText("There is no server identification with this network driver\n"));
-				D_CloseConnection();
-				return;
+				D_QuitNetGame();
+				CL_Reset();
+				D_StartTitle();
 			}
 		}
 		else
-			CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
+		{
+			// Standard behaviour
+			if (I_NetOpenSocket)
+			{
+				I_NetOpenSocket();
+				netgame = true;
+				multiplayer = true;
+
+				if (fasticmp(COM_Argv(1), "any"))
+					servernode = BROADCASTADDR;
+				else if (I_NetMakeNodewPort)
+				{
+					if (COM_Argc() >= 3) // address AND port
+						servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
+					else // address only, or address:port
+						servernode = I_NetMakeNode(COM_Argv(1));
+				}
+				else
+				{
+					CONS_Alert(CONS_ERROR, M_GetText("There is no server identification with this network driver\n"));
+					D_CloseConnection();
+					return;
+				}
+			}
+			else
+			{
+				CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
+				return;
+			}
+		}
 
 		// invalid address
 		if (servernode == -1)
@@ -3458,6 +3476,7 @@ static void ResetNode(INT32 node);
 //
 void CL_ClearPlayer(INT32 playernum)
 {
+	// Handle mobj_t pointers.
 	if (players[playernum].mo)
 	{
 		// Don't leave a NiGHTS ghost!
@@ -3466,6 +3485,7 @@ void CL_ClearPlayer(INT32 playernum)
 		P_RemoveMobj(players[playernum].mo);
 	}
 
+	// Wipe the struct.
 	memset(&players[playernum], 0, sizeof(player_t));
 }
 
@@ -4108,7 +4128,7 @@ static void Got_KickCmd(const UINT8 **p, INT32 playernum)
 						if (!players[i].mo->skin)
 							CONS_Printf("Mobj skin: NULL!\n");
 						else
-							CONS_Printf("Mobj skin: %s\n", ((skin_t *)players[i].mo->skin)->name);
+							CONS_Printf("Mobj skin: %s\n", players[i].mo->skin->name);
 						CONS_Printf("Position: %d, %d, %d\n", players[i].mo->x, players[i].mo->y, players[i].mo->z);
 						if (!players[i].mo->state)
 							CONS_Printf("State: S_NULL\n");
@@ -5174,7 +5194,7 @@ static void PT_ServerInfo(SINT8 node)
 	const tic_t ticthen = (tic_t)LONG(netbuffer->u.serverinfo.time);
 	const tic_t ticdiff = (ticnow - ticthen)*1000/NEWTICRATE;
 	netbuffer->u.serverinfo.time = (tic_t)LONG(ticdiff);
-	netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = 0;
+	netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = '\0';
 	netbuffer->u.serverinfo.application
 		[sizeof netbuffer->u.serverinfo.application - 1] = '\0';
 	memcpy(servername, netbuffer->u.serverinfo.servername, MAXSERVERNAME);
@@ -7253,6 +7273,7 @@ static void DedicatedIdleUpdate(INT32 *realtics)
 		{
 			CONS_Printf("DEDICATED: Awakening from idle (Player detected...)\n");
 		}
+
 		dedicatedidle = 0;
 	}
 }

src/d_main.c

@@ -1149,13 +1149,19 @@ static void D_FindAddonsToAutoload(void)
 		// ok so theres still issues with players adding stuff to autoload by accident
 		// sometimes this stuff contains maps
 		// you can probably imagine how that goes in a netgame....
-		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
+		int retmap = W_CheckAutoLoadContainsMap(wadsToAutoload);
+		if (retmap == -1)
+		{
+			CONS_Alert(CONS_WARNING, "Autoload: file %s was not found or not valid.\n", wadsToAutoload);
+			continue;
+		}
+		if (retmap > 0)
 		{
 			CONS_Alert(CONS_WARNING, "Autoload: file %s contains map data, this WILL cause crashes and desynchs! skipping...\n", wadsToAutoload);
 			continue;
 		}
 
-		if (!postload && W_CheckPostLoadList(wadsToAutoload))
+		if (!postload && W_CheckPostLoadList(wadsToAutoload) > 0)
 		{
 			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
 			postload = true;

src/d_netcmd.c

@@ -147,6 +147,11 @@ static void Command_Addfilelocal(void);
 static void Command_Addfile(void);
 static void Command_Addskins(void);
 static void Command_GLocalSkin(void);
+static void SetPrefcolor(int splitplayer);
+static void Command_UsePrefcolor(void);
+static void Command_UsePrefcolor2(void);
+static void Command_UsePrefcolor3(void);
+static void Command_UsePrefcolor4(void);
 static void Command_ListWADS_f(void);
 static void Command_LocateLump_f(void);
 static void Command_ListDoomednums_f(void);
@@ -866,6 +871,11 @@ void D_RegisterClientCommands(void)
 
 	COM_AddCommand("localskin", Command_GLocalSkin);
 
+	COM_AddCommand("useprefcolor", Command_UsePrefcolor);
+	COM_AddCommand("useprefcolor2", Command_UsePrefcolor2);
+	COM_AddCommand("useprefcolor3", Command_UsePrefcolor3);
+	COM_AddCommand("useprefcolor4", Command_UsePrefcolor4);
+
 	K_RegisterClientKartStuff(); // SRB2kart
 
 	CV_RegisterVar(&cv_screenshot_option);
@@ -1164,14 +1174,14 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 	for (i = 0; i < numskins; i++)
 	{
 		// Perfect match with some skin name, no need to find matching realname
-		if (strncasecmp(value, skins[i].name, sizeof skins[i].name) == 0)
+		if (strncasecmp(value, skins[i]->name, sizeof skins[i]->name) == 0)
 			return;
 
-		const char *match = strcasestr(skins[i].realname, value);
+		const char *match = strcasestr(skins[i]->realname, value);
 		if (match != NULL)
 		{
 			matches[nummatches] = i;
-			matches_pos[nummatches] = match - skins[i].realname;
+			matches_pos[nummatches] = match - skins[i]->realname;
 			++nummatches;
 		}
 	}
@@ -1179,7 +1189,7 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 	if (nummatches == 1)
 	{
 		// Change the cvar to be the value of the name.
-		CV_StealthSet(cvar, skins[matches[0]].name);
+		CV_StealthSet(cvar, skins[matches[0]]->name);
 	}
 	else if (nummatches > 1)
 	{
@@ -1193,7 +1203,7 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 
 		for (i = 0; i < nummatches; ++i)
 		{
-			const char *realname = skins[matches[i]].realname;
+			const char *realname = skins[matches[i]]->realname;
 
 			if (matches_pos[i] == 0)
 				start[0] = 0;
@@ -1208,7 +1218,7 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 
 			end = realname + matches_pos[i] + query_length;
 
-			CONS_Printf("%s\x85%s\x80%s (%s)\n", start, match, end, skins[matches[i]].name);
+			CONS_Printf("%s\x85%s\x80%s (%s)\n", start, match, end, skins[matches[i]]->name);
 		}
 
 		CONS_Printf("\x86Try be more specific\n");
@@ -1543,13 +1553,13 @@ static void ForceAllSkins(INT32 forcedskin)
 		if (!dedicated) // But don't do this for dedicated servers, of course.
 		{
 			if (i == consoleplayer)
-				CV_StealthSet(&cv_skin, skins[forcedskin].name);
+				CV_StealthSet(&cv_skin, skins[forcedskin]->name);
 			else if (i == displayplayers[1])
-				CV_StealthSet(&cv_skin2, skins[forcedskin].name);
+				CV_StealthSet(&cv_skin2, skins[forcedskin]->name);
 			else if (i == displayplayers[2])
-				CV_StealthSet(&cv_skin3, skins[forcedskin].name);
+				CV_StealthSet(&cv_skin3, skins[forcedskin]->name);
 			else if (i == displayplayers[3])
-				CV_StealthSet(&cv_skin4, skins[forcedskin].name);
+				CV_StealthSet(&cv_skin4, skins[forcedskin]->name);
 		}
 	}
 }
@@ -1603,8 +1613,8 @@ static void SendNameAndColor(UINT8 splitplayer)
 	{
 		if (player->skincolor)
 			CV_StealthSetValue(playercolor, player->skincolor);
-		else if (skins[player->skin].prefcolor)
-			CV_StealthSetValue(playercolor, skins[player->skin].prefcolor);
+		else if (skins[player->skin]->prefcolor)
+			CV_StealthSetValue(playercolor, skins[player->skin]->prefcolor);
 		else
 			CV_StealthSet(playercolor, playercolor->defaultvalue);
 	}
@@ -1615,7 +1625,7 @@ static void SendNameAndColor(UINT8 splitplayer)
 
 	if (fastcmp(playername->string, player_names[pnum])
 		&& playercolor->value == player->skincolor
-		&& fastcmp(playerskin->string, skins[player->skin].name))
+		&& fastcmp(playerskin->string, skins[player->skin]->name))
 		return;
 
 	if (playerisbot)
@@ -1644,12 +1654,12 @@ static void SendNameAndColor(UINT8 splitplayer)
 		{
 			playerskin->value = foundskin;
 			SetPlayerSkin(pnum, playerskin->string);
-			CV_StealthSet(playerskin, skins[playerskin->value].name);
+			CV_StealthSet(playerskin, skins[playerskin->value]->name);
 		}
 		else
 		{
 			playerskin->value = player->skin;
-			CV_StealthSet(playerskin, skins[player->skin].name);
+			CV_StealthSet(playerskin, skins[player->skin]->name);
 			// will always be same as current
 			SetPlayerSkin(pnum, playerskin->string);
 		}
@@ -1674,7 +1684,7 @@ static void SendNameAndColor(UINT8 splitplayer)
 
 	// Don't change skin if the server doesn't want you to.
 	if (!CanChangeSkin(pnum))
-		CV_StealthSet(playerskin, skins[player->skin].name);
+		CV_StealthSet(playerskin, skins[player->skin]->name);
 
 	// check if player has the skin loaded (cv_skin may have
 	// the name of a skin that was available in the previous game)
@@ -1682,7 +1692,7 @@ static void SendNameAndColor(UINT8 splitplayer)
 	if (playerskin->value < 0)
 	{
 		INT32 skinnum = player->skin;
-		CV_StealthSet(playerskin, skins[skinnum].name);
+		CV_StealthSet(playerskin, skins[skinnum]->name);
 		playerskin->value = skinnum;
 	}
 
@@ -1770,13 +1780,13 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 
 		// TODO: make cv_skin an array
 		if (playernum == consoleplayer)
-			CV_StealthSet(&cv_skin, skins[forcedskin].name);
+			CV_StealthSet(&cv_skin, skins[forcedskin]->name);
 		else if (playernum == displayplayers[1])
-			CV_StealthSet(&cv_skin2, skins[forcedskin].name);
+			CV_StealthSet(&cv_skin2, skins[forcedskin]->name);
 		else if (playernum == displayplayers[2])
-			CV_StealthSet(&cv_skin3, skins[forcedskin].name);
+			CV_StealthSet(&cv_skin3, skins[forcedskin]->name);
 		else if (playernum == displayplayers[3])
-			CV_StealthSet(&cv_skin4, skins[forcedskin].name);
+			CV_StealthSet(&cv_skin4, skins[forcedskin]->name);
 	}
 	else
 		SetPlayerSkinByNum(playernum, skin);
@@ -4334,6 +4344,49 @@ static void Command_GLocalSkin(void)
 	}
 }
 
+static void SetPrefcolor(int splitplayer)
+{
+	// splitscreen
+	if (splitscreen < splitplayer)
+		return;
+
+	const INT32 pnum = P_GetLocalPlayerNumForNum(splitplayer);
+
+	player_t *player = &players[pnum];
+	consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
+	consvar_t *playercolor = colorvars[splitplayer];
+
+	if (skins[player->skin]->prefcolor)
+	{
+		CV_SetValue(playercolor, skins[player->skin]->prefcolor);
+		CONS_Printf("Set color to %s%s\n", HU_SkinColorToConsoleColor(skins[player->skin]->prefcolor), KartColor_Names[skins[player->skin]->prefcolor]);
+	}
+	else
+	{
+		CONS_Printf("\x86Your skin has no prefcolor set\n");
+	}
+}
+
+static void Command_UsePrefcolor(void)
+{
+	SetPrefcolor(0);
+}
+
+static void Command_UsePrefcolor2(void)
+{
+	SetPrefcolor(1);
+}
+
+static void Command_UsePrefcolor3(void)
+{
+	SetPrefcolor(2);
+}
+
+static void Command_UsePrefcolor4(void)
+{
+	SetPrefcolor(3);
+}
+
 static void Got_RequestAddfilecmd(const UINT8 **cp, INT32 playernum)
 {
 	char filename[241];
@@ -4381,7 +4434,7 @@ static void Got_RequestAddfilecmd(const UINT8 **cp, INT32 playernum)
 		else
 			snprintf(message, sizeof(message), M_GetText("Unknown error finding wad file (%s)\n"), filename);
 
-		CONS_Printf("%s",message);
+		CONS_Printf("%s", message);
 
 		for (j = 0; j < MAXPLAYERS; j++)
 			if (adminplayers[j])
@@ -5579,7 +5632,7 @@ static void Skin_OnChange(void)
 	if (!(cv_debug || devparm) && !(multiplayer || netgame) // In single player.
 		&& (gamestate != GS_WAITINGPLAYERS)) // allows command line -warp x +skin y
 	{
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin]->name);
 		return;
 	}
 
@@ -5588,7 +5641,7 @@ static void Skin_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin]->name);
 	}
 }
 
@@ -5609,7 +5662,7 @@ static void Skin2_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin].name);
+		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin]->name);
 	}
 }
 
@@ -5625,7 +5678,7 @@ static void Skin3_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin].name);
+		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin]->name);
 	}
 }
 
@@ -5641,7 +5694,7 @@ static void Skin4_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin].name);
+		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin]->name);
 	}
 }
 
@@ -5684,7 +5737,7 @@ static void Command_ListSkins(void)
 	for (i = page * 10; i < numskins && i < (page + 1) * 10; i++)
 	{
 		int length;
-		skin_t *skin = &skins[i];
+		skin_t *skin = skins[i];
 
 		if ((length = strlen(skin->name)) > longest_name)
 			longest_name = length;
@@ -5692,7 +5745,7 @@ static void Command_ListSkins(void)
 
 	for (i = page * 10; i < numskins && i < (page + 1) * 10; i++)
 	{
-		skin_t *skin = &skins[i];
+		skin_t *skin = skins[i];
 
 		CONS_Printf(
 			"%s[%-*s]\x80 %s\n",
@@ -5722,7 +5775,7 @@ static void Command_SkinSearch(void)
 	{
 		for (s = 0; s < numskins; s++)
 		{
-			skin_t *skininput = &skins[s];
+			skin_t *skininput = skins[s];
 
 			if (strcasestr(skininput->realname, COM_Argv(i)))
 			{
@@ -5746,7 +5799,7 @@ static void Color_OnChange(void)
 
 	if (!(cv_debug || devparm) && !(multiplayer || netgame || modeattacking)) // In single player.
 	{
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin]->name);
 		return;
 	}
 

src/d_player.h

@@ -361,11 +361,17 @@ typedef struct squishdance_s
 {
 	tic_t   countdown; // hold "custom 3" for 2 seconds to engange le dance
 	tic_t   time;
-	fixed_t work;
-	fixed_t ang;
-	fixed_t bounce;    // hehe squishy
 } squishdance_t;
 
+typedef struct salty_s
+{
+	bool ready;
+	bool tapping;
+	fixed_t zoffset;
+	fixed_t momz;
+	bool jump;
+} salty_t;
+
 // ========================================================================
 //                          PLAYER STRUCTURE
 // ========================================================================
@@ -561,6 +567,9 @@ typedef struct player_s
 
 	fixed_t spinoutrot; // When a player spins out, this value increments modulus 360.
 
+	// saltyhop! hardcode edition
+	salty_t salty;
+
 	squishdance_t squishdance;
 
 	fixed_t fovadd; // adjust FOV for hw rendering

src/discord.c

@@ -684,7 +684,7 @@ void DRPC_UpdatePresence(void)
 		// Character image
 		while (supportedSkins[checkSkin] != NULL)
 		{
-			if (fastcmp(skins[players[consoleplayer].skin].name, supportedSkins[checkSkin]))
+			if (fastcmp(skins[players[consoleplayer].skin]->name, supportedSkins[checkSkin]))
 			{
 				snprintf(charimg, 21, "char%s", supportedSkins[checkSkin]);
 				discordPresence.smallImageKey = charimg;
@@ -701,7 +701,7 @@ void DRPC_UpdatePresence(void)
 			discordPresence.smallImageKey = "charcustom";
 		}
 
-		snprintf(charname, 28, "Character: %s", skins[players[consoleplayer].skin].realname);
+		snprintf(charname, 28, "Character: %s", skins[players[consoleplayer].skin]->realname);
 		discordPresence.smallImageText = charname; // Character name
 	}
 

src/doomdef.h

@@ -128,8 +128,13 @@ extern char  logfilename[1024];
 // most interface strings are ignored in development mode.
 // we use comprevision and compbranch instead.
 #else
+#ifdef PHOBOS_BUILD
+#define VERSION    1 // Game version
+#define SUBVERSION 69 // more precise version number
+#else
 #define VERSION    1 // Game version
 #define SUBVERSION 6 // more precise version number
+#endif
 
 #ifdef PHOBOS_BUILD
 #define CLIENTNAME  "Phobos"
@@ -139,8 +144,8 @@ extern char  logfilename[1024];
 #define CLIENTNAMEW L"Saturn"
 #endif
 
-#define VERSIONSTRING  CLIENTNAME  " v10"
-#define VERSIONSTRINGW CLIENTNAMEW L" v10"
+#define VERSIONSTRING  CLIENTNAME  " v10.1"
+#define VERSIONSTRINGW CLIENTNAMEW L" v10.1"
 
 #define SATURN_TESTING // comment out for saturn release builds!
 

src/f_finale.c

@@ -324,7 +324,7 @@ void F_IntroTicker(void)
 			// Need to use M_Random otherwise it always uses the same sound
 			INT32 rskin = M_RandomKey(numskins);
 			UINT8 rtaunt = M_RandomKey(2);
-			sfxenum_t rsound = skins[rskin].soundsid[SKSKBST1+rtaunt];
+			sfxenum_t rsound = skins[rskin]->soundsid[SKSKBST1+rtaunt];
 			S_StartSound(NULL, rsound);
 		}
 	}
@@ -1162,17 +1162,17 @@ void F_StartWaitingPlayers(void)
 	finalecount = 0;
 
 	randskin = M_RandomKey(numskins);
-	boolean waithires = skins[randskin].flags && SF_HIRES;
+	boolean waithires = skins[randskin]->flags && SF_HIRES;
 
 	Z_Free(waitcolormap);
-	waitcolormap = R_GetTranslationColormap(randskin, skins[randskin].prefcolor, 0);
+	waitcolormap = R_GetTranslationColormap(randskin, skins[randskin]->prefcolor, 0);
 
 	if (waithires)
-		waitscale = waitscale * FIXED_TO_FLOAT(skins[randskin].highresscale); // need to set scale here cause im lazy
+		waitscale = waitscale * FIXED_TO_FLOAT(skins[randskin]->highresscale); // need to set scale here cause im lazy
 
 	for (i = 0; i < 2; i++)
 	{
-		sprframe = &skins[randskin].spritedef.spriteframes[(6+(i*3)) & FF_FRAMEMASK];
+		sprframe = &skins[randskin]->spritedef.spriteframes[(6+(i*3)) & FF_FRAMEMASK];
 		driver[i] = W_CachePatchNum(sprframe->lumppat[1], PU_CACHE);
 	}
 }

src/g_demo.c

@@ -203,7 +203,7 @@ static INT32 GetSkinNumClosestToStats(UINT8 kartspeed, UINT8 kartweight)
 
 	for (i = 0; i < numskins; i++)
 	{
-		stat_diff = abs(skins[i].kartspeed - kartspeed) + abs(skins[i].kartweight - kartweight);
+		stat_diff = abs(skins[i]->kartspeed - kartspeed) + abs(skins[i]->kartweight - kartweight);
 
 		if (stat_diff < closest_stats)
 		{
@@ -266,7 +266,7 @@ void G_ReadDemoExtraData(void)
 			kartspeed = READUINT8(demobuf.p);
 			kartweight = READUINT8(demobuf.p);
 
-			if (!fasticmp(skins[player->skin].name, name))
+			if (!fasticmp(skins[player->skin]->name, name))
 				FindClosestSkinForStats(p, kartspeed, kartweight);
 
 			player->kartspeed = kartspeed;
@@ -396,12 +396,12 @@ void G_WriteDemoExtraData(void)
 			{
 				// Skin
 				memset(name, 0, 16);
-				strncpy(name, skins[players[i].skin].name, 16);
+				strncpy(name, skins[players[i].skin]->name, 16);
 				memcpy(demobuf.p, name, 16);
 				demobuf.p += 16;
 
-				WRITEUINT8(demobuf.p, skins[players[i].skin].kartspeed);
-				WRITEUINT8(demobuf.p, skins[players[i].skin].kartweight);
+				WRITEUINT8(demobuf.p, skins[players[i].skin]->kartspeed);
+				WRITEUINT8(demobuf.p, skins[players[i].skin]->kartweight);
 			}
 
 			if (demo_extradata[i] & DXD_COLOR)
@@ -1807,7 +1807,7 @@ void G_BeginRecording(void)
 
 		// Skin
 		memset(name, 0, 16);
-		strncpy(name, skins[player->skin].name, 16);
+		strncpy(name, skins[player->skin]->name, 16);
 		memcpy(demobuf.p, name, 16);
 		demobuf.p += 16;
 
@@ -1821,8 +1821,8 @@ void G_BeginRecording(void)
 		WRITEUINT32(demobuf.p, player->score);
 
 		// Kart speed and weight
-		WRITEUINT8(demobuf.p, skins[player->skin].kartspeed);
-		WRITEUINT8(demobuf.p, skins[player->skin].kartweight);
+		WRITEUINT8(demobuf.p, skins[player->skin]->kartspeed);
+		WRITEUINT8(demobuf.p, skins[player->skin]->kartweight);
 	}
 
 	WRITEUINT8(demobuf.p, 0xFF); // Denote the end of the player listing
@@ -1878,7 +1878,7 @@ void G_WriteStanding(UINT8 ranking, char *name, INT32 skinnum, UINT8 color, UINT
 
 	// Skin
 	memset(temp, 0, 16);
-	strncpy(temp, skins[skinnum].name, 16);
+	strncpy(temp, skins[skinnum]->name, 16);
 	memcpy(demobuf.p, temp, 16);
 	demobuf.p += 16;
 
@@ -2351,7 +2351,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
 
 		for (i = 0; i < numskins; i++)
 		{
-			if (fasticmp(skins[i].name, temp))
+			if (fasticmp(skins[i]->name, temp))
 			{
 				pdemo->standings[count].skin = i;
 				break;
@@ -3029,7 +3029,7 @@ void G_DoPlayDemo(char *defdemoname)
 		kartspeed[p] = READUINT8(demobuf.p);
 		kartweight[p] = READUINT8(demobuf.p);
 
-		if (!fasticmp(skins[players[p].skin].name, skin))
+		if (!fasticmp(skins[players[p].skin]->name, skin))
 			FindClosestSkinForStats(p, kartspeed[p], kartweight[p]);
 
 		// Look for the next player
@@ -3106,7 +3106,7 @@ void G_AddGhost(char *defdemoname)
 	CLEANUP(Z_Pfree) UINT8 *buffer = NULL;
 	mapthing_t *mthing;
 	UINT16 count, ghostversion;
-	skin_t *ghskin = &skins[0];
+	skin_t *ghskin = skins[0];
 	UINT8 kartspeed = UINT8_MAX, kartweight = UINT8_MAX;
 
 	name[16] = '\0';
@@ -3313,9 +3313,9 @@ void G_AddGhost(char *defdemoname)
 
 	for (i = 0; i < numskins; i++)
 	{
-		if (fasticmp(skins[i].name, skin))
+		if (fasticmp(skins[i]->name, skin))
 		{
-			ghskin = &skins[i];
+			ghskin = skins[i];
 			break;
 		}
 	}
@@ -3323,7 +3323,7 @@ void G_AddGhost(char *defdemoname)
 	if (i == numskins)
 	{
 		if (kartspeed != UINT8_MAX && kartweight != UINT8_MAX)
-			ghskin = &skins[GetSkinNumClosestToStats(kartspeed, kartweight)];
+			ghskin = skins[GetSkinNumClosestToStats(kartspeed, kartweight)];
 
 		CONS_Alert(CONS_NOTICE, M_GetText("Ghost %s: Invalid character. Falling back to %s.\n"), pdemoname, ghskin->name);
 	}

src/g_game.c

@@ -3935,9 +3935,9 @@ void G_DeferedInitNew(boolean pencoremode, const char *mapname, INT32 pickedchar
 	}
 
 	if (!color && !modeattacking)
-		color = skins[pickedchar].prefcolor;
+		color = skins[pickedchar]->prefcolor;
 	SetPlayerSkinByNum(consoleplayer, pickedchar);
-	CV_StealthSet(&cv_skin, skins[pickedchar].name);
+	CV_StealthSet(&cv_skin, skins[pickedchar]->name);
 
 	if (color)
 		CV_StealthSetValue(&cv_playercolor, color);

src/hardware/hw_batching.c

@@ -35,7 +35,7 @@ static int finalVertexArrayAllocSize = 65536;
 // not gonna use this for now, just sort by color and change state when it changes
 // later maybe when using vertex attributes if it's needed
 
-static PolygonArrayEntry* polygonArray        = NULL ;// contains the polygon data from DrawPolygon, waiting to be processed
+static PolygonArrayEntry* polygonArray        = NULL; // contains the polygon data from DrawPolygon, waiting to be processed
 static PolygonArrayEntry **polygonArraySorted = NULL; // contains sorted pointers to polygonArray
 static int polygonArraySize      = 0;
 static int polygonArrayAllocSize = 65536;
@@ -171,8 +171,8 @@ static int comparePolygons(const void *p1, const void *p2)
 
 	// special case with signedness to prevent overflowing
 	// FIXME: check for prediction slowdowns!
-	const int shader1 = poly1->hash & 0x80000000 ? -1 : poly1->shader;
-	const int shader2 = poly2->hash & 0x80000000 ? -1 : poly2->shader;
+	const int shader1 = (poly1->hash & 0x80000000) ? -1 : poly1->shader;
+	const int shader2 = (poly2->hash & 0x80000000) ? -1 : poly2->shader;
 
 	// skywalls and horizon lines must retain their order for horizon lines to work
 	if (shader1 == -1 && shader2 == -1)
@@ -214,8 +214,8 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
 	const PolygonArrayEntry *poly1 = *(PolygonArrayEntry *const *)p1;
 	const PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
 
-	const GLMipmap_t *texture1 = poly1->hash & 0x80000000 ? NULL : poly1->texture;
-	const GLMipmap_t *texture2 = poly2->hash & 0x80000000 ? NULL : poly2->texture;
+	const GLMipmap_t *texture1 = (poly1->hash & 0x80000000) ? NULL : poly1->texture;
+	const GLMipmap_t *texture2 = (poly2->hash & 0x80000000) ? NULL : poly2->texture;
 
 	// skywalls and horizon lines must retain their order for horizon lines to work
 	if (!texture1 && !texture2)

src/hardware/hw_main.cpp

@@ -1236,7 +1236,7 @@ static void HWR_DrawSkyWall(FOutVector *wallVerts, FSurfaceInfo *Surf)
 // Returns true if the midtexture is visible, and false if... it isn't...
 static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
 {
-	FUINT blendmode = PF_Masked | PF_Translucent;
+	FUINT blendmode = PF_Masked;
 
 	pSurf->PolyColor.s.alpha = 0xFF;
 
@@ -3296,7 +3296,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 	// technically this_scale gets multiplied and added to sprite y/x scale, but this thing needs it for some crap so ill just throw it in here again
 	this_scale = FixedToFloat(spr->mobj->scale);
 
-	const skin_t *moskin = K_GetMobjSkin(spr->mobj);
+	const skin_t *moskin = R_GetMobjSkin(spr->mobj);
 	if (moskin && moskin->flags & SF_HIRES)
 		this_scale *= FixedToFloat(moskin->highresscale);
 
@@ -4361,17 +4361,8 @@ static void HWR_DrawSprites(void)
 			{
 				if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
 				{
-					md2_t *md2;
-
-					if (spr->mobj->localskin)
-					{
-						if (spr->mobj->skinlocal)
-							md2 = &md2_localplayermodels[(skin_t *)spr->mobj->localskin - localskins];
-						else
-							md2 = &md2_playermodels     [(skin_t *)spr->mobj->localskin -      skins];
-					}
-					else
-						md2 = &md2_playermodels[(skin_t *)spr->mobj->skin - skins];
+					/* fuck you */
+					md2_t *md2 = &R_GetMobjSkin(spr->mobj)->playermodel;
 
 					// 8/1/19: Only don't display player models if no default SPR_PLAY is found.
 					if (((md2->notfound || md2->scale < 0.0f) && ((!cv_glfallbackplayermodel.value) || md2_models[SPR_PLAY].notfound || md2_models[SPR_PLAY].scale < 0.0f)) || spr->mobj->state == &states[S_PLAY_SIGN])
@@ -4593,7 +4584,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 
 	rot = (thing->frame & FF_FRAMEMASK);
 
-	sprskin = K_GetMobjSkin(thing);
+	sprskin = R_GetMobjSkin(thing);
 
 	//Fab : 02-08-98: 'skin' override spritedef currently used for skin
 	if (sprskin && thing->sprite == SPR_PLAY)

src/hardware/hw_md2.c

@@ -73,8 +73,6 @@
 #endif
 
 md2_t md2_models[NUMSPRITES] = {};
-md2_t md2_playermodels[MAXSKINS] = {};
-md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
 
 /*
  * free model
@@ -421,6 +419,7 @@ static void md2_loadTexture(md2_t *model)
 			}
 		}
 	}
+
 	GL_SetTexture(glPatch->mipmap);
 	HWR_UnlockCachedPatch(glPatch);
 }
@@ -478,6 +477,7 @@ static void md2_loadBlendTexture(md2_t *model)
 		glPatch->mipmap->width = (UINT16)w;
 		glPatch->mipmap->height = (UINT16)h;
 	}
+
 	GL_SetTexture(glPatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
 	HWR_UnlockCachedPatch(glPatch);
 
@@ -487,6 +487,19 @@ static void md2_loadBlendTexture(md2_t *model)
 // Don't spam the console, or the OS with fopen requests!
 static boolean nomd2s = false;
 
+// initializes an md2 model
+static void HWR_InitModel(md2_t *md2)
+{
+	md2->scale = -1.0f;
+	md2->model = NULL;
+	md2->glpatch = NULL;
+	md2->skinnum = -1;
+	md2->notexturefile = false;
+	md2->noblendfile = false;
+	md2->notfound = true;
+	md2->error = false;
+}
+
 void HWR_InitMD2(void)
 {
 	size_t i;
@@ -496,38 +509,22 @@ void HWR_InitMD2(void)
 	float scale, offset;
 
 	CONS_Printf("InitMD2()...\n");
-	for (s = 0; s < MAXSKINS; s++)
+
+	for (s = 0; s < numskins; s++)
 	{
-		md2_playermodels[s].scale = -1.0f;
-		md2_playermodels[s].model = NULL;
-		md2_playermodels[s].glpatch = NULL;
-		md2_playermodels[s].skin = -1;
-		md2_playermodels[s].notexturefile = false;
-		md2_playermodels[s].noblendfile = false;
-		md2_playermodels[s].notfound = true;
-		md2_playermodels[s].error = false;
+		skin_t *skin = skins[s];
+		HWR_InitModel(&skin->playermodel);
 	}
-	for (s = 0; s < MAXLOCALSKINS; s++)
+
+	for (s = 0; s < numlocalskins; s++)
 	{
-		md2_localplayermodels[s].scale = -1.0f;
-		md2_localplayermodels[s].model = NULL;
-		md2_localplayermodels[s].glpatch = NULL;
-		md2_localplayermodels[s].skin = -1;
-		md2_localplayermodels[s].notexturefile = false;
-		md2_localplayermodels[s].noblendfile = false;
-		md2_localplayermodels[s].notfound = true;
-		md2_localplayermodels[s].error = false;
+		skin_t *skin = localskins[s];
+		HWR_InitModel(&skin->playermodel);
 	}
+
 	for (i = 0; i < NUMSPRITES; i++)
 	{
-		md2_models[i].scale = -1.0f;
-		md2_models[i].model = NULL;
-		md2_models[i].glpatch = NULL;
-		md2_models[i].skin = -1;
-		md2_models[s].notexturefile = false;
-		md2_models[s].noblendfile = false;
-		md2_models[i].notfound = true;
-		md2_models[i].error = false;
+		HWR_InitModel(&md2_models[i]);
 	}
 
 	// read the mdls.dat file
@@ -544,6 +541,7 @@ void HWR_InitMD2(void)
 			return;
 		}
 	}
+
 	while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
 	{
 		for (i = 0; i < NUMSPRITES; i++)
@@ -558,18 +556,21 @@ void HWR_InitMD2(void)
 			}
 		}
 
-		for (s = 0; s < MAXSKINS; s++)
+		for (s = 0; s < numskins; s++)
 		{
-			if (fasticmp(name, skins[s].name))
+			skin_t *skin = skins[s];
+
+			if (fasticmp(name, skin->name))
 			{
-				md2_playermodels[s].skin = s;
-				md2_playermodels[s].scale = scale;
-				md2_playermodels[s].offset = offset;
-				md2_playermodels[s].notfound = false;
-				strcpy(md2_playermodels[s].filename, filename);
+				skin->playermodel.skinnum = s;
+				skin->playermodel.scale = scale;
+				skin->playermodel.offset = offset;
+				skin->playermodel.notfound = false;
+				strcpy(skin->playermodel.filename, filename);
 				goto md2found;
 			}
 		}
+
 		// no sprite/player skin name found?!?D
 		CONS_Printf("Unknown sprite/player skin %s detected in mdls.dat\n", name);
 md2found:
@@ -579,12 +580,16 @@ md2found:
 	fclose(f);
 }
 
-void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup
+void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added after startup
 {
 	FILE *f;
 	char name[20], filename[32];
 	float scale, offset;
-	md2_t *md2s;
+
+	skin_t *skin = R_GetSkinArray(local)[skinnum];
+
+	// ensure we ALWAYS initialize the model even if no mdls.dat was found!
+	HWR_InitModel(&skin->playermodel);
 
 	if (nomd2s)
 		return;
@@ -598,6 +603,7 @@ void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added af
 	if (!f)
 	{
 		f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
+
 		if (!f)
 		{
 			CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
@@ -606,25 +612,25 @@ void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added af
 		}
 	}
 
-	md2s = (local ? md2_localplayermodels : md2_playermodels);
-
 	// Check for any MD2s that match the names of player skins!
 	while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
 	{
-		if (fasticmp(name, K_GetSkinArray(local)[skin].name))
+		if (fasticmp(name, skin->name))
 		{
-			md2s[skin].skin = skin;
-			md2s[skin].scale = scale;
-			md2s[skin].offset = offset;
-			md2s[skin].notfound = false;
-			strcpy(md2s[skin].filename, filename);
+			skin->playermodel.skinnum = skinnum;
+			skin->playermodel.scale = scale;
+			skin->playermodel.offset = offset;
+			skin->playermodel.notfound = false;
+			strcpy(skin->playermodel.filename, filename);
 			goto playermd2found;
 		}
 	}
 
-	//CONS_Printf("MD2 for player skin %s not found\n", skins[skin].name);
-	md2s[skin].notfound = true;
+	//CONS_Printf("MD2 for player skin %s not found\n", skins[skinnum].name);
+	skin->playermodel.notfound = true;
+
 playermd2found:
+
 	fclose(f);
 }
 
@@ -674,6 +680,7 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
 
 	//CONS_Printf("MD2 for sprite %s not found\n", sprnames[spritenum]);
 	md2_models[spritenum].notfound = true;
+
 spritemd2found:
 	fclose(f);
 }
@@ -1146,8 +1153,6 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 
 	// Look at HWR_ProjectSprite for more
 	{
-		md2_t *md2s;
-		int skinnum;
 		patch_t *gpatch, *blendgpatch;
 		GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
 		INT32 durs = spr->mobj->state->tics;
@@ -1207,36 +1212,29 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 		// dont forget to enabled the depth test because we can't do this like
 		// before: polygons models are not sorted
 
-		/* fuck you */
-		if (spr->mobj->localskin)
-		{
-			if (spr->mobj->skinlocal)
-			{
-				md2s = md2_localplayermodels;
-				skinnum = (skin_t *)spr->mobj->localskin - localskins;
-			}
-			else
-			{
-				md2s = md2_playermodels;
-				skinnum = (skin_t *)spr->mobj->localskin - skins;
-			}
-		}
-		else
-		{
-			md2s = md2_playermodels;
-			skinnum = (skin_t *)spr->mobj->skin - skins;
-		}
-
 		// 1. load model+texture if not already loaded
 		// 2. draw model with correct position, rotation,...
-		if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY && !md2s[skinnum].notfound) // Use the player MD2 list if the mobj has a skin and is using the player sprites
+
+		// Use the player MD2 list if the mobj has a skin and is using the player sprites
+		if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
 		{
-			md2 = &md2s[skinnum];
-			md2->skin = skinnum;
-			sprinfo = &spriteinfo[spr->mobj->sprite];
+			/* fuck you */
+			md2_t *md2s = &R_GetMobjSkin(spr->mobj)->playermodel;
+
+			if (!md2s->notfound)
+			{
+				md2 = md2s;
+				md2->skinnum = R_GetMobjSkinNum(spr->mobj);
+				sprinfo = &spriteinfo[spr->mobj->sprite];
+			}
+			else // if we can't find the player md2, use SPR_PLAY's MD2.
+			{
+				md2 = &md2_models[spr->mobj->sprite];
+				sprinfo = &spriteinfo[spr->mobj->sprite];
+			}
 		}
 		else
-		{	// if we can't find the player md2, use SPR_PLAY's MD2.
+		{
 			md2 = &md2_models[spr->mobj->sprite];
 			sprinfo = &spriteinfo[spr->mobj->sprite];
 		}
@@ -1299,6 +1297,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 				&& gpatch->width == blendgpatch->width && gpatch->height == blendgpatch->height)
 			{
 				INT32 tcskinnum = TC_DEFAULT;
+
 				if ((spr->mobj->flags & MF_BOSS) && (spr->mobj->flags2 & MF2_FRET) && (leveltime & 1)) // Bosses "flash"
 				{
 					if (spr->mobj->type == MT_CYBRAKDEMON)
@@ -1313,13 +1312,16 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 					if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
 					{
 						if (spr->mobj->colorized)
+						{
 							tcskinnum = TC_RAINBOW;
+						}
 						else
 						{
-							tcskinnum = (INT32)(K_GetMobjSkinNum(K_GetMobjSkin(spr->mobj), spr->mobj->skinlocal));
+							tcskinnum = (INT32)R_GetMobjSkinNum(spr->mobj);
 						}
 					}
-					else tcskinnum = TC_DEFAULT;
+					else
+						tcskinnum = TC_DEFAULT;
 				}
 
 				HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, spr->colormap, (skincolors_t)spr->mobj->color);
@@ -1383,7 +1385,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 			p.z = FIXED_TO_FLOAT(interp.z);
 
 		if ((spr->mobj->skin || spr->mobj->localskin) && spr->mobj->sprite == SPR_PLAY)
-			sprdef = &K_GetMobjSkin(spr->mobj)->spritedef;
+			sprdef = &R_GetMobjSkin(spr->mobj)->spritedef;
 		else
 			sprdef = &sprites[spr->mobj->sprite];
 

src/hardware/hw_md2.h

@@ -33,13 +33,11 @@ typedef struct
 	void        *blendglpatch;
 	boolean     noblendfile; // true if blend texture file was not found
 	boolean     notfound;
-	INT32       skin;
+	INT32       skinnum;
 	boolean     error;
 } md2_t;
 
 extern md2_t md2_models[NUMSPRITES];
-extern md2_t md2_playermodels[MAXSKINS];
-extern md2_t md2_localplayermodels[MAXLOCALSKINS];
 
 void HWR_InitMD2(void);
 void HWR_DrawMD2(gl_vissprite_t *spr);

src/hardware/r_opengl/r_opengl.c

@@ -1931,6 +1931,7 @@ static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD, UINT32
 				{
 					if (samplePoint[p].s.alpha == 0)
 						continue;
+
 					sumR += samplePoint[p].s.red;
 					sumG += samplePoint[p].s.green;
 					sumB += samplePoint[p].s.blue;
@@ -3282,7 +3283,7 @@ static void GL_Framebuffer_Generate(void)
 	{
 		pglGenTextures(1, &framebufferobject.tex);
 		pglBindTexture(GL_TEXTURE_2D, framebufferobject.tex);
-		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screen_width, screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, screen_width, screen_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		Clamp2D(GL_TEXTURE_WRAP_S);

src/hu_stuff.c

@@ -472,9 +472,7 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 		strlcat(msg, COM_Argv(ix + usedargs), msgspace);
 	}
 
-	const size_t msglength = strlen(msg);
-
-	if (msglength > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
+	if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
 	{
 		// what we're gonna do now is check if the node exists
 		// with that logic, characters 4 and 5 are our numbers:
@@ -528,7 +526,7 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 		strlcpy(msg, newmsg, HU_MAXMSGLEN + 1);
 	}
 
-	SendNetXCmd(XD_SAY, buf, msglength + 1 + msg-buf);
+	SendNetXCmd(XD_SAY, buf, strlen(msg) + 1 + msg-buf);
 }
 
 /** Send a message to everyone.
@@ -779,12 +777,11 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 		return;
 	}
 
-	const size_t msglength = strlen(msg);
-
 	//check for invalid characters (0x80 or above)
 	{
 		size_t i;
-		const size_t j = msglength;
+		const size_t j = strlen(msg);
+
 		for (i = 0; i < j; i++)
 		{
 			if (msg[i] & 0x80)
@@ -831,7 +828,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 	}
 
 	// Handle "/me" actions, but only in messages to everyone.
-	if (target == 0 && msglength > 4 && strnicmp(msg, "/me ", 4) == 0)
+	if (target == 0 && strlen(msg) > 4 && strnicmp(msg, "/me ", 4) == 0)
 	{
 		msg += 4;
 		action = true;
@@ -2657,9 +2654,12 @@ static inline void HU_DrawSpectatorTicker(void)
 
 				if (player->mo && player->mo->color)
 				{
-					const UINT8 *colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE);
+					const UINT8 *colormap = NULL;
+
 					if (player->mo->colorized)
 						colormap = R_GetTranslationColormap(TC_RAINBOW, player->mo->color, GTC_CACHE);
+					else
+						colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE);
 
 					if (K_UseHighResPortraits())
 						V_DrawSmallMappedPatch((templength - duptweak), height+10, V_TRANSLUCENT, R_GetSkinFaceWant(player), colormap);

src/k_hud.c

@@ -1221,10 +1221,8 @@ boolean K_UseHighResPortraits(void)
 // accounts for localskins
 patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum)
 {
-	if (!player->skinlocal)
-		return (K_UseHighResPortraits() ? facewantprefix[skinnum] : facerankprefix[skinnum]);
-	else
-		return (K_UseHighResPortraits() ? localfacewantprefix[skinnum] : localfacerankprefix[skinnum]);
+	const skin_t *skin = R_GetSkinArray(player->skinlocal)[skinnum];
+	return (K_UseHighResPortraits() ? skin->facewantprefix : skin->facerankprefix);
 }
 
 INT32 K_calcSplitFlags(INT32 snapflags)
@@ -1426,7 +1424,7 @@ static void K_drawKartStats(void)
 		flags |= V_HUDTRANS;
 		flags2 = flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor);
 
-		fakeskin = K_GetPlayerSkin(stplyr);
+		fakeskin = R_GetPlayerSkin(stplyr);
 
 		// Skin name
 		if (cv_showstats_skinname.value)
@@ -3109,7 +3107,7 @@ static void K_drawNameTags(void)
 		cm = R_GetTranslationColormap(players[i].skin, players[i].mo->color, GTC_CACHE);
 		tagcolor = colortranslations[players[i].mo->color][7];
 		vflags = trans | V_NOSCALESTART;
-		usenametagrestat = ((cv_nametagrestat.value == 1 && (players[i].kartspeed != skins[players[i].skin].kartspeed || players[i].kartweight != skins[players[i].skin].kartweight)) || cv_nametagrestat.value == 2);
+		usenametagrestat = ((cv_nametagrestat.value == 1 && (players[i].kartspeed != skins[players[i].skin]->kartspeed || players[i].kartweight != skins[players[i].skin]->kartweight)) || cv_nametagrestat.value == 2);
 		tagwidthsmall = cv_smallnametags.value ? V_SmallStringWidth(player_names[i], V_ALLOWLOWERCASE) : V_ThinStringWidth(player_names[i], V_ALLOWLOWERCASE);
 		tagwidth = vid.dup*tagwidthsmall;
 
@@ -3594,12 +3592,12 @@ static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
 	INT32 rot = 0;
 #endif
 
-	skin = K_GetMobjSkin(mo);
+	skin = R_GetMobjSkin(mo);
 
 	if (!skin)
 		return;
 
-	minimaphead = (skinlocal ? localfacemmapprefix : facemmapprefix)[K_GetMobjSkinNum(skin, skinlocal)];
+	minimaphead = skin->facemmapprefix;
 
 	if (minimaphead == NULL)
 		return;
@@ -3829,10 +3827,8 @@ static void K_drawKartMinimap(void)
 				}
 				else
 				{
-					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
-
 					// special case if startcolor is not the default (160 / Green)
-					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
+					if (R_GetMobjSkin(mobj)->starttranscolor != skins[0]->starttranscolor)
 					{
 						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
 					}
@@ -4907,7 +4903,7 @@ void K_drawKartHUD(void)
 		for (c = 1; c < MAXSKINCOLORS; c++)
 		{
 			UINT8 *cm = R_GetTranslationColormap(TC_RAINBOW, c, GTC_CACHE);
-			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT>>1, 0, facewantprefix[stplyr->skin], cm);
+			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT>>1, 0, skins[stplyr->skin]->facewantprefix, cm);
 
 			x += 16;
 			if (x > BASEVIDWIDTH-16)

src/k_hud.h

@@ -78,6 +78,8 @@ INT32 K_getMinimapTrans(void);
 void K_getLapsDrawinfo(drawinfo_t *out);
 void K_getMinimapDrawinfo(drawinfo_t *out);
 
+patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/k_kart.c

@@ -71,12 +71,11 @@ consvar_t cv_stairjank = {"stairjank", "Off", CV_SAVE|CV_CALL, CV_OnOff, PDistor
 consvar_t cv_stairjanksfx = {"stairjanksfx", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 //hardcode saltyhop mhhm
-static void saltyhop_onchange(void);
-consvar_t cv_saltyhop = {"hardcodehop", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, saltyhop_onchange, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_saltyhop = {"hardcodehop", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_saltyhopsfx = {"hardcodehopsfx", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_saltysquish = {"hardcodehopsquish", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 static CV_PossibleValue_t saltyheight_t[] = {{FRACUNIT/4, "MIN"}, {2*FRACUNIT, "MAX"}, {0, NULL}};
-consvar_t cv_saltyheight = {"hardcodehopheight", "1", CV_FLOAT|CV_SAVE|CV_CALL|CV_NOINIT, saltyheight_t, saltyhop_onchange, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_saltyheight = {"hardcodehopheight", "1", CV_FLOAT|CV_SAVE, saltyheight_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_saltyroll = {"hardcodehoproll", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_squishdance = {"squishdance", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -84,23 +83,6 @@ consvar_t cv_squishdance = {"squishdance", "On", CV_SAVE, CV_OnOff, NULL, 0, NUL
 static CV_PossibleValue_t squishdancespeed_cons_t[] = {{20, "MIN"}, {280, "MAX"}, {0, NULL}};
 consvar_t cv_squishdancespeed = {"squishdance_speed", "140", CV_SAVE, squishdancespeed_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-static void saltyhop_onchange(void)
-{
-	// reset everything when toggling saltyhop
-	if (gamestate != GS_LEVEL)
-		return;
-
-	for (INT32 i = 0; i < MAXPLAYERS; i++)
-	{
-		player_t *player = &players[i];
-
-		if (!player || P_MobjWasRemoved(player->mo))
-			continue;
-
-		memset(&player->mo->salty, 0, sizeof(player->mo->salty));
-	}
-}
-
 // SOME IMPORTANT VARIABLES DEFINED IN DOOMDEF.H:
 // gamespeed is cc (0 for easy, 1 for normal, 2 for hard)
 // franticitems is Frantic Mode items, bool
@@ -610,7 +592,7 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
 	if (color >= MAXTRANSLATIONS)
 		I_Error("Invalid skin color #%hu.", (UINT16)color);
 
-	starttranscolor = (skinnum != TC_DEFAULT) ? K_GetSkinArray(local)[skinnum].starttranscolor : DEFAULT_STARTTRANSCOLOR;
+	starttranscolor = (skinnum != TC_DEFAULT) ? R_GetSkinArray(local)[skinnum]->starttranscolor : DEFAULT_STARTTRANSCOLOR;
 
 	if (starttranscolor >= NUM_PALETTE_ENTRIES)
 		I_Error("Invalid startcolor #%d.", starttranscolor);
@@ -650,60 +632,6 @@ UINT8 K_GetKartColorByName(const char *name)
 	return 0;
 }
 
-//
-// returns the players skinnumber
-// accounts for localskins
-//
-INT32 K_GetSkinNum(player_t *player)
-{
-	return player->localskin ? (player->localskin - 1) : player->skin;
-}
-
-//
-// returns the mobj skinnumber
-// accounts for localskins ?
-//
-INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
-{
-	return skin - K_GetSkinArray(local);
-}
-
-//
-// returns the mobj skinnumber
-// accounts for localskins
-//
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
-{
-	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
-}
-
-//
-// returns the players skinnumber
-// accounts for localskins
-//
-skin_t *K_GetMobjSkin(const mobj_t *mobj)
-{
-	return mobj->localskin ? mobj->localskin : mobj->skin;
-}
-
-//
-// returns the skin array to use
-// accounts for localskins
-//
-skin_t *K_GetSkinArray(boolean local)
-{
-	return local ? localskins : skins;
-}
-
-//
-// returns the players skin
-// accounts for localskins
-//
-skin_t *K_GetPlayerSkin(player_t *player)
-{
-	return &K_GetSkinArray(player->skinlocal)[K_GetSkinNum(player)];
-}
-
 //}
 
 //{ SRB2kart Net Variables
@@ -1827,25 +1755,56 @@ void K_RespawnChecker(player_t *player)
 				mobj_t *mo;
 				angle_t newangle;
 				fixed_t newx, newy, newz;
-
+#ifdef PHOBOS_BUILD
+				const fixed_t fscale = player->mo->scale;
+#else
+				static const fixed_t fscale = FRACUNIT; // does NOT use scale, since this effect doesn't scale properly
+#endif
 				newangle = FixedAngle(((360/8)*i)*FRACUNIT);
-				newx = player->mo->x + P_ReturnThrustX(player->mo, newangle, 31<<FRACBITS); // does NOT use scale, since this effect doesn't scale properly
-				newy = player->mo->y + P_ReturnThrustY(player->mo, newangle, 31<<FRACBITS);
+				newx = player->mo->x + P_ReturnThrustX(player->mo, newangle, 31 * fscale);
+				newy = player->mo->y + P_ReturnThrustY(player->mo, newangle, 31 * fscale);
 				if (player->mo->eflags & MFE_VERTICALFLIP)
 					newz = player->mo->z + player->mo->height;
 				else
 					newz = player->mo->z;
 
 				mo = P_SpawnMobj(newx, newy, newz, MT_DEZLASER);
-				if (mo)
+				if (!P_MobjWasRemovedCompat(mo))
 				{
 					if (player->mo->eflags & MFE_VERTICALFLIP)
 						mo->eflags |= MFE_VERTICALFLIP;
 					P_SetTarget(&mo->target, player->mo);
 					mo->angle = newangle+ANGLE_90;
-					mo->momz = (8<<FRACBITS) * P_MobjFlip(player->mo);
-					P_SetScale(mo, (mo->destscale = FRACUNIT));
+					mo->momz = (8 * fscale) * P_MobjFlip(player->mo);
+					P_SetScale(mo, (mo->destscale = fscale));
 				}
+#ifndef PHOBOS_BUILD
+				// vanilla compat really is annoying.......
+				// but this stuff is messed up on mobjscaled maps
+				// and we gotta respawn it locally to avoid desynchs...
+				if (mapobjectscale != FRACUNIT)
+				{
+					// hide the normal lazers!
+					mo->flags2 |= MF2_DONTDRAW;
+
+					newx = player->mo->x + P_ReturnThrustX(player->mo, newangle, 31 * player->mo->scale);
+					newy = player->mo->y + P_ReturnThrustY(player->mo, newangle, 31 * player->mo->scale);
+
+					// now spawn our local lazers
+					mo = P_SpawnMobj(newx, newy, newz, MT_DEZLASER);
+					if (!P_MobjWasRemovedCompat(mo))
+					{
+						if (player->mo->eflags & MFE_VERTICALFLIP)
+							mo->eflags |= MFE_VERTICALFLIP;
+						P_SetTarget(&mo->target, player->mo);
+						mo->angle = newangle+ANGLE_90;
+						mo->momz = (8 * player->mo->scale) * P_MobjFlip(player->mo);
+						P_SetScale(mo, (mo->destscale = player->mo->scale));
+
+						mo->islocal = true; // Keep this local!
+					}
+				}
+#endif
 			}
 		}
 	}
@@ -1976,7 +1935,7 @@ static void K_PlayGenericCombatSound(mobj_t *source, mobj_t *other, sfxenum_t sf
 	// I HATE LOCALSKINS! I HATE LOCALSKINS! :AAAAAAAAAA:
 	if (source->player)
 	{
-		skin = K_GetPlayerSkin(source->player);
+		skin = R_GetPlayerSkin(source->player);
 	}
 
 	if (!skin)
@@ -2194,7 +2153,7 @@ static void K_GetKartBoostPower(player_t *player)
 
 		// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
 		// is to hide them if you are in saltyhop jump
-		if (dust && player->mo->salty.jump)
+		if (dust && player->salty.jump)
 			dust->flags2 |= MF2_DONTDRAW;
 
 		if (leveltime % 6 == 0)
@@ -3223,10 +3182,8 @@ static void K_SpawnDriftSparks(player_t *player)
 
 	for (i = 0; i < 2; i++)
 	{
-		fixed_t driftExtraScale = 0;
-
-		angle_t thrustangle = (travelangle + ((i&1) ? -1 : 1)*ANGLE_135);
-		fixed_t smolscale = FixedMul(32*FRACUNIT, player->mo->scale);
+		const angle_t thrustangle = (travelangle + ((i&1) ? -1 : 1)*ANGLE_135);
+		const fixed_t smolscale = FixedMul(32*FRACUNIT, player->mo->scale);
 
 		newx = player->mo->x + P_ReturnThrustX(player->mo, thrustangle, smolscale);
 		newy = player->mo->y + P_ReturnThrustY(player->mo, thrustangle, smolscale);
@@ -3238,9 +3195,9 @@ static void K_SpawnDriftSparks(player_t *player)
 		spark->angle = travelangle-(ANGLE_45/5)*player->kartstuff[k_drift];
 
 		// scale increase while driftspark level gained timer is running
-		driftExtraScale = FixedDiv(player->driftsparkGrowTimer, DRIFTSPARKGROWTICS);
+		const fixed_t driftExtraScale = FixedDiv(player->driftsparkGrowTimer, DRIFTSPARKGROWTICS);
 		spark->destscale = FixedMul(player->mo->scale, FRACUNIT + FixedMul(driftExtraScale, cv_driftsparkpulse.value));
-		P_SetScale(spark, spark->destscale); // why not use what we calculated above?
+		P_SetScale(spark, spark->destscale);
 
 		spark->momx = player->mo->momx/2;
 		spark->momy = player->mo->momy/2;
@@ -3335,7 +3292,7 @@ static void K_StretchPlayerGravity(player_t *player)
 	fixed_t tempxscale = pmo->realxscale;
 	fixed_t tempyscale = pmo->realyscale;
 
-	stretchScaleFactor = FixedDiv(FRACUNIT*60, cv_gravstretch.value);
+	stretchScaleFactor = FixedDiv(mapobjectscale*60, cv_gravstretch.value);
 	stretchScaleFactor = min(stretchScaleFactor, MAXSTRETCHDIV);
 
 	if (pmo->slamsoundtimer)
@@ -3343,26 +3300,26 @@ static void K_StretchPlayerGravity(player_t *player)
 
 	if (!P_IsObjectOnGround(pmo))
 	{
-		fixed_t pzmom = abs(pmo->momz);
+		const fixed_t pzmom = abs(pmo->momz);
 		const fixed_t stretchDiv = FixedDiv(pzmom, stretchScaleFactor);
 
-		if (abs(pzmom/FRACUNIT) != 0)
+		if (abs(pzmom/mapobjectscale) != 0)
 		{
-			if (((tempxscale-(stretchDiv))) > (tempxscale/5))
+			if ((tempxscale - stretchDiv) > (tempxscale / 5))
 			{
 				pmo->spritexscale = (tempxscale - stretchDiv);
 				pmo->stretchslam = pzmom;
 			}
 			else
-				pmo->spritexscale = (tempxscale/5);
+				pmo->spritexscale = (tempxscale / 5);
 
-			pmo->spriteyscale = (tempyscale + ((stretchDiv*2)/3));
+			pmo->spriteyscale = (tempyscale + ((stretchDiv * 2) / 3));
 		}
 	}
 	else if (pmo->stretchslam > 0)
 	{
 		// Funni slam sound when landing
-		if (cv_slamsound.value && (pmo->eflags & MFE_JUSTHITFLOOR) && !pmo->slamsoundtimer && (pmo->stretchslam > 4*FRACUNIT))
+		if (cv_slamsound.value && (pmo->eflags & MFE_JUSTHITFLOOR) && !pmo->slamsoundtimer && (pmo->stretchslam > 4*mapobjectscale))
 		{
 			S_StartSound(pmo, sfx_s3k4c);
 			pmo->slamsoundtimer = TICRATE;
@@ -3370,9 +3327,9 @@ static void K_StretchPlayerGravity(player_t *player)
 
 		const fixed_t slamDiv = FixedDiv(pmo->stretchslam, stretchScaleFactor);
 
-		pmo->spritexscale = (tempxscale + (((slamDiv*2)/3)*2));
+		pmo->spritexscale = (tempxscale + (((slamDiv * 2) / 3 ) * 2));
 		pmo->spriteyscale = (tempyscale - slamDiv);
-		pmo->stretchslam -= (4*FRACUNIT);
+		pmo->stretchslam -= (4*mapobjectscale);
 	}
 	else
 		pmo->stretchslam = 0;
@@ -3392,11 +3349,11 @@ static void K_SaltySquish(player_t *player)
 
 	if (pmo->stretchslam > 0)
 	{
-		const fixed_t slamDiv = FixedDiv(pmo->stretchslam, FRACUNIT*60); // stretchScaleFactor = FixedDiv(FRACUNIT*60, FRACUNIT)
+		const fixed_t slamDiv = FixedDiv(pmo->stretchslam, mapobjectscale*60); // stretchScaleFactor = FixedDiv(mapobjectscale*60, FRACUNIT)
 
-		pmo->spritexscale = (tempxscale + (((slamDiv*2)/3)*2));
+		pmo->spritexscale = (tempxscale + (((slamDiv * 2) / 3) * 2));
 		pmo->spriteyscale = (tempyscale - slamDiv);
-		pmo->stretchslam -= (4*FRACUNIT);
+		pmo->stretchslam -= (4*mapobjectscale);
 	}
 	else
 		pmo->stretchslam = 0;
@@ -3404,88 +3361,92 @@ static void K_SaltySquish(player_t *player)
 
 static void K_QuiteSaltyHop(player_t *player)
 {
-	if (!cv_saltyhop.value)
-		return;
+	I_Assert(player != NULL);
+	I_Assert(!P_MobjWasRemoved(player->mo));
 
 	// what the fuck is this haya
 	mobj_t *pmo = player->mo;
-	salty_t *psalt = &pmo->salty;
+	salty_t *psalty = &player->salty;
+
+	if (!cv_saltyhop.value)
+	{
+		// reset before we leave
+		psalty->jump = psalty->ready = psalty->tapping = false;
+		psalty->momz = psalty->zoffset = 0;
+		return;
+	}
+
 	const boolean onground = P_IsObjectOnGround(pmo);
 
 	// ready?
 	if (!player->kartstuff[k_jmp])
 	{
-		psalt->ready = true;
-		psalt->tapping = false;
+		psalty->ready = true;
+		psalty->tapping = false;
 	}
-	else if (psalt->ready)
+	else if (psalty->ready)
 	{
-		psalt->ready = false;
-		psalt->tapping = true;
+		psalty->ready = false;
+		psalty->tapping = true;
 	}
 	else
 	{
-		psalt->tapping = false;
+		psalty->tapping = false;
 	}
 
 	// GO!
-	if (!psalt->init)
-	{
-		psalt->jump = false;
-		psalt->zoffset = 0;
-		psalt->momz = 0;
-		psalt->init = true;
-	}
-	else if (psalt->jump)
+	if (psalty->jump)
 	{
 		if (pmo->eflags & MFE_JUSTHITFLOOR)
 		{
-			psalt->zoffset = 0;
+			psalty->zoffset = 0;
 		}
 		else if (onground)
 		{
-			psalt->zoffset += psalt->momz;
-			psalt->momz -= (FRACUNIT*3/2);
+			psalty->zoffset += psalty->momz;
+			psalty->momz -= (FRACUNIT*3/2);
 		}
 		else
 		{
-			psalt->zoffset *= (49/50)*FRACUNIT;
-			psalt->momz = 0;
+			//psalty->zoffset *= (49/50)*FRACUNIT; // this just rounds down to 0 lol
+			psalty->zoffset = 0;
+			psalty->momz = 0;
 		}
 
-		if (psalt->zoffset <= 0)
+		if (psalty->zoffset <= 0)
 		{
 			if (cv_saltyhopsfx.value && !(pmo->eflags & MFE_JUSTHITFLOOR) && onground)
 				S_StartSound(pmo, sfx_s268);
-			psalt->jump = false;
-			psalt->zoffset = 0;
-			psalt->momz = 0;
+			psalty->jump = false;
+			psalty->zoffset = 0;
+			psalty->momz = 0;
 			// shlamma damma
 			if (cv_saltysquish.value)
-				pmo->stretchslam += 8*FRACUNIT;
+				pmo->stretchslam += 8*mapobjectscale;
 		}
-		else if (cv_saltysquish.value && psalt->zoffset >= 0)
+		else if (psalty->zoffset > 0)
 		{
-			// goofy ahh hack
-			pmo->spriteyscale += (FRACUNIT/8);
-			pmo->spritexscale -= (FRACUNIT/8);
+			if (cv_saltysquish.value)
+			{
+				// goofy ahh hack
+				pmo->spriteyscale += (FRACUNIT/8);
+				pmo->spritexscale -= (FRACUNIT/8);
+			}
 		}
 
-		pmo->spriteyoffset += FixedMul(psalt->zoffset, cv_saltyheight.value);
+		pmo->spriteyoffset += FixedMul(psalty->zoffset, cv_saltyheight.value);
 
-		if (cv_saltyhopsfx.value)
-		{
-			if (S_SoundPlaying(pmo, sfx_screec))
-				S_StopSoundByID(pmo, sfx_screec);
-			if (S_SoundPlaying(pmo, sfx_drift))
-				S_StopSoundByID(pmo, sfx_drift);
-		}
+		// Stop any and all drift sounds when hopping.
+		if (S_SoundPlaying(pmo, sfx_screec))
+			S_StopSoundByID(pmo, sfx_screec);
+		if (S_SoundPlaying(pmo, sfx_drift))
+			S_StopSoundByID(pmo, sfx_drift);
 	}
-	else if (psalt->tapping && onground && !player->kartstuff[k_spinouttimer] && !player->kartstuff[k_squishedtimer])
+	else if (psalty->tapping && onground && !player->kartstuff[k_spinouttimer] && !player->kartstuff[k_squishedtimer])
 	{
-		psalt->jump = true;
-		psalt->zoffset = 0;
-		psalt->momz = 6*FRACUNIT;
+		psalty->jump = true;
+		psalty->zoffset = 0;
+		psalty->momz = 6*FRACUNIT;
 		if (cv_saltyhopsfx.value)
 			S_StartSound(pmo, sfx_s25a);
 	}
@@ -3512,7 +3473,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj)
 		return false;
 
 	// seeing a character rotate mid-hop looks really janky
-	if (!cv_saltyroll.value && mobj->player && mobj->player->mo->salty.jump)
+	if (!cv_saltyroll.value && mobj->player && mobj->player->salty.jump)
 		return false;
 
 	return K_CheckSlopeRollDist(mobj);
@@ -3724,7 +3685,7 @@ mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 	dust = P_SpawnMobj(rand_x, rand_y, mo->z, MT_WIPEOUTTRAIL);
 
 	P_SetTarget(&dust->target, mo);
-	dust->angle = R_PointToAngle2(0,0,mo->momx,mo->momy);
+	dust->angle = R_PointToAngle2(0, 0, mo->momx, mo->momy);
 	dust->destscale = mo->scale;
 	P_SetScale(dust, mo->scale);
 	K_FlipFromObject(dust, mo);
@@ -3750,6 +3711,11 @@ mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 void K_DriftDustHandling(mobj_t *spawner)
 {
 	angle_t anglediff;
+#ifdef PHOBOS_BUILD
+	const fixed_t fscale = spawner->scale;
+#else
+	static const fixed_t fscale = FRACUNIT; // should be spawner->scale but the below calls P_Random!
+#endif
 
 	if (leveltime % 2 != 0 || !P_IsObjectOnGround(spawner))
 		return;
@@ -3766,7 +3732,7 @@ void K_DriftDustHandling(mobj_t *spawner)
 		{
 			angle_t playerangle = spawner->angle;
 
-			if (spawner->player->speed < 5<<FRACBITS)
+			if (spawner->player->speed < (5 * fscale))
 				return;
 
 			if (spawner->player->cmd.forwardmove < 0)
@@ -3777,7 +3743,7 @@ void K_DriftDustHandling(mobj_t *spawner)
 	}
 	else
 	{
-		if (P_AproxDistance(spawner->momx, spawner->momy) < 5<<FRACBITS)
+		if (P_AproxDistance(spawner->momx, spawner->momy) < (5 * fscale))
 			return;
 
 		anglediff = abs((signed)(spawner->angle - R_PointToAngle2(0, 0, spawner->momx, spawner->momy)));
@@ -3790,13 +3756,29 @@ void K_DriftDustHandling(mobj_t *spawner)
 
 	if (anglediff > ANG10*4) // Trying to turn further than 40 degrees
 	{
+		mobj_t *dust = NULL;
+
 		fixed_t spawnx = P_RandomRange(-spawnrange, spawnrange)<<FRACBITS;
 		fixed_t spawny = P_RandomRange(-spawnrange, spawnrange)<<FRACBITS;
 		INT32 speedrange = 2;
-		mobj_t *dust = P_SpawnMobj(spawner->x + spawnx, spawner->y + spawny, spawner->z, MT_DRIFTDUST);
-		dust->momx = FixedMul(spawner->momx + (P_RandomRange(-speedrange, speedrange)<<FRACBITS), 3*(spawner->scale)/4);
-		dust->momy = FixedMul(spawner->momy + (P_RandomRange(-speedrange, speedrange)<<FRACBITS), 3*(spawner->scale)/4);
-		dust->momz = P_MobjFlip(spawner) * (P_RandomRange(1, 4) * (spawner->scale));
+
+		dust = P_SpawnMobj(spawner->x + spawnx, spawner->y + spawny, spawner->z, MT_DRIFTDUST);
+
+		const INT32 momxrand = P_RandomRange(-speedrange, speedrange);
+		const INT32 momyrand = P_RandomRange(-speedrange, speedrange);
+		const INT32 momzrand = P_RandomRange(1, 4);
+
+		if (P_MobjWasRemovedCompat(dust))
+			return;
+
+#ifdef PHOBOS_BUILD
+		dust->momx = FixedMul(spawner->momx + (momxrand * spawner->scale), 3*FRACUNIT/4);
+		dust->momy = FixedMul(spawner->momy + (momyrand * spawner->scale), 3*FRACUNIT/4);
+#else
+		dust->momx = FixedMul(spawner->momx + (momxrand<<FRACBITS), 3*(spawner->scale)/4);
+		dust->momy = FixedMul(spawner->momy + (momyrand<<FRACBITS), 3*(spawner->scale)/4);
+#endif
+		dust->momz = P_MobjFlip(spawner) * (momzrand * (spawner->scale));
 		P_SetScale(dust, spawner->scale/2);
 		dust->destscale = spawner->scale * 3;
 		dust->scalespeed = spawner->scale/12;
@@ -3805,6 +3787,33 @@ void K_DriftDustHandling(mobj_t *spawner)
 			S_StartSound(spawner, sfx_screec);
 
 		K_MatchGenericExtraFlags(dust, spawner);
+
+#ifndef PHOBOS_BUILD
+		// vanilla compat really is annoying.......
+		// but this stuff is messed up on mobjscaled maps
+		// and we gotta respawn it locally to avoid desynchs...
+		if (mapobjectscale != FRACUNIT)
+		{
+			// hide the normal dust!
+			dust->flags2 |= MF2_DONTDRAW;
+
+			// now spawn our dust locally
+			dust = P_SpawnMobj(spawner->x + spawnx, spawner->y + spawny, spawner->z, MT_DRIFTDUST);
+
+			if (P_MobjWasRemovedCompat(dust))
+				return;
+
+			dust->momx = FixedMul(spawner->momx + (momxrand * spawner->scale), 3*FRACUNIT/4);
+			dust->momy = FixedMul(spawner->momy + (momyrand * spawner->scale), 3*FRACUNIT/4);
+			dust->momz = P_MobjFlip(spawner) * (momzrand * (spawner->scale));
+			P_SetScale(dust, spawner->scale/2);
+			dust->destscale = spawner->scale * 3;
+			dust->scalespeed = spawner->scale/12;
+			dust->islocal = true; // Keep this local!
+
+			K_MatchGenericExtraFlags(dust, spawner);
+		}
+#endif
 	}
 }
 
@@ -4337,7 +4346,6 @@ static void K_DoShrink(player_t *user)
 	}
 }
 
-
 void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound)
 {
 	if (mo->player && mo->player->spectator)
@@ -4400,8 +4408,7 @@ void K_KillBananaChain(mobj_t *banana, mobj_t *inflictor, mobj_t *source)
 	mobj_t *cachenext;
 
 killnext:
-
-	if (!banana)
+	if (P_MobjWasRemovedCompat(banana))
 		return;
 
 	cachenext = banana->hnext;
@@ -4440,10 +4447,21 @@ void K_UpdateHnextList(player_t *player, boolean clean)
 		nextwork = work->hnext;
 
 		if (!clean && (!work->movedir || work->movedir <= (UINT16)player->kartstuff[k_itemamount]))
+		{
 			continue;
+		}
 
 		P_RemoveMobj(work);
 	}
+
+#ifdef PHOBOS_BUILD
+	if (P_MobjWasRemoved(player->mo->hnext))
+	{
+		// Like below, try to clean up the pointer if it's NULL.
+		// Maybe this was a cause of the shrink/eggbox fails?
+		P_SetTarget(&player->mo->hnext, NULL);
+	}
+#endif
 }
 
 // For getting hit!
@@ -4508,7 +4526,9 @@ void K_DropHnextList(player_t *player)
 		}
 
 		dropwork = P_SpawnMobj(work->x, work->y, work->z, type);
+
 		P_SetTarget(&dropwork->target, player->mo);
+
 		dropwork->angle = work->angle;
 		dropwork->flags2 = work->flags2;
 		dropwork->flags |= MF_NOCLIPTHING;
@@ -4576,10 +4596,13 @@ void K_DropHnextList(player_t *player)
 
 	// we need this here too because this is done in afterthink - pointers are cleaned up at the START of each tic...
 	P_SetTarget(&player->mo->hnext, NULL);
+
 	player->kartstuff[k_bananadrag] = 0;
 
 	if (player->kartstuff[k_eggmanheld])
+	{
 		player->kartstuff[k_eggmanheld] = 0;
+	}
 	else if (player->kartstuff[k_itemheld]
 		&& (dropall || (--player->kartstuff[k_itemamount] <= 0)))
 	{
@@ -4880,7 +4903,9 @@ static void K_MoveHeldObjects(player_t *player)
 		player->kartstuff[k_bananadrag] = 0;
 
 		if (player->kartstuff[k_eggmanheld])
+		{
 			player->kartstuff[k_eggmanheld] = 0;
+		}
 		else if (player->kartstuff[k_itemheld])
 		{
 			player->kartstuff[k_itemamount] = player->kartstuff[k_itemheld] = 0;
@@ -4897,7 +4922,9 @@ static void K_MoveHeldObjects(player_t *player)
 		player->kartstuff[k_bananadrag] = 0;
 
 		if (player->kartstuff[k_eggmanheld])
+		{
 			player->kartstuff[k_eggmanheld] = 0;
+		}
 		else if (player->kartstuff[k_itemheld])
 		{
 			player->kartstuff[k_itemamount] = player->kartstuff[k_itemheld] = 0;
@@ -4913,7 +4940,12 @@ static void K_MoveHeldObjects(player_t *player)
 		case MT_JAWZ_SHIELD:
 			{
 				mobj_t *cur = player->mo->hnext;
-				fixed_t speed = ((8 - min(4, player->kartstuff[k_itemamount])) * cur->info->speed) / 7;
+				fixed_t speed = 0;
+
+				if (cur == NULL)
+					return;
+
+				speed = ((8 - min(4, player->kartstuff[k_itemamount])) * cur->info->speed) / 7;
 
 				player->kartstuff[k_bananadrag] = 0; // Just to make sure
 
@@ -4960,8 +4992,13 @@ static void K_MoveHeldObjects(player_t *player)
 					cur->flags &= ~MF_NOCLIPTHING;
 
 					if (!P_TryMove(cur, player->mo->x + cur->momx, player->mo->y + cur->momy, true))
+					{
 						P_SlideMove(cur, true);
 
+						if (P_MobjWasRemovedCompat(cur))
+							continue;
+					}
+
 					if (P_IsObjectOnGround(player->mo))
 					{
 						if (P_MobjFlip(cur) > 0)

src/lua_baselib.c

@@ -1766,6 +1766,8 @@ static int lib_rSetPlayerSkin(lua_State *L)
 		INT32 i = luaL_checkinteger(L, 2);
 		if (i < 0 || i >= MAXSKINS)
 			return luaL_error(L, "skin number (argument #2) %d out of range (0 - %d)", i, MAXSKINS-1);
+		if (i >= numskins)
+			return 0;
 		SetPlayerSkinByNum(player-players, i);
 	}
 	else // skin name
@@ -2631,7 +2633,7 @@ static int lib_kLossSound(lua_State *L)
 	if (!mobj->player)
 		return luaL_error(L, "K_PlayLossSound: mobj_t isn't a player object.");
 
-	sfx_id = ((skin_t *)mobj->skin)->soundsid[S_sfx[sfx_klose].skinsound];
+	sfx_id = R_GetMobjSkin(mobj)->soundsid[S_sfx[sfx_klose].skinsound];
 	S_StartSound(mobj, sfx_id);
 	return 0;
 }

src/lua_hooklib.c

@@ -962,7 +962,7 @@ static void res_botai(Hook_State *hook)
 
 int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
 {
-	const char *skin = ((skin_t *)tails->skin)->name;
+	const char *skin = tails->skin->name;
 
 	Hook_State hook = {};
 	BotAI_State botai = {};

src/lua_hud.h

@@ -53,4 +53,6 @@ boolean LUA_HudEnabled(enum hud option);
 
 void LUA_SetHudHook(int hook, huddrawlist_h list);
 
+#define LOCALSKINIMMERSION (hud_running && cv_luaimmersion.value)
+
 #endif // __LUA_HUD_H__

src/lua_hudlib.c

@@ -487,7 +487,7 @@ static int libd_getSpritePatch(lua_State *L)
 		{
 			const char *name = luaL_checkstring(L, 1);
 			for (skn = 0; skn < numskins; skn++)
-				if (fastcmp(skins[skn].name, name))
+				if (fastcmp(skins[skn]->name, name))
 					break;
 			if (skn >= numskins)
 				return 0;
@@ -527,9 +527,9 @@ static int libd_getSpritePatch(lua_State *L)
 	}
 	else // player skin
 	{
-		sprdef = &skins[skn].spritedef;
+		sprdef = &skins[skn]->spritedef;
 #ifdef ROTSPRITE
-		sprinfo = &skins[skn].sprinfo;
+		sprinfo = &skins[skn]->sprinfo;
 #endif
 	}
 
@@ -1056,6 +1056,8 @@ static int libd_getColormap(lua_State *L)
 		skinnum = (INT32)luaL_checkinteger(L, 1);
 		if (skinnum < TC_BLINK || skinnum >= MAXSKINS)
 			return luaL_error(L, "skin number %d is out of range (%d - %d)", skinnum, TC_BLINK, MAXSKINS-1);
+		if (skinnum >= numskins)
+			return 0;
 	}
 	else // skin name
 	{

src/lua_mobjlib.c

@@ -392,12 +392,14 @@ int mobj_skin_getter(lua_State *L)
         return 0;
 
     // HUD ONLY!!!!!!!!!!
-    if (hud_running && cv_luaimmersion.value)
+    if LOCALSKINIMMERSION
     {
-        lua_pushstring(L, K_GetMobjSkin(mo)->name);
+        lua_pushstring(L, R_GetMobjSkin(mo)->name);
     }
     else
-        lua_pushstring(L, ((skin_t *)mo->skin)->name);
+    {
+        lua_pushstring(L, mo->skin->name);
+    }
 
     return 1;
 }
@@ -412,9 +414,9 @@ int mobj_skin_setter(lua_State *L)
     strlwr(skin); // all skin names are lowercase
     for (i = 0; i < numskins; i++)
     {
-        if (fastcmp(skins[i].name, skin))
+        if (fastcmp(skins[i]->name, skin))
         {
-            mo->skin = &skins[i];
+            mo->skin = skins[i];
             return 0;
         }
     }
@@ -427,7 +429,7 @@ int mobj_localskin_getter(lua_State *L)
 	mobj_t *mo = GETMO();
 
 	if (mo->localskin)
-		lua_pushstring(L, ((skin_t *)mo->localskin)->name);
+		lua_pushstring(L, mo->localskin->name);
 	else
 		lua_pushnil(L);
 
@@ -454,9 +456,9 @@ int mobj_localskin_setter(lua_State *L)
 			// Try localskins
 			for (i = 0; i < numlocalskins; i++)
 			{
-				if (fasticmp(localskins[i].name, skin))
+				if (fasticmp(localskins[i]->name, skin))
 				{
-					mo->localskin = &localskins[i];
+					mo->localskin = localskins[i];
 					mo->skinlocal = true;
 					return 0;
 				}
@@ -465,9 +467,9 @@ int mobj_localskin_setter(lua_State *L)
 			// Try other skins
 			for (i = 0; i < numskins; i++)
 			{
-				if (fasticmp(skins[i].name, skin))
+				if (fasticmp(skins[i]->name, skin))
 				{
-					mo->localskin = &skins[i];
+					mo->localskin = skins[i];
 					mo->skinlocal = false;
 					return 0;
 				}

src/lua_playerlib.c

@@ -296,7 +296,7 @@ int player_localskin_getter(lua_State *L)
 	player_t *plr = GETPLAYER();
 
 	if (plr->localskin)
-		lua_pushstring(L, K_GetPlayerSkin(plr)->name);
+		lua_pushstring(L, R_GetPlayerSkin(plr)->name);
 	else
 		lua_pushnil(L);
 

src/lua_script.c

@@ -62,14 +62,6 @@ static lua_CFunction liblist[] = {
 	NULL
 };
 
-// Lua asks for memory using this.
-static void *LUA_Alloc(void *ud, void *ptr, size_t osize, size_t nsize)
-{
-	(void)ud;
-	(void)osize;
-	return Z_Realloc(ptr, nsize, PU_LUA, NULL);
-}
-
 // Panic function Lua calls when there's an unprotected error.
 // This function cannot return. Lua would kill the application anyway if it did.
 FUNCNORETURN static int LUA_Panic(lua_State *L)
@@ -197,7 +189,7 @@ void LUA_ClearState(void)
 	CONS_Printf(M_GetText("Pardon me while I initialize the Lua scripting interface...\n"));
 
 	// allocate state
-	L = lua_newstate(LUA_Alloc, NULL);
+	L = luaL_newstate();
 	lua_atpanic(L, LUA_Panic);
 
 	// open base libraries
@@ -373,7 +365,7 @@ void LUA_DumpFile(const char *filename)
 
 static void createMathLibState(void)
 {
-	mL = lua_newstate(LUA_Alloc, NULL);
+	mL = luaL_newstate();
 	lua_atpanic(mL, LUA_Panic);
 
 	// open only enum lib
@@ -1465,3 +1457,16 @@ int Lua_CreateFieldTable(lua_State *L, const char *const lst[])
 
 	return luaL_ref(L, LUA_REGISTRYINDEX);
 }
+
+size_t LUA_MemoryUsage(void)
+{
+	size_t usage = 0;
+
+	if (gL)
+		usage += lua_gc(gL, LUA_GCCOUNT, 0);
+
+	if (mL)
+		usage += lua_gc(mL, LUA_GCCOUNT, 0);
+
+	return usage;
+}

src/lua_script.h

@@ -82,6 +82,9 @@ int Lua_optoption(lua_State *L, int narg, int def, int list_ref);
 int Lua_CreateFieldTable(lua_State *L, const char *const lst[]);
 void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save);
 
+// Returns lua memory usage in kbytes
+size_t LUA_MemoryUsage(void);
+
 // Console wrapper
 void COM_Lua_f(void);
 

src/lua_skinlib.c

@@ -18,6 +18,10 @@
 
 #include "lua_script.h"
 #include "lua_libs.h"
+#include "lua_hud.h" // hud_running errors
+
+#define SKINARR (LOCALSKINIMMERSION ? allskins : skins)
+#define NSKINS (LOCALSKINIMMERSION ? numallskins : numskins)
 
 enum skin {
 	skin_valid = 0,
@@ -150,13 +154,15 @@ static int skin_num(lua_State *L)
 	// skins are always valid, only added, never removed
 	I_Assert(skin != NULL);
 
-	lua_pushinteger(L, skin-skins);
+	lua_pushinteger(L, LOCALSKINIMMERSION ? skin->allskinnum : skin->skinnum);
 	return 1;
 }
 
 static int lib_iterateSkins(lua_State *L)
 {
 	INT32 i;
+	skin_t **skinar = SKINARR;
+	const INT32 nskins = NSKINS;
 
 	if (lua_gettop(L) < 2)
 	{
@@ -169,14 +175,17 @@ static int lib_iterateSkins(lua_State *L)
 	lua_remove(L, 1); // state is unused.
 
 	if (!lua_isnil(L, 1))
-		i = (INT32)(*((skin_t **)luaL_checkudata(L, 1, META_SKIN)) - allskins) + 1;
+	{
+		skin_t *skin = (*((skin_t **)luaL_checkudata(L, 1, META_SKIN)));
+		i = (INT32)(LOCALSKINIMMERSION ? skin->allskinnum : skin->skinnum) + 1;
+	}
 	else
 		i = 0;
 
 	// skins are always valid, only added, never removed
-	if (i < numallskins)
+	if (i < nskins)
 	{
-		LUA_PushUserdata(L, &allskins[i], META_SKIN);
+		LUA_PushUserdata(L, skinar[i], META_SKIN);
 		return 1;
 	}
 
@@ -188,32 +197,40 @@ static int lib_getSkin(lua_State *L)
 	const char *field;
 	INT32 i;
 
+	skin_t **skinar = SKINARR;
+	const INT32 nskins = NSKINS;
+
 	// find skin by number
 	if (lua_type(L, 2) == LUA_TNUMBER)
 	{
+		const INT32 skinmax = LOCALSKINIMMERSION ? numallskins : MAXSKINS;
+
 		i = luaL_checkinteger(L, 2);
-		if (i < 0 || i >= MAXSKINS)
-			return luaL_error(L, "skins[] index %d out of range (0 - %d)", i, MAXSKINS-1);
-		if (i >= numallskins)
+
+		if (i < 0 || i >= skinmax)
+			return luaL_error(L, "skins[] index %d out of range (0 - %d)", i, skinmax-1);
+		if (i >= nskins)
 			return 0;
-		LUA_PushUserdata(L, &allskins[i], META_SKIN);
+
+		LUA_PushUserdata(L, skinar[i], META_SKIN);
+
 		return 1;
 	}
 
 	field = luaL_checkstring(L, 2);
 
 	// special function iterate
-	if (fastcmp(field,"iterate"))
+	if (fastcmp(field, "iterate"))
 	{
 		lua_pushcfunction(L, lib_iterateSkins);
 		return 1;
 	}
 
 	// find skin by name
-	for (i = 0; i < numallskins; i++)
-		if (fastcmp(allskins[i].name, field))
+	for (i = 0; i < nskins; i++)
+		if (fastcmp(skinar[i]->name, field))
 		{
-			LUA_PushUserdata(L, &allskins[i], META_SKIN);
+			LUA_PushUserdata(L, skinar[i], META_SKIN);
 			return 1;
 		}
 
@@ -222,7 +239,7 @@ static int lib_getSkin(lua_State *L)
 
 static int lib_numSkins(lua_State *L)
 {
-	lua_pushinteger(L, numallskins);
+	lua_pushinteger(L, NSKINS);
 	return 1;
 }
 

src/m_menu.c

@@ -809,7 +809,7 @@ static void M_ChangeCvar(INT32 choice)
 		{
 			INT32 skinno = R_SkinAvailable(cv_chooseskin.string);
 			if (skinno != -1)
-				CV_SetValue(cv,skins[skinno].prefcolor);
+				CV_SetValue(cv,skins[skinno]->prefcolor);
 			return;
 		}
 
@@ -2851,11 +2851,11 @@ static void M_PatchSkinNameTable(void)
 
 	memset(skins_cons_t, 0, sizeof (skins_cons_t));
 
-	for (j = 0; j < MAXSKINS; j++)
+	for (j = 0; j < numskins; j++)
 	{
-		if (skins[j].name[0] != '\0')
+		if (skins[j]->name[0] != '\0')
 		{
-			skins_cons_t[j].strvalue = skins[j].name;
+			skins_cons_t[j].strvalue = skins[j]->name;
 			skins_cons_t[j].value = j+1;
 		}
 		else
@@ -4543,9 +4543,9 @@ static void DrawReplayHutReplayInfo(void)
 			}
 
 			// Character face!
-			if (replaydemolist->standings[0].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[0].skin].facewant) != LUMPERROR)
+			if (replaydemolist->standings[0].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[0].skin]->facewant) != LUMPERROR)
 			{
-				patch = facewantprefix[replaydemolist->standings[0].skin];
+				patch = skins[replaydemolist->standings[0].skin]->facewantprefix;
 				colormap = R_GetTranslationColormap(
 					replaydemolist->standings[0].skin,
 					replaydemolist->standings[0].color,
@@ -4766,9 +4766,9 @@ static void M_DrawReplayStartMenu(void)
 			V_DrawString(BASEVIDWIDTH-92, STARTY + i*20 + 9, V_SNAPTOTOP, va("%d", timeorscore));
 
 		// Character face!
-		if (replaydemolist->standings[i].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[i].skin].facerank) != LUMPERROR)
+		if (replaydemolist->standings[i].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[i].skin]->facerank) != LUMPERROR)
 		{
-			patch = facerankprefix[replaydemolist->standings[i].skin];
+			patch = skins[replaydemolist->standings[i].skin]->facerankprefix;
 			colormap = R_GetTranslationColormap(
 				replaydemolist->standings[i].skin,
 				replaydemolist->standings[i].color,
@@ -4957,13 +4957,15 @@ static void M_DrawPlaybackMenu(void)
 
 		if (i >= playback_view1 && i <= playback_view4)
 		{
-			if (modeattacking) continue;
+			if (modeattacking)
+				continue;
 
 			if (splitscreen >= i - playback_view1)
 			{
 				INT32 ply = displayplayers[i - playback_view1];
 
-				icon = facerankprefix[players[ply].skin];
+				icon = skins[players[ply].skin]->facerankprefix;
+
 				if (i != itemOn)
 					inactivemap = R_GetTranslationColormap(players[ply].skin, players[ply].skincolor, GTC_MENUCACHE);
 			}
@@ -6249,17 +6251,17 @@ void M_DrawTimeAttackMenu(void)
 	SHOWMODDEDGAME
 
 	const INT32 skinnum = max(cv_chooseskin.value-1, 0); // dont think its needed but better safe than sorry!
-	const skin_t *skin = &skins[skinnum];
+	const skin_t *skin = skins[skinnum];
 
 	// Character face!
 	if (W_CheckNumForName(skin->facewant) != LUMPERROR)
 	{
-		const INT32 charx = (BASEVIDWIDTH-x - facewantprefix[skinnum]->width);
+		const INT32 charx = (BASEVIDWIDTH-x - skins[skinnum]->facewantprefix->width);
 
 		UINT8 *colormap = NULL;
 
 		colormap = R_GetTranslationColormap(skinnum, cv_playercolor.value, GTC_MENUCACHE);
-		V_DrawMappedPatch(charx, y, 0, facewantprefix[skinnum], colormap);
+		V_DrawMappedPatch(charx, y, 0, skins[skinnum]->facewantprefix, colormap);
 
 		// draw stats
 		// speed
@@ -7667,7 +7669,7 @@ static void M_DrawMPMainMenu(void)
 	{
 		char buf[28];
 		strlcpy(buf, setupm_ip, sizeof(buf));
-		V_DrawString(x+8,y+12, V_ALLOWLOWERCASE, buf);
+		V_DrawString(x+8, y+12, V_ALLOWLOWERCASE, buf);
 	}
 	else
 		M_DrawTextInputScroll(x+8, y+12, &setupm_input_ip, 0, SETUPM_IP_MAXSIZE);
@@ -7707,7 +7709,7 @@ static void M_DrawMPMainMenu(void)
 					break;
 			}
 
-			if (pskin >= MAXSKINS)
+			if (pskin >= numskins)
 				pskin = 0;
 
 			if (!trans && i > cv_splitplayers.value)
@@ -7715,7 +7717,7 @@ static void M_DrawMPMainMenu(void)
 
 			colmap = R_GetTranslationColormap(pskin, pcol, GTC_MENUCACHE);
 
-			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, trans, facewantprefix[pskin], colmap);
+			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, trans, skins[pskin]->facewantprefix, colmap);
 
 			if (itemOn == 2 && i == setupm_pselect)
 			{
@@ -7976,12 +7978,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	else
 		M_DrawTextInput(mx + 40, my + nameboxaddy, &setupm_input, 0);
 
-#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].realname : skins[setupm_fakeskin].realname)
-#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed)
-#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
+#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]]->realname : skins[setupm_fakeskin]->realname)
+#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]]->kartspeed : skins[setupm_fakeskin]->kartspeed)
+#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]]->kartweight : skins[setupm_fakeskin]->kartweight)
 
 	// draw skin string
-	st = V_StringWidth(skins[setupm_fakeskin].realname, 0);
+	st = V_StringWidth(skins[setupm_fakeskin]->realname, 0);
 	switch (cv_skinselectmenu.value)
 	{
 		case SKINMENUTYPE_EXTENDED:
@@ -8003,10 +8005,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 				skintodisplay = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime()/TICRATE)%SELECTEDSTATSCOUNT];
 
 			tw = V_StringWidth("Character", 0);
-			st = V_StringWidth(skins[skintodisplay].realname, 0);
+			st = V_StringWidth(skins[skintodisplay]->realname, 0);
 			V_DrawString((mx+(tw/2)) - (st/2), my + 37,
 				((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
-				skins[skintodisplay].realname);
+				skins[skintodisplay]->realname);
 			// the menu is now 2d, no need for scroll arrows...
 			if (itemOn == 1 && setupm_skinlockedselect)
 			{
@@ -8020,7 +8022,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 		default:
 			V_DrawString(BASEVIDWIDTH - mx - st, my + 16,
 						((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0)|highlightflags|V_ALLOWLOWERCASE,
-						skins[setupm_fakeskin].realname);
+						skins[setupm_fakeskin]->realname);
 			if (itemOn == 1)
 			{
 				V_DrawCharacter(BASEVIDWIDTH - mx - 10 - st - (skullAnimCounter/5), my + 16,
@@ -8126,10 +8128,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 			for (i = 0; i < numskins; i++) // draw the stat dots
 			{
-				if (i != setupm_fakeskin && R_SkinAvailable(skins[i].name) != -1)
+				if (i != setupm_fakeskin && R_SkinAvailable(skins[i]->name) != -1)
 				{
-					speed = skins[i].kartspeed;
-					weight = skins[i].kartweight;
+					speed = skins[i]->kartspeed;
+					weight = skins[i]->kartweight;
 					V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL);
 				}
 			}
@@ -8185,10 +8187,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 			for (i = 0; i < numskins; i++) // draw the stat dots
 			{
-				if (i != setupm_fakeskin && R_SkinAvailable(skins[i].name) != -1)
+				if (i != setupm_fakeskin && R_SkinAvailable(skins[i]->name) != -1)
 				{
-					speed = skins[i].kartspeed;
-					weight = skins[i].kartweight;
+					speed = skins[i]->kartspeed;
+					weight = skins[i]->kartweight;
 					V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, NULL);
 				}
 			}
@@ -8205,12 +8207,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
 		case SKINMENUTYPE_EXTENDED:
 			for (s = 0; s < SKINGRIDNEWWIDTH*SKINGRIDNEWHEIGHT; s++)
 			{
-				INT32 x = ((s % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
-				INT32 y = ((s / SKINGRIDNEWWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2)) + 10); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
-				INT32 calcs = s + (setupm_skinypos * SKINGRIDNEWWIDTH);
 				INT32 skinn;
 				patch_t *face;
 				UINT8 *cmap;
+				const INT32 x = ((s % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
+				const INT32 y = ((s / SKINGRIDNEWWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2)) + 10); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
+				const INT32 calcs = s + (setupm_skinypos * SKINGRIDNEWWIDTH);
 
 				if (calcs < numskins)
 					skinn = skinsorted[calcs];
@@ -8222,8 +8224,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					continue;
 				}
 
-				face = facerankprefix[skinn];
-				cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
+				face = skins[skinn]->facerankprefix;
+				cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
 
 				V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 			}
@@ -8231,10 +8233,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			if (itemOn == 1) //has to be on skin select part
 			{
 				patch_t *cursor;
-				INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20;
-				INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ 10);
+				const INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20;
+				const INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ 10);
 
-				UINT8 cursorframe = (I_GetTime() / 4) % 7;
+				const UINT8 cursorframe = (I_GetTime() / 4) % 7;
 				cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
 				V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
 			}
@@ -8243,9 +8245,9 @@ static void M_DrawSetupMultiPlayerMenu(void)
 		case SKINMENUTYPE_GRID:
 			for (s = 0; s < SKINGRIDWIDTH*SKINGRIDHEIGHT; s++)
 			{
-				INT32 x = ((s % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
-				INT32 y = ((s / SKINGRIDWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2))); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
-				INT32 calcs = s + (setupm_skinypos * SKINGRIDWIDTH);
+				const INT32 x = ((s % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
+				const INT32 y = ((s / SKINGRIDWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2))); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
+				const INT32 calcs = s + (setupm_skinypos * SKINGRIDWIDTH);
 				INT16 skinn;
 				patch_t *face;
 				UINT8 *cmap;
@@ -8260,8 +8262,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					continue;
 				}
 
-				face = facerankprefix[skinn];
-				cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
+				face = skins[skinn]->facerankprefix;
+				cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
 
 				V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 			}
@@ -8269,36 +8271,44 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			if (itemOn == 1) //has to be on skin select part
 			{
 				patch_t *cursor;
-				INT32 curx = (((setupm_skinselect % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH/2)) + SKINXSHIFT) + 20;
-				INT32 cury = (((setupm_skinselect / SKINGRIDWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2)));
+				const INT32 curx = (((setupm_skinselect % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH/2)) + SKINXSHIFT) + 20;
+				const INT32 cury = (((setupm_skinselect / SKINGRIDWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2)));
 
 				if (setupm_skinselect < numskins)
 				{
-					UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
-					cursor = facewantprefix[skinsorted[setupm_skinselect]];
+					const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
+					cursor = skins[skinsorted[setupm_skinselect]]->facewantprefix;
 					V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
 				}
 				else
 				{
-					UINT8 cursorframe = (I_GetTime() / 4) % 7;
+					const UINT8 cursorframe = (I_GetTime() / 4) % 7;
 					cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
 					V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
 				}
 			}
 
 			{ // stat dot
-				INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
-				speed = skins[selectedskin].kartspeed;
-				weight = skins[selectedskin].kartweight;
+				const INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
+
+				speed = skins[selectedskin]->kartspeed;
+				weight = skins[selectedskin]->kartweight;
+
+				const INT32 x = (((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1);
+				const INT32 y = (((staty+71) + (weight*4))<<FRACBITS);
+
 				statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
+
 				if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
-					V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, flashcol);
+					V_DrawFixedPatch(x, y, FRACUNIT>>1, 0, statdot, flashcol);
 				else
-					V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL);
+					V_DrawFixedPatch(x, y, FRACUNIT>>1, 0, statdot, NULL);
 
-				statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
 				if (setupm_fakecolor)
-					V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
+				{
+					statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
+					V_DrawFixedPatch(x, y, FRACUNIT>>1, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
+				}
 			}
 			break;
 		case SKINMENUTYPE_2D:
@@ -8307,12 +8317,13 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			{
 				for (w = 0; w < MAXSTAT; w++)
 				{
-					INT32 x = ((s * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
-					INT32 y = ((w * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
 					INT32 skinn;
 					patch_t *face;
 					UINT8 *cmap;
 
+					const INT32 x = ((s * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
+					const INT32 y = ((w * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
+
 					if (!skinstatscount[s][w])
 					{
 						V_DrawFill(x, y, 16, 16, 239);
@@ -8320,8 +8331,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					}
 
 					skinn = skinstats[s][w][(I_GetTime() / TICRATE) % skinstatscount[s][w]];
-					face = facerankprefix[skinn];
-					cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
+					face = skins[skinn]->facerankprefix;
+					cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
 
 					V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 				}
@@ -8330,20 +8341,20 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			if (itemOn == 1) //has to be on skin select part
 			{
 				patch_t *cursor;
-				INT32 curx = ((setupm_skinxpos * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT);
-				INT32 cury = ((setupm_skinypos * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8);
+				const INT32 curx = ((setupm_skinxpos * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT);
+				const INT32 cury = ((setupm_skinypos * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8);
 
 				if (skinstatscount[setupm_skinxpos][setupm_skinypos])
 				{
-					UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
-					INT32 skinn = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime() / TICRATE) % skinstatscount[setupm_skinxpos][setupm_skinypos]];
+					const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
+					const INT32 skinn = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime() / TICRATE) % skinstatscount[setupm_skinxpos][setupm_skinypos]];
 
-					cursor = facewantprefix[skinn];
+					cursor = skins[skinn]->facewantprefix;
 					V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
 				}
 				else
 				{
-					UINT8 cursorframe = (I_GetTime() / 4) % 7;
+					const UINT8 cursorframe = (I_GetTime() / 4) % 7;
 					cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
 					V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
 				}
@@ -8351,18 +8362,26 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			break;
 #undef SKINXSHIFT
 		default:
-			speed = skins[setupm_fakeskin].kartspeed;
-			weight = skins[setupm_fakeskin].kartweight;
+			{
+				speed = skins[setupm_fakeskin]->kartspeed;
+				weight = skins[setupm_fakeskin]->kartweight;
 
-			statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
-			if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
-				V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, flashcol);
-			else
-				V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, NULL);
+				const INT32 x = ((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS;
+				const INT32 y = ((my+76) + ((weight-1)*8))<<FRACBITS;
 
-			statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
-			if (setupm_fakecolor)
-				V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
+				statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
+
+				if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
+					V_DrawFixedPatch(x, y, FRACUNIT, 0, statdot, flashcol);
+				else
+					V_DrawFixedPatch(x, y, FRACUNIT, 0, statdot, NULL);
+
+				if (setupm_fakecolor)
+				{
+					statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
+					V_DrawFixedPatch(x, y, FRACUNIT, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
+				}
+			}
 			break;
 	}
 
@@ -8389,10 +8408,13 @@ static void M_DrawSetupMultiPlayerMenu(void)
 				cw = charw;
 			else
 				cw = indexwidth;
+
 			for (ch = 0; ch < 16; ch++)
 				V_DrawFill(x, my+(cv_skinselectmenu.value?176:162)+ch, cw, 1, colortranslations[col][ch]);
+
 			if (++col >= MAXSKINCOLORS)
 				col -= MAXSKINCOLORS-1;
+
 			x += cw;
 		}
 	}
@@ -8420,28 +8442,33 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 		if (col < 0)
 			col += numskins;
+
 		while (k <= icons)
 		{
 			if (!(k++))
 			{
 				scale = FRACUNIT;
-				face = facewantprefix[col];
+				face = skins[col]->facewantprefix;
 				offx = 12;
 				offy = 0;
 			}
 			else
 			{
 				scale = FRACUNIT/2;
-				face = facerankprefix[col];
+				face = skins[col]->facerankprefix;
 				offx = 8;
 				offy = 8;
 			}
+
 			colmap =  R_GetTranslationColormap(col, setupm_fakecolor, GTC_MENUCACHE);
 			V_DrawFixedPatch((x+offx)<<FRACBITS, (my+28+offy)<<FRACBITS, FRACUNIT, 0, face, colmap);
+
 			if (scale == FRACUNIT) // bit of a hack
 				V_DrawFixedPatch((x+offx)<<FRACBITS, (my+28+offy)<<FRACBITS, FRACUNIT, 0, cursor, colmap);
+
 			if (++col >= numskins)
 				col -= numskins;
+
 			x += FixedMul(iconwidth<<FRACBITS, 3*scale/2)/FRACUNIT;
 		}
 	}
@@ -8482,15 +8509,15 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			break;
 	}
 
-	if (skintodisplay >= MAXSKINS)
+	if (skintodisplay >= numskins)
 		skintodisplay = 0;
 
-	skinnum = R_SkinAvailable(skins[skintodisplay].name);
+	skinnum = R_SkinAvailable(skins[skintodisplay]->name);
 
-	if (skinnum < 0 || skinnum >= MAXSKINS)
+	if (skinnum < 0 || skinnum >= numskins)
 		skinnum = 0;
 
-	sprdef = &skins[skinnum].spritedef;
+	sprdef = &skins[skinnum]->spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -8508,7 +8535,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	{
 		UINT8 *colormap = R_GetTranslationColormap(skintodisplay, setupm_fakecolor, GTC_MENUCACHE);
 #ifdef HWRENDER
-		md2_t *md2 = &md2_playermodels[skinnum];
+		md2_t *md2 = &skins[skinnum]->playermodel;
 #endif
 		mx += 36;
 		my += 131;
@@ -8539,11 +8566,11 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 			patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
 
-			if (skins[skintodisplay].flags & SF_HIRES)
+			if (skins[skintodisplay]->flags & SF_HIRES)
 			{
 				V_DrawFixedPatch(mx<<FRACBITS,
 								 my<<FRACBITS,
-								 skins[skintodisplay].highresscale,
+								 skins[skintodisplay]->highresscale,
 								 flags, patch, colormap);
 			}
 			else
@@ -8582,6 +8609,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 				}
 				else
 					M_NextOpt();
+
 				S_StartSound(NULL, sfx_menu1); // Tails
 				break;
 			}
@@ -8608,6 +8636,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 					{
 						M_NextOpt();
 					}
+
 					S_StartSound(NULL, sfx_menu1);
 				}
 				else if (itemOn == 0)
@@ -8618,9 +8647,11 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 				}
 				else
 					M_NextOpt();
+
 				S_StartSound(NULL, sfx_menu1); // Tails
 				break;
 			}
+
 			M_NextOpt();
 			S_StartSound(NULL, sfx_menu1); // Tails
 			break;
@@ -8638,6 +8669,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 				}
 				else
 					M_PrevOpt();
+
 				S_StartSound(NULL, sfx_menu1); // Tails
 				break;
 			}
@@ -8656,6 +8688,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 					{
 						M_PrevOpt();
 					}
+
 					S_StartSound(NULL, sfx_menu1);
 				}
 				else if (itemOn == 2)
@@ -8675,9 +8708,11 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 				}
 				else
 					M_PrevOpt();
+
 				S_StartSound(NULL, sfx_menu1); // Tails
 				break;
 			}
+
 			M_PrevOpt();
 			S_StartSound(NULL, sfx_menu1); // Tails
 			break;
@@ -8696,6 +8731,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 						setupm_skinselect--;
 					else
 						setupm_skinselect = SELECTEDSTATSCOUNT - 1;
+
 					S_StartSound(NULL, sfx_menu1);
 				}
 				else       //player skin
@@ -8728,6 +8764,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 					else if (cv_skinselectmenu.value == SKINMENUTYPE_EXTENDED)
 						setupm_skinypos = (((roundedskins/8) - SKINGRIDHEIGHT-2) > 0 ? (roundedskins/8) - SKINGRIDHEIGHT-2 : 0);
 				}
+
 				S_StartSound(NULL, sfx_menu1);
 				break;
 			}
@@ -8758,6 +8795,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 						setupm_skinselect++;
 					else
 						setupm_skinselect = 0;
+
 					S_StartSound(NULL, sfx_menu1);
 				}
 				else       //player skin
@@ -8792,6 +8830,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 					setupm_skinselect = 0;
 					setupm_skinypos = 0;
 				}
+
 				S_StartSound(NULL, sfx_menu1);
 				break;
 			}
@@ -8814,12 +8853,14 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 				setupm_skinlockedselect = false;
 				break;
 			}
+
 			exitmenu = true;
 			break;
 
 		case KEY_BACKSPACE:
 			if (cv_skinselectmenu.value)
 				BREAKWHENLOCKED
+
 			if (itemOn == 0)
 			{
 				M_TextInputHandle(&setupm_input, choice);
@@ -8836,7 +8877,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 			}
 			else if (itemOn == 2)
 			{
-				UINT8 col = skins[setupm_fakeskin].prefcolor;
+				UINT8 col = skins[setupm_fakeskin]->prefcolor;
 				if (setupm_fakecolor != col)
 				{
 					S_StartSound(NULL, sfx_menu1); // Tails
@@ -8849,6 +8890,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 		case KEY_DEL:
 			if (cv_skinselectmenu.value)
 				BREAKWHENLOCKED
+
 			if (itemOn == 0)
 			{
 				M_TextInputHandle(&setupm_input, choice);
@@ -9058,7 +9100,7 @@ static boolean M_QuitMultiPlayerMenu(void)
 	}
 
 	// you know what? always putting these in the buffer won't hurt anything.
-	COM_BufAddText(va("%s \"%s\"\n", setupm_cvskin->name, skins[setupm_fakeskin].name));
+	COM_BufAddText(va("%s \"%s\"\n", setupm_cvskin->name, skins[setupm_fakeskin]->name));
 	COM_BufAddText(va("%s %d\n", setupm_cvcolor->name, setupm_fakecolor));
 
 	return true;
@@ -9165,7 +9207,7 @@ static void M_DrawJoystick(void)
 		compareval4 = cv_usejoystick[3].value;
 		compareval3 = cv_usejoystick[2].value;
 		compareval2 = cv_usejoystick[1].value;
-		compareval = cv_usejoystick[0].value;
+		compareval  = cv_usejoystick[0].value;
 #endif
 
 		if    ((setupcontrolplayer == 4 && (i == compareval4))
@@ -9204,14 +9246,13 @@ void M_SetupJoystickMenu(INT32 choice)
 		//
 		// Update cv_usejoystick.string here so that the user can
 		// properly change this value.
-		if (i == cv_usejoystick[0].value)
-			CV_SetValue(&cv_usejoystick[0], i);
-		if (i == cv_usejoystick[1].value)
-			CV_SetValue(&cv_usejoystick[1], i);
-		if (i == cv_usejoystick[2].value)
-			CV_SetValue(&cv_usejoystick[2], i);
-		if (i == cv_usejoystick[3].value)
-			CV_SetValue(&cv_usejoystick[3], i);
+		for (INT32 f = 0; f < MAXSPLITSCREENPLAYERS; f++)
+		{
+			if (i == cv_usejoystick[f].value)
+			{
+				CV_SetValue(&cv_usejoystick[f], i);
+			}
+		}
 #endif
 	}
 
@@ -9250,9 +9291,11 @@ static void M_Setup4PJoystickMenu(INT32 choice)
 static void M_DoAssignJoystick(UINT8 pnum, INT32 choice)
 {
 	INT32 oldchoice, oldstringchoice;
-	const int joynum = atoi(cv_usejoystick[pnum].string);
 
-	oldchoice = oldstringchoice = joynum > numcontrollers ? joynum : cv_usejoystick[pnum].value;
+#define joystrnum (atoi(cv_usejoystick[pnum].string))
+#define joyoldchoice ((joystrnum > numcontrollers) ? joystrnum : cv_usejoystick[pnum].value)
+
+	oldchoice = oldstringchoice = joyoldchoice;
 	CV_SetValue(&cv_usejoystick[pnum], choice);
 
 	// Just in case last-minute changes were made to cv_usejoystick.value,
@@ -9262,59 +9305,37 @@ static void M_DoAssignJoystick(UINT8 pnum, INT32 choice)
 	{
 		CV_SetValue(&cv_usejoystick[pnum], cv_usejoystick[pnum].value);
 
-		if (oldchoice > numcontrollers)  /* reset this so the comparison is valid*/
+		// reset this so the comparison is valid
+		if (oldchoice > numcontrollers)
 			oldchoice = cv_usejoystick[pnum].value;
 
 		if (oldchoice != choice)
 		{
 			if (choice && oldstringchoice > numcontrollers) // if we did not select "None", we likely selected a used device
-				CV_SetValue(&cv_usejoystick[pnum], (oldstringchoice > numcontrollers ? oldstringchoice : oldchoice));
+			{
+				CV_SetValue(&cv_usejoystick[pnum], ((oldstringchoice > numcontrollers) ? oldstringchoice : oldchoice));
+			}
 
-			if (oldstringchoice ==
-				(joynum > numcontrollers ? joynum : cv_usejoystick[pnum].value))
+			if (oldstringchoice == joyoldchoice)
+			{
 				M_StartMessage("This joystick is used by another\n"
 				"player. Reset the joystick\n"
 				"for that player first.\n\n"
 				"(Press a key)\n", NULL, MM_NOTHING);
+			}
 		}
 	}
+#undef joystrnum
+#undef joyoldchoice
 }
 #endif
 
 static void M_AssignJoystick(INT32 choice)
 {
 #ifdef JOYSTICK_HOTPLUG
-	switch (setupcontrolplayer)
-	{
-		case 4:
-			M_DoAssignJoystick(3, choice);
-			break;
-		case 3:
-			M_DoAssignJoystick(2, choice);
-			break;
-		case 2:
-			M_DoAssignJoystick(1, choice);
-			break;
-		case 1:
-			M_DoAssignJoystick(0, choice);
-			break;
-	}
+	M_DoAssignJoystick((setupcontrolplayer-1), choice);
 #else
-	switch (setupcontrolplayer)
-	{
-		case 4:
-			CV_SetValue(&cv_usejoystick[3], choice);
-			break;
-		case 3:
-			CV_SetValue(&cv_usejoystick[2], choice);
-			break;
-		case 2:
-			CV_SetValue(&cv_usejoystick[1], choice);
-			break;
-		case 1:
-			CV_SetValue(&cv_usejoystick[0], choice);
-			break;
-	}
+	CV_SetValue(&cv_usejoystick[(setupcontrolplayer-1)], choice);
 #endif
 }
 
@@ -9352,7 +9373,7 @@ static void M_SetupControlsMenu(UINT8 pnum)
 	{
 		// Hide P1-only controls
 		OP_AllControlsMenu[19].status = IT_GRAYEDOUT2; // Chat
-		OP_AllControlsMenu[10].status = IT_GRAYEDOUT2; // Rankings
+		OP_AllControlsMenu[20].status = IT_GRAYEDOUT2; // Rankings
 		OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Pause
 		OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // Screenshot
 		OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // GIF
@@ -9364,7 +9385,7 @@ static void M_SetupControlsMenu(UINT8 pnum)
 	{
 		// Unhide P1-only controls
 		OP_AllControlsMenu[19].status = IT_CONTROL; // Chat
-		OP_AllControlsMenu[10].status = IT_CONTROL; // Rankings
+		OP_AllControlsMenu[20].status = IT_CONTROL; // Rankings
 		OP_AllControlsMenu[21].status = IT_CONTROL; // Pause
 		OP_AllControlsMenu[22].status = IT_CONTROL; // Screenshot
 		OP_AllControlsMenu[23].status = IT_CONTROL; // GIF
@@ -9855,7 +9876,7 @@ static void M_DrawLocalSkinMenu(void)
 	UINT8 frame;
 	INT32 skintodisplay = 0;
 	UINT32 speenframe;
-	skin_t displayskin;
+	skin_t *displayskin;
 
 	mx = OP_ForkedBirdDef.x;
 	my = OP_ForkedBirdDef.y;
@@ -9897,7 +9918,7 @@ static void M_DrawLocalSkinMenu(void)
 
 	displayskin = allskins[skintodisplay];
 
-	sprdef = &displayskin.spritedef;
+	sprdef = &displayskin->spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -9910,24 +9931,25 @@ static void M_DrawLocalSkinMenu(void)
 	V_DrawFill(mx + 220 - (charw/2), my+54, charw, 84, 239);
 #undef charw
 
-	UINT8 *colormap = R_GetLocalTranslationColormap(&skins[displayskin.localnum], (displayskin.localskin ? &localskins[displayskin.localnum] : NULL), cv_playercolor.value, GTC_MENUCACHE, displayskin.localskin);
+	// FIXME: is using just "skins" array even correct?
+	UINT8 *colormap = R_GetLocalTranslationColormap(skins[displayskin->skinnum], (displayskin->localskin ? localskins[displayskin->skinnum] : NULL), cv_playercolor.value, GTC_MENUCACHE, displayskin->localskin);
 
-	V_DrawMappedPatch(mx, my+50, 0, (patch_t *)W_CachePatchName(displayskin.facewant, PU_PATCH), colormap);
-	V_DrawMappedPatch(mx+8, my+85, 0, (patch_t *)W_CachePatchName(displayskin.facerank, PU_PATCH), colormap);
+	V_DrawMappedPatch(mx, my+50, 0, (patch_t *)W_CachePatchName(displayskin->facewant, PU_PATCH), colormap);
+	V_DrawMappedPatch(mx+8, my+85, 0, (patch_t *)W_CachePatchName(displayskin->facerank, PU_PATCH), colormap);
 
 	V_DrawString(mx, my+108, V_ALLOWLOWERCASE, "Character");
 
-	if (strlen(displayskin.realname) > 10)
-		V_DrawThinString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin.realname);
+	if (strlen(displayskin->realname) > 10)
+		V_DrawThinString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin->realname);
 	else
-		V_DrawString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin.realname);
+		V_DrawString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin->realname);
 
 	// draw player sprite
 	mx += 220;
 	my += 120;
 
 #ifdef HWRENDER
-	md2_t *md2 = (displayskin.localskin ? &md2_localplayermodels[skintodisplay] : &md2_playermodels[skintodisplay]);
+	md2_t *md2 = &displayskin->playermodel;
 
 	// if we have 3d models enabled and a model exists
 	// try to show it instead of the sprite
@@ -9955,9 +9977,9 @@ static void M_DrawLocalSkinMenu(void)
 
 		patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
 
-		if (displayskin.flags & SF_HIRES)
+		if (displayskin->flags & SF_HIRES)
 		{
-			V_DrawFixedPatch(mx<<FRACBITS, my<<FRACBITS, displayskin.highresscale, flags, patch, colormap);
+			V_DrawFixedPatch(mx<<FRACBITS, my<<FRACBITS, displayskin->highresscale, flags, patch, colormap);
 		}
 		else
 		{

src/p_inter.c

@@ -107,6 +107,9 @@ void P_DoNightsScore(player_t *player)
 
 	dummymo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z+player->mo->height/2, MT_NIGHTSCORE);
 
+	if (P_MobjWasRemovedCompat(dummymo))
+		return;
+
 	if (player->bot)
 		player = &players[consoleplayer];
 
@@ -2013,7 +2016,7 @@ static inline void P_NiGHTSDamage(mobj_t *target, mobj_t *source)
 	}
 }
 
-static inline boolean P_TagDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage)
+static boolean P_TagDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage)
 {
 	player_t *player = target->player;
 	(void)damage; //unused parm

src/p_local.h

@@ -418,6 +418,7 @@ boolean P_CheckSector(sector_t *sector, boolean crunch);
 void P_DelSeclist(msecnode_t *node);
 
 void P_CreateSecNodeList(mobj_t *thing, fixed_t x, fixed_t y);
+void P_Initsecnode(void);
 
 void P_RadiusAttack(mobj_t *spot, mobj_t *source, fixed_t damagedist);
 

src/p_map.c

@@ -2026,7 +2026,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
 
 	mapcampointer = thiscam;
 
-	if (UNLIKELY(GETSECSPECIAL(newsec->special, 4) == 12))
+	if (newsec->flags & SF_NOCLIPCAMERA)
 	{ // Camera noclip on entire sector.
 		tmfloorz = tmdropoffz = thiscam->z;
 		tmceilingz = tmdrpoffceilz = thiscam->z + thiscam->height;
@@ -2068,7 +2068,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
 			fixed_t topheight, bottomheight, midheight;
 
 			if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL)
-			   || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
+			   || rover->master->frontsector->flags & SF_NOCLIPCAMERA)
 				continue;
 
 			topheight    = P_CameraGetFOFTopZ(thiscam, newsec, rover, x, y, NULL);
@@ -2144,7 +2144,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
 						// We're inside it! Yess...
 						polysec = po->lines[0]->backsector;
 
-						if (UNLIKELY(GETSECSPECIAL(polysec->special, 4) == 12))
+						if (polysec->flags & SF_NOCLIPCAMERA)
 						{ // Camera noclip polyobj.
 							plink = (polymaplink_t *)(plink->link.next);
 							continue;
@@ -3983,19 +3983,51 @@ boolean P_CheckSector(sector_t *sector, boolean crunch)
  Lots of new Boom functions that work faster and add functionality.
 */
 
+#ifndef PHOBOS_BUILD
+static msecnode_t *headsecnode = NULL;
+#endif
+
+void P_Initsecnode(void)
+{
+#ifndef PHOBOS_BUILD
+	headsecnode = NULL;
+#endif
+}
+
 // P_GetSecnode() retrieves a node from the freelist. The calling routine
 // should make sure it sets all fields properly.
 
 static msecnode_t *P_GetSecnode(void)
 {
+#ifdef PHOBOS_BUILD
 	return Z_LevelPoolCalloc(sizeof(msecnode_t));
+#else
+	msecnode_t *node;
+
+	if (headsecnode)
+	{
+		// vanilla does not clear this
+		// so for compat reasons we also dont
+		// means we just reuse stale data which causes weird interactions with orbiting items in some cases
+		node = headsecnode;
+		headsecnode = headsecnode->m_thinglist_next;
+	}
+	else
+		node = Z_LevelPoolCalloc(sizeof(msecnode_t));
+
+	return node;
+#endif
 }
 
 // P_PutSecnode() returns a node to the freelist.
-
 static inline void P_PutSecnode(msecnode_t *node)
 {
+#ifdef PHOBOS_BUILD
 	Z_LevelPoolFree(node, sizeof(msecnode_t));
+#else
+	node->m_thinglist_next = headsecnode;
+	headsecnode = node;
+#endif
 }
 
 // P_AddSecnode() searches the current list to see if this sector is

src/p_maputl.cpp

@@ -328,7 +328,7 @@ void P_CameraLineOpening(line_t *linedef)
 			{
 				fixed_t topheight, bottomheight, midheight;
 
-				if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
+				if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
 					continue;
 
 				topheight = P_CameraGetFOFTopZ(mapcampointer, front, rover, tmx, tmy, linedef);
@@ -358,7 +358,7 @@ void P_CameraLineOpening(line_t *linedef)
 			{
 				fixed_t topheight, bottomheight, midheight;
 
-				if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
+				if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
 					continue;
 
 				topheight = P_CameraGetFOFTopZ(mapcampointer, back, rover, tmx, tmy, linedef);

src/p_mobj.h

@@ -266,15 +266,8 @@ typedef enum {
 	PCF_THUNK     = 1<<5, // Ran the thinker this tic.
 } precipflag_t;
 
-typedef struct salty_s
-{
-	bool init;
-	bool ready;
-	bool tapping;
-	fixed_t zoffset;
-	fixed_t momz;
-	bool jump;
-} salty_t;
+
+typedef struct skin_s skin_t;
 
 // Map Object definition.
 typedef struct mobj_s
@@ -351,9 +344,9 @@ typedef struct mobj_s
 	struct mobj_s *hnext;
 	struct mobj_s *hprev;
 
-	void *skin; // overrides 'sprite' when non-NULL (for player bodies to 'remember' the skin)
-	void *localskin;
-	boolean skinlocal;
+	skin_t *skin; // overrides 'sprite' when non-NULL (for player bodies to 'remember' the skin)
+	skin_t *localskin;
+	boolean skinlocal; // if the skin is from a LOCALLY loaded skin
 
 	// Player and mobj sprites in multiplayer modes are modified
 	//  using an internal color lookup table for re-indexing.
@@ -412,9 +405,6 @@ typedef struct mobj_s
 
 	tic_t slamsoundtimer; // Funni slam sound when landing
 
-	// saltyhop! hardcode edition
-	salty_t salty;
-
 	// WARNING: New fields must be added separately to savegame and Lua.
 	boolean islocal; // BEWARE: islocal does not exist in vanilla, strictly to be used for locally loaded addons to not cause desynchs with the mobj linedef trigger check. DO NOT USE THIS IN ACTUAL ADDONS YOU INTEND TO USE ON YOUR SERVER
 } mobj_t;

src/p_saveg.c

@@ -1109,6 +1109,10 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
 	if (mobj->type == MT_HOOPCENTER && mobj->threshold == 4242)
 		return;
 
+	// do not send over locally spawned mobjs
+	if (mobj->islocal)
+		return;
+
 	if (mobj->spawnpoint && mobj->info->doomednum != -1)
 	{
 		// spawnpoint is not modified but we must save it since it is an identifier
@@ -1134,9 +1138,17 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
 	if (mobj->momx != 0 || mobj->momy != 0 || mobj->momz != 0)
 #endif
 		diff |= MD_MOM;
+#ifdef PHOBOS_BUILD
+	if (mobj->radius != FixedMul(mapobjectscale, mobj->info->radius))
+#else
 	if (mobj->radius != mobj->info->radius)
+#endif
 		diff |= MD_RADIUS;
+#ifdef PHOBOS_BUILD
+	if (mobj->height != FixedMul(mapobjectscale, mobj->info->height))
+#else
 	if (mobj->height != mobj->info->height)
+#endif
 		diff |= MD_HEIGHT;
 	if (mobj->flags != mobj->info->flags)
 		diff |= MD_FLAGS;
@@ -1179,11 +1191,19 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
 		diff |= MD_MOVEFACTOR;
 	if (mobj->fuse)
 		diff |= MD_FUSE;
+#ifdef PHOBOS_BUILD
+	if (mobj->watertop != INT32_MAX)
+#else
 	if (mobj->watertop)
+#endif
 		diff |= MD_WATERTOP;
 	if (mobj->waterbottom)
 		diff |= MD_WATERBOTTOM;
+#ifdef PHOBOS_BUILD
+	if (mobj->scale != mapobjectscale)
+#else
 	if (mobj->scale != FRACUNIT)
+#endif
 		diff |= MD_SCALE;
 	if (mobj->destscale != mobj->scale)
 		diff |= MD_DSCALE;
@@ -1324,7 +1344,7 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
 	if (diff2 & MD2_CVMEM)
 		WRITEINT32(save->p, mobj->cvmem);
 	if (diff2 & MD2_SKIN)
-		WRITESKIN(save->p, (skinnum_t)((skin_t *)mobj->skin - skins));
+		WRITESKIN(save->p, (skinnum_t)mobj->skin->skinnum);
 	if (diff2 & MD2_COLOR)
 		WRITEUINT8(save->p, mobj->color);
 	if (diff2 & MD2_EXTVAL1)
@@ -2090,11 +2110,19 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
 	if (diff & MD_RADIUS)
 		mobj->radius = READFIXED(save->p);
 	else
+#ifdef PHOBOS_BUILD
+		mobj->radius = FixedMul(mobj->info->radius, mapobjectscale);
+#else
 		mobj->radius = mobj->info->radius;
+#endif
 	if (diff & MD_HEIGHT)
 		mobj->height = READFIXED(save->p);
 	else
+#ifdef PHOBOS_BUILD
+		mobj->height = FixedMul(mobj->info->height, mapobjectscale);
+#else
 		mobj->height = mobj->info->height;
+#endif
 	if (diff & MD_FLAGS)
 		mobj->flags = READUINT32(save->p);
 	else
@@ -2166,12 +2194,20 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
 		mobj->fuse = READINT32(save->p);
 	if (diff & MD_WATERTOP)
 		mobj->watertop = READFIXED(save->p);
+#ifdef PHOBOS_BUILD
+	else
+		mobj->watertop = INT32_MAX;
+#endif
 	if (diff & MD_WATERBOTTOM)
 		mobj->waterbottom = READFIXED(save->p);
 	if (diff & MD_SCALE)
 		mobj->scale = READFIXED(save->p);
 	else
+#ifdef PHOBOS_BUILD
+		mobj->scale = mapobjectscale;
+#else
 		mobj->scale = FRACUNIT;
+#endif
 	if (diff & MD_DSCALE)
 		mobj->destscale = READFIXED(save->p);
 	else
@@ -2185,7 +2221,7 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
 	if (diff2 & MD2_CVMEM)
 		mobj->cvmem = READINT32(save->p);
 	if (diff2 & MD2_SKIN)
-		mobj->skin = &skins[READSKIN(save->p)];
+		mobj->skin = skins[READSKIN(save->p)];
 	if (diff2 & MD2_COLOR)
 		mobj->color = READUINT8(save->p);
 	if (diff2 & MD2_EXTVAL1)

src/p_setup.c

@@ -2478,28 +2478,28 @@ static void P_ForceCharacter(const char *forcecharskin)
 		if (splitscreen)
 		{
 			SetPlayerSkin(displayplayers[1], forcecharskin);
-			if ((unsigned)cv_playercolor2.value != skins[players[displayplayers[1]].skin].prefcolor && !modeattacking)
+			if ((unsigned)cv_playercolor2.value != skins[players[displayplayers[1]].skin]->prefcolor && !modeattacking)
 			{
-				CV_StealthSetValue(&cv_playercolor2, skins[players[displayplayers[1]].skin].prefcolor);
-				players[displayplayers[1]].skincolor = skins[players[displayplayers[1]].skin].prefcolor;
+				CV_StealthSetValue(&cv_playercolor2, skins[players[displayplayers[1]].skin]->prefcolor);
+				players[displayplayers[1]].skincolor = skins[players[displayplayers[1]].skin]->prefcolor;
 			}
 
 			if (splitscreen > 1)
 			{
 				SetPlayerSkin(displayplayers[2], forcecharskin);
-				if ((unsigned)cv_playercolor3.value != skins[players[displayplayers[2]].skin].prefcolor && !modeattacking)
+				if ((unsigned)cv_playercolor3.value != skins[players[displayplayers[2]].skin]->prefcolor && !modeattacking)
 				{
-					CV_StealthSetValue(&cv_playercolor3, skins[players[displayplayers[2]].skin].prefcolor);
-					players[displayplayers[2]].skincolor = skins[players[displayplayers[2]].skin].prefcolor;
+					CV_StealthSetValue(&cv_playercolor3, skins[players[displayplayers[2]].skin]->prefcolor);
+					players[displayplayers[2]].skincolor = skins[players[displayplayers[2]].skin]->prefcolor;
 				}
 
 				if (splitscreen > 2)
 				{
 					SetPlayerSkin(displayplayers[3], forcecharskin);
-					if ((unsigned)cv_playercolor4.value != skins[players[displayplayers[3]].skin].prefcolor && !modeattacking)
+					if ((unsigned)cv_playercolor4.value != skins[players[displayplayers[3]].skin]->prefcolor && !modeattacking)
 					{
-						CV_StealthSetValue(&cv_playercolor4, skins[players[displayplayers[3]].skin].prefcolor);
-						players[displayplayers[3]].skincolor = skins[players[displayplayers[3]].skin].prefcolor;
+						CV_StealthSetValue(&cv_playercolor4, skins[players[displayplayers[3]].skin]->prefcolor);
+						players[displayplayers[3]].skincolor = skins[players[displayplayers[3]].skin]->prefcolor;
 					}
 				}
 			}
@@ -2507,10 +2507,10 @@ static void P_ForceCharacter(const char *forcecharskin)
 
 		SetPlayerSkin(consoleplayer, forcecharskin);
 		// normal player colors in single player
-		if ((unsigned)cv_playercolor.value != skins[players[consoleplayer].skin].prefcolor && !modeattacking)
+		if ((unsigned)cv_playercolor.value != skins[players[consoleplayer].skin]->prefcolor && !modeattacking)
 		{
-			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin].prefcolor);
-			players[consoleplayer].skincolor = skins[players[consoleplayer].skin].prefcolor;
+			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin]->prefcolor);
+			players[consoleplayer].skincolor = skins[players[consoleplayer].skin]->prefcolor;
 		}
 	}
 }
@@ -2537,8 +2537,8 @@ static void P_LoadRecordGhosts(void)
 			if (cv_ghost_besttime.value == 1 && players[consoleplayer].skin != i)
 				continue;
 
-			if (FIL_FileExists(va("%s-%s-time-best.lmp", gpath, skins[i].name)))
-				G_AddGhost(va("%s-%s-time-best.lmp", gpath, skins[i].name));
+			if (FIL_FileExists(va("%s-%s-time-best.lmp", gpath, skins[i]->name)))
+				G_AddGhost(va("%s-%s-time-best.lmp", gpath, skins[i]->name));
 		}
 	}
 
@@ -2550,8 +2550,8 @@ static void P_LoadRecordGhosts(void)
 			if (cv_ghost_bestlap.value == 1 && players[consoleplayer].skin != i)
 				continue;
 
-			if (FIL_FileExists(va("%s-%s-lap-best.lmp", gpath, skins[i].name)))
-				G_AddGhost(va("%s-%s-lap-best.lmp", gpath, skins[i].name));
+			if (FIL_FileExists(va("%s-%s-lap-best.lmp", gpath, skins[i]->name)))
+				G_AddGhost(va("%s-%s-lap-best.lmp", gpath, skins[i]->name));
 		}
 	}
 
@@ -2563,8 +2563,8 @@ static void P_LoadRecordGhosts(void)
 			if (cv_ghost_last.value == 1 && players[consoleplayer].skin != i)
 				continue;
 
-			if (FIL_FileExists(va("%s-%s-last.lmp", gpath, skins[i].name)))
-				G_AddGhost(va("%s-%s-last.lmp", gpath, skins[i].name));
+			if (FIL_FileExists(va("%s-%s-last.lmp", gpath, skins[i]->name)))
+				G_AddGhost(va("%s-%s-last.lmp", gpath, skins[i]->name));
 		}
 	}
 
@@ -3001,6 +3001,9 @@ boolean P_SetupLevel(boolean fromnetsave, boolean reloadinggamestate)
 	CON_Drawer(); // let the user know what we are going to do
 	I_FinishUpdate(); // page flip or blit buffer
 
+	// Initialize sector node list.
+	P_Initsecnode();
+
 	if (netgame || multiplayer)
 		cv_debug = botskin = 0;
 
@@ -3328,6 +3331,7 @@ static boolean P_CheckSoundReplacements(UINT16 wadnum, char *name, size_t i)
 
 	return false;
 }
+
 //
 // P_CheckReplacMapReplacements
 //
@@ -3420,7 +3424,13 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
 	{
 		// check if someone tries to load maps locally lol
 		// do this here so we can skip loading the file anyways
-		if (W_CheckAutoLoadContainsMap(wadfilename))
+		int retmap = W_CheckAutoLoadContainsMap(wadfilename);
+		if (retmap == -1)
+		{
+			CONS_Alert(CONS_WARNING, "addilelocal: file %s was not found or not valid.\n", wadfilename);
+			return UINT16_MAX;
+		}
+		if (retmap > 0)
 		{
 			CONS_Alert(CONS_WARNING, "addilelocal: locally added file %s contains map data, this WILL cause crashes and desynchs! not added.\n", wadfilename);
 			return UINT16_MAX;

src/p_spec.c

@@ -3394,7 +3394,7 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
 			break;
 		case 12: // SRB2kart: Invert Encore Remap
 			break;
-		case 15: // no idea but keep it dont want anything to break
+		case 15: // also Invert Encore Remap....
 			break;
 	}
 DoneSection2:
@@ -5368,6 +5368,11 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
 			case 11: // Custom global gravity!
 				gravity = sector->floorheight/1000;
 				break;
+
+			case 12: // SRB2kart: Invert Encore Remap
+			case 15: // NOTE: vanilla kart checks only for this for some reason!
+				sector->flags |= SF_INVERTENCORE;
+				break;
 		}
 
 		// Process Section 4
@@ -5377,6 +5382,10 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
 				if (G_RaceGametype())
 					circuitmap = true;
 				break;
+
+			case 12: // Camera noclip
+				sector->flags |= SF_NOCLIPCAMERA;
+				break;
 		}
 	}
 
@@ -5461,11 +5470,11 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
 					sectors[s].gravity = &sectors[sec].floorheight; // This allows it to change in realtime!
 
 					if (lines[i].flags & ML_NOCLIMB)
-						sectors[s].verticalflip = true;
+						sectors[s].flags |= SF_GRAVITYFLIP;
 					else
-						sectors[s].verticalflip = false;
+						sectors[s].flags &= ~SF_GRAVITYFLIP;
 
-					CheckForReverseGravity = sectors[s].verticalflip;
+					CheckForReverseGravity = (boolean)(sectors[s].flags & SF_GRAVITYFLIP);
 				}
 				break;
 
@@ -5558,6 +5567,11 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
 					sectors[s].cullheight = &lines[i]; // This allows it to change in realtime!
 				break;
 
+			case 13: // Heat wave effect
+				for (s = -1; (s = P_FindSectorFromLineTag(lines + i, s)) >= 0 ;)
+					sectors[s].flags |= SF_HEATWAVE;
+				break;
+
 			case 50: // Insta-Lower Sector
 				EV_DoFloor(&lines[i], instantLower);
 				break;

src/p_user.c

@@ -498,7 +498,7 @@ void P_PlayRinglossSound(mobj_t *source, mobj_t *damager)
 
 			// I HATE LOCALSKINS! I HATE LOCALSKINS! :AAAAAAAAAA:
 			if (source->player)
-				sfx = K_GetPlayerSkin(source->player)->soundsid[SKSKPAN1 + key];
+				sfx = R_GetPlayerSkin(source->player)->soundsid[SKSKPAN1 + key];
 
 			S_StartSound(NULL, sfx);
 		}
@@ -1017,7 +1017,7 @@ boolean P_IsLocalPlayer(const player_t *player)
 }
 
 //
-// P_IsLocalPlayer
+// P_IsLocalPlayerNum
 //
 // Returns true if playernum is
 // on the local machine.
@@ -1271,7 +1271,7 @@ void P_DoPlayerExit(player_t *player)
 
 			if (islocalplayer)
 			{
-				sfxenum_t sfx_id = K_GetMobjSkin(player->mo)->soundsid[S_sfx[soundid].skinsound];
+				sfxenum_t sfx_id = R_GetMobjSkin(player->mo)->soundsid[S_sfx[soundid].skinsound];
 				S_StartSound(NULL, sfx_id);
 			}
 			else
@@ -3561,7 +3561,7 @@ static boolean P_CheckNoclipCameraPosition(player_t *player, camera_t *thiscam,
 			for (rover = newsubsec->sector->ffloors; rover; rover = rover->next)
 			{
 				fixed_t topheight, bottomheight;
-				if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL) || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
+				if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL) || (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
 					continue;
 
 				topheight = P_CameraGetFOFTopZ(thiscam, newsubsec->sector, rover, midx, midy, NULL);
@@ -3626,7 +3626,7 @@ static boolean P_CheckNoclipCameraPosition(player_t *player, camera_t *thiscam,
 							// We're inside it! Yess...
 							polysec = po->lines[0]->backsector;
 
-							if (UNLIKELY(GETSECSPECIAL(polysec->special, 4) == 12))
+							if (polysec->flags & SF_NOCLIPCAMERA)
 							{ // Camera noclip polyobj.
 								plink = (polymaplink_t *)(plink->link.next);
 								continue;
@@ -3682,7 +3682,8 @@ static boolean P_CheckNoclipCameraPosition(player_t *player, camera_t *thiscam,
 			for (rover = newsubsec->sector->ffloors; rover; rover = rover->next)
 			{
 				fixed_t topheight, bottomheight;
-				if (UNLIKELY((rover->flags & FF_BLOCKOTHERS) && (rover->flags & FF_RENDERALL) && (rover->flags & FF_EXISTS) && GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
+
+				if ((rover->flags & FF_BLOCKOTHERS) && (rover->flags & FF_RENDERALL) && (rover->flags & FF_EXISTS) && (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
 				{
 					topheight = P_CameraGetFOFTopZ(thiscam, newsubsec->sector, rover, midx, midy, NULL);
 					bottomheight = P_CameraGetFOFBottomZ(thiscam, newsubsec->sector, rover, midx, midy, NULL);
@@ -4262,7 +4263,7 @@ boolean P_SpectatorJoinGame(player_t *player)
 
 static boolean P_CameraCheckHeatFirstperson(player_t *player, sector_t *sector, fixed_t pviewheight)
 {
-	if (P_FindSpecialLineFromTag(13, sector->tag, -1) != -1)
+	if (sector->flags & SF_HEATWAVE)
 		return true;
 
 	if (sector->ffloors)
@@ -4280,7 +4281,7 @@ static boolean P_CameraCheckHeatFirstperson(player_t *player, sector_t *sector,
 			if (pviewheight <= P_GetFFloorBottomZAt(rover, player->mo->x, player->mo->y))
 				continue;
 
-			if (P_FindSpecialLineFromTag(13, rover->master->frontsector->tag, -1) != -1)
+			if (rover->master->frontsector->flags & SF_HEATWAVE)
 				return true;
 		}
 	}
@@ -4516,27 +4517,33 @@ static void DoABarrelRoll(player_t *player)
 static void P_DoFunnyDance(player_t *player)
 {
 	fixed_t bpm; // 140bpm ish
+	fixed_t work, ang, bounce; // hehe squishy
 
-	if (player->spectator || !player->mo || player->kartstuff[k_respawn] || player->mo->salty.jump) // this looks jank as hell during hop
+	I_Assert(player != NULL);
+	I_Assert(!P_MobjWasRemoved(player->mo));
+
+	if (player->spectator)
 		return;
 
-	player->squishdance.bounce = 0;
+	// this looks jank as hell during hop or respawn
+	if (player->kartstuff[k_respawn] || player->salty.jump)
+		return;
 
 	// bpm = FixedDiv((60*TICRATE)<<FRACBITS, FLOAT_TO_FIXED(mapmusic.bpm)); << maybe can get the tempo and beat detection lib to work for bpm autodetection
-	bpm = FixedDiv((60*TICRATE)<<FRACBITS, FLOAT_TO_FIXED((float)cv_squishdancespeed.value));
+	bpm = ((60*TICRATE) / (cv_squishdancespeed.value)) << FRACBITS;
 
-	player->squishdance.work = (player->squishdance.time << FRACBITS) % bpm;
+	work = (player->squishdance.time << FRACBITS) % bpm;
 
 	if (player->squishdance.time >= (FRACUNIT >> 1)) // prevent overflow jump - takes about 15 minutes
-		player->squishdance.time = (player->squishdance.work >> FRACBITS);
+		player->squishdance.time = (work >> FRACBITS);
 
-	player->squishdance.work = FixedDiv(player->squishdance.work*180, bpm);
+	work = FixedDiv(work*180, bpm);
 
-	player->squishdance.ang = ((FixedAngle(player->squishdance.work) >> ANGLETOFINESHIFT) & FINEMASK);
-	player->squishdance.bounce = ((FINESINE(player->squishdance.ang) - FRACUNIT/2) / 2);
+	ang = ((FixedAngle(work) >> ANGLETOFINESHIFT) & FINEMASK);
+	bounce = ((FINESINE(ang) - FRACUNIT/2) / 2);
 
-	player->mo->spritexscale -= player->squishdance.bounce;
-	player->mo->spriteyscale += player->squishdance.bounce;
+	player->mo->spritexscale -= bounce;
+	player->mo->spriteyscale += bounce;
 
 	player->squishdance.time++;
 }

src/r_bsp.cpp

@@ -48,8 +48,7 @@ boolean g_walloffscreen = false;
 
 boolean R_NoEncore(sector_t *sector, boolean ceiling)
 {
-	const INT32 invspecial = GETSECSPECIAL(sector->special, 2);
-	boolean invertencore = (invspecial == 12 || invspecial == 15); // keeping this incase its used
+	const boolean invertEncore = (sector->flags & SF_INVERTENCORE);
 
 #if 0 // perfect implementation
 	const INT32 sprnspecial = GETSECSPECIAL(sector->special, 3);
@@ -59,10 +58,10 @@ boolean R_NoEncore(sector_t *sector, boolean ceiling)
 #endif
 		&& GETSECSPECIAL(sector->special, 4) != 6) // sneaker panel
 	{
-		return invertencore;
+		return invertEncore;
 	}
 
-	if (invertencore)
+	if (invertEncore)
 	{
 		return false;
 	}

src/r_defs.h

@@ -307,10 +307,19 @@ typedef struct pslope_s
 
 typedef enum
 {
-	SF_FLIPSPECIAL_FLOOR    =  1,
-	SF_FLIPSPECIAL_CEILING  =  2,
-	SF_FLIPSPECIAL_BOTH     =  3,
-	SF_TRIGGERSPECIAL_TOUCH =  4,
+	// flipspecial - planes with effect
+	SF_FLIPSPECIAL_FLOOR       =  1,
+	SF_FLIPSPECIAL_CEILING     =  1<<1,
+	SF_FLIPSPECIAL_BOTH        =  (SF_FLIPSPECIAL_FLOOR|SF_FLIPSPECIAL_CEILING),
+	// triggerspecial - conditions under which plane touch causes effect
+	SF_TRIGGERSPECIAL_TOUCH    =  1<<2,
+
+	SF_GRAVITYFLIP             =  1<<3,
+	SF_HEATWAVE                =  1<<4,
+	SF_NOCLIPCAMERA            =  1<<5,
+
+	// invert encore color remap status
+	SF_INVERTENCORE            =  1<<6,
 } sectorflags_t;
 
 //
@@ -391,7 +400,6 @@ typedef struct sector_s
 
 	// This points to the master's floorheight, so it can be changed in realtime!
 	fixed_t *gravity; // per-sector gravity
-	boolean verticalflip; // If gravity < 0, then allow flipped physics
 	sectorflags_t flags;
 
 	// Sprite culling feature

src/r_draw.cpp

@@ -94,19 +94,18 @@ spandrawfunc_t *spanfuncs[SPANDRAWFUNC_MAX] = {};
 //                   TRANSLATION COLORMAP CODE
 // =========================================================================
 
-#define DEFAULT_TT_CACHE_INDEX MAXSKINS
-#define BOSS_TT_CACHE_INDEX (MAXSKINS + 1)
-#define METALSONIC_TT_CACHE_INDEX (MAXSKINS + 2)
-#define ALLWHITE_TT_CACHE_INDEX (MAXSKINS + 3)
-#define RAINBOW_TT_CACHE_INDEX (MAXSKINS + 4)
-#define BLINK_TT_CACHE_INDEX (MAXSKINS + 5)
-#define TT_CACHE_SIZE (MAXSKINS + 6)
+#define DEFAULT_TT_CACHE_INDEX 0
+#define BOSS_TT_CACHE_INDEX 1
+#define METALSONIC_TT_CACHE_INDEX 2
+#define ALLWHITE_TT_CACHE_INDEX 3
+#define RAINBOW_TT_CACHE_INDEX 4
+#define BLINK_TT_CACHE_INDEX 5
+#define TT_CACHE_SIZE 6
 #define SKIN_RAMP_LENGTH 16
 #define DEFAULT_STARTTRANSCOLOR 160
 #define NUM_PALETTE_ENTRIES 256
 
-static UINT8 **translationtablecache[TT_CACHE_SIZE] = {};
-static UINT8 **localtranslationtablecache[MAXLOCALSKINS] = {};
+static UINT8 **specialtranslationtablecache[TT_CACHE_SIZE] = {};
 
 CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1] = {};
 
@@ -174,15 +173,10 @@ static void BlendTab_Translucent(UINT8 *table, int style, UINT8 blendamt)
 		{
 			frontrgba = pGammaCorrectedPalette[fg];
 
-#if 0 // perfect implementation
-			result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
-			result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
-			table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
-#else // performance scrabbler
 			result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
 			result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
+
 			table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut_corrected, result.s.red, result.s.green, result.s.blue); // pGammaCorrectedPalette
-#endif
 		}
 	}
 }
@@ -190,6 +184,7 @@ static void BlendTab_Translucent(UINT8 *table, int style, UINT8 blendamt)
 static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
 {
 	INT16 bg, fg;
+	RGBA_t backrgba, frontrgba, result;
 
 	if (table == NULL)
 		I_Error("BlendTab_Subtractive: input table was NULL!");
@@ -202,11 +197,11 @@ static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
 
 	for (bg = 0; bg < 0x100; bg++)
 	{
+		backrgba = pLocalPalette[bg]; // intentionally uses pLocalPalette
+
 		for (fg = 0; fg < 0x100; fg++)
 		{
-			RGBA_t backrgba = V_GetColor(bg);
-			RGBA_t frontrgba = V_GetColor(fg);
-			RGBA_t result;
+			frontrgba = pLocalPalette[fg];
 
 			result.rgba    = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
 			result.s.red   = std::max(0, result.s.red - blendamt);
@@ -221,17 +216,19 @@ static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
 static void BlendTab_Modulative(UINT8 *table)
 {
 	INT16 bg, fg;
+	RGBA_t backrgba, frontrgba, result;
 
 	if (table == NULL)
 		I_Error("BlendTab_Modulative: input table was NULL!");
 
 	for (bg = 0; bg < 0x100; bg++)
 	{
+		backrgba = pGammaCorrectedPalette[bg];
+
 		for (fg = 0; fg < 0x100; fg++)
 		{
-			RGBA_t backrgba = V_GetColor(bg);
-			RGBA_t frontrgba = V_GetColor(fg);
-			RGBA_t result;
+			frontrgba = pGammaCorrectedPalette[fg];
+
 			result.rgba = ASTBlendPixel(backrgba, frontrgba, AST_MODULATE, 0);
 			table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut_corrected, result.s.red, result.s.green, result.s.blue);
 		}
@@ -380,38 +377,60 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 {
 	UINT8 ***tt;
 	UINT8* ret;
-	INT32 skintableindex;
 
 	if (local)
 	{
-		tt = localtranslationtablecache;
-		skintableindex = skinnum;
+		I_Assert(skinnum >= 0 && skinnum < numlocalskins);
+		tt = &localskins[skinnum]->translationtablecache;
 	}
 	else
 	{
-		tt = translationtablecache;
-
 		// Adjust if we want the default colormap
-		switch (skinnum)
+		if (skinnum < 0)
 		{
-			case TC_DEFAULT:    skintableindex = DEFAULT_TT_CACHE_INDEX; break;
-			case TC_BOSS:       skintableindex = BOSS_TT_CACHE_INDEX; break;
-			case TC_METALSONIC: skintableindex = METALSONIC_TT_CACHE_INDEX; break;
-			case TC_ALLWHITE:   skintableindex = ALLWHITE_TT_CACHE_INDEX; break;
-			case TC_RAINBOW:    skintableindex = RAINBOW_TT_CACHE_INDEX; break;
-			case TC_BLINK:      skintableindex = BLINK_TT_CACHE_INDEX; break;
-			default:            skintableindex = skinnum; break;
+			INT32 skintableindex;
+
+			switch (skinnum)
+			{
+				case TC_DEFAULT:
+					skintableindex = DEFAULT_TT_CACHE_INDEX;
+					break;
+				case TC_BOSS:
+					skintableindex = BOSS_TT_CACHE_INDEX;
+					break;
+				case TC_METALSONIC:
+					skintableindex = METALSONIC_TT_CACHE_INDEX;
+					break;
+				case TC_ALLWHITE:
+					skintableindex = ALLWHITE_TT_CACHE_INDEX;
+					break;
+				case TC_RAINBOW:
+					skintableindex = RAINBOW_TT_CACHE_INDEX;
+					break;
+				case TC_BLINK:
+					skintableindex = BLINK_TT_CACHE_INDEX;
+					break;
+				default:
+					return NULL;
+			}
+
+			tt = &specialtranslationtablecache[skintableindex];
+		}
+		else
+		{
+			I_Assert(skinnum >= 0 && skinnum < numskins);
+			tt = &skins[skinnum]->translationtablecache;
 		}
 	}
 
 	if (flags & GTC_CACHE)
 	{
 		// Allocate table for skin if necessary
-		if (!tt[skintableindex])
-			tt[skintableindex] = static_cast<UINT8**>(Z_Calloc(MAXTRANSLATIONS * sizeof(UINT8**), PU_STATIC, NULL));
+		if (!*tt)
+			*tt = static_cast<UINT8**>(Z_Calloc(MAXTRANSLATIONS * sizeof(UINT8**), PU_STATIC, NULL));
 
 		// Get colormap
-		ret = tt[skintableindex][color];
+		ret = (*tt)[color];
 	}
 	else
 		ret = NULL;
@@ -420,11 +439,11 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 	if (!ret)
 	{
 		ret = static_cast<UINT8*>(Z_Malloc(NUM_PALETTE_ENTRIES, PU_STATIC, NULL));
-		K_GenerateKartColormap(ret, skinnum, color, local); //R_GenerateTranslationColormap(ret, skinnum, color);		// SRB2kart
+		K_GenerateKartColormap(ret, skinnum, color, local); // R_GenerateTranslationColormap(ret, skinnum, color);		// SRB2kart
 
 		// Cache the colormap if desired
 		if (flags & GTC_CACHE)
-			tt[skintableindex][color] = ret;
+			(*tt)[color] = ret;
 	}
 
 	return ret;
@@ -437,46 +456,26 @@ UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags)
 
 UINT8* R_GetLocalTranslationColormap(skin_t *skin, skin_t *localskin, skincolors_t color, UINT8 flags, boolean local)
 {
-	return RGetTranslationColormap(K_GetMobjLocalSkinNum(skin, localskin, local), color, flags, (localskin && local));
+	const INT32 skinnum = (INT32)((localskin && local) ? localskin->skinnum : (skin != NULL ? skin->skinnum : 0));
+	return RGetTranslationColormap(skinnum, color, flags, (localskin && local));
 }
 
-patch_t* R_GetSkinFaceRank(player_t* ply)
+patch_t* R_GetSkinFaceRank(player_t* player)
 {
-	if (ply->localskin)
-	{
-		if (ply->skinlocal)
-			return localfacerankprefix[ply->localskin - 1];
-
-		return facerankprefix[ply->localskin - 1];
-	}
-
-	return facerankprefix[ply->skin];
+	const skin_t *skin = R_GetPlayerSkin(player);
+	return skin->facerankprefix;
 }
 
-patch_t* R_GetSkinFaceWant(player_t* ply)
+patch_t* R_GetSkinFaceWant(player_t* player)
 {
-	if (ply->localskin)
-	{
-		if (ply->skinlocal)
-			return localfacewantprefix[ply->localskin - 1];
-
-		return facewantprefix[ply->localskin - 1];
-	}
-
-	return facewantprefix[ply->skin];
+	const skin_t *skin = R_GetPlayerSkin(player);
+	return skin->facewantprefix;
 }
 
-patch_t* R_GetSkinFaceMini(player_t* ply)
+patch_t* R_GetSkinFaceMini(player_t* player)
 {
-	if (ply->localskin)
-	{
-		if (ply->skinlocal)
-			return localfacemmapprefix[ply->localskin - 1];
-
-		return facemmapprefix[ply->localskin - 1];
-	}
-
-	return facemmapprefix[ply->skin];
+	const skin_t *skin = R_GetPlayerSkin(player);
+	return skin->facemmapprefix;
 }
 
 /**	\brief	Flushes cache of translation colormaps.
@@ -495,13 +494,20 @@ void R_FlushTranslationColormapCache(void)
 {
 	INT32 i;
 
-	for (i = 0; i < (INT32)(sizeof(translationtablecache) / sizeof(translationtablecache[0])); i++)
-		if (translationtablecache[i])
-			memset(translationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
+	// skin cache
+	for (i = 0; i < (INT32)numskins; i++)
+		if (skins[i]->translationtablecache)
+			memset(skins[i]->translationtablecache, 0, MAXTRANSLATIONS * sizeof(UINT8**));
 
-	for (i = 0; i < (INT32)(sizeof(localtranslationtablecache) / sizeof(localtranslationtablecache[0])); i++)
-		if (localtranslationtablecache[i])
-			memset(localtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
+	// localskin cache
+	for (i = 0; i < (INT32)numlocalskins; i++)
+		if (localskins[i]->translationtablecache)
+			memset(localskins[i]->translationtablecache, 0, MAXTRANSLATIONS * sizeof(UINT8**));
+
+	// special cache
+	for (i = 0; i < (INT32)(sizeof(specialtranslationtablecache) / sizeof(specialtranslationtablecache[0])); i++)
+		if (specialtranslationtablecache[i])
+			memset(specialtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
 }
 */
 

src/r_draw_flush.cpp

@@ -6,7 +6,7 @@
 // Copyright (C) 1996 by id Software, Inc.
 // Copyright (C) 1999 by Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
 // Copyright (C) 1999-2000 by Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
-// Copyright (C) Copyright 2005, 2006 by Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
+// Copyright (C) 2005, 2006 by Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
 // Copyright (C) 2013 by James Haley, Stephen McGranahan, et al.
 //
 // This program is free software distributed under the

src/r_main.cpp

@@ -389,7 +389,7 @@ angle_t R_PlayerSliptideAngle(player_t *player)
 
 	if (mo->skin && mo->sprite == SPR_PLAY)
 	{
-		sprdef = &((skin_t *)mo->skin)->spritedef;
+		sprdef = &mo->skin->spritedef;
 
 		if (rot >= sprdef->numframes)
 			sprdef = &sprites[mo->sprite];

src/r_patch.cpp

@@ -129,8 +129,8 @@ static void R_ParseSpriteInfo(boolean spr2)
 	spritenum_t sprnum = NUMSPRITES;
 	//playersprite_t spr2num = NUMPLAYERSPRITES;
 	INT32 i;
-	INT32 skinnumbers[MAXSKINS]; // >variable 'skinnumbers' set but not used >compile error when commented out
 	INT32 foundskins = 0;
+	CLEANUP(pfree) INT32 *skinnumbers = (INT32 *)calloc(1, numallskins); // could realloc this for foundskins but this is simpler
 
 	// Sprite name
 	sprinfoToken = M_GetToken(NULL);
@@ -236,10 +236,10 @@ static void R_ParseSpriteInfo(boolean spr2)
 					{
 						size_t skinnum = skinnumbers[i];
 						skin_t *skin;
-						if (allskins[skinnum].localskin)
-							skin = &localskins[allskins[skinnum].localnum];
+						if (allskins[skinnum]->localskin)
+							skin = localskins[allskins[skinnum]->skinnum];
 						else
-							skin = &skins[allskins[skinnum].localnum];
+							skin = skins[allskins[skinnum]->skinnum];
 						memcpy(&skin->sprinfo, info, sizeof(spriteinfo_t));
 					}
 				}

src/r_segs.cpp

@@ -61,7 +61,6 @@ fixed_t rw_distance = 0;
 static INT32 rw_x, rw_stopx;
 static angle_t rw_centerangle;
 static fixed_t rw_offset;
-static fixed_t rw_offset2; // for splats
 static fixed_t rw_scale, rw_scalestep;
 static fixed_t rw_midtexturemid, rw_toptexturemid, rw_bottomtexturemid;
 static INT32 worldtop, worldbottom, worldhigh, worldlow;
@@ -264,12 +263,7 @@ static void R_RenderMaskedSegLoop(drawcolumndata_t* dc, drawseg_t *drawseg, INT3
 		else if (P_ApplyLightOffset(lightnum, frontsector))
 			lightnum += curline->lightOffset;
 
-		if (lightnum < 0)
-			walllights = scalelight[0];
-		else if (lightnum >= LIGHTLEVELS)
-			walllights = scalelight[LIGHTLEVELS - 1];
-		else
-			walllights = scalelight[lightnum];
+		walllights = R_GetWallLight(lightnum);
 	}
 
 	if (frontsector->heightsec != -1)
@@ -371,12 +365,7 @@ static void R_RenderMaskedSegLoop(drawcolumndata_t* dc, drawseg_t *drawseg, INT3
 
 					lightnum = rlight->lightnum;
 
-					if (lightnum < 0)
-						xwalllights = scalelight[0];
-					else if (lightnum >= LIGHTLEVELS)
-						xwalllights = scalelight[LIGHTLEVELS-1];
-					else
-						xwalllights = scalelight[lightnum];
+					xwalllights = R_GetWallLight(lightnum);
 
 					pindex = FixedMul(spryscale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
 
@@ -824,12 +813,7 @@ void R_RenderThickSideRange(drawseg_t *drawseg, INT32 x1, INT32 x2, ffloor_t *pf
 		else if (P_ApplyLightOffset(lightnum, frontsector))
 			lightnum += curline->lightOffset;
 
-		if (lightnum < 0)
-			walllights = scalelight[0];
-		else if (lightnum >= LIGHTLEVELS)
-			walllights = scalelight[LIGHTLEVELS-1];
-		else
-			walllights = scalelight[lightnum];
+		walllights = R_GetWallLight(lightnum);
 	}
 
 	maskedtexturecol = drawseg->thicksidecol;
@@ -971,12 +955,7 @@ void R_RenderThickSideRange(drawseg_t *drawseg, INT32 x1, INT32 x2, ffloor_t *pf
 
 				lightnum = rlight->lightnum;
 
-				if (lightnum < 0)
-					xwalllights = scalelight[0];
-				else if (lightnum >= LIGHTLEVELS)
-					xwalllights = scalelight[LIGHTLEVELS-1];
-				else
-					xwalllights = scalelight[lightnum];
+				xwalllights = R_GetWallLight(lightnum);
 
 				pindex = FixedMul(spryscale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
 
@@ -1467,12 +1446,7 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
 				else if (P_ApplyLightOffset(lightnum, curline->frontsector))
 					lightnum += curline->lightOffset;
 
-				if (lightnum < 0)
-					xwalllights = scalelight[0];
-				else if (lightnum >= LIGHTLEVELS)
-					xwalllights = scalelight[LIGHTLEVELS-1];
-				else
-					xwalllights = scalelight[lightnum];
+				xwalllights = R_GetWallLight(lightnum);
 
 				pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
 
@@ -2551,7 +2525,6 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 			rw_offset = -rw_offset;
 
 		/// don't use texture offset for splats
-		rw_offset2 = rw_offset + curline->offset;
 		rw_offset += sidedef->textureoffset + curline->offset;
 		rw_centerangle = ANGLE_90 + viewangle - rw_normalangle;
 
@@ -2564,12 +2537,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 		if (P_ApplyLightOffset(lightnum, frontsector))
 			lightnum += curline->lightOffset;
 
-		if (lightnum < 0)
-			walllights = scalelight[0];
-		else if (lightnum >= LIGHTLEVELS)
-			walllights = scalelight[LIGHTLEVELS - 1];
-		else
-			walllights = scalelight[lightnum];
+		walllights = R_GetWallLight(lightnum);
 	}
 
 	// if a floor / ceiling plane is on the wrong side

src/r_segs.h

@@ -22,6 +22,11 @@ extern "C" {
 #pragma interface
 #endif
 
+FUNCINLINE static ATTRINLINE lighttable_t** R_GetWallLight(INT32 llevel)
+{
+	return scalelight[CLAMP(llevel, 0, LIGHTLEVELS-1)];
+}
+
 void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2);
 void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pffloor);
 void R_StoreWallRange(INT32 start, INT32 stop);

src/r_skins.c

@@ -40,7 +40,9 @@ CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2] = {}; // huehuehuehuehue
 INT32 numskins = 0;
 INT32 numallskins = 0;
 INT32 numlocalskins = 0;
-skin_t skins[MAXSKINS];
+skin_t **skins = NULL;
+skin_t **localskins = NULL;
+skin_t **allskins = NULL;
 
 skinnum_t skinstats[9][9][MAXSKINS];
 skinnum_t skinstatscount[9][9] = {
@@ -56,17 +58,8 @@ skinnum_t skinstatscount[9][9] = {
 };
 
 skinnum_t skinsorted[MAXSKINS] = {};
-skin_t localskins[MAXLOCALSKINS] = {};
-skin_t allskins[MAXSKINS+MAXLOCALSKINS] = {};
 
-// FIXTHIS: don't work because it must be inistilised before the config load
-//#define SKINVALUES
-#ifdef SKINVALUES
-CV_PossibleValue_t skin_cons_t[MAXSKINS+1] = {};
-CV_PossibleValue_t localskin_cons_t[MAXLOCALSKINS+1] = {};
-#endif
-
-static void Sk_SetDefaultValue(skin_t *skin, boolean local)
+static void Sk_SetDefaultValue(skin_t *skin)
 {
 	INT32 i;
 	//
@@ -74,7 +67,7 @@ static void Sk_SetDefaultValue(skin_t *skin, boolean local)
 	//
 	memset(skin, 0, sizeof(skin_t));
 
-	snprintf(skin->name, sizeof skin->name, "skin %u", K_GetMobjSkinNum(skin, local));
+	snprintf(skin->name, sizeof skin->name, "skin %u", skin->skinnum); // this will always be "skin 0" cause of the memset above lmao
 	skin->name[sizeof skin->name - 1] = '\0';
 
 	skin->wadnum = INT16_MAX;
@@ -112,35 +105,22 @@ static void Sk_SetDefaultValue(skin_t *skin, boolean local)
 void R_InitSkins(void)
 {
 	skin_t *skin;
-#ifdef SKINVALUES
-	INT32 i;
 
-	for (i = 0; i <= MAXSKINS; i++)
-	{
-		skin_cons_t[i].value = 0;
-		skin_cons_t[i].strvalue = NULL;
-	}
-	for (i = 0; i <= MAXLOCALSKINS; i++)
-	{
-		localskin_cons_t[i].value = 0;
-		localskin_cons_t[i].strvalue = NULL;
-	}
-#endif
+	skins = Z_Calloc(sizeof(skin_t *), PU_STATIC, NULL);
+	//localskins = Z_Calloc(sizeof(skin_t *), PU_STATIC, NULL);
+	allskins = Z_Calloc(sizeof(skin_t *), PU_STATIC, NULL);
 
 	// skin[0] = Sonic skin
-	skin = &skins[0];
-	numskins = 1;
-	Sk_SetDefaultValue(skin, false);
+	skin = skins[0] = Z_Calloc(sizeof(skin_t), PU_STATIC, NULL);
+
+	Sk_SetDefaultValue(skin);
+	skin->skinnum = 0;
 
 	memset(skinstats, 0, sizeof(skinstats));
 	memset(skinsorted, 0, sizeof(skinsorted));
 
 	// Hardcoded S_SKIN customizations for Sonic.
 	strcpy(skin->name,       DEFAULTSKIN);
-#ifdef SKINVALUES
-	skin_cons_t[0].strvalue = skins[0].name;
-#endif
-
 	strcpy(skin->realname,   "Sonic");
 	strcpy(skin->hudname,    "SONIC");
 
@@ -153,7 +133,6 @@ void R_InitSkins(void)
 	skin->wadnum = 0; // god what have you brought to this world
 	skin->prefcolor = SKINCOLOR_BLUE;
 	skin->localskin = false;
-	skin->localnum = 0;
 
 	// SRB2kart
 	skin->kartspeed = 8;
@@ -163,7 +142,7 @@ void R_InitSkins(void)
 	skin->spritedef.numframes = sprites[SPR_PLAY].numframes;
 	skin->spritedef.spriteframes = sprites[SPR_PLAY].spriteframes;
 	skin->sprinfo = spriteinfo[SPR_PLAY];
-	ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, 0);
+	ST_LoadFaceGraphics(skin);
 
 	// Set values for Sonic skin
 	Forceskin_cons_t[1].value = 0;
@@ -177,6 +156,8 @@ void R_InitSkins(void)
 
 	// lets set it
 	allskins[0] = skins[0];
+
+	numskins = 1;
 	numallskins = 1;
 }
 
@@ -188,7 +169,7 @@ INT32 R_SkinAvailable(const char *name)
 
 	for (i = 0; i < numskins; i++)
 	{
-		if (fasticmp(skins[i].name, name))
+		if (fasticmp(skins[i]->name, name))
 			return i;
 	}
 
@@ -203,7 +184,7 @@ INT32 R_AnySkinAvailable(const char *name)
 
 	for (i = 0; i < numallskins; i++)
 	{
-		if (fasticmp(allskins[i].name, name))
+		if (fasticmp(allskins[i]->name, name))
 			return i;
 	}
 
@@ -218,7 +199,7 @@ INT32 R_LocalSkinAvailable(const char *name, boolean local)
 	{
 		for (i = 0; i < numlocalskins; i++)
 		{
-			if (fasticmp(localskins[i].name, name))
+			if (fasticmp(localskins[i]->name, name))
 				return i;
 		}
 
@@ -236,7 +217,7 @@ boolean SetPlayerSkin(INT32 playernum, const char *skinname)
 	for (i = 0; i < numskins; i++)
 	{
 		// search in the skin list
-		if (fasticmp(skins[i].name, skinname))
+		if (fasticmp(skins[i]->name, skinname))
 		{
 			SetPlayerSkinByNum(playernum, i);
 			return true;
@@ -262,14 +243,14 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
 		for (i = 0; i < numlocalskins; i++)
 		{
 			// search in the localskin list
-			if (fasticmp(localskins[i].name, skinname))
+			if (fasticmp(localskins[i]->name, skinname))
 			{
 				player->localskin = 1 + i;
 				player->skinlocal = true;
 
 				if (player->mo)
 				{
-					player->mo->localskin = &localskins[i];
+					player->mo->localskin = localskins[i];
 					player->mo->skinlocal = true;
 				}
 
@@ -280,14 +261,14 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
 		for (i = 0; i < numskins; i++)
 		{
 			// search in the skin list
-			if (fasticmp(skins[i].name, skinname))
+			if (fasticmp(skins[i]->name, skinname))
 			{
 				player->localskin = 1 + i;
 				player->skinlocal = false;
 
 				if (player->mo)
 				{
-					player->mo->localskin = &skins[i];
+					player->mo->localskin = skins[i];
 					player->mo->skinlocal = false;
 				}
 
@@ -312,9 +293,9 @@ setcvar:
 	{
 		if (player->localskin > 0)
 		{
-			CV_StealthSet(&cv_fakelocalskin, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
-			CV_StealthSet(cvar, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
-
+			skin_t *lskin = R_GetSkinArray(player->skinlocal)[player->localskin-1];
+			CV_StealthSet(&cv_fakelocalskin, lskin->name);
+			CV_StealthSet(cvar, lskin->name);
 		}
 		else
 		{
@@ -329,10 +310,12 @@ setcvar:
 void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
 {
 	player_t *player = &players[playernum];
-	skin_t *skin = &skins[skinnum];
+	skin_t *skin;
 
 	if (skinnum >= 0 && skinnum < numskins) // Make sure it exists!
 	{
+		skin = skins[skinnum];
+
 		player->skin = skinnum;
 
 		if (player->mo)
@@ -400,8 +383,8 @@ static int skinSortFunc(const void *a, const void *b) // tbh i have no clue what
 	int diff = 0;
 	const skinnum_t val_a = *(const skinnum_t *)a;
 	const skinnum_t val_b = *(const skinnum_t *)b;
-	const skin_t *in1 = &skins[val_a];
-	const skin_t *in2 = &skins[val_b];
+	const skin_t *in1 = skins[val_a];
+	const skin_t *in2 = skins[val_b];
 
 	// return (strcmp(in1->realname, in2->realname) < 0) || (strcmp(in1->realname, in2->realname) ==);
 
@@ -488,7 +471,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 	char *stoken;
 	char *value;
 	size_t size;
-	skin_t *skin;
+	skin_t *skin = NULL;
 	boolean hudname, realname;
 
 #define lnumskins (local ? numlocalskins : numskins)
@@ -502,16 +485,18 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		// advance by default
 		lastlump = lump + 1;
 
+		// gotta keep this for vanilla compat reasons
 		if (!local && numskins >= MAXSKINS)
 		{
 			CONS_Alert(CONS_WARNING, M_GetText("Unable to add skin, too many characters are loaded (%d maximum)\n"), MAXSKINS);
 			continue; // so we know how many skins couldn't be added
 		}
-		if (local && numlocalskins >= MAXLOCALSKINS)
+
+		/* if (local && numlocalskins >= MAXLOCALSKINS)
 		{
 			CONS_Alert(CONS_WARNING, M_GetText("Unable to add localskin, too many localskins are loaded (%d maximum)\n"), MAXLOCALSKINS);
 			continue; // so we know how many skins couldn't be added
-		}
+		} */
 
 		buf = W_CacheLumpNumPwad(wadnum, lump, PU_CACHE);
 		size = W_LumpLengthPwad(wadnum, lump);
@@ -524,8 +509,19 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		buf2[size] = '\0';
 
 		// set defaults
-		skin = &K_GetSkinArray(local)[lnumskins];
-		Sk_SetDefaultValue(skin, local);
+		if (!local)
+		{
+			skins = Z_Realloc(skins, sizeof(skin_t *) * (numskins + 1), PU_STATIC, NULL);
+		}
+		else
+		{
+			localskins = Z_Realloc(localskins, sizeof(skin_t *) * (numlocalskins + 1), PU_STATIC, NULL);
+		}
+
+		skin = R_GetSkinArray(local)[lnumskins] = Z_Calloc(sizeof(skin_t), PU_STATIC, NULL);
+		Sk_SetDefaultValue(skin);
+		skin->skinnum = lnumskins;
+		skin->allskinnum = numallskins;
 		skin->wadnum = wadnum;
 		hudname = realname = false;
 
@@ -777,24 +773,19 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		//R_FlushTranslationColormapCache();
 
 		CONS_Printf(M_GetText("Added skin '%s'\n"), skin->name);
-#ifdef SKINVALUES
-		(local ? localskin_cons_t : skin_cons_t)[lnumskins].value = lnumskins;
-		(local ? localskin_cons_t : skin_cons_t)[lnumskins].strvalue = skin->name;
-#endif
+
 		if (!local)
 		{
 			// Update the forceskin possiblevalues
 			Forceskin_cons_t[numskins+1].value = numskins;
-			Forceskin_cons_t[numskins+1].strvalue = skins[numskins].name;
+			Forceskin_cons_t[numskins+1].strvalue = skins[numskins]->name;
 			skin->localskin = false;
-			skin->localnum = numskins;
-			ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numskins);
+			ST_LoadFaceGraphics(skin);
 		}
 		else
 		{
 			skin->localskin = true;
-			skin->localnum = numlocalskins;
-			ST_LoadLocalFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numlocalskins);
+			ST_LoadFaceGraphics(skin);
 		}
 
 #ifdef HWRENDER
@@ -810,7 +801,8 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 			skinsorted[numskins] = numskins;
 		}
 
-		allskins[numallskins] = K_GetSkinArray(local)[lnumskins];
+		allskins = Z_Realloc(allskins, sizeof(skin_t*) * (numallskins + 1), PU_STATIC, NULL);
+		allskins[numallskins] = R_GetSkinArray(local)[lnumskins];
 
 		local ? numlocalskins++ : numskins++;
 		numallskins++;
@@ -820,3 +812,50 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 
 	return;
 }
+
+// Helper functions for skin stuff
+
+//
+// returns the skin array to use
+// accounts for localskins
+//
+skin_t **R_GetSkinArray(boolean local)
+{
+	return local ? localskins : skins;
+}
+
+//
+// returns the players skinnumber
+// accounts for localskins
+//
+INT32 R_GetPlayerSkinNum(player_t *player)
+{
+	return player->localskin ? (player->localskin - 1) : player->skin;
+}
+
+//
+// returns the players skin
+// accounts for localskins
+//
+skin_t *R_GetPlayerSkin(player_t *player)
+{
+	return R_GetSkinArray(player->skinlocal)[R_GetPlayerSkinNum(player)];
+}
+
+//
+// returns the mobj skinnumber
+// accounts for localskins
+//
+INT32 R_GetMobjSkinNum(const mobj_t *mobj)
+{
+	return mobj->localskin ? mobj->localskin->skinnum : mobj->skin->skinnum;
+}
+
+//
+// returns the mobjs skin
+// accounts for localskins
+//
+skin_t *R_GetMobjSkin(const mobj_t *mobj)
+{
+	return mobj->localskin ? mobj->localskin : mobj->skin;
+}

src/r_skins.h

@@ -16,6 +16,7 @@
 #ifndef __R_SKINS__
 #define __R_SKINS__
 
+#include "doomtype.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -24,6 +25,10 @@ extern "C" {
 #include "sounds.h"
 #include "r_patch.h"
 
+#ifdef HWRENDER
+#include "hardware/hw_md2.h"
+#endif
+
 // "Left" and "Right" character symbols for additional rotation functionality
 #define ROT_L ('L' - '0')
 #define ROT_R ('R' - '0')
@@ -35,7 +40,7 @@ extern "C" {
 #define DEFAULTSKIN3 "knuckles" // third player
 #define DEFAULTSKIN4 "eggman" // fourth player
 
-typedef struct
+typedef struct skin_s
 {
 	char name[SKINNAMESIZE+1]; // INT16 descriptive name of the skin
 	spritedef_t spritedef;
@@ -48,12 +53,17 @@ typedef struct
 	char hudname[SKINNAMESIZE+1]; // HUD name to display (officially exactly 5 characters long)
 	char facerank[9], facewant[9], facemmap[9]; // Arbitrarily named patch lumps
 
+	patch_t *facerankprefix; // ranking
+	patch_t *facewantprefix; // wanted
+	patch_t *facemmapprefix; // minimap
+
 	// SRB2kart
 	UINT8 kartspeed;
 	UINT8 kartweight;
 	//
 
 	// Definable color translation table
+	UINT8 **translationtablecache;
 	UINT8 starttranscolor;
 	UINT8 prefcolor;
 	fixed_t highresscale; // scale of highres, default is 0.5
@@ -61,8 +71,13 @@ typedef struct
 	// specific sounds per skin
 	sfxenum_t soundsid[NUMSKINSOUNDS]; // sound # in S_sfx table
 
+#ifdef HWRENDER
+	md2_t playermodel;
+#endif
+
 	boolean localskin;
-	INT32 localnum;
+	skinnum_t skinnum;
+	UINT16 allskinnum;
 } skin_t;
 
 extern CV_PossibleValue_t Forceskin_cons_t[];
@@ -70,14 +85,14 @@ extern CV_PossibleValue_t Forceskin_cons_t[];
 extern INT32 numskins;
 extern INT32 numlocalskins;
 extern INT32 numallskins;
-extern skin_t skins[MAXSKINS];
+extern skin_t **skins;
+extern skin_t **localskins;
+extern skin_t **allskins;
+
 extern skinnum_t skinstats[9][9][MAXSKINS];
 extern skinnum_t skinstatscount[9][9];
 extern skinnum_t skinsorted[MAXSKINS];
 
-extern skin_t localskins[MAXLOCALSKINS];
-extern skin_t allskins[MAXSKINS+MAXLOCALSKINS];
-
 //faB: find sprites in wadfile, replace existing, add new ones
 //     (only sprites from namelist are added or replaced)
 void R_AddSpriteDefs(UINT16 wadnum);
@@ -90,13 +105,11 @@ INT32 R_AnySkinAvailable(const char *name);
 INT32 R_LocalSkinAvailable(const char *name, boolean local);
 
 // had to move those here Zzz...
-INT32 K_GetSkinNum(player_t *player);
-INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local);
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local);
-skin_t *K_GetPlayerSkin(player_t *player);
-skin_t *K_GetMobjSkin(const mobj_t *mobj);
-patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);
-skin_t *K_GetSkinArray(boolean local);
+skin_t **R_GetSkinArray(boolean local);
+skin_t *R_GetPlayerSkin(player_t *player);
+INT32 R_GetPlayerSkinNum(player_t *player);
+INT32 R_GetMobjSkinNum(const mobj_t *mobj);
+skin_t *R_GetMobjSkin(const mobj_t *mobj);
 
 void sortSkinGrid(void);
 

src/r_things.cpp

@@ -1062,12 +1062,7 @@ static void R_SplitSprite(vissprite_t *sprite)
 		{
 			INT32 lightnum = R_GetSoftLightlevel(*sector->lightlist[i].lightlevel);
 
-			if (lightnum < 0)
-				spritelights = scalelight[0];
-			else if (lightnum >= LIGHTLEVELS)
-				spritelights = scalelight[LIGHTLEVELS-1];
-			else
-				spritelights = scalelight[lightnum];
+			spritelights = R_GetWallLight(lightnum);
 
 			newsprite->extra_colormap = sector->lightlist[i].extra_colormap;
 
@@ -1281,7 +1276,7 @@ static void R_ProjectSprite(mobj_t *thing)
 	const boolean shouldrotate = (interp.sloperoll || interp.slopepitch || interp.roll || interp.pitch || thing->rollangle || thing->temprollangle || sliprollrotate);
 #endif
 
-	sprskin = K_GetMobjSkin(thing);
+	sprskin = R_GetMobjSkin(thing);
 
 	//Fab : 02-08-98: 'skin' override spritedef currently used for skin
 	if (sprskin && thing->sprite == SPR_PLAY)
@@ -1745,12 +1740,7 @@ static void R_ProjectSprite(mobj_t *thing)
 			}
 		}
 
-		if (lightnum < 0)
-			lights_array = scalelight[0];
-		else if (lightnum >= LIGHTLEVELS)
-			lights_array = scalelight[LIGHTLEVELS-1];
-		else
-			lights_array = scalelight[lightnum];
+		lights_array = R_GetWallLight(lightnum);
 	}
 
 	// store information in a vissprite
@@ -2087,16 +2077,11 @@ void R_AddSprites(sector_t *sec, INT32 lightlevel)
 
 	if (!sec->numlights)
 	{
-		if (sec->heightsec == -1) lightlevel = sec->lightlevel;
+		if (sec->heightsec == -1)
+			lightlevel = sec->lightlevel;
 
 		lightnum = R_GetSoftLightlevel(lightlevel);
-
-		if (lightnum < 0)
-			spritelights = scalelight[0];
-		else if (lightnum >= LIGHTLEVELS)
-			spritelights = scalelight[LIGHTLEVELS-1];
-		else
-			spritelights = scalelight[lightnum];
+		spritelights = R_GetWallLight(lightnum);
 	}
 
 	// Handle all things in sector.

src/s_sound.c

@@ -529,7 +529,7 @@ void S_StartSoundAtVolume(const void *origin_p, sfxenum_t sfx_id, INT32 volume)
 	if (sfx->skinsound != -1 && origin && origin->skin)
 	{
 		// redirect player sound to the sound in the skin table
-		sfx_id = K_GetMobjSkin(origin)->soundsid[sfx->skinsound];
+		sfx_id = R_GetMobjSkin(origin)->soundsid[sfx->skinsound];
 		sfx = &S_sfx[sfx_id];
 	}
 

src/sdl/i_system.cpp

@@ -1021,6 +1021,8 @@ void I_InitJoystick(UINT8 index)
 		}
 	}
 
+#if 0 // no dont do this
+	// reset everything just in case
 	JoyInfo[index].dev = NULL;
 	JoyInfo[index].oldjoy = -1;
 #if (SDL_VERSION_ATLEAST(2,32,4))
@@ -1028,6 +1030,7 @@ void I_InitJoystick(UINT8 index)
 #endif
 	JoyInfo[index].hasled = false;
 	JoyInfo[index].hasrumble = false;
+#endif
 
 	if (cv_usejoystick[index].value)
 		newcontroller = SDL_GameControllerOpen(cv_usejoystick[index].value-1);

src/st_stuff.c

@@ -60,22 +60,6 @@ tic_t directortoggletimer = 0;
 // STATUS BAR DATA
 //
 
-patch_t *facerankprefix[MAXSKINS] = {}; // ranking
-patch_t *facewantprefix[MAXSKINS] = {}; // wanted
-patch_t *facemmapprefix[MAXSKINS] = {}; // minimap
-
-patch_t *localfacerankprefix[MAXLOCALSKINS] = {}; // ranking
-patch_t *localfacewantprefix[MAXLOCALSKINS] = {}; // wanted
-patch_t *localfacemmapprefix[MAXLOCALSKINS] = {}; // minimap
-
-/*char *facerankprefix_name[MAXSKINS]; // ranking
-char *facewantprefix_name[MAXSKINS]; // wanted
-char *facemmapprefix_name[MAXSKINS]; // minimap
-
-char *localfacerankprefix_name[MAXLOCALSKINS]; // ranking
-char *localfacewantprefix_name[MAXLOCALSKINS]; // wanted
-char *localfacemmapprefix_name[MAXLOCALSKINS]; // minimap*/
-
 // ------------------------------------------
 //             status bar overlay
 // ------------------------------------------
@@ -243,30 +227,11 @@ void ST_LoadGraphics(void)
 }
 
 // made separate so that skins code can reload custom face graphics
-void ST_LoadFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 skinnum)
+void ST_LoadFaceGraphics(skin_t *skin)
 {
-	facerankprefix[skinnum] = W_CachePatchName(rankstr, PU_HUDGFX);
-	facewantprefix[skinnum] = W_CachePatchName(wantstr, PU_HUDGFX);
-	facemmapprefix[skinnum] = W_CachePatchName(mmapstr, PU_HUDGFX);
-
-	/*facerankprefix_name[skinnum] = rankstr;
-	facewantprefix_name[skinnum] = wantstr;
-	facemmapprefix_name[skinnum] = mmapstr;*/
-}
-
-void ST_LoadLocalFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 skinnum)
-{
-	localfacerankprefix[skinnum] = W_CachePatchName(rankstr, PU_HUDGFX);
-	localfacewantprefix[skinnum] = W_CachePatchName(wantstr, PU_HUDGFX);
-	localfacemmapprefix[skinnum] = W_CachePatchName(mmapstr, PU_HUDGFX);
-
-	/*localfacerankprefix_name[skinnum] = rankstr;
-	localfacewantprefix_name[skinnum] = wantstr;
-	localfacemmapprefix_name[skinnum] = mmapstr;*/
-
-	//CONS_Printf("Added rank prefix %s\n", rankstr);
-	//CONS_Printf("Added want prefix %s\n", wantstr);
-	//CONS_Printf("Added mmap prefix %s\n", mmapstr);
+	skin->facerankprefix = W_CachePatchName(skin->facerank, PU_HUDGFX);
+	skin->facewantprefix = W_CachePatchName(skin->facewant, PU_HUDGFX);
+	skin->facemmapprefix = W_CachePatchName(skin->facemmap, PU_HUDGFX);
 }
 
 void ST_ReloadSkinFaceGraphics(void)
@@ -274,10 +239,10 @@ void ST_ReloadSkinFaceGraphics(void)
 	INT32 i;
 
 	for (i = 0; i < numskins; i++)
-		ST_LoadFaceGraphics(skins[i].facerank, skins[i].facewant, skins[i].facemmap, i);
+		ST_LoadFaceGraphics(skins[i]);
 
 	for (i = 0; i < numlocalskins; i++)
-		ST_LoadLocalFaceGraphics(localskins[i].facerank, localskins[i].facewant, localskins[i].facemmap, i);
+		ST_LoadFaceGraphics(localskins[i]);
 }
 
 static inline void ST_InitData(void)
@@ -410,7 +375,7 @@ static void ST_drawDebugInfo(void)
 	}
 
 	if (cv_debug & DBG_MEMORY)
-		V_DrawRightAlignedString(320, height,     V_MONOSPACE, va("Heap used: %7sKB", sizeu1(Z_TagsUsage(0, INT32_MAX)>>10)));
+		V_DrawRightAlignedString(320, height,     V_MONOSPACE, va("Heap used: %7sKB", sizeu1(Z_TotalUsage()>>10)));
 }
 
 static void ST_drawLevelTitle(void)
@@ -568,7 +533,7 @@ static void ST_overlayDrawer(void)
 		{
 			if (!(multiplayer && demo.playback))
 			{
-				if(!P_IsLocalPlayer(stplyr))
+				if (!P_IsLocalPlayer(stplyr))
 				{
 					/*char name[MAXPLAYERNAME+1];
 					// shorten the name if its more than twelve characters.

src/st_stuff.h

@@ -58,8 +58,7 @@ void ST_UnloadGraphics(void);
 void ST_LoadGraphics(void);
 
 // face load graphics, called when skin changes
-void ST_LoadFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 playernum);
-void ST_LoadLocalFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 playernum);
+void ST_LoadFaceGraphics(skin_t *skin);
 void ST_ReloadSkinFaceGraphics(void);
 
 // return if player a is in the same team as player b
@@ -76,14 +75,6 @@ extern UINT8 stplyrnum;
 
 extern lumpnum_t st_borderpatchnum;
 
-// patches, also used in intermission
-extern patch_t *facerankprefix[MAXSKINS]; // ranking
-extern patch_t *facewantprefix[MAXSKINS]; // wanted
-extern patch_t *facemmapprefix[MAXSKINS]; // minimap
-extern patch_t *localfacerankprefix[MAXLOCALSKINS]; // ranking
-extern patch_t *localfacewantprefix[MAXLOCALSKINS]; // wanted
-extern patch_t *localfacemmapprefix[MAXLOCALSKINS]; // minimap
-
 /** HUD location information (don't move this comment)
   */
 typedef struct

src/v_video.c

@@ -1261,11 +1261,11 @@ void V_DrawCroppedPatch(fixed_t x, fixed_t y, fixed_t pscale, INT32 scrn, patch_
 //
 void V_DrawContinueIcon(INT32 x, INT32 y, INT32 flags, INT32 skinnum, UINT8 skincolor)
 {
-	if (skinnum < 0 || skinnum >= numskins || (skins[skinnum].flags & SF_HIRES))
+	if (skinnum < 0 || skinnum >= numskins || (skins[skinnum]->flags & SF_HIRES))
 		V_DrawScaledPatch(x - 10, y - 14, flags, W_CachePatchName("CONTINS", PU_PATCH)); // Draw a star
 	else
 	{ // Find front angle of the first waiting frame of the character's actual sprites
-		spriteframe_t *sprframe = &skins[skinnum].spritedef.spriteframes[2 & FF_FRAMEMASK];
+		spriteframe_t *sprframe = &skins[skinnum]->spritedef.spriteframes[2 & FF_FRAMEMASK];
 		patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
 		const UINT8 *colormap = R_GetTranslationColormap(skinnum, skincolor, GTC_CACHE);
 

src/w_wad.c

@@ -396,6 +396,11 @@ FUNCINLINE static ATTRINLINE UINT32 W_HashLumpName(const char *name)
 	return FNV1a_HashLowercaseString(name);
 }
 
+FUNCINLINE static ATTRINLINE UINT32 W_HashLumpNameLen(const char *name, size_t len)
+{
+	return FNV1a_QuickCaseHash(name, len);
+}
+
 /** Detect a file type.
  * \todo Actually detect the wad/pkzip headers and whatnot, instead of just checking the extensions.
  */
@@ -1095,18 +1100,14 @@ const char *W_CheckNameForNum(lumpnum_t lumpnum)
 UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 i;
-	static char uname[8 + 1];
 	UINT32 hash;
 	size_t namelen;
 
 	if (!TestValidLump(wad, 0))
 		return INT16_MAX;
 
-	memset(uname, 0, sizeof(uname));
-	strncpy(uname, name, sizeof(uname)-1);
-	strupr(uname);
-	namelen = strlen(uname);
-	hash = W_HashLumpName(uname);
+	namelen = strnlen(name, 8); // :chaosleep:
+	hash = W_HashLumpNameLen(name, namelen);
 
 	//
 	// scan forward
@@ -1121,7 +1122,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 		{
 			if (lump_p->namelength == namelen
 				&& lump_p->hash.name == hash
-				&& !memcmp(lump_p->name, uname, sizeof(uname) - 1))
+				&& !strncasecmp(lump_p->name, name, namelen))
 				return i;
 		}
 	}

src/y_inter.c

@@ -256,6 +256,7 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
 		}
 
 		if (demo.recording && !rankingsmode)
+		{
 			G_WriteStanding(
 				data.pos[data.numplayers],
 				data.name[data.numplayers],
@@ -263,6 +264,7 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
 				*data.color[data.numplayers],
 				data.val[data.numplayers]
 			);
+		}
 
 		data.numplayers++;
 	}
@@ -1188,8 +1190,7 @@ void Y_VoteDrawer(void)
 			if (player->skincolor)
 			{
 				UINT8 *colormap = R_GetTranslationColormap(player->skin, player->skincolor, GTC_CACHE);
-
-				patch_t *faceprefix = K_GetFacePrefix(player, K_GetSkinNum(player));
+				patch_t *faceprefix = K_GetFacePrefix(player, R_GetPlayerSkinNum(player));
 
 				if (K_UseHighResPortraits())
 					V_DrawSmallMappedPatch(x+24, y+9, V_SNAPTOLEFT, faceprefix, colormap);

src/z_zone.cpp

@@ -75,7 +75,7 @@ typedef struct memblock_s
 #define MEMBLOCK(x) (memblock_t *)((uintptr_t)(x) - ALIGNPAD - sizeof(memblock_t))
 
 // both the head and tail of the zone memory block list
-static memblock_t head;
+static memblock_t headlist[NUM_PURGETAGS];
 
 static constexpr size_t kLevelLargePoolBlockSize = sizeof(mobj_t);
 static constexpr size_t kLevelMedPoolBlockSize = sizeof(precipmobj_t);
@@ -107,10 +107,14 @@ static void Command_Memdump_f(void);
 void Z_Init(void)
 {
 	size_t total, memfree;
+	size_t i;
 
-	memset(&head, 0x00, sizeof(head));
+	memset(&headlist, 0x00, sizeof(headlist));
 
-	head.next = head.prev = &head;
+	for (i = 0; i < NUM_PURGETAGS; i++)
+	{
+		headlist[i].next = headlist[i].prev = &headlist[i];
+	}
 
 	memfree = I_GetFreeMem(&total)>>20;
 
@@ -204,7 +208,7 @@ static void *xm(size_t size)
 	if (p == NULL)
 	{
 		// Oh crumbs: we're out of heap. Try purging the cache and reallocating.
-		Z_FreeTags(PU_PURGELEVEL, INT32_MAX);
+		Z_FreeTags(PU_PURGELEVEL, NUM_PURGETAGS-1);
 		p = malloc(padedsize);
 
 		if (p == NULL)
@@ -245,9 +249,9 @@ void *Z_Malloc(size_t size, INT32 tag, void *user)
 	ptr = MEMORY(block);
 	I_Assert((intptr_t)ptr % alignof (max_align_t) == 0);
 
-	block->next = head.next;
-	block->prev = &head;
-	head.next = block;
+	block->next = headlist[tag].next;
+	block->prev = &headlist[tag];
+	headlist[tag].next = block;
 	block->next->prev = block;
 
 	block->tag = tag;
@@ -411,6 +415,7 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
 #endif
 {
 	memblock_t *block, *next;
+	INT32 i;
 
 #ifdef ZDEBUG
 	Z_CheckHeap2(file, line);
@@ -427,11 +432,13 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
 		g_level_tiny_pool.release();
 	}
 
-	for (block = head.next; block != &head; block = next)
+	for (i = lowtag; i <= hightag; i++)
 	{
-		next = block->next; // get link before freeing
-		if (block->tag >= lowtag && block->tag <= hightag)
+		for (block = headlist[i].next; block != &headlist[i]; block = next)
+		{
+			next = block->next; // get link before freeing
 			Z_Free(MEMORY(block));
+		}
 	}
 }
 
@@ -444,18 +451,20 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
 void Z_IterateTags(INT32 lowtag, INT32 hightag, boolean (*iterfunc)(void *))
 {
 	memblock_t *block, *next;
+	INT32 i;
 
 	if (!iterfunc)
 		I_Error("Z_IterateTags: no iterator function was given");
 
-	for (block = head.next; block != &head; block = next)
+	for (i = lowtag; i <= hightag; i++)
 	{
-		next = block->next; // get link before possibly freeing
-
-		if (block->tag >= lowtag && block->tag <= hightag)
+		for (block = headlist[i].next; block != &headlist[i]; block = next)
 		{
+			next = block->next; // get link before possibly freeing
+
 			void *mem = MEMORY(block);
 			boolean free = iterfunc(mem);
+
 			if (free)
 				Z_Free(mem);
 		}
@@ -486,7 +495,7 @@ void Z_CheckMemCleanup(void)
 	if (nextcleanup-- == 0)
 	{
 		nextcleanup = CLEANUPCOUNT;
-		Z_FreeTags(PU_PURGELEVEL, INT32_MAX);
+		Z_FreeTags(PU_PURGELEVEL, NUM_PURGETAGS-1);
 	}
 }
 
@@ -504,6 +513,7 @@ void Z_CheckHeap(INT32 tag)
 {
 	memblock_t *block;
 	UINT32 blocknumon = 0;
+	size_t j;
 	void *given;
 
 #ifndef ZDEBUG
@@ -520,40 +530,47 @@ void Z_CheckHeap(INT32 tag)
 			blocknumon, block->ownerfile, block->ownerline, msg)
 #endif
 
-	for (block = head.next; block != &head; block = block->next)
+	for (j = 0; j < NUM_PURGETAGS; j++)
 	{
-		blocknumon++;
-		given = MEMORY(block);
+		for (block = headlist[j].next; block != &headlist[j]; block = block->next)
+		{
+			blocknumon++;
+			given = MEMORY(block);
 #ifdef ZDEBUG2
-		CONS_Debug(DBG_MEMORY, "block %u owned by %s:%d\n",
-			blocknumon, block->ownerfile, block->ownerline);
+			CONS_Debug(DBG_MEMORY, "block %u owned by %s:%d\n",
+				blocknumon, block->ownerfile, block->ownerline);
 #endif
 #ifdef HAVE_VALGRIND
-		if (RUNNING_ON_VALGRIND && !VALGRIND_MEMPOOL_EXISTS(block))
-		{
-			HeapError(" should not exist");
-		}
+			if (RUNNING_ON_VALGRIND && !VALGRIND_MEMPOOL_EXISTS(block))
+			{
+				HeapError(" should not exist");
+			}
 #endif
-		if (block->user != NULL && *(block->user) != given)
-		{
-			HeapError(" doesn't have a proper user");
-		}
+			if (block->user != NULL && *(block->user) != given)
+			{
+				HeapError(" doesn't have a proper user");
+			}
 
-		if (block->next->prev != block)
-		{
-			HeapError(" lacks proper backlink");
-		}
+			if (block->next->prev != block)
+			{
+				HeapError(" lacks proper backlink");
+			}
 
-		if (block->prev->next != block)
-		{
-			HeapError(" lacks proper forward link");
-		}
+			if (block->prev->next != block)
+			{
+				HeapError(" lacks proper forward link");
+			}
 #ifdef PARANOIA
-		if (block->id != ZONEID)
-		{
-			HeapError(" has the wrong ID");
-		}
+			if (block->id != ZONEID)
+			{
+				HeapError(" has the wrong ID");
+			}
 #endif
+			if (block->tag != j)
+			{
+				HeapError(va(" block is contained in the wrong headlist (got: %d expected: %s)", block->tag, sizeu1(j)));
+			}
+		}
 	}
 }
 
@@ -582,13 +599,22 @@ void Z_ChangeTag(void *ptr, INT32 tag)
 	block = MEMBLOCK(ptr);
 
 #ifdef PARANOIA
-	if (block->id != ZONEID) I_Error("Z_ChangeTag at %s:%d: wrong id", file, line);
+	if (block->id != ZONEID)
+		I_Error("Z_ChangeTag at %s:%d: wrong id", file, line);
 #endif
 
 	if (tag >= PU_PURGELEVEL && block->user == NULL)
 		I_Error("Internal memory management error: "
 			"tried to make block purgable but it has no owner");
 
+	block->prev->next = block->next;
+	block->next->prev = block->prev;
+
+	block->next = headlist[tag].next;
+	block->prev = &headlist[tag];
+	headlist[tag].next = block;
+	block->next->prev = block;
+
 	block->tag = tag;
 }
 
@@ -613,7 +639,8 @@ void Z_SetUser(void *ptr, void **newuser)
 	block = MEMBLOCK(ptr);
 
 #ifdef PARANOIA
-	if (block->id != ZONEID) I_Error("Z_SetUser at %s:%d: wrong id", file, line);
+	if (block->id != ZONEID)
+		I_Error("Z_SetUser at %s:%d: wrong id", file, line);
 #endif
 
 	if (block->tag >= PU_PURGELEVEL && newuser == NULL)
@@ -638,18 +665,21 @@ void Z_SetUser(void *ptr, void **newuser)
 size_t Z_TagsUsage(INT32 lowtag, INT32 hightag)
 {
 	size_t cnt = 0;
-	memblock_t *rover;
+	memblock_t *head; // why was this called rover before?????
+	INT32 i;
 
-	for (rover = head.next; rover != &head; rover = rover->next)
+	for (i = lowtag; i <= hightag; i++)
 	{
-		if (rover->tag < lowtag || rover->tag > hightag)
-			continue;
-		cnt += rover->size + sizeof(memblock_t);
+		for (head = headlist[i].next; head != &headlist[i]; head = head->next)
+		{
+			cnt += head->size + sizeof *head;
+		}
 	}
 
 	return cnt;
 }
 
+
 // -----------------------
 // Miscellaneous functions
 // -----------------------
@@ -663,8 +693,8 @@ static void Command_Memfree_f(void)
 
 	Z_CheckHeap(-1);
 	CONS_Printf("\x82%s", M_GetText("Memory Info\n"));
-	CONS_Printf(M_GetText("Total heap used        : %7s KB\n"), sizeu1(Z_TotalUsage()>>10));
-	CONS_Printf(M_GetText("Lua                    : %7s KB\n"), sizeu1(Z_TagUsage(PU_LUA)>>10));
+	CONS_Printf(M_GetText("Total heap used        : %7s KB\n"), sizeu1((Z_TotalUsage()>>10) + LUA_MemoryUsage()));
+	CONS_Printf(M_GetText("Lua                    : %7s KB\n"), sizeu1(LUA_MemoryUsage())); // No longer uses z_zone memory but for consistency keep it here
 	CONS_Printf(M_GetText("Static                 : %7s KB\n"), sizeu1(Z_TagUsage(PU_STATIC)>>10));
 	CONS_Printf(M_GetText("Static (sound)         : %7s KB\n"), sizeu1(Z_TagUsage(PU_SOUND)>>10));
 	CONS_Printf(M_GetText("Static (music)         : %7s KB\n"), sizeu1(Z_TagUsage(PU_MUSIC)>>10));
@@ -678,7 +708,7 @@ static void Command_Memfree_f(void)
 	CONS_Printf(M_GetText("Level (pooled)         : %7s KB\n"), sizeu1(Z_LevelPoolUsage()>>10));
 	CONS_Printf(M_GetText("Special thinker        : %7s KB\n"), sizeu1(Z_TagUsage(PU_LEVSPEC)>>10));
 	CONS_Printf(M_GetText("All purgable           : %7s KB\n"),
-		sizeu1(Z_TagsUsage(PU_PURGELEVEL, INT32_MAX)>>10));
+		sizeu1(Z_TagsUsage(PU_PURGELEVEL, NUM_PURGETAGS-1)>>10));
 
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
@@ -707,21 +737,24 @@ static void Command_Memfree_f(void)
 static void Command_Memdump_f(void)
 {
 	memblock_t *block;
-	INT32 mintag = 0, maxtag = INT32_MAX;
+	INT32 mintag = 0, maxtag = NUM_PURGETAGS-1;
+	INT32 check;
 	INT32 i;
 
-	if ((i = COM_CheckParm("-min")))
-		mintag = atoi(COM_Argv(i + 1));
+	if ((check = COM_CheckParm("-min")))
+		mintag = atoi(COM_Argv(check + 1));
 
-	if ((i = COM_CheckParm("-max")))
-		maxtag = atoi(COM_Argv(i + 1));
+	if ((check = COM_CheckParm("-max")))
+		maxtag = atoi(COM_Argv(check + 1));
 
-	for (block = head.next; block != &head; block = block->next)
-		if (block->tag >= mintag && block->tag <= maxtag)
+	for (i = mintag; i <= maxtag; i++)
+	{
+		for (block = headlist[i].next; block != &headlist[i]; block = block->next)
 		{
 			const char *filename = strrchr(block->ownerfile, PATHSEP[0]);
-			CONS_Printf("[%3d] %s (%s) bytes @ %s:%d\n", block->tag, sizeu1(block->size + sizeof(memblock_t)), sizeu2(block->size), filename ? filename + 1 : block->ownerfile, block->ownerline);
+			CONS_Printf("[%3d] %s (%s) bytes @ %s:%d tag: %d (%d)\n", block->tag, sizeu1(block->size + sizeof(memblock_t)), sizeu2(block->size), filename ? filename + 1 : block->ownerfile, block->ownerline, block->tag, i);
 		}
+	}
 }
 #endif
 

src/z_zone.h

@@ -42,39 +42,42 @@ extern "C" {
 enum
 {
 	// Tags < PU_LEVEL are not purged until freed explicitly.
-	PU_STATIC                = 1, // static entire execution time
-	PU_LUA                   = 2, // static entire execution time -- used by lua so it doesn't get caught in loops forever
-	PU_PERFSTATS             = 3, // static between changes to ps_samplesize cvar
+	PU_STATIC                = 0, // static entire execution time
+	PU_LUA, // static entire execution time -- used by lua so it doesn't get caught in loops forever
+	PU_PERFSTATS, // static between changes to ps_samplesize cvar
 
-	PU_SOUND                 = 11, // static while playing
-	PU_MUSIC                 = 12, // static while playing
+	PU_SOUND, // static while playing
+	PU_MUSIC, // static while playing
 
-	PU_PATCH                 = 14, // static entire execution time
-	PU_PATCH_LOWPRIORITY     = 15, // lower priority patch, static until level exited
-	PU_PATCH_ROTATED         = 16, // rotated patch, static entire execution time
-	PU_PATCH_DATA            = 17, // patch data, lifetime depends on the patch that owns it
-	PU_SPRITE                = 18, // sprite patch, static until WAD added
-	PU_HUDGFX                = 19, // HUD patch, static until WAD added
+	PU_PATCH, // static entire execution time
+	PU_PATCH_LOWPRIORITY, // lower priority patch, static until level exited
+	PU_PATCH_ROTATED, // rotated patch, static until level exited or WAD added
+	PU_PATCH_DATA, // patch data, lifetime depends on the patch that owns it
+	PU_SPRITE, // sprite patch, static until WAD added
+	PU_HUDGFX, // HUD patch, static until WAD added
 
-	PU_HWRPATCHINFO          = 21, // Hardware GLPatch_t struct for OpenGL texture cache
-	PU_HWRPATCHCOLMIPMAP     = 22, // Hardware GLMipmap_t struct colormap variation of patch
-	PU_HWRMODELTEXTURE       = 23, // Hardware model texture
+	PU_HWRPATCHINFO, // Hardware GLPatch_t struct for OpenGL texture cache
+	PU_HWRPATCHCOLMIPMAP, // Hardware GLMipmap_t struct colormap variation of patch
+	PU_HWRMODELTEXTURE, // Hardware model texture
 
-	PU_HWRCACHE              = 48, // static until unlocked
-	PU_CACHE                 = 49, // static until unlocked
+	PU_HWRCACHE, // static until unlocked
+	PU_CACHE, // static until unlocked
 
 	// Tags s.t. PU_LEVEL <= tag < PU_PURGELEVEL are purged at level start
-	PU_LEVEL                 = 50, // static until level exited
-	PU_LEVSPEC               = 51, // a special thinker in a level
-	PU_HWRPLANE              = 52, // if ZPLANALLOC is enabled in hw_bsp.c, this is used to alloc polygons for OpenGL
+	PU_LEVEL, // static until level exited
+	PU_LEVSPEC, // a special thinker in a level
+	PU_HWRPLANE, // if ZPLANALLOC is enabled in hw_bsp.c, this is used to alloc polygons for OpenGL
 
 	// Tags >= PU_PURGELEVEL are purgable whenever needed
-	PU_PURGELEVEL            = 100, // Note: this is never actually used as a tag
-	PU_CACHE_UNLOCKED        = 101, // Note: unused
-	PU_HWRCACHE_UNLOCKED     = 102, // 'unlocked' PU_HWRCACHE memory:
+	PU_PURGELEVEL, // Note: this is never actually used as a tag
+	PU_CACHE_UNLOCKED, // Note: unused
+	PU_HWRCACHE_UNLOCKED, // 'unlocked' PU_HWRCACHE memory:
 									// 'second-level' cache for graphics
-                                    // stored in hardware format and downloaded as needed
-	PU_HWRMODELTEXTURE_UNLOCKED = 103, // 'unlocked' PU_HWRMODELTEXTURE memory
+
+									// stored in hardware format and downloaded as needed
+	PU_HWRMODELTEXTURE_UNLOCKED, // 'unlocked' PU_HWRMODELTEXTURE memory
+
+	NUM_PURGETAGS
 };
 
 //
@@ -157,7 +160,7 @@ void Z_SetUser(void *ptr, void **newuser);
 //
 #define Z_TagUsage(tagnum) Z_TagsUsage(tagnum, tagnum)
 size_t Z_TagsUsage(INT32 lowtag, INT32 hightag);
-#define Z_TotalUsage() Z_TagsUsage(0, INT32_MAX)
+#define Z_TotalUsage() Z_TagsUsage(0, NUM_PURGETAGS-1)
 
 //
 // Miscellaneous functions