[chocolate-doom] 70/79: 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.
Jonathan Dowland
jmtd at moszumanska.debian.org
Mon Jan 30 15:07:27 UTC 2017
This is an automated email from the git hooks/post-receive script.
jmtd pushed a commit to annotated tag chocolate-doom-0.1.3
in repository chocolate-doom.
commit fa843fc93409d2b83d2b0dae4d743acd5f028ea9
Author: Simon Howard <fraggle at gmail.com>
Date: Thu Jan 19 00:09:20 2006 +0000
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.
Subversion-branch: /trunk/chocolate-doom
Subversion-revision: 298
---
src/p_saveg.c | 1525 +++++++++++++++++++++++++++++++++++++++++++++++++--------
1 file changed, 1323 insertions(+), 202 deletions(-)
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 455dc61..22e9646 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,57 +22,1284 @@
// 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
//
-// Revision 1.3 2005/10/16 01:18:10 fraggle
-// Global "configdir" variable with directory to store config files in.
-// Create a function to find the filename for a savegame slot. Store
-// savegames in the config dir.
+// Revision 1.3 2005/10/16 01:18:10 fraggle
+// Global "configdir" variable with directory to store config files in.
+// Create a function to find the filename for a savegame slot. Store
+// savegames in the config dir.
+//
+// Revision 1.2 2005/07/23 16:44:56 fraggle
+// Update copyright to GNU GPL
+//
+// Revision 1.1.1.1 2005/07/23 16:20:39 fraggle
+// Initial import
+//
+//
+// DESCRIPTION:
+// Archiving: SaveGame I/O.
+//
+//-----------------------------------------------------------------------------
+
+static const char
+rcsid[] = "$Id: p_saveg.c 298 2006-01-19 00:09:20Z fraggle $";
+
+#include "dstrings.h"
+#include "deh_main.h"
+#include "i_system.h"
+#include "z_zone.h"
+#include "p_local.h"
+
+// State.
+#include "doomstat.h"
+#include "r_state.h"
+
+byte* save_p;
+
+
+// Pads save_p to a 4-byte boundary
+// so that the load/save works on SGI&Gecko.
+#define PADSAVEP() save_p += (4 - ((int) save_p & 3)) & 3
+
+
+char *P_SaveGameFile(int slot)
+{
+ static char filename[256];
+ char basename[32];
+
+ sprintf(basename, DEH_String(SAVEGAMENAME "%d.dsg"), slot);
+
+ sprintf(filename, "%s%s", configdir, basename);
+
+ 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
//
-// Revision 1.2 2005/07/23 16:44:56 fraggle
-// Update copyright to GNU GPL
+
+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 = §ors[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);
+}
+
//
-// Revision 1.1.1.1 2005/07/23 16:20:39 fraggle
-// Initial import
+// 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 = §ors[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);
+}
+
//
-// DESCRIPTION:
-// Archiving: SaveGame I/O.
+// floormove_t
//
-//-----------------------------------------------------------------------------
-static const char
-rcsid[] = "$Id: p_saveg.c 296 2006-01-16 21:40:38Z fraggle $";
+static void saveg_read_floormove_t(floormove_t *str)
+{
+ int sector;
-#include "dstrings.h"
-#include "deh_main.h"
-#include "i_system.h"
-#include "z_zone.h"
-#include "p_local.h"
+ // thinker_t thinker;
+ saveg_read_thinker_t(&str->thinker);
-// State.
-#include "doomstat.h"
-#include "r_state.h"
+ // floor_e type;
+ str->type = saveg_read_enum();
-byte* save_p;
+ // boolean crush;
+ str->crush = saveg_read32();
+ // sector_t* sector;
+ sector = saveg_read32();
+ str->sector = §ors[sector];
-// Pads save_p to a 4-byte boundary
-// so that the load/save works on SGI&Gecko.
-#define PADSAVEP() save_p += (4 - ((int) save_p & 3)) & 3
+ // int direction;
+ str->direction = saveg_read32();
+ // int newspecial;
+ str->newspecial = saveg_read32();
-char *P_SaveGameFile(int slot)
+ // 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)
{
- static char filename[256];
- char basename[32];
+ // thinker_t thinker;
+ saveg_write_thinker_t(&str->thinker);
- sprintf(basename, DEH_String(SAVEGAMENAME "%d.dsg"), slot);
+ // floor_e type;
+ saveg_write_enum(str->type);
- sprintf(filename, "%s%s", configdir, basename);
+ // boolean crush;
+ saveg_write32(str->crush);
- return filename;
+ // 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 = §ors[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 = §ors[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 = §ors[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 = §ors[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);
}
@@ -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 = §ors[(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 = §ors[(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 = §ors[(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 = §ors[(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 = §ors[(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 = §ors[(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 = §ors[(int)glow->sector];
+ saveg_read_glow_t(glow);
glow->thinker.function.acp1 = (actionf_p1)T_Glow;
P_AddThinker (&glow->thinker);
break;
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-games/chocolate-doom.git
More information about the Pkg-games-commits
mailing list