ContaminatedArea_Dynamic.c

Go to the documentation of this file.

enum eAreaDecayStage
{
  INIT = 1, // The dynamic area is initializing
  START = 2, // The dynamic area is starting
  LIVE = 3, // The dynamic area is live
  DECAY_START = 4, // The dynamic area decay has started
  DECAY_END = 5, // The dynamic area will soon be deleted
}
 
// The parameters for the explosion light when creating dynamic area
class ShellLight extends PointLightBase
{
  protected float m_DefaultBrightness = 10;
  protected float m_DefaultRadius = 100;
 
  void ShellLight()
  {
    SetVisibleDuringDaylight(false);
    SetRadiusTo(m_DefaultRadius);
    SetBrightnessTo(m_DefaultBrightness);
    SetFlareVisible(false);
    SetAmbientColor(1.0, 1.0, 0.3);
    SetDiffuseColor(1.0, 1.0, 0.3);
    SetLifetime(0.15);
    SetDisableShadowsWithinRadius(-1);
    SetCastShadow(false);
  }
}
 
// The dynamic Contaminated area, using it's own default settings
class ContaminatedArea_Dynamic : ContaminatedArea_Base
{
  protected ref Timer m_StartupTimer;
  protected ref Timer m_FXTimer;
  protected FlareLight m_FlareLight;
  protected ShellLight m_ShellLight; // Light used upon ariborne shell detonation
  protected vector m_OffsetPos; // This will be the position at which we spawn all future airborne FX
  protected int m_DecayState = eAreaDecayStage.INIT; // The current state in which the area is
 
  // Constants used for startup events
  const int AIRBORNE_EXPLOSION_DELAY = 20;
  const int AREA_SETUP_DELAY = 10;
  const float AIRBORNE_FX_OFFSET = 50;
  const float ARTILLERY_SHELL_SPEED = 100; // Units per second
 
  // Constants used for dissapearing events
  const float DECAY_START_PART_SIZE = 32;
  const int DECAY_START_PART_BIRTH_RATE = 1;
  const float DECAY_END_PART_SIZE = 17;
  const int DECAY_END_PART_BIRTH_RATE = 1;
  const float START_DECAY_LIFETIME = 900;
  const float FINISH_DECAY_LIFETIME = 300;
 
  // Item Spawning upon area creation, the 4 arrays bellow have to have the same amount of elements
  const ref array<string> SPAWN_ITEM_TYPE = {"Grenade_ChemGas"};//item classnames
  const ref array<int> SPAWN_ITEM_COUNT = {Math.RandomIntInclusive(2, 5)}; //how many of each type
  const ref array<float> SPAWN_ITEM_RAD_MIN = {5};//min distance the item will be spawned from the area position(epicenter)
  const ref array<float> SPAWN_ITEM_RAD_MAX = {15};//max distance the item will be spawned from the area position(epicenter)
 
 
  void ContaminatedArea_Dynamic()
  {
    RegisterNetSyncVariableInt("m_DecayState");
  }
 
  override void EEOnCECreate()
  {
    // We get the PPE index for future usage and synchronization ( we must do it here for dynamic as it is not read through file )
    if (GetGame().IsServer())
      m_PPERequesterIdx = GetRequesterIndex(m_PPERequesterType);
 
    SetSynchDirty();
 
    // If this is the first initialization, we delay it in order to play cool effects
    if (m_DecayState == eAreaDecayStage.INIT)
    {
      vector areaPos = GetPosition();
      m_OffsetPos = areaPos;
      m_OffsetPos[1] = m_OffsetPos[1] + AIRBORNE_FX_OFFSET;
 
      // play artillery sound, sent to be played for everyone on server
      array<vector> artilleryPoints = GetGame().GetMission().GetWorldData().GetArtyFiringPos();
      vector closestPoint = areaPos;
      int dist = 0;
      int temp;
      int index = 0;
      for (int i = 0; i < artilleryPoints.Count(); i++)
      {
        temp = vector.DistanceSq(artilleryPoints.Get(i), areaPos);
        if (temp < dist || dist == 0)
        {
          dist = temp;
          index = i;
        }
      }
 
      closestPoint = artilleryPoints.Get(index);
 
      // We calculate the delay depending on distance from firing position to simulate shell travel time
      float delay = vector.Distance(closestPoint, areaPos);
      delay = delay / ARTILLERY_SHELL_SPEED;
      delay += AIRBORNE_EXPLOSION_DELAY; // We add the base, minimum time ( no area can start before this delay )
 
      Param3<vector, vector, float> pos; // The value to be sent through RPC
      array<ref Param> params; // The RPC params
 
      // We prepare to send the message
      pos = new Param3<vector, vector, float>(closestPoint, areaPos, delay);
      params = new array<ref Param>;
 
      // We send the message with this set of coords
      params.Insert(pos);
      GetGame().RPC(null, ERPCs.RPC_SOUND_ARTILLERY_SINGLE, params, true);
 
      m_FXTimer = new Timer(CALL_CATEGORY_GAMEPLAY);
      m_FXTimer.Run(delay, this, "PlayFX");
 
      delay += AREA_SETUP_DELAY; // We have an additional delay between shell detonation and finalization of area creation
      // setup zone
      m_StartupTimer = new Timer(CALL_CATEGORY_GAMEPLAY);
      m_StartupTimer.Run(delay, this, "InitZone");
    }
  }
 
  float GetRemainingTime()
  {
    return GetLifetime();
  }
 
  float GetStartDecayLifetime()
  {
    return START_DECAY_LIFETIME;
  }
 
  float GetFinishDecayLifetime()
  {
    return FINISH_DECAY_LIFETIME;
  }
 
  override void Tick()
  {
    if (GetRemainingTime() < GetFinishDecayLifetime())
    {
      // The second state of decay, further reduction of particle density and size
      SetDecayState(eAreaDecayStage.DECAY_END);
    }
    else if (GetRemainingTime() < GetStartDecayLifetime())
    {
      // The first state of decay, slight reduction in particle density and size
      SetDecayState(eAreaDecayStage.DECAY_START);
    }
 
  }
 
  // Set the new state of the Area
  void SetDecayState(int newState)
  {
    if (m_DecayState != newState)
    {
      m_DecayState = newState;
 
      // We update the trigger state values as we also want to update player bound effects
      if (m_Trigger)
        ContaminatedTrigger_Dynamic.Cast(m_Trigger).SetAreaState(m_DecayState);
 
      SetSynchDirty();
    }
  }
 
  override void EEInit()
  {
    // We make sure we have the particle array
    if (!m_ToxicClouds)
      m_ToxicClouds = new array<Particle>;
 
    // We set the values for dynamic area as these are not set through JSON and are standardized
    m_Name = "Default Dynamic";
    m_Radius = 120;
    m_PositiveHeight = 7;
    m_NegativeHeight = 10;
    m_InnerRings = 1;
    m_InnerSpacing = 40;
    m_OuterSpacing = 30;
    m_OuterRingOffset = 0;
    m_Type = eZoneType.DYNAMIC;
    m_TriggerType = "ContaminatedTrigger_Dynamic";
 
    SetSynchDirty();
 
#ifdef DEVELOPER
    // Debugs when placing entity by hand using internal tools
    /*if ( GetGame().IsServer() && !GetGame().IsMultiplayer() )
      {
      Debug.Log("YOU CAN IGNORE THE FOLLOWING DUMP");
      InitZone();
      Debug.Log("YOU CAN USE FOLLOWING DATA PROPERLY");
      }*/
#endif
 
    m_OffsetPos = GetPosition();
    m_OffsetPos[1] = m_OffsetPos[1] + AIRBORNE_FX_OFFSET;
 
    // If a player arrives slightly later during the creation process we check if playing the flare FX is relevant
    if (m_DecayState == eAreaDecayStage.INIT)
      PlayFlareVFX();
 
    if (m_DecayState == eAreaDecayStage.LIVE)
      InitZone(); // If it has already been created, we simply do the normal setup, no cool effects, force the LIVE state
    else if (GetGame().IsClient() && m_DecayState > eAreaDecayStage.LIVE)
      InitZoneClient(); // Same as before but without state forcing
 
    super.EEInit();
  }
 
  // We spawn particles and setup trigger
  override void InitZone()
  {
    m_DecayState = eAreaDecayStage.LIVE;
    SetSynchDirty();
 
    super.InitZone();
  }
 
  override void InitZoneServer()
  {
    super.InitZoneServer();
 
    SpawnItems();
    // We create the trigger on server
    if (m_TriggerType != "")
      CreateTrigger(m_Position, m_Radius);
  }
 
  void SpawnItems()
  {
    //Print("---------============ Spawning items at pos:"+m_Position);
    foreach (int j, string type: SPAWN_ITEM_TYPE)
    {
      //Print("----------------------------------");
      for (int i = 0; i < SPAWN_ITEM_COUNT[j]; i++)
      {
        vector randomDir2d = vector.RandomDir2D();
        float randomDist = Math.RandomFloatInclusive(SPAWN_ITEM_RAD_MIN[j], SPAWN_ITEM_RAD_MAX[j]);
        vector spawnPos = m_Position + (randomDir2d * randomDist);
        InventoryLocation il = new InventoryLocation;
        vector mat[4];
        Math3D.MatrixIdentity4(mat);
        mat[3] = spawnPos;
        il.SetGround(NULL, mat);
        //Print("Spawning item:"+ type + " at position:" + il.GetPos());
        GetGame().CreateObjectEx(type, il.GetPos(), ECE_PLACE_ON_SURFACE);
      }
    }
  }
 
  override void InitZoneClient()
  {
    super.InitZoneClient();
 
    if (!m_ToxicClouds)
      m_ToxicClouds = new array<Particle>;
 
    // We spawn VFX on client
    PlaceParticles(GetWorldPosition(), m_Radius, m_InnerRings, m_InnerSpacing, m_OuterRingToggle, m_OuterSpacing, m_OuterRingOffset, m_ParticleID);
  }
 
  override void OnParticleAllocation(ParticleManager pm, array<ParticleSource> particles)
  {
    super.OnParticleAllocation(pm, particles);
 
    if (m_DecayState > eAreaDecayStage.LIVE)
    {
      foreach (ParticleSource p : particles)
      {
        if (m_DecayState == eAreaDecayStage.DECAY_END)
        {
          p.SetParameter(0, EmitorParam.BIRTH_RATE, DECAY_END_PART_BIRTH_RATE);
          p.SetParameter(0, EmitorParam.SIZE, DECAY_END_PART_SIZE);
        }
        else
        {
          p.SetParameter(0, EmitorParam.BIRTH_RATE, DECAY_START_PART_BIRTH_RATE);
          p.SetParameter(0, EmitorParam.SIZE, DECAY_START_PART_SIZE);
        }
      }
    }
  }
 
  override void CreateTrigger(vector pos, int radius)
  {
    super.CreateTrigger(pos, radius);
 
    // This handles the specific case of dynamic triggers as some additionnal parameters are present
    ContaminatedTrigger_Dynamic dynaTrigger = ContaminatedTrigger_Dynamic.Cast(m_Trigger);
    if (dynaTrigger)
    {
      dynaTrigger.SetLocalEffects(m_AroundParticleID, m_TinyParticleID, m_PPERequesterIdx);
      dynaTrigger.SetAreaState(m_DecayState);
    }
  }
 
  void PlayFX()
  {
    if (GetGame().IsServer())
    {
      Param1<vector> pos; // The value to be sent through RPC
      array<ref Param> params; // The RPC params
 
      // We prepare to send the message
      pos = new Param1<vector>(vector.Zero);
      params = new array<ref Param>;
 
      // We send the message with this set of coords
      pos.param1 = m_OffsetPos;
      params.Insert(pos);
      GetGame().RPC(null, ERPCs.RPC_SOUND_CONTAMINATION, params, true);
 
      // We go to the next stage
      m_DecayState = eAreaDecayStage.START;
      SetSynchDirty();
    }
  }
 
  void PlayExplosionLight()
  {
    m_ShellLight = ShellLight.Cast(ScriptedLightBase.CreateLight(ShellLight, m_OffsetPos));
  }
 
  void PlayFlareVFX()
  {
    if (GetGame().IsClient() || (GetGame().IsServer() && !GetGame().IsMultiplayer()))
    {
      // We spawn locally the dummy object which will be used to move and manage the particle
      DynamicArea_Flare dummy = DynamicArea_Flare.Cast(GetGame().CreateObjectEx("DynamicArea_Flare", m_OffsetPos, ECE_SETUP | ECE_LOCAL));
 
      // We add some light to reinforce the effect
      m_FlareLight = FlareLightContamination.Cast(ScriptedLightBase.CreateLight(FlareLightContamination, m_OffsetPos));
    }
  }
 
  override void EEDelete(EntityAI parent)
  {
    super.EEDelete(parent);
  }
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    if (!m_ToxicClouds)
      m_ToxicClouds = new array<Particle>;
 
    switch (m_DecayState)
    {
    case eAreaDecayStage.START:
      PlayExplosionLight();
      break;
    case eAreaDecayStage.LIVE:
      InitZoneClient();
 
      break;
    case eAreaDecayStage.DECAY_START:
    {
      // We go through all the particles bound to this area and update relevant parameters
      //Debug.Log("We start decay");
      foreach (Particle p : m_ToxicClouds)
      {
        p.SetParameter(0, EmitorParam.BIRTH_RATE, DECAY_START_PART_BIRTH_RATE);
        p.SetParameter(0, EmitorParam.SIZE, DECAY_START_PART_SIZE);
      }
 
      break;
    }
    case eAreaDecayStage.DECAY_END:
    {
      // We go through all the particles bound to this area and update relevant parameters
      //Debug.Log("We finish decay");
      foreach (Particle prt : m_ToxicClouds)
      {
        prt.SetParameter(0, EmitorParam.BIRTH_RATE, DECAY_END_PART_BIRTH_RATE);
        prt.SetParameter(0, EmitorParam.SIZE, DECAY_END_PART_SIZE);
      }
 
      break;
    }
    default:
      break;
    }
  }
}