roadflare.c

Go to the documentation of this file.

/*
 Author: Boris Vacula
 Description: The flare has 3 burning states during which it uses different particle effects while illumnatingthe environment. After it burns up, it still releases smoke for a while.
 When the flare is dropped while its burning, it is stood up on its stands. This makes the shadows, illumination and particles stand out better.
*/
 
enum RoadflareBurningState
{
 NOT_BURNING,
 INITIAL_BURN,
 MAIN_BURN,
 FINAL_BURN,
 SMOKE_ONLY
};
 
enum RoadflareModelStates
{
 DEFAULT,
 UNCAPPED_UNIGNITED,
 UNCAPPED_IGNITED,
 UNCAPPED_BURNED_OUT
};
 
class Roadflare : ItemBase
{
 // Burning
 static protected const int INITIAL_BURNING_STATE_TIME = 5;
 static protected const int FINAL_BURNING_STATE_TIME = 60;
 static protected vector m_FlameLocalPos = "0 0.285 0";
 private int m_BurningState = RoadflareBurningState.NOT_BURNING;
 
 // Light
 RoadflareLight m_Light;
 
 // Particles
 protected Particle m_ParInitialFire;
 protected Particle m_ParMainFire;
 protected Particle m_ParFinalFire;
 protected Particle m_ParJustSmoke;
 
 static protected int PARTICLE_INIT_FIRE = ParticleList.ROADFLARE_BURNING_INIT;
 static protected int PARTICLE_MAIN_FIRE = ParticleList.ROADFLARE_BURNING_MAIN;
 static protected int PARTICLE_FINAL_FIRE = ParticleList.ROADFLARE_BURNING_ENDING;
 static protected int PARTICLE_FINAL_SMOKE = ParticleList.ROADFLARE_BURNING_SMOKE;
 
 // Sounds
 protected EffectSound m_BurningSound;
 protected EffectSound m_IgniteSound;
 static protected const string BURNING_SOUND = "roadflareLoop_SoundSet";
 static protected const string IGNITE_SOUND = "roadflareTurnOn_SoundSet";
 static protected const int BURNING_NOISE_RANGE = 30;
 
 // Timers
 ref Timer m_FinalSmokeTimer;
 
 // Ignition states
 private int m_ModelState = RoadflareModelStates.DEFAULT;
 
 // Selections
 static const string STANDS_FOLDED = "Sticks_Flare_Folded";
 static const string STANDS_UNFOLDED = "Sticks_Flare_Unfolded";
 static const string FLARE_CAP = "Flare_cap";
 static const string UNIGNITED_TIP = "Pristine";
 static const string IGNITED_TIP = "Burning";
 static const string EXTINGUISHED_TIP = "Burned_out";
 
 static const int SELECTION_Burning = 0;
 static const int SELECTION_Burned_out = 1;
 static const int SELECTION_Pristine = 2;
 static const int SELECTION_All = 3;
 
 static const string DEFAULT_TEXTURE = "dz\\gear\\consumables\\data\\road_flare_co.paa";
 static const string BURNING_TEXTURE = "dz\\gear\\consumables\\data\\road_flare_e_co.paa";
 
 static const string DEFAULT_MATERIAL = "dz\\gear\\consumables\\data\\road_flare.rvmat";
 static const string BURNING_MATERIAL = "dz\\gear\\consumables\\data\\road_flare_on.rvmat";
 
 // Noise
 ref NoiseParams m_NoisePar;
 private float m_NoiseTimer;
 
 void Roadflare()
 {
 RegisterNetSyncVariableInt("m_BurningState");
 }
 
 // Use RoadflareModelStates enum
 void SetModelState(int enum_state)
 {
 m_ModelState = enum_state;
 UpdateModelSelections();
 }
 
 override void EEDelete(EntityAI parent)
 {
 super.EEDelete(parent);
 
 if ( GetGame() )
 {
 SEffectManager.DestroyEffect( m_BurningSound ); 
 SEffectManager.DestroyEffect( m_IgniteSound ); 
 delete m_FinalSmokeTimer;
 }
 
 DestroyAllParticles();
 
 if (m_Light)
 m_Light.FadeOut(0); 
 }
 
 override void OnStoreSave(ParamsWriteContext ctx)
 {
 super.OnStoreSave(ctx);
 
 ctx.Write( m_ModelState );
 }
 
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 {
 if ( !super.OnStoreLoad(ctx, version) )
 return false;
 
 int state;
 if ( !ctx.Read(state) )
 state = RoadflareModelStates.DEFAULT;
 
 SetModelState(state);
 
 return true;
 }
 
 void UpdateModelSelections()
 {
 switch (m_ModelState)
 {
 case RoadflareModelStates.DEFAULT: 
 
 ShowSelection(FLARE_CAP);
 ShowSelection(UNIGNITED_TIP);
 
 HideSelection(IGNITED_TIP);
 HideSelection(EXTINGUISHED_TIP);
 
 SetObjectTexture(SELECTION_Pristine, DEFAULT_TEXTURE);
 SetObjectMaterial(SELECTION_Pristine, DEFAULT_MATERIAL);
 
 break;
 
 case RoadflareModelStates.UNCAPPED_UNIGNITED: 
 
 ShowSelection(UNIGNITED_TIP);
 
 HideSelection(FLARE_CAP);
 HideSelection(IGNITED_TIP);
 HideSelection(EXTINGUISHED_TIP);
 
 SetObjectTexture(SELECTION_Pristine, DEFAULT_TEXTURE);
 SetObjectMaterial(SELECTION_Pristine, DEFAULT_MATERIAL);
 
 break;
 
 case RoadflareModelStates.UNCAPPED_IGNITED:
 
 ShowSelection(IGNITED_TIP);
 
 HideSelection(UNIGNITED_TIP);
 HideSelection(FLARE_CAP);
 HideSelection(EXTINGUISHED_TIP);
 
 // No texture/material change here because the model already contains them
 
 break; 
 
 case RoadflareModelStates.UNCAPPED_BURNED_OUT:
 
 ShowSelection(EXTINGUISHED_TIP);
 
 HideSelection(UNIGNITED_TIP);
 HideSelection(FLARE_CAP);
 HideSelection(IGNITED_TIP);
 
 SetObjectTexture(SELECTION_Burned_out, DEFAULT_TEXTURE);
 SetObjectMaterial(SELECTION_Burned_out, DEFAULT_MATERIAL);
 
 break;
 }
 }
 
 // When the flare starts burning
 override void OnWorkStart()
 {
 if ( !GetGame().IsServer() || !GetGame().IsMultiplayer() )
 {
 PlaySoundSetLoop( m_BurningSound, BURNING_SOUND, 0.5, 0 );
 PlaySoundSet( m_IgniteSound, IGNITE_SOUND, 0, 0 );
 
 m_Light = RoadflareLight.Cast( ScriptedLightBase.CreateLight( RoadflareLight, Vector(0,0,0) ) );
 m_Light.AttachOnMemoryPoint( this, m_Light.m_MemoryPoint );
 }
 
 if ( GetGame().IsServer() )
 {
 /*m_NoisePar = new NoiseParams();
 m_NoisePar.LoadFromPath("cfgVehicles Roadflare NoiseRoadFlare");
 if ( GetGame().GetWorld().IsNight() )
 {
 NoiseSystem noise = GetGame().GetNoiseSystem();
 if ( noise )
 {
 noise.AddNoisePos( this, GetPosition(), m_NoisePar );
 }
 }*/
 }
 
 SetBurningState(RoadflareBurningState.INITIAL_BURN);
 SetModelState( RoadflareModelStates.UNCAPPED_IGNITED );
 }
 
 // Insert RoadflareBurningState enum index as parameter
 void SetBurningState(int state_number)
 {
 m_BurningState = state_number;
 }
 
 // Insert RoadflareBurningState enum index as parameter. Activates server -> client synchronization
 void SetBurningStateSynchronized(int state_number)
 {
 if ( GetGame().IsServer() )
 {
 m_BurningState = state_number;
 SetSynchDirty();
 }
 }
 
 // Every second of the flare burning
 override void OnWork(float consumed_energy)
 {
 if ( GetGame().IsServer() )
 {
 float burning_time = GetCompEM().GetEnergyMax() - GetCompEM().GetEnergy();
 
 // Update burning states
 if (m_BurningState == RoadflareBurningState.INITIAL_BURN)
 {
 if (burning_time >= INITIAL_BURNING_STATE_TIME)
 {
 SetBurningStateSynchronized(RoadflareBurningState.MAIN_BURN);
 }
 }
 else if ( m_BurningState == RoadflareBurningState.MAIN_BURN )
 {
 /*if ( GetGame().GetWorld().IsNight() )
 {
 NoiseSystem noise = GetGame().GetNoiseSystem();
 if ( noise )
 {
 noise.AddNoisePos( this, GetPosition(), m_NoisePar);
 }
 }*/
 
 if ( burning_time >= GetCompEM().GetEnergyMax() - FINAL_BURNING_STATE_TIME )
 {
 SetBurningStateSynchronized(RoadflareBurningState.FINAL_BURN);
 }
 }
 
 // Burn containers of this roadflare. This might be removed if lit roadflare can't be put into inventory.
 /*EntityAI container_EAI = GetHierarchyParent();
 
 if ( container_EAI && container_EAI.IsInherited(ItemBase) && !container_EAI.IsInherited(TripwireTrap) )
 {
 ItemBase container_IB = ItemBase.Cast( container_EAI );
 
 int c_size = container_IB.GetItemSize();
 if (c_size == 0)
 c_size = 1;
 
 container_IB.AddHealth("","",-10/c_size);
 }*/
 }
 
 UpdateActiveParticles();
 }
 
 // When the flare stops burning
 override void OnWorkStop()
 {
 if ( GetGame().IsMissionMainMenu() ) // This is singleplayer main menu so no synchronization here!
 {
 SetBurningState(RoadflareBurningState.NOT_BURNING);
 UpdateActiveParticles();
 }
 else
 {
 if ( GetGame().IsServer() )
 {
 //Safeguard if item is turned off by another event than running out of energy
 if (GetCompEM().GetEnergy() > 0)
 {
 if (m_Light)
 {
 m_Light.FadeOut();
 }
 SetBurningState(RoadflareBurningState.NOT_BURNING);
 return;
 }
 SetBurningStateSynchronized(RoadflareBurningState.SMOKE_ONLY);
 SetHealth("","",0);
 }
 
 UpdateActiveParticles();
 m_FinalSmokeTimer = new Timer( CALL_CATEGORY_SYSTEM );
 m_FinalSmokeTimer.Run(60, this, "StopSmoking", NULL, false);
 }
 
 
 if ( m_BurningSound )
 StopSoundSet( m_BurningSound );
 
 if (m_Light)
 m_Light.FadeOut();
 
 SetModelState( RoadflareModelStates.UNCAPPED_BURNED_OUT );
 }
 
 // Updates all (in)active particles
 void UpdateActiveParticles()
 {
 if ( GetGame().IsDedicatedServer() )
 return;
 
 switch (m_BurningState)
 {
 case RoadflareBurningState.NOT_BURNING: 
 
 DestroyAllParticles();
 break;
 
 case RoadflareBurningState.INITIAL_BURN: 
 
 if (!m_ParInitialFire)
 {
 DestroyAllParticles();
 m_ParInitialFire = ParticleManager.GetInstance().PlayOnObject( PARTICLE_INIT_FIRE, this, m_FlameLocalPos);
 m_ParInitialFire.SetWiggle( 10, 0.3 );
 }
 break;
 
 case RoadflareBurningState.MAIN_BURN:
 
 if (!m_ParMainFire)
 {
 m_ParMainFire = ParticleManager.GetInstance().PlayOnObject( PARTICLE_MAIN_FIRE, this, m_FlameLocalPos);
 m_ParMainFire.SetWiggle( 7, 0.3 );
 }
 
 DestroyParticleEx(m_ParInitialFire);
 
 break; 
 
 case RoadflareBurningState.FINAL_BURN:
 
 if (!m_ParFinalFire)
 {
 DestroyAllParticles();
 m_ParFinalFire = ParticleManager.GetInstance().PlayOnObject( PARTICLE_FINAL_FIRE, this, m_FlameLocalPos);
 m_ParFinalFire.SetWiggle( 4, 0.3 );
 }
 break;
 
 case RoadflareBurningState.SMOKE_ONLY: 
 
 if (!m_ParJustSmoke)
 {
 DestroyAllParticles();
 m_ParJustSmoke = ParticleManager.GetInstance().PlayOnObject( PARTICLE_FINAL_SMOKE, this, m_FlameLocalPos);
 m_ParJustSmoke.SetWiggle( 2, 0.3 );
 }
 break;
 }
 }
 
 // Destroys the given particle
 void DestroyParticle( Particle p )
 {
 if (p)
 {
 p.SetWiggle(0,0);
 p.Stop();
 }
 }
 
 void DestroyParticleEx( out Particle p )
 {
 DestroyParticle(p);
 p = null;
 }
 
 // Destroys all particles
 void DestroyAllParticles()
 {
 DestroyParticleEx(m_ParInitialFire);
 DestroyParticleEx(m_ParMainFire);
 DestroyParticleEx(m_ParFinalFire);
 DestroyParticleEx(m_ParJustSmoke);
 }
 
 // Stop releasing final smoke
 void StopSmoking()
 {
 SetBurningStateSynchronized(RoadflareBurningState.NOT_BURNING);
 UpdateActiveParticles();
 }
 
 // Inventory manipulation
 override void OnInventoryExit(Man player)
 {
 super.OnInventoryExit(player);
 
 if (m_BurningState != RoadflareBurningState.NOT_BURNING)
 {
 HideSelection(STANDS_FOLDED);
 ShowSelection(STANDS_UNFOLDED);
 
 if (player)
 {
 vector ori_rotate = player.GetOrientation();
 ori_rotate = ori_rotate + Vector(180, 32, 0);
 SetOrientation(ori_rotate);
 }
 }
 }
 
 override bool CanPutInCargo( EntityAI parent )
 {
 if ( !super.CanPutInCargo(parent) ) 
 return false;
 
 if ( parent && parent.IsInherited( FireplaceBase ) )
 return true;
 
 if ( m_BurningState != RoadflareBurningState.NOT_BURNING )
 return false;
 
 return true;
 }
 
 override void OnInventoryEnter(Man player)
 {
 super.OnInventoryEnter(player);
 
 HideSelection(STANDS_UNFOLDED);
 ShowSelection(STANDS_FOLDED);
 }
 
 override void OnActivatedByItem(notnull ItemBase item)
 {
 if (item.IsInherited(TripwireTrap))
 {
 GetCompEM().SwitchOn();
 }
 }
 
 override bool CanIgniteItem(EntityAI ignite_target = NULL)
 {
 return GetCompEM().IsWorking();
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 UpdateActiveParticles();
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionAttach);
 AddAction(ActionDetach);
 AddAction(ActionLightItemOnFire);
 AddAction(ActionTurnOnWhileInHands);
 }
};