g_save.c File Reference

#include "g_local.h"

Go to the source code of this file.

Macros
#define	Function(f)   {#f, f}

Functions
void	InitGame (void)
void	WriteField1 (FILE *f, field_t *field, byte *base)
void	WriteField2 (FILE *f, field_t *field, byte *base)
void	ReadField (FILE *f, field_t *field, byte *base)
void	WriteClient (FILE *f, gclient_t *client)
void	ReadClient (FILE *f, gclient_t *client)
void	WriteGame (char *filename, qboolean autosave)
void	ReadGame (char *filename)
void	WriteEdict (FILE *f, edict_t *ent)
void	WriteLevelLocals (FILE *f)
void	ReadEdict (FILE *f, edict_t *ent)
void	ReadLevelLocals (FILE *f)
void	WriteLevel (char *filename)
void	ReadLevel (char *filename)

Variables
mmove_t	mmove_reloc
field_t	fields []
field_t	levelfields []
field_t	clientfields []

Macro Definition Documentation

Function

#define Function

(

f

)

{#f, f}

Definition at line 24 of file g_save.c.

Function Documentation

InitGame()

void InitGame

(

void

)

Definition at line 153 of file g_save.c.

{
    gi.dprintf ("==== InitGame ====\n");
 
    gun_x = gi.cvar ("gun_x", "0", 0);
    gun_y = gi.cvar ("gun_y", "0", 0);
    gun_z = gi.cvar ("gun_z", "0", 0);
 
    //FIXME: sv_ prefix is wrong for these
    sv_rollspeed = gi.cvar ("sv_rollspeed", "200", 0);
    sv_rollangle = gi.cvar ("sv_rollangle", "2", 0);
    sv_maxvelocity = gi.cvar ("sv_maxvelocity", "2000", 0);
    sv_gravity = gi.cvar ("sv_gravity", "800", 0);
 
    // noset vars
    dedicated = gi.cvar ("dedicated", "0", CVAR_NOSET);
 
    // latched vars
    sv_cheats = gi.cvar ("cheats", "0", CVAR_SERVERINFO|CVAR_LATCH);
    gi.cvar ("gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_LATCH);
    gi.cvar ("gamedate", __DATE__ , CVAR_SERVERINFO | CVAR_LATCH);
 
    maxclients = gi.cvar ("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
    maxspectators = gi.cvar ("maxspectators", "4", CVAR_SERVERINFO);
    deathmatch = gi.cvar ("deathmatch", "0", CVAR_LATCH);
    coop = gi.cvar ("coop", "0", CVAR_LATCH);
    skill = gi.cvar ("skill", "1", CVAR_LATCH);
    maxentities = gi.cvar ("maxentities", "1024", CVAR_LATCH);
 
    // change anytime vars
    dmflags = gi.cvar ("dmflags", "0", CVAR_SERVERINFO);
    fraglimit = gi.cvar ("fraglimit", "0", CVAR_SERVERINFO);
    timelimit = gi.cvar ("timelimit", "0", CVAR_SERVERINFO);
    password = gi.cvar ("password", "", CVAR_USERINFO);
    spectator_password = gi.cvar ("spectator_password", "", CVAR_USERINFO);
    needpass = gi.cvar ("needpass", "0", CVAR_SERVERINFO);
    filterban = gi.cvar ("filterban", "1", 0);
 
    g_select_empty = gi.cvar ("g_select_empty", "0", CVAR_ARCHIVE);
 
    run_pitch = gi.cvar ("run_pitch", "0.002", 0);
    run_roll = gi.cvar ("run_roll", "0.005", 0);
    bob_up  = gi.cvar ("bob_up", "0.005", 0);
    bob_pitch = gi.cvar ("bob_pitch", "0.002", 0);
    bob_roll = gi.cvar ("bob_roll", "0.002", 0);
 
    // flood control
    flood_msgs = gi.cvar ("flood_msgs", "4", 0);
    flood_persecond = gi.cvar ("flood_persecond", "4", 0);
    flood_waitdelay = gi.cvar ("flood_waitdelay", "10", 0);
 
    // dm map list
    sv_maplist = gi.cvar ("sv_maplist", "", 0);
 
    // items
    InitItems ();
 
    Com_sprintf (game.helpmessage1, sizeof(game.helpmessage1), "");
 
    Com_sprintf (game.helpmessage2, sizeof(game.helpmessage2), "");
 
    // initialize all entities for this game
    game.maxentities = maxentities->value;
    g_edicts =  gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
    globals.edicts = g_edicts;
    globals.max_edicts = game.maxentities;
 
    // initialize all clients for this game
    game.maxclients = maxclients->value;
    game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME);
    globals.num_edicts = game.maxclients+1;
}

Referenced by GetGameAPI(), ReadField(), WriteField1(), and WriteLevel().

ReadClient()

void ReadClient	(	FILE *	f,
		gclient_t *	client
	)

Definition at line 438 of file g_save.c.

{
    field_t     *field;
 
    fread (client, sizeof(*client), 1, f);
 
    for (field=clientfields ; field->name ; field++)
    {
        ReadField (f, field, (byte *)client);
    }
}

Referenced by ReadGame().

ReadEdict()

void ReadEdict	(	FILE *	f,
		edict_t *	ent
	)

Definition at line 595 of file g_save.c.

{
    field_t     *field;
 
    fread (ent, sizeof(*ent), 1, f);
 
    for (field=fields ; field->name ; field++)
    {
        ReadField (f, field, (byte *)ent);
    }
}

Referenced by ReadLevel().

ReadField()

void ReadField	(	FILE *	f,
		field_t *	field,
		byte *	base
	)

Definition at line 324 of file g_save.c.

{
    void        *p;
    int         len;
    int         index;
 
    if (field->flags & FFL_SPAWNTEMP)
        return;
 
    p = (void *)(base + field->ofs);
    switch (field->type)
    {
    case F_INT:
    case F_FLOAT:
    case F_ANGLEHACK:
    case F_VECTOR:
    case F_IGNORE:
        break;
 
    case F_LSTRING:
        len = *(int *)p;
        if (!len)
            *(char **)p = NULL;
        else
        {
            *(char **)p = gi.TagMalloc (len, TAG_LEVEL);
            fread (*(char **)p, len, 1, f);
        }
        break;
    case F_EDICT:
        index = *(int *)p;
        if ( index == -1 )
            *(edict_t **)p = NULL;
        else
            *(edict_t **)p = &g_edicts[index];
        break;
    case F_CLIENT:
        index = *(int *)p;
        if ( index == -1 )
            *(gclient_t **)p = NULL;
        else
            *(gclient_t **)p = &game.clients[index];
        break;
    case F_ITEM:
        index = *(int *)p;
        if ( index == -1 )
            *(gitem_t **)p = NULL;
        else
            *(gitem_t **)p = &itemlist[index];
        break;
 
    //relative to code segment
    case F_FUNCTION:
        index = *(int *)p;
        if ( index == 0 )
            *(byte **)p = NULL;
        else
            *(byte **)p = ((byte *)InitGame) + index;
        break;
 
    //relative to data segment
    case F_MMOVE:
        index = *(int *)p;
        if (index == 0)
            *(byte **)p = NULL;
        else
            *(byte **)p = (byte *)&mmove_reloc + index;
        break;
 
    default:
        gi.error ("ReadEdict: unknown field type");
    }
}

Referenced by ReadClient(), ReadEdict(), and ReadLevelLocals().

ReadGame()

void ReadGame

(

char *

filename

)

Definition at line 491 of file g_save.c.

{
    FILE    *f;
    int     i;
    char    str[16];
 
    gi.FreeTags (TAG_GAME);
 
    f = fopen (filename, "rb");
    if (!f)
        gi.error ("Couldn't open %s", filename);
 
    fread (str, sizeof(str), 1, f);
    if (strcmp (str, __DATE__))
    {
        fclose (f);
        gi.error ("Savegame from an older version.\n");
    }
 
    g_edicts =  gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
    globals.edicts = g_edicts;
 
    fread (&game, sizeof(game), 1, f);
    game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME);
    for (i=0 ; i<game.maxclients ; i++)
        ReadClient (f, &game.clients[i]);
 
    fclose (f);
}

Referenced by GetGameAPI().

ReadLevel()

void ReadLevel

(

char *

filename

)

Definition at line 686 of file g_save.c.

{
    int     entnum;
    FILE    *f;
    int     i;
    void    *base;
    edict_t *ent;
 
    f = fopen (filename, "rb");
    if (!f)
        gi.error ("Couldn't open %s", filename);
 
    // free any dynamic memory allocated by loading the level
    // base state
    gi.FreeTags (TAG_LEVEL);
 
    // wipe all the entities
    memset (g_edicts, 0, game.maxentities*sizeof(g_edicts[0]));
    globals.num_edicts = maxclients->value+1;
 
    // check edict size
    fread (&i, sizeof(i), 1, f);
    if (i != sizeof(edict_t))
    {
        fclose (f);
        gi.error ("ReadLevel: mismatched edict size");
    }
 
    // check function pointer base address
    fread (&base, sizeof(base), 1, f);
 
    // load the level locals
    ReadLevelLocals (f);
 
    // load all the entities
    while (1)
    {
        if (fread (&entnum, sizeof(entnum), 1, f) != 1)
        {
            fclose (f);
            gi.error ("ReadLevel: failed to read entnum");
        }
        if (entnum == -1)
            break;
        if (entnum >= globals.num_edicts)
            globals.num_edicts = entnum+1;
 
        ent = &g_edicts[entnum];
        ReadEdict (f, ent);
 
        // let the server rebuild world links for this ent
        memset (&ent->area, 0, sizeof(ent->area));
        gi.linkentity (ent);
    }
 
    fclose (f);
 
    // mark all clients as unconnected
    for (i=0 ; i<maxclients->value ; i++)
    {
        ent = &g_edicts[i+1];
        ent->client = game.clients + i;
        ent->client->pers.connected = false;
    }
 
    // do any load time things at this point
    for (i=0 ; i<globals.num_edicts ; i++)
    {
        ent = &g_edicts[i];
 
        if (!ent->inuse)
            continue;
 
        // fire any cross-level triggers
        if (ent->classname)
            if (strcmp(ent->classname, "target_crosslevel_target") == 0)
                ent->nextthink = level.time + ent->delay;
    }
}

Referenced by GetGameAPI().

ReadLevelLocals()

void ReadLevelLocals

(

FILE *

f

)

Definition at line 614 of file g_save.c.

{
    field_t     *field;
 
    fread (&level, sizeof(level), 1, f);
 
    for (field=levelfields ; field->name ; field++)
    {
        ReadField (f, field, (byte *)&level);
    }
}

Referenced by ReadLevel().

WriteClient()

void WriteClient	(	FILE *	f,
		gclient_t *	client
	)

Definition at line 407 of file g_save.c.

{
    field_t     *field;
    gclient_t   temp;
    
    // all of the ints, floats, and vectors stay as they are
    temp = *client;
 
    // change the pointers to lengths or indexes
    for (field=clientfields ; field->name ; field++)
    {
        WriteField1 (f, field, (byte *)&temp);
    }
 
    // write the block
    fwrite (&temp, sizeof(temp), 1, f);
 
    // now write any allocated data following the edict
    for (field=clientfields ; field->name ; field++)
    {
        WriteField2 (f, field, (byte *)client);
    }
}

Referenced by WriteGame().

WriteEdict()

void WriteEdict	(	FILE *	f,
		edict_t *	ent
	)

Definition at line 531 of file g_save.c.

{
    field_t     *field;
    edict_t     temp;
 
    // all of the ints, floats, and vectors stay as they are
    temp = *ent;
 
    // change the pointers to lengths or indexes
    for (field=fields ; field->name ; field++)
    {
        WriteField1 (f, field, (byte *)&temp);
    }
 
    // write the block
    fwrite (&temp, sizeof(temp), 1, f);
 
    // now write any allocated data following the edict
    for (field=fields ; field->name ; field++)
    {
        WriteField2 (f, field, (byte *)ent);
    }
 
}

Referenced by WriteLevel().

WriteField1()

void WriteField1	(	FILE *	f,
		field_t *	field,
		byte *	base
	)

Definition at line 228 of file g_save.c.

{
    void        *p;
    int         len;
    int         index;
 
    if (field->flags & FFL_SPAWNTEMP)
        return;
 
    p = (void *)(base + field->ofs);
    switch (field->type)
    {
    case F_INT:
    case F_FLOAT:
    case F_ANGLEHACK:
    case F_VECTOR:
    case F_IGNORE:
        break;
 
    case F_LSTRING:
    case F_GSTRING:
        if ( *(char **)p )
            len = (int)strlen(*(char **)p) + 1;
        else
            len = 0;
        *(int *)p = len;
        break;
    case F_EDICT:
        if ( *(edict_t **)p == NULL)
            index = -1;
        else
            index = *(edict_t **)p - g_edicts;
        *(int *)p = index;
        break;
    case F_CLIENT:
        if ( *(gclient_t **)p == NULL)
            index = -1;
        else
            index = *(gclient_t **)p - game.clients;
        *(int *)p = index;
        break;
    case F_ITEM:
        if ( *(edict_t **)p == NULL)
            index = -1;
        else
            index = *(gitem_t **)p - itemlist;
        *(int *)p = index;
        break;
 
    //relative to code segment
    case F_FUNCTION:
        if (*(byte **)p == NULL)
            index = 0;
        else
            index = *(byte **)p - ((byte *)InitGame);
        *(int *)p = index;
        break;
 
    //relative to data segment
    case F_MMOVE:
        if (*(byte **)p == NULL)
            index = 0;
        else
            index = *(byte **)p - (byte *)&mmove_reloc;
        *(int *)p = index;
        break;
 
    default:
        gi.error ("WriteEdict: unknown field type");
    }
}

Referenced by WriteClient(), WriteEdict(), and WriteLevelLocals().

WriteField2()

void WriteField2	(	FILE *	f,
		field_t *	field,
		byte *	base
	)

Definition at line 301 of file g_save.c.

{
    int         len;
    void        *p;
 
    if (field->flags & FFL_SPAWNTEMP)
        return;
 
    p = (void *)(base + field->ofs);
    switch (field->type)
    {
    case F_LSTRING:
        if ( *(char **)p )
        {
            len = (int)strlen(*(char **)p) + 1;
            fwrite (*(char **)p, len, 1, f);
        }
        break;
    default:
        break;
    }
}

Referenced by WriteClient(), WriteEdict(), and WriteLevelLocals().

WriteGame()

void WriteGame	(	char *	filename,
		qboolean	autosave
	)

Definition at line 464 of file g_save.c.

{
    FILE    *f;
    int     i;
    char    str[16];
 
    if (!autosave)
        SaveClientData ();
 
    f = fopen (filename, "wb");
    if (!f)
        gi.error ("Couldn't open %s", filename);
 
    memset (str, 0, sizeof(str));
    strcpy (str, __DATE__);
    fwrite (str, sizeof(str), 1, f);
 
    game.autosaved = autosave;
    fwrite (&game, sizeof(game), 1, f);
    game.autosaved = false;
 
    for (i=0 ; i<game.maxclients ; i++)
        WriteClient (f, &game.clients[i]);
 
    fclose (f);
}

Referenced by GetGameAPI().

WriteLevel()

void WriteLevel

(

char *

filename

)

Definition at line 632 of file g_save.c.

{
    int     i;
    edict_t *ent;
    FILE    *f;
    void    *base;
 
    f = fopen (filename, "wb");
    if (!f)
        gi.error ("Couldn't open %s", filename);
 
    // write out edict size for checking
    i = sizeof(edict_t);
    fwrite (&i, sizeof(i), 1, f);
 
    // write out a function pointer for checking
    base = (void *)InitGame;
    fwrite (&base, sizeof(base), 1, f);
 
    // write out level_locals_t
    WriteLevelLocals (f);
 
    // write out all the entities
    for (i=0 ; i<globals.num_edicts ; i++)
    {
        ent = &g_edicts[i];
        if (!ent->inuse)
            continue;
        fwrite (&i, sizeof(i), 1, f);
        WriteEdict (f, ent);
    }
    i = -1;
    fwrite (&i, sizeof(i), 1, f);
 
    fclose (f);
}

Referenced by GetGameAPI().

WriteLevelLocals()

void WriteLevelLocals

(

FILE *

f

)

Definition at line 563 of file g_save.c.

{
    field_t     *field;
    level_locals_t      temp;
 
    // all of the ints, floats, and vectors stay as they are
    temp = level;
 
    // change the pointers to lengths or indexes
    for (field=levelfields ; field->name ; field++)
    {
        WriteField1 (f, field, (byte *)&temp);
    }
 
    // write the block
    fwrite (&temp, sizeof(temp), 1, f);
 
    // now write any allocated data following the edict
    for (field=levelfields ; field->name ; field++)
    {
        WriteField2 (f, field, (byte *)&level);
    }
}

Referenced by WriteLevel().

Variable Documentation

clientfields

field_t clientfields[]

Initial value:

=
{
    {"pers.weapon", CLOFS(pers.weapon), F_ITEM},
    {"pers.lastweapon", CLOFS(pers.lastweapon), F_ITEM},
    {"newweapon", CLOFS(newweapon), F_ITEM},
 
    {NULL, 0, F_INT}
}

Definition at line 135 of file g_save.c.

Referenced by ReadClient(), and WriteClient().

fields

field_t fields[]

Definition at line 28 of file g_save.c.

Referenced by ED_ParseField(), ReadEdict(), and WriteEdict().

levelfields

field_t levelfields[]

Initial value:

=
{
    {"changemap", LLOFS(changemap), F_LSTRING},
                   
    {"sight_client", LLOFS(sight_client), F_EDICT},
    {"sight_entity", LLOFS(sight_entity), F_EDICT},
    {"sound_entity", LLOFS(sound_entity), F_EDICT},
    {"sound2_entity", LLOFS(sound2_entity), F_EDICT},
 
    {NULL, 0, F_INT}
}

Definition at line 123 of file g_save.c.

Referenced by ReadLevelLocals(), and WriteLevelLocals().

mmove_reloc

mmove_t mmove_reloc

Definition at line 26 of file g_save.c.

Referenced by ReadField(), and WriteField1().