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();
    }
}