bleedingsourcesmanagerserver.c

Go to the documentation of this file.

class BleedingSourcesManagerServer extends BleedingSourcesManagerBase
{
    const float TICK_INTERVAL_SEC = 3;
    float   m_Tick;
    bool    m_DisableBloodLoss = false;
    ref array<int> m_DeleteList = new array<int>;
    
    const int STORAGE_VERSION = 103;
    
    protected BleedingSourceZone GetBleedingSourceZone(int bit)
    {
        return m_BleedingSourceZone.Get(GetSelectionNameFromBit(bit));
    }
    
    int GetStorageVersion()
    {
        return STORAGE_VERSION;
    }
    
    void RequestDeletion(int bit)
    {
        m_DeleteList.Insert(bit);
    }
    
    override protected void AddBleedingSource(int bit)
    {
        #ifdef DEVELOPER
        if (m_Player && !m_Player.GetAllowDamage())//full invincibility prevents bleeding source creation
            return;
        #endif
        
        m_Player.SetBleedingBits(m_Player.GetBleedingBits() | bit );
        super.AddBleedingSource(bit);
        m_Player.OnBleedingSourceAdded();
    }
    
    override protected bool RemoveBleedingSource(int bit)
    {
        if(!super.RemoveBleedingSource(bit))
        {
            Error("Failed to remove bleeding source:" + bit);
        }
        else
        {
            m_Player.OnBleedingSourceRemovedEx(m_Item);
        }
        
        int inverse_bit_mask = ~bit;
        m_Player.SetBleedingBits(m_Player.GetBleedingBits() & inverse_bit_mask );
        
        
        //infection moved here to allow proper working in singleplayer
        float chanceToInfect;
        
        if (m_Item)
        {
            chanceToInfect = m_Item.GetInfectionChance(0, CachedObjectsParams.PARAM1_BOOL);
        }
        else
        {
            chanceToInfect = PlayerConstants.BLEEDING_SOURCE_CLOSE_INFECTION_CHANCE;
        }
        float diceRoll = Math.RandomFloat01();
        if (diceRoll < chanceToInfect)
        {
            m_Player.InsertAgent(eAgents.WOUND_AGENT);
        }
        
        m_Item = null;//reset, so that next call, if induced by self-healing, will have no item
        
        return true;
    }
    
    void RemoveAnyBleedingSource()
    {
        int bleeding_sources_bits = m_Player.GetBleedingBits();
        int rightmost_bit = bleeding_sources_bits & (-bleeding_sources_bits);
        
        RemoveBleedingSource(rightmost_bit);
    }
    
    void RemoveMostSignificantBleedingSource()
    {
        int bit = GetMostSignificantBleedingSource();
        if( bit != 0)
            RemoveBleedingSource(bit);
    }
    
    void RemoveMostSignificantBleedingSourceEx(ItemBase item)
    {
        SetItem(item);
        RemoveMostSignificantBleedingSource();
    }
    
    int GetMostSignificantBleedingSource()
    {
        int bleeding_sources_bits = m_Player.GetBleedingBits();
        
        float highest_flow;
        int highest_flow_bit;
        int bit_offset;
        
        for(int i = 0; i < BIT_INT_SIZE; i++)
        {
            int bit = 1 << bit_offset;
            
            if( (bit & bleeding_sources_bits) != 0 )
            {
                BleedingSourceZone meta = GetBleedingSourceMeta(bit);
                if(meta)
                {
                    if( meta.GetFlowModifier() > highest_flow )
                    {
                        highest_flow = meta.GetFlowModifier();
                        highest_flow_bit = bit;
                        //Print(meta.GetSelectionName());
                    }
                }
            }
            bit_offset++;
        }
        return highest_flow_bit;
    }
    
    void OnTick(float delta_time)
    {
        m_Tick += delta_time;
        if( m_Tick > TICK_INTERVAL_SEC )
        {
            while( m_DeleteList.Count() > 0 )
            {
                RemoveBleedingSource(m_DeleteList.Get(0));
                m_DeleteList.Remove(0);
            } 
            
            float blood_scale = Math.InverseLerp(PlayerConstants.BLOOD_THRESHOLD_FATAL, PlayerConstants.BLEEDING_LOW_PRESSURE_BLOOD, m_Player.GetHealth( "GlobalHealth", "Blood" ));
            blood_scale = Math.Clamp( blood_scale, PlayerConstants.BLEEDING_LOW_PRESSURE_MIN_MOD, 1 );
 
            for(int i = 0; i < m_BleedingSources.Count(); i++)
            {
                m_BleedingSources.GetElement(i).OnUpdateServer( m_Tick, blood_scale, m_DisableBloodLoss );
            }
            m_Tick = 0;
        }
    }
    
    void ActivateAllBS()
    {
        for(int i = 0; i < m_BleedingSourceZone.Count(); i++)
        {
            int bit = m_BleedingSourceZone.GetElement(i).GetBit();
            if( CanAddBleedingSource(bit) )
            {
                AddBleedingSource(bit);
            }
        }
    }
    
    //damage must be to "Blood" healthType
    void ProcessHit(float damage, EntityAI source, int component, string zone, string ammo, vector modelPos)
    {
        float dmg_max = m_Player.GetMaxHealth(zone, "Blood");
        float bleed_threshold = GetGame().ConfigGetFloat("CfgAmmo " + ammo + " DamageApplied bleedThreshold");
        string damageTypeString = GetGame().ConfigGetTextOut("CfgAmmo " + ammo + " DamageApplied type");
        bleed_threshold = Math.Clamp(bleed_threshold,0,1);
        float bleedingChance;
        bool createBleedingSource = false;
        
        // 'true' only when the damageTypeString is handled there
        if (BleedChanceData.CalculateBleedChance(damageTypeString, damage, bleed_threshold,bleedingChance))
        {
            float roll = Math.RandomFloat01();
            createBleedingSource = bleedingChance != 0 && bleedingChance >= roll;
            
            #ifdef DEVELOPER
            if (LogManager.IsBleedingChancesLogEnable())
            {   
                Debug.BleedingChancesLog(roll.ToString(), "BleedingSourcesManagerServer" , "n/a", "bleeding random roll:");
            }
            #endif
        }
        else if (source && source.IsZombie())
        {
            int chance = Math.RandomInt(0,100);
            if (chance <= damage)
            {
                createBleedingSource = true;
            }
        }
        else if (damage > (dmg_max * (1 - bleed_threshold)) )
        {
            createBleedingSource = true;
        }
        
        if (createBleedingSource)
        {
            #ifdef DEVELOPER
            if (LogManager.IsBleedingChancesLogEnable())
            {   
                Debug.BleedingChancesLog("true", "BleedingSourcesManagerServer" , "n/a", "Attempting to create bleeding source");
            }
            #endif
            AttemptAddBleedingSource(component);
        }
    }
    
    void DebugActivateBleedingSource(int source)
    {
        RemoveAllSources();
        
        if(source >= m_BleedingSourceZone.Count() || !m_BleedingSourceZone.GetElement(source)) return;
        
        int bit = m_BleedingSourceZone.GetElement(source).GetBit();
        
        if( bit && CanAddBleedingSource(bit) )
        {
            AddBleedingSource(bit);
        }
    }
    
    void SetBloodLoss(bool status)
    {
        m_DisableBloodLoss = status;
    }
    
    void OnStoreSave( ParamsWriteContext ctx )
    {
        //int count = m_BleedingSources.Count();
        int active_bits = m_Player.GetBleedingBits();
        ctx.Write(active_bits);
        
        int bit_offset = 0;
        for(int i = 0; i < BIT_INT_SIZE; i++)
        {
            int bit = 1 << bit_offset;
            if( (bit & active_bits) != 0 )
            {
                int active_time = GetBleedingSourceActiveTime(bit);
                eBleedingSourceType type = GetBleedingSourceType(bit);
                
                ctx.Write(active_time);
                ctx.Write(type);
            }
            bit_offset++;
        }
    }
 
    bool OnStoreLoad( ParamsReadContext ctx, int version )
    {
        int active_bits;
        if(!ctx.Read(active_bits))
        {
            return false;
        }
    
        int bit_offset = 0;
        for(int i = 0; i < BIT_INT_SIZE; i++)
        {
            int bit = 1 << bit_offset;
            if( (bit & active_bits) != 0 && CanAddBleedingSource(bit))
            {
                AddBleedingSource(bit);
                int active_time = 0;
                if(!ctx.Read(active_time))
                {
                    return false;
                }
                else
                {
                    SetBleedingSourceActiveTime(bit,active_time);
                }
                if( version >= 121 )//type was added in this version
                {
                    eBleedingSourceType type = eBleedingSourceType.NORMAL;
                    if (!ctx.Read(type))
                    {
                        return false;
                    }
                    else
                    {
                        SetBleedingSourceType(bit,type);
                    }
                }
            }
            bit_offset++;
        }
        return true;
    }
    
    
    void ~BleedingSourcesManagerServer()
    {
        if (m_Player && !m_Player.IsAlive())
            RemoveAllSources();
    }
}