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