improvisedexplosive.c

Go to the documentation of this file.

class ImprovisedExplosive : ExplosivesBase
{
 protected const float TIME_TRIGGER_INITIAL_DELAY_SECS = 0.1;
 protected const float TIME_TRIGGER_TIMER_BASED_DELAY_SECS = 1.0;
 protected const float TIME_TRIGGER_DELAY_SECS = 0.3;
 
 protected static const string SLOT_TRIGGER_ALARM_CLOCK = "TriggerAlarmClock";
 protected static const string SLOT_TRIGGER_KITCHEN_TIMER = "TriggerKitchenTimer";
 protected static const string SLOT_TRIGGER_REMOTE = "TriggerRemoteDetonator_Receiver";
 
 protected static const string SLOT_EXPLOSIVE_A = "IEDExplosiveA";
 protected static const string SLOT_EXPLOSIVE_B = "IEDExplosiveB";
 
 protected const int SLOT_EXPLOSIVE_COUNT = 2;
 protected const string SLOT_EXPLOSIVES[SLOT_EXPLOSIVE_COUNT] = {
 SLOT_EXPLOSIVE_A,
 SLOT_EXPLOSIVE_B
 };
 
 protected const int SLOT_TRIGGERS_COUNT = 3;
 protected const string SLOT_TRIGGERS[SLOT_TRIGGERS_COUNT] = {
 SLOT_TRIGGER_ALARM_CLOCK,
 SLOT_TRIGGER_KITCHEN_TIMER,
 SLOT_TRIGGER_REMOTE
 };
 
 protected const string ANIM_PHASE_TRIGGER_EMPTY = "TriggerEmpty";
 protected const string ANIM_PHASE_TRIGGER_TIMER = "TriggerTimer";
 protected const string ANIM_PHASE_TRIGGER_CLOCK = "TriggerClock";
 protected const string ANIM_PHASE_TRIGGER_REMOTE = "TriggerRemote";
 
 protected ref RemotelyActivatedItemBehaviour m_RAIB;
 
 void ImprovisedExplosive()
 {
 m_RAIB = new RemotelyActivatedItemBehaviour(this);
 
 RegisterNetSyncVariableInt("m_RAIB.m_PairDeviceNetIdLow");
 RegisterNetSyncVariableInt("m_RAIB.m_PairDeviceNetIdHigh");
 }
 
 override void EOnInit(IEntity other, int extra)
 {
 if (!g_Game.IsMultiplayer())
 LockTriggerSlots();
 }
 
 override bool HasLockedTriggerSlots()
 {
 foreach (string triggerSlot : SLOT_TRIGGERS)
 return GetInventory().GetSlotLock(InventorySlots.GetSlotIdFromString(triggerSlot));
 
 return false;
 }
 
 override void LockTriggerSlots()
 {
 foreach (string triggerSlotName : SLOT_TRIGGERS)
 GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(triggerSlotName), true);
 }
 
 override void UnlockTriggerSlots()
 {
 foreach (string triggerSlotName : SLOT_TRIGGERS)
 GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(triggerSlotName), false);
 }
 
 override void LockExplosivesSlots()
 { 
 foreach (string explosiveSlotName : SLOT_EXPLOSIVES)
 GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(explosiveSlotName), true);
 }
 
 override void UnlockExplosivesSlots()
 { 
 foreach (string explosiveSlotName : SLOT_EXPLOSIVES)
 GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString(explosiveSlotName), false);
 }
 
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 {
 if (!super.OnStoreLoad(ctx, version))
 return false;
 
 if (version <= 134) // up to 1.21
 {
 foreach (string triggerSlotName : SLOT_TRIGGERS)
 {
 int slotId = InventorySlots.GetSlotIdFromString(triggerSlotName);
 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();
 }
 
 
 foreach (string slotName : SLOT_TRIGGERS)
 {
 EntityAI trigger = GetInventory().FindAttachmentByName(slotName);
 if (trigger)
 {
 UpdateVisuals(trigger);
 break;
 }
 }
 }
 
 override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
 {
 super.OnPlacementComplete(player, position, orientation);
 
 if (GetGame().IsServer())
 {
 SetOrientation(vector.Up);
 }
 }
 
 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
 {
 super.EEItemLocationChanged(oldLoc, newLoc);
 
 if (m_RAIB)
 {
 m_RAIB.Pair();
 }
 }
 
 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 (GetArmed())
 return false;
 
 if (!HasLockedTriggerSlots())
 return false;
 
 foreach (string slotName : SLOT_EXPLOSIVES)
 {
 EntityAI explosive = GetInventory().FindAttachmentByName(slotName);
 if (explosive)
 return true;
 }
 
 return false;
 }
 
 override bool CanBeDisarmed()
 {
 return true;
 }
 
 
 override bool CanReceiveAttachment(EntityAI attachment, int slotId)
 {
 InventoryLocation il = new InventoryLocation();
 GetInventory().GetCurrentInventoryLocation(il);
 
 foreach (string slotName : SLOT_TRIGGERS)
 {
 if (slotId == InventorySlots.GetSlotIdFromString(slotName))
 {
 if (il.GetType() == InventoryLocationType.HANDS)
 return false;
 }
 }
 
 return !GetArmed();
 }
 
 override bool CanDisplayAttachmentSlot(int slot_id)
 {
 string slotName = InventorySlots.GetSlotName(slot_id);
 
 switch (slotName)
 {
 case SLOT_TRIGGER_ALARM_CLOCK:
 case SLOT_TRIGGER_KITCHEN_TIMER:
 case SLOT_TRIGGER_REMOTE:
 return FindAttachmentBySlotName(slotName) != null;
 break;
 }
 
 return true;
 }
 
 override bool IsTimerDetonable()
 {
 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 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 void OnActivatedByItem(notnull ItemBase item)
 {
 if (GetGame().IsServer() && GetArmed())
 {
 bool isTimeTriggered = false;
 
 array<ItemBase> attachmentsCache = new array<ItemBase>();
 for (int attachmentIdx = 0; attachmentIdx < GetInventory().AttachmentCount(); attachmentIdx++)
 {
 ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(attachmentIdx));
 if (attachment)
 attachmentsCache.Insert(attachment);
 }
 
 foreach (ItemBase attachment1 : attachmentsCache)
 attachment1.UnlockFromParent();
 
 foreach (ItemBase attachment2 : attachmentsCache)
 {
 if (attachment2.IsInherited(ClockBase))
 {
 isTimeTriggered = true;
 break;
 }
 }
 
 foreach (ItemBase attachment3 : attachmentsCache)
 {
 if (attachment3)
 {
 vector dropExtents = "0.5 0.0 0.5";
 if (isTimeTriggered)
 dropExtents[1] = 0.15; 
 
 GetInventory().DropEntityInBounds(InventoryMode.SERVER, this, attachment3, dropExtents, 0, 0, 0);
 attachment3.SetAnimationPhase(ANIM_PHASE_VISIBILITY, 1.0);
 attachment3.SetTakeable(false);
 }
 }
 
 float delayFor = TIME_TRIGGER_INITIAL_DELAY_SECS;
 if (isTimeTriggered)
 {
 delayFor = TIME_TRIGGER_INITIAL_DELAY_SECS + TIME_TRIGGER_TIMER_BASED_DELAY_SECS;
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(DeleteSafe, delayFor * 1000, false);
 }
 else
 {
 DeleteSafe();
 }
 
 foreach (ItemBase attachment4 : attachmentsCache)
 {
 if (attachment4.IsAnyInherited({RemoteDetonator, ClockBase}))
 {
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(attachment4.DeleteSafe, delayFor * 1000, false);
 }
 
 if (attachment4 && !attachment4.IsAnyInherited({RemoteDetonator, ClockBase}))
 {
 Param1<ItemBase> params = new Param1<ItemBase>(attachment4);
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLaterByName(attachment4, "OnActivatedByItem", delayFor * 1000, false, params);
 delayFor += TIME_TRIGGER_DELAY_SECS; 
 }
 }
 }
 }
 
 override protected void InitiateExplosion();
 
 override void EEItemAttached(EntityAI item, string slot_name)
 {
 super.EEItemAttached(item, slot_name);
 
 switch (slot_name)
 {
 case SLOT_TRIGGER_ALARM_CLOCK:
 case SLOT_TRIGGER_KITCHEN_TIMER:
 case SLOT_TRIGGER_REMOTE:
 OnTriggerAttached(FindAttachmentBySlotName(slot_name));
 break;
 }
 }
 
 override void EEItemDetached(EntityAI item, string slot_name)
 {
 super.EEItemDetached(item, slot_name);
 
 switch (slot_name)
 {
 case SLOT_TRIGGER_ALARM_CLOCK:
 case SLOT_TRIGGER_KITCHEN_TIMER:
 case SLOT_TRIGGER_REMOTE:
 OnTriggerDetached(FindAttachmentBySlotName(slot_name));
 break;
 }
 }
 
 override void OnBeforeDisarm()
 {
 UnlockExplosivesSlots();
 }
 
 override void OnDisarmed(bool pWithTool)
 {
 super.OnDisarmed(pWithTool);
 
 UnpairRemote();
 
 array<ItemBase> attachmentsCache = new array<ItemBase>();
 for (int attachmentIdx = 0; attachmentIdx < GetInventory().AttachmentCount(); attachmentIdx++)
 {
 ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(attachmentIdx));
 if (attachment)
 {
 attachmentsCache.Insert(attachment);
 } 
 }
 
 foreach (ItemBase attachment1 : attachmentsCache)
 attachment1.UnlockFromParent();
 
 foreach (ItemBase attachment2 : attachmentsCache)
 {
 if (attachment2.IsInherited(ClockBase))
 {
 if (pWithTool)
 GetInventory().DropEntity(InventoryMode.SERVER, this, attachment2);
 }
 
 if (attachment2.IsInherited(RemoteDetonator))
 {
 if (pWithTool)
 {
 GetInventory().DropEntity(InventoryMode.SERVER, this, attachment2);
 attachment2.SetHealth("", "", 0.0);
 }
 else
 {
 attachment2.Delete();
 }
 }
 }
 
 LockTriggerSlots();
 SetTakeable(true);
 }
 
 override void UpdateLED(int pState)
 {
 RemoteDetonatorReceiver receiver = RemoteDetonatorReceiver.Cast(FindAttachmentBySlotName(SLOT_TRIGGER_REMOTE));
 if (receiver)
 receiver.UpdateLED(pState, true);
 }
 
 protected void OnTriggerAttached(EntityAI entity)
 {
 UpdateVisuals(entity);
 UpdateLED(ERemoteDetonatorLEDState.LIT);
 
 if (entity.IsInherited(ClockBase))
 Arm();
 
 LockTriggerSlots();
 LockExplosivesSlots();
 }
 
 protected void OnTriggerDetached(EntityAI entity)
 {
 UpdateVisuals(null);
 UpdateLED(ERemoteDetonatorLEDState.OFF);
 }
 
 protected void UpdateVisuals(EntityAI entity)
 {
 if (entity)
 {
 if (entity.IsInherited(RemoteDetonator))
 {
 SetAnimationPhase(ANIM_PHASE_TRIGGER_EMPTY, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_TIMER, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_CLOCK, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_REMOTE, 0.0);
 }
 else if (entity.IsInherited(AlarmClock_ColorBase))
 {
 SetAnimationPhase(ANIM_PHASE_TRIGGER_EMPTY, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_TIMER, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_CLOCK, 0.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_REMOTE, 1.0);
 }
 else if (entity.IsInherited(KitchenTimer))
 {
 SetAnimationPhase(ANIM_PHASE_TRIGGER_EMPTY, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_TIMER, 0.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_CLOCK, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_REMOTE, 1.0);
 }
 }
 else
 {
 SetAnimationPhase(ANIM_PHASE_TRIGGER_EMPTY, 0.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_TIMER, 1.0);
 SetAnimationPhase(ANIM_PHASE_TRIGGER_CLOCK, 1.0);
 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;
 }
 
#ifdef DEVELOPER
 override protected string GetDebugText()
 {
 string debug_output;
 debug_output += string.Format("low net id: %1\n", m_RAIB.GetPairDeviceNetIdLow());
 debug_output += string.Format("high net id: %1\n", m_RAIB.GetPairDeviceNetIdHigh());
 debug_output += string.Format("pair device: %1\n", m_RAIB.GetPairDevice());
 
 return debug_output;
 }
#endif
}
 
class ImprovisedExplosivePlacing : ImprovisedExplosive {}