/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "Precompiled.h"
#include "globaldata.h"


#include "m_menu.h"
#include "i_system.h"
#include "i_video.h"
#include "i_net.h"
#include "g_game.h"
#include "doomdef.h"
#include "doomstat.h"

#include "doomlib.h"
#include "Main.h"
#include "d3xp/Game_local.h"


void I_GetEvents( controller_t * );
void D_ProcessEvents (void); 
void G_BuildTiccmd (ticcmd_t *cmd, idUserCmdMgr *, int newTics ); 
void D_DoAdvanceDemo (void);

extern bool globalNetworking;
extern idCVar cl_engineHz;

//
// NETWORKING
//
// ::g->gametic is the tic about to (or currently being) run
// ::g->maketic is the tick that hasn't had control made for it yet
// ::g->nettics[] has the maketics for all ::g->players 
//
// a ::g->gametic cannot be run until ::g->nettics[] > ::g->gametic for all ::g->players
//




#define NET_TIMEOUT	1 * TICRATE





//
//
//
int NetbufferSize (void)
{
	int size = (intptr_t)&(((doomdata_t *)0)->cmds[::g->netbuffer->numtics]);

	return size;
}

//
// Checksum 
//
unsigned NetbufferChecksum (void)
{
	unsigned		c;
	int		i,l;

	c = 0x1234567;

	if ( globalNetworking ) {
		l = (NetbufferSize () - (intptr_t)&(((doomdata_t *)0)->retransmitfrom))/4;
		for (i=0 ; i<l ; i++)
			c += ((unsigned *)&::g->netbuffer->retransmitfrom)[i] * (i+1);
	}

	return c & NCMD_CHECKSUM;
}

//
//
//
int ExpandTics (int low)
{
	int	delta;

	delta = low - (::g->maketic&0xff);

	if (delta >= -64 && delta <= 64)
		return (::g->maketic&~0xff) + low;
	if (delta > 64)
		return (::g->maketic&~0xff) - 256 + low;
	if (delta < -64)
		return (::g->maketic&~0xff) + 256 + low;

	I_Error ("ExpandTics: strange value %i at ::g->maketic %i",low,::g->maketic);
	return 0;
}



//
// HSendPacket
//
void
HSendPacket
(int	node,
 int	flags )
{
	::g->netbuffer->checksum = NetbufferChecksum () | flags;

	if (!::g->netgame || ::g->demoplayback || node == ::g->consoleplayer) //GK:Before it was expecting the local player to be the node 0 now it expects to be the proper player
	{
		::g->reboundstore = *::g->netbuffer;
		::g->reboundpacket = true;
		return;
	}

	if (::g->demoplayback)
		return;

	if (!::g->netgame)
		I_Error ("Tried to transmit to another node");

	::g->doomcom.command = CMD_SEND;
	::g->doomcom.remotenode = node;
	::g->doomcom.datalength = NetbufferSize ();

	if (::g->debugfile)
	{
		int		i;
		int		realretrans;
		if (::g->netbuffer->checksum & NCMD_RETRANSMIT)
			realretrans = ExpandTics (::g->netbuffer->retransmitfrom);
		else
			realretrans = -1;

		fprintf (::g->debugfile,"send (%i + %i, R %i) [%i] ",
			ExpandTics(::g->netbuffer->starttic),
			::g->netbuffer->numtics, realretrans, ::g->doomcom.datalength);

		for (i=0 ; i < ::g->doomcom.datalength ; i++)
			fprintf (::g->debugfile,"%i ",((byte *)::g->netbuffer)[i]);

		fprintf (::g->debugfile,"\n");
	}

	I_NetCmd ();
}

//
// HGetPacket
// Returns false if no packet is waiting
//
qboolean HGetPacket (void)
{	
	if (::g->reboundpacket)
	{
		*::g->netbuffer = ::g->reboundstore;
		::g->doomcom.remotenode = ::g->consoleplayer; //GK:Expect to be the player in the right slot
		::g->reboundpacket = false;
		return true;
	}

	if (!::g->netgame)
		return false;

	if (::g->demoplayback)
		return false;

	::g->doomcom.command = CMD_GET;
	I_NetCmd ();

	if (::g->doomcom.remotenode == -1)
		return false;

	if (::g->doomcom.datalength != NetbufferSize ())
	{
		if (::g->debugfile)
			fprintf (::g->debugfile,"bad packet length %i\n",::g->doomcom.datalength);
		return false;
	}

	// ALAN NETWORKING -- this fails a lot on 4 player split debug!!
	// TODO: Networking
#ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
	if ( /*!gameLocal->IsSplitscreen() &&*/ NetbufferChecksum() != (::g->netbuffer->checksum&NCMD_CHECKSUM) ) //GK:No splitscreen
	{
		if (::g->debugfile) {
			fprintf (::g->debugfile,"bad packet checksum\n");
		}

		return false;
	}
#endif

	if (::g->debugfile)
	{
		int		realretrans;
		int	i;

		if (::g->netbuffer->checksum & NCMD_SETUP)
			fprintf (::g->debugfile,"setup packet\n");
		else
		{
			if (::g->netbuffer->checksum & NCMD_RETRANSMIT)
				realretrans = ExpandTics (::g->netbuffer->retransmitfrom);
			else
				realretrans = -1;

			fprintf (::g->debugfile,"get %i = (%i + %i, R %i)[%i] ",
				::g->doomcom.remotenode,
				ExpandTics(::g->netbuffer->starttic),
				::g->netbuffer->numtics, realretrans, ::g->doomcom.datalength);

			for (i=0 ; i < ::g->doomcom.datalength ; i++)
				fprintf (::g->debugfile,"%i ",((byte *)::g->netbuffer)[i]);
			fprintf (::g->debugfile,"\n");
		}
	}
	return true;	
}


//
// GetPackets
//

void GetPackets (void)
{
	int		netconsole;
	int		netnode;
	ticcmd_t	*src, *dest;
	int		realend;
	int		realstart;

	while ( HGetPacket() )
	{
		if (::g->netbuffer->checksum & NCMD_SETUP)
			continue;		// extra setup packet

		netconsole = ::g->netbuffer->player & ~PL_DRONE;
		if (::g->demoplayback) {
			netnode = 0;
		}
		else {
			netnode = ::g->doomcom.remotenode;
		}

		// to save bytes, only the low byte of tic numbers are sent
		// Figure out what the rest of the bytes are
		realstart = ExpandTics (::g->netbuffer->starttic);		
		realend = (realstart+::g->netbuffer->numtics);

		// check for exiting the game
		if (::g->netbuffer->checksum & NCMD_EXIT)
		{
			if (!::g->nodeingame[netnode])
				continue;
			::g->nodeingame[netnode] = false;
			::g->playeringame[netconsole] = false;
			strcpy (::g->exitmsg, "Player 1 left the game");
			::g->exitmsg[7] += netconsole;
			::g->players[::g->consoleplayer].message = ::g->exitmsg;

			if( ::g->demorecording ) {
				G_CheckDemoStatus();
			}
			continue;
		}

		// check for a remote game kill
/*
		if (::g->netbuffer->checksum & NCMD_KILL)
			I_Error ("Killed by network driver");
*/

		::g->nodeforplayer[netconsole] = netnode;

		// check for retransmit request
		if ( ::g->resendcount[netnode] <= 0 
			&& (::g->netbuffer->checksum & NCMD_RETRANSMIT) )
		{
			::g->resendto[netnode] = ExpandTics(::g->netbuffer->retransmitfrom);
			if (::g->debugfile)
				fprintf (::g->debugfile,"retransmit from %i\n", ::g->resendto[netnode]);
			::g->resendcount[netnode] = RESENDCOUNT;
		}
		else
			::g->resendcount[netnode]--;

		// check for out of order / duplicated packet		
		if (realend == ::g->nettics[netnode])
			continue;

		if (realend < ::g->nettics[netnode])
		{
			if (::g->debugfile)
				fprintf (::g->debugfile,
				"out of order packet (%i + %i)\n" ,
				realstart,::g->netbuffer->numtics);
			continue;
		}

		// check for a missed packet
		if (realstart > ::g->nettics[netnode])
		{
			// stop processing until the other system resends the missed tics
			if (::g->debugfile)
				fprintf (::g->debugfile,
				"missed tics from %i (%i - %i)\n",
				netnode, realstart, ::g->nettics[netnode]);
			::g->remoteresend[netnode] = true;
			continue;
		}

		// update command store from the packet
		{
			int		start;

			::g->remoteresend[netnode] = false;

			start = ::g->nettics[netnode] - realstart;		
			src = &::g->netbuffer->cmds[start];

			while (::g->nettics[netnode] < realend)
			{
				dest = &::g->netcmds[netconsole][::g->nettics[netnode]%BACKUPTICS];
				::g->nettics[netnode]++;
				*dest = *src;
				src++;
			}
		}
	}
}


//
// NetUpdate
// Builds ticcmds for console player,
// sends out a packet
//

void NetUpdate ( idUserCmdMgr * userCmdMgr )
{
	int             nowtime;
	int             newtics;
	int				i,j;
	int				realstart;
	int				gameticdiv;

	// check time
	nowtime = I_GetTime ()/::g->ticdup;
	newtics = nowtime - ::g->gametime;
	::g->gametime = nowtime;

	if (newtics <= 0) 	// nothing new to update
		goto listen; 

	if (::g->skiptics <= newtics)
	{
		newtics -= ::g->skiptics;
		::g->skiptics = 0;
	}
	else
	{
		::g->skiptics -= newtics;
		newtics = 0;
	}


	::g->netbuffer->player = ::g->doomcom.consoleplayer; //GK:Just in case

	// build new ticcmds for console player
	gameticdiv = ::g->gametic/::g->ticdup;
	for (i=0 ; i<newtics ; i++)
	{
		//I_GetEvents( ::g->I_StartTicCallback () );
		D_ProcessEvents ();
		if (::g->maketic - gameticdiv >= BACKUPTICS/2-1) {
			printf( "Out of room for ticcmds: maketic = %d, gameticdiv = %d\n", ::g->maketic, gameticdiv );
			break;          // can't hold any more
		}

		//I_Printf ("mk:%i ",::g->maketic);

		// Grab the latest tech5 command

		G_BuildTiccmd (&::g->localcmds[::g->maketic%BACKUPTICS], userCmdMgr, newtics );
		::g->maketic++;
	}
	

	if (::g->singletics)
		return;         // singletic update is syncronous

	// send the packet to the other ::g->nodes
	for (i=0 ; i < ::g->doomcom.numnodes ; i++) {

		if (::g->nodeingame[i])	{
			::g->netbuffer->starttic = realstart = ::g->resendto[i];
			::g->netbuffer->numtics = ::g->maketic - realstart;
			if (::g->netbuffer->numtics > BACKUPTICS)
				I_Error ("NetUpdate: ::g->netbuffer->numtics > BACKUPTICS");

			::g->resendto[i] = ::g->maketic - ::g->doomcom.extratics;

			for (j=0 ; j< ::g->netbuffer->numtics ; j++)
				::g->netbuffer->cmds[j] = 
				::g->localcmds[(realstart+j)%BACKUPTICS];

			if (::g->remoteresend[i])
			{
				::g->netbuffer->retransmitfrom = ::g->nettics[i];
				HSendPacket (i, NCMD_RETRANSMIT);
			}
			else
			{
				::g->netbuffer->retransmitfrom = 0;
				HSendPacket (i, 0);
			}
		}
	}

	// listen for other packets
listen:
	GetPackets ();
}



//
// CheckAbort
//
void CheckAbort(void)
{
	// DHM - Time starts at 0 tics when starting a multiplayer game, so we can
	// check for timeouts easily.  If we're still waiting after N seconds, abort.
	if (I_GetTime() > NET_TIMEOUT*10) { //GK: Give more time to wait (but dont remove it because the game will freeze)
		// TOOD: Show error & leave net game.
		I_Printf("NET GAME TIMED OUT! %d\n", I_GetTime());
		//gameLocal->showFatalErrorMessage( XuiLookupStringTable(globalStrings,L"Timed out waiting for match start.") );


		D_QuitNetGame();

		session->QuitMatch();
		if (!common->IsNewDOOM3()) {
			common->Dialog().AddDialog(GDM_OPPONENT_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false);
		}
		else {
			I_Error("Connection Lost");
		}
	}
}


//
// D_ArbitrateNetStart
//
bool D_ArbitrateNetStart (void)
{
	int		i;

	::g->autostart = true;
	if (::g->doomcom.consoleplayer)
	{
		// listen for setup info from key player
		CheckAbort ();
		if (!HGetPacket ())
			return false;
		if (::g->netbuffer->checksum & NCMD_SETUP)
		{
			I_Printf( "Received setup info\n" );

			if (::g->netbuffer->player != VERSION)
				I_Error ("Different DOOM versions cannot play a net game!");
			::g->startskill = (skill_t)(::g->netbuffer->retransmitfrom & 15);
			::g->deathmatch = (::g->netbuffer->retransmitfrom & 0xc0) >> 6;
			::g->nomonsters = (::g->netbuffer->retransmitfrom & 0x20) > 0;
			::g->respawnparm = (::g->netbuffer->retransmitfrom & 0x10) > 0;
			// VV original xbox doom :: don't do this.. it will be setup from the launcher
			//::g->startmap = ::g->netbuffer->starttic & 0x3f;
			//::g->startepisode = ::g->netbuffer->starttic >> 6;
			return true;
		}
		return false;
	}
	else
	{
		// key player, send the setup info
		CheckAbort ();
		for (i=0 ; i < ::g->doomcom.numnodes ; i++)
		{
			printf( "Sending setup info to node %d\n", i );

			::g->netbuffer->retransmitfrom = ::g->startskill;
			if (::g->deathmatch)
				::g->netbuffer->retransmitfrom |= (::g->deathmatch<<6);
			if (::g->nomonsters)
				::g->netbuffer->retransmitfrom |= 0x20;
			if (::g->respawnparm)
				::g->netbuffer->retransmitfrom |= 0x10;
			::g->netbuffer->starttic = ::g->startepisode * 64 + ::g->startmap;
			::g->netbuffer->player = VERSION;
			::g->netbuffer->numtics = 0;
			HSendPacket (i, NCMD_SETUP);
		}

		while (HGetPacket ())
		{
			::g->gotinfo[::g->netbuffer->player&0x7f] = true;
		}

		for (i=1 ; i < ::g->doomcom.numnodes ; i++) {
			if (!::g->gotinfo[i])
				break;
		}

		if (i >= ::g->doomcom.numnodes)
			return true;

		return false;
	}
}

//
// D_CheckNetGame
// Works out player numbers among the net participants
//

void D_CheckNetGame (void)
{
	int             i;

	for (i=0 ; i<MAXNETNODES ; i++)
	{
		::g->nodeingame[i] = false;
		::g->nettics[i] = 0;
		::g->remoteresend[i] = false;	// set when local needs tics
		::g->resendto[i] = 0;		// which tic to start sending
	}

	// I_InitNetwork sets ::g->doomcom and ::g->netgame
	I_InitNetwork ();
#if 0 //GK: Just in case
	memset(&::g->doomcom, 0, sizeof(::g->doomcom));
	::g->doomcom.ticdup = 1;
	::g->doomcom.extratics = 0;
	::g->netgame = false;
	::g->doomcom.id = DOOMCOM_ID;
	::g->doomcom.numplayers = ::g->doomcom.numnodes = 1;
	::g->doomcom.deathmatch = false;
	::g->doomcom.consoleplayer = 0;
#endif
#ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
	if (::g->doomcom.id != DOOMCOM_ID)
		I_Error ("Doomcom buffer invalid!");
#endif

	::g->netbuffer = &::g->doomcom.data;
	::g->consoleplayer = ::g->displayplayer = ::g->doomcom.consoleplayer;
}

bool D_PollNetworkStart()
{
	int             i;
	if (::g->netgame)
	{
		if (D_ArbitrateNetStart () == false)
			return false;
	}

	I_Printf ("startskill %i  deathmatch: %i  startmap: %i  startepisode: %i\n",
		::g->startskill, ::g->deathmatch, ::g->startmap, ::g->startepisode);

	// read values out of ::g->doomcom
	::g->ticdup = ::g->doomcom.ticdup;
	::g->maxsend = BACKUPTICS/(2*::g->ticdup)-1;
	if (::g->maxsend<1)
		::g->maxsend = 1;

	for (i=0 ; i < ::g->doomcom.numplayers ; i++)
		::g->playeringame[i] = true;
	for (i=0 ; i < ::g->doomcom.numnodes ; i++)
		::g->nodeingame[i] = true;

	I_Printf ("player %i of %i (%i ::g->nodes)\n",
		::g->consoleplayer+1, ::g->doomcom.numplayers, ::g->doomcom.numnodes);

	return true;
}


//
// D_QuitNetGame
// Called before quitting to leave a net game
// without hanging the other ::g->players
//
void D_QuitNetGame (void)
{
	int i;

	if ( (!::g->netgame && !::g->usergame) || ::g->consoleplayer == -1 || ::g->demoplayback || ::g->netbuffer == NULL )
		return;

	// send a quit packet to the other nodes
	::g->netbuffer->player = ::g->doomcom.consoleplayer;
	::g->netbuffer->numtics = 0;

	for ( i=0; i < ::g->doomcom.numnodes; i++ ) {
		if ( ::g->nodeingame[i] ) {
			HSendPacket( i, NCMD_EXIT );
		}
	}
	DoomLib::SendNetwork();

	for (i=1 ; i<MAXNETNODES ; i++)
	{
		::g->nodeingame[i] = false;
		::g->nettics[i] = 0;
		::g->remoteresend[i] = false;	// set when local needs tics
		::g->resendto[i] = 0;		// which tic to start sending
	}

	//memset (&::g->doomcom, 0, sizeof(::g->doomcom) );

	// Reset singleplayer state
	::g->doomcom.id = DOOMCOM_ID;
	::g->doomcom.ticdup = 1;
	::g->doomcom.extratics = 0;
	::g->doomcom.numplayers = ::g->doomcom.numnodes = 1;
	::g->doomcom.deathmatch = false;
	::g->doomcom.consoleplayer = 0;
	::g->netgame = false;

	::g->netbuffer = &::g->doomcom.data;
	::g->consoleplayer = ::g->displayplayer = ::g->doomcom.consoleplayer;

	::g->ticdup = ::g->doomcom.ticdup;
	::g->maxsend = BACKUPTICS/(2*::g->ticdup)-1;
	if (::g->maxsend<1)
		::g->maxsend = 1;

	for (i=0 ; i < ::g->doomcom.numplayers ; i++)
		::g->playeringame[i] = true;
	for (i=0 ; i < ::g->doomcom.numnodes ; i++)
		::g->nodeingame[i] = true;
}

//GK: Begin
/**
* CalculateInterpolationCheckSkips
* 
* Calculate and check if the engine's frameTime is slower than the expected frameTime and if it is accumulate interpolaction check skips in order to not lose any frames
*/
void CalculateInterpolationCheckSkips(int timeDelta, float expectedFrameMs, int index) {
	if (index == 100) { //We only use 100 entries to keep the accumulated FrameTimes, if it run out just skip and start playing the frames
		return;
	}
	::g->accumulatedTimeDeltas[index] += timeDelta - expectedFrameMs;
	if (::g->accumulatedTimeDeltas[index] >= expectedFrameMs) {
		::g->skipTicInterpolationCheck++;
		CalculateInterpolationCheckSkips(::g->accumulatedTimeDeltas[index], expectedFrameMs, index + 1);
		::g->accumulatedTimeDeltas[index] = 0;
	}
}

//	InterpolateTics
//
// Check if the current tic must run or not.
//
bool InterpolateTics() {
	if (!::g->skipTicInterpolationCheck) {
		const int currentTime = Sys_Milliseconds();
		float expectedFrameMs = 1000.0f / cl_engineHz.GetFloat();
		::g->timeDelta = currentTime - ::g->lastTicTime;
		if (::g->timeDelta >= expectedFrameMs) {
			CalculateInterpolationCheckSkips(::g->timeDelta, expectedFrameMs, 0);
			::g->lastTicTime = currentTime;
			return true;
		}
	}
	else {
		::g->skipTicInterpolationCheck--;
		return true;
	}
	return false;
	/*int notyet = 0;
	if (::g->ownedframe) {
		::g->ownedframe = false;
		::g->lasttic[!::g->ownedtic] = ::g->lasttic[::g->ownedtic];
		::g->counttics[!::g->ownedtic]++;
		return true;
	}
	for (int i = 0; i < 3; i++) {
		if (::g->ticrate[i] < 0) {
			return false;
		}
		if (!::g->lasttic[i]) {
			::g->lasttic[i] = ::g->trt_entertic;
			::g->counttics[i]++;
			return true;
		}
			if (::g->trt_entertic - ::g->lasttic[i] < ::g->ticrate[i]) {
				notyet++;
			}
			else {
				int j = !i;
				if (::g->trt_entertic - ::g->lasttic[j] >= ::g->ticrate[j]) {
					::g->ownedframe = true;
					::g->ownedtic = i;
				}
				::g->lasttic[i] = ::g->trt_entertic;
				::g->counttics[i]++;
				return true;
			}
	}
	
	if (notyet == 3) {
		notyet = 0;
		return false;
	}
	return false;*/
}
//GK: End


//
// TryRunTics
//
bool TryRunTics ( idUserCmdMgr * userCmdMgr )
{
	int		i;
	int		lowtic_node = -1;

	// get real tics		
	::g->trt_entertic = I_GetTime ()/::g->ticdup;
	::g->trt_realtics = ::g->trt_entertic - ::g->oldtrt_entertics;
	::g->oldtrt_entertics = ::g->trt_entertic;

	int currentTime = Sys_Milliseconds();
	if (currentTime - ::g->firstClock >= 1000) {
		/*int tempcounttics[3] = { 0, 0, 0 };
		memcpy(::g->counttics, tempcounttics, sizeof(tempcounttics));*/
		::g->firstClock = currentTime;
		::g->dgameframe = ::g->gameframecount;
		::g->gameframecount = 0;
	}

	// get available tics
	NetUpdate ( userCmdMgr );

	::g->trt_lowtic = MAXINT;
	::g->trt_numplaying = 0;

	for (i=0 ; i < ::g->doomcom.numnodes ; i++) {

		if (::g->nodeingame[i]) {
			::g->trt_numplaying++;

			if (::g->nettics[i] < ::g->trt_lowtic) {
				::g->trt_lowtic = ::g->nettics[i];
				lowtic_node = i;
			}
		}
	}

	::g->trt_availabletics = ::g->trt_lowtic - ::g->gametic/::g->ticdup;

	// decide how many tics to run
	if (::g->trt_realtics < ::g->trt_availabletics-1) {
		::g->trt_counts = ::g->trt_realtics+1;
	} else if (::g->trt_realtics < ::g->trt_availabletics) {
		::g->trt_counts = ::g->trt_realtics;
	} else {
		::g->trt_counts = ::g->trt_availabletics;
	}

	if (::g->trt_counts < 1) {
		::g->trt_counts = 1;
	}

	::g->frameon++;

	if (::g->debugfile) {
		fprintf (::g->debugfile, "=======real: %i  avail: %i  game: %i\n", ::g->trt_realtics, ::g->trt_availabletics,::g->trt_counts);
	}

	if ( !::g->demoplayback )
	{	
		// ideally ::g->nettics[0] should be 1 - 3 tics above ::g->trt_lowtic
		// if we are consistantly slower, speed up time
		for (i=0 ; i< ::g->doomcom.numnodes ; i++) { //GK:Optimize by using the number of nodes instead of maxplayers
			if (::g->playeringame[i]) {
				break;
			}
		}

		if (::g->consoleplayer == i) {
			// the key player does not adapt
		}
		else {
			//GK:Network optimization by stop assuming the the local player is always the node 0
			if (::g->nettics[::g->nodeforplayer[::g->consoleplayer]] <= ::g->nettics[::g->nodeforplayer[i]])	{
				::g->gametime--;
				//OutputDebugString("-");
			}

			::g->frameskip[::g->frameon&3] = (::g->oldnettics > ::g->nettics[::g->nodeforplayer[i]]);
			::g->oldnettics = ::g->nettics[::g->nodeforplayer[::g->consoleplayer]];

			if (::g->frameskip[0] && ::g->frameskip[1] && ::g->frameskip[2] && ::g->frameskip[3]) {
				::g->skiptics = 1;
				//OutputDebugString("+");
			}
		}
	}

	// wait for new tics if needed
	if (::g->trt_lowtic < ::g->gametic/::g->ticdup + ::g->trt_counts)	
	{
		int lagtime = 0;

		if (::g->trt_lowtic < ::g->gametic/::g->ticdup) {
			I_Error ("TryRunTics: ::g->trt_lowtic < gametic");
		}

		if ( ::g->lastnettic == 0 ) {
			::g->lastnettic = ::g->trt_entertic;
		}
		lagtime = ::g->trt_entertic - ::g->lastnettic;

		// Detect if a client has stopped sending updates, remove them from the game after 5 secs.
		if ( common->IsMultiplayer() && (!::g->demoplayback && ::g->netgame) && lagtime >= TICRATE ) {

			if ( lagtime > NET_TIMEOUT ) {

				if ( lowtic_node == ::g->nodeforplayer[::g->consoleplayer] ) {

#ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
#ifndef __PS3__
					//session->showFatalErrorMessage( XuiLookupStringTable(globalStrings,L"You have been disconnected from the match.") );
					DoomLib::Interface.QuitCurrentGame(); //GK:Proper exit
#endif
#endif
				} else {
					if (::g->nodeingame[lowtic_node]) {
						int i_, consoleNum = lowtic_node;

						for ( i_=0; i_ < ::g->doomcom.numnodes; i_++ ) {
							if ( ::g->nodeforplayer[i_] == lowtic_node ) {
								consoleNum = i_;
								break;
							}
						}

						::g->nodeingame[lowtic_node] = false;
						::g->playeringame[consoleNum] = false;
						strcpy (::g->exitmsg, "Player 1 left the game");
						::g->exitmsg[7] += consoleNum;
						::g->players[::g->consoleplayer].message = ::g->exitmsg;

						// Stop a demo record now, as playback doesn't support losing players
						G_CheckDemoStatus();
					}
				}
			}
		} 

		return false;
	}

	::g->lastnettic = 0;

	// run the count * ::g->ticdup dics
	while (::g->trt_counts--)
	{
		for (i = 0; i < ::g->ticdup; i++)
		{
			if (::g->gametic / ::g->ticdup > ::g->trt_lowtic) {
				I_Error("gametic(%d) greater than trt_lowtic(%d), trt_counts(%d)", ::g->gametic, ::g->trt_lowtic, ::g->trt_counts);
				return false;
			}

			int engineHz_denominator = com_engineHz_denominator / 100LL;
			int engine_diff = engineHz_denominator - com_engineHz_latched;
			::g->runTic = InterpolateTics(); //GK: Kepp it in memory just in case
			if (::g->runTic || !engine_diff) {
				if (::g->advancedemo) {
					D_DoAdvanceDemo();
				}
				M_Ticker();
				G_Ticker();
				::g->gameframecount++;
			}
			
			if (!::g->paused) {
				::g->gametic++;
			}

			// modify command for duplicated tics
			if (i != ::g->ticdup-1)
			{
				ticcmd_t	*cmd;
				int			buf;
				int			j;

				buf = (::g->gametic/::g->ticdup)%BACKUPTICS; 
				for (j=0 ; j< ::g->doomcom.numnodes ; j++) //GK:Optimize by using the number of nodes instead of maxplayers
				{
					cmd = &::g->netcmds[j][buf];
					if (cmd->buttons & BT_SPECIAL)
						cmd->buttons = 0;
				}
			}
		}

		NetUpdate ( userCmdMgr );	// check for new console commands
	}

	return true;
}

