SCR_DamageArea.c

Go to the documentation of this file.

class SCR_DamageArea : DamageArea
{
    [Attribute(defvalue: "1", desc: "Should this area be automatically registered to the system, when owner is initalized")]
    protected bool m_bRegisterAutomatically;
 
    [Attribute(desc: "Damage type of the damage which is going to be applied, when player enters the area.\nWhen none is selected the damage is no applied.", uiwidget: UIWidgets.ComboBox, enumType: EDamageType)]
    protected EDamageType m_eDamageType;
 
    [Attribute(desc: "How much damage should be dealt upon entering the zone")]
    protected float m_fDamageValue;
 
    [Attribute()]
    protected ref BaseDamageEffect m_DamageEffect;
 
    [Attribute(defvalue: "0", desc: "Remove Effect When Leaving The Area\nNOTE:If component has many areas with same Damage Effect, then leaving one zone will cause a removal of all instances of this Damage Effects type, that was applied by this component owner.")]
    protected bool m_bRemoveEffectWhenLeavingTheArea;
    
    [Attribute(defvalue: "1", desc: "Should the damage go through watertight compartments to be applied to its occupants")]
    protected bool m_bPenetrateWatertightCompartments;
    
    [Attribute(defvalue: SCR_EHitZoneSelectionMode.DEFAULT.ToString(), desc: "Determines how hit zone is selected.\nThis attribute is also passed to the Custom Hit Zone Selector when such is present.", uiwidget: UIWidgets.ComboBox, enumType: SCR_EHitZoneSelectionMode)]
    protected SCR_EHitZoneSelectionMode m_eHitZoneSelectionMode;
 
    [Attribute(desc: "Custom selector of the hit zones. If not provided then basic area logic is used.")]
    protected ref SCR_BaseHitZoneSelector m_CustomHitZoneSelector;
 
    //------------------------------------------------------------------------------------------------
    bool IsRegisteredAutomatically()
    {
        return m_bRegisterAutomatically;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnAreaEntered(notnull IEntity entity)
    {
        if (!m_bPenetrateWatertightCompartments)
        {
            SCR_CompartmentAccessComponent compartmentAccessComp = SCR_CompartmentAccessComponent.Cast(entity.FindComponent(SCR_CompartmentAccessComponent));
            if (compartmentAccessComp)
            {           
                compartmentAccessComp.GetOnPlayerCompartmentExit().Insert(ReevaluateDamageEffect);
                compartmentAccessComp.GetOnPlayerCompartmentEnter().Insert(ReevaluateDamageEffect);
                
                BaseCompartmentSlot compartment = compartmentAccessComp.GetCompartment();
 
                if (compartment && compartmentAccessComp.GetCompartment().GetIsWaterTight())
                    return;
            }
        }
        
        AddEffect(entity);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnAreaExit(IEntity entity)
    {
        if (!entity)
            return;
        
        if (!m_bPenetrateWatertightCompartments)
        {
            SCR_CompartmentAccessComponent compartmentAccessComp = SCR_CompartmentAccessComponent.Cast(entity.FindComponent(SCR_CompartmentAccessComponent));
            if (compartmentAccessComp)
            {
                compartmentAccessComp.GetOnPlayerCompartmentExit().Remove(ReevaluateDamageEffect);
                compartmentAccessComp.GetOnPlayerCompartmentEnter().Remove(ReevaluateDamageEffect);
            }
        }
        
        if (m_bRemoveEffectWhenLeavingTheArea)
        {
            super.OnAreaExit(entity);
            return;
        }
        
        RemoveEffect(entity);
    }
    
    
    //------------------------------------------------------------------------------------------------
    protected void ReevaluateDamageEffect(ChimeraCharacter playerCharacter, IEntity compartmentEntity)
    {
        if (!playerCharacter)
            return;
        
        SCR_CompartmentAccessComponent compartmentAccessComp = SCR_CompartmentAccessComponent.Cast(playerCharacter.FindComponent(SCR_CompartmentAccessComponent));
        BaseCompartmentSlot compartment;
        if (compartmentAccessComp)
            compartment = compartmentAccessComp.GetCompartment();
 
        if (compartmentAccessComp && compartment && compartmentAccessComp.GetCompartment().GetIsWaterTight())
        {
            RemoveEffect(playerCharacter);
        }
        else
        {
            if (!IsEffectApplied(playerCharacter) && !compartmentAccessComp.IsSwitchingSeatsAnim())
                AddEffect(playerCharacter);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected bool IsEffectApplied(notnull IEntity entity)
    {
        const SCR_ExtendedDamageManagerComponent damageManager = SCR_ExtendedDamageManagerComponent.Cast(SCR_DamageManagerComponent.GetDamageManager(entity));
        array<ref SCR_PersistentDamageEffect> damageEffects = {};
        if (damageManager.FindAllDamageEffectsOfType(GetDamageEffect().Type(), damageEffects) < 1)
            return false;
 
        const IEntity owner = GetParent();
        foreach (SCR_PersistentDamageEffect effect : damageEffects)
        {
            if (effect.GetInstigator().GetInstigatorEntity() == owner)
                return true;
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void AddEffect(notnull IEntity entity)
    {
        const SCR_ExtendedDamageManagerComponent damageManager = SCR_ExtendedDamageManagerComponent.Cast(SCR_DamageManagerComponent.GetDamageManager(entity));
        if (!damageManager)
            return;
 
        HitZone hitZone = GetAffectedHitZone(damageManager, m_eHitZoneSelectionMode);
        if (!hitZone)
            return;
 
        if (m_fDamageValue == 0 || m_eDamageType == int.MAX) //int.MAX is equal to selecting in the prefab the option 'none' for m_eDamageType
        {
            damageManager.AddDamageEffect(GetDamageEffect(damageManager, hitZone));
            return;
        }
 
        const IEntity owner = GetParent();
        vector posDirNorm[3];
        posDirNorm[0] = entity.GetOrigin();
        SCR_DamageContext context = new SCR_DamageContext(m_eDamageType, m_fDamageValue, posDirNorm,
                                                        entity, hitZone, Instigator.CreateInstigator(owner),
                                                        null, 0, 0);
 
        context.damageEffect = GetDamageEffect(damageManager, hitZone);
        context.damageSource = owner;
        damageManager.HandleDamage(context);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void RemoveEffect(notnull IEntity entity)
    {
        const SCR_ExtendedDamageManagerComponent dmgMgr = SCR_ExtendedDamageManagerComponent.Cast(SCR_DamageManagerComponent.GetDamageManager(entity));
        if (!dmgMgr)
            return;
 
        array<ref SCR_PersistentDamageEffect> damageEffects = {};
        if (dmgMgr.FindAllDamageEffectsOfType(GetDamageEffect().Type(), damageEffects) < 1)
            return;
 
        const IEntity owner = GetParent();
        foreach (SCR_PersistentDamageEffect effect : damageEffects)
        {
            if (effect.GetInstigator().GetInstigatorEntity() == owner)
                effect.Terminate();
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected BaseDamageEffect GetDamageEffect(SCR_DamageManagerComponent dmgMgr = null, HitZone affectedHitZone = null)
    {
        return m_DamageEffect;
    }
 
    //------------------------------------------------------------------------------------------------
    protected HitZone GetAffectedHitZone(notnull SCR_DamageManagerComponent dmgMgr, SCR_EHitZoneSelectionMode hitZoneSelectionMode)
    {
        if (m_CustomHitZoneSelector)
        {
            HitZone hitZone = m_CustomHitZoneSelector.SelectHitZone(dmgMgr, hitZoneSelectionMode);
            if (hitZone)
                return hitZone;
 
            if (m_CustomHitZoneSelector.ShouldAbortWhenNoCompatibleHitZonesWereFound())
                return null;
        }
 
        if (hitZoneSelectionMode == SCR_EHitZoneSelectionMode.DEFAULT)
            return dmgMgr.GetDefaultHitZone();
 
        array<HitZone> hitZones = {};
        if (hitZoneSelectionMode == SCR_EHitZoneSelectionMode.RANDOM)
            dmgMgr.GetAllHitZones(hitZones);
        else
            dmgMgr.GetPhysicalHitZones(hitZones);
 
        if (hitZones.IsEmpty())
            return null;
 
        if (hitZoneSelectionMode == SCR_EHitZoneSelectionMode.FIRST_PHYSICAL)
            return hitZones[0];
 
        return hitZones.GetRandomElement();
    }
 
    //------------------------------------------------------------------------------------------------
    override void DisplayInfo()
    {
        DbgUI.Text("Area information");
        DbgUI.Text("Area prefab = "+SCR_DamageAreaComponent.GetPrefabname(GetParent()));
    }
}