//
// CL_PredictPlayers
//
void CL_PredictPlayers (int predtic)
{
	size_t n = players.size();

	for(size_t i = 0; i < n; i++)
	{
		player_t *p = &players[i];
	
		if (!p->ingame() || !p->mo)
			continue;
			
		// GhostlyDeath -- Ignore Spectators
		if (p->spectator)
			continue;

		// Update this player if their last known status is before this tic
		if(p->tic < predtic)
		{
			if(p == &consoleplayer())
			{
				int buf = predtic%MAXSAVETICS;
				ticcmd_t *cmd = &consoleplayer().cmd;
				memcpy(cmd, &localcmds[buf], sizeof(ticcmd_t));

				p->mo->angle = cl_angle[predtic%MAXSAVETICS];
				p->mo->pitch = cl_pitch[predtic%MAXSAVETICS];
				p->viewheight = cl_viewheight[predtic%MAXSAVETICS];
				p->deltaviewheight = cl_deltaviewheight[predtic%MAXSAVETICS];
				p->mo->reactiontime = reactiontime[predtic%MAXSAVETICS];
			}
	
			CL_PredictPlayer(p);
		}
	}
}

//
// writeLocalCmd()
//
//   Generates a message indicating the current position and angle of the
//   consoleplayer, taking the place of ticcmds.
void NetDemo::writeLocalCmd(buf_t *netbuffer) const
{
    // Record the local player's data
    player_t *player = &consoleplayer();
    if (!player->mo)
        return;

    AActor *mo = player->mo;

    MSG_WriteByte(netbuffer, svc_netdemocap);
    MSG_WriteByte(netbuffer, player->cmd.ucmd.buttons);
    MSG_WriteByte(netbuffer, player->cmd.ucmd.impulse);
    MSG_WriteShort(netbuffer, player->cmd.ucmd.yaw);
    MSG_WriteShort(netbuffer, player->cmd.ucmd.forwardmove);
    MSG_WriteShort(netbuffer, player->cmd.ucmd.sidemove);
    MSG_WriteShort(netbuffer, player->cmd.ucmd.upmove);
    MSG_WriteShort(netbuffer, player->cmd.ucmd.pitch);

    MSG_WriteByte(netbuffer, mo->waterlevel);
    MSG_WriteLong(netbuffer, mo->x);
    MSG_WriteLong(netbuffer, mo->y);
    MSG_WriteLong(netbuffer, mo->z);
    MSG_WriteLong(netbuffer, mo->momx);
    MSG_WriteLong(netbuffer, mo->momy);
    MSG_WriteLong(netbuffer, mo->momz);
    MSG_WriteLong(netbuffer, mo->angle);
    MSG_WriteLong(netbuffer, mo->pitch);
    MSG_WriteLong(netbuffer, player->viewheight);
    MSG_WriteLong(netbuffer, player->deltaviewheight);
    MSG_WriteLong(netbuffer, player->jumpTics);
    MSG_WriteLong(netbuffer, mo->reactiontime);
    MSG_WriteByte(netbuffer, player->readyweapon);
    MSG_WriteByte(netbuffer, player->pendingweapon);
}

//
// CL_PredictLocalPlayer
//
// 
static void CL_PredictLocalPlayer(int predtic)
{
	player_t *player = &consoleplayer();
	
	if (!player->ingame() || !player->mo || player->tic >= predtic)
		return;

	// Restore the angle, viewheight, etc for the player
	P_SetPlayerSnapshotNoPosition(player, cl_savedsnaps[predtic % MAXSAVETICS]);

	// Copy the player's previous input ticcmd for the tic 'predtic'
	// to player.cmd so that P_MovePlayer can simulate their movement in
	// that tic
	NetCommand *netcmd = &localcmds[predtic % MAXSAVETICS];
	netcmd->toPlayer(player);

	if (!cl_predictlocalplayer)
	{
		if (predtic == gametic)
		{
			P_PlayerThink(player);
			player->mo->RunThink();
		}

		return;
	}

	if (!predicting)
		P_PlayerThink(player);
	else
		P_MovePlayer(player);

	player->mo->RunThink();
}

void D_SetupUserInfo(void)
{
	UserInfo* coninfo = &consoleplayer().userinfo;

	std::string netname = cl_name.str();
	if (netname.length() > MAXPLAYERNAME)
		netname.erase(MAXPLAYERNAME);

	coninfo->netname			= netname;
	coninfo->team				= D_TeamByName (cl_team.cstring()); // [Toke - Teams]
	coninfo->color				= V_GetColorFromString (NULL, cl_color.cstring());
	coninfo->gender				= D_GenderByName (cl_gender.cstring());
	coninfo->aimdist			= (fixed_t)(cl_autoaim * 16384.0);
	coninfo->unlag				= (cl_unlag != 0);
	coninfo->update_rate		= cl_updaterate;
	coninfo->predict_weapons	= (cl_predictweapons != 0);

	// sanitize the weapon switching choice
	if (cl_switchweapon < 0 || cl_switchweapon > 2)
		cl_switchweapon.ForceSet(float(WPSW_ALWAYS));
	coninfo->switchweapon	= (weaponswitch_t)cl_switchweapon.asInt();

	// Copies the updated cl_weaponpref* cvars to coninfo->weapon_prefs[]
	D_PrepareWeaponPreferenceUserInfo();
}

void D_SetupUserInfo(void)
{
	userinfo_t *coninfo = &consoleplayer().userinfo;

	// Save the previous weapon preferences
	weapontype_t backup_weapon_prefs[NUMWEAPONS];
	memcpy(backup_weapon_prefs, coninfo->weapon_prefs, sizeof(backup_weapon_prefs));

	memset (&consoleplayer().userinfo, 0, sizeof(userinfo_t));
	
	strncpy (coninfo->netname, cl_name.cstring(), MAXPLAYERNAME);
	coninfo->team			= D_TeamByName (cl_team.cstring()); // [Toke - Teams]
	coninfo->color			= V_GetColorFromString (NULL, cl_color.cstring());
	coninfo->skin			= R_FindSkin (cl_skin.cstring());
	coninfo->gender			= D_GenderByName (cl_gender.cstring());
	coninfo->aimdist		= (fixed_t)(cl_autoaim * 16384.0);
	coninfo->unlag			= cl_unlag;
	coninfo->update_rate	= cl_updaterate;
	coninfo->switchweapon	= (weaponswitch_t)cl_switchweapon.asInt();

	// Copies the updated cl_weaponpref* cvars to coninfo->weapon_prefs[]
	CL_PrepareWeaponPreferenceUserInfo();

	// Find which weapon preference slot was changed
	for (size_t i = 0; i < NUMWEAPONS; i++)
	{
		if (backup_weapon_prefs[i] != coninfo->weapon_prefs[i])
		{
			// slot i was changed
			weapontype_t oldweapon = backup_weapon_prefs[i];
			weapontype_t newweapon = coninfo->weapon_prefs[i];
			
			// swap the weapon in slot i with whatever slot already has newweapon
			for (size_t j = 0; j < NUMWEAPONS; j++)
			{
				if (coninfo->weapon_prefs[j] == newweapon &&  j != i)
				{
					coninfo->weapon_prefs[j] = oldweapon;
					CL_SetWeaponPreferenceCvar(j, oldweapon);
					break;
				}
			}

			break;
		}
	}
}

BOOL P_ActivateMobj (AActor *mobj, AActor *activator)
{
	if (mobj->flags & MF_COUNTKILL)
	{
		mobj->flags2 &= !(MF2_DORMANT | MF2_INVULNERABLE);
		return true;
	}
	else
	{
		switch (mobj->type)
		{
			case MT_SPARK:
			{
				int count = mobj->args[0];
				char sound[16];

				if (count == 0)
					count = 32;

				P_DrawSplash (count, mobj->x, mobj->y, mobj->z, mobj->angle, 1);
				sprintf (sound, "world/spark%d", 1+(M_Random() % 3));
				S_Sound (mobj, CHAN_AUTO, sound, 1, ATTN_STATIC);
				break;
			}

			case MT_FOUNTAIN:
				mobj->effects &= ~FX_FOUNTAINMASK;
				mobj->effects |= mobj->args[0] << FX_FOUNTAINSHIFT;
				break;

			case MT_SECRETTRIGGER:
				if (activator->player->mo == consoleplayer().camera)
				{
					if (mobj->args[0] <= 1)
					{
						C_MidPrint ("A secret is revealed!");
					}
					if (mobj->args[0] == 0 || mobj->args[0] == 2)
					{
						S_Sound (activator, CHAN_AUTO, "misc/secret", 1, ATTN_NORM);
					}
				}
				level.found_secrets++;
				mobj->Destroy ();
				break;

			default:
				break;
		}
	}
	return false;
}

//
// CL_PredictSpectator
//
//
static void CL_PredictSpectator()
{
	player_t *player = &consoleplayer();
	if (!player->spectator)
		return;
		
	predicting = true;
	
	P_PlayerThink(player);
	P_CalcHeight(player);
	
	predicting = false;
}

void ST_refreshBackground(void)
{
    if (st_statusbaron)
    {
        // [RH] If screen is wider than the status bar,
        //      draw stuff around status bar.
        if (FG->width > ST_WIDTH)
        {
            R_DrawBorder (0, ST_Y, ST_X, FG->height);
            R_DrawBorder (FG->width - ST_X, ST_Y, FG->width, FG->height);
        }

        BG->DrawPatch (sbar, 0, 0);

        if (sv_gametype == GM_CTF) {
            BG->DrawPatch (flagsbg, ST_FLAGSBGX, ST_FLAGSBGY);
            BG->DrawPatch (flagbox, ST_FLGBOXX, ST_FLGBOXY);
        } else if (sv_gametype == GM_COOP)
            BG->DrawPatch (armsbg, ST_ARMSBGX, ST_ARMSBGY);

        if (multiplayer)
        {
            if (!demoplayback || !democlassic) {
                // [RH] Always draw faceback with the player's color
                //		using a translation rather than a different patch.
                V_ColorMap = translationtables + (consoleplayer().id) * 256;
                BG->DrawTranslatedPatch (faceback, ST_FX, ST_FY);
            } else {
                BG->DrawPatch (faceclassic[consoleplayer().id-1], ST_FX, ST_FY);
            }
        }

        BG->Blit (0, 0, 320, 32, stnumscreen, 0, 0, 320, 32);

        if (!st_scale)
            stnumscreen->Blit (0, 0, 320, 32,
                               FG, ST_X, ST_Y, ST_WIDTH, ST_HEIGHT);
    }
}

// Return a string that contains the name of the player being spectated,
// or a blank string if you are looking out of your own viewpoint.
std::string SpyPlayerName(int& color) {
	color = CR_GREY;
	player_t *plyr = &displayplayer();

	if (plyr == &consoleplayer()) {
		return "";
	}

	if (sv_gametype == GM_TEAMDM || sv_gametype == GM_CTF) {
		color = teamTextColor(plyr->userinfo.team);
	}

	return plyr->userinfo.netname;
}

void ST_nameDraw (int y)
{
	player_t *plyr = &displayplayer();

	if (plyr == &consoleplayer())
		return;
	
	char *string = plyr->userinfo.netname;
	size_t x = (screen->width - V_StringWidth (string)*CleanXfac) >> 1;

	if (level.time < NameUp)
		screen->DrawTextClean (CR_GREEN, x, y, string);
	else
		screen->DrawTextCleanLuc (CR_GREEN, x, y, string);
}

//
// D_PrepareWeaponPreferenceUserInfo
//
// Copies the weapon order preferences from the cl_weaponpref_* cvars
// to the userinfo struct for the consoleplayer.
//
void D_PrepareWeaponPreferenceUserInfo()
{
	byte *prefs = consoleplayer().userinfo.weapon_prefs;

	for (size_t i = 0; i < NUMWEAPONS; i++)
	{
		// sanitize the weapon preferences
		if (weaponpref_cvar_map[i]->asInt() < 0)
			weaponpref_cvar_map[i]->ForceSet(0.0f);
		if (weaponpref_cvar_map[i]->asInt() >= NUMWEAPONS)
			weaponpref_cvar_map[i]->ForceSet(float(NUMWEAPONS - 1));

		prefs[i] = weaponpref_cvar_map[i]->asInt();
	}
}

void RenderAutomap()
{
	size_t i;

	glDisable(GL_TEXTURE_2D);

	glColor4f(0.2,0.2,0,1);
	DrawQuad(0,0,1,1);

	glColor4f(1,1,1,1);

	glPushMatrix();

	glTranslatef(0.5, 0.5, 0);

	glScalef(-0.001, 0.001, 0.001);

	AActor *mo = consoleplayer().mo;
	if(mo)
		glTranslatef(FIXED2FLOAT(mo->x), FIXED2FLOAT(mo->y), 0);
	glRotatef(180, 0, 0, 1);

	glBegin(GL_LINES);

	// grid

	// walls
	for(i = 0; i < numlines; i++)
	{
		if (!(lines[i].flags & ML_MAPPED))
			continue;

		glVertex2f(FIXED2FLOAT(lines[i].v1->x), FIXED2FLOAT(lines[i].v1->y));
		glVertex2f(FIXED2FLOAT(lines[i].v2->x), FIXED2FLOAT(lines[i].v2->y));
	}

	// players
	for (i = 0; i < players.size(); i++)
	{
	}

	// things

	glEnd();

	glPopMatrix();
}

//
// CL_PredicMove
//
void CL_PredictMove (void)
{
	if (noservermsgs)
		return;

	player_t *p = &consoleplayer();

	if (!p->tic || !p->mo)
		return;

	// Save player angle, viewheight,deltaviewheight and jumpTics.
	// Will use it later to predict movements
	int buf = gametic%MAXSAVETICS;
	
	cl_angle[buf] = p->mo->angle;
	cl_pitch[buf] = p->mo->pitch;
	cl_viewheight[buf] = p->viewheight;
	cl_deltaviewheight[buf] = p->deltaviewheight;
	cl_jumpTics[buf] = p->jumpTics;
	cl_reactiontime[buf] = p->mo->reactiontime;

	// Disable sounds, etc, during prediction
	predicting = true;

	// Set predictable items to their last received positions
	CL_ResetPlayers();
	CL_ResetSectors();

	int predtic = gametic - MAXSAVETICS;

	if(predtic < 0)
		predtic = 0;

	// Predict each tic
	while(predtic < gametic)
	{
		CL_PredictPlayers(predtic);
		CL_PredictSectors(predtic);

		++predtic;
	}

	predicting = false;

	CL_PredictPlayers(predtic);
	CL_PredictSectors(predtic);
}

//
// C_DoSpectatorKey
//
// [SL] 2012-09-14 - Handles the hard-coded key bindings used while spectating
// or during NetDemo playback.  Returns false if the key pressed is not
// bound to any spectating command such as spynext.
//
bool C_DoSpectatorKey (event_t *ev)
{
	if (!consoleplayer().spectator && !netdemo.isPlaying() && !netdemo.isPaused())
		return false;

	if (ev->type == ev_keydown && ev->data1 == KEY_MWHEELUP)
	{
		AddCommandString("spyprev");
		return true;
	}
	if (ev->type == ev_keydown && ev->data1 == KEY_MWHEELDOWN)
	{
		AddCommandString("spynext");
		return true;
	}

	return false;
}

//
//	[Toke - CTF] CTF_CarryFlag
//	Spawns a flag on a players location and links the flag to the player
//
void CTF_CarryFlag (player_t &player, flag_t flag)
{
	if (!validplayer(player))
		return;

	player.flags[flag] = true;
	CTFdata[flag].flagger = player.id;
	CTFdata[flag].state = flag_carried;

	// spawn visible flags on other players
	if(&player != &consoleplayer())
	{
		AActor *actor = new AActor(0, 0, 0, flag_table[flag][flag_carried]);
		CTFdata[flag].actor = actor->ptr();

		CTF_MoveFlags();
	}
}

/* Original redscreen palette method - replaces ZDoom method - ML       */
void ST_doPaletteStuff(void)
{

    int		palette;
    byte*	pal;
    int		cnt;
    int		bzc;

    player_t *plyr = &consoleplayer();

    cnt = plyr->damagecount;

    if (plyr->powers[pw_strength])
    {
        // slowly fade the berzerk out
        bzc = 12 - (plyr->powers[pw_strength]>>6);

        if (bzc > cnt)
            cnt = bzc;
    }

int ST_calcPainOffset(void)
{
    int 		health;
    static int	lastcalc;
    static int	oldhealth = -1;

    health = consoleplayer().health;

    if(health < -1)
        health = -1;
    else if(health > 100)
        health = 100;

    if (health != oldhealth)
    {
        lastcalc = ST_FACESTRIDE * (((100 - health) * ST_NUMPAINFACES) / 101);
        oldhealth = health;
    }

    return lastcalc;
}

/* Original redscreen palette method - replaces ZDoom method - ML       */
void ST_doPaletteStuff(void)
{

    int		palette;
    byte*	pal;
    float	cnt;
    int		bzc;

	player_t *plyr = &consoleplayer();

    cnt = (float)plyr->damagecount;
	if (!multiplayer || sv_allowredscreen)
		cnt *= r_painintensity;

    if (plyr->powers[pw_strength])
    {
	// slowly fade the berzerk out
        bzc = 12 - (plyr->powers[pw_strength]>>6);

        if (bzc > cnt)
            cnt = bzc;
    }

void ST_AdjustStatusBarScale(bool scale)
{
	if (scale)
	{
		// Scale status bar height to screen.
		ST_HEIGHT = (32 * screen->height) / 200;
		// [AM] Scale status bar width according to height, unless there isn't
		//      enough room for it.  Fixes widescreen status bar scaling.
		// [ML] A couple of minor changes for true 4:3 correctness...
		ST_WIDTH = ST_HEIGHT*10;
		if (!screen->isProtectedRes())
        {
            ST_WIDTH = SquareWidth;
        }
	}
	else
	{
		// Do not stretch status bar
		ST_WIDTH = 320;
		ST_HEIGHT = 32;
	}

	if (consoleplayer().spectator && displayplayer_id == consoleplayer_id)
	{
		ST_X = 0;
		ST_Y = screen->height;
	}
	else
	{
		ST_X = (screen->width-ST_WIDTH)/2;
		ST_Y = screen->height - ST_HEIGHT;
	}

	setsizeneeded = true;
	st_firsttime = true;
}

// Returns a string that contains the current warmup state.
std::string Warmup(int& color)
{
	color = CR_GREY;
	player_t *dp = &displayplayer();
	player_t *cp = &consoleplayer();

	::Warmup::status_t wstatus = warmup.get_status();

	if (wstatus == ::Warmup::WARMUP)
	{
		if (dp->spectator)
			return "Warmup: You are spectating";
		else if (dp->ready)
		{
			color = CR_GREEN;
			if (dp == cp)
				return "Warmup: You are ready";
			else
				return "Warmup: This player is ready";
		}
		else
		{
			color = CR_RED;
			if (dp == cp)
				return "Warmup: You are not ready";
			else
				return "Warmup: This player is not ready";
		}
	}
	else if (wstatus == ::Warmup::COUNTDOWN || wstatus == ::Warmup::FORCE_COUNTDOWN)
	{
		color = CR_GOLD;
		return "Match is about to start...";
	}
	return "";
}