Directory restructuring to make it easier to version projects that don't build zdoom.exe.
SVN r4 (trunk)
This commit is contained in:
Randy Heit
commit
cf11cbdb30
821 changed files with 361202 additions and 0 deletions
722
src/dobject.cpp
Normal file
722
src/dobject.cpp
Normal file
|
|
@ -0,0 +1,722 @@
|
|||
/*
|
||||
** dobject.cpp
|
||||
** Implements the base class DObject, which most other classes derive from
|
||||
**
|
||||
**---------------------------------------------------------------------------
|
||||
** Copyright 1998-2005 Randy Heit
|
||||
** All rights reserved.
|
||||
**
|
||||
** Redistribution and use in source and binary forms, with or without
|
||||
** modification, are permitted provided that the following conditions
|
||||
** are met:
|
||||
**
|
||||
** 1. Redistributions of source code must retain the above copyright
|
||||
** notice, this list of conditions and the following disclaimer.
|
||||
** 2. Redistributions in binary form must reproduce the above copyright
|
||||
** notice, this list of conditions and the following disclaimer in the
|
||||
** documentation and/or other materials provided with the distribution.
|
||||
** 3. The name of the author may not be used to endorse or promote products
|
||||
** derived from this software without specific prior written permission.
|
||||
**
|
||||
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
**---------------------------------------------------------------------------
|
||||
**
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "cmdlib.h"
|
||||
#include "actor.h"
|
||||
#include "dobject.h"
|
||||
#include "m_alloc.h"
|
||||
#include "doomstat.h" // Ideally, DObjects can be used independant of Doom.
|
||||
#include "d_player.h" // See p_user.cpp to find out why this doesn't work.
|
||||
#include "g_game.h" // Needed for bodyque.
|
||||
#include "c_dispatch.h"
|
||||
#include "i_system.h"
|
||||
#include "r_state.h"
|
||||
#include "stats.h"
|
||||
|
||||
TArray<TypeInfo *> TypeInfo::m_RuntimeActors;
|
||||
TypeInfo **TypeInfo::m_Types;
|
||||
unsigned short TypeInfo::m_NumTypes;
|
||||
unsigned short TypeInfo::m_MaxTypes;
|
||||
unsigned int TypeInfo::TypeHash[256]; // Why can't I use TypeInfo::HASH_SIZE?
|
||||
|
||||
#if defined(_MSC_VER) || defined(__GNUC__)
|
||||
#include "autosegs.h"
|
||||
|
||||
TypeInfo DObject::_StaticType =
|
||||
{
|
||||
"DObject",
|
||||
NULL,
|
||||
sizeof(DObject),
|
||||
};
|
||||
|
||||
void TypeInfo::StaticInit ()
|
||||
{
|
||||
TAutoSegIterator<TypeInfo *, &CRegHead, &CRegTail> probe;
|
||||
|
||||
while (++probe != NULL)
|
||||
{
|
||||
probe->RegisterType ();
|
||||
}
|
||||
}
|
||||
#else
|
||||
TypeInfo DObject::_StaticType(NULL, "DObject", NULL, sizeof(DObject));
|
||||
#endif
|
||||
|
||||
static cycle_t StaleCycles;
|
||||
static int StaleCount;
|
||||
|
||||
void TypeInfo::RegisterType ()
|
||||
{
|
||||
// Add type to list
|
||||
if (m_NumTypes == m_MaxTypes)
|
||||
{
|
||||
m_MaxTypes = m_MaxTypes ? m_MaxTypes*2 : 256;
|
||||
m_Types = (TypeInfo **)Realloc (m_Types, m_MaxTypes * sizeof(*m_Types));
|
||||
}
|
||||
m_Types[m_NumTypes] = this;
|
||||
TypeIndex = m_NumTypes;
|
||||
m_NumTypes++;
|
||||
|
||||
// Add type to hash table. Types are inserted into each bucket
|
||||
// lexicographically, and the prefix character is ignored.
|
||||
unsigned int bucket = MakeKey (Name+1) % HASH_SIZE;
|
||||
unsigned int *hashpos = &TypeHash[bucket];
|
||||
while (*hashpos != 0)
|
||||
{
|
||||
int lexx = strcmp (Name+1, m_Types[*hashpos-1]->Name+1);
|
||||
// (The Lexx is the most powerful weapon of destruction
|
||||
// in the two universes.)
|
||||
|
||||
if (lexx > 0)
|
||||
{ // This type should come later in the chain
|
||||
hashpos = &m_Types[*hashpos-1]->HashNext;
|
||||
}
|
||||
else if (lexx == 0)
|
||||
{ // This type has already been inserted
|
||||
I_FatalError ("Class %s already registered", Name);
|
||||
}
|
||||
else
|
||||
{ // Type comes right here
|
||||
break;
|
||||
}
|
||||
}
|
||||
HashNext = *hashpos;
|
||||
*hashpos = TypeIndex + 1;
|
||||
}
|
||||
|
||||
// Case-sensitive search (preferred)
|
||||
const TypeInfo *TypeInfo::FindType (const char *name)
|
||||
{
|
||||
if (name != NULL)
|
||||
{
|
||||
unsigned int index = TypeHash[MakeKey (name) % HASH_SIZE];
|
||||
|
||||
while (index != 0)
|
||||
{
|
||||
int lexx = strcmp (name, m_Types[index-1]->Name + 1);
|
||||
if (lexx > 0)
|
||||
{
|
||||
index = m_Types[index-1]->HashNext;
|
||||
}
|
||||
else if (lexx == 0)
|
||||
{
|
||||
return m_Types[index-1];
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Case-insensitive search
|
||||
const TypeInfo *TypeInfo::IFindType (const char *name)
|
||||
{
|
||||
if (name != NULL)
|
||||
{
|
||||
for (int i = 0; i < TypeInfo::m_NumTypes; i++)
|
||||
{
|
||||
if (stricmp (TypeInfo::m_Types[i]->Name + 1, name) == 0)
|
||||
return TypeInfo::m_Types[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Create a new object that this type represents
|
||||
DObject *TypeInfo::CreateNew () const
|
||||
{
|
||||
BYTE *mem = (BYTE *)Malloc (SizeOf);
|
||||
ConstructNative (mem);
|
||||
((DObject *)mem)->SetClass (const_cast<TypeInfo *>(this));
|
||||
|
||||
// If this is a scripted extension of a class but not an actor,
|
||||
// initialize any extended space to zero. Actors have defaults, so
|
||||
// we can initialize them better
|
||||
if (ActorInfo != NULL)
|
||||
{
|
||||
AActor *actor = (AActor *)mem;
|
||||
memcpy (&(actor->x), &(((AActor *)ActorInfo->Defaults)->x), SizeOf - ((BYTE *)&actor->x - (BYTE *)actor));
|
||||
}
|
||||
else if (ParentType != 0 &&
|
||||
ConstructNative == ParentType->ConstructNative &&
|
||||
SizeOf > ParentType->SizeOf)
|
||||
{
|
||||
memset (mem + ParentType->SizeOf, 0, SizeOf - ParentType->SizeOf);
|
||||
}
|
||||
return (DObject *)mem;
|
||||
}
|
||||
|
||||
// Create a new type based on an existing type
|
||||
TypeInfo *TypeInfo::CreateDerivedClass (char *name, unsigned int size)
|
||||
{
|
||||
TypeInfo *type = new TypeInfo;
|
||||
|
||||
type->Name = name;
|
||||
type->ParentType = this;
|
||||
type->SizeOf = size;
|
||||
type->Pointers = NULL;
|
||||
type->ConstructNative = ConstructNative;
|
||||
type->RegisterType();
|
||||
type->Meta = Meta;
|
||||
type->FlatPointers = NULL;
|
||||
|
||||
// If this class has an actor info, then any classes derived from it
|
||||
// also need an actor info.
|
||||
if (this->ActorInfo != NULL)
|
||||
{
|
||||
FActorInfo *info = type->ActorInfo = new FActorInfo;
|
||||
info->Class = type;
|
||||
info->Defaults = new BYTE[size];
|
||||
info->GameFilter = GAME_Any;
|
||||
info->SpawnID = 0;
|
||||
info->DoomEdNum = -1;
|
||||
info->OwnedStates = NULL;
|
||||
info->NumOwnedStates = 0;
|
||||
|
||||
memcpy (info->Defaults, ActorInfo->Defaults, SizeOf);
|
||||
if (size > SizeOf)
|
||||
{
|
||||
memset (info->Defaults + SizeOf, 0, size - SizeOf);
|
||||
}
|
||||
m_RuntimeActors.Push (type);
|
||||
}
|
||||
else
|
||||
{
|
||||
type->ActorInfo = NULL;
|
||||
}
|
||||
return type;
|
||||
}
|
||||
|
||||
// Create the FlatPointers array, if it doesn't exist already.
|
||||
// It comprises all the Pointers from superclasses plus this class's own Pointers.
|
||||
// If this class does not define any new Pointers, then FlatPointers will be set
|
||||
// to the same array as the super class's.
|
||||
void TypeInfo::BuildFlatPointers ()
|
||||
{
|
||||
static const size_t TheEnd = ~0;
|
||||
|
||||
if (FlatPointers != NULL)
|
||||
{ // Already built: Do nothing.
|
||||
return;
|
||||
}
|
||||
else if (ParentType == NULL)
|
||||
{ // No parent: FlatPointers is the same as Pointers.
|
||||
if (Pointers == NULL)
|
||||
{ // No pointers: Make FlatPointers a harmless non-NULL.
|
||||
FlatPointers = &TheEnd;
|
||||
}
|
||||
else
|
||||
{
|
||||
FlatPointers = Pointers;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ParentType->BuildFlatPointers ();
|
||||
if (Pointers == NULL)
|
||||
{ // No new pointers: Just use the same FlatPointers as the parent.
|
||||
FlatPointers = ParentType->FlatPointers;
|
||||
}
|
||||
else
|
||||
{ // New pointers: Create a new FlatPointers array and add them.
|
||||
int numPointers, numSuperPointers;
|
||||
|
||||
// Count pointers defined by this class.
|
||||
for (numPointers = 0; Pointers[numPointers] != ~(size_t)0; numPointers++)
|
||||
{ }
|
||||
// Count pointers defined by superclasses.
|
||||
for (numSuperPointers = 0; ParentType->FlatPointers[numSuperPointers] != ~(size_t)0; numSuperPointers++)
|
||||
{ }
|
||||
|
||||
// Concatenate them into a new array
|
||||
size_t *flat = new size_t[numPointers + numSuperPointers + 1];
|
||||
if (numSuperPointers > 0)
|
||||
{
|
||||
memcpy (flat, ParentType->FlatPointers, sizeof(size_t)*numSuperPointers);
|
||||
}
|
||||
memcpy (flat + numSuperPointers, Pointers, sizeof(size_t)*(numPointers+1));
|
||||
FlatPointers = flat;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
FMetaTable::~FMetaTable ()
|
||||
{
|
||||
FreeMeta ();
|
||||
}
|
||||
|
||||
FMetaTable::FMetaTable (const FMetaTable &other)
|
||||
{
|
||||
Meta = NULL;
|
||||
CopyMeta (&other);
|
||||
}
|
||||
|
||||
FMetaTable &FMetaTable::operator = (const FMetaTable &other)
|
||||
{
|
||||
CopyMeta (&other);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void FMetaTable::FreeMeta ()
|
||||
{
|
||||
while (Meta != NULL)
|
||||
{
|
||||
FMetaData *meta = Meta;
|
||||
|
||||
switch (meta->Type)
|
||||
{
|
||||
case META_String:
|
||||
delete meta->Value.String;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
Meta = meta->Next;
|
||||
delete meta;
|
||||
}
|
||||
}
|
||||
|
||||
void FMetaTable::CopyMeta (const FMetaTable *other)
|
||||
{
|
||||
const FMetaData *meta_src;
|
||||
FMetaData **meta_dest;
|
||||
|
||||
FreeMeta ();
|
||||
|
||||
meta_src = other->Meta;
|
||||
meta_dest = &Meta;
|
||||
while (meta_src != NULL)
|
||||
{
|
||||
FMetaData *newmeta = new FMetaData (meta_src->Type, meta_src->ID);
|
||||
switch (meta_src->Type)
|
||||
{
|
||||
case META_String:
|
||||
newmeta->Value.String = copystring (meta_src->Value.String);
|
||||
break;
|
||||
default:
|
||||
newmeta->Value = meta_src->Value;
|
||||
break;
|
||||
}
|
||||
*meta_dest = newmeta;
|
||||
meta_dest = &newmeta->Next;
|
||||
meta_src = meta_src->Next;
|
||||
}
|
||||
*meta_dest = NULL;
|
||||
}
|
||||
|
||||
FMetaData *FMetaTable::FindMeta (EMetaType type, DWORD id) const
|
||||
{
|
||||
FMetaData *meta = Meta;
|
||||
|
||||
while (meta != NULL)
|
||||
{
|
||||
if (meta->ID == id && meta->Type == type)
|
||||
{
|
||||
return meta;
|
||||
}
|
||||
meta = meta->Next;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
FMetaData *FMetaTable::FindMetaDef (EMetaType type, DWORD id)
|
||||
{
|
||||
FMetaData *meta = FindMeta (type, id);
|
||||
if (meta == NULL)
|
||||
{
|
||||
meta = new FMetaData (type, id);
|
||||
meta->Next = Meta;
|
||||
meta->Value.String = NULL;
|
||||
Meta = meta;
|
||||
}
|
||||
return meta;
|
||||
}
|
||||
|
||||
void FMetaTable::SetMetaInt (DWORD id, int parm)
|
||||
{
|
||||
FMetaData *meta = FindMetaDef (META_Int, id);
|
||||
meta->Value.Int = parm;
|
||||
}
|
||||
|
||||
int FMetaTable::GetMetaInt (DWORD id) const
|
||||
{
|
||||
FMetaData *meta = FindMeta (META_Int, id);
|
||||
return meta != NULL ? meta->Value.Int : 0;
|
||||
}
|
||||
|
||||
void FMetaTable::SetMetaFixed (DWORD id, fixed_t parm)
|
||||
{
|
||||
FMetaData *meta = FindMetaDef (META_Fixed, id);
|
||||
meta->Value.Fixed = parm;
|
||||
}
|
||||
|
||||
fixed_t FMetaTable::GetMetaFixed (DWORD id) const
|
||||
{
|
||||
FMetaData *meta = FindMeta (META_Fixed, id);
|
||||
return meta != NULL ? meta->Value.Fixed : 0;
|
||||
}
|
||||
|
||||
void FMetaTable::SetMetaString (DWORD id, const char *parm)
|
||||
{
|
||||
FMetaData *meta = FindMetaDef (META_String, id);
|
||||
ReplaceString (&meta->Value.String, parm);
|
||||
}
|
||||
|
||||
const char *FMetaTable::GetMetaString (DWORD id) const
|
||||
{
|
||||
FMetaData *meta = FindMeta (META_String, id);
|
||||
return meta != NULL ? meta->Value.String : NULL;
|
||||
}
|
||||
|
||||
CCMD (dumpclasses)
|
||||
{
|
||||
const TypeInfo *root;
|
||||
int i;
|
||||
int shown, omitted;
|
||||
bool showall = true;
|
||||
|
||||
if (argv.argc() > 1)
|
||||
{
|
||||
root = TypeInfo::IFindType (argv[1]);
|
||||
if (root == NULL)
|
||||
{
|
||||
Printf ("Class '%s' not found\n", argv[1]);
|
||||
return;
|
||||
}
|
||||
if (stricmp (argv[1], "Actor") == 0)
|
||||
{
|
||||
if (argv.argc() < 3 || stricmp (argv[2], "all") != 0)
|
||||
{
|
||||
showall = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
root = NULL;
|
||||
}
|
||||
|
||||
shown = omitted = 0;
|
||||
for (i = 0; i < TypeInfo::m_NumTypes; i++)
|
||||
{
|
||||
if (root == NULL ||
|
||||
(TypeInfo::m_Types[i]->IsDescendantOf (root) &&
|
||||
(showall || TypeInfo::m_Types[i] == root ||
|
||||
TypeInfo::m_Types[i]->ActorInfo != root->ActorInfo)))
|
||||
{
|
||||
Printf (" %s\n", TypeInfo::m_Types[i]->Name + 1);
|
||||
shown++;
|
||||
}
|
||||
else
|
||||
{
|
||||
omitted++;
|
||||
}
|
||||
}
|
||||
Printf ("%d classes shown, %d omitted\n", shown, omitted);
|
||||
}
|
||||
|
||||
TArray<DObject *> DObject::Objects;
|
||||
TArray<size_t> DObject::FreeIndices;
|
||||
TArray<DObject *> DObject::ToDestroy;
|
||||
bool DObject::Inactive;
|
||||
|
||||
DObject::DObject ()
|
||||
: ObjectFlags(0), Class(0)
|
||||
{
|
||||
if (FreeIndices.Pop (Index))
|
||||
Objects[Index] = this;
|
||||
else
|
||||
Index = Objects.Push (this);
|
||||
}
|
||||
|
||||
DObject::DObject (TypeInfo *inClass)
|
||||
: ObjectFlags(0), Class(inClass)
|
||||
{
|
||||
if (FreeIndices.Pop (Index))
|
||||
Objects[Index] = this;
|
||||
else
|
||||
Index = Objects.Push (this);
|
||||
}
|
||||
|
||||
DObject::~DObject ()
|
||||
{
|
||||
if (!Inactive)
|
||||
{
|
||||
if (!(ObjectFlags & OF_MassDestruction))
|
||||
{
|
||||
RemoveFromArray ();
|
||||
DestroyScan (this);
|
||||
}
|
||||
else if (!(ObjectFlags & OF_Cleanup))
|
||||
{
|
||||
// object is queued for deletion, but is not being deleted
|
||||
// by the destruction process, so remove it from the
|
||||
// ToDestroy array and do other necessary stuff.
|
||||
unsigned int i;
|
||||
|
||||
for (i = ToDestroy.Size() - 1; i-- > 0; )
|
||||
{
|
||||
if (ToDestroy[i] == this)
|
||||
{
|
||||
ToDestroy[i] = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
DestroyScan (this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DObject::Destroy ()
|
||||
{
|
||||
if (!Inactive)
|
||||
{
|
||||
if (!(ObjectFlags & OF_MassDestruction))
|
||||
{
|
||||
RemoveFromArray ();
|
||||
ObjectFlags |= OF_MassDestruction;
|
||||
ToDestroy.Push (this);
|
||||
}
|
||||
}
|
||||
else
|
||||
delete this;
|
||||
}
|
||||
|
||||
void DObject::BeginFrame ()
|
||||
{
|
||||
StaleCycles = 0;
|
||||
StaleCount = 0;
|
||||
}
|
||||
|
||||
void DObject::EndFrame ()
|
||||
{
|
||||
clock (StaleCycles);
|
||||
if (ToDestroy.Size ())
|
||||
{
|
||||
StaleCount += (int)ToDestroy.Size ();
|
||||
DestroyScan ();
|
||||
//Printf ("Destroyed %d objects\n", ToDestroy.Size());
|
||||
|
||||
DObject *obj;
|
||||
while (ToDestroy.Pop (obj))
|
||||
{
|
||||
if (obj)
|
||||
{
|
||||
obj->ObjectFlags |= OF_Cleanup;
|
||||
delete obj;
|
||||
}
|
||||
}
|
||||
}
|
||||
unclock (StaleCycles);
|
||||
}
|
||||
|
||||
void DObject::RemoveFromArray ()
|
||||
{
|
||||
if (Objects.Size() == Index + 1)
|
||||
{
|
||||
DObject *dummy;
|
||||
Objects.Pop (dummy);
|
||||
}
|
||||
else if (Objects.Size() > Index)
|
||||
{
|
||||
Objects[Index] = NULL;
|
||||
FreeIndices.Push (Index);
|
||||
}
|
||||
}
|
||||
|
||||
void DObject::PointerSubstitution (DObject *old, DObject *notOld)
|
||||
{
|
||||
unsigned int i, highest;
|
||||
highest = Objects.Size ();
|
||||
|
||||
for (i = 0; i <= highest; i++)
|
||||
{
|
||||
DObject *current = i < highest ? Objects[i] : &bglobal;
|
||||
if (current)
|
||||
{
|
||||
const TypeInfo *info = current->GetClass();
|
||||
const size_t *offsets = info->FlatPointers;
|
||||
if (offsets == NULL)
|
||||
{
|
||||
const_cast<TypeInfo *>(info)->BuildFlatPointers();
|
||||
offsets = info->FlatPointers;
|
||||
}
|
||||
while (*offsets != ~(size_t)0)
|
||||
{
|
||||
if (*(DObject **)((BYTE *)current + *offsets) == old)
|
||||
{
|
||||
*(DObject **)((BYTE *)current + *offsets) = notOld;
|
||||
}
|
||||
offsets++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < BODYQUESIZE; ++i)
|
||||
{
|
||||
if (bodyque[i] == old)
|
||||
{
|
||||
bodyque[i] = static_cast<AActor *>(notOld);
|
||||
}
|
||||
}
|
||||
|
||||
// This is an ugly hack, but it's the best I can do for now.
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (playeringame[i])
|
||||
players[i].FixPointers (old, notOld);
|
||||
}
|
||||
}
|
||||
|
||||
// Search for references to a single object and NULL them.
|
||||
// It should not be listed in ToDestroy.
|
||||
void DObject::DestroyScan (DObject *obj)
|
||||
{
|
||||
PointerSubstitution (obj, NULL);
|
||||
}
|
||||
|
||||
// Search for references to all objects scheduled for
|
||||
// destruction and NULL them.
|
||||
void DObject::DestroyScan ()
|
||||
{
|
||||
unsigned int i, highest;
|
||||
int j, destroycount;
|
||||
DObject **destroybase;
|
||||
destroycount = (int)ToDestroy.Size ();
|
||||
if (destroycount == 0)
|
||||
return;
|
||||
destroybase = &ToDestroy[0] + destroycount;
|
||||
destroycount = -destroycount;
|
||||
highest = Objects.Size ();
|
||||
|
||||
for (i = 0; i <= highest; i++)
|
||||
{
|
||||
DObject *current = i < highest ? Objects[i] : &bglobal;
|
||||
if (current)
|
||||
{
|
||||
const TypeInfo *info = current->GetClass();
|
||||
const size_t *offsets = info->FlatPointers;
|
||||
if (offsets == NULL)
|
||||
{
|
||||
const_cast<TypeInfo *>(info)->BuildFlatPointers();
|
||||
offsets = info->FlatPointers;
|
||||
}
|
||||
while (*offsets != ~(size_t)0)
|
||||
{
|
||||
j = destroycount;
|
||||
do
|
||||
{
|
||||
if (*(DObject **)((BYTE *)current + *offsets) == *(destroybase + j))
|
||||
{
|
||||
*(DObject **)((BYTE *)current + *offsets) = NULL;
|
||||
}
|
||||
} while (++j);
|
||||
offsets++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
j = destroycount;
|
||||
do
|
||||
{
|
||||
for (i = 0; i < BODYQUESIZE; ++i)
|
||||
{
|
||||
if (bodyque[i] == *(destroybase + j))
|
||||
{
|
||||
bodyque[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
} while (++j);
|
||||
|
||||
// This is an ugly hack, but it's the best I can do for now.
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (playeringame[i])
|
||||
{
|
||||
j = destroycount;
|
||||
do
|
||||
{
|
||||
players[i].FixPointers (*(destroybase + j), NULL);
|
||||
} while (++j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void STACK_ARGS DObject::StaticShutdown ()
|
||||
{
|
||||
Inactive = true;
|
||||
}
|
||||
|
||||
void DObject::Serialize (FArchive &arc)
|
||||
{
|
||||
ObjectFlags |= OF_SerialSuccess;
|
||||
}
|
||||
|
||||
void DObject::CheckIfSerialized () const
|
||||
{
|
||||
if (!(ObjectFlags & OF_SerialSuccess))
|
||||
{
|
||||
I_Error (
|
||||
"BUG: %s::Serialize\n"
|
||||
"(or one of its superclasses) needs to call\n"
|
||||
"Super::Serialize\n",
|
||||
StaticType ()->Name);
|
||||
}
|
||||
}
|
||||
|
||||
FArchive &operator<< (FArchive &arc, const TypeInfo * &info)
|
||||
{
|
||||
if (arc.IsStoring ())
|
||||
{
|
||||
arc.UserWriteClass (info);
|
||||
}
|
||||
else
|
||||
{
|
||||
arc.UserReadClass (info);
|
||||
}
|
||||
return arc;
|
||||
}
|
||||
|
||||
ADD_STAT (destroys, out)
|
||||
{
|
||||
sprintf (out, "Pointer fixing: %d in %04.1f ms",
|
||||
StaleCount, SecondsPerCycle * (double)StaleCycles * 1000);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue