have Z_IsMobjValid2 print an error in console

if mobj pointer is invalid
the callee should handle the behavior

src/core/memory.cpp

@@ -149,6 +149,30 @@ void PoolAllocator::release()
 	allocated_blocks_ = 0;
 }
 
+bool PoolAllocator::ptrcheck(const void* p) const
+{
+	const uintptr_t paddr = reinterpret_cast<uintptr_t>(p);
+
+	ChunkFooter* next = nullptr;
+	for (ChunkFooter* chunk = first_chunk_; chunk != nullptr; chunk = next)
+	{
+		const uintptr_t blockstart = reinterpret_cast<uintptr_t>(chunk->start);
+		const uintptr_t blockend = blockstart + blocks_ * block_size_;
+
+		//CONS_Printf("mobj ptr %lu, block start %lu end %lu\n", paddr, blockstart, blockend);
+
+		if (paddr >= blockstart && paddr < blockend)
+		{
+			return true;
+		}
+
+		next = chunk->next;
+	}
+
+	return false;
+}
+
+
 static LinearMemory g_frame_memory {4 * 1024 * 1024};
 
 void* Z_Frame_Alloc(size_t size)

src/core/memory.h

@@ -65,6 +65,7 @@ public:
 	constexpr size_t allocated_bytes() const noexcept { return allocated_blocks_ * block_size_; };
 
 	void release();
+	bool ptrcheck(const void* p) const;
 };
 
 } // namespace srb2

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);
@@ -4128,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", players[i].mo->skin->name);
+							CONS_Printf("Mobj skin: %s\n", ((skin_t *)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");

src/d_main.c

@@ -1149,19 +1149,13 @@ 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....
-		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)
+		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
 		{
 			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) > 0)
+		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
 			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
 			postload = true;

src/d_netcmd.c

@@ -1174,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;
 		}
 	}
@@ -1189,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)
 	{
@@ -1203,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;
@@ -1218,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");
@@ -1553,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);
 		}
 	}
 }
@@ -1613,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);
 	}
@@ -1625,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)
@@ -1654,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);
 		}
@@ -1684,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)
@@ -1692,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;
 	}
 
@@ -1780,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);
@@ -4356,10 +4356,10 @@ static void SetPrefcolor(int splitplayer)
 	consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
 	consvar_t *playercolor = colorvars[splitplayer];
 
-	if (skins[player->skin]->prefcolor)
+	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]);
+		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
 	{
@@ -5632,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;
 	}
 
@@ -5641,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);
 	}
 }
 
@@ -5662,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);
 	}
 }
 
@@ -5678,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);
 	}
 }
 
@@ -5694,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);
 	}
 }
 
@@ -5737,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;
@@ -5745,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",
@@ -5775,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)))
 			{
@@ -5799,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,17 +361,11 @@ 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
 // ========================================================================
@@ -567,9 +561,6 @@ 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/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_main.cpp

@@ -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 = R_GetMobjSkin(spr->mobj);
+	const skin_t *moskin = K_GetMobjSkin(spr->mobj);
 	if (moskin && moskin->flags & SF_HIRES)
 		this_scale *= FixedToFloat(moskin->highresscale);
 
@@ -4361,8 +4361,17 @@ static void HWR_DrawSprites(void)
 			{
 				if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
 				{
-					/* fuck you */
-					md2_t *md2 = &R_GetMobjSkin(spr->mobj)->playermodel;
+					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];
 
 					// 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])
@@ -4584,7 +4593,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 
 	rot = (thing->frame & FF_FRAMEMASK);
 
-	sprskin = R_GetMobjSkin(thing);
+	sprskin = K_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,6 +73,8 @@
 #endif
 
 md2_t md2_models[NUMSPRITES] = {};
+md2_t md2_playermodels[MAXSKINS] = {};
+md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
 
 /*
  * free model
@@ -419,7 +421,6 @@ static void md2_loadTexture(md2_t *model)
 			}
 		}
 	}
-
 	GL_SetTexture(glPatch->mipmap);
 	HWR_UnlockCachedPatch(glPatch);
 }
@@ -477,7 +478,6 @@ 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,19 +487,6 @@ 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;
@@ -509,22 +496,38 @@ void HWR_InitMD2(void)
 	float scale, offset;
 
 	CONS_Printf("InitMD2()...\n");
-
-	for (s = 0; s < numskins; s++)
+	for (s = 0; s < MAXSKINS; s++)
 	{
-		skin_t *skin = skins[s];
-		HWR_InitModel(&skin->playermodel);
+		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;
 	}
-
-	for (s = 0; s < numlocalskins; s++)
+	for (s = 0; s < MAXLOCALSKINS; s++)
 	{
-		skin_t *skin = localskins[s];
-		HWR_InitModel(&skin->playermodel);
+		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;
 	}
-
 	for (i = 0; i < NUMSPRITES; i++)
 	{
-		HWR_InitModel(&md2_models[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;
 	}
 
 	// read the mdls.dat file
@@ -541,7 +544,6 @@ void HWR_InitMD2(void)
 			return;
 		}
 	}
-
 	while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
 	{
 		for (i = 0; i < NUMSPRITES; i++)
@@ -556,21 +558,18 @@ void HWR_InitMD2(void)
 			}
 		}
 
-		for (s = 0; s < numskins; s++)
+		for (s = 0; s < MAXSKINS; s++)
 		{
-			skin_t *skin = skins[s];
-
-			if (fasticmp(name, skin->name))
+			if (fasticmp(name, skins[s].name))
 			{
-				skin->playermodel.skinnum = s;
-				skin->playermodel.scale = scale;
-				skin->playermodel.offset = offset;
-				skin->playermodel.notfound = false;
-				strcpy(skin->playermodel.filename, filename);
+				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);
 				goto md2found;
 			}
 		}
-
 		// no sprite/player skin name found?!?D
 		CONS_Printf("Unknown sprite/player skin %s detected in mdls.dat\n", name);
 md2found:
@@ -580,16 +579,12 @@ md2found:
 	fclose(f);
 }
 
-void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added after startup
+void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup
 {
 	FILE *f;
 	char name[20], filename[32];
 	float scale, offset;
-
-	skin_t *skin = R_GetSkinArray(local)[skinnum];
-
-	// ensure we ALWAYS initialize the model even if no mdls.dat was found!
-	HWR_InitModel(&skin->playermodel);
+	md2_t *md2s;
 
 	if (nomd2s)
 		return;
@@ -603,7 +598,6 @@ void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added
 	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));
@@ -612,25 +606,25 @@ void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added
 		}
 	}
 
+	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, skin->name))
+		if (fasticmp(name, K_GetSkinArray(local)[skin].name))
 		{
-			skin->playermodel.skinnum = skinnum;
-			skin->playermodel.scale = scale;
-			skin->playermodel.offset = offset;
-			skin->playermodel.notfound = false;
-			strcpy(skin->playermodel.filename, filename);
+			md2s[skin].skin = skin;
+			md2s[skin].scale = scale;
+			md2s[skin].offset = offset;
+			md2s[skin].notfound = false;
+			strcpy(md2s[skin].filename, filename);
 			goto playermd2found;
 		}
 	}
 
-	//CONS_Printf("MD2 for player skin %s not found\n", skins[skinnum].name);
-	skin->playermodel.notfound = true;
-
+	//CONS_Printf("MD2 for player skin %s not found\n", skins[skin].name);
+	md2s[skin].notfound = true;
 playermd2found:
-
 	fclose(f);
 }
 
@@ -680,7 +674,6 @@ 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);
 }
@@ -1153,6 +1146,8 @@ 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;
@@ -1212,29 +1207,36 @@ 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
 
-		// 1. load model+texture if not already loaded
-		// 2. draw model with correct position, rotation,...
-
-		// 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)
+		/* fuck you */
+		if (spr->mobj->localskin)
 		{
-			/* fuck you */
-			md2_t *md2s = &R_GetMobjSkin(spr->mobj)->playermodel;
-
-			if (!md2s->notfound)
+			if (spr->mobj->skinlocal)
 			{
-				md2 = md2s;
-				md2->skinnum = R_GetMobjSkinNum(spr->mobj);
-				sprinfo = &spriteinfo[spr->mobj->sprite];
+				md2s = md2_localplayermodels;
+				skinnum = (skin_t *)spr->mobj->localskin - localskins;
 			}
-			else // if we can't find the player md2, use SPR_PLAY's MD2.
+			else
 			{
-				md2 = &md2_models[spr->mobj->sprite];
-				sprinfo = &spriteinfo[spr->mobj->sprite];
+				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
+		{
+			md2 = &md2s[skinnum];
+			md2->skin = skinnum;
+			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];
 		}
@@ -1297,7 +1299,6 @@ 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)
@@ -1312,16 +1313,13 @@ 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)R_GetMobjSkinNum(spr->mobj);
+							tcskinnum = (INT32)(K_GetMobjSkinNum(K_GetMobjSkin(spr->mobj), spr->mobj->skinlocal));
 						}
 					}
-					else
-						tcskinnum = TC_DEFAULT;
+					else tcskinnum = TC_DEFAULT;
 				}
 
 				HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, spr->colormap, (skincolors_t)spr->mobj->color);
@@ -1385,7 +1383,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 = &R_GetMobjSkin(spr->mobj)->spritedef;
+			sprdef = &K_GetMobjSkin(spr->mobj)->spritedef;
 		else
 			sprdef = &sprites[spr->mobj->sprite];
 

src/hardware/hw_md2.h

@@ -33,11 +33,13 @@ typedef struct
 	void        *blendglpatch;
 	boolean     noblendfile; // true if blend texture file was not found
 	boolean     notfound;
-	INT32       skinnum;
+	INT32       skin;
 	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/hu_stuff.c

@@ -2654,12 +2654,9 @@ static inline void HU_DrawSpectatorTicker(void)
 
 				if (player->mo && player->mo->color)
 				{
-					const UINT8 *colormap = NULL;
-
+					const UINT8 *colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE);
 					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,8 +1221,10 @@ boolean K_UseHighResPortraits(void)
 // accounts for localskins
 patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum)
 {
-	const skin_t *skin = R_GetSkinArray(player->skinlocal)[skinnum];
-	return (K_UseHighResPortraits() ? skin->facewantprefix : skin->facerankprefix);
+	if (!player->skinlocal)
+		return (K_UseHighResPortraits() ? facewantprefix[skinnum] : facerankprefix[skinnum]);
+	else
+		return (K_UseHighResPortraits() ? localfacewantprefix[skinnum] : localfacerankprefix[skinnum]);
 }
 
 INT32 K_calcSplitFlags(INT32 snapflags)
@@ -1424,7 +1426,7 @@ static void K_drawKartStats(void)
 		flags |= V_HUDTRANS;
 		flags2 = flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor);
 
-		fakeskin = R_GetPlayerSkin(stplyr);
+		fakeskin = K_GetPlayerSkin(stplyr);
 
 		// Skin name
 		if (cv_showstats_skinname.value)
@@ -3107,7 +3109,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;
 
@@ -3592,12 +3594,12 @@ static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
 	INT32 rot = 0;
 #endif
 
-	skin = R_GetMobjSkin(mo);
+	skin = K_GetMobjSkin(mo);
 
 	if (!skin)
 		return;
 
-	minimaphead = skin->facemmapprefix;
+	minimaphead = (skinlocal ? localfacemmapprefix : facemmapprefix)[K_GetMobjSkinNum(skin, skinlocal)];
 
 	if (minimaphead == NULL)
 		return;
@@ -3827,8 +3829,10 @@ 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 (R_GetMobjSkin(mobj)->starttranscolor != skins[0]->starttranscolor)
+					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
 					{
 						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
 					}
@@ -4903,7 +4907,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, skins[stplyr->skin]->facewantprefix, cm);
+			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT>>1, 0, facewantprefix[stplyr->skin], cm);
 
 			x += 16;
 			if (x > BASEVIDWIDTH-16)

src/k_hud.h

@@ -78,8 +78,6 @@ 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,11 +71,12 @@ 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
-consvar_t cv_saltyhop = {"hardcodehop", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+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_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, saltyheight_t, NULL, 0, NULL, NULL, 0, 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_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};
@@ -83,6 +84,23 @@ 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
@@ -592,7 +610,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) ? R_GetSkinArray(local)[skinnum]->starttranscolor : DEFAULT_STARTTRANSCOLOR;
+	starttranscolor = (skinnum != TC_DEFAULT) ? K_GetSkinArray(local)[skinnum].starttranscolor : DEFAULT_STARTTRANSCOLOR;
 
 	if (starttranscolor >= NUM_PALETTE_ENTRIES)
 		I_Error("Invalid startcolor #%d.", starttranscolor);
@@ -632,6 +650,60 @@ 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
@@ -1755,56 +1827,25 @@ 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 * fscale);
-				newy = player->mo->y + P_ReturnThrustY(player->mo, newangle, 31 * fscale);
+				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);
 				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 (!P_MobjWasRemovedCompat(mo))
+				if (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 * fscale) * P_MobjFlip(player->mo);
-					P_SetScale(mo, (mo->destscale = fscale));
+					mo->momz = (8<<FRACBITS) * P_MobjFlip(player->mo);
+					P_SetScale(mo, (mo->destscale = FRACUNIT));
 				}
-#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
 			}
 		}
 	}
@@ -1935,7 +1976,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 = R_GetPlayerSkin(source->player);
+		skin = K_GetPlayerSkin(source->player);
 	}
 
 	if (!skin)
@@ -2153,7 +2194,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->salty.jump)
+		if (dust && player->mo->salty.jump)
 			dust->flags2 |= MF2_DONTDRAW;
 
 		if (leveltime % 6 == 0)
@@ -3182,8 +3223,10 @@ static void K_SpawnDriftSparks(player_t *player)
 
 	for (i = 0; i < 2; i++)
 	{
-		const angle_t thrustangle = (travelangle + ((i&1) ? -1 : 1)*ANGLE_135);
-		const fixed_t smolscale = FixedMul(32*FRACUNIT, player->mo->scale);
+		fixed_t driftExtraScale = 0;
+
+		angle_t thrustangle = (travelangle + ((i&1) ? -1 : 1)*ANGLE_135);
+		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);
@@ -3195,9 +3238,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
-		const fixed_t driftExtraScale = FixedDiv(player->driftsparkGrowTimer, DRIFTSPARKGROWTICS);
+		driftExtraScale = FixedDiv(player->driftsparkGrowTimer, DRIFTSPARKGROWTICS);
 		spark->destscale = FixedMul(player->mo->scale, FRACUNIT + FixedMul(driftExtraScale, cv_driftsparkpulse.value));
-		P_SetScale(spark, spark->destscale);
+		P_SetScale(spark, spark->destscale); // why not use what we calculated above?
 
 		spark->momx = player->mo->momx/2;
 		spark->momy = player->mo->momy/2;
@@ -3292,7 +3335,7 @@ static void K_StretchPlayerGravity(player_t *player)
 	fixed_t tempxscale = pmo->realxscale;
 	fixed_t tempyscale = pmo->realyscale;
 
-	stretchScaleFactor = FixedDiv(mapobjectscale*60, cv_gravstretch.value);
+	stretchScaleFactor = FixedDiv(FRACUNIT*60, cv_gravstretch.value);
 	stretchScaleFactor = min(stretchScaleFactor, MAXSTRETCHDIV);
 
 	if (pmo->slamsoundtimer)
@@ -3300,26 +3343,26 @@ static void K_StretchPlayerGravity(player_t *player)
 
 	if (!P_IsObjectOnGround(pmo))
 	{
-		const fixed_t pzmom = abs(pmo->momz);
+		fixed_t pzmom = abs(pmo->momz);
 		const fixed_t stretchDiv = FixedDiv(pzmom, stretchScaleFactor);
 
-		if (abs(pzmom/mapobjectscale) != 0)
+		if (abs(pzmom/FRACUNIT) != 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*mapobjectscale))
+		if (cv_slamsound.value && (pmo->eflags & MFE_JUSTHITFLOOR) && !pmo->slamsoundtimer && (pmo->stretchslam > 4*FRACUNIT))
 		{
 			S_StartSound(pmo, sfx_s3k4c);
 			pmo->slamsoundtimer = TICRATE;
@@ -3327,9 +3370,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*mapobjectscale);
+		pmo->stretchslam -= (4*FRACUNIT);
 	}
 	else
 		pmo->stretchslam = 0;
@@ -3349,11 +3392,11 @@ static void K_SaltySquish(player_t *player)
 
 	if (pmo->stretchslam > 0)
 	{
-		const fixed_t slamDiv = FixedDiv(pmo->stretchslam, mapobjectscale*60); // stretchScaleFactor = FixedDiv(mapobjectscale*60, FRACUNIT)
+		const fixed_t slamDiv = FixedDiv(pmo->stretchslam, FRACUNIT*60); // stretchScaleFactor = FixedDiv(FRACUNIT*60, FRACUNIT)
 
-		pmo->spritexscale = (tempxscale + (((slamDiv * 2) / 3) * 2));
+		pmo->spritexscale = (tempxscale + (((slamDiv*2)/3)*2));
 		pmo->spriteyscale = (tempyscale - slamDiv);
-		pmo->stretchslam -= (4*mapobjectscale);
+		pmo->stretchslam -= (4*FRACUNIT);
 	}
 	else
 		pmo->stretchslam = 0;
@@ -3361,92 +3404,88 @@ static void K_SaltySquish(player_t *player)
 
 static void K_QuiteSaltyHop(player_t *player)
 {
-	I_Assert(player != NULL);
-	I_Assert(!P_MobjWasRemoved(player->mo));
+	if (!cv_saltyhop.value)
+		return;
 
 	// what the fuck is this haya
 	mobj_t *pmo = player->mo;
-	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;
-	}
-
+	salty_t *psalt = &pmo->salty;
 	const boolean onground = P_IsObjectOnGround(pmo);
 
 	// ready?
 	if (!player->kartstuff[k_jmp])
 	{
-		psalty->ready = true;
-		psalty->tapping = false;
+		psalt->ready = true;
+		psalt->tapping = false;
 	}
-	else if (psalty->ready)
+	else if (psalt->ready)
 	{
-		psalty->ready = false;
-		psalty->tapping = true;
+		psalt->ready = false;
+		psalt->tapping = true;
 	}
 	else
 	{
-		psalty->tapping = false;
+		psalt->tapping = false;
 	}
 
 	// GO!
-	if (psalty->jump)
+	if (!psalt->init)
+	{
+		psalt->jump = false;
+		psalt->zoffset = 0;
+		psalt->momz = 0;
+		psalt->init = true;
+	}
+	else if (psalt->jump)
 	{
 		if (pmo->eflags & MFE_JUSTHITFLOOR)
 		{
-			psalty->zoffset = 0;
+			psalt->zoffset = 0;
 		}
 		else if (onground)
 		{
-			psalty->zoffset += psalty->momz;
-			psalty->momz -= (FRACUNIT*3/2);
+			psalt->zoffset += psalt->momz;
+			psalt->momz -= (FRACUNIT*3/2);
 		}
 		else
 		{
-			//psalty->zoffset *= (49/50)*FRACUNIT; // this just rounds down to 0 lol
-			psalty->zoffset = 0;
-			psalty->momz = 0;
+			psalt->zoffset *= (49/50)*FRACUNIT;
+			psalt->momz = 0;
 		}
 
-		if (psalty->zoffset <= 0)
+		if (psalt->zoffset <= 0)
 		{
 			if (cv_saltyhopsfx.value && !(pmo->eflags & MFE_JUSTHITFLOOR) && onground)
 				S_StartSound(pmo, sfx_s268);
-			psalty->jump = false;
-			psalty->zoffset = 0;
-			psalty->momz = 0;
+			psalt->jump = false;
+			psalt->zoffset = 0;
+			psalt->momz = 0;
 			// shlamma damma
 			if (cv_saltysquish.value)
-				pmo->stretchslam += 8*mapobjectscale;
+				pmo->stretchslam += 8*FRACUNIT;
 		}
-		else if (psalty->zoffset > 0)
+		else if (cv_saltysquish.value && psalt->zoffset >= 0)
 		{
-			if (cv_saltysquish.value)
-			{
-				// goofy ahh hack
-				pmo->spriteyscale += (FRACUNIT/8);
-				pmo->spritexscale -= (FRACUNIT/8);
-			}
+			// goofy ahh hack
+			pmo->spriteyscale += (FRACUNIT/8);
+			pmo->spritexscale -= (FRACUNIT/8);
 		}
 
-		pmo->spriteyoffset += FixedMul(psalty->zoffset, cv_saltyheight.value);
+		pmo->spriteyoffset += FixedMul(psalt->zoffset, cv_saltyheight.value);
 
-		// 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);
+		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);
+		}
 	}
-	else if (psalty->tapping && onground && !player->kartstuff[k_spinouttimer] && !player->kartstuff[k_squishedtimer])
+	else if (psalt->tapping && onground && !player->kartstuff[k_spinouttimer] && !player->kartstuff[k_squishedtimer])
 	{
-		psalty->jump = true;
-		psalty->zoffset = 0;
-		psalty->momz = 6*FRACUNIT;
+		psalt->jump = true;
+		psalt->zoffset = 0;
+		psalt->momz = 6*FRACUNIT;
 		if (cv_saltyhopsfx.value)
 			S_StartSound(pmo, sfx_s25a);
 	}
@@ -3473,7 +3512,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->salty.jump)
+	if (!cv_saltyroll.value && mobj->player && mobj->player->mo->salty.jump)
 		return false;
 
 	return K_CheckSlopeRollDist(mobj);
@@ -3685,7 +3724,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);
@@ -3711,11 +3750,6 @@ 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;
@@ -3732,7 +3766,7 @@ void K_DriftDustHandling(mobj_t *spawner)
 		{
 			angle_t playerangle = spawner->angle;
 
-			if (spawner->player->speed < (5 * fscale))
+			if (spawner->player->speed < 5<<FRACBITS)
 				return;
 
 			if (spawner->player->cmd.forwardmove < 0)
@@ -3743,7 +3777,7 @@ void K_DriftDustHandling(mobj_t *spawner)
 	}
 	else
 	{
-		if (P_AproxDistance(spawner->momx, spawner->momy) < (5 * fscale))
+		if (P_AproxDistance(spawner->momx, spawner->momy) < 5<<FRACBITS)
 			return;
 
 		anglediff = abs((signed)(spawner->angle - R_PointToAngle2(0, 0, spawner->momx, spawner->momy)));
@@ -3756,29 +3790,13 @@ 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;
-
-		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));
+		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));
 		P_SetScale(dust, spawner->scale/2);
 		dust->destscale = spawner->scale * 3;
 		dust->scalespeed = spawner->scale/12;
@@ -3787,33 +3805,6 @@ 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
 	}
 }
 

src/lua_baselib.c

@@ -1766,8 +1766,6 @@ 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
@@ -2633,7 +2631,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 = R_GetMobjSkin(mobj)->soundsid[S_sfx[sfx_klose].skinsound];
+	sfx_id = ((skin_t *)mobj->skin)->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 = tails->skin->name;
+	const char *skin = ((skin_t *)tails->skin)->name;
 
 	Hook_State hook = {};
 	BotAI_State botai = {};

src/lua_hud.h

@@ -53,6 +53,4 @@ 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,8 +1056,6 @@ 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,14 +392,12 @@ int mobj_skin_getter(lua_State *L)
         return 0;
 
     // HUD ONLY!!!!!!!!!!
-    if LOCALSKINIMMERSION
+    if (hud_running && cv_luaimmersion.value)
     {
-        lua_pushstring(L, R_GetMobjSkin(mo)->name);
+        lua_pushstring(L, K_GetMobjSkin(mo)->name);
     }
     else
-    {
-        lua_pushstring(L, mo->skin->name);
-    }
+        lua_pushstring(L, ((skin_t *)mo->skin)->name);
 
     return 1;
 }
@@ -414,9 +412,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;
         }
     }
@@ -429,7 +427,7 @@ int mobj_localskin_getter(lua_State *L)
 	mobj_t *mo = GETMO();
 
 	if (mo->localskin)
-		lua_pushstring(L, mo->localskin->name);
+		lua_pushstring(L, ((skin_t *)mo->localskin)->name);
 	else
 		lua_pushnil(L);
 
@@ -456,9 +454,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;
 				}
@@ -467,9 +465,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, R_GetPlayerSkin(plr)->name);
+		lua_pushstring(L, K_GetPlayerSkin(plr)->name);
 	else
 		lua_pushnil(L);
 

src/lua_skinlib.c

@@ -18,10 +18,6 @@
 
 #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,
@@ -154,15 +150,13 @@ static int skin_num(lua_State *L)
 	// skins are always valid, only added, never removed
 	I_Assert(skin != NULL);
 
-	lua_pushinteger(L, LOCALSKINIMMERSION ? skin->allskinnum : skin->skinnum);
+	lua_pushinteger(L, skin-skins);
 	return 1;
 }
 
 static int lib_iterateSkins(lua_State *L)
 {
 	INT32 i;
-	skin_t **skinar = SKINARR;
-	const INT32 nskins = NSKINS;
 
 	if (lua_gettop(L) < 2)
 	{
@@ -175,17 +169,14 @@ static int lib_iterateSkins(lua_State *L)
 	lua_remove(L, 1); // state is unused.
 
 	if (!lua_isnil(L, 1))
-	{
-		skin_t *skin = (*((skin_t **)luaL_checkudata(L, 1, META_SKIN)));
-		i = (INT32)(LOCALSKINIMMERSION ? skin->allskinnum : skin->skinnum) + 1;
-	}
+		i = (INT32)(*((skin_t **)luaL_checkudata(L, 1, META_SKIN)) - allskins) + 1;
 	else
 		i = 0;
 
 	// skins are always valid, only added, never removed
-	if (i < nskins)
+	if (i < numallskins)
 	{
-		LUA_PushUserdata(L, skinar[i], META_SKIN);
+		LUA_PushUserdata(L, &allskins[i], META_SKIN);
 		return 1;
 	}
 
@@ -197,40 +188,32 @@ 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 >= skinmax)
-			return luaL_error(L, "skins[] index %d out of range (0 - %d)", i, skinmax-1);
-		if (i >= nskins)
+		if (i < 0 || i >= MAXSKINS)
+			return luaL_error(L, "skins[] index %d out of range (0 - %d)", i, MAXSKINS-1);
+		if (i >= numallskins)
 			return 0;
-
-		LUA_PushUserdata(L, skinar[i], META_SKIN);
-
+		LUA_PushUserdata(L, &allskins[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 < nskins; i++)
-		if (fastcmp(skinar[i]->name, field))
+	for (i = 0; i < numallskins; i++)
+		if (fastcmp(allskins[i].name, field))
 		{
-			LUA_PushUserdata(L, skinar[i], META_SKIN);
+			LUA_PushUserdata(L, &allskins[i], META_SKIN);
 			return 1;
 		}
 
@@ -239,7 +222,7 @@ static int lib_getSkin(lua_State *L)
 
 static int lib_numSkins(lua_State *L)
 {
-	lua_pushinteger(L, NSKINS);
+	lua_pushinteger(L, numallskins);
 	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 < numskins; j++)
+	for (j = 0; j < MAXSKINS; 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 = skins[replaydemolist->standings[0].skin]->facewantprefix;
+				patch = facewantprefix[replaydemolist->standings[0].skin];
 				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 = skins[replaydemolist->standings[i].skin]->facerankprefix;
+			patch = facerankprefix[replaydemolist->standings[i].skin];
 			colormap = R_GetTranslationColormap(
 				replaydemolist->standings[i].skin,
 				replaydemolist->standings[i].color,
@@ -4957,15 +4957,13 @@ 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 = skins[players[ply].skin]->facerankprefix;
-
+				icon = facerankprefix[players[ply].skin];
 				if (i != itemOn)
 					inactivemap = R_GetTranslationColormap(players[ply].skin, players[ply].skincolor, GTC_MENUCACHE);
 			}
@@ -6251,17 +6249,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 - skins[skinnum]->facewantprefix->width);
+		const INT32 charx = (BASEVIDWIDTH-x - facewantprefix[skinnum]->width);
 
 		UINT8 *colormap = NULL;
 
 		colormap = R_GetTranslationColormap(skinnum, cv_playercolor.value, GTC_MENUCACHE);
-		V_DrawMappedPatch(charx, y, 0, skins[skinnum]->facewantprefix, colormap);
+		V_DrawMappedPatch(charx, y, 0, facewantprefix[skinnum], colormap);
 
 		// draw stats
 		// speed
@@ -7709,7 +7707,7 @@ static void M_DrawMPMainMenu(void)
 					break;
 			}
 
-			if (pskin >= numskins)
+			if (pskin >= MAXSKINS)
 				pskin = 0;
 
 			if (!trans && i > cv_splitplayers.value)
@@ -7717,7 +7715,7 @@ static void M_DrawMPMainMenu(void)
 
 			colmap = R_GetTranslationColormap(pskin, pcol, GTC_MENUCACHE);
 
-			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, trans, skins[pskin]->facewantprefix, colmap);
+			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, trans, facewantprefix[pskin], colmap);
 
 			if (itemOn == 2 && i == setupm_pselect)
 			{
@@ -7978,12 +7976,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:
@@ -8005,10 +8003,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)
 			{
@@ -8022,7 +8020,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,
@@ -8128,10 +8126,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);
 				}
 			}
@@ -8187,10 +8185,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);
 				}
 			}
@@ -8224,8 +8222,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					continue;
 				}
 
-				face = skins[skinn]->facerankprefix;
-				cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
+				face = facerankprefix[skinn];
+				cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
 
 				V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 			}
@@ -8262,8 +8260,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					continue;
 				}
 
-				face = skins[skinn]->facerankprefix;
-				cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
+				face = facerankprefix[skinn];
+				cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
 
 				V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 			}
@@ -8277,7 +8275,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 				if (setupm_skinselect < numskins)
 				{
 					const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
-					cursor = skins[skinsorted[setupm_skinselect]]->facewantprefix;
+					cursor = facewantprefix[skinsorted[setupm_skinselect]];
 					V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
 				}
 				else
@@ -8291,8 +8289,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			{ // stat dot
 				const INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
 
-				speed = skins[selectedskin]->kartspeed;
-				weight = skins[selectedskin]->kartweight;
+				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);
@@ -8331,8 +8329,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					}
 
 					skinn = skinstats[s][w][(I_GetTime() / TICRATE) % skinstatscount[s][w]];
-					face = skins[skinn]->facerankprefix;
-					cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
+					face = facerankprefix[skinn];
+					cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
 
 					V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 				}
@@ -8349,7 +8347,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					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 = skins[skinn]->facewantprefix;
+					cursor = facewantprefix[skinn];
 					V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
 				}
 				else
@@ -8363,8 +8361,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 #undef SKINXSHIFT
 		default:
 			{
-				speed = skins[setupm_fakeskin]->kartspeed;
-				weight = skins[setupm_fakeskin]->kartweight;
+				speed = skins[setupm_fakeskin].kartspeed;
+				weight = skins[setupm_fakeskin].kartweight;
 
 				const INT32 x = ((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS;
 				const INT32 y = ((my+76) + ((weight-1)*8))<<FRACBITS;
@@ -8448,14 +8446,14 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			if (!(k++))
 			{
 				scale = FRACUNIT;
-				face = skins[col]->facewantprefix;
+				face = facewantprefix[col];
 				offx = 12;
 				offy = 0;
 			}
 			else
 			{
 				scale = FRACUNIT/2;
-				face = skins[col]->facerankprefix;
+				face = facerankprefix[col];
 				offx = 8;
 				offy = 8;
 			}
@@ -8509,15 +8507,15 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			break;
 	}
 
-	if (skintodisplay >= numskins)
+	if (skintodisplay >= MAXSKINS)
 		skintodisplay = 0;
 
-	skinnum = R_SkinAvailable(skins[skintodisplay]->name);
+	skinnum = R_SkinAvailable(skins[skintodisplay].name);
 
-	if (skinnum < 0 || skinnum >= numskins)
+	if (skinnum < 0 || skinnum >= MAXSKINS)
 		skinnum = 0;
 
-	sprdef = &skins[skinnum]->spritedef;
+	sprdef = &skins[skinnum].spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -8535,7 +8533,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	{
 		UINT8 *colormap = R_GetTranslationColormap(skintodisplay, setupm_fakecolor, GTC_MENUCACHE);
 #ifdef HWRENDER
-		md2_t *md2 = &skins[skinnum]->playermodel;
+		md2_t *md2 = &md2_playermodels[skinnum];
 #endif
 		mx += 36;
 		my += 131;
@@ -8566,11 +8564,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
@@ -8877,7 +8875,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
@@ -9100,7 +9098,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;
@@ -9876,7 +9874,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;
@@ -9918,7 +9916,7 @@ static void M_DrawLocalSkinMenu(void)
 
 	displayskin = allskins[skintodisplay];
 
-	sprdef = &displayskin->spritedef;
+	sprdef = &displayskin.spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -9931,25 +9929,24 @@ static void M_DrawLocalSkinMenu(void)
 	V_DrawFill(mx + 220 - (charw/2), my+54, charw, 84, 239);
 #undef charw
 
-	// 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);
+	UINT8 *colormap = R_GetLocalTranslationColormap(&skins[displayskin.localnum], (displayskin.localskin ? &localskins[displayskin.localnum] : 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->playermodel;
+	md2_t *md2 = (displayskin.localskin ? &md2_localplayermodels[skintodisplay] : &md2_playermodels[skintodisplay]);
 
 	// if we have 3d models enabled and a model exists
 	// try to show it instead of the sprite
@@ -9977,9 +9974,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_enemy.c

@@ -2312,7 +2312,7 @@ void A_1upThinker(void *thing)
 		}
 	}
 
-	if (closestplayer == -1 || skins[players[closestplayer].skin]->spritedef.numframes <= states[S_PLAY_BOX1].frame)
+	if (closestplayer == -1 || skins[players[closestplayer].skin].spritedef.numframes <= states[S_PLAY_BOX1].frame)
 	{ // Closest player not found (no players in game?? may be empty dedicated server!), or does not have correct sprite.
 		actor->frame = 0;
 
@@ -2337,7 +2337,7 @@ void A_1upThinker(void *thing)
 	}
 
 	actor->tracer->color = players[closestplayer].mo->color;
-	actor->tracer->skin = skins[players[closestplayer].skin];
+	actor->tracer->skin = &skins[players[closestplayer].skin];
 }
 
 // Function: A_MonitorPop
@@ -2436,7 +2436,7 @@ void A_MonitorPop(void *thing)
 				if (actor->tracer) // Remove the old lives icon.
 					P_RemoveMobj(actor->tracer);
 
-				if (!newmobj->target->skin || newmobj->target->skin->spritedef.numframes <= states[S_PLAY_BOX1].frame)
+				if (!newmobj->target->skin || ((skin_t *)newmobj->target->skin)->spritedef.numframes <= states[S_PLAY_BOX1].frame)
 					newmobj->frame -= 2; // No lives icon for this player, use the default.
 				else
 				{ // Spawn the lives icon.
@@ -2448,7 +2448,7 @@ void A_MonitorPop(void *thing)
 						P_SetTarget(&newmobj->tracer, remains);
 
 						remains->color = newmobj->target->player->mo->color;
-						remains->skin = skins[newmobj->target->player->skin];
+						remains->skin = &skins[newmobj->target->player->skin];
 						P_SetMobjState(remains, newmobj->info->seestate);
 					}
 				}
@@ -3995,14 +3995,14 @@ void A_SignPlayer(void *thing)
 
 	P_SetTarget(&ov->target, actor);
 	ov->color = actor->target->player->skincolor;
-	ov->skin = skins[actor->target->player->skin];
+	ov->skin = &skins[actor->target->player->skin];
 
 	// needs - 1 or else it pukes an error out
 	// same thing happens on p_mobj.c
 	if (actor->target->skinlocal)
-		ov->localskin = localskins[actor->target->player->localskin - 1];
+		ov->localskin = &localskins[actor->target->player->localskin - 1];
 	else if (actor->target->player->localskin)
-		ov->localskin = skins[actor->target->player->localskin - 1];
+		ov->localskin = &skins[actor->target->player->localskin - 1];
 	ov->skinlocal = actor->target->skinlocal;
 
 	P_SetMobjState(ov, actor->info->seestate); // S_PLAY_SIGN

src/p_mobj.c

@@ -6154,7 +6154,7 @@ angle_t P_MobjPitchAndRoll(mobj_t *mobj)
 
 	if (mobj->skin && mobj->sprite == SPR_PLAY)
 	{
-		sprdef = &mobj->skin->spritedef;
+		sprdef = &((skin_t *)mobj->skin)->spritedef;
 
 		if (rot >= sprdef->numframes)
 			sprdef = &sprites[mobj->sprite];
@@ -6280,39 +6280,16 @@ static void P_MobjSceneryThink(mobj_t *mobj)
 		case MT_SMOLDERING:
 			if (leveltime % 2 == 0)
 			{
-				mobj_t *smoke;
 				fixed_t x = P_RandomRange(-35, 35)*mobj->scale;
 				fixed_t y = P_RandomRange(-35, 35)*mobj->scale;
 				fixed_t z = P_RandomRange(0, 70)*mobj->scale;
 
-				smoke = P_SpawnMobj(mobj->x + x, mobj->y + y, mobj->z + z, MT_SMOKE);
+				mobj_t *smoke = P_SpawnMobj(mobj->x + x, mobj->y + y, mobj->z + z, MT_SMOKE);
 				P_SetMobjState(smoke, S_OPAQUESMOKE1);
 				K_MatchGenericExtraFlags(smoke, mobj);
 				smoke->scale = mobj->scale * 2;
 				smoke->destscale = mobj->scale * 6;
-				const INT32 momrand = P_RandomRange(4, 9);
-#ifdef PHOBOS_BUILD
-				smoke->momz = momrand*mobj->scale*P_MobjFlip(smoke);
-#else
-				smoke->momz = momrand*FRACUNIT*P_MobjFlip(smoke);
-
-				// vanilla compat really is annoying.......
-				// but this stuff is messed up on mobjscaled maps
-				// so we gotta respawn it locally to avoid desynchs...
-				if (mapobjectscale != FRACUNIT)
-				{
-					// hide the smoke!
-					smoke->flags2 |= MF2_DONTDRAW;
-
-					smoke = P_SpawnMobj(mobj->x + x, mobj->y + y, mobj->z + z, MT_SMOKE);
-					P_SetMobjState(smoke, S_OPAQUESMOKE1);
-					K_MatchGenericExtraFlags(smoke, mobj);
-					smoke->scale = mobj->scale * 2;
-					smoke->destscale = mobj->scale * 6;
-					smoke->momz = momrand*mobj->scale*P_MobjFlip(smoke);
-					smoke->islocal = true; // Keep this local!
-				}
-#endif
+				smoke->momz = P_RandomRange(4, 9)*FRACUNIT*P_MobjFlip(smoke);
 			}
 			break;
 		case MT_BOOMPARTICLE:
@@ -10939,9 +10916,9 @@ void P_SpawnPlayer(INT32 playernum)
 	// set 'spritedef' override in mobj for player skins.. (see ProjectSprite)
 	// (usefulness: when body mobj is detached from player (who respawns),
 	// the dead body mobj retains the skin through the 'spritedef' override).
-	mobj->skin = skins[p->skin];
+	mobj->skin = &skins[p->skin];
 
-	mobj->localskin = (p->localskin ? R_GetPlayerSkin(p) : NULL);
+	mobj->localskin = (p->localskin ? K_GetPlayerSkin(p) : NULL);
 	mobj->skinlocal = p->skinlocal;
 
 	mobj->health = p->health;

src/p_mobj.h

@@ -266,8 +266,15 @@ typedef enum {
 	PCF_THUNK     = 1<<5, // Ran the thinker this tic.
 } precipflag_t;
 
-
-typedef struct skin_s skin_t;
+typedef struct salty_s
+{
+	bool init;
+	bool ready;
+	bool tapping;
+	fixed_t zoffset;
+	fixed_t momz;
+	bool jump;
+} salty_t;
 
 // Map Object definition.
 typedef struct mobj_s
@@ -344,9 +351,9 @@ typedef struct mobj_s
 	struct mobj_s *hnext;
 	struct mobj_s *hprev;
 
-	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
+	void *skin; // overrides 'sprite' when non-NULL (for player bodies to 'remember' the skin)
+	void *localskin;
+	boolean skinlocal;
 
 	// Player and mobj sprites in multiplayer modes are modified
 	//  using an internal color lookup table for re-indexing.
@@ -405,6 +412,9 @@ 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,10 +1109,6 @@ 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
@@ -1138,17 +1134,9 @@ 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;
@@ -1191,19 +1179,11 @@ 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;
@@ -1344,7 +1324,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)mobj->skin->skinnum);
+		WRITESKIN(save->p, (skinnum_t)((skin_t *)mobj->skin - skins));
 	if (diff2 & MD2_COLOR)
 		WRITEUINT8(save->p, mobj->color);
 	if (diff2 & MD2_EXTVAL1)
@@ -2110,19 +2090,11 @@ 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
@@ -2194,20 +2166,12 @@ 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
@@ -2221,7 +2185,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));
 		}
 	}
 
@@ -3424,13 +3424,7 @@ 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
-		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)
+		if (W_CheckAutoLoadContainsMap(wadfilename))
 		{
 			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_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 = R_GetPlayerSkin(source->player)->soundsid[SKSKPAN1 + key];
+				sfx = K_GetPlayerSkin(source->player)->soundsid[SKSKPAN1 + key];
 
 			S_StartSound(NULL, sfx);
 		}
@@ -1271,7 +1271,7 @@ void P_DoPlayerExit(player_t *player)
 
 			if (islocalplayer)
 			{
-				sfxenum_t sfx_id = R_GetMobjSkin(player->mo)->soundsid[S_sfx[soundid].skinsound];
+				sfxenum_t sfx_id = K_GetMobjSkin(player->mo)->soundsid[S_sfx[soundid].skinsound];
 				S_StartSound(NULL, sfx_id);
 			}
 			else
@@ -4517,33 +4517,27 @@ 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
 
-	I_Assert(player != NULL);
-	I_Assert(!P_MobjWasRemoved(player->mo));
-
-	if (player->spectator)
+	if (player->spectator || !player->mo || player->kartstuff[k_respawn] || player->mo->salty.jump) // this looks jank as hell during hop
 		return;
 
-	// this looks jank as hell during hop or respawn
-	if (player->kartstuff[k_respawn] || player->salty.jump)
-		return;
+	player->squishdance.bounce = 0;
 
 	// 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 = ((60*TICRATE) / (cv_squishdancespeed.value)) << FRACBITS;
+	bpm = FixedDiv((60*TICRATE)<<FRACBITS, FLOAT_TO_FIXED((float)cv_squishdancespeed.value));
 
-	work = (player->squishdance.time << FRACBITS) % bpm;
+	player->squishdance.work = (player->squishdance.time << FRACBITS) % bpm;
 
 	if (player->squishdance.time >= (FRACUNIT >> 1)) // prevent overflow jump - takes about 15 minutes
-		player->squishdance.time = (work >> FRACBITS);
+		player->squishdance.time = (player->squishdance.work >> FRACBITS);
 
-	work = FixedDiv(work*180, bpm);
+	player->squishdance.work = FixedDiv(player->squishdance.work*180, bpm);
 
-	ang = ((FixedAngle(work) >> ANGLETOFINESHIFT) & FINEMASK);
-	bounce = ((FINESINE(ang) - FRACUNIT/2) / 2);
+	player->squishdance.ang = ((FixedAngle(player->squishdance.work) >> ANGLETOFINESHIFT) & FINEMASK);
+	player->squishdance.bounce = ((FINESINE(player->squishdance.ang) - FRACUNIT/2) / 2);
 
-	player->mo->spritexscale -= bounce;
-	player->mo->spriteyscale += bounce;
+	player->mo->spritexscale -= player->squishdance.bounce;
+	player->mo->spriteyscale += player->squishdance.bounce;
 
 	player->squishdance.time++;
 }

src/r_draw.cpp

@@ -94,18 +94,19 @@ spandrawfunc_t *spanfuncs[SPANDRAWFUNC_MAX] = {};
 //                   TRANSLATION COLORMAP CODE
 // =========================================================================
 
-#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 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 SKIN_RAMP_LENGTH 16
 #define DEFAULT_STARTTRANSCOLOR 160
 #define NUM_PALETTE_ENTRIES 256
 
-static UINT8 **specialtranslationtablecache[TT_CACHE_SIZE] = {};
+static UINT8 **translationtablecache[TT_CACHE_SIZE] = {};
+static UINT8 **localtranslationtablecache[MAXLOCALSKINS] = {};
 
 CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1] = {};
 
@@ -377,60 +378,38 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 {
 	UINT8 ***tt;
 	UINT8* ret;
+	INT32 skintableindex;
 
 	if (local)
 	{
-		I_Assert(skinnum >= 0 && skinnum < numlocalskins);
-		tt = &localskins[skinnum]->translationtablecache;
+		tt = localtranslationtablecache;
+		skintableindex = skinnum;
 	}
 	else
 	{
+		tt = translationtablecache;
+
 		// Adjust if we want the default colormap
-		if (skinnum < 0)
+		switch (skinnum)
 		{
-			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;
+			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;
 		}
 	}
 
 	if (flags & GTC_CACHE)
 	{
 		// Allocate table for skin if necessary
-		if (!*tt)
-			*tt = static_cast<UINT8**>(Z_Calloc(MAXTRANSLATIONS * sizeof(UINT8**), PU_STATIC, NULL));
+		if (!tt[skintableindex])
+			tt[skintableindex] = static_cast<UINT8**>(Z_Calloc(MAXTRANSLATIONS * sizeof(UINT8**), PU_STATIC, NULL));
 
 		// Get colormap
-		ret = (*tt)[color];
+		ret = tt[skintableindex][color];
 	}
 	else
 		ret = NULL;
@@ -439,11 +418,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)[color] = ret;
+			tt[skintableindex][color] = ret;
 	}
 
 	return ret;
@@ -456,26 +435,46 @@ 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)
 {
-	const INT32 skinnum = (INT32)((localskin && local) ? localskin->skinnum : (skin != NULL ? skin->skinnum : 0));
-	return RGetTranslationColormap(skinnum, color, flags, (localskin && local));
+	return RGetTranslationColormap(K_GetMobjLocalSkinNum(skin, localskin, local), color, flags, (localskin && local));
 }
 
-patch_t* R_GetSkinFaceRank(player_t* player)
+patch_t* R_GetSkinFaceRank(player_t* ply)
 {
-	const skin_t *skin = R_GetPlayerSkin(player);
-	return skin->facerankprefix;
+	if (ply->localskin)
+	{
+		if (ply->skinlocal)
+			return localfacerankprefix[ply->localskin - 1];
+
+		return facerankprefix[ply->localskin - 1];
+	}
+
+	return facerankprefix[ply->skin];
 }
 
-patch_t* R_GetSkinFaceWant(player_t* player)
+patch_t* R_GetSkinFaceWant(player_t* ply)
 {
-	const skin_t *skin = R_GetPlayerSkin(player);
-	return skin->facewantprefix;
+	if (ply->localskin)
+	{
+		if (ply->skinlocal)
+			return localfacewantprefix[ply->localskin - 1];
+
+		return facewantprefix[ply->localskin - 1];
+	}
+
+	return facewantprefix[ply->skin];
 }
 
-patch_t* R_GetSkinFaceMini(player_t* player)
+patch_t* R_GetSkinFaceMini(player_t* ply)
 {
-	const skin_t *skin = R_GetPlayerSkin(player);
-	return skin->facemmapprefix;
+	if (ply->localskin)
+	{
+		if (ply->skinlocal)
+			return localfacemmapprefix[ply->localskin - 1];
+
+		return facemmapprefix[ply->localskin - 1];
+	}
+
+	return facemmapprefix[ply->skin];
 }
 
 /**	\brief	Flushes cache of translation colormaps.
@@ -494,20 +493,13 @@ void R_FlushTranslationColormapCache(void)
 {
 	INT32 i;
 
-	// 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(translationtablecache) / sizeof(translationtablecache[0])); i++)
+		if (translationtablecache[i])
+			memset(translationtablecache[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**));
+	for (i = 0; i < (INT32)(sizeof(localtranslationtablecache) / sizeof(localtranslationtablecache[0])); i++)
+		if (localtranslationtablecache[i])
+			memset(localtranslationtablecache[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) 2005, 2006 by Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
+// Copyright (C) Copyright 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 = &mo->skin->spritedef;
+		sprdef = &((skin_t *)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]->skinnum];
+						if (allskins[skinnum].localskin)
+							skin = &localskins[allskins[skinnum].localnum];
 						else
-							skin = skins[allskins[skinnum]->skinnum];
+							skin = &skins[allskins[skinnum].localnum];
 						memcpy(&skin->sprinfo, info, sizeof(spriteinfo_t));
 					}
 				}

src/r_segs.cpp

@@ -61,6 +61,7 @@ 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;
@@ -263,7 +264,12 @@ static void R_RenderMaskedSegLoop(drawcolumndata_t* dc, drawseg_t *drawseg, INT3
 		else if (P_ApplyLightOffset(lightnum, frontsector))
 			lightnum += curline->lightOffset;
 
-		walllights = R_GetWallLight(lightnum);
+		if (lightnum < 0)
+			walllights = scalelight[0];
+		else if (lightnum >= LIGHTLEVELS)
+			walllights = scalelight[LIGHTLEVELS - 1];
+		else
+			walllights = scalelight[lightnum];
 	}
 
 	if (frontsector->heightsec != -1)
@@ -365,7 +371,12 @@ static void R_RenderMaskedSegLoop(drawcolumndata_t* dc, drawseg_t *drawseg, INT3
 
 					lightnum = rlight->lightnum;
 
-					xwalllights = R_GetWallLight(lightnum);
+					if (lightnum < 0)
+						xwalllights = scalelight[0];
+					else if (lightnum >= LIGHTLEVELS)
+						xwalllights = scalelight[LIGHTLEVELS-1];
+					else
+						xwalllights = scalelight[lightnum];
 
 					pindex = FixedMul(spryscale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
 
@@ -813,7 +824,12 @@ void R_RenderThickSideRange(drawseg_t *drawseg, INT32 x1, INT32 x2, ffloor_t *pf
 		else if (P_ApplyLightOffset(lightnum, frontsector))
 			lightnum += curline->lightOffset;
 
-		walllights = R_GetWallLight(lightnum);
+		if (lightnum < 0)
+			walllights = scalelight[0];
+		else if (lightnum >= LIGHTLEVELS)
+			walllights = scalelight[LIGHTLEVELS-1];
+		else
+			walllights = scalelight[lightnum];
 	}
 
 	maskedtexturecol = drawseg->thicksidecol;
@@ -955,7 +971,12 @@ void R_RenderThickSideRange(drawseg_t *drawseg, INT32 x1, INT32 x2, ffloor_t *pf
 
 				lightnum = rlight->lightnum;
 
-				xwalllights = R_GetWallLight(lightnum);
+				if (lightnum < 0)
+					xwalllights = scalelight[0];
+				else if (lightnum >= LIGHTLEVELS)
+					xwalllights = scalelight[LIGHTLEVELS-1];
+				else
+					xwalllights = scalelight[lightnum];
 
 				pindex = FixedMul(spryscale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
 
@@ -1446,7 +1467,12 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
 				else if (P_ApplyLightOffset(lightnum, curline->frontsector))
 					lightnum += curline->lightOffset;
 
-				xwalllights = R_GetWallLight(lightnum);
+				if (lightnum < 0)
+					xwalllights = scalelight[0];
+				else if (lightnum >= LIGHTLEVELS)
+					xwalllights = scalelight[LIGHTLEVELS-1];
+				else
+					xwalllights = scalelight[lightnum];
 
 				pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
 
@@ -2525,6 +2551,7 @@ 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;
 
@@ -2537,7 +2564,12 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 		if (P_ApplyLightOffset(lightnum, frontsector))
 			lightnum += curline->lightOffset;
 
-		walllights = R_GetWallLight(lightnum);
+		if (lightnum < 0)
+			walllights = scalelight[0];
+		else if (lightnum >= LIGHTLEVELS)
+			walllights = scalelight[LIGHTLEVELS - 1];
+		else
+			walllights = scalelight[lightnum];
 	}
 
 	// if a floor / ceiling plane is on the wrong side

src/r_segs.h

@@ -22,11 +22,6 @@ 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,9 +40,7 @@ CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2] = {}; // huehuehuehuehue
 INT32 numskins = 0;
 INT32 numallskins = 0;
 INT32 numlocalskins = 0;
-skin_t **skins = NULL;
-skin_t **localskins = NULL;
-skin_t **allskins = NULL;
+skin_t skins[MAXSKINS];
 
 skinnum_t skinstats[9][9][MAXSKINS];
 skinnum_t skinstatscount[9][9] = {
@@ -58,8 +56,17 @@ skinnum_t skinstatscount[9][9] = {
 };
 
 skinnum_t skinsorted[MAXSKINS] = {};
+skin_t localskins[MAXLOCALSKINS] = {};
+skin_t allskins[MAXSKINS+MAXLOCALSKINS] = {};
 
-static void Sk_SetDefaultValue(skin_t *skin)
+// 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)
 {
 	INT32 i;
 	//
@@ -67,7 +74,7 @@ static void Sk_SetDefaultValue(skin_t *skin)
 	//
 	memset(skin, 0, sizeof(skin_t));
 
-	snprintf(skin->name, sizeof skin->name, "skin %u", skin->skinnum); // this will always be "skin 0" cause of the memset above lmao
+	snprintf(skin->name, sizeof skin->name, "skin %u", K_GetMobjSkinNum(skin, local));
 	skin->name[sizeof skin->name - 1] = '\0';
 
 	skin->wadnum = INT16_MAX;
@@ -105,22 +112,35 @@ static void Sk_SetDefaultValue(skin_t *skin)
 void R_InitSkins(void)
 {
 	skin_t *skin;
+#ifdef SKINVALUES
+	INT32 i;
 
-	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);
+	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
 
 	// skin[0] = Sonic skin
-	skin = skins[0] = Z_Calloc(sizeof(skin_t), PU_STATIC, NULL);
-
-	Sk_SetDefaultValue(skin);
-	skin->skinnum = 0;
+	skin = &skins[0];
+	numskins = 1;
+	Sk_SetDefaultValue(skin, false);
 
 	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");
 
@@ -133,6 +153,7 @@ 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;
@@ -142,7 +163,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);
+	ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, 0);
 
 	// Set values for Sonic skin
 	Forceskin_cons_t[1].value = 0;
@@ -156,8 +177,6 @@ void R_InitSkins(void)
 
 	// lets set it
 	allskins[0] = skins[0];
-
-	numskins = 1;
 	numallskins = 1;
 }
 
@@ -169,7 +188,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;
 	}
 
@@ -184,7 +203,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;
 	}
 
@@ -199,7 +218,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;
 		}
 
@@ -217,7 +236,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;
@@ -243,14 +262,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;
 				}
 
@@ -261,14 +280,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;
 				}
 
@@ -293,9 +312,9 @@ setcvar:
 	{
 		if (player->localskin > 0)
 		{
-			skin_t *lskin = R_GetSkinArray(player->skinlocal)[player->localskin-1];
-			CV_StealthSet(&cv_fakelocalskin, lskin->name);
-			CV_StealthSet(cvar, lskin->name);
+			CV_StealthSet(&cv_fakelocalskin, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
+			CV_StealthSet(cvar, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
+
 		}
 		else
 		{
@@ -310,12 +329,10 @@ setcvar:
 void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
 {
 	player_t *player = &players[playernum];
-	skin_t *skin;
+	skin_t *skin = &skins[skinnum];
 
 	if (skinnum >= 0 && skinnum < numskins) // Make sure it exists!
 	{
-		skin = skins[skinnum];
-
 		player->skin = skinnum;
 
 		if (player->mo)
@@ -383,8 +400,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) ==);
 
@@ -471,7 +488,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 	char *stoken;
 	char *value;
 	size_t size;
-	skin_t *skin = NULL;
+	skin_t *skin;
 	boolean hudname, realname;
 
 #define lnumskins (local ? numlocalskins : numskins)
@@ -485,18 +502,16 @@ 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);
@@ -509,19 +524,8 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		buf2[size] = '\0';
 
 		// set defaults
-		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 = &K_GetSkinArray(local)[lnumskins];
+		Sk_SetDefaultValue(skin, local);
 		skin->wadnum = wadnum;
 		hudname = realname = false;
 
@@ -773,19 +777,24 @@ 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;
-			ST_LoadFaceGraphics(skin);
+			skin->localnum = numskins;
+			ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numskins);
 		}
 		else
 		{
 			skin->localskin = true;
-			ST_LoadFaceGraphics(skin);
+			skin->localnum = numlocalskins;
+			ST_LoadLocalFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numlocalskins);
 		}
 
 #ifdef HWRENDER
@@ -801,8 +810,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 			skinsorted[numskins] = numskins;
 		}
 
-		allskins = Z_Realloc(allskins, sizeof(skin_t*) * (numallskins + 1), PU_STATIC, NULL);
-		allskins[numallskins] = R_GetSkinArray(local)[lnumskins];
+		allskins[numallskins] = K_GetSkinArray(local)[lnumskins];
 
 		local ? numlocalskins++ : numskins++;
 		numallskins++;
@@ -812,50 +820,3 @@ 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,7 +16,6 @@
 #ifndef __R_SKINS__
 #define __R_SKINS__
 
-#include "doomtype.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -25,10 +24,6 @@ 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')
@@ -40,7 +35,7 @@ extern "C" {
 #define DEFAULTSKIN3 "knuckles" // third player
 #define DEFAULTSKIN4 "eggman" // fourth player
 
-typedef struct skin_s
+typedef struct
 {
 	char name[SKINNAMESIZE+1]; // INT16 descriptive name of the skin
 	spritedef_t spritedef;
@@ -53,17 +48,12 @@ typedef struct skin_s
 	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
@@ -71,13 +61,8 @@ typedef struct skin_s
 	// specific sounds per skin
 	sfxenum_t soundsid[NUMSKINSOUNDS]; // sound # in S_sfx table
 
-#ifdef HWRENDER
-	md2_t playermodel;
-#endif
-
 	boolean localskin;
-	skinnum_t skinnum;
-	UINT16 allskinnum;
+	INT32 localnum;
 } skin_t;
 
 extern CV_PossibleValue_t Forceskin_cons_t[];
@@ -85,14 +70,14 @@ extern CV_PossibleValue_t Forceskin_cons_t[];
 extern INT32 numskins;
 extern INT32 numlocalskins;
 extern INT32 numallskins;
-extern skin_t **skins;
-extern skin_t **localskins;
-extern skin_t **allskins;
-
+extern skin_t skins[MAXSKINS];
 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);
@@ -105,11 +90,13 @@ INT32 R_AnySkinAvailable(const char *name);
 INT32 R_LocalSkinAvailable(const char *name, boolean local);
 
 // had to move those here Zzz...
-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);
+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);
 
 void sortSkinGrid(void);
 

src/r_things.cpp

@@ -1062,7 +1062,12 @@ static void R_SplitSprite(vissprite_t *sprite)
 		{
 			INT32 lightnum = R_GetSoftLightlevel(*sector->lightlist[i].lightlevel);
 
-			spritelights = R_GetWallLight(lightnum);
+			if (lightnum < 0)
+				spritelights = scalelight[0];
+			else if (lightnum >= LIGHTLEVELS)
+				spritelights = scalelight[LIGHTLEVELS-1];
+			else
+				spritelights = scalelight[lightnum];
 
 			newsprite->extra_colormap = sector->lightlist[i].extra_colormap;
 
@@ -1276,7 +1281,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 = R_GetMobjSkin(thing);
+	sprskin = K_GetMobjSkin(thing);
 
 	//Fab : 02-08-98: 'skin' override spritedef currently used for skin
 	if (sprskin && thing->sprite == SPR_PLAY)
@@ -1740,7 +1745,12 @@ static void R_ProjectSprite(mobj_t *thing)
 			}
 		}
 
-		lights_array = R_GetWallLight(lightnum);
+		if (lightnum < 0)
+			lights_array = scalelight[0];
+		else if (lightnum >= LIGHTLEVELS)
+			lights_array = scalelight[LIGHTLEVELS-1];
+		else
+			lights_array = scalelight[lightnum];
 	}
 
 	// store information in a vissprite
@@ -2077,11 +2087,16 @@ 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);
-		spritelights = R_GetWallLight(lightnum);
+
+		if (lightnum < 0)
+			spritelights = scalelight[0];
+		else if (lightnum >= LIGHTLEVELS)
+			spritelights = scalelight[LIGHTLEVELS-1];
+		else
+			spritelights = scalelight[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 = R_GetMobjSkin(origin)->soundsid[sfx->skinsound];
+		sfx_id = K_GetMobjSkin(origin)->soundsid[sfx->skinsound];
 		sfx = &S_sfx[sfx_id];
 	}
 

src/st_stuff.c

@@ -60,6 +60,22 @@ 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
 // ------------------------------------------
@@ -227,11 +243,30 @@ void ST_LoadGraphics(void)
 }
 
 // made separate so that skins code can reload custom face graphics
-void ST_LoadFaceGraphics(skin_t *skin)
+void ST_LoadFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 skinnum)
 {
-	skin->facerankprefix = W_CachePatchName(skin->facerank, PU_HUDGFX);
-	skin->facewantprefix = W_CachePatchName(skin->facewant, PU_HUDGFX);
-	skin->facemmapprefix = W_CachePatchName(skin->facemmap, PU_HUDGFX);
+	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);
 }
 
 void ST_ReloadSkinFaceGraphics(void)
@@ -239,10 +274,10 @@ void ST_ReloadSkinFaceGraphics(void)
 	INT32 i;
 
 	for (i = 0; i < numskins; i++)
-		ST_LoadFaceGraphics(skins[i]);
+		ST_LoadFaceGraphics(skins[i].facerank, skins[i].facewant, skins[i].facemmap, i);
 
 	for (i = 0; i < numlocalskins; i++)
-		ST_LoadFaceGraphics(localskins[i]);
+		ST_LoadLocalFaceGraphics(localskins[i].facerank, localskins[i].facewant, localskins[i].facemmap, i);
 }
 
 static inline void ST_InitData(void)

src/st_stuff.h

@@ -58,7 +58,8 @@ void ST_UnloadGraphics(void);
 void ST_LoadGraphics(void);
 
 // face load graphics, called when skin changes
-void ST_LoadFaceGraphics(skin_t *skin);
+void ST_LoadFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 playernum);
+void ST_LoadLocalFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 playernum);
 void ST_ReloadSkinFaceGraphics(void);
 
 // return if player a is in the same team as player b
@@ -75,6 +76,14 @@ 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/y_inter.c

@@ -1190,7 +1190,8 @@ void Y_VoteDrawer(void)
 			if (player->skincolor)
 			{
 				UINT8 *colormap = R_GetTranslationColormap(player->skin, player->skincolor, GTC_CACHE);
-				patch_t *faceprefix = K_GetFacePrefix(player, R_GetPlayerSkinNum(player));
+
+				patch_t *faceprefix = K_GetFacePrefix(player, K_GetSkinNum(player));
 
 				if (K_UseHighResPortraits())
 					V_DrawSmallMappedPatch(x+24, y+9, V_SNAPTOLEFT, faceprefix, colormap);

src/z_zone.cpp

@@ -804,6 +804,27 @@ void* Z_LevelPoolMalloc(size_t size)
 	return p;
 }
 
+boolean Z_IsMobjValid2(void *p, const char *file, INT32 line)
+{
+	//(void)file;
+	//(void)line;
+
+	// mobj was removed
+	// no need to worry here
+	if (p == NULL)
+		return false;
+
+	// mobjs reside in the large pool
+	if (!g_level_large_pool.ptrcheck(p))
+	{
+		//I_Error("invalid mobj! at %s:%d", file, line);
+		CONS_Alert(CONS_ERROR, "invalid mobj! at %s:%d", file, line);
+		return false;
+	}
+
+	return true;
+}
+
 void* Z_LevelPoolCalloc(size_t size)
 {
 	void* p = Z_LevelPoolMalloc(size);

src/z_zone.h

@@ -173,6 +173,8 @@ char *Z_StrDup(const char *in);
 size_t Z_LevelPoolUsage(void);
 void *Z_LevelPoolMalloc(size_t size);
 void *Z_LevelPoolCalloc(size_t size);
+#define Z_IsMobjValid(p) Z_IsMobjValid2(p, __FILE__, __LINE__)
+boolean Z_IsMobjValid2(void *p, const char *file, INT32 line);
 void Z_LevelPoolFree(void *p, size_t size);
 
 // for use with CLEANUP macro