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);
 
 } 
}