PlayerStomach.c

Go to the documentation of this file.

class StomachItem
{
  ref NutritionalProfile m_Profile;
  float m_Amount;
  int m_FoodStage;
  //bool m_IsLiquid;
  string m_ClassName;
  int m_Agents;
 
  void StomachItem(string class_name, float amount, NutritionalProfile profile, int foodstage, int agents)
  {
    m_Amount = amount;
    m_Profile = profile;
    //m_IsLiquid = is_liquid;
    m_FoodStage = foodstage;
    m_ClassName = class_name;
    m_Agents = agents;
  }
 
  string GetClassName()
  {
    return m_ClassName;
  }
 
  /*
    void SetLiquid(bool is_liquid)
    {
    m_IsLiquid = is_liquid;
    }
 
    bool IsLiquid()
    {
    return m_IsLiquid;
    }*/
 
 
  int GetFoodStage()
  {
    return m_FoodStage;
  }
 
  void SetFoodStage(int food_stage)
  {
    m_FoodStage = food_stage;
  }
 
  // returns grams or ml's of this item/liquid
  float GetAmount()
  {
    return m_Amount;
  }
 
  // adds grams or ml's of this item/liquid
  void AddAmount(float amount)
  {
    m_Amount += amount;
  }
 
  void AddAgents(int agents)
  {
    m_Agents = m_Agents | agents;
  }
 
 
  // "digests" given amount, "outs" nutritional components, and returns 'true' if leads to complete item digestion(no amount left)
  bool ProcessDigestion(float digestion_points, out float water, out float energy, out float toxicity, out float volume, out int agents, out float consumed_amount)
  {
    agents = m_Agents;
    consumed_amount = GetNutritions(digestion_points, m_Profile, water, energy, toxicity);
    m_Amount -= consumed_amount;
    volume = m_Profile.GetFullnessIndex() * m_Amount;
    return (m_Amount < 0.001);
  }
 
  float GetNutritions(float digestion_points, NutritionalProfile profile, out float water, out float energy, out float toxicity)
  {
    float energy_per_unit = profile.GetEnergy() / 100;
    float water_per_unit = profile.GetWaterContent() / 100;
    float toxicity_per_unit = profile.GetToxicity();
    float digestability = profile.GetDigestibility();
 
    if (digestability == 0) //if undefined
      digestability = 1;
 
    float consumed_quantity = digestion_points * digestability;
 
    if (m_Amount < consumed_quantity)
      consumed_quantity = m_Amount;
    if (consumed_quantity > 0)
    {
      water = consumed_quantity * water_per_unit;
      energy = consumed_quantity * energy_per_unit;
      toxicity = consumed_quantity * toxicity_per_unit;
    }
    return consumed_quantity;
  }
}
 
class PlayerStomach
{
  const int DIGESTING_WATER = 1;
  const int DIGESTING_ENERGY = 2;
 
  const int quantity_bit_offset = 16;
  const int id_bit_offset = 4;//based on food stage count(+1 for safe measure)
  static int CHECKSUM;
  const float DIGESTION_POINTS = PlayerConstants.DIGESTION_SPEED;
  const int ACCEPTABLE_QUANTITY_MAX = 32768;
  const int ACCEPTABLE_FOODSTAGE_MAX = FoodStageType.COUNT - 1;
  static ref map<string, int> m_NamesToIDs = new map<string, int>;
  static ref map<int, string> m_IDsToNames = new map<int, string>;
  static const bool m_InitData = PlayerStomach.InitData();
  ref array<ref StomachItem> m_StomachContents = new array<ref StomachItem>;
  int m_AgentTransferFilter;//bit mask that prevents agents set in the mask from passing to the player
  bool m_Digesting;
  int m_DigestingType;
  PlayerBase m_Player;
  float m_StomachVolume;
  const int STORAGE_VERSION = 106;
 
 
  void PlayerStomach(PlayerBase player)
  {
    m_Player = player;
  }
 
  void ~PlayerStomach()
  {
 
  }
 
 
  float GetStomachVolume()
  {
    return m_StomachVolume;
  }
 
  void ClearContents()
  {
    m_StomachContents.Clear();
    m_StomachVolume = 0.0;
  }
 
  void SetAgentTransferFilter(int filter_agents)
  {
    m_AgentTransferFilter;
  }
 
  int GetAgentTransferFilter()
  {
    return m_AgentTransferFilter;
  }
 
  static void RegisterItem(string classname, int id)
  {
    int hash = classname.Hash();
    CHECKSUM = CHECKSUM ^ hash; //xor hash vs current checksum
    // Print(classname);
    // Print(CHECKSUM);
    m_NamesToIDs.Insert(classname, id);
    m_IDsToNames.Insert(id, classname);
  }
 
  static string GetClassnameFromID(int id)
  {
    return m_IDsToNames.Get(id);
  }
 
  static int GetIDFromClassname(string name)
  {
    if (!m_NamesToIDs.Contains(name))
      return -1;
    return m_NamesToIDs.Get(name);
  }
 
  static bool InitData()
  {
    TStringArray all_paths = new TStringArray;
 
    all_paths.Insert("CfgVehicles");
    all_paths.Insert("cfgLiquidDefinitions");
 
    string config_path;
    string child_name;
    int scope;
    string path;
    int consumable_count;
    for (int i = 0; i < all_paths.Count(); i++)
    {
      config_path = all_paths.Get(i);
      int children_count = GetGame().ConfigGetChildrenCount(config_path);
 
      for (int x = 0; x < children_count; x++)
      {
        GetGame().ConfigGetChildName(config_path, x, child_name);
        path = config_path + " " + child_name;
        scope = GetGame().ConfigGetInt(config_path + " " + child_name + " scope");
        bool should_check = 1;
        if (config_path == "CfgVehicles" && scope == 0)
          should_check = 0;
 
        if (should_check)
        {
          bool has_nutrition = GetGame().ConfigIsExisting(path + " Nutrition");
          bool has_stages = GetGame().ConfigIsExisting(path + " Food");
 
          if (has_nutrition || has_stages)
          {
            //Print("child name:" + child_name);
            RegisterItem(child_name, consumable_count);//consumable_count value serves as an unique ID for each item
            consumable_count++;
          }
        }
      }
    }
    //Print("consumable_count " + consumable_count);
    return true;
  }
 
  int GetStorageVersion()
  {
    return STORAGE_VERSION;
  }
 
  bool IsDigesting()
  {
    return (m_DigestingType != 0);
  }
 
  int GetDigestingType()
  {
    return m_DigestingType;
  }
 
 
  void Update(float delta_time)
  {
    ProcessNutrients(delta_time);
  }
 
  void ProcessNutrients(float delta_time)
  {
    StomachItem item;
    int stomach_items_count = m_StomachContents.Count();
    m_DigestingType = 0;
    if (stomach_items_count == 0)
      return;
 
    float digestion_points_per_item = (DIGESTION_POINTS / stomach_items_count) * delta_time;
    m_StomachVolume = 0;//reset, it's accumulated with each pass
    for (int i = 0; i < m_StomachContents.Count(); i ++)
    {
      item = m_StomachContents.Get(i);
      float water, energy, toxicity, volume, consumed_amount;
      int agents;
      if (item.ProcessDigestion(digestion_points_per_item, water, energy, toxicity, volume, agents, consumed_amount))
      {
        m_StomachContents.Remove(i);
        i--;
      }
      m_StomachVolume += volume;
      m_Player.GetStatEnergy().Add(energy);
      m_Player.GetStatWater().Add(water);
 
      if (energy > 0)
        m_DigestingType = m_DigestingType | DIGESTING_ENERGY;
 
      if (water > 0)
        m_DigestingType = m_DigestingType | DIGESTING_WATER;
 
      DigestAgents(agents, consumed_amount);
    }
  }
 
 
  void DigestAgents(int agents, float quantity)
  {
    if (!agents)
      return;
    agents = agents & (~m_AgentTransferFilter);//filter against the agent filter mask
    int highest_bit = Math.Log2(agents) + 1;
    for (int i = 0; i < highest_bit; i++)
    {
      int agent = (1 << i)& agents;
      if (agent)
        m_Player.m_AgentPool.DigestAgent(agent, quantity);
    }
  }
 
  void PrintUpdate()
  {
    Print("================================");
    for (int i = 0; i < m_StomachContents.Count(); i++)
    {
      string itemname = m_StomachContents.Get(i).m_ClassName;
      float amount = m_StomachContents.Get(i).GetAmount();
      int food_stage = m_StomachContents.Get(i).GetFoodStage();
      int agents = m_StomachContents.Get(i).m_Agents;
      Print(">");
      Print("itemname:" + itemname);
      Print("amount:" + amount);
      Print("food_stage:" + food_stage);
      Print("agents:" + agents);
      Print(">");
    }
    Print("m_StomachVolume:" + m_StomachVolume);
    Print("================================");
  }
 
  void AddToStomach(string class_name, float amount, int food_stage = 0, int agents = 0)
  {
    if (GetIDFromClassname(class_name) == -1)
      return;
    bool is_liquid;
 
    NutritionalProfile profile = Liquid.GetNutritionalProfileByName(class_name);
    if (profile)
      is_liquid = true;
    else
      profile = Edible_Base.GetNutritionalProfile(null, class_name, food_stage);
 
    if (profile)
    {
      // sanity checks start
      if (amount > ACCEPTABLE_QUANTITY_MAX || amount < 0)
        amount = 0;
      if (food_stage < 0 || food_stage > ACCEPTABLE_FOODSTAGE_MAX)
        food_stage = FoodStageType.RAW;
      // sanity checks end
 
      agents = agents | profile.GetAgents();
      bool found = false;
      for (int i = 0; i < m_StomachContents.Count(); i++)
      {
        StomachItem stomach_item = m_StomachContents.Get(i);
        if (stomach_item.GetClassName() == class_name)
        {
          if (is_liquid || stomach_item.GetFoodStage() == food_stage)
          {
            stomach_item.AddAmount(amount);
            stomach_item.AddAgents(agents);
            found = true;
          }
        }
      }
 
      if (!found)
        m_StomachContents.Insert(new StomachItem(class_name, amount, profile, food_stage, agents));
    }
  }
 
  void OnStoreSave(ParamsWriteContext ctx)
  {
    ctx.Write(PlayerStomach.CHECKSUM);
    ctx.Write(m_StomachContents.Count());
    StomachItem stomach_item;
    for (int i = 0; i < m_StomachContents.Count(); i++)
    {
      stomach_item = m_StomachContents.Get(i);
      int id = PlayerStomach.GetIDFromClassname(stomach_item.m_ClassName);
      //Print("SAVE id:" + id);
      //Print("SAVE id_bit_offset:" + id_bit_offset);
 
      int write_result = stomach_item.m_FoodStage | (id << id_bit_offset);
      write_result = write_result | ((int)stomach_item.m_Amount << quantity_bit_offset);
      ctx.Write(write_result);
      ctx.Write(stomach_item.m_Agents);
      //Print("SAVE write_result:" + write_result);
    }
    //Print("SAVE CHECKSUM:" + PlayerStomach.CHECKSUM);
  }
 
  bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    int checksum, count;
    if (!ctx.Read(checksum))
      return false;
 
    if (!ctx.Read(count))
      return false;
    for (int i = 0; i < count; i++)
    {
      int value, agents;
      if (!ctx.Read(value))
        return false;
      if (!ctx.Read(agents))
        return false;
      if (checksum == CHECKSUM) //if checksum matches, add to stomach, otherwise throw the data away but go through the de-serialization to keep the stream intact
      {
        int amount = value >> quantity_bit_offset;//isolate amount bits
        int id_mask = Math.Pow(2, quantity_bit_offset) - 1;
        int id = (id_mask & value) >> id_bit_offset;//isolate id bits
        int food_mask = Math.Pow(2, id_bit_offset) - 1;
        int food_stage = value & food_mask;
        //Print("LOAD value:" + value);
        //Print("LOAD id:" + id);
        //Print("LOAD id_bit_offset:" + id_bit_offset);
        //Print("LOAD food_stage:" + food_stage);
        string classname = GetClassnameFromID(id);
        AddToStomach(classname, amount, food_stage, agents);
      }
    }
    //Print("LOAD checksum:" + checksum);
    if (checksum != CHECKSUM)
      Print("Stomach checksum fail");
    return true;
  }
 
  int GetDebugObject(array<ref Param> object_out)
  {
    int count = m_StomachContents.Count();
    for (int i = 0; i < m_StomachContents.Count(); i++)
    {
      int id = PlayerStomach.GetIDFromClassname(m_StomachContents.Get(i).m_ClassName);
      int food_stage = m_StomachContents.Get(i).m_FoodStage;
      int agents = m_StomachContents.Get(i).m_Agents;
      float amount = m_StomachContents.Get(i).m_Amount;
      Param4<int, int, int, float> p4 = new Param4<int, int, int, float>(id, food_stage, agents, amount);
      object_out.Insert(p4);
    }
    Param1<float> p1 = new Param1<float>(m_StomachVolume);
    object_out.Insert(p1);
    return count;
 
  }
}