#include <ultra64.h>
#include "constants.h"
#include "game/camdraw.h"
#include "game/title.h"
#include "game/pdmode.h"
#include "game/bondgun.h"
#include "game/game_0b0fd0.h"
#include "game/player.h"
#include "game/savebuffer.h"
#include "game/menu.h"
#include "game/playermgr.h"
#include "game/game_1531a0.h"
#include "game/lv.h"
#include "game/music.h"
#include "game/mplayer/setup.h"
#include "game/mplayer/scenarios.h"
#include "game/mpstats.h"
#include "game/challenge.h"
#include "game/lang.h"
#include "game/mplayer/mplayer.h"
#include "game/pak.h"
#include "bss.h"
#include "lib/args.h"
#include "lib/vi.h"
#include "lib/main.h"
#include "lib/rng.h"
#include "lib/str.h"
#include "lib/lib_317f0.h"
#include "data.h"
#include "types.h"

// bss
struct chrdata *g_MpAllChrPtrs[MAX_MPCHRS];
struct mpchrconfig *g_MpAllChrConfigPtrs[MAX_MPCHRS];
s32 g_MpNumChrs;
u32 var800ac534;
struct mpbotconfig g_BotConfigsArray[MAX_BOTS];
u8 g_MpSimulantDifficultiesPerNumPlayers[MAX_BOTS][MAX_PLAYERS];
struct mpplayerconfig g_PlayerConfigsArray[MAX_MPPLAYERCONFIGS];
u8 g_AmBotCommands[9];
struct mpsetup g_MpSetup;
struct bossfile g_BossFile;
u32 var800acc1c;
struct mplockinfo g_MpLockInfo;
struct modeldef *var800acc28[18];

// Forward declaractions
struct mpweaponset g_MpWeaponSets[12];
s32 g_MpWeaponSetNum;

#if VERSION >= VERSION_NTSC_1_0
const char var7f1b8a00[] = "||||||||||||| Starting game... players %d\n";
#endif

s32 var80087260 = 0x00000000;
bool g_MpEnableMusicSwitching = false;

struct mpweapon g_MpWeapons[NUM_MPWEAPONS] = {
	/*0x00*/ { WEAPON_NONE,             0,                    0,   0,                   0,  1, 0,                                MODEL_CHRTT33,          256 },
	/*0x01*/ { WEAPON_FALCON2,          AMMOTYPE_PISTOL,      80,  0,                   0,  1, 0,                                MODEL_CHRFALCON2,       256 },
	/*0x02*/ { WEAPON_FALCON2_SILENCER, AMMOTYPE_PISTOL,      80,  0,                   0,  1, MPFEATURE_WEAPON_FALCON2SILENCED, MODEL_CHRFALCON2SIL,    256 },
	/*0x03*/ { WEAPON_FALCON2_SCOPE,    AMMOTYPE_PISTOL,      80,  0,                   0,  1, MPFEATURE_WEAPON_FALCON2SCOPE,    MODEL_CHRFALCON2SCOPE,  256 },
	/*0x04*/ { WEAPON_MAGSEC4,          AMMOTYPE_PISTOL,      80,  0,                   0,  1, 0,                                MODEL_CHRLEEGUN1,       256 },
	/*0x05*/ { WEAPON_MAULER,           AMMOTYPE_PISTOL,      92,  0,                   0,  1, MPFEATURE_WEAPON_MAULER,          MODEL_CHRMAULER,        256 },
	/*0x06*/ { WEAPON_PHOENIX,          AMMOTYPE_PISTOL,      64,  0,                   0,  1, MPFEATURE_WEAPON_PHOENIX,         MODEL_CHRMAIANPISTOL,   256 },
	/*0x07*/ { WEAPON_DY357MAGNUM,      AMMOTYPE_MAGNUM,      50,  0,                   0,  1, 0,                                MODEL_CHRDY357,         256 },
	/*0x08*/ { WEAPON_DY357LX,          AMMOTYPE_MAGNUM,      50,  0,                   0,  1, MPFEATURE_WEAPON_DY357LX,         MODEL_CHRDY357TRENT,    256 },
	/*0x09*/ { WEAPON_CMP150,           AMMOTYPE_SMG,         100, 0,                   0,  1, 0,                                MODEL_CHRCMP150,        256 },
	/*0x0a*/ { WEAPON_CYCLONE,          AMMOTYPE_SMG,         150, 0,                   0,  1, 0,                                MODEL_CHRCYCLONE,       256 },
	/*0x0b*/ { WEAPON_CALLISTO,         AMMOTYPE_SMG,         150, 0,                   0,  1, MPFEATURE_WEAPON_CALLISTO,        MODEL_CHRMAIANSMG,      256 },
	/*0x0c*/ { WEAPON_RCP120,           AMMOTYPE_SMG,         150, 0,                   0,  1, MPFEATURE_WEAPON_RCP120,          MODEL_CHRRCP120,        256 },
	/*0x0d*/ { WEAPON_LAPTOPGUN,        AMMOTYPE_SMG,         150, 0,                   0,  1, MPFEATURE_WEAPON_LAPTOPGUN,       MODEL_CHRPCGUN,         256 },
	/*0x0e*/ { WEAPON_DRAGON,           AMMOTYPE_RIFLE,       150, 0,                   0,  1, 0,                                MODEL_CHRDRAGON,        256 },
	/*0x0f*/ { WEAPON_K7AVENGER,        AMMOTYPE_RIFLE,       150, 0,                   0,  1, MPFEATURE_WEAPON_K7AVENGER,       MODEL_CHRAVENGER,       256 },
	/*0x10*/ { WEAPON_AR34,             AMMOTYPE_RIFLE,       100, 0,                   0,  1, 0,                                MODEL_CHRAR34,          256 },
	/*0x11*/ { WEAPON_SUPERDRAGON,      AMMOTYPE_RIFLE,       150, AMMOTYPE_DEVASTATOR, 16, 1, MPFEATURE_WEAPON_SUPERDRAGON,     MODEL_CHRSUPERDRAGON,   256 },
	/*0x12*/ { WEAPON_SHOTGUN,          AMMOTYPE_SHOTGUN,     16,  0,                   0,  1, MPFEATURE_WEAPON_SHOTGUN,         MODEL_CHRSHOTGUN,       256 },
	/*0x13*/ { WEAPON_REAPER,           AMMOTYPE_REAPER,      200, 0,                   0,  1, MPFEATURE_WEAPON_REAPER,          MODEL_CHRSKMINIGUN,     256 },
	/*0x14*/ { WEAPON_SNIPERRIFLE,      AMMOTYPE_RIFLE,       50,  0,                   0,  1, 0,                                MODEL_CHRSNIPERRIFLE,   256 },
	/*0x15*/ { WEAPON_FARSIGHT,         AMMOTYPE_FARSIGHT,    10,  0,                   0,  1, MPFEATURE_WEAPON_FARSIGHT,        MODEL_CHRZ2020,         256 },
	/*0x16*/ { WEAPON_DEVASTATOR,       AMMOTYPE_DEVASTATOR,  16,  0,                   0,  1, MPFEATURE_WEAPON_DEVASTATOR,      MODEL_CHRDEVASTATOR,    256 },
	/*0x17*/ { WEAPON_ROCKETLAUNCHER,   AMMOTYPE_ROCKET,      3,   0,                   0,  1, 0,                                MODEL_CHRDYROCKET,      256 },
	/*0x18*/ { WEAPON_SLAYER,           AMMOTYPE_ROCKET,      3,   0,                   0,  1, MPFEATURE_WEAPON_SLAYER,          MODEL_CHRSKROCKET,      256 },
#if !((VERSION == VERSION_JPN_FINAL) && defined(PLATFORM_N64))
	/*0x19*/ { WEAPON_COMBATKNIFE,      AMMOTYPE_KNIFE,       5,   0,                   0,  1, 0,                                MODEL_CHRKNIFE,         256 },
#endif
	/*0x1a*/ { WEAPON_CROSSBOW,         AMMOTYPE_CROSSBOW,    10,  0,                   0,  1, MPFEATURE_WEAPON_CROSSBOW,        MODEL_CHRCROSSBOW,      256 },
	/*0x1b*/ { WEAPON_TRANQUILIZER,     AMMOTYPE_SEDATIVE,    50,  0,                   0,  1, MPFEATURE_WEAPON_TRANQUILIZER,    MODEL_CHRDRUGGUN,       256 },
	/*0x1c*/ { WEAPON_GRENADE,          AMMOTYPE_GRENADE,     5,   0,                   0,  0, 0,                                MODEL_CHRGRENADE,       256 },
	/*0x1d*/ { WEAPON_NBOMB,            AMMOTYPE_NBOMB,       3,   0,                   0,  0, MPFEATURE_WEAPON_NBOMB,           MODEL_CHRNBOMB,         256 },
	/*0x1e*/ { WEAPON_TIMEDMINE,        AMMOTYPE_TIMED_MINE,  5,   0,                   0,  0, 0,                                MODEL_CHRTIMEDMINE,     384 },
	/*0x1f*/ { WEAPON_PROXIMITYMINE,    AMMOTYPE_PROXY_MINE,  5,   0,                   0,  0, MPFEATURE_WEAPON_PROXIMITYMINE,   MODEL_CHRPROXIMITYMINE, 384 },
	/*0x20*/ { WEAPON_REMOTEMINE,       AMMOTYPE_REMOTE_MINE, 5,   0,                   0,  0, MPFEATURE_WEAPON_REMOTEMINE,      MODEL_CHRREMOTEMINE,    384 },
	/*0x21*/ { WEAPON_LASER,            0,                    0,   0,                   0,  1, MPFEATURE_WEAPON_LASER,           MODEL_CHRLASER,         512 },
	/*0x22*/ { WEAPON_XRAYSCANNER,      0,                    0,   0,                   0,  1, MPFEATURE_WEAPON_XRAYSCANNER,     MODEL_CHRNIGHTSIGHT,    256 },
	/*0x23*/ { WEAPON_CLOAKINGDEVICE,   0,                    0,   0,                   0,  1, MPFEATURE_WEAPON_CLOAKINGDEVICE,  MODEL_CHRCLOAKER,       256 },
	/*0x24*/ { WEAPON_COMBATBOOST,      0,                    0,   0,                   0,  1, MPFEATURE_WEAPON_COMBATBOOST,     MODEL_CHRSPEEDPILL,     256 },
#ifndef PLATFORM_N64
	/*0x25*/ { WEAPON_PP9I,             AMMOTYPE_PISTOL,      80,  0,                   0,  1, 0,                                MODEL_CHRWPPK,          256 },
	/*0x26*/ { WEAPON_CC13,             AMMOTYPE_PISTOL,      80,  0,                   0,  1, 0,                                MODEL_CHRTT33,          256 },
	/*0x27*/ { WEAPON_KL01313,          AMMOTYPE_SMG,         100, 0,                   0,  1, 0,                                MODEL_CHRSKORPION,      256 },
	/*0x28*/ { WEAPON_KF7SPECIAL,       AMMOTYPE_RIFLE,       100, 0,                   0,  1, 0,                                MODEL_CHRKALASH,        256 },
	/*0x29*/ { WEAPON_ZZT,              AMMOTYPE_SMG,         100, 0,                   0,  1, 0,                                MODEL_CHRUZI,           256 },
	/*0x2a*/ { WEAPON_DMC,              AMMOTYPE_SMG,         100, 0,                   0,  1, 0,                                MODEL_CHRMP5K,          256 },
	/*0x2b*/ { WEAPON_AR53,             AMMOTYPE_RIFLE,       150, 0,                   0,  1, 0,                                MODEL_CHRM16,           256 },
	/*0x2c*/ { WEAPON_RCP45,            AMMOTYPE_SMG,         150, 0,                   0,  1, 0,                                MODEL_CHRFNP90,         256 },
#endif
	/*0x2d*/ { WEAPON_MPSHIELD,         0,                    0,   0,                   0,  1, MPFEATURE_WEAPON_SHIELD,          MODEL_CHRSHIELD,        256 },
	/*0x2e*/ { WEAPON_DISABLED }, // 0x25 on N64
};

#ifndef PLATFORM_N64

#define PLAYER_EXT_CFG_DEFAULT { \
	.fovy = 60.f, \
	.fovzoommult = 1.f, \
	.fovzoom = true, \
	.mouseaimmode = MOUSEAIM_CLASSIC, \
	.mouseaimspeedx = 0.7f, \
	.mouseaimspeedy = 0.7f, \
	.radialmenuspeed = 4.f, \
	.crosshairsway = 1.f, \
	.crouchmode = CROUCHMODE_TOGGLE_ANALOG, \
	.extcontrols = true, \
}

struct extplayerconfig g_PlayerExtCfg[MAX_PLAYERS] = { 
	PLAYER_EXT_CFG_DEFAULT,
	PLAYER_EXT_CFG_DEFAULT,
	PLAYER_EXT_CFG_DEFAULT,
	PLAYER_EXT_CFG_DEFAULT,
};

#endif

/**
 * Converts the given value into a float on a curved scale from 0.1 to 10.
 *
 * value 0 will return 0.1
 * value 127 will return 1
 * value 255 will return 10
 */
f32 mpHandicapToDamageScale(u8 value)
{
	f32 tmp;

	if (value < 127) {
		return (value / 127.0f) * (value / 127.0f) * 0.9f + 0.1f;
	}

	if (value == 127) {
		return 1;
	}

	tmp = (value - 128) / 127.0f + 1;

	return tmp * tmp * 3 - 2;
}

void func0f187838(struct mpchrconfig *mpchr)
{
	s32 i = 0;

	while (i < ARRAYCOUNT(mpchr->killcounts)) {
		mpchr->killcounts[i++] = 0;
	}

	mpchr->numdeaths = 0;
	mpchr->numpoints = 0;
	mpchr->unk40 = 0;
}

void mpStartMatch(void)
{
	s32 i;
	s32 numplayers = 0;
	s32 stagenum;

	mpConfigureQuickTeamSimulants();

	if (!challengeIsFeatureUnlocked(MPFEATURE_ONEHITKILLS)) {
		g_MpSetup.options &= ~MPOPTION_ONEHITKILLS;
	}

	if (!challengeIsFeatureUnlocked(MPFEATURE_SLOWMOTION)) {
		g_MpSetup.options &= ~(MPOPTION_SLOWMOTION_ON | MPOPTION_SLOWMOTION_SMART);
	}

	for (i = 0; i < MAX_PLAYERS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			numplayers++;
		}
	}

	stagenum = g_MpSetup.stagenum;

	if (g_MpSetup.stagenum == STAGE_MP_RANDOM) {
		stagenum = mpChooseRandomStage();
	}

	titleSetNextStage(stagenum);
	mainChangeToStage(stagenum);
	setNumPlayers(numplayers);
	titleSetNextMode(TITLEMODE_SKIP);

	g_Vars.perfectbuddynum = 1;
}

void mpReset(void)
{
	s32 i;
	s32 mpindex = 0;

	g_MpNumChrs = 0;
	g_Vars.mplayerisrunning = true;

	if (g_Vars.coopplayernum >= 0 || g_Vars.antiplayernum >= 0) {
		g_Vars.normmplayerisrunning = false;
	} else {
		g_Vars.normmplayerisrunning = true;
	}

	g_Vars.perfectbuddynum = 0;

	if (mpHasSimulants()) {
		g_Vars.lvmpbotlevel = true;
	}

	if (g_Vars.coopplayernum >= 0 || g_Vars.antiplayernum >= 0) {
		struct mpplayerconfig tmp;

		tmp = g_PlayerConfigsArray[MAX_PLAYERS];
		g_PlayerConfigsArray[MAX_PLAYERS] = g_PlayerConfigsArray[0];
		g_PlayerConfigsArray[0] = tmp;

		tmp = g_PlayerConfigsArray[MAX_PLAYERS + 1];
		g_PlayerConfigsArray[MAX_PLAYERS + 1] = g_PlayerConfigsArray[1];
		g_PlayerConfigsArray[1] = tmp;

		// Player index 0
		g_Vars.playerstats[0].mpindex = 0;

		g_PlayerConfigsArray[0].contpad1 = 0;
		g_PlayerConfigsArray[0].contpad2 = 2;

		if ((g_Vars.coopplayernum >= 0 && g_Vars.coopradaron)
				|| (g_Vars.antiplayernum >= 0 && g_Vars.antiradaron)) {
			g_PlayerConfigsArray[0].base.displayoptions |= MPDISPLAYOPTION_RADAR;
		} else {
			g_PlayerConfigsArray[0].base.displayoptions &= ~MPDISPLAYOPTION_RADAR;
		}

		// Player index 1
		g_Vars.playerstats[1].mpindexu32 = 1;

		g_PlayerConfigsArray[1].contpad1 = 1;
		g_PlayerConfigsArray[1].contpad2 = 3;

		if ((g_Vars.coopplayernum >= 0 && g_Vars.coopradaron)
				|| (g_Vars.antiplayernum >= 0 && g_Vars.antiradaron)) {
			g_PlayerConfigsArray[1].base.displayoptions |= MPDISPLAYOPTION_RADAR;
		} else {
			g_PlayerConfigsArray[1].base.displayoptions &= ~MPDISPLAYOPTION_RADAR;
		}

		g_MpNumChrs = 2;
	} else {
		for (i = 0; i < MAX_PLAYERS; i++) {
			if (g_MpSetup.chrslots & (1 << i)) {
				g_Vars.playerstats[mpindex].mpindex = i;

				g_PlayerConfigsArray[i].contpad1 = i;
				g_PlayerConfigsArray[i].contpad2 = 0;

				mpCalculatePlayerTitle(&g_PlayerConfigsArray[i]);

				g_PlayerConfigsArray[i].newtitle = g_PlayerConfigsArray[i].title;
				g_MpNumChrs++;
				mpindex++;
			}
		}
	}

	for (i = 0; i < MAX_MPCHRS; i++) {
		struct mpchrconfig *mpchr = MPCHR(i);

		func0f187838(mpchr);

#if VERSION >= VERSION_NTSC_1_0
		g_MpAllChrPtrs[i] = NULL;
#endif
	}

	g_MpSetup.paused = false;

	g_MpEnableMusicSwitching = false;

	if (g_Vars.normmplayerisrunning) {
		if (mpGetUsingMultipleTunes()) {
			s32 i = 0;
			s32 count = 0;
			s32 numtracks = mpGetNumUnlockedTracks();

			for (i; i < numtracks && count < 2; i++) {
				if (mpIsMultiTrackSlotEnabled(i)) {
					count++;
				}
			}

			if (count >= 2) {
				g_MpEnableMusicSwitching = true;
			}
		}

		g_MpLockInfo.unk04 = -1;
	}

	// Assign aibot commands to active menu slots
	for (i = 0; i < ARRAYCOUNT(g_AmBotCommands); i++) {
		g_AmBotCommands[i] = AIBOTCMD_NORMAL;
	}

	g_AmBotCommands[1] = AIBOTCMD_ATTACK;
	g_AmBotCommands[7] = AIBOTCMD_NORMAL;
	g_AmBotCommands[0] = AIBOTCMD_FOLLOW;
	g_AmBotCommands[2] = AIBOTCMD_PROTECT;
	g_AmBotCommands[3] = AIBOTCMD_DEFEND;
	g_AmBotCommands[5] = AIBOTCMD_HOLD;

	switch (g_MpSetup.scenario) {
	case MPSCENARIO_CAPTURETHECASE:
		g_AmBotCommands[3] = AIBOTCMD_GETCASE;
		g_AmBotCommands[5] = AIBOTCMD_SAVECASE;
		break;
	case MPSCENARIO_KINGOFTHEHILL:
		g_AmBotCommands[6] = AIBOTCMD_DEFHILL;
		g_AmBotCommands[8] = AIBOTCMD_HOLDHILL;
		break;
	case MPSCENARIO_HACKERCENTRAL:
		g_AmBotCommands[6] = AIBOTCMD_DOWNLOAD;
		g_AmBotCommands[8] = AIBOTCMD_DOWNLOAD;
		break;
	case MPSCENARIO_POPACAP:
		g_AmBotCommands[6] = AIBOTCMD_POPCAP;
		g_AmBotCommands[8] = AIBOTCMD_POPCAP;
		break;
	case MPSCENARIO_HOLDTHEBRIEFCASE:
		g_AmBotCommands[6] = AIBOTCMD_GETCASE2;
		g_AmBotCommands[8] = AIBOTCMD_GETCASE2;
		break;
	default:
		g_AmBotCommands[0] = AIBOTCMD_FOLLOW;
		g_AmBotCommands[1] = AIBOTCMD_ATTACK;
		g_AmBotCommands[2] = AIBOTCMD_PROTECT;
		g_AmBotCommands[3] = AIBOTCMD_DEFEND;
		g_AmBotCommands[5] = AIBOTCMD_HOLD;
		g_AmBotCommands[7] = AIBOTCMD_NORMAL;
		break;
	}
}

void mpCalculateTeamIsOnlyAi(void)
{
	s32 playercount = PLAYERCOUNT();
	s32 i;
	s32 j;

	// Iterate simulants, which go after players in the g_MpAllChrPtrs array
	for (i = playercount; i < g_MpNumChrs; i++) {
		if (!g_MpAllChrPtrs[i]) {
			continue;
		}

		g_MpAllChrPtrs[i]->aibot->teamisonlyai = true;

		if (g_MpSetup.options & MPOPTION_TEAMSENABLED) {
			// Iterate human players
			for (j = 0; j < playercount; j++) {
				if (g_MpAllChrPtrs[i]->team == g_MpAllChrPtrs[j]->team) {
					g_MpAllChrPtrs[i]->aibot->teamisonlyai = false;
					break;
				}
			}
		}
	}
}

void func0f187fbc(s32 playernum)
{
	g_PlayerConfigsArray[playernum].base.unk18 = 80;
	g_PlayerConfigsArray[playernum].base.unk1a = 80;
	g_PlayerConfigsArray[playernum].base.unk1c = 75;
}

void func0f187fec(void)
{
	g_MpSetup.timelimit = 9;
	g_MpSetup.scorelimit = 9;
	g_MpSetup.teamscorelimit = 19;
}

void mpPlayerSetDefaults(s32 playernum, bool autonames)
{
	s32 i;
	s32 j;

	func0f187fbc(playernum);

	g_PlayerConfigsArray[playernum].controlmode = CONTROLMODE_11;

#ifndef PLATFORM_N64
	if (g_PlayerExtCfg[playernum % MAX_PLAYERS].extcontrols) {
		g_PlayerConfigsArray[playernum].controlmode = CONTROLMODE_PC;
	}
#endif

	g_PlayerConfigsArray[playernum].options =
#ifdef PLATFORM_N64
		  OPTION_LOOKAHEAD
#else
		  OPTION_FORWARDPITCH
#endif
		| OPTION_SIGHTONSCREEN
		| OPTION_AUTOAIM
		| OPTION_AMMOONSCREEN
		| OPTION_SHOWGUNFUNCTION
		| OPTION_HEADROLL
		| OPTION_0100
		| OPTION_ALWAYSSHOWTARGET
		| OPTION_SHOWZOOMRANGE;

	g_PlayerConfigsArray[playernum].handicap = 128;

	switch (playernum) {
	case 0:
	default:
		g_PlayerConfigsArray[playernum].base.mpbodynum = MPBODY_DARK_COMBAT;
		break;
	case 1:
		g_PlayerConfigsArray[playernum].base.mpbodynum = MPBODY_CASSANDRA;
		break;
	case 2:
		g_PlayerConfigsArray[playernum].base.mpbodynum = MPBODY_CARRINGTON;
		break;
	case 3:
		g_PlayerConfigsArray[playernum].base.mpbodynum = MPBODY_CILABTECH;
		break;
	}

	g_PlayerConfigsArray[playernum].base.mpheadnum = mpGetMpheadnumByMpbodynum(g_PlayerConfigsArray[playernum].base.mpbodynum);
	g_PlayerConfigsArray[playernum].base.displayoptions = MPDISPLAYOPTION_RADAR | MPDISPLAYOPTION_HIGHLIGHTTEAMS;
	g_PlayerConfigsArray[playernum].fileguid.fileid = 0;
	g_PlayerConfigsArray[playernum].fileguid.deviceserial = 0;

	if (autonames) {
		// "Player 1" etc
		sprintf(g_PlayerConfigsArray[playernum].base.name, "%s %d\n", langGet(L_MISC_437), playernum + 1);
	} else {
		g_PlayerConfigsArray[playernum].base.name[0] = '\0';
	}

	g_PlayerConfigsArray[playernum].kills = 0;
	g_PlayerConfigsArray[playernum].deaths = 0;
	g_PlayerConfigsArray[playernum].gamesplayed = 0;
	g_PlayerConfigsArray[playernum].gameswon = 0;
	g_PlayerConfigsArray[playernum].gameslost = 0;
	g_PlayerConfigsArray[playernum].time = 0;
	g_PlayerConfigsArray[playernum].distance = 0;
	g_PlayerConfigsArray[playernum].accuracy = 1000;
	g_PlayerConfigsArray[playernum].damagedealt = 0;
	g_PlayerConfigsArray[playernum].painreceived = 0;
	g_PlayerConfigsArray[playernum].headshots = 0;
	g_PlayerConfigsArray[playernum].ammoused = 0;
	g_PlayerConfigsArray[playernum].accuracymedals = 0;
	g_PlayerConfigsArray[playernum].headshotmedals = 0;
	g_PlayerConfigsArray[playernum].killmastermedals = 0;
	g_PlayerConfigsArray[playernum].survivormedals = 0;
	g_PlayerConfigsArray[playernum].title = MPPLAYERTITLE_BEGINNER;

	if (playernum < MAX_PLAYERS) {
		for (i = 0; i < ARRAYCOUNT(g_MpChallenges); i++) {
			for (j = 1; j <= MAX_PLAYERS; j++) {
				challengeSetCompletedByPlayerWithNumPlayers(playernum, i, j, false);
			}
		}

		challengeDetermineUnlockedFeatures();
	}

	for (i = 0; i < ARRAYCOUNT(g_PlayerConfigsArray); i++) {
		g_PlayerConfigsArray[playernum].gunfuncs[i] = 0;
	}
}

void func0f1881d4(s32 index)
{
	g_BotConfigsArray[index].base.name[0] = '\0';
	g_BotConfigsArray[index].base.mpheadnum = MPHEAD_DARK_COMBAT;
	g_BotConfigsArray[index].base.mpbodynum = MPBODY_DARK_COMBAT;
	g_BotConfigsArray[index].type = BOTTYPE_GENERAL;
	g_BotConfigsArray[index].difficulty = BOTDIFF_DISABLED;
}

void mpInit(void)
{
	s32 i;
	s32 j;

	g_MpSetup.scenario = MPSCENARIO_COMBAT;
	g_MpSetup.stagenum = STAGE_MP_SKEDAR;
	g_MpSetup.options = MPOPTION_DISPLAYTEAM
		| MPOPTION_KILLSSCORE
		| MPOPTION_HTB_HIGHLIGHTBRIEFCASE
		| MPOPTION_HTB_SHOWONRADAR
		| MPOPTION_CTC_SHOWONRADAR
		| MPOPTION_KOH_HILLONRADAR
		| MPOPTION_KOH_MOBILEHILL
		| MPOPTION_00010000
		| MPOPTION_HTM_HIGHLIGHTTERMINAL
		| MPOPTION_HTM_SHOWONRADAR
		| MPOPTION_PAC_HIGHLIGHTTARGET
		| MPOPTION_PAC_SHOWONRADAR;

	g_Vars.mphilltime = 10;

	func0f187fec();

	g_MpSetup.fileguid.fileid = 0;
	g_MpSetup.fileguid.deviceserial = 0;

	strcpy(g_MpSetup.name, "");

	for (i = 0; i < ARRAYCOUNT(g_PlayerConfigsArray); i++) {
		mpPlayerSetDefaults(i, false);
	}

	for (i = 0; i < MAX_BOTS; i++) {
		func0f1881d4(i);
	}

	if (argFindByPrefix(1, "-mpwpnset")) {
		char *value = argFindByPrefix(1, "-mpwpnset");
		mpSetWeaponSet(*value - '0');
	} else {
		mpSetWeaponSet(0);
	}

	g_Vars.mplayerisrunning = false;
	g_Vars.normmplayerisrunning = false;
	g_Vars.lvmpbotlevel = 0;

	g_MpLockInfo.lockedplayernum = 0;
	g_MpLockInfo.lastwinner = -1;
	g_MpLockInfo.lastloser = -1;
	g_MpLockInfo.unk03 = -1;
	g_MpLockInfo.unk04 = -1;

	challengeForceUnlockBotFeatures();

	for (i = 0; i < ARRAYCOUNT(g_PlayerConfigsArray); i++) {
		for (j = 0; j < ARRAYCOUNT(g_PlayerConfigsArray[i].gunfuncs); j++) {
			g_PlayerConfigsArray[i].gunfuncs[j] = 0;
		}
	}

	g_MpSetup.chrslots = 0;
}

#if VERSION >= VERSION_PAL_BETA
void mpGetTeamsWithDefaultName(u8 *mask)
{
	s32 i;

	*mask = 0;

	for (i = 0; i < ARRAYCOUNT(g_BossFile.teamnames); i++) {
		if (strcmp(g_BossFile.teamnames[i], langGet(L_OPTIONS_008 + i)) == 0) {
			*mask |= 1 << i;
		}
	}
}
#endif

#if VERSION >= VERSION_PAL_BETA
void mpSetTeamNamesToDefault(u8 mask)
{
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_BossFile.teamnames); i++) {
		if (mask & (1 << i)) {
			strcpy(g_BossFile.teamnames[i], langGet(L_OPTIONS_008 + i));
		}
	}
}
#endif

void mpSetDefaultNamesIfEmpty(void)
{
	s32 i;

	// Setup file name
	if (g_MpSetup.name[0] == '\0') {
		strcpy(g_MpSetup.name, langGet(L_MISC_438)); // empty string
	}

	// Team names
	for (i = 0; i < ARRAYCOUNT(g_BossFile.teamnames); i++) {
		if (g_BossFile.teamnames[i][0] == '\0') {
			strcpy(g_BossFile.teamnames[i], langGet(L_OPTIONS_008 + i)); // "Red", "Yellow" etc
		}
	}

	// Player names
	for (i = 0; i < MAX_PLAYERS; i++) {
		if (g_PlayerConfigsArray[i].base.name[0] == '\0') {
			sprintf(g_PlayerConfigsArray[i].base.name, "%s %d\n", langGet(L_MISC_437), i + 1); // "Player 1" etc
		}
	}
}

s32 mpCalculateTeamScoreLimit(void)
{
	s32 limit = g_MpSetup.teamscorelimit;
	s32 i;

	if (g_BossFile.locktype == MPLOCKTYPE_CHALLENGE
			&& g_MpSetup.teamscorelimit != 400
			&& (g_MpSetup.scenario == MPSCENARIO_COMBAT || g_MpSetup.scenario == MPSCENARIO_KINGOFTHEHILL)) {
		s32 numchrs = 0;

		for (i = 0; i < MAX_PLAYERS; i++) {
			if (g_MpSetup.chrslots & (1 << i)) {
				numchrs++;
			}
		}

		switch (numchrs) {
		case 1:
			break;
		case 2:
			limit = limit * 2 + 1;
			break;
		case 3:
			limit = (limit * 5 + 5) / 2 - 1;
			break;
		case 4:
			limit = limit * 3 + 2;
			break;
		}
	}

	return limit;
}

void mpApplyLimits(void)
{
	if (g_MpSetup.timelimit >= 60) {
		lvSetMpTimeLimit60(0);
	} else {
		lvSetMpTimeLimit60(SECSTOTIME60((g_MpSetup.timelimit + 1) * 60));
	}

	if (g_MpSetup.scorelimit >= 100) {
		lvSetMpScoreLimit(0);
	} else {
		lvSetMpScoreLimit(g_MpSetup.scorelimit + 1);
	}

	if (g_MpSetup.teamscorelimit >= 400) {
		lvSetMpTeamScoreLimit(0);
	} else {
		lvSetMpTeamScoreLimit(mpCalculateTeamScoreLimit() + 1);
	}
}

/**
 * Given a pointer to an array of 12 ranking structs, populate those rankings
 * with the winner first, loser last. Return the number of rows (players).
 *
 * The function also populates the placement an rankablescore values in the
 * mpchr structs and calculates the last winner and loser for the lock settings.
 */
s32 mpGetPlayerRankings(struct ranking *rankings)
{
	s32 i;
	s32 scores[MAX_MPCHRS];
	u32 rankablescores[MAX_MPCHRS];
	struct mpchrconfig *mpchrs[MAX_MPCHRS];
	s32 chrnums[MAX_MPCHRS];
	s32 count = 0;
	s32 numteams;
	struct ranking teamrankings[MAX_MPCHRS];
	s32 winner;
	s32 loser;
	s32 score;
	s32 deaths;
	struct mpchrconfig *mpchr;
	s32 dstindex;
	bool found;
	u32 rankablescore;
	s32 j;

	if (g_MpSetup.options & MPOPTION_TEAMSENABLED) {
		numteams = mpGetTeamRankings(teamrankings);
	}

	// Populate 4 arrays with player info, sorted by highest score descending
	for (i = 0; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			mpchr = MPCHR(i);

			scenarioCalculatePlayerScore(mpchr, i, &score, &deaths);

			rankablescore = (score + 0x8000) << 16 | (0xffff - deaths);
			dstindex = 0;
			found = false;

			// Find where this player should be placed in the sorted arrays
			for (j = 0; j < count && !found; j++) {
				if (rankablescore > rankablescores[j]) {
					dstindex = j;
					found = true;
				}
			}

			if (!found) {
				dstindex = count;
			}

			// Shuffle everything forward after dstindex to create a gap
			for (j = count; j > dstindex; j--) {
				rankablescores[j] = rankablescores[j - 1];
				scores[j] = scores[j - 1];
				mpchrs[j] = mpchrs[j - 1];
				chrnums[j] = chrnums[j - 1];
			}

			count++;

			// Write the new figures
			rankablescores[dstindex] = (score + 0x8000) << 16 | (0xffff - deaths);
			scores[dstindex] = score;
			mpchrs[dstindex] = mpchr;
			chrnums[dstindex] = i;
		}
	}

	// Populate the rankings array, copy some values into the mpchr structs
	// and calculate the winner and loser
	winner = -1;
	loser = -1;

	for (j = 0; j < count; j++) {
		rankings[j].mpchr = mpchrs[j];
		rankings[j].teamnum = chrnums[j];
		rankings[j].positionindex = j;
		rankings[j].unk0c = 0;
		rankings[j].score = scores[j];

		// For a team game, the mpchr's placement has to be the team's placement
		// and not the placement of the individual player.
		if (g_MpSetup.options & MPOPTION_TEAMSENABLED) {
			s32 placement = numteams - 1;
			s32 i;

			for (i = 0; i < numteams; i++) {
				if (teamrankings[i].teamnum == mpchrs[j]->team) {
					placement = i;
				}
			}

			mpchrs[j]->placement = placement;
#if VERSION >= VERSION_NTSC_1_0
			mpchrs[j]->rankablescore = 255 - placement;
#endif
		} else {
			mpchrs[j]->placement = j;
#if VERSION >= VERSION_NTSC_1_0
			mpchrs[j]->rankablescore = rankablescores[j];
#endif
		}

#if VERSION < VERSION_NTSC_1_0
		mpchrs[j]->rankablescore = rankablescores[j];
#endif

		if (chrnums[j] < 4) {
			loser = chrnums[j];

			if (winner == -1) {
				winner = chrnums[j];
				if (1);
			}
		}
	}

	g_MpLockInfo.lastwinner = winner;
	g_MpLockInfo.lastloser = loser;

	if (g_BossFile.locktype == MPLOCKTYPE_RANDOM) {
		g_MpLockInfo.lockedplayernum = mpChooseRandomLockPlayer();
	}

	return count;
}

/**
 * Iterate players on the given team and add their scores.
 *
 * There are two score values:
 * - The team score, which is written to the result pointer and eventually
 *   displayed on screen
 * - The rankable score, which is the returned value. The rankable score is
 *   similar to the team score but uses the number of deaths as a tie breaker.
 */
s32 mpCalculateTeamScore(s32 teamnum, s32 *result)
{
	struct mpchrconfig *mpchr;
	s32 teamscore = 0;
	s32 teamdeaths = 0;
	bool teamexists = false;
	s32 i;
	u32 stack;
	s32 score;
	s32 deaths;

	for (i = 0; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			mpchr = MPCHR(i);

			if (mpchr->team == teamnum) {
				scenarioCalculatePlayerScore(mpchr, i, &score, &deaths);
				teamexists = true;
				teamscore += score;
				teamdeaths += deaths;
			}
		}
	}

	if (teamexists) {
		*result = teamscore;
		return (teamscore + 0x8000) << 16 | (0xffff - teamdeaths);
	}

	return 0;
}

/**
 * Given a pointer to an array of 8 ranking structs, populate those rankings
 * with the winning team first, losing team last. Return the number of rows
 * (teams).
 */
s32 mpGetTeamRankings(struct ranking *rankings)
{
	s32 i;
	s32 count;
	s32 apparentscores[MAX_TEAMS];
	u32 rankablescores[MAX_TEAMS];
	u32 bestrankablescore;
	s32 thisteamnum;

	count = 0;

	// Calculate scores for each team
	for (i = 0; i < MAX_TEAMS; i++) {
		apparentscores[i] = -8000;
		rankablescores[i] = mpCalculateTeamScore(i, &apparentscores[i]);
	}

	// Iterate each slot and determine which team belongs in it.
	// As each team is found, set their apparent score to -8000 so they're not
	// found again.
	do {
		bestrankablescore = 0;
		thisteamnum = -8000;

		// Check which team has the best remaining score
		for (i = 0; i < MAX_TEAMS; i++) {
			if (apparentscores[7 - i] > -8000 && rankablescores[7 - i] >= bestrankablescore) {
				thisteamnum = 7 - i;
				bestrankablescore = rankablescores[thisteamnum];
			}
		}

		if (thisteamnum > -8000) {
			// Append to the rankings array
			rankings[count].mpchr = NULL;
			rankings[count].teamnum = thisteamnum;
			rankings[count].positionindex = count + 1;
			rankings[count].unk0c = 0;
			rankings[count].score = apparentscores[thisteamnum];

			apparentscores[thisteamnum] = -8000;

			count++;
		}
	} while (thisteamnum != -8000);

	return count;
}

s32 func0f188bcc(void)
{
	return NUM_MPWEAPONS;
}

s32 mpGetNumWeaponOptions(void)
{
	s32 count = 0;
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpWeapons); i++) {
		if (challengeIsFeatureUnlocked(g_MpWeapons[i].unlockfeature)) {
			count++;
		}
	}

	return count;
}

char *mpGetWeaponLabel(s32 weaponnum)
{
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpWeapons); i++) {
		if (challengeIsFeatureUnlocked(g_MpWeapons[i].unlockfeature)) {
			if (weaponnum == 0) {
				if (g_MpWeapons[i].weaponnum == WEAPON_NONE) {
					return langGet(L_MPWEAPONS_058); // "Nothing"
				}

				if (g_MpWeapons[i].weaponnum == WEAPON_MPSHIELD) {
					return langGet(L_MPWEAPONS_059); // "Shield"
				}

				if (g_MpWeapons[i].weaponnum == WEAPON_DISABLED) {
					return langGet(L_MPWEAPONS_060); // "Disabled"
				}

				return bgunGetName(g_MpWeapons[i].weaponnum);
			}

			weaponnum--;
		}
	}

	return "";
}

#if VERSION >= VERSION_NTSC_1_0
const char var7f1b8a5c[] = "Gun index %d -> slot %d = gun %d\n\n";
const char var7f1b8a80[] = "HOLDER: selecting weapon set %d\n";
#endif

void mpSetWeaponSlot(s32 slot, s32 mpweaponnum)
{
	s32 optionindex = mpweaponnum;
	s32 i;

	for (i = 0; i <= mpweaponnum; i++) {
		if (challengeIsFeatureUnlocked(g_MpWeapons[i].unlockfeature) == 0) {
			mpweaponnum++;
		}

		optionindex = mpweaponnum;
	}

	g_MpSetup.weapons[slot] = optionindex;
}

s32 mpGetWeaponSlot(s32 slot)
{
	s32 count = 0;
	s32 i;

	for (i = 0; i < g_MpSetup.weapons[slot]; i++) {
		if (challengeIsFeatureUnlocked(g_MpWeapons[i].unlockfeature)) {
			count++;
		}
	}

	return count;
}

struct mpweapon *mpGetMpWeaponByLocation(s32 locationindex)
{
	s32 v0 = locationindex + 1;
	s32 slot = 0;
	s32 a2 = v0;
	u8 mpweaponnum;

	while (v0 > 0) {
		mpweaponnum = g_MpSetup.weapons[slot];

		if (g_MpWeapons[mpweaponnum].weaponnum != WEAPON_DISABLED) {
			v0--;
		}

		if (v0 > 0) {
			slot++;

			if (slot >= ARRAYCOUNT(g_MpSetup.weapons)) {
				slot = 0;

				if (a2 == v0) {
					mpweaponnum = 0;
					v0 = 0;
				}

				a2 = v0;
			}
		}
	}

	return &g_MpWeapons[mpweaponnum];
}

s32 mpCountWeaponSetThing(s32 weaponsetindex)
{
	s32 i;
	s32 count = 0;

	if (weaponsetindex >= ARRAYCOUNT(g_MpWeaponSets)) {
		count = weaponsetindex - ARRAYCOUNT(g_MpWeaponSets);
		weaponsetindex = ARRAYCOUNT(g_MpWeaponSets);
	}

	for (i = 0; i < weaponsetindex; i++) {
		if ((challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[0])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[1])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[2])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[3])) || g_MpWeaponSets[i].unk0c != WEAPON_DISABLED) {
			count++;
		}
	}

	return count;
}

s32 func0f188f9c(s32 arg0)
{
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpWeaponSets); i++) {
		// @bug? Shouldn't the disabled check be == WEAPON_DISABLED?
		if ((challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[0])
					&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[1])
					&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[2])
					&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[3]))
				|| g_MpWeaponSets[i].unk0c != WEAPON_DISABLED) {
			if (arg0 == 0) {
				break;
			}

			arg0--;
		}
	}

	return i + arg0;
}

s32 func0f189058(bool full)
{
	return mpCountWeaponSetThing(full ? ARRAYCOUNT(g_MpWeaponSets) + 3 : ARRAYCOUNT(g_MpWeaponSets));
}

s32 func0f189088(void)
{
	return mpCountWeaponSetThing(ARRAYCOUNT(g_MpWeaponSets) + 2);
}

char *mpGetWeaponSetName(s32 index)
{
	index = func0f188f9c(index);

	if (index < 0 || index >= ARRAYCOUNT(g_MpWeaponSets) + 2) {
		return langGet(L_MPWEAPONS_041); // "Custom"
	}

	if (index == ARRAYCOUNT(g_MpWeaponSets) + 1) {
		return langGet(L_MPWEAPONS_042); // "Random"
	}

	if (index == ARRAYCOUNT(g_MpWeaponSets)) {
		return langGet(L_MPWEAPONS_043); // "Random Five"
	}

	return langGet(g_MpWeaponSets[index].name);
}

void func0f18913c(void)
{
	s32 i;
	bool done = false;
	u8 *ptr;
	s32 j;

	for (i = 0; !done && i < ARRAYCOUNT(g_MpWeaponSets); i++) {
		if (challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[0])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[1])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[2])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[i].requirefeatures[3])) {
			ptr = &g_MpWeaponSets[i].slots[0];
		} else if (g_MpWeaponSets[i].unk0c != WEAPON_DISABLED) {
			ptr = &g_MpWeaponSets[i].unk0c;
		} else {
			ptr = NULL;
		}

		if (ptr != NULL) {
			bool ok = true;

			for (j = 0; j < ARRAYCOUNT(g_MpWeaponSets[j].slots); j++) {
				s32 weaponnum = ptr[j];

				if (weaponnum == WEAPON_MPSHIELD) {
					if (!challengeIsFeatureUnlocked(MPFEATURE_WEAPON_SHIELD)) {
						weaponnum = 0;
					}
				}

				if (weaponnum != g_MpWeapons[g_MpSetup.weapons[j]].weaponnum) {
					ok = false;
				}
			}

			if (ok) {
				done = true;
				g_MpWeaponSetNum = i;
			}
		}
	}

	if (!done) {
		g_MpWeaponSetNum = WEAPONSET_CUSTOM;
	}
}

void mpApplyWeaponSet(void)
{
	s32 i;
	u8 *ptr;

	if (g_MpWeaponSetNum >= 0 && g_MpWeaponSetNum < ARRAYCOUNT(g_MpWeaponSets)) {
		if (challengeIsFeatureUnlocked(g_MpWeaponSets[g_MpWeaponSetNum].requirefeatures[0])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[g_MpWeaponSetNum].requirefeatures[1])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[g_MpWeaponSetNum].requirefeatures[2])
				&& challengeIsFeatureUnlocked(g_MpWeaponSets[g_MpWeaponSetNum].requirefeatures[3])) {
			ptr = &g_MpWeaponSets[g_MpWeaponSetNum].slots[0];
		} else if (g_MpWeaponSets[g_MpWeaponSetNum].unk0c != WEAPON_DISABLED) {
			ptr = &g_MpWeaponSets[g_MpWeaponSetNum].unk0c;
		} else {
			ptr = NULL;
		}

		if (ptr != NULL) {
			for (i = 0; i < ARRAYCOUNT(g_MpSetup.weapons); i++) {
				u32 j;
				bool done = false;
				s32 mpweaponnum = MPWEAPON_NONE;
				s32 weaponnum = ptr[i];

				if (weaponnum == WEAPON_MPSHIELD && !challengeIsFeatureUnlocked(MPFEATURE_WEAPON_SHIELD)) {
					weaponnum = 0;
				}

				for (j = 0; !done; j++) {
					if (j > MPWEAPON_DISABLED) {
						done = true;
					} else if (weaponnum == g_MpWeapons[j].weaponnum) {
						mpweaponnum = j;
						done = true;
					}
				}

				g_MpSetup.weapons[i] = mpweaponnum;
			}
		}
	} else if (g_MpWeaponSetNum == WEAPONSET_RANDOM) {
		s32 numoptions = mpGetNumWeaponOptions();

		for (i = 0; i < ARRAYCOUNT(g_MpSetup.weapons); i++) {
			mpSetWeaponSlot(i, random() % numoptions);
		}
	} else if (g_MpWeaponSetNum == WEAPONSET_RANDOMFIVE) {
		s32 numoptions = mpGetNumWeaponOptions() - 2;

		for (i = 0; i < 5; i++) {
			mpSetWeaponSlot(i, random() % numoptions + 1);
		}

		mpSetWeaponSlot(i, mpGetNumWeaponOptions() - 1);
	}
}

void mpSetWeaponSet(s32 weaponsetnum)
{
	g_MpWeaponSetNum = func0f188f9c(weaponsetnum);
	mpApplyWeaponSet();
}

void func0f1895e8(void)
{
	if (g_MpWeaponSetNum < ARRAYCOUNT(g_MpWeaponSets)) {
		mpApplyWeaponSet();
	}
}

s32 mpGetWeaponSet(void)
{
	return mpCountWeaponSetThing(g_MpWeaponSetNum);
}

bool mpIsPaused(void)
{
	if (PLAYERCOUNT() == 1
			&& g_Vars.mplayerisrunning
			&& g_Menus[g_Vars.currentplayerstats->mpindex].curdialog) {
		return true;
	}

	if (g_MpSetup.paused == PAUSEMODE_UNPAUSED) {
		return false;
	}

	return true;
}

void mpSetPaused(u8 mode)
{
	g_MpSetup.paused = mode;
}

/**
 * Render "Paused" in the middle of the viewport if paused,
 * or "Press START" if player has finished their death animation.
 *
 * @bug: When calling textRender(), viGetWidth() is used twice but it should be
 * viGetViewWidth() and viGetViewHeight(). These arguments to textRender() set
 * the crop box for the text, but the text doesn't extend past the box anyway
 * so it has no effect.
 */
Gfx *mpRenderModalText(Gfx *gdl)
{
	s32 textwidth;
	s32 textheight;
	s32 x;
	s32 y;
	char text[50];
	s32 stack1;

#if VERSION >= VERSION_JPN_FINAL
	g_ScaleX = g_ViRes == VIRES_HI ? 2 : 1;
#endif

	if (g_MpSetup.paused == MPPAUSEMODE_PAUSED) {
		s32 red = (s32) ((1.0f - g_20SecIntervalFrac) * 20.0f * 255.0f) % 255;
		s32 stack2;

		gdl = text0f153628(gdl);

		strcpy(text, langGet(L_MPWEAPONS_040)); // "Paused"

		x = viGetViewLeft() + viGetViewWidth() / 2;

#if VERSION >= VERSION_JPN_FINAL
		x = x / g_ScaleX;
#endif

#if VERSION >= VERSION_NTSC_1_0
		if (g_Menus[g_Vars.currentplayerstats->mpindex].curdialog)
#else
		if (g_Menus[g_Vars.currentplayernum].curdialog)
#endif
		{
			y = viGetViewTop() + 10;
		} else {
			y = viGetViewTop() + viGetViewHeight() / 2;
		}

#if VERSION >= VERSION_JPN_FINAL
		textMeasure(&textheight, &textwidth, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0);
#elif PAL
		// Use smaller fonts
		textMeasure(&textheight, &textwidth, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0);
#else
		textMeasure(&textheight, &textwidth, text, g_CharsHandelGothicMd, g_FontHandelGothicMd, 0);
#endif
		x -= textwidth / 2;

#if VERSION >= VERSION_JPN_FINAL
		gdl = func0f1574d0jf(gdl, &x, &y, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, (red << 24) | 0x00ff00ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#elif PAL
		gdl = textRender(gdl, &x, &y, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, (red << 24) | 0x00ff00ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#else
		gdl = textRender(gdl, &x, &y, text, g_CharsHandelGothicMd, g_FontHandelGothicMd, (red << 24) | 0x00ff00ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#endif

		gdl = text0f153780(gdl);
	} else if (!g_MainIsEndscreen
			&& g_MpSetup.paused == MPPAUSEMODE_UNPAUSED
			&& g_Vars.currentplayer->isdead
			&& g_Vars.currentplayer->redbloodfinished
			&& g_Vars.currentplayer->deathanimfinished
			&& !(g_Vars.coopplayernum >= 0 && ((g_Vars.bond->isdead && g_Vars.coop->isdead) || !g_Vars.currentplayer->coopcanrestart || g_InCutscene))
			&& !(g_Vars.antiplayernum >= 0 && ((g_Vars.currentplayer != g_Vars.anti || g_InCutscene)))
			&& g_NumReasonsToEndMpMatch == 0) {
		// Render "Press START" text
		gdl = text0f153628(gdl);

		strcpy(text, langGet(L_MPWEAPONS_039));

		x = viGetViewLeft() + viGetViewWidth() / 2;

#if VERSION >= VERSION_JPN_FINAL
		x = x / g_ScaleX;
#endif

		y = viGetViewTop() + viGetViewHeight() / 2;

		textMeasure(&textheight, &textwidth, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0);
		x -= textwidth / 2;

#if VERSION >= VERSION_JPN_FINAL
		gdl = func0f1574d0jf(gdl, &x, &y, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0xff0000ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#else
		gdl = textRender(gdl, &x, &y, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0xff0000ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#endif

		if (g_Vars.currentplayer->deadtimer > 0) {
			// Render countdown timer
			s32 countdowny = viGetViewTop() + viGetViewHeight() / 2 + textheight + 2;
			s32 countdownx = viGetViewLeft() + viGetViewWidth() / 2;

#if VERSION >= VERSION_JPN_FINAL
			countdownx = countdownx / g_ScaleX;
#endif
			sprintf(text, "%d\n", (g_Vars.currentplayer->deadtimer + TICKS(60) - 1) / TICKS(60));

			textMeasure(&textheight, &textwidth, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0);
			x = countdownx - textwidth / 2;
			y = countdowny;

#if VERSION >= VERSION_JPN_FINAL
			gdl = func0f1574d0jf(gdl, &x, &y, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0xff0000ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#else
			gdl = textRender(gdl, &x, &y, text, g_CharsHandelGothicSm, g_FontHandelGothicSm, 0xff0000ff, 0x000000ff, viGetWidth(), viGetWidth(), 0, 0);
#endif
		}

		gdl = text0f153780(gdl);

		g_Menus[g_Vars.currentplayerstats->mpindex].openinhibit = 10;
	}

#if VERSION >= VERSION_JPN_FINAL
	g_ScaleX = 1;
#endif

	return gdl;
}

s32 mpFindMaxInt(s32 numplayers, s32 val0, s32 val1, s32 val2, s32 val3)
{
	s32 bestvalue = val0;
	s32 bestplayer = 0;

	if (numplayers >= 2) {
		if (val1 > bestvalue || (val1 == bestvalue && (random() % 2))) {
			bestplayer = 1;
			bestvalue = val1;
		} else {
			bestvalue = val0;
			bestplayer = 0;
		}

		if (numplayers >= 3) {
			if (val2 > bestvalue || (val2 == bestvalue && (random() % 2))) {
				bestplayer = 2;
				bestvalue = val2;
			}

			if (numplayers >= 4) {
				if (val3 > bestvalue || (val3 == bestvalue && (random() % 2))) {
					bestplayer = 3;
				}
			}
		}
	}

	return bestplayer;
}

s32 mpFindMinInt(s32 numplayers, s32 val0, s32 val1, s32 val2, s32 val3)
{
	s32 bestvalue = val0;
	s32 bestplayer = 0;

	if (numplayers >= 2) {
		if (val1 < bestvalue || (val1 == bestvalue && (random() % 2))) {
			bestplayer = 1;
			bestvalue = val1;
		} else {
			bestvalue = val0;
			bestplayer = 0;
		}

		if (numplayers >= 3) {
			if (val2 < bestvalue || (val2 == bestvalue && (random() % 2))) {
				bestplayer = 2;
				bestvalue = val2;
			}

			if (numplayers >= 4) {
				if (val3 < bestvalue || (val3 == bestvalue && (random() % 2))) {
					bestplayer = 3;
				}
			}
		}
	}

	return bestplayer;
}

s32 mpFindMaxFloat(s32 numplayers, f32 val0, f32 val1, f32 val2, f32 val3)
{
	// @bug: bestvalue should be an f32. Any value saved into here will be
	// rounded down which may cause the function to return an incorrect result.
	s32 bestvalue;
	s32 bestplayer = 0;

	if (numplayers >= 2) {
		if (val1 > val0 || (val1 == val0 && (random() % 2))) {
			bestplayer = 1;
			bestvalue = val1;
		} else {
			bestvalue = val0;
			bestplayer = 0;
		}

		if (numplayers >= 3) {
			if (val2 > bestvalue || (val2 == bestvalue && (random() % 2))) {
				bestplayer = 2;
				bestvalue = val2;
			}

			if (numplayers >= 4) {
				if (val3 > bestvalue || (val3 == bestvalue && (random() % 2))) {
					bestplayer = 3;
				}
			}
		}
	}

	return bestplayer;
}

s32 mpFindMinFloat(s32 numplayers, f32 val0, f32 val1, f32 val2, f32 val3)
{
	// @bug: bestvalue should be an f32. Any value saved into here will be
	// rounded down which may cause the function to return an incorrect result.
	s32 bestvalue;
	s32 bestplayer = 0;

	if (numplayers >= 2) {
		if (val0);

		if (val1 < val0 || (val1 == val0 && (random() % 2))) {
			bestplayer = 1;
			bestvalue = val1;
		} else {
			bestplayer = 0;
			bestvalue = val0;
		}

		if (numplayers >= 3) {
			if (val2 < bestvalue || (val2 == bestvalue && (random() % 2))) {
				bestplayer = 2;
				bestvalue = val2;
			}

			if (numplayers >= 4) {
				if (val3 < bestvalue || (val3 == bestvalue && (random() % 2))) {
					bestplayer = 3;
				}
			}
		}
	}

	return bestplayer;
}

struct mpweaponset g_MpWeaponSets[12] = {
	{ /*0x00*/ L_MPWEAPONS_055, { WEAPON_FALCON2,          WEAPON_MAGSEC4,     WEAPON_PHOENIX,     WEAPON_MAULER,         WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_PHOENIX,         MPFEATURE_WEAPON_MAULER,     0,                              0                       }, WEAPON_FALCON2,     WEAPON_MAGSEC4,     WEAPON_FALCON2,   WEAPON_DY357MAGNUM,    WEAPON_MPSHIELD, WEAPON_DISABLED }, // Pistols
	{ /*0x01*/ L_MPWEAPONS_054, { WEAPON_FALCON2,          WEAPON_CMP150,      WEAPON_LAPTOPGUN,   WEAPON_AR34,           WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_LAPTOPGUN,       0,                           0,                              0                       }, WEAPON_FALCON2,     WEAPON_CMP150,      WEAPON_DRAGON,    WEAPON_AR34,           WEAPON_MPSHIELD, WEAPON_DISABLED }, // Automatics
	{ /*0x02*/ L_MPWEAPONS_053, { WEAPON_MAGSEC4,          WEAPON_DY357MAGNUM, WEAPON_SHOTGUN,     WEAPON_RCP120,         WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_SHOTGUN,         MPFEATURE_WEAPON_RCP120,     0,                              0                       }, WEAPON_MAGSEC4,     WEAPON_DY357MAGNUM, WEAPON_DRAGON,    WEAPON_AR34,           WEAPON_MPSHIELD, WEAPON_DISABLED }, // Power
	{ /*0x03*/ L_MPWEAPONS_052, { WEAPON_PHOENIX,          WEAPON_CYCLONE,     WEAPON_CALLISTO,    WEAPON_FARSIGHT,       WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_FARSIGHT,        MPFEATURE_WEAPON_CALLISTO,   0,                              0                       }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // FarSight
	{ /*0x04*/ L_MPWEAPONS_051, { WEAPON_FALCON2,          WEAPON_CMP150,      WEAPON_DRAGON,      WEAPON_TRANQUILIZER,   WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_TRANQUILIZER,    0,                           0,                              0                       }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // Tranquilizer
	{ /*0x05*/ L_MPWEAPONS_050, { WEAPON_MAULER,           WEAPON_K7AVENGER,   WEAPON_REAPER,      WEAPON_SUPERDRAGON,    WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_SUPERDRAGON,     MPFEATURE_WEAPON_MAULER,     MPFEATURE_WEAPON_K7AVENGER,     MPFEATURE_WEAPON_REAPER }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // Heavy
	{ /*0x06*/ L_MPWEAPONS_049, { WEAPON_FALCON2_SILENCER, WEAPON_GRENADE,     WEAPON_CMP150,      WEAPON_DY357LX,        WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_FALCON2SILENCED, MPFEATURE_WEAPON_DY357LX,    0,                              0                       }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // Golden Magnum
	{ /*0x07*/ L_MPWEAPONS_048, { WEAPON_DEVASTATOR,       WEAPON_DEVASTATOR,  WEAPON_SUPERDRAGON, WEAPON_SUPERDRAGON,    WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_SUPERDRAGON,     MPFEATURE_WEAPON_DEVASTATOR, 0,                              0                       }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // Explosive
	{ /*0x08*/ L_MPWEAPONS_047, { WEAPON_MAGSEC4,          WEAPON_CMP150,      WEAPON_AR34,        WEAPON_DEVASTATOR,     WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_DEVASTATOR,      0,                           0,                              0                       }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // Grenade Launcher
	{ /*0x09*/ L_MPWEAPONS_046, { WEAPON_MAULER,           WEAPON_CYCLONE,     WEAPON_DRAGON,      WEAPON_ROCKETLAUNCHER, WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_MAULER,          0,                           0,                              0                       }, WEAPON_FALCON2,     WEAPON_CYCLONE,     WEAPON_DRAGON,    WEAPON_ROCKETLAUNCHER, WEAPON_MPSHIELD, WEAPON_DISABLED }, // Rocket Launcher
	{ /*0x0a*/ L_MPWEAPONS_045, { WEAPON_MAGSEC4,          WEAPON_LAPTOPGUN,   WEAPON_K7AVENGER,   WEAPON_PROXIMITYMINE,  WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_LAPTOPGUN,       MPFEATURE_WEAPON_K7AVENGER,  MPFEATURE_WEAPON_PROXIMITYMINE, 0                       }, WEAPON_DISABLED,    WEAPON_DISABLED,    WEAPON_DISABLED,  WEAPON_DISABLED,       WEAPON_DISABLED, WEAPON_DISABLED }, // Proximity Mine
#if VERSION == VERSION_JPN_FINAL
	{ /*0x0b*/ L_MPWEAPONS_044, { WEAPON_TIMEDMINE,        WEAPON_CROSSBOW,    WEAPON_TIMEDMINE,   WEAPON_CROSSBOW,       WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_CROSSBOW,        0,                           0,                              0                       }, WEAPON_TIMEDMINE,   WEAPON_TIMEDMINE,   WEAPON_TIMEDMINE, WEAPON_TIMEDMINE,      WEAPON_MPSHIELD, WEAPON_DISABLED }, // Close Combat
#else
	{ /*0x0b*/ L_MPWEAPONS_044, { WEAPON_COMBATKNIFE,      WEAPON_COMBATKNIFE, WEAPON_TIMEDMINE,   WEAPON_CROSSBOW,       WEAPON_MPSHIELD, WEAPON_DISABLED }, { MPFEATURE_WEAPON_CROSSBOW,        0,                           0,                              0                       }, WEAPON_COMBATKNIFE, WEAPON_COMBATKNIFE, WEAPON_TIMEDMINE, WEAPON_TIMEDMINE,      WEAPON_MPSHIELD, WEAPON_DISABLED }, // Close Combat
#endif
};

s32 g_MpWeaponSetNum = 0x00000000;

u16 g_AwardNames[] = {
	L_MPMENU_000, // "Most Suicidal"
	L_MPMENU_001, // "Who Needs Ammo?"
	L_MPMENU_002, // "Least Shielded"
	L_MPMENU_003, // "Best Protected"
	L_MPMENU_004, // "Marksmanship"
	L_MPMENU_005, // "Most Professional"
	L_MPMENU_006, // "Most Deadly"
	L_MPMENU_007, // "Most Harmless"
	L_MPMENU_008, // "Most Cowardly"
	L_MPMENU_009, // "Most Frantic"
	L_MPMENU_010, // "Most Honorable"
	L_MPMENU_011, // "Most Dishonourable"
	L_MPMENU_012, // "Shortest Life"
	L_MPMENU_013, // "Longest Life"
	L_MPMENU_014, // "Double Kill"
	L_MPMENU_015, // "Triple Kill"
	L_MPMENU_016, // "Quad Kill"
};

void mpCalculatePlayerTitle(struct mpplayerconfig *mpplayer)
{
#if VERSION >= VERSION_NTSC_1_0
	const u32 tiers[] = { 2, 4, 8, 16, 28, 60, 100, 150, 210, 300 };
#else
	const u32 tiers[] = { 2, 4, 8, 16, 28, 48, 78, 138, 198, 300 };
#endif
	s32 tallies[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	s32 sum;
	s32 max;
	s32 i;

#if VERSION >= VERSION_NTSC_1_0
#define MULT(val) (val * 3)
#else
#define MULT(val) (val)
#endif

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->kills >= tiers[i] * MULT(20)) {
			tallies[0]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->gameswon >= tiers[i] * MULT(1)) {
			tallies[1]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->accuracymedals >= tiers[i] * MULT(1)) {
			tallies[2]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->headshotmedals >= tiers[i] * MULT(1)) {
			tallies[3]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->killmastermedals >= tiers[i] * MULT(1)) {
			tallies[4]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->time >= tiers[i] * MULT(1200)) {
			tallies[5]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->distance >= tiers[i] * MULT(100)) {
			tallies[6]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->damagedealt >= tiers[i] * MULT(1)) {
			tallies[7]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->ammoused >= tiers[i] * MULT(500)) {
			tallies[8]++;
		} else {
			break;
		}
	}

	for (i = 0; i < ARRAYCOUNT(tiers); i++) {
		if (mpplayer->survivormedals >= tiers[i] * MULT(1)) {
			tallies[9]++;
		} else {
			break;
		}
	}

	sum = 0;

	for (i = 0; i < ARRAYCOUNT(tallies); i++) {
		sum = sum + tallies[i];
	}

	if (sum > 100) {
		sum = 100;
	}

	mpplayer->title = sum / 5;

	max = MPPLAYERTITLE_PERFECT;

	if (mpplayer->title > max) {
		mpplayer->title = max;
	}
}

#if VERSION >= VERSION_NTSC_1_0
const char var7f1b8ad0[] = "%s%sAccuracy Peak! real value: %f (*100)\n";
const char var7f1b8afc[] = "";
const char var7f1b8b00[] = "";
const char var7f1b8b04[] = "%splayer %d Accuracy :%f\n";
const char var7f1b8b20[] = "";
const char var7f1b8b24[] = "%splayer %d dist:%f -> %f = %d\n";
const char var7f1b8b44[] = "";
const char var7f1b8b48[] = "Player %d TitleCalc ============\n";
#endif

struct mphead g_MpBeauHeads[] = {
	// head, require feature
	{ HEAD_BEAU2, 0 },
	{ HEAD_BEAU3, 0 },
	{ HEAD_BEAU4, 0 },
	{ HEAD_BEAU5, 0 },
	{ HEAD_BEAU6, 0 },
};

struct mphead g_MpHeads[] = {
	// head, require feature
	{ /*0x00*/ HEAD_DARK_COMBAT,  0                          },
	{ /*0x01*/ HEAD_DARK_FROCK,   MPFEATURE_CHR_CI           },
	{ /*0x02*/ HEAD_DARKAQUA,     MPFEATURE_CHR_PELAGIC      },
	{ /*0x03*/ HEAD_DARK_SNOW,    MPFEATURE_CHR_DARKSNOW               },
	{ /*0x04*/ HEAD_ELVIS,        MPFEATURE_CHR_ELVIS        },
	{ /*0x05*/ HEAD_ELVIS_GOGS,   MPFEATURE_CHR_ELVIS        },
	{ /*0x06*/ HEAD_CARRINGTON,   0                          },
	{ /*0x07*/ HEAD_MRBLONDE,     MPFEATURE_CHR_MRBLONDE     },
	{ /*0x08*/ HEAD_CASSANDRA,    0                          },
	{ /*0x09*/ HEAD_TRENT,        MPFEATURE_CHR_TRENT        },
	{ /*0x0a*/ HEAD_JONATHAN,     MPFEATURE_CHR_INFILTRATION },
	{ /*0x0b*/ HEAD_VD,           0                          },
	{ /*0x0c*/ HEAD_PRESIDENT,    MPFEATURE_CHR_CI           },
	{ /*0x0d*/ HEAD_DDSHOCK,      0                          },
	{ /*0x0e*/ HEAD_BIOTECH,      MPFEATURE_CHR_BIOTECH      },
	{ /*0x0f*/ HEAD_DDSNIPER,     MPFEATURE_CHR_VILLACHRS    },
	{ /*0x10*/ HEAD_A51FACEPLATE, MPFEATURE_CHR_INFILTRATION },
	{ /*0x11*/ HEAD_SECRETARY,    0                          },
	{ /*0x12*/ HEAD_FEM_GUARD,    MPFEATURE_CHR_FEMGUARD     },
	{ /*0x13*/ HEAD_FEM_GUARD2,   MPFEATURE_CHR_FEMGUARD     },
	{ /*0x14*/ HEAD_MAIAN_S,      MPFEATURE_CHR_ELVIS        },
	{ /*0x15*/ HEAD_JON,          0                          },
	{ /*0x16*/ HEAD_BEAU1,        0                          },
	{ /*0x17*/ HEAD_ROSS,         0                          },
	{ /*0x18*/ HEAD_MARK2,        0                          },
	{ /*0x19*/ HEAD_CHRIST,       0                          },
	{ /*0x1a*/ HEAD_RUSS,         0                          },
	{ /*0x1b*/ HEAD_DARLING,      0                          },
	{ /*0x1c*/ HEAD_BRIAN,        0                          },
	{ /*0x1d*/ HEAD_JAMIE,        0                          },
	{ /*0x1e*/ HEAD_DUNCAN2,      0                          },
	{ /*0x1f*/ HEAD_KEITH,        0                          },
	{ /*0x20*/ HEAD_STEVEM,       0                          },
	{ /*0x21*/ HEAD_GRANT,        0                          },
	{ /*0x22*/ HEAD_PENNY,        0                          },
	{ /*0x23*/ HEAD_DAVEC,        0                          },
	{ /*0x24*/ HEAD_JONES,        0                          },
	{ /*0x25*/ HEAD_GRAHAM,       0                          },
	{ /*0x26*/ HEAD_ROBERT,       0                          },
	{ /*0x27*/ HEAD_NEIL2,        0                          },
	{ /*0x28*/ HEAD_SHAUN,        0                          },
	{ /*0x29*/ HEAD_ROBIN,        0                          },
	{ /*0x2a*/ HEAD_COOK,         0                          },
	{ /*0x2b*/ HEAD_PRYCE,        0                          },
	{ /*0x2c*/ HEAD_SILKE,        0                          },
	{ /*0x2d*/ HEAD_SMITH,        0                          },
	{ /*0x2e*/ HEAD_GARETH,       0                          },
	{ /*0x2f*/ HEAD_MURCHIE,      0                          },
	{ /*0x30*/ HEAD_WONG,         0                          },
	{ /*0x31*/ HEAD_CARTER,       0                          },
	{ /*0x32*/ HEAD_TINTIN,       0                          },
	{ /*0x33*/ HEAD_MUNTON,       0                          },
	{ /*0x34*/ HEAD_STAMPER,      0                          },
	{ /*0x35*/ HEAD_PHELPS,       0                          },
	{ /*0x36*/ HEAD_ALEX,         0                          },
	{ /*0x37*/ HEAD_JULIANNE,     0                          },
	{ /*0x38*/ HEAD_LAURA,        0                          },
	{ /*0x39*/ HEAD_EDMCG,        0                          },
	{ /*0x3a*/ HEAD_ANKA,         0                          },
	{ /*0x3b*/ HEAD_LESLIE_S,     0                          },
	{ /*0x3c*/ HEAD_MATT_C,       0                          },
	{ /*0x3d*/ HEAD_PEER_S,       0                          },
	{ /*0x3e*/ HEAD_EILEEN_T,     0                          },
	{ /*0x3f*/ HEAD_ANDY_R,       0                          },
	{ /*0x40*/ HEAD_BEN_R,        0                          },
	{ /*0x41*/ HEAD_STEVE_K,      0                          },
	{ /*0x42*/ HEAD_SANCHEZ,      0                          },
	{ /*0x43*/ HEAD_TIM,          0                          },
	{ /*0x44*/ HEAD_KEN,          0                          },
	{ /*0x45*/ HEAD_EILEEN_H,     0                          },
	{ /*0x46*/ HEAD_SCOTT_H,      0                          },
	{ /*0x47*/ HEAD_JOEL,         0                          },
	{ /*0x48*/ HEAD_GRIFFEY,      0                          },
#if VERSION != VERSION_JPN_FINAL
	{ /*0x49*/ HEAD_MOTO,         0                          },
#endif
	{ /*0x4a*/ HEAD_WINNER,       0                          },
};

u32 g_BotHeads[] = {
	MPHEAD_JON,
	MPHEAD_BEAU1,
	MPHEAD_ROSS,
	MPHEAD_MARK2,
	MPHEAD_CHRIST,
	MPHEAD_RUSS,
	MPHEAD_DARLING,
	MPHEAD_BRIAN,
	MPHEAD_JAMIE,
	MPHEAD_DUNCAN2,
	MPHEAD_KEITH,
	MPHEAD_STEVEM,
	MPHEAD_GRANT,
	MPHEAD_PENNY,
	MPHEAD_DAVEC,
	MPHEAD_JONES,
	MPHEAD_GRAHAM,
	MPHEAD_ROBERT,
	MPHEAD_NEIL2,
	MPHEAD_SHAUN,
	MPHEAD_ROBIN,
	MPHEAD_COOK,
	MPHEAD_PRYCE,
	MPHEAD_SILKE,
	MPHEAD_SMITH,
	MPHEAD_GARETH,
	MPHEAD_MURCHIE,
	MPHEAD_WONG,
	MPHEAD_CARTER,
	MPHEAD_TINTIN,
	MPHEAD_MUNTON,
	MPHEAD_STAMPER,
	MPHEAD_PHELPS,
	MPHEAD_ALEX,
	MPHEAD_JULIANNE,
	MPHEAD_LAURA,
	MPHEAD_EDMCG,
	MPHEAD_ANKA,
	MPHEAD_LESLIE_S,
	MPHEAD_MATT_C,
	MPHEAD_PEER_S,
	MPHEAD_EILEEN_T,
	MPHEAD_ANDY_R,
	MPHEAD_BEN_R,
	MPHEAD_STEVE_K,
	MPHEAD_SANCHEZ,
	MPHEAD_TIM,
	MPHEAD_KEN,
	MPHEAD_EILEEN_H,
	MPHEAD_SCOTT_H,
	MPHEAD_JOEL,
	MPHEAD_GRIFFEY,
#if VERSION != VERSION_JPN_FINAL
	MPHEAD_MOTO,
#endif
};

struct botprofile g_BotProfiles[] = {
	// type,           difficulty,      name,       body,                 require feature
	{ BOTTYPE_GENERAL, BOTDIFF_MEAT,    L_MISC_088, MPBODY_DD_GUARD,      0                         },
	{ BOTTYPE_GENERAL, BOTDIFF_EASY,    L_MISC_089, MPBODY_DD_SECGUARD,   0                         },
	{ BOTTYPE_GENERAL, BOTDIFF_NORMAL,  L_MISC_090, MPBODY_DD_SHOCK_INF,  0                         },
	{ BOTTYPE_GENERAL, BOTDIFF_HARD,    L_MISC_091, MPBODY_DDSHOCK,       MPFEATURE_BOTDIFF_HARD    },
	{ BOTTYPE_GENERAL, BOTDIFF_PERFECT, L_MISC_092, MPBODY_STRIPES,       MPFEATURE_BOTDIFF_PERFECT },
	{ BOTTYPE_GENERAL, BOTDIFF_DARK,    L_MISC_093, MPBODY_MOORE,         MPFEATURE_BOTDIFF_DARK    },
	{ BOTTYPE_PEACE,   BOTDIFF_NORMAL,  L_MISC_094, MPBODY_DD_LABTECH,    0                         },
	{ BOTTYPE_SHIELD,  BOTDIFF_NORMAL,  L_MISC_095, MPBODY_G5_SWAT_GUARD, 0                         },
	{ BOTTYPE_ROCKET,  BOTDIFF_NORMAL,  L_MISC_096, MPBODY_G5_GUARD,      0                         },
	{ BOTTYPE_KAZE,    BOTDIFF_NORMAL,  L_MISC_097, MPBODY_PRES_SECURITY, 0                         },
	{ BOTTYPE_FIST,    BOTDIFF_NORMAL,  L_MISC_098, MPBODY_PELAGIC_GUARD, 0                         },
	{ BOTTYPE_PREY,    BOTDIFF_NORMAL,  L_MISC_099, MPBODY_DDSHOCK,       0                         },
	{ BOTTYPE_COWARD,  BOTDIFF_NORMAL,  L_MISC_100, MPBODY_PRESIDENT,     0                         },
	{ BOTTYPE_JUDGE,   BOTDIFF_NORMAL,  L_MISC_101, MPBODY_STEWARD,       0                         },
	{ BOTTYPE_FEUD,    BOTDIFF_NORMAL,  L_MISC_102, MPBODY_NSA_LACKEY,    0                         },
	{ BOTTYPE_SPEED,   BOTDIFF_NORMAL,  L_MISC_103, MPBODY_MRBLONDE,      0                         },
	{ BOTTYPE_TURTLE,  BOTDIFF_NORMAL,  L_MISC_104, MPBODY_CARRINGTON,    0                         },
	{ BOTTYPE_VENGE,   BOTDIFF_NORMAL,  L_MISC_105, MPBODY_ALASKAN_GUARD, 0                         },
};

struct mpbody g_MpBodies[] = {
	// global body ID,                name,            head,             require feature
	/*0x00*/ { BODY_DARK_COMBAT,      L_OPTIONS_016,   HEAD_DARK_COMBAT, 0                          },
	/*0x01*/ { BODY_DARK_TRENCH,      L_OPTIONS_017,   HEAD_DARK_COMBAT, MPFEATURE_CHR_JOTRENCH     },
	/*0x02*/ { BODY_DARK_FROCK,       L_OPTIONS_018,   HEAD_DARK_FROCK,  MPFEATURE_CHR_CI           },
	/*0x03*/ { BODY_DARK_RIPPED,      L_OPTIONS_019,   HEAD_DARK_FROCK,  MPFEATURE_CHR_CI           },
	/*0x04*/ { BODY_DARK_AF1,         L_OPTIONS_020,   HEAD_DARK_COMBAT, MPFEATURE_CHR_AF1          },
	/*0x05*/ { BODY_DARK_LEATHER,     L_MPWEAPONS_156, HEAD_DARK_COMBAT, MPFEATURE_CHR_G5           },
	/*0x06*/ { BODY_DARK_NEGOTIATOR,  L_MPWEAPONS_157, HEAD_DARK_COMBAT, MPFEATURE_CHR_VILLACHRS    },
	/*0x07*/ { BODY_DARKWET,          L_OPTIONS_021,   HEAD_DARKAQUA,    MPFEATURE_CHR_PELAGIC      },
	/*0x08*/ { BODY_DARKAQUALUNG,     L_OPTIONS_022,   HEAD_DARKAQUA,    MPFEATURE_CHR_PELAGIC      },
	/*0x09*/ { BODY_DARKSNOW,         L_OPTIONS_023,   HEAD_DARK_SNOW,   MPFEATURE_CHR_DARKSNOW     },
	/*0x0a*/ { BODY_DARKLAB,          L_OPTIONS_024,   HEAD_DARK_COMBAT, MPFEATURE_CHR_INFILTRATION },
	/*0x0b*/ { BODY_THEKING,          L_OPTIONS_025,   HEAD_ELVIS,       MPFEATURE_CHR_ELVIS        },
	/*0x0c*/ { BODY_ELVIS1,           L_OPTIONS_026,   HEAD_ELVIS,       MPFEATURE_CHR_ELVIS        },
	/*0x0d*/ { BODY_ELVISWAISTCOAT,   L_MPWEAPONS_158, HEAD_ELVIS,       MPFEATURE_CHR_ELVIS        },
	/*0x0e*/ { BODY_CARRINGTON,       L_OPTIONS_027,   HEAD_CARRINGTON,  0                          },
	/*0x0f*/ { BODY_CARREVENINGSUIT,  L_OPTIONS_028,   HEAD_CARRINGTON,  MPFEATURE_CHR_CI           },
	/*0x10*/ { BODY_MRBLONDE,         L_OPTIONS_029,   HEAD_MRBLONDE,    MPFEATURE_CHR_MRBLONDE     },
	/*0x11*/ { BODY_CASSANDRA,        L_OPTIONS_030,   HEAD_CASSANDRA,   0                          },
	/*0x12*/ { BODY_TRENT,            L_OPTIONS_031,   HEAD_TRENT,       MPFEATURE_CHR_TRENT        },
	/*0x13*/ { BODY_JONATHAN,         L_OPTIONS_032,   HEAD_JONATHAN,    MPFEATURE_CHR_JONATHAN     },
	/*0x14*/ { BODY_CILABTECH,        L_OPTIONS_033,   1000,             0                          },
	/*0x15*/ { BODY_CIFEMTECH,        L_OPTIONS_034,   1000,             0                          },
	/*0x16*/ { BODY_CISOLDIER,        L_OPTIONS_035,   1000,             0                          },
	/*0x17*/ { BODY_DDSHOCK,          L_OPTIONS_036,   HEAD_DDSHOCK,     0                          },
	/*0x18*/ { BODY_FEM_GUARD,        L_OPTIONS_037,   1000,             MPFEATURE_CHR_FEMGUARD     },
	/*0x19*/ { BODY_DD_SECGUARD,      L_OPTIONS_038,   1000,             0                          },
	/*0x1a*/ { BODY_DD_GUARD,         L_OPTIONS_039,   1000,             0                          },
	/*0x1b*/ { BODY_DD_SHOCK_INF,     L_OPTIONS_040,   1000,             0                          },
	/*0x1c*/ { BODY_SECRETARY,        L_OPTIONS_041,   1000,             0                          },
	/*0x1d*/ { BODY_OFFICEWORKER,     L_OPTIONS_042,   1000,             MPFEATURE_CHR_OFFICEWORKER },
	/*0x1e*/ { BODY_OFFICEWORKER2,    L_OPTIONS_043,   1000,             MPFEATURE_CHR_OFFICEWORKER },
	/*0x1f*/ { BODY_NEGOTIATOR,       L_OPTIONS_044,   1000,             MPFEATURE_CHR_VILLACHRS    },
	/*0x20*/ { BODY_DDSNIPER,         L_OPTIONS_045,   HEAD_DDSNIPER,    MPFEATURE_CHR_VILLACHRS    },
	/*0x21*/ { BODY_G5_GUARD,         L_OPTIONS_046,   1000,             MPFEATURE_CHR_G5           },
	/*0x22*/ { BODY_G5_SWAT_GUARD,    L_OPTIONS_047,   1000,             MPFEATURE_CHR_G5           },
	/*0x23*/ { BODY_CIAGUY,           L_OPTIONS_048,   1000,             MPFEATURE_CHR_CIAFBI       },
	/*0x24*/ { BODY_FBIGUY,           L_OPTIONS_049,   1000,             MPFEATURE_CHR_CIAFBI       },
	/*0x25*/ { BODY_AREA51GUARD,      L_OPTIONS_050,   1000,             MPFEATURE_CHR_INFILTRATION },
	/*0x26*/ { BODY_A51TROOPER,       L_OPTIONS_051,   1000,             MPFEATURE_CHR_INFILTRATION },
	/*0x27*/ { BODY_A51AIRMAN,        L_OPTIONS_052,   1000,             MPFEATURE_CHR_INFILTRATION },
	/*0x28*/ { BODY_OVERALL,          L_OPTIONS_053,   1000,             MPFEATURE_CHR_INFILTRATION },
	/*0x29*/ { BODY_STRIPES,          L_OPTIONS_054,   1000,             MPFEATURE_CHR_STRIPES      },
	/*0x2a*/ { BODY_LABTECH,          L_OPTIONS_055,   1000,             MPFEATURE_CHR_LABTECH      },
	/*0x2b*/ { BODY_FEMLABTECH,       L_OPTIONS_056,   1000,             MPFEATURE_CHR_LABTECH      },
	/*0x2c*/ { BODY_DD_LABTECH,       L_OPTIONS_057,   1000,             MPFEATURE_CHR_LABTECH      },
	/*0x2d*/ { BODY_BIOTECH,          L_OPTIONS_058,   HEAD_BIOTECH,     MPFEATURE_CHR_BIOTECH      },
	/*0x2e*/ { BODY_ALASKAN_GUARD,    L_OPTIONS_059,   1000,             MPFEATURE_CHR_ALASKANGUARD },
	/*0x2f*/ { BODY_PILOTAF1,         L_OPTIONS_060,   1000,             MPFEATURE_CHR_AF1          },
	/*0x30*/ { BODY_STEWARD,          L_OPTIONS_061,   1000,             MPFEATURE_CHR_AF1          },
	/*0x31*/ { BODY_STEWARDESS,       L_OPTIONS_062,   1000,             MPFEATURE_CHR_AF1          },
	/*0x32*/ { BODY_STEWARDESS_COAT,  L_OPTIONS_063,   1000,             MPFEATURE_CHR_AF1          },
	/*0x33*/ { BODY_PRESIDENT,        L_OPTIONS_064,   HEAD_PRESIDENT,   MPFEATURE_CHR_CI           },
	/*0x34*/ { BODY_NSA_LACKEY,       L_OPTIONS_065,   1000,             MPFEATURE_CHR_NSALACKEY    },
	/*0x35*/ { BODY_PRES_SECURITY,    L_OPTIONS_066,   1000,             MPFEATURE_CHR_PRESSECURITY },
	/*0x36*/ { BODY_PRESIDENT_CLONE2, L_OPTIONS_067,   HEAD_PRESIDENT,   MPFEATURE_CHR_PRESCLONE    },
	/*0x37*/ { BODY_PELAGIC_GUARD,    L_OPTIONS_068,   1000,             MPFEATURE_CHR_PELAGIC      },
	/*0x38*/ { BODY_MAIAN_SOLDIER,    L_OPTIONS_069,   HEAD_MAIAN_S,     MPFEATURE_CHR_ELVIS        },
	/*0x39*/ { BODY_CONNERY,          L_OPTIONS_070,   1000,             MPFEATURE_8BOTS            },
	/*0x3a*/ { BODY_MOORE,            L_OPTIONS_070,   1000,             MPFEATURE_8BOTS            },
	/*0x3b*/ { BODY_DALTON,           L_OPTIONS_070,   1000,             MPFEATURE_8BOTS            },
	/*0x3c*/ { BODY_DJBOND,           L_OPTIONS_070,   1000,             MPFEATURE_8BOTS            },
};

u32 g_MpMaleHeads[] = {
	HEAD_JON,
	HEAD_BEAU1,
	HEAD_ROSS,
	HEAD_MARK2,
	HEAD_CHRIST,
	HEAD_RUSS,
	HEAD_DARLING,
	HEAD_BRIAN,
	HEAD_JAMIE,
	HEAD_DUNCAN2,
	HEAD_KEITH,
	HEAD_STEVEM,
	HEAD_GRANT,
	HEAD_PENNY,
	HEAD_DAVEC,
	HEAD_JONES,
	HEAD_GRAHAM,
	HEAD_NEIL2,
	HEAD_SHAUN,
	HEAD_ROBIN,
	HEAD_COOK,
	HEAD_PRYCE,
	HEAD_SILKE,
	HEAD_SMITH,
	HEAD_GARETH,
	HEAD_MURCHIE,
	HEAD_WONG,
	HEAD_CARTER,
	HEAD_TINTIN,
	HEAD_MUNTON,
	HEAD_STAMPER,
	HEAD_PHELPS,
	HEAD_EDMCG,
	HEAD_MATT_C,
	HEAD_PEER_S,
	HEAD_ANDY_R,
	HEAD_BEN_R,
	HEAD_STEVE_K,
	HEAD_SANCHEZ,
	HEAD_TIM,
	HEAD_KEN,
	HEAD_SCOTT_H,
	HEAD_JOEL,
#if VERSION != VERSION_JPN_FINAL
	HEAD_MOTO,
#endif
};

u32 g_MpFemaleHeads[] = {
	HEAD_ALEX,
	HEAD_JULIANNE,
	HEAD_LAURA,
	HEAD_ANKA,
	HEAD_LESLIE_S,
	HEAD_EILEEN_T,
	HEAD_EILEEN_H,
};

/**
 * Calculate player awards, medals, and update character statistics.
 */
void mpCalculateAwards(void)
{
	s32 playercount;
	s32 i;
	s32 j;
	s32 prevplayernum;
	s32 duration60;
	struct awardmetrics metrics[MAX_PLAYERS];

	// @bug: playerrankings should have 12 elements. Because it's too small,
	// overflow occurs in mpGetPlayerRankings. The overflow writes into the
	// metrics array (above) which is yet to be initialised, so this bug has
	// no effect on IDO.
#ifdef AVOID_UB
	struct ranking playerrankings[MAX_MPCHRS];
#else
	struct ranking playerrankings[1];
#endif

	s32 numchrs;
#if VERSION >= VERSION_NTSC_1_0
	s32 numteams;
	struct ranking teamrankings[MAX_MPCHRS];
	u32 stack[4];
#else
	u32 stack[3];
#endif

	playercount = PLAYERCOUNT();

	duration60 = playerGetMissionTime();

	func00033dd8();

	numchrs = mpGetPlayerRankings(playerrankings);
#if VERSION >= VERSION_NTSC_1_0
	numteams = (g_MpSetup.options & MPOPTION_TEAMSENABLED) ? mpGetTeamRankings(teamrankings) : 0;
#endif

	prevplayernum = g_Vars.currentplayernum;

	// Iterate all human players and update their character stats.
	// At the same time, populate the metrics array
	// which is a temporary array for award calculation.
	for (i = 0; i < playercount; i++) {
		struct mpchrconfig *mpchr = mpGetChrConfigBySlotNum(i);
		struct mpplayerconfig *mpplayer = (struct mpplayerconfig *)mpchr;
#if VERSION >= VERSION_NTSC_1_0
		s32 chrnum = mpGetChrIndexBySlotNum(i);
#else
		s32 chrnum = i;
#endif
		s32 sum;

		setCurrentPlayerNum(i);

		g_Vars.currentplayer->award1 = NULL;
		g_Vars.currentplayer->award2 = NULL;

		metrics[i].numshots = mpstatsGetPlayerShotCountByRegion(SHOTREGION_TOTAL);
		metrics[i].numheadshots = mpstatsGetPlayerShotCountByRegion(SHOTREGION_HEAD);
		metrics[i].numkills = 0;
		metrics[i].numdeaths = 0;
		metrics[i].numsuicides = 0;

		for (j = 0; j < MAX_MPCHRS; j++) {
#if VERSION >= VERSION_NTSC_1_0
			if (chrnum == j)
#else
			if (i == j)
#endif
			{
				metrics[i].numsuicides += mpchr->killcounts[j];
			} else {
				metrics[i].numkills += mpchr->killcounts[j];
			}
		}

		for (j = 0; j < MAX_MPCHRS; j++) {
			struct mpchrconfig *othermpchr = MPCHR(j);
#if VERSION >= VERSION_NTSC_1_0
			metrics[i].numdeaths += othermpchr->killcounts[chrnum];
#else
			metrics[i].numdeaths += othermpchr->killcounts[i];
#endif
		}

		metrics[i].ksratio = metrics[i].numkills * 100.0f / (metrics[i].numshots + 1.0f);
		metrics[i].kdratio = metrics[i].numkills * 100.0f / (metrics[i].numdeaths + 1.0f);
		metrics[i].backshotcount = g_Vars.playerstats[i].backshotcount;
		metrics[i].drawplayercount = g_Vars.playerstats[i].drawplayercount;
		metrics[i].avgkmperhour = g_Vars.playerstats[i].distance / 100000.0f / ((duration60 + 1) / (3600.0f * 60.0f));
		metrics[i].armourcount = g_Vars.playerstats[i].armourcount;
		metrics[i].awards = 0;
		metrics[i].longestlife = g_Vars.playerstats[i].longestlife;
		metrics[i].shortestlife = g_Vars.playerstats[i].shortestlife;

		sum = mpstatsGetPlayerShotCountByRegion(SHOTREGION_HEAD)
			+ mpstatsGetPlayerShotCountByRegion(SHOTREGION_BODY)
			+ mpstatsGetPlayerShotCountByRegion(SHOTREGION_LIMB)
			+ mpstatsGetPlayerShotCountByRegion(SHOTREGION_GUN)
			+ mpstatsGetPlayerShotCountByRegion(SHOTREGION_HAT)
			+ mpstatsGetPlayerShotCountByRegion(SHOTREGION_OBJECT);

		if (metrics[i].numshots > 0) {
			metrics[i].accuracyfrac = sum / (f32)metrics[i].numshots;
		} else {
			metrics[i].accuracyfrac = 0.0f;
		}

		if (metrics[i].accuracyfrac > 1.0f) {
			metrics[i].accuracyfrac = 1.0f;
		}

		mpplayer->medals = 0;

		if (!g_CheatsActiveBank0 && !g_CheatsActiveBank1) {
			mpplayer->kills += metrics[i].numkills;
			mpplayer->deaths += metrics[i].numdeaths;
			mpplayer->gamesplayed++;
			mpplayer->time += duration60 / 60;
			mpplayer->distance += (u32)(g_Vars.playerstats[i].distance / 10000.0f);

#if VERSION >= VERSION_NTSC_1_0
			if (metrics[i].numshots > 0) {
				if (mpplayer->gamesplayed < 2) {
					mpplayer->accuracy = metrics[i].accuracyfrac * 1000.0f;
				} else {
					mpplayer->accuracy = ((metrics[i].accuracyfrac * 0.3f) + (mpplayer->accuracy / 1000.0f * 0.7f)) * 1000.0f;
				}
			}
#else
			mpplayer->accuracy = ((metrics[i].accuracyfrac * 0.3f) + (mpplayer->accuracy / 1000.0f * 0.7f)) * 1000.0f;
#endif

			mpplayer->damagedealt += (u32)(g_Vars.playerstats[i].damtransmitted / 0.1f);
			mpplayer->painreceived += (u32)(g_Vars.playerstats[i].damreceived / 0.1f);
			mpplayer->headshots += metrics[i].numheadshots;
			mpplayer->ammoused += metrics[i].numshots;

#if VERSION >= VERSION_NTSC_1_0
			if ((numchrs >= 2 && (g_MpSetup.options & MPOPTION_TEAMSENABLED) == 0) || numteams >= 2)
#else
			if (numchrs >= 2)
#endif
			{
				if (mpplayer->base.placement == 0) {
					bool lost = false;

					for (j = 0; j < MAX_MPCHRS; j++) {
#if VERSION >= VERSION_NTSC_1_0
						if (g_MpSetup.chrslots & (1 << j))
#endif
						{
							struct mpchrconfig *othermpchr = MPCHR(j);

							if (othermpchr->rankablescore == mpplayer->base.rankablescore
									&& othermpchr != &mpplayer->base
									&& !((g_MpSetup.options & MPOPTION_TEAMSENABLED) && othermpchr->team == mpplayer->base.team)) {
								lost = true;
							}
						}
					}

					if (!lost) {
						mpplayer->gameswon++;
					}
				}

#if VERSION >= VERSION_NTSC_1_0
				if (((g_MpSetup.options & MPOPTION_TEAMSENABLED) == 0 && numchrs == mpplayer->base.placement + 1)
						|| ((g_MpSetup.options & MPOPTION_TEAMSENABLED) && numteams == mpplayer->base.placement + 1))
#else
				if (mpplayer->base.placement == numchrs - 1)
#endif
				{
					bool won = false;

					for (j = 0; j < MAX_MPCHRS; j++) {
#if VERSION >= VERSION_NTSC_1_0
						if (g_MpSetup.chrslots & (1 << j))
#endif
						{
							struct mpchrconfig *othermpchr = MPCHR(j);

							if (othermpchr->rankablescore == mpplayer->base.rankablescore
									&& &mpplayer->base != othermpchr
									&& !((g_MpSetup.options & MPOPTION_TEAMSENABLED) && othermpchr->team == mpplayer->base.team)) {
								won = true;
							}
						}
					}

					if (!won) {
						mpplayer->gameslost++;
					}
				}
			}
#if VERSION >= VERSION_NTSC_1_0
			else {
				// empty
			}
#endif
		}
	}

	setCurrentPlayerNum(prevplayernum);

	// Choose which players are eligible for which awards
	i = mpFindMaxInt(playercount, metrics[0].numsuicides, metrics[1].numsuicides, metrics[2].numsuicides, metrics[3].numsuicides);

	if (metrics[i].numsuicides > 0) {
		metrics[i].awards |= AWARD_MOSTSUICIDAL;
	}

	i = mpFindMinInt(playercount, metrics[0].numshots, metrics[1].numshots, metrics[2].numshots, metrics[3].numshots);

	if (metrics[i].numshots < 100) {
		metrics[i].awards |= AWARD_WHONEEDSAMMO;
	}

	i = mpFindMinFloat(playercount, metrics[0].armourcount, metrics[1].armourcount, metrics[2].armourcount, metrics[3].armourcount);

	if (metrics[i].armourcount <= 2.0f) {
		metrics[i].awards |= AWARD_LEASTSHIELDED;
	}

	i = mpFindMaxFloat(playercount, metrics[0].armourcount, metrics[1].armourcount, metrics[2].armourcount, metrics[3].armourcount);

	if (metrics[i].armourcount > 6.0f) {
		metrics[i].awards |= AWARD_BESTPROTECTED;
	}

	i = mpFindMaxInt(playercount, metrics[0].numheadshots, metrics[1].numheadshots, metrics[2].numheadshots, metrics[3].numheadshots);

	if (metrics[i].numheadshots > 0) {
		metrics[i].awards |= AWARD_MARKSMANSHIP;
	}

	i = mpFindMaxFloat(playercount, metrics[0].ksratio, metrics[1].ksratio, metrics[2].ksratio, metrics[3].ksratio);

	if (metrics[i].ksratio > 0.0f) {
		metrics[i].awards |= AWARD_MOSTPROFESSIONAL;
	}

	i = mpFindMaxFloat(playercount, metrics[0].kdratio, metrics[1].kdratio, metrics[2].kdratio, metrics[3].kdratio);

	if (metrics[i].kdratio > 0.0f) {
		metrics[i].awards |= AWARD_MOSTDEADLY;
	}

	i = mpFindMinFloat(playercount, metrics[0].kdratio, metrics[1].kdratio, metrics[2].kdratio, metrics[3].kdratio);

	if (PLAYERCOUNT() >= 2) {
		metrics[i].awards |= AWARD_MOSTHARMLESS;
	}

	i = mpFindMinInt(playercount, metrics[0].drawplayercount, metrics[1].drawplayercount, metrics[2].drawplayercount, metrics[3].drawplayercount);

	if (PLAYERCOUNT() >= 2) {
		metrics[i].awards |= AWARD_MOSTCOWARDLY;
	}

	i = mpFindMaxFloat(playercount, metrics[0].avgkmperhour, metrics[1].avgkmperhour, metrics[2].avgkmperhour, metrics[3].avgkmperhour);

	if (metrics[i].avgkmperhour > 10.0f) {
		metrics[i].awards |= AWARD_MOSTFRANTIC;
	}

	i = mpFindMinInt(playercount, metrics[0].backshotcount, metrics[1].backshotcount, metrics[2].backshotcount, metrics[3].backshotcount);
	metrics[i].awards |= AWARD_MOSTHONORABLE;

	i = mpFindMaxInt(playercount, metrics[0].backshotcount, metrics[1].backshotcount, metrics[2].backshotcount, metrics[3].backshotcount);

	if (metrics[i].backshotcount > 0 && (metrics[i].awards & AWARD_MOSTHONORABLE) == 0) {
		metrics[i].awards |= AWARD_MOSTDISHONORABLE;
	}

	i = mpFindMaxInt(playercount, metrics[0].longestlife, metrics[1].longestlife, metrics[2].longestlife, metrics[3].longestlife);

	if (metrics[i].longestlife > 0) {
		metrics[i].awards |= AWARD_LONGESTLIFE;
	}

	i = mpFindMinInt(playercount, metrics[0].shortestlife, metrics[1].shortestlife, metrics[2].shortestlife, metrics[3].shortestlife);

	if (metrics[i].shortestlife > 0 && metrics[i].numdeaths > 0) {
		metrics[i].awards |= AWARD_SHORTESTLIFE;
	}

	for (i = 0; i < playercount; i++) {
		if (g_Vars.playerstats[i].maxsimulkills == 4) {
			metrics[i].awards |= AWARD_QUADKILL;
		} else if (g_Vars.playerstats[i].maxsimulkills == 3) {
			metrics[i].awards |= AWARD_TRIPLEKILL;
		} else if (g_Vars.playerstats[i].maxsimulkills == 2) {
			metrics[i].awards |= AWARD_DOUBLEKILL;
		}
	}

	// These loops would have printed each player's awards
	for (i = 0; i < playercount; i++) {
		for (j = 0; j < 17; j++) {
			if (metrics[i].awards & (1 << j));
		}
	}

	// For each player, choose which two awards to actually give them.
	// Note that the first award checked is quad kill, but after that the awards
	// are checked randomly. So if a player has quad kill they'll definitely see
	// it on the endscreen, but this is not the case for triple kill or any
	// other awards.
	for (i = 0; i < playercount; i++) {
		s32 numdone = 0;
		s32 awardindex = 16;

		if (playercount == 1) {
			// In a single player game, only allow the following awards
			metrics[i].awards &= 0
				| AWARD_MARKSMANSHIP
				| AWARD_MOSTPROFESSIONAL
				| AWARD_MOSTDEADLY
				| AWARD_MOSTFRANTIC
				| AWARD_MOSTHONORABLE
				| AWARD_DOUBLEKILL
				| AWARD_TRIPLEKILL
				| AWARD_QUADKILL;
		}

		while (numdone == 0) {
			if (metrics[i].awards & (1 << awardindex)) {
				metrics[i].awards &= ~(1 << awardindex);
				g_Vars.players[i]->award1 = langGet(g_AwardNames[awardindex]);
				numdone = 1;
			}

			if (metrics[i].awards == 0) {
				numdone = 1;
			}

			awardindex = random() % 17;
		}

		while (numdone < 2) {
			awardindex = random() % 17;

			if (metrics[i].awards & (1 << awardindex)) {
				metrics[i].awards &= ~(1 << awardindex);
				g_Vars.players[i]->award2 = langGet(g_AwardNames[awardindex]);
				numdone = 2;
			}

			if (metrics[i].awards == 0) {
				numdone = 2;
			}
		}
	}

	// Calculate KillMaster and Survivor medals
	if (numchrs >= 2) {
		s32 mostkillsvalue = 0;
		s32 mostkillsplayer = -1;
		s32 leastdeathsvalue = 0xffffff;
		s32 leastdeathsplayer = -1;
		s32 k;

		for (k = 0; k < MAX_MPCHRS; k++) {
			if (g_MpSetup.chrslots & (1 << k)) {
				s32 totalkills = 0;
				struct mpchrconfig *mpchr = MPCHR(k);

				for (j = 0; j < MAX_MPCHRS; j++) {
					// @bug: i should be k. The value of i was incremented after
					// the last iteration of its loop above so it'll be between
					// 1 and 4 inclusively depending on the number of players.
					// The bot nums start from 4 regardless of how many players
					// there are. So in a game with 4 humans, the kills on the
					// first bot will not be considered for the killmaster medal
					// which means the medal could go to a player who got fewer
					// total kills. Additionally, suicides are counted as kills
					// while the intention here was to omit them.
					if (i != j) {
						totalkills += mpchr->killcounts[j];
					}
				}

				if (totalkills == mostkillsvalue) {
					mostkillsplayer = -1;
				}

				if (totalkills > mostkillsvalue) {
					mostkillsplayer = k;
					mostkillsvalue = totalkills;
				}

				if (mpchr->numdeaths == leastdeathsvalue) {
					leastdeathsplayer = -1;
				}

				if (mpchr->numdeaths < leastdeathsvalue) {
					leastdeathsplayer = k;
					leastdeathsvalue = mpchr->numdeaths;
				}
			}
		}

		if (!g_CheatsActiveBank0 && !g_CheatsActiveBank1) {
			if (mostkillsplayer < 4 && mostkillsplayer >= 0) {
				struct mpplayerconfig *mpplayer = (struct mpplayerconfig *)MPCHR(mostkillsplayer);
				mpplayer->medals |= MEDAL_KILLMASTER;
				mpplayer->killmastermedals++;
			}

			if (leastdeathsplayer < 4 && leastdeathsplayer >= 0) {
				struct mpplayerconfig *mpplayer = (struct mpplayerconfig *)MPCHR(leastdeathsplayer);
				mpplayer->medals |= MEDAL_SURVIVOR;
				mpplayer->survivormedals++;
			}
		}
	}

	// Calculate Headshot and Accuracy medals
	if (!g_CheatsActiveBank0 && !g_CheatsActiveBank1 && playercount >= 2) {
		s32 mostheadshotvalue = 0;
		f32 mostaccuratevalue = 0.5f;
		s32 mostheadshotplayer = -1;
		s32 mostaccurateplayer = -1;

		for (i = 0; i < playercount; i++) {
			if (mostheadshotvalue == metrics[i].numheadshots) {
				mostheadshotplayer = -1;
			}

			if (metrics[i].numheadshots > mostheadshotvalue) {
				mostheadshotplayer = i;
				mostheadshotvalue = metrics[i].numheadshots;
			}

			if (metrics[i].accuracyfrac > mostaccuratevalue) {
				mostaccurateplayer = i;
				mostaccuratevalue = metrics[i].accuracyfrac;
			}
		}

		if (mostheadshotplayer >= 0) {
			struct mpplayerconfig *mpplayer = (struct mpplayerconfig *)mpGetChrConfigBySlotNum(mostheadshotplayer);
			mpplayer->medals |= MEDAL_HEADSHOT;
			mpplayer->headshotmedals++;
		}

		if (mostaccurateplayer >= 0) {
			struct mpplayerconfig *mpplayer = (struct mpplayerconfig *)mpGetChrConfigBySlotNum(mostaccurateplayer);
			mpplayer->medals |= MEDAL_ACCURACY;
			mpplayer->accuracymedals++;
		}
	}

	// Recalculate title for all players
	for (i = 0; i < playercount; i++) {
		struct mpplayerconfig *mpchr = (struct mpplayerconfig *)mpGetChrConfigBySlotNum(i);
		mpCalculatePlayerTitle(mpchr);
	}
}

void mpEndMatch(void)
{
	s32 stack;
	s32 playercount = PLAYERCOUNT();
	s32 prevplayernum;
	s32 i;

	musicStartMenu();
	mpSetPaused(MPPAUSEMODE_GAMEOVER);

	prevplayernum = g_Vars.currentplayernum;

	for (i = 0; i < playercount; i++) {
		setCurrentPlayerNum(i);

		g_Vars.currentplayer->award1 = NULL;
		g_Vars.currentplayer->award2 = NULL;

		if (g_Vars.currentplayer->visionmode == VISIONMODE_SLAYERROCKET) {
			g_Vars.currentplayer->visionmode = VISIONMODE_NORMAL;
		}
	}

	setCurrentPlayerNum(prevplayernum);
	mpCalculateAwards();

	if (g_BossFile.locktype == MPLOCKTYPE_CHALLENGE) {
		challengeConsiderMarkingComplete();
	}

	func0f0f820c(NULL, -6);
}

s32 mpGetNumHeads2(void)
{
	return ARRAYCOUNT(g_MpHeads);
}

s32 mpGetNumHeads(void)
{
	return ARRAYCOUNT(g_MpHeads);
}

s32 mpGetHeadId(u8 headnum)
{
	return g_MpHeads[headnum].headnum;
}

s32 mpGetHeadRequiredFeature(u8 headnum)
{
	return g_MpHeads[headnum].requirefeature;
}

s32 mpGetBeauHeadId(u8 headnum)
{
	return g_MpBeauHeads[headnum].headnum;
}

s32 mpGetNumBeauHeads(void)
{
	return ARRAYCOUNT(g_MpBeauHeads);
}

u32 mpGetNumBodies(void)
{
	return ARRAYCOUNT(g_MpBodies);
}

s32 mpGetBodyId(u8 bodynum)
{
	/**
	 * @bug: bodynum 61 (0x3d) would cause an array overflow.
	 * ARRAYCOUNT(g_MpBodies) is 61.
	 */
	if (bodynum > ARRAYCOUNT(g_MpBodies)) {
		if (bodynum == ARRAYCOUNT(g_MpBodies) + 1) {
			return BODY_DRCAROLL;
		}

		return BODY_DARK_COMBAT;
	}

	return g_MpBodies[bodynum].bodynum;
}

s32 mpGetMpbodynumByBodynum(u16 bodynum)
{
	s32 i;

	if (bodynum == BODY_DRCAROLL) {
		return ARRAYCOUNT(g_MpBodies) + 1;
	}

	for (i = 0; i < ARRAYCOUNT(g_MpBodies); i++) {
		if (g_MpBodies[i].bodynum == bodynum) {
			return i;
		}
	}

	return g_MpBodies[0].bodynum;
}

char *mpGetBodyName(u8 mpbodynum)
{
	// @bug: This should be >=
	if (mpbodynum > ARRAYCOUNT(g_MpBodies)) {
		mpbodynum = 0;
	}

	return langGet(g_MpBodies[mpbodynum].name);
}

u8 mpGetBodyRequiredFeature(u8 mpbodynum)
{
	// @bug: This should be >=
	if (mpbodynum > ARRAYCOUNT(g_MpBodies)) {
		mpbodynum = 0;
	}

	return g_MpBodies[mpbodynum].requirefeature;
}

s32 mpGetMpheadnumByMpbodynum(s32 mpbodynum)
{
	s32 headnum;
	s32 index = 0;
	s32 i;

	if (mpbodynum >= HEAD_VD) {
		mpbodynum = 0;
	}

	headnum = g_MpBodies[mpbodynum].headnum;

	if (headnum == 1000) {
		if (g_HeadsAndBodies[g_MpBodies[mpbodynum].bodynum].ismale) {
			headnum = g_MpMaleHeads[random() % ARRAYCOUNT(g_MpMaleHeads)];
		} else {
			headnum = g_MpFemaleHeads[random() % ARRAYCOUNT(g_MpFemaleHeads)];
		}
	}

	for (i = 0; i != ARRAYCOUNT(g_MpHeads); i++) {
		if (g_MpHeads[i].headnum == headnum) {
			index = i;
		}
	}

	return index;
}

void mpFindUnusedHeadAndBody(u8 *mpheadnum, u8 *mpbodynum)
{
	struct mpchrconfig *mpchr;
	bool available;
	u8 trympheadnum;
	u8 trympbodynum;
	s32 i;

	do {
		available = true;
		trympheadnum = random() % ARRAYCOUNT(g_MpHeads);
		trympbodynum = random() % ARRAYCOUNT(g_MpBodies);

		for (i = 0; i < MAX_MPCHRS; i++) {
			if (g_MpSetup.chrslots & (1 << i)) {
				mpchr = MPCHR(i);

				if (mpchr->mpheadnum == trympheadnum) {
					available = false;
				}

				if (mpchr->mpbodynum == trympbodynum) {
					available = false;
				}
			}
		}
	} while (!available);

	if (1);

	*mpheadnum = trympheadnum;
	*mpbodynum = trympbodynum;
}

s32 mpChooseRandomLockPlayer(void)
{
	s32 start = random() % 4;
	s32 i;

	for (i = (start + 1) % 4;; i = (i + 1) % 4) {
		if ((g_MpSetup.chrslots & (1 << i)) || i == start) {
			break;
		}
	}

	return i;
}

bool mpSetLock(s32 locktype, s32 playernum)
{
	g_BossFile.locktype = locktype;

	if (g_BossFile.locktype == MPLOCKTYPE_RANDOM) {
		g_MpLockInfo.lockedplayernum = mpChooseRandomLockPlayer();
	} else {
		g_MpLockInfo.lockedplayernum = playernum;
	}

	return true;
}

s32 mpGetLockType(void)
{
	return g_BossFile.locktype;
}

u32 mpGetLockPlayerNum(void)
{
	return g_MpLockInfo.lockedplayernum;
}

bool mpIsPlayerLockedOut(s32 playernum)
{
	if (g_BossFile.locktype == MPLOCKTYPE_NONE) {
		return false;
	}

	if (g_MpLockInfo.lockedplayernum == playernum) {
		return false;
	}

	return true;
}

void mpCalculateLockIfLastWinnerOrLoser(void)
{
	if (g_BossFile.locktype == MPLOCKTYPE_LASTWINNER && g_MpLockInfo.lastwinner >= 0) {
		g_MpLockInfo.lockedplayernum = g_MpLockInfo.lastwinner;
	}

	if (g_BossFile.locktype == MPLOCKTYPE_LASTLOSER && g_MpLockInfo.lastloser >= 0) {
		g_MpLockInfo.lockedplayernum = g_MpLockInfo.lastloser;
	}

	if (g_MpLockInfo.lockedplayernum >= 0
			&& g_BossFile.locktype != MPLOCKTYPE_CHALLENGE
			&& (g_MpSetup.chrslots & (1 << g_MpLockInfo.lockedplayernum)) == 0) {
		g_MpLockInfo.lastwinner = g_MpLockInfo.lastloser = -1;
		g_MpLockInfo.lockedplayernum = mpChooseRandomLockPlayer();
	}
}

struct mptrack g_MpTracks[] = {
	// Audio ID, duration, name, unlock after stage
	/*0x00*/ { MUSIC_DARK_COMBAT,     160, L_MISC_124, -1 }, // "Dark Combat"
	/*0x01*/ { MUSIC_SKEDAR_MYSTERY,  170, L_MISC_125, -1 }, // "Skedar Mystery"
	/*0x02*/ { MUSIC_CI_OPERATIVE,    170, L_MISC_126, -1 }, // "CI Operative"
	/*0x03*/ { MUSIC_DATADYNE_ACTION, 180, L_MISC_127, -1 }, // "dataDyne Action"
	/*0x04*/ { MUSIC_MAIAN_TEARS,     200, L_MISC_128, -1 }, // "Maian Tears"
	/*0x05*/ { MUSIC_ALIEN_CONFLICT,  197, L_MISC_129, -1 }, // "Alien Conflict"
	/*0x06*/ { MUSIC_CI,              120, L_MISC_130, -1 }, // "Carrington Institute"
	/*0x07*/ { MUSIC_DEFECTION,       120, L_MISC_131, SOLOSTAGEINDEX_DEFECTION }, // "dD Central"
	/*0x08*/ { MUSIC_DEFECTION_X,     120, L_MISC_132, SOLOSTAGEINDEX_DEFECTION }, // "dD Central X"
	/*0x09*/ { MUSIC_INVESTIGATION,   120, L_MISC_133, SOLOSTAGEINDEX_INVESTIGATION }, // "dD Research"
	/*0x0a*/ { MUSIC_INVESTIGATION_X, 120, L_MISC_134, SOLOSTAGEINDEX_INVESTIGATION }, // "dD Research X"
	/*0x0b*/ { MUSIC_EXTRACTION,      120, L_MISC_135, SOLOSTAGEINDEX_EXTRACTION }, // "dD Extraction"
	/*0x0c*/ { MUSIC_EXTRACTION_X,    120, L_MISC_136, SOLOSTAGEINDEX_EXTRACTION }, // "dD Extraction X"
	/*0x0d*/ { MUSIC_VILLA,           120, L_MISC_137, SOLOSTAGEINDEX_VILLA }, // "Carrington Villa"
	/*0x0e*/ { MUSIC_VILLA_X,         120, L_MISC_138, SOLOSTAGEINDEX_VILLA }, // "Carrington Villa X"
	/*0x0f*/ { MUSIC_CHICAGO,         120, L_MISC_139, SOLOSTAGEINDEX_CHICAGO }, // "Chicago"
	/*0x10*/ { MUSIC_CHICAGO_X,       120, L_MISC_140, SOLOSTAGEINDEX_CHICAGO }, // "Chicago X"
	/*0x11*/ { MUSIC_G5,              120, L_MISC_141, SOLOSTAGEINDEX_G5BUILDING }, // "G5 Building"
	/*0x12*/ { MUSIC_G5_X,            120, L_MISC_142, SOLOSTAGEINDEX_G5BUILDING }, // "G5 Building X"
	/*0x13*/ { MUSIC_INFILTRATION,    120, L_MISC_143, SOLOSTAGEINDEX_INFILTRATION }, // "A51 Infiltration"
	/*0x14*/ { MUSIC_INFILTRATION_X,  120, L_MISC_144, SOLOSTAGEINDEX_INFILTRATION }, // "A51 Infiltration X"
	/*0x15*/ { MUSIC_RESCUE,          120, L_MISC_145, SOLOSTAGEINDEX_RESCUE }, // "A51 Rescue"
	/*0x16*/ { MUSIC_RESCUE_X,        120, L_MISC_146, SOLOSTAGEINDEX_RESCUE }, // "A51 Rescue X"
	/*0x17*/ { MUSIC_ESCAPE,          120, L_MISC_147, SOLOSTAGEINDEX_ESCAPE }, // "A51 Escape"
	/*0x18*/ { MUSIC_ESCAPE_X,        120, L_MISC_148, SOLOSTAGEINDEX_ESCAPE }, // "A51 Escape X"
	/*0x19*/ { MUSIC_AIRBASE,         120, L_MISC_149, SOLOSTAGEINDEX_AIRBASE }, // "Air Base"
	/*0x1a*/ { MUSIC_AIRBASE_X,       120, L_MISC_150, SOLOSTAGEINDEX_AIRBASE }, // "Air Base X"
	/*0x1b*/ { MUSIC_AIRFORCEONE,     120, L_MISC_151, SOLOSTAGEINDEX_AIRFORCEONE }, // "Air Force One"
	/*0x1c*/ { MUSIC_AIRFORCEONE_X,   120, L_MISC_152, SOLOSTAGEINDEX_AIRFORCEONE }, // "Air Force One X"
	/*0x1d*/ { MUSIC_CRASHSITE,       120, L_MISC_153, SOLOSTAGEINDEX_CRASHSITE }, // "Crash Site"
	/*0x1e*/ { MUSIC_CRASHSITE_X,     120, L_MISC_154, SOLOSTAGEINDEX_CRASHSITE }, // "Crash Site X"
	/*0x1f*/ { MUSIC_PELAGIC,         120, L_MISC_155, SOLOSTAGEINDEX_PELAGIC }, // "Pelagic II"
	/*0x20*/ { MUSIC_PELAGIC_X,       120, L_MISC_156, SOLOSTAGEINDEX_PELAGIC }, // "Pelagic II X"
	/*0x21*/ { MUSIC_DEEPSEA,         120, L_MISC_157, SOLOSTAGEINDEX_DEEPSEA }, // "Deep Sea"
	/*0x22*/ { MUSIC_DEEPSEA_X,       120, L_MISC_158, SOLOSTAGEINDEX_DEEPSEA }, // "Deep Sea X"
	/*0x23*/ { MUSIC_DEFENSE,         120, L_MISC_159, SOLOSTAGEINDEX_DEFENSE }, // "Institute Defense"
	/*0x24*/ { MUSIC_DEFENSE_X,       120, L_MISC_160, SOLOSTAGEINDEX_DEFENSE }, // "Institute Defense X"
	/*0x25*/ { MUSIC_ATTACKSHIP,      120, L_MISC_161, SOLOSTAGEINDEX_ATTACKSHIP }, // "Attack Ship"
	/*0x26*/ { MUSIC_ATTACKSHIP_X,    120, L_MISC_162, SOLOSTAGEINDEX_ATTACKSHIP }, // "Attack Ship X"
	/*0x27*/ { MUSIC_SKEDARRUINS,     120, L_MISC_163, SOLOSTAGEINDEX_SKEDARRUINS }, // "Skedar Ruins"
	/*0x28*/ { MUSIC_SKEDARRUINS_X,   120, L_MISC_164, SOLOSTAGEINDEX_SKEDARRUINS }, // "Skedar Ruins X"
	/*0x29*/ { MUSIC_CREDITS,         120, L_MISC_165, SOLOSTAGEINDEX_SKEDARRUINS }, // "End Credits"
	/*0x30*/ { MUSIC_SKEDARRUINS_KING,120, L_MISC_261, SOLOSTAGEINDEX_SKEDARRUINS }, // "Skedar Warrior" (Skedar Leader)
};

bool mpIsTrackUnlocked(s32 tracknum)
{
	s16 stageindex = g_MpTracks[tracknum].unlockstage;
	bool unlocked = false;
	u32 i;

	if (stageindex < 0 || stageindex > SOLOSTAGEINDEX_SKEDARRUINS) {
		unlocked = true;
	} else {
		for (i = 0; i != 3; i++) {
			if (g_GameFile.besttimes[stageindex][i]) {
				unlocked = true;
				break;
			}
		}
	}

	return unlocked;
}

s32 mpGetTrackSlotIndex(s32 tracknum)
{
	s32 i;
	s32 slotindex = 0;

	for (i = 0; i < tracknum; i++) {
		if (mpIsTrackUnlocked(i)) {
			slotindex++;
		}
	}

	return slotindex;
}

s32 mpGetTrackNumAtSlotIndex(s32 slotindex)
{
	s32 i;
	s32 numunlocked = 0;

	for (i = 0; i != ARRAYCOUNT(g_MpTracks); i++) {
		if (mpIsTrackUnlocked(i)) {
			if (numunlocked == slotindex) {
				break;
			}

			numunlocked++;
		}
	}

	return i;
}

s32 mpGetNumUnlockedTracks(void)
{
	return mpGetTrackSlotIndex(ARRAYCOUNT(g_MpTracks));
}

s32 mpGetTrackMusicNum(s32 slotindex)
{
	s32 tracknum = mpGetTrackNumAtSlotIndex(slotindex);

	return g_MpTracks[tracknum].musicnum;
}

char *mpGetTrackName(s32 slotindex)
{
	s32 tracknum = mpGetTrackNumAtSlotIndex(slotindex);

	return langGet(g_MpTracks[tracknum].name);
}

void mpSetUsingMultipleTunes(bool enable)
{
	g_BossFile.usingmultipletunes = enable;
}

bool mpGetUsingMultipleTunes(void)
{
	return g_BossFile.usingmultipletunes;
}

bool mpIsMultiTrackSlotEnabled(s32 slot)
{
	s32 tracknum = mpGetTrackNumAtSlotIndex(slot);
	u8 index = tracknum >> 3;
	u8 value = 1 << (tracknum & 7);

	if ((g_BossFile.multipletracknums[index] & value) == 0) {
		return false;
	}

	return true;
}

void mpSetMultiTrackSlotEnabled(s32 slot, bool enable)
{
	s32 tracknum = mpGetTrackNumAtSlotIndex(slot);
	u8 value = 1 << (tracknum & 7);
	u8 index = tracknum >> 3;

	if (enable) {
		g_BossFile.multipletracknums[index] |= value;
	} else {
		g_BossFile.multipletracknums[index] &= ~value;
	}
}

void mpSetTrackSlotEnabled(s32 slot)
{
	if (mpGetUsingMultipleTunes()) {
		mpSetMultiTrackSlotEnabled(slot, 1 - mpIsMultiTrackSlotEnabled(slot));
	} else {
		g_BossFile.tracknum = mpGetTrackNumAtSlotIndex(slot);
	}
}

void mpEnableAllMultiTracks(void)
{
	s32 i;

	for (i = 0; i != ARRAYCOUNT(g_BossFile.multipletracknums); i++) {
		g_BossFile.multipletracknums[i] = 0xff;
	}
}

void mpDisableAllMultiTracks(void)
{
	s32 i;

	for (i = 0; i != ARRAYCOUNT(g_BossFile.multipletracknums); i++) {
		g_BossFile.multipletracknums[i] = 0;
	}
}

void mpRandomiseMultiTracks(void)
{
	s32 i;

	for (i = 0; i != ARRAYCOUNT(g_BossFile.multipletracknums); i++) {
		g_BossFile.multipletracknums[i] = random();
	}
}

void mpSetTrackToRandom(void)
{
	g_BossFile.tracknum = -1;
}

s32 mpGetCurrentTrackSlotNum(void)
{
	if (g_BossFile.tracknum < 0) {
		return g_BossFile.tracknum;
	}

	return mpGetTrackSlotIndex(g_BossFile.tracknum);
}

s32 mpChooseTrack(void)
{
	s32 i;
	s32 tracknum;

	if (mpGetUsingMultipleTunes()) {
		s32 numunlocked = mpGetNumUnlockedTracks();
		s32 numselected = 0;

		for (i = 0; i < numunlocked; i++) {
			if (mpIsMultiTrackSlotEnabled(i)) {
				numselected++;
			}
		}

		if (numselected == 0) {
			do {
				tracknum = mpGetTrackNumAtSlotIndex(random() % numunlocked);
			} while (tracknum == g_MpLockInfo.unk04);

			g_MpLockInfo.unk04 = tracknum;
			g_MusicLife60 = g_MpTracks[tracknum].duration * TICKS(60);

			return g_MpTracks[tracknum].musicnum;
		}

		do {
			s32 selectionindex = random() % numselected;
			s32 selectioncount = 0;
			tracknum = -1;

			for (i = 0; i < numunlocked; i++) {
				if (mpIsMultiTrackSlotEnabled(i)) {
					if (selectionindex == selectioncount) {
						tracknum = i;
					}

					selectioncount++;
				}
			}

			if (tracknum == -1) {
				g_MusicLife60 = g_MpTracks[0].duration * TICKS(60);
				return g_MpTracks[0].musicnum;
			}

			tracknum = mpGetTrackNumAtSlotIndex(tracknum);
		} while (numselected > 1 && tracknum == g_MpLockInfo.unk04);

		g_MpLockInfo.unk04 = tracknum;
		g_MusicLife60 = g_MpTracks[tracknum].duration * TICKS(60);

		return g_MpTracks[tracknum].musicnum;
	}

	tracknum = mpGetCurrentTrackSlotNum();

	if (tracknum < 0) {
		s32 numunlocked = mpGetNumUnlockedTracks();

		do {
			tracknum = mpGetTrackNumAtSlotIndex(random() % numunlocked);
		} while (tracknum == g_MpLockInfo.unk04);

		g_MpLockInfo.unk04 = tracknum;
		g_MusicLife60 = g_MpTracks[tracknum].duration * TICKS(60);
		return g_MpTracks[tracknum].musicnum;
	}

	tracknum = mpGetTrackNumAtSlotIndex(tracknum);
	g_MpLockInfo.unk04 = tracknum;
	g_MusicLife60 = g_MpTracks[tracknum].duration * TICKS(60);

	return g_MpTracks[tracknum].musicnum;
}

struct mpchrconfig *mpGetChrConfigBySlotNum(s32 slot)
{
	s32 count = 0;
	struct mpchrconfig *result = NULL;
	s32 i;

	for (i = 0; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			if (count == slot) {
				result = MPCHR(i);
				break;
			}

			count++;
		}
	}

	return result;
}

#if VERSION >= VERSION_NTSC_1_0
s32 mpGetChrIndexBySlotNum(s32 slot)
{
	s32 count = 0;
	s32 result = 0;
	s32 i;

	for (i = 0; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			if (count == slot) {
				result = i;
				break;
			}

			count++;
		}
	}

	return result;
}
#endif

s32 mpGetNumChrs(void)
{
	s32 count = 0;
	s32 i;

	for (i = 0; i != MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			count++;
		}
	}

	return count;
}

u8 mpFindUnusedTeamNum(void)
{
	u8 teamnum = 0;
	bool available = false;
	s32 i;

	while (teamnum < 7 && !available) {
		available = true;

		for (i = 0; i < MAX_MPCHRS; i++) {
			if (g_MpSetup.chrslots & (1 << i)) {
				struct mpchrconfig *mpchr = MPCHR(i);

				if (mpchr->team == teamnum) {
					available = false;
				}
			}
		}

		if (!available) {
			teamnum++;
		}
	}

	if (teamnum > 7) {
		teamnum = 7;
	}

	return teamnum;
}

void mpCreateBotFromProfile(s32 botnum, u8 profilenum)
{
	s32 headnum = 0;
	u8 team = mpFindUnusedTeamNum();
	bool available = false;
	s32 i;

	g_BotConfigsArray[botnum].type = g_BotProfiles[profilenum].type;
	g_BotConfigsArray[botnum].difficulty = g_BotProfiles[profilenum].difficulty;

	for (i = 0; i < MAX_PLAYERS; i++) {
		g_MpSimulantDifficultiesPerNumPlayers[botnum][i] = g_BotConfigsArray[botnum].difficulty;
	}

	g_MpSetup.chrslots |= 1 << (botnum + 4);
	strcpy(g_BotConfigsArray[botnum].base.name, "Sim\n");
	g_BotConfigsArray[botnum].base.team = team;

	while (!available) {
		headnum = g_BotHeads[random() % ARRAYCOUNT(g_BotHeads)];
		available = true;

		for (i = 0; i < MAX_MPCHRS; i++) {
			if (g_MpSetup.chrslots & (1 << i)) {
				struct mpchrconfig *mpchr = MPCHR(i);

				if (mpchr->mpheadnum == headnum) {
					available = false;
				}
			}
		}
	}

	g_BotConfigsArray[botnum].base.mpheadnum = headnum;
	g_BotConfigsArray[botnum].base.mpbodynum = g_BotProfiles[profilenum].body;
}

void mpSetBotDifficulty(s32 botnum, s32 difficulty)
{
	s32 i;

	g_BotConfigsArray[botnum].difficulty = difficulty;

	for (i = 0; i < MAX_PLAYERS; i++) {
		g_MpSimulantDifficultiesPerNumPlayers[botnum][i] = g_BotConfigsArray[botnum].difficulty;
	}
}

/**
 * Return the first unused bot slot (0-7), or return 7 if all slots are full.
 *
 * This is used for the quick team feature.
 */
s32 mpGetSlotForNewBot(void)
{
	s32 i = 0;

	while (i < MAX_BOTS - 1 && g_MpSetup.chrslots & (1 << (i + 4))) {
		i++;
	}

	return i;
}

void mpRemoveSimulant(s32 index)
{
	g_MpSetup.chrslots &= ~(1 << (index + 4));
	g_BotConfigsArray[index].base.name[0] = '\0';
	func0f1881d4(index);
	mpGenerateBotNames();
}

bool mpHasSimulants(void)
{
	if ((g_MpSetup.chrslots & 0xfff0) != 0) {
		return true;
	}

	return false;
}

bool mpHasUnusedBotSlots(void)
{
	s32 numvacant = challengeIsFeatureUnlocked(MPFEATURE_8BOTS) ? MAX_BOTS : 4;
	s32 i;

	for (i = 4; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			numvacant--;
		}
	}

	if (numvacant > 0) {
		return true;
	}

	return false;
}

bool mpIsSimSlotEnabled(s32 slot)
{
	s32 numfree = MAX_BOTS;
	s32 i;

	if ((g_MpSetup.chrslots & (1 << (slot + 4))) == 0) {
		for (i = 0; i < MAX_BOTS; i++) {
			if (g_MpSetup.chrslots & (1 << (i + 4))) {
				numfree--;
			}
		}

		if (numfree > 0) {
			return true;
		}

		return false;
	}

	return true;
}

s32 mpFindBotProfile(s32 type, s32 difficulty)
{
	s32 i;

	if (type == BOTTYPE_GENERAL) {
		for (i = 0; i < ARRAYCOUNT(g_BotProfiles); i++) {
			if (g_BotProfiles[i].difficulty == difficulty) {
				break;
			}
		}
	} else {
		for (i = 0; i < ARRAYCOUNT(g_BotProfiles); i++) {
			if (g_BotProfiles[i].type == type) {
				break;
			}
		}
	}

	if (i >= ARRAYCOUNT(g_BotProfiles)) {
		i = -1;
	}

	return i;
}

void mpGenerateBotNames(void)
{
	s32 counts[ARRAYCOUNT(g_BotProfiles)];
	s32 profilenum;
	s32 i;
	char name[16];

	for (i = 0; i < ARRAYCOUNT(g_BotProfiles); i++) {
		counts[i] = 0;
	}

	// Count the number of bots using each profile (MeatSim, TurtleSim etc)
	for (i = 4; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			profilenum = mpFindBotProfile(g_BotConfigsArray[i - 4].type, g_BotConfigsArray[i - 4].difficulty);

			if (profilenum >= 0 && profilenum < ARRAYCOUNT(g_BotProfiles)) {
				counts[profilenum]++;
			}
		}
	}

	// Profiles with only one bot don't need to have to number appended to the
	// name, so mark those as -1. For profiles with multiple bots, reset them
	// to 0 because they'll be a counter for the final loop.
	for (i = 0; i < ARRAYCOUNT(g_BotProfiles); i++) {
		if (counts[i] <= 1) {
			counts[i] = -1;
		} else {
			counts[i] = 0;
		}
	}

	for (i = 4; i < MAX_MPCHRS; i++) {
		if (g_MpSetup.chrslots & (1 << i)) {
			profilenum = mpFindBotProfile(g_BotConfigsArray[i - 4].type, g_BotConfigsArray[i - 4].difficulty);

			if (profilenum >= 0 && profilenum < ARRAYCOUNT(g_BotProfiles)) {
				if (counts[profilenum] >= 0) {
					// Multiple bots using this profile - append the number
					counts[profilenum]++;
					sprintf(name, "%s:%d\n", langGet(g_BotProfiles[profilenum].name), counts[profilenum]);
					strcpy(g_BotConfigsArray[i - 4].base.name, name);
				} else {
					// One bots using this profile - just use the profile name
					sprintf(name, "%s\n", langGet(g_BotProfiles[profilenum].name));
					strcpy(g_BotConfigsArray[i - 4].base.name, name);
				}
			}
		}
	}
}

#if VERSION >= VERSION_NTSC_1_0
const char var7f1b8b80[] = "Adding GBCHead to load to slot %d: guid is %x-%x, player is %d\n";
const char var7f1b8bc0[] = "PakId for player %d: %d\n";
const char var7f1b8bdc[] = "Save Player Result: %d   New GUID: %x\n";
const char var7f1b8c04[] = "PakId for player %d: %d\n";
const char var7f1b8c20[] = "Load Player - Result: %d\n";
#endif

s32 mpPlayerGetIndex(struct chrdata *chr)
{
	s32 i;

	for (i = 0; i < g_MpNumChrs; i++) {
		if (g_MpAllChrPtrs[i] == chr) {
			return i;
		}
	}

	return -1;
}

struct chrdata *mpGetChrFromPlayerIndex(s32 index)
{
	if (index >= 0 && index < g_MpNumChrs) {
		return g_MpAllChrPtrs[index];
	}

	return NULL;
}

s32 func0f18d074(s32 index)
{
	s32 i;

	for (i = 0; i < MAX_PLAYERS; i++) {
		if (&g_PlayerConfigsArray[i].base == g_MpAllChrConfigPtrs[index]) {
			return i;
		}
	}

	for (i = 0; i < MAX_BOTS; i++) {
		if (&g_BotConfigsArray[i].base == g_MpAllChrConfigPtrs[index]) {
			return i + 4;
		}
	}

	return -1;
}

s32 func0f18d0e8(s32 arg0)
{
	s32 i;

	if (arg0 < 4) {
		for (i = 0; i < g_MpNumChrs; i++) {
			if (g_MpAllChrConfigPtrs[i] == &g_PlayerConfigsArray[arg0].base) {
				return i;
			}
		}
	} else {
		for (i = 0; i < g_MpNumChrs; i++) {
			if (g_MpAllChrConfigPtrs[i] == &g_BotConfigsArray[arg0 - 4].base) {
				return i;
			}
		}
	}

	return -1;
}

void mpplayerfileLoadGunFuncs(struct savebuffer *buffer, s32 playernum)
{
	s32 bitsremaining = 35;
	s32 i = 0;

	while (bitsremaining > 0) {
		s32 numbits = bitsremaining;

		if (numbits > 8) {
			numbits = 8;
		}

		g_PlayerConfigsArray[playernum].gunfuncs[i] = savebufferReadBits(buffer, numbits);

		bitsremaining -= 8;
		i++;
	}
}

void mpplayerfileSaveGunFuncs(struct savebuffer *buffer, s32 playernum)
{
	s32 bitsremaining = 35;
	s32 i = 0;

	while (bitsremaining > 0) {
		s32 numbits = bitsremaining;

		if (numbits > 8) {
			numbits = 8;
		}

		savebufferOr(buffer, g_PlayerConfigsArray[playernum].gunfuncs[i], numbits);

		bitsremaining -= 8;
		i++;
	}
}

void mpplayerfileLoadWad(s32 playernum, struct savebuffer *buffer, s32 arg2)
{
	struct fileguid guid;
	u32 stack;
	s32 i;
	s32 j;

	savebufferReadString(buffer, g_PlayerConfigsArray[playernum].base.name, 1);
	g_PlayerConfigsArray[playernum].time = savebufferReadBits(buffer, 28);

	if (arg2 != 0) {
		g_PlayerConfigsArray[playernum].base.mpheadnum = savebufferReadBits(buffer, 7);
		g_PlayerConfigsArray[playernum].base.mpbodynum = savebufferReadBits(buffer, 7);

		savebufferReadGuid(buffer, &guid);

		if (g_PlayerConfigsArray[playernum].base.mpheadnum >= mpGetNumHeads2()) {
			if (guid.fileid != 0 && guid.deviceserial != 0) {
				if (g_MenuData.unk668 < 11) {
					g_MenuData.unk668++;
					g_MenuData.unk5d8[g_MenuData.unk668].fileguid.fileid = guid.fileid;
					g_MenuData.unk5d8[g_MenuData.unk668].fileguid.deviceserial = guid.deviceserial;
					g_MenuData.unk5d8[g_MenuData.unk668].unk08 = g_MpPlayerNum;
					g_MenuData.unk5d8[g_MenuData.unk668].unk09 = g_MpPlayerNum;
				}
			} else {
				g_PlayerConfigsArray[playernum].base.mpheadnum = MPHEAD_DARK_COMBAT;
			}
		}
	} else {
		savebufferReadBits(buffer, 7);
		savebufferReadBits(buffer, 7);
		savebufferReadGuid(buffer, &guid);
	}

	g_PlayerConfigsArray[playernum].base.displayoptions = savebufferReadBits(buffer, 8);
	g_PlayerConfigsArray[playernum].kills = savebufferReadBits(buffer, 20);
	g_PlayerConfigsArray[playernum].deaths = savebufferReadBits(buffer, 20);
	g_PlayerConfigsArray[playernum].gamesplayed = savebufferReadBits(buffer, 19);
	g_PlayerConfigsArray[playernum].gameswon = savebufferReadBits(buffer, 19);
	g_PlayerConfigsArray[playernum].gameslost = savebufferReadBits(buffer, 19);
	g_PlayerConfigsArray[playernum].distance = savebufferReadBits(buffer, 25);
	g_PlayerConfigsArray[playernum].accuracy = savebufferReadBits(buffer, 10);
	g_PlayerConfigsArray[playernum].damagedealt = savebufferReadBits(buffer, 26);
	g_PlayerConfigsArray[playernum].painreceived = savebufferReadBits(buffer, 26);
	g_PlayerConfigsArray[playernum].headshots = savebufferReadBits(buffer, 20);
	g_PlayerConfigsArray[playernum].ammoused = savebufferReadBits(buffer, 30);
	g_PlayerConfigsArray[playernum].accuracymedals = savebufferReadBits(buffer, 18);
	g_PlayerConfigsArray[playernum].headshotmedals = savebufferReadBits(buffer, 18);
	g_PlayerConfigsArray[playernum].killmastermedals = savebufferReadBits(buffer, 18);
	g_PlayerConfigsArray[playernum].survivormedals = savebufferReadBits(buffer, 16);
	g_PlayerConfigsArray[playernum].controlmode = savebufferReadBits(buffer, 2);
	g_PlayerConfigsArray[playernum].options = savebufferReadBits(buffer, 12);

#ifndef PLATFORM_N64
	// override with PC controls if enabled in the config
	if (g_PlayerExtCfg[playernum % MAX_PLAYERS].extcontrols) {
		g_PlayerConfigsArray[playernum].controlmode = CONTROLMODE_PC;
	}
#endif

	for (i = 0; i < ARRAYCOUNT(g_MpChallenges); i++) {
		for (j = 1; j < MAX_PLAYERS + 1; j++) {
			challengeSetCompletedByPlayerWithNumPlayers(playernum, i, j, savebufferReadBits(buffer, 1));
		}
	}

	challengeDetermineUnlockedFeatures();
	mpCalculatePlayerTitle(&g_PlayerConfigsArray[playernum]);
	mpplayerfileLoadGunFuncs(buffer, playernum);
}

void mpplayerfileSaveWad(s32 playernum, struct savebuffer *buffer)
{
	s32 i;
	s32 j;
	u32 stack;

	func0f0d55a4(buffer, g_PlayerConfigsArray[playernum].base.name);

	if (g_PlayerConfigsArray[playernum].time > 0x0fffffff) { // over 3106 days
		g_PlayerConfigsArray[playernum].time = 0x0fffffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].time, 28);
	savebufferOr(buffer, g_PlayerConfigsArray[playernum].base.mpheadnum, 7);
	savebufferOr(buffer, g_PlayerConfigsArray[playernum].base.mpbodynum, 7);

	if (g_PlayerConfigsArray[playernum].base.mpheadnum >= mpGetNumHeads2()) {
		struct fileguid guid;
		phGetGuid(g_PlayerConfigsArray[playernum].base.mpheadnum - mpGetNumHeads2(), &guid);
		savebufferWriteGuid(buffer, &guid);
	} else {
		struct fileguid guid;
		guid.deviceserial = 0;
		guid.fileid = 0;
		savebufferWriteGuid(buffer, &guid);
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].base.displayoptions, 8);

	if (g_PlayerConfigsArray[playernum].kills > 0xfffff) { // 1,048,575
		g_PlayerConfigsArray[playernum].kills = 0xfffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].kills, 20);

	if (g_PlayerConfigsArray[playernum].deaths > 0xfffff) { // 1,048,575
		g_PlayerConfigsArray[playernum].deaths = 0xfffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].deaths, 20);

	if (g_PlayerConfigsArray[playernum].gamesplayed > 0x7ffff) { // 524,287
		g_PlayerConfigsArray[playernum].gamesplayed = 0x7ffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].gamesplayed, 19);

	if (g_PlayerConfigsArray[playernum].gameswon > 0x7ffff) { // 524,287
		g_PlayerConfigsArray[playernum].gameswon = 0x7ffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].gameswon, 19);

	if (g_PlayerConfigsArray[playernum].gameslost > 0x7ffff) { // 524,287
		g_PlayerConfigsArray[playernum].gameslost = 0x7ffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].gameslost, 19);

	if (g_PlayerConfigsArray[playernum].distance > 0x1ffffff) { // 33,554,431
		g_PlayerConfigsArray[playernum].distance = 0x1ffffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].distance, 25);

	if (g_PlayerConfigsArray[playernum].accuracy > 0x3ff) { // 1023
		g_PlayerConfigsArray[playernum].accuracy = 0x3ff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].accuracy, 10);

	if (g_PlayerConfigsArray[playernum].damagedealt > 0x3ffffff) { // 67,108,863
		g_PlayerConfigsArray[playernum].damagedealt = 0x3ffffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].damagedealt, 26);

	if (g_PlayerConfigsArray[playernum].painreceived > 0x3ffffff) { // 67,108,863
		g_PlayerConfigsArray[playernum].painreceived = 0x3ffffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].painreceived, 26);

	if (g_PlayerConfigsArray[playernum].headshots > 0xfffff) { // 1,048,575
		g_PlayerConfigsArray[playernum].headshots = 0xfffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].headshots, 20);

	if (g_PlayerConfigsArray[playernum].ammoused > 0x3fffffff) { // 1,073,741,823
		g_PlayerConfigsArray[playernum].ammoused = 0x3fffffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].ammoused, 30);

	if (g_PlayerConfigsArray[playernum].accuracymedals > 0x3ffff) { // 262,143
		g_PlayerConfigsArray[playernum].accuracymedals = 0x3ffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].accuracymedals, 18);

	if (g_PlayerConfigsArray[playernum].headshotmedals > 0x3ffff) { // 262,143
		g_PlayerConfigsArray[playernum].headshotmedals = 0x3ffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].headshotmedals, 18);

	if (g_PlayerConfigsArray[playernum].killmastermedals > 0x3ffff) { // 262,143
		g_PlayerConfigsArray[playernum].killmastermedals = 0x3ffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].killmastermedals, 18);

	if (g_PlayerConfigsArray[playernum].survivormedals > 0xffff) { // 65,535
		g_PlayerConfigsArray[playernum].survivormedals = 0xffff;
	}

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].survivormedals, 16);

#ifdef PLATFORM_N64
	savebufferOr(buffer, g_PlayerConfigsArray[playernum].controlmode, 2);
#else
	// PC control mode is enabled in the .ini to avoid changing the save structure
	const u32 controlmode = g_PlayerConfigsArray[playernum].controlmode;
	savebufferOr(buffer, ((controlmode == CONTROLMODE_PC) ? CONTROLMODE_11 : controlmode), 2);
#endif

	savebufferOr(buffer, g_PlayerConfigsArray[playernum].options, 12);

	for (i = 0; i < ARRAYCOUNT(g_MpChallenges); i++) {
		for (j = 1; j < MAX_PLAYERS + 1; j++) {
			savebufferOr(buffer, challengeIsCompletedByPlayerWithNumPlayers(playernum, i, j), 1);
		}
	}

	mpplayerfileSaveGunFuncs(buffer, playernum);
}

void mpplayerfileGetOverview(char *arg0, char *name, u32 *playtime)
{
	struct savebuffer buffer;

	func0f0d5484(&buffer, arg0, 15);

	savebufferReadString(&buffer, name, 0);
	*playtime = savebufferReadBits(&buffer, 28);
}

s32 mpplayerfileSave(s32 playernum, s32 device, s32 fileid, u16 deviceserial)
{
	s32 ret;
	s32 newfileid;
	struct savebuffer buffer;

	if (device >= 0) {
		savebufferClear(&buffer);
		mpplayerfileSaveWad(playernum, &buffer);
		func0f0d54c4(&buffer);

		var80075bd0[2] = true;

		ret = pakSaveAtGuid(device, fileid, PAKFILETYPE_MPPLAYER, buffer.bytes, &newfileid, 0);

		if (ret == 0) {
			g_PlayerConfigsArray[playernum].fileguid.fileid = newfileid;
			g_PlayerConfigsArray[playernum].fileguid.deviceserial = deviceserial;
			return 0;
		}

		g_FilemgrLastPakError = ret;
		return -1;
	}

	return -1;
}

s32 mpplayerfileLoad(s32 playernum, s32 device, s32 fileid, u16 deviceserial)
{
	s32 ret;
	struct savebuffer buffer;

	if (device >= 0) {
		savebufferClear(&buffer);

		ret = pakReadBodyAtGuid(device, fileid, buffer.bytes, 0);

		if (ret == 0) {
			g_PlayerConfigsArray[playernum].fileguid.fileid = fileid;
			g_PlayerConfigsArray[playernum].fileguid.deviceserial = deviceserial;

			mpplayerfileLoadWad(playernum, &buffer, 1);
			func0f0d54c4(&buffer);

			g_PlayerConfigsArray[playernum].handicap = 0x80;
			return 0;
		}

		g_FilemgrLastPakError = ret;
		return -1;
	}

	return -1;
}

struct mppreset g_MpPresets[] = {
	{ L_MPWEAPONS_025, MPCONFIG_NOSHIELD   }, // "No Shield"
	{ L_MPWEAPONS_026, MPCONFIG_AUTOMATICS }, // "Automatics"
	{ L_MPWEAPONS_027, MPCONFIG_ROCKETS    }, // "Rocket Launcher"
	{ L_MPWEAPONS_028, MPCONFIG_SIMULANTS  }, // "Simulants"
	{ L_MPWEAPONS_029, MPCONFIG_SKEDARKING }, // "King of the Hill"
	{ L_MPWEAPONS_030, MPCONFIG_FARSIGHT   }, // "Complex FarSight"
	{ L_MPWEAPONS_031, MPCONFIG_BRIEFCASE  }, // "Hold the Briefcase"
	{ L_MPWEAPONS_032, MPCONFIG_PISTOLS    }, // "Pistol One-Hit Kills"
	{ L_MPWEAPONS_033, MPCONFIG_FLAGS      }, // "Capture the Case"
	{ L_MPWEAPONS_034, MPCONFIG_CLOAKING   }, // "Cloaking"
	{ L_MPWEAPONS_035, MPCONFIG_TEMPLE     }, // "Temple Explosives"
	{ L_MPWEAPONS_036, MPCONFIG_SLAYER     }, // "Slayer"
	{ L_MPWEAPONS_037, MPCONFIG_DRUGGUN    }, // "Tranquilizr"
	{ L_MPWEAPONS_038, MPCONFIG_SLOWMO     }, // "Slow Motion"
};

s32 mpGetNumPresets(void)
{
	return ARRAYCOUNT(g_MpPresets);
}

bool mpIsPresetUnlocked(s32 presetnum)
{
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpPresets[presetnum].requirefeatures); i++) {
		if (!challengeIsFeatureUnlocked(g_MpPresets[presetnum].requirefeatures[i]) &&
				g_MpPresets[presetnum].requirefeatures[i] != MPFEATURE_WEAPON_SHIELD) {
			return false;
		}
	}

	return true;
}

s32 mpGetNumUnlockedPresets(void)
{
	s32 numunlocked = 0;
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpPresets); i++) {
		if (mpIsPresetUnlocked(i)) {
			numunlocked++;
		}
	}

	return numunlocked;
}

char *mpGetPresetNameBySlot(s32 slot)
{
	s32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpPresets); i++) {
		if (mpIsPresetUnlocked(i)) {
			if (slot == 0) {
				return langGet(g_MpPresets[i].name);
			}

			slot--;
		}
	}

	return "";
}

#if VERSION >= VERSION_NTSC_1_0
const char var7f1b8c40[] = "bot %d headId %d bodyId %d\n";
const char var7f1b8c5c[] = "team change %s %d\n";

#if VERSION >= VERSION_PAL_FINAL
const char var7f1b8c70[] = "options/mplayer.c";
#else
const char var7f1b8c70[] = "mplayer.c";
#endif

const char var7f1b8c7c[] = "team change %s %d\n";

#if VERSION >= VERSION_PAL_FINAL
const char var7f1b8c90[] = "options/mplayer.c";
#else
const char var7f1b8c90[] = "mplayer.c";
#endif

const char var7f1b8c9c[] = "SaveMultiGameFile : PakId=0x%x, FileId=0x%x\n";
const char var7f1b8ccc[] = "SaveGame Result: %d   New GUID: %x\n";
const char var7f1b8cf0[] = "LoadMultiGameFile : PakId=0x%x, FileId=0x%x\n";
const char var7f1b8d20[] = "LoadGame Result: %d\n";
const char var7f1b8d38[] = "GBCHead: Call to create head for slot %d (gbcheadobjs[slotno]=%x)\n";
#endif // >= VERSION_NTSC_1_0

void mpApplyConfig(struct mpconfigfull *config)
{
	s32 i;
	s32 j;
	u16 chrslots;

	g_MpSetup.scenario = config->config.setup.scenario;

#if VERSION >= VERSION_PAL_FINAL
	chrslots = g_MpSetup.chrslots;
#endif

	scenarioInit();

	g_MpSetup = config->config.setup;

#if VERSION >= VERSION_PAL_FINAL
	g_MpSetup.chrslots = chrslots;
#endif

	for (i = 0; i < MAX_BOTS; i++) {
		g_BotConfigsArray[i].type = config->config.simulants[i].type;

		for (j = 0; j < MAX_PLAYERS; j++) {
			g_MpSimulantDifficultiesPerNumPlayers[i][j] = config->config.simulants[i].difficulties[j];
		}

		g_BotConfigsArray[i].difficulty = g_MpSimulantDifficultiesPerNumPlayers[i][0];

#if VERSION >= VERSION_NTSC_1_0
		if (IS4MB()) {
			// "ShockSim:%d"
			sprintf(g_BotConfigsArray[i].base.name, langGet(L_MPWEAPONS_241), i + 1);
		} else {
			strcpy(g_BotConfigsArray[i].base.name, config->strings.aibotnames[i]);
		}
#else
		strcpy(g_BotConfigsArray[i].base.name, config->strings.aibotnames[i]);
#endif

		g_BotConfigsArray[i].base.mpheadnum = config->config.simulants[i].mpheadnum;
		g_BotConfigsArray[i].base.mpbodynum = config->config.simulants[i].mpbodynum;
		g_BotConfigsArray[i].base.team = config->config.simulants[i].team;
	}

	if (!challengeIsFeatureUnlocked(MPFEATURE_WEAPON_SHIELD)) {
		for (i = 0; i < ARRAYCOUNT(g_MpSetup.weapons); i++) {
			if (g_MpSetup.weapons[i] == MPWEAPON_SHIELD) {
				g_MpSetup.weapons[i] = MPWEAPON_NONE;
			}
		}
	}

	func0f18913c();
	challengeRemoveForceUnlocks();
}

void mp0f18dec4(s32 slot)
{
	struct mpconfigfull *config;
	u8 buffer[0x1ca];
	s32 confignum = 0;
	u32 i;

	for (i = 0; i < ARRAYCOUNT(g_MpPresets); i++) {
		if (mpIsPresetUnlocked(i)) {
			if (slot == 0) {
				confignum = g_MpPresets[i].confignum;
				break;
			}

			slot--;
		}
	}

	config = challengeLoadConfig(confignum, buffer, sizeof(buffer));

	mpApplyConfig(config);

#if VERSION >= VERSION_JPN_FINAL
	g_MpSetup.chrslots &= 0x0f;

	for (i = 0; i < MAX_BOTS; i++) {
		if (g_BotConfigsArray[i].difficulty != BOTDIFF_DISABLED) {
			g_MpSetup.chrslots |= 1 << (i + 4);
		}
	}
#endif
}

void mpsetupfileLoadWad(struct savebuffer *buffer)
{
	s32 i;
	s32 j;

	savebufferReadString(buffer, g_MpSetup.name, false);
	savebufferReadBits(buffer, 4);

	g_MpSetup.stagenum = savebufferReadBits(buffer, 7);
	g_MpSetup.scenario = savebufferReadBits(buffer, 3);

	scenarioInit();
	scenarioReadSave(buffer);

	g_MpSetup.options = savebufferReadBits(buffer, 21);
	g_MpSetup.chrslots &= 0x000f;

	for (i = 0; i < MAX_BOTS; i++) {
		g_BotConfigsArray[i].base.name[0] = '\0';
		g_BotConfigsArray[i].type = savebufferReadBits(buffer, 5);
		g_BotConfigsArray[i].difficulty = savebufferReadBits(buffer, 3);

		for (j = 0; j < MAX_PLAYERS; j++) {
			g_MpSimulantDifficultiesPerNumPlayers[i][j] = g_BotConfigsArray[i].difficulty;
		}

		if (g_BotConfigsArray[i].difficulty != BOTDIFF_DISABLED) {
			g_MpSetup.chrslots |= 1 << (i + 4);
		}

		g_BotConfigsArray[i].base.mpheadnum = savebufferReadBits(buffer, 7);
		g_BotConfigsArray[i].base.mpbodynum = savebufferReadBits(buffer, 7);
		g_BotConfigsArray[i].base.team = savebufferReadBits(buffer, 3);
	}

	mpGenerateBotNames();

	for (i = 0; i < ARRAYCOUNT(g_MpSetup.weapons); i++) {
		g_MpSetup.weapons[i] = savebufferReadBits(buffer, 7);
	}

	func0f18913c();

	g_MpSetup.timelimit = savebufferReadBits(buffer, 6);
	g_MpSetup.scorelimit = savebufferReadBits(buffer, 7);
	g_MpSetup.teamscorelimit = savebufferReadBits(buffer, 9);

	for (i = 0; i < MAX_PLAYERS; i++) {
		g_PlayerConfigsArray[i].base.team = savebufferReadBits(buffer, 3);
	}

	challengeForceUnlockBotFeatures();
}

void mpsetupfileSaveWad(struct savebuffer *buffer)
{
	s32 numsims = 0;
	s32 mpbodynum;
	s32 i;

	func0f0d55a4(buffer, g_MpSetup.name);

	for (i = 0; i < MAX_BOTS; i++) {
		if (g_MpSetup.chrslots & (1 << (i + 4))) {
			numsims++;
		}
	}

	savebufferOr(buffer, numsims, 4);
	savebufferOr(buffer, g_MpSetup.stagenum, 7);
	savebufferOr(buffer, g_MpSetup.scenario, 3);

	scenarioWriteSave(buffer);

	savebufferOr(buffer, g_MpSetup.options, 21);

	for (i = 0; i < MAX_BOTS; i++) {
		savebufferOr(buffer, g_BotConfigsArray[i].type, 5);

		if (g_MpSetup.chrslots & (1 << (i + 4))) {
			savebufferOr(buffer, g_BotConfigsArray[i].difficulty, 3);
		} else {
			savebufferOr(buffer, BOTDIFF_DISABLED, 3);
		}

		savebufferOr(buffer, g_BotConfigsArray[i].base.mpheadnum, 7);

		if (g_BotConfigsArray[i].base.mpbodynum == 0xff) {
			s32 profilenum = mpFindBotProfile(g_BotConfigsArray[i].type, g_BotConfigsArray[i].difficulty);

			if (profilenum < 0 || profilenum >= ARRAYCOUNT(g_BotProfiles)) {
				profilenum = 0;
			}

			mpbodynum = g_BotProfiles[profilenum].body;
		} else {
			mpbodynum = g_BotConfigsArray[i].base.mpbodynum;
		}

		savebufferOr(buffer, mpbodynum, 7);
		savebufferOr(buffer, g_BotConfigsArray[i].base.team, 3);
	}

	for (i = 0; i < ARRAYCOUNT(g_MpSetup.weapons); i++) {
		savebufferOr(buffer, g_MpSetup.weapons[i], 7);
	}

	savebufferOr(buffer, g_MpSetup.timelimit, 6);
	savebufferOr(buffer, g_MpSetup.scorelimit, 7);
	savebufferOr(buffer, g_MpSetup.teamscorelimit, 9);

	for (i = 0; i < MAX_PLAYERS; i++) {
		savebufferOr(buffer, g_PlayerConfigsArray[i].base.team, 3);
	}
}

void mpsetupfileGetOverview(char *arg0, char *filename, u16 *numsims, u16 *stagenum, u16 *scenarionum)
{
	struct savebuffer buffer;

	func0f0d5484(&buffer, arg0, 15);

	savebufferReadString(&buffer, filename, 0);

	*numsims = savebufferReadBits(&buffer, 4);
	*stagenum = savebufferReadBits(&buffer, 7);
	*scenarionum = savebufferReadBits(&buffer, 3);
}

s32 mpsetupfileSave(s32 device, s32 fileid, u16 deviceserial)
{
	s32 ret;
	s32 newfileid;
	struct savebuffer buffer;

	if (device >= 0) {
		savebufferClear(&buffer);
		mpsetupfileSaveWad(&buffer);
		func0f0d54c4(&buffer);

		ret = pakSaveAtGuid(device, fileid, PAKFILETYPE_MPSETUP, buffer.bytes, &newfileid, 0);
		var80075bd0[1] = true;

		if (ret == 0) {
			g_MpSetup.fileguid.fileid = newfileid;
			g_MpSetup.fileguid.deviceserial = deviceserial;
			return 0;
		}

		g_FilemgrLastPakError = ret;
		return -1;
	}

	return -1;
}

s32 mpsetupfileLoad(s32 device, s32 fileid, u16 deviceserial)
{
	s32 ret;
	struct savebuffer buffer;

	if (device >= 0) {
		savebufferClear(&buffer);
		ret = pakReadBodyAtGuid(device, fileid, buffer.bytes, 0);

		if (ret == 0) {
			g_MpSetup.fileguid.fileid = fileid;
			g_MpSetup.fileguid.deviceserial = deviceserial;

			mpsetupfileLoadWad(&buffer);
			func0f0d54c4(&buffer);

			return 0;
		}

		g_FilemgrLastPakError = ret;

		return -1;
	}

	return -1;
}

void func0f18e558(void)
{
	s32 i;

	for (i = 0; i < ARRAYCOUNT(var800acc28); i++) {
		var800acc28[i] = NULL;
	}
}

struct modeldef *func0f18e57c(s32 index, s32 *headnum)
{
	return var800acc28[index];
}