barbedwire.c

Go to the documentation of this file.

class BarbedWire extends ItemBase
{
    // Sounds lists
    const static int        SOUNDS_SPARK_COUNT                          = 4;
    const static int        SOUNDS_CUT_COUNT                            = 3;
    const static int        SOUNDS_COLLISION_COUNT                      = 4;
    const static int        SOUNDS_SHOCK_COUNT                          = 4;
    const static float      RANDOM_SPARK_INTERVAL                       = 5.0; // TO DO! Currently not used.
    
    const static string         m_SoundsSpark[SOUNDS_SPARK_COUNT]           = {"electricFenceSpark1", "electricFenceSpark2", "electricFenceSpark3", "electricFenceSpark4"};
    const static string         m_SoundsCut[SOUNDS_CUT_COUNT]               = {"barbedFenceCut1", "barbedFenceCut2", "barbedFenceCut3"};
    const static string         m_SoundsCollision[SOUNDS_COLLISION_COUNT]   = {"barbedFenceCollision1", "barbedFenceCollision2", "barbedFenceCollision3", "barbedFenceCollision4"};
    const static string         m_SoundsShock[SOUNDS_SHOCK_COUNT]           = {"electricFenceShock1", "electricFenceShock2", "electricFenceShock3", "electricFenceShock4"};
    const static string         m_SoundBuzzLoop                             = "electricFenceBuzzLoop1";
    ref protected EffectSound   m_DeployLoopSound;
    
    SoundOnVehicle m_BuzzSoundLoop;
    
    ref Timer m_SparkEvent;
    protected ref AreaDamageManager m_AreaDamage;
    
    protected bool m_TriggerActive;
    protected bool m_IsPlaced;
    
    //mounting
    protected bool m_IsMounted;
    protected bool m_LastMountedState;
    const string                SOUND_MOUNT = "putDown_BarbedWire_SoundSet";
    protected EffectSound       m_MountSound;
    
    
    void BarbedWire()
    {
        m_SparkEvent    = new Timer( CALL_CATEGORY_SYSTEM );
        m_TriggerActive = false;
        m_IsPlaced      = false;
        
        //synchronized variables
        RegisterNetSyncVariableBool( "m_IsSoundSynchRemote" );  
        RegisterNetSyncVariableBool( "m_IsDeploySound" );
        RegisterNetSyncVariableBool( "m_IsMounted" );
    }
    
    void ~BarbedWire()
    {
        SEffectManager.DestroyEffect( m_DeployLoopSound );
    }
    
    override void EEInit()
    {
        super.EEInit();
    
        GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( UpdateAttachmentSlot, 100, false );
    }
    
    bool IsMounted()
    {
        return GetSlotLockedState();
    }
    
    protected bool GetSlotLockedState()
    {
        BaseBuildingBase base_building = BaseBuildingBase.Cast( GetHierarchyParent() );
        if ( base_building )
        {
            InventoryLocation inventory_location = new InventoryLocation;
            GetInventory().GetCurrentInventoryLocation( inventory_location );           
            return base_building.GetInventory().GetSlotLock( inventory_location.GetSlot() );
        }
        
        return false;   
    }
    
    void SetMountedState( bool is_mounted )
    {
        if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " SetMountedState mounted=" + is_mounted);
        
        //lock slot
        m_IsMounted = is_mounted;
        LockAttachmentSlot( is_mounted );
        SetTakeable( !is_mounted );
        
        //synchronize
        Synchronize();
    }
    
    protected void UpdateAttachmentSlot()
    {
        BaseBuildingBase base_building = BaseBuildingBase.Cast( GetHierarchyParent() );
        if ( base_building )
        {
            InventoryLocation inventory_location = new InventoryLocation;
            GetInventory().GetCurrentInventoryLocation( inventory_location );           
            bool is_mounted = base_building.GetInventory().GetSlotLock( inventory_location.GetSlot() );
            string slot_name = InventorySlots.GetSlotName( inventory_location.GetSlot() );
            
            base_building.UpdateAttachmentVisuals( slot_name, is_mounted );
            base_building.UpdateAttachmentPhysics( slot_name, is_mounted );
        }
    }
 
    protected void LockAttachmentSlot( bool lock_state )
    {
        BaseBuildingBase base_building = BaseBuildingBase.Cast( GetHierarchyParent() );
        if ( base_building )
        {
            InventoryLocation inventory_location = new InventoryLocation;
            GetInventory().GetCurrentInventoryLocation( inventory_location );           
            base_building.GetInventory().SetSlotLock( inventory_location.GetSlot(), lock_state );
            //string slot_name = InventorySlots.GetSlotName( inventory_location.GetSlot() );
            //base_building.UpdateAttachmentVisuals( slot_name, lock_state );
            //base_building.UpdateAttachmentPhysics( slot_name, lock_state );
        }
    }
        
    // --- SYNCHRONIZATION
    void Synchronize()
    {
        if ( GetGame().IsServer() )
        {
            SetSynchDirty();
        }
    }
    
    override void OnVariablesSynchronized()
    {
        super.OnVariablesSynchronized();
        
        if ( ( m_IsMounted && !m_LastMountedState ) || ( !m_IsMounted && m_LastMountedState ) )
        {
            //Play sound
            PlaySoundSet( m_MountSound, SOUND_MOUNT, 0.1, 0.1 );
        }
        m_LastMountedState = m_IsMounted;
        
        if ( IsDeploySound() )
        {
            PlayDeploySound();
        }
        
        if ( CanPlayDeployLoopSound() )
        {
            PlayDeployLoopSound();
        }
                    
        if ( m_DeployLoopSound && !CanPlayDeployLoopSound() )
        {
            StopDeployLoopSound();
        }
    }   
 
    void PlayDeployLoopSound()
    {       
        if ( !GetGame().IsDedicatedServer() )
        {       
            if ( !m_DeployLoopSound || !m_DeployLoopSound.IsSoundPlaying() )
            {
                m_DeployLoopSound = SEffectManager.PlaySound( GetLoopDeploySoundset(), GetPosition() );
            }
        }
    }
    
    void StopDeployLoopSound()
    {
        if ( !GetGame().IsDedicatedServer() )
        {   
            m_DeployLoopSound.SetSoundFadeOut(0.5);
            m_DeployLoopSound.SoundStop();
        }
    }
    
    // --- EVENTS
    override void OnStoreSave( ParamsWriteContext ctx )
    {   
        super.OnStoreSave( ctx );
    }
    
    override bool OnStoreLoad( ParamsReadContext ctx, int version )
    {
        if ( !super.OnStoreLoad( ctx, version ) )
            return false;
        
        //--- Barbed wire data ---
        //is mounted (removed in ver. 105)
        if ( version < 105 )
        {
            float is_mounted;
            if ( !ctx.Read( is_mounted ) )
            {
                return false;
            }           
        }
        //---
        
        return true;
    }
 
    override void AfterStoreLoad()
    {   
        super.AfterStoreLoad();
                
        //set mounted state based on locked slot after everything is loaded
        SetMountedState( GetSlotLockedState() );
    }
 
    // ---
    override void OnWorkStart()
    {
        SoundBuzzLoopStart();
        if (m_TriggerActive)
            { DestroyDamageTrigger(); }
 
        if (m_IsPlaced)
        {
            //TimerRandomSpark();
            CreateElectrifiedDamageTrigger();
        }
    }   
    
    override void OnWorkStop()
    {
        SoundBuzzLoopStop();
        if (m_TriggerActive)
            { DestroyDamageTrigger(); }
        
        if (m_IsPlaced)
            { CreateDamageTrigger(); }
        
        m_SparkEvent.Stop();
    }
 
    override void OnWork( float consumed_energy ) {}
 
    override void OnIsPlugged(EntityAI source_device)
    {
        SoundCut();
    }
 
    override void OnIsUnplugged( EntityAI last_energy_source )
    {
        if (m_TriggerActive)
            { DestroyDamageTrigger(); }
        SoundCut();
    }
    
    override void OnInventoryEnter(Man player)
    {
        super.OnInventoryEnter(player);
        HideSelection("placing");
        ShowSelection("zbytek");
        if (m_TriggerActive)
            { DestroyDamageTrigger(); }
        GetCompEM().UnplugThis();
        GetCompEM().UnplugAllDevices();
    }
    
    // Area Damage triggers
    // ---------------------------------------------------------            
    protected void CreateElectrifiedDamageTrigger()
    {
        m_AreaDamage = new AreaDamageRegular(this);
        m_AreaDamage.SetExtents("-1 0 -0.4", "1 0.7 0.4");
        m_AreaDamage.SetLoopInterval(0.3);
        m_AreaDamage.SetHitZones({"RightLeg", "LeftLeg", "RightFoot", "LeftFoot"});
        m_AreaDamage.SetAmmoName("BarbedWireHit");
        m_AreaDamage.Spawn();
        m_TriggerActive = true;
    }
    
    protected void CreateDamageTrigger()
    {
        m_AreaDamage = new AreaDamageOneTime(this);
        m_AreaDamage.SetExtents("-1 0 -0.4", "1 0.7 0.4");
        m_AreaDamage.SetHitZones({"RightLeg", "LeftLeg", "RightFoot", "LeftFoot"});
        m_AreaDamage.SetAmmoName("BarbedWireHit");
        m_AreaDamage.Spawn();
        m_TriggerActive = true;
    }
    
    protected void DestroyDamageTrigger()
    {
        m_AreaDamage.Destroy();
        m_TriggerActive = false;
    }
    // ---------------------------------------------------------
    
    // Controls spawn of random sparks
    /*
    protected void TimerRandomSpark() // TO DO: Come up with randomized functionality.
    {
        if ( GetCompEM().IsSwitchedOn() )
        {
            int plugged_devices = GetCompEM().GetEnergySource().GetCompEM().GetPluggedDevicesCount();
            float rnd_time = Math.RandomFloat(0.3, RANDOM_SPARK_INTERVAL / plugged_devices + 1.0);
            m_SparkEvent.Run(rnd_time + 0.3, this, "Spark", NULL, true);
        }
    }
    */
 
    // Spawns spark particle effect and plays sound.
    void Spark()
    {
        ParticleManager.GetInstance().PlayOnObject( ParticleList.BARBED_WIRE_SPARKS, this);
        SoundSpark();
    }
    
    
    // SOUNDS
    // ---------------------------------------------------------
    void SoundCut()
    {
        if ( !GetGame().IsServer()  ||  !GetGame().IsMultiplayer() ) // client side
        {
            int random_index = Math.RandomInt(0, SOUNDS_CUT_COUNT);
            string sound_type = m_SoundsCut[random_index];
            PlaySound(sound_type, 50);
        }
    }
 
    // Plays sound
    void SoundSpark()
    {
        if ( !GetGame().IsServer()  ||  !GetGame().IsMultiplayer() ) // client side
        {
            int random_index = Math.RandomInt(0, SOUNDS_SPARK_COUNT);
            string sound_type = m_SoundsSpark[random_index];
            PlaySound(sound_type, 50);
        }
    }
 
    // Plays sound
    void SoundBuzzLoopStart()
    {
        if ( !GetGame().IsServer()  ||  !GetGame().IsMultiplayer() ) // client side
        {
            if (!m_BuzzSoundLoop)
            {
                m_BuzzSoundLoop = PlaySoundLoop(m_SoundBuzzLoop, 50);
            }
        }
    }
 
    // Stops sound
    void SoundBuzzLoopStop()
    {
        if ( !GetGame().IsServer()  ||  !GetGame().IsMultiplayer() ) // client side
        {
            if (m_BuzzSoundLoop)
            {
                GetGame().ObjectDelete(m_BuzzSoundLoop);
                m_BuzzSoundLoop = NULL;
            }
        }
    }
    
    // Plays an electric shock sound
    void SoundElectricShock()
    {
        if ( !GetGame().IsServer()  ||  !GetGame().IsMultiplayer() ) // client side
        {
            int random_index = Math.RandomInt(0, SOUNDS_SHOCK_COUNT);
            string sound_type = m_SoundsShock[random_index];
            PlaySound(sound_type, 50);
        }
    }
    
    // Plays a collision sound
    void SoundCollision()
    {
        if ( !GetGame().IsServer()  ||  !GetGame().IsMultiplayer() ) // client side
        {
            int random_index = Math.RandomInt(0, SOUNDS_COLLISION_COUNT);
            string sound_type = m_SoundsCollision[random_index];
            PlaySound(sound_type, 50);
        }
    }
    // ---------------------------------------------------------
 
    // Area Damage Pre/Post actions 
    // ---------------------------------------------------------
    override void PreAreaDamageActions()
    {
        if ( GetCompEM().IsPlugged() && GetCompEM().IsSwitchedOn() )
        {
            Spark();
            SoundElectricShock();
        }
        SoundCollision();
    }
    
    override void PostAreaDamageActions() 
    {
        //dmg to barbed wire here
        MiscGameplayFunctions.DealAbsoluteDmg(this, 1000);
    }
    // ---------------------------------------------------------    
    
    
    // TODO: proper handling can be done once the ticket DAYZ-26145 is resolved
    override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
    {
        super.OnItemLocationChanged(old_owner, new_owner);
 
        if (m_TriggerActive)
        {
            DestroyDamageTrigger();
            m_IsPlaced = false;
        }
    }
    
    //================================================================
    // ADVANCED PLACEMENT
    //================================================================
    
    override void OnPlacementComplete( Man player, vector position = "0 0 0", vector orientation = "0 0 0" )
    {
        super.OnPlacementComplete( player, position, orientation );
        
        if ( GetGame().IsServer() )
        {
            ShowAllSelections();
            HideSelection("zbytek");
    
            if (!GetHierarchyParent())
            {
                if (GetCompEM().IsPlugged() && GetCompEM().IsWorking() )
                    { CreateElectrifiedDamageTrigger(); }
                else
                    { CreateDamageTrigger(); }
                m_IsPlaced = true;
            }
            
            SetIsDeploySound( true );
        }   
    }
    
    override string GetDeploySoundset()
    {
        return "placeBarbedWire_SoundSet";
    }
    
    override string GetLoopDeploySoundset()
    {
        return "barbedwire_deploy_SoundSet";
    }
    
    override void SetActions()
    {
        super.SetActions();
 
        AddAction(ActionRestrainTarget);
        AddAction(ActionRestrainSelf);
        AddAction(ActionAttachToConstruction);
        
    }   
}