quakeforge/nq/source/host.c

1046 lines
22 KiB
C
Raw Normal View History

/*
host.c
2001-05-09 17:12:49 +00:00
host init
Copyright (C) 1996-1997 Id Software, Inc.
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
static __attribute__ ((used)) const char rcsid[] =
"$Id$";
#include "QF/cbuf.h"
#include "QF/idparse.h"
#include "QF/cdaudio.h"
#include "QF/cmd.h"
#include "QF/console.h"
2001-05-31 03:41:35 +00:00
#include "QF/cvar.h"
2001-05-09 22:40:51 +00:00
#include "QF/draw.h"
2001-05-09 17:12:49 +00:00
#include "QF/input.h"
#include "QF/keys.h"
#include "QF/msg.h"
2001-04-25 00:20:23 +00:00
#include "QF/plugin.h"
#include "QF/progs.h"
#include "QF/qargs.h"
2001-05-09 17:12:49 +00:00
#include "QF/screen.h"
#include "QF/sys.h"
#include "QF/va.h"
#include "QF/vid.h"
#include "QF/gib.h"
2001-05-09 17:12:49 +00:00
#include "buildnum.h"
2001-05-09 17:12:49 +00:00
#include "chase.h"
2001-08-29 02:12:57 +00:00
#include "compat.h"
2001-05-09 17:12:49 +00:00
#include "host.h"
2001-10-28 04:23:37 +00:00
#include "r_dynamic.h"
2001-05-09 17:12:49 +00:00
#include "sbar.h"
#include "server.h"
#include "sv_progs.h"
2001-05-09 17:12:49 +00:00
#include "view.h"
/*
2001-08-29 02:12:57 +00:00
A server can always be started, even if the system started out as a client
to a remote system.
2001-08-29 02:12:57 +00:00
A client can NOT be started if the system started as a dedicated server.
2001-08-29 02:12:57 +00:00
Memory is cleared/released when a server or client begins, not when they end.
*/
SERVER_PLUGIN_PROTOS
static plugin_list_t server_plugin_list[] = {
SERVER_PLUGIN_LIST
};
2002-01-16 21:53:42 +00:00
CLIENT_PLUGIN_PROTOS
static plugin_list_t client_plugin_list[] = {
CLIENT_PLUGIN_LIST
};
2001-08-29 02:12:57 +00:00
qboolean host_initialized; // true if into command execution
quakeparms_t host_parms;
cbuf_t *host_cbuf;
double host_frametime;
double host_time;
double realtime; // without any filtering or bounding
double oldrealtime; // last frame run
2001-08-29 02:12:57 +00:00
double con_frametime;
double con_realtime;
double oldcon_realtime;
int host_framecount;
int host_hunklevel;
int minimum_memory;
client_t *host_client; // current client
jmp_buf host_abortserver;
byte *host_basepal;
cvar_t *fs_globalcfg;
cvar_t *fs_usercfg;
cvar_t *host_mem_size;
cvar_t *host_framerate;
cvar_t *host_speeds;
cvar_t *max_edicts;
cvar_t *sys_ticrate;
cvar_t *serverprofile;
cvar_t *cl_quakerc;
cvar_t *fraglimit;
cvar_t *timelimit;
cvar_t *teamplay;
cvar_t *noexit;
2001-08-29 02:12:57 +00:00
cvar_t *samelevel;
cvar_t *skill;
cvar_t *coop;
2001-08-29 02:12:57 +00:00
cvar_t *deathmatch;
cvar_t *pausable;
cvar_t *temp1;
2001-08-29 02:12:57 +00:00
void
2001-07-15 07:04:17 +00:00
Host_EndGame (const char *message, ...)
{
static dstring_t *str;
2001-08-29 02:12:57 +00:00
va_list argptr;
if (!str)
str = dstring_new ();
va_start (argptr, message);
dvsprintf (str, message, argptr);
va_end (argptr);
Sys_MaskPrintf (SYS_DEV, "Host_EndGame: %s\n", str->str);
if (sv.active)
Host_ShutdownServer (false);
if (cls.state == ca_dedicated)
Sys_Error ("Host_EndGame: %s", str->str); // dedicated servers exit
if (cls.demonum != -1)
CL_NextDemo ();
else
CL_Disconnect ();
longjmp (host_abortserver, 1);
}
/*
2001-05-09 17:12:49 +00:00
Host_Error
2001-05-09 17:12:49 +00:00
This shuts down both the client and server
*/
void
2001-07-15 07:04:17 +00:00
Host_Error (const char *error, ...)
{
static dstring_t *str;
static qboolean inerror = false;
2001-08-29 02:12:57 +00:00
va_list argptr;
if (inerror)
Sys_Error ("Host_Error: recursively entered");
if (!str)
str = dstring_new ();
inerror = true;
// SCR_EndLoadingPlaque (); // reenable screen updates
va_start (argptr, error);
dvsprintf (str, error, argptr);
va_end (argptr);
if (sv.active)
Host_ShutdownServer (false);
if (cls.state == ca_dedicated)
Sys_Error ("Host_Error: %s", str->str); // dedicated servers exit
Sys_Printf ("Host_Error: %s\n", str->str);
CL_Disconnect ();
cls.demonum = -1;
inerror = false;
longjmp (host_abortserver, 1);
}
static void
Host_FindMaxClients (void)
{
int 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 =
Hunk_AllocName (svs.maxclientslimit * sizeof (client_t), "clients");
if (svs.maxclients > 1)
Cvar_SetValue (deathmatch, 1.0);
else
Cvar_SetValue (deathmatch, 0.0);
}
static void
Host_InitLocal (void)
{
Host_InitCommands ();
host_framerate =
Cvar_Get ("host_framerate", "0", CVAR_NONE, NULL,
"set for slow motion");
host_speeds =
Cvar_Get ("host_speeds", "0", CVAR_NONE, NULL,
"set for running times");
max_edicts = Cvar_Get ("max_edicts", "1024", CVAR_NONE, NULL,
"maximum server edicts");
sys_ticrate = Cvar_Get ("sys_ticrate", "0.05", CVAR_NONE, NULL, "None");
serverprofile = Cvar_Get ("serverprofile", "0", CVAR_NONE, NULL, "None");
cl_quakerc = Cvar_Get ("cl_quakerc", "1", CVAR_NONE, NULL,
"exec quake.rc on startup");
2001-08-29 02:12:57 +00:00
fraglimit = Cvar_Get ("fraglimit", "0", CVAR_SERVERINFO, Cvar_Info,
"None");
timelimit = Cvar_Get ("timelimit", "0", CVAR_SERVERINFO, Cvar_Info,
"None");
teamplay = Cvar_Get ("teamplay", "0", CVAR_SERVERINFO, Cvar_Info, "None");
samelevel = Cvar_Get ("samelevel", "0", CVAR_NONE, NULL, "None");
noexit = Cvar_Get ("noexit", "0", CVAR_SERVERINFO, Cvar_Info, "None");
skill = Cvar_Get ("skill", "1", CVAR_NONE, NULL, "0 - 3");
deathmatch = Cvar_Get ("deathmatch", "0", CVAR_NONE, NULL, "0, 1, or 2");
coop = Cvar_Get ("coop", "0", CVAR_NONE, NULL, "0 or 1");
pausable = Cvar_Get ("pausable", "1", CVAR_NONE, NULL, "None");
temp1 = Cvar_Get ("temp1", "0", CVAR_NONE, NULL, "None");
Host_FindMaxClients ();
host_time = 1.0; // so a think at time 0 won't get called
}
/*
2001-05-09 17:12:49 +00:00
Host_WriteConfiguration
2001-05-09 17:12:49 +00:00
Writes key bindings and archived cvars to config.cfg
*/
static void
Host_WriteConfiguration (void)
{
QFile *f;
2001-08-29 02:12:57 +00:00
// dedicated servers initialize the host but don't parse and set the
// config.cfg cvars
if (host_initialized && !isDedicated && cl_writecfg->int_val) {
2003-02-14 22:36:10 +00:00
char *path = va ("%s/config.cfg", qfs_gamedir->dir.def);
f = QFS_WOpen (path, 0);
if (!f) {
Sys_Printf ("Couldn't write config.cfg.\n");
return;
}
Key_WriteBindings (f);
Cvar_WriteVariables (f);
Qclose (f);
}
}
/*
2001-05-09 17:12:49 +00:00
SV_ClientPrintf
2001-05-09 17:12:49 +00:00
Sends text across to be displayed
*/
void
2001-07-15 07:04:17 +00:00
SV_ClientPrintf (const char *fmt, ...)
{
static dstring_t *str;
2001-08-29 02:12:57 +00:00
va_list argptr;
if (!str)
str = dstring_new ();
va_start (argptr, fmt);
dvsprintf (str, fmt, argptr);
va_end (argptr);
MSG_WriteByte (&host_client->message, svc_print);
MSG_WriteString (&host_client->message, str->str);
}
/*
2001-05-09 17:12:49 +00:00
SV_BroadcastPrintf
2001-05-09 17:12:49 +00:00
Sends text to all active clients
*/
void
2001-07-15 07:04:17 +00:00
SV_BroadcastPrintf (const char *fmt, ...)
{
static dstring_t *str;
int i;
2001-08-29 02:12:57 +00:00
va_list argptr;
if (!str)
str = dstring_new ();
va_start (argptr, fmt);
dvsprintf (str, 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, str->str);
}
}
/*
2001-05-09 17:12:49 +00:00
Host_ClientCommands
2001-05-09 17:12:49 +00:00
Send text over to the client to be executed
*/
void
2001-07-15 07:04:17 +00:00
Host_ClientCommands (const char *fmt, ...)
{
static dstring_t *str;
2001-08-29 02:12:57 +00:00
va_list argptr;
if (!str)
str = dstring_new ();
va_start (argptr, fmt);
dvsprintf (str, fmt, argptr);
va_end (argptr);
MSG_WriteByte (&host_client->message, svc_stufftext);
MSG_WriteString (&host_client->message, str->str);
}
/*
2001-05-09 17:12:49 +00:00
SV_DropClient
2001-05-09 17:12:49 +00:00
Called when the player is getting totally kicked off the host
if (crash = true), don't bother sending signofs
*/
void
SV_DropClient (qboolean crash)
{
client_t *client;
2001-08-29 02:12:57 +00:00
int saveSelf, i;
if (!crash) {
// send any final messages (don't check for errors)
if (NET_CanSendMessage (host_client->netconnection)) {
MSG_WriteByte (&host_client->message, svc_disconnect);
2001-08-29 02:12:57 +00:00
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_globals.self;
*sv_globals.self =
EDICT_TO_PROG (&sv_pr_state, host_client->edict);
PR_ExecuteProgram (&sv_pr_state, sv_funcs.ClientDisconnect);
*sv_globals.self = saveSelf;
}
Sys_Printf ("Client %s removed\n", host_client->name);
}
2001-08-29 02:12:57 +00:00
// break the net connection
NET_Close (host_client->netconnection);
host_client->netconnection = NULL;
2001-08-29 02:12:57 +00:00
// free the client (the body stays around)
host_client->active = false;
host_client->name[0] = 0;
host_client->old_frags = -999999;
net_activeconnections--;
2001-08-29 02:12:57 +00:00
// 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);
}
}
/*
2001-05-09 17:12:49 +00:00
Host_ShutdownServer
This happens only at the end of a game, not between levels
*/
void
Host_ShutdownServer (qboolean crash)
{
byte message[4];
double start;
2001-08-29 02:12:57 +00:00
int count, i;
sizebuf_t buf;
if (!sv.active)
return;
sv.active = false;
2001-08-29 02:12:57 +00:00
// stop all client sounds immediately
if (cls.state == ca_connected)
CL_Disconnect ();
2001-08-29 02:12:57 +00:00
// 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);
2001-08-29 02:12:57 +00:00
// 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)
Sys_Printf
("Host_ShutdownServer: NET_SendToAll failed for %u clients\n",
count);
for (i = 0, host_client = svs.clients; i < svs.maxclients;
i++, host_client++)
if (host_client->active)
SV_DropClient (crash);
2001-08-29 02:12:57 +00:00
// clear structures
memset (&sv, 0, sizeof (sv));
memset (svs.clients, 0, svs.maxclientslimit * sizeof (client_t));
}
/*
2001-05-09 17:12:49 +00:00
Host_ClearMemory
2001-05-09 17:12:49 +00:00
This clears all the memory used by both the client and server, but does
not reinitialize anything.
*/
void
Host_ClearMemory (void)
{
Sys_MaskPrintf (SYS_DEV, "Clearing memory\n");
D_FlushCaches ();
Mod_ClearAll ();
if (host_hunklevel)
Hunk_FreeToLowMark (host_hunklevel);
cls.signon = 0;
memset (&sv, 0, sizeof (sv));
memset (&cl, 0, sizeof (cl));
r_force_fullscreen = 0;
}
/*
2001-05-09 17:12:49 +00:00
Host_FilterTime
2001-05-09 17:12:49 +00:00
Returns false if the time is too short to run a frame
*/
static qboolean
Host_FilterTime (float time)
{
float timedifference;
2001-09-06 04:35:02 +00:00
float timescale = 1.0;
con_realtime += time;
2001-09-06 04:35:02 +00:00
if (cls.demoplayback) {
timescale = max (0, demo_speed->value);
2001-09-06 04:35:02 +00:00
time *= timescale;
}
realtime += time;
//FIXME not having the framerate cap is nice, but it breaks net play
timedifference = (timescale / 72.0) - (realtime - oldrealtime);
if (!cls.timedemo && (timedifference > 0))
return false; // framerate is too high
host_frametime = realtime - oldrealtime;
oldrealtime = realtime;
con_frametime = con_realtime - oldcon_realtime;
oldcon_realtime = con_realtime;
if (host_framerate->value > 0)
host_frametime = host_framerate->value;
else // don't allow really long or short frames
host_frametime = bound (0.001, host_frametime, 0.1);
return true;
}
void
Host_ServerFrame (void)
{
*sv_globals.frametime = host_frametime;
2001-08-29 02:12:57 +00:00
// set the time and clear the general datagram
SV_ClearDatagram ();
SV_CheckForNewClients ();
2001-08-29 02:12:57 +00:00
// read client messages
SV_RunClients ();
2001-08-29 02:12:57 +00:00
// 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 ();
sv.time += host_frametime;
}
2001-08-29 02:12:57 +00:00
// send all messages to the clients
SV_SendClientMessages ();
}
static void
Host_ClientFrame (void)
{
2001-08-29 02:12:57 +00:00
static double time1 = 0, time2 = 0, time3 = 0;
int pass1, pass2, pass3;
2001-08-29 02:12:57 +00:00
// if running the server remotely, send intentions now after
// the incoming messages have been read
if (!sv.active)
CL_SendCmd ();
host_time += host_frametime;
2001-08-29 02:12:57 +00:00
// fetch results from server
if (cls.state == ca_connected)
CL_ReadFromServer ();
2001-08-29 02:12:57 +00:00
// update video
if (host_speeds->int_val)
time1 = Sys_DoubleTime ();
r_inhibit_viewmodel = (chase_active->int_val
|| (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
|| cl.stats[STAT_HEALTH] <= 0);
r_frametime = host_frametime;
CL_UpdateScreen (cl.time);
if (host_speeds->int_val)
time2 = Sys_DoubleTime ();
2001-08-29 02:12:57 +00:00
// update audio
if (cls.signon == SIGNONS) {
S_Update (r_origin, vpn, vright, vup);
R_DecayLights (host_frametime);
} else
S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);
CDAudio_Update ();
if (host_speeds->int_val) {
pass1 = (time1 - time3) * 1000;
time3 = Sys_DoubleTime ();
pass2 = (time2 - time1) * 1000;
pass3 = (time3 - time2) * 1000;
Sys_Printf ("%3i tot %3i server %3i gfx %3i snd\n",
pass1 + pass2 + pass3, pass1, pass2, pass3);
}
}
/*
Host_Frame
Runs all active servers
*/
static void
_Host_Frame (float time)
{
static int first = 1;
if (setjmp (host_abortserver))
return; // something bad happened, or the
// server disconnected
rand (); // keep the random time dependent
// decide the simulation time
if (!Host_FilterTime (time))
return; // don't run too fast, or packets
// will flood out
if (cls.state != ca_dedicated)
IN_ProcessEvents ();
if (cls.state == ca_dedicated)
Con_ProcessInput ();
GIB_Thread_Execute ();
cmd_source = src_command;
Cbuf_Execute_Stack (host_cbuf);
if (first) {
first = 0;
if (isDedicated) {
if (!sv.active)
Cmd_ExecuteString ("map start", src_command);
if (!sv.active)
Sys_Error ("Could not initialize server");
} else {
Con_NewMap ();
}
CL_UpdateScreen (cl.time);
}
NET_Poll ();
if (sv.active) {
CL_SendCmd ();
Host_ServerFrame ();
}
if (cls.state != ca_dedicated)
Host_ClientFrame ();
else
host_time += host_frametime; //FIXME is this needed? vcr stuff
host_framecount++;
fps_count++;
}
void
Host_Frame (float time)
{
2001-08-29 02:12:57 +00:00
double time1, time2;
static double timetotal;
2001-08-29 02:12:57 +00:00
int i, c, m;
static int timecount;
if (!serverprofile->int_val) {
_Host_Frame (time);
return;
}
time1 = Sys_DoubleTime ();
_Host_Frame (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++;
}
Sys_Printf ("serverprofile: %2i clients %2i msec\n", c, m);
}
#define VCR_SIGNATURE 0x56435231
// "VCR1"
static void
Host_InitVCR (quakeparms_t *parms)
{
char *p;
2001-08-29 02:12:57 +00:00
int i, len, n;
if (COM_CheckParm ("-playback")) {
if (com_argc != 2)
Sys_Error ("No other parameters allowed with -playback");
vcrFile = QFS_Open ("quake.vcr", "rbz");
if (!vcrFile)
Sys_Error ("playback file not found");
Qread (vcrFile, &i, sizeof (int));
if (i != VCR_SIGNATURE)
Sys_Error ("Invalid signature in vcr file");
Qread (vcrFile, &com_argc, sizeof (int));
com_argv = malloc (com_argc * sizeof (char *));
2002-05-14 06:37:28 +00:00
SYS_CHECKMEM (com_argv);
com_argv[0] = parms->argv[0];
for (i = 0; i < com_argc; i++) {
Qread (vcrFile, &len, sizeof (int));
p = malloc (len);
2002-05-14 06:37:28 +00:00
SYS_CHECKMEM (p);
Qread (vcrFile, p, len);
com_argv[i + 1] = p;
}
com_argc++; /* add one for arg[0] */
parms->argc = com_argc;
parms->argv = com_argv;
}
if ((n = COM_CheckParm ("-record")) != 0) {
vcrFile = QFS_Open ("quake.vcr", "wb");
i = VCR_SIGNATURE;
Qwrite (vcrFile, &i, sizeof (int));
i = com_argc - 1;
Qwrite (vcrFile, &i, sizeof (int));
for (i = 1; i < com_argc; i++) {
if (i == n) {
len = 10;
Qwrite (vcrFile, &len, sizeof (int));
Qwrite (vcrFile, "-playback", len);
continue;
}
len = strlen (com_argv[i]) + 1;
Qwrite (vcrFile, &len, sizeof (int));
Qwrite (vcrFile, com_argv[i], len);
}
}
}
static int
check_quakerc (void)
{
2001-07-15 07:04:17 +00:00
const char *l, *p;
int ret = 1;
QFile *f;
QFS_FOpenFile ("quake.rc", &f);
if (!f)
return 1;
while ((l = Qgetline (f))) {
if ((p = strstr (l, "stuffcmds"))) {
if (p == l) { // only known case so far
ret = 0;
break;
}
}
}
Qclose (f);
return ret;
}
static void
CL_Init_Memory (void)
{
int mem_parm = COM_CheckParm ("-mem");
int mem_size;
void *mem_base;
if (standard_quake)
minimum_memory = MINIMUM_MEMORY;
else
minimum_memory = MINIMUM_MEMORY_LEVELPAK;
2009-12-20 05:34:41 +00:00
host_mem_size = Cvar_Get ("host_mem_size", "32", CVAR_NONE, NULL,
"Amount of memory (in MB) to allocate for the "
PACKAGE_NAME " heap");
if (mem_parm)
Cvar_Set (host_mem_size, com_argv[mem_parm + 1]);
if (COM_CheckParm ("-minmemory"))
Cvar_SetValue (host_mem_size, minimum_memory / (1024 * 1024.0));
Cvar_SetFlags (host_mem_size, host_mem_size->flags | CVAR_ROM);
mem_size = (int) (host_mem_size->value * 1024 * 1024);
if (mem_size < minimum_memory)
Sys_Error ("Only %4.1f megs of memory reported, can't execute game",
mem_size / (float) 0x100000);
mem_base = malloc (mem_size);
if (!mem_base)
Sys_Error ("Can't allocate %d", mem_size);
Sys_PageIn (mem_base, mem_size);
Memory_Init (mem_base, mem_size);
}
void
Host_Init (void)
{
const char *mp;
Sys_Printf ("Host_Init\n");
host_cbuf = Cbuf_New (&id_interp);
cmd_source = src_command;
Cvar_Init_Hash ();
Cmd_Init_Hash ();
Cvar_Init ();
2002-01-17 04:11:36 +00:00
Sys_Init_Cvars ();
Sys_Init ();
Cmd_Init ();
GIB_Init (true);
// execute +set as early as possible
Cmd_StuffCmds (host_cbuf);
Cbuf_Execute_Sets (host_cbuf);
// execute the global configuration file if it exists
// would have been nice if Cmd_Exec_f could have been used, but it
// reads only from within the quake file system, and changing that is
// probably Not A Good Thing (tm).
fs_globalcfg = Cvar_Get ("fs_globalcfg", FS_GLOBALCFG,
CVAR_ROM, NULL, "global configuration file");
Cmd_Exec_File (host_cbuf, fs_globalcfg->string, 0);
Cbuf_Execute_Sets (host_cbuf);
// execute +set again to override the config file
Cmd_StuffCmds (host_cbuf);
Cbuf_Execute_Sets (host_cbuf);
fs_usercfg = Cvar_Get ("fs_usercfg", FS_USERCFG, CVAR_ROM, NULL,
"user configuration file");
Cmd_Exec_File (host_cbuf, fs_usercfg->string, 0);
Cbuf_Execute_Sets (host_cbuf);
// execute +set again to override the config file
Cmd_StuffCmds (host_cbuf);
Cbuf_Execute_Sets (host_cbuf);
CL_Init_Memory ();
2002-01-17 04:29:41 +00:00
mp = Game_Init ();
QFS_Init (mp);
2002-01-17 04:11:36 +00:00
PI_Init ();
Chase_Init_Cvars ();
CL_InitCvars ();
IN_Init_Cvars ();
VID_Init_Cvars ();
S_Init_Cvars ();
Key_Init_Cvars ();
PR_Init_Cvars ();
SV_Progs_Init_Cvars ();
R_Init_Cvars ();
R_Particles_Init_Cvars ();
Mod_Init_Cvars ();
Host_Skin_Init_Cvars ();
2001-05-20 00:34:40 +00:00
V_Init_Cvars ();
PR_Init ();
2002-01-17 04:11:36 +00:00
V_Init ();
COM_Init ();
2001-04-25 00:20:23 +00:00
if (isDedicated) {
PI_RegisterPlugins (server_plugin_list);
Con_Init ("server");
} else {
PI_RegisterPlugins (client_plugin_list);
Con_Init ("client");
}
2002-01-16 21:53:42 +00:00
if (con_module) {
con_module->data->console->realtime = &con_realtime;
con_module->data->console->frametime = &con_frametime;
con_module->data->console->quit = Host_Quit_f;
con_module->data->console->cbuf = host_cbuf;
2002-01-16 21:53:42 +00:00
}
Host_InitVCR (&host_parms);
Host_InitLocal ();
2002-01-17 04:11:36 +00:00
NET_Init ();
W_LoadWadFile ("gfx.wad");
Key_Init (host_cbuf);
2002-01-17 04:11:36 +00:00
Mod_Init ();
CL_Demo_Init ();
SV_Progs_Init ();
SV_Init ();
Sys_Printf ("%4.1f megabyte heap\n", host_mem_size->value);
if (cls.state != ca_dedicated) {
host_basepal = (byte *) QFS_LoadHunkFile ("gfx/palette.lmp");
if (!host_basepal)
Sys_Error ("Couldn't load gfx/palette.lmp");
vid_colormap = (byte *) QFS_LoadHunkFile ("gfx/colormap.lmp");
2001-04-16 20:38:51 +00:00
if (!vid_colormap)
Sys_Error ("Couldn't load gfx/colormap.lmp");
VID_Init (host_basepal);
Draw_Init ();
SCR_Init ();
R_Init ();
2001-10-28 04:23:37 +00:00
S_Init (&cl.worldmodel, &viewentity, &host_frametime);
CDAudio_Init ();
Sbar_Init ();
CL_Init ();
2002-01-17 04:11:36 +00:00
IN_Init ();
2001-10-03 17:25:21 +00:00
CL_SetState (ca_disconnected);
}
2002-01-03 06:26:57 +00:00
Host_Skin_Init ();
CL_UpdateScreen (cl.time);
CL_UpdateScreen (cl.time);
if (!isDedicated && cl_quakerc->int_val)
Cbuf_InsertText (host_cbuf, "exec quake.rc\n");
Cmd_Exec_File (host_cbuf, fs_usercfg->string, 0);
// reparse the command line for + commands other than set
// (sets still done, but it doesn't matter)
2001-10-05 19:21:23 +00:00
if (isDedicated || (cl_quakerc->int_val && check_quakerc ()))
Cmd_StuffCmds (host_cbuf);
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
Sys_Printf ("\nVersion %s (build %04d)\n\n", PACKAGE_VERSION,
build_number ());
Sys_Printf ("\x80\x81\x81\x82 %s initialized \x80\x81\x81\x82\n",
PACKAGE_NAME);
host_initialized = true;
CL_UpdateScreen (cl.time);
}
/*
2001-05-09 17:12:49 +00:00
Host_Shutdown
2001-05-09 17:12:49 +00:00
FIXME: this is a callback from Sys_Quit and Sys_Error. It would be
better to run quit through here before final handoff to the sys code.
*/
void
Host_Shutdown (void)
{
static qboolean isdown = false;
if (isdown) {
printf ("recursive shutdown\n");
return;
}
isdown = true;
Host_WriteConfiguration ();
NET_Shutdown ();
if (cls.state != ca_dedicated) {
2001-10-03 17:25:21 +00:00
CDAudio_Shutdown ();
S_Shutdown ();
IN_Shutdown ();
VID_Shutdown ();
}
2001-10-03 21:37:20 +00:00
Con_Shutdown ();
}