simulation
Class CEntity

IJSComplex
   |
   +--CJSComplex, IEventTarget, boost::noncopyable
         |
         +--CEntity

class CEntity

extends CJSComplex, IEventTarget, boost::noncopyable

ent_flags

public uint ent_flags;

m_actions

public CEntity::ActionTable m_actions;

m_actor

public CUnit* m_actor;

m_actor_transform_valid

public bool m_actor_transform_valid;

m_actorSelections

public std::set< CStr8 > m_actorSelections;

m_ahead

public CVector2D m_ahead;

m_associatedTerritory

public CTerritory* m_associatedTerritory;

m_auras

public CEntity::AuraTable m_auras;

m_aurasInfluencingMe

public CEntity::AuraSet m_aurasInfluencingMe;

m_base

public CEntityTemplate* m_base;

m_bounds

public CBoundingObject* m_bounds;

m_building

public CStrW m_building;

m_buildingLimitCategory

public CStrW m_buildingLimitCategory;

m_classes

public CClassSet m_classes;

m_collisionPatch

public std::vector< CEntity* >* m_collisionPatch;

m_currentNotification

public int m_currentNotification;

m_currentRequest

public int m_currentRequest;

m_EventHandlers

public CScriptObject m_EventHandlers[ EVENT_LAST ];

m_extant

public bool m_extant;

m_formation

public int m_formation;

m_formationSlot

public int m_formationSlot;

m_frameCheck

public int m_frameCheck;

m_fsm_cyclepos

public size_t m_fsm_cyclepos;

m_graphics_orientation

public CVector3D m_graphics_orientation;

m_graphics_position

public CVector3D m_graphics_position;

m_grouped

public i32 m_grouped;

m_healthCurr

public float m_healthCurr;

m_healthDecayRate

public float m_healthDecayRate;

m_healthMax

public float m_healthMax;

m_healthRegenRate

public float m_healthRegenRate;

m_healthRegenStart

public float m_healthRegenStart;

m_lastCombatTime

public double m_lastCombatTime;

m_lastRunTime

public double m_lastRunTime;

m_lastState

public int m_lastState;

m_listeners

public std::deque< CEntityListener > m_listeners;

m_los

public int m_los;

m_maxActorPitch

public float m_maxActorPitch;

m_minActorPitch

public float m_minActorPitch;

m_notifiers

public std::vector< CEntity* > m_notifiers;

m_orderQueue

public CEntityOrders m_orderQueue;

m_orientation

public CVector3D m_orientation;

m_orientation_previous

public CVector3D m_orientation_previous;

m_orientation_smoothed

public CVector3D m_orientation_smoothed;

m_orientation_unclamped

public CVector2D m_orientation_unclamped;

m_player

private CPlayer* m_player;

m_position

public CVector3D m_position;

m_position_previous

public CVector3D m_position_previous;

m_productionQueue

public CProductionQueue* m_productionQueue;

m_rallyPoint

public CVector3D m_rallyPoint;

m_rankName

public CStr m_rankName;

m_runDecayRate

public float m_runDecayRate;

m_runMaxRange

public float m_runMaxRange;

m_runMinRange

public float m_runMinRange;

m_runRegenRate

public float m_runRegenRate;

m_runSpeed

public float m_runSpeed;

m_sectorValues

public std::vector< bool > m_sectorValues;

m_selected

public bool m_selected;

m_speed

public float m_speed;

m_staminaCurr

public float m_staminaCurr;

m_staminaMax

public float m_staminaMax;

m_stance

public CStance* m_stance;

m_stanceName

public CStr m_stanceName;

m_targetorientation

public float m_targetorientation;

m_turningRadius

public float m_turningRadius;

m_unsnappedPoints

public std::vector< std::vector< CVector2D > > m_unsnappedPoints;

m_visible

public bool m_visible;

me

public HEntity me;

NOT_IN_CYCLE

public static const size_t NOT_IN_CYCLE;

CEntity

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

~CEntity

public ~CEntity();

AddAura

public jsval_t AddAura( JSContext* cx, uintN argc, jsval* argv );

CalculateRegen

public void CalculateRegen( float timestep );

CheckExtant

public void CheckExtant();

CheckGroup

public void CheckGroup();

CheckListeners

public void CheckListeners( int type, CEntity* target );

CheckSelection

public void CheckSelection();

ChooseMovementSpeed

private float ChooseMovementSpeed( float distance );

ClearOrders

public void ClearOrders();

Construct

public JSBool Construct( JSContext* cx, JSObject* UNUSED( obj ), uint argc, jsval* argv, jsval* rval );

DestroyAllNotifiers

public void DestroyAllNotifiers();

DestroyAllNotifiers

public jsval_t DestroyAllNotifiers( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

DestroyNotifier

public int DestroyNotifier( CEntity* target );

DestroyNotifier

public jsval_t DestroyNotifier( JSContext* cx, uintN argc, jsval* argv );

DispatchFormationEvent

public void DispatchFormationEvent( int type );

DispatchNotification

public void DispatchNotification( CEntityOrder order, int type );

Distance2D

public float Distance2D( CEntity* other );

Distance2D

public float Distance2D( CVector2D p );

Distance2D

public float Distance2D( float x, float z );

DrawBar

public void DrawBar( CVector3D& centre, CVector3D& up, CVector3D& right, float x1, float y1, float x2, float y2, SColour col1, SColour col2, float currVal, float maxVal );

DrawRect

public void DrawRect( CVector3D& centre, CVector3D& up, CVector3D& right, float x1, float y1, float x2, float y2 );

entf_clear

public void entf_clear( uint desired_flag );

entf_get

public bool entf_get( uint desired_flag ) const;

entf_set

public void entf_set( uint desired_flag );

entf_set_to

public void entf_set_to( uint desired_flag, bool value );

ExitAuras

public void ExitAuras();

FindSector

public int FindSector( int divs, float angle, float maxAngle, bool negative = true );

FindSector

public jsval_t FindSector( JSContext* cx, uintN argc, jsval* argv );

FlattenTerrain

public jsval_t FlattenTerrain( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

ForceCheckListeners

public bool ForceCheckListeners( JSContext* cx, uintN argc, jsval* argv );

GetAnchorLevel

public float GetAnchorLevel( float x, float z );

GetAttackAction

public int GetAttackAction( HEntity target );

GetAttackDirections

public jsval_t GetAttackDirections( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetClassSet

public jsval GetClassSet();

GetCurrentRequest

public int GetCurrentRequest( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetDistance

public float GetDistance( JSContext* cx, uintN argc, jsval* argv );

GetFormation

public CEntityFormation* GetFormation();

GetFormationBonus

public jsval_t GetFormationBonus( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationBonusBase

public jsval_t GetFormationBonusBase( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationBonusType

public jsval_t GetFormationBonusType( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationBonusVal

public jsval_t GetFormationBonusVal( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationPenalty

public jsval_t GetFormationPenalty( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationPenaltyBase

public jsval_t GetFormationPenaltyBase( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationPenaltyType

public jsval_t GetFormationPenaltyType( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetFormationPenaltyVal

public jsval_t GetFormationPenaltyVal( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetHeight

public jsval_t GetHeight( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetPlayer

public CPlayer* GetPlayer();

GetRallyPoint

public jsval_t GetRallyPoint( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetRunState

public jsval_t GetRunState( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

GetScreenCoords

public CVector2D GetScreenCoords( float height );

GetScriptExecContext

public JSObject* GetScriptExecContext( IEventTarget* target );

GetSpawnPoint

public jsval_t GetSpawnPoint( JSContext* UNUSED( cx ), uintN argc, jsval* argv );

GetVisibleEntities

public jsval_t GetVisibleEntities( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

HasClass

public bool HasClass( JSContext* cx, uintN argc, jsval* argv );

HasRallyPoint

public jsval_t HasRallyPoint( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

InitAttributes

public static void InitAttributes( const CEntity* _this );

initAuraData

public void initAuraData();

Initialize

public bool Initialize();

Interpolate

public void Interpolate( float relativeoffset );

InvalidateActor

public void InvalidateActor();

IsIdle

public bool IsIdle( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

IsInFormation

public bool IsInFormation( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

IsRunning

public jsval_t IsRunning( JSContext* cx, uintN argc, jsval* argv );

JSI_GetPlayer

public jsval JSI_GetPlayer();

JSI_SetPlayer

public void JSI_SetPlayer( jsval val );

Kill

public bool Kill( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

Kill

public void Kill( bool keepActor = false );

LoadBase

public void LoadBase();

OnDamaged

public jsval_t OnDamaged( JSContext* cx, uintN argc, jsval* argv );

Order

public bool Order( JSContext* cx, uintN argc, jsval* argv, CEntityOrder::EOrderSource source, bool Queued );

OrderFromTriggers

public inline bool OrderFromTriggers( JSContext* cx, uintN argc, jsval* argv );

OrderQueued

public inline bool OrderQueued( JSContext* cx, uintN argc, jsval* argv );

OrderSingle

public inline bool OrderSingle( JSContext* cx, uintN argc, jsval* argv );

PopOrder

public void PopOrder();

ProcessContactAction

private bool ProcessContactAction( CEntityOrder* current, size_t UNUSED( timestep_millis ), CEntityOrder::EOrderType transition, SEntityAction* action );

ProcessContactActionNoPathing

private bool ProcessContactActionNoPathing( CEntityOrder* current, size_t timestep_millis, const CStr& animation, CScriptEvent* contactEvent, SEntityAction* action );

ProcessGeneric

private bool ProcessGeneric( CEntityOrder* current, size_t timestep_millis );

ProcessGenericNoPathing

private bool ProcessGenericNoPathing( CEntityOrder* current, size_t timestep_millis );

ProcessGoto

private bool ProcessGoto( CEntityOrder* current, size_t UNUSED( timestep_millis ) );

ProcessGotoHelper

private uint ProcessGotoHelper( CEntityOrder* current, size_t timestep_millis, HEntity& collide, float& timeLeft );

ProcessGotoNoPathing

private bool ProcessGotoNoPathing( CEntityOrder* current, size_t timestep_millis );

ProcessGotoWaypoint

private bool ProcessGotoWaypoint( CEntityOrder* current, size_t UNUSED( timestep_milli ), bool contact );

ProcessPatrol

private bool ProcessPatrol( CEntityOrder* current, size_t UNUSED( timestep_millis ) );

ProcessProduce

private bool ProcessProduce( CEntityOrder* order );

PushOrder

public void PushOrder( CEntityOrder& order );

RebuildClassSet

public void RebuildClassSet();

RegisterDamage

public jsval_t RegisterDamage( JSContext* cx, uintN argc, jsval* argv );

RegisterOrderChange

public jsval_t RegisterOrderChange( JSContext* cx, uintN argc, jsval* argv );

RemoveAura

public jsval_t RemoveAura( JSContext* UNUSED( cx ), uintN argc, jsval* argv );

Render

public void Render();

RenderAuras

public void RenderAuras();

RenderBarBorders

public void RenderBarBorders();

RenderBars

public void RenderBars();

RenderHealthBar

public void RenderHealthBar();

RenderRallyPoint

public void RenderRallyPoint();

RenderRank

public void RenderRank();

RenderSelectionOutline

public void RenderSelectionOutline( float alpha = 1. 0f );

RenderStaminaBar

public void RenderStaminaBar();

Reorient

public void Reorient();

Repath

public void Repath();

RequestNotification

public bool RequestNotification( JSContext* cx, uintN argc, jsval* argv );

ScriptingInit

public static void ScriptingInit();

SetActionParams

public jsval_t SetActionParams( JSContext* UNUSED( cx ), uintN argc, jsval* argv );

SetClassSet

public void SetClassSet( jsval value );

SetPlayer

private void SetPlayer( CPlayer* pPlayer );

SetRallyPoint

public jsval_t SetRallyPoint( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

SetRun

public jsval_t SetRun( JSContext* cx, uintN argc, jsval* argv );

ShouldRun

private bool ShouldRun( float distance );

SnapToGround

public void SnapToGround();

StanceChanged

public void StanceChanged();

Teleport

public void Teleport();

TerminateOrder

public jsval_t TerminateOrder( JSContext* UNUSED( cx ), uintN argc, jsval* argv );

ToString

public jsval_t ToString( JSContext* cx, uintN UNUSED( argc ), jsval* UNUSED( argv ) );

TriggerRun

public jsval_t TriggerRun( JSContext* UNUSED( cx ), uintN UNUSED( argc ), jsval* UNUSED( argv ) );

Update

public void Update( size_t timestep_millis );

UpdateActorTransforms

public void UpdateActorTransforms();

UpdateAuras

public void UpdateAuras( size_t timestep_millis );

UpdateCollisionPatch

public void UpdateCollisionPatch();

UpdateOrders

private void UpdateOrders( size_t timestep_millis );

UpdateXZOrientation

public void UpdateXZOrientation();