EffectArea.c

Go to the documentation of this file.

// Mostly used for better readability
enum eZoneType
{
  STATIC = 1,
  DYNAMIC = 2
}
 
// Class used for parameter transfer, all of the params are shadows of EffectArea member variables
class EffectAreaParams
{
  string m_ParamName = "Default setup";
  string m_ParamTriggerType = "ContaminatedTrigger";
  float m_ParamRadius = 100;
  float m_ParamPosHeight = 25;
  float m_ParamNegHeight = 10;
  int m_ParamInnerRings = 1;
  int m_ParamInnerSpace = 35;
  bool m_ParamOuterToggle = true;
  int m_ParamOuterSpace = 20;
  int m_ParamOuterOffset = -5;
  int m_ParamVertLayers = 0;
  int m_ParamVerticalOffset = 10;
  /*
    int   m_ParamPartId         = ParticleList.CONTAMINATED_AREA_GAS_BIGASS;
    int   m_ParamAroundPartId     = ParticleList.CONTAMINATED_AREA_GAS_AROUND;
    int   m_ParamTinyPartId       = ParticleList.CONTAMINATED_AREA_GAS_TINY;
  */
  int m_ParamPartId = 0;
  int m_ParamAroundPartId = 0;
  int m_ParamTinyPartId = 0;
 
  string m_ParamPpeRequesterType = "PPERequester_ContaminatedAreaTint";
}
 
// Base class for contaminated and other "Effect" areas
class EffectArea : House
{
  // Area Data
  string m_Name = "Default setup"; // The user defined name of the area
  int m_Type = eZoneType.STATIC; // If the zone is static or dynamic
  vector m_Position; // World position of Area
 
  // Trigger Data
  float m_Radius = 100; // Radius of the Contaminated Area
  float m_PositiveHeight = 25; // Distance between center and maximum height
  float m_NegativeHeight = 10; // Distance between center and minimum height
 
  // PCG parameters
  // Inner Particle data
  int m_InnerRings = 1; // The amount of inner rings one wants
  int m_InnerSpacing = 35; // Distance between two particles placed on inner rings of the area
  // Outer particle data
  bool m_OuterRingToggle = true; // Allow disabling outer ring if undesired
  int m_OuterRingOffset = -5; // Distance between the outermost ring of particles and area radius
  int m_OuterSpacing = 20; // Distance between two particles placed on the outer most ring of the area
  // Verticality handling
  int m_VerticalLayers = 0; // Used to add multiple layers vertically and set vertical spacing ( 0 don't do anything )
  int m_VerticalOffset = 10; // Used to determine vertical offset between two vertical layers
 
  // Particles and visual effects
  int m_ParticleID = ParticleList.CONTAMINATED_AREA_GAS_BIGASS;
  int m_AroundParticleID = ParticleList.CONTAMINATED_AREA_GAS_AROUND;
  int m_TinyParticleID = ParticleList.CONTAMINATED_AREA_GAS_TINY;
  string m_PPERequesterType;
  int m_PPERequesterIdx = -1;
  int m_EffectsPriority; // When multiple areas overlap, only the area with the highest priority will play its effects
 
  // Other values and storage
  string m_TriggerType = "ContaminatedTrigger"; // The trigger class used by this zone
  EffectTrigger m_Trigger; // The trigger used to determine if player is inside toxic area
 
  ref array<Particle> m_ToxicClouds; // All static toxic clouds in ContaminatedArea
 
 
  // ----------------------------------------------
  // INITIAL SETUP
  // ----------------------------------------------
 
  void EffectArea()
  {
    RegisterNetSyncVariableFloat("m_Radius", 0, 0, 2);
    RegisterNetSyncVariableFloat("m_PositiveHeight", 0, 0, 2);
    RegisterNetSyncVariableFloat("m_NegativeHeight", 0, 0, 2);
 
    RegisterNetSyncVariableInt("m_InnerRings");
    RegisterNetSyncVariableInt("m_InnerSpacing");
    RegisterNetSyncVariableInt("m_OuterRingOffset");
    RegisterNetSyncVariableInt("m_OuterSpacing");
    RegisterNetSyncVariableInt("m_VerticalLayers");
    RegisterNetSyncVariableInt("m_VerticalOffset");
 
    RegisterNetSyncVariableInt("m_ParticleID");
    /*
      RegisterNetSyncVariableInt("m_AroundParticleID");
      RegisterNetSyncVariableInt("m_TinyParticleID");
      RegisterNetSyncVariableInt("m_PPERequesterIdx");
    */
    RegisterNetSyncVariableBool("m_OuterRingToggle");
  }
 
  void ~EffectArea()
  {
 
  }
 
  void SetupZoneData(EffectAreaParams params)
  {
    // A lot of branching, allowing to use default values on specified params
    if (params.m_ParamName != "")
      m_Name = params.m_ParamName;
    if (params.m_ParamTriggerType != "")
      m_TriggerType = params.m_ParamTriggerType;
 
    if (params.m_ParamRadius > 0)
      m_Radius = params.m_ParamRadius;
    if (params.m_ParamPosHeight > -1)
      m_PositiveHeight = params.m_ParamPosHeight;
    if (params.m_ParamNegHeight > -1)
      m_NegativeHeight = params.m_ParamNegHeight;
 
    m_InnerRings = params.m_ParamInnerRings;
    if (params.m_ParamInnerSpace > -1)
      m_InnerSpacing = params.m_ParamInnerSpace;
 
    m_OuterRingToggle = params.m_ParamOuterToggle;
    if (params.m_ParamOuterSpace > -1)
      m_OuterSpacing = params.m_ParamOuterSpace;
    m_OuterRingOffset = params.m_ParamOuterOffset;
 
    if (params.m_ParamVertLayers > 0)
      m_VerticalLayers = params.m_ParamVertLayers;
    if (params.m_ParamVerticalOffset > 0)
      m_VerticalOffset = params.m_ParamVerticalOffset;
 
    m_ParticleID = params.m_ParamPartId;
    m_AroundParticleID = params.m_ParamAroundPartId;
    m_TinyParticleID = params.m_ParamTinyPartId;
 
    if (params.m_ParamPpeRequesterType != "")
    {
      m_PPERequesterType = params.m_ParamPpeRequesterType;
      m_PPERequesterIdx = GetRequesterIndex(m_PPERequesterType);
    }
    // We get the PPE index for future usage and synchronization
 
 
    // DEVELOPER NOTE :
    // If you cannot register a new requester, add your own indexation and lookup methods to get an index and synchronize it
    // EXAMPLE : m_PPERequesterIdx = MyLookupMethod()
 
    // We sync our data
    SetSynchDirty();
 
    // Now that everything is ready, we finalize setup
    InitZone();
  }
 
  void Tick() {};
 
 
  // Through this we will evaluate the resize of particles
  override void OnCEUpdate()
  {
    super.OnCEUpdate();
    Tick();
  }
 
  void InitZone()
  {
    //Debug.Log("------------------------------------------");
    //Debug.Log( "We have created the zone : " + m_Name );
 
    m_Position = GetWorldPosition();
 
    if (!GetGame().IsDedicatedServer())
      InitZoneClient();
 
    if (GetGame().IsServer())
      InitZoneServer();
 
    //Debug.Log("------------------------------------------");
  }
 
  // The following methods are to be overriden to execute specifc logic
  // Each method is executed where it says it will so no need to check for server or client ;)
  void InitZoneServer() {};
 
  void InitZoneClient() {};
 
  // ----------------------------------------------
  // INTERACTION SETUP
  // ----------------------------------------------
 
  override bool CanPutInCargo(EntityAI parent)
  {
    return false;
  }
 
  override bool CanPutIntoHands(EntityAI parent)
  {
    return false;
  }
 
  override bool DisableVicinityIcon()
  {
    return true;
  }
 
  override bool CanBeTargetedByAI(EntityAI ai)
  {
    return false;
  }
 
  // ----------------------------------------------
  // PARTICLE GENERATION
  // ----------------------------------------------
  // Used to position all particles procedurally
  void PlaceParticles(vector pos, float radius, int nbRings, int innerSpacing, bool outerToggle, int outerSpacing, int outerOffset, int partId)
  {
#ifdef NO_GUI
    return; // do not place any particles if there is no GUI
#endif
    if (partId == 0)
    {
      Error("[WARNING] :: [EffectArea PlaceParticles] :: no particle defined, skipping area particle generation");
      return;
    }
    // Determine if we snap first layer to ground
    bool snapFirstLayer = true;
    if (m_Type == eZoneType.STATIC && pos[1] != GetGame().SurfaceRoadY(pos[0], pos[2]))
      snapFirstLayer = false;
 
    // BEGINNING OF SAFETY NET
    // We want to prevent divisions by 0
    if (radius == 0)
    {
      // In specific case of radius, we log an error and return as it makes no sense
      Error("[WARNING] :: [EffectArea PlaceParticles] :: Radius of contaminated zone is set to 0, this should not happen");
      return;
    }
 
    if (outerToggle && radius == outerOffset)
    {
      Error("[WARNING] :: [EffectArea PlaceParticles] :: Your outerOffset is EQUAL to your Radius, this will result in division by 0");
      return;
    }
 
    // Inner spacing of 0 would cause infinite loops as no increment would happen
    if (innerSpacing == 0)
      innerSpacing = 1;
 
    // END OF SAFETY NET
 
    int partCounter = 0; // Used for debugging, allows one to know how many emitters are spawned in zone
    int numberOfEmitters = 1; // We always have the central emitter
 
    //Debug.Log("We have : " + nbRings + " rings");
    //Debug.Log("We have : " + m_VerticalLayers + " layers");
 
    float angle = 0; // Used in for loop to know where we are in terms of angle spacing ( RADIANS )
 
    ParticlePropertiesArray props = new ParticlePropertiesArray();
 
    // We also populate vertically, layer 0 will be snapped to ground, subsequent layers will see particles floating and relevant m_VerticalOffset
    for (int k = 0; k <= m_VerticalLayers; k++)
    {
      vector partPos = pos;
      // We prevent division by 0
      // We don't want to tamper with ground layer vertical positioning
      if (k != 0)
        partPos[1] = partPos[1] + (m_VerticalOffset * k);
 
      // We will want to start by placing a particle at center of area
      props.Insert(ParticleProperties(partPos, ParticlePropertiesFlags.PLAY_ON_CREATION, null, vector.Zero, this));
      partCounter++;
 
      // For each concentric ring, we place a particle emitter at a set offset
      for (int i = 1; i <= nbRings + outerToggle; i++)
      {
        //Debug.Log("We are on iteration I : " + i );
 
        // We prepare the variables to use later in calculation
        float angleIncrement; // The value added to the offset angle to place following particle
        float ab; // Length of a side of triangle used to calculate particle positionning
        vector temp = vector.Zero; // Vector we rotate to position next spawn point
 
        // The particle density is not the same on the final ring which will only happen if toggled
        // Toggle uses bool parameter treated as int, thus i > nbRings test ( allows to limit branching )
        if (i > nbRings)
        {
          ab = radius - outerOffset; // We want to leave some space to better see area demarcation
 
          // We calculate the rotation angle depending on particle spacing and distance from center
          angleIncrement = Math.Acos(1 - ((outerSpacing * outerSpacing) / (2 * Math.SqrInt(ab))));
          temp[2] = temp[2] + ab;
 
          //Debug.Log("Radius of last circle " + i + " is : " + ab);
        }
        else
        {
          ab = (radius / (nbRings + 1)) * i; // We add the offset from one ring to another
 
          // We calculate the rotation angle depending on particle spacing and distance from center
          angleIncrement = Math.Acos(1 - ((innerSpacing * innerSpacing) / (2 * Math.SqrInt(ab))));
          temp[2] = temp[2] + ab;
 
          //Debug.Log("Radius of inner circle " + i + " is : " + ab);
        }
 
        for (int j = 0; j <= (Math.PI2 / angleIncrement); j++)
        {
          // Determine position of particle emitter
          // Use offset of current ring for vector length
          // Use accumulated angle for vector direction
 
          float sinAngle = Math.Sin(angle);
          float cosAngle = Math.Cos(angle);
 
          partPos = vector.RotateAroundZero(temp, vector.Up, cosAngle, sinAngle);
          partPos += pos;
 
          // We snap first layer to ground if specified
          if (k == 0 && snapFirstLayer == true)
            partPos[1] = GetGame().SurfaceY(partPos[0], partPos[2]);
          else if (k == 0 && snapFirstLayer == false)
            partPos[1] = partPos[1] - m_NegativeHeight;
 
          // We check the particle is indeed in the trigger to make it consistent
          if (partPos[1] <= pos[1] + m_PositiveHeight && partPos[1] >= pos[1] - m_NegativeHeight)
          {
            // Place emitter at vector end ( coord )
            props.Insert(ParticleProperties(partPos, ParticlePropertiesFlags.PLAY_ON_CREATION, null, GetGame().GetSurfaceOrientation(partPos[0], partPos[2]), this));
 
            ++partCounter;
          }
 
          // Increase accumulated angle
          angle += angleIncrement;
        }
 
        angle = 0; // We reset our accumulated angle for the next ring
      }
    }
 
    m_ToxicClouds.Reserve(partCounter);
 
    ParticleManager gPM = ParticleManager.GetInstance();
 
    array<ParticleSource> createdParticles = gPM.CreateParticlesByIdArr(partId, props, partCounter);
    if (createdParticles.Count() != partCounter)
    {
      if (gPM.IsFinishedAllocating())
      {
        ErrorEx(string.Format("Not enough particles in pool for EffectArea: %1", m_Name));
        OnParticleAllocation(gPM, createdParticles);
      }
      else
        gPM.GetEvents().Event_OnAllocation.Insert(OnParticleAllocation);
    }
    else
      OnParticleAllocation(gPM, createdParticles);
 
    //Debug.Log("Emitter count : " + partCounter );
  }
 
  void OnParticleAllocation(ParticleManager pm, array<ParticleSource> particles)
  {
    foreach (ParticleSource p : particles)
    {
      if (p.GetOwner() == this) // Safety, since it can be unrelated particles when done through event
        m_ToxicClouds.Insert(p);
    }
  }
 
  int GetRequesterIndex(string type)
  {
    typename t = type.ToType();
    if (!t)
      return - 1;
    PPERequesterBase req = PPERequesterBank.GetRequester(t);
    if (req)
      return req.GetRequesterIDX();
    return -1;
  }
 
 
  // ----------------------------------------------
  // TRIGGER SETUP
  // ----------------------------------------------
 
  void CreateTrigger(vector pos, int radius)
  {
    // The trigger pos is based on lwer end, but we want to stretch downwards
    pos[1] = pos[1] - m_NegativeHeight;
 
    // Create new trigger of specified type
    if (Class.CastTo(m_Trigger, GetGame().CreateObjectEx(m_TriggerType, pos, ECE_NONE)))
    {
      // We finalize trigger dimension setup
      m_Trigger.SetCollisionCylinder(radius, (m_NegativeHeight + m_PositiveHeight));
 
      // If the trigger is lower in hierarchy and can see it's local effects customized, we pass the new parameters
      if (m_Trigger.IsInherited(EffectTrigger))
      {
        //Debug.Log("We override area local effects");
        EffectTrigger.Cast(m_Trigger).SetLocalEffects(m_AroundParticleID, m_TinyParticleID, m_PPERequesterIdx);
      }
      m_Trigger.Init(this, m_EffectsPriority);
      //Debug.Log("We created the trigger at : " + m_Trigger.GetWorldPosition() );
    }
  }
 
  // ----------------------------------------------
  // AREA DELETION
  // ----------------------------------------------
 
  override void EEDelete(EntityAI parent)
  {
    if (m_Trigger)
      GetGame().ObjectDelete(m_Trigger);
 
    // We stop playing particles on this client when the base object is deleted ( out of range for example )
    if ((GetGame().IsClient() || !GetGame().IsMultiplayer()) && m_ToxicClouds)
    {
      foreach (Particle p : m_ToxicClouds)
        p.Stop();
    }
 
    super.EEDelete(parent);
  }
 
  void OnPlayerEnterServer(PlayerBase player, EffectTrigger trigger)
  {
    player.IncreaseEffectAreaCount();
  }
  void OnPlayerExitServer(PlayerBase player, EffectTrigger trigger)
  {
    player.DecreaseEffectAreaCount();
  }
 
}