torch.c

Go to the documentation of this file.

class FlammableBase : ItemBase
{
    void FlammableBase()
    {
        Init();
    }
    
    private SoundOnVehicle  m_LoopSoundEntity;
    Particle                m_FireParticle;
    bool                    m_CanReceiveUpgrade; // Synchronized variable
    bool                    m_IsBeingDestructed = false;
    
    float                   m_BurnTimePerRagEx;
    float                   m_BurnTimePerFullLardEx;
    float                   m_BurnTimePerFullFuelDoseEx;
    float                   m_MaxConsumableLardQuantityEx;
    float                   m_MaxConsumableFuelQuantityEx;
    float                   m_WaterEvaporationByFireIntensityEx = 0.001;
    int                     m_StartFadeOutOfLightAtQuantityEx = 3;
    
    int                     m_RagsUpgradedCount;//how many rags were upgraded with fuel/lard
    bool                    m_ConsumeRagFlipFlop;//are we burning rag or fuel/lard
    vector                  m_ParticleLocalPos = Vector(0, 0.50, 0);
    
    string                  m_DecraftResult = "WoodenStick";
    TorchLight              m_Light;
    bool                    m_WasLit;//was this item ever lit ? (used for correct material setting after reconnect for extinguished flammable items)
    
    protected ref UniversalTemperatureSource m_UTSource;
    protected ref UniversalTemperatureSourceSettings m_UTSSettings;
    protected ref UniversalTemperatureSourceLambdaConstant m_UTSLConstant;
    
    override void DeferredInit()
    {
        if(m_RagsUpgradedCount)
        {
            LockRags(true);
        }
    }
    
    void Init()
    {
        if ( m_BurnTimePerRagEx == 0 || m_BurnTimePerFullLardEx == 0 || m_MaxConsumableLardQuantityEx == 0 || m_MaxConsumableFuelQuantityEx == 0 )
        {
            string cfg_path = "CfgVehicles " + GetType();
            m_BurnTimePerRagEx = GetGame().ConfigGetFloat( cfg_path + " burnTimePerRag" );
            m_BurnTimePerFullLardEx = GetGame().ConfigGetFloat( cfg_path + " burnTimePerFullLardDose" );
            m_BurnTimePerFullFuelDoseEx = GetGame().ConfigGetFloat( cfg_path + " burnTimePerFullFuelDose" );
            m_MaxConsumableLardQuantityEx = GetGame().ConfigGetFloat( cfg_path + " maxConsumableLardDose" );
            m_MaxConsumableFuelQuantityEx = GetGame().ConfigGetFloat( cfg_path + " maxConsumableFuelDose" );
        }
        RegisterNetSyncVariableBool("m_CanReceiveUpgrade");
    }
    
    override void EEInit()
    {       
        super.EEInit();
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            m_UTSSettings                   = new UniversalTemperatureSourceSettings();
            m_UTSSettings.m_Updateable      = true;
            m_UTSSettings.m_UpdateInterval  = 1;
            m_UTSSettings.m_TemperatureMin  = 0;
            m_UTSSettings.m_TemperatureMax  = 300;
            m_UTSSettings.m_RangeFull       = 0.5;
            m_UTSSettings.m_RangeMax        = 1;
            m_UTSSettings.m_TemperatureCap  = 5;
            
            m_UTSLConstant                  = new UniversalTemperatureSourceLambdaConstant();
            m_UTSource                      = new UniversalTemperatureSource(this, m_UTSSettings, m_UTSLConstant);
        }
 
    }
    
    override vector GetUniversalTemperatureSourcePosition()
    {
        if (GetHierarchyRoot())
        {
            return GetHierarchyRoot().GetPosition();
        }
 
        return super.GetPosition();
    }
    
    override void EEDelete(EntityAI parent)
    {
        super.EEDelete(parent);
        if ( m_LoopSoundEntity != NULL && GetGame() != NULL )
        {
            GetGame().ObjectDelete( m_LoopSoundEntity );
        }
        
        StopAllParticles();
    }
 
    override bool CanReceiveAttachment(EntityAI attachment, int slotId)
    {
        ItemBase att = ItemBase.Cast(GetInventory().FindAttachment(slotId));
        if (att && att.IsFullQuantity())
            return false;
        
        return super.CanReceiveAttachment(attachment, slotId);
    }
    
    override bool CanPutInCargo( EntityAI parent )
    {
        if( !super.CanPutInCargo(parent) ) {return false;}
        return CanBeTakenAsCargo();
    }
    
    override bool CanReleaseAttachment(EntityAI attachment)
    {
        if( !super.CanReleaseAttachment( attachment ) )
            return false;
        return !GetCompEM().IsWorking();
    }
    
    override bool CanRemoveFromCargo(EntityAI parent)
    {
        return CanBeTakenAsCargo();
    }
    
    override bool CanPutAsAttachment (EntityAI parent)
    {
        return !GetCompEM().IsWorking();
    }
    
    bool CanBeTakenAsCargo()
    {
        // Don't let players burn their pockets!
        return !GetCompEM().IsWorking();
    }
    
    override bool IsIgnited()
    {
        return GetCompEM().IsWorking();
    }
    
    override bool CanIgniteItem(EntityAI ignite_target = NULL)
    {
        return GetCompEM().IsWorking();
    }
    
    override bool HasFlammableMaterial()
    {
        return true;
    }
    
    // Checkes if Torch can be ignited
    override bool CanBeIgnitedBy(EntityAI igniter = NULL)
    {
        if ( !GetCompEM().CheckWetness() )
            return false;
        
        ItemBase rag = GetRag();
        
        if (rag  &&  GetCompEM().GetEnergy() < GetCompEM().GetEnergyUsage() * GetCompEM().GetUpdateInterval() )
        {
            if (IsRagDryEnough(rag))
                return false;
        }
        
        if ( !GetCompEM().CanWork() )
            return false;
        
        if ( GetCompEM().GetEnergy() < 3 )
            return false;
        
        PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
        if (player)
        {
            if (this != player.GetItemInHands())//we are in player's inventory, but not in his hands
            {
                return false;
            }
        }
        
        return true;
    }
    
    bool IsRagDryEnough(ItemBase rag)
    {
        float wetness = rag.GetWet();
        bool is_dry_enough = wetness <= 1-GetCompEM().GetWetnessExposure();
        return is_dry_enough;
    }
    
    void UpdateCheckForReceivingUpgrade()
    {
        if ( GetGame().IsServer() || !GetGame().IsMultiplayer() )
        {
            m_CanReceiveUpgrade = GetRagQuantity() > 0 && m_RagsUpgradedCount < GetRagQuantity() || (m_BurnTimePerRagEx * (m_RagsUpgradedCount + GetRagQuantity()) - GetCompEM().GetEnergy()) > 1;
            SetSynchDirty();
        }
    }
    
    override void OnIgnitedThis(EntityAI fire_source)
    {
        if ( !GetCompEM().HasEnoughStoredEnergy() )
        {
            ConsumeRag();
        }
        
        GetCompEM().SwitchOn();
    }
    
    override void OnSwitchOn()
    {
        if (!GetCompEM().HasEnoughStoredEnergy())
        {
            GetCompEM().SwitchOff();
        }
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            m_UTSource.SetActive(true);
        }
    }
    
    override void OnSwitchOff()
    {
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            m_UTSource.SetActive(false);
        }
    }
    
    void SetTorchDecraftResult(string type)
    {
        m_DecraftResult = type; //not persistent for the moment
    }
    
    bool ConsumeRag()
    {
        ItemBase rag = GetRag();
        
        if (rag)
        {
            if (rag.GetQuantity() <= 1)
            {
                LockRags(false); // Unlock attachment slot before deletion. Otherwise it will get stuck locked and unusable.
            }
            
            rag.AddQuantity(-1);
            rag.SetHealth(0);
            //GetCompEM().AddEnergy( m_BurnTimePerRagEx );
            return true;
        }
        
        return false;
    }
    
    void ConsumeLard(Lard lard)
    {
        if (lard)
        {
            float lard_quant = lard.GetQuantity();
            
            float available_lard_quant = lard_quant;
            
            if ( available_lard_quant > m_MaxConsumableLardQuantityEx )
                available_lard_quant = m_MaxConsumableLardQuantityEx;
            
            float available_lard_coef = available_lard_quant / m_MaxConsumableLardQuantityEx;
            
            float add_energy = m_BurnTimePerFullLardEx * available_lard_coef;
            float add_energy_coef = 1;
            
            float energy_limit = GetCompEM().GetEnergyMax() - GetCompEM().GetEnergy();
            
            if (add_energy > energy_limit )
            {
                add_energy_coef = energy_limit / add_energy;
                add_energy = energy_limit;
                available_lard_quant = available_lard_quant * add_energy_coef;
            }
            
            GetCompEM().AddEnergy( add_energy );
            lard.AddQuantity(-available_lard_quant);
            
            CalculateQuantity();
            
            UpdateCheckForReceivingUpgrade();
        }
    }
 
    void Upgrade(ItemBase source)
    {
        if (!GetRag())
        {
            return;
        }
        RuinRags();
        LockRags(true);
        float torchCurrentEnergy = GetCompEM().GetEnergy();
        float sourceQuantity = 100000;//for upgrade from environment(gas pump)
        
        if (source)
        {
            sourceQuantity = source.GetQuantity();
        }
        
        float maxOverallCapacity = GetRagQuantity() * 2 * m_BurnTimePerRagEx;
        //float maxUpgradeCapacity = GetRagQuantity() * m_BurnTimePerRagEx;
        float currentlyUpgraded =  Math.Max(0, torchCurrentEnergy - (GetRagQuantity() * m_BurnTimePerRagEx));
        //float freeUpgradeCapacity = maxUpgradeCapacity - currentlyUpgraded;
        float freeUpgradeCapacity = maxOverallCapacity - torchCurrentEnergy;
        float upgradeQuantity = Math.Min(freeUpgradeCapacity, sourceQuantity);
        int upgradedRags = Math.Ceil((upgradeQuantity + currentlyUpgraded) / m_BurnTimePerRagEx);
        upgradedRags = Math.Min(GetRagQuantity(), upgradedRags);
        m_RagsUpgradedCount = upgradedRags;
        GetCompEM().AddEnergy(upgradeQuantity);
        m_ConsumeRagFlipFlop = 0;//consume fuel first
        if (source)
        {
            source.AddQuantity(-upgradeQuantity);
        }
        CalculateQuantity();
        UpdateCheckForReceivingUpgrade();
    }
    
    
    
    void ConsumeFuelFromBottle(ItemBase vessel)
    {
        if (vessel)
        {
            float vessel_quant = vessel.GetQuantity();
            
            float available_vessel_quant = vessel_quant;
            
            if ( available_vessel_quant > m_MaxConsumableFuelQuantityEx )
                available_vessel_quant = m_MaxConsumableFuelQuantityEx;
            
            float available_vessel_coef = available_vessel_quant / m_MaxConsumableFuelQuantityEx;
            
            float add_energy = m_BurnTimePerFullFuelDoseEx * available_vessel_coef;
            float add_energy_coef = 1;
            
            float energy_limit = GetCompEM().GetEnergyMax() - GetCompEM().GetEnergy();
            
            if (add_energy > energy_limit )
            {
                add_energy_coef = energy_limit / add_energy;
                add_energy = energy_limit;
                available_vessel_quant = available_vessel_quant * add_energy_coef;
            }
            
            GetCompEM().AddEnergy( add_energy );
            vessel.AddQuantity(-available_vessel_quant);
            
            CalculateQuantity();
            
            UpdateCheckForReceivingUpgrade();
        }
    }
    
    void ConsumeFuelFromGasStation()
    {
        float add_energy = m_BurnTimePerFullFuelDoseEx;
        float add_energy_coef = 1;
        
        float energy_limit = GetCompEM().GetEnergyMax() - GetCompEM().GetEnergy();
        
        if (add_energy > energy_limit )
        {
            add_energy_coef = energy_limit / add_energy;
            add_energy = energy_limit;
        }
        
        GetCompEM().AddEnergy( add_energy );
        CalculateQuantity();
        UpdateCheckForReceivingUpgrade();
    }
    
    void RuinRags()
    {
        ItemBase rag = GetRag();
        
        if (rag)
        {
            rag.SetHealth(1); //does not actually ruin rags, combining would be impossible
        }
    }
    
    // Inventory manipulation
    override void OnInventoryExit(Man player)
    {
        super.OnInventoryExit(player);
        
        StandUp();
    }
    
    // Stands up the torch, if possible. Returns true on success.
    bool StandUp()
    {
        string surface_type;
        vector position = GetPosition();
        GetGame().SurfaceGetType ( position[0], position[2], surface_type );
        bool is_surface_soft = GetGame().IsSurfaceDigable(surface_type);
        
        if ( is_surface_soft && !IsRuined() )
        {
            vector ori_rotate = "0 0 0";
            ori_rotate[0] = Math.RandomFloat(0, 360);
            ori_rotate[1] = Math.RandomFloat(0, 10);
            SetOrientation(ori_rotate);
            
            return true; // I am standing up
        }
        
        return false; // I am NOT standing up
    }
    
    void CalculateQuantity()
    {
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            SetQuantityNormalized(GetCompEM().GetEnergy0To1());
        }
    }
 
    bool CanReceiveUpgrade()
    {
        return m_CanReceiveUpgrade;
    }
    
    void CraftingInit(float quantity)
    {
        GetCompEM().SetEnergy(m_BurnTimePerRagEx * quantity);
        m_CanReceiveUpgrade = true;
        SetSynchDirty();
    }
    
    
    override void EEItemAttached( EntityAI item, string slot_name ) 
    {
        super.EEItemAttached( item, slot_name );
        CalculateQuantity();
        UpdateCheckForReceivingUpgrade();
    }
    
    
    override void EEItemDetached( EntityAI item, string slot_name ) 
    {
        super.EEItemDetached( item, slot_name );
 
        if (m_IsBeingDestructed)
        {
            if (GetGame().IsServer() || !GetGame().IsMultiplayer())
            {
                EntityAI rags = EntityAI.Cast(GetGame().CreateObjectEx(item.GetType(), GetPosition(), ECE_PLACE_ON_SURFACE));
                if( rags )
                    MiscGameplayFunctions.TransferItemProperties(item, rags);
            }
            return;
        }
        
        CalculateQuantity();
        UpdateCheckForReceivingUpgrade();
        GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( TryTransformIntoStick, 100);
    }
    
    bool CanTransformIntoStick()
    {
        if ((GetGame().IsServer() || !GetGame().IsMultiplayer()) && !IsIgnited() && !GetRag() && !IsSetForDeletion() )
            return true;
        else
            return false;
    }
    
    void TryTransformIntoStick()
    {
        PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
        if ( m_IsBeingDestructed || (player && player.IsPlayerDisconnected()) )
            return;
                
        if ( CanTransformIntoStick() )
        {
            m_IsBeingDestructed = true;
            if (player)
            {
                // Transform object into wooden stick
                StopAllParticles();
                
                TorchLambda lambda = new TorchLambda(this, m_DecraftResult);
                player.ServerReplaceItemInHandsWithNew(lambda);
            }
            else
            {
                // Create wooden stick and delete Torch
                vector pos = GetPosition();
                vector ori = GetOrientation();
                
                if ( GetType() == "WoodenStick" )
                    ori = ori + Vector(0,90,0);
                
                ItemBase stick = ItemBase.Cast( GetGame().CreateObjectEx(m_DecraftResult, pos, ECE_PLACE_ON_SURFACE) );
                ApplyResultModifications(stick);
                stick.SetPosition(pos);
                stick.PlaceOnSurface();
                
                if ( stick.GetType() == "LongWoodenStick" )
                {
                    pos = stick.GetPosition() + Vector(0,-0.3,0);
                    stick.SetPosition(pos);
                }
                
                stick.SetOrientation(ori);
                GetGame().ObjectDelete(this);
            }
        }
    }
    
    
    override void OnWorkStart()
    {
        m_WasLit = true;
        LockRags(true);
        UpdateMaterial();
    }
    
    void StopAllParticles()
    {
        if (m_FireParticle)
        {
            m_FireParticle.Stop();
        }
    }
    
    Rag GetRag()
    {
        return Rag.Cast( GetAttachmentByType(Rag) );
    }
    
    void LockRags(bool do_lock)
    {
        ItemBase rag = GetRag();
        if (rag)
        {
            if (do_lock)
            {
                rag.LockToParent();
            }
            else if (!m_RagsUpgradedCount)
            {
                rag.UnlockFromParent();
            }
        }
    }
    
    void UpdateLight()
    {
        if (!m_Light)
        {
            m_Light = TorchLight.Cast( ScriptedLightBase.CreateLight( TorchLight, Vector(0,0,0), 1 ) );
            m_Light.AttachOnObject(this, m_ParticleLocalPos + Vector (0,0.2,0));
        }
        
        if (m_FireParticle)
        {
            Object direct_particle = m_FireParticle.GetDirectParticleEffect();
            
            if (direct_particle  &&  direct_particle != m_Light.GetAttachmentParent())
            {
                m_Light.AttachOnObject(direct_particle, Vector(0,0.2,0));
            }   
        }
        
        float update_interval = GetCompEM().GetUpdateInterval();
        
        if (GetQuantity() <= m_StartFadeOutOfLightAtQuantityEx)
        {
            float brightness_coef = GetQuantity() / m_StartFadeOutOfLightAtQuantityEx;
            float radius_coef = GetQuantity() / m_StartFadeOutOfLightAtQuantityEx;
            
            if (radius_coef < m_StartFadeOutOfLightAtQuantityEx/10)
                radius_coef = m_StartFadeOutOfLightAtQuantityEx/10;
            
            if (brightness_coef < m_StartFadeOutOfLightAtQuantityEx/10)
                brightness_coef = m_StartFadeOutOfLightAtQuantityEx/10;
            
            m_Light.FadeBrightnessTo(m_Light.m_TorchBrightness * brightness_coef, update_interval);
            m_Light.FadeRadiusTo(m_Light.m_TorchRadius * radius_coef, update_interval);
        }
        else
        {
            m_Light.FadeBrightnessTo(m_Light.m_TorchBrightness, update_interval);
            m_Light.FadeRadiusTo(m_Light.m_TorchRadius, update_interval);
        }
    }
 
    override void OnItemInHandsPlayerSwimStart(PlayerBase player)
    {
        GetCompEM().SwitchOff();
    }
    
    
    override void OnWork( float consumed_energy )
    {
        UpdateMaterial();
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            if (GetCompEM().GetEnergy() < ((GetRagQuantity() + m_RagsUpgradedCount) - 1) * m_BurnTimePerRagEx)
            {
                if (m_RagsUpgradedCount==0)//always burn rag
                {
                    ConsumeRag();
                }
                else if (m_ConsumeRagFlipFlop)//burn rag
                {
                    ConsumeRag();
                    m_ConsumeRagFlipFlop = !m_ConsumeRagFlipFlop;
                }
                else//burn lard/fuel
                {
                    m_RagsUpgradedCount--;
                    m_ConsumeRagFlipFlop = !m_ConsumeRagFlipFlop;
                }
            }
            if (GetRag() && GetCompEM().GetEnergy() == 0 && GetRagQuantity() > 0)
            {
                GetRag().SetQuantity(0);
            }
            RuinRags();
            
            CalculateQuantity();
            
            UpdateCheckForReceivingUpgrade();
            
            AddWet( -m_WaterEvaporationByFireIntensityEx * GetCompEM().GetUpdateInterval() );
            
            Rag rag = GetRag();
            
            if ( rag )
            {
                rag.AddWet( -m_WaterEvaporationByFireIntensityEx * GetCompEM().GetUpdateInterval() );
            }
        }
        
        if ( !m_LoopSoundEntity && GetGame() && ( !GetGame().IsDedicatedServer() ) )
        {
            m_LoopSoundEntity = PlaySoundLoop(GetSoundName(), 50);
        }
        
        // Effect scaling by fuel
        if ( !GetGame().IsDedicatedServer() )
        {
            UpdateLight();
            UpdateParticle();
        }
    }
    
    
    string GetSoundName()
    {
        return "torchLoop";
    }
    
    void UpdateParticle()
    {
        if ( GetQuantity() < 40 )
        {
            if (!m_FireParticle)
                m_FireParticle = ParticleManager.GetInstance().PlayOnObject(ParticleList.TORCH_T1, this, m_ParticleLocalPos);
            
            float scale = GetQuantity() / 40;
            
            if (scale > 1)
                scale = 1;
            
            if (scale < 0.25)
                scale = 0.25;
            
            m_FireParticle.ScaleParticleParamFromOriginal(EmitorParam.SIZE, scale);
            m_FireParticle.ScaleParticleParamFromOriginal(EmitorParam.VELOCITY, scale);
            m_FireParticle.ScaleParticleParamFromOriginal(EmitorParam.VELOCITY_RND, scale);
        }
        else
        {
            if ( !m_FireParticle  ||  m_FireParticle.GetParticleID() != ParticleList.TORCH_T2 )
            {
                // Executes once when fire particle starts or changes
                
                if (m_FireParticle)
                    m_FireParticle.Stop();
                
                m_FireParticle = ParticleManager.GetInstance().PlayOnObject(ParticleList.TORCH_T2, this, m_ParticleLocalPos);
            }
        }
    
    }
    
    override void OnWorkStop()
    {
        UpdateMaterial();
        if (m_Light)
            m_Light.FadeOut();
        
        if ( m_LoopSoundEntity && GetGame() && ( !GetGame().IsDedicatedServer() ) )
        {
            GetGame().ObjectDelete( m_LoopSoundEntity );
            m_LoopSoundEntity = NULL;
        }
        
        if ( m_FireParticle)
        {
            m_FireParticle.Stop();
            m_FireParticle = NULL;
        }
        
        CalculateQuantity();
        UpdateCheckForReceivingUpgrade();
        
        LockRags(false);
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            if (GetRag() && GetCompEM().GetEnergy() == 0 && GetRagQuantity() > 0)
            {
                GetRag().SetQuantity(0);
            }
        }
        
        TryTransformIntoStick();
    }
    
    // COMBAT
    // This needs refactor!
    override int GetMeleeMode()
    {
        if ( GetCompEM().IsWorking() )
            return 3; // ???
        else
            return 0; // ???
    }
 
    override int GetMeleeHeavyMode()
    {
        if ( GetCompEM().IsWorking() )
            return 4; // ???
        else
            return 1; // ???
    }
    
    override int GetMeleeSprintMode()
    {
        if ( GetCompEM().IsWorking() )
            return 5; // ???
        else
            return 2; // ???
    }
    
    override void SetActions()
    {
        super.SetActions();
        
        AddAction(ActionLightItemOnFire);
    }
    
    override void OnAttachmentQuantityChangedEx(ItemBase item, float delta)
    {
        super.OnAttachmentQuantityChangedEx(item, delta);
        if (delta > 0)
        {
            GetCompEM().AddEnergy(m_BurnTimePerRagEx * delta);
            CalculateQuantity();
            UpdateCheckForReceivingUpgrade();
        }
    }
        
    
    override bool DisassembleOnLastDetach()
    {
        return true;
    }
    
    override void OnDebugSpawn()
    {
        GetInventory().CreateAttachment("Rag");
        CraftingInit(GetRagQuantity());
        CalculateQuantity();
    }
    
    int GetRagQuantity()
    {
        if (GetRag())
        {
            return Math.Round(GetRag().GetQuantity());
        }
        return 0;
    }
    
    string GetBurningMaterial()
    {
        return "";
    }
    
    string GetBurntMaterial()
    {
        return "";
    }
    
    void UpdateMaterial()
    {
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            if (GetCompEM().IsWorking())
            {
                if (GetBurningMaterial())
                {
                    SetObjectMaterial(0, GetBurningMaterial());
                }
            }
            else if (m_WasLit)
            {
                if (GetBurntMaterial())
                {
                    SetObjectMaterial(0, GetBurntMaterial());
                }
            }
        }
    }
    
    
    override void OnStoreSave(ParamsWriteContext ctx)
    {
        super.OnStoreSave(ctx);
        ctx.Write(m_WasLit);
    }
    
    
    override bool OnStoreLoad( ParamsReadContext ctx, int version )
    {
        if (!super.OnStoreLoad(ctx, version))
        {
            return false;
        }
        if (version >= 130)
        {
            if (!ctx.Read( m_WasLit ))
            {
                return false;
            }
        }
        UpdateMaterial();
        return true;
    }
    
    void ApplyResultModifications(ItemBase result)
    {
        result.SetQuantity(1);
    }
    
    //-------------
    // DEBUG BELLOW
    //-------------
    #ifdef DEVELOPER
    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.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);
            }
            
        }
        return false;
    }
 
    override string GetDebugText()
    {
        string debug_output;
 
        debug_output = super.GetDebugText();
        
        if( GetGame().IsDedicatedServer())
        {
            debug_output+="m_RagsUpgradedCount:"+m_RagsUpgradedCount+"\n";
            debug_output+="m_ConsumeRagFlipFlop:"+m_ConsumeRagFlipFlop+"\n";
            if (IsIgnited() && m_ConsumeRagFlipFlop)
            {
                debug_output+="Burning rag \n";
            }
            else if (IsIgnited())
            {
                debug_output+="Burning lard/fuel \n";
            }
        }
        else
        {
            
        }
        return debug_output;
    }
    #endif
}
 
 
class Torch : FlammableBase
{
    //legacy vars which cannot be moved/removed
    static float            m_BurnTimePerRag;
    static float            m_BurnTimePerFullLard;
    static float            m_BurnTimePerFullFuelDose;
    static float            m_MaxConsumableLardQuantity;
    static float            m_MaxConsumableFuelQuantity;
    static float            m_WaterEvaporationByFireIntensity = 0.001;
    static int              m_StartFadeOutOfLightAtQuantity = 3;
    
 
    override void Init()
    {
        super.Init();
        
        //for legacy reasons
        m_BurnTimePerRag = m_BurnTimePerRagEx;
        m_BurnTimePerFullLard = m_BurnTimePerFullLardEx;
        m_BurnTimePerFullFuelDose = m_BurnTimePerFullFuelDoseEx;
        m_MaxConsumableLardQuantity = m_MaxConsumableLardQuantityEx;
        m_MaxConsumableFuelQuantity = m_MaxConsumableFuelQuantityEx;
    }
    
    override void SetActions()
    {
        super.SetActions();
        
        AddAction(ActionUpgradeTorchFromGasPump);
        AddAction(ActionRefuelTorch);
    }
    
    // !Called on CHILD when it's attached to parent.
    override void OnWasAttached( EntityAI parent, int slot_id )
    {
        super.OnWasAttached(parent, slot_id);
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
            LockRags(true);
    }
        
    // !Called on CHILD when it's detached from parent.
    override void OnWasDetached( EntityAI parent, int slot_id )
    {
        super.OnWasDetached(parent, slot_id);
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
            LockRags(false);
    }
    
    
    override void OnStoreSave(ParamsWriteContext ctx)
    {
        super.OnStoreSave(ctx);
        ctx.Write(m_ConsumeRagFlipFlop);
        ctx.Write(m_RagsUpgradedCount);
    }
    
    
    override bool OnStoreLoad( ParamsReadContext ctx, int version )
    {
        if (!super.OnStoreLoad(ctx, version))
        {
            return false;
        }
        
        if (version >= 129)
        {
            if (!ctx.Read( m_ConsumeRagFlipFlop ))
            {
                return false;
            }
        
            if (!ctx.Read( m_RagsUpgradedCount ))
            {
                return false;
            }
        }
        UpdateCheckForReceivingUpgrade();
        return true;
    }
};
 
class TorchLambda : ReplaceItemWithNewLambdaBase
{
    override void CopyOldPropertiesToNew (notnull EntityAI old_item, EntityAI new_item)
    {
        super.CopyOldPropertiesToNew(old_item, new_item);
 
        ItemBase stick;
        FlammableBase flammable = FlammableBase.Cast(old_item);
        Class.CastTo(stick, new_item);
        if (stick && flammable)
        {
            flammable.ApplyResultModifications(stick);
        }
    }
};