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