Merge branch 'Saturn-Next' into retrySOCK

windoze.......

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_netcmd.c

@@ -1176,14 +1176,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;
 		}
 	}
@@ -1191,7 +1191,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)
 	{
@@ -1205,7 +1205,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;
@@ -1220,7 +1220,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");
@@ -1555,13 +1555,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);
 		}
 	}
 }
@@ -1615,8 +1615,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);
 	}
@@ -1627,7 +1627,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)
@@ -1656,12 +1656,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);
 		}
@@ -1686,7 +1686,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)
@@ -1694,7 +1694,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;
 	}
 
@@ -1782,13 +1782,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);
@@ -4358,10 +4358,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
 	{
@@ -5634,7 +5634,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;
 	}
 
@@ -5643,7 +5643,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);
 	}
 }
 
@@ -5664,7 +5664,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);
 	}
 }
 
@@ -5680,7 +5680,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);
 	}
 }
 
@@ -5696,7 +5696,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);
 	}
 }
 
@@ -5739,7 +5739,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;
@@ -5747,7 +5747,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",
@@ -5777,7 +5777,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)))
 			{
@@ -5801,7 +5801,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/discord.c

@@ -686,7 +686,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;
@@ -703,7 +703,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

@@ -202,7 +202,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)
 		{
@@ -265,7 +265,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;
@@ -395,12 +395,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)
@@ -1806,7 +1806,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;
 
@@ -1820,8 +1820,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
@@ -1877,7 +1877,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;
 
@@ -2350,7 +2350,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;
@@ -2998,7 +2998,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
@@ -3075,7 +3075,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';
@@ -3282,9 +3282,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;
 		}
 	}
@@ -3292,7 +3292,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

@@ -3580,7 +3580,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);
 
@@ -4655,8 +4655,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])
@@ -4878,7 +4887,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 = NULL;
+		int skinnum = 0;
 		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
+		else if (spr->mobj->skin)
 		{
+			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/i_tcp.c

@@ -752,9 +752,14 @@ static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr
 
 static void SOCK_Send(void)
 {
-	ssize_t c = ERRSOCKET;
-	int e = 0; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
 	size_t i, j;
+	int retrycount = 0;
+	ssize_t c;
+	int e; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
+
+retry:
+	c = ERRSOCKET;
+	e = 0;
 
 	if (doomcom->remotenode < 0 || !nodeconnected[doomcom->remotenode])
 		return;
@@ -808,10 +813,35 @@ static void SOCK_Send(void)
 
 	if (c == ERRSOCKET && e != 0) // 0 means no socket for the address family was found
 	{
-		if (!ALLOWEDERROR(e))
-			I_Error("SOCK_Send, error sending to node %d (%s) #%u, %s", doomcom->remotenode,
+		if (ALLOWEDERROR(e))
+			return;
+
+		//if (!ALLOWEDERROR(e))
+			//I_Error("SOCK_Send, error sending to node %d (%s) #%u, %s", doomcom->remotenode,
+				//SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
+
+		// no need to spam this on retries
+		if (retrycount == 0)
+			CONS_Alert(CONS_ERROR, "SOCK_Send, error sending to node %d (%s) #%u, %s\n", doomcom->remotenode,
+					SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
+
+		// retry sending it
+		if (retrycount <= 3)
+		{
+			CONS_Printf("SOCK_Send: retrying... Attempt %d\n", retrycount+1);
+			retrycount++;
+			// wait quarter of a second or smth
+			I_Sleep(250);
+			goto retry;
+		}
+
+		// no recovery, guess we die
+		I_Error("SOCK_Send, error sending to node %d (%s) #%u, %s", doomcom->remotenode,
 				SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
 	}
+
+	if (retrycount > 0)
+		CONS_Alert(CONS_NOTICE, "SOCK_Send: successfully reconnected on Attempt %d\n", retrycount);
 }
 #undef ALLOWEDERROR
 

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;
@@ -3828,7 +3830,7 @@ static void K_drawKartMinimap(void)
 				else
 				{
 					// special case if startcolor is not the default (160 / Green)
-					if (R_GetMobjSkin(mobj)->starttranscolor != skins[0]->starttranscolor)
+					if (K_GetMobjSkin(mobj)->starttranscolor != skins[0].starttranscolor)
 					{
 						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
 					}
@@ -4903,7 +4905,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

@@ -592,7 +592,7 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
 	if (color >= MAXTRANSLATIONS)
 		I_Error("Invalid skin color #%hu.", (UINT16)color);
 
-	starttranscolor = (skinnum != TC_DEFAULT) ? 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 +632,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
@@ -1935,7 +1989,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)

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

@@ -217,15 +217,7 @@ static int mobj_get(lua_State *L)
 	case mobj_skin: // skin name or nil, not struct
 		if (!mo->skin)
 			return 0;
-		// HUD ONLY!!!!!!!!!!
-		if LOCALSKINIMMERSION
-		{
-			lua_pushstring(L, R_GetMobjSkin(mo)->name);
-		}
-		else
-		{
-			lua_pushstring(L, mo->skin->name);
-		}
+		lua_pushstring(L, ((skin_t *)mo->skin)->name);
 		break;
 	case mobj_color:
 		lua_pushinteger(L, mo->color);
@@ -379,7 +371,7 @@ static int mobj_get(lua_State *L)
 		break;
 	case mobj_localskin:
 		if (mo->localskin)
-			lua_pushstring(L, mo->localskin->name);
+			lua_pushstring(L, ((skin_t *)mo->localskin)->name);
 		else
 			lua_pushnil(L);
 		break;
@@ -552,9 +544,9 @@ static int mobj_set(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;
 				}
 			}
@@ -765,9 +757,9 @@ static int mobj_set(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;
 						}
@@ -776,9 +768,9 @@ static int mobj_set(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

@@ -615,7 +615,7 @@ static int player_get(lua_State *L)
 	// Saturn
 	case player_localskin:
 		if (plr->localskin)
-			lua_pushstring(L, R_GetPlayerSkin(plr)->name);
+			lua_pushstring(L, K_GetPlayerSkin(plr)->name);
 		else
 			lua_pushnil(L);
 		break;

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
@@ -4564,9 +4564,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,
@@ -4787,9 +4787,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,
@@ -4978,15 +4978,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);
 			}
@@ -6272,17 +6270,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
@@ -7730,7 +7728,7 @@ static void M_DrawMPMainMenu(void)
 					break;
 			}
 
-			if (pskin >= numskins)
+			if (pskin >= MAXSKINS)
 				pskin = 0;
 
 			if (!trans && i > cv_splitplayers.value)
@@ -7738,7 +7736,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)
 			{
@@ -7999,12 +7997,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:
@@ -8026,10 +8024,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)
 			{
@@ -8043,7 +8041,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,
@@ -8149,10 +8147,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);
 				}
 			}
@@ -8208,10 +8206,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);
 				}
 			}
@@ -8245,8 +8243,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);
 			}
@@ -8283,8 +8281,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);
 			}
@@ -8298,7 +8296,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
@@ -8312,8 +8310,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);
@@ -8352,8 +8350,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);
 				}
@@ -8370,7 +8368,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
@@ -8384,8 +8382,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;
@@ -8469,14 +8467,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;
 			}
@@ -8530,15 +8528,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!
@@ -8556,7 +8554,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;
@@ -8587,11 +8585,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
@@ -8898,7 +8896,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
@@ -9121,7 +9119,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;
@@ -9897,7 +9895,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;
@@ -9939,7 +9937,7 @@ static void M_DrawLocalSkinMenu(void)
 
 	displayskin = allskins[skintodisplay];
 
-	sprdef = &displayskin->spritedef;
+	sprdef = &displayskin.spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -9952,25 +9950,25 @@ 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);
+	// FIXME: is skins[displayskin.localnum] even correct?
+	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[displayskin.localnum] : &md2_playermodels[skintodisplay]);
 
 	// if we have 3d models enabled and a model exists
 	// try to show it instead of the sprite
@@ -9998,9 +9996,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];
@@ -10958,9 +10958,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

@@ -265,8 +265,6 @@ typedef enum {
 } precipflag_t;
 
 
-typedef struct skin_s skin_t;
-
 // Map Object definition.
 typedef struct mobj_s
 {
@@ -342,9 +340,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.

src/p_saveg.c

@@ -1344,7 +1344,7 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
 	if (diff2 & MD2_CVMEM)
 		WRITEINT32(save->p, mobj->cvmem);
 	if (diff2 & MD2_SKIN)
-		WRITESKIN(save->p, (skinnum_t)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)
@@ -2221,7 +2221,7 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
 	if (diff2 & MD2_CVMEM)
 		mobj->cvmem = READINT32(save->p);
 	if (diff2 & MD2_SKIN)
-		mobj->skin = skins[READSKIN(save->p)];
+		mobj->skin = &skins[READSKIN(save->p)];
 	if (diff2 & MD2_COLOR)
 		mobj->color = READUINT8(save->p);
 	if (diff2 & MD2_EXTVAL1)

src/p_setup.c

@@ -2483,28 +2483,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;
 					}
 				}
 			}
@@ -2512,10 +2512,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;
 		}
 	}
 }
@@ -2542,8 +2542,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));
 		}
 	}
 
@@ -2555,8 +2555,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));
 		}
 	}
 
@@ -2568,8 +2568,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));
 		}
 	}
 

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

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_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_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

@@ -1276,7 +1276,7 @@ static void R_ProjectSprite(mobj_t *thing)
 	const boolean shouldrotate = (interp.sloperoll || interp.slopepitch || interp.roll || interp.pitch || thing->rollangle || thing->temprollangle || sliprollrotate);
 #endif
 
-	sprskin = 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/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);