nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-26 22:01:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/server/savegame.c
Spoike c035801161 Add support for maps/foo.bsp.xz too, for better compression. 
Seeking within files inside zips is now slightly more efficient.
Fix issue with servers decompressing .gz before download...

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5883 fc73d0e0-1445-4013-8a0c-d673dee63da5
2021-06-02 15:29:44 +00:00

2368 lines
66 KiB
C
Raw Blame History

#include "quakedef.h"
#include "pr_common.h"
#if !defined(CLIENTONLY) && defined(SAVEDGAMES)
#define CACHEGAME_VERSION_DEFAULT CACHEGAME_VERSION_VERBOSE
extern cvar_t skill;
extern cvar_t deathmatch;
extern cvar_t coop;
extern cvar_t teamplay;
extern cvar_t pr_enable_profiling;
cvar_t sv_savefmt = CVARFD("sv_savefmt", "", CVAR_SAVE, "Specifies the format used for the saved game.\n0=legacy.\n1=fte\n2=binary");
cvar_t sv_autosave = CVARFD("sv_autosave", "5", CVAR_SAVE, "Interval for autosaves, in minutes. Set to 0 to disable autosave.");
extern cvar_t pr_ssqc_memsize;
void SV_Savegame_f (void);
typedef struct
{
char name[32];
union
{
int i;
float f;
} parm[NUM_SPAWN_PARMS];
char *parmstr;
client_t *source;
} loadplayer_t;
struct loadinfo_s
{
size_t numplayers;
loadplayer_t *players;
};
//Writes a SAVEGAME_COMMENT_LENGTH character comment describing the current
void SV_SavegameComment (char *text, size_t textsize)
{
int i;
char kills[20];
char datetime[64];
time_t timeval;
char *mapname = sv.mapname;
for (i=0 ; i<textsize-1 ; i++)
text[i] = ' ';
text[textsize-1] = '\0';
if (!mapname)
strcpy( text, "Unnamed_Level");
else
{
i = strlen(mapname);
if (i > 22)
i = 22;
memcpy (text, mapname, i);
}
kills[0] = '\0';
#ifdef Q2SERVER
if (ge) //q2
{
kills[0] = '\0';
}
else
#endif
#ifdef HLSERVER
if (svs.gametype == GT_HALFLIFE)
{
sprintf (kills,"");
}
else
#endif
{
if ((int)pr_global_struct->killed_monsters || (int)pr_global_struct->total_monsters)
sprintf (kills,"kills:%3i/%3i", (int)pr_global_struct->killed_monsters, (int)pr_global_struct->total_monsters);
}
time(&timeval);
strftime(datetime, sizeof(datetime), "%Y-%m-%d %H:%M:%S", localtime( &timeval ));
memcpy (text+22, kills, strlen(kills));
if (textsize > 39)
{
Q_strncpyz(text+39, datetime, textsize-39);
}
// convert space to _ to make stdio happy
for (i=0 ; i<textsize-1 ; i++)
{
if (text[i] == ' ')
text[i] = '_';
else if (text[i] == '\n')
text[i] = '\0';
}
text[textsize-1] = '\0';
}
pbool PDECL SV_ExtendedSaveData(pubprogfuncs_t *progfuncs, void *loadctx, const char **ptr)
{
struct loadinfo_s *loadinfo = loadctx;
char token[65536];
com_tokentype_t tt;
const char *l = *ptr;
size_t idx;
if (l[0] == 's' && l[1] == 'v' && l[2] == '.')
l += 3; //DPism
do
{
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);
} while(tt == TTP_LINEENDING);
if (tt != TTP_RAWTOKEN)return false;
if (!strcmp(token, "lightstyle") || !strcmp(token, "lightstyles"))
{ //lightstyle N "STYLESTRING" 1 1 1
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
if (idx >= sv.maxlightstyles)
{
if (idx >= MAX_NET_LIGHTSTYLES)
return false; //unsupported index.
Z_ReallocElements((void**)&sv.lightstyles, &sv.maxlightstyles, idx+1, sizeof(*sv.lightstyles));
}
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_STRING)return false;
if (sv.lightstyles[idx].str)
Z_Free((char*)sv.lightstyles[idx].str);
sv.lightstyles[idx].str = Z_StrDup(token);
sv.lightstyles[idx].colours[0] = sv.lightstyles[idx].colours[1] = sv.lightstyles[idx].colours[2] = 1.0;
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
sv.lightstyles[idx].colours[0] = atof(token);
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
sv.lightstyles[idx].colours[1] = atof(token);
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
sv.lightstyles[idx].colours[2] = atof(token);
}
else if (!strcmp(token, "model_precache") || !strcmp(token, "model"))
{ //model_precache N "MODELNAME"
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
if (!idx || idx >= countof(sv.strings.model_precache))
return false; //unsupported index.
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_STRING)return false;
sv.strings.model_precache[idx] = PR_AddString(svprogfuncs, token, 0, false);
}
#ifdef HAVE_LEGACY
else if (!strcmp(token, "vwep"))
{ //vwep N "MODELNAME"
//0 IS valid, and frankly this stuff sucks.
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
if (idx >= countof(sv.strings.vw_model_precache))
return false; //unsupported index.
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_STRING)return false;
sv.strings.vw_model_precache[idx] = PR_AddString(svprogfuncs, token, 0, false);
}
#endif
else if (!strcmp(token, "sound_precache") || !strcmp(token, "sound"))
{ //sound_precache N "MODELNAME"
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
if (!idx || idx >= countof(sv.strings.sound_precache))
return false; //unsupported index.
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_STRING)return false;
sv.strings.sound_precache[idx] = PR_AddString(svprogfuncs, token, 0, false);
}
else if (!strcmp(token, "particle_precache") || !strcmp(token, "particle"))
{ //particle_precache N "MODELNAME"
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
if (!idx || idx >= countof(sv.strings.particle_precache))
return false; //unsupported index.
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_STRING)return false;
sv.strings.particle_precache[idx] = PR_AddString(svprogfuncs, token, 0, false);
}
else if (!strcmp(token, "serverflags"))
{ //serverflags N (for map_restart to work properly)
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
svs.serverflags = idx;
}
else if (!strcmp(token, "startspot"))
{ //startspot "foo" (for map_restart to work properly)
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
InfoBuf_SetStarKey(&svs.info, "*startspot", token);
}
else if (loadinfo && !strcmp(token, "spawnparm"))
{ //spawnparm idx val (for map_restart to work properly)
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
idx = atoi(token);
if (idx == 0)
{ //the parmstr...
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_STRING)return false;
loadinfo->players[0].parmstr = Z_StrDup(token);
}
else if (idx >= 1 && idx <= countof(loadinfo->players->parm))
{ //regular parm
l = COM_ParseTokenOut(l, NULL, token, sizeof(token), &tt);if (tt != TTP_RAWTOKEN)return false;
loadinfo->players[0].parm[idx-1].f = atof(token);
}
}
//strbuffer+hashtable+etc junk
else if (PR_Common_LoadGame(svprogfuncs, token, &l))
;
else
return false;
*ptr = l;
return true;
}
#ifndef QUAKETC
static qboolean SV_LegacySavegame (const char *savename, qboolean verbose)
{
size_t len;
char *s = NULL;
client_t *cl;
int clnum;
int version = SAVEGAME_VERSION_FTE_LEG;
char native[MAX_OSPATH];
char name[MAX_QPATH];
vfsfile_t *f;
int i;
char comment[SAVEGAME_COMMENT_LENGTH+1];
if (sv.state != ss_active)
{
if (verbose)
Con_TPrintf("Can't apply: Server isn't running or is still loading\n");
return false;
}
if (sv.allocated_client_slots != 1 || svs.clients->state != cs_spawned)
{
//we don't care about fte-format legacy.
if (verbose)
Con_TPrintf("Unable to use legacy savegame format to save multiplayer games\n");
return false;
}
sprintf (name, "%s", savename);
COM_RequireExtension (name, ".sav", sizeof(name)); //do NOT allow .pak etc
if (!FS_NativePath(name, FS_GAMEONLY, native, sizeof(native)))
return false;
Con_TPrintf (U8("Saving game to %s...\n"), native);
f = FS_OpenVFS(name, "wbp", FS_GAMEONLY);
if (!f)
{
if (verbose)
Con_TPrintf ("ERROR: couldn't open %s.\n", name);
return false;
}
//if there are 1 of 1 players connected
if (sv.allocated_client_slots == 1 && svs.clients->state == cs_spawned)
{//try to go for nq/zq compatability as this is a single player game.
s = PR_SaveEnts(svprogfuncs, NULL, &len, 0, 2); //get the entity state now, so that we know if we can get the full state in a q1 format.
if (s)
{
if (progstype == PROG_QW)
version = SAVEGAME_VERSION_QW;
else
version = SAVEGAME_VERSION_NQ;
}
}
VFS_PRINTF(f, "%i\n", version);
SV_SavegameComment (comment, sizeof(comment));
VFS_PRINTF(f, "%s\n", comment);
if (version == SAVEGAME_VERSION_NQ || version == SAVEGAME_VERSION_QW)
{
//only 16 spawn parms.
for (i=0; i < 16; i++)
VFS_PRINTF(f, "%f\n", svs.clients->spawn_parms[i]); //client 1.
VFS_PRINTF(f, "%f\n", skill.value);
}
else
{
VFS_PRINTF(f, "%i\n", sv.allocated_client_slots);
for (cl = svs.clients, clnum=0; clnum < sv.allocated_client_slots; cl++,clnum++)
{
if (cl->state < cs_loadzombie || !cl->spawned) //don't save if they are still connecting
{
VFS_PRINTF(f, "\"\"\n");
continue;
}
VFS_PRINTF(f, "\"%s\"\n", cl->name);
for (i=0; i<NUM_SPAWN_PARMS ; i++)
VFS_PRINTF(f, "%f\n", cl->spawn_parms[i]);
}
VFS_PRINTF(f, "%i\n", progstype);
VFS_PRINTF(f, "%f\n", skill.value);
VFS_PRINTF(f, "%f\n", deathmatch.value);
VFS_PRINTF(f, "%f\n", coop.value);
VFS_PRINTF(f, "%f\n", teamplay.value);
}
VFS_PRINTF(f, "%s\n", svs.name);
VFS_PRINTF(f, "%f\n",sv.time);
// write the light styles (only 64 are saved in legacy saved games)
for (i=0 ; i < 64; i++)
{
if (i < sv.maxlightstyles && sv.lightstyles[i].str && *sv.lightstyles[i].str)
VFS_PRINTF(f, "%s\n", sv.lightstyles[i].str);
else
VFS_PRINTF(f,"m\n");
}
if (!s)
s = PR_SaveEnts(svprogfuncs, NULL, &len, 0, 1);
VFS_PUTS(f, s);
VFS_PUTS(f, "\n");
#if 1
/* Extended save info
** This should also be compatible with both DP and QSS.
** WARNING: this does NOT protect against models/sounds being precached in different/random orders (statics/baselines/ambients will be wrong).
** the only protection we get is from late precaches.
** theoretically the loader could make it work by rewriting the various tables, but that would not necessarily be reliable.
*/
VFS_PUTS(f, "/*\n");
VFS_PUTS(f, "// FTE extended savegame\n");
for (i=0 ; i < sv.maxlightstyles; i++)
{ //yes, repeat styles 0-63 again, but only list ones that are not empty.
if (sv.lightstyles[i].str)
VFS_PRINTF(f, "sv.lightstyles %i %s\n", i, sv.lightstyles[i].str);
}
for (i=1 ; i < countof(sv.strings.model_precache); i++)
{
if (sv.strings.model_precache[i])
VFS_PRINTF(f, "sv.model_precache %i %s\n", i, sv.strings.model_precache[i]);
}
for (i=1 ; i < countof(sv.strings.sound_precache); i++)
{
if (sv.strings.sound_precache[i])
VFS_PRINTF(f, "sv.sound_precache %i %s\n", i, sv.strings.sound_precache[i]);
}
for (i=1 ; i < countof(sv.strings.particle_precache); i++)
{
if (sv.strings.particle_precache[i])
VFS_PRINTF(f, "sv.particle_precache %i %s\n", i, sv.strings.particle_precache[i]);
}
VFS_PRINTF(f, "sv.serverflags %i\n", svs.serverflags); //zomg! a fix for losing runes on load;restart!
// VFS_PRINTF(f, "sv.startspot %s\n", InfoBuf_ValueForKey(&svs.info, "*startspot")); //startspot, for restarts.
if (svs.clients->spawn_parmstring)
{
size_t maxlen = strlen(svs.clients->spawn_parmstring)*2+4 + 1;
char *buffer = BZ_Malloc(maxlen);
VFS_PRINTF(f, "spawnparm 0 %s\n", COM_QuotedString(svs.clients->spawn_parmstring, buffer, sizeof(maxlen), false));
BZ_Free(buffer);
}
if (version == SAVEGAME_VERSION_NQ || version == SAVEGAME_VERSION_QW)
for (i=16 ; i < countof(svs.clients->spawn_parms); i++)
VFS_PRINTF(f, "spawnparm %i %g\n", i+1, svs.clients->spawn_parms[i]);
// sv.buffer %i %i "string"
// sv.bufstr %i %i "%s"
VFS_PUTS(f, "*/\n");
#endif
svprogfuncs->parms->memfree(s);
VFS_CLOSE(f);
FS_FlushFSHashWritten(name);
Q_strncpyz(sv.loadgame_on_restart, savename, sizeof(sv.loadgame_on_restart));
return true;
}
#endif
void SV_FlushLevelCache(void)
{
levelcache_t *cache;
while(svs.levcache)
{
cache = svs.levcache->next;
Z_Free(svs.levcache);
svs.levcache = cache;
}
}
void LoadModelsAndSounds(vfsfile_t *f)
{
char str[32768];
int i;
sv.strings.model_precache[0] = PR_AddString(svprogfuncs, "", 0, false);
for (i=1; i < MAX_PRECACHE_MODELS; i++)
{
VFS_GETS(f, str, sizeof(str));
if (!*str)
break;
sv.strings.model_precache[i] = PR_AddString(svprogfuncs, str, 0, false);
}
if (i == MAX_PRECACHE_MODELS)
{
VFS_GETS(f, str, sizeof(str));
if (*str)
SV_Error("Too many model precaches in loadgame cache");
}
for (; i < MAX_PRECACHE_MODELS; i++)
sv.strings.model_precache[i] = NULL;
sv.strings.sound_precache[0] = PR_AddString(svprogfuncs, "", 0, false);
for (i=1; i < MAX_PRECACHE_SOUNDS; i++)
{
VFS_GETS(f, str, sizeof(str));
if (!*str)
break;
sv.strings.sound_precache[i] = PR_AddString(svprogfuncs, str, 0, false);
}
if (i == MAX_PRECACHE_SOUNDS)
{
VFS_GETS(f, str, sizeof(str));
if (*str)
SV_Error("Too many sound precaches in loadgame cache");
}
for (; i < MAX_PRECACHE_SOUNDS; i++)
sv.strings.sound_precache[i] = NULL;
}
/*ignoreplayers - says to not tell gamecode (a loadgame rather than a level change)*/
qboolean SV_LoadLevelCache(const char *savename, const char *level, const char *startspot, qboolean isloadgame)
{
eval_t *eval, *e2;
char name[MAX_OSPATH];
vfsfile_t *f;
char mapname[MAX_QPATH];
float time;
char str[32768];
int i;
size_t j;
edict_t *ent;
int version;
int current_skill;
int pt;
int modelpos;
qofs_t filelen, filepos;
char *file;
gametype_e gametype;
levelcache_t *cache;
int numstyles;
if (isloadgame)
{
gametype = svs.gametype;
}
else
{
cache = svs.levcache;
while(cache)
{
if (!strcmp(cache->mapname, level))
break;
cache = cache->next;
}
if (!cache)
return false; //not visited yet. Ignore the existing caches as fakes.
gametype = cache->gametype;
}
if (savename)
Q_snprintfz (name, sizeof(name), "saves/%s/%s.lvc", savename, level);
else
Q_snprintfz (name, sizeof(name), "saves/%s.lvc", level);
// Con_TPrintf ("Loading game from %s...\n", name);
#ifdef Q2SERVER
if (gametype == GT_QUAKE2)
{
char *s;
flocation_t loc;
SV_SpawnServer (level, startspot, false, false, 0);
World_ClearWorld(&sv.world, false);
if (!ge)
{
Con_Printf("Incorrect gamecode type.\n");
return false;
}
if (!FS_FLocateFile(name, FSLF_IFFOUND, &loc))
{
Con_Printf("Couldn't find %s.\n", name);
return false;
}
if (!*loc.rawname || loc.offset)
{
Con_Printf("%s is inside a package and cannot be used by the quake2 gamecode.\n", name);
return false;
}
if (savename)
Q_snprintfz (name, sizeof(name), "saves/%s/%s.lvx", savename, level);
else
Q_snprintfz (name, sizeof(name), "saves/%s.lvx", level);
file = FS_MallocFile(name, FS_GAME, &filelen);
if (file)
{
s = file;
//Read config strings
for (i = 0; i < countof(sv.strings.configstring) && s < file+filelen; i++)
{
Z_Free((char*)sv.strings.configstring[i]);
sv.strings.configstring[i] = Z_StrDup(s);
s += strlen(s)+1;
}
for (i = 0; s < file+filelen; i++)
{
if (!*s)
break;
if (i < countof(sv.strings.q2_extramodels))
{
Z_Free((char*)sv.strings.q2_extramodels[i]);
sv.strings.q2_extramodels[i] = Z_StrDup(s);
}
s += strlen(s)+1;
}
for (; i < countof(sv.strings.q2_extramodels); i++)
{
Z_Free((char*)sv.strings.q2_extramodels[i]);
sv.strings.q2_extramodels[i] = NULL;
}
for (i = 0; s < file+filelen; i++)
{
if (!*s)
break;
if (i < countof(sv.strings.q2_extrasounds))
{
Z_Free((char*)sv.strings.q2_extrasounds[i]);
sv.strings.q2_extrasounds[i] = Z_StrDup(s);
}
s += strlen(s)+1;
}
for (; i < countof(sv.strings.q2_extrasounds); i++)
{
Z_Free((char*)sv.strings.q2_extrasounds[i]);
sv.strings.q2_extrasounds[i] = NULL;
}
//Read portal state
CM_ReadPortalState(sv.world.worldmodel, s, (file+filelen)-s);
FS_FreeFile(file);
}
ge->ReadLevel(loc.rawname);
for (i=0 ; i<100 ; i++) //run for 10 secs to iron out a few bugs.
ge->RunFrame ();
return true;
}
#endif
// we can't call SCR_BeginLoadingPlaque, because too much stack space has
// been used. The menu calls it before stuffing loadgame command
// SCR_BeginLoadingPlaque ();
f = FS_OpenVFS(name, "rb", FS_GAME);
if (!f)
{
if (isloadgame)
Con_Printf ("ERROR: Couldn't load \"%s\"\n", name);
return false;
}
VFS_GETS(f, str, sizeof(str));
version = atoi(str);
if (version != CACHEGAME_VERSION_OLD && version != CACHEGAME_VERSION_VERBOSE && version != CACHEGAME_VERSION_MODSAVED)
{
VFS_CLOSE (f);
Con_TPrintf ("Savegame is version %i, not %i\n", version, CACHEGAME_VERSION_DEFAULT);
return false;
}
VFS_GETS(f, str, sizeof(str)); //comment
SV_SendMessagesToAll();
if (version == CACHEGAME_VERSION_OLD)
{
VFS_GETS(f, str, sizeof(str));
pt = atof(str);
// this silliness is so we can load 1.06 save files, which have float skill values
VFS_GETS(f, str, sizeof(str));
current_skill = (int)(atof(str) + 0.1);
Cvar_Set (&skill, va("%i", current_skill));
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (&deathmatch, atof(str));
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (&coop, atof(str));
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (&teamplay, atof(str));
VFS_GETS(f, mapname, sizeof(mapname));
VFS_GETS(f, str, sizeof(str));
time = atof(str);
}
else
{
time = 0;
pt = PROG_UNKNOWN;
while (VFS_GETS(f, str, sizeof(str)))
{
char *s = str;
cvar_t *var;
s = COM_Parse(s);
if (!strcmp(com_token, "map"))
{ //map "foo": terminates the preamble.
COM_ParseOut(s, mapname, sizeof(mapname));
break;
}
else if (!strcmp(com_token, "cvar"))
{
s = COM_Parse(s);
var = Cvar_FindVar(com_token);
s = COM_Parse(s);
if (var)
Cvar_Set(var, com_token);
}
else if (!strcmp(com_token, "time"))
{
s = COM_Parse(s);
time = atof(com_token);
}
else if (!strcmp(com_token, "vmmode"))
{
s = COM_Parse(s);
if (!strcmp(com_token, "NONE")) pt = PROG_NONE;
else if (!strcmp(com_token, "QW")) pt = PROG_QW;
else if (!strcmp(com_token, "NQ")) pt = PROG_NQ;
else if (!strcmp(com_token, "H2")) pt = PROG_H2;
else if (!strcmp(com_token, "PREREL")) pt = PROG_PREREL;
else if (!strcmp(com_token, "TENEBRAE")) pt = PROG_TENEBRAE;
else if (!strcmp(com_token, "UNKNOWN")) pt = PROG_UNKNOWN;
else pt = PROG_UNKNOWN;
}
else
Con_TPrintf ("Unknown savegame directive %s\n", com_token);
}
}
//NOTE: This sets up the default baselines+statics+ambients.
//FIXME: if any model names changed, then we're screwed.
SV_SpawnServer (mapname, startspot, false, false, svs.allocated_client_slots);
sv.time = time;
if (svs.gametype != gametype)
{
VFS_CLOSE (f);
Con_Printf("Incorrect gamecode type. Cannot load game.\n");
return false;
}
if (sv.state != ss_active)
{
VFS_CLOSE (f);
Con_TPrintf ("Couldn't load map\n");
return false;
}
if (version == CACHEGAME_VERSION_MODSAVED)
{
const char *line;
void *pr_globals = PR_globals(svprogfuncs, PR_CURRENT);
func_t restorefunc = PR_FindFunction(svprogfuncs, "SV_PerformLoad", PR_ANY);
com_tokentype_t tt;
if (!restorefunc)
{
VFS_CLOSE (f);
Con_TPrintf ("SV_PerformLoad missing, unable to load game\n");
return false;
}
//shove it into a buffer to make the next bit easier.
filepos = VFS_TELL(f);
filelen = VFS_GETLEN(f);
filelen -= filepos;
file = BZ_Malloc(filelen+1);
memset(file, 0, filelen+1);
filelen = VFS_READ(f, file, filelen);
VFS_CLOSE (f);
if ((int)filelen < 0)
filelen = 0;
file[filelen]='\0';
//look for possible engine commands followed by a 'moddata' line (with no args)
line = file;
while(line && *line)
{
if (SV_ExtendedSaveData(svprogfuncs, NULL, &line))
continue;
line = COM_ParseTokenOut(line, NULL, com_token, sizeof(com_token), &tt);
if (!strcmp(com_token, "moddata"))
{
//loop till end of line
while (line && tt != TTP_LINEENDING)
line = COM_ParseTokenOut(line, NULL, com_token, sizeof(com_token), &tt);
break; //terminates the postamble
}
//loop till end of line
while (line && tt != TTP_LINEENDING)
line = COM_ParseTokenOut(line, NULL, com_token, sizeof(com_token), &tt);
}
if (!line)
{
BZ_Free(file);
Con_TPrintf ("unsupported saved game\n");
return false;
}
// for(i = sv.allocated_client_slots+1; i < sv.world.num_edicts; i++)
// svprogfuncs->EntFree (svprogfuncs, EDICT_NUM_PB(svprogfuncs, i), false);
//and now we can stomp on everything. yay.
sv.world.edicts[0].readonly = false;
G_FLOAT(OFS_PARM0) = PR_QCFile_From_Buffer(svprogfuncs, name, file, line-file, filelen);
G_FLOAT(OFS_PARM1) = sv.world.num_edicts;
G_FLOAT(OFS_PARM2) = sv.allocated_client_slots;
PR_ExecuteProgram(svprogfuncs, restorefunc);
sv.world.edicts[0].readonly = true;
//in case they forgot to setorigin everything after blindly loading its fields...
World_ClearWorld (&sv.world, true);
//let time jump to match whatever time the mod wanted.
sv.time = sv.world.physicstime = pr_global_struct->time = time;
sv.starttime = Sys_DoubleTime() - sv.time;
return true;
}
// load the edicts out of the savegame file
// the rest of the file is sent directly to the progs engine.
/*hexen2's gamecode doesn't have SAVE set on all variables, in which case we must clobber them, and run the risk that they were set at map load time, but clear in the savegame.*/
if (progstype != PROG_H2)
{
Q_SetProgsParms(false);
PR_Configure(svprogfuncs, PR_ReadBytesString(pr_ssqc_memsize.string), MAX_PROGS, pr_enable_profiling.ival);
PR_RegisterFields();
PR_InitEnts(svprogfuncs, sv.world.max_edicts);
}
if (version == CACHEGAME_VERSION_OLD)
{
// load the light styles
VFS_GETS(f, str, sizeof(str));
numstyles = atoi(str);
if (numstyles > MAX_NET_LIGHTSTYLES)
{
VFS_CLOSE (f);
Con_Printf ("load failed - invalid number of lightstyles\n");
return false;
}
for (i = 0; i<sv.maxlightstyles ; i++)
{
if (sv.lightstyles[i].str)
BZ_Free((void*)sv.lightstyles[i].str);
sv.lightstyles[i].str = NULL;
}
Z_ReallocElements((void**)&sv.lightstyles, &sv.maxlightstyles, numstyles, sizeof(*sv.lightstyles));
for (i=0 ; i<numstyles ; i++)
{
VFS_GETS(f, str, sizeof(str));
sv.lightstyles[i].str = Z_StrDup(str);
}
for ( ; i<sv.maxlightstyles ; i++)
{
sv.lightstyles[i].str = Z_StrDup("");
}
modelpos = VFS_TELL(f);
LoadModelsAndSounds(f);
}
else
modelpos = 0;
filepos = VFS_TELL(f);
filelen = VFS_GETLEN(f);
filelen -= filepos;
file = BZ_Malloc(filelen+1);
memset(file, 0, filelen+1);
VFS_READ(f, file, filelen);
file[filelen]='\0';
sv.world.edict_size=svprogfuncs->load_ents(svprogfuncs, file, NULL, NULL, SV_ExtendedSaveData);
BZ_Free(file);
progstype = pt;
PR_LoadGlabalStruct(false);
pr_global_struct->time = sv.time = sv.world.physicstime = time;
sv.starttime = Sys_DoubleTime() - sv.time;
if (modelpos != 0)
{
VFS_SEEK(f, modelpos);
LoadModelsAndSounds(f);
}
VFS_CLOSE(f);
PF_InitTempStrings(svprogfuncs);
World_ClearWorld (&sv.world, true);
for (i=0 ; i<svs.allocated_client_slots ; i++)
{
if (i < sv.allocated_client_slots)
ent = EDICT_NUM_PB(svprogfuncs, i+1);
else
ent = NULL;
svs.clients[i].edict = ent;
ent->ereftype = ER_ENTITY; //should have already been allocated.
svs.clients[i].name = PR_AddString(svprogfuncs, svs.clients[i].namebuf, sizeof(svs.clients[i].namebuf), false);
svs.clients[i].team = PR_AddString(svprogfuncs, svs.clients[i].teambuf, sizeof(svs.clients[i].teambuf), false);
//svs.clients[i].spawned = (svs.clients[i].state == cs_loadzombie);
#ifdef HEXEN2
if (ent)
svs.clients[i].playerclass = ent->xv->playerclass;
else
svs.clients[i].playerclass = 0;
#endif
}
if (!isloadgame)
{
eval = PR_FindGlobal(svprogfuncs, "startspot", 0, NULL);
if (eval) eval->_int = (int)PR_NewString(svprogfuncs, startspot);
eval = PR_FindGlobal(svprogfuncs, "ClientReEnter", 0, NULL);
if (eval)
for (i=0 ; i<sv.allocated_client_slots ; i++)
{
if (svs.clients[i].spawninfo)
{
globalvars_t *pr_globals = PR_globals(svprogfuncs, PR_CURRENT);
ent = svs.clients[i].edict;
j = strlen(svs.clients[i].spawninfo);
svprogfuncs->restoreent(svprogfuncs, svs.clients[i].spawninfo, &j, ent);
e2 = svprogfuncs->GetEdictFieldValue(svprogfuncs, ent, "stats_restored", ev_float, NULL);
if (e2)
e2->_float = 1;
SV_SpawnParmsToQC(host_client);
pr_global_struct->time = sv.world.physicstime;
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, ent);
World_UnlinkEdict((wedict_t*)ent);
G_FLOAT(OFS_PARM0) = sv.time-host_client->spawninfotime;
PR_ExecuteProgram(svprogfuncs, eval->function);
// if (svs.clients[i].state == cs_loadzombie)
// svs.clients[i].istobeloaded = 1;
// else
// svs.clients[i].state = cs_spawned; //don't do a separate ClientConnect.
}
}
pr_global_struct->serverflags = svs.serverflags;
}
pr_global_struct->time = sv.world.physicstime;
for (i=0 ; i<sv.world.num_edicts ; i++)
{
ent = EDICT_NUM_PB(svprogfuncs, i);
if (ED_ISFREE(ent))
continue;
/*hexen2 instead overwrites ents, which can theoretically be unreliable (ents with this flag are not saved in the first place, and thus are effectively reset instead of reloaded).
fte purges all ents beforehand in a desperate attempt to remain sane.
this behaviour does not match exactly, but is enough for vanilla hexen2/POP.
*/
if ((unsigned int)ent->v->flags & FL_HUBSAVERESET)
{
func_t f;
/*set some minimal fields*/
ent->v->solid = SOLID_NOT;
ent->v->use = 0;
ent->v->touch = 0;
ent->v->think = 0;
ent->v->nextthink = 0;
/*reinvoke the spawn function*/
pr_global_struct->time = 0.1;
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, ent);
f = PR_FindFunction(svprogfuncs, PR_GetString(svprogfuncs, ent->v->classname), PR_ANY);
if (f)
PR_ExecuteProgram(svprogfuncs, f);
}
}
return true; //yay
}
void SV_SaveLevelCache(const char *savedir, qboolean dontharmgame)
{
size_t len;
char *s;
client_t *cl;
int clnum;
char name[256];
vfsfile_t *f;
int i;
char comment[SAVEGAME_COMMENT_LENGTH+1];
levelcache_t *cache;
int version = CACHEGAME_VERSION_DEFAULT;
func_t func;
if (!sv.state)
return;
if (!dontharmgame)
{
cache = svs.levcache;
while(cache)
{
if (!strcmp(cache->mapname, svs.name))
break;
cache = cache->next;
}
if (!cache) //not visited yet. Let us know that we went there.
{
cache = Z_Malloc(sizeof(levelcache_t)+strlen(svs.name)+1);
cache->mapname = (char *)(cache+1);
strcpy(cache->mapname, svs.name);
cache->gametype = svs.gametype;
cache->next = svs.levcache;
svs.levcache = cache;
}
}
if (savedir)
Q_snprintfz (name, sizeof(name), "saves/%s/%s.lvc", savedir, svs.name);
else
Q_snprintfz (name, sizeof(name), "saves/%s.lvc", svs.name);
FS_CreatePath(name, FS_GAMEONLY);
if (!dontharmgame) //save game in progress
Con_TPrintf ("Saving game to %s...\n", name);
#ifdef Q2SERVER
if (ge)
{
char syspath[256];
if (!FS_NativePath(name, FS_GAMEONLY, syspath, sizeof(syspath)))
return;
ge->WriteLevel(syspath);
if (savedir)
Q_snprintfz (name, sizeof(name), "saves/%s/%s.lvx", savedir, svs.name);
else
Q_snprintfz (name, sizeof(name), "saves/%s.lvx", svs.name);
//write configstrings
f = FS_OpenVFS (name, "wbp", FS_GAMEONLY);
if (f)
{
size_t portalblobsize;
void *portalblob = NULL;
for (i = 0; i < countof(sv.strings.configstring); i++)
{
if (sv.strings.configstring[i])
VFS_WRITE(f, sv.strings.configstring[i], strlen(sv.strings.configstring[i])+1);
else
VFS_WRITE(f, "", 1);
}
for (i = 0; i < countof(sv.strings.q2_extramodels); i++)
{
if (!sv.strings.q2_extramodels[i])
break;
VFS_WRITE(f, sv.strings.q2_extramodels[i], strlen(sv.strings.q2_extramodels[i])+1);
}
VFS_WRITE(f, "", 1);
for (i = 0; i < countof(sv.strings.q2_extrasounds); i++)
{
if (!sv.strings.q2_extrasounds[i])
break;
VFS_WRITE(f, sv.strings.q2_extrasounds[i], strlen(sv.strings.q2_extrasounds[i])+1);
}
VFS_WRITE(f, "", 1);
portalblobsize = CM_WritePortalState(sv.world.worldmodel, &portalblob);
VFS_WRITE(f, portalblob, portalblobsize);
VFS_CLOSE(f);
}
FS_FlushFSHashFull();
return;
}
#endif
#ifdef HLSERVER
if (svs.gametype == GT_HALFLIFE)
{
SVHL_SaveLevelCache(name);
FS_FlushFSHashFull();
return;
}
#endif
func = PR_FindFunction(svprogfuncs, "SV_PerformSave", PR_ANY);
if (func)
version = CACHEGAME_VERSION_MODSAVED;
f = FS_OpenVFS (name, "wbp", FS_GAMEONLY);
if (!f)
{
Con_TPrintf ("ERROR: couldn't open %s.\n", name);
return;
}
VFS_PRINTF (f, "%i\n", version);
SV_SavegameComment (comment, sizeof(comment));
VFS_PRINTF (f, "%s\n", comment);
if (!dontharmgame)
{
//map-change caches require the players to have been de-spawned
//saved games require players to retain their fields.
//probably this should happen elsewhere.
for (cl = svs.clients, clnum=0; clnum < sv.allocated_client_slots; cl++,clnum++)//fake dropping
{
if (cl->state < cs_connected)
continue;
else if (progstype == PROG_H2)
cl->edict->ereftype = ER_FREE; //hexen2 has some annoying prints. it never formally dropped clients on map changes (we'll reset this later, so they'll just not appear in the saved game).
else if (!cl->spawned) //don't drop if they are still connecting
cl->edict->v->solid = 0;
else
SV_DespawnClient(cl);
}
}
if (version >= CACHEGAME_VERSION_VERBOSE)
{
char buf[8192];
char *mode = "?";
switch(progstype)
{
case PROG_NONE: break;
case PROG_QW: mode = "QW"; break;
case PROG_NQ: mode = "NQ"; break;
case PROG_H2: mode = "H2"; break;
case PROG_PREREL: mode = "PREREL"; break;
case PROG_TENEBRAE: mode = "TENEBRAE"; break;
case PROG_UNKNOWN: mode = "UNKNOWN"; break;
}
VFS_PRINTF (f, "vmmode %s\n", COM_QuotedString(mode, buf, sizeof(buf), false));
VFS_PRINTF (f, "cvar skill %s\n", COM_QuotedString(skill.string, buf, sizeof(buf), false));
VFS_PRINTF (f, "cvar deathmatch %s\n", COM_QuotedString(deathmatch.string, buf, sizeof(buf), false));
VFS_PRINTF (f, "cvar coop %s\n", COM_QuotedString(coop.string, buf, sizeof(buf), false));
VFS_PRINTF (f, "cvar teamplay %s\n", COM_QuotedString(teamplay.string, buf, sizeof(buf), false));
VFS_PRINTF (f, "time %f\n", sv.time);
VFS_PRINTF (f, "map %s\n", COM_QuotedString(svs.name, buf, sizeof(buf), false));
}
else
{
VFS_PRINTF (f, "%d\n", progstype);
VFS_PRINTF (f, "%f\n", skill.value);
VFS_PRINTF (f, "%f\n", deathmatch.value);
VFS_PRINTF (f, "%f\n", coop.value);
VFS_PRINTF (f, "%f\n", teamplay.value);
VFS_PRINTF (f, "%s\n", svs.name);
VFS_PRINTF (f, "%f\n", sv.time);
// write the light styles
VFS_PRINTF (f, "%u\n",(unsigned)sv.maxlightstyles);
for (i=0 ; i<sv.maxlightstyles ; i++)
{
VFS_PRINTF (f, "%s\n", sv.lightstyles[i].str?sv.lightstyles[i].str:"");
}
for (i=1 ; i<MAX_PRECACHE_MODELS ; i++)
{
if (sv.strings.model_precache[i] && *sv.strings.model_precache[i])
VFS_PRINTF (f, "%s\n", sv.strings.model_precache[i]);
else
break;
}
VFS_PRINTF (f,"\n");
for (i=1 ; i<MAX_PRECACHE_SOUNDS ; i++)
{
if (sv.strings.sound_precache[i] && *sv.strings.sound_precache[i])
VFS_PRINTF (f, "%s\n", sv.strings.sound_precache[i]);
else
break;
}
VFS_PRINTF (f,"\n");
}
if (version == CACHEGAME_VERSION_MODSAVED)
{
struct globalvars_s *pr_globals = PR_globals(svprogfuncs, PR_CURRENT);
func_t func = PR_FindFunction(svprogfuncs, "SV_PerformSave", PR_ANY);
//FIXME: save precaches here.
VFS_PRINTF (f, "moddata\n");
G_FLOAT(OFS_PARM0) = PR_QCFile_From_VFS(svprogfuncs, name, f, true);
G_FLOAT(OFS_PARM1) = sv.world.num_edicts;
G_FLOAT(OFS_PARM2) = sv.allocated_client_slots;
PR_ExecuteProgram(svprogfuncs, func);
}
else
{
/*if (version >= CACHEGAME_VERSION_BINARY)
{
VFS_PUTS(f, va("%i\n", svprogfuncs->stringtablesize));
VFS_WRITE(f, svprogfuncs->stringtable, svprogfuncs->stringtablesize);
}
else*/
{
s = PR_SaveEnts(svprogfuncs, NULL, &len, 0, 1);
VFS_PUTS(f, s);
VFS_PUTS(f, "\n");
svprogfuncs->parms->memfree(s);
}
if (version >= CACHEGAME_VERSION_VERBOSE)
{
char buf[8192];
for (i=0 ; i<sv.maxlightstyles ; i++)
if (sv.lightstyles[i].str)
VFS_PRINTF (f, "lightstyle %i %s %f %f %f\n", i, COM_QuotedString(sv.lightstyles[i].str, buf, sizeof(buf), false), sv.lightstyles[i].colours[0], sv.lightstyles[i].colours[1], sv.lightstyles[i].colours[2]);
for (i=1 ; i<MAX_PRECACHE_MODELS ; i++)
if (sv.strings.model_precache[i] && *sv.strings.model_precache[i])
VFS_PRINTF (f, "model %i %s\n", i, COM_QuotedString(sv.strings.model_precache[i], buf, sizeof(buf), false));
for (i=1 ; i<MAX_PRECACHE_SOUNDS ; i++)
if (sv.strings.sound_precache[i] && *sv.strings.sound_precache[i])
VFS_PRINTF (f, "sound %i %s\n", i, COM_QuotedString(sv.strings.sound_precache[i], buf, sizeof(buf), false));
for (i=1 ; i<MAX_SSPARTICLESPRE ; i++)
if (sv.strings.particle_precache[i] && *sv.strings.particle_precache[i])
VFS_PRINTF (f, "particle %i %s\n", i, COM_QuotedString(sv.strings.particle_precache[i], buf, sizeof(buf), false));
#ifdef HAVE_LEGACY
for (i = 0; i < sizeof(sv.strings.vw_model_precache)/sizeof(sv.strings.vw_model_precache[0]); i++)
if (sv.strings.vw_model_precache[i])
VFS_PRINTF (f, "vwep %i %s\n", i, COM_QuotedString(sv.strings.vw_model_precache[i], buf, sizeof(buf), false));
#endif
PR_Common_SaveGame(f, svprogfuncs, false);//, version >= CACHEGAME_VERSION_BINARY);
//FIXME: string buffers
//FIXME: hash tables
//FIXME: skeletal objects?
//FIXME: static entities
//FIXME: midi track
//FIXME: custom temp-ents?
//FIXME: pending uri_gets? (if only just to report fails on load)
//FIXME: routing calls?
//FIXME: sql queries?
//FIXME: frik files?
//FIXME: qc threads?
// portalblobsize = CM_WritePortalState(sv.world.worldmodel, &portalblob);
// VFS_WRITE(f, portalblob, portalblobsize);
}
VFS_CLOSE (f);
}
if (!dontharmgame)
{
for (clnum=0; clnum < sv.allocated_client_slots; clnum++)
{
edict_t *ed = EDICT_NUM_PB(svprogfuncs, clnum+1);
ed->ereftype = ER_ENTITY;
}
}
FS_FlushFSHashWritten(name);
}
//mapchange is true for Q2's map-change autosaves.
void SV_Savegame (const char *savename, qboolean mapchange)
{
client_t *cl;
int clnum;
char comment[(SAVEGAME_COMMENT_LENGTH+1)*2];
vfsfile_t *f;
int len;
levelcache_t *cache;
char *savefilename;
if (!sv.state || sv.state == ss_clustermode)
{
Con_Printf("Server is not active - unable to save\n");
return;
}
if (sv.state == ss_cinematic)
{
Con_Printf("Server is playing a cinematic - unable to save\n");
return;
}
#ifndef QUAKETC
{
int savefmt = sv_savefmt.ival;
if (!*sv_savefmt.string && (svs.gametype != GT_PROGS || progstype == PROG_H2 || svs.levcache || (progstype == PROG_QW && strcmp(pr_ssqc_progs.string, "spprogs")) || (svs.gametype==GT_PROGS && PR_FindFunction(svprogfuncs, "SV_PerformSave", PR_ANY))))
savefmt = 1; //hexen2+q2/etc must not use the legacy format by default. can't use it when using any kind of hub system either (harder to detect upfront, which might give confused saved game naming but will at least work).
else
savefmt = sv_savefmt.ival;
if (!savefmt && !mapchange)
{
if (SV_LegacySavegame(savename, *sv_savefmt.string))
return;
if (*sv_savefmt.string)
Con_Printf("Unable to use legacy saved game format\n");
}
}
#endif
switch(svs.gametype)
{
default:
case GT_Q1QVM:
#ifdef VM_LUA
case GT_LUA:
#endif
Con_Printf("gamecode doesn't support saving\n");
return;
case GT_PROGS:
case GT_QUAKE2:
break;
}
if (sv.allocated_client_slots == 1 && svs.gametype == GT_PROGS)
{
if (svs.clients->state > cs_connected && svs.clients[0].edict->v->health <= 0)
{
Con_Printf("Refusing to save while dead.\n");
return;
}
}
//FIXME: we should probably block saving during intermission too.
/*catch invalid names*/
if (!*savename || strstr(savename, ".."))
savename = "quick";
savefilename = va("saves/%s/info.fsv", savename);
FS_CreatePath(savefilename, FS_GAMEONLY);
f = FS_OpenVFS(savefilename, "wbp", FS_GAMEONLY);
if (!f)
{
Con_Printf("Couldn't open file saves/%s/info.fsv\n", savename);
return;
}
SV_SavegameComment(comment, sizeof(comment));
VFS_PRINTF (f, "%d\n", SAVEGAME_VERSION_FTE_HUB+svs.gametype);
VFS_PRINTF (f, "%s\n", comment);
VFS_PRINTF(f, "%i\n", sv.allocated_client_slots);
for (cl = svs.clients, clnum=0; clnum < sv.allocated_client_slots; cl++,clnum++)
{
//FIXME: the qc is only told about the new client when the client finally sends a begin.
// this means that if we save a client that is still connecting, the loading code HAS to assume that the qc already knows about the player.
// this means that such players would not be loaded properly anyway, and would bug out the server.
// so its best to not bother saving them at all. pro-top: don't save shortly after a map change in coop/sp.
//istobeloaded means that the qc has already been told about the client from a previous saved game, regardless of the fact that they're still technically connecting (this may even be a zombie with no actual client connection).
//note that autosave implies that we're saving on a map boundary. this is for q2 gamecode. q1 can't cope.
if (cl->state < cs_spawned && !cl->istobeloaded) //don't save if they are still connecting
{
VFS_PRINTF(f, "\n");
continue;
}
VFS_PRINTF(f, "%s\n", cl->name);
if (*cl->name)
{
char tmp[65536];
VFS_PRINTF(f, "{\n");
for (len = 0; len < NUM_SPAWN_PARMS; len++)
VFS_PRINTF(f, "\tparm%i 0x%x //%.9g\n", len, *(int*)&cl->spawn_parms[len], cl->spawn_parms[len]); //write hex as not everyone passes a float in the parms.
VFS_PRINTF(f, "\tparm_string %s\n", COM_QuotedString(cl->spawn_parmstring?cl->spawn_parmstring:"", tmp, sizeof(tmp), false));
/*if (cl->spawninfo)
{
VFS_PRINTF(f, "\tspawninfo %s\n", COM_QuotedString(cl->spawninfo, tmp, sizeof(tmp), false));
VFS_PRINTF(f, "\tspawninfotime %9g\n", cl->spawninfotime);
}*/
VFS_PRINTF(f, "}\n"); //write ints as not everyone passes a float in the parms.
}
}
InfoBuf_WriteToFile(f, &svs.info, NULL, 0);
VFS_PUTS(f, "\n");
InfoBuf_WriteToFile(f, &svs.localinfo, NULL, 0);
VFS_PRINTF (f, "\n{\n"); //all game vars. FIXME: Should save the ones that have been retrieved/set by progs.
VFS_PRINTF (f, "skill \"%s\"\n", skill.string);
VFS_PRINTF (f, "deathmatch \"%s\"\n", deathmatch.string);
VFS_PRINTF (f, "coop \"%s\"\n", coop.string);
VFS_PRINTF (f, "teamplay \"%s\"\n", teamplay.string);
VFS_PRINTF (f, "nomonsters \"%s\"\n", nomonsters.string);
VFS_PRINTF (f, "gamecfg\t \"%s\"\n", gamecfg.string);
VFS_PRINTF (f, "scratch1 \"%s\"\n", scratch1.string);
VFS_PRINTF (f, "scratch2 \"%s\"\n", scratch2.string);
VFS_PRINTF (f, "scratch3 \"%s\"\n", scratch3.string);
VFS_PRINTF (f, "scratch4 \"%s\"\n", scratch4.string);
VFS_PRINTF (f, "savedgamecfg\t \"%s\"\n", savedgamecfg.string);
VFS_PRINTF (f, "saved1 \"%s\"\n", saved1.string);
VFS_PRINTF (f, "saved2 \"%s\"\n", saved2.string);
VFS_PRINTF (f, "saved3 \"%s\"\n", saved3.string);
VFS_PRINTF (f, "saved4 \"%s\"\n", saved4.string);
VFS_PRINTF (f, "temp1 \"%s\"\n", temp1.string);
VFS_PRINTF (f, "noexit \"%s\"\n", noexit.string);
VFS_PRINTF (f, "pr_maxedicts\t \"%s\"\n", pr_maxedicts.string);
VFS_PRINTF (f, "progs \"%s\"\n", pr_ssqc_progs.string);
VFS_PRINTF (f, "set nextserver \"%s\"\n", Cvar_Get("nextserver", "", 0, "")->string);
VFS_PRINTF (f, "}\n");
SV_SaveLevelCache(savename, true); //add the current level.
cache = svs.levcache; //state from previous levels - just copy it all accross.
VFS_PRINTF(f, "{\n");
while(cache)
{
VFS_PRINTF(f, "%s\n", cache->mapname);
if (strcmp(cache->mapname, svs.name))
{
FS_Copy(va("saves/%s.lvc", cache->mapname), va("saves/%s/%s.lvc", savename, cache->mapname), FS_GAME, FS_GAME);
}
cache = cache->next;
}
VFS_PRINTF(f, "}\n");
VFS_PRINTF (f, "%s\n", svs.name);
VFS_PRINTF (f, "%i\n", svs.serverflags);
VFS_CLOSE(f);
#ifdef HAVE_CLIENT
//try to save screenshots automagically.
Q_snprintfz(comment, sizeof(comment), "saves/%s/screeny.%s", savename, "tga");//scr_sshot_type.string);
savefilename = comment;
FS_Remove(savefilename, FS_GAMEONLY);
if (cls.state == ca_active && qrenderer > QR_NONE && qrenderer != QR_VULKAN/*FIXME*/)
{
int stride;
int width = vid.pixelwidth;
int height = vid.pixelheight;
image_t *img;
uploadfmt_t format;
void *rgbbuffer = SCR_ScreenShot_Capture(width, height, &stride, &format, false, false);
if (rgbbuffer)
{
// extern cvar_t scr_sshot_type;
SCR_ScreenShot(savefilename, FS_GAMEONLY, &rgbbuffer, 1, stride, width, height, format, false);
BZ_Free(rgbbuffer);
//if any menu code has the shader loaded, we want to avoid them using a cache.
//hopefully the menu code will unload as it goes, because these screenshots could be truely massive, as they're taken at screen resolution.
//should probably use a smaller fbo or something, but whatever.
img = Image_FindTexture(va("saves/%s/screeny.%s", savename, "tga"), NULL, 0);
if (img)
{
if (Image_UnloadTexture(img))
{
//and then reload it so that any shaders using it don't get confused
Image_GetTexture(va("saves/%s/screeny.%s", savename, "tga"), NULL, 0, NULL, NULL, 0, 0, TF_INVALID);
}
}
}
}
#endif
#ifdef Q2SERVER
//save the player's inventory and other map-persistant state that is owned by the gamecode.
if (ge)
{
char syspath[256];
if (!FS_NativePath(va("saves/%s/game.gsv", savename), FS_GAMEONLY, syspath, sizeof(syspath)))
return;
ge->WriteGame(syspath, mapchange);
FS_FlushFSHashFull();
}
else
#endif
{
//fixme
FS_FlushFSHashFull();
}
Q_strncpyz(sv.loadgame_on_restart, savename, sizeof(sv.loadgame_on_restart));
}
static int QDECL CompleteSaveList (const char *name, qofs_t flags, time_t mtime, void *parm, searchpathfuncs_t *spath)
{
struct xcommandargcompletioncb_s *ctx = parm;
char trimmed[256];
size_t l;
Q_strncpyz(trimmed, name+6, sizeof(trimmed));
l = strlen(trimmed);
if (l >= 9 && !Q_strcasecmp(trimmed+l-9, "/info.fsv"))
{
trimmed[l-9] = 0;
ctx->cb(trimmed, NULL, NULL, ctx);
}
return true;
}
#ifndef QUAKETC
static int QDECL CompleteSaveListLegacy (const char *name, qofs_t flags, time_t mtime, void *parm, searchpathfuncs_t *spath)
{
struct xcommandargcompletioncb_s *ctx = parm;
char stripped[64];
COM_StripExtension(name, stripped, sizeof(stripped));
ctx->cb(stripped, NULL, NULL, ctx);
return true;
}
#endif
void SV_Savegame_c(int argn, const char *partial, struct xcommandargcompletioncb_s *ctx)
{
if (argn == 1)
{
COM_EnumerateFiles(va("saves/%s*/info.fsv", partial), CompleteSaveList, ctx);
#ifndef QUAKETC
COM_EnumerateFiles(va("%s*.sav", partial), CompleteSaveListLegacy, ctx);
#endif
}
}
void SV_Savegame_f (void)
{
if (sv.state == ss_clustermode && MSV_ForwardToAutoServer())
;
else if (Cmd_Argc() <= 2)
{
const char *savename = Cmd_Argv(1);
if (strstr(savename, ".."))
{
Con_TPrintf ("Relative pathnames are not allowed\n");
return;
}
//make sure the name is valid, eg if its omitted.
if (!*savename || strstr(savename, ".."))
savename = "quick";
#ifndef QUAKETC
if (!Q_strcasecmp(Cmd_Argv(0), "savegame_legacy"))
{
if (SV_LegacySavegame(savename, true))
return;
Con_Printf("Unable to use legacy save format\n");
return;
}
#endif
SV_Savegame(savename, false);
}
else
Con_Printf("%s: invalid number of arguments\n", Cmd_Argv(0));
}
void SV_AutoSave(void)
{
#ifndef NOBUILTINMENUS
#ifndef SERVERONLY
const char *autosavename;
int i;
if (sv_autosave.value <= 0)
return;
if (sv.state != ss_active)
return;
switch(svs.gametype)
{
default: //probably broken. don't ever try.
return;
case GT_Q1QVM:
case GT_PROGS:
//don't bother to autosave multiplayer games.
//this may be problematic with splitscreen, but coop rules tend to apply there anyway.
if (sv.allocated_client_slots != 1)
return;
for (i = 0; i < sv.allocated_client_slots; i++)
{
if (svs.clients[i].state == cs_spawned)
{
if (svs.clients[i].edict->v->health <= 0)
return; //autosaves with a dead player are just cruel.
if ((int)svs.clients[i].edict->v->flags & (FL_GODMODE | FL_NOTARGET))
return; //autosaves to highlight cheaters is also just spiteful.
if (svs.clients[i].edict->v->movetype != MOVETYPE_WALK)
return; //noclip|fly are cheaters, toss|bounce are bad at playing. etc.
if (!((int)svs.clients[i].edict->v->flags & FL_ONGROUND))
return; //autosaves while people are jumping are awkward.
if (svs.clients[i].edict->v->velocity[0] || svs.clients[i].edict->v->velocity[1] || svs.clients[i].edict->v->velocity[2])
return; //people running around are likely to result in poor saves
}
}
break;
}
autosavename = M_ChooseAutoSave();
Con_DPrintf("Autosaving to %s\n", autosavename);
SV_Savegame(autosavename, false);
sv.autosave_time = sv.time + sv_autosave.value * 60;
#endif
#endif
}
static void SV_SwapPlayers(client_t *a, client_t *b)
{
size_t i;
client_t tmp;
if (a==b)
return; //o.O
tmp = *a;
*a = *b;
*b = tmp;
//swap over pointers for splitscreen.
for (i = 0; i < svs.allocated_client_slots; i++)
{
if (svs.clients[i].controller == a)
svs.clients[i].controller = b;
else if (svs.clients[i].controller == b)
svs.clients[i].controller = a;
if (svs.clients[i].controlled == a)
svs.clients[i].controlled = b;
else if (svs.clients[i].controlled == b)
svs.clients[i].controlled = a;
}
//undo some damage...
b->edict = a->edict;
a->edict = tmp.edict;
if (a->name == b->namebuf) a->name = a->namebuf;
if (b->name == a->namebuf) b->name = b->namebuf;
if (a->team == b->teambuf) a->team = a->teambuf;
if (b->team == a->teambuf) b->team = b->teambuf;
if (a->netchan.message.data)
a->netchan.message.data += (qbyte*)a-(qbyte*)b;
if (a->datagram.data)
a->datagram.data += (qbyte*)a-(qbyte*)b;
if (a->backbuf.data)
a->backbuf.data += (qbyte*)a-(qbyte*)b;
if (b->netchan.message.data)
b->netchan.message.data += (qbyte*)b-(qbyte*)a;
if (b->datagram.data)
b->datagram.data += (qbyte*)b-(qbyte*)a;
if (b->backbuf.data)
b->backbuf.data += (qbyte*)b-(qbyte*)a;
}
void SV_LoadPlayers(loadplayer_t *lp, size_t slots)
{ //loading games is messy as fuck
//we need to reorder players to the order in the saved game.
//swapping players around is really rather messy...
client_t *cl;
size_t clnum, p, p2;
int to[255];
//kick any splitscreen seats. they'll get re-added after load (filling slots like connecting players would)
for (clnum = 0; clnum < svs.allocated_client_slots; clnum++)
{
cl = &svs.clients[clnum];
cl->controlled = NULL; //kill the links.
if (cl->controller) //its a slave
{
//unlink it
cl->controller = NULL;
//make it into a pseudo-bot so the kicking doesn't do weird stuff.
cl->netchan.remote_address.type = NA_INVALID; //so the remaining client doesn't get the kick too.
cl->protocol = SCP_BAD; //make it a bit like a bot, so we don't try sending any datagrams/reliables at someone that isn't able to receive anything.
//okay, it can get lost now.
cl->drop = true;
}
}
//despawn any entity data, and try to find the loaded player to move them to
for (clnum = 0; clnum < svs.allocated_client_slots; clnum++) //clear the server for the level change.
{
to[clnum] = -1;
cl = &svs.clients[clnum];
SV_DespawnClient(cl);
if (cl->state <= cs_loadzombie)
continue;
if (cl->state == cs_spawned)
cl->state = cs_connected;
//FIXME: try to match by guids (but we don't have saved guid info)
//try to match the player to a slot by name.
for (p = 0; p < slots; p++)
if (*lp[p].name)
{
if (!strcmp(cl->name, lp[p].name) || slots == 1)
{ //this player matched matched...
to[clnum] = p;
lp[p].source = cl;
break;
}
}
}
//for loaded players that don't have a client go and find a player to spawn there, to try to deal with players that renamed themselves.
for (p = 0; p < slots; p++)
{
if (!*lp[p].name || lp[p].source)
continue;
for (clnum = 0; clnum < svs.allocated_client_slots; clnum++)
{
cl = &svs.clients[clnum];
if (cl->state <= cs_loadzombie)
continue;
if (to[clnum] >= 0)
continue; //was already mapped
if (cl->spectator)
continue; //spectators shouldn't be pulled into a player against their will. it may still happen though.
to[clnum] = p;
lp[p].source = cl;
SV_BroadcastPrintf(PRINT_HIGH, "%s reprises %s\n", cl->name, lp[p].name);
break;
}
}
//we walk the list in order, pulling from the appropriate slot.
//we're swapping each time, so uninteresting players will bubble to the end instead of breaking our finalised list..
//if we're swapping from an earlier slot then that slot wasn't relevant anyway.
for (p = 0; p < slots; p++)
{
if (lp[p].source && lp[p].source!=&svs.clients[p])
{
SV_SwapPlayers(&svs.clients[p], lp[p].source);
for (p2 = 0; p2 < slots; p2++)
{
if (p == p2)
continue;
if (lp[p2].source == &svs.clients[p])
lp[p2].source = lp[p].source;
else if (lp[p2].source == lp[p].source)
lp[p2].source = &svs.clients[p];
}
}
}
if (slots > svs.allocated_client_slots) //will be trimmed later
SV_UpdateMaxPlayers(slots);
for (cl = svs.clients, clnum=0; clnum < slots; cl++,clnum++)
{
if (*lp[clnum].name)
{ //okay so we have a player ready for this slot.
for (p = 0; p < NUM_SPAWN_PARMS; p++)
cl->spawn_parms[p] = lp[clnum].parm[p].f;
cl->spawn_parmstring = lp[clnum].parmstr;
continue;
}
else if (cl->state > cs_zombie)
SV_DropClient(cl);
/*
Q_strncpyz(cl->namebuf, lp[clnum].name, sizeof(cl->namebuf));
cl->name = cl->namebuf;
if (*cl->namebuf)
{
cl->state = cs_loadzombie;
cl->connection_started = realtime+20;
cl->istobeloaded = true; //the parms are known
cl->userid = 0;
memset(&cl->netchan, 0, sizeof(cl->netchan));
for (p = 0; p < NUM_SPAWN_PARMS; p++)
cl->spawn_parms[p] = lp[clnum].parm[p].f;
cl->spawn_parmstring = lp[clnum].parmstr;
}*/
}
}
static void SV_GameLoaded(loadplayer_t *lp, size_t slots, const char *savename)
{
size_t clnum;
client_t *cl;
//make sure autosave doesn't save too early.
sv.autosave_time = sv.time + sv_autosave.value*60;
//let the restart command know the name of the saved game to reload.
Q_strncpyz(sv.loadgame_on_restart, savename, sizeof(sv.loadgame_on_restart));
slots = min(slots, svs.allocated_client_slots);
//make sure the player state is set up properly.
for (clnum = 0; clnum < slots; clnum++)
{
cl = &svs.clients[clnum];
cl->spawned = !!*lp[clnum].name;
if (cl->spawned)
{
sv.spawned_client_slots++;
Q_strncpyz(cl->namebuf, lp[clnum].name, sizeof(cl->namebuf));
}
cl->name = PR_AddString(svprogfuncs, cl->namebuf, sizeof(cl->namebuf), false);
cl->team = PR_AddString(svprogfuncs, cl->teambuf, sizeof(cl->teambuf), false);
cl->edict = EDICT_NUM_PB(svprogfuncs, clnum+1);
#ifdef HEXEN2
{
if (cl->edict)
cl->playerclass = cl->edict->xv->playerclass;
else
cl->playerclass = 0;
}
#endif
#ifdef HAVE_LEGACY
cl->edict->xv->clientcolors = cl->playercolor;
#endif
if (cl->state == cs_spawned) //shouldn't have gotten past SV_SpawnServer, but just in case...
cl->state = cs_connected; //client needs new serverinfo.
if (cl->spawned && cl->state < cs_connected) //make sure the player slot is active when the gamecode thinks it was (with a loadzombie if needed)
{
cl->state = cs_loadzombie;
cl->connection_started = realtime+20;
cl->istobeloaded = true; //the parms are known
cl->userid = 0;
memset(&cl->netchan, 0, sizeof(cl->netchan));
}
if (cl->controller)
continue;
if (cl->state>=cs_connected)
{
if (cl->protocol == SCP_QUAKE3)
continue;
if (cl->protocol == SCP_BAD)
continue;
host_client = cl;
#ifdef NQPROT
if (ISNQCLIENT(host_client))
SVNQ_New_f();
else
#endif
SV_New_f();
}
}
host_client = NULL;
//make sure userinfos match any renamed players.
for (clnum = 0; clnum < slots; clnum++)
if (svs.clients[clnum].state >= cs_connected)
SV_ExtractFromUserinfo (&svs.clients[clnum], true);
}
#ifndef QUAKETC
//expects the version to have already been parsed
static qboolean SV_Loadgame_Legacy(const char *savename, const char *filename, vfsfile_t *f, int version)
{
//FIXME: Multiplayer save probably won't work with spectators.
char mapname[MAX_QPATH];
float time;
char str[32768];
int i;
int pt;
int lstyles;
int slots;
int clnum;
char plname[32];
int filelen, filepos;
char *file;
char *modelnames[MAX_PRECACHE_MODELS];
char *soundnames[MAX_PRECACHE_SOUNDS];
loadplayer_t lp[255];
struct loadinfo_s loadinfo;
loadinfo.numplayers = countof(lp);
loadinfo.players = lp;
if (version != SAVEGAME_VERSION_FTE_LEG && version != SAVEGAME_VERSION_NQ && version != SAVEGAME_VERSION_QW)
{
VFS_CLOSE (f);
Con_TPrintf ("Unable to load savegame of version %i\n", version);
return false;
}
VFS_GETS(f, str, sizeof(str)); //discard comment.
Con_Printf("loading legacy game from %s...\n", filename);
if (version == SAVEGAME_VERSION_NQ || version == SAVEGAME_VERSION_QW)
{
slots = 1;
#ifdef SERVERONLY
Q_strncpyz(lp[0].name, "", sizeof(lp[0].name));
#else
Q_strncpyz(lp[0].name, name.string, sizeof(lp[0].name));
#endif
lp[0].parmstr = NULL;
lp[0].source = NULL;
for (i=0 ; i<16 ; i++)
{
VFS_GETS(f, str, sizeof(str));
lp[0].parm[i].f = atof(str);
}
for (; i < countof(lp[0].parm); i++)
lp[0].parm[i].i = 0;
}
else //fte saves ALL the clients on the server.
{
VFS_GETS(f, str, strlen(str));
slots = atoi(str);
if (!slots || slots >= countof(lp)) //err
{
VFS_CLOSE(f);
Con_Printf ("Corrupted save game");
return false;
}
for (clnum = 0; clnum < slots; clnum++)
{
VFS_GETS(f, plname, sizeof(plname));
COM_Parse(plname);
Q_strncpyz(lp[clnum].name, com_token, sizeof(lp[clnum].name));
lp[clnum].parmstr = NULL;
lp[clnum].source = NULL;
if (!*com_token)
continue;
//probably should be 32, rather than NUM_SPAWN_PARMS(64)
for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
{
VFS_GETS(f, str, sizeof(str));
lp[clnum].parm[i].f = atof(str);
}
for (; i < countof(lp[clnum].parm); i++)
lp[clnum].parm[i].i = 0;
}
}
SV_LoadPlayers(lp, slots);
if (version == SAVEGAME_VERSION_NQ || version == SAVEGAME_VERSION_QW)
{
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (Cvar_FindVar("skill"), atof(str));
Cvar_SetValue (Cvar_FindVar("deathmatch"), 0);
Cvar_SetValue (Cvar_FindVar("coop"), 0);
Cvar_SetValue (Cvar_FindVar("teamplay"), 0);
if (version == SAVEGAME_VERSION_NQ)
{
progstype = PROG_NQ;
Cvar_Set (&pr_ssqc_progs, "progs.dat"); //NQ's progs.
}
else
{
progstype = PROG_QW;
Cvar_Set (&pr_ssqc_progs, "spprogs"); //zquake's single player qw progs.
}
pt = 0;
}
else
{
VFS_GETS(f, str, sizeof(str));
pt = atoi(str);
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (Cvar_FindVar("skill"), atof(str));
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (Cvar_FindVar("deathmatch"), atof(str));
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (Cvar_FindVar("coop"), atof(str));
VFS_GETS(f, str, sizeof(str));
Cvar_SetValue (Cvar_FindVar("teamplay"), atof(str));
}
VFS_GETS(f, mapname, sizeof(mapname));
VFS_GETS(f, str, sizeof(str));
time = atof(str);
SV_SpawnServer (mapname, NULL, false, false, slots); //always inits MAX_CLIENTS slots. That's okay, because we can cut the max easily.
if (sv.state != ss_active)
{
VFS_CLOSE (f);
Con_TPrintf ("Couldn't load map\n");
return false;
}
if (sv.allocated_client_slots != slots)
{
Con_TPrintf ("Player count changed\n");
return false;
}
// load the light styles
lstyles = 64;
if (lstyles > sv.maxlightstyles)
Z_ReallocElements((void**)&sv.lightstyles, &sv.maxlightstyles, lstyles, sizeof(*sv.lightstyles));
for (i=0 ; i<lstyles ; i++)
{
VFS_GETS(f, str, sizeof(str));
if (sv.lightstyles[i].str)
Z_Free((char*)sv.lightstyles[i].str);
sv.lightstyles[i].str = Z_StrDup(str);
sv.lightstyles[i].colours[0] = sv.lightstyles[i].colours[1] = sv.lightstyles[i].colours[2] = 1;
}
for (; i < sv.maxlightstyles; i++)
{
if (sv.lightstyles[i].str)
Z_Free((char*)sv.lightstyles[i].str);
sv.lightstyles[i].str = NULL;
}
//model names are pointers to vm-accessible memory. as that memory is going away, we need to destroy and recreate, which requires preserving them.
for (i = 1; i < MAX_PRECACHE_MODELS; i++)
{
if (!sv.strings.model_precache[i])
{
modelnames[i] = NULL;
break;
}
modelnames[i] = Z_StrDup(sv.strings.model_precache[i]);
}
for (i = 1; i < MAX_PRECACHE_SOUNDS; i++)
{
if (!sv.strings.sound_precache[i])
{
soundnames[i] = NULL;
break;
}
soundnames[i] = Z_StrDup(sv.strings.sound_precache[i]);
}
// load the edicts out of the savegame file
// the rest of the file is sent directly to the progs engine.
if (version == SAVEGAME_VERSION_NQ || version == SAVEGAME_VERSION_QW)
;//Q_InitProgs(); //reinitialize progs entirly.
else
{
Q_SetProgsParms(false);
svs.numprogs = 0;
PR_Configure(svprogfuncs, PR_ReadBytesString(pr_ssqc_memsize.string), MAX_PROGS, pr_enable_profiling.ival);
PR_RegisterFields();
PR_InitEnts(svprogfuncs, sv.world.max_edicts); //just in case the max edicts isn't set.
progstype = pt; //presumably the progs.dat will be what they were before.
}
//reload model names.
for (i = 1; i < MAX_PRECACHE_MODELS; i++)
{
if (!modelnames[i])
break;
sv.strings.model_precache[i] = PR_AddString(svprogfuncs, modelnames[i], 0, false);
Z_Free(modelnames[i]);
}
for (i = 1; i < MAX_PRECACHE_SOUNDS; i++)
{
if (!soundnames[i])
break;
sv.strings.sound_precache[i] = PR_AddString(svprogfuncs, soundnames[i], 0, false);
Z_Free(soundnames[i]);
}
filepos = VFS_TELL(f);
filelen = VFS_GETLEN(f);
filelen -= filepos;
file = BZ_Malloc(filelen+1+8);
memset(file, 0, filelen+1+8);
strcpy(file, "loadgame");
clnum=VFS_READ(f, file+8, filelen);
file[filelen+8]='\0';
sv.world.edict_size=svprogfuncs->load_ents(svprogfuncs, file, &loadinfo, NULL, SV_ExtendedSaveData);
BZ_Free(file);
PR_LoadGlabalStruct(false);
pr_global_struct->time = sv.world.physicstime = sv.time = time;
sv.starttime = Sys_DoubleTime() - sv.time;
VFS_CLOSE(f);
//FIXME: QSS+DP saved games have some / *\nkey values\nkey values\n* / thing in them to save precaches and stuff
World_ClearWorld(&sv.world, true);
SV_GameLoaded(lp, slots, savename);
return true;
}
#endif
//Attempts to load a named saved game.
qboolean SV_Loadgame (const char *unsafe_savename)
{
levelcache_t *cache;
unsigned char str[MAX_LOCALINFO_STRING+1], *trim;
unsigned char savename[MAX_QPATH];
vfsfile_t *f;
unsigned char filename[MAX_OSPATH];
int version;
int clnum;
int slots;
int p;
client_t *cl;
gametype_e gametype;
loadplayer_t lp[255];
struct
{
char *pattern;
flocation_t loc;
} savefiles[] =
{
{"saves/%s/info.fsv"},
#ifndef QUAKETC
{"%s.sav"},
#endif
{"%s"}
};
int bestd=0x7fffffff,best=0;
time_t bestt=0,t;
Q_strncpyz(savename, unsafe_savename, sizeof(savename));
if (!*savename || strstr(savename, ".."))
{ //if no args, or its invalid, try to pick the last one that was saved (of those listed in the menu)
size_t n;
static char *autoload[] = { "quick", "a0", "a1", "a2",
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9"};
strcpy(savename, "quick"); //default...
for (n = 0; n < countof(autoload); n++)
{
for (p = 0; p < countof(savefiles)-1; p++)
{
int d = FS_FLocateFile(va(savefiles[p].pattern, autoload[n]), FSLF_DONTREFERENCE, &savefiles[p].loc);
if (!d)
continue;
FS_GetLocMTime(&savefiles[p].loc, &t);
if (d < bestd || (bestd==d&&t>bestt))
{
bestd = d;
bestt = t;
best = p;
strcpy(savename, autoload[n]);
}
}
}
}
for (p = 0; p < countof(savefiles); p++)
{
int d = FS_FLocateFile(va(savefiles[p].pattern, savename), FSLF_DONTREFERENCE, &savefiles[p].loc);
if (!d)
continue;
FS_GetLocMTime(&savefiles[p].loc, &t);
if (d < bestd || (bestd==d&&t>bestt))
{
bestd = d;
bestt = t;
best = p;
}
}
Q_snprintfz (filename, sizeof(filename), savefiles[best].pattern, savename);
f = FS_OpenReadLocation(filename, &savefiles[best].loc);
if (!f)
{
Con_TPrintf ("ERROR: couldn't open %s.\n", filename);
return false;
}
#if defined(MENU_DAT) && !defined(SERVERONLY)
MP_Toggle(0);
#endif
VFS_GETS(f, str, sizeof(str)-1);
version = atoi(str);
if (version < SAVEGAME_VERSION_FTE_HUB || version >= SAVEGAME_VERSION_FTE_HUB+GT_MAX)
{
#ifdef QUAKETC
VFS_CLOSE (f);
Con_TPrintf ("Unable to load savegame of version %i\n", version);
return false;
#else
return SV_Loadgame_Legacy(savename, filename, f, version);
#endif
}
gametype = version - SAVEGAME_VERSION_FTE_HUB;
VFS_GETS(f, str, sizeof(str)-1);
#ifndef SERVERONLY
if (!cls.state)
#endif
Con_TPrintf ("Loading game from %s...\n", filename);
VFS_GETS(f, str, sizeof(str)-1);
slots = atoi(str);
if (slots < 1 || slots > countof(lp))
{
VFS_CLOSE (f);
Con_Printf ("invalid player count in saved game\n");
return false;
}
for (cl = svs.clients, clnum=0; clnum < slots; cl++,clnum++)
{
VFS_GETS(f, str, sizeof(str)-1);
str[sizeof(cl->namebuf)-1] = '\0';
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
strcpy(lp[clnum].name, str);
lp[clnum].parmstr = NULL;
lp[clnum].source = NULL;
if (*str)
{
VFS_GETS(f, str, sizeof(str)-1);
if (*str == '{')
{
while(VFS_GETS(f, str, sizeof(str)-1))
{
if (*str == '}')
break;
trim = COM_Parse(str);
if (!strcmp(com_token, "parm_string"))
{
COM_Parse(trim);
Z_Free(lp[clnum].parmstr);
lp[clnum].parmstr = Z_StrDup(com_token);
}
else if (!strncmp(com_token, "parm", 4))
{
unsigned int parm = atoi(com_token+4);
COM_Parse(trim);
if (parm < NUM_SPAWN_PARMS)
{
if (!strncmp(com_token, "0x", 2))
lp[clnum].parm[parm].i = strtoul(com_token, NULL, 16);
else
lp[clnum].parm[parm].f = strtod(com_token, NULL);
}
}
else
Con_Printf("Unknown player data: %s\n", com_token);
}
}
else
{ //we used to have N integers, where N was some random outdated constant.
VFS_CLOSE (f);
Con_Printf ("Incompatible saved game\n");
return false;
}
}
}
SV_LoadPlayers(lp, slots);
VFS_GETS(f, str, sizeof(str)-1);
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
Info_RemovePrefixedKeys(str, '*'); //just in case
InfoBuf_Clear(&svs.info, false);
InfoBuf_FromString(&svs.info, str, true);
VFS_GETS(f, str, sizeof(str)-1);
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
Info_RemovePrefixedKeys(str, '*'); //just in case
InfoBuf_Clear(&svs.localinfo, false);
InfoBuf_FromString(&svs.localinfo, str, true);
VFS_GETS(f, str, sizeof(str)-1);
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
if (strcmp(str, "{"))
SV_Error("Corrupt saved game\n");
while(1)
{
if (!VFS_GETS(f, str, sizeof(str)-1))
SV_Error("Corrupt saved game\n");
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
if (!strcmp(str, "}"))
break;
else if (*str)
Cmd_ExecuteString(str, RESTRICT_RCON);
}
SV_FlushLevelCache();
VFS_GETS(f, str, sizeof(str)-1);
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
if (strcmp(str, "{"))
SV_Error("Corrupt saved game\n");
while(1)
{
if (!VFS_GETS(f, str, sizeof(str)-1))
SV_Error("Corrupt saved game\n");
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
if (!strcmp(str, "}"))
break;
if (!*str)
continue;
cache = Z_Malloc(sizeof(levelcache_t)+strlen(str)+1);
cache->mapname = (char *)(cache+1);
strcpy(cache->mapname, str);
cache->gametype = gametype;
cache->next = svs.levcache;
FS_Copy(va("saves/%s/%s.lvc", savename, cache->mapname), va("saves/%s.lvc", cache->mapname), FS_GAME, FS_GAMEONLY);
svs.levcache = cache;
}
VFS_GETS(f, str, sizeof(str)-1);
for (trim = str+strlen(str)-1; trim>=str && *trim <= ' '; trim--)
*trim='\0';
for (trim = str; *trim <= ' ' && *trim; trim++)
;
//serverflags is reset on restart, so we need to read the value as it was at the start of the current map.
VFS_GETS(f, filename, sizeof(filename)-1);
svs.serverflags = atof(filename);
VFS_CLOSE(f);
#ifdef Q2SERVER
if (gametype == GT_QUAKE2)
{
flocation_t loc;
char *name = va("saves/%s/game.gsv", savename);
if (!FS_FLocateFile(name, FSLF_IFFOUND, &loc))
Con_Printf("Couldn't find %s.\n", name);
else if (!*loc.rawname || loc.offset)
Con_Printf("%s is inside a package and cannot be used by the quake2 gamecode.\n", name);
else
{
SVQ2_InitGameProgs();
if (ge)
ge->ReadGame(loc.rawname);
}
}
#endif
svs.gametype = gametype;
SV_LoadLevelCache(savename, str, "", true);
SV_GameLoaded(lp, slots, savename);
return true;
}
void SV_Loadgame_f (void)
{
#ifdef HAVE_CLIENT
if (!Renderer_Started() && !isDedicated)
{
Cbuf_AddText(va("wait;%s %s\n", Cmd_Argv(0), Cmd_Args()), Cmd_ExecLevel);
return;
}
if (sv.state == ss_dead)
CL_Disconnect(NULL);
#endif
if (sv.state == ss_clustermode && MSV_ForwardToAutoServer())
;
else
SV_Loadgame(Cmd_Argv(1));
}
#include "fs.h"
void SV_DeleteSavegame_f (void)
{
const char *savename = Cmd_Argv(1);
//either saves/$FOO/info.fsv (rmtree) or $FOO.sav (single file)
//extensions are strictly implicit to limit damage.
const char *fname;
flocation_t loc;
if (!*savename || *savename == '.' || strchr(savename, '/') || strchr(savename, '\\'))
{
Con_Printf("\"%s\" is not a valid saved game name to delete\n", savename);
return;
}
fname = va("saves/%s/info.fsv", savename);
if (FS_FLocateFile(fname, FSLF_IGNORELINKS|FSLF_DONTREFERENCE, &loc))
{
fname = va("saves/%s/", savename);
if (FS_RemoveTree(loc.search->handle, fname))
Con_Printf("Removed %s\n", fname);
else
Con_Printf("Unable to remove %s\n", fname);
}
#ifndef QUAKETC
fname = va("%s.sav", savename);
if (FS_FLocateFile(fname, FSLF_IGNORELINKS|FSLF_DONTREFERENCE, &loc))
{
if (loc.search->handle->RemoveFile && loc.search->handle->RemoveFile(loc.search->handle, fname))
Con_Printf("Removed %s\n", fname);
else
Con_Printf("Unable to remove %s\n", fname);
}
#endif
}
#endif
Reference in a new issue View git blame Copy permalink