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