static void saveg_read_ticcmd_t(ticcmd_t *str)
{
// signed char forwardmove;
str->forwardmove = saveg_read8();
// signed char sidemove;
str->sidemove = saveg_read8();
// short angleturn;
str->angleturn = saveg_read16();
// short consistancy;
// STRIFE-FIXME: throwing away top byte of consistancy until
// the true Strife ticcmd_t structure is available.
str->consistancy = (byte)saveg_read16();
// byte chatchar;
str->chatchar = saveg_read8();
// byte buttons;
str->buttons = saveg_read8();
// byte buttons2;
str->buttons2 = saveg_read8(); // [STRIFE]
// int inventory;
str->inventory = saveg_read32(); // [STRIFE]
}
void P_UnArchiveMacros(void) {
int i;
int current;
byte havemacro;
saveg_read_pad();
// [kex] 12/26/11 - read tracked info for disabled macros
for(i = 0; i < macros.macrocount; i++) {
if(saveg_read8()) {
macros.def[i].data[0].id = 0;
}
}
havemacro = saveg_read8();
if(!havemacro) {
return;
}
macroid = saveg_read16();
macrocounter = saveg_read16();
current = saveg_read16();
mobjmacro = saveg_read_mobjindex();
taglistidx = saveg_read16();
macro = ¯os.def[macroid];
nextmacro = ¯o->data[current];
for(i = 0; i < MAXQUEUELIST; i++) {
taglist[i] = saveg_read16();
}
}
//
// ticcmd_t
//
static void saveg_read_ticcmd_t(ticcmd_t *str)
{
str->forwardmove = saveg_read8();
str->sidemove = saveg_read8();
str->angleturn = saveg_read16();
str->buttons = saveg_read8();
str->lookdir = saveg_read32();
}
static short saveg_read16(void) {
int result;
result = saveg_read8();
result |= saveg_read8() << 8;
return result;
}
static void saveg_read_header(void) {
int i;
int size;
byte a, b, c;
// skip the description field
for(i = 0; i < SAVESTRINGSIZE; i++) {
saveg_read8();
}
// skip the date
for(i = 0; i < 32; i++) {
saveg_read8();
}
size = saveg_read32() / sizeof(int);
// skip the thumbnail
for(i = 0; i < size; i++) {
saveg_read32();
}
for(i = 0; i < 16; i++) {
passwordData[i] = saveg_read8();
}
gameskill = saveg_read8();
gamemap = saveg_read8();
nextmap = saveg_read8();
saveg_read_pad();
globalint = saveg_read16();
//
// [kex] 12/26/11 - read total stat info
//
saveg_read_pad();
totalkills = saveg_read32();
totalitems = saveg_read32();
totalsecret = saveg_read32();
for(i = 0; i < MAXPLAYERS; i++) {
playeringame[i] = saveg_read8();
}
// get the times
a = saveg_read8();
b = saveg_read8();
c = saveg_read8();
leveltime = (a<<16) + (b<<8) + c;
saveg_read_pad();
}
static int saveg_read32(void) {
int result;
result = saveg_read8();
result |= saveg_read8() << 8;
result |= saveg_read8() << 16;
result |= saveg_read8() << 24;
return result;
}
boolean P_ReadSaveGameHeader(void)
{
int i;
byte a, b, c;
char vcheck[VERSIONSIZE];
char read_vcheck[VERSIONSIZE];
// skip the description field
for (i=0; i<SAVESTRINGSIZE; ++i)
saveg_read8();
for (i=0; i<VERSIONSIZE; ++i)
read_vcheck[i] = saveg_read8();
memset(vcheck, 0, sizeof(vcheck));
M_snprintf(vcheck, sizeof(vcheck), "version %i", G_VanillaVersionCode());
if (strcmp(read_vcheck, vcheck) != 0)
return false; // bad version
gameskill = saveg_read8();
gameepisode = saveg_read8();
gamemap = saveg_read8();
for (i=0 ; i<MAXPLAYERS ; i++)
playeringame[i] = saveg_read8();
// get the times
a = saveg_read8();
b = saveg_read8();
c = saveg_read8();
leveltime = (a<<16) + (b<<8) + c;
return true;
}
// Pad to 4-byte boundaries
static void saveg_read_pad(void)
{
unsigned long pos = ftell(save_stream);
int padding = (4 - (pos & 3)) & 3;
for (int i = 0; i < padding; i++)
saveg_read8();
}
//
// Read the header for a savegame
//
dboolean P_ReadSaveGameHeader(char *description)
{
byte a, b, c;
char vcheck[VERSIONSIZE];
char read_vcheck[VERSIONSIZE];
for (int i = 0; i < SAVESTRINGSIZE; i++)
description[i] = saveg_read8();
for (int i = 0; i < VERSIONSIZE; i++)
read_vcheck[i] = saveg_read8();
memset(vcheck, 0, sizeof(vcheck));
strcpy(vcheck, PACKAGE_SAVEGAMEVERSIONSTRING);
if (strcmp(read_vcheck, vcheck))
{
menuactive = false;
C_ShowConsole();
C_Warning("This savegame requires <i>%s</i>.", read_vcheck);
return false; // bad version
}
gameskill = (skill_t)saveg_read8();
gameepisode = saveg_read8();
gamemap = saveg_read8();
if (gamemode != commercial)
{
if (gamemap == 10)
{
gamemap = 4;
M_StringCopy(speciallumpname, "E1M4B", 6);
}
else if (gamemap == 11)
{
gamemap = 8;
M_StringCopy(speciallumpname, "E1M8B", 6);
}
}
saveg_read8();
// get the times
a = saveg_read8();
b = saveg_read8();
c = saveg_read8();
leveltime = (a << 16) + (b << 8) + c;
return true;
}
boolean P_ReadSaveGameEOF(void)
{
int value;
value = saveg_read8();
return value == SAVEGAME_EOF;
}
static void saveg_read_ticcmd_t(ticcmd_t *str)
{
// signed char forwardmove;
str->forwardmove = saveg_read8();
// signed char sidemove;
str->sidemove = saveg_read8();
// short angleturn;
str->angleturn = saveg_read16();
// short consistancy;
str->consistancy = saveg_read16();
// byte chatchar;
str->chatchar = saveg_read8();
// byte buttons;
str->buttons = saveg_read8();
}
//
// P_UnArchiveThinkers
//
void P_UnArchiveThinkers (void)
{
byte tclass;
thinker_t* currentthinker;
thinker_t* next;
mobj_t* mobj;
// 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 = saveg_read8();
switch (tclass)
{
case tc_end:
return; // end of list
case tc_mobj:
saveg_read_pad();
mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
saveg_read_mobj_t(mobj);
mobj->target = NULL;
mobj->tracer = NULL;
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);
}
}
}
dboolean P_QuickReadSaveHeader(char* name, char* date,
int* thumbnail, int* skill, int* map) {
int i;
int size;
if(M_ReadFile(name, &savebuffer) == -1) {
return 0;
}
save_offset = 0;
// skip the description field
for(i = 0; i < SAVESTRINGSIZE; i++) {
saveg_read8();
}
for(i = 0; i < 32; i++) {
date[i] = saveg_read8();
}
size = saveg_read32() / sizeof(int);
for(i = 0; i < size; i++) {
thumbnail[i] = saveg_read32();
}
// skip password
for(i = 0; i < 16; i++) {
saveg_read8();
}
*skill = saveg_read8();
*map = saveg_read8();
Z_Free(savebuffer);
return 1;
}
static void saveg_read_pad(void)
{
unsigned long pos;
int padding;
int i;
pos = f_tell (&save_stream);
padding = (4 - (pos & 3)) & 3;
for (i=0; i<padding; ++i)
{
saveg_read8();
}
}
static void saveg_read_ticcmd_t(ticcmd_t* cmd) {
cmd->forwardmove = saveg_read8();
cmd->sidemove = saveg_read8();
cmd->angleturn = saveg_read16();
cmd->pitch = saveg_read16();
cmd->consistancy = saveg_read8();
cmd->chatchar = saveg_read8();
cmd->buttons = saveg_read8();
cmd->buttons2 = saveg_read8();
}
boolean P_ReadSaveGameHeader(void)
{
int i;
byte a, b, c;
char vcheck[VERSIONSIZE];
char read_vcheck[VERSIONSIZE];
// skip the description field
/*
for (i=0; i<SAVESTRINGSIZE; ++i)
saveg_read8();
*/
for (i=0; i<VERSIONSIZE; ++i)
read_vcheck[i] = saveg_read8();
memset (vcheck,0,sizeof(vcheck));
snprintf(vcheck, sizeof(vcheck), "ver %i", STRIFE_VERSION);
if (strcmp(read_vcheck, vcheck) != 0)
return false; // bad version
gameskill = saveg_read8();
// [STRIFE] This info is implicit in the file being read.
//gameepisode = saveg_read8();
//gamemap = saveg_read8();
for (i=0 ; i<MAXPLAYERS ; i++)
playeringame[i] = saveg_read8();
// get the times
a = saveg_read8();
b = saveg_read8();
c = saveg_read8();
leveltime = (a<<16) + (b<<8) + c;
return true;
}
//
// P_UnArchiveSpecials
//
void P_UnArchiveSpecials (void)
{
byte tclass;
ceiling_t* ceiling;
vldoor_t* door;
floormove_t* floor;
plat_t* plat;
lightflash_t* flash;
strobe_t* strobe;
glow_t* glow;
// read in saved thinkers
while (1)
{
tclass = saveg_read8();
switch (tclass)
{
case tc_endspecials:
return; // end of list
case tc_ceiling:
saveg_read_pad();
ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVEL, NULL);
saveg_read_ceiling_t(ceiling);
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:
saveg_read_pad();
door = Z_Malloc (sizeof(*door), PU_LEVEL, NULL);
saveg_read_vldoor_t(door);
door->sector->specialdata = door;
door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
P_AddThinker (&door->thinker);
break;
case tc_floor:
saveg_read_pad();
floor = Z_Malloc (sizeof(*floor), PU_LEVEL, NULL);
saveg_read_floormove_t(floor);
floor->sector->specialdata = floor;
floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
P_AddThinker (&floor->thinker);
break;
case tc_plat:
saveg_read_pad();
plat = Z_Malloc (sizeof(*plat), PU_LEVEL, NULL);
saveg_read_plat_t(plat);
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:
saveg_read_pad();
flash = Z_Malloc (sizeof(*flash), PU_LEVEL, NULL);
saveg_read_lightflash_t(flash);
flash->thinker.function.acp1 = (actionf_p1)T_LightFlash;
P_AddThinker (&flash->thinker);
break;
case tc_strobe:
saveg_read_pad();
strobe = Z_Malloc (sizeof(*strobe), PU_LEVEL, NULL);
saveg_read_strobe_t(strobe);
strobe->thinker.function.acp1 = (actionf_p1)T_StrobeFlash;
P_AddThinker (&strobe->thinker);
break;
case tc_glow:
saveg_read_pad();
glow = Z_Malloc (sizeof(*glow), PU_LEVEL, NULL);
saveg_read_glow_t(glow);
glow->thinker.function.acp1 = (actionf_p1)T_Glow;
P_AddThinker (&glow->thinker);
break;
default:
I_Error ("P_UnarchiveSpecials:Unknown tclass %i "
"in savegame",tclass);
}
}
}
static void saveg_read_mobj_t(mobj_t *str)
{
int pl;
// thinker_t thinker;
saveg_read_thinker_t(&str->thinker);
// fixed_t x;
str->x = saveg_read32();
// fixed_t y;
str->y = saveg_read32();
// fixed_t z;
str->z = saveg_read32();
// struct mobj_s* snext;
str->snext = saveg_readp();
// struct mobj_s* sprev;
str->sprev = saveg_readp();
// angle_t angle;
str->angle = saveg_read32();
// spritenum_t sprite;
str->sprite = saveg_read_enum();
// int frame;
str->frame = saveg_read32();
// struct mobj_s* bnext;
str->bnext = saveg_readp();
// struct mobj_s* bprev;
str->bprev = saveg_readp();
// struct subsector_s* subsector;
str->subsector = saveg_readp();
// fixed_t floorz;
str->floorz = saveg_read32();
// fixed_t ceilingz;
str->ceilingz = saveg_read32();
// fixed_t radius;
str->radius = saveg_read32();
// fixed_t height;
str->height = saveg_read32();
// fixed_t momx;
str->momx = saveg_read32();
// fixed_t momy;
str->momy = saveg_read32();
// fixed_t momz;
str->momz = saveg_read32();
// int validcount;
str->validcount = saveg_read32();
// mobjtype_t type;
str->type = saveg_read_enum();
// mobjinfo_t* info;
str->info = saveg_readp();
// int tics;
str->tics = saveg_read32();
// state_t* state;
str->state = &states[saveg_read32()];
// int flags;
str->flags = saveg_read32();
// int health;
str->health = saveg_read32();
// int movedir;
str->movedir = saveg_read32();
// int movecount;
str->movecount = saveg_read32();
// struct mobj_s* target;
str->target = saveg_readp();
// int reactiontime;
str->reactiontime = saveg_read32();
// int threshold;
str->threshold = saveg_read32();
// struct player_s* player;
pl = saveg_read32();
if (pl > 0)
{
str->player = &players[pl - 1];
str->player->mo = str;
}
else
{
str->player = NULL;
}
// int lastlook;
str->lastlook = saveg_read32();
// mapthing_t spawnpoint;
saveg_read_mapthing_t(&str->spawnpoint);
// struct mobj_s* tracer;
str->tracer = saveg_readp();
// byte miscdata;
str->miscdata = saveg_read8(); // [STRIFE] Only change to mobj_t.
}
//
// Read the end of file marker. Returns true if read successfully.
//
dboolean P_ReadSaveGameEOF(void)
{
return (saveg_read8() == SAVEGAME_EOF);
}
//
// P_UnArchiveWorld
//
void P_UnArchiveWorld(void) {
int i;
int j;
sector_t *sec;
line_t *li;
light_t *light;
side_t *si;
// do sectors
for(i = 0, sec = sectors; i < numsectors; i++, sec++) {
sec->floorheight = INT2F(saveg_read16());
sec->ceilingheight = INT2F(saveg_read16());
sec->floorpic = saveg_read16();
sec->ceilingpic = saveg_read16();
sec->special = saveg_read16();
sec->tag = saveg_read16();
sec->flags = saveg_read16();
sec->lightlevel = saveg_read16();
sec->xoffset = saveg_read32();
sec->yoffset = saveg_read32();
saveg_set_mobjtarget(&sec->soundtarget, saveg_read_mobjindex());
for(j = 0; j < 5; j++) {
sec->colors[j] = saveg_read16();
}
sec->specialdata = 0;
}
// do lines
for(i = 0, li = lines; i < numlines; i++, li++) {
li->flags = (saveg_read16() << 16);
li->flags = li->flags | (saveg_read16() & 0xFFFF);
li->special = saveg_read16();
li->tag = saveg_read16();
for(j = 0; j < 2; j++) {
if(li->sidenum[j] == NO_SIDE_INDEX) {
continue;
}
si = &sides[li->sidenum[j]];
si->textureoffset = INT2F(saveg_read16());
si->rowoffset = INT2F(saveg_read16());
si->toptexture = saveg_read16();
si->bottomtexture = saveg_read16();
si->midtexture = saveg_read16();
}
}
// do lights
for(i = 0, light = lights; i < numlights; i++, light++) {
light->base_r = saveg_read8();
light->base_g = saveg_read8();
light->base_b = saveg_read8();
light->active_r = saveg_read8();
light->active_g = saveg_read8();
light->active_b = saveg_read8();
light->r = saveg_read8();
light->g = saveg_read8();
light->b = saveg_read8();
saveg_read_pad();
light->tag = saveg_read16();
}
}
void P_UnArchiveSpecials(void) {
int i;
dboolean specialthinker;
byte tclass;
void* thinker;
thinker_t* currentthinker;
thinker_t* next;
// remove all the current thinkers
currentthinker = thinkercap.next;
while(currentthinker != &thinkercap) {
next = currentthinker->next;
Z_Free(currentthinker);
currentthinker = next;
}
thinkercap.prev = thinkercap.next = &thinkercap;
while(1) {
tclass = saveg_read8();
if(tclass == tc_endthinkers) {
return;
}
if(tclass > tc_endthinkers) {
I_Error("P_UnarchiveSpecials: Unknown tclass %i in savegame", tclass);
}
for(i = 0; saveg_specials[i].type != tc_endthinkers; i++) {
if(tclass == saveg_specials[i].type) {
saveg_read_pad();
thinker = Z_Malloc(saveg_specials[i].structsize, PU_LEVEL, NULL);
saveg_specials[i].readfunc(thinker);
((thinker_t*)thinker)->function.acp1 = (actionf_p1)saveg_specials[i].function.acp1;
P_AddThinker(thinker);
// handle special cases
switch(tclass) {
case tc_ceiling:
specialthinker = saveg_read32();
if(!specialthinker) {
((thinker_t*)thinker)->function.acp1 = NULL;
}
P_AddActiveCeiling(thinker);
break;
case tc_plat:
specialthinker = saveg_read32();
if(!specialthinker) {
((thinker_t*)thinker)->function.acp1 = NULL;
}
P_AddActivePlat(thinker);
break;
case tc_combine:
P_CombineLightSpecials(((combine_t*)thinker)->sector);
P_RemoveThinker(thinker);
break;
}
if(((thinker_t*)thinker)->function.acp1 != NULL) {
specialthinker = saveg_read32();
if(specialthinker) {
macrothinker = (thinker_t*)thinker;
}
}
break;
}
}
}
}
//
// P_UnArchiveSpecials
//
void P_UnArchiveSpecials(void)
{
// read in saved thinkers
while (true)
{
byte tclass = saveg_read8();
switch (tclass)
{
case tc_endspecials:
// end of list
return;
case tc_ceiling:
{
ceiling_t *ceiling = Z_Malloc(sizeof(*ceiling), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_ceiling_t(ceiling);
ceiling->sector->ceilingdata = ceiling;
ceiling->thinker.function = T_MoveCeiling;
P_AddThinker(&ceiling->thinker);
P_AddActiveCeiling(ceiling);
break;
}
case tc_door:
{
vldoor_t *door = Z_Malloc(sizeof(*door), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_vldoor_t(door);
door->sector->ceilingdata = door;
door->thinker.function = T_VerticalDoor;
P_AddThinker(&door->thinker);
break;
}
case tc_floor:
{
floormove_t *floor = Z_Malloc(sizeof(*floor), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_floormove_t(floor);
floor->sector->floordata = floor;
floor->thinker.function = T_MoveFloor;
P_AddThinker(&floor->thinker);
break;
}
case tc_plat:
{
plat_t *plat = Z_Malloc(sizeof(*plat), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_plat_t(plat);
plat->sector->floordata = plat;
P_AddThinker(&plat->thinker);
P_AddActivePlat(plat);
break;
}
case tc_flash:
{
lightflash_t *flash = Z_Malloc(sizeof(*flash), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_lightflash_t(flash);
flash->thinker.function = T_LightFlash;
P_AddThinker(&flash->thinker);
break;
}
case tc_strobe:
{
strobe_t *strobe = Z_Malloc(sizeof(*strobe), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_strobe_t(strobe);
strobe->thinker.function = T_StrobeFlash;
P_AddThinker(&strobe->thinker);
break;
}
case tc_glow:
{
glow_t *glow = Z_Malloc(sizeof(*glow), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_glow_t(glow);
glow->thinker.function = T_Glow;
P_AddThinker(&glow->thinker);
break;
}
case tc_fireflicker:
{
fireflicker_t *fireflicker = Z_Malloc(sizeof(*fireflicker), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_fireflicker_t(fireflicker);
fireflicker->thinker.function = T_FireFlicker;
P_AddThinker(&fireflicker->thinker);
break;
}
case tc_elevator:
{
elevator_t *elevator = Z_Malloc(sizeof(*elevator), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_elevator_t(elevator);
elevator->sector->ceilingdata = elevator;
elevator->thinker.function = T_MoveElevator;
P_AddThinker(&elevator->thinker);
break;
}
case tc_scroll:
{
scroll_t *scroll = Z_Malloc(sizeof(*scroll), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_scroll_t(scroll);
scroll->thinker.function = T_Scroll;
P_AddThinker(&scroll->thinker);
break;
}
case tc_pusher:
{
pusher_t *pusher = Z_Malloc(sizeof(*pusher), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_pusher_t(pusher);
pusher->thinker.function = T_Pusher;
pusher->source = P_GetPushThing(pusher->affectee);
P_AddThinker(&pusher->thinker);
break;
}
case tc_button:
{
button_t *button = Z_Malloc(sizeof(*button), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_button_t(button);
P_StartButton(button->line, button->where, button->btexture, button->btimer);
break;
}
default:
I_Error("This savegame is invalid.");
}
}
}
//
// P_UnArchiveThinkers
//
void P_UnArchiveThinkers(void)
{
thinker_t *currentthinker = thinkers[th_all].next;
// remove all the current thinkers
while (currentthinker != &thinkers[th_all])
{
thinker_t *next = currentthinker->next;
if (currentthinker->function == P_MobjThinker || currentthinker->function == MusInfoThinker)
{
P_RemoveMobj((mobj_t *)currentthinker);
P_RemoveThinkerDelayed(currentthinker);
}
else
Z_Free(currentthinker);
currentthinker = next;
}
P_InitThinkers();
// remove all bloodsplats
for (int i = 0; i < numsectors; i++)
{
bloodsplat_t *splat = sectors[i].splatlist;
while (splat)
{
bloodsplat_t *next = splat->snext;
P_UnsetBloodSplatPosition(splat);
splat = next;
}
}
r_bloodsplats_total = 0;
thingindex = 0;
// read in saved thinkers
while (true)
{
byte tclass = saveg_read8();
switch (tclass)
{
case tc_end:
return; // end of list
case tc_mobj:
{
mobj_t *mobj = Z_Calloc(1, sizeof(*mobj), PU_LEVEL, NULL);
saveg_read_pad();
saveg_read_mobj_t(mobj);
mobj->info = &mobjinfo[mobj->type];
P_SetThingPosition(mobj);
mobj->thinker.function = (mobj->type == MT_MUSICSOURCE ? MusInfoThinker : P_MobjThinker);
P_AddThinker(&mobj->thinker);
mobj->colfunc = mobj->info->colfunc;
mobj->altcolfunc = mobj->info->altcolfunc;
P_SetShadowColumnFunction(mobj);
thingindex = MIN(thingindex + 1, TARGETLIMIT - 1);
break;
}
case tc_bloodsplat:
{
bloodsplat_t *splat = calloc(1, sizeof(*splat));
saveg_read_pad();
saveg_read_bloodsplat_t(splat);
if (r_bloodsplats_total < r_bloodsplats_max)
{
splat->width = spritewidth[splat->patch];
splat->sector = R_PointInSubsector(splat->x, splat->y)->sector;
P_SetBloodSplatPosition(splat);
splat->colfunc = (splat->blood == FUZZYBLOOD ? fuzzcolfunc : bloodsplatcolfunc);
r_bloodsplats_total++;
}
break;
}
default:
I_Error("This savegame is invalid.");
}
}
}
//
// P_UnArchiveThinkers
//
void P_UnArchiveThinkers (void)
{
byte tclass;
thinker_t* currentthinker;
thinker_t* next;
mobj_t* mobj;
// 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 = saveg_read8();
switch (tclass)
{
case tc_end:
return; // end of list
case tc_mobj:
saveg_read_pad();
mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
saveg_read_mobj_t(mobj);
// haleyjd 09/29/10: Strife sets the targets of non-allied creatures
// who had a non-NULL target at save time to players[0].mo so that
// they won't fall back asleep.
//
// BUG: As the player may not have been spawned yet, we could be
// setting monsters' targets to the mobj which was spawned by
// P_SetupLevel and then removed just above. Due to a subtle glitch
// in the DOOM engine whereby all things removed in this function
// are leaked until the next time P_SetupLevel is called, this is a
// safe operation - the call to P_InitThinkers above stops any of
// the objects removed, including the player's previous body, from
// being passed to Z_Free. One glitch relying on another!
if(mobj->target != NULL && (mobj->flags & MF_ALLY) != MF_ALLY)
mobj->target = players[0].mo;
else
mobj->target = NULL;
// WARNING! Strife does not seem to set tracer! I am leaving it be
// for now because so far no crashes have been observed, and failing
// to set this here will almost certainly crash Choco.
mobj->tracer = NULL;
P_SetThingPosition (mobj);
mobj->info = &mobjinfo[mobj->type];
// [STRIFE]: doesn't set these
//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);
}
}
}
