Iskhodnyy_kod_Doom

// do lines

for (i=0, li = lines ; i<numlines ; i++,li++)

{

*put++ = li->flags; *put++ = li->special; *put++ = li->tag;

for (j=0 ; j<2 ; j++)

{

if (li->sidenum[j] == -1)

continue;

si = &sides[li->sidenum[j]];

*put++ = si->textureoffset >> FRACBITS; *put++ = si->rowoffset >> FRACBITS; *put++ = si->toptexture;

*put++ = si->bottomtexture; *put++ = si->midtexture;

}

}

save_p = (byte *)put;

}

//

// P_UnArchiveWorld

//

void P_UnArchiveWorld (void)

{

// do sectors

for (i=0, sec = sectors ; i<numsectors ; i++,sec++)

{

521

li->special = *get++; li->tag = *get++;

for (j=0 ; j<2 ; j++)

{

if (li->sidenum[j] == -1) continue;

si = &sides[li->sidenum[j]]; si->textureoffset = *get++ << FRACBITS; si->rowoffset = *get++ << FRACBITS; si->toptexture = *get++; si->bottomtexture = *get++; si->midtexture = *get++;

}

}

save_p = (byte *)get;

}

//

// Thinkers

//

typedef enum

{

tc_end, tc_mobj

} thinkerclass_t;

//

// P_ArchiveThinkers

//

void P_ArchiveThinkers (void)

{

{

if (th->function.acp1 == (actionf_p1)P_MobjThinker)

{

*save_p++ = tc_mobj; PADSAVEP();

mobj = (mobj_t *)save_p;

memcpy (mobj, th, sizeof(*mobj)); save_p += sizeof(*mobj);

mobj->state = (state_t *)(mobj->state - states);

if (mobj->player)

mobj->player = (player_t *)((mobj->player-players) + 1); continue;

}

// I_Error ("P_ArchiveThinkers: Unknown thinker function");

}

// add a terminating marker *save_p++ = tc_end;

}

522

//

// P_UnArchiveThinkers

//

void P_UnArchiveThinkers (void)

{

// remove all the current thinkers currentthinker = thinkercap.next; while (currentthinker != &thinkercap)

{

next = currentthinker->next;

if (currentthinker->function.acp1 == (actionf_p1)P_MobjThinker) P_RemoveMobj ((mobj_t *)currentthinker);

else

Z_Free (currentthinker);

currentthinker = next;

}

P_InitThinkers ();

// read in saved thinkers while (1)

{

tclass = *save_p++; switch (tclass)

{

case tc_mobj: PADSAVEP();

mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL); memcpy (mobj, save_p, sizeof(*mobj));

save_p += sizeof(*mobj);

mobj->state = &states[(int)mobj->state]; mobj->target = NULL;

if (mobj->player)

{

mobj->player = &players[(int)mobj->player-1]; mobj->player->mo = mobj;

}

P_SetThingPosition (mobj); mobj->info = &mobjinfo[mobj->type];

mobj->floorz = mobj->subsector->sector->floorheight; mobj->ceilingz = mobj->subsector->sector->ceilingheight; mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker; P_AddThinker (&mobj->thinker);

break;

default:

I_Error ("Unknown tclass %i in savegame",tclass);

}

}

}

523

//

// P_ArchiveSpecials

//

enum

{

tc_ceiling, tc_door, tc_floor, tc_plat, tc_flash, tc_strobe, tc_glow, tc_endspecials

} specials_e;

//

//Things to handle:

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

//

void P_ArchiveSpecials (void)

{

// save off the current thinkers

for (th = thinkercap.next ; th != &thinkercap ; th=th->next)

{

if (th->function.acv == (actionf_v)NULL)

{

for (i = 0; i < MAXCEILINGS;i++)

if (activeceilings[i] == (ceiling_t *)th) break;

if (i<MAXCEILINGS)

{

*save_p++ = tc_ceiling; PADSAVEP();

ceiling = (ceiling_t *)save_p;

memcpy (ceiling, th, sizeof(*ceiling)); save_p += sizeof(*ceiling);

ceiling->sector = (sector_t *)(ceiling->sector - sectors);

}

continue;

}

if (th->function.acp1 == (actionf_p1)T_MoveCeiling)

{

*save_p++ = tc_ceiling;

524

PADSAVEP();

ceiling = (ceiling_t *)save_p;

memcpy (ceiling, th, sizeof(*ceiling)); save_p += sizeof(*ceiling);

ceiling->sector = (sector_t *)(ceiling->sector - sectors); continue;

}

if (th->function.acp1 == (actionf_p1)T_VerticalDoor)

{

*save_p++ = tc_door; PADSAVEP();

door = (vldoor_t *)save_p;

memcpy (door, th, sizeof(*door)); save_p += sizeof(*door);

door->sector = (sector_t *)(door->sector - sectors); continue;

}

if (th->function.acp1 == (actionf_p1)T_MoveFloor)

{

*save_p++ = tc_floor; PADSAVEP();

floor = (floormove_t *)save_p; memcpy (floor, th, sizeof(*floor)); save_p += sizeof(*floor);

floor->sector = (sector_t *)(floor->sector - sectors); continue;

}

if (th->function.acp1 == (actionf_p1)T_PlatRaise)

{

*save_p++ = tc_plat; PADSAVEP();

plat = (plat_t *)save_p;

memcpy (plat, th, sizeof(*plat)); save_p += sizeof(*plat);

plat->sector = (sector_t *)(plat->sector - sectors); continue;

}

if (th->function.acp1 == (actionf_p1)T_LightFlash)

{

*save_p++ = tc_flash; PADSAVEP();

flash = (lightflash_t *)save_p; memcpy (flash, th, sizeof(*flash)); save_p += sizeof(*flash);

flash->sector = (sector_t *)(flash->sector - sectors); continue;

}

if (th->function.acp1 == (actionf_p1)T_StrobeFlash)

{

*save_p++ = tc_strobe; PADSAVEP();

strobe = (strobe_t *)save_p;

memcpy (strobe, th, sizeof(*strobe)); save_p += sizeof(*strobe);

strobe->sector = (sector_t *)(strobe->sector - sectors); continue;

}

if (th->function.acp1 == (actionf_p1)T_Glow)

{

525

*save_p++ = tc_glow; PADSAVEP();

glow = (glow_t *)save_p;

memcpy (glow, th, sizeof(*glow)); save_p += sizeof(*glow);

glow->sector = (sector_t *)(glow->sector - sectors); continue;

}

}

// add a terminating marker *save_p++ = tc_endspecials;

}

//

// P_UnArchiveSpecials

//

void P_UnArchiveSpecials (void)

{

// read in saved thinkers while (1)

{

tclass = *save_p++; switch (tclass)

{

case tc_endspecials:

return; // end of list

case tc_ceiling: PADSAVEP();

ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVEL, NULL); memcpy (ceiling, save_p, sizeof(*ceiling));

save_p += sizeof(*ceiling);

ceiling->sector = &sectors[(int)ceiling->sector]; ceiling->sector->specialdata = ceiling;

if (ceiling->thinker.function.acp1) ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;

P_AddThinker (&ceiling->thinker); P_AddActiveCeiling(ceiling); break;

case tc_door: PADSAVEP();

door = Z_Malloc (sizeof(*door), PU_LEVEL, NULL); memcpy (door, save_p, sizeof(*door));

save_p += sizeof(*door);

door->sector = &sectors[(int)door->sector]; door->sector->specialdata = door; door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor; P_AddThinker (&door->thinker);

break;

526

case tc_floor: PADSAVEP();

floor = Z_Malloc (sizeof(*floor), PU_LEVEL, NULL); memcpy (floor, save_p, sizeof(*floor));

save_p += sizeof(*floor);

floor->sector = &sectors[(int)floor->sector]; floor->sector->specialdata = floor; floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor; P_AddThinker (&floor->thinker);

break;

case tc_plat: PADSAVEP();

plat = Z_Malloc (sizeof(*plat), PU_LEVEL, NULL); memcpy (plat, save_p, sizeof(*plat));

save_p += sizeof(*plat);

plat->sector = &sectors[(int)plat->sector]; plat->sector->specialdata = plat;

if (plat->thinker.function.acp1) plat->thinker.function.acp1 = (actionf_p1)T_PlatRaise;

P_AddThinker (&plat->thinker);

P_AddActivePlat(plat);

break;

case tc_flash: PADSAVEP();

flash = Z_Malloc (sizeof(*flash), PU_LEVEL, NULL); memcpy (flash, save_p, sizeof(*flash));

save_p += sizeof(*flash);

flash->sector = &sectors[(int)flash->sector]; flash->thinker.function.acp1 = (actionf_p1)T_LightFlash; P_AddThinker (&flash->thinker);

break;

case tc_strobe: PADSAVEP();

strobe = Z_Malloc (sizeof(*strobe), PU_LEVEL, NULL); memcpy (strobe, save_p, sizeof(*strobe));

save_p += sizeof(*strobe);

strobe->sector = &sectors[(int)strobe->sector]; strobe->thinker.function.acp1 = (actionf_p1)T_StrobeFlash; P_AddThinker (&strobe->thinker);

break;

case tc_glow: PADSAVEP();

glow = Z_Malloc (sizeof(*glow), PU_LEVEL, NULL); memcpy (glow, save_p, sizeof(*glow));

save_p += sizeof(*glow);

glow->sector = &sectors[(int)glow->sector]; glow->thinker.function.acp1 = (actionf_p1)T_Glow; P_AddThinker (&glow->thinker);

break;

default:

I_Error ("P_UnarchiveSpecials:Unknown tclass %i " "in savegame",tclass);

}

}

}

527

9.19 p saveg.h

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//This program is free software; you can redistribute it and/or

//modify it under the terms of the GNU General Public License

//as published by the Free Software Foundation; either version 2

//of the License, or (at your option) any later version.

//

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

//

//DESCRIPTION:

//Savegame I/O, archiving, persistence.

//-----------------------------------------------------------------------------

#ifndef __P_SAVEG__ #define __P_SAVEG__

#ifdef __GNUG__ #pragma interface #endif

//Persistent storage/archiving.

//These are the load / save game routines. void P_ArchivePlayers (void);

void P_UnArchivePlayers (void); void P_ArchiveWorld (void); void P_UnArchiveWorld (void); void P_ArchiveThinkers (void);

void P_UnArchiveThinkers (void); void P_ArchiveSpecials (void); void P_UnArchiveSpecials (void);

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

528

//

//This program is free software; you can redistribute it and/or

//modify it under the terms of the GNU General Public License

//as published by the Free Software Foundation; either version 2

//of the License, or (at your option) any later version.

//

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

//

//$Log:$

//DESCRIPTION:

//Do all the WAD I/O, get map description,

//set up initial state and misc. LUTs.

//

//-----------------------------------------------------------------------------

static const char

rcsid[] = "$Id: p_setup.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";

#include <math.h>

#include "z_zone.h"

#include "m_swap.h" #include "m_bbox.h"

#include "g_game.h"

#include "i_system.h" #include "w_wad.h"

#include "doomdef.h" #include "p_local.h"

#include "s_sound.h"

#include "doomstat.h"

//

//MAP related Lookup tables.

//Store VERTEXES, LINEDEFS, SIDEDEFS, etc.

529

//BLOCKMAP

//Created from axis aligned bounding box

//of the map, a rectangular array of

//blocks of size ...

//Used to speed up collision detection

//by spatial subdivision in 2D.

//REJECT

//For fast sight rejection.

//Speeds up enemy AI by skipping detailed

//LineOf Sight calculation.

//Without special effect, this could be

//used as a PVS lookup as well.

//

// P_LoadVertexes

//

void P_LoadVertexes (int lump)

{

//Determine number of lumps:

//total lump length / vertex record length. numvertexes = W_LumpLength (lump) / sizeof(mapvertex_t);

//Allocate zone memory for buffer.

vertexes = Z_Malloc (numvertexes*sizeof(vertex_t),PU_LEVEL,0);

530