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