FireplaceBase.c

Go to the documentation of this file.

enum FireplaceFireState
{
  NO_FIRE = 1,
  START_FIRE = 2,
  SMALL_FIRE = 3,
  NORMAL_FIRE = 4,
  END_FIRE = 5,
  EXTINGUISHING_FIRE = 6,
  EXTINGUISHED_FIRE = 7,
  REIGNITED_FIRE = 8,
 
  COUNT = 9 //for net sync purposes
}
 
enum FirePlaceFailure
{
  WIND = 0,
  WET = 1,
}
 
class FireplaceBase extends ItemBase
{
  //State params
  protected bool m_IsBurning = false;
  protected bool m_HasAshes = false;
  protected bool m_IsOven = false;
  protected bool m_HasStoneCircle = false;
  protected bool m_RoofAbove = false;
  protected bool m_NoIgnite = false;
  protected int m_OvenAttachmentsLockState = -1;
  protected FireplaceFireState m_FireState = FireplaceFireState.NO_FIRE;
  protected FireplaceFireState m_LastFireState = FireplaceFireState.NO_FIRE; //for synchronization purposes
  protected vector m_HalfExtents;
 
  //Fireplace params
  protected float m_TemperatureLossMP = 1.0; 
  protected float m_FuelBurnRateMP = 1.0; 
 
  //cooking
  protected ref Cooking m_CookingProcess;
 
  //
  const float PARAM_SMALL_FIRE_TEMPERATURE = 150; 
  const float PARAM_NORMAL_FIRE_TEMPERATURE = 1000; 
  const float PARAM_MIN_FIRE_TEMPERATURE = 30; 
  const float PARAM_TEMPERATURE_INCREASE = 3; 
  const float PARAM_TEMPERATURE_DECREASE = 3; 
  const float PARAM_MAX_WET_TO_IGNITE = 0.2; 
  const float PARAM_MIN_TEMP_TO_REIGNITE = 30; 
  const float PARAM_IGNITE_RAIN_THRESHOLD = 0.1; 
  const float PARAM_BURN_WET_THRESHOLD = 0.40; 
  const float PARAM_WET_INCREASE_COEF = 0.02; 
  const float PARAM_WET_HEATING_DECREASE_COEF = 0.01; 
  const float PARAM_WET_COOLING_DECREASE_COEF = 0.002; 
  const float PARAM_FIRE_CONSUM_RATE_AMOUNT = 0.5; 
  const float PARAM_BURN_DAMAGE_COEF = 5.0; 
  const float PARAM_ITEM_HEAT_TEMP_INCREASE_COEF = 10; 
  const float PARAM_ITEM_HEAT_MIN_TEMP = 40; 
  const float PARAM_MAX_ITEM_HEAT_TEMP_INCREASE = 200; 
  const float PARAM_FULL_HEAT_RADIUS = 2.0; 
  const float PARAM_HEAT_RADIUS = 4.0; 
  const float PARAM_HEAT_THROUGH_AIR_COEF = 0.1; 
  const float PARAM_MAX_TRANSFERED_TEMPERATURE = 25; 
  const int MIN_STONES_TO_BUILD_CIRCLE = 8; 
  const int MIN_STONES_TO_BUILD_OVEN = 16; 
  const int MAX_TEMPERATURE_TO_DISMANTLE_OVEN = 40; 
  const float MIN_CEILING_HEIGHT = 5; 
  //
  const float TEMPERATURE_LOSS_MP_DEFAULT = 1.0;
  const float TEMPERATURE_LOSS_MP_STONES = 0.90; //10% boost
  const float TEMPERATURE_LOSS_MP_OVEN = 0.75; //25% boost
 
  const float FUEL_BURN_RATE_DEFAULT = 1.0;
  const float FUEL_BURN_RATE_STONES = 0.92;
  const float FUEL_BURN_RATE_OVEN = 0.85;
 
  const float PARAM_COOKING_TEMP_THRESHOLD = 100; 
  const float PARAM_COOKING_EQUIP_MAX_TEMP = 250; 
  const float PARAM_COOKING_EQUIP_TEMP_INCREASE = 10; 
  const int TIMER_HEATING_UPDATE_INTERVAL = 3; 
  const int TIMER_COOLING_UPDATE_INTERVAL = 2; 
  const int DIRECT_COOKING_SLOT_COUNT = 3;
  const float DIRECT_COOKING_SPEED = 1.5; // per second
  const int SMOKING_SLOT_COUNT = 4;
  const float SMOKING_SPEED = 1; // per second
 
  // stage lifetimes
  const int LIFETIME_FIREPLACE_STONE_CIRCLE = 172800;
  const int LIFETIME_FIREPLACE_STONE_OVEN = 604800;
 
  const float IGNITE_WIND_THRESHOLD = 0.8; //fireplace can not be ignited above this multiple of max wind
 
  //Timers
  protected ref Timer m_HeatingTimer;
  protected ref Timer m_CoolingTimer;
 
  // Light entity
  protected FireplaceLight m_Light;
  protected float m_LightDistance = 2000;
 
  //Attachments
  protected ItemBase m_CookingEquipment;
  protected ItemBase m_DirectCookingSlots[DIRECT_COOKING_SLOT_COUNT];
  protected ItemBase m_SmokingSlots[SMOKING_SLOT_COUNT];
  protected ref FireConsumable m_ItemToConsume;
 
  //Particles - default for FireplaceBase
  protected int PARTICLE_FIRE_START = ParticleList.CAMP_FIRE_START;
  protected int PARTICLE_OVEN_FIRE_START = ParticleList.CAMP_STOVE_FIRE_START;
  protected int PARTICLE_SMALL_FIRE = ParticleList.CAMP_SMALL_FIRE;
  protected int PARTICLE_NORMAL_FIRE = ParticleList.CAMP_NORMAL_FIRE;
  protected int PARTICLE_OVEN_FIRE = ParticleList.CAMP_STOVE_FIRE;
  protected int PARTICLE_SMALL_SMOKE = ParticleList.CAMP_SMALL_SMOKE;
  protected int PARTICLE_NORMAL_SMOKE = ParticleList.CAMP_NORMAL_SMOKE;
  protected int PARTICLE_FIRE_END = ParticleList.CAMP_FIRE_END;
  protected int PARTICLE_OVEN_FIRE_END = ParticleList.CAMP_STOVE_FIRE_END;
  protected int PARTICLE_STEAM_END = ParticleList.CAMP_STEAM_2END;
  protected int PARTICLE_STEAM_EXTINGUISHING = ParticleList.CAMP_STEAM_EXTINGUISH_START;
  protected int PARTICLE_NO_IGNITE_WIND = ParticleList.CAMP_NO_IGNITE_WIND;
  //
  protected Particle m_ParticleFireStart;
  protected Particle m_ParticleSmallFire;
  protected Particle m_ParticleNormalFire;
  protected Particle m_ParticleSmallSmoke;
  protected Particle m_ParticleNormalSmoke;
  protected Particle m_ParticleFireEnd;
  protected Particle m_ParticleSteamEnd;
  protected Particle m_ParticleSteamExtinguishing;
 
  //Sounds
  const string SOUND_FIRE_HEAVY = "HeavyFire_SoundSet";
  const string SOUND_FIRE_LIGHT = "LightFire_SoundSet";
  const string SOUND_FIRE_NO_FIRE = "NoFuelFire_SoundSet";
  const string SOUND_FIRE_EXTINGUISHING = "ExtinguishByWater_SoundSet";
  const string SOUND_FIRE_EXTINGUISHED = "ExtinguishByWaterEnd_SoundSet";
 
  //
  protected EffectSound m_SoundFireLoop;
  protected EffectSound m_SoundFire;
  //
 
  //Fuel
  //Kindling / Fuel item types
  protected static ref map<typename, ref FireConsumableType> m_FireConsumableTypes;
  protected ref map<ItemBase, ref FireConsumable> m_FireConsumables;
 
  //Player action / status messages
  const string MESSAGE_IGNITE_IGNIT_ITEM_DAMAGED = "You cannot start fire. Fireplace is ruined.";
  const string MESSAGE_IGNITE_NO_KINDLING = "There needs to be some kindling to start a fire.";
  const string MESSAGE_IGNITE_TOO_WET = "The fireplace is too wet to be ignited.";
  const string MESSAGE_IGNITE_RAIN = "The fire went out because of the rain.";
  const string MESSAGE_IGNITE_WIND = "The fire went out because of the wind.";
  const string MESSAGE_IGNITE_IN_WATER = "I cannot ignite the fireplace in the water.";
  const string MESSAGE_IGNITE_UNDER_LOW_ROOF = "I cannot ignite the fireplace here, the is not enough room.";
  const string MESSAGE_REIGNITE_NO_KINDLING = "There needs to be some kindling to start a fire.";
  const string MESSAGE_REIGNITE_RAIN = "Cannot reignite fireplace in rain.";
  const string MESSAGE_REIGNITE_TOO_WET = "The fireplace is too wet to be reignited.";
  const string MESSAGE_BURY_ASHES_FAILED_NOT_EMPTY = "Cannot bury ashes. There are sill items in it.";
  const string MESSAGE_BURY_ASHES_FAILED_SURFACE = "Cannot bury ashes on hard surface.";
  const string MESSAGE_BURY_ASHES_FAILED_BURNING = "Cannot bury ashes, the fireplace is still burning.";
  const string MESSAGE_BURY_ASHES_FAILED_TOO_HOT = "Cannot bury ashes, the fireplace is too hot.";
  const string MESSAGE_CANNOT_BUILD_OVEN = "Cannot build oven.";
  const string MESSAGE_CANNOT_DISMANTLE_OVEN = "Cannot dismantle oven.";
 
  //Visual animations
  const string ANIMATION_ASHES = "Ashes";
  const string ANIMATION_KINDLING = "Kindling";
  const string ANIMATION_STICKS = "Sticks";
  const string ANIMATION_WOOD = "Wood";
  const string ANIMATION_BURNT_WOOD = "BurntWood";
  const string ANIMATION_STONE = "Stone";
  const string ANIMATION_STONES = "StonesCircle";
  const string ANIMATION_TRIPOD = "Tripod";
  const string ANIMATION_OVEN = "Oven";
  const string ANIMATION_INVENTORY = "Inventory";
  const string ANIMATION_COOKWARE_HANDLE = "handleRotate";
  const string ANIMATION_CAULDRON_HANDLE = "handle1Rotate";
 
 
  //Visual textures and materials
  const string MATERIAL_FIREPLACE_GLOW = "dz\\gear\\cooking\\data\\stoneground.rvmat";
  const string MATERIAL_FIREPLACE_NOGLOW = "dz\\gear\\cooking\\data\\stonegroundnoemit.rvmat";
 
  //Attachment types
  //Fuel
  typename ATTACHMENT_STICKS = WoodenStick;
  typename ATTACHMENT_FIREWOOD = Firewood;
  //Kindling
  typename ATTACHMENT_RAGS = Rag;
  typename ATTACHMENT_BANDAGE = BandageDressing;
  typename ATTACHMENT_BOOK = ItemBook;
  typename ATTACHMENT_BARK_OAK = Bark_Oak;
  typename ATTACHMENT_BARK_BIRCH = Bark_Birch;
  typename ATTACHMENT_PAPER = Paper;
  typename ATTACHMENT_GIFTWRAP = GiftWrapPaper;
  typename ATTACHMENT_PUNCHEDCARD = PunchedCard;
  typename ATTACHMENT_EYEMASK_COLORBASE = EyeMask_ColorBase;
  //Other
  typename ATTACHMENT_TRIPOD = Tripod;
  typename ATTACHMENT_COOKINGSTAND = CookingStand;
  typename ATTACHMENT_STONES = Stone;
  typename ATTACHMENT_COOKING_POT = Pot;
  typename ATTACHMENT_FRYING_PAN = FryingPan;
  typename ATTACHMENT_CAULDRON = Cauldron;
  //
  const string OBJECT_CLUTTER_CUTTER = "ClutterCutterFireplace";
  protected Object m_ClutterCutter;
 
  //area damage
  protected ref AreaDamageManager m_AreaDamage;
 
  //quantity
  protected float m_TotalEnergy;
 
  // Noise
  ref NoiseParams m_NoisePar;
  private bool m_CanNoise = true; // Flip every fireplace update to limit amount of noise generation
 
  // UniversalTemperatureSource
  protected ref UniversalTemperatureSource m_UTSource;
  protected ref UniversalTemperatureSourceSettings m_UTSSettings;
  protected ref UniversalTemperatureSourceLambdaFireplace m_UTSLFireplace;
 
  //================================================================
  // INIT / STORE LOAD-SAVE
  //================================================================
  //Constructor
  protected void FireplaceBase()
  {
    //STATIC: define kindling types
    if (!m_FireConsumableTypes)
    {
      m_FireConsumableTypes = new ref map<typename, ref FireConsumableType>();
      m_FireConsumableTypes.Insert(ATTACHMENT_RAGS, new FireConsumableType(ATTACHMENT_RAGS, 14, true, "Rags"));
      m_FireConsumableTypes.Insert(ATTACHMENT_BANDAGE, new FireConsumableType(ATTACHMENT_BANDAGE, 14, true, "MedicalBandage"));
      m_FireConsumableTypes.Insert(ATTACHMENT_BOOK, new FireConsumableType(ATTACHMENT_BOOK, 36, true, "Book"));
      m_FireConsumableTypes.Insert(ATTACHMENT_BARK_OAK, new FireConsumableType(ATTACHMENT_BARK_OAK, 20, true, "OakBark"));
      m_FireConsumableTypes.Insert(ATTACHMENT_BARK_BIRCH, new FireConsumableType(ATTACHMENT_BARK_BIRCH, 14, true, "BirchBark"));
      m_FireConsumableTypes.Insert(ATTACHMENT_PAPER, new FireConsumableType(ATTACHMENT_PAPER, 10, true, "Paper"));
      m_FireConsumableTypes.Insert(ATTACHMENT_GIFTWRAP, new FireConsumableType(ATTACHMENT_GIFTWRAP, 10, true, "GiftWrapPaper"));
      m_FireConsumableTypes.Insert(ATTACHMENT_PUNCHEDCARD, new FireConsumableType(ATTACHMENT_PUNCHEDCARD, 10, true, "PunchedCard"));
      m_FireConsumableTypes.Insert(ATTACHMENT_EYEMASK_COLORBASE, new FireConsumableType(ATTACHMENT_EYEMASK_COLORBASE, 10, true, "EyeMask_ColorBase"));
 
      //define fuel types
      m_FireConsumableTypes.Insert(ATTACHMENT_STICKS, new FireConsumableType(ATTACHMENT_STICKS, 40, false, "WoodenStick"));
      m_FireConsumableTypes.Insert(ATTACHMENT_FIREWOOD, new FireConsumableType(ATTACHMENT_FIREWOOD, 100, false, "Firewood"));
    }
 
    //calculate total energy
    CalcAndSetTotalEnergy();
 
    //define fuel / kindling items (fire consumables)
    m_FireConsumables = new ref map<ItemBase, ref FireConsumable>;
 
    //default burning parameters
    SetTemperatureLossMP(TEMPERATURE_LOSS_MP_DEFAULT);
    SetFuelBurnRateMP(FUEL_BURN_RATE_DEFAULT);
 
    //synchronized variables
    RegisterNetSyncVariableBool("m_IsBurning");
    RegisterNetSyncVariableBool("m_HasAshes");
    RegisterNetSyncVariableBool("m_IsOven");
    RegisterNetSyncVariableBool("m_HasStoneCircle");
    RegisterNetSyncVariableBool("m_RoofAbove");
    RegisterNetSyncVariableInt("m_FireState", FireplaceFireState.NO_FIRE, FireplaceFireState.COUNT);
    RegisterNetSyncVariableBool("m_IsSoundSynchRemote");
    RegisterNetSyncVariableBool("m_IsPlaceSound");
    RegisterNetSyncVariableBool("m_NoIgnite");
 
    m_HalfExtents = vector.Zero;
  }
 
  protected void ~FireplaceBase()
  {
    DestroyAreaDamage();
 
    if (GetLightEntity())
      GetLightEntity().FadeOut();
  }
 
  override void EEInit()
  {
    super.EEInit();
 
    //refresh visual on init
    RefreshFireplaceVisuals();
 
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
    {
      m_UTSSettings = new UniversalTemperatureSourceSettings();
      m_UTSSettings.m_AffectStat = true;
      m_UTSSettings.m_ManualUpdate = true;
      m_UTSSettings.m_TemperatureMin = 0;
      m_UTSSettings.m_TemperatureMax = PARAM_NORMAL_FIRE_TEMPERATURE;
      m_UTSSettings.m_TemperatureCap = PARAM_MAX_TRANSFERED_TEMPERATURE;
      m_UTSSettings.m_RangeFull = PARAM_FULL_HEAT_RADIUS;
      m_UTSSettings.m_RangeMax = PARAM_HEAT_RADIUS;
 
      m_UTSLFireplace = new UniversalTemperatureSourceLambdaFireplace();
      m_UTSLFireplace.SetSmallFireplaceTemperatureMax(PARAM_SMALL_FIRE_TEMPERATURE);
      m_UTSLFireplace.SetNormalFireplaceTemperatureMax(PARAM_NORMAL_FIRE_TEMPERATURE);
 
      m_UTSource = new UniversalTemperatureSource(this, m_UTSSettings, m_UTSLFireplace);
    }
  }
 
  override void EEItemAttached(EntityAI item, string slot_name)
  {
    super.EEItemAttached(item, slot_name);
 
    //cookware
    switch (item.Type())
    {
    case ATTACHMENT_CAULDRON:
    case ATTACHMENT_COOKING_POT:
    case ATTACHMENT_FRYING_PAN:
      SetCookingEquipment(ItemBase.Cast(item));
      break;
    }
  }
 
  override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
  {
    super.OnItemLocationChanged(old_owner, new_owner);
 
    //refresh physics after location change (with delay)
    GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Call(RefreshFireplacePhysics);
  }
 
  override void OnAttachmentRuined(EntityAI attachment)
  {
    switch (attachment.Type())
    {
    case ATTACHMENT_TRIPOD:
    case ATTACHMENT_COOKINGSTAND:
      int slot = InventorySlots.GetSlotIdFromString("CookingEquipment");
      EntityAI ent = GetInventory().FindAttachment(slot);
      if (ent)
      {
        switch (ent.Type())
        {
        case ATTACHMENT_COOKING_POT:
        case ATTACHMENT_CAULDRON:
        case ATTACHMENT_FRYING_PAN:
          vector direction = ent.GetDirection();
          float dot = vector.Dot(direction, vector.Forward);
 
          float angle = Math.Acos(dot);
          if (direction[0] < 0)
            angle = -angle;
 
          float cos = Math.Cos(angle);
          float sin = Math.Sin(angle);
          GetInventory().DropEntityInBounds(InventoryMode.SERVER, this, ent, "2 0 2", angle, cos, sin);
          break;
        }
      }
 
      attachment.Delete();
      break;
    }
  }
 
  override void EEDelete(EntityAI parent)
  {
    super.EEDelete(parent);
 
    SetFireState(FireplaceFireState.NO_FIRE);
 
    // cleanup particles (for cases of leaving burning fplace and going back outside of network bubble)
#ifndef SERVER
    StopAllParticlesAndSounds();
#endif
  }
 
  //on store save/load
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    //Save ashes state
    ctx.Write(m_HasAshes);
 
    //Save temperature loss MP
    ctx.Write(m_TemperatureLossMP);
 
    //Save fuel burn rate MP
    ctx.Write(m_FuelBurnRateMP);
 
    //Save burning state
    ctx.Write(m_IsBurning);
  }
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
    //--- Fireplace data ---
    //Load ashes state
    if (!ctx.Read(m_HasAshes))
    {
      m_HasAshes = false; //set default
      return false;
    }
 
    //Load temperature loss MP
    if (!ctx.Read(m_TemperatureLossMP))
    {
      m_TemperatureLossMP = 1.0; //set default
      return false;
    }
 
    //Load fuel burn rate MP
    if (!ctx.Read(m_FuelBurnRateMP))
    {
      m_FuelBurnRateMP = 1.0; //set default
      return false;
    }
 
    //Load burning state, if true start fire
    if (!ctx.Read(m_IsBurning))
    {
      m_IsBurning = false; //set default
      return false;
    }
    //---
 
    return true;
  }
 
  override void AfterStoreLoad()
  {
    super.AfterStoreLoad();
 
    Synchronize();
 
    //start fire
    if (IsBurning())
    {
      if (GetGame() && GetGame().IsServer())
      {
        StartFire(true); //will be auto-synchronized when starting fire
      }
    }
  }
 
  //================================================================
  // SYNCHRONIZATION
  //================================================================
  void Synchronize()
  {
    if (GetGame() && GetGame().IsServer())
    {
      SetSynchDirty();
 
      if (GetGame().IsMultiplayer() && GetGame().IsServer())
      {
        //Refresh visuals (on server)
        GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Call(RefreshFireplaceVisuals);
      }
    }
  }
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    RefreshFireplaceVisuals();
    RefreshFireParticlesAndSounds(false);
 
    if (IsPlaceSound())
      PlayPlaceSound();
 
    if (IsBaseFireplace() && !IsOven())
    {
      if (m_IsBurning && !m_AreaDamage)
        CreateAreaDamage();
      else if (!m_IsBurning && m_AreaDamage)
        DestroyAreaDamage();
    }
  }
 
  //================================================================
  // BASE
  //================================================================
 
  //States
  //check fireplace types
  override bool IsFireplace()
  {
    return true;
  }
 
  bool IsBaseFireplace()
  {
    return false;
  }
 
  bool IsBarrelWithHoles()
  {
    return false;
  }
 
  bool IsFireplaceIndoor()
  {
    return false;
  }
 
  bool IsIndoorOven()
  {
    return false;
  }
 
  override bool CanHaveWetness()
  {
    return true;
  }
 
  override bool CanHaveTemperature()
  {
    return true;
  }
 
  //cooking equipment
  ItemBase GetCookingEquipment()
  {
    return m_CookingEquipment;
  }
 
  void SetCookingEquipment(ItemBase equipment)
  {
    m_CookingEquipment = equipment;
  }
 
  void ClearCookingEquipment(ItemBase pItem)
  {
    if (m_CookingProcess)
      m_CookingProcess.TerminateCookingSounds(pItem);
 
    SetCookingEquipment(null);
  }
 
  void ClearCookingEquipment()
  {
    SetCookingEquipment(null);
  }
 
  bool DirectCookingSlotsInUse()
  {
    for (int i = 0; i < DIRECT_COOKING_SLOT_COUNT; i++)
    {
      if (m_DirectCookingSlots[i])
        return true;
    }
    return false;
  }
 
  bool SmokingSlotsInUse()
  {
    for (int i = 0; i < SMOKING_SLOT_COUNT; i++)
    {
      if (m_SmokingSlots[i])
        return true;
    }
    return false;
  }
 
  void DestroyFireplace()
  {
    DeleteSafe();
  }
 
  override bool IsPrepareToDelete()
  {
    return IsEmpty() && !IsBurning() && !HasAshes();
  }
 
  override void EECargoOut(EntityAI item)
  {
    super.EECargoOut(item);
 
    CheckForDestroy();
  }
 
  //================================================================
  // VISUAL
  //================================================================
  //Fireplace visual
  void RefreshFireplaceVisuals()
  {
    if (IsHologram())
      return;
 
    // Light
#ifndef SERVER
    if (IsBurning())
    {
      //turn light on
      if (!GetLightEntity())
      {
        SetLightEntity(FireplaceLight.Cast(ScriptedLightBase.CreateLight(FireplaceLight, GetPosition(), 20)));
        GetLightEntity().AttachOnMemoryPoint(this, "light");
      }
 
      if (GetLightEntity() && GetLightEntity().GetBrightness() > 0)
      {
        // change brightness based on the distance of player to the fireplace
        Object player = GetGame().GetPlayer();
        float lightDist = m_LightDistance;
 
        if (IsOven())
          lightDist = 50;
 
        if (player)
        {
          if (vector.DistanceSq(player.GetPosition(), this.GetPosition()) > lightDist * lightDist)
            GetLightEntity().FadeBrightnessTo(0, 5);
          else
            GetLightEntity().FadeBrightnessTo(FireplaceLight.m_FireplaceBrightness, 5);
        }
 
        // The following solves an issue with the light point clipping through narrow geometry
        if (IsItemTypeAttached(ATTACHMENT_STONES) || IsBarrelWithHoles() || IsFireplaceIndoor())
          GetLightEntity().SetInteriorMode();
        else
          GetLightEntity().SetExteriorMode();
      }
    }
    else
    {
      //turn light off
      if (GetLightEntity())
        GetLightEntity().FadeOut();
    }
#endif
 
    //set default burn parameters based on fireplace type
    if (IsBarrelWithHoles() || IsFireplaceIndoor() || IsIndoorOven() || IsOven())
    {
      SetFuelBurnRateMP(FUEL_BURN_RATE_OVEN);
      SetTemperatureLossMP(TEMPERATURE_LOSS_MP_OVEN);
    }
    else if (HasStoneCircle())
    {
      SetFuelBurnRateMP(FUEL_BURN_RATE_STONES);
      SetTemperatureLossMP(TEMPERATURE_LOSS_MP_STONES);
    }
    else
    {
      SetFuelBurnRateMP(FUEL_BURN_RATE_DEFAULT);
      SetTemperatureLossMP(TEMPERATURE_LOSS_MP_DEFAULT);
    }
 
    // Oven attachments
    if (IsOven())
    {
      //lock attachment slots
      if (!m_OvenAttachmentsLockState)
        LockOvenAttachments(true);
    }
    else
    {
      //unlock attachment slots
      if (m_OvenAttachmentsLockState)
        LockOvenAttachments(false);
    }
 
    //VISUAL STATES
    //Fuel state
    if (GetGame().IsServer()) // SetAnimationPhase should ideally be called on server only..
    {
      // Sticks state
      if (IsItemTypeAttached(ATTACHMENT_STICKS))
        SetAnimationPhase(ANIMATION_STICKS, 0);
      else
        SetAnimationPhase(ANIMATION_STICKS, 1);
 
      // Firewood state
      if (IsItemTypeAttached(ATTACHMENT_FIREWOOD))
      {
        if (IsBurning() && HasAshes())
        {
          SetAnimationPhase(ANIMATION_BURNT_WOOD, 0); // Because this might not be set under certain circumstances
          SetAnimationPhase(ANIMATION_WOOD, 1);
        }
 
        if (IsWet() || !IsBurning())
        {
          SetAnimationPhase(ANIMATION_BURNT_WOOD, 1);
          SetAnimationPhase(ANIMATION_WOOD, 0);
        }
      }
      else
      {
        SetAnimationPhase(ANIMATION_WOOD, 1);
        SetAnimationPhase(ANIMATION_BURNT_WOOD, 1);
      }
 
      // Kindling state
      if (GetKindlingCount() != 0)
        SetAnimationPhase(ANIMATION_KINDLING, 0);
      else
        SetAnimationPhase(ANIMATION_KINDLING, 1);
 
      // Ashes state
      if (HasAshes())
        SetAnimationPhase(ANIMATION_ASHES, 0);
      else
        SetAnimationPhase(ANIMATION_ASHES, 1);
 
      // Stone variations
      if (HasStones())
      {
        if (HasStoneCircle())
        {
          SetAnimationPhase(ANIMATION_STONES, 0);
          SetAnimationPhase(ANIMATION_STONE, 1);
        }
        else if (IsOven())
        {
          SetAnimationPhase(ANIMATION_OVEN, 0);
          SetAnimationPhase(ANIMATION_STONE, 1);
        }
        else
        {
          SetAnimationPhase(ANIMATION_STONES, 1);
          SetAnimationPhase(ANIMATION_OVEN, 1);
          SetAnimationPhase(ANIMATION_STONE, 0);
        }
      }
      else
      {
        SetAnimationPhase(ANIMATION_STONE, 1); 
      }
    }
 
    //refresh physics (with delay)
    GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Call(RefreshFireplacePhysics);
  }
 
  protected void SetBurntFirewood()
  {
    if (GetGame().IsServer() && IsInAnimPhase(ANIMATION_WOOD))
    {
      SetAnimationPhase(ANIMATION_WOOD, 1);
      SetAnimationPhase(ANIMATION_BURNT_WOOD, 0);
    }
  }
 
  //Refresh fireplace object physics
  void RefreshFireplacePhysics();
 
  protected void RefreshFireParticlesAndSounds(bool force_refresh)
  {
    FireplaceFireState fire_state = GetFireState();
 
    if (m_LastFireState != fire_state || force_refresh)
    {
      switch (fire_state)
      {
      case FireplaceFireState.START_FIRE:
      {
        //particles
        ParticleFireStartStart();
 
        //sounds
        SoundFireStop();
        SoundFireLightStart();
        break;
      }
      case FireplaceFireState.SMALL_FIRE:
      {
        //particles
        ParticleFireStartStop();
 
        ParticleSmallFireStart();
 
        if (CanShowSmoke())
          ParticleSmallSmokeStart();
        else
          ParticleSmallSmokeStop();
 
        ParticleNormalFireStop();
        ParticleNormalSmokeStop();
 
        ParticleSteamExtinguishingStop();
 
        //sounds
        SoundFireStop();
        SoundFireLightStart();
        break;
      }
      case FireplaceFireState.NORMAL_FIRE:
      {
        //particles
        ParticleFireStartStop();
 
        ParticleSmallFireStop();
        ParticleSmallSmokeStop();
 
        ParticleNormalFireStart();
 
        if (CanShowSmoke())
          ParticleNormalSmokeStart();
        else
          ParticleNormalSmokeStop();
 
        ParticleSteamExtinguishingStop();
 
        //sounds
        SoundFireStop();
        SoundFireHeavyStart();
        break;
      }
      case FireplaceFireState.END_FIRE:
      {
        //particles
        ParticleFireStartStop();
 
        ParticleSmallFireStop();
        ParticleSmallSmokeStop();
 
        ParticleNormalFireStop();
        ParticleNormalSmokeStop();
 
        ParticleFireEndStart();
 
        //sounds
        SoundFireStop();
        SoundFireNoFireStart();
        break;
      }
      case FireplaceFireState.EXTINGUISHING_FIRE: //TODO add steam particles when extinguishing
      {
        //particles
        ParticleFireStartStop();
 
        ParticleSmallFireStop();
        ParticleSmallSmokeStop();
 
        ParticleNormalFireStop();
        ParticleNormalSmokeStop();
 
        ParticleFireEndStop();
 
        ParticleSteamExtinguishingStart();
 
        //sounds
        SoundFireStop();
        SoundFireExtinguishingStart();
        break;
      }
      case FireplaceFireState.EXTINGUISHED_FIRE: //TODO add steam particles when fireplace is extinguished
      {
        //particles
        ParticleFireStartStop();
 
        ParticleSmallFireStop();
        ParticleSmallSmokeStop();
 
        ParticleNormalFireStop();
        ParticleNormalSmokeStop();
 
        ParticleFireEndStop();
 
        ParticleSteamExtinguishingStop();
 
        if (CanShowSmoke())
          ParticleSteamEndStart();
        else
          ParticleSteamEndStop();
 
        //sounds
        SoundFireStop();
        SoundFireExtinguishedStart();
        SoundFireNoFireStart();
        break;
      }
      case FireplaceFireState.REIGNITED_FIRE:
      {
        //particles
        ParticleFireStartStart();
 
        ParticleSmallFireStop();
        ParticleSmallSmokeStop();
 
        ParticleNormalFireStop();
        ParticleNormalSmokeStop();
 
        ParticleFireEndStop();
 
        ParticleSteamEndStop();
 
        //sounds
        SoundFireStop();
        break;
      }
      case FireplaceFireState.NO_FIRE:
      {
        //particles
        ParticleFireStartStop();
 
        ParticleSmallFireStop();
        ParticleSmallSmokeStop();
 
        ParticleNormalFireStop();
        ParticleNormalSmokeStop();
 
        ParticleFireEndStop();
 
        ParticleSteamEndStop();
        ParticleSteamExtinguishingStop();
 
        //sounds
        SoundFireStop();
        break;
      }
      }
 
      m_LastFireState = fire_state;
    }
  }
 
  protected void StopAllParticlesAndSounds()
  {
    // go through all fireplace particles
    if (m_ParticleFireStart)
      StopParticle(m_ParticleFireStart);
    if (m_ParticleSmallFire)
      StopParticle(m_ParticleSmallFire);
    if (m_ParticleNormalFire)
      StopParticle(m_ParticleNormalFire);
    if (m_ParticleSmallSmoke)
      StopParticle(m_ParticleSmallSmoke);
    if (m_ParticleNormalSmoke)
      StopParticle(m_ParticleNormalSmoke);
    if (m_ParticleFireEnd)
      StopParticle(m_ParticleFireEnd);
    if (m_ParticleSteamEnd)
      StopParticle(m_ParticleSteamEnd);
    if (m_ParticleSteamExtinguishing)
      StopParticle(m_ParticleSteamExtinguishing);
 
    // go through all fireplace sounds
    if (m_SoundFireLoop)
      StopSoundSet(m_SoundFireLoop);
    if (m_SoundFire)
      StopSoundSet(m_SoundFire);
  }
 
  bool CanShowSmoke()
  {
    return true;
  }
 
  //Fireplace fire intensity
  void RefreshFireState()
  {
    float temperature = GetTemperature();
 
    //if it's burning
    if (IsBurning())
    {
      //Start fire
      if (temperature <= PARAM_MIN_FIRE_TEMPERATURE)
      {
        if (GetFireState() != FireplaceFireState.START_FIRE)
          SetFireState(FireplaceFireState.START_FIRE);
      }
      //Small fire
      else if (temperature <= PARAM_SMALL_FIRE_TEMPERATURE)
      {
        if (GetFireState() != FireplaceFireState.SMALL_FIRE)
          SetFireState(FireplaceFireState.SMALL_FIRE);
      }
      //Normal fire
      else if (temperature > PARAM_SMALL_FIRE_TEMPERATURE)
      {
        if (GetFireState() != FireplaceFireState.NORMAL_FIRE)
          SetFireState(FireplaceFireState.NORMAL_FIRE);
      }
    }
  }
 
  //================================================================
  // PARTICLES & SOUNDS
  //================================================================
  //returns true if particle started, false if not
  protected bool PlayParticle(out Particle particle, int particle_type, vector pos, bool worldpos = false)
  {
    if (!particle && GetGame() && (!GetGame().IsDedicatedServer()))
    {
      if (!worldpos)
        particle = ParticleManager.GetInstance().PlayOnObject(particle_type, this, pos);
      else
        particle = ParticleManager.GetInstance().PlayInWorld(particle_type, pos);
 
      return true;
    }
 
    return false;
  }
 
  //returns true if particle stopped, false if not
  protected bool StopParticle(out Particle particle)
  {
    if (particle && GetGame() && (!GetGame().IsDedicatedServer()))
    {
      particle.Stop();
      particle = NULL;
 
      return true;
    }
 
    return false;
  }
 
  //start fire
  protected void ParticleFireStartStart()
  {
    if (IsOven())
      PlayParticle(m_ParticleFireStart, PARTICLE_OVEN_FIRE_START, GetFireEffectPosition());
    else
      PlayParticle(m_ParticleFireStart, PARTICLE_FIRE_START, GetFireEffectPosition());
  }
 
  protected void ParticleFireStartStop()
  {
    StopParticle(m_ParticleFireStart);
  }
 
  //small fire
  protected void ParticleSmallFireStart()
  {
    if (IsOven())
      PlayParticle(m_ParticleSmallFire, PARTICLE_OVEN_FIRE, GetFireEffectPosition());
    else
      PlayParticle(m_ParticleSmallFire, PARTICLE_SMALL_FIRE, GetFireEffectPosition());
  }
 
  protected void ParticleSmallFireStop()
  {
    StopParticle(m_ParticleSmallFire);
  }
 
  //normal fire
  protected void ParticleNormalFireStart()
  {
    if (IsOven())
      PlayParticle(m_ParticleNormalFire, PARTICLE_OVEN_FIRE, GetFireEffectPosition());
    else
      PlayParticle(m_ParticleNormalFire, PARTICLE_NORMAL_FIRE, GetFireEffectPosition());
  }
 
  protected void ParticleNormalFireStop()
  {
    StopParticle(m_ParticleNormalFire);
  }
 
  //small smoke
  protected void ParticleSmallSmokeStart()
  {
    PlayParticle(m_ParticleSmallSmoke, PARTICLE_SMALL_SMOKE, GetSmokeEffectPosition());
 
    //calculate air resistance
    float actual_height;
    if (GetCeilingHeight(actual_height))
    {
      float air_resistance = GetAirResistanceForSmokeParticles(actual_height);
 
      //alter smoke height
      m_ParticleSmallSmoke.SetParameter(-1, EmitorParam.AIR_RESISTANCE, air_resistance);
    }
 
    if (IsRoofAbove())
      m_ParticleSmallSmoke.SetParameter(-1, EmitorParam.WIND, false);
  }
 
  protected void ParticleSmallSmokeStop()
  {
    StopParticle(m_ParticleSmallSmoke);
  }
 
  //normal smoke
  protected void ParticleNormalSmokeStart()
  {
    PlayParticle(m_ParticleNormalSmoke, PARTICLE_NORMAL_SMOKE, GetSmokeEffectPosition());
 
    //calculate air resistance
    float actual_height;
    if (GetCeilingHeight(actual_height))
    {
      float air_resistance = GetAirResistanceForSmokeParticles(actual_height);
 
      //alter smoke height
      m_ParticleNormalSmoke.SetParameter(-1, EmitorParam.AIR_RESISTANCE, air_resistance);
    }
 
    if (IsRoofAbove())
      m_ParticleNormalSmoke.SetParameter(-1, EmitorParam.WIND, false);
  }
 
  protected void ParticleNormalSmokeStop()
  {
    StopParticle(m_ParticleNormalSmoke);
  }
 
  //fire end
  protected void ParticleFireEndStart()
  {
    if (IsOven())
      PlayParticle(m_ParticleFireEnd, PARTICLE_OVEN_FIRE_END, GetFireEffectPosition());
    else
      PlayParticle(m_ParticleFireEnd, PARTICLE_FIRE_END, GetFireEffectPosition());
  }
 
  protected void ParticleFireEndStop()
  {
    StopParticle(m_ParticleFireEnd);
  }
 
  protected void ParticleFireWindyNoIgniteStart()
  {
    if (IsOven())
      PlayParticle(m_ParticleFireEnd, PARTICLE_OVEN_FIRE_END, GetFireEffectPosition());
    else
      PlayParticle(m_ParticleFireEnd, PARTICLE_NO_IGNITE_WIND, GetFireEffectPosition());
  }
 
  //steam extinguishing
  protected void ParticleSteamExtinguishingStart()
  {
    PlayParticle(m_ParticleSteamExtinguishing, PARTICLE_STEAM_EXTINGUISHING, GetFireEffectPosition());
  }
 
  protected void ParticleSteamExtinguishingStop()
  {
    StopParticle(m_ParticleSteamExtinguishing);
  }
 
  //steam end
  protected void ParticleSteamEndStart()
  {
    PlayParticle(m_ParticleSteamEnd, PARTICLE_STEAM_END, GetFireEffectPosition());
  }
 
  protected void ParticleSteamEndStop()
  {
    StopParticle(m_ParticleSteamEnd);
  }
 
  protected void ParticleWetNoIgniteStart()
  {
    PlayParticle(m_ParticleSteamEnd, PARTICLE_STEAM_END, GetFireEffectPosition());
  }
 
  protected void ParticleWetNoIgniteStop()
  {
    StopParticle(m_ParticleSteamEnd);
  }
 
  bool GetCeilingHeight(out float actual_height)
  {
    vector from = this.GetPosition();
    vector to = this.GetPosition();
    from[1] = from[1] + 1.0;
    to[1] = to[1] + MIN_CEILING_HEIGHT;
    vector contactPos;
    vector contactDir;
    int contactComponent;
 
    bool hit = DayZPhysics.RaycastRV(from, to, contactPos, contactDir, contactComponent, NULL, NULL, this);
    actual_height = vector.Distance(from, contactPos) + 1.0;
 
    return hit;
  }
 
  float GetAirResistanceForSmokeParticles(float actual_height)
  {
    float air_res;
    actual_height = Math.Clamp(actual_height, 0, 36);
 
    air_res = (6 - actual_height) * 0.33;
    air_res = Math.Clamp(air_res, 0, 2);
 
    return air_res;
  }
 
  //Particle Positions
  //Get local fire and smoke effect position
  protected vector GetFireEffectPosition()
  {
    return Vector(0, 0.05, 0);
  }
 
  protected vector GetSmokeEffectPosition()
  {
    return Vector(0, 0.05, 0);
  }
 
  //================================================================
  // SOUNDS
  //================================================================
  //Burning
  //Start
  protected void SoundFireLightStart()
  {
    PlaySoundSetLoop(m_SoundFireLoop, SOUND_FIRE_LIGHT, 1.0, 1.0);
  }
 
  protected void SoundFireHeavyStart()
  {
    PlaySoundSetLoop(m_SoundFireLoop, SOUND_FIRE_HEAVY, 1.0, 2.0);
  }
 
  protected void SoundFireNoFireStart()
  {
    PlaySoundSetLoop(m_SoundFireLoop, SOUND_FIRE_NO_FIRE, 2.0, 2.0);
  }
 
  protected void SoundFireExtinguishedStart()
  {
    PlaySoundSet(m_SoundFire, SOUND_FIRE_EXTINGUISHED, 0.1, 0.1);
  }
 
  protected void SoundFireWetNoIgniteStart()
  {
    PlaySoundSet(m_SoundFire, SOUND_FIRE_EXTINGUISHED, 0.1, 0.1);
  }
 
  protected void SoundFireExtinguishingStart()
  {
    PlaySoundSetLoop(m_SoundFireLoop, SOUND_FIRE_EXTINGUISHING, 1.0, 0.5);
  }
 
  protected void SoundFireWindyNoIgniteStart()
  {
    PlaySoundSet(m_SoundFire, "ExtinguishByWind_SoundSet", 0, 0);
  }
 
  //Stop
  protected void SoundFireStop()
  {
    StopSoundSet(m_SoundFireLoop);
  }
 
  //================================================================
  // FUEL / KINDLING
  //================================================================
  //Add to fire consumables
  protected void AddToFireConsumables(ItemBase item)
  {
    m_FireConsumables.Insert(item, new FireConsumable(item, GetFireConsumableTypeEnergy(item)));
    CalcAndSetQuantity();
  }
 
  protected float GetFireConsumableTypeEnergy(ItemBase item)
  {
    FireConsumableType fireConsumableType = m_FireConsumableTypes.Get(item.Type());
    if (!fireConsumableType)
    {
      int count = m_FireConsumableTypes.Count();
      for (int i = 0; i < count; ++i)
      {
        if (item.IsInherited(m_FireConsumableTypes.GetKey(i)))
          fireConsumableType = m_FireConsumableTypes.GetElement(i);
      }
    }
 
    if (fireConsumableType)
      return fireConsumableType.GetEnergy();
 
    return 0;
  }
 
  //Remove from fire consumables
  protected void RemoveFromFireConsumables(FireConsumable fire_consumable)
  {
    if (fire_consumable)
    {
      m_FireConsumables.Remove(fire_consumable.GetItem());
      delete fire_consumable;
    }
 
    CalcAndSetQuantity();
  }
 
  protected FireConsumable GetFireConsumableByItem(ItemBase item)
  {
    return m_FireConsumables.Get(item);
  }
 
  //Set fuel / kindling to consume
  //Sets the item with the lowest energy value as item that will be consumed next
  //Returns reference to set fire consumable
  protected FireConsumable SetItemToConsume()
  {
    if (m_FireConsumables.Count() == 0)
      m_ItemToConsume = null;
    else
    {
      for (int i = 0; i < m_FireConsumables.Count(); ++i)
      {
        ItemBase key = m_FireConsumables.GetKey(i);
        FireConsumable fireConsumable = m_FireConsumables.Get(key);
 
        if (i == 0)
          m_ItemToConsume = fireConsumable;
        else
        {
          if (fireConsumable.GetEnergy() < m_ItemToConsume.GetEnergy())
            m_ItemToConsume = fireConsumable;
        }
      }
    }
 
    //refresh visual
    RefreshFireplaceVisuals();
 
    return m_ItemToConsume;
  }
 
  protected FireConsumable GetItemToConsume()
  {
    return m_ItemToConsume;
  }
 
  //Spend item that is used as consumable for fire (fuel, kindling)
  //if 'amount == 0', the whole quantity will be consumed (quantity -= 1 )
  //debug
  //int m_debug_fire_consume_time = 0;
  protected void SpendFireConsumable(float amount)
  {
    //spend item
    FireConsumable fireConsumable = GetItemToConsume();
 
    if (!fireConsumable)
    {
      //Set new item to consume
      fireConsumable = SetItemToConsume();
    }
 
    if (fireConsumable)
    {
      ItemBase item = fireConsumable.GetItem();
      fireConsumable.SetRemainingEnergy(fireConsumable.GetRemainingEnergy() - amount);
 
      if (fireConsumable.GetRemainingEnergy() <= 0 || amount == 0)
      {
        //set ashes
        if (!HasAshes())
          SetAshesState(true);
 
        if (item.IsAnyInherited({ItemBook, Paper, GiftWrapPaper, EyeMask_ColorBase}))
        {
          RemoveFromFireConsumables(fireConsumable);
          item.Delete();
        }
        else
        {
          //if there is nothing left, delete and remove old consumable, set new fire consumable
          if (item.GetQuantity() <= 1)
          {
            //remove item from fuel items
            RemoveFromFireConsumables(fireConsumable);
          }
          else
            fireConsumable.SetRemainingEnergy(fireConsumable.GetEnergy());
 
          item.AddQuantity(-1);
          SetItemToConsume();
        }
      }
    }
 
    CalcAndSetQuantity();
  }
 
  protected int GetKindlingCount()
  {
    int attachmentsCount = GetInventory().AttachmentCount();
    int kindlingCount = 0;
 
    for (int i = 0; i < attachmentsCount; ++i)
    {
      ItemBase item = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(i));
 
      if (IsKindling(item))
        kindlingCount++;
    }
 
    return kindlingCount;
  }
 
  protected int GetFuelCount()
  {
    int attachmentsCount = GetInventory().AttachmentCount();
    int fuelCount = 0;
 
    for (int i = 0; i < attachmentsCount; ++i)
    {
      ItemBase item = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(i));
      if (IsFuel(item))
        fuelCount++;
    }
 
    return fuelCount;
  }
 
  protected bool IsKindling(ItemBase item)
  {
    FireConsumableType fireConsumableType = m_FireConsumableTypes.Get(item.Type());
    if (!fireConsumableType)
    {
      int count = m_FireConsumableTypes.Count();
      for (int i = 0; i < count; ++i)
      {
        if (item.IsInherited(m_FireConsumableTypes.GetKey(i)))
          fireConsumableType = m_FireConsumableTypes.GetElement(i);
      }
    }
 
    return fireConsumableType && fireConsumableType.IsKindling();
  }
 
  protected bool IsFuel(ItemBase item)
  {
    FireConsumableType fireConsumableType = m_FireConsumableTypes.Get(item.Type());
    if (!fireConsumableType)
    {
      int count = m_FireConsumableTypes.Count();
      for (int i = 0; i < count; ++i)
      {
        if (item.IsInherited(m_FireConsumableTypes.GetKey(i)))
          fireConsumableType = m_FireConsumableTypes.GetElement(i);
      }
    }
 
    return fireConsumableType && !fireConsumableType.IsKindling();
  }
 
  //Has attachments of given type
  bool IsItemTypeAttached(typename item_type)
  {
    return GetAttachmentByType(item_type) != null;
  }
 
  //Has attachments of required quantity
  bool IsItemAttachedQuantity(typename item_type, float quantity)
  {
    ItemBase item = ItemBase.Cast(GetAttachmentByType(item_type));
 
    return item.GetQuantity() >= quantity;
  }
 
  //Has last attached item
  bool HasLastAttachment()
  {
    return GetInventory().AttachmentCount() == 1;
  }
 
  //Has last fuel/kindling attached
  bool HasLastFuelKindlingAttached()
  {
    return (GetFuelCount() + GetKindlingCount()) == 1;
  }
 
 
  //================================================================
  // FIRE STATE
  //================================================================
  //Is fireplace burning?
  bool IsBurning()
  {
    return m_IsBurning;
  }
 
  //Set burning state
  protected void SetBurningState(bool is_burning)
  {
    m_IsBurning = is_burning;
  }
 
  //Are ashes present in fireplace?
  bool HasAshes()
  {
    return m_HasAshes;
  }
 
  //Set ashes state
  protected void SetAshesState(bool has_ashes)
  {
    m_HasAshes = has_ashes;
 
    if (m_HasAshes)
      SetBurntFirewood();
  }
 
  //Is in oven state
  bool IsOven()
  {
    return m_IsOven;
  }
  bool HasStoneCircle()
  {
    return m_HasStoneCircle;
  }
 
  bool HasStones()
  {
    EntityAI attached_item = GetAttachmentByType(ATTACHMENT_STONES);
 
    return attached_item && attached_item.GetQuantity() > 0;
  }
 
  int GetAttachedStonesCount()
  {
    if (HasStones())
      return GetAttachmentByType(ATTACHMENT_STONES).GetQuantity();
 
    return 0;
  }
 
  void SetOvenState(bool is_oven)
  {
    if (m_IsOven != is_oven)
    {
      m_IsOven = is_oven;
      m_RoofAbove = is_oven;
 
      GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString("Stones"), is_oven);
 
      Synchronize();
    }
  }
  void SetStoneCircleState(bool has_stonecircle)
  {
    if (m_HasStoneCircle != has_stonecircle)
    {
      m_HasStoneCircle = has_stonecircle;
 
      GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString("Stones"), has_stonecircle);
 
      Synchronize();
    }
  }
 
  //Temperature loss MP
  protected float GetTemperatureLossMP()
  {
    return m_TemperatureLossMP;
  }
 
  protected void SetTemperatureLossMP(float value)
  {
    m_TemperatureLossMP = value;
  }
 
  //Fuel burn rate MP
  protected float GetFuelBurnRateMP()
  {
    return m_FuelBurnRateMP;
  }
 
  protected void SetFuelBurnRateMP(float value)
  {
    m_FuelBurnRateMP = value;
  }
 
  //Get fire state
  protected int GetFireState()
  {
    return m_FireState;
  }
 
  //Sets fire state
  protected void SetFireState(FireplaceFireState state)
  {
    if (m_FireState != state)
    {
      m_FireState = state;
 
      Synchronize();
    }
  }
 
  void SetExtinguishingState()
  {
    SetFireState(FireplaceFireState.EXTINGUISHING_FIRE);
  }
 
  //================================================================
  // FIRE PROCESS
  //================================================================
 
  //Start the fire process
  // 1. start heating
  // 2. heating
  // 3. stop heating
  void StartFire(bool force_start = false)
  {
    //stop cooling process if active
    if (m_CoolingTimer)
    {
      m_CoolingTimer.Stop();
      m_CoolingTimer = null;
    }
 
    //set under roof flag (was fire ignited under roof?)
    if (MiscGameplayFunctions.IsUnderRoof(this))
      m_RoofAbove = true;
 
    //start fire
    if (!IsBurning() || force_start)
    {
      SetItemToConsume();
      SetBurningState(true);
      m_UTSource.SetActive(true);
      StartHeating();
 
      //Update navmesh
      if (!IsFireplaceIndoor())
      {
        SetAffectPathgraph(false, true);
        GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(GetGame().UpdatePathgraphRegionByObject, 100, false, this);
      }
    }
 
    Synchronize();
  }
 
  //Start heating
  protected void StartHeating()
  {
    //visual
    SetObjectMaterial(0, MATERIAL_FIREPLACE_GLOW);
 
    if (IsWindy() && !IsRoofAbove() && !IsOven() && !IsBarrelWithHoles())
    {
      StopFire();
      return;
    }
 
    if (GetWet() > PARAM_BURN_WET_THRESHOLD)
    {
      StopFire(FireplaceFireState.EXTINGUISHED_FIRE);
      return;
    }
 
    //create area damage
    if (IsBaseFireplace() && !IsOven())
      CreateAreaDamage();
 
    m_HeatingTimer = new Timer(CALL_CATEGORY_GAMEPLAY);
    m_HeatingTimer.Run(TIMER_HEATING_UPDATE_INTERVAL, this, "Heating", null, true);
 
    //Setup the noise parameters on fire start
    m_NoisePar = new NoiseParams();
    if (IsRoofAbove() || IsOven() || IsFireplaceIndoor()) //If we have a roof, we are probably inside
      m_NoisePar.LoadFromPath("CfgVehicles FireplaceBase NoiseFireplaceSpecial");
    else
      m_NoisePar.LoadFromPath("CfgVehicles FireplaceBase NoiseFireplaceBase");
  }
 
  //Do heating
  protected void Heating()
  {
    float temperature = GetTemperature();
    float temperature_modifier = 0;
 
    //check burning conditions
    if (GetWet() > PARAM_BURN_WET_THRESHOLD)
    {
      StopFire(FireplaceFireState.EXTINGUISHED_FIRE);
      return;
    }
    else
    {
      if (m_FireConsumables.Count() == 0)
      {
        StopFire();
        return;
      }
    }
 
    //spend actual fire consumable
    float amount = PARAM_FIRE_CONSUM_RATE_AMOUNT * GetFuelBurnRateMP() * TIMER_HEATING_UPDATE_INTERVAL;
    SpendFireConsumable(amount);
 
    //set wetness if raining and alter temperature modifier (which will lower temperature increase because of rain)
    float rain = GetGame().GetWeather().GetRain().GetActual();
    if (rain >= PARAM_BURN_WET_THRESHOLD && !IsRoofAbove())
    {
      //set wet to fireplace
      AddWetnessToFireplace(PARAM_WET_INCREASE_COEF * rain);
 
      //set temperature modifier
      temperature_modifier = PARAM_TEMPERATURE_INCREASE * rain;
    }
    //subtract wetness when heating and not raining above
    else
      AddWetnessToFireplace(-PARAM_WET_HEATING_DECREASE_COEF);
 
    // temperature via UniversalTemperatureSource
    m_UTSLFireplace.SetFuelCount(GetFuelCount());
    temperature = GetTemperature() + (PARAM_TEMPERATURE_INCREASE * TIMER_HEATING_UPDATE_INTERVAL) - temperature_modifier;
    m_UTSLFireplace.SetCurrentTemperature(temperature);
    m_UTSource.Update(m_UTSSettings, m_UTSLFireplace);
 
    //check fire state
    if (GetFireState() != FireplaceFireState.EXTINGUISHING_FIRE)
      RefreshFireState();
 
    //damage cargo items
    BurnItemsInFireplace();
 
    //manage cooking equipment (this applies only for case of cooking pot on a tripod)
    if (HasCookingStand() && m_CookingEquipment)
    {
      float cook_equip_temp = m_CookingEquipment.GetTemperature();
 
      if (cook_equip_temp >= PARAM_COOKING_TEMP_THRESHOLD)
      {
        //start cooking
        CookWithEquipment();
      }
 
      //DEBUG
      /*
        PlayerBase player = ( PlayerBase ) GetGame().GetPlayer();
        string s_message = "cooking equipment temp = " + ftoa(cook_equip_temp) + " | PARAM_COOKING_TEMP_THRESHOLD = " + ftoa(PARAM_COOKING_TEMP_THRESHOLD);
        if (player != NULL) {player.MessageAction (s_message);}
        Print ( s_message );
      */
      //set temperature to cooking equipment
      cook_equip_temp = cook_equip_temp + PARAM_COOKING_EQUIP_TEMP_INCREASE;
      if (temperature <= PARAM_SMALL_FIRE_TEMPERATURE)
        cook_equip_temp = Math.Clamp(cook_equip_temp, PARAM_ITEM_HEAT_MIN_TEMP, PARAM_SMALL_FIRE_TEMPERATURE);
      else
        cook_equip_temp = Math.Clamp(cook_equip_temp, PARAM_ITEM_HEAT_MIN_TEMP, PARAM_COOKING_EQUIP_MAX_TEMP);
 
      m_CookingEquipment.SetTemperature(cook_equip_temp);
    }
 
    float cook_item_temp;
    int i;
    // manage cooking on direct cooking slots
    if (DirectCookingSlotsInUse())
    {
      for (i = 0; i < DIRECT_COOKING_SLOT_COUNT; i++)
      {
        if (m_DirectCookingSlots[i])
        {
          cook_item_temp = m_DirectCookingSlots[i].GetTemperature();
          if (cook_item_temp >= PARAM_COOKING_TEMP_THRESHOLD)
            CookOnDirectSlot(m_DirectCookingSlots[i], cook_item_temp, temperature);
        }
      }
    }
 
    // manage smoking slots
    if (SmokingSlotsInUse())
    {
      for (i = 0; i < SMOKING_SLOT_COUNT; i++)
      {
        if (m_SmokingSlots[i])
          SmokeOnSmokingSlot(m_SmokingSlots[i], cook_item_temp, temperature);
      }
    }
 
    //Make noise for AI, only at night
    if (GetGame().GetWorld().IsNight() && m_CanNoise)
    {
      NoiseSystem noise = GetGame().GetNoiseSystem();
      if (noise && m_NoisePar)
        noise.AddNoisePos(this, GetPosition(), m_NoisePar);
      m_CanNoise = false;
    }
    else
      m_CanNoise = true;
 
    Synchronize();
  }
 
  //Stop the fire process
  // 1. start cooling
  // 2. cooling
  // 3. stop cooling
  void StopFire(FireplaceFireState fire_state = FireplaceFireState.END_FIRE)
  {
    StopHeating();
    SpendFireConsumable(0);
    SetBurningState(false);
    StartCooling();
    SetFireState(fire_state);
 
    //Update navmesh
    if (!IsFireplaceIndoor())
    {
      SetAffectPathgraph(false, false);
      GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(GetGame().UpdatePathgraphRegionByObject, 100, false, this);
    }
 
    Synchronize();
  }
 
  protected void StopHeating()
  {
    if (!m_HeatingTimer)
      return;
 
    m_HeatingTimer.Stop();
    m_HeatingTimer = null;
  }
 
  protected void StartCooling()
  {
    if (m_HeatingTimer)
    {
      m_HeatingTimer.Stop();
      m_HeatingTimer = null;
    }
 
    //Start cooling
    m_CoolingTimer = new Timer(CALL_CATEGORY_GAMEPLAY);
    m_CoolingTimer.Run(TIMER_COOLING_UPDATE_INTERVAL, this, "Cooling", null, true);
  }
 
  protected void Cooling()
  {
    float wetness = GetWet();
    float temperature = GetTemperature();
    float temperature_modifier = 0;
 
    if (!IsBurning() && temperature >= 10)
    {
      //check wetness
      //set wetness if raining and alter temperature modifier (which will lower temperature increase because of rain)
      float rain = GetGame().GetWeather().GetRain().GetActual();
      if (IsRainingAbove() && !IsRoofAbove())
      {
        //set wet to fireplace
        AddWetnessToFireplace(PARAM_WET_INCREASE_COEF * rain);
 
        //set temperature modifier
        temperature_modifier = temperature_modifier + (PARAM_TEMPERATURE_DECREASE * rain);
      }
      else //subtract wetness
        AddWetnessToFireplace(-PARAM_WET_COOLING_DECREASE_COEF);
 
      //calculate already obtained wetness (e.g. extinguished by water)
      temperature_modifier = temperature_modifier + (PARAM_TEMPERATURE_DECREASE * wetness);
 
      // temperature via UniversalTemperatureSource
      m_UTSLFireplace.SetFuelCount(GetFuelCount());
      temperature = GetTemperature() - (PARAM_TEMPERATURE_DECREASE * TIMER_COOLING_UPDATE_INTERVAL) - temperature_modifier;
      m_UTSLFireplace.SetCurrentTemperature(temperature);
      m_UTSource.Update(m_UTSSettings, m_UTSLFireplace);
 
      //damage cargo items
      BurnItemsInFireplace();
 
      //cook with equipment if temperature of equipment is still high
      if (m_CookingEquipment)
      {
        float cook_equip_temp = m_CookingEquipment.GetTemperature();
 
        if (cook_equip_temp >= PARAM_COOKING_TEMP_THRESHOLD)
        {
          //cook
          CookWithEquipment();
        }
      }
 
      float cook_item_temp;
      int i;
 
      // manage cooking on direct cooking slots
      if (DirectCookingSlotsInUse())
      {
        for (i = 0; i < DIRECT_COOKING_SLOT_COUNT; i++)
        {
          if (m_DirectCookingSlots[i])
          {
            cook_item_temp = m_DirectCookingSlots[i].GetTemperature();
            if (cook_item_temp >= PARAM_COOKING_TEMP_THRESHOLD)
              CookOnDirectSlot(m_DirectCookingSlots[i], cook_item_temp, temperature);
          }
        }
      }
 
      // manage smoking slots
      if (SmokingSlotsInUse())
      {
        for (i = 0; i < SMOKING_SLOT_COUNT; i++)
        {
          if (m_SmokingSlots[i])
            SmokeOnSmokingSlot(m_SmokingSlots[i], cook_item_temp, temperature);
        }
      }
 
      //Debug
      //PlayerBase player = ( PlayerBase ) GetGame().GetPlayer();
      //if (player != NULL) {player.MessageAction ( temperature.ToString() );}
    }
    else
    {
      //stop cooling
      if (Math.AbsFloat(temperature) < 10)
      {
        StopCooling();
        m_UTSource.SetActive(false);
      }
    }
  }
 
  protected void StopCooling()
  {
    //stop all fire visuals
    SetFireState(FireplaceFireState.NO_FIRE);
    SetObjectMaterial(0, MATERIAL_FIREPLACE_NOGLOW);
 
    //Stop cooling
    m_CoolingTimer.Stop();
    m_CoolingTimer = NULL;
 
    //destroy area damage
    DestroyAreaDamage();
 
    //remove cookware audio visuals
    if (GetCookingEquipment())
    {
      Bottle_Base cooking_pot = Bottle_Base.Cast(GetCookingEquipment());
      if (cooking_pot)
        cooking_pot.RemoveAudioVisualsOnClient();
    }
 
    if (DirectCookingSlotsInUse())
    {
      for (int i = 0; i < DIRECT_COOKING_SLOT_COUNT; i++)
      {
        if (m_DirectCookingSlots[i])
        {
          Bottle_Base cookingpot = Bottle_Base.Cast(m_DirectCookingSlots[i]);
          if (cookingpot)
            cookingpot.RemoveAudioVisualsOnClient();
 
          FryingPan fryingpan = FryingPan.Cast(m_DirectCookingSlots[i]);
          if (fryingpan)
            fryingpan.RemoveAudioVisualsOnClient();
 
          Edible_Base itsfood = Edible_Base.Cast(m_DirectCookingSlots[i]);
          if (itsfood)
            itsfood.MakeSoundsOnClient(false);
        }
      }
    }
  }
 
  //================================================================
  // COOKING
  //================================================================
  protected void CookWithEquipment()
  {
    if (m_CookingProcess == null)
      m_CookingProcess = new Cooking();
 
    m_CookingProcess.CookWithEquipment(m_CookingEquipment);
  }
 
  Cooking GetCookingProcess()
  {
    if (m_CookingProcess == null)
      m_CookingProcess = new Cooking();
 
    return m_CookingProcess;
  }
 
  protected void CookOnDirectSlot(ItemBase slot_item, float temp_equip, float temp_ext)
  {
    if (m_CookingProcess == null)
      m_CookingProcess = new Cooking();
 
    m_CookingProcess.CookWithEquipment(slot_item);
 
    switch (slot_item.Type())
    {
    case ATTACHMENT_CAULDRON:
    case ATTACHMENT_COOKING_POT:
    case ATTACHMENT_FRYING_PAN:
      float cookEquipTemp = temp_equip + PARAM_COOKING_EQUIP_TEMP_INCREASE;
      if (temp_ext <= PARAM_SMALL_FIRE_TEMPERATURE)
        cookEquipTemp = Math.Clamp(cookEquipTemp, PARAM_ITEM_HEAT_MIN_TEMP, PARAM_SMALL_FIRE_TEMPERATURE);
      else
        cookEquipTemp = Math.Clamp(cookEquipTemp, PARAM_ITEM_HEAT_MIN_TEMP, PARAM_COOKING_EQUIP_MAX_TEMP);
      slot_item.SetTemperature(cookEquipTemp);
      break;
    }
  }
 
  protected void SmokeOnSmokingSlot(ItemBase slot_item, float temp_equip, float temp_ext)
  {
    if (m_CookingProcess == NULL)
      m_CookingProcess = new Cooking();
 
    // smoking slots accept only individual meat/fruit/veg items
    Edible_Base ingr = Edible_Base.Cast(slot_item);
    if (ingr)
      m_CookingProcess.SmokeItem(ingr, FireplaceBase.TIMER_HEATING_UPDATE_INTERVAL * FireplaceBase.SMOKING_SPEED);
  }
 
  //================================================================
  // FIRE VICINITY
  //================================================================
  //apply damage to all items, raise temperature to only specific items
  protected void BurnItemsInFireplace()
  {
    CargoBase cargo = GetInventory().GetCargo();
    for (int i = 0; i < cargo.GetItemCount(); i++)
    {
      ItemBase item = ItemBase.Cast(cargo.GetItem(i));
 
      //set damage
      AddDamageToItemByFireEx(item, false, false);
 
      if (item.GetHealth("", "Health") <= 0 && !item.IsKindOf("Grenade_Base"))
        item.Delete();
 
      //add temperature
      AddTemperatureToItemByFire(item);
 
      //remove wetness
      AddWetnessToItem(item, -PARAM_WET_HEATING_DECREASE_COEF);
    }
 
    for (int j = 0; j < GetInventory().AttachmentCount(); ++j)
    {
      ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(j));
 
      //set damage
      AddDamageToItemByFireEx(attachment, false, true);
 
      //add temperature
      AddTemperatureToItemByFire(attachment);
 
      //remove wetness
      AddWetnessToItem(attachment, -PARAM_WET_HEATING_DECREASE_COEF);
    }
  }
 
  //add temperature to item by fire
  protected void AddTemperatureToItemByFire(ItemBase item)
  {
    if (item.GetTemperatureMax() >= PARAM_ITEM_HEAT_MIN_TEMP)
    {
      float temperature = item.GetTemperature() + PARAM_ITEM_HEAT_TEMP_INCREASE_COEF;
      temperature = Math.Clamp(temperature, PARAM_ITEM_HEAT_MIN_TEMP, PARAM_MAX_ITEM_HEAT_TEMP_INCREASE);
      item.SetTemperature(temperature);
    }
  }
 
  protected void AddTemperatureToFireplace(float amount) {};
 
  //add damage to item by fire
  protected void AddDamageToItemByFireEx(ItemBase item, bool can_be_ruined, bool pAttachment)
  {
    if (!item)
      return;
 
    if (GetTemperature() <= PARAM_ITEM_HEAT_MIN_TEMP)
      return;
 
    if (!pAttachment)
    {
      GameInventory itemInventory = item.GetInventory();
      if (itemInventory)
      {
        for (int i = 0; i < itemInventory.AttachmentCount(); ++i)
          itemInventory.GetAttachmentFromIndex(i).AddHealth("", "", -PARAM_BURN_DAMAGE_COEF);
      }
 
      item.AddHealth("", "", -PARAM_BURN_DAMAGE_COEF);
    }
    else
    {
      float timerCoef = 1.0;
      if (m_HeatingTimer && m_HeatingTimer.IsRunning())
        timerCoef = TIMER_HEATING_UPDATE_INTERVAL;
      else if (m_CoolingTimer && m_CoolingTimer.IsRunning())
        timerCoef = TIMER_COOLING_UPDATE_INTERVAL;
 
      switch (item.Type())
      {
      case ATTACHMENT_TRIPOD:
      case ATTACHMENT_COOKINGSTAND:
      case ATTACHMENT_COOKING_POT:
      case ATTACHMENT_CAULDRON:
      case ATTACHMENT_FRYING_PAN:
        item.DecreaseHealth(GameConstants.FIRE_ATTACHMENT_DAMAGE_PER_SECOND * timerCoef, false);
        break;
      }
 
      if (IsFuel(item) || IsKindling(item))
      {
        if (item.GetHealthLevel() < GameConstants.STATE_BADLY_DAMAGED)
          item.DecreaseHealth(PARAM_BURN_DAMAGE_COEF, false);
      }
 
      if (item.CanBeCooked() && item.GetHealthLevel() >= GameConstants.STATE_BADLY_DAMAGED)
      {
        Edible_Base edible_item = Edible_Base.Cast(item);
        edible_item.ChangeFoodStage(FoodStageType.BURNED);
      }
    }
  }
 
  // DEPRECATED
  protected void AddDamageToItemByFire(ItemBase item, bool can_be_ruined)
  {
    item.DecreaseHealth(PARAM_BURN_DAMAGE_COEF, false);
 
    if (item.CanBeCooked() & item.GetHealthLevel() >= GameConstants.STATE_BADLY_DAMAGED)
    {
      Edible_Base edible_item = Edible_Base.Cast(item);
      edible_item.ChangeFoodStage(FoodStageType.BURNED);
    }
  }
 
  //add wetness on item
  protected void AddWetnessToItem(ItemBase item, float amount)
  {
    float wetness = item.GetWet();
    wetness = wetness + amount;
    wetness = Math.Clamp(wetness, 0, 1); //wetness <0-1>
    item.SetWet(wetness);
  }
 
  //add wetness on fireplace
  void AddWetnessToFireplace(float amount)
  {
    //add wetness
    float wetness = GetWet();
    wetness = wetness + amount;
    wetness = Math.Clamp(wetness, 0, 1); //wetness <0-1>
    SetWet(wetness);
 
    //decrease temperature
    if (amount > 0)
    {
      float temperature = GetTemperature();
      temperature = temperature * (1 - (wetness * 0.5));
      temperature = Math.Clamp(temperature, PARAM_MIN_FIRE_TEMPERATURE, PARAM_NORMAL_FIRE_TEMPERATURE);
      // temperature via UniversalTemperatureSource
      m_UTSLFireplace.SetFuelCount(GetFuelCount());
      m_UTSLFireplace.SetCurrentTemperature(temperature);
    }
  }
 
  protected void TransferHeatToNearPlayers() {}
 
  //Create and Destroy damage radius around the fireplace when starting/stopping burning process
  void CreateAreaDamage()
  {
    //destroy area damage if some already exists
    DestroyAreaDamage();
 
    //create new area damage
    m_AreaDamage = new AreaDamageLoopedDeferred(this);
    m_AreaDamage.SetDamageComponentType(AreaDamageComponentTypes.HITZONE);
    m_AreaDamage.SetExtents("-0.30 0 -0.30", "0.30 0.75 0.30");
    m_AreaDamage.SetLoopInterval(0.5);
    m_AreaDamage.SetDeferDuration(0.5);
    m_AreaDamage.SetHitZones({ "Head", "Torso", "LeftHand", "LeftLeg", "LeftFoot", "RightHand", "RightLeg", "RightFoot" });
    m_AreaDamage.SetAmmoName("FireDamage");
    m_AreaDamage.Spawn();
  }
 
  void DestroyAreaDamage()
  {
    if (m_AreaDamage)
      m_AreaDamage.Destroy();
  }
 
  bool IsFacingFireplace(PlayerBase player)
  {
    ErrorEx("Deprecated method", ErrorExSeverity.INFO);
 
    return false;
  }
 
  //================================================================
  // ACTIONS
  //================================================================
  // --- Actions / Action conditions
  //Check if there is some kindling attached
  bool HasAnyKindling()
  {
    return GetKindlingCount() > 0;
  }
 
  //Check if the weather is too windy
  static bool IsWindy()
  {
    //check wind
    float wind_speed = GetGame().GetWeather().GetWindSpeed();
    float wind_speed_threshold = GetGame().GetWeather().GetWindMaximumSpeed() * FireplaceBase.IGNITE_WIND_THRESHOLD;
 
    return (wind_speed >= wind_speed_threshold);
  }
 
  bool GetIgniteFailure()
  {
    return m_NoIgnite;
  }
 
  void SetIgniteFailure(bool failure)
  {
    m_NoIgnite = failure;
  }
 
  //Check if the fireplace is too wet to be ignited
  static bool IsEntityWet(notnull EntityAI entity_ai)
  {
    return (entity_ai.GetWet() >= FireplaceBase.PARAM_MAX_WET_TO_IGNITE);
  }
 
  bool IsWet()
  {
    return FireplaceBase.IsEntityWet(this);
  }
 
  //Check if there is any roof above fireplace
  bool IsRoofAbove()
  {
    return m_RoofAbove;
  }
 
  //check if fireplace is opened
  override bool IsOpen()
  {
    return true;
  }
 
  //Check if there is enough space for smoke
  bool IsCeilingHighEnoughForSmoke()
  {
    return !MiscGameplayFunctions.IsUnderRoof(this, FireplaceBase.MIN_CEILING_HEIGHT);
  }
 
  //Check if it's raining and there is only sky above fireplace
  static bool IsRainingAboveEntity(notnull EntityAI entity_ai)
  {
    return (GetGame() && (GetGame().GetWeather().GetRain().GetActual() >= FireplaceBase.PARAM_IGNITE_RAIN_THRESHOLD));
  }
 
  bool IsRainingAbove()
  {
    return FireplaceBase.IsRainingAboveEntity(this);
  }
 
  //Check there is water surface bellow fireplace
  static bool IsEntityOnWaterSurface(notnull EntityAI entity_ai)
  {
    vector fireplacePosition = entity_ai.GetPosition();
    string surfaceType;
    g_Game.SurfaceGetType3D(fireplacePosition[0], fireplacePosition[1] + g_Game.SurfaceGetSeaLevel(), fireplacePosition[2], surfaceType);
    if (!surfaceType)
    {
      float waterLevelDiff = fireplacePosition[1] - g_Game.SurfaceGetSeaLevel();
      return waterLevelDiff < 0.5;
    }
    else if (surfaceType.Contains("water"))
      return true;
 
    return false;
  }
  bool IsOnWaterSurface()
  {
    return FireplaceBase.IsEntityOnWaterSurface(this);
  }
 
  //check if the surface is interior
  static bool IsEntityOnInteriorSurface(notnull EntityAI entity_ai)
  {
    string surfaceType;
    vector fireplacePosition = entity_ai.GetPosition();
    GetGame().SurfaceGetType3D(fireplacePosition[0], fireplacePosition[1] + 1.0, fireplacePosition[2], surfaceType);
    return (GetGame().ConfigGetInt("CfgSurfaces " + surfaceType + " interior") == 1);
  }
  bool IsOnInteriorSurface()
  {
    return FireplaceBase.IsEntityOnInteriorSurface(this);
  }
 
  //Checks if has not additional items in it
  override bool IsEmpty()
  {
    return (GetInventory().GetCargo().GetItemCount() == 0 && GetInventory().AttachmentCount() == 0);
  }
 
  //Checks if it has no items in cargo
  bool IsCargoEmpty()
  {
    return (GetInventory().GetCargo().GetItemCount() == 0);
  }
 
  bool HasCookingStand()
  {
    return GetInventory().FindAttachment(InventorySlots.GetSlotIdFromString("CookingTripod")) != null;
  }
 
  //Check if object is in animation phase
  bool IsInAnimPhase(string anim_phase)
  {
    return GetAnimationPhase(anim_phase) == 0;
  }
 
  bool IsSpaceFor(vector size)
  {
    array<Object> objs = {};
    if (GetGame().IsBoxCollidingGeometry(GetWorldPosition() + Vector(0, size[1] * 0.5 + 0.1, 0), GetDirection().VectorToAngles(), size, ObjIntersect.View, ObjIntersect.Geom, {this}, objs))
    {
      foreach (Object obj : objs)
      {
        if (dBodyGetInteractionLayer(obj) == PhxInteractionLayers.ITEM_LARGE)
          return false;
      }
    }
    return true;
  }
 
 
  override bool CanSwapEntities(EntityAI otherItem, InventoryLocation otherDestination, InventoryLocation destination)
  {
    if (!otherDestination || otherDestination.GetParent() == this)
      return false;
    return true;
  }
 
  //Action condition for building oven
  bool CanBuildOven()
  {
    return !IsOven() && !IsBurning() && (GetAttachedStonesCount() >= MIN_STONES_TO_BUILD_OVEN) && !FindAttachmentBySlotName("CookingTripod") && !HasStoneCircle() && IsSpaceForOven();
  }
 
  bool IsSpaceForOven()
  {
    const float size = 0.6;
    return IsSpaceFor(Vector(size, size, size));
  }
 
  //Action condition for stone circle
  bool CanBuildStoneCircle()
  {
    return !HasStoneCircle() && !IsOven() && !IsBurning() && (GetAttachedStonesCount() >= MIN_STONES_TO_BUILD_CIRCLE) && IsSpaceForCircle();
  }
 
  bool IsSpaceForCircle()
  {
    return IsSpaceFor(Vector(0.9, 0.1, 0.9));
  }
 
  //Action condition for dismantling oven
  bool CanDismantleOven()
  {
    return (IsOven() && !IsBurning() && !DirectCookingSlotsInUse() && !SmokingSlotsInUse() && GetTemperature() <= MAX_TEMPERATURE_TO_DISMANTLE_OVEN);
  }
  //Action condition for dismantling stone circle
  bool CanDismantleStoneCircle()
  {
    return (HasStoneCircle() && !IsOven() && !IsBurning());
  }
 
  bool CanCookOnStick()
  {
    return (GetTemperature() >= PARAM_COOKING_TEMP_THRESHOLD);
  }
 
  //Can extinguish fire
  bool CanExtinguishFire()
  {
    return IsBurning();
  }
 
  FireplaceLight GetLightEntity()
  {
    return m_Light;
  }
 
  void SetLightEntity(FireplaceLight light)
  {
    m_Light = light;
  }
 
  //================================================================
  // ADVANCED PLACEMENT
  //================================================================
 
  override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
  {
    super.OnPlacementComplete(player, position, orientation);
 
    if (GetGame().IsServer())
    {
      //remove grass
      Object cc_object = GetGame().CreateObjectEx(OBJECT_CLUTTER_CUTTER, position, ECE_PLACE_ON_SURFACE);
      cc_object.SetOrientation(orientation);
      GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(GetGame().ObjectDelete, 1000, false, cc_object);
 
      SetIsPlaceSound(true);
    }
  }
 
  override string GetPlaceSoundset()
  {
    return "placeFireplace_SoundSet";
  }
 
  //================================================================
  // QUANITTY
  //================================================================
  // calculates and sets total energy based on possible (fuel/kinidling) item attachments
  protected void CalcAndSetTotalEnergy()
  {
    if (GetGame() && GetGame().IsServer())
    {
      m_TotalEnergy = 0;
 
      foreach (FireConsumableType fireConsumableType : m_FireConsumableTypes)
      {
        string quantityConfigPath = string.Format("CfgVehicles %1 varQuantityMax", fireConsumableType.GetItemType().ToString());
        string stackMaxConfigPath = string.Format("CfgSlots Slot_%1 stackMax", fireConsumableType.GetAttSlot());
        if (GetGame().ConfigIsExisting(quantityConfigPath))
          float quantityMax = GetGame().ConfigGetFloat(quantityConfigPath);
 
        if (GetGame().ConfigIsExisting(stackMaxConfigPath))
          float stackMax = GetGame().ConfigGetFloat(stackMaxConfigPath);
 
        //debug
        //Print( fireConsumableType.GetItemType().ToString() + " quantityMax = " + quantityMax.ToString() + " [" + (quantity_max*fire_consumable_type.GetEnergy()).ToString()  + "] | stack_max = " + stack_max.ToString() + " [" + (stack_max*fire_consumable_type.GetEnergy()).ToString() + "]" );
 
        if (stackMax > 0)
          m_TotalEnergy += stackMax * fireConsumableType.GetEnergy();
        else
          m_TotalEnergy += quantityMax * fireConsumableType.GetEnergy();
      }
 
      //debug
      //Print( "Total energy = " + m_TotalEnergy.ToString() );
    }
  }
 
  // calculates and sets current quantity based on actual (fuel/kinidling) item attachments
  protected void CalcAndSetQuantity()
  {
    if (GetGame() && GetGame().IsServer())
    {
      float remainingEnergy;
 
      foreach (FireConsumable fireConsumable : m_FireConsumables)
      {
        float quantity = fireConsumable.GetItem().GetQuantity();
        if (quantity > 0)
        {
          remainingEnergy += ((quantity - 1) * fireConsumable.GetEnergy()) + fireConsumable.GetRemainingEnergy();
          //Print( fireConsumable.GetItem().GetType() + " remaining energy = " + ( ( ( quantity - 1 ) * fire_consumable.GetEnergy() ) + fire_consumable.GetRemainingEnergy() ).ToString() );
        }
        else
        {
          remainingEnergy += fireConsumable.GetRemainingEnergy();
          //Print( fireConsumable.GetItem().GetType() + " remaining energy = " + ( fireConsumable.GetRemainingEnergy().ToString() ) );
        }
      }
 
      SetQuantity(remainingEnergy / m_TotalEnergy * GetQuantityMax());
    }
  }
 
  override void OnAttachmentQuantityChanged(ItemBase item)
  {
    super.OnAttachmentQuantityChanged(item);
 
    CalcAndSetQuantity();
  }
 
  override bool CanReleaseAttachment(EntityAI attachment)
  {
    if (!super.CanReleaseAttachment(attachment))
      return false;
 
    ItemBase item = ItemBase.Cast(attachment);
    if (IsKindling(item) || IsFuel(item))
      return !IsBurning();
 
    return true;
  }
 
  void LockOvenAttachments(bool lock)
  {
    //Print("LockOvenAttachments");
    //string path_cooking_equipment = "" + CFG_VEHICLESPATH + " " + GetType() + " GUIInventoryAttachmentsProps CookingEquipment attachmentSlots";
    string path_cooking_equipment = string.Format("%1 %2 GUIInventoryAttachmentsProps CookingEquipment attachmentSlots", CFG_VEHICLESPATH, GetType());
    //string path_direct_cooking = "" + CFG_VEHICLESPATH + " " + GetType() + " GUIInventoryAttachmentsProps DirectCooking attachmentSlots";
    string path_direct_cooking = string.Format("%1 %2 GUIInventoryAttachmentsProps DirectCooking attachmentSlots", CFG_VEHICLESPATH, GetType());
    if (GetGame().ConfigIsExisting(path_cooking_equipment) && GetGame().ConfigIsExisting(path_direct_cooking))
    {
      array<string> arr_cooking_equipment = new array<string>;
      array<string> arr_direct_cooking = new array<string>;
      GetGame().ConfigGetTextArray(path_cooking_equipment, arr_cooking_equipment);
      GetGame().ConfigGetTextArray(path_direct_cooking, arr_direct_cooking);
      for (int i = 0; i < arr_cooking_equipment.Count(); i++)
      {
        if (lock != GetInventory().GetSlotLock(InventorySlots.GetSlotIdFromString(arr_cooking_equipment[i])))
        {
          GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(arr_cooking_equipment[i]), lock);
          //Print("attachment lock: " + arr_cooking_equipment[i] + " " + lock);
        }
      }
 
      for (i = 0; i < arr_direct_cooking.Count(); i++)
      {
        if (lock == GetInventory().GetSlotLock(InventorySlots.GetSlotIdFromString(arr_direct_cooking[i])))
        {
          GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(arr_direct_cooking[i]), !lock);
          //Print("attachment lock: " + arr_direct_cooking[i] + " " + !lock);
        }
      }
    }
    m_OvenAttachmentsLockState = lock;
  }
  override bool DisassembleOnLastDetach()
  {
    return true;
  }
 
  override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
  {
    super.OnRPC(sender, rpc_type, ctx);
 
    ref Param1<bool> p = new Param1<bool>(false);
 
    if (ctx.Read(p))
      bool failure = p.param1;
 
    switch (rpc_type)
    {
    case FirePlaceFailure.WIND:
 
      if (failure)
      {
        ParticleFireWindyNoIgniteStart();
        SoundFireStop();
        SoundFireWindyNoIgniteStart();
      }
 
      break;
 
    case FirePlaceFailure.WET:
 
      if (failure)
      {
        ParticleWetNoIgniteStart();
        SoundFireStop();
        SoundFireWetNoIgniteStart();
      }
 
      break;
    }
  }
 
 
  //================================================================
  // DEBUG
  //================================================================
 
  //Debug menu Spawn Ground Special
  override void OnDebugSpawn()
  {
    ItemBase firewood = ItemBase.Cast(GetInventory().CreateInInventory("Firewood"));
    firewood.SetQuantity(firewood.GetQuantityMax());
 
    ItemBase sticks = ItemBase.Cast(GetInventory().CreateInInventory("WoodenStick"));
    sticks.SetQuantity(sticks.GetQuantityMax());
 
    ItemBase stone = ItemBase.Cast(GetInventory().CreateInInventory("Stone"));
    stone.SetQuantity(stone.GetQuantityMax());
 
    GetInventory().CreateInInventory("Rag");
 
    SpawnEntityOnGroundPos("PetrolLighter", GetPosition());
  }
 
  override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
  {
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ACTIVATE_ENTITY, "Ignite", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DEACTIVATE_ENTITY, "Extinguish", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.LIGHT_GREY));
 
    super.GetDebugActions(outputList);
  }
 
  override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
  {
    if (super.OnAction(action_id, player, ctx))
      return true;
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
    {
      if (action_id == EActions.ACTIVATE_ENTITY)
        OnIgnitedThis(null);
      else if (action_id == EActions.DEACTIVATE_ENTITY)
        StopFire();
    }
    return false;
  }
 
 
}