simulation
Class CEntityManager

class CEntityManager

m_collisionPatches

private std::vector< CEntity* >* m_collisionPatches;

m_collisionPatchesPerSide

private int m_collisionPatchesPerSide;

m_death

private bool m_death;

m_entities

private CHandle m_entities[ 4096 ];

m_entityClassData

private std::map< size_t, std::map< CStrW, int > > m_entityClassData;

m_extant

private static bool m_extant;

m_nextalloc

private int m_nextalloc;

m_reaper

private std::vector< CEntity* > m_reaper;

m_refd

private std::bitset< 4096 > m_refd;

m_screenshotMode

public bool m_screenshotMode;

CEntityManager

public CEntityManager();

~CEntityManager

public ~CEntityManager();

AddEntityClassData

public void AddEntityClassData( const HEntity& handle );

ConformAll

public void ConformAll();

Create

 HEntity Create( CEntityTemplate* base, CVector3D position, float orientation, const std::set< CStr >& actorSelections, const CStrW* building );

Create

public HEntity Create( const CStrW& templateName, CPlayer* player, CVector3D position, float orientation, const CStrW* building = 0 );

Create

public HEntity Create( CEntityTemplate* base, CVector3D position, float orientation, const std::set< CStr8 >& actorSelections, const CStrW* building = 0 );

CreateFoundation

public HEntity CreateFoundation( const CStrW& templateName, CPlayer* player, CVector3D position, float orientation );

DeleteAll

public void DeleteAll();

DeleteAllHelper

private void DeleteAllHelper();

Destroy

private void Destroy( u16 handle );

EntityPredicateLogicalAnd

public static bool EntityPredicateLogicalAnd( CEntity* target, void* userdata );

EntityPredicateLogicalNot

public static bool EntityPredicateLogicalNot( CEntity* target, void* userdata );

EntityPredicateLogicalOr

public static bool EntityPredicateLogicalOr( CEntity* target, void* userdata );

GetByHandle

public HEntity* GetByHandle( u16 index );

GetCollisionPatch

public std::vector< CEntity* >* GetCollisionPatch( CEntity* e );

GetDeath

public bool GetDeath();

GetExtant

public void GetExtant( std::vector< CEntity* >& results );

GetExtantAsHandles

public void GetExtantAsHandles( std::vector< HEntity >& results );

GetHandle

public CHandle* GetHandle( int index );

GetInLOS

public void GetInLOS( CEntity* entity, std::vector< CEntity* >& results );

GetInRange

public void GetInRange( float x, float z, float radius, std::vector< CEntity* >& results );

GetMatchingAsHandles

public void GetMatchingAsHandles( std::vector< HEntity >& matchlist, CEntityManager::EntityPredicate predicate, void* userdata = 0 );

GetPlayerUnitCount

public inline int GetPlayerUnitCount( size_t player, const CStrW& name );

InitializeAll

public void InitializeAll();

InterpolateAll

public void InterpolateAll( float relativeoffset );

InvalidateAll

public void InvalidateAll();

IsEntityRefd

private inline bool IsEntityRefd( u16 index );

IsExtant

public static inline bool IsExtant();

RemoveUnitCount

public void RemoveUnitCount( CEntity* ent );

RenderAll

public void RenderAll();

SetDeath

public void SetDeath( bool set );

UpdateAll

public void UpdateAll( size_t timestep );