g_save.c File Reference

#include "g_local.h"
#include "g_ptrs.h"

Go to the source code of this file.

Classes
struct	save_field_t

Macros
#define	_FA(type, name, size)   { type, _OFS(name), size }
#define	_F(type, name)   _FA(type, name, 1)
#define	SZ(name, size)   _FA(F_ZSTRING, name, size)
#define	BA(name, size)   _FA(F_BYTE, name, size)
#define	B(name)   BA(name, 1)
#define	SA(name, size)   _FA(F_SHORT, name, size)
#define	S(name)   SA(name, 1)
#define	IA(name, size)   _FA(F_INT, name, size)
#define	I(name)   IA(name, 1)
#define	FA(name, size)   _FA(F_FLOAT, name, size)
#define	F(name)   FA(name, 1)
#define	L(name)   _F(F_LSTRING, name)
#define	V(name)   _F(F_VECTOR, name)
#define	T(name)   _F(F_ITEM, name)
#define	E(name)   _F(F_EDICT, name)
#define	P(name, type)   _FA(F_POINTER, name, type)
#define	_OFS   FOFS
#define	_OFS   LLOFS
#define	_OFS   CLOFS
#define	_OFS   GLOFS
#define	SAVE_MAGIC1   (('1'<<24)|('V'<<16)|('S'<<8)|'S')
#define	SAVE_MAGIC2   (('1'<<24)|('V'<<16)|('A'<<8)|'S')
#define	SAVE_VERSION   2

Functions
static void	write_data (void *buf, size_t len, FILE *f)
static void	write_short (FILE *f, short v)
static void	write_int (FILE *f, int v)
static void	write_float (FILE *f, float v)
static void	write_string (FILE *f, char *s)
static void	write_vector (FILE *f, vec_t *v)
static void	write_index (FILE *f, void *p, size_t size, void *start, int max_index)
static void	write_pointer (FILE *f, void *p, ptr_type_t type)
static void	write_field (FILE *f, const save_field_t *field, void *base)
static void	write_fields (FILE *f, const save_field_t *fields, void *base)
static void	read_data (void *buf, size_t len, FILE *f)
static int	read_short (FILE *f)
static int	read_int (FILE *f)
static float	read_float (FILE *f)
static char *	read_string (FILE *f)
static void	read_zstring (FILE *f, char *s, size_t size)
static void	read_vector (FILE *f, vec_t *v)
static void *	read_index (FILE *f, size_t size, void *start, int max_index)
static void *	read_pointer (FILE *f, ptr_type_t type)
static void	read_field (FILE *f, const save_field_t *field, void *base)
static void	read_fields (FILE *f, const save_field_t *fields, void *base)
void	WriteGame (const char *filename, qboolean autosave)
void	ReadGame (const char *filename)
void	WriteLevel (const char *filename)
void	ReadLevel (const char *filename)

Variables
static const save_field_t	entityfields []
static const save_field_t	levelfields []
static const save_field_t	clientfields []
static const save_field_t	gamefields []

Macro Definition Documentation

_F

#define _F	(		type,
			name
	)		_FA(type, name, 1)

Definition at line 37 of file g_save.c.

_FA

#define _FA	(		type,
			name,
			size
	)		{ type, _OFS(name), size }

Definition at line 35 of file g_save.c.

_OFS [1/4]

#define _OFS   FOFS

_OFS [2/4]

#define _OFS   LLOFS

_OFS [3/4]

#define _OFS   CLOFS

_OFS [4/4]

#define _OFS   GLOFS

B

#define B

(

name

)

BA(name, 1)

Definition at line 40 of file g_save.c.

BA

#define BA	(		name,
			size
	)		_FA(F_BYTE, name, size)

Definition at line 39 of file g_save.c.

E

#define E

(

name

)

_F(F_EDICT, name)

Definition at line 50 of file g_save.c.

F

#define F

(

name

)

FA(name, 1)

Definition at line 46 of file g_save.c.

FA

#define FA	(		name,
			size
	)		_FA(F_FLOAT, name, size)

Definition at line 45 of file g_save.c.

I

#define I

(

name

)

IA(name, 1)

Definition at line 44 of file g_save.c.

IA

#define IA	(		name,
			size
	)		_FA(F_INT, name, size)

Definition at line 43 of file g_save.c.

L

#define L

(

name

)

_F(F_LSTRING, name)

Definition at line 47 of file g_save.c.

P

#define P	(		name,
			type
	)		_FA(F_POINTER, name, type)

Definition at line 51 of file g_save.c.

S

#define S

(

name

)

SA(name, 1)

Definition at line 42 of file g_save.c.

SA

#define SA	(		name,
			size
	)		_FA(F_SHORT, name, size)

Definition at line 41 of file g_save.c.

SAVE_MAGIC1

#define SAVE_MAGIC1   (('1'<<24)|('V'<<16)|('S'<<8)|'S')

Definition at line 766 of file g_save.c.

SAVE_MAGIC2

#define SAVE_MAGIC2   (('1'<<24)|('V'<<16)|('A'<<8)|'S')

Definition at line 767 of file g_save.c.

SAVE_VERSION

#define SAVE_VERSION   2

Definition at line 768 of file g_save.c.

SZ

#define SZ	(		name,
			size
	)		_FA(F_ZSTRING, name, size)

Definition at line 38 of file g_save.c.

T

#define T

(

name

)

_F(F_ITEM, name)

Definition at line 49 of file g_save.c.

V

#define V

(

name

)

_F(F_VECTOR, name)

Definition at line 48 of file g_save.c.

Function Documentation

read_data()

static void read_data ( void *  buf, size_t  len, FILE *  f  )

static

Definition at line 582 of file g_save.c.

{
    if (fread(buf, 1, len, f) != len) {
        gi.error("%s: couldn't read %"PRIz" bytes", __func__, len);
    }
}

Referenced by read_field(), read_float(), read_int(), read_short(), read_string(), and read_zstring().

read_field()

static void read_field ( FILE *  f, const save_field_t *  field, void *  base  )

static

Definition at line 701 of file g_save.c.

{
    void *p = (byte *)base + field->ofs;
    int i;
 
    switch (field->type) {
    case F_BYTE:
        read_data(p, field->size, f);
        break;
    case F_SHORT:
        for (i = 0; i < field->size; i++) {
            ((short *)p)[i] = read_short(f);
        }
        break;
    case F_INT:
        for (i = 0; i < field->size; i++) {
            ((int *)p)[i] = read_int(f);
        }
        break;
    case F_FLOAT:
        for (i = 0; i < field->size; i++) {
            ((float *)p)[i] = read_float(f);
        }
        break;
    case F_VECTOR:
        read_vector(f, (vec_t *)p);
        break;
 
    case F_LSTRING:
        *(char **)p = read_string(f);
        break;
    case F_ZSTRING:
        read_zstring(f, (char *)p, field->size);
        break;
 
    case F_EDICT:
        *(edict_t **)p = read_index(f, sizeof(edict_t), g_edicts, game.maxentities - 1);
        break;
    case F_CLIENT:
        *(gclient_t **)p = read_index(f, sizeof(gclient_t), game.clients, game.maxclients - 1);
        break;
    case F_ITEM:
        *(gitem_t **)p = read_index(f, sizeof(gitem_t), itemlist, game.num_items - 1);
        break;
 
    case F_POINTER:
        *(void **)p = read_pointer(f, field->size);
        break;
 
    default:
        gi.error("%s: unknown field type", __func__);
    }
}

Referenced by read_fields().

read_fields()

static void read_fields ( FILE *  f, const save_field_t *  fields, void *  base  )

static

Definition at line 755 of file g_save.c.

{
    const save_field_t *field;
 
    for (field = fields; field->type; field++) {
        read_field(f, field, base);
    }
}

Referenced by ReadGame(), and ReadLevel().

read_float()

static float read_float ( FILE *  f )

static

Definition at line 609 of file g_save.c.

{
    float v;
 
    read_data(&v, sizeof(v), f);
    v = LittleFloat(v);
 
    return v;
}

Referenced by read_field(), and read_vector().

read_index()

static void* read_index ( FILE *  f, size_t  size, void *  start, int  max_index  )

static

Definition at line 661 of file g_save.c.

{
    int index;
    byte *p;
 
    index = read_int(f);
    if (index == -1) {
        return NULL;
    }
 
    if (index < 0 || index > max_index) {
        gi.error("%s: bad index", __func__);
    }
 
    p = (byte *)start + index * size;
    return p;
}

Referenced by read_field().

read_int()

static int read_int ( FILE *  f )

static

Definition at line 599 of file g_save.c.

{
    int v;
 
    read_data(&v, sizeof(v), f);
    v = LittleLong(v);
 
    return v;
}

Referenced by read_field(), read_index(), read_pointer(), read_string(), read_zstring(), ReadGame(), and ReadLevel().

read_pointer()

static void* read_pointer ( FILE *  f, ptr_type_t  type  )

static

Definition at line 679 of file g_save.c.

{
    int index;
    const save_ptr_t *ptr;
 
    index = read_int(f);
    if (index == -1) {
        return NULL;
    }
 
    if (index < 0 || index >= num_save_ptrs) {
        gi.error("%s: bad index", __func__);
    }
 
    ptr = &save_ptrs[index];
    if (ptr->type != type) {
        gi.error("%s: type mismatch", __func__);
    }
 
    return ptr->ptr;
}

Referenced by read_field().

read_short()

static int read_short ( FILE *  f )

static

Definition at line 589 of file g_save.c.

{
    short v;
 
    read_data(&v, sizeof(v), f);
    v = LittleShort(v);
 
    return v;
}

Referenced by read_field().

read_string()

static char* read_string ( FILE *  f )

static

Definition at line 620 of file g_save.c.

{
    int len;
    char *s;
 
    len = read_int(f);
    if (len == -1) {
        return NULL;
    }
 
    if (len < 0 || len > 65536) {
        gi.error("%s: bad length", __func__);
    }
 
    s = gi.TagMalloc(len + 1, TAG_LEVEL);
    read_data(s, len, f);
    s[len] = 0;
 
    return s;
}

Referenced by read_field().

read_vector()

static void read_vector ( FILE *  f, vec_t *  v  )

static

Definition at line 654 of file g_save.c.

{
    v[0] = read_float(f);
    v[1] = read_float(f);
    v[2] = read_float(f);
}

Referenced by read_field().

read_zstring()

static void read_zstring ( FILE *  f, char *  s, size_t  size  )

static

Definition at line 641 of file g_save.c.

{
    int len;
 
    len = read_int(f);
    if (len < 0 || len >= size) {
        gi.error("%s: bad length", __func__);
    }
 
    read_data(s, len, f);
    s[len] = 0;
}

Referenced by read_field().

ReadGame()

void ReadGame

(

const char *

filename

)

Definition at line 810 of file g_save.c.

{
    FILE    *f;
    int     i;
 
    gi.FreeTags(TAG_GAME);
 
    f = fopen(filename, "rb");
    if (!f)
        gi.error("Couldn't open %s", filename);
 
    i = read_int(f);
    if (i != SAVE_MAGIC1) {
        fclose(f);
        gi.error("Not a save game");
    }
 
    i = read_int(f);
    if (i != SAVE_VERSION) {
        fclose(f);
        gi.error("Savegame from an older version");
    }
 
    read_fields(f, gamefields, &game);
 
    // should agree with server's version
    if (game.maxclients != (int)maxclients->value) {
        fclose(f);
        gi.error("Savegame has bad maxclients");
    }
    if (game.maxentities <= game.maxclients || game.maxentities > MAX_EDICTS) {
        fclose(f);
        gi.error("Savegame has bad maxentities");
    }
 
    g_edicts = gi.TagMalloc(game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
    globals.edicts = g_edicts;
    globals.max_edicts = game.maxentities;
 
    game.clients = gi.TagMalloc(game.maxclients * sizeof(game.clients[0]), TAG_GAME);
    for (i = 0; i < game.maxclients; i++) {
        read_fields(f, clientfields, &game.clients[i]);
    }
 
    fclose(f);
}

Referenced by GetGameAPI().

ReadLevel()

void ReadLevel

(

const char *

filename

)

Definition at line 912 of file g_save.c.

{
    int     entnum;
    FILE    *f;
    int     i;
    edict_t *ent;
 
    // free any dynamic memory allocated by loading the level
    // base state
    gi.FreeTags(TAG_LEVEL);
 
    f = fopen(filename, "rb");
    if (!f)
        gi.error("Couldn't open %s", filename);
 
    // wipe all the entities
    memset(g_edicts, 0, game.maxentities * sizeof(g_edicts[0]));
    globals.num_edicts = maxclients->value + 1;
 
    i = read_int(f);
    if (i != SAVE_MAGIC2) {
        fclose(f);
        gi.error("Not a save game");
    }
 
    i = read_int(f);
    if (i != SAVE_VERSION) {
        fclose(f);
        gi.error("Savegame from an older version");
    }
 
    // load the level locals
    read_fields(f, levelfields, &level);
 
    // load all the entities
    while (1) {
        entnum = read_int(f);
        if (entnum == -1)
            break;
        if (entnum < 0 || entnum >= game.maxentities) {
            gi.error("%s: bad entity number", __func__);
        }
        if (entnum >= globals.num_edicts)
            globals.num_edicts = entnum + 1;
 
        ent = &g_edicts[entnum];
        read_fields(f, entityfields, ent);
        ent->inuse = qtrue;
        ent->s.number = entnum;
 
        // 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 = qfalse;
    }
 
    // 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;
 
        if (ent->think == func_clock_think || ent->use == func_clock_use) {
            char *msg = ent->message;
            ent->message = gi.TagMalloc(CLOCK_MESSAGE_SIZE, TAG_LEVEL);
            if (msg) {
                Q_strlcpy(ent->message, msg, CLOCK_MESSAGE_SIZE);
                gi.TagFree(msg);
            }
        }
    }
}

Referenced by GetGameAPI().

write_data()

static void write_data ( void *  buf, size_t  len, FILE *  f  )

static

Definition at line 433 of file g_save.c.

{
    if (fwrite(buf, 1, len, f) != len) {
        gi.error("%s: couldn't write %"PRIz" bytes", __func__, len);
    }
}

Referenced by write_field(), write_float(), write_int(), write_short(), and write_string().

write_field()

static void write_field ( FILE *  f, const save_field_t *  field, void *  base  )

static

Definition at line 519 of file g_save.c.

{
    void *p = (byte *)base + field->ofs;
    int i;
 
    switch (field->type) {
    case F_BYTE:
        write_data(p, field->size, f);
        break;
    case F_SHORT:
        for (i = 0; i < field->size; i++) {
            write_short(f, ((short *)p)[i]);
        }
        break;
    case F_INT:
        for (i = 0; i < field->size; i++) {
            write_int(f, ((int *)p)[i]);
        }
        break;
    case F_FLOAT:
        for (i = 0; i < field->size; i++) {
            write_float(f, ((float *)p)[i]);
        }
        break;
    case F_VECTOR:
        write_vector(f, (vec_t *)p);
        break;
 
    case F_ZSTRING:
        write_string(f, (char *)p);
        break;
    case F_LSTRING:
        write_string(f, *(char **)p);
        break;
 
    case F_EDICT:
        write_index(f, *(void **)p, sizeof(edict_t), g_edicts, MAX_EDICTS - 1);
        break;
    case F_CLIENT:
        write_index(f, *(void **)p, sizeof(gclient_t), game.clients, game.maxclients - 1);
        break;
    case F_ITEM:
        write_index(f, *(void **)p, sizeof(gitem_t), itemlist, game.num_items - 1);
        break;
 
    case F_POINTER:
        write_pointer(f, *(void **)p, field->size);
        break;
 
    default:
        gi.error("%s: unknown field type", __func__);
    }
}

Referenced by write_fields().

write_fields()

static void write_fields ( FILE *  f, const save_field_t *  fields, void *  base  )

static

Definition at line 573 of file g_save.c.

{
    const save_field_t *field;
 
    for (field = fields; field->type; field++) {
        write_field(f, field, base);
    }
}

Referenced by WriteGame(), and WriteLevel().

write_float()

static void write_float ( FILE *  f, float  v  )

static

Definition at line 452 of file g_save.c.

{
    v = LittleFloat(v);
    write_data(&v, sizeof(v), f);
}

Referenced by write_field(), and write_vector().

write_index()

static void write_index ( FILE *  f, void *  p, size_t  size, void *  start, int  max_index  )

static

Definition at line 479 of file g_save.c.

{
    size_t diff;
 
    if (!p) {
        write_int(f, -1);
        return;
    }
 
    if (p < start || (byte *)p > (byte *)start + max_index * size) {
        gi.error("%s: pointer out of range: %p", __func__, p);
    }
 
    diff = (byte *)p - (byte *)start;
    if (diff % size) {
        gi.error("%s: misaligned pointer: %p", __func__, p);
    }
    write_int(f, (int)(diff / size));
}

Referenced by write_field().

write_int()

static void write_int ( FILE *  f, int  v  )

static

Definition at line 446 of file g_save.c.

{
    v = LittleLong(v);
    write_data(&v, sizeof(v), f);
}

Referenced by write_field(), write_index(), write_pointer(), write_string(), WriteGame(), and WriteLevel().

write_pointer()

static void write_pointer ( FILE *  f, void *  p, ptr_type_t  type  )

static

Definition at line 499 of file g_save.c.

{
    const save_ptr_t *ptr;
    int i;
 
    if (!p) {
        write_int(f, -1);
        return;
    }
 
    for (i = 0, ptr = save_ptrs; i < num_save_ptrs; i++, ptr++) {
        if (ptr->type == type && ptr->ptr == p) {
            write_int(f, i);
            return;
        }
    }
 
    gi.error("%s: unknown pointer: %p", __func__, p);
}

Referenced by write_field().

write_short()

static void write_short ( FILE *  f, short  v  )

static

Definition at line 440 of file g_save.c.

{
    v = LittleShort(v);
    write_data(&v, sizeof(v), f);
}

Referenced by write_field().

write_string()

static void write_string ( FILE *  f, char *  s  )

static

Definition at line 458 of file g_save.c.

{
    size_t len;
 
    if (!s) {
        write_int(f, -1);
        return;
    }
 
    len = strlen(s);
    write_int(f, len);
    write_data(s, len, f);
}

Referenced by write_field().

write_vector()

static void write_vector ( FILE *  f, vec_t *  v  )

static

Definition at line 472 of file g_save.c.

{
    write_float(f, v[0]);
    write_float(f, v[1]);
    write_float(f, v[2]);
}

Referenced by write_field().

WriteGame()

void WriteGame	(	const char *	filename,
		qboolean	autosave
	)

Definition at line 784 of file g_save.c.

{
    FILE    *f;
    int     i;
 
    if (!autosave)
        SaveClientData();
 
    f = fopen(filename, "wb");
    if (!f)
        gi.error("Couldn't open %s", filename);
 
    write_int(f, SAVE_MAGIC1);
    write_int(f, SAVE_VERSION);
 
    game.autosaved = autosave;
    write_fields(f, gamefields, &game);
    game.autosaved = qfalse;
 
    for (i = 0; i < game.maxclients; i++) {
        write_fields(f, clientfields, &game.clients[i]);
    }
 
    fclose(f);
}

Referenced by GetGameAPI().

WriteLevel()

void WriteLevel

(

const char *

filename

)

Definition at line 866 of file g_save.c.

{
    int     i;
    edict_t *ent;
    FILE    *f;
 
    f = fopen(filename, "wb");
    if (!f)
        gi.error("Couldn't open %s", filename);
 
    write_int(f, SAVE_MAGIC2);
    write_int(f, SAVE_VERSION);
 
    // write out level_locals_t
    write_fields(f, levelfields, &level);
 
    // write out all the entities
    for (i = 0; i < globals.num_edicts; i++) {
        ent = &g_edicts[i];
        if (!ent->inuse)
            continue;
        write_int(f, i);
        write_fields(f, entityfields, ent);
    }
    write_int(f, -1);
 
    fclose(f);
}

Referenced by GetGameAPI().

Variable Documentation

clientfields

const save_field_t clientfields[]

static

Definition at line 292 of file g_save.c.

Referenced by ReadGame(), and WriteGame().

entityfields

const save_field_t entityfields[]

static

Definition at line 53 of file g_save.c.

Referenced by ReadLevel(), and WriteLevel().

gamefields

const save_field_t gamefields[]

static

Initial value:

= {
#define _OFS
    SZ(helpmessage1, 512),
    SZ(helpmessage2, 512),
 
    I(maxclients),
    I(maxentities),
 
    I(serverflags),
 
    I(num_items),
 
    I(autosaved),
 
    {0}
 
}

Definition at line 413 of file g_save.c.

Referenced by ReadGame(), and WriteGame().

levelfields

const save_field_t levelfields[]

static

Definition at line 249 of file g_save.c.

Referenced by ReadLevel(), and WriteLevel().