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