2006-04-13 20:47:06 +00:00
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
/*
|
2010-05-25 10:56:00 +00:00
|
|
|
Copyright (C) 2010 EDuke32 developers and contributors
|
2006-04-13 20:47:06 +00:00
|
|
|
|
2010-05-25 10:56:00 +00:00
|
|
|
This file is part of EDuke32.
|
2006-04-13 20:47:06 +00:00
|
|
|
|
|
|
|
EDuke32 is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU General Public License version 2
|
|
|
|
as published by the Free Software Foundation.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
|
|
#include "duke3d.h"
|
2010-08-02 08:13:51 +00:00
|
|
|
#include "premap.h"
|
2011-12-25 15:34:06 +00:00
|
|
|
#include "menus.h" // menutext
|
2010-06-23 04:20:46 +00:00
|
|
|
#include "prlights.h"
|
2011-07-29 22:07:49 +00:00
|
|
|
#include "savegame.h"
|
2013-05-20 19:31:42 +00:00
|
|
|
#ifdef LUNATIC
|
|
|
|
# include "lunatic_game.h"
|
|
|
|
static int32_t g_savedOK;
|
|
|
|
const char *g_failedVarname;
|
|
|
|
#endif
|
2006-04-13 20:47:06 +00:00
|
|
|
|
2008-08-16 22:15:46 +00:00
|
|
|
extern char *bitptr;
|
|
|
|
|
2012-11-13 10:50:06 +00:00
|
|
|
uint8_t g_oldverSavegame[10];
|
|
|
|
|
2008-08-17 09:01:31 +00:00
|
|
|
#define BITPTR_POINTER 1
|
|
|
|
|
2011-07-29 22:07:49 +00:00
|
|
|
// For storing pointers in files.
|
|
|
|
// back_p==0: ptr -> "small int"
|
|
|
|
// back_p==1: "small int" -> ptr
|
|
|
|
//
|
|
|
|
// mode: see enum in savegame.h
|
2012-11-11 17:57:01 +00:00
|
|
|
void G_Util_PtrToIdx(void *ptr, int32_t count, const void *base, int32_t mode)
|
2011-07-29 22:07:49 +00:00
|
|
|
{
|
2012-11-11 17:57:01 +00:00
|
|
|
int32_t i;
|
2012-11-15 14:28:36 +00:00
|
|
|
intptr_t *iptr = (intptr_t *)ptr;
|
2012-11-11 17:57:01 +00:00
|
|
|
intptr_t ibase = (intptr_t)base;
|
2011-07-29 22:07:49 +00:00
|
|
|
int32_t back_p = mode&P2I_BACK_BIT;
|
|
|
|
int32_t onlynon0_p = mode&P2I_ONLYNON0_BIT;
|
|
|
|
|
|
|
|
// TODO: convert to proper offsets/indices for (a step towards) cross-
|
|
|
|
// compatibility between 32- and 64-bit systems in the netplay.
|
|
|
|
// REMEMBER to bump BYTEVERSION then.
|
|
|
|
|
2012-11-11 17:57:01 +00:00
|
|
|
for (i=0; i<count; i++)
|
2011-07-29 22:07:49 +00:00
|
|
|
// WARNING: C std doesn't say that bit pattern of NULL is necessarily 0!
|
|
|
|
if (!onlynon0_p || iptr[i])
|
|
|
|
{
|
|
|
|
if (!back_p)
|
|
|
|
iptr[i] -= ibase;
|
|
|
|
else
|
|
|
|
iptr[i] += ibase;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-11 17:57:01 +00:00
|
|
|
void G_Util_PtrToIdx2(void *ptr, int32_t count, size_t stride, const void *base, int32_t mode)
|
2012-10-30 15:54:35 +00:00
|
|
|
{
|
2012-11-11 17:57:01 +00:00
|
|
|
int32_t i;
|
|
|
|
uint8_t *iptr = (uint8_t *)ptr;
|
2012-10-30 15:54:35 +00:00
|
|
|
intptr_t ibase = (intptr_t)base;
|
|
|
|
int32_t back_p = mode&P2I_BACK_BIT;
|
|
|
|
int32_t onlynon0_p = mode&P2I_ONLYNON0_BIT;
|
|
|
|
|
2012-11-11 17:57:01 +00:00
|
|
|
for (i=0; i<count; i++)
|
2012-10-30 15:54:35 +00:00
|
|
|
{
|
|
|
|
if (!onlynon0_p || *(intptr_t *)iptr)
|
|
|
|
{
|
|
|
|
if (!back_p)
|
|
|
|
*(intptr_t *)iptr -= ibase;
|
|
|
|
else
|
|
|
|
*(intptr_t *)iptr += ibase;
|
|
|
|
}
|
|
|
|
|
2012-11-11 17:57:01 +00:00
|
|
|
iptr += stride;
|
2012-10-30 15:54:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-29 22:07:28 +00:00
|
|
|
// TODO: sync with TROR special interpolations? (e.g. upper floor of subway)
|
|
|
|
void G_ResetInterpolations(void)
|
|
|
|
{
|
|
|
|
int32_t k, i;
|
|
|
|
|
|
|
|
g_numInterpolations = 0;
|
|
|
|
startofdynamicinterpolations = 0;
|
|
|
|
|
|
|
|
k = headspritestat[STAT_EFFECTOR];
|
|
|
|
while (k >= 0)
|
|
|
|
{
|
|
|
|
switch (sprite[k].lotag)
|
|
|
|
{
|
2012-08-26 22:16:08 +00:00
|
|
|
case SE_31_FLOOR_RISE_FALL:
|
2011-07-29 22:07:28 +00:00
|
|
|
G_SetInterpolation(§or[sprite[k].sectnum].floorz);
|
|
|
|
break;
|
2012-08-26 22:16:08 +00:00
|
|
|
case SE_32_CEILING_RISE_FALL:
|
2011-07-29 22:07:28 +00:00
|
|
|
G_SetInterpolation(§or[sprite[k].sectnum].ceilingz);
|
|
|
|
break;
|
2012-08-26 22:16:08 +00:00
|
|
|
case SE_17_WARP_ELEVATOR:
|
|
|
|
case SE_25_PISTON:
|
2011-07-29 22:07:28 +00:00
|
|
|
G_SetInterpolation(§or[sprite[k].sectnum].floorz);
|
|
|
|
G_SetInterpolation(§or[sprite[k].sectnum].ceilingz);
|
|
|
|
break;
|
2012-09-08 22:18:44 +00:00
|
|
|
case SE_0_ROTATING_SECTOR:
|
|
|
|
case SE_5:
|
|
|
|
case SE_6_SUBWAY:
|
|
|
|
case SE_11_SWINGING_DOOR:
|
|
|
|
case SE_14_SUBWAY_CAR:
|
|
|
|
case SE_15_SLIDING_DOOR:
|
2012-08-26 22:16:08 +00:00
|
|
|
case SE_16_REACTOR:
|
|
|
|
case SE_26:
|
|
|
|
case SE_30_TWO_WAY_TRAIN:
|
2011-07-29 22:07:28 +00:00
|
|
|
Sect_SetInterpolation(sprite[k].sectnum);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
k = nextspritestat[k];
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i=g_numInterpolations-1; i>=0; i--) bakipos[i] = *curipos[i];
|
|
|
|
for (i = g_animateCount-1; i>=0; i--)
|
|
|
|
G_SetInterpolation(animateptr[i]);
|
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
void ReadSaveGameHeaders(void)
|
|
|
|
{
|
|
|
|
char fn[16];
|
|
|
|
int32_t fil, i;
|
|
|
|
|
|
|
|
savehead_t h;
|
|
|
|
|
|
|
|
Bstrcpy(fn, "dukesav0.esv");
|
|
|
|
|
|
|
|
for (i=0; i<10; i++)
|
|
|
|
{
|
|
|
|
int32_t k;
|
|
|
|
|
|
|
|
fn[7] = i + '0';
|
|
|
|
fil = kopen4loadfrommod(fn, 0);
|
|
|
|
if (fil == -1)
|
|
|
|
{
|
|
|
|
Bmemset(ud.savegame[i], 0, sizeof(ud.savegame[i]));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
k = sv_loadheader(fil, i, &h);
|
|
|
|
if (k)
|
|
|
|
{
|
2012-11-13 10:50:06 +00:00
|
|
|
// old version, signal to menu code
|
2011-12-25 15:34:06 +00:00
|
|
|
if (k==2 || k==3)
|
2012-11-13 10:50:06 +00:00
|
|
|
g_oldverSavegame[i] = 1;
|
2011-12-25 15:34:06 +00:00
|
|
|
// else h.savename is all zeros (fatal failure, like wrong header
|
|
|
|
// magic or too short header)
|
|
|
|
}
|
|
|
|
|
|
|
|
Bmemcpy(ud.savegame[i], h.savename, sizeof(ud.savegame[i]));
|
|
|
|
|
|
|
|
kclose(fil);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t G_LoadSaveHeaderNew(int32_t spot, savehead_t *saveh)
|
|
|
|
{
|
|
|
|
char fn[16];
|
2011-12-25 15:34:52 +00:00
|
|
|
int32_t fil, screenshotofs, i;
|
2011-12-25 15:34:06 +00:00
|
|
|
|
|
|
|
Bstrcpy(fn, "dukesav0.esv");
|
|
|
|
fn[7] = spot + '0';
|
|
|
|
|
|
|
|
fil = kopen4loadfrommod(fn, 0);
|
|
|
|
if (fil == -1)
|
|
|
|
return -1;
|
|
|
|
|
2011-12-25 15:34:52 +00:00
|
|
|
i = sv_loadheader(fil, spot, saveh);
|
|
|
|
if (i && (i != 2 && i != 3))
|
2011-12-25 15:34:06 +00:00
|
|
|
goto corrupt;
|
|
|
|
|
|
|
|
if (kread(fil, &screenshotofs, 4) != 4)
|
|
|
|
goto corrupt;
|
|
|
|
|
|
|
|
walock[TILE_LOADSHOT] = 255;
|
|
|
|
if (waloff[TILE_LOADSHOT] == 0)
|
|
|
|
allocache(&waloff[TILE_LOADSHOT], 320*200, &walock[TILE_LOADSHOT]);
|
|
|
|
tilesizx[TILE_LOADSHOT] = 200;
|
|
|
|
tilesizy[TILE_LOADSHOT] = 320;
|
|
|
|
if (screenshotofs)
|
|
|
|
{
|
|
|
|
if (kdfread((char *)waloff[TILE_LOADSHOT], 320, 200, fil) != 200)
|
2011-12-25 15:34:52 +00:00
|
|
|
{
|
|
|
|
OSD_Printf("G_LoadSaveHeaderNew(%d): failed reading screenshot\n", spot);
|
2011-12-25 15:34:06 +00:00
|
|
|
goto corrupt;
|
2011-12-25 15:34:52 +00:00
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Bmemset((char *)waloff[TILE_LOADSHOT], 0, 320*200);
|
|
|
|
}
|
|
|
|
invalidatetile(TILE_LOADSHOT, 0, 255);
|
|
|
|
|
|
|
|
kclose(fil);
|
|
|
|
return 0;
|
2006-12-10 06:49:01 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
corrupt:
|
|
|
|
kclose(fil);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void sv_postudload();
|
2006-04-13 20:47:06 +00:00
|
|
|
|
2013-05-19 19:29:18 +00:00
|
|
|
// XXX: keyboard input 'blocked' after load fail? (at least ESC?)
|
2011-12-25 15:34:06 +00:00
|
|
|
int32_t G_LoadPlayer(int32_t spot)
|
|
|
|
{
|
|
|
|
char fn[16];
|
|
|
|
int32_t fil, i;
|
|
|
|
|
|
|
|
savehead_t h;
|
|
|
|
|
|
|
|
Bstrcpy(fn, "dukesav0.esv");
|
|
|
|
fn[7] = spot + '0';
|
|
|
|
|
|
|
|
fil = kopen4loadfrommod(fn, 0);
|
|
|
|
if (fil == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ready2send = 0;
|
|
|
|
|
|
|
|
i = sv_loadheader(fil, spot, &h);
|
|
|
|
if (i || h.numplayers!=ud.multimode)
|
|
|
|
{
|
|
|
|
if (i == 2 || i == 3)
|
|
|
|
P_DoQuote(QUOTE_SAVE_BAD_VERSION, g_player[myconnectindex].ps);
|
|
|
|
else if (h.numplayers!=ud.multimode)
|
|
|
|
P_DoQuote(QUOTE_SAVE_BAD_PLAYERS, g_player[myconnectindex].ps);
|
|
|
|
|
|
|
|
kclose(fil);
|
|
|
|
ototalclock = totalclock;
|
|
|
|
ready2send = 1;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// some setup first
|
|
|
|
ud.multimode = h.numplayers;
|
|
|
|
|
|
|
|
if (numplayers > 1)
|
|
|
|
{
|
|
|
|
pub = NUMPAGES;
|
|
|
|
pus = NUMPAGES;
|
|
|
|
G_UpdateScreenArea();
|
|
|
|
G_DrawBackground();
|
|
|
|
menutext(160,100, 0,0, "LOADING...");
|
|
|
|
nextpage();
|
|
|
|
}
|
|
|
|
|
|
|
|
Net_WaitForServer();
|
|
|
|
|
|
|
|
FX_StopAllSounds();
|
|
|
|
S_ClearSoundLocks();
|
|
|
|
|
|
|
|
if (spot >= 0 && numplayers==1)
|
|
|
|
{
|
|
|
|
Bmemcpy(ud.savegame[spot], h.savename, sizeof(ud.savegame[0]));
|
|
|
|
ud.savegame[spot][sizeof(ud.savegame[0])-1] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// non-"m_" fields will be loaded from svgm_udnetw
|
|
|
|
ud.m_volume_number = h.volnum;
|
|
|
|
ud.m_level_number = h.levnum;
|
|
|
|
ud.m_player_skill = h.skill;
|
|
|
|
|
|
|
|
Bstrcpy(boardfilename, h.boardfn);
|
|
|
|
|
|
|
|
if (boardfilename[0])
|
|
|
|
Bstrcpy(currentboardfilename, boardfilename);
|
|
|
|
else if (MapInfo[h.volnum*MAXLEVELS + h.levnum].filename)
|
|
|
|
Bstrcpy(currentboardfilename, MapInfo[h.volnum*MAXLEVELS + h.levnum].filename);
|
|
|
|
|
|
|
|
if (currentboardfilename[0])
|
|
|
|
{
|
2013-05-06 19:43:38 +00:00
|
|
|
append_ext_UNSAFE(currentboardfilename, ".mhk");
|
2011-12-25 15:34:06 +00:00
|
|
|
loadmaphack(currentboardfilename);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bmemcpy(currentboardfilename, boardfilename, BMAX_PATH);
|
|
|
|
|
|
|
|
// read the rest...
|
|
|
|
i = sv_loadsnapshot(fil, spot, &h);
|
|
|
|
if (i)
|
|
|
|
{
|
|
|
|
// in theory, we could load into an initial dump first and trivially
|
|
|
|
// recover if things go wrong...
|
|
|
|
Bsprintf(tempbuf, "Loading save game file \"%s\" failed (code %d), cannot recover.", fn, i);
|
|
|
|
G_GameExit(tempbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
sv_postudload(); // ud.m_XXX = ud.XXX
|
|
|
|
|
2012-05-25 05:14:19 +00:00
|
|
|
VM_OnEvent(EVENT_LOADGAME, g_player[myconnectindex].ps->i, myconnectindex, -1, 0);
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int32_t G_SavePlayer(int32_t spot)
|
|
|
|
{
|
|
|
|
char fn[16];
|
|
|
|
// char mpfn[16];
|
|
|
|
FILE *fil;
|
|
|
|
|
|
|
|
Bstrcpy(fn, "dukesav0.esv");
|
|
|
|
fn[7] = spot + '0';
|
|
|
|
|
|
|
|
// Bstrcpy(mpfn, "edukA_00.esv");
|
|
|
|
|
|
|
|
Net_WaitForServer();
|
|
|
|
ready2send = 0;
|
|
|
|
|
|
|
|
{
|
|
|
|
char temp[BMAX_PATH];
|
|
|
|
|
2012-09-05 17:25:37 +00:00
|
|
|
if (G_ModDirSnprintf(temp, sizeof(temp), "%s", fn))
|
|
|
|
{
|
|
|
|
OSD_Printf("G_SavePlayer: file name \"%s\" too long\n", fn);
|
|
|
|
return -1;
|
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
|
2012-03-01 23:35:53 +00:00
|
|
|
errno = 0;
|
2011-12-25 15:34:06 +00:00
|
|
|
fil = fopen(temp, "wb");
|
|
|
|
if (!fil)
|
2012-03-01 23:35:53 +00:00
|
|
|
{
|
2012-03-26 05:05:57 +00:00
|
|
|
OSD_Printf("G_SavePlayer: failed opening \"%s\" for writing: %s\n",
|
2012-03-01 23:35:53 +00:00
|
|
|
temp, strerror(errno));
|
2012-09-05 17:25:40 +00:00
|
|
|
return -1;
|
2012-03-01 23:35:53 +00:00
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
}
|
|
|
|
|
2012-01-05 21:58:23 +00:00
|
|
|
#ifdef POLYMER
|
2013-05-17 03:44:09 +00:00
|
|
|
if (getrendermode() == REND_POLYMER)
|
2012-01-05 21:58:23 +00:00
|
|
|
polymer_resetlights();
|
|
|
|
#endif
|
|
|
|
|
2012-05-25 05:14:19 +00:00
|
|
|
VM_OnEvent(EVENT_SAVEGAME, g_player[myconnectindex].ps->i, myconnectindex, -1, 0);
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// SAVE!
|
2011-12-28 20:33:54 +00:00
|
|
|
sv_saveandmakesnapshot(fil, spot, 0, 0, 0);
|
2011-12-25 15:34:06 +00:00
|
|
|
|
|
|
|
fclose(fil);
|
|
|
|
|
|
|
|
if (!g_netServer && ud.multimode < 2)
|
|
|
|
{
|
2013-05-20 19:31:42 +00:00
|
|
|
#ifdef LUNATIC
|
|
|
|
if (!g_savedOK)
|
|
|
|
Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "^10Failed Saving Game");
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Game Saved");
|
2011-12-25 15:34:06 +00:00
|
|
|
P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
|
|
|
|
}
|
|
|
|
|
|
|
|
ready2send = 1;
|
|
|
|
Net_WaitForServer();
|
|
|
|
|
|
|
|
ototalclock = totalclock;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-04-13 20:47:06 +00:00
|
|
|
|
2012-09-05 17:25:43 +00:00
|
|
|
void G_LoadPlayerMaybeMulti(int32_t slot)
|
|
|
|
{
|
|
|
|
if (g_netServer || ud.multimode > 1)
|
|
|
|
{
|
|
|
|
Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Multiplayer Loading Not Yet Supported");
|
|
|
|
P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
|
|
|
|
|
|
|
|
// G_LoadPlayer(-1-g_lastSaveSlot);
|
|
|
|
// g_player[myconnectindex].ps->gm = MODE_GAME;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int32_t c = G_LoadPlayer(slot);
|
|
|
|
if (c == 0)
|
|
|
|
g_player[myconnectindex].ps->gm = MODE_GAME;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void G_SavePlayerMaybeMulti(int32_t slot)
|
|
|
|
{
|
|
|
|
Bassert(slot >= 0);
|
|
|
|
|
2013-04-03 17:26:49 +00:00
|
|
|
CONFIG_WriteSetup(2);
|
2013-03-19 06:23:12 +00:00
|
|
|
|
2012-09-05 17:25:43 +00:00
|
|
|
if (g_netServer || ud.multimode > 1)
|
|
|
|
{
|
|
|
|
Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Multiplayer Saving Not Yet Supported");
|
|
|
|
P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
|
|
|
|
// G_SavePlayer(-1-slot);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
G_SavePlayer(slot);
|
|
|
|
}
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
////////// GENERIC SAVING/LOADING SYSTEM //////////
|
|
|
|
|
|
|
|
typedef struct dataspec_
|
|
|
|
{
|
|
|
|
uint32_t flags;
|
|
|
|
void *ptr;
|
|
|
|
uint32_t size;
|
|
|
|
intptr_t cnt;
|
|
|
|
} dataspec_t;
|
|
|
|
|
|
|
|
#define SV_DEFAULTCOMPRTHRES 8
|
|
|
|
static uint8_t savegame_diffcompress; // 0:none, 1:Ken's LZW in cache1d.c
|
|
|
|
static uint8_t savegame_comprthres;
|
|
|
|
|
|
|
|
|
|
|
|
#define DS_DYNAMIC 1 // dereference .ptr one more time
|
|
|
|
#define DS_STRING 2
|
|
|
|
#define DS_CMP 4
|
|
|
|
// 8
|
|
|
|
#define DS_CNT(x) ((sizeof(x))<<3) // .cnt is pointer to...
|
|
|
|
#define DS_CNT16 16
|
|
|
|
#define DS_CNT32 32
|
|
|
|
#define DS_CNTMASK (8|DS_CNT16|DS_CNT32|64)
|
|
|
|
// 64
|
|
|
|
#define DS_LOADFN 128 // .ptr is function that is run when loading
|
|
|
|
#define DS_SAVEFN 256 // .ptr is function that is run when saving
|
2011-02-21 23:08:21 +00:00
|
|
|
#define DS_NOCHK 1024 // don't check for diffs (and don't write out in dump) since assumed constant throughout demo
|
2011-05-12 23:31:13 +00:00
|
|
|
#define DS_PROTECTFN 512
|
2010-01-24 23:33:17 +00:00
|
|
|
#define DS_END (0x70000000)
|
|
|
|
|
|
|
|
static int32_t ds_getcnt(const dataspec_t *sp)
|
|
|
|
{
|
|
|
|
switch (sp->flags&DS_CNTMASK)
|
|
|
|
{
|
2010-02-23 18:13:46 +00:00
|
|
|
case 0: return sp->cnt;
|
2010-01-24 23:33:17 +00:00
|
|
|
case DS_CNT16: return *((int16_t *)sp->cnt);
|
|
|
|
case DS_CNT32: return *((int32_t *)sp->cnt);
|
|
|
|
default: return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-05 20:48:20 +00:00
|
|
|
static void ds_get(const dataspec_t *sp, void **ptr, int32_t *cnt)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
|
|
|
*cnt = ds_getcnt(sp);
|
|
|
|
|
|
|
|
if (sp->flags&DS_DYNAMIC)
|
|
|
|
*ptr = *((void **)sp->ptr);
|
|
|
|
else
|
|
|
|
*ptr = sp->ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// write state to file and/or to dump
|
|
|
|
static uint8_t *writespecdata(const dataspec_t *spec, FILE *fil, uint8_t *dump)
|
|
|
|
{
|
|
|
|
int32_t cnt;
|
2012-01-05 20:48:20 +00:00
|
|
|
void *ptr;
|
2010-01-24 23:33:17 +00:00
|
|
|
const dataspec_t *sp=spec;
|
|
|
|
|
|
|
|
for (; sp->flags!=DS_END; sp++)
|
|
|
|
{
|
|
|
|
if (sp->flags&(DS_SAVEFN|DS_LOADFN))
|
|
|
|
{
|
|
|
|
if (sp->flags&DS_SAVEFN)
|
2011-12-25 15:34:06 +00:00
|
|
|
(*(void (*)(void))sp->ptr)();
|
2010-01-24 23:33:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!fil && (sp->flags&(DS_NOCHK|DS_CMP|DS_STRING)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sp->flags&DS_STRING)
|
|
|
|
{
|
2012-11-15 14:28:36 +00:00
|
|
|
fwrite(sp->ptr, Bstrlen((const char *)sp->ptr), 1, fil); // not null-terminated!
|
2010-01-24 23:33:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ds_get(sp, &ptr, &cnt);
|
|
|
|
if (cnt < 0) { OSD_Printf("wsd: cnt=%d, f=0x%x.\n",cnt,sp->flags); continue; }
|
|
|
|
|
|
|
|
if (fil)
|
|
|
|
{
|
2011-12-09 19:08:29 +00:00
|
|
|
if (((sp->flags&DS_CNTMASK)==0 && sp->size*cnt<=savegame_comprthres)
|
2010-02-23 18:13:46 +00:00
|
|
|
|| (sp->flags&DS_CMP))
|
2010-01-24 23:33:17 +00:00
|
|
|
fwrite(ptr, sp->size, cnt, fil);
|
|
|
|
else
|
|
|
|
dfwrite((void *)ptr, sp->size, cnt, fil);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dump && (sp->flags&(DS_NOCHK|DS_CMP))==0)
|
|
|
|
{
|
|
|
|
Bmemcpy(dump, ptr, sp->size*cnt);
|
|
|
|
dump += sp->size*cnt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dump;
|
|
|
|
}
|
|
|
|
|
|
|
|
// let havedump=dumpvar&&*dumpvar
|
|
|
|
// (fil>=0 && havedump): first restore dump from file, then restore state from dump
|
|
|
|
// (fil<0 && havedump): only restore state from dump
|
|
|
|
// (fil>=0 && !havedump): only restore state from file
|
|
|
|
static int32_t readspecdata(const dataspec_t *spec, int32_t fil, uint8_t **dumpvar)
|
|
|
|
{
|
|
|
|
int32_t cnt, i, j;
|
|
|
|
void *ptr;
|
|
|
|
uint8_t *dump=dumpvar?*dumpvar:NULL, *mem;
|
|
|
|
const dataspec_t *sp=spec;
|
|
|
|
static char cmpstrbuf[32];
|
|
|
|
|
|
|
|
for (; sp->flags!=DS_END; sp++)
|
|
|
|
{
|
|
|
|
if (fil < 0 && sp->flags&(DS_NOCHK|DS_STRING|DS_CMP)) // we're updating
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sp->flags&(DS_LOADFN|DS_SAVEFN))
|
|
|
|
{
|
|
|
|
if (sp->flags&DS_LOADFN)
|
2012-03-28 19:45:25 +00:00
|
|
|
(*(void (*)())sp->ptr)();
|
2010-01-24 23:33:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sp->flags&(DS_STRING|DS_CMP)) // DS_STRING and DS_CMP is for static data only
|
|
|
|
{
|
|
|
|
if (sp->flags&(DS_STRING))
|
2012-11-15 14:28:36 +00:00
|
|
|
i = Bstrlen((const char *)sp->ptr);
|
2010-01-24 23:33:17 +00:00
|
|
|
else
|
|
|
|
i = sp->size*sp->cnt;
|
|
|
|
|
|
|
|
j=kread(fil, cmpstrbuf, i);
|
|
|
|
if (j!=i || Bmemcmp(sp->ptr, cmpstrbuf, i))
|
|
|
|
{
|
2011-12-26 14:37:34 +00:00
|
|
|
OSD_Printf("rsd: spec=%s, idx=%d:\n", (char *)spec->ptr, (int32_t)(sp-spec));
|
2010-01-24 23:33:17 +00:00
|
|
|
if (j!=i)
|
2011-12-25 15:34:06 +00:00
|
|
|
OSD_Printf(" kread returned %d, expected %d.\n", j, i);
|
2010-01-24 23:33:17 +00:00
|
|
|
else
|
2011-12-25 15:34:06 +00:00
|
|
|
OSD_Printf(" sp->ptr and cmpstrbuf not identical!\n");
|
2010-01-24 23:33:17 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-01-05 20:48:20 +00:00
|
|
|
ds_get(sp, &ptr, &cnt);
|
2010-01-24 23:33:17 +00:00
|
|
|
if (cnt < 0) { OSD_Printf("rsd: cnt<0... wtf?\n"); return -1; }
|
|
|
|
|
|
|
|
if (fil>=0)
|
|
|
|
{
|
2012-11-15 14:28:36 +00:00
|
|
|
mem = (dump && (sp->flags&DS_NOCHK)==0) ? dump : (uint8_t *)ptr;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-09 19:08:29 +00:00
|
|
|
if ((sp->flags&DS_CNTMASK)==0 && sp->size*cnt<=savegame_comprthres)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
|
|
|
i = kread(fil, mem, cnt*sp->size);
|
|
|
|
j = cnt*sp->size;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
i = kdfread(mem, sp->size, cnt, fil);
|
|
|
|
j = cnt;
|
|
|
|
}
|
|
|
|
if (i!=j)
|
|
|
|
{
|
2011-12-26 14:37:34 +00:00
|
|
|
OSD_Printf("rsd: spec=%s, idx=%d, mem=%p\n", (char *)spec->ptr, (int32_t)(sp-spec), mem);
|
2011-12-25 15:34:06 +00:00
|
|
|
OSD_Printf(" (%s): read %d, expected %d!\n",
|
2011-12-09 19:08:29 +00:00
|
|
|
((sp->flags&DS_CNTMASK)==0 && sp->size*cnt<=savegame_comprthres)?
|
2011-12-25 15:34:06 +00:00
|
|
|
"uncompressed":"compressed", i, j);
|
2010-02-23 18:13:46 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
if (i==-1)
|
2011-12-21 18:42:12 +00:00
|
|
|
OSD_Printf(" read: %s\n", strerror(errno));
|
2010-01-24 23:33:17 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dump && (sp->flags&DS_NOCHK)==0)
|
|
|
|
{
|
|
|
|
Bmemcpy(ptr, dump, sp->size*cnt);
|
|
|
|
dump += sp->size*cnt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dumpvar)
|
|
|
|
*dumpvar = dump;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define UINT(bits) uint##bits##_t
|
|
|
|
#define BYTES(bits) (bits>>3)
|
|
|
|
#define VAL(bits,p) (*(UINT(bits) *)(p))
|
|
|
|
|
|
|
|
static void docmpsd(const void *ptr, void *dump, uint32_t size, uint32_t cnt, uint8_t **diffvar)
|
|
|
|
{
|
|
|
|
uint8_t *retdiff = *diffvar;
|
|
|
|
|
|
|
|
// Hail to the C preprocessor, baby!
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPSINGLEVAL(Datbits) \
|
2010-01-24 23:33:17 +00:00
|
|
|
if (VAL(Datbits, ptr) != VAL(Datbits, dump)) \
|
|
|
|
{ \
|
|
|
|
VAL(Datbits, retdiff) = VAL(Datbits, dump) = VAL(Datbits, ptr); \
|
|
|
|
*diffvar = retdiff+BYTES(Datbits); \
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cnt==1)
|
|
|
|
switch (size)
|
|
|
|
{
|
|
|
|
case 8: CPSINGLEVAL(64); return;
|
|
|
|
case 4: CPSINGLEVAL(32); return;
|
|
|
|
case 2: CPSINGLEVAL(16); return;
|
|
|
|
case 1: CPSINGLEVAL(8); return;
|
|
|
|
}
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPELTS(Idxbits, Datbits) do \
|
2010-01-24 23:33:17 +00:00
|
|
|
{ \
|
|
|
|
for (i=0; i<nelts; i++) \
|
|
|
|
{ \
|
|
|
|
if (*p!=*op) \
|
|
|
|
{ \
|
2012-11-15 14:28:47 +00:00
|
|
|
*op = *p; \
|
2010-01-24 23:33:17 +00:00
|
|
|
VAL(Idxbits, retdiff) = i; \
|
|
|
|
retdiff += BYTES(Idxbits); \
|
|
|
|
VAL(Datbits, retdiff) = *p; \
|
|
|
|
retdiff += BYTES(Datbits); \
|
|
|
|
} \
|
|
|
|
p++; \
|
|
|
|
op++; \
|
|
|
|
} \
|
|
|
|
VAL(Idxbits, retdiff) = -1; \
|
|
|
|
retdiff += BYTES(Idxbits); \
|
|
|
|
} while (0)
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPDATA(Datbits) do \
|
2010-01-24 23:33:17 +00:00
|
|
|
{ \
|
2012-11-15 14:28:36 +00:00
|
|
|
const UINT(Datbits) *p=(UINT(Datbits) *)ptr; \
|
|
|
|
UINT(Datbits) *op=(UINT(Datbits) *)dump; \
|
|
|
|
uint32_t i, nelts=(size*cnt)/BYTES(Datbits); \
|
|
|
|
if (nelts>65536) \
|
|
|
|
CPELTS(32,Datbits); \
|
|
|
|
else if (nelts>256) \
|
|
|
|
CPELTS(16,Datbits); \
|
|
|
|
else \
|
|
|
|
CPELTS(8,Datbits); \
|
2010-01-24 23:33:17 +00:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
if (size==8)
|
|
|
|
CPDATA(64);
|
|
|
|
else if ((size&3)==0)
|
|
|
|
CPDATA(32);
|
|
|
|
else if ((size&1)==0)
|
|
|
|
CPDATA(16);
|
|
|
|
else
|
|
|
|
CPDATA(8);
|
|
|
|
|
|
|
|
*diffvar = retdiff;
|
|
|
|
return;
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#undef CPELTS
|
|
|
|
#undef CPSINGLEVAL
|
|
|
|
#undef CPDATA
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// get the number of elements to be monitored for changes
|
|
|
|
static int32_t getnumvar(const dataspec_t *spec)
|
|
|
|
{
|
|
|
|
int32_t n=0;
|
2010-02-23 18:13:46 +00:00
|
|
|
for (; spec->flags!=DS_END; spec++)
|
2010-01-24 23:33:17 +00:00
|
|
|
n += (spec->flags&(DS_STRING|DS_CMP|DS_NOCHK|DS_SAVEFN|DS_LOADFN) ? 0 : 1);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
// update dump at *dumpvar with new state and write diff to *diffvar
|
|
|
|
static void cmpspecdata(const dataspec_t *spec, uint8_t **dumpvar, uint8_t **diffvar)
|
|
|
|
{
|
2012-01-05 20:48:20 +00:00
|
|
|
void *ptr;
|
2010-01-24 23:33:17 +00:00
|
|
|
uint8_t *dump=*dumpvar, *diff=*diffvar, *tmptr;
|
|
|
|
const dataspec_t *sp=spec;
|
2012-11-15 14:28:36 +00:00
|
|
|
int32_t cnt, eltnum=0, nbytes=(getnumvar(spec)+7)>>3, l=Bstrlen((const char *)spec->ptr);
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
Bmemcpy(diff, spec->ptr, l);
|
|
|
|
diff+=l;
|
|
|
|
|
|
|
|
while (nbytes--)
|
|
|
|
*(diff++) = 0; // the bitmap of indices which elements of spec have changed go here
|
|
|
|
|
|
|
|
for (sp++; sp->flags!=DS_END; sp++)
|
|
|
|
{
|
|
|
|
if ((sp->flags&(DS_NOCHK|DS_STRING|DS_CMP)))
|
|
|
|
continue;
|
|
|
|
|
* New m32script commands:
- sethighlightsector <sectnum> <on?>
- updatehighlightsector
- collectsectors <<array_to_collect_sectnums>> <initial_sector> <<num_collected_sectors>> <sector_filtering_state>
The latter does a breadth-first search starting from an initial sector and collects nextsectors only when the filtering state, given a sectnum as RETURN input, writes a nonzero value into RETURN. As a usage example, a.m32 includes the state 'collect_teleporting_sectors', that collects all sectors containing an SE7 and highlights them afterwards. This way, it should be possible to retrofit old maps with TROR by distributing small scripts that do most of the work (right now, joining has to be done by hand, though).
* corruption checker: for the 'nextwall inconsistent with nextsector' corruption, suggest an alternative fix by searching fitting nextwalls and changing the nextwall of the corrupt wall (as opposed to the nextsector). It will display with a leading '?' in the listing, and can be demanded by suffixing 'corruptcheck tryfix' with it. For example,
corruptcheck tryfix 9-21 ?
would fix some corruptions in Billy Boy's cranium.map without introducing drawing errors.
* fix demo playback (tueidj figured this out)
git-svn-id: https://svn.eduke32.com/eduke32@1927 1a8010ca-5511-0410-912e-c29ae57300e0
2011-07-03 22:51:28 +00:00
|
|
|
if (sp->flags&(DS_LOADFN|DS_SAVEFN))
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
* New m32script commands:
- sethighlightsector <sectnum> <on?>
- updatehighlightsector
- collectsectors <<array_to_collect_sectnums>> <initial_sector> <<num_collected_sectors>> <sector_filtering_state>
The latter does a breadth-first search starting from an initial sector and collects nextsectors only when the filtering state, given a sectnum as RETURN input, writes a nonzero value into RETURN. As a usage example, a.m32 includes the state 'collect_teleporting_sectors', that collects all sectors containing an SE7 and highlights them afterwards. This way, it should be possible to retrofit old maps with TROR by distributing small scripts that do most of the work (right now, joining has to be done by hand, though).
* corruption checker: for the 'nextwall inconsistent with nextsector' corruption, suggest an alternative fix by searching fitting nextwalls and changing the nextwall of the corrupt wall (as opposed to the nextsector). It will display with a leading '?' in the listing, and can be demanded by suffixing 'corruptcheck tryfix' with it. For example,
corruptcheck tryfix 9-21 ?
would fix some corruptions in Billy Boy's cranium.map without introducing drawing errors.
* fix demo playback (tueidj figured this out)
git-svn-id: https://svn.eduke32.com/eduke32@1927 1a8010ca-5511-0410-912e-c29ae57300e0
2011-07-03 22:51:28 +00:00
|
|
|
if ((sp->flags&(DS_PROTECTFN))==0)
|
2011-12-25 15:34:06 +00:00
|
|
|
(*(void (*)())sp->ptr)();
|
2010-01-24 23:33:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ds_get(sp, &ptr, &cnt);
|
|
|
|
if (cnt < 0) { OSD_Printf("csd: cnt=%d, f=0x%x\n", cnt, sp->flags); continue; }
|
|
|
|
|
|
|
|
tmptr = diff;
|
|
|
|
docmpsd(ptr, dump, sp->size, cnt, &diff);
|
|
|
|
if (diff != tmptr)
|
|
|
|
(*diffvar + l)[eltnum>>3] |= 1<<(eltnum&7);
|
|
|
|
dump += sp->size*cnt;
|
|
|
|
eltnum++;
|
|
|
|
}
|
|
|
|
|
|
|
|
*diffvar = diff;
|
|
|
|
*dumpvar = dump;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define VALOFS(bits,p,ofs) (*(((UINT(bits) *)(p)) + (ofs)))
|
|
|
|
|
|
|
|
// apply diff to dump, not to state! state is restored from dump afterwards.
|
|
|
|
static int32_t applydiff(const dataspec_t *spec, uint8_t **dumpvar, uint8_t **diffvar)
|
|
|
|
{
|
|
|
|
uint8_t *dumptr=*dumpvar, *diffptr=*diffvar;
|
|
|
|
const dataspec_t *sp=spec;
|
2012-11-15 14:28:36 +00:00
|
|
|
int32_t cnt, eltnum=-1, nbytes=(getnumvar(spec)+7)>>3, l=Bstrlen((const char *)spec->ptr);
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
if (Bmemcmp(diffptr, spec->ptr, l)) // check STRING magic (sync check)
|
|
|
|
return 1;
|
2011-12-21 18:40:47 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
diffptr += l+nbytes;
|
|
|
|
|
|
|
|
for (sp++; sp->flags!=DS_END; sp++)
|
|
|
|
{
|
|
|
|
if ((sp->flags&(DS_NOCHK|DS_STRING|DS_CMP|DS_LOADFN|DS_SAVEFN)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cnt = ds_getcnt(sp);
|
|
|
|
if (cnt < 0) return 1;
|
|
|
|
|
|
|
|
eltnum++;
|
|
|
|
if (((*diffvar + l)[eltnum>>3]&(1<<(eltnum&7))) == 0)
|
|
|
|
{
|
|
|
|
dumptr += sp->size*cnt;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPSINGLEVAL(Datbits) \
|
2010-01-24 23:33:17 +00:00
|
|
|
VAL(Datbits, dumptr) = VAL(Datbits, diffptr); \
|
|
|
|
diffptr += BYTES(Datbits); \
|
|
|
|
dumptr += BYTES(Datbits)
|
|
|
|
|
|
|
|
if (cnt==1)
|
|
|
|
{
|
|
|
|
switch (sp->size)
|
|
|
|
{
|
|
|
|
case 8: CPSINGLEVAL(64); continue;
|
|
|
|
case 4: CPSINGLEVAL(32); continue;
|
|
|
|
case 2: CPSINGLEVAL(16); continue;
|
|
|
|
case 1: CPSINGLEVAL(8); continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPELTS(Idxbits, Datbits) do \
|
2010-01-24 23:33:17 +00:00
|
|
|
{ \
|
|
|
|
UINT(Idxbits) idx; \
|
|
|
|
goto readidx_##Idxbits##_##Datbits; \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
VALOFS(Datbits, dumptr, idx) = VAL(Datbits, diffptr); \
|
|
|
|
diffptr += BYTES(Datbits); \
|
|
|
|
readidx_##Idxbits##_##Datbits: \
|
|
|
|
idx = VAL(Idxbits, diffptr); \
|
|
|
|
diffptr += BYTES(Idxbits); \
|
|
|
|
} while ((int##Idxbits##_t)idx != -1); \
|
|
|
|
} while (0)
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPDATA(Datbits) do \
|
2010-01-24 23:33:17 +00:00
|
|
|
{ \
|
|
|
|
uint32_t nelts=(sp->size*cnt)/BYTES(Datbits); \
|
|
|
|
if (nelts>65536) \
|
|
|
|
CPELTS(32,Datbits); \
|
|
|
|
else if (nelts>256) \
|
|
|
|
CPELTS(16,Datbits); \
|
|
|
|
else \
|
|
|
|
CPELTS(8,Datbits); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
if (sp->size==8)
|
|
|
|
CPDATA(64);
|
|
|
|
else if ((sp->size&3)==0)
|
|
|
|
CPDATA(32);
|
|
|
|
else if ((sp->size&1)==0)
|
|
|
|
CPDATA(16);
|
|
|
|
else
|
|
|
|
CPDATA(8);
|
|
|
|
dumptr += sp->size*cnt;
|
|
|
|
// ----------
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#undef CPELTS
|
|
|
|
#undef CPSINGLEVAL
|
|
|
|
#undef CPDATA
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*diffvar = diffptr;
|
|
|
|
*dumpvar = dumptr;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef VAL
|
|
|
|
#undef VALOFS
|
|
|
|
#undef BYTES
|
|
|
|
#undef UINT
|
|
|
|
|
|
|
|
// calculate size needed for dump
|
|
|
|
static uint32_t calcsz(const dataspec_t *spec)
|
|
|
|
{
|
|
|
|
const dataspec_t *sp=spec;
|
|
|
|
int32_t cnt;
|
|
|
|
uint32_t dasiz=0;
|
|
|
|
|
|
|
|
for (; sp->flags!=DS_END; sp++)
|
|
|
|
{
|
|
|
|
// DS_STRINGs are used as sync checks in the diffs but not in the dump
|
|
|
|
if ((sp->flags&(DS_CMP|DS_NOCHK|DS_SAVEFN|DS_LOADFN|DS_STRING)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cnt = ds_getcnt(sp);
|
|
|
|
if (cnt<=0) continue;
|
|
|
|
|
|
|
|
dasiz += cnt*sp->size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dasiz;
|
|
|
|
}
|
|
|
|
|
2011-03-04 08:50:58 +00:00
|
|
|
#ifdef USE_OPENGL
|
2010-01-25 01:11:34 +00:00
|
|
|
static void sv_prespriteextsave();
|
|
|
|
static void sv_postspriteext();
|
2011-02-27 22:11:39 +00:00
|
|
|
#endif
|
2013-02-03 12:48:17 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-25 01:11:34 +00:00
|
|
|
static void sv_calcbitptrsize();
|
|
|
|
static void sv_prescriptsave_once();
|
2010-02-13 21:46:42 +00:00
|
|
|
static void sv_prescriptload_once();
|
2010-01-25 01:11:34 +00:00
|
|
|
static void sv_postscript_once();
|
2013-02-03 12:48:17 +00:00
|
|
|
#endif
|
2010-01-25 01:11:34 +00:00
|
|
|
static void sv_preactordatasave();
|
|
|
|
static void sv_postactordata();
|
|
|
|
static void sv_preanimateptrsave();
|
|
|
|
static void sv_postanimateptr();
|
|
|
|
static void sv_prequote();
|
|
|
|
static void sv_quotesave();
|
|
|
|
static void sv_quoteload();
|
|
|
|
static void sv_prequoteredef();
|
|
|
|
static void sv_quoteredefsave();
|
|
|
|
static void sv_quoteredefload();
|
|
|
|
static void sv_postquoteredef();
|
|
|
|
static void sv_restsave();
|
|
|
|
static void sv_restload();
|
|
|
|
|
|
|
|
#define SVARDATALEN \
|
|
|
|
((sizeof(g_player[0].user_name)+sizeof(g_player[0].pcolor)+sizeof(g_player[0].pteam) \
|
2012-12-09 13:24:32 +00:00
|
|
|
+sizeof(g_player[0].frags)+sizeof(DukePlayer_t))*MAXPLAYERS)
|
2010-01-25 01:11:34 +00:00
|
|
|
|
|
|
|
static uint32_t savegame_bitptrsize;
|
|
|
|
static uint8_t savegame_quotedef[MAXQUOTES>>3];
|
2010-02-23 18:13:46 +00:00
|
|
|
static char(*savegame_quotes)[MAXQUOTELEN];
|
|
|
|
static char(*savegame_quoteredefs)[MAXQUOTELEN];
|
2010-01-25 01:11:34 +00:00
|
|
|
static uint8_t savegame_restdata[SVARDATALEN];
|
|
|
|
|
|
|
|
static const dataspec_t svgm_udnetw[] =
|
|
|
|
{
|
2012-11-15 14:28:36 +00:00
|
|
|
{ DS_STRING, (void *)"blK:udnt", 0, 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ 0, &ud.multimode, sizeof(ud.multimode), 1 },
|
|
|
|
{ 0, &g_numPlayerSprites, sizeof(g_numPlayerSprites), 1 },
|
|
|
|
{ 0, &g_playerSpawnPoints, sizeof(g_playerSpawnPoints), 1 },
|
|
|
|
|
|
|
|
{ DS_NOCHK, &ud.volume_number, sizeof(ud.volume_number), 1 },
|
|
|
|
{ DS_NOCHK, &ud.level_number, sizeof(ud.level_number), 1 },
|
|
|
|
{ DS_NOCHK, &ud.player_skill, sizeof(ud.player_skill), 1 },
|
|
|
|
|
|
|
|
{ DS_NOCHK, &ud.from_bonus, sizeof(ud.from_bonus), 1 },
|
|
|
|
{ DS_NOCHK, &ud.secretlevel, sizeof(ud.secretlevel), 1 },
|
|
|
|
{ DS_NOCHK, &ud.respawn_monsters, sizeof(ud.respawn_monsters), 1 },
|
|
|
|
{ DS_NOCHK, &ud.respawn_items, sizeof(ud.respawn_items), 1 },
|
|
|
|
{ DS_NOCHK, &ud.respawn_inventory, sizeof(ud.respawn_inventory), 1 },
|
|
|
|
{ 0, &ud.god, sizeof(ud.god), 1 },
|
|
|
|
{ 0, &ud.auto_run, sizeof(ud.auto_run), 1 },
|
|
|
|
// { DS_NOCHK, &ud.crosshair, sizeof(ud.crosshair), 1 },
|
|
|
|
{ DS_NOCHK, &ud.monsters_off, sizeof(ud.monsters_off), 1 },
|
|
|
|
{ DS_NOCHK, &ud.last_level, sizeof(ud.last_level), 1 },
|
|
|
|
{ 0, &ud.eog, sizeof(ud.eog), 1 },
|
|
|
|
{ DS_NOCHK, &ud.coop, sizeof(ud.coop), 1 },
|
|
|
|
{ DS_NOCHK, &ud.marker, sizeof(ud.marker), 1 },
|
|
|
|
{ DS_NOCHK, &ud.ffire, sizeof(ud.ffire), 1 },
|
|
|
|
{ DS_NOCHK, &ud.noexits, sizeof(ud.noexits), 1 },
|
|
|
|
{ DS_NOCHK, &ud.playerai, sizeof(ud.playerai), 1 },
|
2010-02-13 21:46:42 +00:00
|
|
|
{ 0, &ud.pause_on, sizeof(ud.pause_on), 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_NOCHK, ¤tboardfilename[0], BMAX_PATH, 1 },
|
2011-12-25 15:34:06 +00:00
|
|
|
// { DS_LOADFN, (void *)&sv_postudload, 0, 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ 0, connectpoint2, sizeof(connectpoint2), 1 },
|
|
|
|
{ 0, &randomseed, sizeof(randomseed), 1 },
|
|
|
|
{ 0, &g_globalRandom, sizeof(g_globalRandom), 1 },
|
|
|
|
// { 0, &lockclock_dummy, sizeof(lockclock), 1 },
|
|
|
|
{ DS_END, 0, 0, 0 }
|
|
|
|
};
|
|
|
|
|
Inreased debugging level for catching oob accesses to 'main' arrays.
If enabled, this makes the following arrays be allocated statically:
spriteext, spritesmooth, sector, wall, sprite, tsprite, while
necessarily disabling the clipshape feature (because it relies on
setting sector/wall to different malloc'd block temporarily).
To compile, pass DEBUGANYWAY=1 in addition to RELEASE=0 to 'make',
and it's really only useful with CC=clang, of course.
git-svn-id: https://svn.eduke32.com/eduke32@2270 1a8010ca-5511-0410-912e-c29ae57300e0
2012-01-19 23:17:34 +00:00
|
|
|
#if !defined DEBUG_MAIN_ARRAYS
|
|
|
|
# define DS_MAINAR DS_DYNAMIC
|
|
|
|
#else
|
|
|
|
# define DS_MAINAR 0
|
|
|
|
#endif
|
|
|
|
|
2010-01-25 01:11:34 +00:00
|
|
|
static const dataspec_t svgm_secwsp[] =
|
|
|
|
{
|
2012-11-15 14:28:36 +00:00
|
|
|
{ DS_STRING, (void *)"blK:swsp", 0, 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_NOCHK, &numwalls, sizeof(numwalls), 1 },
|
Inreased debugging level for catching oob accesses to 'main' arrays.
If enabled, this makes the following arrays be allocated statically:
spriteext, spritesmooth, sector, wall, sprite, tsprite, while
necessarily disabling the clipshape feature (because it relies on
setting sector/wall to different malloc'd block temporarily).
To compile, pass DEBUGANYWAY=1 in addition to RELEASE=0 to 'make',
and it's really only useful with CC=clang, of course.
git-svn-id: https://svn.eduke32.com/eduke32@2270 1a8010ca-5511-0410-912e-c29ae57300e0
2012-01-19 23:17:34 +00:00
|
|
|
{ DS_MAINAR|DS_CNT(numwalls), &wall, sizeof(walltype), (intptr_t)&numwalls },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_NOCHK, &numsectors, sizeof(numsectors), 1 },
|
Inreased debugging level for catching oob accesses to 'main' arrays.
If enabled, this makes the following arrays be allocated statically:
spriteext, spritesmooth, sector, wall, sprite, tsprite, while
necessarily disabling the clipshape feature (because it relies on
setting sector/wall to different malloc'd block temporarily).
To compile, pass DEBUGANYWAY=1 in addition to RELEASE=0 to 'make',
and it's really only useful with CC=clang, of course.
git-svn-id: https://svn.eduke32.com/eduke32@2270 1a8010ca-5511-0410-912e-c29ae57300e0
2012-01-19 23:17:34 +00:00
|
|
|
{ DS_MAINAR|DS_CNT(numsectors), §or, sizeof(sectortype), (intptr_t)&numsectors },
|
|
|
|
{ DS_MAINAR, &sprite, sizeof(spritetype), MAXSPRITES },
|
2011-05-12 23:31:13 +00:00
|
|
|
#ifdef YAX_ENABLE
|
|
|
|
{ DS_NOCHK, &numyaxbunches, sizeof(numyaxbunches), 1 },
|
2013-04-09 17:35:11 +00:00
|
|
|
# if !defined NEW_MAP_FORMAT
|
2011-05-12 23:31:13 +00:00
|
|
|
{ DS_CNT(numsectors), yax_bunchnum, sizeof(yax_bunchnum[0]), (intptr_t)&numsectors },
|
|
|
|
{ DS_CNT(numwalls), yax_nextwall, sizeof(yax_nextwall[0]), (intptr_t)&numwalls },
|
2013-04-09 17:35:11 +00:00
|
|
|
# endif
|
2011-05-12 23:31:13 +00:00
|
|
|
{ DS_LOADFN|DS_PROTECTFN, (void *)&sv_postyaxload, 0, 1 },
|
|
|
|
#endif
|
2012-03-14 22:31:49 +00:00
|
|
|
{ 0, &Numsprites, sizeof(Numsprites), 1 },
|
2012-03-13 20:07:17 +00:00
|
|
|
{ 0, &tailspritefree, sizeof(tailspritefree), 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ 0, &headspritesect[0], sizeof(headspritesect[0]), MAXSECTORS+1 },
|
|
|
|
{ 0, &prevspritesect[0], sizeof(prevspritesect[0]), MAXSPRITES },
|
|
|
|
{ 0, &nextspritesect[0], sizeof(nextspritesect[0]), MAXSPRITES },
|
|
|
|
{ 0, &headspritestat[0], sizeof(headspritestat[0]), MAXSTATUS+1 },
|
|
|
|
{ 0, &prevspritestat[0], sizeof(prevspritestat[0]), MAXSPRITES },
|
|
|
|
{ 0, &nextspritestat[0], sizeof(nextspritestat[0]), MAXSPRITES },
|
2011-03-04 08:50:58 +00:00
|
|
|
#ifdef USE_OPENGL
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_SAVEFN, (void *)&sv_prespriteextsave, 0, 1 },
|
|
|
|
#endif
|
Inreased debugging level for catching oob accesses to 'main' arrays.
If enabled, this makes the following arrays be allocated statically:
spriteext, spritesmooth, sector, wall, sprite, tsprite, while
necessarily disabling the clipshape feature (because it relies on
setting sector/wall to different malloc'd block temporarily).
To compile, pass DEBUGANYWAY=1 in addition to RELEASE=0 to 'make',
and it's really only useful with CC=clang, of course.
git-svn-id: https://svn.eduke32.com/eduke32@2270 1a8010ca-5511-0410-912e-c29ae57300e0
2012-01-19 23:17:34 +00:00
|
|
|
{ DS_MAINAR, &spriteext, sizeof(spriteext_t), MAXSPRITES },
|
2011-03-04 08:50:58 +00:00
|
|
|
#ifdef USE_OPENGL
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_SAVEFN|DS_LOADFN, (void *)&sv_postspriteext, 0, 1 },
|
|
|
|
#endif
|
|
|
|
{ 0, &DynamicTileMap[0], sizeof(DynamicTileMap[0]), MAXTILES }, // NOCHK?
|
2013-06-01 06:55:30 +00:00
|
|
|
{ 0, &DynamicSoundMap[0], sizeof(DynamicSoundMap[0]), MAXSOUNDS }, // NOCHK?
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_NOCHK, &g_numCyclers, sizeof(g_numCyclers), 1 },
|
|
|
|
{ DS_CNT(g_numCyclers), &cyclers[0][0], sizeof(cyclers[0]), (intptr_t)&g_numCyclers },
|
|
|
|
{ DS_NOCHK, &g_numAnimWalls, sizeof(g_numAnimWalls), 1 },
|
|
|
|
{ DS_CNT(g_numAnimWalls), &animwall, sizeof(animwall[0]), (intptr_t)&g_numAnimWalls },
|
|
|
|
{ DS_NOCHK, &g_mirrorCount, sizeof(g_mirrorCount), 1 },
|
|
|
|
{ DS_NOCHK, &g_mirrorWall[0], sizeof(g_mirrorWall[0]), sizeof(g_mirrorWall)/sizeof(g_mirrorWall[0]) },
|
|
|
|
{ DS_NOCHK, &g_mirrorSector[0], sizeof(g_mirrorSector[0]), sizeof(g_mirrorSector)/sizeof(g_mirrorSector[0]) },
|
|
|
|
// projectiles
|
|
|
|
{ 0, &SpriteProjectile[0], sizeof(projectile_t), MAXSPRITES },
|
2012-11-11 17:57:06 +00:00
|
|
|
{ 0, &ProjectileData[0], sizeof(projectile_t), MAXTILES },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ 0, &everyothertime, sizeof(everyothertime), 1 },
|
|
|
|
{ DS_END, 0, 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const dataspec_t svgm_script[] =
|
|
|
|
{
|
2012-11-15 14:28:36 +00:00
|
|
|
{ DS_STRING, (void *)"blK:scri", 0, 1 },
|
2013-02-03 12:48:17 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_NOCHK, &g_scriptSize, sizeof(g_scriptSize), 1 },
|
|
|
|
{ DS_SAVEFN|DS_LOADFN|DS_NOCHK, (void *)&sv_calcbitptrsize, 0, 1 },
|
|
|
|
{ DS_DYNAMIC|DS_CNT(savegame_bitptrsize)|DS_NOCHK, &bitptr, sizeof(bitptr[0]), (intptr_t)&savegame_bitptrsize },
|
|
|
|
|
|
|
|
{ DS_SAVEFN|DS_NOCHK, (void *)&sv_prescriptsave_once, 0, 1 },
|
2013-02-03 12:48:17 +00:00
|
|
|
#endif
|
2012-11-11 17:57:06 +00:00
|
|
|
{ DS_NOCHK, &g_tile[0], sizeof(tiledata_t), MAXTILES },
|
2013-02-03 12:48:17 +00:00
|
|
|
#if !defined LUNATIC
|
2010-02-13 21:46:42 +00:00
|
|
|
{ DS_LOADFN|DS_NOCHK, (void *)&sv_prescriptload_once, 0, 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_DYNAMIC|DS_CNT(g_scriptSize)|DS_NOCHK, &script, sizeof(script[0]), (intptr_t)&g_scriptSize },
|
|
|
|
// { DS_NOCHK, &apScriptGameEvent[0], sizeof(apScriptGameEvent[0]), MAXGAMEEVENTS },
|
|
|
|
{ DS_SAVEFN|DS_LOADFN|DS_NOCHK, (void *)&sv_postscript_once, 0, 1 },
|
2013-02-03 12:48:17 +00:00
|
|
|
#endif
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_SAVEFN, (void *)&sv_preactordatasave, 0, 1 },
|
2010-08-02 08:13:51 +00:00
|
|
|
{ 0, &actor[0], sizeof(actor_t), MAXSPRITES },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_SAVEFN|DS_LOADFN, (void *)&sv_postactordata, 0, 1 },
|
|
|
|
|
|
|
|
{ DS_END, 0, 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const dataspec_t svgm_anmisc[] =
|
|
|
|
{
|
2012-11-15 14:28:36 +00:00
|
|
|
{ DS_STRING, (void *)"blK:anms", 0, 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ 0, &g_animateCount, sizeof(g_animateCount), 1 },
|
|
|
|
{ 0, &animatesect[0], sizeof(animatesect[0]), MAXANIMATES },
|
|
|
|
{ 0, &animategoal[0], sizeof(animategoal[0]), MAXANIMATES },
|
|
|
|
{ 0, &animatevel[0], sizeof(animatevel[0]), MAXANIMATES },
|
|
|
|
{ DS_SAVEFN, (void *)&sv_preanimateptrsave, 0, 1 },
|
|
|
|
{ 0, &animateptr[0], sizeof(animateptr[0]), MAXANIMATES },
|
|
|
|
{ DS_SAVEFN|DS_LOADFN , (void *)&sv_postanimateptr, 0, 1 },
|
|
|
|
{ 0, &camsprite, sizeof(camsprite), 1 },
|
|
|
|
{ 0, &msx[0], sizeof(msx[0]), sizeof(msx)/sizeof(msx[0]) },
|
|
|
|
{ 0, &msy[0], sizeof(msy[0]), sizeof(msy)/sizeof(msy[0]) },
|
2010-02-13 21:46:42 +00:00
|
|
|
{ 0, &g_spriteDeleteQueuePos, sizeof(g_spriteDeleteQueuePos), 1 },
|
|
|
|
{ DS_NOCHK, &g_spriteDeleteQueueSize, sizeof(g_spriteDeleteQueueSize), 1 },
|
|
|
|
{ DS_CNT(g_spriteDeleteQueueSize), &SpriteDeletionQueue[0], sizeof(int16_t), (intptr_t)&g_spriteDeleteQueueSize },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ 0, &show2dsector[0], sizeof(uint8_t), MAXSECTORS>>3 },
|
|
|
|
{ DS_NOCHK, &g_numClouds, sizeof(g_numClouds), 1 },
|
|
|
|
{ 0, &clouds[0], sizeof(clouds), 1 },
|
|
|
|
{ 0, &cloudx[0], sizeof(cloudx), 1 },
|
|
|
|
{ 0, &cloudy[0], sizeof(cloudy), 1 },
|
|
|
|
{ DS_NOCHK, ¶llaxyscale, sizeof(parallaxyscale), 1 },
|
|
|
|
{ 0, &pskybits, sizeof(pskybits), 1 },
|
|
|
|
{ 0, &pskyoff[0], sizeof(pskyoff[0]), MAXPSKYTILES },
|
|
|
|
{ 0, &g_earthquakeTime, sizeof(g_earthquakeTime), 1 },
|
|
|
|
|
|
|
|
{ DS_SAVEFN|DS_LOADFN|DS_NOCHK, (void *)sv_prequote, 0, 1 },
|
|
|
|
{ DS_SAVEFN, (void *)&sv_quotesave, 0, 1 },
|
|
|
|
{ DS_NOCHK, &savegame_quotedef, sizeof(savegame_quotedef), 1 }, // quotes can change during runtime, but new quote numbers cannot be allocated
|
|
|
|
{ DS_DYNAMIC, &savegame_quotes, MAXQUOTELEN, MAXQUOTES },
|
|
|
|
{ DS_LOADFN, (void *)&sv_quoteload, 0, 1 },
|
|
|
|
|
|
|
|
{ DS_NOCHK, &g_numQuoteRedefinitions, sizeof(g_numQuoteRedefinitions), 1 },
|
|
|
|
{ DS_NOCHK|DS_SAVEFN|DS_LOADFN, (void *)&sv_prequoteredef, 0, 1 },
|
|
|
|
{ DS_NOCHK|DS_SAVEFN, (void *)&sv_quoteredefsave, 0, 1 }, // quote redefinitions replace quotes at runtime, but cannot be changed after CON compilation
|
|
|
|
{ DS_NOCHK|DS_DYNAMIC|DS_CNT(g_numQuoteRedefinitions), &savegame_quoteredefs, MAXQUOTELEN, (intptr_t)&g_numQuoteRedefinitions },
|
|
|
|
{ DS_NOCHK|DS_LOADFN, (void *)&sv_quoteredefload, 0, 1 },
|
|
|
|
{ DS_NOCHK|DS_SAVEFN|DS_LOADFN, (void *)&sv_postquoteredef, 0, 1 },
|
|
|
|
|
|
|
|
{ DS_SAVEFN, (void *)&sv_restsave, 0, 1 },
|
|
|
|
{ 0, savegame_restdata, 1, sizeof(savegame_restdata) }, // sz/cnt swapped for kdfread
|
|
|
|
{ DS_LOADFN, (void *)&sv_restload, 0, 1 },
|
|
|
|
|
2012-11-15 14:28:36 +00:00
|
|
|
{ DS_STRING, (void *)"savegame_end", 0, 1 },
|
2010-01-25 01:11:34 +00:00
|
|
|
{ DS_END, 0, 0, 0 }
|
|
|
|
};
|
|
|
|
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
static dataspec_t *svgm_vars=NULL;
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2011-12-25 15:34:06 +00:00
|
|
|
static uint8_t *dosaveplayer2(FILE *fil, uint8_t *mem);
|
|
|
|
static int32_t doloadplayer2(int32_t fil, uint8_t **memptr);
|
|
|
|
static void postloadplayer(int32_t savegamep);
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
// SVGM snapshot system
|
|
|
|
static uint32_t svsnapsiz;
|
|
|
|
static uint8_t *svsnapshot, *svinitsnap;
|
|
|
|
static uint32_t svdiffsiz;
|
|
|
|
static uint8_t *svdiff;
|
|
|
|
|
|
|
|
#include "gamedef.h"
|
|
|
|
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
|
|
|
# define SV_SKIPMASK (/*GAMEVAR_SYSTEM|*/GAMEVAR_READONLY|GAMEVAR_INTPTR| \
|
|
|
|
GAMEVAR_SHORTPTR|GAMEVAR_CHARPTR /*|GAMEVAR_NORESET*/ |GAMEVAR_SPECIAL)
|
2010-01-24 23:33:17 +00:00
|
|
|
// setup gamevar data spec for snapshotting and diffing... gamevars must be loaded when called
|
|
|
|
static void sv_makevarspec()
|
|
|
|
{
|
|
|
|
static char *magic = "blK:vars";
|
|
|
|
int32_t i, j, numsavedvars=0, per;
|
|
|
|
|
|
|
|
for (i=0; i<g_gameVarCount; i++)
|
|
|
|
numsavedvars += (aGameVars[i].dwFlags&SV_SKIPMASK) ? 0 : 1;
|
|
|
|
|
2013-05-24 13:54:32 +00:00
|
|
|
Bfree(svgm_vars);
|
2012-11-15 14:28:29 +00:00
|
|
|
svgm_vars = (dataspec_t *)Bmalloc((numsavedvars+g_gameArrayCount+2)*sizeof(dataspec_t));
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2013-05-24 13:54:32 +00:00
|
|
|
if (svgm_vars == NULL)
|
|
|
|
G_GameExit("OUT OF MEMORY in sv_makevarspec()\n");
|
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
svgm_vars[0].flags = DS_STRING;
|
|
|
|
svgm_vars[0].ptr = magic;
|
|
|
|
svgm_vars[0].cnt = 1;
|
|
|
|
|
|
|
|
j=1;
|
|
|
|
for (i=0; i<g_gameVarCount; i++)
|
|
|
|
{
|
|
|
|
if (aGameVars[i].dwFlags&SV_SKIPMASK)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
per = aGameVars[i].dwFlags&GAMEVAR_USER_MASK;
|
|
|
|
|
|
|
|
svgm_vars[j].flags = 0;
|
|
|
|
svgm_vars[j].ptr = (per==0) ? &aGameVars[i].val.lValue : aGameVars[i].val.plValues;
|
|
|
|
svgm_vars[j].size = sizeof(intptr_t);
|
|
|
|
svgm_vars[j].cnt = (per==0) ? 1 : (per==GAMEVAR_PERPLAYER ? MAXPLAYERS : MAXSPRITES);
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i=0; i<g_gameArrayCount; i++)
|
|
|
|
{
|
|
|
|
svgm_vars[j].flags = 0;
|
|
|
|
svgm_vars[j].ptr = aGameArrays[i].plValues;
|
|
|
|
svgm_vars[j].size = sizeof(aGameArrays[0].plValues[0]);
|
|
|
|
svgm_vars[j].cnt = aGameArrays[i].size; // assumed constant throughout demo, i.e. no RESIZEARRAY
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
|
|
|
|
svgm_vars[j].flags = DS_END;
|
|
|
|
}
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
void sv_freemem()
|
|
|
|
{
|
|
|
|
if (svsnapshot)
|
|
|
|
Bfree(svsnapshot), svsnapshot=NULL;
|
|
|
|
if (svinitsnap)
|
|
|
|
Bfree(svinitsnap), svinitsnap=NULL;
|
|
|
|
if (svdiff)
|
|
|
|
Bfree(svdiff), svdiff=NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int32_t doallocsnap(int32_t allocinit)
|
|
|
|
{
|
|
|
|
sv_freemem();
|
|
|
|
|
2012-11-15 14:28:29 +00:00
|
|
|
svsnapshot = (uint8_t *)Bmalloc(svsnapsiz);
|
2010-01-24 23:33:17 +00:00
|
|
|
if (allocinit)
|
2012-11-15 14:28:29 +00:00
|
|
|
svinitsnap = (uint8_t *)Bmalloc(svsnapsiz);
|
2010-01-24 23:33:17 +00:00
|
|
|
svdiffsiz = svsnapsiz; // theoretically it's less than could be needed in the worst case, but practically it's overkill
|
2012-11-15 14:28:29 +00:00
|
|
|
svdiff = (uint8_t *)Bmalloc(svdiffsiz);
|
2011-12-21 18:42:12 +00:00
|
|
|
if (svsnapshot==NULL || (allocinit && svinitsnap==NULL) || svdiff==NULL)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
|
|
|
sv_freemem();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-04-05 17:53:14 +00:00
|
|
|
EDUKE32_STATIC_ASSERT(sizeof(savehead_t) == 310);
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// make snapshot only if spot < 0 (demo)
|
|
|
|
int32_t sv_saveandmakesnapshot(FILE *fil, int8_t spot, int8_t recdiffsp, int8_t diffcompress, int8_t synccompress)
|
|
|
|
{
|
|
|
|
savehead_t h;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// set a few savegame system globals
|
2010-01-24 23:33:17 +00:00
|
|
|
savegame_comprthres = SV_DEFAULTCOMPRTHRES;
|
2011-12-25 15:34:06 +00:00
|
|
|
savegame_diffcompress = diffcompress;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// calculate total snapshot size
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
sv_makevarspec();
|
|
|
|
svsnapsiz = calcsz(svgm_vars);
|
2013-05-19 19:29:18 +00:00
|
|
|
#else
|
|
|
|
svsnapsiz = 0;
|
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
svsnapsiz += calcsz(svgm_udnetw) + calcsz(svgm_secwsp) + calcsz(svgm_script) + calcsz(svgm_anmisc);
|
|
|
|
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// create header
|
|
|
|
Bmemcpy(h.headerstr, "EDuke32SAVE", 11);
|
|
|
|
h.majorver = SV_MAJOR_VER;
|
|
|
|
h.minorver = SV_MINOR_VER;
|
|
|
|
h.ptrsize = sizeof(intptr_t);
|
|
|
|
h.bytever = BYTEVERSION;
|
|
|
|
|
|
|
|
h.comprthres = savegame_comprthres;
|
|
|
|
h.recdiffsp = recdiffsp;
|
|
|
|
h.diffcompress = savegame_diffcompress;
|
|
|
|
h.synccompress = synccompress;
|
|
|
|
|
|
|
|
h.reccnt = 0;
|
|
|
|
h.snapsiz = svsnapsiz;
|
|
|
|
|
|
|
|
// the following is kinda redundant, but we save it here to be able to quickly fetch
|
|
|
|
// it in a savegame header read
|
|
|
|
h.numplayers = ud.multimode;
|
|
|
|
h.volnum = ud.volume_number;
|
|
|
|
h.levnum = ud.level_number;
|
|
|
|
h.skill = ud.player_skill;
|
|
|
|
Bstrncpy(h.boardfn, currentboardfilename, sizeof(h.boardfn));
|
|
|
|
|
|
|
|
if (spot >= 0)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
// savegame
|
2012-03-28 19:43:21 +00:00
|
|
|
Bstrncpyz(h.savename, ud.savegame[spot], sizeof(h.savename));
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// demo
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
const time_t t=time(NULL);
|
|
|
|
struct tm *st;
|
|
|
|
|
2012-03-28 19:43:21 +00:00
|
|
|
Bstrncpyz(h.savename, "Eduke32 demo", sizeof(h.savename));
|
2011-12-25 15:34:06 +00:00
|
|
|
if (t>=0 && (st = localtime(&t)))
|
|
|
|
Bsprintf(h.savename, "Edemo32 %04d%02d%02d", st->tm_year+1900, st->tm_mon+1, st->tm_mday);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// write header
|
|
|
|
fwrite(&h, sizeof(savehead_t), 1, fil);
|
|
|
|
|
|
|
|
// for savegames, the file offset after the screenshot goes here;
|
|
|
|
// for demos, we keep it 0 to signify that we didn't save one
|
|
|
|
fwrite("\0\0\0\0", 4, 1, fil);
|
|
|
|
if (spot >= 0 && waloff[TILE_SAVESHOT])
|
|
|
|
{
|
|
|
|
int32_t ofs;
|
|
|
|
|
|
|
|
// write the screenshot compressed
|
|
|
|
dfwrite((char *)waloff[TILE_SAVESHOT], 320, 200, fil);
|
|
|
|
|
|
|
|
// write the current file offset right after the header
|
|
|
|
ofs = ftell(fil);
|
|
|
|
fseek(fil, sizeof(savehead_t), SEEK_SET);
|
|
|
|
fwrite(&ofs, 4, 1, fil);
|
|
|
|
fseek(fil, ofs, SEEK_SET);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUGGINGAIDS
|
|
|
|
OSD_Printf("sv_saveandmakesnapshot: snapshot size: %d bytes.\n", svsnapsiz);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (spot >= 0)
|
|
|
|
{
|
|
|
|
// savegame
|
|
|
|
dosaveplayer2(fil, NULL);
|
2013-05-20 19:31:42 +00:00
|
|
|
#ifdef LUNATIC
|
|
|
|
if (!g_savedOK)
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_saveandmakesnapshot: failed serializing Lunatic gamevar %s.\n",
|
|
|
|
g_failedVarname);
|
|
|
|
g_failedVarname = NULL;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
2011-12-25 15:34:06 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
uint8_t *p;
|
|
|
|
|
|
|
|
// demo
|
|
|
|
if (doallocsnap(0))
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_saveandmakesnapshot: failed allocating memory.\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = dosaveplayer2(fil, svsnapshot);
|
|
|
|
if (p != svsnapshot+svsnapsiz)
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_saveandmakesnapshot: ptr-(snapshot end)=%d!\n", (int32_t)(p-(svsnapshot+svsnapsiz)));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2012-11-13 10:50:06 +00:00
|
|
|
g_oldverSavegame[spot] = 0;
|
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-05 17:53:14 +00:00
|
|
|
|
|
|
|
EDUKE32_STATIC_ASSERT(sizeof(savehead_t) == 310);
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// if file is not an EDuke32 savegame/demo, h->headerstr will be all zeros
|
|
|
|
int32_t sv_loadheader(int32_t fil, int32_t spot, savehead_t *h)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
int32_t havedemo = (spot < 0);
|
|
|
|
|
|
|
|
if (kread(fil, h, sizeof(savehead_t)) != sizeof(savehead_t))
|
|
|
|
{
|
|
|
|
OSD_Printf("%s %d header corrupt.\n", havedemo ? "Demo":"Savegame", havedemo ? -spot : spot);
|
|
|
|
Bmemset(h->headerstr, 0, sizeof(h->headerstr));
|
|
|
|
return -1;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (Bmemcmp(h->headerstr, "EDuke32SAVE", 11))
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
h->headerstr[sizeof(h->headerstr)-1] = 0;
|
|
|
|
OSD_Printf("%s %d header reads \"%s\", expected \"EDuke32SAVE\".\n",
|
|
|
|
havedemo ? "Demo":"Savegame", havedemo ? -spot : spot, h->headerstr);
|
|
|
|
Bmemset(h->headerstr, 0, sizeof(h->headerstr));
|
2010-01-24 23:33:17 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (h->majorver != SV_MAJOR_VER || h->minorver != SV_MINOR_VER || h->bytever != BYTEVERSION)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
if (havedemo)
|
|
|
|
OSD_Printf("Incompatible demo version. Expected %d.%d.%d, found %d.%d.%d\n",
|
|
|
|
SV_MAJOR_VER, SV_MINOR_VER, BYTEVERSION,
|
|
|
|
h->majorver, h->minorver, h->bytever);
|
2010-01-24 23:33:17 +00:00
|
|
|
return 2;
|
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
|
|
|
|
if (h->ptrsize != sizeof(intptr_t))
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
if (havedemo)
|
|
|
|
OSD_Printf("Demo incompatible. Expected pointer size %d, found %d\n",
|
|
|
|
(int32_t)sizeof(intptr_t), h->ptrsize);
|
2010-01-24 23:33:17 +00:00
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
int32_t sv_loadsnapshot(int32_t fil, int32_t spot, savehead_t *h)
|
|
|
|
{
|
|
|
|
uint8_t *p;
|
|
|
|
int32_t i;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (spot < 0)
|
|
|
|
{
|
|
|
|
// demo
|
|
|
|
i = sv_loadheader(fil, spot, h);
|
|
|
|
if (i)
|
|
|
|
return i;
|
|
|
|
|
|
|
|
// Used to be in doloadplayer2(), now redundant for savegames since
|
|
|
|
// we checked before. Multiplayer demos need still to be taken care of.
|
|
|
|
if (h->numplayers != numplayers)
|
|
|
|
return 9;
|
|
|
|
}
|
|
|
|
// else (if savegame), we just read the header and are now at offset sizeof(savehead_t)
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
#ifdef DEBUGGINGAIDS
|
|
|
|
OSD_Printf("sv_loadsnapshot: snapshot size: %d bytes.\n", h->snapsiz);
|
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (kread(fil, &i, 4) != 4)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
OSD_Printf("sv_snapshot: couldn't read 4 bytes after header.\n");
|
|
|
|
return 7;
|
|
|
|
}
|
|
|
|
if (i > 0)
|
|
|
|
{
|
|
|
|
if (klseek(fil, i, SEEK_SET) != i)
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_snapshot: failed skipping over the screenshot.\n");
|
|
|
|
return 8;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
2011-12-26 14:37:34 +00:00
|
|
|
savegame_comprthres = h->comprthres;
|
|
|
|
|
2013-05-20 19:31:42 +00:00
|
|
|
#ifdef LUNATIC
|
|
|
|
El_CreateGameState();
|
|
|
|
G_PostCreateGameState();
|
|
|
|
#endif
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (spot >= 0)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
// savegame
|
|
|
|
i = doloadplayer2(fil, NULL);
|
|
|
|
if (i)
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_loadsnapshot: doloadplayer2() returned %d.\n", i);
|
|
|
|
return 5;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// demo
|
|
|
|
savegame_diffcompress = h->diffcompress;
|
|
|
|
|
|
|
|
svsnapsiz = h->snapsiz;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (doallocsnap(1))
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_loadsnapshot: failed allocating memory.\n");
|
|
|
|
return 4;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
p = svsnapshot;
|
|
|
|
i = doloadplayer2(fil, &p);
|
|
|
|
if (i)
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_loadsnapshot: doloadplayer2() returned %d.\n", i);
|
|
|
|
sv_freemem();
|
|
|
|
return 5;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
if (p != svsnapshot+svsnapsiz)
|
|
|
|
{
|
|
|
|
OSD_Printf("sv_loadsnapshot: internal error: p-(snapshot end)=%d!\n",
|
|
|
|
(int32_t)(p-(svsnapshot+svsnapsiz)));
|
|
|
|
sv_freemem();
|
|
|
|
return 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bmemcpy(svinitsnap, svsnapshot, svsnapsiz);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
postloadplayer((spot >= 0));
|
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
uint32_t sv_writediff(FILE *fil)
|
|
|
|
{
|
|
|
|
uint8_t *p=svsnapshot, *d=svdiff;
|
|
|
|
uint32_t diffsiz;
|
|
|
|
|
|
|
|
cmpspecdata(svgm_udnetw, &p, &d);
|
|
|
|
cmpspecdata(svgm_secwsp, &p, &d);
|
|
|
|
cmpspecdata(svgm_script, &p, &d);
|
|
|
|
cmpspecdata(svgm_anmisc, &p, &d);
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
cmpspecdata(svgm_vars, &p, &d);
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
if (p != svsnapshot+svsnapsiz)
|
|
|
|
OSD_Printf("sv_writediff: dump+siz=%p, p=%p!\n", svsnapshot+svsnapsiz, p);
|
|
|
|
|
|
|
|
diffsiz = d-svdiff;
|
|
|
|
|
|
|
|
fwrite("dIfF",4,1,fil);
|
|
|
|
fwrite(&diffsiz, sizeof(diffsiz), 1, fil);
|
|
|
|
if (savegame_diffcompress)
|
|
|
|
dfwrite(svdiff, 1, diffsiz, fil); // cnt and sz swapped
|
|
|
|
else
|
|
|
|
fwrite(svdiff, 1, diffsiz, fil);
|
|
|
|
|
|
|
|
return diffsiz;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t sv_readdiff(int32_t fil)
|
|
|
|
{
|
|
|
|
uint8_t *p=svsnapshot, *d=svdiff, i=0; //, tbuf[4];
|
2010-02-23 18:13:46 +00:00
|
|
|
int32_t diffsiz;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
#if 0 // handled by the caller
|
2010-02-23 18:13:46 +00:00
|
|
|
if (kread(fil, tbuf, 4)!=4)
|
|
|
|
return -1;
|
|
|
|
if (Bmemcmp(tbuf, "dIfF", 4))
|
|
|
|
return 4;
|
2010-01-24 23:33:17 +00:00
|
|
|
#endif
|
2010-02-23 18:13:46 +00:00
|
|
|
if (kread(fil, &diffsiz, sizeof(uint32_t))!=sizeof(uint32_t))
|
|
|
|
return -1;
|
2010-01-24 23:33:17 +00:00
|
|
|
if (savegame_diffcompress)
|
|
|
|
{
|
|
|
|
if (kdfread(svdiff, 1, diffsiz, fil) != diffsiz) // cnt and sz swapped
|
|
|
|
return -2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (kread(fil, svdiff, diffsiz) != diffsiz)
|
|
|
|
return -2;
|
|
|
|
}
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
if (applydiff(svgm_udnetw, &p, &d)) return -3;
|
|
|
|
if (applydiff(svgm_secwsp, &p, &d)) return -4;
|
|
|
|
if (applydiff(svgm_script, &p, &d)) return -5;
|
|
|
|
if (applydiff(svgm_anmisc, &p, &d)) return -6;
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-02-23 18:13:46 +00:00
|
|
|
if (applydiff(svgm_vars, &p, &d)) return -7;
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2010-02-23 18:13:46 +00:00
|
|
|
|
|
|
|
if (p!=svsnapshot+svsnapsiz)
|
|
|
|
i|=1;
|
|
|
|
if (d!=svdiff+diffsiz)
|
|
|
|
i|=2;
|
|
|
|
if (i)
|
|
|
|
OSD_Printf("sv_readdiff: p=%p, svsnapshot+svsnapsiz=%p; d=%p, svdiff+diffsiz=%p",
|
|
|
|
p, svsnapshot+svsnapsiz, d, svdiff+diffsiz);
|
|
|
|
return i;
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// SVGM data description
|
|
|
|
static void sv_postudload()
|
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
// Bmemcpy(&boardfilename[0], ¤tboardfilename[0], BMAX_PATH); // DON'T do this in demos!
|
|
|
|
#if 1
|
2010-01-24 23:33:17 +00:00
|
|
|
ud.m_level_number = ud.level_number;
|
|
|
|
ud.m_volume_number = ud.volume_number;
|
|
|
|
ud.m_player_skill = ud.player_skill;
|
|
|
|
ud.m_respawn_monsters = ud.respawn_monsters;
|
|
|
|
ud.m_respawn_items = ud.respawn_items;
|
|
|
|
ud.m_respawn_inventory = ud.respawn_inventory;
|
|
|
|
ud.m_monsters_off = ud.monsters_off;
|
|
|
|
ud.m_coop = ud.coop;
|
|
|
|
ud.m_marker = ud.marker;
|
|
|
|
ud.m_ffire = ud.ffire;
|
|
|
|
ud.m_noexits = ud.noexits;
|
2010-02-13 21:46:42 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
//static int32_t lockclock_dummy;
|
|
|
|
|
2011-03-04 08:50:58 +00:00
|
|
|
#ifdef USE_OPENGL
|
2010-01-24 23:33:17 +00:00
|
|
|
static void sv_prespriteextsave()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
|
|
if (spriteext[i].mdanimtims)
|
|
|
|
{
|
|
|
|
spriteext[i].mdanimtims -= mdtims;
|
|
|
|
if (spriteext[i].mdanimtims==0)
|
|
|
|
spriteext[i].mdanimtims++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void sv_postspriteext()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
|
|
if (spriteext[i].mdanimtims)
|
|
|
|
spriteext[i].mdanimtims += mdtims;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-05-12 23:31:13 +00:00
|
|
|
#ifdef YAX_ENABLE
|
2012-03-11 17:37:08 +00:00
|
|
|
void sv_postyaxload(void)
|
2011-05-12 23:31:13 +00:00
|
|
|
{
|
|
|
|
yax_update(numyaxbunches>0 ? 2 : 1);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-02-03 12:48:17 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
static void sv_calcbitptrsize()
|
|
|
|
{
|
|
|
|
savegame_bitptrsize = (g_scriptSize+7)>>3;
|
|
|
|
}
|
|
|
|
static void sv_prescriptsave_once()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
for (i=0; i<g_scriptSize; i++)
|
|
|
|
if (bitptr[i>>3]&(BITPTR_POINTER<<(i&7)))
|
2011-12-25 15:32:00 +00:00
|
|
|
script[i] = (intptr_t *)script[i] - script;
|
2011-07-29 22:07:49 +00:00
|
|
|
|
2012-10-30 15:54:35 +00:00
|
|
|
G_Util_PtrToIdx2(&g_tile[0].execPtr, MAXTILES, sizeof(tiledata_t), script, P2I_FWD_NON0);
|
|
|
|
G_Util_PtrToIdx2(&g_tile[0].loadPtr, MAXTILES, sizeof(tiledata_t), script, P2I_FWD_NON0);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
2010-02-13 21:46:42 +00:00
|
|
|
static void sv_prescriptload_once()
|
|
|
|
{
|
|
|
|
if (script)
|
|
|
|
Bfree(script);
|
2012-11-15 14:28:29 +00:00
|
|
|
script = (intptr_t *)Bmalloc(g_scriptSize * sizeof(script[0]));
|
2010-02-13 21:46:42 +00:00
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
static void sv_postscript_once()
|
|
|
|
{
|
|
|
|
int32_t i;
|
2011-07-29 22:07:49 +00:00
|
|
|
|
2012-10-30 15:54:35 +00:00
|
|
|
G_Util_PtrToIdx2(&g_tile[0].execPtr, MAXTILES, sizeof(tiledata_t), script, P2I_BACK_NON0);
|
|
|
|
G_Util_PtrToIdx2(&g_tile[0].loadPtr, MAXTILES, sizeof(tiledata_t), script, P2I_BACK_NON0);
|
2011-07-29 22:07:49 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
for (i=0; i<g_scriptSize; i++)
|
|
|
|
if (bitptr[i>>3]&(BITPTR_POINTER<<(i&7)))
|
2011-12-25 15:32:00 +00:00
|
|
|
script[i] = (intptr_t)(script + script[i]);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
2013-02-03 12:48:17 +00:00
|
|
|
#endif
|
2011-12-21 18:40:47 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
static void sv_preactordatasave()
|
|
|
|
{
|
|
|
|
int32_t i;
|
2012-03-11 17:37:50 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
|
|
{
|
2011-06-19 18:30:32 +00:00
|
|
|
actor[i].lightptr = NULL;
|
|
|
|
actor[i].lightId = -1;
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
}
|
2011-12-21 18:40:47 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
static void sv_postactordata()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
|
|
{
|
2011-06-19 18:30:32 +00:00
|
|
|
actor[i].lightptr = NULL;
|
|
|
|
actor[i].lightId = -1;
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sv_preanimateptrsave()
|
|
|
|
{
|
2011-07-29 22:07:49 +00:00
|
|
|
G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_FWD);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
static void sv_postanimateptr()
|
|
|
|
{
|
2011-07-29 22:07:49 +00:00
|
|
|
G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_BACK);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
static void sv_prequote()
|
|
|
|
{
|
|
|
|
if (!savegame_quotes)
|
2012-11-15 14:28:29 +00:00
|
|
|
savegame_quotes = (char (*)[MAXQUOTELEN])Bcalloc(MAXQUOTES, MAXQUOTELEN);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
static void sv_quotesave()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
Bmemset(savegame_quotedef, 0, sizeof(savegame_quotedef));
|
|
|
|
for (i=0; i<MAXQUOTES; i++)
|
|
|
|
if (ScriptQuotes[i])
|
|
|
|
{
|
|
|
|
savegame_quotedef[i>>3] |= 1<<(i&7);
|
|
|
|
Bmemcpy(savegame_quotes[i], ScriptQuotes[i], MAXQUOTELEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void sv_quoteload()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
for (i=0; i<MAXQUOTES; i++)
|
|
|
|
{
|
|
|
|
if (savegame_quotedef[i>>3]&(1<<(i&7)))
|
|
|
|
{
|
2013-01-01 15:24:25 +00:00
|
|
|
C_AllocQuote(i);
|
2010-01-24 23:33:17 +00:00
|
|
|
Bmemcpy(ScriptQuotes[i], savegame_quotes[i], MAXQUOTELEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void sv_prequoteredef()
|
|
|
|
{
|
|
|
|
// "+1" needed for dfwrite which doesn't handle the src==NULL && cnt==0 case
|
2012-11-15 14:28:29 +00:00
|
|
|
savegame_quoteredefs = (char (*)[MAXQUOTELEN])Bcalloc(g_numQuoteRedefinitions+1, MAXQUOTELEN);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
static void sv_quoteredefsave()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
for (i=0; i<g_numQuoteRedefinitions; i++)
|
|
|
|
if (ScriptQuoteRedefinitions[i])
|
|
|
|
Bmemcpy(savegame_quoteredefs[i], ScriptQuoteRedefinitions[i], MAXQUOTELEN);
|
|
|
|
}
|
|
|
|
static void sv_quoteredefload()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
for (i=0; i<g_numQuoteRedefinitions; i++)
|
|
|
|
{
|
|
|
|
if (!ScriptQuoteRedefinitions[i])
|
2012-11-15 14:28:29 +00:00
|
|
|
ScriptQuoteRedefinitions[i] = (char *)Bcalloc(1,MAXQUOTELEN);
|
2010-01-24 23:33:17 +00:00
|
|
|
Bmemcpy(ScriptQuoteRedefinitions[i], savegame_quoteredefs[i], MAXQUOTELEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void sv_postquoteredef()
|
|
|
|
{
|
|
|
|
Bfree(savegame_quoteredefs), savegame_quoteredefs=NULL;
|
|
|
|
}
|
|
|
|
static void sv_restsave()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
uint8_t *mem = savegame_restdata;
|
|
|
|
DukePlayer_t dummy_ps;
|
|
|
|
|
|
|
|
Bmemset(&dummy_ps, 0, sizeof(DukePlayer_t));
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPDAT(ptr,sz) Bmemcpy(mem, ptr, sz), mem+=sz
|
2010-01-24 23:33:17 +00:00
|
|
|
for (i=0; i<MAXPLAYERS; i++)
|
|
|
|
{
|
|
|
|
CPDAT(g_player[i].user_name, 32);
|
|
|
|
CPDAT(&g_player[i].pcolor, sizeof(g_player[0].pcolor));
|
|
|
|
CPDAT(&g_player[i].pteam, sizeof(g_player[0].pteam));
|
|
|
|
CPDAT(&g_player[i].frags[0], sizeof(g_player[0].frags));
|
|
|
|
if (g_player[i].ps)
|
|
|
|
CPDAT(g_player[i].ps, sizeof(DukePlayer_t));
|
|
|
|
else
|
|
|
|
CPDAT(&dummy_ps, sizeof(DukePlayer_t));
|
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
|
2012-12-09 13:24:32 +00:00
|
|
|
Bassert((savegame_restdata+SVARDATALEN)-mem == 0);
|
2010-02-23 18:13:46 +00:00
|
|
|
#undef CPDAT
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
static void sv_restload()
|
|
|
|
{
|
|
|
|
int32_t i;
|
|
|
|
uint8_t *mem = savegame_restdata;
|
|
|
|
DukePlayer_t dummy_ps;
|
|
|
|
|
2010-02-23 18:13:46 +00:00
|
|
|
#define CPDAT(ptr,sz) Bmemcpy(ptr, mem, sz), mem+=sz
|
2010-01-24 23:33:17 +00:00
|
|
|
for (i=0; i<MAXPLAYERS; i++)
|
|
|
|
{
|
|
|
|
CPDAT(g_player[i].user_name, 32);
|
|
|
|
CPDAT(&g_player[i].pcolor, sizeof(g_player[0].pcolor));
|
|
|
|
CPDAT(&g_player[i].pteam, sizeof(g_player[0].pteam));
|
|
|
|
CPDAT(&g_player[i].frags[0], sizeof(g_player[0].frags));
|
|
|
|
if (g_player[i].ps)
|
|
|
|
CPDAT(g_player[i].ps, sizeof(DukePlayer_t));
|
|
|
|
else
|
|
|
|
CPDAT(&dummy_ps, sizeof(DukePlayer_t));
|
|
|
|
}
|
2010-02-23 18:13:46 +00:00
|
|
|
#undef CPDAT
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
2011-12-25 15:32:00 +00:00
|
|
|
#ifdef DEBUGGINGAIDS
|
2011-12-28 20:33:54 +00:00
|
|
|
# define PRINTSIZE(name) do { if (mem) OSD_Printf(name ": %d\n", (int32_t)(mem-tmem)); \
|
|
|
|
OSD_Printf(name ": %d ms\n", getticks()-t); t=getticks(); tmem=mem; } while (0)
|
2011-12-25 15:32:00 +00:00
|
|
|
#else
|
2011-12-28 20:33:54 +00:00
|
|
|
# define PRINTSIZE(name) do { } while (0)
|
2011-12-25 15:32:00 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2013-05-20 19:31:42 +00:00
|
|
|
#ifdef LUNATIC
|
|
|
|
LUNATIC_CB const char *(*El_SerializeGamevars)(int32_t *slenptr);
|
|
|
|
#endif
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
static uint8_t *dosaveplayer2(FILE *fil, uint8_t *mem)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-28 20:33:54 +00:00
|
|
|
#ifdef DEBUGGINGAIDS
|
2010-01-24 23:33:17 +00:00
|
|
|
uint8_t *tmem = mem;
|
2011-12-28 20:33:54 +00:00
|
|
|
int32_t t=getticks();
|
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
mem=writespecdata(svgm_udnetw, fil, mem); // user settings, players & net
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("ud");
|
2010-01-24 23:33:17 +00:00
|
|
|
mem=writespecdata(svgm_secwsp, fil, mem); // sector, wall, sprite
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("sws");
|
2010-01-24 23:33:17 +00:00
|
|
|
mem=writespecdata(svgm_script, fil, mem); // script
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("script");
|
2010-01-24 23:33:17 +00:00
|
|
|
mem=writespecdata(svgm_anmisc, fil, mem); // animates, quotes & misc.
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("animisc");
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
Gv_WriteSave(fil, 1); // gamevars
|
|
|
|
mem=writespecdata(svgm_vars, 0, mem);
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("vars");
|
2013-05-20 19:31:42 +00:00
|
|
|
#else
|
|
|
|
{
|
|
|
|
int32_t slen, slen_ext;
|
|
|
|
const char *svcode = El_SerializeGamevars(&slen);
|
|
|
|
|
|
|
|
if (slen < 0)
|
|
|
|
{
|
|
|
|
// Serialization failed.
|
|
|
|
g_savedOK = 0;
|
|
|
|
g_failedVarname = svcode;
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: compress text.
|
|
|
|
fwrite("\0\1LunaGVAR\3\4", 12, 1, fil);
|
|
|
|
slen_ext = B_LITTLE32(slen);
|
|
|
|
fwrite(&slen_ext, sizeof(slen_ext), 1, fil);
|
|
|
|
fwrite(svcode, slen, 1, fil);
|
|
|
|
|
|
|
|
g_savedOK = 1;
|
|
|
|
}
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LOADRD(ptr, sz, cnt) (kdfread(ptr,sz,cnt,fil)!=(cnt))
|
|
|
|
#define LOADRDU(ptr, sz, cnt) (kread(fil,ptr,(sz)*(cnt))!=(sz)*(cnt))
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
static int32_t doloadplayer2(int32_t fil, uint8_t **memptr)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2011-12-28 20:33:54 +00:00
|
|
|
uint8_t *mem = memptr ? *memptr : NULL;
|
|
|
|
#ifdef DEBUGGINGAIDS
|
|
|
|
uint8_t *tmem=mem;
|
|
|
|
int32_t t=getticks();
|
|
|
|
#endif
|
2011-12-25 15:34:06 +00:00
|
|
|
if (readspecdata(svgm_udnetw, fil, &mem)) return -2;
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("ud");
|
2010-01-24 23:33:17 +00:00
|
|
|
if (readspecdata(svgm_secwsp, fil, &mem)) return -4;
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("sws");
|
2010-01-24 23:33:17 +00:00
|
|
|
if (readspecdata(svgm_script, fil, &mem)) return -5;
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("script");
|
2010-01-24 23:33:17 +00:00
|
|
|
if (readspecdata(svgm_anmisc, fil, &mem)) return -6;
|
2011-12-25 15:32:00 +00:00
|
|
|
PRINTSIZE("animisc");
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
if (Gv_ReadSave(fil, 1)) return -7;
|
|
|
|
|
2011-12-21 18:42:12 +00:00
|
|
|
if (mem)
|
2011-12-25 15:32:00 +00:00
|
|
|
{
|
2011-12-25 15:34:06 +00:00
|
|
|
int32_t i;
|
|
|
|
|
2011-12-25 15:32:00 +00:00
|
|
|
sv_makevarspec();
|
2011-12-21 18:42:12 +00:00
|
|
|
for (i=1; svgm_vars[i].flags!=DS_END; i++)
|
|
|
|
{
|
|
|
|
Bmemcpy(mem, svgm_vars[i].ptr, svgm_vars[i].size*svgm_vars[i].cnt); // careful! works because there are no DS_DYNAMIC's!
|
|
|
|
mem += svgm_vars[i].size*svgm_vars[i].cnt;
|
|
|
|
}
|
2011-12-25 15:32:00 +00:00
|
|
|
}
|
2011-12-28 20:33:54 +00:00
|
|
|
PRINTSIZE("vars");
|
2013-05-20 19:31:42 +00:00
|
|
|
#else
|
|
|
|
{
|
|
|
|
// Read Lua code to restore gamevar values from the savegame and run it.
|
|
|
|
|
|
|
|
char header[12];
|
|
|
|
int32_t slen;
|
|
|
|
|
|
|
|
if (kread(fil, header, 12) != 12)
|
|
|
|
{
|
|
|
|
OSD_Printf("doloadplayer2: failed reading Lunatic gamevar header.\n");
|
|
|
|
return -100;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Bmemcmp(header, "\0\1LunaGVAR\3\4", 12))
|
|
|
|
{
|
|
|
|
OSD_Printf("doloadplayer2: Lunatic gamevar header doesn't match.\n");
|
|
|
|
return -101;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (kread(fil, &slen, sizeof(slen)) != sizeof(slen))
|
|
|
|
{
|
|
|
|
OSD_Printf("doloadplayer2: failed reading Lunatic gamevar string size.\n");
|
|
|
|
return -102;
|
|
|
|
}
|
|
|
|
|
|
|
|
slen = B_LITTLE32(slen);
|
|
|
|
if (slen < 0)
|
|
|
|
{
|
|
|
|
OSD_Printf("doloadplayer2: invalid Lunatic gamevar string size %d.\n", slen);
|
|
|
|
return -103;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (slen > 0)
|
|
|
|
{
|
|
|
|
char *svcode = Bmalloc(slen);
|
|
|
|
if (svcode == NULL)
|
|
|
|
G_GameExit("OUT OF MEMORY in doloadplayer2().");
|
|
|
|
|
|
|
|
if (kread(fil, svcode, slen) != slen)
|
|
|
|
{
|
|
|
|
OSD_Printf("doloadplayer2: failed reading Lunatic gamevar restoration code.\n");
|
|
|
|
return -104;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (L_RunString(&g_ElState, svcode, 0, slen, "luaload"))
|
|
|
|
{
|
|
|
|
OSD_Printf("doloadplayer2: failed restoring Lunatic gamevars.\n");
|
|
|
|
return -105;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
if (memptr)
|
|
|
|
*memptr = mem;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t sv_updatestate(int32_t frominit)
|
|
|
|
{
|
|
|
|
uint8_t *p = svsnapshot, *pbeg=p;
|
|
|
|
|
|
|
|
if (frominit)
|
|
|
|
Bmemcpy(svsnapshot, svinitsnap, svsnapsiz);
|
|
|
|
|
|
|
|
if (readspecdata(svgm_udnetw, -1, &p)) return -2;
|
|
|
|
if (readspecdata(svgm_secwsp, -1, &p)) return -4;
|
|
|
|
if (readspecdata(svgm_script, -1, &p)) return -5;
|
|
|
|
if (readspecdata(svgm_anmisc, -1, &p)) return -6;
|
|
|
|
|
2013-05-19 19:29:18 +00:00
|
|
|
#if !defined LUNATIC
|
2010-01-24 23:33:17 +00:00
|
|
|
if (readspecdata(svgm_vars, -1, &p)) return -8;
|
2013-05-19 19:29:18 +00:00
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
if (p != pbeg+svsnapsiz)
|
2011-12-25 15:32:00 +00:00
|
|
|
{
|
2010-01-24 23:33:17 +00:00
|
|
|
OSD_Printf("sv_updatestate: ptr-(snapshot end)=%d\n", (int32_t)(p-(pbeg+svsnapsiz)));
|
2011-12-25 15:32:00 +00:00
|
|
|
return -9;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
if (frominit)
|
2011-12-25 15:34:06 +00:00
|
|
|
postloadplayer(0);
|
|
|
|
#ifdef POLYMER
|
2012-12-30 20:34:34 +00:00
|
|
|
if (getrendermode() == REND_POLYMER)
|
2011-12-25 15:34:06 +00:00
|
|
|
polymer_resetlights(); // must do it after polymer_loadboard() !!!
|
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
static void postloadplayer(int32_t savegamep)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
|
|
|
int32_t i;
|
2011-12-25 15:34:06 +00:00
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
//1
|
|
|
|
if (g_player[myconnectindex].ps->over_shoulder_on != 0)
|
|
|
|
{
|
2013-01-19 18:28:32 +00:00
|
|
|
CAMERADIST = 0;
|
|
|
|
CAMERACLOCK = 0;
|
2010-01-24 23:33:17 +00:00
|
|
|
g_player[myconnectindex].ps->over_shoulder_on = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
//2
|
2011-12-25 15:34:06 +00:00
|
|
|
screenpeek = myconnectindex;
|
|
|
|
|
|
|
|
//2.5
|
|
|
|
if (savegamep)
|
|
|
|
{
|
|
|
|
Bmemset(gotpic, 0, sizeof(gotpic));
|
|
|
|
S_ClearSoundLocks();
|
|
|
|
G_CacheMapData();
|
|
|
|
|
|
|
|
i = g_musicIndex;
|
|
|
|
g_musicIndex = (ud.volume_number*MAXLEVELS) + ud.level_number;
|
|
|
|
|
|
|
|
if (boardfilename[0] != 0 && ud.level_number == 7 && ud.volume_number == 0)
|
|
|
|
{
|
|
|
|
char levname[BMAX_PATH];
|
|
|
|
|
|
|
|
G_SetupFilenameBasedMusic(levname, boardfilename, ud.level_number);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ud.config.MusicToggle)
|
|
|
|
{
|
2012-06-04 22:01:45 +00:00
|
|
|
if (MapInfo[g_musicIndex].musicfn != NULL &&
|
2011-12-25 15:34:06 +00:00
|
|
|
(i != g_musicIndex || MapInfo[MAXVOLUMES*MAXLEVELS+2].alt_musicfn))
|
|
|
|
{
|
|
|
|
S_StopMusic();
|
2012-06-04 22:01:45 +00:00
|
|
|
S_PlayMusic(&MapInfo[g_musicIndex].musicfn[0], g_musicIndex);
|
2011-12-25 15:34:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
S_PauseMusic(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_player[myconnectindex].ps->gm = MODE_GAME;
|
|
|
|
ud.recstat = 0;
|
|
|
|
|
|
|
|
if (g_player[myconnectindex].ps->jetpack_on)
|
|
|
|
A_PlaySound(DUKE_JETPACK_IDLE, g_player[myconnectindex].ps->i);
|
|
|
|
}
|
|
|
|
|
2010-01-24 23:33:17 +00:00
|
|
|
//3
|
|
|
|
P_UpdateScreenPal(g_player[myconnectindex].ps);
|
2012-02-02 17:34:16 +00:00
|
|
|
g_restorePalette = -1;
|
2011-12-25 15:34:06 +00:00
|
|
|
|
|
|
|
//3.5
|
|
|
|
if (savegamep)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2012-11-13 10:50:06 +00:00
|
|
|
for (SPRITES_OF(STAT_FX, i))
|
2012-10-14 22:13:49 +00:00
|
|
|
if (sprite[i].picnum == MUSICANDSFX)
|
|
|
|
{
|
|
|
|
T2 = ud.config.SoundToggle;
|
|
|
|
T1 = 0;
|
|
|
|
}
|
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
G_UpdateScreenArea();
|
|
|
|
FX_SetReverb(0);
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
2011-12-25 15:34:06 +00:00
|
|
|
|
|
|
|
//4
|
|
|
|
if (savegamep)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2012-01-05 20:48:37 +00:00
|
|
|
if (ud.lockout)
|
2011-12-25 15:34:06 +00:00
|
|
|
{
|
|
|
|
for (i=0; i<g_numAnimWalls; i++)
|
2012-01-28 14:38:23 +00:00
|
|
|
switch (DYNAMICTILEMAP(wall[animwall[i].wallnum].picnum))
|
2011-12-25 15:34:06 +00:00
|
|
|
{
|
|
|
|
case FEMPIC1__STATIC:
|
|
|
|
wall[animwall[i].wallnum].picnum = BLANKSCREEN;
|
|
|
|
break;
|
|
|
|
case FEMPIC2__STATIC:
|
|
|
|
case FEMPIC3__STATIC:
|
|
|
|
wall[animwall[i].wallnum].picnum = SCREENBREAK6;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-01-05 20:48:37 +00:00
|
|
|
#if 0
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (i=0; i<g_numAnimWalls; i++)
|
|
|
|
if (wall[animwall[i].wallnum].extra >= 0)
|
|
|
|
wall[animwall[i].wallnum].picnum = wall[animwall[i].wallnum].extra;
|
|
|
|
}
|
|
|
|
#endif
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//5
|
2011-07-29 22:07:28 +00:00
|
|
|
G_ResetInterpolations();
|
2010-01-24 23:33:17 +00:00
|
|
|
|
|
|
|
//6
|
|
|
|
g_showShareware = 0;
|
2011-12-25 15:34:06 +00:00
|
|
|
if (savegamep)
|
|
|
|
everyothertime = 0;
|
2011-12-21 18:42:12 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
//7
|
2010-01-24 23:33:17 +00:00
|
|
|
for (i=0; i<MAXPLAYERS; i++)
|
2011-12-21 18:42:12 +00:00
|
|
|
g_player[i].playerquitflag = 1;
|
2010-01-24 23:33:17 +00:00
|
|
|
|
2011-12-25 15:34:06 +00:00
|
|
|
// ----------
|
|
|
|
|
|
|
|
//7.5
|
|
|
|
if (savegamep)
|
|
|
|
{
|
|
|
|
ready2send = 1;
|
|
|
|
G_ClearFIFO();
|
|
|
|
Net_WaitForServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
//8
|
|
|
|
// if (savegamep) ?
|
2010-01-24 23:33:17 +00:00
|
|
|
G_ResetTimers();
|
|
|
|
|
|
|
|
#ifdef POLYMER
|
2011-12-25 15:34:06 +00:00
|
|
|
//9
|
2012-12-30 20:34:34 +00:00
|
|
|
if (getrendermode() == REND_POLYMER)
|
2010-01-25 01:11:34 +00:00
|
|
|
polymer_loadboard();
|
2010-01-24 23:33:17 +00:00
|
|
|
#elif 0
|
2012-12-30 20:34:34 +00:00
|
|
|
if (getrendermode() == REND_POLYMER)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
|
|
|
int32_t i = 0;
|
|
|
|
|
|
|
|
polymer_loadboard();
|
|
|
|
while (i < MAXSPRITES)
|
|
|
|
{
|
2010-05-02 23:27:30 +00:00
|
|
|
if (actor[i].lightptr)
|
2010-01-24 23:33:17 +00:00
|
|
|
{
|
2010-05-02 23:27:30 +00:00
|
|
|
polymer_deletelight(actor[i].lightId);
|
|
|
|
actor[i].lightptr = NULL;
|
|
|
|
actor[i].lightId = -1;
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2011-12-25 15:34:06 +00:00
|
|
|
// this light pointer nulling needs to be outside the getrendermode check
|
|
|
|
// because we might be loading the savegame using another renderer but
|
|
|
|
// change to Polymer later
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
|
|
{
|
|
|
|
actor[i].lightptr = NULL;
|
|
|
|
actor[i].lightId = -1;
|
|
|
|
}
|
2010-01-24 23:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
////////// END GENERIC SAVING/LOADING SYSTEM //////////
|