spingle/source/host.c

/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2007-2008 Kristian Duske
Copyright (C) 2010-2014 QuakeSpasm developers

This program 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 2
of the License, or (at your option) any later version.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// host.c -- coordinates spawning and killing of local servers

#include "q_defs.h"
#include "bgmusic.h"
#include <setjmp.h>

/*

A server can allways be started, even if the system started out as a client
to a remote system.

A client can NOT be started if the system started as a dedicated server.

Memory is cleared / released when a server or client begins, not when they end.

*/

quakeparms_t *host_parms;

bool    host_initialized;               // true if into command execution

double          host_frametime;
double          realtime;                               // without any filtering or bounding
double          oldrealtime;                    // last frame run

int32_t         host_framecount;

int32_t         host_hunklevel;

client_t        *host_client;                   // current client

jmp_buf         host_abortserver;

byte            *host_colormap;

cvar_t  host_framerate = {"host_framerate", "0", CVAR_NONE};    // set for slow motion
cvar_t  host_speeds = {"host_speeds", "0", CVAR_NONE};                  // set for running times
cvar_t  host_maxfps = {"host_maxfps", "72", CVAR_ARCHIVE}; //johnfitz
cvar_t  host_timescale = {"host_timescale", "0", CVAR_NONE}; //johnfitz
cvar_t  max_edicts = {"max_edicts", "8192", CVAR_NONE}; //johnfitz //ericw -- changed from 2048 to 8192, removed CVAR_ARCHIVE

cvar_t  sys_ticrate = {"sys_ticrate", "0.05", CVAR_NONE}; // dedicated server
cvar_t  serverprofile = {"serverprofile", "0", CVAR_NONE};

cvar_t  fraglimit = {"fraglimit", "0", CVAR_NOTIFY | CVAR_SERVERINFO};
cvar_t  timelimit = {"timelimit", "0", CVAR_NOTIFY | CVAR_SERVERINFO};
cvar_t  teamplay = {"teamplay", "0", CVAR_NOTIFY | CVAR_SERVERINFO};
cvar_t  samelevel = {"samelevel", "0", CVAR_NONE};
cvar_t  noexit = {"noexit", "0", CVAR_NOTIFY | CVAR_SERVERINFO};
cvar_t  skill = {"skill", "1", CVAR_NONE};                      // 0 - 3
cvar_t  deathmatch = {"deathmatch", "0", CVAR_NONE};    // 0, 1, or 2
cvar_t  coop = {"coop", "0", CVAR_NONE};                // 0 or 1

cvar_t  pausable = {"pausable", "1", CVAR_NONE};

cvar_t  developer = {"developer", "0", CVAR_NONE};

cvar_t devstats = {"devstats", "0", CVAR_NONE}; //johnfitz -- track developer statistics that vary every frame

devstats_t dev_stats, dev_peakstats;
overflowtimes_t dev_overflows; //this stores the last time overflow messages were displayed, not the last time overflows occured

/*
================
Max_Edicts_f -- johnfitz
================
*/
static void Max_Edicts_f(cvar_t *var)
{
	(void)var;
	//TODO: clamp it here?
	if(cls.state == ca_connected || sv.active)
		Con_Printf("Changes to max_edicts will not take effect until the next time a map is loaded.\n");
}

/*
================
Max_Fps_f -- ericw
================
*/
static void Max_Fps_f(cvar_t *var)
{
	if(var->value > 72)
		Con_Warning("host_maxfps above 72 breaks physics.\n");
}

/*
================
Host_EndGame
================
*/
void Host_EndGame(const char *message, ...)
{
	va_list         argptr;
	char            string[1024];

	va_start(argptr, message);
	q_vsnprintf(string, sizeof(string), message, argptr);
	va_end(argptr);
	Con_DPrintf("Host_EndGame: %s\n", string);

	if(sv.active)
		Host_ShutdownServer(false);

	if(cls.state == ca_dedicated)
		Sys_Error("Host_EndGame: %s\n", string);        // dedicated servers exit

	if(cls.demonum != -1)
		CL_NextDemo();
	else
		CL_Disconnect();

	longjmp(host_abortserver, 1);
}

/*
================
Host_Error

This shuts down both the client and server
================
*/
void Host_Error(const char *error, ...)
{
	va_list         argptr;
	char            string[1024];
	static  bool inerror = false;

	if(inerror)
		Sys_Error("Host_Error: recursively entered");
	inerror = true;

	SCR_EndLoadingPlaque();                 // reenable screen updates

	va_start(argptr, error);
	q_vsnprintf(string, sizeof(string), error, argptr);
	va_end(argptr);
	Con_Printf("Host_Error: %s\n", string);

	if(sv.active)
		Host_ShutdownServer(false);

	if(cls.state == ca_dedicated)
		Sys_Error("Host_Error: %s\n", string);  // dedicated servers exit

	CL_Disconnect();
	cls.demonum = -1;
	cl.intermission = 0; //johnfitz -- for errors during intermissions (changelevel with no map found, etc.)

	inerror = false;

	longjmp(host_abortserver, 1);
}

/*
================
Host_FindMaxClients
================
*/
void    Host_FindMaxClients(void)
{
	int32_t         i;

	svs.maxclients = 1;

	i = COM_CheckParm("-dedicated");
	if(i)
	{
		cls.state = ca_dedicated;
		if(i != (com_argc - 1))
		{
			svs.maxclients = atoi(com_argv[i + 1]);
		}
		else
			svs.maxclients = 8;
	}
	else
		cls.state = ca_disconnected;

	i = COM_CheckParm("-listen");
	if(i)
	{
		if(cls.state == ca_dedicated)
			Sys_Error("Only one of -dedicated or -listen can be specified");
		if(i != (com_argc - 1))
			svs.maxclients = atoi(com_argv[i + 1]);
		else
			svs.maxclients = 8;
	}
	if(svs.maxclients < 1)
		svs.maxclients = 8;
	else if(svs.maxclients > MAX_SCOREBOARD)
		svs.maxclients = MAX_SCOREBOARD;

	svs.maxclientslimit = svs.maxclients;
	if(svs.maxclientslimit < 4)
		svs.maxclientslimit = 4;
	svs.clients = (struct client_s *) Hunk_AllocName(svs.maxclientslimit * sizeof(client_t), "clients");

	if(svs.maxclients > 1)
		Cvar_SetQuick(&deathmatch, "1");
	else
		Cvar_SetQuick(&deathmatch, "0");
}

static void PrintExeTime(void)
{
	Con_Printf("Compiled on " __DATE__ " " __TIME__ "\n");
}

void Host_Version_f(void)
{
	Con_Printf(ENGINE_NAME " Version " VERSION "\n");
	PrintExeTime();
}

/* cvar callback functions : */
void Host_Callback_Notify(cvar_t *var)
{
	if(sv.active)
		SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, var->string);
}

/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal(void)
{
	Cmd_AddCommand("version", Host_Version_f);

	Host_InitCommands();

	Cvar_RegisterVariable(&host_framerate);
	Cvar_RegisterVariable(&host_speeds);
	Cvar_RegisterVariable(&host_maxfps);  //johnfitz
	Cvar_SetCallback(&host_maxfps, Max_Fps_f);
	Cvar_RegisterVariable(&host_timescale);  //johnfitz

	Cvar_RegisterVariable(&max_edicts);  //johnfitz
	Cvar_SetCallback(&max_edicts, Max_Edicts_f);
	Cvar_RegisterVariable(&devstats);  //johnfitz

	Cvar_RegisterVariable(&sys_ticrate);
	Cvar_RegisterVariable(&sys_throttle);
	Cvar_RegisterVariable(&serverprofile);

	Cvar_RegisterVariable(&fraglimit);
	Cvar_RegisterVariable(&timelimit);
	Cvar_RegisterVariable(&teamplay);
	Cvar_SetCallback(&fraglimit, Host_Callback_Notify);
	Cvar_SetCallback(&timelimit, Host_Callback_Notify);
	Cvar_SetCallback(&teamplay, Host_Callback_Notify);
	Cvar_RegisterVariable(&samelevel);
	Cvar_RegisterVariable(&noexit);
	Cvar_SetCallback(&noexit, Host_Callback_Notify);
	Cvar_RegisterVariable(&skill);
	Cvar_RegisterVariable(&developer);
	Cvar_RegisterVariable(&coop);
	Cvar_RegisterVariable(&deathmatch);

	Cvar_RegisterVariable(&pausable);

	Host_FindMaxClients();
}


/*
===============
Host_WriteConfiguration

Writes key bindings and archived cvars to config.cfg
===============
*/
void Host_WriteConfiguration(void)
{
	FILE    *f;

// dedicated servers initialize the host but don't parse and set the
// config.cfg cvars
	if(host_initialized && !isDedicated && !host_parms->errstate)
	{
		f = fopen(va("%s/config.cfg", com_gamedir), "w");
		if(!f)
		{
			Con_Printf("Couldn't write config.cfg.\n");
			return;
		}

		//VID_SyncCvars (); //johnfitz -- write actual current mode to config file, in case cvars were messed with

		Key_WriteBindings(f);
		Cvar_WriteVariables(f);

		//johnfitz -- extra commands to preserve state
		fprintf(f, "vid_restart\n");
		if(in_mlook.state & 1) fprintf(f, "+mlook\n");
		//johnfitz

		fclose(f);
	}
}


/*
=================
SV_ClientPrintf

Sends text across to be displayed
FIXME: make this just a stuffed echo?
=================
*/
void SV_ClientPrintf(const char *fmt, ...)
{
	va_list         argptr;
	char            string[1024];

	va_start(argptr, fmt);
	q_vsnprintf(string, sizeof(string), fmt, argptr);
	va_end(argptr);

	MSG_WriteByte(&host_client->message, svc_print);
	MSG_WriteString(&host_client->message, string);
}

/*
=================
SV_BroadcastPrintf

Sends text to all active clients
=================
*/
void SV_BroadcastPrintf(const char *fmt, ...)
{
	va_list         argptr;
	char            string[1024];
	int32_t                 i;

	va_start(argptr, fmt);
	q_vsnprintf(string, sizeof(string), fmt, argptr);
	va_end(argptr);

	for(i = 0; i < svs.maxclients; i++)
	{
		if(svs.clients[i].active && svs.clients[i].spawned)
		{
			MSG_WriteByte(&svs.clients[i].message, svc_print);
			MSG_WriteString(&svs.clients[i].message, string);
		}
	}
}

/*
=================
Host_ClientCommands

Send text over to the client to be executed
=================
*/
void Host_ClientCommands(const char *fmt, ...)
{
	va_list         argptr;
	char            string[1024];

	va_start(argptr, fmt);
	q_vsnprintf(string, sizeof(string), fmt, argptr);
	va_end(argptr);

	MSG_WriteByte(&host_client->message, svc_stufftext);
	MSG_WriteString(&host_client->message, string);
}

/*
=====================
SV_DropClient

Called when the player is getting totally kicked off the host
if (crash = true), don't bother sending signofs
=====================
*/
void SV_DropClient(bool crash)
{
	int32_t         saveSelf;
	int32_t         i;
	client_t *client;

	if(!crash)
	{
		// send any final messages (don't check for errors)
		if(NET_CanSendMessage(host_client->netconnection))
		{
			MSG_WriteByte(&host_client->message, svc_disconnect);
			NET_SendMessage(host_client->netconnection, &host_client->message);
		}

		if(host_client->edict && host_client->spawned)
		{
			// call the prog function for removing a client
			// this will set the body to a dead frame, among other things
			saveSelf = G_PEdict(GBL_self);
			G_PEdict(GBL_self) = EdictProg(host_client->edict);
			PR_ExecuteProgram(G_Func(GBL_ClientDisconnect));
			G_PEdict(GBL_self) = saveSelf;
		}

		Sys_Printf("Client %s removed\n", host_client->name);
	}

// break the net connection
	NET_Close(host_client->netconnection);
	host_client->netconnection = NULL;

// free the client (the body stays around)
	host_client->active = false;
	host_client->name[0] = 0;
	host_client->old_frags = -999999;
	net_activeconnections--;

// send notification to all clients
	for(i = 0, client = svs.clients; i < svs.maxclients; i++, client++)
	{
		if(!client->active)
			continue;
		MSG_WriteByte(&client->message, svc_updatename);
		MSG_WriteByte(&client->message, host_client - svs.clients);
		MSG_WriteString(&client->message, "");
		MSG_WriteByte(&client->message, svc_updatefrags);
		MSG_WriteByte(&client->message, host_client - svs.clients);
		MSG_WriteShort(&client->message, 0);
		MSG_WriteByte(&client->message, svc_updatecolors);
		MSG_WriteByte(&client->message, host_client - svs.clients);
		MSG_WriteByte(&client->message, 0);
	}
}

/*
==================
Host_ShutdownServer

This only happens at the end of a game, not between levels
==================
*/
void Host_ShutdownServer(bool crash)
{
	int32_t         i;
	int32_t         count;
	sizebuf_t       buf;
	byte            message[4];
	double  start;

	if(!sv.active)
		return;

	sv.active = false;

// stop all client sounds immediately
	if(cls.state == ca_connected)
		CL_Disconnect();

// flush any pending messages - like the score!!!
	start = Sys_DoubleTime();
	do
	{
		count = 0;
		for(i = 0, host_client = svs.clients ; i < svs.maxclients ; i++, host_client++)
		{
			if(host_client->active && host_client->message.cursize)
			{
				if(NET_CanSendMessage(host_client->netconnection))
				{
					NET_SendMessage(host_client->netconnection, &host_client->message);
					SZ_Clear(&host_client->message);
				}
				else
				{
					NET_GetMessage(host_client->netconnection);
					count++;
				}
			}
		}
		if((Sys_DoubleTime() - start) > 3.0)
			break;
	}
	while(count);

// make sure all the clients know we're disconnecting
	buf.data = message;
	buf.maxsize = 4;
	buf.cursize = 0;
	MSG_WriteByte(&buf, svc_disconnect);
	count = NET_SendToAll(&buf, 5.0);
	if(count)
		Con_Printf("Host_ShutdownServer: NET_SendToAll failed for %" PRIu32 " clients\n", count);

	for(i = 0, host_client = svs.clients; i < svs.maxclients; i++, host_client++)
		if(host_client->active)
			SV_DropClient(crash);

//
// clear structures
//
//	memset (&sv, 0, sizeof(sv)); // ServerSpawn already do this by Host_ClearMemory
	memset(svs.clients, 0, svs.maxclientslimit * sizeof(client_t));
}


/*
================
Host_ClearMemory

This clears all the memory used by both the client and server, but does
not reinitialize anything.
================
*/
void Host_ClearMemory(void)
{
	Con_DPrintf("Clearing memory\n");
	D_FlushCaches();
	Mod_ClearAll();
	/* host_hunklevel MUST be set at this point */
	Hunk_FreeToLowMark(host_hunklevel);
	cls.signon = 0;
	free(sv.edicts); // ericw -- sv.edicts switched to use malloc()
	memset(&sv, 0, sizeof(sv));
	memset(&cl, 0, sizeof(cl));
}


//==============================================================================
//
// Host Frame
//
//==============================================================================

/*
===================
Host_FilterTime

Returns false if the time is too short to run a frame
===================
*/
bool Host_FilterTime(float time)
{
	float maxfps; //johnfitz

	realtime += time;

	//johnfitz -- max fps cvar
	maxfps = CLAMP(10.0, host_maxfps.value, 1000.0);
	if(!cls.timedemo && realtime - oldrealtime < 1.0 / maxfps)
		return false; // framerate is too high
	//johnfitz

	host_frametime = realtime - oldrealtime;
	oldrealtime = realtime;

	//johnfitz -- host_timescale is more intuitive than host_framerate
	if(host_timescale.value > 0)
		host_frametime *= host_timescale.value;
	//johnfitz
	else if(host_framerate.value > 0)
		host_frametime = host_framerate.value;
	else // don't allow really long or short frames
		host_frametime = CLAMP(0.001, host_frametime, 0.1);  //johnfitz -- use CLAMP

	return true;
}

/*
===================
Host_GetConsoleCommands

Add them exactly as if they had been typed at the console
===================
*/
void Host_GetConsoleCommands(void)
{
	const char      *cmd;

	if(!isDedicated)
		return; // no stdin necessary in graphical mode

	while(1)
	{
		cmd = Sys_ConsoleInput();
		if(!cmd)
			break;
		Cbuf_AddText(cmd);
	}
}

/*
==================
Host_ServerFrame
==================
*/
void Host_ServerFrame(void)
{
	int32_t         i, active; //johnfitz
	edict_t *ent; //johnfitz

// run the world state
	G_Float(GBL_frametime) = host_frametime;

// set the time and clear the general datagram
	SV_ClearDatagram();

// check for new clients
	SV_CheckForNewClients();

// read client messages
	SV_RunClients();

// move things around and think
// always pause in single player if in console or menus
	if(!sv.paused && (svs.maxclients > 1 || key_dest == key_game))
		SV_Physics();

//johnfitz -- devstats
	if(cls.signon == SIGNONS)
	{
		for(i = 0, active = 0; i < sv.num_edicts; i++)
		{
			ent = EdictNum(i);
			if(!ent->free)
				active++;
		}
		if(active > 600 && dev_peakstats.edicts <= 600)
			Con_DWarning("%" PRIi32 " edicts exceeds standard limit of 600 (max = %" PRIi32 ").\n", active, sv.max_edicts);
		dev_stats.edicts = active;
		dev_peakstats.edicts = q_max(active, dev_peakstats.edicts);
	}
//johnfitz

// send all messages to the clients
	SV_SendClientMessages();
}

/*
==================
Host_Frame

Runs all active servers
==================
*/
static void Host_FrameT(float time)
{
	static double           time1 = 0;
	static double           time2 = 0;
	static double           time3 = 0;
	int32_t                 pass1, pass2, pass3;

	if(setjmp(host_abortserver))
		return;                 // something bad happened, or the server disconnected

// keep the random time dependent
	rand();

// decide the simulation time
	if(!Host_FilterTime(time))
		return;                 // don't run too fast, or packets will flood out

// get new key events
	Key_UpdateForDest();
	IN_UpdateInputMode();
	Sys_SendKeyEvents();

// allow mice or other external controllers to add commands
	IN_Commands();

// process console commands
	Cbuf_Execute();

	NET_Poll();

// if running the server locally, make intentions now
	if(sv.active)
		CL_SendCmd();

//-------------------
//
// server operations
//
//-------------------

// check for commands typed to the host
	Host_GetConsoleCommands();

	if(sv.active)
		Host_ServerFrame();

//-------------------
//
// client operations
//
//-------------------

// if running the server remotely, send intentions now after
// the incoming messages have been read
	if(!sv.active)
		CL_SendCmd();

// fetch results from server
	if(cls.state == ca_connected)
		CL_ReadFromServer();

// update video
	if(host_speeds.value)
		time1 = Sys_DoubleTime();

	SCR_UpdateScreen();

	CL_RunParticles();  //johnfitz -- seperated from rendering

	if(host_speeds.value)
		time2 = Sys_DoubleTime();

// update audio
	BGM_Update();   // adds music raw samples and/or advances midi driver
	if(cls.signon == SIGNONS)
	{
		S_Update(r_origin, vpn, vright, vup);
		CL_DecayLights();
	}
	else
		S_Update(vec3_origin, vec3_origin, vec3_origin, vec3_origin);

	if(host_speeds.value)
	{
		pass1 = (time1 - time3) * 1000;
		time3 = Sys_DoubleTime();
		pass2 = (time2 - time1) * 1000;
		pass3 = (time3 - time2) * 1000;
		Con_Printf("%3" PRIi32 " tot %3" PRIi32 " server %3" PRIi32 " gfx %3" PRIi32 " snd\n",
		           pass1 + pass2 + pass3, pass1, pass2, pass3);
	}

	host_framecount++;

}

void Host_Frame(float time)
{
	double  time1, time2;
	static double   timetotal;
	static int32_t          timecount;
	int32_t         i, c, m;

	if(!serverprofile.value)
	{
		Host_FrameT(time);
		return;
	}

	time1 = Sys_DoubleTime();
	Host_FrameT(time);
	time2 = Sys_DoubleTime();

	timetotal += time2 - time1;
	timecount++;

	if(timecount < 1000)
		return;

	m = timetotal * 1000 / timecount;
	timecount = 0;
	timetotal = 0;
	c = 0;
	for(i = 0; i < svs.maxclients; i++)
	{
		if(svs.clients[i].active)
			c++;
	}

	Con_Printf("serverprofile: %2" PRIi32 " clients %2" PRIi32 " msec\n",  c,  m);
}

/*
====================
Host_Init
====================
*/
void Host_Init(void)
{
	int32_t minimum_memory;

	if(standard_quake)
		minimum_memory = MINIMUM_MEMORY;
	else
		minimum_memory = MINIMUM_MEMORY_LEVELPAK;

	if(COM_CheckParm("-minmemory"))
		host_parms->memsize = minimum_memory;

	if(host_parms->memsize < minimum_memory)
		Sys_Error("Only %4.1f MiB of memory available, can't execute game", host_parms->memsize / (float)0x100000);

	com_argc = host_parms->argc;
	com_argv = host_parms->argv;

	Memory_Init(host_parms->membase, host_parms->memsize);
	Cbuf_Init();
	Cmd_Init();
	LOG_Init(host_parms);
	Cvar_Init();  //johnfitz
	COM_InitFilesystem();
	Host_InitLocal();
	W_LoadWadFile();  //johnfitz -- filename is now hard-coded for honesty
	if(cls.state != ca_dedicated)
	{
		Key_Init();
		Con_Init();
	}
	PR_Init();
	Mod_Init();
	NET_Init();
	SV_Init();

	PrintExeTime();
	Con_Printf("%4.1f megabyte heap\n", host_parms->memsize / (1024 * 1024.0));

	if(cls.state != ca_dedicated)
	{
		host_colormap = (byte *)COM_LoadHunkFile("gfx/colormap.lmp", NULL);
		if(!host_colormap)
			Sys_Error("Couldn't load gfx/colormap.lmp");

		V_Init();
		Chase_Init();
		M_Init();
		ExtraMaps_Init();  //johnfitz
		Modlist_Init();  //johnfitz
		DemoList_Init();  //ericw
		VID_Init();
		IN_Init();
		TexMgr_Init();  //johnfitz
		Draw_Init();
		SCR_Init();
		R_Init();
		S_Init();
		BGM_Init();
		Sbar_Init();
		CL_Init();
	}

	Hunk_AllocName(0, "-HOST_HUNKLEVEL-");
	host_hunklevel = Hunk_LowMark();

	host_initialized = true;

	if(cls.state != ca_dedicated)
	{
		Cbuf_InsertText("exec quake.rc\n");
		// johnfitz -- in case the vid mode was locked during vid_init, we can unlock it now.
		// note: two leading newlines because the command buffer swallows one of them.
		Cbuf_AddText("\n\nvid_unlock\n");
	}

	if(cls.state == ca_dedicated)
	{
		Cbuf_AddText("exec autoexec.cfg\n");
		Cbuf_AddText("stuffcmds");
		Cbuf_Execute();
		if(!sv.active)
			Cbuf_AddText("map start\n");
	}
}


/*
===============
Host_Shutdown

FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
to run quit through here before the final handoff to the sys code.
===============
*/
void Host_Shutdown(void)
{
	static bool isdown = false;

	if(isdown)
	{
		printf("recursive shutdown\n");
		return;
	}
	isdown = true;

// keep Con_Printf from trying to update the screen
	scr_disabled_for_loading = true;

	Host_WriteConfiguration();

	NET_Shutdown();

	if(cls.state != ca_dedicated)
	{
		if(con_initialized)
			History_Shutdown();
		BGM_Shutdown();
		S_Shutdown();
		IN_Shutdown();
		VID_Shutdown();
	}

	LOG_Close();
}