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 {}