SCR_DamageManagerComponent.c

Go to the documentation of this file.

class SCR_DamageManagerComponentClass : DamageManagerComponentClass
{
    [Attribute()]
    protected ref SCR_SecondaryExplosions m_SecondaryExplosions;
 
    [Attribute()]
    protected ref SCR_SecondaryExplosions m_SecondaryFires;
 
    [Attribute(category: "Repairs")]
    protected ref SCR_RepairConfig m_RepairConfig;
 
    protected ref map<EHitZoneGroup, ref array<int>> m_mHitZoneGroupMap;
 
    //------------------------------------------------------------------------------------------------
    SCR_SecondaryExplosions GetSecondaryExplosions()
    {
        return m_SecondaryExplosions;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_SecondaryExplosions GetSecondaryFires()
    {
        return m_SecondaryFires;
    }
 
    //------------------------------------------------------------------------------------------------
    //! \param[in] health percenatage of total health (0.0 to 1.0)
    //! \param[out] state output that will contain state that coresponds to the provided health or SCR_EBurningState.NONE if there is no such state 
    //! \return true if coresponding state was found
    bool GetBurnStateForHealth(float health, out SCR_EBurningState state)
    {
        if (!m_RepairConfig)
        {
            state = SCR_EBurningState.NONE;
            return false;
        }
 
        return m_RepairConfig.GetBurnStateForHealth(health, state);
    }
 
    //------------------------------------------------------------------------------------------------
    //! Retreives a list of ids which are corresponding to the id of the hit zones that are part of the provided group
    //! \param[in] hitZoneGroup
    //! \return list of ids, if none are found then null
    array<int> GetGroupHitZoneIds(EHitZoneGroup hitZoneGroup)
    {
        if (!m_mHitZoneGroupMap)
            return null;
 
        return m_mHitZoneGroupMap.Get(hitZoneGroup);
    }
 
    //------------------------------------------------------------------------------------------------
    void InitPrefabData(notnull IEntity owner, notnull SCR_DamageManagerComponent dmgManager)
    {
        if (m_mHitZoneGroupMap)
            return; // if it isnt null then we assume that this was already done, thus we quit
 
        array<HitZone> allHitZones = {};
        if (dmgManager.GetAllHitZonesInHierarchy(allHitZones) < 1)
            return; // we have to ignore such entities as PreloadManager can spawn character prefabs on game startup, but they will not have any hit zones. This would result in us having an empty map if we wouldn't quit now
 
        m_mHitZoneGroupMap = new map<EHitZoneGroup, ref array<int>>();
        EHitZoneGroup group;
        SCR_HitZone scrHitZone;
        array<int> groupedIds;
        foreach (int hitZoneId, HitZone hitzone : allHitZones)
        {
            scrHitZone = SCR_HitZone.Cast(hitzone);
            if (!scrHitZone)
                continue;
 
            group = scrHitZone.GetHitZoneGroup();
            groupedIds = m_mHitZoneGroupMap.Get(group);
            if (groupedIds)
                groupedIds.Insert(hitZoneId);
            else
                groupedIds = {hitZoneId};
 
            m_mHitZoneGroupMap.Set(group, groupedIds);
        }
    }
}
 
class SCR_DamageManagerComponent : DamageManagerComponent
{
    [Attribute(defvalue: SCR_EBurningState.SMOKING_LIGHT.ToString(), uiwidget: UIWidgets.ComboBox, desc: "State from which vehicle will be considered on fire thus players will be able to extinguish it", enums: ParamEnumArray.FromEnum(SCR_EBurningState))]
    protected SCR_EBurningState m_iMinimumBurningState;
 
    protected static const int MIN_MOMENTUM_RESPONSE_INDEX = 1;
    protected static const int MAX_MOMENTUM_RESPONSE_INDEX = 5;
    protected static const int MIN_DESTRUCTION_RESPONSE_INDEX = 6;
    protected const float SIMULATION_IMPRECISION_MULTIPLIER = 1.1;
    static const int MAX_DESTRUCTION_RESPONSE_INDEX = 10;
    static const string MAX_DESTRUCTION_RESPONSE_INDEX_NAME = "HugeDestructible";
    private static int s_iFirstFreeDamageManagerData = -1;
    protected static ref array<ref SCR_DamageManagerData> s_aDamageManagerData = {};
    
    static const ref array<EDamageType> HEALING_DAMAGE_TYPES = {EDamageType.HEALING, EDamageType.REGENERATION};
 
    protected int m_iTimetickInstigator = System.GetTickCount();
    protected int m_iTimeThresholdInstigatorReplacement = 180000; //180000 miliseconds = 3 minutes
    protected int m_iPlayerId = 0;
 
    protected int m_iDamageManagerDataIndex = -1;
 
 
    //------------------------------------------------------------------------------------------------
    void GetPhysicalHitZones(out notnull array<HitZone> physicalHitZones)
    {
        array<HitZone> hitZones = {};
        GetAllHitZonesInHierarchy(hitZones);
 
        HitZoneContainerComponent container;
        foreach (HitZone hitZone : hitZones)
        {
            if (hitZone.HasColliderNodes())
            {
                physicalHitZones.Insert(hitZone);
                continue;
            }
 
            // Ignore own default hit zone
            container = hitZone.GetHitZoneContainer();
            if (container == null || container == this)
                continue;
 
            // Allow subordinate default hit zone
            if (container.GetDefaultHitZone() == hitZone)
                physicalHitZones.Insert(hitZone);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void GetRegeneratingHitZones(out notnull array<SCR_RegeneratingHitZone> regeneratingHitZones)
    {
        array<HitZone> hitZones = {};
        GetAllHitZonesInHierarchy(hitZones);
 
        foreach (HitZone hitZone : hitZones)
        {
            SCR_RegeneratingHitZone regenHitZone = SCR_RegeneratingHitZone.Cast(hitZone);
            if (regenHitZone)
                regeneratingHitZones.Insert(regenHitZone);
        }
    }
 
    //---- REFACTOR NOTE START: This code will need to be refactored as current implementation is not conforming to the standards ----
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void RpcDo_SetFireState_(int hitZoneIndex, SCR_EBurningState fireState)
    {
        array<HitZone> hitZones = {};
        GetAllHitZones(hitZones);
        SCR_FlammableHitZone flammableHitZone = SCR_FlammableHitZone.Cast(hitZones.Get(hitZoneIndex));
        if (flammableHitZone)
            flammableHitZone.SetFireState(fireState);
    }
    void RpcDo_SetFireState(int hitZoneIndex, SCR_EBurningState fireState)
    {
        Rpc(RpcDo_SetFireState_, hitZoneIndex, fireState);
    }
    //---- REFACTOR NOTE END ----
 
    //------------------------------------------------------------------------------------------------
    override bool FilterContact(IEntity owner, IEntity other, Contact contact)
    {
        return GetState() != EDamageState.DESTROYED;
    }
    
    //------------------------------------------------------------------------------------------------
    // This method uses similar logic to the logic of DamageSurroundingHitzones, but not the same.
    int GetSurroundingHitzones(vector origin, Physics physics, float maxDistance, out array<HitZone> outHitzones)
    {
        array<HitZone> hitZones = {};
        outHitzones = {};
        int hitZonesCount;
 
        int count = GetAllHitZonesInHierarchy(hitZones);
        float maxDistanceSq = maxDistance * maxDistance; //SQUARE it for faster calculations of distance
        array<string> hitZoneColliderNames = {};
 
        float minDistance, currentDistance;
        int colliderCount, geomIndex;
        vector mat[4];
        for (int i = count - 1; i >= 0; i--)
        {
            minDistance = float.MAX;
            colliderCount = hitZones[i].GetAllColliderNames(hitZoneColliderNames); //The array is cleared inside the GetAllColliderNames method
 
            if (colliderCount == 0)
                continue;
 
            for (int y = colliderCount - 1; y >= 0; y--)
            {
                geomIndex = physics.GetGeom(hitZoneColliderNames[y]);
                if (geomIndex == -1)
                    continue;
 
                physics.GetGeomWorldTransform(geomIndex, mat);
                currentDistance = vector.DistanceSq(origin, mat[3]);
 
                if (currentDistance < minDistance)
                    minDistance = currentDistance;
            }
 
            if (minDistance > maxDistanceSq)
                continue;
 
            minDistance = Math.Sqrt(minDistance);
 
            hitZonesCount++;
            outHitzones.Insert(hitZones[i]);
        }
 
        return hitZonesCount;
    }
 
    //------------------------------------------------------------------------------------------------
    */
    float GetMinDestroyDamage(EDamageType damageType, array<HitZone> hitzones)
    {
        if (!IsDamageHandlingEnabled())
            return -1;
 
        float damage;
        float damageMultiplier;
        HitZone defaultHitzone = GetDefaultHitZone();
        if (defaultHitzone.GetDamageMultiplier(damageType) * defaultHitzone.GetBaseDamageMultiplier() == 0)
            return -1; // invalid damage value, because this vehicle cannot be destroyed
 
        foreach (HitZone hitZone : hitzones)
        {
            damageMultiplier = hitZone.GetBaseDamageMultiplier() * hitZone.GetDamageMultiplier(damageType);
            if (damageMultiplier == 0)
                continue;
 
            damage += (hitZone.GetMaxHealth() + hitZone.GetDamageReduction()) / damageMultiplier;
 
            if (damage < hitZone.GetDamageThreshold())
                damage += hitZone.GetDamageThreshold();
        }
 
        return damage;
    }
 
    //------------------------------------------------------------------------------------------------
    protected notnull SCR_DamageManagerData GetScriptedDamageManagerData()
    {
        if (m_iDamageManagerDataIndex == -1)
            m_iDamageManagerDataIndex = AllocateScriptedDamageManagerData();
 
        return s_aDamageManagerData[m_iDamageManagerDataIndex];
    }
 
    //------------------------------------------------------------------------------------------------
    private int AllocateScriptedDamageManagerData()
    {
        if (s_iFirstFreeDamageManagerData == -1)
            return s_aDamageManagerData.Insert(new SCR_DamageManagerData());
        else
        {
            int returnIndex = s_iFirstFreeDamageManagerData;
            SCR_DamageManagerData data = s_aDamageManagerData[returnIndex];
            s_iFirstFreeDamageManagerData = data.m_iNextFreeIndex;
            data.m_iNextFreeIndex = -1;
            return returnIndex;
        }
    }
 
    //------------------------------------------------------------------------------------------------
    private void FreeScriptedDamageManagerData(int index)
    {
        s_aDamageManagerData[index].Reset();
        s_aDamageManagerData[index].m_iNextFreeIndex = s_iFirstFreeDamageManagerData;
        s_iFirstFreeDamageManagerData = index;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnDamage()
    {
        return GetScriptedDamageManagerData().GetOnDamage();
    }
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnDamageOverTimeAdded()
    {
        return GetScriptedDamageManagerData().GetOnDamageOverTimeAdded();
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnDamageOverTimeRemoved()
    {
        return GetScriptedDamageManagerData().GetOnDamageOverTimeRemoved();
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnDamageStateChanged()
    {
        return GetScriptedDamageManagerData().GetOnDamageStateChanged();
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void OnDamage(notnull BaseDamageContext damageContext)
    {
        if (!s_aDamageManagerData.IsIndexValid(m_iDamageManagerDataIndex))
            return;
 
        ScriptInvoker invoker = s_aDamageManagerData[m_iDamageManagerDataIndex].GetOnDamage(false);
        if (invoker)
            invoker.Invoke(damageContext);
    }
 
    //---- REFACTOR NOTE START: This code will need to be refactored as current implementation is not conforming to the standards ----
    // TODO: Move to Character Damage Manager, use simplified instigator tracking for everything else
    //------------------------------------------------------------------------------------------------
    protected override bool ShouldOverrideInstigator(notnull Instigator currentInstigator, notnull Instigator newInstigator)
    {
        //If time difference since last instigator set is small, this kill was a suicide, and the previous instigator was an enemy, do not override
        int currentTimeTick = System.GetTickCount();
 
        if (m_iPlayerId == 0)
        {
            m_iPlayerId = GetGame().GetPlayerManager().GetPlayerIdFromControlledEntity(GetOwner());
        }
 
        SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
        if (m_iPlayerId <= 0 || !factionManager)
        {
            m_iTimetickInstigator = currentTimeTick;
            return true;
        }
 
        int newId = newInstigator.GetInstigatorPlayerID();
        int oldId = currentInstigator.GetInstigatorPlayerID();
 
        Faction factionKiller = factionManager.GetPlayerFaction(newId);
        if (!factionKiller)
        {
            m_iTimetickInstigator = currentTimeTick;
            return true;
        }
 
        Faction factionPrevInstigator = factionManager.GetPlayerFaction(oldId);
        if (!factionPrevInstigator)
        {
            m_iTimetickInstigator = currentTimeTick;
            return true;
        }
        Faction factionPlayer = factionManager.GetPlayerFaction(m_iPlayerId);
        if (!factionPlayer)
        {
            m_iTimetickInstigator = currentTimeTick;
            return true;
        }
 
        if (newId == m_iPlayerId && (currentTimeTick - m_iTimetickInstigator) < m_iTimeThresholdInstigatorReplacement && !factionPrevInstigator.IsFactionFriendly(factionPlayer))
        {
            return false;
        }
 
        m_iTimetickInstigator = currentTimeTick;
        return true;
    }
    //---- REFACTOR NOTE END ----
 
    //------------------------------------------------------------------------------------------------
    void ~SCR_DamageManagerComponent()
    {
        if (m_iDamageManagerDataIndex != -1)
            FreeScriptedDamageManagerData(m_iDamageManagerDataIndex);
    }
 
    //------------------------------------------------------------------------------------------------
    static SCR_DamageManagerComponent GetDamageManager(notnull IEntity owner)
    {
        ChimeraCharacter character = ChimeraCharacter.Cast(owner);
        if (character)
            return character.GetDamageManager();
 
        BaseVehicle vehicle = BaseVehicle.Cast(owner);
        if (vehicle)
            return vehicle.GetDamageManager();
 
        return SCR_DamageManagerComponent.Cast(owner.FindComponent(SCR_DamageManagerComponent));
    }
 
    //------------------------------------------------------------------------------------------------
    int GetHitZonesOfGroup(EHitZoneGroup hitZoneGroup, out notnull array<HitZone> groupHitZones, bool clearArray = true)
    {
        if (clearArray)
            groupHitZones.Clear();
 
        array<HitZone> allHitZones = {};
        GetAllHitZonesInHierarchy(allHitZones);
        SCR_HitZone scrHitZone;
 
        foreach (HitZone hitZone : allHitZones)
        {
            scrHitZone = SCR_HitZone.Cast(hitZone);
            if (scrHitZone && scrHitZone.GetHitZoneGroup() == hitZoneGroup)
                groupHitZones.Insert(hitZone);
        }
 
        return groupHitZones.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    int GetHitZonesOfGroupFromOwner(EHitZoneGroup hitZoneGroup, out notnull array<HitZone> groupHitZones, bool clearArray = true)
    {
        if (clearArray)
            groupHitZones.Clear();
 
        SCR_DamageManagerComponentClass data = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        array<int> groupedHitZoneIds = data.GetGroupHitZoneIds(hitZoneGroup);
        if (!groupedHitZoneIds)
            return -1;
 
        GetHitZonesByID(groupHitZones, groupedHitZoneIds);
 
        return groupHitZones.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    int GetHitZonesOfGroups(notnull array<EHitZoneGroup> hitZoneGroups, out notnull array<HitZone> groupHitZones)
    {
        groupHitZones.Clear();
 
        if (hitZoneGroups.IsEmpty())
            return 0;
 
        array<HitZone> allHitZones = {};
        GetAllHitZonesInHierarchy(allHitZones);
        SCR_HitZone scrHitZone;
 
        foreach (HitZone hitZone : allHitZones)
        {
            scrHitZone = SCR_HitZone.Cast(hitZone);
            if (scrHitZone && hitZoneGroups.Contains(scrHitZone.GetHitZoneGroup()))
                groupHitZones.Insert(hitZone);
        }
 
        return groupHitZones.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    int GetHitZonesOfGroupsFromOwner(notnull array<EHitZoneGroup> hitZoneGroups, out notnull array<HitZone> groupHitZones)
    {
        groupHitZones.Clear();
 
        if (hitZoneGroups.IsEmpty())
            return 0;
 
        SCR_DamageManagerComponentClass data = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        array<EHitZoneGroup> groupedHitZoneIds = {};
        array<EHitZoneGroup> individualHitZoneGroupIds;
        foreach (EHitZoneGroup hitZoneGroup : hitZoneGroups)
        {
            individualHitZoneGroupIds = data.GetGroupHitZoneIds(hitZoneGroup);
            if (individualHitZoneGroupIds)
                groupedHitZoneIds.InsertAll(individualHitZoneGroupIds);
        }
 
        GetHitZonesByID(groupHitZones, groupedHitZoneIds);
 
        return groupHitZones.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    float GetGroupDamageOverTime(ECharacterHitZoneGroup hitZoneGroup, EDamageType damageType)
    {
        float totalGroupDamage;
        array<HitZone> groupedHitZones = {};
        GetHitZonesOfGroup(hitZoneGroup, groupedHitZones);
 
        foreach (HitZone hitzone : groupedHitZones)
        {
            totalGroupDamage += hitzone.GetDamageOverTime(damageType);
        }
 
        return totalGroupDamage;
    }
 
    //------------------------------------------------------------------------------------------------
    void Kill(notnull Instigator instigator)
    {
        IEntity owner = GetOwner();
        if (!owner)
            return;
 
        vector hitPosDirNorm[3];
 
        HitZone hitZone = GetDefaultHitZone();
        SCR_DamageContext damageContext = new SCR_DamageContext(EDamageType.TRUE, hitZone.GetMaxHealth(), hitPosDirNorm, owner, hitZone, instigator, null, -1, -1);
        if (instigator.GetInstigatorType() == InstigatorType.INSTIGATOR_GM)
            damageContext.damageEffect = new SCR_GameMasterActionDamageEffect();
 
        HandleDamage(damageContext);
    }
 
    //------------------------------------------------------------------------------------------------
    void DamageRandomHitZones(float damage, EDamageType type, notnull Instigator instigator, bool onlyPhysical = true, vector outMat[3] = {}, bool damageDefault = false)
    {
        array<HitZone> hitZones = {};
 
        if (onlyPhysical)
            GetPhysicalHitZones(hitZones);
        else
            GetAllHitZonesInHierarchy(hitZones);
 
        if (!damageDefault)
            hitZones.RemoveItem(GetDefaultHitZone());
 
        HitZone hitZone;
        DamageManagerComponent damageManager;
        float hitZoneDamage;
 
        while (damage > 0 && !hitZones.IsEmpty())
        {
            hitZone = hitZones.GetRandomElement();
            if (!hitZone)
            {
                hitZones.RemoveItem(hitZone);
                continue;
            }
 
            damageManager = DamageManagerComponent.Cast(hitZone.GetHitZoneContainer());
            if (!damageManager)
            {
                hitZones.RemoveItem(hitZone);
                continue;
            }
 
            // Check actual damage that will be dealt
            SCR_DamageContext hitZoneContext = new SCR_DamageContext(type, damage, outMat, damageManager.GetOwner(), hitZone, instigator, null, -1, -1);
            hitZoneDamage = Math.Min(hitZone.ComputeEffectiveDamage(hitZoneContext, false), hitZone.GetHealth());
 
            // Remove hit zones that cannot be damaged with this loop
            if (hitZoneDamage <= 0 || float.AlmostEqual(hitZoneDamage, 0))
            {
                hitZones.RemoveItem(hitZone);
                continue;
            }
 
            //damage is the remaining amount of damage to split between future hit zones
            damage -= hitZoneDamage;
 
            damageManager.HandleDamage(hitZoneContext);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool CanBeHealed(bool ignoreHealingDOT = true)
    {
        // Any damage to default hitzone
        if (GetDefaultHitZone().GetDamageState() == EDamageState.UNDAMAGED)
            return true;
 
        // Check if has damage over time
        array<EDamageType> damageTypes = {};
        SCR_Enum.GetEnumValues(EDamageType, damageTypes);
        
        foreach (EDamageType type : damageTypes)
        {
            if (!ignoreHealingDOT && HEALING_DAMAGE_TYPES.Contains(type))
                continue;
            
            if (IsDamagedOverTime(type))
                return true;
        }
        
        // No need to check fire on characters
        if (SCR_ChimeraCharacter.Cast(GetOwner()))
            return false;
 
        // Check if any hitzone is damaged
        array<HitZone> hitZones = {};
        GetAllHitZonesInHierarchy(hitZones);
        SCR_FlammableHitZone flammableHitZone;
        foreach (HitZone hitZone : hitZones)
        {
            if (hitZone && hitZone.GetDamageState() != EDamageState.UNDAMAGED)
                return true;
 
            // Flammable hitzone may be smoking
            flammableHitZone = SCR_FlammableHitZone.Cast(hitZone);
            if (flammableHitZone && IsOnFire(flammableHitZone))
                return true;
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    void FullHeal(bool ignoreHealingDOT = true)
    {
        array<HitZone> hitZones = {};
        GetAllHitZonesInHierarchy(hitZones);
 
        // Extinguish flammable hitzones
        SCR_FlammableHitZone flammableHitZone;
        foreach (HitZone hitZone : hitZones)
        {
            // Put out fire and smoke
            flammableHitZone = SCR_FlammableHitZone.Cast(hitZone);
            if (flammableHitZone)
                flammableHitZone.SetFireRate(0);
        }
 
        // Heal remaining damage over time
        array<EDamageType> damageTypes = {};
        SCR_Enum.GetEnumValues(EDamageType, damageTypes);
 
        foreach (EDamageType type : damageTypes)
        {
            // Prevent removing of healing DOTs so morphine and saline effects aren't stopped by healing action
            if (ignoreHealingDOT && (type == EDamageType.REGENERATION || type == EDamageType.HEALING))
                continue;
 
            if (IsDamagedOverTime(type))
                RemoveDamageOverTime(type);
        }
 
        // Fix hitzones
        foreach (HitZone hitZone : hitZones)
        {
            if (hitZone && hitZone.GetDamageState() != EDamageState.UNDAMAGED)
                hitZone.SetHealthScaled(1);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    float HealHitZones(float healthToDistribute, bool sequential = false, float maxHealThresholdScaled = 1, array<HitZone> alternativeHitZones = null)
    {
        if (healthToDistribute <= 0)
            return healthToDistribute;
 
        if (maxHealThresholdScaled < 0 || maxHealThresholdScaled > 1)
            maxHealThresholdScaled = 1;
 
        array<HitZone> targetHitZones = {};
        if (alternativeHitZones)
            targetHitZones.Copy(alternativeHitZones);
        else
            GetPhysicalHitZones(targetHitZones);
 
        if (sequential)
            healthToDistribute = HealHitZonesInSequence(healthToDistribute, maxHealThresholdScaled, targetHitZones);
        else // if in Parallel
            healthToDistribute = HealHitZonesInParallel(healthToDistribute, maxHealThresholdScaled, targetHitZones);
 
        ReduceSmoke();
        return healthToDistribute;
    }
 
    //------------------------------------------------------------------------------------------------
    protected float HealHitZonesInSequence(float healthToDistribute, float maxHealThresholdScaled, array<HitZone> targetHitZones)
    {
        foreach (HitZone hitZone : targetHitZones)
        {
            if (healthToDistribute <= 0)
                break;
 
            // If hitzone is undamaged, go onto the next one
            float healthToAdd = (hitZone.GetMaxHealth() * maxHealThresholdScaled) - hitZone.GetHealth();
            if (healthToAdd <= 0)
                continue;
 
            // If health to distribute runs out, heal hitzone with whats left and exit
            if (healthToAdd > healthToDistribute)
            {
                hitZone.HandleDamage(-healthToDistribute, EDamageType.HEALING, null);
                healthToDistribute = 0;
                break;
            }
 
            // Heal hitZone and substract distributable health value
            hitZone.HandleDamage(-healthToAdd, EDamageType.HEALING, null);
            healthToDistribute -= healthToAdd;
        }
 
        return healthToDistribute;
    }
 
    //------------------------------------------------------------------------------------------------
    protected float HealHitZonesInParallel(float healthToDistribute, float maxHealThresholdScaled, array<HitZone> targetHitZones)
    {
        array<HitZone> damagedHitZones = {};
 
        while (healthToDistribute > 0)
        {
            foreach (HitZone hitZone : targetHitZones)
            {
                if (hitZone.GetHealth() < (hitZone.GetMaxHealth() * maxHealThresholdScaled))
                    damagedHitZones.Insert(hitZone);
            }
 
            if (damagedHitZones.IsEmpty())
                break;
 
            float healthToDistributeHitZone = healthToDistribute / damagedHitZones.Count();
            foreach (HitZone hitZone : damagedHitZones)
            {
                if (healthToDistribute <= 0)
                    break;
 
                // If hitzone is undamaged, go onto the next one
                float healthToAdd = (hitZone.GetMaxHealth() * maxHealThresholdScaled) - hitZone.GetHealth();
                if (healthToAdd <= 0)
                    continue;
 
                // If health to distribute is more than needed, apply what's needed and save whats' left
                if (healthToDistributeHitZone > healthToAdd)
                {
                    hitZone.HandleDamage(-healthToAdd, EDamageType.HEALING, null);
                    healthToDistribute -= healthToAdd;
                    continue;
                }
                else// If health to distribute is less than needed, reduce healthToDistribute by health applied and continue
                {
                    hitZone.HandleDamage(-healthToDistributeHitZone, EDamageType.HEALING, null);
                    healthToDistribute -= healthToDistributeHitZone;
                    continue;
                }
            }
 
            damagedHitZones.Clear();
        }
 
        return healthToDistribute;
    }
 
    //------------------------------------------------------------------------------------------------
    void ReduceSmoke()
    {
        if (IsOnFire())
            return;
 
        SCR_DamageManagerComponentClass prefabData = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        if (!prefabData)
            return;
 
        HitZone defaultHZ = GetDefaultHitZone();
 
        array<HitZone> hitZones = {};
        GetAllHitZones(hitZones);
 
        float averageHP;
        int numberOfValidHZ;
        foreach (HitZone hz : hitZones)
        {
            if (hz == defaultHZ)
                continue;
 
            numberOfValidHZ++;
            averageHP += hz.GetHealthScaled();
        }
 
        if (numberOfValidHZ > 0)
        {
            averageHP /= numberOfValidHZ;
            if (averageHP > defaultHZ.GetHealthScaled())
                averageHP = defaultHZ.GetHealthScaled();
        }
        else
        {
            averageHP = defaultHZ.GetHealthScaled();
        }
 
        SCR_EBurningState desiredState;
        if (!prefabData.GetBurnStateForHealth(averageHP, desiredState))
            return;
 
        SCR_FlammableHitZone flammableHZ;
        foreach (HitZone hz : hitZones)
        {
            flammableHZ = SCR_FlammableHitZone.Cast(hz);
            if (!flammableHZ)
                continue;
 
            //make sure that we are not going to make it worse than it is now
            if (flammableHZ.GetFireState() <= desiredState)
                continue;
 
            flammableHZ.SetFireState(desiredState);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    float GetHitZonesDamage(float untilThresholdScaled = 1, array<HitZone> alternativeHitZones = null)
    {
        array<HitZone> hitZones = {};
        if (!alternativeHitZones || alternativeHitZones.IsEmpty())
            GetPhysicalHitZones(hitZones);
        else
            hitZones.Copy(alternativeHitZones);
 
        if (!hitZones)
            return 0;
 
        float totalDamage, addedDamage;
 
        foreach (HitZone hitZone : hitZones)
        {
            //~ Ignore undamaged
            if (hitZone.GetDamageState() == EDamageState.UNDAMAGED)
                continue;
 
            addedDamage = (hitZone.GetMaxHealth() * untilThresholdScaled) - hitZone.GetHealth();
            if (addedDamage > 0)
                totalDamage += addedDamage;
        }
 
        return totalDamage;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetHitZonesHealthScaled(array<HitZone> alternativeHitZones = null)
    {
        array<HitZone> hitZones = {};
        if (!alternativeHitZones || alternativeHitZones.IsEmpty())
            GetPhysicalHitZones(hitZones);
        else
            hitZones.Copy(alternativeHitZones);
 
        //~ No hitzones so health is full
        if (!hitZones || hitZones.IsEmpty())
            return 1;
 
        float totalHealthScaled;
 
        foreach (HitZone hitZone : hitZones)
        {
            if (hitZone.GetDamageState() == EDamageState.UNDAMAGED)
            {
                totalHealthScaled += 1;
                continue;
            }
 
            totalHealthScaled += hitZone.GetHealthScaled();
        }
 
        return totalHealthScaled / hitZones.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    float GetSingleHitZonesHealthScaled(array<HitZone> alternativeHitZones = null, bool getLowestHealth = true)
    {
        array<HitZone> hitZones = {};
        if (!alternativeHitZones || alternativeHitZones.IsEmpty())
            GetPhysicalHitZones(hitZones);
        else
            hitZones.Copy(alternativeHitZones);
 
        //~ No hitzones so health is full
        if (!hitZones || hitZones.IsEmpty())
            return 1;
 
        float returnValue = -1;
        float healthScaled;
 
        foreach (HitZone hitZone : hitZones)
        {
            if (returnValue < 0)
            {
                if (hitZone.GetDamageState() == EDamageState.UNDAMAGED)
                    returnValue = 1;
                else
                    returnValue = hitZone.GetHealthScaled();
 
                continue;
            }
 
            if (hitZone.GetDamageState() == EDamageState.UNDAMAGED)
                healthScaled = 1;
            else
                healthScaled = hitZone.GetHealthScaled();
 
            if ((getLowestHealth && returnValue > healthScaled) || (!getLowestHealth && returnValue < healthScaled))
                returnValue = healthScaled;
        }
 
        return returnValue;
    }
 
    //------------------------------------------------------------------------------------------------
    ResourceName GetSecondaryExplosion(float value, SCR_ESecondaryExplosionType explosionType, EResourceType resourceType = EResourceType.SUPPLIES, bool fire = false, out bool hasData = false)
    {
        SCR_DamageManagerComponentClass prefabData = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        if (!prefabData)
            return ResourceName.Empty;
 
        SCR_SecondaryExplosions secondaries;
        if (fire)
            secondaries = prefabData.GetSecondaryFires();
        else
            secondaries = prefabData.GetSecondaryExplosions();
 
        if (!secondaries)
            return ResourceName.Empty;
 
        hasData = true;
        return secondaries.GetExplosionPrefab(value, explosionType, resourceType);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_SecondaryExplosion GetSecondaryExplosionForScale(SCR_ESecondaryExplosionScale scale, SCR_ESecondaryExplosionType explosionType, EResourceType resourceType = EResourceType.SUPPLIES)
    {
        SCR_DamageManagerComponentClass prefabData = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        if (!prefabData)
            return null;
 
        SCR_SecondaryExplosions secondaries = prefabData.GetSecondaryFires();
        if (!secondaries)
            return null;
 
        return secondaries.GetSecondaryExplosionForScale(scale, explosionType, resourceType);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ESecondaryExplosionScale GetSecondaryExplosionScale(float value, SCR_ESecondaryExplosionType explosionType, EResourceType resourceType = EResourceType.SUPPLIES)
    {
        SCR_DamageManagerComponentClass prefabData = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        if (!prefabData)
            return SCR_ESecondaryExplosionScale.NONE;
 
        SCR_SecondaryExplosions secondaries = prefabData.GetSecondaryFires();
        if (!secondaries)
            return SCR_ESecondaryExplosionScale.NONE;
 
        return secondaries.GetSecondaryExplosionScale(value, explosionType, resourceType);
    }
 
    //------------------------------------------------------------------------------------------------
    ResourceName GetSecondaryFireParticle(float value, SCR_ESecondaryExplosionType explosionType, EResourceType resourceType = EResourceType.SUPPLIES)
    {
        SCR_DamageManagerComponentClass prefabData = SCR_DamageManagerComponentClass.Cast(GetComponentData(GetOwner()));
        if (!prefabData)
            return ResourceName.Empty;
 
        SCR_SecondaryExplosions secondaries = prefabData.GetSecondaryFires();
        if (!secondaries)
            return ResourceName.Empty;
 
        return secondaries.GetFireParticles(value, explosionType, resourceType);
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsOnFire(HitZone hitZone = null)
    {
        if (!hitZone)
            return IsOnFire(new array<HitZone>);
        
        SCR_FlammableHitZone flammableHZ = SCR_FlammableHitZone.Cast(hitZone);
        if (!flammableHZ)
            return false;
 
        return flammableHZ.GetFireState() >= m_iMinimumBurningState;
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsOnFire(notnull array<HitZone> hitZones)
    {
        if (hitZones.IsEmpty())
        {
            GetAllHitZones(hitZones);
            if (hitZones.IsEmpty())
                return false;
        }
 
        SCR_FlammableHitZone flammableHZ;
        foreach (HitZone hz : hitZones)
        {
            flammableHZ = SCR_FlammableHitZone.Cast(hz);
            if (!flammableHZ)
                continue;
 
            if (flammableHZ.GetFireState() >= m_iMinimumBurningState)
                return true;
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    void SecondaryExplosion(ResourceName prefabName, notnull Instigator instigator, notnull EntitySpawnParams spawnParams)
    {
        if (GetDefaultHitZone() && GetDefaultHitZone().IsProxy())
            return;
 
        Resource secondaryResource = Resource.Load(prefabName);
        if (!secondaryResource.IsValid())
            return;
 
        if (!spawnParams.Parent)
            spawnParams.Parent = GetOwner();
 
        IEntity explosion = GetGame().SpawnEntityPrefab(secondaryResource, spawnParams.Parent.GetWorld(), spawnParams);
        if (!explosion)
            return;
 
        // Set instigator on trigger component
        BaseTriggerComponent trigger = BaseTriggerComponent.Cast(explosion.FindComponent(BaseTriggerComponent));
        if (!trigger)
            return;
 
        trigger.SetInstigator(GetInstigator());
        // Ignore own vehicle
        array<IEntity> ignoreList = {GetOwner().GetRootParent()};
 
        // Ignore all hierarchy members as well
        SCR_EntityHelper.GetHierarchyEntityList(GetOwner().GetRootParent(), ignoreList);
 
        // Remove possible character entites from ignorelist
        SCR_BaseCompartmentManagerComponent baseCompartment = SCR_BaseCompartmentManagerComponent.Cast(GetOwner().FindComponent(SCR_BaseCompartmentManagerComponent));
        if (baseCompartment)
        {
            array<IEntity> vehicleOccupants = {};
            baseCompartment.GetOccupants(vehicleOccupants);
            foreach (IEntity entity : vehicleOccupants)
            {
                ignoreList.RemoveItem(entity);
            }
        }
            
        array<BaseProjectileEffect> explosionContainers = {};
        trigger.GetProjectileEffects(ExplosionDamageContainer, explosionContainers);
        foreach (BaseProjectileEffect effect : explosionContainers)
        {
            ExplosionDamageContainer.Cast(effect).SetIgnoreList(ignoreList);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ResourceEncapsulator GetResourceEncapsulator(EResourceType suppliesType = EResourceType.SUPPLIES)
    {
        IEntity owner = GetOwner();
        if (!owner)
            return null;
 
        SCR_ResourceComponent resourceComponent = SCR_ResourceComponent.FindResourceComponent(owner);
        if (!resourceComponent)
            return null;
 
        SCR_ResourceContainer container = resourceComponent.GetContainer(suppliesType);
        if (!container)
            return null;
 
        return container.GetResourceEncapsulator();
    }
 
    //------------------------------------------------------------------------------------------------
    void SupplySecondaryExplosion(notnull Instigator instigator)
    {
        SCR_ResourceEncapsulator encapsulator = GetResourceEncapsulator();
        if (!encapsulator)
            return;
 
        // First check, if there are any supplies at all
        // If there is no explosion, then do not spend time trying to figure out where it should be originated from
        float resourceValue = encapsulator.GetAggregatedResourceValue();
        if (resourceValue <= 0)
            return;
 
        IEntity owner = encapsulator.GetOwner();
        if (!owner)
            owner = GetOwner();
 
        if (!owner)
            return;
 
        bool hasData;
        ResourceName secondaryExplosionPrefab = GetSecondaryExplosion(resourceValue, SCR_ESecondaryExplosionType.RESOURCE, EResourceType.SUPPLIES, false, hasData);
        if (!hasData)
            return;
 
        SCR_ResourceContainerQueueBase containerQueue = encapsulator.GetContainerQueue();
        int containerCount = encapsulator.GetContainerCount();
        SCR_ResourceContainer container;
        EntitySpawnParams spawnParams = new EntitySpawnParams();
 
        // Get the weighed average position of explosion relative to encapsulator
        // Only calculate if we actually have an explosion to spawn
        if (!secondaryExplosionPrefab.IsEmpty())
        {
            float weight;
            vector position;
            vector averagePosition = owner.CoordToLocal(encapsulator.GetOwnerOrigin());
            spawnParams.Parent = owner;
 
            for (int i; i < containerCount; i++)
            {
                container = containerQueue.GetContainerAt(i);
                if (!container)
                    continue;
 
                // Determine secondary explosion position
                weight = container.GetResourceValue() / resourceValue;
                if (weight <= 0)
                    continue;
 
                position = owner.CoordToLocal(container.GetOwnerOrigin());
                averagePosition += position * weight;
            }
            spawnParams.Transform[3] = averagePosition;
        }
 
 
        // Destroy the resources and deny further use
        for (int i; i < containerCount; i++)
        {
            container = containerQueue.GetContainerAt(i);
            if (!container)
                continue;
 
            container.SetResourceValue(0);
            container.SetResourceRights(EResourceRights.NONE);
        }
 
        // Spawn explosion if prefab is available
        if (!secondaryExplosionPrefab.IsEmpty())
            SecondaryExplosion(secondaryExplosionPrefab, instigator, spawnParams);
    }
 
    //------------------------------------------------------------------------------------------------
    vector GetSecondaryExplosionPosition(typename hitZoneType, out float totalWeight = 0)
    {
        IEntity owner = GetOwner();
        if (!owner)
            return vector.Zero;
 
        array<HitZone> hitZones = {};
        GetAllHitZonesInHierarchy(hitZones);
        SCR_DestructibleHitzone destructibleHitZone;
        PointInfo explosionPoint;
        vector position;
        vector weighedAveragePosition;
        vector averagePosition;
        Physics physics = owner.GetPhysics();
        float weight;
        int validHitZones;
 
        // Get weighed average position of fuel tanks if defined in their hitzones
        foreach (HitZone hitZone : hitZones)
        {
            destructibleHitZone = SCR_DestructibleHitzone.Cast(hitZone);
            if (!destructibleHitZone || !destructibleHitZone.Type().IsInherited(hitZoneType))
                continue;
 
            explosionPoint = destructibleHitZone.GetSecondaryExplosionPoint();
            if (!explosionPoint && destructibleHitZone != GetDefaultHitZone())
                continue;
 
            if (explosionPoint)
                position = owner.CoordToLocal(explosionPoint.GetWorldTransformAxis(3));
            else if (physics)
                position = physics.GetCenterOfMass();
 
            validHitZones++;
            averagePosition += position;
            weight = destructibleHitZone.GetSecondaryExplosionScale();
            if (weight < 0 || float.AlmostEqual(weight, 0))
                continue;
 
            weighedAveragePosition += position * weight;
            totalWeight += weight;
        }
 
        if (totalWeight > 0)
            return weighedAveragePosition / totalWeight;
        else if (validHitZones > 0)
            return averagePosition / validHitZones;
        else if (physics)
            return physics.GetCenterOfMass();
 
        return vector.Zero;
    }
 
    //------------------------------------------------------------------------------------------------
    void FuelSecondaryExplosion(notnull Instigator instigator)
    {
        float totalFuel;
        vector explosionPosition = GetSecondaryExplosionPosition(SCR_FuelHitZone, totalFuel);
        EntitySpawnParams spawnParams = new EntitySpawnParams();
        spawnParams.Transform[3] = explosionPosition;
        ResourceName secondaryExplosionPrefab = GetSecondaryExplosion(totalFuel, SCR_ESecondaryExplosionType.FUEL);
        SecondaryExplosion(secondaryExplosionPrefab, instigator, spawnParams);
    }
 
    //------------------------------------------------------------------------------------------------
    void UpdateFireDamage(float timeSlice);
 
    //------------------------------------------------------------------------------------------------
    void UpdateFireParticles(vector position, out ParticleEffectEntity particles, SCR_ESecondaryExplosionScale state, SCR_ESecondaryExplosionType fireType, EResourceType resourceType = EResourceType.SUPPLIES)
    {
        if (particles)
        {
            SCR_ParticleHelper.StopParticleEmissionAndLights(particles);
            particles = null;
        }
 
        SCR_SecondaryExplosion secondaryFire = GetSecondaryExplosionForScale(state, fireType, resourceType);
        if (!secondaryFire)
            return;
 
        ResourceName fireParticles = secondaryFire.m_sSecondaryFireParticles;
        if (fireParticles.IsEmpty())
            return;
 
        ParticleEffectEntitySpawnParams params = new ParticleEffectEntitySpawnParams();
        params.FollowParent = GetOwner();
        params.Transform[3] = position;
        params.PlayOnSpawn = true;
        params.DeleteWhenStopped = true;
        params.UseFrameEvent = true;
 
        particles = ParticleEffectEntity.SpawnParticleEffect(fireParticles, params);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void ConnectToFireDamageSystem()
    {
        World world = GetOwner().GetWorld();
        FireDamageSystem system = FireDamageSystem.Cast(world.FindSystem(FireDamageSystem));
        if (system)
            system.Register(this);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void DisconnectFromFireDamageSystem()
    {
        World world = GetOwner().GetWorld();
        FireDamageSystem system = FireDamageSystem.Cast(world.FindSystem(FireDamageSystem));
        if (system)
            system.Unregister(this);
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnDamageStateChanged(EDamageState newState, EDamageState previousDamageState, bool isJIP)
    {
        super.OnDamageStateChanged(newState, previousDamageState, isJIP);
 
        if (m_iDamageManagerDataIndex != -1)
        {
            ScriptInvoker invoker = s_aDamageManagerData[m_iDamageManagerDataIndex].GetOnDamageStateChanged(false);
            if (invoker)
                invoker.Invoke(newState);
        }
 
        // Only main hitzone can explode supplies
        if (newState == EDamageState.DESTROYED)
        {
            Instigator instigator = GetInstigator();
            SupplySecondaryExplosion(instigator);
            FuelSecondaryExplosion(instigator);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnDamageOverTimeAdded(EDamageType dType, float dps, HitZone hz)
    {
        super.OnDamageOverTimeAdded(dType, dps, hz);
 
        if (m_iDamageManagerDataIndex != -1)
        {
            ScriptInvoker invoker = s_aDamageManagerData[m_iDamageManagerDataIndex].GetOnDamageOverTimeAdded(false);
            if (invoker)
                invoker.Invoke(dType, dps, hz);
        }
 
        RplComponent rpl = RplComponent.Cast(GetOwner().FindComponent(RplComponent));
        if (rpl && rpl.IsProxy())
            return;
 
        if (dType == EDamageType.FIRE)
            ConnectToFireDamageSystem();
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnDamageOverTimeRemoved(EDamageType dType, HitZone hz)
    {
        super.OnDamageOverTimeRemoved(dType, hz);
 
        if (m_iDamageManagerDataIndex != -1)
        {
            ScriptInvoker invoker = s_aDamageManagerData[m_iDamageManagerDataIndex].GetOnDamageOverTimeRemoved(false);
            if (invoker)
                invoker.Invoke(dType, hz);
        }
 
        RplComponent rpl = RplComponent.Cast(GetOwner().FindComponent(RplComponent));
        if (rpl && rpl.IsProxy())
            return;
 
        if (dType == EDamageType.FIRE && !IsDamagedOverTime(dType))
            DisconnectFromFireDamageSystem();
    }
 
    //------------------------------------------------------------------------------------------------ 
    override void OnPostInit(IEntity owner)
    {
        if (GetGame().GetWorld() != owner.GetWorld())
            return; // ignore entities which are in a different world, like preview world, or preload manager world
 
        SCR_DamageManagerComponentClass data = SCR_DamageManagerComponentClass.Cast(GetComponentData(owner));
        data.InitPrefabData(owner, this);
    }
 
    //------------------------------------------------------------------------------------------------
    */
    override bool HijackDamageHandling(notnull BaseDamageContext damageContext)
    {
        SCR_HitZone hitZone = SCR_HitZone.Cast(damageContext.struckHitZone);
        if (hitZone)
            hitZone.ApplyDamagePassRules(damageContext);
 
        SCR_FlammableHitZone flammableHitZone = SCR_FlammableHitZone.Cast(damageContext.struckHitZone);
        if (flammableHitZone && damageContext.damageType == EDamageType.INCENDIARY)
            flammableHitZone.HandleIncendiaryDamage(damageContext);
 
        return false;
    }
 
#ifdef WORKBENCH
 
    //------------------------------------------------------------------------------------------------
    override int _WB_GetAfterWorldUpdateSpecs(IEntity owner, IEntitySource src)
    {
        return EEntityFrameUpdateSpecs.CALL_WHEN_ENTITY_VISIBLE;
    }
    
    //---- REFACTOR NOTE START: This code will need to be refactored as current implementation is not conforming to the standards ----
    // TODO: DrawDebug should only run when toggled on by user
    //------------------------------------------------------------------------------------------------
    protected override void _WB_AfterWorldUpdate(IEntity owner, float timeSlice)
    {
        super._WB_AfterWorldUpdate(owner, timeSlice);
 
        GenericEntity entity = GenericEntity.Cast(owner);
        if (!entity)
            return;
 
        WorldEditorAPI api = entity._WB_GetEditorAPI();
        if (!api || !api.IsEntitySelected(api.EntityToSource(owner)))
            return;

        array<HitZone> hitZones = {};
        GetAllHitZones(hitZones);
 
        SCR_HitZone hitzone;
        foreach (HitZone hitZone : hitZones)
        {
            hitzone = SCR_HitZone.Cast(hitZone);
            if (hitzone)
                hitzone.DrawDebug();
        }
    }
    //---- REFACTOR NOTE END ----
#endif
}