PlayerAgentPool.c

Go to the documentation of this file.

class PlayerAgentPool
{
    ref map<int,float> m_VirusPool = new map<int,float>;
    ref array<int> m_VirusPoolArray = new array<int>;
    float m_LastTicked = 0;
    float m_TotalAgentCount;
    PlayerBase m_Player;
    int m_AgentMask;
        
    const int STORAGE_VERSION = 100;
    
    PluginTransmissionAgents m_PluginTransmissionAgents = PluginTransmissionAgents.Cast(GetPlugin(PluginTransmissionAgents));
    
    void PlayerAgentPool(PlayerBase player)
    {
        m_Player = player;
    }
 
    void ~PlayerAgentPool()
    {
        
    }
    
    int GetStorageVersion()
    {
        return STORAGE_VERSION;
    }
    
    void PrintAgents()
    {
        if( m_VirusPool )
        {
            for(int i = 0; i < m_VirusPool.Count(); i++)
            {
                Debug.Log("Agent: "+ m_VirusPool.GetKey(i).ToString(), "Agents");
                Debug.Log("Count: "+ m_VirusPool.GetElement(i).ToString(), "Agents");
            }
        
        }
    }
 
    void ImmuneSystemTick(float value, float deltaT)//this is a regular tick induced in the the player's immune system
    {
        SpawnAgents(deltaT);
        GrowAgents(deltaT);
    }
    
    void GrowAgents(float deltaT)
    {
        if ( !IsPluginManagerExists() )//check if modules are running
            return;
        
        EStatLevels immunity_level = m_Player.GetImmunityLevel();
        
        m_TotalAgentCount = 0;
        for(int i = 0; i < m_VirusPool.Count(); i++)
        {   
            int agent_id = m_VirusPool.GetKey(i);
            int max_count = m_PluginTransmissionAgents.GetAgentMaxCount( agent_id );
 
            EStatLevels agent_potency = m_PluginTransmissionAgents.GetAgentPotencyEx( agent_id, m_Player );
            
            float grow_delta;
 
            if( agent_potency <= immunity_level )
            {
                bool grow_during_antibiotics = m_PluginTransmissionAgents.GrowDuringAntibioticsAttack(agent_id, m_Player);
                if (m_Player.IsAntibioticsActive() && !grow_during_antibiotics)
                    continue;
                float invasibility = m_PluginTransmissionAgents.GetAgentInvasibilityEx( agent_id, m_Player );
                grow_delta = invasibility * deltaT;
            }
            else
            {
                float dieoff_speed = m_PluginTransmissionAgents.GetAgentDieOffSpeedEx( agent_id, m_Player );
                grow_delta = -dieoff_speed * deltaT;
            }
 
            //Print( agent_id );
            //Print( grow_delta );
            
            float old_count = m_VirusPool.Get( agent_id );
            float new_count = old_count + grow_delta;
            new_count = Math.Clamp(new_count, 0,max_count);
            
            m_TotalAgentCount += new_count;
            SetAgentCount(agent_id, new_count);
        }
    }
 
    void OnStoreSave(ParamsWriteContext ctx)
    {
        //Debug.Log("PlayerAgentPool OnStoreSave called", "Agents");
        
        ctx.Write( m_VirusPool.Count() );
        for(int i = 0; i < m_VirusPool.Count();i++)
        {
            int key = m_VirusPool.GetKey(i);
            int value = m_VirusPool.GetElement(i);
            ctx.Write( key );
            ctx.Write( value );
        }
    }
    
    bool OnStoreLoad(ParamsReadContext ctx, int version)
    {
        //Debug.Log("PlayerAgentPool OnStoreLoad called", "Agents");
        int count;
        
        if(!ctx.Read(count))
        {
            return false;
        }
    
        for(int i = 0; i < count;i++)
        {
            int key;
            int value;
            if(!ctx.Read(key))
            {
                return false;
            }
            
            if(!ctx.Read(value))
            {
                return false;
            }
            
            SetAgentCount( key,value );
        }
    
        return true;
    }
    void DigestAgent(int agent_id, float count)
    {
        AddAgent(agent_id, m_PluginTransmissionAgents.GetAgentDigestibility(agent_id) * count);
    }   
    
    void AddAgent(int agent_id, float count)
    {
        int max_count = m_PluginTransmissionAgents.GetAgentMaxCount(agent_id);
        
        if( !m_VirusPool.Contains(agent_id) && count > 0 )//if it contains, maybe add count only ?
        {
            //m_VirusPool.Insert( agent_id, Math.Clamp(count,0,max_count) );
            SetAgentCount(agent_id,count);
        }
        else
        {
            float new_value = m_VirusPool.Get(agent_id) + count;
            //Print(new_value);
            SetAgentCount(agent_id,new_value);
        }
    }
 
/*
    void RemoveAgent(int agent_id)
    {
        if( m_VirusPool.Contains(agent_id) )
        {
            m_VirusPool.Remove( agent_id );
        }
    }
    */
    void RemoveAgent(int agent_id)
    {
        SetAgentCount(agent_id, 0);
    }
    
    void RemoveAllAgents()
    {
        m_AgentMask = 0;
        m_VirusPool.Clear();
    }
    
    /*
    array<int GetAgents()
    {
        m_VirusPoolArray.Clear();
        
        for(int i = 0; i < m_VirusPool.Count();i++)
        {
            m_VirusPoolArray.Insert( m_VirusPool.GetKey(i) );
        }
        
        return m_VirusPoolArray;
    }
    */
    
    int GetAgents()
    {
        return m_AgentMask;
    }
 
    int GetSingleAgentCount(int agent_id)
    {
        if( m_VirusPool.Contains(agent_id) )
        {
            return m_VirusPool.Get( agent_id );
        }
        else return 0;
    }
    
    float GetTotalAgentCount()
    {
        float agent_count;
        for(int i = 0; i < m_VirusPool.Count(); i++)
        {
            agent_count += m_VirusPool.GetElement(i);
        }
        return agent_count;
    }
    
    void SpawnAgents(float deltaT)
    {
        int count = m_PluginTransmissionAgents.GetAgentList().Count();
        for(int i = 0; i < count;i++)
        {
            AgentBase agent = m_PluginTransmissionAgents.GetAgentList().GetElement(i);
            int agent_id = agent.GetAgentType();
            
            if( GetSingleAgentCount(agent_id)==0 && agent.AutoinfectCheck(deltaT, m_Player) )
            {
                AddAgent(agent_id,100);
            }
        }
    }
    
 
    void SetAgentCount(int agent_id, float count)
    {
        if(count > 0)
        {
            //Debug.Log("+ growing agent"+ agent_id.ToString() +"to count: "+count.ToString(), "Agents");
            m_VirusPool.Set( agent_id, count);
            m_AgentMask = m_AgentMask | agent_id;
        }
        else
        {
            //Debug.Log("- REMOVING agent"+ agent_id.ToString(), "Agents");
            m_VirusPool.Remove( agent_id );
            m_AgentMask = m_AgentMask & ~agent_id;
        }           
        if(m_Player.m_Agents != m_AgentMask)
        {
            m_Player.m_Agents = m_AgentMask;
            m_Player.SetSynchDirty();
        }
    }
 
    void AntibioticsAttack(float attack_value)
    {
        for(int i = 0; i < m_VirusPool.Count(); i++)
        {
            int agent_id = m_VirusPool.GetKey(i);
            float antibiotics_resistance = 1 - m_PluginTransmissionAgents.GetAgentAntiboticsResistanceEx(agent_id, m_Player);
            float delta = attack_value * antibiotics_resistance;
            float old_count = m_VirusPool.Get( agent_id );
            float new_count = old_count - delta;
            //PrintString("delta:"+delta.ToString());
            //PrintString("old_count:"+old_count.ToString());
            //PrintString("new_count:"+new_count.ToString());
            SetAgentCount(agent_id, new_count);
        }
    }
 
    
    void RemoteGrowRequestDebug(ParamsReadContext ctx)
    {
        ctx.Read(CachedObjectsParams.PARAM1_INT);
        int id = CachedObjectsParams.PARAM1_INT.param1;
        int max = m_PluginTransmissionAgents.GetAgentMaxCount(Math.AbsInt(id));
        int grow = max / 10;
        if(id > 0)
        {
            AddAgent(id, grow);
        }
        else if( id < 0)
        {
            AddAgent(-id, -grow);
        }
    }
    
    void GetDebugObject(array<ref Param> object_out)
    {
        int count = m_PluginTransmissionAgents.GetAgentList().Count();
        for(int i = 0; i < count;i++)
        {
            AgentBase agent = m_PluginTransmissionAgents.GetAgentList().GetElement(i);
            string agent_name = agent.GetName();
            int agent_id = agent.GetAgentType();
            int max_agents = m_PluginTransmissionAgents.GetAgentMaxCount(agent_id);
            string amount = GetSingleAgentCount(agent_id).ToString() + "/" + max_agents.ToString();
            object_out.Insert( new Param3<string,string, int>(agent_name, amount, agent_id) );
        }
        object_out.InsertAt(new Param1<int>(count) ,0);
    }
}