edible_base.c

Go to the documentation of this file.

class Edible_Base : ItemBase
{
 const string DIRECT_COOKING_SLOT_NAME = "DirectCooking";
 
 const string SOUND_BAKING_START = "Baking_SoundSet";
 const string SOUND_BAKING_DONE = "Baking_Done_SoundSet";
 const string SOUND_BURNING_DONE = "Food_Burning_SoundSet";
 
 protected bool m_MakeCookingSounds;
 protected SoundOnVehicle m_SoundCooking; 
 protected EffectSound m_SoundEffectCooking;
 protected string m_SoundPlaying;
 ref FoodStage m_FoodStage;
 protected float m_DecayTimer;
 protected float m_DecayDelta = 0.0;
 protected FoodStageType m_LastDecayStage = FoodStageType.NONE;
 
 private CookingMethodType m_CookedByMethod;
 
 void Edible_Base()
 {
 if (HasFoodStage())
 {
 m_FoodStage = new FoodStage(this);
 
 RegisterNetSyncVariableInt("m_FoodStage.m_FoodStageType", FoodStageType.NONE, FoodStageType.COUNT);
 RegisterNetSyncVariableInt("m_FoodStage.m_SelectionIndex", 0, 6);
 RegisterNetSyncVariableInt("m_FoodStage.m_TextureIndex", 0, 6);
 RegisterNetSyncVariableInt("m_FoodStage.m_MaterialIndex", 0, 6);
 RegisterNetSyncVariableFloat("m_FoodStage.m_CookingTime", 0, 600, 0);
 
 m_SoundPlaying = "";
 m_CookedByMethod = CookingMethodType.NONE;
 RegisterNetSyncVariableInt("m_CookedByMethod", CookingMethodType.NONE, CookingMethodType.COUNT);
 RegisterNetSyncVariableBool("m_MakeCookingSounds");
 }
 }
 
 override void EEInit()
 {
 super.EEInit();
 
 UpdateVisuals();
 }
 
 override void EEDelete(EntityAI parent)
 {
 super.EEDelete(parent);
 
 RemoveAudio();
 }
 
 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
 {
 super.EEItemLocationChanged(oldLoc, newLoc);
 
 if (oldLoc.GetType() == InventoryLocationType.ATTACHMENT || oldLoc.GetType() == InventoryLocationType.CARGO)
 {
 switch (oldLoc.GetParent().GetType())
 {
 case "FryingPan":
 case "Pot":
 case "Cauldron":
 case "SharpWoodenStick":
 MakeSoundsOnClient(false);
 break;
 }
 
 if (oldLoc.GetSlot() > -1 && InventorySlots.GetSlotName(oldLoc.GetSlot()).Contains(DIRECT_COOKING_SLOT_NAME))
 {
 MakeSoundsOnClient(false);
 }
 }
 }
 
 void UpdateVisuals()
 {
 if (GetFoodStage())
 {
 GetFoodStage().UpdateVisuals();
 }
 }
 
 bool Consume(float amount, PlayerBase consumer)
 {
 AddQuantity(-amount, false, false);
 OnConsume(amount, consumer);
 
 return true;
 }
 
 void OnConsume(float amount, PlayerBase consumer); 
 
 //food staging
 override bool CanBeCooked()
 {
 return false;
 }
 
 override bool CanBeCookedOnStick()
 {
 return false;
 }
 
 //================================================================
 // SYNCHRONIZATION
 //================================================================ 
 void Synchronize()
 {
 SetSynchDirty();
 
 if (GetGame().IsMultiplayer())
 {
 UpdateVisuals();
 }
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 UpdateVisuals();
 
 //update audio
 if (m_MakeCookingSounds)
 {
 RefreshAudio();
 }
 else
 {
 RemoveAudio();
 }
 }
 
 //================================================================
 // AUDIO EFFECTS (WHEN ON DCS)
 //================================================================ 
 void MakeSoundsOnClient(bool soundstate, CookingMethodType cookingMethod = CookingMethodType.NONE)
 {
 m_MakeCookingSounds = soundstate;
 m_CookedByMethod = cookingMethod;
 
 Synchronize();
 }
 
 protected void RefreshAudio()
 {
 string soundName = "";
 
 FoodStageType nextFoodState = GetNextFoodStageType(m_CookedByMethod);
 
 switch (GetFoodStageType())
 {
 case FoodStageType.RAW:
 soundName = SOUND_BAKING_START;
 if (nextFoodState == FoodStageType.BOILED)
 soundName = "";
 break;
 case FoodStageType.BAKED:
 soundName = SOUND_BAKING_DONE;
 break;
 case FoodStageType.BURNED:
 soundName = SOUND_BURNING_DONE;
 break;
 default:
 soundName = "";
 break;
 }
 
 SoundCookingStart(soundName);
 }
 
 protected void RemoveAudio()
 {
 m_MakeCookingSounds = false;
 SoundCookingStop();
 }
 
 //================================================================
 // SERIALIZATION
 //================================================================ 
 override void OnStoreSave(ParamsWriteContext ctx)
 { 
 super.OnStoreSave(ctx);
 
 if (GetFoodStage())
 {
 GetFoodStage().OnStoreSave(ctx);
 }
 
 // food decay
 ctx.Write(m_DecayTimer);
 ctx.Write(m_LastDecayStage);
 }
 
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 {
 if (!super.OnStoreLoad(ctx, version))
 return false;
 
 if (GetFoodStage())
 {
 if (!GetFoodStage().OnStoreLoad(ctx, version))
 return false;
 }
 
 if (version >= 115)
 {
 if (!ctx.Read(m_DecayTimer))
 {
 m_DecayTimer = 0.0;
 return false;
 }
 if (!ctx.Read(m_LastDecayStage))
 {
 m_LastDecayStage = FoodStageType.NONE;
 return false;
 }
 }
 
 return true;
 }
 
 override void AfterStoreLoad()
 { 
 super.AfterStoreLoad();
 
 Synchronize();
 } 
 
 //get food stage
 FoodStage GetFoodStage()
 {
 return m_FoodStage;
 }
 
 //food types
 override bool IsMeat()
 {
 return false;
 }
 
 override bool IsCorpse()
 {
 return false;
 }
 
 override bool IsFruit()
 {
 return false;
 }
 
 override bool IsMushroom()
 {
 return false;
 } 
 
 //================================================================
 // NUTRITIONAL VALUES
 //================================================================ 
 //food properties
 static float GetFoodTotalVolume(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetFullnessIndex(food_item.GetFoodStage());
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetFullnessIndex(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetFloat( class_path + " fullnessIndex" );
 
 }
 
 static float GetFoodEnergy(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetEnergy(food_item.GetFoodStage());
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetEnergy(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetFloat( class_path + " energy" ); 
 }
 
 static float GetFoodWater(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetWater(food_item.GetFoodStage());
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetWater(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetFloat( class_path + " water" ); 
 }
 
 static float GetFoodNutritionalIndex(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetNutritionalIndex(food_item.GetFoodStage()); 
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetNutritionalIndex(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetFloat( class_path + " nutritionalIndex" ); 
 
 }
 
 static float GetFoodToxicity(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetToxicity(food_item.GetFoodStage());
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetToxicity(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetFloat( class_path + " toxicity" ); 
 }
 
 static int GetFoodAgents(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetAgents(food_item.GetFoodStage());
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetAgents(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetInt( class_path + " agents" );
 }
 
 static float GetFoodDigestibility(ItemBase item, string classname = "", int food_stage = 0)
 {
 Edible_Base food_item = Edible_Base.Cast(item);
 if (food_item && food_item.GetFoodStage())
 {
 return FoodStage.GetDigestibility(food_item.GetFoodStage());
 }
 else if (classname != "" && food_stage)
 {
 return FoodStage.GetDigestibility(null, food_stage, classname);
 }
 string class_path = string.Format("cfgVehicles %1 Nutrition", classname);
 return GetGame().ConfigGetInt( class_path + " digestibility" );
 }
 
 static NutritionalProfile GetNutritionalProfile(ItemBase item, string classname = "", int food_stage = 0)
 {
 return new NutritionalProfile(GetFoodEnergy(item, classname, food_stage),GetFoodWater(item, classname, food_stage),GetFoodNutritionalIndex(item, classname, food_stage),GetFoodTotalVolume(item, classname, food_stage), GetFoodToxicity(item, classname, food_stage), GetFoodAgents(item, classname,food_stage), GetFoodDigestibility(item, classname,food_stage));
 }
 
 //================================================================
 // FOOD STAGING
 //================================================================
 FoodStageType GetFoodStageType()
 {
 return GetFoodStage().GetFoodStageType();
 }
 
 //food stage states
 bool IsFoodRaw()
 {
 if ( GetFoodStage() ) 
 {
 return GetFoodStage().IsFoodRaw();
 }
 
 return false;
 }
 
 bool IsFoodBaked()
 {
 if ( GetFoodStage() ) 
 {
 return GetFoodStage().IsFoodBaked();
 }
 
 return false;
 }
 
 bool IsFoodBoiled()
 {
 if ( GetFoodStage() ) 
 {
 return GetFoodStage().IsFoodBoiled();
 }
 
 return false;
 }
 
 bool IsFoodDried()
 {
 if ( GetFoodStage() ) 
 {
 return GetFoodStage().IsFoodDried();
 }
 
 return false;
 }
 
 bool IsFoodBurned()
 {
 if ( GetFoodStage() ) 
 {
 return GetFoodStage().IsFoodBurned();
 }
 
 return false;
 }
 
 bool IsFoodRotten()
 {
 if ( GetFoodStage() ) 
 {
 return GetFoodStage().IsFoodRotten();
 }
 
 return false;
 } 
 
 //food stage change
 void ChangeFoodStage( FoodStageType new_food_stage_type )
 {
 GetFoodStage().ChangeFoodStage( new_food_stage_type );
 }
 
 FoodStageType GetNextFoodStageType( CookingMethodType cooking_method )
 {
 return GetFoodStage().GetNextFoodStageType( cooking_method );
 }
 
 string GetFoodStageName( FoodStageType food_stage_type )
 {
 return GetFoodStage().GetFoodStageName( food_stage_type );
 }
 
 bool CanChangeToNewStage( CookingMethodType cooking_method )
 {
 return GetFoodStage().CanChangeToNewStage( cooking_method );
 }
 
 //Use this to receive food stage from another Edible_Base
 void TransferFoodStage( notnull Edible_Base source )
 {
 if ( !source.HasFoodStage())
 return;
 m_LastDecayStage = source.GetLastDecayStage();
 ChangeFoodStage(source.GetFoodStage().GetFoodStageType());
 m_DecayTimer = source.GetDecayTimer();
 m_DecayDelta = source.GetDecayDelta();
 }
 
 //================================================================
 // COOKING
 //================================================================
 //cooking time
 float GetCookingTime()
 {
 return GetFoodStage().GetCookingTime();
 }
 
 void SetCookingTime( float time )
 {
 GetFoodStage().SetCookingTime( time );
 
 //synchronize when calling on server
 Synchronize();
 }
 
 //replace edible with new item (opening cans)
 void ReplaceEdibleWithNew( string typeName )
 {
 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
 if (player)
 {
 ReplaceEdibleWithNewLambda lambda = new ReplaceEdibleWithNewLambda(this, typeName, player);
 player.ServerReplaceItemInHandsWithNew(lambda);
 }
 else
 Error("ReplaceEdibleWithNew - cannot use edible without player");
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionAttach);
 AddAction(ActionDetach);
 }
 
 protected void SoundCookingStart(string sound_name)
 {
 #ifndef SERVER
 if (m_SoundPlaying != sound_name)
 {
 SoundCookingStop();
 
 m_SoundEffectCooking = SEffectManager.PlaySound(sound_name, GetPosition(), 0, 0, true);
 m_SoundPlaying = sound_name;
 }
 #endif
 }
 
 protected void SoundCookingStop()
 {
 #ifndef SERVER
 if (m_SoundEffectCooking)
 {
 m_SoundEffectCooking.Stop();
 m_SoundEffectCooking = null;
 m_SoundPlaying = "";
 }
 #endif
 }
 
 override bool CanHaveTemperature()
 {
 return true;
 }
 
 override bool CanDecay()
 {
 return false;
 }
 
 override bool CanProcessDecay()
 {
 return ( GetFoodStageType() != FoodStageType.ROTTEN );
 }
 
 override void ProcessDecay( float delta, bool hasRootAsPlayer )
 {
 delta *= DayZGame.Cast(GetGame()).GetFoodDecayModifier();
 m_DecayDelta += ( 1 + ( 1 - GetHealth01( "", "" ) ) );
 if ( hasRootAsPlayer )
 m_DecayDelta += GameConstants.DECAY_RATE_ON_PLAYER;
 
 /*Print( "-------------------------" );
 Print( this );
 Print( m_DecayTimer );
 Print( m_DecayDelta );
 Print( m_LastDecayStage );*/
 
 if ( IsFruit() || IsMushroom() )
 {
 // fruit, vegetables and mushrooms
 if ( m_LastDecayStage != GetFoodStageType() )
 {
 switch ( GetFoodStageType() )
 {
 case FoodStageType.RAW:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_RAW_FRVG + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_RAW_FRVG * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.RAW;
 break;
 
 case FoodStageType.BOILED:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_BOILED_FRVG + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_BOILED_FRVG * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.BOILED;
 break;
 
 case FoodStageType.BAKED:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_BAKED_FRVG + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_BAKED_FRVG * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.BAKED;
 break;
 
 case FoodStageType.DRIED:
 case FoodStageType.BURNED:
 case FoodStageType.ROTTEN:
 default:
 m_DecayTimer = -1;
 m_LastDecayStage = FoodStageType.NONE;
 return;
 }
 
 //m_DecayTimer = m_DecayTimer / 1000.0;
 }
 
 m_DecayTimer -= ( delta * m_DecayDelta );
 
 if ( m_DecayTimer <= 0 ) 
 {
 if ( m_LastDecayStage != FoodStageType.NONE )
 {
 // switch to decayed stage
 if ( ( m_LastDecayStage == FoodStageType.BOILED ) || ( m_LastDecayStage == FoodStageType.BAKED ) )
 {
 ChangeFoodStage( FoodStageType.ROTTEN );
 } 
 if ( m_LastDecayStage == FoodStageType.RAW )
 {
 int rng = Math.RandomIntInclusive( 0, 100 );
 if ( rng > GameConstants.DECAY_FOOD_FRVG_DRIED_CHANCE )
 {
 ChangeFoodStage( FoodStageType.ROTTEN );
 }
 else
 {
 if ( CanChangeToNewStage( FoodStageType.DRIED ) )
 {
 ChangeFoodStage( FoodStageType.DRIED );
 }
 else
 {
 ChangeFoodStage( FoodStageType.ROTTEN );
 }
 }
 }
 }
 }
 
 }
 else if ( IsMeat() )
 {
 // meat
 if ( m_LastDecayStage != GetFoodStageType() )
 {
 switch ( GetFoodStageType() )
 {
 case FoodStageType.RAW:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_RAW_MEAT + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_RAW_MEAT * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.RAW;
 break;
 
 case FoodStageType.BOILED:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_BOILED_MEAT + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_BOILED_MEAT * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.BOILED;
 break;
 
 case FoodStageType.BAKED:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_BAKED_MEAT + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_BAKED_MEAT * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.BAKED;
 break;
 
 case FoodStageType.DRIED:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_DRIED_MEAT + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_DRIED_MEAT * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.DRIED;
 break;
 
 case FoodStageType.BURNED:
 case FoodStageType.ROTTEN:
 default:
 m_DecayTimer = -1;
 m_LastDecayStage = FoodStageType.NONE;
 return;
 }
 }
 
 m_DecayTimer -= ( delta * m_DecayDelta );
 
 if ( m_DecayTimer <= 0 ) 
 {
 if ( m_LastDecayStage != FoodStageType.NONE )
 {
 // switch to decayed stage
 if ( ( m_LastDecayStage == FoodStageType.DRIED ) || ( m_LastDecayStage == FoodStageType.RAW ) || ( m_LastDecayStage == FoodStageType.BOILED ) || ( m_LastDecayStage == FoodStageType.BAKED ) )
 {
 ChangeFoodStage( FoodStageType.ROTTEN );
 }
 }
 }
 }
 else if ( IsCorpse() )
 {
 // corpse
 if ( m_LastDecayStage != GetFoodStageType() )
 {
 switch ( GetFoodStageType() )
 {
 case FoodStageType.RAW:
 m_DecayTimer = ( GameConstants.DECAY_FOOD_RAW_CORPSE + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_RAW_CORPSE * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.RAW;
 break;
 
 case FoodStageType.BURNED:
 case FoodStageType.ROTTEN:
 default:
 m_DecayTimer = -1;
 m_LastDecayStage = FoodStageType.NONE;
 return;
 }
 }
 
 m_DecayTimer -= ( delta * m_DecayDelta );
 
 if ( m_DecayTimer <= 0 ) 
 {
 if ( m_LastDecayStage != FoodStageType.NONE )
 {
 // switch to decayed stage
 if ( ( m_LastDecayStage == FoodStageType.DRIED ) || ( m_LastDecayStage == FoodStageType.RAW ) || ( m_LastDecayStage == FoodStageType.BOILED ) || ( m_LastDecayStage == FoodStageType.BAKED ) )
 {
 ChangeFoodStage( FoodStageType.ROTTEN );
 }
 }
 }
 }
 else
 {
 // opened cans
 m_DecayTimer -= ( delta * m_DecayDelta );
 
 if ( ( m_DecayTimer <= 0 ) && ( m_LastDecayStage == FoodStageType.NONE ) )
 {
 m_DecayTimer = ( GameConstants.DECAY_FOOD_CAN_OPEN + ( Math.RandomFloat01() * ( GameConstants.DECAY_FOOD_DRIED_MEAT * ( GameConstants.DECAY_TIMER_RANDOM_PERCENTAGE / 100.0 ) ) ) );
 m_LastDecayStage = FoodStageType.RAW;
 //m_DecayTimer = m_DecayTimer / 1000.0;
 }
 else
 {
 if ( m_DecayTimer <= 0 )
 {
 InsertAgent(eAgents.FOOD_POISON, 1);
 m_DecayTimer = -1;
 }
 }
 }
 
 m_DecayDelta = 0.0;
 }
 
 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
 {
 super.GetDebugActions(outputList);
 
 if (HasFoodStage())
 {
 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.FOOD_STAGE_PREV, "Food Stage Prev", FadeColors.WHITE));
 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.FOOD_STAGE_NEXT, "Food Stage Next", FadeColors.WHITE));
 }
 }
 
 override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
 {
 super.OnAction(action_id, player, ctx);
 
 if ( GetGame().IsServer() )
 {
 if ( action_id == EActions.FOOD_STAGE_PREV )
 {
 int food_stage_prev = GetFoodStageType() - 1;
 if (food_stage_prev <= 0)
 {
 food_stage_prev = FoodStageType.COUNT - 1;
 }
 ChangeFoodStage(food_stage_prev);
 return true;
 }
 else if ( action_id == EActions.FOOD_STAGE_NEXT )
 {
 int food_stage_next = GetFoodStageType() + 1;
 if (food_stage_next >= FoodStageType.COUNT )
 {
 food_stage_next = FoodStageType.RAW;
 }
 ChangeFoodStage(food_stage_next);
 return true;
 }
 }
 return false;
 }
 
 override string GetDebugText()
 {
 string debug_output;
 
 debug_output = super.GetDebugText();
 
 debug_output+="m_CookedByMethod:"+m_CookedByMethod+"\n";
 debug_output+="m_MakeCookingSounds:"+m_MakeCookingSounds+"\n";
 
 return debug_output;
 }
 
 //================================================================
 // GENERAL GETTERS
 //================================================================
 
 float GetDecayTimer()
 {
 return m_DecayTimer;
 }
 
 float GetDecayDelta()
 {
 return m_DecayDelta;
 }
 
 FoodStageType GetLastDecayStage()
 {
 return m_LastDecayStage;
 }
}
 
class ReplaceEdibleWithNewLambda : TurnItemIntoItemLambda
{
 void ReplaceEdibleWithNewLambda(EntityAI old_item, string new_item_type, PlayerBase player) { }
};