SRB2Kart-Saturn/src/r_skins.c

// SONIC ROBO BLAST 2 KART
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Vivian "toastergrl" Grannell.
// Copyright (C) 2025 by Kart Krew.
// Copyright (C) 2020 by Sonic Team Junior.
// Copyright (C) 2000 by DooM Legacy Team.
// Copyright (C) 1996 by id Software, Inc.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file  r_skins.c
/// \brief Loading skins

#include "dehacked.h" // get_number (for thok)
#include "doomdef.h"
#include "console.h"
#include "r_draw.h"
#include "r_things.h"
#include "r_skins.h"
#include "g_game.h"
#include "k_kart.h" // SRB2kart
#include "p_local.h"
#include "st_stuff.h"
#include "i_video.h" // rendermode
#include "w_wad.h"
#include "z_zone.h"

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

#include "qs22j.h"

CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2] = {}; // huehuehuehuehue

#include "discord.h"

INT32 numskins = 0;
INT32 numallskins = 0;
INT32 numlocalskins = 0;
skin_t skins[MAXSKINS];

UINT8 skinstats[9][9][MAXSKINS];
UINT8 skinstatscount[9][9] = {
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 1, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0}
};

UINT8 skinsorted[MAXSKINS] = {};
skin_t localskins[MAXLOCALSKINS] = {};
skin_t allskins[MAXSKINS+MAXLOCALSKINS] = {};

// FIXTHIS: don't work because it must be inistilised before the config load
//#define SKINVALUES
#ifdef SKINVALUES
CV_PossibleValue_t skin_cons_t[MAXSKINS+1] = {};
CV_PossibleValue_t localskin_cons_t[MAXLOCALSKINS+1] = {};
#endif

static void Sk_SetDefaultValue(skin_t *skin, boolean local)
{
	INT32 i;
	//
	// set default skin values
	//
	memset(skin, 0, sizeof(skin_t));

	snprintf(skin->name, sizeof skin->name, "skin %u", K_GetMobjSkinNum(skin, local));
	skin->name[sizeof skin->name - 1] = '\0';

	skin->wadnum = INT16_MAX;

	strcpy(skin->sprite, "");

	strcpy(skin->realname, "Someone");
	strcpy(skin->hudname, "???");
	strncpy(skin->facerank, "PLAYRANK", 9);
	strncpy(skin->facewant, "PLAYWANT", 9);
	strncpy(skin->facemmap, "PLAYMMAP", 9);

	skin->starttranscolor = 160;
	skin->prefcolor = SKINCOLOR_GREEN;

	// SRB2kart
	skin->kartspeed = 5;
	skin->kartweight = 5;
	//

	skin->highresscale = FRACUNIT>>1;

	for (i = 0; i < sfx_skinsoundslot0; i++)
	{
		const INT32 skinsound = S_sfx[i].skinsound;

		if (skinsound != -1)
			skin->soundsid[skinsound] = i;
	}
}

//
// Initialize the basic skins
//
void R_InitSkins(void)
{
	skin_t *skin;
#ifdef SKINVALUES
	INT32 i;

	for (i = 0; i <= MAXSKINS; i++)
	{
		skin_cons_t[i].value = 0;
		skin_cons_t[i].strvalue = NULL;
	}
	for (i = 0; i <= MAXLOCALSKINS; i++)
	{
		localskin_cons_t[i].value = 0;
		localskin_cons_t[i].strvalue = NULL;
	}
#endif

	// skin[0] = Sonic skin
	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");

	strncpy(skin->facerank, "PLAYRANK", 9);
	strncpy(skin->facewant, "PLAYWANT", 9);
	strncpy(skin->facemmap, "PLAYMMAP", 9);

	skin->flags = 0;

	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;
	skin->kartweight = 2;
	//

	skin->spritedef.numframes = sprites[SPR_PLAY].numframes;
	skin->spritedef.spriteframes = sprites[SPR_PLAY].spriteframes;
	skin->sprinfo = spriteinfo[SPR_PLAY];
	ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, 0);

	// Set values for Sonic skin
	Forceskin_cons_t[1].value = 0;
	Forceskin_cons_t[1].strvalue = skin->name;

	//MD2 for sonic doesn't want to load in Linux.
#ifdef HWRENDER
	if (rendermode == render_opengl)
		HWR_AddPlayerMD2(0, false);
#endif

	// lets set it
	allskins[0] = skins[0];
	numallskins = 1;
}

// returns true if the skin name is found (loaded from pwad)
// warning return -1 if not found
INT32 R_SkinAvailable(const char *name)
{
	INT32 i;

	for (i = 0; i < numskins; i++)
	{
		if (fasticmp(skins[i].name, name))
			return i;
	}

	return -1;
}

// returns true if the skin name is found (loaded from pwad)
// warning return -1 if not found
INT32 R_AnySkinAvailable(const char *name)
{
	INT32 i;

	for (i = 0; i < numallskins; i++)
	{
		if (fasticmp(allskins[i].name, name))
			return i;
	}

	return -1;
}

INT32 R_LocalSkinAvailable(const char *name, boolean local)
{
	INT32 i;

	if (local)
	{
		for (i = 0; i < numlocalskins; i++)
		{
			if (fasticmp(localskins[i].name, name))
				return i;
		}

		return -1;
	}

	return R_SkinAvailable(name);
}

// network code calls this when a 'skin change' is received
boolean SetPlayerSkin(INT32 playernum, const char *skinname)
{
	INT32 i;

	for (i = 0; i < numskins; i++)
	{
		// search in the skin list
		if (fasticmp(skins[i].name, skinname))
		{
			SetPlayerSkinByNum(playernum, i);
			return true;
		}
	}

	if (P_IsLocalPlayer(&players[playernum]))
		CONS_Alert(CONS_WARNING, M_GetText("Skin '%s' not found.\n"), skinname);
	else if (server || IsPlayerAdmin(consoleplayer))
		CONS_Alert(CONS_WARNING, M_GetText("Player %d (%s) skin '%s' not found\n"), playernum, player_names[playernum], skinname);

	SetPlayerSkinByNum(playernum, 0);
	return false;
}

void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
{
	INT32 i;
	player_t *player = &players[playernum];

	if (!fasticmp(skinname, "none"))
	{
		for (i = 0; i < numlocalskins; i++)
		{
			// search in the localskin list
			if (fasticmp(localskins[i].name, skinname))
			{
				player->localskin = 1 + i;
				player->skinlocal = true;

				if (player->mo)
				{
					player->mo->localskin = &localskins[i];
					player->mo->skinlocal = true;
				}

				goto setcvar;
			}
		}

		for (i = 0; i < numskins; i++)
		{
			// search in the skin list
			if (fasticmp(skins[i].name, skinname))
			{
				player->localskin = 1 + i;
				player->skinlocal = false;

				if (player->mo)
				{
					player->mo->localskin = &skins[i];
					player->mo->skinlocal = false;
				}

				goto setcvar;
			}
		}
	}
	else
	{
		player->localskin = 0;
		player->skinlocal = false;

		if (player->mo)
		{
			player->mo->localskin = NULL;
			player->mo->skinlocal = false;
		}
	}

setcvar:
	if (cvar != NULL)
	{
		if (player->localskin > 0)
		{
			CV_StealthSet(&cv_fakelocalskin, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
			CV_StealthSet(cvar, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);

		}
		else
		{
			CV_StealthSet(&cv_fakelocalskin, "none");
			CV_StealthSet(cvar, "none");
		}
	}
}

// Same as SetPlayerSkin, but uses the skin #.
// network code calls this when a 'skin change' is received
void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
{
	player_t *player = &players[playernum];
	skin_t *skin = &skins[skinnum];

	if (skinnum >= 0 && skinnum < numskins) // Make sure it exists!
	{
		player->skin = skinnum;

		if (player->mo)
			player->mo->skin = skin;

		player->charflags = (UINT32)skin->flags;

		// SRB2kart
		player->kartspeed = skin->kartspeed;
		player->kartweight = skin->kartweight;

		if (player->mo)
			P_SetScale(player->mo, player->mo->scale);

		// for replays: We have changed our skin mid-game; let the game know so it can do the same in the replay!
		demo_extradata[playernum] |= DXD_SKIN;

#ifdef HAVE_DISCORDRPC
		if (player - players == consoleplayer)
			DRPC_UpdatePresence();
#endif

		return;
	}

	if (P_IsLocalPlayer(player))
		CONS_Alert(CONS_WARNING, M_GetText("Skin %d not found\n"), skinnum);
	else if (server || IsPlayerAdmin(consoleplayer))
		CONS_Alert(CONS_WARNING, "Player %d (%s) skin %d not found\n", playernum, player_names[playernum], skinnum);

	SetPlayerSkinByNum(playernum, 0); // not found put the sonic skin
}

//
// Add skins from a pwad, each skin preceded by 'S_SKIN' marker
//

// Does the same is in w_wad, but check only for
// the first 6 characters (this is so we can have S_SKIN1, S_SKIN2..
// for wad editors that don't like multiple resources of the same name)
//
static UINT16 W_CheckForSkinMarkerInPwad(UINT16 wadid, UINT16 startlump)
{
	UINT16 i;
	lumpinfo_t *lump_p;

	// scan forward, start at <startlump>
	if (startlump < wadfiles[wadid]->numlumps)
	{
		lump_p = wadfiles[wadid]->lumpinfo + startlump;

		for (i = startlump; i < wadfiles[wadid]->numlumps; i++, lump_p++)
		{
			if (memcmp(lump_p->name, "S_SKIN", 6) == 0)
				return i;
		}
	}

	return INT16_MAX; // not found
}

//sort function for sorting skin names
static int skinSortFunc(const void *a, const void *b) // tbh i have no clue what the naming conventions for local functions are
{
	int diff = 0;
	const UINT8 val_a = *(const UINT8 *)a;
	const UINT8 val_b = *(const UINT8 *)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) ==);

	switch (cv_skinselectgridsort.value)
	{
		case SKINMENUSORT_REALNAME:
			// CONS_Printf("Sorting by realname\n");
			// check name
			diff = strcmp(in1->realname, in2->realname);
			if (diff != 0) return diff;

			break;
		case SKINMENUSORT_SPEED:
			// CONS_Printf("Sorting by speed\n");
			// check speed
			diff = in1->kartspeed - in2->kartspeed;
			if (diff != 0) return diff;

			// then check weight
			diff = in1->kartweight - in2->kartweight;
			if (diff != 0) return diff;

			// then check name
			diff = strcmp(in1->realname, in2->realname);
			if (diff != 0) return diff;

			break;
		case SKINMENUSORT_WEIGHT:
			// CONS_Printf("Sorting by weight\n");
			// check weight
			diff = in1->kartweight - in2->kartweight;
			if (diff != 0) return diff;

			// then check speed
			diff = in1->kartspeed - in2->kartspeed;
			if (diff != 0) return diff;

			// then check name
			diff = strcmp(in1->realname, in2->realname);
			if (diff != 0) return diff;

			break;
		case SKINMENUSORT_PREFCOLOR:
			// CONS_Printf("Sorting by prefcolor\n");
			// check prefcolor
			diff = in1->prefcolor - in2->prefcolor;
			if (diff != 0) return diff;

			// then check name
			diff = strcmp(in1->realname, in2->realname);
			if (diff != 0) return diff;

			break;
		case SKINMENUSORT_ID:
			// CONS_Printf("Sorting by id\n");
			// how do i do by ID?????
			// wait why dont i just convert the inputs to UINT32s
			// please tell me im allowed to define variables in here since its a block
			return (int)val_a - (int)val_b;
		case SKINMENUSORT_NAME:
		default:
			break;
	}

	// im scared this somehow will sometimes end up here so im gonna add this here just to be safe
	// now it will often end up here >:3
	return strcmp(in1->name, in2->name);
}

void sortSkinGrid(void)
{
	//CONS_Printf("Sorting skin list (%d)...\n", cv_skinselectgridsort.value);
	qs22j(skinsorted, numskins, sizeof(UINT8), skinSortFunc);
}

//
// Find skin sprites, sounds & optional status bar face, & add them
//
void R_AddSkins(UINT16 wadnum, boolean local)
{
	UINT16 lump, lastlump = 0;
	char *buf;
	char *buf2;
	char *stoken;
	char *value;
	size_t size;
	skin_t *skin;
	boolean hudname, realname;

#define lnumskins (local ? numlocalskins : numskins)

	//
	// search for all skin markers in pwad
	//

	while ((lump = W_CheckForSkinMarkerInPwad(wadnum, lastlump)) != INT16_MAX)
	{
		// advance by default
		lastlump = lump + 1;

		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)
		{
			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);

		// for strtok
		buf2 = malloc(size+1);
		if (!buf2)
			I_Error("R_AddSkins: No more free memory\n");
		memcpy(buf2,buf,size);
		buf2[size] = '\0';

		// set defaults
		skin = &K_GetSkinArray(local)[lnumskins];
		Sk_SetDefaultValue(skin, local);
		skin->wadnum = wadnum;
		hudname = realname = false;

		// parse
		stoken = strtok(buf2, "\r\n= ");
		while (stoken)
		{
			if ((stoken[0] == '/' && stoken[1] == '/')
				|| (stoken[0] == '#'))// skip comments
			{
				strtok(NULL, "\r\n"); // skip end of line
				stoken = strtok(NULL, "\r\n= ");
				continue; // find the real next token
			}

			value = strtok(NULL, "\r\n= ");

			if (!value)
				I_Error("R_AddSkins: syntax error in S_SKIN lump# %d(%s) in WAD %s\n", lump, W_CheckNameForNumPwad(wadnum,lump), wadfiles[wadnum]->filename);

			if (fasticmp(stoken, "name"))
			{
				// the skin name must uniquely identify a single skin
				// I'm lazy so if name is already used I leave the 'skin x'
				// default skin name set in Sk_SetDefaultValue
				if (R_LocalSkinAvailable(value, local) == -1)
				{
					STRBUFCPY(skin->name, value);
					strlwr(skin->name);
				}
				// I'm not lazy, so if the name is already used I make the name 'namex'
				// using the default skin name's number set above
				else
				{
					const size_t stringspace = strlen(value) + sizeof lnumskins + 1;
					char *value2 = Z_Malloc(stringspace, PU_STATIC, NULL);

					snprintf(value2, stringspace, "%s%d", value, lnumskins);
					value2[stringspace - 1] = '\0';

					if (R_LocalSkinAvailable(value2, local) == -1)
					{
						STRBUFCPY(skin->name, value2);
						strlwr(skin->name);
					}

					Z_Free(value2);
				}

				// copy to hudname and fullname as a default.
				if (!realname)
				{
					STRBUFCPY(skin->realname, skin->name);
					for (value = skin->realname; *value; value++)
						if (*value == '_') *value = ' '; // turn _ into spaces.
				}

				if (!hudname)
				{
					STRBUFCPY(skin->hudname, skin->name);
					strupr(skin->hudname);

					for (value = skin->hudname; *value; value++)
						if (*value == '_') *value = ' '; // turn _ into spaces.
				}
			}
			else if (fasticmp(stoken, "realname"))
			{ // Display name (eg. "Knuckles")
				realname = true;
				STRBUFCPY(skin->realname, value);

				for (value = skin->realname; *value; value++)
					if (*value == '_') *value = ' '; // turn _ into spaces.

				if (!hudname)
					STRBUFCPY(skin->hudname, skin->realname);
			}
			else if (fasticmp(stoken, "hudname"))
			{ // Life icon name (eg. "K.T.E")
				hudname = true;
				STRBUFCPY(skin->hudname, value);

				for (value = skin->hudname; *value; value++)
					if (*value == '_') *value = ' '; // turn _ into spaces.

				if (!realname)
					STRBUFCPY(skin->realname, skin->hudname);
			}
			else if (fasticmp(stoken, "sprite"))
			{
				strupr(value);
				memcpy(skin->sprite, value, sizeof skin->sprite);
			}
			else if (fasticmp(stoken, "facerank"))
			{
				strupr(value);
				memcpy(skin->facerank, value, sizeof(skin->facerank)-1);
				skin->facerank[sizeof(skin->facerank)-1] = '\0';
			}
			else if (fasticmp(stoken, "facewant"))
			{
				strupr(value);
				memcpy(skin->facewant, value, sizeof(skin->facewant)-1);
				skin->facewant[sizeof(skin->facewant)-1] = '\0';
			}
			else if (fasticmp(stoken, "facemmap"))
			{
				strupr(value);
				strncpy(skin->facemmap, value, sizeof(skin->facemmap)-1);
				skin->facemmap[sizeof(skin->facemmap)-1] = '\0';
			}
			else if (fasticmp(stoken, "flags")) // character type identification
			{
				skin->flags = get_number(value);
			}
			else if (fasticmp(stoken, "kartspeed"))
			{
				skin->kartspeed = atoi(value);

				if (skin->kartspeed < 1)
					skin->kartspeed = 1;
				if (skin->kartspeed > 9)
					skin->kartspeed = 9;
			}
			else if (fasticmp(stoken, "kartweight"))
			{
				skin->kartweight = atoi(value);

				if (skin->kartweight < 1)
					skin->kartweight = 1;
				if (skin->kartweight > 9)
					skin->kartweight = 9;
			}
			// custom translation table
			else if (fasticmp(stoken, "startcolor"))
			{
				skin->starttranscolor = atoi(value);
			}
			else if (fasticmp(stoken, "prefcolor"))
			{
				skin->prefcolor = K_GetKartColorByName(value);
			}
			else if (fasticmp(stoken, "highresscale"))
			{
				skin->highresscale = FLOAT_TO_FIXED(atof(value));
			}
			else
			{
				INT32 found = false;
				sfxenum_t i;

				// copy name of sounds that are remapped
				// for this skin
				for (i = 0; i < sfx_skinsoundslot0; i++)
				{
					const sfxinfo_t *sfx = &S_sfx[i];

					if (!sfx->name)
						continue;

					if (sfx->skinsound != -1
					&& fasticmp(sfx->name, stoken + 2))
					{
						skin->soundsid[sfx->skinsound] = S_AddSoundFx(value+2, sfx->singularity, sfx->pitch, true);
						found = true;
					}
				}

				if (!found)
					CONS_Debug(DBG_SETUP, "R_AddSkins: Unknown keyword '%s' in S_SKIN lump# %d (WAD %s)\n", stoken, lump, wadfiles[wadnum]->filename);
			}

			stoken = strtok(NULL, "\r\n= ");
		}

		free(buf2);

		lump++; // if no sprite defined use spirte just after this one

		if (skin->sprite[0] == '\0')
		{
			const char *csprname = W_CheckNameForNumPwad(wadnum, lump);

			// skip to end of this skin's frames
			lastlump = lump;

			while (W_CheckNameForNumPwad(wadnum, lastlump) && memcmp(W_CheckNameForNumPwad(wadnum, lastlump), csprname,4)==0)
				lastlump++;

			// allocate (or replace) sprite frames, and set spritedef
			R_AddSingleSpriteDef(csprname, &skin->spritedef, wadnum, lump, lastlump);
		}
		else
		{
			// search in the normal sprite tables
			size_t name;
			boolean found = false;
			const char *sprname = skin->sprite;

			for (name = 0; sprnames[name][0] != '\0'; name++)
			{
				if (strncmp(sprnames[name], sprname, 4) == 0)
				{
					skin->spritedef = sprites[name];
					found = true;
				}
			}

			// not found so make a new one
			// go through the entire current wad looking for our sprite
			// don't just mass add anything beginning with our four letters.
			// "HOODFACE" is not a sprite name.
			if (!found)
			{
				UINT16 localllump = 0, lstart = UINT16_MAX, lend = UINT16_MAX;
				const char *lname;

				while ((lname = W_CheckNameForNumPwad(wadnum, localllump)))
				{
					// If this is a valid sprite...
					if (!memcmp(lname, sprname, 4) && lname[4] && lname[5] && lname[5] >= '0' && lname[5] <= '8')
					{
						if (lstart == UINT16_MAX)
							lstart = localllump;
						// If already set do nothing
					}
					else
					{
						if (lstart != UINT16_MAX)
						{
							lend = localllump;
							break;
						}
						// If not already set do nothing
					}

					++localllump;
				}

				R_AddSingleSpriteDef(sprname, &skin->spritedef, wadnum, lstart, lend);
			}

			// I don't particularly care about skipping to the end of the used frames.
			// We could be using frames from ANYWHERE in the current WAD file, including
			// right before us, which is a terrible idea.
			// So just let the function in the while loop take care of it for us.
		}

		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;
			skin->localskin = false;
			skin->localnum = numskins;
			ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numskins);
		}
		else
		{
			skin->localskin = true;
			skin->localnum = numlocalskins;
			ST_LoadLocalFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numlocalskins);
		}

#ifdef HWRENDER
		if (rendermode == render_opengl)
			HWR_AddPlayerMD2(lnumskins, local);
#endif
		if (!local)
		{
			skinstats[skin->kartspeed-1][skin->kartweight-1][skinstatscount[skin->kartspeed-1][skin->kartweight-1]] = numskins;
			CONS_Debug(DBG_SETUP, M_GetText("Added %d to %d, %d\n"), numskins, skin->kartweight, skin->kartweight);
			skinstatscount[skin->kartspeed-1][skin->kartweight-1]++;
			CONS_Debug(DBG_SETUP, M_GetText("Incremented %d, %d to %d\n"), skin->kartspeed, skin->kartweight, skinstatscount[skin->kartspeed - 1][skin->kartweight - 1]);
			skinsorted[numskins] = numskins;
		}

		allskins[numallskins] = K_GetSkinArray(local)[lnumskins];

		local ? numlocalskins++ : numskins++;
		numallskins++;
	}

#undef lnumskins
	//sortSkinGrid();

	return;
}