newtree/source/sv_init.c

428 lines
11 KiB
C
Raw Normal View History

/*
sv_init.c
(description)
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
$Id$
*/
2000-05-10 11:29:38 +00:00
2000-05-17 10:03:19 +00:00
#ifdef HAVE_CONFIG_H
# include "config.h"
2000-05-17 10:03:19 +00:00
#endif
2000-12-30 02:16:36 +00:00
#ifdef HAVE_STRING_H
# include <string.h>
2000-12-30 02:16:36 +00:00
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
2000-12-30 02:16:36 +00:00
#endif
#include "crc.h"
#include "msg.h"
#include "quakefs.h"
2000-12-30 02:16:36 +00:00
#include "server.h"
#include "world.h"
#include "va.h"
2000-05-10 11:29:38 +00:00
server_t sv; // local server
2000-05-10 11:29:38 +00:00
char localmodels[MAX_MODELS][5]; // inline model names for precache
2000-05-10 11:29:38 +00:00
char localinfo[MAX_LOCALINFO_STRING + 1]; // local game info
2000-05-10 11:29:38 +00:00
/*
2001-02-09 02:53:09 +00:00
SV_ModelIndex
2000-05-10 11:29:38 +00:00
*/
int
SV_ModelIndex (char *name)
2000-05-10 11:29:38 +00:00
{
int i;
2000-05-10 11:29:38 +00:00
if (!name || !name[0])
return 0;
for (i = 0; i < MAX_MODELS && sv.model_precache[i]; i++)
if (!strcmp (sv.model_precache[i], name))
2000-05-10 11:29:38 +00:00
return i;
if (i == MAX_MODELS || !sv.model_precache[i])
2000-05-10 11:29:38 +00:00
SV_Error ("SV_ModelIndex: model %s not precached", name);
return i;
}
/*
2001-02-09 02:53:09 +00:00
SV_FlushSignon
2000-05-10 11:29:38 +00:00
2001-02-09 02:53:09 +00:00
Moves to the next signon buffer if needed
2000-05-10 11:29:38 +00:00
*/
void
SV_FlushSignon (void)
2000-05-10 11:29:38 +00:00
{
if (sv.signon.cursize < sv.signon.maxsize - 512)
return;
if (sv.num_signon_buffers == MAX_SIGNON_BUFFERS - 1)
2000-05-10 11:29:38 +00:00
SV_Error ("sv.num_signon_buffers == MAX_SIGNON_BUFFERS-1");
sv.signon_buffer_size[sv.num_signon_buffers - 1] = sv.signon.cursize;
2000-05-10 11:29:38 +00:00
sv.signon.data = sv.signon_buffers[sv.num_signon_buffers];
sv.num_signon_buffers++;
sv.signon.cursize = 0;
}
/*
2001-02-09 02:53:09 +00:00
SV_CreateBaseline
2000-05-10 11:29:38 +00:00
2001-02-09 02:53:09 +00:00
Entity baselines are used to compress the update messages
to the clients -- only the fields that differ from the
baseline will be transmitted
2000-05-10 11:29:38 +00:00
*/
void
SV_CreateBaseline (void)
2000-05-10 11:29:38 +00:00
{
int i;
edict_t *svent;
int entnum;
for (entnum = 0; entnum < sv.num_edicts; entnum++) {
svent = EDICT_NUM (&sv_pr_state, entnum);
2000-05-10 11:29:38 +00:00
if (svent->free)
continue;
// create baselines for all player slots,
// and any other edict that has a visible model
if (entnum > MAX_CLIENTS && !svent->v.v.modelindex)
2000-05-10 11:29:38 +00:00
continue;
//
// create entity baseline
//
VectorCopy (svent->v.v.origin, svent->baseline.origin);
VectorCopy (svent->v.v.angles, svent->baseline.angles);
svent->baseline.frame = svent->v.v.frame;
svent->baseline.skinnum = svent->v.v.skin;
if (entnum > 0 && entnum <= MAX_CLIENTS) {
2000-05-10 11:29:38 +00:00
svent->baseline.colormap = entnum;
svent->baseline.modelindex = SV_ModelIndex ("progs/player.mdl");
} else {
2000-05-10 11:29:38 +00:00
svent->baseline.colormap = 0;
svent->baseline.modelindex =
SV_ModelIndex (PR_GetString (&sv_pr_state, svent->v.v.model));
2000-05-10 11:29:38 +00:00
}
// LordHavoc: setup baseline to include new effects
svent->baseline.alpha = 255;
svent->baseline.scale = 16;
svent->baseline.glowsize = 0;
svent->baseline.glowcolor = 254;
svent->baseline.colormap = 255;
2000-05-10 11:29:38 +00:00
//
2000-05-10 11:29:38 +00:00
// flush the signon message out to a seperate buffer if
// nearly full
//
2000-05-10 11:29:38 +00:00
SV_FlushSignon ();
//
2000-05-10 11:29:38 +00:00
// add to the message
//
MSG_WriteByte (&sv.signon, svc_spawnbaseline);
MSG_WriteShort (&sv.signon, entnum);
2000-05-10 11:29:38 +00:00
MSG_WriteByte (&sv.signon, svent->baseline.modelindex);
MSG_WriteByte (&sv.signon, svent->baseline.frame);
MSG_WriteByte (&sv.signon, svent->baseline.colormap);
MSG_WriteByte (&sv.signon, svent->baseline.skinnum);
for (i = 0; i < 3; i++) {
MSG_WriteCoord (&sv.signon, svent->baseline.origin[i]);
MSG_WriteAngle (&sv.signon, svent->baseline.angles[i]);
2000-05-10 11:29:38 +00:00
}
}
}
/*
2001-02-09 02:53:09 +00:00
SV_SaveSpawnparms
2000-05-10 11:29:38 +00:00
2001-02-09 02:53:09 +00:00
Grabs the current state of the progs serverinfo flags
and each client for saving across the
transition to another level
2000-05-10 11:29:38 +00:00
*/
void
SV_SaveSpawnparms (void)
2000-05-10 11:29:38 +00:00
{
int i, j;
2000-05-10 11:29:38 +00:00
if (!sv.state)
return; // no progs loaded yet
2000-05-10 11:29:38 +00:00
// serverflags is the only game related thing maintained
svs.serverflags = sv_pr_state.pr_global_struct->serverflags;
2000-05-10 11:29:38 +00:00
for (i = 0, host_client = svs.clients; i < MAX_CLIENTS; i++, host_client++) {
2000-05-10 11:29:38 +00:00
if (host_client->state != cs_spawned)
continue;
// needs to reconnect
host_client->state = cs_connected;
// call the progs to get default spawn parms for the new client
sv_pr_state.pr_global_struct->self = EDICT_TO_PROG (&sv_pr_state, host_client->edict);
PR_ExecuteProgram (&sv_pr_state, sv_pr_state.pr_global_struct->SetChangeParms);
for (j = 0; j < NUM_SPAWN_PARMS; j++)
host_client->spawn_parms[j] = (&sv_pr_state.pr_global_struct->parm1)[j];
2000-05-10 11:29:38 +00:00
}
}
/*
2001-02-09 02:53:09 +00:00
SV_CalcPHS
2000-05-10 11:29:38 +00:00
2001-02-09 02:53:09 +00:00
Expands the PVS and calculates the PHS
(Potentially Hearable Set)
2000-05-10 11:29:38 +00:00
*/
void
SV_CalcPHS (void)
2000-05-10 11:29:38 +00:00
{
int rowbytes, rowwords;
int i, j, k, l, index, num;
int bitbyte;
unsigned int *dest, *src;
byte *scan;
int count, vcount;
2000-05-10 11:29:38 +00:00
Con_Printf ("Building PHS...\n");
num = sv.worldmodel->numleafs;
rowwords = (num + 31) >> 5;
rowbytes = rowwords * 4;
2000-05-10 11:29:38 +00:00
sv.pvs = Hunk_Alloc (rowbytes * num);
2000-05-10 11:29:38 +00:00
scan = sv.pvs;
vcount = 0;
for (i = 0; i < num; i++, scan += rowbytes) {
memcpy (scan, Mod_LeafPVS (sv.worldmodel->leafs + i, sv.worldmodel),
rowbytes);
2000-05-10 11:29:38 +00:00
if (i == 0)
continue;
for (j = 0; j < num; j++) {
if (scan[j >> 3] & (1 << (j & 7))) {
2000-05-10 11:29:38 +00:00
vcount++;
}
}
}
sv.phs = Hunk_Alloc (rowbytes * num);
2000-05-10 11:29:38 +00:00
count = 0;
scan = sv.pvs;
dest = (unsigned int *) sv.phs;
for (i = 0; i < num; i++, dest += rowwords, scan += rowbytes) {
2000-05-10 11:29:38 +00:00
memcpy (dest, scan, rowbytes);
for (j = 0; j < rowbytes; j++) {
2000-05-10 11:29:38 +00:00
bitbyte = scan[j];
if (!bitbyte)
continue;
for (k = 0; k < 8; k++) {
if (!(bitbyte & (1 << k)))
2000-05-10 11:29:38 +00:00
continue;
// or this pvs row into the phs
// +1 because pvs is 1 based
index = ((j << 3) + k + 1);
2000-05-10 11:29:38 +00:00
if (index >= num)
continue;
src = (unsigned int *) sv.pvs + index * rowwords;
for (l = 0; l < rowwords; l++)
2000-05-10 11:29:38 +00:00
dest[l] |= src[l];
}
}
if (i == 0)
continue;
for (j = 0; j < num; j++)
if (((byte *) dest)[j >> 3] & (1 << (j & 7)))
2000-05-10 11:29:38 +00:00
count++;
}
Con_Printf ("Average leafs visible / hearable / total: %i / %i / %i\n",
vcount / num, count / num, num);
2000-05-10 11:29:38 +00:00
}
unsigned int
SV_CheckModel (char *mdl)
2000-05-10 11:29:38 +00:00
{
byte stackbuf[1024]; // avoid dirtying the cache heap
byte *buf;
unsigned short crc = 0;
2000-05-10 11:29:38 +00:00
// int len;
buf = (byte *) COM_LoadStackFile (mdl, stackbuf, sizeof (stackbuf));
if (buf) {
crc = CRC_Block (buf, com_filesize);
} else {
Con_Printf ("WARNING: cannot generate checksum for %s\n", mdl);
}
2000-05-10 11:29:38 +00:00
return crc;
}
/*
2001-02-09 02:53:09 +00:00
SV_SpawnServer
2000-05-10 11:29:38 +00:00
2001-02-09 02:53:09 +00:00
Change the server to a new map, taking all connected
clients along with it.
2000-05-10 11:29:38 +00:00
2001-02-09 02:53:09 +00:00
This is only called from the SV_Map_f() function.
2000-05-10 11:29:38 +00:00
*/
void
SV_SpawnServer (char *server)
2000-05-10 11:29:38 +00:00
{
edict_t *ent;
int i;
Con_DPrintf ("SpawnServer: %s\n", server);
2000-05-10 11:29:38 +00:00
SV_SaveSpawnparms ();
svs.spawncount++; // any partially connected client
// will be
// restarted
2000-05-10 11:29:38 +00:00
sv.state = ss_dead;
sv_pr_state.null_bad = 0;
2000-05-10 11:29:38 +00:00
Mod_ClearAll ();
Hunk_FreeToLowMark (host_hunklevel);
// wipe the entire per-level structure
memset (&sv, 0, sizeof (sv));
2000-05-10 11:29:38 +00:00
sv.datagram.maxsize = sizeof (sv.datagram_buf);
2000-05-10 11:29:38 +00:00
sv.datagram.data = sv.datagram_buf;
sv.datagram.allowoverflow = true;
sv.reliable_datagram.maxsize = sizeof (sv.reliable_datagram_buf);
2000-05-10 11:29:38 +00:00
sv.reliable_datagram.data = sv.reliable_datagram_buf;
sv.multicast.maxsize = sizeof (sv.multicast_buf);
2000-05-10 11:29:38 +00:00
sv.multicast.data = sv.multicast_buf;
sv.master.maxsize = sizeof (sv.master_buf);
2000-05-10 11:29:38 +00:00
sv.master.data = sv.master_buf;
sv.signon.maxsize = sizeof (sv.signon_buffers[0]);
2000-05-10 11:29:38 +00:00
sv.signon.data = sv.signon_buffers[0];
sv.num_signon_buffers = 1;
strcpy (sv.name, server);
// load progs to get entity field count
// which determines how big each edict is
SV_LoadProgs ();
Info_SetValueForStarKey (svs.info, "*progs", va ("%i", sv_pr_state.crc),
MAX_SERVERINFO_STRING, !sv_highchars->int_val);
2000-05-10 11:29:38 +00:00
// allocate edicts
sv.edicts = Hunk_AllocName (MAX_EDICTS * sv_pr_state.pr_edict_size, "edicts");
2000-05-10 11:29:38 +00:00
// leave slots at start for clients only
sv.num_edicts = MAX_CLIENTS + 1;
for (i = 0; i < MAX_CLIENTS; i++) {
ent = EDICT_NUM (&sv_pr_state, i + 1);
2000-05-10 11:29:38 +00:00
svs.clients[i].edict = ent;
//ZOID - make sure we update frags right
svs.clients[i].old_frags = 0;
}
sv.time = 1.0;
strncpy (sv.name, server, sizeof (sv.name));
snprintf (sv.modelname, sizeof (sv.modelname), "maps/%s.bsp", server);
2000-05-10 11:29:38 +00:00
sv.worldmodel = Mod_ForName (sv.modelname, true);
SV_CalcPHS ();
//
2000-05-10 11:29:38 +00:00
// clear physics interaction links
//
2000-05-10 11:29:38 +00:00
SV_ClearWorld ();
sv.sound_precache[0] = sv_pr_state.pr_strings;
2000-05-10 11:29:38 +00:00
sv.model_precache[0] = sv_pr_state.pr_strings;
2000-05-10 11:29:38 +00:00
sv.model_precache[1] = sv.modelname;
sv.models[1] = sv.worldmodel;
for (i = 1; i < sv.worldmodel->numsubmodels; i++) {
sv.model_precache[1 + i] = localmodels[i];
sv.models[i + 1] = Mod_ForName (localmodels[i], false);
2000-05-10 11:29:38 +00:00
}
// check player/eyes models for hacks
sv.model_player_checksum = SV_CheckModel ("progs/player.mdl");
sv.eyes_player_checksum = SV_CheckModel ("progs/eyes.mdl");
2000-05-10 11:29:38 +00:00
//
2000-05-10 11:29:38 +00:00
// spawn the rest of the entities on the map
//
2000-05-10 11:29:38 +00:00
// precache and static commands can be issued during
// map initialization
sv.state = ss_loading;
sv_pr_state.null_bad = 0;
2000-05-10 11:29:38 +00:00
ent = EDICT_NUM (&sv_pr_state, 0);
2000-05-10 11:29:38 +00:00
ent->free = false;
ent->v.v.model = PR_SetString (&sv_pr_state, sv.worldmodel->name);
ent->v.v.modelindex = 1; // world model
ent->v.v.solid = SOLID_BSP;
ent->v.v.movetype = MOVETYPE_PUSH;
2000-05-10 11:29:38 +00:00
sv_pr_state.pr_global_struct->mapname = PR_SetString (&sv_pr_state, sv.name);
2000-05-10 11:29:38 +00:00
// serverflags are for cross level information (sigils)
sv_pr_state.pr_global_struct->serverflags = svs.serverflags;
2000-05-10 11:29:38 +00:00
// run the frame start qc function to let progs check cvars
SV_ProgStartFrame ();
// load and spawn all other entities
ED_LoadFromFile (&sv_pr_state, sv.worldmodel->entities);
2000-05-10 11:29:38 +00:00
// look up some model indexes for specialized message compression
SV_FindModelNumbers ();
// all spawning is completed, any further precache statements
// or prog writes to the signon message are errors
sv.state = ss_active;
sv_pr_state.null_bad = 1;
2000-05-10 11:29:38 +00:00
// run two frames to allow everything to settle
sv_frametime = 0.1;
2000-05-10 11:29:38 +00:00
SV_Physics ();
SV_Physics ();
// save movement vars
SV_SetMoveVars ();
2000-05-10 11:29:38 +00:00
// create a baseline for more efficient communications
SV_CreateBaseline ();
sv.signon_buffer_size[sv.num_signon_buffers - 1] = sv.signon.cursize;
2000-05-10 11:29:38 +00:00
Info_SetValueForKey (svs.info, "map", sv.name, MAX_SERVERINFO_STRING, !sv_highchars->int_val);
2000-05-10 11:29:38 +00:00
Con_DPrintf ("Server spawned.\n");
}