/*
====================
SV_Record_f
record <demoname>
====================
*/
void SV_MVD_Record_f (void)
{
int c;
char name[MAX_OSPATH+MAX_MVD_NAME];
char newname[MAX_MVD_NAME];
dir_t dir;
c = Cmd_Argc();
if (c != 2)
{
Com_Printf ("mvdrecord <demoname>\n");
return;
}
if (sv.state != ss_game){
Com_Printf ("Not active yet.\n");
return;
}
dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string), ".*", false);
if (sv_demoMaxDirSize.value && dir.size > sv_demoMaxDirSize.value*1024)
{
Com_Printf("insufficient directory space, increase sv_demoMaxDirSize\n");
return;
}
Q_strncpyz(newname, va("%s%s", sv_demoPrefix.string, SV_CleanName(Cmd_Argv(1))), sizeof(newname) - strlen(sv_demoSuffix.string) - 5);
Q_strncatz(newname, sv_demoSuffix.string, MAX_MVD_NAME);
_snprintf (name, MAX_OSPATH+MAX_MVD_NAME, "%s/%s/%s", fs_gamedir, sv_demoDir.string, newname);
FS_StripExtension(name, name, sizeof(name));
FS_DefaultExtension(name, ".mvd", sizeof(name));
// FS_CreatePath(name);
//
// open the demo file and start recording
//
SV_MVD_Record (SV_InitRecordFile(name));
}
void SV_MVDStream_Poll(void)
{
static int listensocket=INVALID_SOCKET;
static int listenport;
int client;
netadr_t na;
struct sockaddr_in addr;
int addrlen;
int count;
qbool wanted;
mvddest_t *dest;
if (!sv.state || !mvd_streamport.value)
wanted = false;
else if (listenport && (int)mvd_streamport.value != listenport) // easy way to switch... disable for a frame. :)
{
listenport = mvd_streamport.value;
wanted = false;
}
else
{
listenport = mvd_streamport.value;
wanted = true;
}
if (wanted && listensocket==INVALID_SOCKET)
listensocket = MVD_StreamStartListening(listenport);
else if (!wanted && listensocket!=INVALID_SOCKET)
{
closesocket(listensocket);
listensocket = INVALID_SOCKET;
return;
}
if (listensocket==INVALID_SOCKET)
return;
addrlen = sizeof(addr);
client = accept(listensocket, (struct sockaddr *)&addr, &addrlen);
if (client == INVALID_SOCKET)
return;
if (mvd_maxstreams.value > 0)
{
count = 0;
for (dest = demo.dest; dest; dest = dest->nextdest)
{
if (dest->desttype == DEST_STREAM)
count++;
}
if (count > mvd_maxstreams.value)
{
//sorry
char *goawaymessage = "This server enforces a limit on the number of proxies connected at any one time. Please try again later\n";
char packetheader[6];
packetheader[0] = 1;
packetheader[1] = dem_all;
packetheader[2] = strlen(goawaymessage)+1;
packetheader[3] = 0;
packetheader[4] = 0;
packetheader[5] = 0;
send(client, packetheader, sizeof(packetheader), 0);
send(client, goawaymessage, strlen(goawaymessage)+1, 0);
closesocket(client);
return;
}
}
SockadrToNetadr(&addr, &na);
Com_Printf("MVD streaming client connected from %s\n", NET_AdrToString(na));
SV_MVD_Record (SV_InitStream(client));
}
void SV_MVDEasyRecord_f (void)
{
int c;
dir_t dir;
char name[1024];
char name2[MAX_OSPATH*7]; // scream
int i;
FILE *f;
c = Cmd_Argc();
if (c > 2)
{
Com_Printf ("easyrecord [demoname]\n");
return;
}
if (sv.state < ss_game)
{
Com_Printf("Server isn't running or is still loading\n");
return;
}
dir = Sys_listdir(va("%s/%s", fs_gamedir,sv_demoDir.string), ".*", false);
if (sv_demoMaxDirSize.value && dir.size > sv_demoMaxDirSize.value*1024)
{
Com_Printf("insufficient directory space, increase sv_demoMaxDirSize\n");
return;
}
if (c == 2)
Q_strncpyz (name, Cmd_Argv(1), sizeof(name));
else
{
i = Dem_CountPlayers();
if (teamplay.value >= 1 && i > 2)
{
// Teamplay
_snprintf (name, sizeof(name), "%don%d_", Dem_CountTeamPlayers(Dem_Team(1)), Dem_CountTeamPlayers(Dem_Team(2)));
if (sv_demoExtraNames.value > 0)
{
Q_strncatz (name, va("[%s]_%s_vs_[%s]_%s_%s",
Dem_Team(1), Dem_PlayerNameTeam(Dem_Team(1)),
Dem_Team(2), Dem_PlayerNameTeam(Dem_Team(2)),
sv.mapname), sizeof(name));
} else
Q_strncatz (name, va("%s_vs_%s_%s", Dem_Team(1), Dem_Team(2), sv.mapname), sizeof(name));
} else {
if (i == 2) {
// Duel
_snprintf (name, sizeof(name), "duel_%s_vs_%s_%s",
Dem_PlayerName(1),
Dem_PlayerName(2),
sv.mapname);
} else {
// FFA
_snprintf (name, sizeof(name), "ffa_%s(%d)", sv.mapname, i);
}
}
}
// Make sure the filename doesn't contain illegal characters
Q_strncpyz(name, va("%s%s", sv_demoPrefix.string, SV_CleanName(name)),
MAX_MVD_NAME - strlen(sv_demoSuffix.string) - 7);
Q_strncatz(name, sv_demoSuffix.string, sizeof(name));
Q_strncpyz(name, va("%s/%s/%s", fs_gamedir, sv_demoDir.string, name), sizeof(name));
// find a filename that doesn't exist yet
Q_strncpyz(name2, name, sizeof(name2));
Sys_mkdir(va("%s/%s", fs_gamedir, sv_demoDir.string));
// FS_StripExtension(name2, name2, sizeof(name2));
strcat (name2, ".mvd");
if ((f = fopen (name2, "rb")) == 0)
f = fopen(va("%s.gz", name2), "rb");
if (f)
{
i = 1;
do {
fclose (f);
_snprintf(name2, sizeof(name2), "%s_%02i", name, i);
// FS_StripExtension(name2, name2, sizeof(name2));
strcat (name2, ".mvd");
if ((f = fopen (name2, "rb")) == 0)
f = fopen(va("%s.gz", name2), "rb");
i++;
} while (f);
}
SV_MVD_Record (SV_InitRecordFile(name2));
}
/*
================
SV_SpawnServer
Change the server to a new map, taking all connected
clients along with it.
This is only called from the SV_Map_f() function.
================
*/
void SV_SpawnServer (char *mapname, qbool devmap, char* entityfile)
{
extern func_t ED_FindFunctionOffset (char *name);
edict_t *ent;
int i;
extern cvar_t sv_loadentfiles, sv_loadentfiles_dir;
char *entitystring;
char oldmap[MAP_NAME_LEN];
extern qbool sv_allow_cheats;
extern cvar_t sv_cheats, sv_paused, sv_bigcoords;
#ifndef SERVERONLY
extern void CL_ClearState (void);
#endif
// store old map name
snprintf (oldmap, MAP_NAME_LEN, "%s", sv.mapname);
Con_DPrintf ("SpawnServer: %s\n",mapname);
#ifndef SERVERONLY
// As client+server we do it here.
// As serveronly we do it in NET_Init().
NET_InitServer();
#endif
SV_SaveSpawnparms ();
SV_LoadAccounts();
#ifdef USE_PR2
// remove bot clients
for (i = 0; i < MAX_CLIENTS; i++)
{
if( sv_vm && svs.clients[i].isBot )
{
svs.clients[i].old_frags = 0;
svs.clients[i].edict->v.frags = 0.0;
svs.clients[i].name[0] = 0;
svs.clients[i].state = cs_free;
Info_RemoveAll(&svs.clients[i]._userinfo_ctx_);
Info_RemoveAll(&svs.clients[i]._userinfoshort_ctx_);
SV_FullClientUpdate(&svs.clients[i], &sv.reliable_datagram);
svs.clients[i].isBot = 0;
}
}
#endif
// Shutdown game.
PR_GameShutDown();
PR_UnLoadProgs();
svs.spawncount++; // any partially connected client will be restarted
#ifndef SERVERONLY
com_serveractive = false;
#endif
sv.state = ss_dead;
sv.paused = false;
Cvar_SetROM(&sv_paused, "0");
Host_ClearMemory();
#ifdef FTE_PEXT_FLOATCOORDS
if (sv_bigcoords.value)
{
msg_coordsize = 4;
msg_anglesize = 2;
}
else
{
msg_coordsize = 2;
msg_anglesize = 1;
}
#endif
if ((int)coop.value)
Cvar_Set (&deathmatch, "0");
current_skill = (int) (skill.value + 0.5);
if (current_skill < 0)
current_skill = 0;
Cvar_Set (&skill, va("%d", current_skill));
if (current_skill > 3)
current_skill = 3;
if ((sv_cheats.value || devmap) && !sv_allow_cheats) {
sv_allow_cheats = true;
Info_SetValueForStarKey (svs.info, "*cheats", "ON", MAX_SERVERINFO_STRING);
}
else if ((!sv_cheats.value && !devmap) && sv_allow_cheats) {
sv_allow_cheats = false;
Info_SetValueForStarKey (svs.info, "*cheats", "", MAX_SERVERINFO_STRING);
}
// wipe the entire per-level structure
// NOTE: this also set sv.mvdrecording to false, so calling SV_MVD_Record() at end of function
memset (&sv, 0, sizeof(sv));
sv.datagram.maxsize = sizeof(sv.datagram_buf);
sv.datagram.data = sv.datagram_buf;
sv.datagram.allowoverflow = true;
sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
sv.reliable_datagram.data = sv.reliable_datagram_buf;
sv.multicast.maxsize = sizeof(sv.multicast_buf);
sv.multicast.data = sv.multicast_buf;
sv.signon.maxsize = sizeof(sv.signon_buffers[0]);
sv.signon.data = sv.signon_buffers[0];
sv.num_signon_buffers = 1;
sv.time = 1.0;
// load progs to get entity field count
// which determines how big each edict is
// and allocate edicts
PR_LoadProgs ();
#ifdef WITH_NQPROGS
PR_InitPatchTables();
#endif
PR_InitProg();
for (i = 0; i < MAX_EDICTS; i++)
{
ent = EDICT_NUM(i);
ent->e = &sv.sv_edicts[i]; // assigning ->e field in each edict_t
ent->e->entnum = i;
ent->e->area.ed = ent; // yeah, pretty funny, but this help to find which edict_t own this area (link_t)
}
fofs_items2 = ED_FindFieldOffset ("items2"); // ZQ_ITEMS2 extension
fofs_maxspeed = ED_FindFieldOffset ("maxspeed");
fofs_gravity = ED_FindFieldOffset ("gravity");
fofs_movement = ED_FindFieldOffset ("movement");
fofs_vw_index = ED_FindFieldOffset ("vw_index");
fofs_hideentity = ED_FindFieldOffset ("hideentity");
fofs_trackent = ED_FindFieldOffset ("trackent");
// find optional QC-exported functions.
// we have it here, so we set it to NULL in case of PR2 progs.
mod_SpectatorConnect = ED_FindFunctionOffset ("SpectatorConnect");
mod_SpectatorThink = ED_FindFunctionOffset ("SpectatorThink");
mod_SpectatorDisconnect = ED_FindFunctionOffset ("SpectatorDisconnect");
mod_ChatMessage = ED_FindFunctionOffset ("ChatMessage");
mod_UserInfo_Changed = ED_FindFunctionOffset ("UserInfo_Changed");
mod_ConsoleCmd = ED_FindFunctionOffset ("ConsoleCmd");
mod_UserCmd = ED_FindFunctionOffset ("UserCmd");
mod_localinfoChanged = ED_FindFunctionOffset ("localinfoChanged");
GE_ClientCommand = ED_FindFunctionOffset ("GE_ClientCommand");
GE_PausedTic = ED_FindFunctionOffset ("GE_PausedTic");
GE_ShouldPause = ED_FindFunctionOffset ("GE_ShouldPause");
// leave slots at start for clients only
sv.num_edicts = MAX_CLIENTS+1;
for (i=0 ; i<MAX_CLIENTS ; i++)
{
ent = EDICT_NUM(i+1);
// restore client name.
ent->v.netname = PR_SetString(svs.clients[i].name);
// reserve edict.
svs.clients[i].edict = ent;
//ZOID - make sure we update frags right
svs.clients[i].old_frags = 0;
}
// fill sv.mapname and sv.modelname with new map name
strlcpy (sv.mapname, mapname, sizeof(sv.mapname));
snprintf (sv.modelname, sizeof(sv.modelname), "maps/%s.bsp", sv.mapname);
#ifndef SERVERONLY
// set cvar
Cvar_ForceSet (&host_mapname, mapname);
#endif
if (!(sv.worldmodel = CM_LoadMap (sv.modelname, false, &sv.map_checksum, &sv.map_checksum2))) // true if bad map
{
Con_Printf ("Cant load map %s, falling back to %s\n", mapname, oldmap);
// fill mapname, sv.mapname and sv.modelname with old map name
strlcpy (sv.mapname, oldmap, sizeof(sv.mapname));
snprintf (sv.modelname, sizeof(sv.modelname), "maps/%s.bsp", sv.mapname);
mapname = oldmap;
// and re-load old map
sv.worldmodel = CM_LoadMap (sv.modelname, false, &sv.map_checksum, &sv.map_checksum2);
// this should never happen
if (!sv.worldmodel)
SV_Error ("CM_LoadMap: bad map");
}
sv.map_checksum2 = Com_TranslateMapChecksum (sv.mapname, sv.map_checksum2);
SV_ClearWorld (); // clear physics interaction links
#ifdef USE_PR2
if ( sv_vm )
{
sv.sound_precache[0] = "";
sv.model_precache[0] = "";
}
else
#endif
{
sv.sound_precache[0] = pr_strings;
sv.model_precache[0] = pr_strings;
}
sv.model_precache[1] = sv.modelname;
sv.models[1] = sv.worldmodel;
for (i=1 ; i< CM_NumInlineModels() ; i++)
{
sv.model_precache[1+i] = localmodels[i];
sv.models[i+1] = CM_InlineModel (localmodels[i]);
}
//check player/eyes models for hacks
sv.model_player_checksum = SV_CheckModel("progs/player.mdl");
sv.model_newplayer_checksum = SV_CheckModel("progs/newplayer.mdl");
sv.eyes_player_checksum = SV_CheckModel("progs/eyes.mdl");
//
// spawn the rest of the entities on the map
//
// precache and static commands can be issued during
// map initialization
sv.state = ss_loading;
#ifndef SERVERONLY
com_serveractive = true;
#endif
ent = EDICT_NUM(0);
ent->e->free = false;
ent->v.model = PR_SetString(sv.modelname);
ent->v.modelindex = 1; // world model
ent->v.solid = SOLID_BSP;
ent->v.movetype = MOVETYPE_PUSH;
// information about the server
ent->v.netname = PR_SetString(VersionStringFull());
ent->v.targetname = PR_SetString(SERVER_NAME);
ent->v.impulse = VERSION_NUM;
ent->v.items = pr_numbuiltins - 1;
PR_GLOBAL(mapname) = PR_SetString(sv.mapname);
// serverflags are for cross level information (sigils)
PR_GLOBAL(serverflags) = svs.serverflags;
if (pr_nqprogs)
{
pr_globals[35] = deathmatch.value;
pr_globals[36] = coop.value;
pr_globals[37] = teamplay.value;
NQP_Reset ();
}
if (pr_nqprogs)
{
// register the cvars that NetQuake provides for mod use
const char **var, *nqcvars[] = {"gamecfg", "scratch1", "scratch2", "scratch3", "scratch4",
"saved1", "saved2", "saved3", "saved4", "savedgamecfg", "temp1", NULL};
for (var = nqcvars; *var; var++)
Cvar_Create((char *)/*stupid const warning*/ *var, "0", 0);
}
// run the frame start qc function to let progs check cvars
if (!pr_nqprogs)
SV_ProgStartFrame ();
// ********* External Entity support (.ent file(s) in gamedir/maps) pinched from ZQuake *********
// load and spawn all other entities
entitystring = NULL;
if ((int)sv_loadentfiles.value)
{
char ent_path[1024] = {0};
if (!entityfile || !entityfile[0])
entityfile = sv.mapname;
// first try maps/sv_loadentfiles_dir/
if (sv_loadentfiles_dir.string[0])
{
snprintf(ent_path, sizeof(ent_path), "maps/%s/%s.ent", sv_loadentfiles_dir.string, entityfile);
entitystring = (char *) FS_LoadHunkFile(ent_path, NULL);
}
// try maps/ if not loaded yet.
if (!entitystring)
{
snprintf(ent_path, sizeof(ent_path), "maps/%s.ent", entityfile);
entitystring = (char *) FS_LoadHunkFile(ent_path, NULL);
}
if (entitystring) {
Con_DPrintf ("Using entfile %s\n", ent_path);
}
}
if (!entitystring) {
entitystring = CM_EntityString();
}
PR_LoadEnts(entitystring);
// ********* End of External Entity support code *********
// 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;
// run two frames to allow everything to settle
SV_Physics ();
sv.time += 0.1;
SV_Physics ();
sv.time += 0.1;
sv.old_time = sv.time;
// save movement vars
SV_SetMoveVars();
// create a baseline for more efficient communications
SV_CreateBaseline ();
sv.signon_buffer_size[sv.num_signon_buffers-1] = sv.signon.cursize;
Info_SetValueForKey (svs.info, "map", sv.mapname, MAX_SERVERINFO_STRING);
// calltimeofday.
{
extern void PF_calltimeofday (void);
pr_global_struct->time = sv.time;
pr_global_struct->self = 0;
PF_calltimeofday();
}
Con_DPrintf ("Server spawned.\n");
// we change map - clear whole demo struct and sent initial state to all dest if any (for QTV only I thought)
SV_MVD_Record(NULL, true);
#ifndef SERVERONLY
CL_ClearState ();
#endif
}
