summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/p_saveg.c1465
1 files changed, 1293 insertions, 172 deletions
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 455dc61a..22e9646a 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -1,7 +1,7 @@
// Emacs style mode select -*- C++ -*-
//-----------------------------------------------------------------------------
//
-// $Id: p_saveg.c 296 2006-01-16 21:40:38Z fraggle $
+// $Id: p_saveg.c 298 2006-01-19 00:09:20Z fraggle $
//
// Copyright(C) 1993-1996 Id Software, Inc.
// Copyright(C) 2005 Simon Howard
@@ -22,6 +22,12 @@
// 02111-1307, USA.
//
// $Log$
+// Revision 1.5 2006/01/19 00:09:20 fraggle
+// Add functions to r/w structures to the savegame buffer, rather than
+// copying the raw structures. This way, we read and write to the DOS
+// savegame format always, regardless of the compiler and processor
+// architecture, to ensure Vanilla compatibility.
+//
// Revision 1.4 2006/01/16 21:40:38 fraggle
// Vanilla savegame load/save
//
@@ -43,7 +49,7 @@
//-----------------------------------------------------------------------------
static const char
-rcsid[] = "$Id: p_saveg.c 296 2006-01-16 21:40:38Z fraggle $";
+rcsid[] = "$Id: p_saveg.c 298 2006-01-19 00:09:20Z fraggle $";
#include "dstrings.h"
#include "deh_main.h"
@@ -75,6 +81,1227 @@ char *P_SaveGameFile(int slot)
return filename;
}
+// Endian-safe integer read/write functions
+
+static byte saveg_read8(void)
+{
+ int result;
+
+ result = *save_p;
+
+ save_p += 1;
+
+ return result;
+}
+
+static void saveg_write8(byte value)
+{
+ *save_p = value;
+
+ save_p += 1;
+}
+
+static short saveg_read16(void)
+{
+ int result;
+
+ result = save_p[0] | (save_p[1] << 8);
+
+ save_p += 2;
+
+ return result;
+}
+
+static void saveg_write16(short value)
+{
+ save_p[0] = value & 0xff;
+ save_p[1] = (value >> 8) & 0xff;
+
+ save_p += 2;
+}
+
+static int saveg_read32(void)
+{
+ int result;
+
+ result = save_p[0] | (save_p[1] << 8)
+ | (save_p[2] << 16) | (save_p[3] << 24);
+
+ save_p += 4;
+
+ return result;
+}
+
+static void saveg_write32(int value)
+{
+ save_p[0] = value & 0xff;
+ save_p[1] = (value >> 8) & 0xff;
+ save_p[2] = (value >> 16) & 0xff;
+ save_p[3] = (value >> 24) & 0xff;
+
+ save_p += 4;
+}
+
+// Pointers
+
+static void *saveg_readp(void)
+{
+ return (void *) saveg_read32();
+}
+
+static void saveg_writep(void *p)
+{
+ saveg_write32((int) p);
+}
+
+// Enum values are 32-bit integers.
+
+#define saveg_read_enum saveg_read32
+#define saveg_write_enum saveg_write32
+
+//
+// Structure read/write functions
+//
+
+//
+// mapthing_t
+//
+
+static void saveg_read_mapthing_t(mapthing_t *str)
+{
+ // short x;
+ str->x = saveg_read16();
+
+ // short y;
+ str->y = saveg_read16();
+
+ // short angle;
+ str->angle = saveg_read16();
+
+ // short type;
+ str->type = saveg_read16();
+
+ // short options;
+ str->options = saveg_read16();
+}
+
+static void saveg_write_mapthing_t(mapthing_t *str)
+{
+ // short x;
+ saveg_write16(str->x);
+
+ // short y;
+ saveg_write16(str->y);
+
+ // short angle;
+ saveg_write16(str->angle);
+
+ // short type;
+ saveg_write16(str->type);
+
+ // short options;
+ saveg_write16(str->options);
+}
+
+//
+// actionf_t
+//
+
+static void saveg_read_actionf_t(actionf_t *str)
+{
+ // actionf_p1 acp1;
+ str->acp1 = saveg_readp();
+}
+
+static void saveg_write_actionf_t(actionf_t *str)
+{
+ // actionf_p1 acp1;
+ saveg_writep(str->acp1);
+}
+
+//
+// think_t
+//
+// This is just an actionf_t.
+//
+
+#define saveg_read_think_t saveg_read_actionf_t
+#define saveg_write_think_t saveg_write_actionf_t
+
+//
+// thinker_t
+//
+
+static void saveg_read_thinker_t(thinker_t *str)
+{
+ // struct thinker_s* prev;
+ str->prev = saveg_readp();
+
+ // struct thinker_s* next;
+ str->next = saveg_readp();
+
+ // think_t function;
+ saveg_read_think_t(&str->function);
+}
+
+static void saveg_write_thinker_t(thinker_t *str)
+{
+ // struct thinker_s* prev;
+ saveg_writep(str->prev);
+
+ // struct thinker_s* next;
+ saveg_writep(str->next);
+
+ // think_t function;
+ saveg_write_think_t(&str->function);
+}
+
+//
+// mobj_t
+//
+
+static void saveg_read_mobj_t(mobj_t *str)
+{
+ int pl;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // fixed_t x;
+ str->x = saveg_read32();
+
+ // fixed_t y;
+ str->y = saveg_read32();
+
+ // fixed_t z;
+ str->z = saveg_read32();
+
+ // struct mobj_s* snext;
+ str->snext = saveg_readp();
+
+ // struct mobj_s* sprev;
+ str->sprev = saveg_readp();
+
+ // angle_t angle;
+ str->angle = saveg_read32();
+
+ // spritenum_t sprite;
+ str->sprite = saveg_read_enum();
+
+ // int frame;
+ str->frame = saveg_read32();
+
+ // struct mobj_s* bnext;
+ str->bnext = saveg_readp();
+
+ // struct mobj_s* bprev;
+ str->bprev = saveg_readp();
+
+ // struct subsector_s* subsector;
+ str->subsector = saveg_readp();
+
+ // fixed_t floorz;
+ str->floorz = saveg_read32();
+
+ // fixed_t ceilingz;
+ str->ceilingz = saveg_read32();
+
+ // fixed_t radius;
+ str->radius = saveg_read32();
+
+ // fixed_t height;
+ str->height = saveg_read32();
+
+ // fixed_t momx;
+ str->momx = saveg_read32();
+
+ // fixed_t momy;
+ str->momy = saveg_read32();
+
+ // fixed_t momz;
+ str->momz = saveg_read32();
+
+ // int validcount;
+ str->validcount = saveg_read32();
+
+ // mobjtype_t type;
+ str->type = saveg_read_enum();
+
+ // mobjinfo_t* info;
+ str->info = saveg_readp();
+
+ // int tics;
+ str->tics = saveg_read32();
+
+ // state_t* state;
+ str->state = &states[saveg_read32()];
+
+ // int flags;
+ str->flags = saveg_read32();
+
+ // int health;
+ str->health = saveg_read32();
+
+ // int movedir;
+ str->movedir = saveg_read32();
+
+ // int movecount;
+ str->movecount = saveg_read32();
+
+ // struct mobj_s* target;
+ str->target = saveg_readp();
+
+ // int reactiontime;
+ str->reactiontime = saveg_read32();
+
+ // int threshold;
+ str->threshold = saveg_read32();
+
+ // struct player_s* player;
+ pl = saveg_read32();
+
+ if (pl > 0)
+ {
+ str->player = &players[pl - 1];
+ str->player->mo = str;
+ }
+ else
+ {
+ str->player = NULL;
+ }
+
+ // int lastlook;
+ str->lastlook = saveg_read32();
+
+ // mapthing_t spawnpoint;
+ saveg_read_mapthing_t(&str->spawnpoint);
+
+ // struct mobj_s* tracer;
+ str->tracer = saveg_readp();
+}
+
+static void saveg_write_mobj_t(mobj_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // fixed_t x;
+ saveg_write32(str->x);
+
+ // fixed_t y;
+ saveg_write32(str->y);
+
+ // fixed_t z;
+ saveg_write32(str->z);
+
+ // struct mobj_s* snext;
+ saveg_writep(str->snext);
+
+ // struct mobj_s* sprev;
+ saveg_writep(str->sprev);
+
+ // angle_t angle;
+ saveg_write32(str->angle);
+
+ // spritenum_t sprite;
+ saveg_write_enum(str->sprite);
+
+ // int frame;
+ saveg_write32(str->frame);
+
+ // struct mobj_s* bnext;
+ saveg_writep(str->bnext);
+
+ // struct mobj_s* bprev;
+ saveg_writep(str->bprev);
+
+ // struct subsector_s* subsector;
+ saveg_writep(str->subsector);
+
+ // fixed_t floorz;
+ saveg_write32(str->floorz);
+
+ // fixed_t ceilingz;
+ saveg_write32(str->ceilingz);
+
+ // fixed_t radius;
+ saveg_write32(str->radius);
+
+ // fixed_t height;
+ saveg_write32(str->height);
+
+ // fixed_t momx;
+ saveg_write32(str->momx);
+
+ // fixed_t momy;
+ saveg_write32(str->momy);
+
+ // fixed_t momz;
+ saveg_write32(str->momz);
+
+ // int validcount;
+ saveg_write32(str->validcount);
+
+ // mobjtype_t type;
+ saveg_write_enum(str->type);
+
+ // mobjinfo_t* info;
+ saveg_writep(str->info);
+
+ // int tics;
+ saveg_write32(str->tics);
+
+ // state_t* state;
+ saveg_write32(str->state - states);
+
+ // int flags;
+ saveg_write32(str->flags);
+
+ // int health;
+ saveg_write32(str->health);
+
+ // int movedir;
+ saveg_write32(str->movedir);
+
+ // int movecount;
+ saveg_write32(str->movecount);
+
+ // struct mobj_s* target;
+ saveg_writep(str->target);
+
+ // int reactiontime;
+ saveg_write32(str->reactiontime);
+
+ // int threshold;
+ saveg_write32(str->threshold);
+
+ // struct player_s* player;
+ if (str->player)
+ {
+ saveg_write32(str->player - players + 1);
+ }
+ else
+ {
+ saveg_write32(0);
+ }
+
+ // int lastlook;
+ saveg_write32(str->lastlook);
+
+ // mapthing_t spawnpoint;
+ saveg_write_mapthing_t(&str->spawnpoint);
+
+ // struct mobj_s* tracer;
+ saveg_writep(str->tracer);
+}
+
+
+//
+// ticcmd_t
+//
+
+static void saveg_read_ticcmd_t(ticcmd_t *str)
+{
+
+ // signed char forwardmove;
+ str->forwardmove = saveg_read8();
+
+ // signed char sidemove;
+ str->sidemove = saveg_read8();
+
+ // short angleturn;
+ str->angleturn = saveg_read16();
+
+ // short consistancy;
+ str->consistancy = saveg_read16();
+
+ // byte chatchar;
+ str->chatchar = saveg_read8();
+
+ // byte buttons;
+ str->buttons = saveg_read8();
+}
+
+static void saveg_write_ticcmd_t(ticcmd_t *str)
+{
+
+ // signed char forwardmove;
+ saveg_write8(str->forwardmove);
+
+ // signed char sidemove;
+ saveg_write8(str->sidemove);
+
+ // short angleturn;
+ saveg_write16(str->angleturn);
+
+ // short consistancy;
+ saveg_write16(str->consistancy);
+
+ // byte chatchar;
+ saveg_write8(str->chatchar);
+
+ // byte buttons;
+ saveg_write8(str->buttons);
+}
+
+//
+// pspdef_t
+//
+
+static void saveg_read_pspdef_t(pspdef_t *str)
+{
+ int state;
+
+ // state_t* state;
+ state = saveg_read32();
+
+ if (state > 0)
+ {
+ str->state = &states[state];
+ }
+ else
+ {
+ str->state = NULL;
+ }
+
+ // int tics;
+ str->tics = saveg_read32();
+
+ // fixed_t sx;
+ str->sx = saveg_read32();
+
+ // fixed_t sy;
+ str->sy = saveg_read32();
+}
+
+static void saveg_write_pspdef_t(pspdef_t *str)
+{
+ // state_t* state;
+ if (str->state)
+ {
+ saveg_write32(str->state - states);
+ }
+ else
+ {
+ saveg_write32(0);
+ }
+
+ // int tics;
+ saveg_write32(str->tics);
+
+ // fixed_t sx;
+ saveg_write32(str->sx);
+
+ // fixed_t sy;
+ saveg_write32(str->sy);
+}
+
+//
+// player_t
+//
+
+static void saveg_read_player_t(player_t *str)
+{
+ int i;
+
+ // mobj_t* mo;
+ str->mo = saveg_readp();
+
+ // playerstate_t playerstate;
+ str->playerstate = saveg_read_enum();
+
+ // ticcmd_t cmd;
+ saveg_read_ticcmd_t(&str->cmd);
+
+ // fixed_t viewz;
+ str->viewz = saveg_read32();
+
+ // fixed_t viewheight;
+ str->viewheight = saveg_read32();
+
+ // fixed_t deltaviewheight;
+ str->deltaviewheight = saveg_read32();
+
+ // fixed_t bob;
+ str->bob = saveg_read32();
+
+ // int health;
+ str->health = saveg_read32();
+
+ // int armorpoints;
+ str->armorpoints = saveg_read32();
+
+ // int armortype;
+ str->armortype = saveg_read32();
+
+ // int powers[NUMPOWERS];
+ for (i=0; i<NUMPOWERS; ++i)
+ {
+ str->powers[i] = saveg_read32();
+ }
+
+ // boolean cards[NUMCARDS];
+ for (i=0; i<NUMCARDS; ++i)
+ {
+ str->cards[i] = saveg_read32();
+ }
+
+ // boolean backpack;
+ str->backpack = saveg_read32();
+
+ // int frags[MAXPLAYERS];
+ for (i=0; i<MAXPLAYERS; ++i)
+ {
+ str->frags[i] = saveg_read32();
+ }
+
+ // weapontype_t readyweapon;
+ str->readyweapon = saveg_read_enum();
+
+ // weapontype_t pendingweapon;
+ str->pendingweapon = saveg_read_enum();
+
+ // boolean weaponowned[NUMWEAPONS];
+ for (i=0; i<NUMWEAPONS; ++i)
+ {
+ str->weaponowned[i] = saveg_read32();
+ }
+
+ // int ammo[NUMAMMO];
+ for (i=0; i<NUMAMMO; ++i)
+ {
+ str->ammo[i] = saveg_read32();
+ }
+
+ // int maxammo[NUMAMMO];
+ for (i=0; i<NUMAMMO; ++i)
+ {
+ str->maxammo[i] = saveg_read32();
+ }
+
+ // int attackdown;
+ str->attackdown = saveg_read32();
+
+ // int usedown;
+ str->usedown = saveg_read32();
+
+ // int cheats;
+ str->cheats = saveg_read32();
+
+ // int refire;
+ str->refire = saveg_read32();
+
+ // int killcount;
+ str->killcount = saveg_read32();
+
+ // int itemcount;
+ str->itemcount = saveg_read32();
+
+ // int secretcount;
+ str->secretcount = saveg_read32();
+
+ // char* message;
+ str->message = saveg_readp();
+
+ // int damagecount;
+ str->damagecount = saveg_read32();
+
+ // int bonuscount;
+ str->bonuscount = saveg_read32();
+
+ // mobj_t* attacker;
+ str->attacker = saveg_readp();
+
+ // int extralight;
+ str->extralight = saveg_read32();
+
+ // int fixedcolormap;
+ str->fixedcolormap = saveg_read32();
+
+ // int colormap;
+ str->colormap = saveg_read32();
+
+ // pspdef_t psprites[NUMPSPRITES];
+ for (i=0; i<NUMPSPRITES; ++i)
+ {
+ saveg_read_pspdef_t(&str->psprites[i]);
+ }
+
+ // boolean didsecret;
+ str->didsecret = saveg_read32();
+}
+
+static void saveg_write_player_t(player_t *str)
+{
+ int i;
+
+ // mobj_t* mo;
+ saveg_writep(str->mo);
+
+ // playerstate_t playerstate;
+ saveg_write_enum(str->playerstate);
+
+ // ticcmd_t cmd;
+ saveg_write_ticcmd_t(&str->cmd);
+
+ // fixed_t viewz;
+ saveg_write32(str->viewz);
+
+ // fixed_t viewheight;
+ saveg_write32(str->viewheight);
+
+ // fixed_t deltaviewheight;
+ saveg_write32(str->deltaviewheight);
+
+ // fixed_t bob;
+ saveg_write32(str->bob);
+
+ // int health;
+ saveg_write32(str->health);
+
+ // int armorpoints;
+ saveg_write32(str->armorpoints);
+
+ // int armortype;
+ saveg_write32(str->armortype);
+
+ // int powers[NUMPOWERS];
+ for (i=0; i<NUMPOWERS; ++i)
+ {
+ saveg_write32(str->powers[i]);
+ }
+
+ // boolean cards[NUMCARDS];
+ for (i=0; i<NUMCARDS; ++i)
+ {
+ saveg_write32(str->cards[i]);
+ }
+
+ // boolean backpack;
+ saveg_write32(str->backpack);
+
+ // int frags[MAXPLAYERS];
+ for (i=0; i<MAXPLAYERS; ++i)
+ {
+ saveg_write32(str->frags[i]);
+ }
+
+ // weapontype_t readyweapon;
+ saveg_write_enum(str->readyweapon);
+
+ // weapontype_t pendingweapon;
+ saveg_write_enum(str->pendingweapon);
+
+ // boolean weaponowned[NUMWEAPONS];
+ for (i=0; i<NUMWEAPONS; ++i)
+ {
+ saveg_write32(str->weaponowned[i]);
+ }
+
+ // int ammo[NUMAMMO];
+ for (i=0; i<NUMAMMO; ++i)
+ {
+ saveg_write32(str->ammo[i]);
+ }
+
+ // int maxammo[NUMAMMO];
+ for (i=0; i<NUMAMMO; ++i)
+ {
+ saveg_write32(str->maxammo[i]);
+ }
+
+ // int attackdown;
+ saveg_write32(str->attackdown);
+
+ // int usedown;
+ saveg_write32(str->usedown);
+
+ // int cheats;
+ saveg_write32(str->cheats);
+
+ // int refire;
+ saveg_write32(str->refire);
+
+ // int killcount;
+ saveg_write32(str->killcount);
+
+ // int itemcount;
+ saveg_write32(str->itemcount);
+
+ // int secretcount;
+ saveg_write32(str->secretcount);
+
+ // char* message;
+ saveg_writep(str->message);
+
+ // int damagecount;
+ saveg_write32(str->damagecount);
+
+ // int bonuscount;
+ saveg_write32(str->bonuscount);
+
+ // mobj_t* attacker;
+ saveg_writep(str->attacker);
+
+ // int extralight;
+ saveg_write32(str->extralight);
+
+ // int fixedcolormap;
+ saveg_write32(str->fixedcolormap);
+
+ // int colormap;
+ saveg_write32(str->colormap);
+
+ // pspdef_t psprites[NUMPSPRITES];
+ for (i=0; i<NUMPSPRITES; ++i)
+ {
+ saveg_write_pspdef_t(&str->psprites[i]);
+ }
+
+ // boolean didsecret;
+ saveg_write32(str->didsecret);
+}
+
+
+//
+// ceiling_t
+//
+
+static void saveg_read_ceiling_t(ceiling_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // ceiling_e type;
+ str->type = saveg_read_enum();
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // fixed_t bottomheight;
+ str->bottomheight = saveg_read32();
+
+ // fixed_t topheight;
+ str->topheight = saveg_read32();
+
+ // fixed_t speed;
+ str->speed = saveg_read32();
+
+ // boolean crush;
+ str->crush = saveg_read32();
+
+ // int direction;
+ str->direction = saveg_read32();
+
+ // int tag;
+ str->tag = saveg_read32();
+
+ // int olddirection;
+ str->olddirection = saveg_read32();
+}
+
+static void saveg_write_ceiling_t(ceiling_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // ceiling_e type;
+ saveg_write_enum(str->type);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // fixed_t bottomheight;
+ saveg_write32(str->bottomheight);
+
+ // fixed_t topheight;
+ saveg_write32(str->topheight);
+
+ // fixed_t speed;
+ saveg_write32(str->speed);
+
+ // boolean crush;
+ saveg_write32(str->crush);
+
+ // int direction;
+ saveg_write32(str->direction);
+
+ // int tag;
+ saveg_write32(str->tag);
+
+ // int olddirection;
+ saveg_write32(str->olddirection);
+}
+
+//
+// vldoor_t
+//
+
+static void saveg_read_vldoor_t(vldoor_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // vldoor_e type;
+ str->type = saveg_read_enum();
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // fixed_t topheight;
+ str->topheight = saveg_read32();
+
+ // fixed_t speed;
+ str->speed = saveg_read32();
+
+ // int direction;
+ str->direction = saveg_read32();
+
+ // int topwait;
+ str->topwait = saveg_read32();
+
+ // int topcountdown;
+ str->topcountdown = saveg_read32();
+}
+
+static void saveg_write_vldoor_t(vldoor_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // vldoor_e type;
+ saveg_write_enum(str->type);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // fixed_t topheight;
+ saveg_write32(str->topheight);
+
+ // fixed_t speed;
+ saveg_write32(str->speed);
+
+ // int direction;
+ saveg_write32(str->direction);
+
+ // int topwait;
+ saveg_write32(str->topwait);
+
+ // int topcountdown;
+ saveg_write32(str->topcountdown);
+}
+
+//
+// floormove_t
+//
+
+static void saveg_read_floormove_t(floormove_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // floor_e type;
+ str->type = saveg_read_enum();
+
+ // boolean crush;
+ str->crush = saveg_read32();
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // int direction;
+ str->direction = saveg_read32();
+
+ // int newspecial;
+ str->newspecial = saveg_read32();
+
+ // short texture;
+ str->texture = saveg_read16();
+
+ // fixed_t floordestheight;
+ str->floordestheight = saveg_read32();
+
+ // fixed_t speed;
+ str->speed = saveg_read32();
+}
+
+static void saveg_write_floormove_t(floormove_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // floor_e type;
+ saveg_write_enum(str->type);
+
+ // boolean crush;
+ saveg_write32(str->crush);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // int direction;
+ saveg_write32(str->direction);
+
+ // int newspecial;
+ saveg_write32(str->newspecial);
+
+ // short texture;
+ saveg_write16(str->texture);
+
+ // fixed_t floordestheight;
+ saveg_write32(str->floordestheight);
+
+ // fixed_t speed;
+ saveg_write32(str->speed);
+}
+
+//
+// plat_t
+//
+
+static void saveg_read_plat_t(plat_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // fixed_t speed;
+ str->speed = saveg_read32();
+
+ // fixed_t low;
+ str->low = saveg_read32();
+
+ // fixed_t high;
+ str->high = saveg_read32();
+
+ // int wait;
+ str->wait = saveg_read32();
+
+ // int count;
+ str->count = saveg_read32();
+
+ // plat_e status;
+ str->status = saveg_read_enum();
+
+ // plat_e oldstatus;
+ str->oldstatus = saveg_read_enum();
+
+ // boolean crush;
+ str->crush = saveg_read32();
+
+ // int tag;
+ str->tag = saveg_read32();
+
+ // plattype_e type;
+ str->type = saveg_read_enum();
+}
+
+static void saveg_write_plat_t(plat_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // fixed_t speed;
+ saveg_write32(str->speed);
+
+ // fixed_t low;
+ saveg_write32(str->low);
+
+ // fixed_t high;
+ saveg_write32(str->high);
+
+ // int wait;
+ saveg_write32(str->wait);
+
+ // int count;
+ saveg_write32(str->count);
+
+ // plat_e status;
+ saveg_write_enum(str->status);
+
+ // plat_e oldstatus;
+ saveg_write_enum(str->oldstatus);
+
+ // boolean crush;
+ saveg_write32(str->crush);
+
+ // int tag;
+ saveg_write32(str->tag);
+
+ // plattype_e type;
+ saveg_write_enum(str->type);
+}
+
+//
+// lightflash_t
+//
+
+static void saveg_read_lightflash_t(lightflash_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // int count;
+ str->count = saveg_read32();
+
+ // int maxlight;
+ str->maxlight = saveg_read32();
+
+ // int minlight;
+ str->minlight = saveg_read32();
+
+ // int maxtime;
+ str->maxtime = saveg_read32();
+
+ // int mintime;
+ str->mintime = saveg_read32();
+}
+
+static void saveg_write_lightflash_t(lightflash_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // int count;
+ saveg_write32(str->count);
+
+ // int maxlight;
+ saveg_write32(str->maxlight);
+
+ // int minlight;
+ saveg_write32(str->minlight);
+
+ // int maxtime;
+ saveg_write32(str->maxtime);
+
+ // int mintime;
+ saveg_write32(str->mintime);
+}
+
+//
+// strobe_t
+//
+
+static void saveg_read_strobe_t(strobe_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // int count;
+ str->count = saveg_read32();
+
+ // int minlight;
+ str->minlight = saveg_read32();
+
+ // int maxlight;
+ str->maxlight = saveg_read32();
+
+ // int darktime;
+ str->darktime = saveg_read32();
+
+ // int brighttime;
+ str->brighttime = saveg_read32();
+}
+
+static void saveg_write_strobe_t(strobe_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // int count;
+ saveg_write32(str->count);
+
+ // int minlight;
+ saveg_write32(str->minlight);
+
+ // int maxlight;
+ saveg_write32(str->maxlight);
+
+ // int darktime;
+ saveg_write32(str->darktime);
+
+ // int brighttime;
+ saveg_write32(str->brighttime);
+}
+
+//
+// glow_t
+//
+
+static void saveg_read_glow_t(glow_t *str)
+{
+ int sector;
+
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = &sectors[sector];
+
+ // int minlight;
+ str->minlight = saveg_read32();
+
+ // int maxlight;
+ str->maxlight = saveg_read32();
+
+ // int direction;
+ str->direction = saveg_read32();
+}
+
+static void saveg_write_glow_t(glow_t *str)
+{
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
+
+ // sector_t* sector;
+ saveg_write32(str->sector - sectors);
+
+ // int minlight;
+ saveg_write32(str->minlight);
+
+ // int maxlight;
+ saveg_write32(str->maxlight);
+
+ // int direction;
+ saveg_write32(str->direction);
+}
+
//
// P_ArchivePlayers
@@ -82,8 +1309,6 @@ char *P_SaveGameFile(int slot)
void P_ArchivePlayers (void)
{
int i;
- int j;
- player_t* dest;
for (i=0 ; i<MAXPLAYERS ; i++)
{
@@ -92,17 +1317,7 @@ void P_ArchivePlayers (void)
PADSAVEP();
- dest = (player_t *)save_p;
- memcpy (dest,&players[i],sizeof(player_t));
- save_p += sizeof(player_t);
- for (j=0 ; j<NUMPSPRITES ; j++)
- {
- if (dest->psprites[j].state)
- {
- dest->psprites[j].state
- = (state_t *)(dest->psprites[j].state-states);
- }
- }
+ saveg_write_player_t(&players[i]);
}
}
@@ -114,7 +1329,6 @@ void P_ArchivePlayers (void)
void P_UnArchivePlayers (void)
{
int i;
- int j;
for (i=0 ; i<MAXPLAYERS ; i++)
{
@@ -123,22 +1337,12 @@ void P_UnArchivePlayers (void)
PADSAVEP();
- memcpy (&players[i],save_p, sizeof(player_t));
- save_p += sizeof(player_t);
+ saveg_read_player_t(&players[i]);
// will be set when unarc thinker
players[i].mo = NULL;
players[i].message = NULL;
players[i].attacker = NULL;
-
- for (j=0 ; j<NUMPSPRITES ; j++)
- {
- if (players[i]. psprites[j].state)
- {
- players[i]. psprites[j].state
- = &states[ (int)players[i].psprites[j].state ];
- }
- }
}
}
@@ -153,29 +1357,26 @@ void P_ArchiveWorld (void)
sector_t* sec;
line_t* li;
side_t* si;
- short* put;
-
- put = (short *)save_p;
// do sectors
for (i=0, sec = sectors ; i<numsectors ; i++,sec++)
{
- *put++ = sec->floorheight >> FRACBITS;
- *put++ = sec->ceilingheight >> FRACBITS;
- *put++ = sec->floorpic;
- *put++ = sec->ceilingpic;
- *put++ = sec->lightlevel;
- *put++ = sec->special; // needed?
- *put++ = sec->tag; // needed?
+ saveg_write16(sec->floorheight >> FRACBITS);
+ saveg_write16(sec->ceilingheight >> FRACBITS);
+ saveg_write16(sec->floorpic);
+ saveg_write16(sec->ceilingpic);
+ saveg_write16(sec->lightlevel);
+ saveg_write16(sec->special); // needed?
+ saveg_write16(sec->tag); // needed?
}
// do lines
for (i=0, li = lines ; i<numlines ; i++,li++)
{
- *put++ = li->flags;
- *put++ = li->special;
- *put++ = li->tag;
+ saveg_write16(li->flags);
+ saveg_write16(li->special);
+ saveg_write16(li->tag);
for (j=0 ; j<2 ; j++)
{
if (li->sidenum[j] == -1)
@@ -183,15 +1384,13 @@ void P_ArchiveWorld (void)
si = &sides[li->sidenum[j]];
- *put++ = si->textureoffset >> FRACBITS;
- *put++ = si->rowoffset >> FRACBITS;
- *put++ = si->toptexture;
- *put++ = si->bottomtexture;
- *put++ = si->midtexture;
+ saveg_write16(si->textureoffset >> FRACBITS);
+ saveg_write16(si->rowoffset >> FRACBITS);
+ saveg_write16(si->toptexture);
+ saveg_write16(si->bottomtexture);
+ saveg_write16(si->midtexture);
}
}
-
- save_p = (byte *)put;
}
@@ -206,20 +1405,17 @@ void P_UnArchiveWorld (void)
sector_t* sec;
line_t* li;
side_t* si;
- short* get;
-
- get = (short *)save_p;
// do sectors
for (i=0, sec = sectors ; i<numsectors ; i++,sec++)
{
- sec->floorheight = *get++ << FRACBITS;
- sec->ceilingheight = *get++ << FRACBITS;
- sec->floorpic = *get++;
- sec->ceilingpic = *get++;
- sec->lightlevel = *get++;
- sec->special = *get++; // needed?
- sec->tag = *get++; // needed?
+ sec->floorheight = saveg_read16() << FRACBITS;
+ sec->ceilingheight = saveg_read16() << FRACBITS;
+ sec->floorpic = saveg_read16();
+ sec->ceilingpic = saveg_read16();
+ sec->lightlevel = saveg_read16();
+ sec->special = saveg_read16(); // needed?
+ sec->tag = saveg_read16(); // needed?
sec->specialdata = 0;
sec->soundtarget = 0;
}
@@ -227,22 +1423,21 @@ void P_UnArchiveWorld (void)
// do lines
for (i=0, li = lines ; i<numlines ; i++,li++)
{
- li->flags = *get++;
- li->special = *get++;
- li->tag = *get++;
+ li->flags = saveg_read16();
+ li->special = saveg_read16();
+ li->tag = saveg_read16();
for (j=0 ; j<2 ; j++)
{
if (li->sidenum[j] == -1)
continue;
si = &sides[li->sidenum[j]];
- si->textureoffset = *get++ << FRACBITS;
- si->rowoffset = *get++ << FRACBITS;
- si->toptexture = *get++;
- si->bottomtexture = *get++;
- si->midtexture = *get++;
+ si->textureoffset = saveg_read16() << FRACBITS;
+ si->rowoffset = saveg_read16() << FRACBITS;
+ si->toptexture = saveg_read16();
+ si->bottomtexture = saveg_read16();
+ si->midtexture = saveg_read16();
}
}
- save_p = (byte *)get;
}
@@ -280,31 +1475,16 @@ typedef enum
void P_ArchiveThinkers (void)
{
thinker_t* th;
- mobj_t* mobj;
// save off the current thinkers
for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
{
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
{
- *save_p++ = tc_mobj;
+ saveg_write8(tc_mobj);
PADSAVEP();
- mobj = (mobj_t *)save_p;
- memcpy (mobj, th, sizeof(*mobj));
- save_p += sizeof(*mobj);
-
- // Hack fix for structure packing bug, see above.
+ saveg_write_mobj_t((mobj_t *) th);
- if (sizeof(mobj_t) == 156)
- {
- memmove(save_p - 6, save_p - 4, 4);
- save_p -= 2;
- }
-
- mobj->state = (state_t *)(mobj->state - states);
-
- if (mobj->player)
- mobj->player = (player_t *)((mobj->player-players) + 1);
continue;
}
@@ -312,7 +1492,7 @@ void P_ArchiveThinkers (void)
}
// add a terminating marker
- *save_p++ = tc_end;
+ saveg_write8(tc_end);
}
@@ -345,7 +1525,7 @@ void P_UnArchiveThinkers (void)
// read in saved thinkers
while (1)
{
- tclass = *save_p++;
+ tclass = saveg_read8();
switch (tclass)
{
case tc_end:
@@ -354,24 +1534,9 @@ void P_UnArchiveThinkers (void)
case tc_mobj:
PADSAVEP();
mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
- memcpy (mobj, save_p, sizeof(*mobj));
- save_p += sizeof(*mobj);
-
- // Hack fix for structure packing bug, see above.
-
- if (sizeof(mobj_t) == 156)
- {
- save_p -= 2;
- memmove(&mobj->tracer, save_p - 4, 4);
- }
+ saveg_read_mobj_t(mobj);
- mobj->state = &states[(int)mobj->state];
mobj->target = NULL;
- if (mobj->player)
- {
- mobj->player = &players[(int)mobj->player-1];
- mobj->player->mo = mobj;
- }
P_SetThingPosition (mobj);
mobj->info = &mobjinfo[mobj->type];
mobj->floorz = mobj->subsector->sector->floorheight;
@@ -379,7 +1544,7 @@ void P_UnArchiveThinkers (void)
mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker;
P_AddThinker (&mobj->thinker);
break;
-
+
default:
I_Error ("Unknown tclass %i in savegame",tclass);
}
@@ -421,13 +1586,6 @@ enum
void P_ArchiveSpecials (void)
{
thinker_t* th;
- ceiling_t* ceiling;
- vldoor_t* door;
- floormove_t* floor;
- plat_t* plat;
- lightflash_t* flash;
- strobe_t* strobe;
- glow_t* glow;
int i;
// save off the current thinkers
@@ -441,96 +1599,72 @@ void P_ArchiveSpecials (void)
if (i<MAXCEILINGS)
{
- *save_p++ = tc_ceiling;
+ saveg_write8(tc_ceiling);
PADSAVEP();
- ceiling = (ceiling_t *)save_p;
- memcpy (ceiling, th, sizeof(*ceiling));
- save_p += sizeof(*ceiling);
- ceiling->sector = (sector_t *)(ceiling->sector - sectors);
+ saveg_write_ceiling_t((ceiling_t *) th);
}
continue;
}
if (th->function.acp1 == (actionf_p1)T_MoveCeiling)
{
- *save_p++ = tc_ceiling;
+ saveg_write8(tc_ceiling);
PADSAVEP();
- ceiling = (ceiling_t *)save_p;
- memcpy (ceiling, th, sizeof(*ceiling));
- save_p += sizeof(*ceiling);
- ceiling->sector = (sector_t *)(ceiling->sector - sectors);
+ saveg_write_ceiling_t((ceiling_t *) th);
continue;
}
if (th->function.acp1 == (actionf_p1)T_VerticalDoor)
{
- *save_p++ = tc_door;
+ saveg_write8(tc_door);
PADSAVEP();
- door = (vldoor_t *)save_p;
- memcpy (door, th, sizeof(*door));
- save_p += sizeof(*door);
- door->sector = (sector_t *)(door->sector - sectors);
+ saveg_write_vldoor_t((vldoor_t *) th);
continue;
}
if (th->function.acp1 == (actionf_p1)T_MoveFloor)
{
- *save_p++ = tc_floor;
+ saveg_write8(tc_floor);
PADSAVEP();
- floor = (floormove_t *)save_p;
- memcpy (floor, th, sizeof(*floor));
- save_p += sizeof(*floor);
- floor->sector = (sector_t *)(floor->sector - sectors);
+ saveg_write_floormove_t((floormove_t *) th);
continue;
}
if (th->function.acp1 == (actionf_p1)T_PlatRaise)
{
- *save_p++ = tc_plat;
+ saveg_write8(tc_plat);
PADSAVEP();
- plat = (plat_t *)save_p;
- memcpy (plat, th, sizeof(*plat));
- save_p += sizeof(*plat);
- plat->sector = (sector_t *)(plat->sector - sectors);
+ saveg_write_plat_t((plat_t *) th);
continue;
}
if (th->function.acp1 == (actionf_p1)T_LightFlash)
{
- *save_p++ = tc_flash;
+ saveg_write8(tc_flash);
PADSAVEP();
- flash = (lightflash_t *)save_p;
- memcpy (flash, th, sizeof(*flash));
- save_p += sizeof(*flash);
- flash->sector = (sector_t *)(flash->sector - sectors);
+ saveg_write_lightflash_t((lightflash_t *) th);
continue;
}
if (th->function.acp1 == (actionf_p1)T_StrobeFlash)
{
- *save_p++ = tc_strobe;
+ saveg_write8(tc_strobe);
PADSAVEP();
- strobe = (strobe_t *)save_p;
- memcpy (strobe, th, sizeof(*strobe));
- save_p += sizeof(*strobe);
- strobe->sector = (sector_t *)(strobe->sector - sectors);
+ saveg_write_strobe_t((strobe_t *) th);
continue;
}
if (th->function.acp1 == (actionf_p1)T_Glow)
{
- *save_p++ = tc_glow;
+ saveg_write8(tc_glow);
PADSAVEP();
- glow = (glow_t *)save_p;
- memcpy (glow, th, sizeof(*glow));
- save_p += sizeof(*glow);
- glow->sector = (sector_t *)(glow->sector - sectors);
+ saveg_write_glow_t((glow_t *) th);
continue;
}
}
// add a terminating marker
- *save_p++ = tc_endspecials;
+ saveg_write8(tc_endspecials);
}
@@ -553,7 +1687,8 @@ void P_UnArchiveSpecials (void)
// read in saved thinkers
while (1)
{
- tclass = *save_p++;
+ tclass = saveg_read8();
+
switch (tclass)
{
case tc_endspecials:
@@ -562,9 +1697,7 @@ void P_UnArchiveSpecials (void)
case tc_ceiling:
PADSAVEP();
ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVEL, NULL);
- memcpy (ceiling, save_p, sizeof(*ceiling));
- save_p += sizeof(*ceiling);
- ceiling->sector = &sectors[(int)ceiling->sector];
+ saveg_read_ceiling_t(ceiling);
ceiling->sector->specialdata = ceiling;
if (ceiling->thinker.function.acp1)
@@ -577,9 +1710,7 @@ void P_UnArchiveSpecials (void)
case tc_door:
PADSAVEP();
door = Z_Malloc (sizeof(*door), PU_LEVEL, NULL);
- memcpy (door, save_p, sizeof(*door));
- save_p += sizeof(*door);
- door->sector = &sectors[(int)door->sector];
+ saveg_read_vldoor_t(door);
door->sector->specialdata = door;
door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
P_AddThinker (&door->thinker);
@@ -588,9 +1719,7 @@ void P_UnArchiveSpecials (void)
case tc_floor:
PADSAVEP();
floor = Z_Malloc (sizeof(*floor), PU_LEVEL, NULL);
- memcpy (floor, save_p, sizeof(*floor));
- save_p += sizeof(*floor);
- floor->sector = &sectors[(int)floor->sector];
+ saveg_read_floormove_t(floor);
floor->sector->specialdata = floor;
floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
P_AddThinker (&floor->thinker);
@@ -599,9 +1728,7 @@ void P_UnArchiveSpecials (void)
case tc_plat:
PADSAVEP();
plat = Z_Malloc (sizeof(*plat), PU_LEVEL, NULL);
- memcpy (plat, save_p, sizeof(*plat));
- save_p += sizeof(*plat);
- plat->sector = &sectors[(int)plat->sector];
+ saveg_read_plat_t(plat);
plat->sector->specialdata = plat;
if (plat->thinker.function.acp1)
@@ -614,9 +1741,7 @@ void P_UnArchiveSpecials (void)
case tc_flash:
PADSAVEP();
flash = Z_Malloc (sizeof(*flash), PU_LEVEL, NULL);
- memcpy (flash, save_p, sizeof(*flash));
- save_p += sizeof(*flash);
- flash->sector = &sectors[(int)flash->sector];
+ saveg_read_lightflash_t(flash);
flash->thinker.function.acp1 = (actionf_p1)T_LightFlash;
P_AddThinker (&flash->thinker);
break;
@@ -624,9 +1749,7 @@ void P_UnArchiveSpecials (void)
case tc_strobe:
PADSAVEP();
strobe = Z_Malloc (sizeof(*strobe), PU_LEVEL, NULL);
- memcpy (strobe, save_p, sizeof(*strobe));
- save_p += sizeof(*strobe);
- strobe->sector = &sectors[(int)strobe->sector];
+ saveg_read_strobe_t(strobe);
strobe->thinker.function.acp1 = (actionf_p1)T_StrobeFlash;
P_AddThinker (&strobe->thinker);
break;
@@ -634,9 +1757,7 @@ void P_UnArchiveSpecials (void)
case tc_glow:
PADSAVEP();
glow = Z_Malloc (sizeof(*glow), PU_LEVEL, NULL);
- memcpy (glow, save_p, sizeof(*glow));
- save_p += sizeof(*glow);
- glow->sector = &sectors[(int)glow->sector];
+ saveg_read_glow_t(glow);
glow->thinker.function.acp1 = (actionf_p1)T_Glow;
P_AddThinker (&glow->thinker);
break;