Plastic_Explosive.c

Go to the documentation of this file.

class Plastic_Explosive : ExplosivesBase
{
  protected const string SLOT_TRIGGER = "TriggerRemoteDetonator_Receiver";
  protected const string ANIM_PHASE_TRIGGER_REMOTE = "TriggerRemote";
 
  protected bool m_UsedAsCharge;
 
  protected ref RemotelyActivatedItemBehaviour m_RAIB;
 
  void Plastic_Explosive()
  {
    m_RAIB = new RemotelyActivatedItemBehaviour(this);
 
    SetAmmoType("Plastic_Explosive_Ammo");
    SetParticleExplosion(ParticleList.PLASTIC_EXPLOSION);
 
    RegisterNetSyncVariableInt("m_RAIB.m_PairDeviceNetIdLow");
    RegisterNetSyncVariableInt("m_RAIB.m_PairDeviceNetIdHigh");
  }
 
  override void EOnInit(IEntity other, int extra)
  {
    if (!g_Game.IsMultiplayer())
      LockTriggerSlots();
  }
 
  override void EEKilled(Object killer)
  {
    //analytics (behaviour from EntityAI)
    GetGame().GetAnalyticsServer().OnEntityKilled(killer, this);
  }
 
  override bool HasLockedTriggerSlots()
  {
    return GetInventory().GetSlotLock(InventorySlots.GetSlotIdFromString(SLOT_TRIGGER));
  }
 
  override void LockTriggerSlots()
  {
    GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(SLOT_TRIGGER), true);
  }
 
  override void UnlockTriggerSlots()
  {
    GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(SLOT_TRIGGER), false);
  }
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
    if (version <= 134) // up to 1.21
    {
      int slotId = InventorySlots.GetSlotIdFromString(SLOT_TRIGGER);
      bool locked = GetInventory().GetSlotLock(slotId);
      while (locked)
      {
        GetInventory().SetSlotLock(slotId, false);
        locked = GetInventory().GetSlotLock(slotId);
      }
    }
 
    return true;
  }
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    LockTriggerSlots();
  }
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    if (m_RAIB)
      m_RAIB.OnVariableSynchronized();
 
    int slotId = InventorySlots.GetSlotIdFromString(SLOT_TRIGGER);
    UpdateVisuals(GetInventory().FindAttachment(slotId));
  }
 
  override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
  {
    super.EEItemLocationChanged(oldLoc, newLoc);
 
    if (m_RAIB)
      m_RAIB.Pair();
  }
 
  override bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    InventoryLocation il = new InventoryLocation();
    GetInventory().GetCurrentInventoryLocation(il);
    if (il.GetType() == InventoryLocationType.HANDS)
      return false;
 
    ClockBase timer = ClockBase.Cast(attachment);
    if (timer && !timer.IsAlarmOn())
      return false;
 
    return !GetArmed();
  }
 
  override bool CanDisplayAttachmentSlot(int slot_id)
  {
    string slotName = InventorySlots.GetSlotName(slot_id);
 
    switch (slotName)
    {
    case SLOT_TRIGGER:
      return FindAttachmentBySlotName(slotName) != null;
      break;
    }
 
    return true;
  }
 
  override bool IsTakeable()
  {
    return !GetArmed() && super.IsTakeable();
  }
 
  override bool IsDeployable()
  {
    return !GetArmed();
  }
 
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionTogglePlaceObject);
    AddAction(ActionDeployObject);
  }
 
  override void OnWasAttached(EntityAI parent, int slot_id)
  {
    super.OnWasAttached(parent, slot_id);
 
    m_UsedAsCharge = false;
 
    if (parent && parent.IsInherited(ExplosivesBase))
      m_UsedAsCharge = true;
  }
 
  override void OnWasDetached(EntityAI parent, int slot_id)
  {
    super.OnWasDetached(parent, slot_id);
 
    if (parent && !parent.IsInherited(ExplosivesBase))
      m_UsedAsCharge = false;
  }
 
  override bool EEOnDamageCalculated(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
  {
    if (damageType == DamageType.EXPLOSION)
      return !m_UsedAsCharge;
 
    return true;
  }
 
  override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
  {
    super.EEHealthLevelChanged(oldLevel, newLevel, zone);
 
    if (GetGame().IsServer())
    {
      if (newLevel == GameConstants.STATE_RUINED)
      {
        for (int attachmentIdx = 0; attachmentIdx < GetInventory().AttachmentCount(); attachmentIdx++)
        {
          ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(attachmentIdx));
          if (attachment)
          {
            attachment.UnlockFromParent();
            attachment.SetHealth("", "", 0.0);
          }
        }
 
        SetArmed(false);
        SetTakeable(true);
      }
    }
  }
 
  override RemotelyActivatedItemBehaviour GetRemotelyActivatedItemBehaviour()
  {
    return m_RAIB;
  }
 
  override void PairRemote(notnull EntityAI trigger)
  {
    m_RAIB.Pair(trigger);
  }
 
 
  override EntityAI GetPairDevice()
  {
    return m_RAIB.GetPairDevice();
  }
 
  override bool CanBeArmed()
  {
    if (!super.CanBeArmed())
      return false;
 
    return HasLockedTriggerSlots() && !GetArmed();
  }
 
  override bool CanBeDisarmed()
  {
    return GetArmed();
  }
 
  override void OnActivatedByItem(notnull ItemBase item)
  {
    if (GetGame().IsServer())
    {
      if (GetHealthLevel("") == GameConstants.STATE_RUINED)
        return;
 
      if (item == this)
      {
        SetHealth("", "", 0.0);
        InitiateExplosion();
        return;
      }
 
      if (m_RAIB.IsPaired() && GetArmed())
      {
        if (GetPairDevice() == item)
        {
          SetHealth("", "", 0.0);
          InitiateExplosion();
        }
      }
    }
  }
 
  override void OnDisarmed(bool pWithTool)
  {
    super.OnDisarmed(pWithTool);
 
    UnpairRemote();
    UpdateVisuals(null);
 
    for (int att = 0; att < GetInventory().AttachmentCount(); att++)
    {
      ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(att));
      if (attachment)
      {
        attachment.UnlockFromParent();
        if (attachment.IsInherited(RemoteDetonator))
        {
          if (pWithTool)
          {
            GetInventory().DropEntity(InventoryMode.SERVER, this, attachment);
            attachment.SetHealth("", "", 0.0);
          }
          else
            attachment.Delete();
        }
      }
    }
 
    LockTriggerSlots();
    SetTakeable(true);
  }
 
  override void EEItemAttached(EntityAI item, string slot_name)
  {
    super.EEItemAttached(item, slot_name);
 
    if (slot_name == SLOT_TRIGGER)
      OnTriggerAttached(item);
  }
 
  override void EEItemDetached(EntityAI item, string slot_name)
  {
    super.EEItemDetached(item, slot_name);
 
    if (slot_name == SLOT_TRIGGER)
      OnTriggerDetached(item);
  }
 
  override void UpdateLED(int pState)
  {
    RemoteDetonatorReceiver receiver = RemoteDetonatorReceiver.Cast(FindAttachmentBySlotName(SLOT_TRIGGER));
    if (receiver)
      receiver.UpdateLED(pState, true);
  }
 
  protected void OnTriggerAttached(EntityAI entity)
  {
    Arm();
    UpdateVisuals(entity);
    UpdateLED(ERemoteDetonatorLEDState.LIT);
 
    for (int att = 0; att < GetInventory().AttachmentCount(); att++)
    {
      ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(att));
      if (attachment)
        attachment.LockToParent();
    }
  }
 
  protected void OnTriggerDetached(EntityAI entity)
  {
    UpdateVisuals(null);
    UpdateLED(ERemoteDetonatorLEDState.OFF);
  }
 
  protected void UpdateVisuals(EntityAI entity)
  {
    if (entity)
      SetAnimationPhase(ANIM_PHASE_TRIGGER_REMOTE, 0.0);
    else
      SetAnimationPhase(ANIM_PHASE_TRIGGER_REMOTE, 1.0);
  }
 
 
  override string GetDeploySoundset()
  {
    return "placeImprovisedExplosive_SoundSet";
  }
 
  override string GetLoopDeploySoundset()
  {
    return "improvisedexplosive_deploy_SoundSet";
  }
 
  override protected bool UsesGlobalDeploy()
  {
    return true;
  }
}
 
class Plastic_Explosive_Placing : Plastic_Explosive {}