WebSVN – eduke32 – Diff – /polymer/eduke32/source/savegame.c


//-------------------------------------------------------------------------
/*
Copyright (C) 2010 EDuke32 developers and contributors

This file is part of EDuke32.

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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/
//-------------------------------------------------------------------------

#include "duke3d.h"
#include "premap.h"
#include "menus.h"  // menutext
#include "prlights.h"
#include "savegame.h"
#ifdef LUNATIC
# include "lunatic_game.h"
static int32_t g_savedOK;
const char *g_failedVarname;
#endif

extern char *bitptr;

uint8_t g_oldverSavegame[MAXSAVEGAMES];

#define BITPTR_POINTER 1

// For storing pointers in files.
//  back_p==0: ptr -> "small int"
//  back_p==1: "small int" -> ptr
//
//  mode: see enum in savegame.h
void G_Util_PtrToIdx(void *ptr, int32_t const count, const void *base, int32_t const mode)
{
    intptr_t *iptr = (intptr_t *)ptr;
    intptr_t const ibase = (intptr_t)base;
    int32_t const 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.

    // WARNING: C std doesn't say that bit pattern of NULL is necessarily 0!
    if ((mode & P2I_BACK_BIT) == 0)
    {
        for (int i = 0; i < count; i++)
            if (!onlynon0_p || iptr[i])
                iptr[i] -= ibase;
    }
    else
    {
        for (int i = 0; i < count; i++)
            if (!onlynon0_p || iptr[i])
                iptr[i] += ibase;
    }
}

void G_Util_PtrToIdx2(void *ptr, int32_t const count, size_t const stride, const void *base, int32_t const mode)
{
    uint8_t *iptr = (uint8_t *)ptr;
    intptr_t const ibase = (intptr_t)base;
    int32_t const onlynon0_p = mode&P2I_ONLYNON0_BIT;

    if ((mode & P2I_BACK_BIT) == 0)
    {
        for (int i = 0; i < count; ++i)
        {
            if (!onlynon0_p || *(intptr_t *)iptr)
                *(intptr_t *)iptr -= ibase;

            iptr += stride;
        }
    }
    else
    {
        for (int i = 0; i < count; ++i)
        {
            if (!onlynon0_p || *(intptr_t *)iptr)
                *(intptr_t *)iptr += ibase;

            iptr += stride;
        }
    }
}

// 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)
        {
        case SE_31_FLOOR_RISE_FALL:
            G_SetInterpolation(&sector[sprite[k].sectnum].floorz);
            break;
        case SE_32_CEILING_RISE_FALL:
            G_SetInterpolation(&sector[sprite[k].sectnum].ceilingz);
            break;
        case SE_17_WARP_ELEVATOR:
        case SE_25_PISTON:
            G_SetInterpolation(&sector[sprite[k].sectnum].floorz);
            G_SetInterpolation(&sector[sprite[k].sectnum].ceilingz);
            break;
        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:
        case SE_16_REACTOR:
        case SE_26:
        case SE_30_TWO_WAY_TRAIN:
            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]);
}

void ReadSaveGameHeaders(void)
{
    char fn[16];
    int32_t fil, i;

    savehead_t h;

    EDUKE32_STATIC_ASSERT(sizeof(h.savename) == sizeof(ud.savegame[0]));

    Bstrcpy(fn, "dukesav0.esv");

    for (i=0; i<MAXSAVEGAMES; 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)
        {
            // old version, signal to menu code
            if (k==2 || k==3)
                g_oldverSavegame[i] = 1;
            // 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];
    int32_t fil, screenshotofs, i;

    Bassert(spot < MAXSAVEGAMES);

    Bstrcpy(fn, "dukesav0.esv");
    fn[7] = spot + '0';

    fil = kopen4loadfrommod(fn, 0);
    if (fil == -1)
        return -1;

    i = sv_loadheader(fil, spot, saveh);
    if (i && (i != 2 && i != 3))
        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]);
    tilesiz[TILE_LOADSHOT].x = 200;
    tilesiz[TILE_LOADSHOT].y = 320;
    if (screenshotofs)
    {
        if (kdfread((char *)waloff[TILE_LOADSHOT], 320, 200, fil) != 200)
        {
            OSD_Printf("G_LoadSaveHeaderNew(%d): failed reading screenshot\n", spot);
            goto corrupt;
        }
    }
    else
    {
        Bmemset((char *)waloff[TILE_LOADSHOT], 0, 320*200);
    }
    invalidatetile(TILE_LOADSHOT, 0, 255);

    kclose(fil);
    return 0;

corrupt:
    kclose(fil);
    return 1;
}


static void sv_postudload();

// XXX: keyboard input 'blocked' after load fail? (at least ESC?)
int32_t G_LoadPlayer(int32_t spot)
{
    char fn[16];
    int32_t fil, i;

    savehead_t h;

    Bassert(spot < MAXSAVEGAMES);

    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 && i != 2) || 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;

    {
        // NOTE: Bmemcpy needed for SAVEGAME_MUSIC.
        EDUKE32_STATIC_ASSERT(sizeof(boardfilename) == sizeof(h.boardfn));
        Bmemcpy(boardfilename, h.boardfn, sizeof(boardfilename));
    }

    E_MapArt_Setup(h.boardfn);  // XXX: Better after the following filename tweaking?

    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])
    {
        append_ext_UNSAFE(currentboardfilename, ".mhk");
        loadmaphack(currentboardfilename);
    }

    Bmemcpy(currentboardfilename, boardfilename, BMAX_PATH);

    if (i == 2)
    {
        G_NewGame_EnterLevel();
    }
    else
    {
        // 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

    VM_OnEvent(EVENT_LOADGAME, g_player[myconnectindex].ps->i, myconnectindex);

    return 0;
}

////////// TIMER SAVING/RESTORING //////////

static struct {
    int32_t totalclock, totalclocklock;  // engine
    int32_t ototalclock, lockclock;  // game
} g_timers;

static void G_SaveTimers(void)
{
    g_timers.totalclock = totalclock;
    g_timers.totalclocklock = totalclocklock;
    g_timers.ototalclock = ototalclock;
    g_timers.lockclock = lockclock;
}

static void G_RestoreTimers(void)
{
    sampletimer();

    totalclock = g_timers.totalclock;
    totalclocklock = g_timers.totalclocklock;
    ototalclock = g_timers.ototalclock;
    lockclock = g_timers.lockclock;
}

//////////

#ifdef __ANDROID__
static void G_SavePalette(void)
{
    int32_t pfil;

    if ((pfil = kopen4load("palette.dat", 0)) != -1)
    {
        int len = kfilelength(pfil);

        FILE *fil = fopen("palette.dat", "rb");

        if (!fil)
        {
            fil = fopen("palette.dat", "wb");

            if (fil)
            {
                char *buf = (char *) Xaligned_alloc(16, len);

                kread(pfil, buf, len);
                fwrite(buf, len, 1, fil);
                fclose(fil);
            }
        }
        else fclose(fil);
    }
}
#endif

int32_t G_SavePlayer(int32_t spot)
{
    char fn[16];
    FILE *fil;

#ifdef __ANDROID__
    G_SavePalette();
#endif

    Bassert(spot < MAXSAVEGAMES);

    G_SaveTimers();

    Bstrcpy(fn, "dukesav0.esv");
    fn[7] = spot + '0';

//    Bstrcpy(mpfn, "edukA_00.esv");

    Net_WaitForServer();
    ready2send = 0;

    {
        char temp[BMAX_PATH];

        if (G_ModDirSnprintf(temp, sizeof(temp), "%s", fn))
        {
            OSD_Printf("G_SavePlayer: file name \"%s\" too long\n", fn);
            return -1;
        }

        errno = 0;
        fil = fopen(temp, "wb");
        if (!fil)
        {
            OSD_Printf("G_SavePlayer: failed opening \"%s\" for writing: %s\n",
                       temp, strerror(errno));
            return -1;
        }
    }

#ifdef POLYMER
    if (getrendermode() == REND_POLYMER)
        polymer_resetlights();
#endif

    VM_OnEvent(EVENT_SAVEGAME, g_player[myconnectindex].ps->i, myconnectindex);

    // SAVE!
    sv_saveandmakesnapshot(fil, spot, 0, 0, 0);

    fclose(fil);

    if (!g_netServer && ud.multimode < 2)
    {
#ifdef LUNATIC
        if (!g_savedOK)
            Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "^10Failed Saving Game");
        else
#endif
            Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Game Saved");
        P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
    }

    ready2send = 1;
    Net_WaitForServer();

    G_RestoreTimers();
    ototalclock = totalclock;

    return 0;
}

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);

    CONFIG_WriteSetup(2);

    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);
    }
}

////////// 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
#define DS_NOCHK 1024  // don't check for diffs (and don't write out in dump) since assumed constant throughout demo
#define DS_PROTECTFN 512
#define DS_END (0x70000000)

static int32_t ds_getcnt(const dataspec_t *sp)
{
    int rv = -1;

    switch (sp->flags & DS_CNTMASK)
    {
        case 0: rv = sp->cnt; break;
        case DS_CNT16: rv = *((int16_t *)sp->cnt); break;
        case DS_CNT32: rv = *((int32_t *)sp->cnt); break;
    }

    return rv;
}

static inline void ds_get(const dataspec_t *sp, void **ptr, int32_t *cnt)
{
    *cnt = ds_getcnt(sp);
    *ptr = (sp->flags&DS_DYNAMIC) ? *((void **)sp->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;
    void *ptr;
    const dataspec_t *sp=spec;

    for (; sp->flags!=DS_END; sp++)
    {
        if (sp->flags&(DS_SAVEFN|DS_LOADFN))
        {
            if (sp->flags&DS_SAVEFN)
                (*(void (*)(void))sp->ptr)();
            continue;
        }

        if (!fil && (sp->flags&(DS_NOCHK|DS_CMP|DS_STRING)))
            continue;

        if (sp->flags&DS_STRING)
        {
            fwrite(sp->ptr, Bstrlen((const char *)sp->ptr), 1, fil);  // not null-terminated!
            continue;
        }

        ds_get(sp, &ptr, &cnt);
        if (cnt < 0) { OSD_Printf("wsd: cnt=%d, f=0x%x.\n",cnt,sp->flags); continue; }

        if (fil)
        {
            if (((sp->flags&DS_CNTMASK)==0 && sp->size*cnt<=savegame_comprthres)
                    || (sp->flags&DS_CMP))
                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)
                (*(void (*)())sp->ptr)();
            continue;
        }

        if (sp->flags&(DS_STRING|DS_CMP))  // DS_STRING and DS_CMP is for static data only
        {
            if (sp->flags&(DS_STRING))
                i = Bstrlen((const char *)sp->ptr);
            else
                i = sp->size*sp->cnt;

            j=kread(fil, cmpstrbuf, i);
            if (j!=i || Bmemcmp(sp->ptr, cmpstrbuf, i))
            {
                OSD_Printf("rsd: spec=%s, idx=%d:\n", (char *)spec->ptr, (int32_t)(sp-spec));
                if (j!=i)
                    OSD_Printf("    kread returned %d, expected %d.\n", j, i);
                else
                    OSD_Printf("    sp->ptr and cmpstrbuf not identical!\n");
                return -1;
            }
            continue;
        }

        ds_get(sp, &ptr, &cnt);
        if (cnt < 0) { OSD_Printf("rsd: cnt<0... wtf?\n"); return -1; }

        if (fil>=0)
        {
            mem = (dump && (sp->flags&DS_NOCHK)==0) ? dump : (uint8_t *)ptr;

            if ((sp->flags&DS_CNTMASK)==0 && sp->size*cnt<=savegame_comprthres)
            {
                i = kread(fil, mem, cnt*sp->size);
                j = cnt*sp->size;
            }
            else
            {
                i = kdfread(mem, sp->size, cnt, fil);
                j = cnt;
            }
            if (i!=j)
            {
                OSD_Printf("rsd: spec=%s, idx=%d, mem=%p\n", (char *)spec->ptr, (int32_t)(sp-spec), mem);
                OSD_Printf("     (%s): read %d, expected %d!\n",
                           ((sp->flags&DS_CNTMASK)==0 && sp->size*cnt<=savegame_comprthres)?
                           "uncompressed":"compressed", i, j);

                if (i==-1)
                    OSD_Printf("     read: %s\n", strerror(errno));
                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!
#define CPSINGLEVAL(Datbits) \
        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;
        }

#define CPELTS(Idxbits, Datbits) do \
    {                                         \
        for (i=0; i<nelts; i++)               \
        {                                     \
            if (*p!=*op)                      \
            {                                 \
                *op = *p;      \
                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)

#define CPDATA(Datbits) do \
    { \
        const UINT(Datbits) *p=(UINT(Datbits) *)ptr;    \
        UINT(Datbits) *op=(UINT(Datbits) *)dump;        \
        uint32_t i, nelts=tabledivide32_noinline(size*cnt, BYTES(Datbits));    \
        if (nelts>65536)                                \
            CPELTS(32,Datbits);                         \
        else if (nelts>256)                             \
            CPELTS(16,Datbits);                         \
        else                                            \
            CPELTS(8,Datbits);                          \
    } 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;

#undef CPELTS
#undef CPSINGLEVAL
#undef CPDATA
}

// get the number of elements to be monitored for changes
static int32_t getnumvar(const dataspec_t *spec)
{
    int32_t n=0;
    for (; spec->flags!=DS_END; spec++)
        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)
{
    void *ptr;
    uint8_t *dump=*dumpvar, *diff=*diffvar, *tmptr;
    const dataspec_t *sp=spec;
    int32_t cnt, eltnum=0, nbytes=(getnumvar(spec)+7)>>3, l=Bstrlen((const char *)spec->ptr);

    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;

        if (sp->flags&(DS_LOADFN|DS_SAVEFN))
        {
            if ((sp->flags&(DS_PROTECTFN))==0)
                (*(void (*)())sp->ptr)();
            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;
    int32_t cnt, eltnum=-1, nbytes=(getnumvar(spec)+7)>>3, l=Bstrlen((const char *)spec->ptr);

    if (Bmemcmp(diffptr, spec->ptr, l))  // check STRING magic (sync check)
        return 1;

    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;
        }

// ----------
#define CPSINGLEVAL(Datbits) \
            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;
            }
        }

#define CPELTS(Idxbits, Datbits) do \
        {                                    \
            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)

#define CPDATA(Datbits) do \
        {                             \
            uint32_t nelts=tabledivide32_noinline(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;
// ----------

#undef CPELTS
#undef CPSINGLEVAL
#undef CPDATA
    }

    *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;
}

#ifdef USE_OPENGL
static void sv_prespriteextsave();
static void sv_postspriteext();
#endif
#if !defined LUNATIC
static void sv_calcbitptrsize();
static void sv_prescriptsave_once();
static void sv_prescriptload_once();
static void sv_postscript_once();
#else
// Recreate Lua state.
// XXX: It may matter a great deal when this is run from if the Lua code refers
// to C-side data at file scope. Such usage is strongly discouraged though.
static void sv_create_lua_state(void)
{
    El_CreateGameState();
    G_PostCreateGameState();
}
#endif
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) \
      +sizeof(g_player[0].frags)+sizeof(DukePlayer_t))*MAXPLAYERS)

#if !defined LUNATIC
static uint32_t savegame_bitptrsize;
#endif
static uint8_t savegame_quotedef[MAXQUOTES>>3];
static char(*savegame_quotes)[MAXQUOTELEN];
static char(*savegame_quoteredefs)[MAXQUOTELEN];
static uint8_t savegame_restdata[SVARDATALEN];

static const dataspec_t svgm_udnetw[] =
{
    { DS_STRING, (void *)"blK:udnt", 0, 1 },
    { 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 },
    { 0, &ud.pause_on, sizeof(ud.pause_on), 1 },
    { DS_NOCHK, &currentboardfilename[0], BMAX_PATH, 1 },
//    { DS_LOADFN, (void *)&sv_postudload, 0, 1 },
    { 0, connectpoint2, sizeof(connectpoint2), 1 },
    { 0, &randomseed, sizeof(randomseed), 1 },
    { 0, &g_globalRandom, sizeof(g_globalRandom), 1 },
#ifdef LUNATIC
    // Save game tic count for Lunatic because it is exposed to userland. See
    // test/helixspawner.lua for an example.
    { 0, &g_moveThingsCount, sizeof(g_moveThingsCount), 1 },
#endif
//    { 0, &lockclock_dummy, sizeof(lockclock), 1 },
    { DS_END, 0, 0, 0 }
};

#if !defined DEBUG_MAIN_ARRAYS
# define DS_MAINAR DS_DYNAMIC
#else
# define DS_MAINAR 0
#endif

static const dataspec_t svgm_secwsp[] =
{
    { DS_STRING, (void *)"blK:swsp", 0, 1 },
    { DS_NOCHK, &numwalls, sizeof(numwalls), 1 },
    { DS_MAINAR|DS_CNT(numwalls), &wall, sizeof(walltype), (intptr_t)&numwalls },
    { DS_NOCHK, &numsectors, sizeof(numsectors), 1 },
    { DS_MAINAR|DS_CNT(numsectors), &sector, sizeof(sectortype), (intptr_t)&numsectors },
    { DS_MAINAR, &sprite, sizeof(spritetype), MAXSPRITES },
#ifdef YAX_ENABLE
    { DS_NOCHK, &numyaxbunches, sizeof(numyaxbunches), 1 },
# if !defined NEW_MAP_FORMAT
    { DS_CNT(numsectors), yax_bunchnum, sizeof(yax_bunchnum[0]), (intptr_t)&numsectors },
    { DS_CNT(numwalls), yax_nextwall, sizeof(yax_nextwall[0]), (intptr_t)&numwalls },
# endif
    { DS_LOADFN|DS_PROTECTFN, (void *)&sv_postyaxload, 0, 1 },
#endif
    { 0, &Numsprites, sizeof(Numsprites), 1 },
    { 0, &tailspritefree, sizeof(tailspritefree), 1 },
    { 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 },
#ifdef USE_OPENGL
    { DS_SAVEFN, (void *)&sv_prespriteextsave, 0, 1 },
#endif
    { DS_MAINAR, &spriteext, sizeof(spriteext_t), MAXSPRITES },
#ifdef USE_OPENGL
    { DS_SAVEFN|DS_LOADFN, (void *)&sv_postspriteext, 0, 1 },
#endif
    { 0, &DynamicTileMap[0], sizeof(DynamicTileMap[0]), MAXTILES },  // NOCHK?
    { 0, &DynamicSoundMap[0], sizeof(DynamicSoundMap[0]), MAXSOUNDS },  // NOCHK?
    { 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]), ARRAY_SIZE(g_mirrorWall) },
    { DS_NOCHK, &g_mirrorSector[0], sizeof(g_mirrorSector[0]), ARRAY_SIZE(g_mirrorSector) },
// projectiles
    { 0, &SpriteProjectile[0], sizeof(projectile_t), MAXSPRITES },
    { 0, &ProjectileData[0], sizeof(projectile_t), MAXTILES },
    { 0, &everyothertime, sizeof(everyothertime), 1 },
    { DS_END, 0, 0, 0 }
};

static const dataspec_t svgm_script[] =
{
    { DS_STRING, (void *)"blK:scri", 0, 1 },
#if !defined LUNATIC
    { 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 },
#endif
    { DS_NOCHK, &g_tile[0], sizeof(tiledata_t), MAXTILES },
#if !defined LUNATIC
    { DS_LOADFN|DS_NOCHK, (void *)&sv_prescriptload_once, 0, 1 },
    { 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 },
#endif
    { DS_SAVEFN, (void *)&sv_preactordatasave, 0, 1 },
    { 0, &actor[0], sizeof(actor_t), MAXSPRITES },
    { DS_SAVEFN|DS_LOADFN, (void *)&sv_postactordata, 0, 1 },
#if defined LUNATIC
    { DS_LOADFN|DS_NOCHK, (void *)&sv_create_lua_state, 0, 1 },
#endif
    { DS_END, 0, 0, 0 }
};

static const dataspec_t svgm_anmisc[] =
{
    { DS_STRING, (void *)"blK:anms", 0, 1 },
    { 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, &g_curViewscreen, sizeof(g_curViewscreen), 1 },
    { 0, &msx[0], sizeof(msx[0]), ARRAY_SIZE(msx) },
    { 0, &msy[0], sizeof(msy[0]), ARRAY_SIZE(msy) },
    { 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 },
    { 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 },
    { 0, &g_pskyidx, sizeof(g_pskyidx), 1 },  // DS_NOCHK?
    { 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 },
#ifdef LUNATIC
    { 0, g_playerWeapon, sizeof(weapondata_t), MAXPLAYERS*MAX_WEAPONS },
#endif
    { 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 },

    { DS_STRING, (void *)"savegame_end", 0, 1 },
    { DS_END, 0, 0, 0 }
};

#if !defined LUNATIC
static dataspec_t *svgm_vars=NULL;
#endif
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);

// SVGM snapshot system
static uint32_t svsnapsiz;
static uint8_t *svsnapshot, *svinitsnap;
static uint32_t svdiffsiz;
static uint8_t *svdiff;

#include "gamedef.h"

#if !defined LUNATIC
# define SV_SKIPMASK (/*GAMEVAR_SYSTEM|*/GAMEVAR_READONLY|GAMEVAR_INTPTR|    \
                      GAMEVAR_SHORTPTR|GAMEVAR_CHARPTR /*|GAMEVAR_NORESET*/ |GAMEVAR_SPECIAL)
// 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, numsavedarrays=0, per;

    for (i=0; i<g_gameVarCount; i++)
        numsavedvars += (aGameVars[i].dwFlags&SV_SKIPMASK) ? 0 : 1;

    for (i=0; i<g_gameArrayCount; i++)
        numsavedarrays += !(aGameArrays[i].dwFlags & GAMEARRAY_READONLY);  // SYSTEM_GAMEARRAY

    Bfree(svgm_vars);
    svgm_vars = (dataspec_t *)Xmalloc((numsavedvars+numsavedarrays+2)*sizeof(dataspec_t));

    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++)
    {
        // We must not update read-only SYSTEM_GAMEARRAY gamearrays: besides
        // being questionable by itself, sizeof(...) may be e.g. 4 whereas the
        // actual element type is int16_t (such as tilesizx[]/tilesizy[]).
        if (aGameArrays[i].dwFlags & GAMEARRAY_READONLY)
            continue;

        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;
    svgm_vars[j].ptr = NULL;
    svgm_vars[j].size = svgm_vars[j].cnt = 0;
}
#endif

void sv_freemem()
{
    DO_FREE_AND_NULL(svsnapshot);
    DO_FREE_AND_NULL(svinitsnap);
    DO_FREE_AND_NULL(svdiff);
}

static void SV_AllocSnap(int32_t allocinit)
{
    sv_freemem();

    svsnapshot = (uint8_t *)Xmalloc(svsnapsiz);
    if (allocinit)
        svinitsnap = (uint8_t *)Xmalloc(svsnapsiz);
    svdiffsiz = svsnapsiz;  // theoretically it's less than could be needed in the worst case, but practically it's overkill
    svdiff = (uint8_t *)Xmalloc(svdiffsiz);
}

EDUKE32_STATIC_ASSERT(sizeof(savehead_t) == SAVEHEAD_SIZE);

// 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;

    // set a few savegame system globals
    savegame_comprthres = SV_DEFAULTCOMPRTHRES;
    savegame_diffcompress = diffcompress;

    // calculate total snapshot size
#if !defined LUNATIC
    sv_makevarspec();
    svsnapsiz = calcsz(svgm_vars);
#else
    svsnapsiz = 0;
#endif
    svsnapsiz += calcsz(svgm_udnetw) + calcsz(svgm_secwsp) + calcsz(svgm_script) + calcsz(svgm_anmisc);


    // 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;

    if (currentboardfilename[0] != 0 && ud.level_number == 7 && ud.volume_number == 0)
    {
        const uint32_t BSZ = sizeof(h.boardfn);
        EDUKE32_STATIC_ASSERT(BSZ == sizeof(currentboardfilename));

        Bstrncpy(h.boardfn, currentboardfilename, BSZ);

        // Shoehorn currently playing music into last bytes of board name buffer.
        // SAVEGAME_MUSIC.
        if (g_musicIndex != (0*MAXLEVELS+7) && Bstrlen(h.boardfn) < BSZ-2)
        {
            h.boardfn[BSZ-2] = g_musicIndex / MAXLEVELS;
            h.boardfn[BSZ-1] = g_musicIndex % MAXLEVELS;
        }
    }

    if ((unsigned)spot < MAXSAVEGAMES)
    {
        // savegame
        Bstrncpyz(h.savename, ud.savegame[spot], sizeof(h.savename));
#ifdef __ANDROID__
        Bstrncpyz(h.volname, EpisodeNames[ud.volume_number], sizeof(h.volname));
        Bstrncpyz(h.skillname, SkillNames[ud.player_skill], sizeof(h.skillname));
#endif
    }
    else
    {
        // demo

        const time_t t=time(NULL);
        struct tm *st;

        Bstrncpyz(h.savename, "EDuke32 demo", sizeof(h.savename));
        if (t>=0 && (st = localtime(&t)))
            Bsnprintf(h.savename, sizeof(h.savename), "Demo %04d%02d%02d %s",
                      st->tm_year+1900, st->tm_mon+1, st->tm_mday, s_buildRev);
    }


    // 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);
#ifdef LUNATIC
        if (!g_savedOK)
        {
            OSD_Printf("sv_saveandmakesnapshot: failed serializing Lunatic gamevar \"%s\".\n",
                       g_failedVarname);
            g_failedVarname = NULL;
            return 1;
        }
#endif
    }
    else
    {
        uint8_t *p;

        // demo
        SV_AllocSnap(0);

        p = dosaveplayer2(fil, svsnapshot);
        if (p != svsnapshot+svsnapsiz)
        {
            OSD_Printf("sv_saveandmakesnapshot: ptr-(snapshot end)=%d!\n", (int32_t)(p-(svsnapshot+svsnapsiz)));
            return 1;
        }
    }

    g_oldverSavegame[spot] = 0;

    return 0;
}

EDUKE32_STATIC_ASSERT(sizeof(savehead_t) == SAVEHEAD_SIZE);

// 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)
{
    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;
    }

    if (Bmemcmp(h->headerstr, "EDuke32SAVE", 11))
    {
        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));
        return 1;
    }

    if (h->majorver != SV_MAJOR_VER || h->minorver != SV_MINOR_VER || h->bytever != BYTEVERSION)
    {
        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);
        return 2;
    }

    if (h->ptrsize != sizeof(intptr_t))
    {
        if (havedemo)
            OSD_Printf("Demo incompatible. Expected pointer size %d, found %d\n",
                       (int32_t)sizeof(intptr_t), h->ptrsize);
        return 3;
    }

    return 0;
}

int32_t sv_loadsnapshot(int32_t fil, int32_t spot, savehead_t *h)
{
    uint8_t *p;
    int32_t i;

    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)

#ifdef DEBUGGINGAIDS
    OSD_Printf("sv_loadsnapshot: snapshot size: %d bytes.\n", h->snapsiz);
#endif

    if (kread(fil, &i, 4) != 4)
    {
        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;
        }
    }

    savegame_comprthres = h->comprthres;

    if (spot >= 0)
    {
        // savegame
        i = doloadplayer2(fil, NULL);
        if (i)
        {
            OSD_Printf("sv_loadsnapshot: doloadplayer2() returned %d.\n", i);
            return 5;
        }
    }
    else
    {
        // demo
        savegame_diffcompress = h->diffcompress;

        svsnapsiz = h->snapsiz;

        SV_AllocSnap(1);

        p = svsnapshot;
        i = doloadplayer2(fil, &p);
        if (i)
        {
            OSD_Printf("sv_loadsnapshot: doloadplayer2() returned %d.\n", i);
            sv_freemem();
            return 5;
        }

        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);
    }

    postloadplayer((spot >= 0));

    return 0;
}


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);
#if !defined LUNATIC
    cmpspecdata(svgm_vars, &p, &d);
#endif

    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];
    int32_t diffsiz;

#if 0  // handled by the caller
    if (kread(fil, tbuf, 4)!=4)
        return -1;
    if (Bmemcmp(tbuf, "dIfF", 4))
        return 4;
#endif
    if (kread(fil, &diffsiz, sizeof(uint32_t))!=sizeof(uint32_t))
        return -1;
    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;
    }

    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;
#if !defined LUNATIC
    if (applydiff(svgm_vars, &p, &d)) return -7;
#endif

    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;
}

// SVGM data description
static void sv_postudload()
{
//    Bmemcpy(&boardfilename[0], &currentboardfilename[0], BMAX_PATH);  // DON'T do this in demos!
#if 1
    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;
#endif
}
//static int32_t lockclock_dummy;

#ifdef USE_OPENGL
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

#ifdef YAX_ENABLE
void sv_postyaxload(void)
{
    yax_update(numyaxbunches>0 ? 2 : 1);
}
#endif

#if !defined LUNATIC
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)))
            script[i] = (intptr_t *)script[i] - script;

   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);
}
static void sv_prescriptload_once()
{
    if (script)
        Bfree(script);
    script = (intptr_t *)Xmalloc(g_scriptSize * sizeof(script[0]));
}
static void sv_postscript_once()
{
    int32_t i;

   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);

    for (i=0; i<g_scriptSize; i++)
        if (bitptr[i>>3]&(BITPTR_POINTER<<(i&7)))
            script[i] = (intptr_t)(script + script[i]);
}
#endif

static void sv_preactordatasave()
{
    int32_t i;

    for (i=0; i<MAXSPRITES; i++)
    {
        actor[i].lightptr = NULL;
        actor[i].lightId = -1;
    }
}

static void sv_postactordata()
{
    int32_t i;

    for (i=0; i<MAXSPRITES; i++)
    {
        actor[i].lightptr = NULL;
        actor[i].lightId = -1;
    }
}

static void sv_preanimateptrsave()
{
    G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_FWD);
}
static void sv_postanimateptr()
{
    G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_BACK);
}
static void sv_prequote()
{
    if (!savegame_quotes)
    {
        void *ptr = Xcalloc(MAXQUOTES, MAXQUOTELEN);
        savegame_quotes = (char(*)[MAXQUOTELEN])ptr;
    }
}
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)))
        {
            C_AllocQuote(i);
            Bmemcpy(ScriptQuotes[i], savegame_quotes[i], MAXQUOTELEN);
        }
    }
}
static void sv_prequoteredef()


Rev 4990	Rev 5069
1	//-------------------------------------------------------------------------	1	//-------------------------------------------------------------------------
2	/*	2	/*
3	Copyright (C) 2010 EDuke32 developers and contributors	3	Copyright (C) 2010 EDuke32 developers and contributors
4		4
5	This file is part of EDuke32.	5	This file is part of EDuke32.
6		6
7	EDuke32 is free software; you can redistribute it and/or	7	EDuke32 is free software; you can redistribute it and/or
8	modify it under the terms of the GNU General Public License version 2	8	modify it under the terms of the GNU General Public License version 2
9	as published by the Free Software Foundation.	9	as published by the Free Software Foundation.
10		10
11	This program is distributed in the hope that it will be useful,	11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14		14
15	See the GNU General Public License for more details.	15	See the GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.	19	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20	*/	20	*/
21	//-------------------------------------------------------------------------	21	//-------------------------------------------------------------------------
22		22
23	#include "duke3d.h"	23	#include "duke3d.h"
24	#include "premap.h"	24	#include "premap.h"
25	#include "menus.h" // menutext	25	#include "menus.h" // menutext
26	#include "prlights.h"	26	#include "prlights.h"
27	#include "savegame.h"	27	#include "savegame.h"
28	#ifdef LUNATIC	28	#ifdef LUNATIC
29	# include "lunatic_game.h"	29	# include "lunatic_game.h"
30	static int32_t g_savedOK;	30	static int32_t g_savedOK;
31	const char *g_failedVarname;	31	const char *g_failedVarname;
32	#endif	32	#endif
33		33
34	extern char *bitptr;	34	extern char *bitptr;
35		35
36	uint8_t g_oldverSavegame[MAXSAVEGAMES];	36	uint8_t g_oldverSavegame[MAXSAVEGAMES];
37		37
38	#define BITPTR_POINTER 1	38	#define BITPTR_POINTER 1
39		39
40	// For storing pointers in files.	40	// For storing pointers in files.
41	// back_p==0: ptr -> "small int"	41	// back_p==0: ptr -> "small int"
42	// back_p==1: "small int" -> ptr	42	// back_p==1: "small int" -> ptr
43	//	43	//
44	// mode: see enum in savegame.h	44	// mode: see enum in savegame.h
45	void G_Util_PtrToIdx(void ptr, int32_t count, const void base, int32_t mode)	45	void G_Util_PtrToIdx(void ptr, int32_t const count, const void base, int32_t const mode)
46	{	46	{
47	intptr_t iptr = (intptr_t )ptr;	47	intptr_t iptr = (intptr_t )ptr;
48	intptr_t const ibase = (intptr_t)base;	48	intptr_t const ibase = (intptr_t)base;
49	int32_t const onlynon0_p = mode&P2I_ONLYNON0_BIT;	49	int32_t const onlynon0_p = mode&P2I_ONLYNON0_BIT;
50		50
51	// TODO: convert to proper offsets/indices for (a step towards) cross-	51	// TODO: convert to proper offsets/indices for (a step towards) cross-
52	// compatibility between 32- and 64-bit systems in the netplay.	52	// compatibility between 32- and 64-bit systems in the netplay.
53	// REMEMBER to bump BYTEVERSION then.	53	// REMEMBER to bump BYTEVERSION then.
54		54
55	// WARNING: C std doesn't say that bit pattern of NULL is necessarily 0!	55	// WARNING: C std doesn't say that bit pattern of NULL is necessarily 0!
56	if ((mode & P2I_BACK_BIT) == 0)	56	if ((mode & P2I_BACK_BIT) == 0)
57	{	57	{
58	for (int i = 0; i < count; i++)	58	for (int i = 0; i < count; i++)
59	if (!onlynon0_p \|\| iptr[i])	59	if (!onlynon0_p \|\| iptr[i])
60	iptr[i] -= ibase;	60	iptr[i] -= ibase;
61	}	61	}
62	else	62	else
63	{	63	{
64	for (int i = 0; i < count; i++)	64	for (int i = 0; i < count; i++)
65	if (!onlynon0_p \|\| iptr[i])	65	if (!onlynon0_p \|\| iptr[i])
66	iptr[i] += ibase;	66	iptr[i] += ibase;
67	}	67	}
68	}	68	}
69		69
70	void G_Util_PtrToIdx2(void ptr, int32_t count, size_t stride, const void base, int32_t mode)	70	void G_Util_PtrToIdx2(void ptr, int32_t const count, size_t const stride, const void base, int32_t const mode)
71	{	71	{
72	uint8_t iptr = (uint8_t )ptr;	72	uint8_t iptr = (uint8_t )ptr;
73	intptr_t const ibase = (intptr_t)base;	73	intptr_t const ibase = (intptr_t)base;
74	int32_t const onlynon0_p = mode&P2I_ONLYNON0_BIT;	74	int32_t const onlynon0_p = mode&P2I_ONLYNON0_BIT;
75		75
76	if ((mode & P2I_BACK_BIT) == 0)	76	if ((mode & P2I_BACK_BIT) == 0)
77	{	77	{
78	for (int i = 0; i < count; ++i)	78	for (int i = 0; i < count; ++i)
79	{	79	{
80	if (!onlynon0_p \|\| (intptr_t )iptr)	80	if (!onlynon0_p \|\| (intptr_t )iptr)
81	(intptr_t )iptr -= ibase;	81	(intptr_t )iptr -= ibase;
82		82
83	iptr += stride;	83	iptr += stride;
84	}	84	}
85	}	85	}
86	else	86	else
87	{	87	{
88	for (int i = 0; i < count; ++i)	88	for (int i = 0; i < count; ++i)
89	{	89	{
90	if (!onlynon0_p \|\| (intptr_t )iptr)	90	if (!onlynon0_p \|\| (intptr_t )iptr)
91	(intptr_t )iptr += ibase;	91	(intptr_t )iptr += ibase;
92		92
93	iptr += stride;	93	iptr += stride;
94	}	94	}
95	}	95	}
96	}	96	}
97		97
98	// TODO: sync with TROR special interpolations? (e.g. upper floor of subway)	98	// TODO: sync with TROR special interpolations? (e.g. upper floor of subway)
99	void G_ResetInterpolations(void)	99	void G_ResetInterpolations(void)
100	{	100	{
101	int32_t k, i;	101	int32_t k, i;
102		102
103	g_numInterpolations = 0;	103	g_numInterpolations = 0;
104	startofdynamicinterpolations = 0;	104	startofdynamicinterpolations = 0;
105		105
106	k = headspritestat[STAT_EFFECTOR];	106	k = headspritestat[STAT_EFFECTOR];
107	while (k >= 0)	107	while (k >= 0)
108	{	108	{
109	switch (sprite[k].lotag)	109	switch (sprite[k].lotag)
110	{	110	{
111	case SE_31_FLOOR_RISE_FALL:	111	case SE_31_FLOOR_RISE_FALL:
112	G_SetInterpolation(&sector[sprite[k].sectnum].floorz);	112	G_SetInterpolation(&sector[sprite[k].sectnum].floorz);
113	break;	113	break;
114	case SE_32_CEILING_RISE_FALL:	114	case SE_32_CEILING_RISE_FALL:
115	G_SetInterpolation(&sector[sprite[k].sectnum].ceilingz);	115	G_SetInterpolation(&sector[sprite[k].sectnum].ceilingz);
116	break;	116	break;
117	case SE_17_WARP_ELEVATOR:	117	case SE_17_WARP_ELEVATOR:
118	case SE_25_PISTON:	118	case SE_25_PISTON:
119	G_SetInterpolation(&sector[sprite[k].sectnum].floorz);	119	G_SetInterpolation(&sector[sprite[k].sectnum].floorz);
120	G_SetInterpolation(&sector[sprite[k].sectnum].ceilingz);	120	G_SetInterpolation(&sector[sprite[k].sectnum].ceilingz);
121	break;	121	break;
122	case SE_0_ROTATING_SECTOR:	122	case SE_0_ROTATING_SECTOR:
123	case SE_5:	123	case SE_5:
124	case SE_6_SUBWAY:	124	case SE_6_SUBWAY:
125	case SE_11_SWINGING_DOOR:	125	case SE_11_SWINGING_DOOR:
126	case SE_14_SUBWAY_CAR:	126	case SE_14_SUBWAY_CAR:
127	case SE_15_SLIDING_DOOR:	127	case SE_15_SLIDING_DOOR:
128	case SE_16_REACTOR:	128	case SE_16_REACTOR:
129	case SE_26:	129	case SE_26:
130	case SE_30_TWO_WAY_TRAIN:	130	case SE_30_TWO_WAY_TRAIN:
131	Sect_SetInterpolation(sprite[k].sectnum);	131	Sect_SetInterpolation(sprite[k].sectnum);
132	break;	132	break;
133	}	133	}
134		134
135	k = nextspritestat[k];	135	k = nextspritestat[k];
136	}	136	}
137		137
138	for (i=g_numInterpolations-1; i>=0; i--) bakipos[i] = *curipos[i];	138	for (i=g_numInterpolations-1; i>=0; i--) bakipos[i] = *curipos[i];
139	for (i = g_animateCount-1; i>=0; i--)	139	for (i = g_animateCount-1; i>=0; i--)
140	G_SetInterpolation(animateptr[i]);	140	G_SetInterpolation(animateptr[i]);
141	}	141	}
142		142
143	void ReadSaveGameHeaders(void)	143	void ReadSaveGameHeaders(void)
144	{	144	{
145	char fn[16];	145	char fn[16];
146	int32_t fil, i;	146	int32_t fil, i;
147		147
148	savehead_t h;	148	savehead_t h;
149		149
150	EDUKE32_STATIC_ASSERT(sizeof(h.savename) == sizeof(ud.savegame[0]));	150	EDUKE32_STATIC_ASSERT(sizeof(h.savename) == sizeof(ud.savegame[0]));
151		151
152	Bstrcpy(fn, "dukesav0.esv");	152	Bstrcpy(fn, "dukesav0.esv");
153		153
154	for (i=0; i<MAXSAVEGAMES; i++)	154	for (i=0; i<MAXSAVEGAMES; i++)
155	{	155	{
156	int32_t k;	156	int32_t k;
157		157
158	fn[7] = i + '0';	158	fn[7] = i + '0';
159	fil = kopen4loadfrommod(fn, 0);	159	fil = kopen4loadfrommod(fn, 0);
160	if (fil == -1)	160	if (fil == -1)
161	{	161	{
162	Bmemset(ud.savegame[i], 0, sizeof(ud.savegame[i]));	162	Bmemset(ud.savegame[i], 0, sizeof(ud.savegame[i]));
163	continue;	163	continue;
164	}	164	}
165		165
166	k = sv_loadheader(fil, i, &h);	166	k = sv_loadheader(fil, i, &h);
167	if (k)	167	if (k)
168	{	168	{
169	// old version, signal to menu code	169	// old version, signal to menu code
170	if (k==2 \|\| k==3)	170	if (k==2 \|\| k==3)
171	g_oldverSavegame[i] = 1;	171	g_oldverSavegame[i] = 1;
172	// else h.savename is all zeros (fatal failure, like wrong header	172	// else h.savename is all zeros (fatal failure, like wrong header
173	// magic or too short header)	173	// magic or too short header)
174	}	174	}
175		175
176	Bmemcpy(ud.savegame[i], h.savename, sizeof(ud.savegame[i]));	176	Bmemcpy(ud.savegame[i], h.savename, sizeof(ud.savegame[i]));
177		177
178	kclose(fil);	178	kclose(fil);
179	}	179	}
180	}	180	}
181		181
182	int32_t G_LoadSaveHeaderNew(int32_t spot, savehead_t *saveh)	182	int32_t G_LoadSaveHeaderNew(int32_t spot, savehead_t *saveh)
183	{	183	{
184	char fn[16];	184	char fn[16];
185	int32_t fil, screenshotofs, i;	185	int32_t fil, screenshotofs, i;
186		186
187	Bassert(spot < MAXSAVEGAMES);	187	Bassert(spot < MAXSAVEGAMES);
188		188
189	Bstrcpy(fn, "dukesav0.esv");	189	Bstrcpy(fn, "dukesav0.esv");
190	fn[7] = spot + '0';	190	fn[7] = spot + '0';
191		191
192	fil = kopen4loadfrommod(fn, 0);	192	fil = kopen4loadfrommod(fn, 0);
193	if (fil == -1)	193	if (fil == -1)
194	return -1;	194	return -1;
195		195
196	i = sv_loadheader(fil, spot, saveh);	196	i = sv_loadheader(fil, spot, saveh);
197	if (i && (i != 2 && i != 3))	197	if (i && (i != 2 && i != 3))
198	goto corrupt;	198	goto corrupt;
199		199
200	if (kread(fil, &screenshotofs, 4) != 4)	200	if (kread(fil, &screenshotofs, 4) != 4)
201	goto corrupt;	201	goto corrupt;
202		202
203	walock[TILE_LOADSHOT] = 255;	203	walock[TILE_LOADSHOT] = 255;
204	if (waloff[TILE_LOADSHOT] == 0)	204	if (waloff[TILE_LOADSHOT] == 0)
205	allocache(&waloff[TILE_LOADSHOT], 320*200, &walock[TILE_LOADSHOT]);	205	allocache(&waloff[TILE_LOADSHOT], 320*200, &walock[TILE_LOADSHOT]);
206	tilesiz[TILE_LOADSHOT].x = 200;	206	tilesiz[TILE_LOADSHOT].x = 200;
207	tilesiz[TILE_LOADSHOT].y = 320;	207	tilesiz[TILE_LOADSHOT].y = 320;
208	if (screenshotofs)	208	if (screenshotofs)
209	{	209	{
210	if (kdfread((char *)waloff[TILE_LOADSHOT], 320, 200, fil) != 200)	210	if (kdfread((char *)waloff[TILE_LOADSHOT], 320, 200, fil) != 200)
211	{	211	{
212	OSD_Printf("G_LoadSaveHeaderNew(%d): failed reading screenshot\n", spot);	212	OSD_Printf("G_LoadSaveHeaderNew(%d): failed reading screenshot\n", spot);
213	goto corrupt;	213	goto corrupt;
214	}	214	}
215	}	215	}
216	else	216	else
217	{	217	{
218	Bmemset((char )waloff[TILE_LOADSHOT], 0, 320200);	218	Bmemset((char )waloff[TILE_LOADSHOT], 0, 320200);
219	}	219	}
220	invalidatetile(TILE_LOADSHOT, 0, 255);	220	invalidatetile(TILE_LOADSHOT, 0, 255);
221		221
222	kclose(fil);	222	kclose(fil);
223	return 0;	223	return 0;
224		224
225	corrupt:	225	corrupt:
226	kclose(fil);	226	kclose(fil);
227	return 1;	227	return 1;
228	}	228	}
229		229
230		230
231	static void sv_postudload();	231	static void sv_postudload();
232		232
233	// XXX: keyboard input 'blocked' after load fail? (at least ESC?)	233	// XXX: keyboard input 'blocked' after load fail? (at least ESC?)
234	int32_t G_LoadPlayer(int32_t spot)	234	int32_t G_LoadPlayer(int32_t spot)
235	{	235	{
236	char fn[16];	236	char fn[16];
237	int32_t fil, i;	237	int32_t fil, i;
238		238
239	savehead_t h;	239	savehead_t h;
240		240
241	Bassert(spot < MAXSAVEGAMES);	241	Bassert(spot < MAXSAVEGAMES);
242		242
243	Bstrcpy(fn, "dukesav0.esv");	243	Bstrcpy(fn, "dukesav0.esv");
244	fn[7] = spot + '0';	244	fn[7] = spot + '0';
245		245
246	fil = kopen4loadfrommod(fn, 0);	246	fil = kopen4loadfrommod(fn, 0);
247	if (fil == -1)	247	if (fil == -1)
248	return -1;	248	return -1;
249		249
250	ready2send = 0;	250	ready2send = 0;
251		251
252	i = sv_loadheader(fil, spot, &h);	252	i = sv_loadheader(fil, spot, &h);
253	if ((i && i != 2) \|\| h.numplayers != ud.multimode)	253	if ((i && i != 2) \|\| h.numplayers != ud.multimode)
254	{	254	{
255	if (i == 2 \|\| i == 3)	255	if (i == 2 \|\| i == 3)
256	P_DoQuote(QUOTE_SAVE_BAD_VERSION, g_player[myconnectindex].ps);	256	P_DoQuote(QUOTE_SAVE_BAD_VERSION, g_player[myconnectindex].ps);
257	else if (h.numplayers!=ud.multimode)	257	else if (h.numplayers!=ud.multimode)
258	P_DoQuote(QUOTE_SAVE_BAD_PLAYERS, g_player[myconnectindex].ps);	258	P_DoQuote(QUOTE_SAVE_BAD_PLAYERS, g_player[myconnectindex].ps);
259		259
260	kclose(fil);	260	kclose(fil);
261	ototalclock = totalclock;	261	ototalclock = totalclock;
262	ready2send = 1;	262	ready2send = 1;
263		263
264	return 1;	264	return 1;
265	}	265	}
266		266
267	// some setup first	267	// some setup first
268	ud.multimode = h.numplayers;	268	ud.multimode = h.numplayers;
269		269
270	if (numplayers > 1)	270	if (numplayers > 1)
271	{	271	{
272	pub = NUMPAGES;	272	pub = NUMPAGES;
273	pus = NUMPAGES;	273	pus = NUMPAGES;
274	G_UpdateScreenArea();	274	G_UpdateScreenArea();
275	G_DrawBackground();	275	G_DrawBackground();
276	menutext(160,100, 0,0, "LOADING...");	276	menutext(160,100, 0,0, "LOADING...");
277	nextpage();	277	nextpage();
278	}	278	}
279		279
280	Net_WaitForServer();	280	Net_WaitForServer();
281		281
282	FX_StopAllSounds();	282	FX_StopAllSounds();
283	S_ClearSoundLocks();	283	S_ClearSoundLocks();
284		284
285	if (spot >= 0 && numplayers==1)	285	if (spot >= 0 && numplayers==1)
286	{	286	{
287	Bmemcpy(ud.savegame[spot], h.savename, sizeof(ud.savegame[0]));	287	Bmemcpy(ud.savegame[spot], h.savename, sizeof(ud.savegame[0]));
288	ud.savegame[spot][sizeof(ud.savegame[0])-1] = 0;	288	ud.savegame[spot][sizeof(ud.savegame[0])-1] = 0;
289	}	289	}
290		290
291	// non-"m_" fields will be loaded from svgm_udnetw	291	// non-"m_" fields will be loaded from svgm_udnetw
292	ud.m_volume_number = h.volnum;	292	ud.m_volume_number = h.volnum;
293	ud.m_level_number = h.levnum;	293	ud.m_level_number = h.levnum;
294	ud.m_player_skill = h.skill;	294	ud.m_player_skill = h.skill;
295		295
296	{	296	{
297	// NOTE: Bmemcpy needed for SAVEGAME_MUSIC.	297	// NOTE: Bmemcpy needed for SAVEGAME_MUSIC.
298	EDUKE32_STATIC_ASSERT(sizeof(boardfilename) == sizeof(h.boardfn));	298	EDUKE32_STATIC_ASSERT(sizeof(boardfilename) == sizeof(h.boardfn));
299	Bmemcpy(boardfilename, h.boardfn, sizeof(boardfilename));	299	Bmemcpy(boardfilename, h.boardfn, sizeof(boardfilename));
300	}	300	}
301		301
302	E_MapArt_Setup(h.boardfn); // XXX: Better after the following filename tweaking?	302	E_MapArt_Setup(h.boardfn); // XXX: Better after the following filename tweaking?
303		303
304	if (boardfilename[0])	304	if (boardfilename[0])
305	Bstrcpy(currentboardfilename, boardfilename);	305	Bstrcpy(currentboardfilename, boardfilename);
306	else if (MapInfo[h.volnum*MAXLEVELS + h.levnum].filename)	306	else if (MapInfo[h.volnum*MAXLEVELS + h.levnum].filename)
307	Bstrcpy(currentboardfilename, MapInfo[h.volnum*MAXLEVELS + h.levnum].filename);	307	Bstrcpy(currentboardfilename, MapInfo[h.volnum*MAXLEVELS + h.levnum].filename);
308		308
309	if (currentboardfilename[0])	309	if (currentboardfilename[0])
310	{	310	{
311	append_ext_UNSAFE(currentboardfilename, ".mhk");	311	append_ext_UNSAFE(currentboardfilename, ".mhk");
312	loadmaphack(currentboardfilename);	312	loadmaphack(currentboardfilename);
313	}	313	}
314		314
315	Bmemcpy(currentboardfilename, boardfilename, BMAX_PATH);	315	Bmemcpy(currentboardfilename, boardfilename, BMAX_PATH);
316		316
317	if (i == 2)	317	if (i == 2)
318	{	318	{
319	G_NewGame_EnterLevel();	319	G_NewGame_EnterLevel();
320	}	320	}
321	else	321	else
322	{	322	{
323	// read the rest...	323	// read the rest...
324	i = sv_loadsnapshot(fil, spot, &h);	324	i = sv_loadsnapshot(fil, spot, &h);
325	if (i)	325	if (i)
326	{	326	{
327	// in theory, we could load into an initial dump first and trivially	327	// in theory, we could load into an initial dump first and trivially
328	// recover if things go wrong...	328	// recover if things go wrong...
329	Bsprintf(tempbuf, "Loading save game file \"%s\" failed (code %d), cannot recover.", fn, i);	329	Bsprintf(tempbuf, "Loading save game file \"%s\" failed (code %d), cannot recover.", fn, i);
330	G_GameExit(tempbuf);	330	G_GameExit(tempbuf);
331	}	331	}
332	}	332	}
333	sv_postudload(); // ud.m_XXX = ud.XXX	333	sv_postudload(); // ud.m_XXX = ud.XXX
334		334
335	VM_OnEvent(EVENT_LOADGAME, g_player[myconnectindex].ps->i, myconnectindex);	335	VM_OnEvent(EVENT_LOADGAME, g_player[myconnectindex].ps->i, myconnectindex);
336		336
337	return 0;	337	return 0;
338	}	338	}
339		339
340	////////// TIMER SAVING/RESTORING //////////	340	////////// TIMER SAVING/RESTORING //////////
341		341
342	static struct {	342	static struct {
343	int32_t totalclock, totalclocklock; // engine	343	int32_t totalclock, totalclocklock; // engine
344	int32_t ototalclock, lockclock; // game	344	int32_t ototalclock, lockclock; // game
345	} g_timers;	345	} g_timers;
346		346
347	static void G_SaveTimers(void)	347	static void G_SaveTimers(void)
348	{	348	{
349	g_timers.totalclock = totalclock;	349	g_timers.totalclock = totalclock;
350	g_timers.totalclocklock = totalclocklock;	350	g_timers.totalclocklock = totalclocklock;
351	g_timers.ototalclock = ototalclock;	351	g_timers.ototalclock = ototalclock;
352	g_timers.lockclock = lockclock;	352	g_timers.lockclock = lockclock;
353	}	353	}
354		354
355	static void G_RestoreTimers(void)	355	static void G_RestoreTimers(void)
356	{	356	{
357	sampletimer();	357	sampletimer();
358		358
359	totalclock = g_timers.totalclock;	359	totalclock = g_timers.totalclock;
360	totalclocklock = g_timers.totalclocklock;	360	totalclocklock = g_timers.totalclocklock;
361	ototalclock = g_timers.ototalclock;	361	ototalclock = g_timers.ototalclock;
362	lockclock = g_timers.lockclock;	362	lockclock = g_timers.lockclock;
363	}	363	}
364		364
365	//////////	365	//////////
366		366
367	#ifdef __ANDROID__	367	#ifdef __ANDROID__
368	static void G_SavePalette(void)	368	static void G_SavePalette(void)
369	{	369	{
370	int32_t pfil;	370	int32_t pfil;
371		371
372	if ((pfil = kopen4load("palette.dat", 0)) != -1)	372	if ((pfil = kopen4load("palette.dat", 0)) != -1)
373	{	373	{
374	int len = kfilelength(pfil);	374	int len = kfilelength(pfil);
375		375
376	FILE *fil = fopen("palette.dat", "rb");	376	FILE *fil = fopen("palette.dat", "rb");
377		377
378	if (!fil)	378	if (!fil)
379	{	379	{
380	fil = fopen("palette.dat", "wb");	380	fil = fopen("palette.dat", "wb");
381		381
382	if (fil)	382	if (fil)
383	{	383	{
384	char buf = (char ) Xaligned_alloc(16, len);	384	char buf = (char ) Xaligned_alloc(16, len);
385		385
386	kread(pfil, buf, len);	386	kread(pfil, buf, len);
387	fwrite(buf, len, 1, fil);	387	fwrite(buf, len, 1, fil);
388	fclose(fil);	388	fclose(fil);
389	}	389	}
390	}	390	}
391	else fclose(fil);	391	else fclose(fil);
392	}	392	}
393	}	393	}
394	#endif	394	#endif
395		395
396	int32_t G_SavePlayer(int32_t spot)	396	int32_t G_SavePlayer(int32_t spot)
397	{	397	{
398	char fn[16];	398	char fn[16];
399	FILE *fil;	399	FILE *fil;
400		400
401	#ifdef __ANDROID__	401	#ifdef __ANDROID__
402	G_SavePalette();	402	G_SavePalette();
403	#endif	403	#endif
404		404
405	Bassert(spot < MAXSAVEGAMES);	405	Bassert(spot < MAXSAVEGAMES);
406		406
407	G_SaveTimers();	407	G_SaveTimers();
408		408
409	Bstrcpy(fn, "dukesav0.esv");	409	Bstrcpy(fn, "dukesav0.esv");
410	fn[7] = spot + '0';	410	fn[7] = spot + '0';
411		411
412	// Bstrcpy(mpfn, "edukA_00.esv");	412	// Bstrcpy(mpfn, "edukA_00.esv");
413		413
414	Net_WaitForServer();	414	Net_WaitForServer();
415	ready2send = 0;	415	ready2send = 0;
416		416
417	{	417	{
418	char temp[BMAX_PATH];	418	char temp[BMAX_PATH];
419		419
420	if (G_ModDirSnprintf(temp, sizeof(temp), "%s", fn))	420	if (G_ModDirSnprintf(temp, sizeof(temp), "%s", fn))
421	{	421	{
422	OSD_Printf("G_SavePlayer: file name \"%s\" too long\n", fn);	422	OSD_Printf("G_SavePlayer: file name \"%s\" too long\n", fn);
423	return -1;	423	return -1;
424	}	424	}
425		425
426	errno = 0;	426	errno = 0;
427	fil = fopen(temp, "wb");	427	fil = fopen(temp, "wb");
428	if (!fil)	428	if (!fil)
429	{	429	{
430	OSD_Printf("G_SavePlayer: failed opening \"%s\" for writing: %s\n",	430	OSD_Printf("G_SavePlayer: failed opening \"%s\" for writing: %s\n",
431	temp, strerror(errno));	431	temp, strerror(errno));
432	return -1;	432	return -1;
433	}	433	}
434	}	434	}
435		435
436	#ifdef POLYMER	436	#ifdef POLYMER
437	if (getrendermode() == REND_POLYMER)	437	if (getrendermode() == REND_POLYMER)
438	polymer_resetlights();	438	polymer_resetlights();
439	#endif	439	#endif
440		440
441	VM_OnEvent(EVENT_SAVEGAME, g_player[myconnectindex].ps->i, myconnectindex);	441	VM_OnEvent(EVENT_SAVEGAME, g_player[myconnectindex].ps->i, myconnectindex);
442		442
443	// SAVE!	443	// SAVE!
444	sv_saveandmakesnapshot(fil, spot, 0, 0, 0);	444	sv_saveandmakesnapshot(fil, spot, 0, 0, 0);
445		445
446	fclose(fil);	446	fclose(fil);
447		447
448	if (!g_netServer && ud.multimode < 2)	448	if (!g_netServer && ud.multimode < 2)
449	{	449	{
450	#ifdef LUNATIC	450	#ifdef LUNATIC
451	if (!g_savedOK)	451	if (!g_savedOK)
452	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "^10Failed Saving Game");	452	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "^10Failed Saving Game");
453	else	453	else
454	#endif	454	#endif
455	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Game Saved");	455	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Game Saved");
456	P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);	456	P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
457	}	457	}
458		458
459	ready2send = 1;	459	ready2send = 1;
460	Net_WaitForServer();	460	Net_WaitForServer();
461		461
462	G_RestoreTimers();	462	G_RestoreTimers();
463	ototalclock = totalclock;	463	ototalclock = totalclock;
464		464
465	return 0;	465	return 0;
466	}	466	}
467		467
468	void G_LoadPlayerMaybeMulti(int32_t slot)	468	void G_LoadPlayerMaybeMulti(int32_t slot)
469	{	469	{
470	if (g_netServer \|\| ud.multimode > 1)	470	if (g_netServer \|\| ud.multimode > 1)
471	{	471	{
472	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Multiplayer Loading Not Yet Supported");	472	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Multiplayer Loading Not Yet Supported");
473	P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);	473	P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
474		474
475	// G_LoadPlayer(-1-g_lastSaveSlot);	475	// G_LoadPlayer(-1-g_lastSaveSlot);
476	// g_player[myconnectindex].ps->gm = MODE_GAME;	476	// g_player[myconnectindex].ps->gm = MODE_GAME;
477	}	477	}
478	else	478	else
479	{	479	{
480	int32_t c = G_LoadPlayer(slot);	480	int32_t c = G_LoadPlayer(slot);
481	if (c == 0)	481	if (c == 0)
482	g_player[myconnectindex].ps->gm = MODE_GAME;	482	g_player[myconnectindex].ps->gm = MODE_GAME;
483	}	483	}
484	}	484	}
485		485
486	void G_SavePlayerMaybeMulti(int32_t slot)	486	void G_SavePlayerMaybeMulti(int32_t slot)
487	{	487	{
488	Bassert(slot >= 0);	488	Bassert(slot >= 0);
489		489
490	CONFIG_WriteSetup(2);	490	CONFIG_WriteSetup(2);
491		491
492	if (g_netServer \|\| ud.multimode > 1)	492	if (g_netServer \|\| ud.multimode > 1)
493	{	493	{
494	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Multiplayer Saving Not Yet Supported");	494	Bstrcpy(ScriptQuotes[QUOTE_RESERVED4], "Multiplayer Saving Not Yet Supported");
495	P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);	495	P_DoQuote(QUOTE_RESERVED4, g_player[myconnectindex].ps);
496	// G_SavePlayer(-1-slot);	496	// G_SavePlayer(-1-slot);
497	}	497	}
498	else	498	else
499	{	499	{
500	G_SavePlayer(slot);	500	G_SavePlayer(slot);

Subversion Repositories eduke32

(root)/polymer/eduke32/source/savegame.c – Rev 4990 → 5069