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