FoodStage.c

Go to the documentation of this file.

enum FoodStageType
{
    NONE        = 0,            //food stage not define
    RAW         = 1,            //default
    BAKED       = 2,
    BOILED      = 3,
    DRIED       = 4,
    BURNED      = 5,
    ROTTEN      = 6,
    
    COUNT                       //for net sync purposes
}
 
// Used to make getting data more readable
enum eCookingPropertyIndices
{
    MIN_TEMP    = 0,
    COOK_TIME   = 1,
    MAX_TEMP    = 2
}
 
class FoodStage
{
    protected FoodStageType m_FoodStageTypeClientLast;
    protected FoodStageType m_FoodStageType;
    protected Edible_Base m_FoodItem;
    
    protected int m_SelectionIndex;             //visual properties
    protected int m_TextureIndex;
    protected int m_MaterialIndex;
    
    protected float m_CookingTime;
    
    // Lookup and search values
    // STRINGs are mostly used for CONFIG searches
    // INTs are mostly used for MAP searches
    static const string VISUAL_PROPERTIES           =   "visual_properties";
    static const string NUTRITION_PROPERTIES        =   "nutrition_properties";
    static const string COOKING_PROPERTIES          =   "cooking_properties";
    static const int    VISUAL_PROPERTIES_HASH      =   VISUAL_PROPERTIES.Hash();
    static const int    NUTRITION_PROPERTIES_HASH   =   NUTRITION_PROPERTIES.Hash();
    static const int    COOKING_PROPERTIES_HASH     =   COOKING_PROPERTIES.Hash();
    
    // The following will be filled in constructor
    private static int  m_StageRawHash      = 0;
    private static int  m_StageBakedHash    = 0;
    private static int  m_StageBoiledHash   = 0;
    private static int  m_StageDriedHash    = 0;
    private static int  m_StageBurnedHash   = 0;
    private static int  m_StageRottenHash   = 0;
    
    // Cache food stage data for each Edible_Base
    // Used to get information for specific Edible_Base
    static ref map<int, ref map<int, ref map<int, ref array<float>>>> m_EdibleBasePropertiesMap;
    // Used to store food stage transitions for every Edible_Base
    static ref map<int, ref map<int, ref map<int, ref array<int>>>> m_EdibleBaseTransitionsMap;
    // Used to store the Hashed key of all possible food transitions ( including modded ones )
    static ref array<int> m_FoodStageTransitionKeys;
    
    //constructor
    void FoodStage( Edible_Base food_item )
    {
        //default
        m_FoodStageType = FoodStageType.RAW;
        m_FoodItem = food_item;
        
        //reset cooking time
        m_CookingTime = 0;
        
        m_FoodStageTypeClientLast = m_FoodStageType;
        
        // We fill all FoodStageHash values
        if ( m_StageRawHash == 0 )
            m_StageRawHash      = "Raw".Hash();
        if ( m_StageBakedHash == 0 )
            m_StageBakedHash    = "Baked".Hash();
        if ( m_StageBoiledHash == 0 )
            m_StageBoiledHash   = "Boiled".Hash();
        if ( m_StageDriedHash == 0 )
            m_StageDriedHash    = "Dried".Hash();
        if ( m_StageBurnedHash == 0 )
            m_StageBurnedHash   = "Burned".Hash();
        if ( m_StageRottenHash == 0 )
            m_StageRottenHash   = "Rotten".Hash();
        
        //get config data for all food stages
        SetupFoodStageMapping();
        
        // Get all config data relative to food stage transitions
        SetupFoodStageTransitionMapping();
        
        ChangeFoodStage( m_FoodStageType );
    }
    
    void SetupFoodStageMapping()
    {
        // We ensure we have the map is setup before trying to fill it
        if ( !m_EdibleBasePropertiesMap )
            m_EdibleBasePropertiesMap = new map<int, ref map<int, ref map< int, ref array<float>>>>;
        
        string foodType = m_FoodItem.GetType();
        int hashedFood = foodType.Hash();
        
        // We start to fill the map, we don't want duplicates of the same food type
        if ( !m_EdibleBasePropertiesMap.Contains( hashedFood ) )
        {
            map<int, ref map<int, ref array<float>>>foodStagesMap = new map<int, ref map<int, ref array<float>>>;
            
            for ( int i = 1; i < FoodStageType.COUNT; ++i )
            {
                map<int, ref array<float>> stagePropertiesMap = new map<int, ref array<float>>;
                
                // Insert visual properties
                array<float> visual_properties = new array<float>;
                string path = string.Format("CfgVehicles %1 Food FoodStages %2 visual_properties", foodType, GetFoodStageName(i));
                GetGame().ConfigGetFloatArray( path, visual_properties);
                
                stagePropertiesMap.Insert( VISUAL_PROPERTIES_HASH , visual_properties );
                
                // Insert nutrition properties
                array<float> nutrition_properties = new array<float>;
                path = string.Format("CfgVehicles %1 Food FoodStages %2 nutrition_properties", foodType, GetFoodStageName(i));
                GetGame().ConfigGetFloatArray( path, nutrition_properties);
                
                stagePropertiesMap.Insert( NUTRITION_PROPERTIES_HASH, nutrition_properties );
                
                // Insert cooking properties
                array<float> cooking_properties = new array<float>;
                path = string.Format("CfgVehicles %1 Food FoodStages %2 cooking_properties", foodType, GetFoodStageName(i));
                GetGame().ConfigGetFloatArray( path, cooking_properties);
                
                stagePropertiesMap.Insert( COOKING_PROPERTIES_HASH , cooking_properties );
                
                // Insert all properties for relevant food stage
                foodStagesMap.Insert( GetFoodStageNameHash( i ), stagePropertiesMap );
            }
            
            m_EdibleBasePropertiesMap.Insert( hashedFood, foodStagesMap );
        }
    }
    
    void SetupFoodStageTransitionMapping()
    {
        // We ensure we have only one map and that it does exist
        if ( !m_EdibleBaseTransitionsMap )
            m_EdibleBaseTransitionsMap = new map<int, ref map<int, ref map< int, ref array<int>>>>;
        
        // We ensure we have our key array setup
        if ( !m_FoodStageTransitionKeys )
            m_FoodStageTransitionKeys = new array<int>;
        
        string foodType = m_FoodItem.GetType();
        int hashedFood = foodType.Hash();
        
        // We start to fill the map, we don't want duplicates of the same food type
        if ( !m_EdibleBaseTransitionsMap.Contains( hashedFood ) )
        {
            map<int, ref map<int, ref array<int>>> foodStagesMap = new map<int, ref map<int, ref array<int>>>;
            
            for ( int i = 1; i < FoodStageType.COUNT; ++i )
            {
                map<int, ref array<int>> stageTransitionsMap = new map<int, ref array<int>>;
                string config_path = string.Format("CfgVehicles %1 Food FoodStageTransitions %2", foodType, GetFoodStageName( i ) );
                
                for ( int j = 0; j < GetGame().ConfigGetChildrenCount( config_path ); ++j )
                {
                    array<int> stageTransition = new array<int>;
                    string classCheck; // Used to get any existing transition class
                    GetGame().ConfigGetChildName( config_path, j, classCheck );
                    
                    string transition_path = string.Format("%1 %2", config_path, classCheck );
                    if ( GetGame().ConfigIsExisting( transition_path ) )
                    {
                        int transitionClassHash = classCheck.Hash();
                        stageTransition.Insert( GetGame().ConfigGetInt( string.Format("%1 transition_to", transition_path) ) );
                        stageTransition.Insert( GetGame().ConfigGetInt( string.Format("%1 cooking_method", transition_path) ) );
                        stageTransitionsMap.Insert( transitionClassHash, stageTransition);
                        
                        // We only want one entry per key
                        if ( m_FoodStageTransitionKeys.Find( transitionClassHash ) == -1 )
                        {
                            m_FoodStageTransitionKeys.Insert( transitionClassHash );
                        }
                    }
                }
                
                foodStagesMap.Insert( GetFoodStageNameHash(i), stageTransitionsMap );
            }
            
            m_EdibleBaseTransitionsMap.Insert( hashedFood, foodStagesMap );
        }
    }
    
    //Food Stage Type
    FoodStageType GetFoodStageType()
    {
        return m_FoodStageType;
    }
    
    void SetFoodStageType( FoodStageType food_stage_type )
    {
        m_FoodStageType = food_stage_type;
    }
    
    //Selection index
    int GetSelectionIndex()
    {
        return m_SelectionIndex;
    }
    void SetSelectionIndex( int index )
    {
        m_SelectionIndex = index;
    }
    
    //Texture index
    int GetTextureIndex()
    {
        return m_TextureIndex;
    }
    void SetTextureIndex( int index )
    {
        m_TextureIndex = index;
    }
    
    //Material index
    int GetMaterialIndex()
    {
        return m_MaterialIndex;
    }
    void SetMaterialIndex( int index )
    {
        m_MaterialIndex = index;
    }
        
    //Food properties
    protected static float GetNutritionPropertyFromIndex( int index, FoodStageType stage_type, FoodStage stage, string classname )
    {
        if ( stage )
        {
            stage_type = stage.m_FoodStageType;
            classname = stage.GetFoodItem().GetType();
        }
        
        string food_stage_name = GetFoodStageName( stage_type );
        int hashedStageName = GetFoodStageNameHash( stage_type );
 
        array<float> nutrition_properties;
        
        map<int, ref map<int, ref array<float>>>foodStagesMap;
        map<int, ref array<float>> stagePropertiesMap;
        
        if( !m_EdibleBasePropertiesMap.Find(classname.Hash(), foodStagesMap))
            return 0;
        if( !foodStagesMap.Find(hashedStageName, stagePropertiesMap))
            return 0;
        if( !stagePropertiesMap.Find(NUTRITION_PROPERTIES_HASH, nutrition_properties))
            return 0;
 
        if ( nutrition_properties.Count() > 0 )
        {
            if ( index > (nutrition_properties.Count() - 1) )
            {
                return 0;
            }
            else
            {
                return nutrition_properties.Get( index );
            }
        }
        //calculate nutrition properties from base stage and nutrition modifiers
        else
        {
            // Will not attempt to optimize this as it is for a setup we do not support internally
            //get modifiers class for nutrition values
            string config_path = string.Format("CfgVehicles %1 Food nutrition_modifiers_class", classname);
            
            if ( GetGame().ConfigIsExisting( config_path ) )
            {
                string nutr_mod_class;
                GetGame().ConfigGetText( config_path, nutr_mod_class );
                
                config_path = string.Format("CfgVehicles NutritionModifiers %1 base_stage", nutr_mod_class);
                string nutr_base_stage;
                GetGame().ConfigGetText( config_path, nutr_base_stage );
                
                //get nutrition values for food stage and modifiers 
                config_path = string.Format("CfgVehicles %1 Food FoodStages %2 nutrition_properties", classname, nutr_base_stage);
                array<float> base_nutr_properties = new array<float>;
                GetGame().ConfigGetFloatArray( config_path, base_nutr_properties );
                
                config_path = string.Format("CfgVehicles NutritionModifiers %1 %2 nutrition_properties", nutr_mod_class, food_stage_name);
                array<float> nutr_mod_properties = new array<float>;
                GetGame().ConfigGetFloatArray( config_path, nutr_mod_properties );
                
                //base nutrition * food stage nutrition modifier
                if ( base_nutr_properties.Count() > 0 && nutr_mod_properties.Count() > 0 )
                {
                    return ( base_nutr_properties.Get( index ) * nutr_mod_properties.Get( index ) );
                }
            }
        }
        
        return 0;
    }
    
    static float GetFullnessIndex(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 0 , stage_type, stage, classname );
    }
    
    static float GetEnergy(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 1 , stage_type, stage, classname );
    }
    
    static float GetWater(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 2 , stage_type, stage, classname );
    }
    
    static float GetNutritionalIndex(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 3 , stage_type , stage, classname);
    }
    
    static float GetToxicity(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 4 , stage_type, stage, classname );
    }
    
    static int GetAgents(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 5 , stage_type, stage, classname );
    }
    
    static float GetDigestibility(FoodStage stage, int stage_type = -1, string classname = "")
    {
        return GetNutritionPropertyFromIndex( 6 , stage_type, stage, classname );
    }
    
    //Food item
    protected Edible_Base GetFoodItem()
    {
        return m_FoodItem;
    }
    
    //Cooking time
    float GetCookingTime()
    {
        return m_CookingTime;
    }
    void SetCookingTime( float time )
    {
        m_CookingTime = time;
    }
    
    static float GetCookingPropertyFromIndex( int index, FoodStageType stage_type, FoodStage stage, string classname )
    { 
        if ( stage )
        {
            stage_type = stage.m_FoodStageType;
            classname = stage.GetFoodItem().GetType();
        }
        
        string food_stage_name = GetFoodStageName( stage_type );
        int hashedStageName = GetFoodStageNameHash( stage_type );
 
        array<float> cooking_properties = new array<float>;
        
        map<int, ref map<int, ref array<float>>>foodStagesMap = new map<int, ref map<int, ref array<float>>>;
        map<int, ref array<float>> stagePropertiesMap = new map<int, ref array<float>>;
        
        m_EdibleBasePropertiesMap.Find(classname.Hash(), foodStagesMap);
        foodStagesMap.Find(hashedStageName, stagePropertiesMap);
        
        stagePropertiesMap.Find(COOKING_PROPERTIES_HASH, cooking_properties);
        
        if ( cooking_properties.Count() > 0 )
        {
            if ( index > (cooking_properties.Count() - 1) )
            {
                return -1;
            }
            else
            {
                return cooking_properties.Get( index );
            }
        }
        return 0;
    }
    
    static array<float> GetAllCookingPropertiesForStage( FoodStageType stage_type, FoodStage stage, string classname )
    {
        if ( stage )
        {
            stage_type = stage.m_FoodStageType;
            classname = stage.GetFoodItem().GetType();
        }
        
        string food_stage_name = GetFoodStageName( stage_type );
        int hashedStageName = GetFoodStageNameHash( stage_type );
 
        array<float> cooking_properties = new array<float>;
        
        map<int, ref map<int, ref array<float>>>foodStagesMap = new map<int, ref map<int, ref array<float>>>;
        map<int, ref array<float>> stagePropertiesMap = new map<int, ref array<float>>;
        
        m_EdibleBasePropertiesMap.Find(classname.Hash(), foodStagesMap);
        foodStagesMap.Find(hashedStageName, stagePropertiesMap);
        
        stagePropertiesMap.Find(COOKING_PROPERTIES_HASH, cooking_properties);
        
        if ( cooking_properties.Count() > 0 )
        {
            return cooking_properties;
        }
        return null;
    }
    
    //********************************************/
    //  FOOD STAGE CHANGE
    //********************************************/
    //Checks if food stage can be changed to another stage
    bool CanChangeToNewStage( CookingMethodType cooking_method )
    {
        if ( GetNextFoodStageType( cooking_method ) == FoodStageType.NONE )
        {
            return false;
        }
        
        return true;
    }
    
    //returns possible food stage type according to given cooking method
    FoodStageType GetNextFoodStageType( CookingMethodType cooking_method )
    {
        array<int> food_transition = new array<int>;
        
        map<int, ref map<int, ref array<int>>> foodStagesMap = new map<int, ref map<int, ref array<int>>>;
        map<int, ref array<int>> foodTransitionsMap = new map<int, ref array<int>>;
        
        m_EdibleBaseTransitionsMap.Find(GetFoodItem().GetType().Hash(), foodStagesMap);
        foodStagesMap.Find( GetFoodStageNameHash( GetFoodStageType() ), foodTransitionsMap );
        
        // We go through the key array, checking every possible transition
        for ( int i = 0; i < m_FoodStageTransitionKeys.Count(); ++i )
        {
            // We test if a given transition is setup on this item
            foodTransitionsMap.Find(m_FoodStageTransitionKeys.Get( i ), food_transition);
            if ( food_transition )
            {
                // We now check if the given transition class is relevant
                if ( food_transition.Get( 1 ) == cooking_method )
                {
                    return food_transition.Get( 0 );
                }
            }
        }
        
        return FoodStageType.BURNED; //If the item cannot transition out of current state, burn it
    }
    
    void ChangeFoodStage( FoodStageType new_stage_type )
    {
        map<int, ref map<int, ref array<float>>>foodStagesMap = new map<int, ref map<int, ref array<float>>>;
        map<int, ref array<float>> stagePropertiesMap = new map<int, ref array<float>>;
        
        //merge stages
        //food stage type
        SetFoodStageType( new_stage_type );
        
        array<float> visual_properties = new array<float>;
        
        m_EdibleBasePropertiesMap.Find( GetFoodItem().GetType().Hash(), foodStagesMap );
        foodStagesMap.Find( GetFoodStageNameHash( GetFoodStageType() ), stagePropertiesMap );
        stagePropertiesMap.Find( VISUAL_PROPERTIES_HASH, visual_properties );
        
        if ( visual_properties.Count() > 0 )
        {
            //selection index
            int index = visual_properties.Get( 0 );
            if ( index >= 0 )
            {
                SetSelectionIndex( index );
            }
            //texture index
            index = visual_properties.Get( 1 );
            if ( index >= 0 )
            {
                SetTextureIndex( index );
            }
            //material index
            index = visual_properties.Get( 2 );
            if ( index >= 0 )
            {
                SetMaterialIndex( index );
            }   
        }
        
        //refresh visual
        GetFoodItem().Synchronize();
    }   
 
    void UpdateVisuals()
    {
        //if item has food stages
        if ( GetFoodItem().HasFoodStage() ) 
        {
            Edible_Base food_item = GetFoodItem();
            
            array<string> config_selections = food_item.GetHiddenSelections();
            array<string> config_textures   = food_item.GetHiddenSelectionsTextures();
            array<string> config_materials  = food_item.GetHiddenSelectionsMaterials();
            
            //selection index
            int selection_index;
            if ( GetSelectionIndex() >= 0 && config_selections.Count() > GetSelectionIndex() )
            {
                selection_index = GetSelectionIndex();
            }
            
            //texture index
            int texture_index;
            if ( GetTextureIndex() >= 0 && config_textures.Count() > GetTextureIndex() )
            {
                texture_index = GetTextureIndex();
            }
    
            //material index
            int material_index;
            if ( GetMaterialIndex() >= 0 && config_materials.Count() > GetMaterialIndex() )
            {
                material_index = GetMaterialIndex();
            }
                
            //hide all selection except the configured one
            for ( int i = 0; i < config_selections.Count(); i++ )
            {
                if ( config_selections.Get( i ) != config_selections.Get( selection_index ) )
                {
                    food_item.SetAnimationPhase( config_selections.Get( i ), 1 );
                }
            }
    
            //Debug 
            //Print( "item = " + food_item.GetType() + " selection index = " + GetSelectionIndex().ToString() + " texture index = " + GetTextureIndex().ToString() );
        
            //show selection
            food_item.SetAnimationPhase( config_selections.Get( selection_index ), 0 );
            //set texture
            food_item.SetObjectTexture( selection_index, config_textures.Get( texture_index ) );
            //set materials
            food_item.SetObjectMaterial( selection_index, config_materials.Get( material_index ) );
        }
                
        m_FoodStageTypeClientLast = m_FoodStageType;
    }
 
    //Food States
    //check food stages
    bool IsFoodInStage( FoodStageType food_stage_type )
    {
        if ( GetFoodStageType() == food_stage_type )
        {
            return true;
        }
        
        return false;
    }
    
    bool IsFoodRaw()
    {
        return IsFoodInStage( FoodStageType.RAW );
    }
    
    bool IsFoodBaked()
    {
        return IsFoodInStage( FoodStageType.BAKED );
    }
    
    bool IsFoodBoiled()
    {
        return IsFoodInStage( FoodStageType.BOILED );
    }
    
    bool IsFoodDried()
    {
        return IsFoodInStage( FoodStageType.DRIED );
    }
    
    bool IsFoodBurned()
    {
        return IsFoodInStage( FoodStageType.BURNED );
    }
 
    bool IsFoodRotten()
    {
        return IsFoodInStage( FoodStageType.ROTTEN );
    }
            
    //get name of food stage type
    static string GetFoodStageName( FoodStageType food_stage_type )
    {
        switch ( food_stage_type )
        {
            case FoodStageType.RAW:     return "Raw";
            case FoodStageType.BAKED:   return "Baked";
            case FoodStageType.BOILED:  return "Boiled";
            case FoodStageType.DRIED:   return "Dried";
            case FoodStageType.BURNED:  return "Burned";
            case FoodStageType.ROTTEN:  return "Rotten";
        }
        
        return "Raw";
    }
    
    // Get hashed name of food stage type for quicker access
    static int GetFoodStageNameHash( FoodStageType food_stage_type )
    {
        switch ( food_stage_type )
        {
            case FoodStageType.RAW:     return m_StageRawHash;
            case FoodStageType.BAKED:   return m_StageBakedHash;
            case FoodStageType.BOILED:  return m_StageBoiledHash;
            case FoodStageType.DRIED:   return m_StageDriedHash;
            case FoodStageType.BURNED:  return m_StageBurnedHash;
            case FoodStageType.ROTTEN:  return m_StageRottenHash;
        }
        
        return m_StageRawHash;
    }
    
    //================================================================
    // SERIALIZATION
    //================================================================  
    void OnStoreSave( ParamsWriteContext ctx )
    {   
        //Food stage type 
        ctx.Write( m_FoodStageType );
        
        //Selection index
        ctx.Write( m_SelectionIndex );
 
        //Texture index
        ctx.Write( m_TextureIndex );
 
        //Material index
        ctx.Write( m_MaterialIndex );
    }
    
    bool OnStoreLoad( ParamsReadContext ctx, int version )
    {
        //Food stage type 
        if ( !ctx.Read( m_FoodStageType ) )
        {
            m_FoodStageType = FoodStageType.RAW;    //set default
            return false;
        }
        
        //Selection index
        if ( !ctx.Read( m_SelectionIndex ) )
        {
            m_SelectionIndex = 0;           //set default
            return false;
        }
        
        //Texture index
        if ( !ctx.Read( m_TextureIndex ) )
        {
            m_TextureIndex = 0;             //set default
            return false;
        }
        
        //Material index
        if ( !ctx.Read( m_MaterialIndex ) )
        {
            m_MaterialIndex = 0;            //set default           
            return false;
        }
        
        return true;
    }
}