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