p_saveg.c

The source code of Doom legacy for windows

    mapsidedef_t  *msd;
    maplinedef_t  *mld;
    sector_t      *ss;
    byte           diff;
    byte           diff2;

    ms = W_CacheLumpNum (lastloadedmaplumpnum+ML_SECTORS,PU_CACHE);
    ss = sectors;
    put = save_p;

    for (i=0 ; i<numsectors ; i++, ss++, ms++)
    {
        diff=0;diff2=0;
        if (ss->floorheight != SHORT(ms->floorheight)<<FRACBITS)
            diff |= SD_FLOORHT;
        if (ss->ceilingheight != SHORT(ms->ceilingheight)<<FRACBITS)
            diff |= SD_CEILHT;
        //
        //  flats
        //
        // P_AddLevelFlat should not add but just return the number
        if (ss->floorpic != P_AddLevelFlat (ms->floorpic,levelflats))
            diff |= SD_FLOORPIC;
        if (ss->ceilingpic != P_AddLevelFlat (ms->ceilingpic,levelflats))
            diff |= SD_CEILPIC;

        if (ss->lightlevel != SHORT(ms->lightlevel))     diff |= SD_LIGHT;
        if (ss->special != SHORT(ms->special))           diff |= SD_SPECIAL;

        if (ss->floor_xoffs != 0)                        diff2 |= SD_FXOFFS;
        if (ss->floor_yoffs != 0)                        diff2 |= SD_FYOFFS;
        if (ss->ceiling_xoffs != 0)                      diff2 |= SD_CXOFFS;
        if (ss->ceiling_yoffs != 0)                      diff2 |= SD_CYOFFS;
        if (ss->stairlock < 0)                           diff2 |= SD_STAIRLOCK;
        if (ss->nextsec != -1)                           diff2 |= SD_NEXTSEC;
        if (ss->prevsec != -1)                           diff2 |= SD_PREVSEC;
        if (diff2)                                       diff |= SD_DIFF2;

        if(diff)
        {
            statsec++;

            WRITESHORT(put,i);
            WRITEBYTE(put,diff);
            if( diff & SD_DIFF2   )     WRITEBYTE(put,diff2);
            if( diff & SD_FLOORHT )     WRITEFIXED(put,ss->floorheight);
            if( diff & SD_CEILHT  )     WRITEFIXED(put,ss->ceilingheight);
            if( diff & SD_FLOORPIC)
            {
                memcpy(put,levelflats[ss->floorpic].name,8);
                put+=8;
            }
            if( diff & SD_CEILPIC )
            {
                memcpy(put,levelflats[ss->ceilingpic].name,8);
                put+=8;
            }
            if( diff & SD_LIGHT   )     WRITESHORT(put,(short)ss->lightlevel);
            if( diff & SD_SPECIAL )     WRITESHORT(put,(short)ss->special);

            if( diff2 & SD_FXOFFS  )    WRITEFIXED(put,ss->floor_xoffs);
            if( diff2 & SD_FYOFFS  )    WRITEFIXED(put,ss->floor_yoffs);
            if( diff2 & SD_CXOFFS  )    WRITEFIXED(put,ss->ceiling_xoffs);
            if( diff2 & SD_CYOFFS  )    WRITEFIXED(put,ss->ceiling_yoffs);
            if( diff2 & SD_STAIRLOCK)   WRITELONG (put,ss->stairlock);
            if( diff2 & SD_NEXTSEC )    WRITELONG (put,ss->nextsec);
            if( diff2 & SD_PREVSEC )    WRITELONG (put,ss->prevsec);
        }
    }
    *((unsigned short *)put)++=0xffff;

    mld = W_CacheLumpNum (lastloadedmaplumpnum+ML_LINEDEFS,PU_CACHE);
    msd = W_CacheLumpNum (lastloadedmaplumpnum+ML_SIDEDEFS,PU_CACHE);
    li = lines;
    // do lines
    for (i=0 ; i<numlines ; i++,mld++,li++)
    {
        diff=0;diff2=0;

        // we don't care of map in deathmatch !
        if(((cv_deathmatch.value==0) && (li->flags != SHORT(mld->flags))) ||
           ((cv_deathmatch.value!=0) && ((li->flags & ~ML_MAPPED) != SHORT(mld->flags))))
            diff |= LD_FLAG;
        if(li->special != SHORT(mld->special))
            diff |= LD_SPECIAL;

        if (li->sidenum[0] != -1)
        {
            si = &sides[li->sidenum[0]];
            if (si->textureoffset != SHORT(msd[li->sidenum[0]].textureoffset)<<FRACBITS)
                diff |= LD_S1TEXOFF;
            //SoM: 4/1/2000: Some textures are colormaps. Don't worry about invalid textures.
            if(R_CheckTextureNumForName(msd[li->sidenum[0]].toptexture) != -1)
              if (si->toptexture != R_TextureNumForName(msd[li->sidenum[0]].toptexture) )
                diff |= LD_S1TOPTEX;
            if(R_CheckTextureNumForName(msd[li->sidenum[0]].bottomtexture) != -1)
              if (si->bottomtexture != R_TextureNumForName(msd[li->sidenum[0]].bottomtexture) )
                diff |= LD_S1BOTTEX;
            if(R_CheckTextureNumForName(msd[li->sidenum[0]].midtexture) != -1)
              if (si->midtexture != R_TextureNumForName(msd[li->sidenum[0]].midtexture) )
                diff |= LD_S1MIDTEX;
        }
        if (li->sidenum[1] != -1)
        {
            si = &sides[li->sidenum[1]];
            if (si->textureoffset != SHORT(msd[li->sidenum[1]].textureoffset)<<FRACBITS)
                diff2 |= LD_S2TEXOFF;
            if(R_CheckTextureNumForName(msd[li->sidenum[1]].toptexture) != -1)
              if (si->toptexture != R_TextureNumForName(msd[li->sidenum[1]].toptexture) )
                diff2 |= LD_S2TOPTEX;
            if(R_CheckTextureNumForName(msd[li->sidenum[1]].bottomtexture) != -1)
              if (si->bottomtexture != R_TextureNumForName(msd[li->sidenum[1]].bottomtexture) )
                diff2 |= LD_S2BOTTEX;
            if(R_CheckTextureNumForName(msd[li->sidenum[1]].midtexture) != -1)
              if (si->midtexture != R_TextureNumForName(msd[li->sidenum[1]].midtexture) )
                diff2 |= LD_S2MIDTEX;
            if(diff2)
                diff |= LD_DIFF2;

        }

        if(diff)
        {
            statline++;
            WRITESHORT(put,(short)i);
            WRITEBYTE(put,diff);
            if( diff & LD_DIFF2    )     WRITEBYTE(put,diff2);
            if( diff & LD_FLAG     )     WRITESHORT(put,li->flags);
            if( diff & LD_SPECIAL  )     WRITESHORT(put,li->special);

            si = &sides[li->sidenum[0]];
            if( diff & LD_S1TEXOFF )     WRITEFIXED(put,si->textureoffset);
            if( diff & LD_S1TOPTEX )     WRITESHORT(put,si->toptexture);
            if( diff & LD_S1BOTTEX )     WRITESHORT(put,si->bottomtexture);
            if( diff & LD_S1MIDTEX )     WRITESHORT(put,si->midtexture);

            si = &sides[li->sidenum[1]];
            if( diff2 & LD_S2TEXOFF )    WRITEFIXED(put,si->textureoffset);
            if( diff2 & LD_S2TOPTEX )    WRITESHORT(put,si->toptexture);
            if( diff2 & LD_S2BOTTEX )    WRITESHORT(put,si->bottomtexture);
            if( diff2 & LD_S2MIDTEX )    WRITESHORT(put,si->midtexture);
        }
    }
    WRITEUSHORT(put,0xffff);

    //CONS_Printf("sector saved %d/%d, line saved %d/%d\n",statsec,numsectors,statline,numlines);
    save_p = put;
}



//
// P_UnArchiveWorld
//
void P_UnArchiveWorld (void)
{
    int                 i;
    line_t*     li;
    side_t*     si;
    byte*       get;
    byte        diff,diff2;

    get = save_p;

    while (1)
    {
        i=*((unsigned short *)get)++;

        if (i==0xffff)
            break;

        diff=READBYTE(get);
        if( diff & SD_DIFF2    )   diff2 = READBYTE(get);
                              else diff2 = 0;
        if( diff & SD_FLOORHT  )   sectors[i].floorheight   = READFIXED(get);
        if( diff & SD_CEILHT   )   sectors[i].ceilingheight = READFIXED(get);
        if( diff & SD_FLOORPIC )
        {
            sectors[i].floorpic = P_AddLevelFlat (get,levelflats);
            get+=8;
        }
        if( diff & SD_CEILPIC )
        {
            sectors[i].ceilingpic = P_AddLevelFlat (get,levelflats);
            get+=8;
        }
        if( diff & SD_LIGHT )    sectors[i].lightlevel = READSHORT(get);
        if( diff & SD_SPECIAL )  sectors[i].special    = READSHORT(get);

        if( diff2 & SD_FXOFFS )  sectors[i].floor_xoffs     = READFIXED(get);
        if( diff2 & SD_FYOFFS )  sectors[i].floor_yoffs     = READFIXED(get);
        if( diff2 & SD_CXOFFS )  sectors[i].ceiling_xoffs   = READFIXED(get);
        if( diff2 & SD_CYOFFS )  sectors[i].ceiling_yoffs   = READFIXED(get);
        if( diff2 & SD_STAIRLOCK)sectors[i].stairlock       = READLONG (get);
                            else sectors[i].stairlock       = 0;
        if( diff2 & SD_NEXTSEC)  sectors[i].nextsec         = READLONG (get);
                            else sectors[i].nextsec         = -1;
        if( diff2 & SD_PREVSEC)  sectors[i].prevsec         = READLONG (get);
                            else sectors[i].prevsec         = -1;
    }

    while(1)
    {
        i=READUSHORT(get);

        if (i==0xffff)
            break;
        diff = READBYTE(get);
        li = &lines[i];

        if( diff & LD_DIFF2    )    diff2 = READBYTE(get);
                               else diff2 = 0;
        if( diff & LD_FLAG     )    li->flags = READSHORT(get);
        if( diff & LD_SPECIAL  )    li->special = READSHORT(get);

        si = &sides[li->sidenum[0]];
        if( diff & LD_S1TEXOFF )    si->textureoffset = READFIXED(get);
        if( diff & LD_S1TOPTEX )    si->toptexture    = READSHORT(get);
        if( diff & LD_S1BOTTEX )    si->bottomtexture = READSHORT(get);
        if( diff & LD_S1MIDTEX )    si->midtexture    = READSHORT(get);

        si = &sides[li->sidenum[1]];
        if( diff2 & LD_S2TEXOFF )   si->textureoffset = READFIXED(get);
        if( diff2 & LD_S2TOPTEX )   si->toptexture    = READSHORT(get);
        if( diff2 & LD_S2BOTTEX )   si->bottomtexture = READSHORT(get);
        if( diff2 & LD_S2MIDTEX )   si->midtexture    = READSHORT(get);
    }

    save_p = get;
}


//
// Thinkers
//

typedef enum {
    MD_SPAWNPOINT = 0x000001,
    MD_POS        = 0x000002,
    MD_TYPE       = 0x000004,
    MD_Z          = 0x000008,
    MD_MOM        = 0x000010,
    MD_RADIUS     = 0x000020,
    MD_HEIGHT     = 0x000040,
    MD_FLAGS      = 0x000080,
    MD_HEALTH     = 0x000100,
    MD_RTIME      = 0x000200,
    MD_STATE      = 0x000400,
    MD_TICS       = 0x000800,
    MD_SPRITE     = 0x001000,
    MD_FRAME      = 0x002000,
    MD_EFLAGS     = 0x004000,
    MD_PLAYER     = 0x008000,
    MD_MOVEDIR    = 0x010000,
    MD_MOVECOUNT  = 0x020000,
    MD_THRESHOLD  = 0x040000,
    MD_LASTLOOK   = 0x080000,
    MD_TARGET     = 0x100000,
    MD_TRACER     = 0x200000,
    MD_FRICTION   = 0x400000,
    MD_MOVEFACTOR = 0x800000,
    MD_FLAGS2     =0x1000000,
    MD_SPECIAL1   =0x2000000,
    MD_SPECIAL2   =0x4000000,
} mobj_diff_t;

enum
{
    tc_mobj,
    tc_ceiling,
    tc_door,
    tc_floor,
    tc_plat,
    tc_flash,
    tc_strobe,
    tc_glow,
    tc_fireflicker,
    tc_elevator, //SoM: 3/15/2000: Add extra boom types.
    tc_scroll,
    tc_friction,
    tc_pusher,
    tc_end

} specials_e;

//
// P_ArchiveThinkers
//
//
// Things to handle:
//
// P_MobjsThinker (all mobj)
// T_MoveCeiling, (ceiling_t: sector_t * swizzle), - active list
// T_VerticalDoor, (vldoor_t: sector_t * swizzle),
// T_MoveFloor, (floormove_t: sector_t * swizzle),
// T_LightFlash, (lightflash_t: sector_t * swizzle),
// T_StrobeFlash, (strobe_t: sector_t *),
// T_Glow, (glow_t: sector_t *),
// T_PlatRaise, (plat_t: sector_t *), - active list
// BP: added missing : T_FireFlicker
//
void P_ArchiveThinkers (void)
{
    thinker_t*          th;
    mobj_t*             mobj;
    ULONG               diff;
//    int                 i; //SoM: 3/16/2000: Removed. Not used any more.

    // save off the current thinkers
    for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
    {
        if (th->function.acp1 == (actionf_p1)P_MobjThinker)
        {
            mobj = (mobj_t *)th;
/*
            // not a monster nor a picable item so don't save it
            if( (((mobj->flags & (MF_COUNTKILL | MF_PICKUP | MF_SHOOTABLE )) == 0)
                 && (mobj->flags & MF_MISSILE)
                 && (mobj->info->doomednum !=-1) )
                || (mobj->type == MT_BLOOD) )
                continue;
*/
            if( mobj->spawnpoint && (mobj->info->doomednum !=-1)) {
                // spawnpoint is not moddified but we must save it since it is a indentifier
                diff = MD_SPAWNPOINT;

                if((mobj->x != mobj->spawnpoint->x << FRACBITS) ||
                   (mobj->y != mobj->spawnpoint->y << FRACBITS) ||
                   (mobj->angle != (unsigned)(ANG45 * (mobj->spawnpoint->angle/45))) ) diff |= MD_POS;
                if(mobj->info->doomednum != mobj->spawnpoint->type)        diff |= MD_TYPE;
            }
            else
            {
                diff = MD_POS | MD_TYPE;
            }

            // not the default but the most probable
            if( mobj->z             != mobj->floorz)                       diff |= MD_Z;
            if((mobj->momx != 0)||(mobj->momy != 0)||(mobj->momz != 0) )   diff |= MD_MOM;
            if( mobj->radius        != mobj->info->radius       )          diff |= MD_RADIUS;
            if( mobj->height        != mobj->info->height       )          diff |= MD_HEIGHT;
            if( mobj->flags         != mobj->info->flags        )          diff |= MD_FLAGS;
            if( mobj->flags2        != mobj->info->flags2       )          diff |= MD_FLAGS2;
            if( mobj->health        != mobj->info->spawnhealth  )          diff |= MD_HEALTH;
            if( mobj->reactiontime  != mobj->info->reactiontime )          diff |= MD_RTIME;
            if( mobj->state-states  != mobj->info->spawnstate   )          diff |= MD_STATE;
            if( mobj->tics          != mobj->state->tics        )          diff |= MD_TICS;
            if( mobj->sprite        != mobj->state->sprite      )          diff |= MD_SPRITE;
            if( mobj->frame         != mobj->state->frame       )          diff |= MD_FRAME;
            if( mobj->eflags        )                                      diff |= MD_EFLAGS;
            if( mobj->player        )                                      diff |= MD_PLAYER;

            if( mobj->movedir       )                                      diff |= MD_MOVEDIR;
            if( mobj->movecount     )                                      diff |= MD_MOVECOUNT;
            if( mobj->threshold     )                                      diff |= MD_THRESHOLD;
            if( mobj->lastlook      != -1 )                                diff |= MD_LASTLOOK;
            if( mobj->target        )                                      diff |= MD_TARGET;
            if( mobj->tracer        )                                      diff |= MD_TRACER;
            if( mobj->friction      !=ORIG_FRICTION             )          diff |= MD_FRICTION;
            if( mobj->movefactor    !=ORIG_FRICTION_FACTOR      )          diff |= MD_MOVEFACTOR;
            if( mobj->special1      )                                      diff |= MD_SPECIAL1;
            if( mobj->special2      )                                      diff |= MD_SPECIAL2;

            PADSAVEP();
            WRITEBYTE(save_p, tc_mobj);
            WRITEULONG(save_p, diff);
            WRITEULONG(save_p, (ULONG)mobj);

            if( diff & MD_SPAWNPOINT )   WRITESHORT(save_p, mobj->spawnpoint-mapthings);
            if( diff & MD_TYPE       )   WRITEULONG(save_p, mobj->type);
            if( diff & MD_POS        ) { WRITEFIXED(save_p, mobj->x);
                                         WRITEFIXED(save_p, mobj->y);
                                         WRITEANGLE(save_p, mobj->angle);     }
            if( diff & MD_Z          )   WRITEFIXED(save_p, mobj->z);
            if( diff & MD_MOM        ) { WRITEFIXED(save_p, mobj->momx);
                                         WRITEFIXED(save_p, mobj->momy);
                                         WRITEFIXED(save_p, mobj->momz);      }
            if( diff & MD_RADIUS     )   WRITEFIXED(save_p, mobj->radius      );
            if( diff & MD_HEIGHT     )   WRITEFIXED(save_p, mobj->height      );
            if( diff & MD_FLAGS      )   WRITELONG (save_p, mobj->flags       );
            if( diff & MD_FLAGS2     )   WRITELONG (save_p, mobj->flags2      );
            if( diff & MD_HEALTH     )   WRITELONG (save_p, mobj->health      );
            if( diff & MD_RTIME      )   WRITELONG (save_p, mobj->reactiontime);
            if( diff & MD_STATE      )  WRITEUSHORT(save_p, mobj->state-states);
            if( diff & MD_TICS       )   WRITELONG (save_p, mobj->tics        );
            if( diff & MD_SPRITE     )  WRITEUSHORT(save_p, mobj->sprite      );
            if( diff & MD_FRAME      )   WRITEULONG(save_p, mobj->frame       );
            if( diff & MD_EFLAGS     )   WRITEULONG(save_p, mobj->eflags      );
            if( diff & MD_PLAYER     )   WRITEBYTE (save_p, mobj->player-players );
            if( diff & MD_MOVEDIR    )   WRITELONG (save_p, mobj->movedir     );