TrapSpawnBase.c

Go to the documentation of this file.

class TrapSpawnBase extends ItemBase
{
  int m_InitWaitTime; //After this time after deployment, the trap is activated
  int m_UpdateWaitTime; //Time when timer will be called again until success or not succes catch is done
  float m_DefectRate; //Added damage after trap activation
  bool m_IsFoldable;
  bool m_CanCatch = false;
  float m_MinimalDistanceFromPlayersToCatch;
 
  float m_BaitCatchProb; // The probability (0-100) to catch something when bait is attached
  float m_NoBaitCatchProb; // The probability (0-100) to catch something when no bait is attached
  float m_FinalCatchProb; // The selected catch probability (0-100) -> Will be overriden no need to allocate
 
  vector m_PreyPos; // The position where prey will be spawned -> Will be overriden later
 
  protected EntityAI m_Bait;
 
  protected bool m_IsActive;
  protected bool m_IsDeployed;
  protected bool m_IsInProgress;
 
  ref Timer m_Timer;
 
  string m_AnimationPhaseSet;
  string m_AnimationPhaseTriggered;
  string m_AnimationPhaseUsed;
 
  const string m_PlaceableWaterType 
  protected ref array<string> m_PlaceableWaterSurfaceList;
 
  bool m_WaterSurfaceForSetup; //if trap can be installed on water surface (cannot be detected via getsurfacetype)
  ref multiMap<string, float> m_CatchesPond; //array of catches that can be catched in trap - string key, float catch_chance
  ref multiMap<string, float> m_CatchesSea; //array of catches that can be catched in trap - string key, float catch_chance
  ref multiMap<string, float> m_CatchesGroundAnimal; //array of catches that can be catched in trap - string key, float catch_chance
 
  protected ref EffectSound m_DeployLoopSound;
 
  // ===============================================================
  // =====================  DEPRECATED  ============================
  // ===============================================================
  ref Timer m_PrevTimer;
  bool m_NeedInstalation;
  bool m_BaitNeeded;
  bool m_IsUsable;
  private ItemBase m_Catch;
  ref Timer m_AlignCatchTimer;
  string m_InfoSetup;
  // ===============================================================
 
  void TrapSpawnBase()
  {
    m_DefectRate = 10; //Added damage after trap activation
    m_UpdateWaitTime = 10;
    m_InitWaitTime = 10;
    m_NeedInstalation = true;
    m_BaitNeeded = true;
    m_IsFoldable = false;
    m_MinimalDistanceFromPlayersToCatch = 0;
 
    m_BaitCatchProb = 95;
    m_NoBaitCatchProb = 50;
 
    m_AnimationPhaseSet = "";
    m_AnimationPhaseTriggered = "";
    m_AnimationPhaseUsed = "";
 
    m_CatchesPond = NULL;
    m_CatchesSea = NULL;
    m_CatchesGroundAnimal = NULL;
 
    m_PlaceableWaterSurfaceList = new array<string>();
    m_PlaceableWaterSurfaceList.Insert(UAWaterType.SEA);
    m_PlaceableWaterSurfaceList.Insert(UAWaterType.FRESH);
 
    RegisterNetSyncVariableBool("m_IsSoundSynchRemote");
    RegisterNetSyncVariableBool("m_IsDeploySound");
    RegisterNetSyncVariableBool("m_IsActive");
    RegisterNetSyncVariableBool("m_IsDeployed");
  }
 
  void ~TrapSpawnBase()
  {
    SEffectManager.DestroyEffect(m_DeployLoopSound);
  }
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    ctx.Write(m_IsActive);
 
    ctx.Write(m_IsInProgress);
 
    ctx.Write(m_IsDeployed);
  }
 
  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;
 
    bool b_is_deployed = false;
    if (!ctx.Read(b_is_deployed))
      b_is_deployed = false;
 
    if (b_is_active)
      SetActive();
 
    if (b_is_in_progress && !b_is_active)
      StartActivate(NULL);
 
    SetDeployed(b_is_deployed);
 
    return true;
  }
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    if (IsDeploySound() && IsDeployed())
      PlayDeploySound();
 
    if (CanPlayDeployLoopSound())
      PlayDeployLoopSound();
 
    if (m_DeployLoopSound && !CanPlayDeployLoopSound())
      StopDeployLoopSound();
  }
 
  bool IsActive()
  {
    return m_IsActive;
  }
 
  bool IsDeployed()
  {
    return m_IsDeployed;
  }
 
  void SetDeployed(bool newState)
  {
    m_IsDeployed = newState;
 
    if (newState == true)
    {
      if (m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "")
      {
        SetAnimationPhase(m_AnimationPhaseSet, 1);
        SetAnimationPhase(m_AnimationPhaseTriggered, 0);
        SetAnimationPhase(m_AnimationPhaseUsed, 1);
      }
    }
    else
    {
      if (m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "")
      {
        SetAnimationPhase(m_AnimationPhaseSet, 0);
        SetAnimationPhase(m_AnimationPhaseTriggered, 1);
        SetAnimationPhase(m_AnimationPhaseUsed, 1);
      }
    }
 
    SetSynchDirty();
  }
 
  override bool IsTakeable()
  {
    return true;
  }
 
  bool IsPlaceableAtPosition(vector position)
  {
    string surface_type;
    GetGame().SurfaceGetType3D(position[0], position[1], position[2], surface_type);
 
    // check surface
    return GetGame().IsSurfaceDigable(surface_type);
  }
 
  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)
      {
        vector trapPos = player.GetPosition() + (player.GetDirection() * 0.5);
        trapPos[1] = GetGame().SurfaceRoadY(trapPos[0], trapPos[2]);
        SetPosition(trapPos);
      }
 
      SetDeployed(true);
    }
  }
 
  void Fold()
  {
    if (GetGame().IsServer() && m_IsFoldable == true)
      SetInactive();
  }
 
  // Deal damage to trap on specific events
  void AddDefect()
  {
    if (GetGame().IsServer())
      DecreaseHealth("", "", m_DefectRate);
  }
 
  void StartActivate(PlayerBase player) { }
 
  // IsTakeable is used to hide tooltips as well, so we use a custom method instead
  // Used to prevent players from taking traps which should be set for catching
  bool CanBeTaken()
  {
    if (!IsDeployed() || (GetInventory().AttachmentCount() == 0 && IsDeployed()))
      return true;
 
    return false;
  }
 
  override bool CanPutInCargo(EntityAI parent)
  {
    super.CanPutInCargo(parent);
    return CanBeTaken();
  }
 
  override bool CanPutIntoHands(EntityAI parent)
  {
    super.CanPutIntoHands(parent);
    return CanBeTaken();
  }
 
  // Set animation phases according to state
  void SetActive()
  {
    if (GetGame().IsServer() && !IsActive())
    {
      m_IsActive = true;
 
      if (m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "")
      {
        SetAnimationPhase(m_AnimationPhaseSet, 1);
        SetAnimationPhase(m_AnimationPhaseTriggered, 0);
        SetAnimationPhase(m_AnimationPhaseUsed, 1);
      }
 
      // When activated we start timer for catch check
      m_Timer = new Timer(CALL_CATEGORY_GAMEPLAY);
      m_Timer.Run(m_InitWaitTime, this, "SpawnCatch");
 
      SetSynchDirty();
    }
  }
 
  void SetInactive()
  {
    if (GetGame().IsServer())
    {
      // We stop timers as the trap is no longer active, then update visuals
      m_IsActive = false;
      if (m_Timer)
        m_Timer.Stop();
 
      SetDeployed(false);
 
      SetSynchDirty();
    }
  }
 
  void SetUsed()
  {
    if (GetGame().IsServer())
    {
      // We updated state, visuals and stop timers
      m_IsActive = false;
      m_IsDeployed = false;
      if (m_Timer)
        m_Timer.Stop();
 
      if (m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "")
      {
        SetAnimationPhase(m_AnimationPhaseSet, 1);
        SetAnimationPhase(m_AnimationPhaseTriggered, 1);
        SetAnimationPhase(m_AnimationPhaseUsed, 0);
      }
 
      SetSynchDirty();
    }
  }
 
  // Used to check catch conditions and spawn relevant prey
  void SpawnCatch()
  {
    // Only server side, let's make sure
    if (GetGame().IsClient())
      return;
 
    // If we can't get CEApi we won't be able to test proximity
    if (!GetCEApi())
      return;
 
    int i;
    m_Bait = null;
 
    // We check if we have bait and can catch
    m_CanCatch = SetCanCatch(m_Bait);
 
    SetIsDeploySound(false);
    SetSynchDirty();
 
    // We check the distance from players through CEApi if that check is enabled
    if (m_MinimalDistanceFromPlayersToCatch > 0)
    {
      if (!GetCEApi().AvoidPlayer(GetPosition(), m_MinimalDistanceFromPlayersToCatch) && m_CanCatch)
      {
        m_CanCatch = false;
 
        // We could not catch yet, let's retest until we can
        if (m_Timer)
          m_Timer.Stop();
 
        m_Timer = new Timer(CALL_CATEGORY_GAMEPLAY);
        m_Timer.Run(m_UpdateWaitTime, this, "SpawnCatch");
 
        return; // No need to go further, let's just wait for next check
      }
    }
 
    // We get the probability to catch depending on bait presence
    if (m_Bait)
      m_FinalCatchProb = m_BaitCatchProb;
    else
      m_FinalCatchProb = m_NoBaitCatchProb;
 
    // We get the position of prey when it will spawn
    m_PreyPos = GetPosition();
    if (MemoryPointExists("Prey_Position"))
      m_PreyPos = ModelToWorld(GetMemoryPointPos("Prey_Position"));
  }
 
  // Used to set if the given trap can catch a prey in it's current state
  // Also outs the current bait to check for specific catches if required
  bool SetCanCatch(out EntityAI bait)
  {
    int slotIdx = InventorySlots.GetSlotIdFromString("Trap_Bait");
    bait = GetInventory().FindAttachment(slotIdx);
 
    if (bait)
    {
      Edible_Base edibleBait = Edible_Base.Cast(bait);
      if (edibleBait)
      {
        if (!edibleBait.GetFoodStage().IsFoodBurned() && !edibleBait.GetFoodStage().IsFoodRotten())
          return true;
        else
          return false; // We have invalid bait, no catch
      }
    }
    // We are allowed to catch with no bait
    return true;
  }
 
  // Used to set the quantity of the catch ( later used when preparing fish )
  void CatchSetQuant(ItemBase catch)
  {
    if (catch.HasQuantity())
    {
      // Random quantity between 50% and 100%
      float coef = Math.RandomFloatInclusive(0.5, 1.0);
      float item_quantity = catch.GetQuantityMax() * coef;
      item_quantity = Math.Round(item_quantity);
      catch.SetQuantity(item_quantity);
    }
  }
 
  override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
  {
    super.OnItemLocationChanged(old_owner, new_owner);
 
    if (GetGame().IsServer())
    {
      // throw trap from vicinity if the trap does not need installation ( action required )
      if (new_owner == NULL && m_NeedInstalation == false)
        SetActive();
      else if (old_owner == NULL && new_owner != NULL)
      {
        if (m_IsFoldable)
          Fold();
        else
          SetInactive();
      }
    }
  }
 
  // Generic water check, no real distinction between pond or sea
  bool IsSurfaceWater(vector position)
  {
    string surfaceType;
    GetGame().SurfaceGetType3D(position[0], position[1], position[2], surfaceType);
 
    return Surface.AllowedWaterSurface(position[1] + 0.1, surfaceType, m_PlaceableWaterSurfaceList);
  }
 
  // Can only receive attachment if deployed
  override bool CanDisplayAttachmentSlot(int slot_id)
  {
    super.CanDisplayAttachmentSlot(slot_id);
    return IsDeployed();
  }
 
  override bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    super.CanReceiveAttachment(attachment, slotId);
    return IsDeployed();
  }
 
  override void EEItemAttached(EntityAI item, string slot_name)
  {
    super.EEItemAttached(item, slot_name);
 
    // In the case the trap was still deployed, enable "quick re-arm" by attaching
    if (IsDeployed() && slot_name == "Trap_Bait")
      SetActive();
  }
 
  //================================================================
  // 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())
    {
      vector rotation_matrix[3];
      float direction[4];
      Math3D.YawPitchRollMatrix(orientation, rotation_matrix);
      Math3D.MatrixToQuat(rotation_matrix, direction);
      InventoryLocation source = new InventoryLocation;
      InventoryLocation destination = new InventoryLocation;
 
      if (GetInventory().GetCurrentInventoryLocation(source))
      {
        destination.SetGroundEx(this, position, direction);
        if (GetGame().IsMultiplayer())
          player.ServerTakeToDst(source, destination);
        else // singleplayer
          player.GetInventory().TakeToDst(InventoryMode.LOCAL, source, destination);
      }
 
      SetupTrapPlayer(PlayerBase.Cast(player), false);
      SetIsDeploySound(true);
      SetActive();
    }
  }
 
  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();
    }
  }
 
  // We add the action to deploy a trap laid on ground
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionActivateTrap);
    AddAction(ActionDeployHuntingTrap);
  }
 
 
  // ===============================================================
  // =====================  DEPRECATED  ============================
  // ===============================================================
 
  bool CanPutInInventory(EntityAI player) { }
 
  void AlignCatch(ItemBase obj, string catch_name) { }
 
  bool IsPlaceable()
  {
    if (GetGame().IsServer())
    {
      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) <= (1.5 * 1.5))
          return IsPlaceableAtPosition(aim_pos);
      }
    }
 
    return false;
  }
 
  override bool CanBePlaced(Man player, vector position)
  {
    return IsPlaceableAtPosition(position);
  }
 
  // ===============================================================
}