Edible_Base.c File Reference

Go to the source code of this file.

Classes
class	Edible_Base

Functions
Edible_Base ItemBase	ReplaceEdibleWithNewLambda (EntityAI old_item, string new_item_type, PlayerBase player)
void	Edible_Base ()
override void	EEInit ()
override void	EEDelete (EntityAI parent)
override void	EEItemLocationChanged (notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
void	UpdateVisuals ()
bool	Consume (float amount, PlayerBase consumer)
void	OnConsume (float amount, PlayerBase consumer)
override bool	CanBeCooked ()
override bool	CanBeCookedOnStick ()
void	Synchronize ()
override void	OnVariablesSynchronized ()
void	MakeSoundsOnClient (bool soundstate, CookingMethodType cookingMethod=CookingMethodType.NONE)
void	RefreshAudio ()
void	RemoveAudio ()
override void	OnStoreSave (ParamsWriteContext ctx)
override bool	OnStoreLoad (ParamsReadContext ctx, int version)
override void	AfterStoreLoad ()
FoodStage	GetFoodStage ()
override bool	IsMeat ()
override bool	IsCorpse ()
override bool	IsFruit ()
override bool	IsMushroom ()
static float	GetFoodTotalVolume (ItemBase item, string classname="", int food_stage=0)
static float	GetFoodEnergy (ItemBase item, string classname="", int food_stage=0)
static float	GetFoodWater (ItemBase item, string classname="", int food_stage=0)
static float	GetFoodNutritionalIndex (ItemBase item, string classname="", int food_stage=0)
static float	GetFoodToxicity (ItemBase item, string classname="", int food_stage=0)
static int	GetFoodAgents (ItemBase item, string classname="", int food_stage=0)
static float	GetFoodDigestibility (ItemBase item, string classname="", int food_stage=0)
static NutritionalProfile	GetNutritionalProfile (ItemBase item, string classname="", int food_stage=0)
FoodStageType	GetFoodStageType ()
bool	IsFoodRaw ()
bool	IsFoodBaked ()
bool	IsFoodBoiled ()
bool	IsFoodDried ()
bool	IsFoodBurned ()
bool	IsFoodRotten ()
void	ChangeFoodStage (FoodStageType new_food_stage_type)
FoodStageType	GetNextFoodStageType (CookingMethodType cooking_method)
string	GetFoodStageName (FoodStageType food_stage_type)
bool	CanChangeToNewStage (CookingMethodType cooking_method)
void	TransferFoodStage (notnull Edible_Base source)
float	GetCookingTime ()
void	SetCookingTime (float time)
void	ReplaceEdibleWithNew (string typeName)
override void	SetActions ()
void	SoundCookingStart (string sound_name)
void	SoundCookingStop ()
override bool	CanHaveTemperature ()
override bool	CanDecay ()
override bool	CanProcessDecay ()
override void	ProcessDecay (float delta, bool hasRootAsPlayer)
override void	GetDebugActions (out TSelectableActionInfoArrayEx outputList)
override bool	OnAction (int action_id, Man player, ParamsReadContext ctx)
override string	GetDebugText ()
float	GetDecayTimer ()
float	GetDecayDelta ()
FoodStageType	GetLastDecayStage ()

Variables
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"
bool	m_MakeCookingSounds
SoundOnVehicle	m_SoundCooking
EffectSound	m_SoundEffectCooking
	DEPRECATED.
string	m_SoundPlaying
ref FoodStage	m_FoodStage
float	m_DecayTimer
float	m_DecayDelta = 0.0
FoodStageType	m_LastDecayStage = FoodStageType.NONE
CookingMethodType	m_CookedByMethod

Function Documentation

AfterStoreLoad()

override void ReplaceEdibleWithNewLambda::AfterStoreLoad ( )

protected

Definition at line 964 of file Edible_Base.c.

CanBeCooked()

override bool ReplaceEdibleWithNewLambda::CanBeCooked ( )

private

Definition at line 843 of file Edible_Base.c.

                  : 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) { }
};

CanBeCookedOnStick()

override bool ReplaceEdibleWithNewLambda::CanBeCookedOnStick ( )

private

Definition at line 848 of file Edible_Base.c.

                  : 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) { }
};

CanChangeToNewStage()

bool ReplaceEdibleWithNewLambda::CanChangeToNewStage ( CookingMethodType cooking_method )

protected

Definition at line 1159 of file Edible_Base.c.

                  : 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) { }
};

CanDecay()

override bool ReplaceEdibleWithNewLambda::CanDecay ( )

protected

Definition at line 1243 of file Edible_Base.c.

                  : 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) { }
};

CanHaveTemperature()

override bool ReplaceEdibleWithNewLambda::CanHaveTemperature ( )

protected

Definition at line 1238 of file Edible_Base.c.

                  : 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) { }
};

CanProcessDecay()

override bool ReplaceEdibleWithNewLambda::CanProcessDecay ( )

protected

Definition at line 1248 of file Edible_Base.c.

                  : 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) { }
};

ChangeFoodStage()

void ReplaceEdibleWithNewLambda::ChangeFoodStage ( FoodStageType new_food_stage_type )

protected

Definition at line 1144 of file Edible_Base.c.

                  : 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) { }
};

Consume()

bool ReplaceEdibleWithNewLambda::Consume ( float amount, PlayerBase consumer )

private

Definition at line 832 of file Edible_Base.c.

                  : 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) { }
};

Edible_Base()

void ReplaceEdibleWithNewLambda::Edible_Base ( )

private

Definition at line 770 of file Edible_Base.c.

                  : 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) { }
};

EEDelete()

override void ReplaceEdibleWithNewLambda::EEDelete ( EntityAI parent )

private

Definition at line 796 of file Edible_Base.c.

                  : 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) { }
};

EEInit()

override void ReplaceEdibleWithNewLambda::EEInit ( )

private

Definition at line 789 of file Edible_Base.c.

                  : 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) { }
};

EEItemLocationChanged()

override void ReplaceEdibleWithNewLambda::EEItemLocationChanged ( notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc )

private

disable sounds (from cooking)

check for DirectCooking slot name

Definition at line 803 of file Edible_Base.c.

                  : 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) { }
};

GetCookingTime()

float ReplaceEdibleWithNewLambda::GetCookingTime ( )

protected

Definition at line 1179 of file Edible_Base.c.

                  : 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) { }
};

GetDebugActions()

override void ReplaceEdibleWithNewLambda::GetDebugActions ( out TSelectableActionInfoArrayEx outputList )

protected

Definition at line 1431 of file Edible_Base.c.

                  : 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) { }
};

GetDebugText()

override string ReplaceEdibleWithNewLambda::GetDebugText ( )

protected

Definition at line 1468 of file Edible_Base.c.

                  : 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) { }
};

GetDecayDelta()

float ReplaceEdibleWithNewLambda::GetDecayDelta ( )

protected

Definition at line 1489 of file Edible_Base.c.

                  : 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) { }
};

GetDecayTimer()

float ReplaceEdibleWithNewLambda::GetDecayTimer ( )

protected

Definition at line 1484 of file Edible_Base.c.

                  : 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) { }
};

GetFoodAgents()

static int ReplaceEdibleWithNewLambda::GetFoodAgents ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1059 of file Edible_Base.c.

                  : 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) { }
};

GetFoodDigestibility()

static float ReplaceEdibleWithNewLambda::GetFoodDigestibility ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1070 of file Edible_Base.c.

                  : 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) { }
};

GetFoodEnergy()

static float ReplaceEdibleWithNewLambda::GetFoodEnergy ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1014 of file Edible_Base.c.

                  : 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) { }
};

GetFoodNutritionalIndex()

static float ReplaceEdibleWithNewLambda::GetFoodNutritionalIndex ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1036 of file Edible_Base.c.

                  : 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) { }
};

GetFoodStage()

FoodStage ReplaceEdibleWithNewLambda::GetFoodStage ( )

protected

Definition at line 972 of file Edible_Base.c.

                  : 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) { }
};

GetFoodStageName()

string ReplaceEdibleWithNewLambda::GetFoodStageName ( FoodStageType food_stage_type )

protected

Definition at line 1154 of file Edible_Base.c.

                  : 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) { }
};

GetFoodStageType()

FoodStageType ReplaceEdibleWithNewLambda::GetFoodStageType ( )

protected

Definition at line 1089 of file Edible_Base.c.

                  : 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) { }
};

GetFoodTotalVolume()

static float ReplaceEdibleWithNewLambda::GetFoodTotalVolume ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1002 of file Edible_Base.c.

                  : 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) { }
};

GetFoodToxicity()

static float ReplaceEdibleWithNewLambda::GetFoodToxicity ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1048 of file Edible_Base.c.

                  : 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) { }
};

GetFoodWater()

static float ReplaceEdibleWithNewLambda::GetFoodWater ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1025 of file Edible_Base.c.

                  : 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) { }
};

GetLastDecayStage()

FoodStageType ReplaceEdibleWithNewLambda::GetLastDecayStage ( )

protected

Definition at line 1494 of file Edible_Base.c.

                  : 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) { }
};

GetNextFoodStageType()

FoodStageType ReplaceEdibleWithNewLambda::GetNextFoodStageType ( CookingMethodType cooking_method )

protected

Definition at line 1149 of file Edible_Base.c.

                  : 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) { }
};

GetNutritionalProfile()

static NutritionalProfile ReplaceEdibleWithNewLambda::GetNutritionalProfile ( ItemBase item, string classname = "", int food_stage = 0 )

staticprotected

Definition at line 1081 of file Edible_Base.c.

                  : 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) { }
};

IsCorpse()

override bool ReplaceEdibleWithNewLambda::IsCorpse ( )

protected

Definition at line 983 of file Edible_Base.c.

                  : 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) { }
};

Referenced by IEntity::IsFood().

IsFoodBaked()

bool ReplaceEdibleWithNewLambda::IsFoodBaked ( )

protected

Definition at line 1103 of file Edible_Base.c.

                  : 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) { }
};

IsFoodBoiled()

bool ReplaceEdibleWithNewLambda::IsFoodBoiled ( )

protected

Definition at line 1111 of file Edible_Base.c.

                  : 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) { }
};

IsFoodBurned()

bool ReplaceEdibleWithNewLambda::IsFoodBurned ( )

protected

Definition at line 1127 of file Edible_Base.c.

                  : 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) { }
};

IsFoodDried()

bool ReplaceEdibleWithNewLambda::IsFoodDried ( )

protected

Definition at line 1119 of file Edible_Base.c.

                  : 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) { }
};

IsFoodRaw()

bool ReplaceEdibleWithNewLambda::IsFoodRaw ( )

protected

Definition at line 1095 of file Edible_Base.c.

                  : 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) { }
};

IsFoodRotten()

bool ReplaceEdibleWithNewLambda::IsFoodRotten ( )

protected

Definition at line 1135 of file Edible_Base.c.

                  : 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) { }
};

IsFruit()

override bool ReplaceEdibleWithNewLambda::IsFruit ( )

protected

Definition at line 988 of file Edible_Base.c.

                  : 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) { }
};

Referenced by IEntity::IsFood().

IsMeat()

override bool ReplaceEdibleWithNewLambda::IsMeat ( )

protected

Definition at line 978 of file Edible_Base.c.

                  : 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) { }
};

Referenced by IEntity::IsFood().

IsMushroom()

override bool ReplaceEdibleWithNewLambda::IsMushroom ( )

protected

Definition at line 993 of file Edible_Base.c.

                  : 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) { }
};

Referenced by IEntity::IsFood().

MakeSoundsOnClient()

void ReplaceEdibleWithNewLambda::MakeSoundsOnClient ( bool soundstate, CookingMethodType cookingMethod = CookingMethodType.NONE )

private

Definition at line 880 of file Edible_Base.c.

                  : 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) { }
};

OnAction()

override bool ReplaceEdibleWithNewLambda::OnAction ( int action_id, Man player, ParamsReadContext ctx )

protected

Definition at line 1442 of file Edible_Base.c.

                  : 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) { }
};

OnConsume()

void ReplaceEdibleWithNewLambda::OnConsume ( float amount, PlayerBase consumer )

private

OnStoreLoad()

override bool ReplaceEdibleWithNewLambda::OnStoreLoad ( ParamsReadContext ctx, int version )

protected

Definition at line 936 of file Edible_Base.c.

                  : 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) { }
};

OnStoreSave()

override void ReplaceEdibleWithNewLambda::OnStoreSave ( ParamsWriteContext ctx )

protected

Definition at line 924 of file Edible_Base.c.

                  : 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) { }
};

OnVariablesSynchronized()

override void ReplaceEdibleWithNewLambda::OnVariablesSynchronized ( )

private

Definition at line 864 of file Edible_Base.c.

                  : 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) { }
};

ProcessDecay()

override void ReplaceEdibleWithNewLambda::ProcessDecay ( float delta, bool hasRootAsPlayer )

protected

Definition at line 1253 of file Edible_Base.c.

                  : 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) { }
};

RefreshAudio()

void ReplaceEdibleWithNewLambda::RefreshAudio ( )

protected

Definition at line 888 of file Edible_Base.c.

                  : 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) { }
};

RemoveAudio()

void ReplaceEdibleWithNewLambda::RemoveAudio ( )

protected

Definition at line 915 of file Edible_Base.c.

                  : 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) { }
};

ReplaceEdibleWithNew()

void ReplaceEdibleWithNewLambda::ReplaceEdibleWithNew ( string typeName )

protected

Definition at line 1193 of file Edible_Base.c.

                  : 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) { }
};

ReplaceEdibleWithNewLambda()

Edible_Base ItemBase ReplaceEdibleWithNewLambda	(	EntityAI	old_item,
		string	new_item_type,
		PlayerBase	player )

Definition at line 1 of file Edible_Base.c.

{ }

Referenced by Edible_Base::ReplaceEdibleWithNew().

SetActions()

override void ReplaceEdibleWithNewLambda::SetActions ( )

protected

Definition at line 1205 of file Edible_Base.c.

                  : 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) { }
};

SetCookingTime()

void ReplaceEdibleWithNewLambda::SetCookingTime ( float time )

protected

Definition at line 1184 of file Edible_Base.c.

                  : 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) { }
};

SoundCookingStart()

void ReplaceEdibleWithNewLambda::SoundCookingStart ( string sound_name )

protected

Definition at line 1213 of file Edible_Base.c.

                  : 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) { }
};

Referenced by RefreshAudioVisuals().

SoundCookingStop()

void ReplaceEdibleWithNewLambda::SoundCookingStop ( )

protected

Definition at line 1226 of file Edible_Base.c.

                  : 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) { }
};

Referenced by RemoveAudioVisuals().

Synchronize()

void ReplaceEdibleWithNewLambda::Synchronize ( )

private

Definition at line 856 of file Edible_Base.c.

                  : 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) { }
};

TransferFoodStage()

void ReplaceEdibleWithNewLambda::TransferFoodStage ( notnull Edible_Base source )

protected

Definition at line 1165 of file Edible_Base.c.

                  : 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) { }
};

UpdateVisuals()

void ReplaceEdibleWithNewLambda::UpdateVisuals ( )

private

Definition at line 826 of file Edible_Base.c.

                  : 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) { }
};

Variable Documentation

DIRECT_COOKING_SLOT_NAME

const string DIRECT_COOKING_SLOT_NAME = "DirectCooking"

Definition at line 753 of file Edible_Base.c.

m_CookedByMethod

CookingMethodType m_CookedByMethod

private

Definition at line 768 of file Edible_Base.c.

m_DecayDelta

float m_DecayDelta = 0.0

protected

Definition at line 765 of file Edible_Base.c.

m_DecayTimer

float m_DecayTimer

protected

Definition at line 764 of file Edible_Base.c.

Referenced by PluginBase::PluginObjectsInteractionManager().

m_FoodStage

ref FoodStage m_FoodStage

protected

Definition at line 763 of file Edible_Base.c.

m_LastDecayStage

FoodStageType m_LastDecayStage = FoodStageType.NONE

protected

Definition at line 766 of file Edible_Base.c.

m_MakeCookingSounds

bool m_MakeCookingSounds

protected

Definition at line 759 of file Edible_Base.c.

m_SoundCooking

SoundOnVehicle m_SoundCooking

protected

Definition at line 760 of file Edible_Base.c.

m_SoundEffectCooking

EffectSound m_SoundEffectCooking

protected

DEPRECATED.

Definition at line 761 of file Edible_Base.c.

m_SoundPlaying

string m_SoundPlaying

protected

Definition at line 762 of file Edible_Base.c.

SOUND_BAKING_DONE

const string SOUND_BAKING_DONE = "Baking_Done_SoundSet"

Definition at line 756 of file Edible_Base.c.

Referenced by RefreshAudioVisuals().

SOUND_BAKING_START

const string SOUND_BAKING_START = "Baking_SoundSet"

Definition at line 755 of file Edible_Base.c.

Referenced by RefreshAudioVisuals().

SOUND_BURNING_DONE

const string SOUND_BURNING_DONE = "Food_Burning_SoundSet"

Definition at line 757 of file Edible_Base.c.

Referenced by RefreshAudioVisuals().