PortableGasStove.c

Go to the documentation of this file.

class PortableGasStove extends ItemBase
{
  StoveLight m_Light;
 
  protected const string FLAME_BUTANE_ON = "dz\\gear\\cooking\\data\\flame_butane_ca.paa";
  protected const string FLAME_BUTANE_OFF = "";
  typename ATTACHMENT_COOKING_POT = Pot;
  typename ATTACHMENT_FRYING_PAN = FryingPan;
  typename ATTACHMENT_CAULDRON = Cauldron;
 
  //cooking
  protected const float PARAM_COOKING_TEMP_THRESHOLD = 100; //temperature threshold for starting coooking process (degree Celsius)
  protected const float PARAM_COOKING_EQUIP_TEMP_INCREASE = 10; //how much will temperature increase when attached on burning fireplace (degree Celsius)
  protected const float PARAM_COOKING_EQUIP_MAX_TEMP = 250; //maximum temperature of attached cooking equipment (degree Celsius)
  protected const float PARAM_COOKING_TIME_INC_COEF = 0.5; //cooking time increase coeficient, can be used when balancing how fast a food can be cooked
 
  private float m_TimeFactor;
  //
  ref Cooking m_CookingProcess;
  ItemBase m_CookingEquipment;
 
  //sound
  const string SOUND_BURNING = "portablegasstove_burn_SoundSet";
  const string SOUND_TURN_ON = "portablegasstove_turn_on_SoundSet";
  const string SOUND_TURN_OFF = "portablegasstove_turn_off_SoundSet";
 
  protected EffectSound m_SoundBurningLoop;
  protected EffectSound m_SoundTurnOn;
  protected EffectSound m_SoundTurnOff;
 
  protected ref UniversalTemperatureSource m_UTSource;
  protected ref UniversalTemperatureSourceSettings m_UTSSettings;
  protected ref UniversalTemperatureSourceLambdaConstant m_UTSLConst;
 
  //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);
  }
 
  //Destroy
  void DestroyFireplace()
  {
    //delete object
    GetGame().ObjectDelete(this);
  }
 
  override void EEInit()
  {
    super.EEInit();
 
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
    {
      m_UTSSettings = new UniversalTemperatureSourceSettings();
      m_UTSSettings.m_ManualUpdate = true;
      m_UTSSettings.m_TemperatureMin = 0;
      m_UTSSettings.m_TemperatureMax = 1000;
      m_UTSSettings.m_RangeFull = 1;
      m_UTSSettings.m_RangeMax = 2;
      m_UTSSettings.m_TemperatureCap = 10;
 
      m_UTSLConst = new UniversalTemperatureSourceLambdaConstant();
      m_UTSource = new UniversalTemperatureSource(this, m_UTSSettings, m_UTSLConst);
    }
  }
 
  //--- ATTACHMENTS
  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));
      RefreshFlameVisual(m_EM.IsSwitchedOn(), true);
      break;
    }
  }
 
  override void EEItemDetached(EntityAI item, string slot_name)
  {
    super.EEItemDetached(item, slot_name);
 
    //cookware
    switch (item.Type())
    {
    case ATTACHMENT_CAULDRON:
    case ATTACHMENT_COOKING_POT:
    case ATTACHMENT_FRYING_PAN:
      RemoveCookingAudioVisuals();
      //remove cooking equipment reference
      ClearCookingEquipment(ItemBase.Cast(item));
      RefreshFlameVisual(m_EM.IsSwitchedOn(), false);
      break;
    }
  }
 
  //--- POWER EVENTS
  override void OnSwitchOn()
  {
    super.OnSwitchOn();
 
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
      m_UTSource.SetDefferedActive(true, 3.0);
 
    //sound (client only)
    SoundTurnOn();
  }
 
  override void OnSwitchOff()
  {
    super.OnSwitchOff();
 
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
      m_UTSource.SetDefferedActive(false, 5.0);
 
    //sound (client only)
    SoundTurnOff();
    if (m_CookingProcess && GetCookingEquipment())
      m_CookingProcess.TerminateCookingSounds(GetCookingEquipment());
  }
 
  override void OnWorkStart()
  {
    super.OnWorkStart();
 
#ifndef SERVER
    m_Light = StoveLight.Cast(ScriptedLightBase.CreateLight(StoveLight, "0 0 0"));
    m_Light.AttachOnMemoryPoint(this, "light");
#endif
 
    //refresh visual
    RefreshFlameVisual(true, GetCookingEquipment() != null);
 
    //sound (client only)
    SoundBurningStart();
  }
 
  override void OnWorkStop()
  {
#ifndef SERVER
    if (m_Light)
      m_Light.FadeOut();
#endif
 
    //refresh visual
    RefreshFlameVisual(false, false);
    //stop steam particle
    RemoveCookingAudioVisuals();
    //sound (client only)
    SoundBurningStop();
  }
 
  //on update
  override void OnWork(float consumed_energy)
  {
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
      m_UTSource.Update(m_UTSSettings, m_UTSLConst);
 
    //manage cooking equipment
    if (GetCookingEquipment())
    {
      if (GetGame() && GetGame().IsServer())
      {
        float cook_equip_temp = GetCookingEquipment().GetTemperature();
 
        //start cooking
        if (cook_equip_temp >= PARAM_COOKING_TEMP_THRESHOLD)
        {
          m_TimeFactor = consumed_energy;
          CookWithEquipment();
        }
 
        //set temperature to cooking equipment
        cook_equip_temp = cook_equip_temp + (PARAM_COOKING_EQUIP_TEMP_INCREASE * consumed_energy);
        cook_equip_temp = Math.Clamp(cook_equip_temp, 0, PARAM_COOKING_EQUIP_MAX_TEMP);
        GetCookingEquipment().SetTemperature(cook_equip_temp);
        GetCookingEquipment().DecreaseHealth(GameConstants.FIRE_ATTACHMENT_DAMAGE_PER_SECOND * GetCompEM().GetUpdateInterval(), false);
      }
    }
  }
 
  void CookWithEquipment()
  {
    if (m_CookingProcess == null)
      m_CookingProcess = new Cooking();
 
    m_CookingProcess.CookWithEquipment(GetCookingEquipment(), PARAM_COOKING_TIME_INC_COEF * m_TimeFactor);
  }
 
  protected void RefreshFlameVisual(bool working = false, bool hasAttachment = false)
  {
    if (!working)
    {
      SetObjectTexture(0, FLAME_BUTANE_OFF);
      SetObjectTexture(1, FLAME_BUTANE_OFF);
 
      return;
    }
 
    if (!hasAttachment)
    {
      SetObjectTexture(0, FLAME_BUTANE_ON);
      SetObjectTexture(1, FLAME_BUTANE_OFF);
    }
    else
    {
      SetObjectTexture(0, FLAME_BUTANE_OFF);
      SetObjectTexture(1, FLAME_BUTANE_ON);
    }
  }
 
  //================================================================
  // PARTICLES
  //================================================================
  //cooking equipment steam
  protected void RemoveCookingAudioVisuals()
  {
    ItemBase cookEquipment = GetCookingEquipment();
    if (cookEquipment)
    {
      switch (cookEquipment.Type())
      {
      case ATTACHMENT_CAULDRON:
      case ATTACHMENT_COOKING_POT:
        Bottle_Base cookingPot = Bottle_Base.Cast(cookEquipment);
        cookingPot.RemoveAudioVisualsOnClient();
        break;
      case ATTACHMENT_FRYING_PAN:
        FryingPan fryingPan = FryingPan.Cast(cookEquipment);
        fryingPan.RemoveAudioVisualsOnClient();
        break;
      }
    }
  }
 
  //================================================================
  // SOUNDS
  //================================================================
  protected void SoundBurningStart()
  {
    PlaySoundSetLoop(m_SoundBurningLoop, SOUND_BURNING, 0.1, 0.3);
  }
 
  protected void SoundBurningStop()
  {
    StopSoundSet(m_SoundBurningLoop);
  }
 
  protected void SoundTurnOn()
  {
    PlaySoundSet(m_SoundTurnOn, SOUND_TURN_ON, 0.1, 0.1);
  }
 
  protected void SoundTurnOff()
  {
    PlaySoundSet(m_SoundTurnOff, SOUND_TURN_OFF, 0.1, 0.1);
  }
 
  //================================================================
  // CONDITIONS
  //================================================================
  //this into/outo parent.Cargo
  override bool CanPutInCargo(EntityAI parent)
  {
    if (!super.CanPutInCargo(parent))
      return false;
 
    if (GetCompEM().IsSwitchedOn())
      return false;
 
    //can 'parent' be attached to 'this' (->assumed smaller size than 'this')?
    if (parent)
    {
      int slotId;
      for (int i = 0; i < GetInventory().GetAttachmentSlotsCount(); i++)
      {
        slotId = GetInventory().GetAttachmentSlotId(i);
        if (parent.GetInventory().HasInventorySlot(slotId))
        {
          //Print("CanPutInCargo | parent " + parent + " matches in slot name: " + InventorySlots.GetSlotName(slotId) + " of " + this);
          return false;
        }
      }
    }
 
    return true;
  }
 
  override bool CanRemoveFromCargo(EntityAI parent)
  {
    return true;
  }
 
  override bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    InventoryLocation loc = new InventoryLocation();
    EntityAI ent = this;
    EntityAI parent;
    while (ent)
    {
      if (ent.GetInventory().GetCurrentInventoryLocation(loc) && loc.IsValid())
      {
        if (loc.GetType() == InventoryLocationType.CARGO)
        {
          parent = ent.GetHierarchyParent();
          if (parent && parent.GetInventory().HasInventorySlot(slotId))
          {
            //Print("CanReceiveAttachment | parent " + parent + " matches in slot name: " + InventorySlots.GetSlotName(slotId) + " of " + this);
            return false;
          }
        }
      }
 
      ent = ent.GetHierarchyParent();
    }
 
    return super.CanReceiveAttachment(attachment, slotId);
  }
 
  override bool CanLoadAttachment(EntityAI attachment)
  {
    int slotId;
    for (int i = 0; i < attachment.GetInventory().GetSlotIdCount(); i++)
    {
      slotId = attachment.GetInventory().GetSlotId(i);
      if (GetInventory().HasAttachmentSlot(slotId))
      {
        InventoryLocation loc = new InventoryLocation();
        EntityAI ent = this;
        EntityAI parent;
        while (ent)
        {
          if (ent.GetInventory().GetCurrentInventoryLocation(loc) && loc.IsValid())
          {
            if (loc.GetType() == InventoryLocationType.CARGO)
            {
              parent = ent.GetHierarchyParent();
              if (parent.GetInventory().HasInventorySlot(slotId))
              {
                //Print("CanLoadAttachment | parent " + parent + " matches in slot name: " + InventorySlots.GetSlotName(slotId) + " of " + this);
                return false;
              }
            }
          }
 
          ent = ent.GetHierarchyParent();
        }
      }
    }
 
    return super.CanLoadAttachment(attachment);
  }
 
  //hands
  override bool CanPutIntoHands(EntityAI parent)
  {
    if (!super.CanPutIntoHands(parent))
      return false;
 
    return !GetCompEM().IsSwitchedOn();
  }
 
  //================================================================
  // ITEM-TO-ITEM FIRE DISTRIBUTION
  //================================================================
 
  override bool IsIgnited()
  {
    return GetCompEM().IsWorking();
  }
 
  override bool CanIgniteItem(EntityAI ignite_target = NULL)
  {
    return GetCompEM().IsWorking();
  }
 
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionLightItemOnFire);
    AddAction(ActionTurnOnWhileOnGround);
    AddAction(ActionTurnOffWhileOnGround);
  }
 
  //Debug menu Spawn Ground Special
  override void OnDebugSpawn()
  {
    EntityAI entity;
    if (Class.CastTo(entity, this))
    {
      GetInventory().CreateInInventory("LargeGasCanister");
      GetInventory().CreateInInventory("Pot");
 
      SpawnEntityOnGroundPos("WaterBottle", entity.GetPosition() + Vector(0.2, 0, 0));
    }
  }
}