trapbase.c

Go to the documentation of this file.

enum SoundTypeTrap
{
 ACTIVATING = 5,
}
 
class TrapBase extends ItemBase
{
 #ifdef SERVER
 protected const int SPAWN_FLAGS = ECE_CREATEPHYSICS;
 #else
 protected const int SPAWN_FLAGS = ECE_LOCAL;
 #endif
 
 protected const int DAMAGE_TRIGGER_MINE = 75;
 protected const float UPDATE_TIMER_INTERVAL = 0.05;
 
 float m_InitWaitTime; //After this time after deployment, the trap is activated
 bool m_NeedActivation; //If activation of trap is needed
 float m_DefectRate; //Added damage after trap activation
 float m_DamagePlayers; //How much damage player gets when caught
 float m_DamageOthers; //How much damage player gets when caught
 
 bool m_AddActivationDefect; // Damage trap after activation
 bool m_AddDeactivationDefect; // Damage trap after deactivation
 protected bool m_IsActive; // True means that the trap is ready to detonate
 protected bool m_IsInProgress;
 
 protected bool m_Disarmed = false; 
 
 bool m_WasActivatedOrDeactivated;
 
 string m_AnimationPhaseGrounded;
 string m_AnimationPhaseSet;
 string m_AnimationPhaseTriggered;
 
 string m_InfoSetup;
 string m_InfoDeactivated;
 string m_InfoDamageManipulation;
 string m_InfoDamage;
 string m_InfoActivationTime;
 
 protected ref Timer m_Timer;
 protected ref Timer m_UpdateTimer;
 protected TrapTrigger m_TrapTrigger;
 
 protected ref array<int> m_ClothingDmg;
 protected ref EffectSound m_DeployLoopSound; //DEPRECATED in favor of m_DeployLoopSoundEx
 
 void TrapBase()
 {
 m_IsInProgress = false;
 m_NeedActivation = true;
 m_InitWaitTime = 5; //After this time after deployment, the trap is activated
 m_DefectRate = 15; //Added damage after trap activation
 m_DamagePlayers = 25; //How much damage player gets when caught
 m_DamageOthers = 100; //How much damage others gets when caught
 
 m_AddActivationDefect = false;
 m_AddDeactivationDefect = false;
 
 m_WasActivatedOrDeactivated = false;
 
 m_AnimationPhaseGrounded = "";
 m_AnimationPhaseSet = "";
 m_AnimationPhaseTriggered = "";
 
 m_InfoSetup = "#STR_TrapBase0";
 m_InfoDeactivated = "#STR_TrapBase1";
 m_InfoDamageManipulation = "#STR_TrapBase2";
 m_InfoDamage = "#STR_TrapBase3";
 m_InfoActivationTime = "#STR_TrapBase4" + m_InitWaitTime.ToString() + "#STR_TrapBase5";
 
 m_UpdateTimer = new ref Timer(); 
 
 RegisterNetSyncVariableBool("m_IsActive");
 RegisterNetSyncVariableBool("m_IsInProgress");
 RegisterNetSyncVariableBool("m_IsSoundSynchRemote");
 RegisterNetSyncVariableBool("m_IsDeploySound"); 
 }
 
 void ~TrapBase()
 {
 SEffectManager.DestroyEffect( m_DeployLoopSound );
 }
 
 void OnUpdate(EntityAI victim);
 
 TrapTrigger GetTrapTrigger()
 {
 return m_TrapTrigger;
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 if (IsDeploySound())
 PlayDeploySound();
 
 if (CanPlayDeployLoopSound())
 PlayDeployLoopSound();
 
 if (m_DeployLoopSound && !CanPlayDeployLoopSound())
 StopDeployLoopSound();
 
 if (GetGame().IsMultiplayer())
 {
 if (m_IsActive && !m_IsInProgress)
 SetActive();
 
 if (m_IsInProgress && !m_IsActive)
 StartActivate(null);
 }
 }
 
 override void EEDelete(EntityAI parent)
 {
 super.EEDelete(parent);
 
 if (GetGame() && m_TrapTrigger)
 {
 GetGame().ObjectDelete(m_TrapTrigger);
 m_TrapTrigger = null;
 }
 }
 
 override void OnStoreSave(ParamsWriteContext ctx)
 {
 super.OnStoreSave(ctx);
 
 ctx.Write(m_IsActive);
 ctx.Write(m_IsInProgress);
 }
 
 //----------------------------------------------------------------
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 { 
 if ( !super.OnStoreLoad(ctx, version) )
 return false;
 
 bool b_is_active = false;
 if ( !ctx.Read( b_is_active ) )
 b_is_active = false;
 
 bool b_is_in_progress = false;
 if ( !ctx.Read( b_is_in_progress ) )
 b_is_in_progress = false;
 
 if ( b_is_active )
 {
 SetActive();
 }
 
 if (b_is_in_progress && !b_is_active)
 {
 StartActivate(null);
 }
 
 return true;
 }
 
 bool IsActive()
 {
 return m_IsActive && m_IsInProgress == false && GetHierarchyRootPlayer() == null;
 }
 
 bool IsInactive()
 {
 return !IsActive() && m_IsInProgress == false && GetHierarchyRootPlayer() == null;
 }
 
 // trap cannot be taken when is activated
 override bool IsTakeable()
 {
 if ( m_IsInProgress == false && !IsActive() )
 {
 return true;
 }
 
 return false;
 }
 
 bool IsActivable()
 {
 return !IsActive() && GetHierarchyRootPlayer() == null && GetHierarchyParent() == null && m_IsInProgress == false && !IsRuined() && m_NeedActivation;
 }
 
 bool IsPlaceable()
 {
 if ( GetHierarchyRootPlayer() != null && GetHierarchyRootPlayer().GetHumanInventory().GetEntityInHands() == this )
 {
 PlayerBase player = PlayerBase.Cast( GetHierarchyRootPlayer() );
 
 vector player_pos = player.GetPosition();
 vector aim_pos = player.GetAimPosition();
 
 if ( vector.DistanceSq( player_pos, aim_pos ) <= ( Math.SqrFloat( 1.5 ) ) )
 {
 return IsPlaceableAtPosition( aim_pos );
 }
 }
 
 return false;
 }
 
 bool IsPlaceableAtPosition( vector position )
 {
 if ( GetGame().SurfaceIsSea( position[0], position[2] ) )
 {
 return false;
 }
 else if ( GetGame().SurfaceIsPond( position[0], position[2] ) )
 {
 return false;
 }
 
 return true;
 }
 
 void Disarm()
 {
 SetInactive(false);
 RefreshState();
 GetGame().RPCSingleParam(this, ERPCs.RPC_TRAP_DISARM, null, true);
 
 OnDisarm();
 }
 
 void OnDisarm();
 
 void SnapOnObject(EntityAI victim)
 {
 if ( GetGame().IsServer() )
 {
 if ( m_Timer )
 {
 m_Timer.Stop();
 }
 
 RefreshState();
 
 if (m_DamagePlayers > 0)
 {
 if (victim)
 {
 if ( victim.IsInherited(SurvivorBase))
 {
 victim.DecreaseHealth("", "", m_DamagePlayers);
 }
 else if (victim.IsInherited(DayZCreatureAI))
 {
 victim.DecreaseHealth("", "", m_DamageOthers);
 }
 else if (victim.IsInherited(ItemBase))
 {
 ItemBase victim_item = ItemBase.Cast(victim);
 float damage_coef = 1;
 
 if (victim_item.HasQuantity() && victim_item.GetQuantityMax() != 0 && victim_item.GetQuantity() > 0)
 {
 damage_coef = victim_item.GetQuantityMax() / victim_item.GetQuantity(); // Lower quantity increases damage exposure
 }
 
 if (damage_coef > 0)
 {
 int item_size_x = 1;
 int item_size_y = 1;
 GetGame().GetInventoryItemSize(victim_item, item_size_x, item_size_y);
 
 float add_damage = 300 * damage_coef / Math.Clamp(item_size_x * item_size_y, 1, int.MAX);
 victim_item.DecreaseHealth("", "", add_damage);
 }
 }
 }
 }
 
 Synch(victim);
 }
 
 OnSteppedOn(victim);
 }
 
 void RemoveFromObject(EntityAI victim)
 {
 OnSteppedOut(victim);
 }
 
 void OnSteppedOn(EntityAI victim)
 {
 SetInactive(false);
 }
 
 void OnSteppedOut(EntityAI victim); 
 
 // Synchronizes states
 protected void Synch(EntityAI victim)
 {
 if (GetGame().IsServer())
 {
 if (victim && !victim.GetAllowDamage())
 return;
 
 Param1<EntityAI> p = new Param1<EntityAI>(victim);
 GetGame().RPCSingleParam(this, ERPCs.RPC_TRAP_VICTIM, p, true);
 }
 
 } 
 
 // On server -> client synchronization
 override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
 {
 super.OnRPC(sender, rpc_type, ctx);
 
 if ( !GetGame().IsDedicatedServer() )
 {
 switch (rpc_type)
 {
 case ERPCs.RPC_TRAP_VICTIM:
 Param1<EntityAI> victim = new Param1<EntityAI>(null);
 
 if (ctx.Read(victim))
 {
 if (victim.param1)
 SnapOnObject(victim.param1);
 }
 
 break;
 
 case ERPCs.RPC_TRAP_DISARM:
 OnDisarm();
 break;
 
 case SoundTypeTrap.ACTIVATING:
 
 Param1<bool> p = new Param1<bool>(false);
 
 bool isActivating = false;
 if (ctx.Read(p))
 isActivating = p.param1;
 
 if (isActivating)
 PlayDeployLoopSound();
 
 if (!isActivating)
 StopDeployLoopSound();
 
 break;
 }
 }
 }
 
 void RefreshState()
 {
 if ( !m_WasActivatedOrDeactivated )
 {
 return;
 }
 
 if ( GetGame().IsServer() )
 {
 // item is owned by player
 if ( GetHierarchyRootPlayer() != NULL && m_AnimationPhaseGrounded != "" )
 {
 SetAnimationPhase( m_AnimationPhaseSet, 1 );
 if ( m_AnimationPhaseTriggered != m_AnimationPhaseGrounded ) 
 {
 SetAnimationPhase( m_AnimationPhaseTriggered, 1 );
 }
 SetAnimationPhase( m_AnimationPhaseGrounded, 0 );
 }
 // item is set active
 else if ( IsActive() )
 {
 if ( m_AnimationPhaseGrounded != "" )
 {
 SetAnimationPhase( m_AnimationPhaseGrounded, 1 );
 }
 if ( m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "" )
 {
 SetAnimationPhase( m_AnimationPhaseTriggered, 1 );
 SetAnimationPhase( m_AnimationPhaseSet, 0 );
 }
 }
 // item is inactive and not owned by player (on the ground)
 else if ( IsInactive() )
 {
 if ( m_AnimationPhaseGrounded != "" && m_AnimationPhaseTriggered != m_AnimationPhaseGrounded )
 {
 SetAnimationPhase( m_AnimationPhaseGrounded, 1 );
 }
 if ( m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "" )
 {
 SetAnimationPhase( m_AnimationPhaseSet, 1 );
 SetAnimationPhase( m_AnimationPhaseTriggered, 0 );
 }
 }
 }
 }
 
 void SetupTrap()
 { 
 if (GetGame().IsServer())
 {
 if (GetHierarchyRootPlayer() && GetHierarchyRootPlayer().CanDropEntity(this))
 SetupTrapPlayer(PlayerBase.Cast(GetHierarchyRootPlayer()));
 }
 }
 
 void SetupTrapPlayer( PlayerBase player, bool set_position = true )
 { 
 if (GetGame().IsServer())
 {
 if (set_position)
 {
 player.LocalDropEntity(this);
 
 vector trapPos = player.GetDirection() * 1.5;
 trapPos[1] = 0;
 SetPosition(player.GetPosition() + trapPos);
 }
 
 if (m_NeedActivation == false)
 SetActive();
 }
 }
 
 void AddDefect()
 {
 if ( GetGame().IsServer() )
 {
 DecreaseHealth( "", "", m_DefectRate );
 }
 }
 
 void SetActive()
 {
 m_WasActivatedOrDeactivated = true;
 
 m_IsInProgress = false;
 m_IsActive = true;
 
 if (m_AddActivationDefect)
 {
 AddDefect();
 }
 
 if (GetGame().IsServer())
 {
 CreateTrigger();
 RefreshState();
 SetSynchDirty();
 }
 
 OnActivate();
 }
 
 void OnActivate();
 
 void StartActivate(PlayerBase player)
 {
 if (GetGame().IsServer())
 {
 m_Timer = new Timer(CALL_CATEGORY_SYSTEM);
 HideSelection("safety_pin");
 
 if (m_InitWaitTime > 0)
 {
 m_IsInProgress = true;
 m_Timer.Run(m_InitWaitTime, this, "SetActive");
 
 SetSynchDirty();
 }
 else
 SetActive();
 }
 }
 
 void StartDeactivate(PlayerBase player);
 
 void SetInactive(bool stop_timer = true)
 {
 m_WasActivatedOrDeactivated = true;
 
 m_IsActive = false;
 if (m_Timer && stop_timer)
 m_Timer.Stop();
 
 if (m_AddDeactivationDefect)
 AddDefect();
 
 SetSynchDirty(); 
 DeleteTrigger();
 RefreshState();
 }
 
 void CreateTrigger()
 {
 if (Class.CastTo(m_TrapTrigger, GetGame().CreateObjectEx("TrapTrigger", GetPosition(), SPAWN_FLAGS)))
 {
 vector mins = "-0.01 -0.05 -0.01";
 vector maxs = "0.01 0.5 0.01";
 m_TrapTrigger.SetOrientation(GetOrientation());
 m_TrapTrigger.SetExtents(mins, maxs);
 m_TrapTrigger.SetParentObject(this);
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(DeferredEnableTrigger);
 }
 }
 
 void DeleteTrigger()
 {
 if (m_TrapTrigger)
 { 
 m_TrapTrigger.SetParentObject(null);
 m_TrapTrigger.DeleteSafe();
 }
 }
 
 void DeferredEnableTrigger()
 {
 if (m_TrapTrigger)
 m_TrapTrigger.SetEnabled();
 }
 
 override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner) 
 {
 super.OnItemLocationChanged(old_owner, new_owner);
 
 if (GetGame().IsServer())
 {
 RefreshState();
 
 // TAKE ACTIVE TRAP FROM VICINITY 
 if (old_owner == NULL && new_owner != NULL && IsActive())
 {
 // TAKE INTO HANDS
 if ( new_owner.IsPlayer() )
 {
 SnapOnObject(new_owner);
 }
 else if (new_owner.GetHierarchyRootPlayer())
 {
 SnapOnObject(new_owner.GetHierarchyRootPlayer());
 }
 }
 }
 
 }
 
 override void EEItemAttached(EntityAI item, string slot_name)
 {
 super.EEItemAttached(item, slot_name);
 
 if (GetGame().IsServer())
 RefreshState();
 } 
 
 override void EEItemDetached(EntityAI item, string slot_name)
 {
 super.EEItemDetached(item, slot_name);
 
 if (GetGame().IsServer())
 RefreshState();
 }
 
 override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
 {
 super.OnPlacementComplete(player, position, orientation);
 
 if (GetGame().IsServer())
 {
 SetOrientation(orientation);
 SetPosition(position);
 PlaceOnSurface();
 SetSynchDirty();
 }
 }
 
 override bool CanPutInCargo( EntityAI parent )
 {
 if ( !super.CanPutInCargo(parent) )
 {
 return false;
 }
 
 return IsTakeable();
 }
 
 override bool CanPutIntoHands( EntityAI parent ) 
 {
 if ( !super.CanPutIntoHands( parent ) )
 {
 return false;
 }
 
 return IsTakeable();
 }
 
 override bool CanRemoveFromHands( EntityAI parent ) 
 {
 return IsTakeable();
 }
 
 override bool CanBePlaced( Man player, vector position )
 {
 return IsPlaceableAtPosition( position );
 }
 
 bool CanBeClapped()
 {
 return true;
 }
 
 //Set if trap can be disarmed using trap-specific action
 bool CanBeDisarmed()
 {
 return false;
 }
 
 void SetDisarmed( bool disarmed )
 {
 m_Disarmed = disarmed;
 }
 
 bool GetDisarmed()
 {
 return m_Disarmed;
 }
 
 //================================================================
 // ADVANCED PLACEMENT
 //================================================================
 
 void PlayDeployLoopSound(); //deprecated
 
 void StopDeployLoopSound(); //deprecated
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionActivateTrap);
 }
 
 // HELPERS
 protected EntityAI GetClosestCarWheel(EntityAI victim)
 {
 vector trapPosXZ = GetPosition();
 trapPosXZ[1] = 0;
 
 GameInventory inv = victim.GetInventory();
 for (int i = 0; i < inv.AttachmentCount(); i++)
 {
 EntityAI wheelEntity = inv.GetAttachmentFromIndex(i);
 if (wheelEntity && wheelEntity.Type() == CarWheel_Ruined)
 {
 continue;
 }
 
 int slotId;
 string slotName; 
 wheelEntity.GetInventory().GetCurrentAttachmentSlotInfo(slotId, slotName);
 slotName.ToLower();
 if (slotName.Contains("spare"))
 {
 continue
 }
 
 if (wheelEntity && wheelEntity.IsInherited(CarWheel))
 {
 vector entPosXZ = wheelEntity.GetPosition();
 entPosXZ[1] = 0;
 if (vector.Distance(trapPosXZ, entPosXZ) < 1)
 {
 return wheelEntity;
 }
 }
 }
 
 return null;
 }
 
 protected void DamageClothing(PlayerBase player)
 {
 //Array used to find all relevant information about currently equipped clothes
 array<ClothingBase> equippedClothes = new array<ClothingBase>;
 
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("LEGS")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("BACK")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("VEST")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("HeadGear")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("Mask")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("BODY")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("FEET")));
 equippedClothes.Insert(ClothingBase.Cast(player.GetItemOnSlot("GLOVES")));
 
 //Damage all currently equipped clothes
 for (int i = 0; i < equippedClothes.Count(); i++)
 {
 //If no item is equipped on slot, slot is ignored
 if (equippedClothes[i] == null)
 {
 continue;
 }
 
 equippedClothes[i].DecreaseHealth(m_ClothingDmg[i], false);
 }
 }
}