ref: d0cba51c9e5c3486797d2b17c5b27b7d54628b63
dir: /host.c/
#include "quakedef.h"
/*
A server can always 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.
*/
int dedicated;
bool host_initialized; // true if into command execution
double host_frametime;
double host_time;
double realtime; // without any filtering or bounding
int host_framecount;
static double oldrealtime; // last frame run
static void *host_hunklevel;
client_t *host_client; // current client
jmp_buf host_abortserver;
byte *host_basepal;
byte *host_colormap;
static cvar_t host_framerate = {"host_framerate","0"}; // set for slow motion
static cvar_t host_speeds = {"host_speeds","0"}; // set for running times
static cvar_t serverprofile = {"serverprofile","0"};
static cvar_t samelevel = {"samelevel","0"};
static cvar_t noexit = {"noexit","0",false,true};
static cvar_t temp1 = {"temp1","0"};
cvar_t sys_ticrate = {"sys_ticrate","0.05"};
cvar_t fraglimit = {"fraglimit","0",false,true};
cvar_t timelimit = {"timelimit","0",false,true};
cvar_t teamplay = {"teamplay","0",false,true};
cvar_t skill = {"skill","1"}; // 0 - 3
cvar_t deathmatch = {"deathmatch","0"}; // 0, 1, or 2
cvar_t coop = {"coop","0"}; // 0 or 1
cvar_t pausable = {"pausable","1"};
/*
================
Host_EndGame
================
*/
void Host_EndGame (char *fmt, ...)
{
va_list arg;
char s[1024];
va_start(arg, fmt);
vsnprint(s, sizeof s, fmt, arg);
va_end(arg);
Con_DPrintf("Host_EndGame: %s\n", s);
if(sv.active)
Host_ShutdownServer(false);
if(cls.state == ca_dedicated)
fatal("Host_EndGame: %s\n", s); // 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
================
*/
_Noreturn void
Host_Error (char *fmt, ...)
{
va_list arg;
char s[1024];
static bool inerror = false;
va_start(arg, fmt);
vsnprint(s, sizeof s, fmt, arg);
va_end(arg);
if(inerror){
assert(nil);
fatal("Host_Error: recursively entered: %s", s);
}
inerror = true;
SCR_EndLoadingPlaque(); // reenable screen updates
Con_Printf("Host_Error: %s\n", s);
if(sv.active)
Host_ShutdownServer(false);
if(cls.state == ca_dedicated)
fatal("Host_Error: %s\n", s); // dedicated servers exit
CL_Disconnect();
cls.demonum = -1;
inerror = false;
longjmp(host_abortserver, 1);
}
/*
================
Host_FindMaxClients
================
*/
void Host_FindMaxClients (void)
{
svs.maxclients = 1;
cls.state = ca_disconnected;
if(dedicated){
cls.state = ca_dedicated;
svs.maxclients = MAX_SCOREBOARD;
}
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 = Hunk_Alloc(svs.maxclientslimit * sizeof *svs.clients);
if (svs.maxclients > 1)
setcvarv ("deathmatch", 1.0);
else
setcvarv ("deathmatch", 0.0);
}
/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal (void)
{
Host_InitCommands ();
Cvar_RegisterVariable (&host_framerate);
Cvar_RegisterVariable (&host_speeds);
Cvar_RegisterVariable (&sys_ticrate);
Cvar_RegisterVariable (&serverprofile);
Cvar_RegisterVariable (&fraglimit);
Cvar_RegisterVariable (&timelimit);
Cvar_RegisterVariable (&teamplay);
Cvar_RegisterVariable (&samelevel);
Cvar_RegisterVariable (&noexit);
Cvar_RegisterVariable (&skill);
Cvar_RegisterVariable (&deathmatch);
Cvar_RegisterVariable (&coop);
Cvar_RegisterVariable (&pausable);
Cvar_RegisterVariable (&temp1);
Host_FindMaxClients ();
host_time = 1.0; // so a think at time 0 won't get called
}
/*
=================
SV_ClientPrintf
Sends text across to be displayed
FIXME: make this just a stuffed echo?
=================
*/
void SV_ClientPrintf (char *fmt, ...)
{
va_list arg;
char s[1024];
va_start(arg, fmt);
vsnprint(s, sizeof s, fmt, arg);
va_end(arg);
MSG_WriteByte(&host_client->message, svc_print);
MSG_WriteString(&host_client->message, s);
}
/*
=================
SV_BroadcastPrintf
Sends text to all active clients
=================
*/
void SV_BroadcastPrintf (char *fmt, ...)
{
va_list arg;
char s[1024];
int i;
va_start(arg, fmt);
vsnprint(s, sizeof s, fmt, arg);
va_end(arg);
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, s);
}
}
/*
=================
Host_ClientCommands
Send text over to the client to be executed
=================
*/
void Host_ClientCommands (char *fmt, ...)
{
va_list arg;
char s[1024];
va_start(arg, fmt);
vsnprint(s, sizeof s, fmt, arg);
va_end(arg);
MSG_WriteByte(&host_client->message, svc_stufftext);
MSG_WriteString(&host_client->message, s);
}
/*
=====================
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)
{
int saveSelf;
int 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 = sv.pr->global_struct->self;
sv.pr->global_struct->self = EDICT_TO_PROG(sv.pr, host_client->edict);
PR_ExecuteProgram(sv.pr, sv.pr->global_struct->ClientDisconnect);
sv.pr->global_struct->self = saveSelf;
}
Con_DPrintf("client %s removed\n", host_client->name);
}
// break the net connection
NET_Close (host_client->netconnection);
host_client->netconnection = nil;
// free the client (the body stays around)
host_client->active = false;
host_client->name[0] = 0;
host_client->old_frags = Q_MININT;
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)
{
int i;
int count;
sizebuf_t buf;
char message[4];
double start;
if (!sv.active)
return;
UDP_Listen(0);
sv.active = false;
// stop all client sounds immediately
if (cls.state == ca_connected)
CL_Disconnect ();
// flush any pending messages - like the score!!!
start = dtime();
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 ((dtime() - start) > 3.0f)
break;
}
while (count);
// make sure all the clients know we're disconnecting
buf.data = (uchar *)message;
buf.maxsize = 4;
buf.cursize = 0;
MSG_WriteByte(&buf, svc_disconnect);
count = NET_SendToAll(&buf, 5);
if (count)
Con_Printf("Host_ShutdownServer: NET_SendToAll failed for %d 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);
memset(svs.clients, 0, svs.maxclientslimit * sizeof *svs.clients);
}
/*
================
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 ();
if (host_hunklevel)
Hunk_FreeToMark (host_hunklevel);
cls.signon = 0;
memset(&sv, 0, sizeof sv);
memset(&cl, 0, sizeof cl);
}
/*
==================
Host_ServerFrame
==================
*/
void Host_ServerFrame (void)
{
// run the world state
sv.pr->global_struct->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 ();
// send all messages to the clients
SV_SendClientMessages ();
}
static int
boundfps(float t)
{
realtime += t;
if(!cls.timedemo && realtime - oldrealtime < 1.0 / Fpsmax)
return -1;
host_frametime = realtime - oldrealtime;
oldrealtime = realtime;
if(host_framerate.value > 0)
host_frametime = host_framerate.value;
else if(host_frametime > 1.0 / Fpsmin)
host_frametime = 1.0 / Fpsmin;
return 0;
}
void _Host_Frame (float time)
{
static double time1 = 0;
static double time2 = 0;
static double time3 = 0;
int pass1, pass2, pass3;
if (setjmp (host_abortserver) )
return; // something bad happened, or the server disconnected
// keep the random time dependent
rand ();
if(boundfps(time) < 0)
return;
// get new key events
Sys_SendKeyEvents ();
// allow mice or other external controllers to add commands
IN_Commands ();
// process console commands
Cbuf_Execute ();
// if running the server locally, make intentions now
if (sv.active)
CL_SendCmd ();
//-------------------
//
// server operations
//
//-------------------
// check for commands typed to the host
conscmd();
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 ();
host_time += host_frametime;
// fetch results from server
if (cls.state == ca_connected)
{
CL_ReadFromServer ();
}
// update video
if (host_speeds.value)
time1 = dtime ();
SCR_UpdateScreen (false);
if (host_speeds.value)
time2 = dtime ();
// update audio
if (cls.signon == SIGNONS)
{
stepsnd (r_origin, vpn, vright, vup);
CL_DecayLights ();
}
else
stepsnd (vec3_origin, vec3_origin, vec3_origin, vec3_origin);
stepcd();
if (host_speeds.value)
{
pass1 = (time1 - time3)*1000;
time3 = dtime ();
pass2 = (time2 - time1)*1000;
pass3 = (time3 - time2)*1000;
Con_Printf ("%3d tot %3d server %3d gfx %3d snd\n",
pass1+pass2+pass3, pass1, pass2, pass3);
}
host_framecount++;
}
void Host_Frame (float time)
{
double time1, time2;
static double timetotal;
static int timecount;
int i, c, m;
if (!serverprofile.value)
{
_Host_Frame (time);
return;
}
time1 = dtime ();
_Host_Frame (time);
time2 = dtime ();
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: %2d clients %2d msec\n", c, m);
}
/*
====================
Host_Init
====================
*/
void Host_Init (int argc, char **argv, char **paths)
{
int i;
Memory_Init();
Cbuf_Init ();
Cmd_Init ();
V_Init ();
Chase_Init ();
initfs(paths);
Host_InitLocal ();
extern Wad *wad_gfx;
wad_gfx = W_OpenWad("gfx.wad");
Key_Init ();
Con_Init ();
M_Init ();
PR_Init ();
Mod_Init ();
NET_Init ();
SV_Init ();
R_InitTextures (); // needed even for dedicated servers
if (cls.state != ca_dedicated)
{
host_basepal = loadhunklmp("gfx/palette.lmp", nil);
if(host_basepal == nil)
fatal("Host_Init: %s", lerr());
setpal(host_basepal);
host_colormap = loadhunklmp("gfx/colormap.lmp", nil);
if(host_colormap == nil)
fatal("Host_Init: %s", lerr());
initfb();
Draw_Init ();
SCR_Init ();
R_Init ();
if(initsnd() < 0)
Con_DPrintf("initsnd: %s\n", lerr());
if(initcd() < 0)
Con_DPrintf("initcd: %s\n", lerr());
Sbar_Init ();
CL_Init ();
}
IN_Init ();
Cbuf_InsertText ("+mlook\n");
Cbuf_InsertText ("exec quake.rc\n");
host_hunklevel = Hunk_Mark ();
host_initialized = true;
if(argc < 1 || **argv != '+')
return;
for(i = 0; i < argc;){
Cbuf_AddText(argv[i++]+1);
while(i < argc && argv[i][0] != '+'){
Cbuf_AddText(" ");
Cbuf_AddText(argv[i++]);
}
Cbuf_AddText("\n");
}
}
/*
===============
Host_Shutdown
FIXME: this is a callback from shutdown and fatal. 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)
{
Con_DPrintf("Host_Shutdown: recursive shutdown\n");
return;
}
isdown = true;
// keep Con_Printf from trying to update the screen
scr_disabled_for_loading = true;
dumpcfg();
NET_Shutdown ();
shutcd();
sndclose();
IN_Shutdown ();
}