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