trap_tripwire.c

Go to the documentation of this file.

// Wire type is used in the case of decrafting to give back the correct base Ingredient
enum eWireMaterial
{
 WIRE = 0,
 BARBED_WIRE = 1,
 ROPE = 2
}
 
class TripwireTrap : TrapBase
{
 // Current state of the tripwire
 static const int FOLDED = 3;
 static const int DEPLOYED = 2;
 static const int TRIGGERED = 1;
 
 int m_State = FOLDED;
 private int m_WireMaterial;
 
 protected bool m_ResultOfAdvancedPlacing;
 protected vector m_TriggerPosition;
 protected vector m_TriggerOrientation;
 
 void TripwireTrap()
 {
 m_DamagePlayers = 0; //How much damage player gets when caught
 m_InitWaitTime = 0.0; //After this time after deployment, the trap is activated
 m_DefectRate = 15;
 m_NeedActivation = false;
 m_AnimationPhaseGrounded = "inventory";
 m_AnimationPhaseSet = "placing";
 m_AnimationPhaseTriggered = "triggered";
 m_InfoActivationTime = string.Format("#STR_TripwireTrap0%1#STR_TripwireTrap1", m_InitWaitTime.ToString()); // nefunguje dynamicke vyrazy mimo funkcii 
 
 RegisterNetSyncVariableInt("m_State");
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 if ( IsPlaceSound() )
 {
 PlayPlaceSound();
 }
 }
 
 override void OnStoreSave(ParamsWriteContext ctx)
 {
 super.OnStoreSave(ctx);
 
 ctx.Write( m_State );
 }
 
 //----------------------------------------------------------------
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 { 
 if ( !super.OnStoreLoad(ctx, version) )
 return false;
 
 int state = FOLDED;
 if ( !ctx.Read( state ) )
 state = FOLDED;
 
 SetState( state );
 RefreshState();
 
 return true;
 }
 
 override void CreateTrigger()
 {
 m_TrapTrigger = TripWireTrigger.Cast(GetGame().CreateObjectEx("TripWireTrigger", GetPosition(), SPAWN_FLAGS));
 vector mins = "-0.75 0.3 -0.01";
 vector maxs = "0.75 0.32 0.01";
 m_TrapTrigger.SetOrientation(GetOrientation());
 m_TrapTrigger.SetExtents(mins, maxs);
 m_TrapTrigger.SetParentObject(this);
 
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(DeferredEnableTrigger);
 }
 
 override void OnSteppedOn(EntityAI victim)
 {
 if (!victim)
 {
 return;
 }
 
 if (!victim.GetAllowDamage())
 {
 return;
 }
 
 // We must deal some damage, here 5 shock as melee damage in order to trigger hit animation
 if (GetGame().IsServer())
 {
 victim.ProcessDirectDamage(DT_CLOSE_COMBAT, this, "", "TripWireHit", "0 0 0", 1);
 SetState(TRIGGERED);
 SetInactive(false);
 }
 
 // We play the trap trigger sound
 #ifndef SERVER
 EffectSound sound = SEffectManager.PlaySound("TripwireTrap_Trigger_SoundSet", GetPosition());
 sound.SetAutodestroy(true);
 #endif
 }
 
 override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
 {
 super.OnItemLocationChanged(old_owner, new_owner);
 
 PlayerBase player = PlayerBase.Cast(new_owner);
 if (player)
 {
 StartDeactivate(player);
 return;
 }
 }
 
 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
 {
 super.EEItemLocationChanged(oldLoc, newLoc);
 
 if (m_ResultOfAdvancedPlacing)
 {
 if (oldLoc.GetType() == InventoryLocationType.GROUND && newLoc.GetType() == InventoryLocationType.GROUND)
 {
 SetActive();
 m_TrapTrigger.SetPosition(m_TriggerPosition);
 m_TrapTrigger.SetOrientation(m_TriggerOrientation);
 }
 
 m_ResultOfAdvancedPlacing = false;
 }
 
 if (oldLoc.GetType() == InventoryLocationType.GROUND && newLoc.GetType() == InventoryLocationType.CARGO)
 {
 SetInactive();
 DeleteTrigger();
 SetState(FOLDED);
 RefreshState();
 }
 }
 
 override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
 {
 super.EEHealthLevelChanged(oldLevel, newLevel, zone);
 
 if (GetGame().IsServer())
 {
 if (newLevel == GameConstants.STATE_RUINED)
 {
 SetState(TRIGGERED);
 RefreshState();
 }
 }
 }
 
 override void SetInactive(bool stop_timer = true)
 {
 super.SetInactive(stop_timer);
 
 // de-attach attachments after "activating them"
 for (int att = 0; att < GetInventory().AttachmentCount(); att++)
 {
 ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(att));
 if (attachment)
 {
 if (attachment.IsLockedInSlot())
 {
 attachment.UnlockFromParent();
 }
 
 attachment.OnActivatedByItem(this);
 GetInventory().DropEntity(InventoryMode.SERVER, this, attachment);
 }
 }
 }
 
 void SetState(int state_ID)
 {
 m_State = state_ID;
 }
 
 int GetState()
 {
 return m_State;
 }
 
 void SetWireType( int wireType )
 {
 m_WireMaterial = wireType;
 }
 
 int GetWireType()
 {
 return m_WireMaterial;
 }
 
 
 override void RefreshState()
 {
 super.RefreshState();
 
 if (GetState() == FOLDED)
 {
 FoldTripWire();
 }
 }
 
 override void SetupTrapPlayer( PlayerBase player, bool set_position = true )
 {
 super.SetupTrapPlayer( player, set_position );
 SetState(DEPLOYED);
 }
 
 override void StartDeactivate(PlayerBase player)
 {
 super.StartDeactivate(player);
 
 DeleteTrigger();
 SetState(FOLDED);
 }
 
 // We do not want players to attach charges before trap is deployed
 override bool CanReceiveAttachment( EntityAI attachment, int slotId )
 {
 if ( GetState() != DEPLOYED )
 return false;
 
 return super.CanReceiveAttachment( attachment, slotId );
 }
 
 // As players cannot attch charges, we do not display the attachment slot before it is necessary
 override bool CanDisplayAttachmentSlot( int slot_id )
 {
 if ( GetState() != DEPLOYED )
 return false;
 
 return super.CanDisplayAttachmentSlot( slot_id );
 }
 
 override void EEItemAttached(EntityAI item, string slot_name)
 {
 super.EEItemAttached(item, slot_name);
 
 SetTakeable(false);
 }
 
 override void EEItemDetached(EntityAI item, string slot_name)
 {
 super.EEItemDetached(item, slot_name);
 
 SetTakeable(false);
 }
 
 override void EEKilled(Object killer)
 {
 if (m_TrapTrigger)
 {
 StartDeactivate(null);
 }
 
 super.EEKilled(killer);
 }
 
 // We reset the animation phases to see the tripwire as folded
 void FoldTripWire()
 {
 if ( m_AnimationPhaseGrounded != "" )
 {
 SetAnimationPhase( m_AnimationPhaseSet, 1 );
 
 if ( m_AnimationPhaseTriggered != m_AnimationPhaseGrounded ) 
 {
 SetAnimationPhase( m_AnimationPhaseTriggered, 1 );
 }
 
 SetAnimationPhase( m_AnimationPhaseGrounded, 0 );
 }
 }
 
 override void OnInventoryEnter( Man player )
 {
 SetState( FOLDED );
 }
 
 #ifdef PLATFORM_WINDOWS
 // How one sees the tripwire when in vicinity
 override int GetViewIndex()
 {
 if ( MemoryPointExists( "invView2" ) )
 { 
 InventoryLocation il = new InventoryLocation;
 GetInventory().GetCurrentInventoryLocation( il );
 InventoryLocationType type = il.GetType();
 switch ( type )
 {
 case InventoryLocationType.CARGO:
 {
 return 0;
 }
 case InventoryLocationType.ATTACHMENT:
 {
 return 1;
 }
 case InventoryLocationType.HANDS:
 {
 return 0;
 }
 case InventoryLocationType.GROUND:
 {
 // Different view index depending on deployment state 
 if ( GetState() == DEPLOYED )
 return 1;
 else if ( GetState() == TRIGGERED )
 return 2;
 
 // When folded
 return 0;
 }
 case InventoryLocationType.PROXYCARGO:
 {
 return 0;
 }
 default:
 {
 if ( GetState() == DEPLOYED )
 return 1;
 else if ( GetState() == TRIGGERED )
 return 2;
 
 // When folded
 return 0;
 }
 }
 }
 return 0;
 }
 #endif
 
 //================================================================
 // ADVANCED PLACEMENT
 //================================================================
 
 // On placement complete, set state, play sound, create trigger and synch to client
 override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
 {
 SetIsPlaceSound(true);
 if (GetGame().IsServer())
 {
 SetState(DEPLOYED);
 
 m_TriggerPosition = position;
 m_TriggerOrientation = orientation;
 m_ResultOfAdvancedPlacing = true;
 }
 }
 
 override void OnPlacementCancelled(Man player)
 {
 super.OnPlacementCancelled(player);
 
 SetState(FOLDED);
 
 m_ResultOfAdvancedPlacing = false;
 }
 
 override bool IsDeployable()
 {
 return true;
 }
 
 // Tripwire cannot be taken if deployed with attachment
 override bool IsTakeable()
 {
 return GetState() != DEPLOYED || (GetInventory().AttachmentCount() == 0 && GetState() == DEPLOYED);
 }
 
 override string GetDeploySoundset()
 {
 return "tripwire_deploy_SoundSet";
 }
 
 override string GetLoopDeploySoundset()
 {
 return "tripwiretrap_deploy_SoundSet";
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionTogglePlaceObject);
 AddAction(ActionDeployObject);
 }
 
 // ====================================
 // =========== DEPRECATED ===========
 // ====================================
 
 void UpdateProxySelections()
 {
 if ( GetInventory().AttachmentCount() > 0)
 {
 ItemBase attachment = ItemBase.Cast( GetInventory().GetAttachmentFromIndex(0) );
 
 if ( attachment )
 {
 // Hide all proxies
 for (int i = 1; i <= 3; i++)
 {
 HideSelection("s" + i + "_charge");
 }
 
 // Now show the one we need to see
 string proxy_to_show = string.Format("s%1_charge", GetState() ); 
 //Print(proxy_to_show);
 ShowSelection( proxy_to_show );
 }
 }
 }
 
#ifdef DEVELOPER 
 //================================================================
 // DEBUG
 //================================================================
 
 //Debug menu Spawn Ground Special
 override void OnDebugSpawn()
 {
 SetState(DEPLOYED);
 StartActivate(null);
 }
 
 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
 {
 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ACTIVATE_ENTITY, "Activate", FadeColors.LIGHT_GREY));
 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DEACTIVATE_ENTITY, "Deactivate", FadeColors.LIGHT_GREY));
 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.LIGHT_GREY));
 
 super.GetDebugActions(outputList);
 }
 
 override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
 {
 if (super.OnAction(action_id, player, ctx))
 return true;
 if (GetGame().IsServer() || !GetGame().IsMultiplayer())
 {
 if (action_id == EActions.ACTIVATE_ENTITY)
 {
 StartActivate(null);
 }
 else if (action_id == EActions.DEACTIVATE_ENTITY)
 {
 SetInactive();
 }
 }
 return false;
 }
 
#endif
}
 
class TripwireTrapDeployed : TripwireTrap
{
 
}