areadamagemanager.c

Go to the documentation of this file.

class AreaDamageComponentTypes
{
 const int BASE = 0;
 const int HITZONE = 1;
 const int RAYCASTED = 2;
}
 
class AreaDamageManager : AreaDamageEvents
{
 protected EntityAI m_ParentObject;
 protected AreaDamageTriggerBase m_AreaDamageTrigger; 
 
 protected ref AreaDamageComponent m_DamageComponent;
 
 protected vector m_ExtentMin;
 protected vector m_ExtentMax;
 protected vector m_AreaPosition;
 protected vector m_AreaOrientation;
 
 protected string m_TriggerBaseClass;
 
 void AreaDamageManager(EntityAI parent)
 {
 m_ParentObject = parent;
 
 m_DamageComponent = new AreaDamageComponent(this);
 
 m_ExtentMin = vector.Zero;
 m_ExtentMax = vector.Zero;
 m_AreaPosition = parent.GetPosition();
 m_AreaOrientation = parent.GetOrientation();
 
 m_TriggerBaseClass = "AreaDamageTriggerBase";
 }
 
 void ~AreaDamageManager()
 {
 Destroy();
 }
 
 void SetDamageComponentType(int type)
 {
 switch (type)
 {
 case AreaDamageComponentTypes.BASE:
 {
 m_DamageComponent = new AreaDamageComponent(this);
 break;
 }
 case AreaDamageComponentTypes.HITZONE:
 {
 m_DamageComponent = new AreaDamageComponentRandomHitzone(this);
 break;
 }
 case AreaDamageComponentTypes.RAYCASTED:
 {
 m_DamageComponent = new AreaDamageComponentRaycasted(this);
 break;
 }
 
 default:
 {
 Error(string.Format("[ERROR] :: [AreaDamageManager] :: Unknown DamageComponentType: %1", type));
 break;
 }
 }
 }
 
 void Spawn()
 {
 if ( CreateDamageTriggerEx() )
 OnTriggerCreated();
 }
 
 void Destroy()
 {
 if ( DestroyDamageTriggerEx() )
 OnTriggerDestroyed();
 }
 
 
 override void OnTriggerCreated()
 {
 m_DamageComponent.OnTriggerCreated();
 }
 
 override void OnTriggerDestroyed()
 {
 m_DamageComponent.OnTriggerDestroyed();
 }
 
 override void OnEnterBeginEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnEnterBeginEvent(insider);
 }
 override void OnEnterServerEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnEnterServerEvent(insider);
 }
 override void OnEnterClientEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnEnterClientEvent(insider);
 }
 override void OnEnterEndEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnEnterEndEvent(insider);
 }
 
 override void OnStayStartBeginEvent(int nrOfInsiders)
 {
 m_DamageComponent.OnStayStartBeginEvent(nrOfInsiders);
 }
 override void OnStayStartServerEvent(int nrOfInsiders)
 {
 m_DamageComponent.OnStayStartServerEvent(nrOfInsiders);
 }
 override void OnStayStartClientEvent(int nrOfInsiders)
 {
 m_DamageComponent.OnStayStartClientEvent(nrOfInsiders);
 }
 override void OnStayStartEndEvent(int nrOfInsiders)
 {
 m_DamageComponent.OnStayStartEndEvent(nrOfInsiders);
 }
 
 override void OnStayBeginEvent(TriggerInsider insider, float deltaTime)
 {
 m_DamageComponent.OnStayBeginEvent(insider, deltaTime);
 }
 override void OnStayServerEvent(TriggerInsider insider, float deltaTime)
 {
 m_DamageComponent.OnStayServerEvent(insider, deltaTime);
 }
 override void OnStayClientEvent(TriggerInsider insider, float deltaTime)
 {
 m_DamageComponent.OnStayClientEvent(insider, deltaTime);
 }
 override void OnStayEndEvent(TriggerInsider insider, float deltaTime)
 {
 m_DamageComponent.OnStayEndEvent(insider, deltaTime);
 }
 
 override void OnStayFinishBeginEvent()
 {
 m_DamageComponent.OnStayFinishBeginEvent();
 }
 override void OnStayFinishServerEvent()
 {
 m_DamageComponent.OnStayFinishServerEvent();
 }
 override void OnStayFinishClientEvent()
 {
 m_DamageComponent.OnStayFinishClientEvent();
 }
 override void OnStayFinishEndEvent()
 {
 m_DamageComponent.OnStayFinishEndEvent();
 }
 
 override void OnLeaveBeginEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnLeaveBeginEvent(insider);
 }
 override void OnLeaveServerEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnLeaveServerEvent(insider);
 }
 override void OnLeaveClientEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnLeaveClientEvent(insider);
 }
 override void OnLeaveEndEvent(TriggerInsider insider)
 {
 m_DamageComponent.OnLeaveEndEvent(insider);
 }
 
 override bool OnEvaluateDamage(TriggerInsider insider, float damageCoef)
 {
 return m_DamageComponent.OnEvaluateDamage(insider, damageCoef);
 }
 
 override void PreDamageActions()
 {
 if ( m_ParentObject )
 m_ParentObject.PreAreaDamageActions();
 }
 
 override void PostDamageActions()
 {
 if ( m_ParentObject )
 m_ParentObject.PostAreaDamageActions();
 }
 
 
 bool OnEvaluateDamageEx(TriggerInsider insider, float deltaTime)
 {
 return OnEvaluateDamage( insider, CalculateDamageScale( insider, deltaTime ) );
 }
 
 protected float CalculateDamageScale(TriggerInsider insider, float deltaTime)
 {
 return deltaTime;
 }
 
 
 void SetExtents( vector mins, vector maxs )
 {
 m_ExtentMin = mins;
 m_ExtentMax = maxs;
 
 if ( m_AreaDamageTrigger )
 {
 m_AreaDamageTrigger.SetExtents(m_ExtentMin, m_ExtentMax);
 }
 } 
 void GetExtents( out vector mins, out vector maxs )
 {
 mins = m_ExtentMin;
 maxs = m_ExtentMax;
 } 
 void GetWorldExtents( out vector mins, out vector maxs )
 {
 GetExtents(mins, maxs);
 
 mins + m_AreaPosition;
 maxs + m_AreaPosition;
 }
 
 void SetAmmoName( string ammo_name )
 {
 m_DamageComponent.m_AmmoName = ammo_name;
 }
 string GetAmmoName()
 {
 return m_DamageComponent.m_AmmoName;
 }
 
 void SetDamageType( int pDamageType )
 {
 m_DamageComponent.m_DamageType = pDamageType;
 }
 int GetDamageType()
 {
 return m_DamageComponent.m_DamageType;
 }
 
 void SetParentObject( EntityAI obj )
 {
 m_ParentObject = obj;
 }
 EntityAI GetParentObject()
 {
 return m_ParentObject;
 }
 
 void SetAreaPosition( vector position )
 {
 m_AreaPosition = position;
 
 if ( m_AreaDamageTrigger )
 {
 m_AreaDamageTrigger.SetPosition(m_AreaPosition);
 }
 }
 vector GetPosition()
 {
 return m_AreaPosition;
 }
 
 void SetAreaOrientation( vector orientation )
 {
 m_AreaOrientation = orientation;
 
 if ( m_AreaDamageTrigger )
 {
 m_AreaDamageTrigger.SetOrientation(m_AreaOrientation);
 }
 } 
 vector GetOrientation()
 {
 return m_AreaOrientation;
 }
 
 void SetDamageableTypes(array<typename> damageableTypes)
 {
 m_DamageComponent.m_DamageableTypes = damageableTypes;
 }
 array<typename> GetDamageableTypes()
 {
 return m_DamageComponent.m_DamageableTypes;
 }
 
 void AddDamageableType(typename damageableType)
 {
 if (m_DamageComponent.m_DamageableTypes.Find(damageableType) != -1)
 m_DamageComponent.m_DamageableTypes.Insert(damageableType);
 }
 
 void RemoveAddDamageableType(typename damageableType)
 {
 m_DamageComponent.m_DamageableTypes.RemoveItem(damageableType);
 }
 
 void SetLoopInterval( float time )
 {
 Error("SetLoopInterval not implemented - usable in Regular(looped) area damage objects only");
 }
 
 void SetDeferDuration( float time )
 {
 Error("SetDeferDuration not implemented - usable in Deferred area damage objects only");
 }
 
 void SetHitZones( array<string> hitzones )
 {
 AreaDamageComponentRandomHitzone adc;
 if ( CastTo( adc, m_DamageComponent ) )
 adc.SetHitZones( hitzones );
 else
 Error("SetHitZones not implemented - override for non raycasted versions of area damage objects only");
 }
 
 void SetRaycastSources( array<string> raycast_sources )
 {
 AreaDamageComponentRaycasted adc;
 if ( CastTo( adc, m_DamageComponent ) )
 adc.SetRaycastSources( raycast_sources );
 else
 Error("SetRaycastSources not implemented - override for raycasted versions of area damage objects only");
 }
 
 void SetRaycastSourcesVector( array<vector> raycast_sources )
 {
 AreaDamageComponentRaycasted adc;
 if ( CastTo( adc, m_DamageComponent ) )
 adc.SetRaycastSourcesVector( raycast_sources );
 else
 Error("SetRaycastSources not implemented - override for raycasted versions of area damage objects only");
 }
 
 AreaDamageTriggerBase GetTrigger()
 {
 return m_AreaDamageTrigger;
 }
 
 
 protected bool CreateDamageTriggerEx()
 {
 int flags;
 
 if ( GetGame().IsMultiplayer() && GetGame().IsServer() )
 flags = ECE_CREATEPHYSICS;
 else
 flags = ECE_LOCAL;
 
 if (Class.CastTo(m_AreaDamageTrigger, GetGame().CreateObjectEx( m_TriggerBaseClass, m_AreaPosition, flags )))
 {
 m_AreaDamageTrigger.SetOrientation( m_AreaOrientation );
 m_AreaDamageTrigger.SetExtents( m_ExtentMin, m_ExtentMax );
 m_AreaDamageTrigger.SetAreaDamageManager(this);
 return true;
 }
 
 return false;
 }
 
 protected void CreateDamageTrigger()
 {
 CreateDamageTriggerEx();
 }
 
 
 protected bool DestroyDamageTriggerEx()
 {
 if ( GetGame() && m_AreaDamageTrigger ) // It's necesarry to check if the game exists. Otherwise a crash occurs while quitting.
 {
 GetGame().ObjectDelete( m_AreaDamageTrigger );
 m_AreaDamageTrigger = null;
 return true;
 }
 
 return false;
 }
 
 protected void DestroyDamageTrigger()
 {
 DestroyDamageTriggerEx();
 }
}