ExplosivesBase.c

Go to the documentation of this file.

class ExplosiveLight : PointLightBase
{
  protected static float m_DefaultBrightness = 10;
  protected static float m_DefaultRadius = 30;
 
  void ExplosiveLight()
  {
    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);
  }
}
 
class ExplosivesBase : ItemBase
{
  protected const string DEFAULT_AMMO_TYPE = "Explosion_NonLethal";
  protected const string ANIM_PHASE_VISIBILITY = "Visibility";
 
  protected bool m_Armed;
  protected bool m_Defused;
  protected ref array<string> m_AmmoTypes;
 
  protected ref Timer m_DeleteTimer;
 
  protected ExplosiveLight m_Light;
 
  protected Particle m_ParticleExplosion;
  protected ref array<ParticleSource> m_ParticleExplosionArr = {};
  protected int m_ParticleExplosionId;
  protected vector m_ParticlePosition;
  protected vector m_ParticleOrientation;
 
  void ExplosivesBase()
  {
    m_DeleteTimer = new Timer();
    m_AmmoTypes = new array<string>();
 
    SetAmmoType(DEFAULT_AMMO_TYPE);
    SetParticleExplosion(ParticleList.INVALID); 
    SetParticlePosition(WorldToModel(GetPosition()));
    SetParticleOrientation(vector.Zero);
 
    RegisterNetSyncVariableBool("m_Armed");
    RegisterNetSyncVariableBool("m_Defused");
  }
 
 
  override bool IsExplosive()
  {
    return true;
  }
 
  override void OnExplosionEffects(Object source, Object directHit, int componentIndex, string surface, vector pos, vector surfNormal, float energyFactor, float explosionFactor, bool isWater, string ammoType)
  {
    super.OnExplosionEffects(source, directHit, componentIndex, surface, pos, surfNormal, energyFactor, explosionFactor, isWater, ammoType);
 
    if (m_ParticleExplosionId > ParticleList.INVALID)
    {
      EntityAI parent = this;
      if (GetHierarchyParent())
        parent = GetHierarchyParent();
 
      ParticleSource p = ParticleManager.GetInstance().PlayOnObject(m_ParticleExplosionId, parent, m_ParticlePosition, m_ParticleOrientation);
      m_ParticleExplosionArr.Insert(p);
      m_ParticleExplosion = p;
    }
 
    CreateLight();
  }
 
  override void EEDelete(EntityAI parent)
  {
    super.EEDelete(parent);
 
    if (m_ParticleExplosion)
    {
      foreach (ParticleSource p : m_ParticleExplosionArr)
        DestroyParticle(p);
    }
  }
 
  override void EEKilled(Object killer)
  {
    super.EEKilled(killer);
 
    InitiateExplosion();
 
    UnpairRemote();
  }
 
  override void OnCEUpdate()
  {
    super.OnCEUpdate();
 
    if (!IsRuined() && GetArmed() && GetPairDevice())
    {
      if (vector.DistanceSq(GetPosition(), GetPairDevice().GetPosition()) <= Math.SqrFloat(UAMaxDistances.EXPLOSIVE_REMOTE_ACTIVATION))
      {
        UpdateLED(ERemoteDetonatorLEDState.LIT);
 
        return;
      }
    }
 
    UpdateLED(ERemoteDetonatorLEDState.OFF);
  }
 
  override void UnpairRemote()
  {
    if (GetRemotelyActivatedItemBehaviour())
    {
      if (GetPairDevice())
        GetPairDevice().UnpairRemote();
      GetRemotelyActivatedItemBehaviour().Unpair();
    }
 
  }
 
  override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
  {
    super.OnPlacementComplete(player, position, orientation);
 
    if (GetGame().IsServer())
    {
      SetOrientation(orientation);
      SetPosition(position);
      PlaceOnSurface();
    }
  }
 
  protected void CreateLight()
  {
    m_Light = ExplosiveLight.Cast(ScriptedLightBase.CreateLight(ExplosiveLight, GetPosition()));
  }
 
  protected void DestroyParticle(Particle p)
  {
#ifndef SERVER
    if (p != null)
      p.Stop();
#endif
  }
 
  protected void InitiateExplosion()
  {
    int count = m_AmmoTypes.Count();
    for (int i = 0; i < count; i++)
      Explode(DamageType.EXPLOSION, m_AmmoTypes[i]);
 
    OnExplode();
  }
 
  protected void OnExplode()
  {
    if (GetGame().IsServer())
      m_DeleteTimer.Run(0.25, this, "DeleteSafe");
  }
 
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionAttach);
    AddAction(ActionDetach);
  }
 
  override bool IsInventoryVisible()
  {
    if (!super.IsInventoryVisible())
      return false;
 
    return GetAnimationPhase("Visibility") == 0;
  }
 
  override bool IsTakeable()
  {
    return super.IsTakeable() && GetAnimationPhase("Visibility") == 0;
  }
 
  bool IsTimerDetonable()
  {
    return false;
  }
 
  void Arm()
  {
    SetArmed(true);
 
    OnArmed();
  }
 
  void OnArmed();
 
  bool CanBeArmed()
  {
    return true;
  }
 
  void Disarm(bool pWithTool = false)
  {
    SetArmed(false);
 
    OnDisarmed(pWithTool);
  }
 
  void OnBeforeDisarm();
  void OnDisarmed(bool pWithTool);
 
  bool CanBeDisarmed()
  {
    return false;
  }
 
  bool GetArmed()
  {
    return m_Armed;
  }
 
  protected void SetArmed(bool state)
  {
    m_Armed = state;
    SetSynchDirty();
  }
 
  override bool CanPutInCargo(EntityAI parent)
  {
    if (!super.CanPutInCargo(parent))
      return false;
 
    return IsTakeable();
  }
 
  override bool CanPutIntoHands(EntityAI parent)
  {
    if (!super.CanPutIntoHands(parent))
      return false;
 
    return IsTakeable();
  }
 
  override bool CanRemoveFromHands(EntityAI parent)
  {
    return IsTakeable();
  }
 
  bool GetDefused()
  {
    return m_Defused;
  }
 
  protected void SetDefused(bool state)
  {
    m_Defused = state;
    SetSynchDirty();
  }
 
  void SetAmmoType(string pAmmoType)
  {
    SetAmmoTypes({pAmmoType});
  }
 
  void SetAmmoTypes(array<string> pAmmoTypes)
  {
    m_AmmoTypes.Clear();
    m_AmmoTypes = pAmmoTypes;
  }
 
  void SetParticleExplosion(int particle)
  {
    m_ParticleExplosionId = particle;
  }
 
  void SetParticlePosition(vector local_pos)
  {
    m_ParticlePosition = local_pos;
 
    if (GetHierarchyParent())
      m_ParticlePosition = GetHierarchyParent().WorldToModel(GetPosition());
  }
 
  void SetParticleOrientation(vector local_ori)
  {
    m_ParticleOrientation = local_ori;
 
    if (GetHierarchyParent())
      m_ParticleOrientation = GetHierarchyParent().WorldToModel(GetOrientation());
  }
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    ctx.Write(m_Armed);
  }
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
    if (version > 129)
    {
      bool armed = false;
      if (!ctx.Read(armed))
        return false;
 
      SetArmed(armed);
    }
 
    return true;
  }
 
  void UpdateLED(int pState);
  bool HasLockedTriggerSlots()
  {
    return false;
  }
 
  void LockTriggerSlots();
  void UnlockTriggerSlots();
 
  void LockExplosivesSlots();
  void UnlockExplosivesSlots();
 
}