DayZPlayerImplementMeleeCombat.c

Go to the documentation of this file.

enum EMeleeHitType
{
  NONE = -1,
 
  LIGHT,
  HEAVY,
  SPRINT,
  KICK,
  FINISHER_LIVERSTAB,
  FINISHER_NECKSTAB,
  FINISHER_GENERIC,
 
  WPN_HIT,
  WPN_HIT_BUTTSTOCK,
  WPN_STAB,
  WPN_STAB_FINISHER,
}
 
class DayZPlayerImplementMeleeCombat
{
  protected const float TARGETING_ANGLE_NORMAL = 30.0; 
  protected const float TARGETING_ANGLE_SPRINT = 15.0; 
  protected const float TARGETING_MIN_HEIGHT = -2.0; 
  protected const float TARGETING_MAX_HEIGHT = 2.0; 
  protected const float TARGETING_RAY_RADIUS_EX = 0.5; 
  protected const float TARGETING_RAY_RADIUS = 0.25; 
  protected const float TARGETING_RAY_DIST = 5.0; 
  protected const float TARGETING_RAY_DIST_SHORT = 2.0; 
 
  protected const float RANGE_EXTENDER_NORMAL = 0.65; 
  protected const float RANGE_EXTENDER_SPRINT = 1.35; 
 
  protected const string DEFAULT_HIT_ZONE = "Torso"; 
 
  protected ref MeleeTargeting m_MeleeTargeting; 
 
  protected Object m_TargetObject; 
  protected EMeleeTargetType m_TargetType; 
  protected ref array<Object> m_AllTargetObjects; 
 
#ifdef DIAG_DEVELOPER
  protected Object m_PreviousTargetObject; 
  protected ref array<Object> m_AllPreviousTargetObjects; 
#endif
 
  protected ref array<typename> m_TargetableObjects; 
  protected ref array<typename> m_NonAlignableObjects; 
  protected ref array<string> m_BlacklistedDamageZones; 
 
  protected DayZPlayerImplement m_DZPlayer; 
 
  protected InventoryItem m_Weapon; 
  protected int m_WeaponMode; 
  protected float m_WeaponRange; 
 
  protected bool m_ForceUntargetable; 
  protected bool m_SprintAttack; 
  protected bool m_WasHit; 
 
  protected vector m_RayStart; 
  protected vector m_RayEnd; 
  protected vector m_RayEndShort; 
 
  protected EMeleeHitType m_HitType; 
 
  protected int m_HitZoneIdx; 
  protected int m_FinisherType;
  protected string m_HitZoneName; 
  protected vector m_HitPositionWS; 
 
#ifdef DIAG_DEVELOPER
  protected int m_PreviousHitZoneIdx; 
  protected string m_PreviousHitZoneName; 
  protected vector m_PreviousHitPositionWS; 
#endif
 
  private int m_DebugForcedFinisherType;
 
  // ------------------------------------------------------------
  // CONSTRUCTOR
  // ------------------------------------------------------------
 
  void DayZPlayerImplementMeleeCombat(DayZPlayerImplement player)
  {
    Init(player);
  }
 
  void Init(DayZPlayerImplement player)
  {
    m_DZPlayer = player;
 
    m_MeleeTargeting = new MeleeTargeting;
 
    m_HitZoneName = "";
    m_HitZoneIdx = -1;
    m_FinisherType = -1;
    m_HitPositionWS = vector.Zero;
 
    m_SprintAttack = false;
    m_WasHit = false;
 
    m_TargetObject = null;
    m_TargetType = EMeleeTargetType.ALIGNABLE;
    m_AllTargetObjects = new array<Object>;
#ifdef DIAG_DEVELOPER
    m_AllPreviousTargetObjects = new array<Object>;
#endif
 
    m_DebugForcedFinisherType = -1;
 
    m_TargetableObjects = new array<typename>; //checks against CONFIG hierarchy
    m_TargetableObjects.Insert(DayZPlayer);
    m_TargetableObjects.Insert(DayZInfected);
    m_TargetableObjects.Insert(DayZAnimal);
 
    m_NonAlignableObjects = new array<typename>;
    m_NonAlignableObjects.Insert(Building);
    m_NonAlignableObjects.Insert(Car);
    m_NonAlignableObjects.Insert(CarWheel);
    m_NonAlignableObjects.Insert(CarDoor);
    m_NonAlignableObjects.Insert(TentBase);
    m_NonAlignableObjects.Insert(BaseBuildingBase);
 
    m_BlacklistedDamageZones = new array<string>;
    m_BlacklistedDamageZones.Insert("Brain");
  }
 
  void ~DayZPlayerImplementMeleeCombat() {}
 
  // ------------------------------------------------------------
  // PUBLIC
  // ------------------------------------------------------------
 
  EMeleeHitType GetHitType()
  {
    return m_HitType;
  }
 
  void SetHitZoneIdx(int pHitZone)
  {
    m_HitZoneIdx = pHitZone;
  }
 
  EntityAI GetTargetEntity()
  {
    return EntityAI.Cast(m_TargetObject);
  }
 
  void SetTargetObject(Object pTarget)
  {
    m_TargetObject = pTarget;
  }
 
  int GetHitZoneIdx()
  {
    return m_HitZoneIdx;
  }
 
  vector GetHitPos()
  {
    return m_HitPositionWS;
  }
 
  void SetHitPos(vector pHitPos)
  {
    m_HitPositionWS = pHitPos;
  }
 
  int GetFinisherType()
  {
    return m_FinisherType;
  }
 
  void SetFinisherType(int pFinisherType)
  {
    m_FinisherType = pFinisherType;
  }
 
  int GetWeaponMode()
  {
    return m_WeaponMode;
  }
 
  void Reset(InventoryItem weapon, EMeleeHitType hitMask, bool wasHitEvent = false)
  {
    m_Weapon = weapon;
    m_HitType = hitMask;
    m_TargetType = EMeleeTargetType.ALIGNABLE;
    m_SprintAttack = hitMask == EMeleeHitType.SPRINT;
    m_WeaponMode = SelectWeaponMode(weapon);
    m_WeaponRange = GetWeaponRange(weapon, m_WeaponMode);
    m_WasHit = wasHitEvent;
 
#ifdef DIAG_DEVELOPER
    m_AllPreviousTargetObjects = m_AllTargetObjects;
#endif
    m_AllTargetObjects.Clear();
  }
 
  void ResetTarget()
  {
#ifdef DIAG_DEVELOPER
    m_PreviousTargetObject = m_TargetObject;
    m_PreviousHitPositionWS = m_HitPositionWS;
    m_PreviousHitZoneIdx = m_HitZoneIdx;
    m_PreviousHitZoneName = m_HitZoneName;
#endif
 
    InternalResetTarget();
  }
 
  void Update(InventoryItem weapon, EMeleeHitType hitMask, bool wasHitEvent = false)
  {
    Reset(weapon, hitMask, wasHitEvent);
 
#ifndef SERVER
    if (!ScriptInputUserData.CanStoreInputUserData())
    {
      //Error("DayZPlayerImplementMeleeCombat - ScriptInputUserData already posted");
      return;
    }
 
    TargetSelection();
    SetFinisherType(TrySelectFinisherType(weapon, GetTargetEntity()));
 
    if (GetGame().IsMultiplayer())
    {
      ScriptInputUserData ctx = new ScriptInputUserData();
      ctx.Write(INPUT_UDT_MELEE_TARGET);
      ctx.Write(m_TargetObject);
      ctx.Write(m_HitPositionWS);
      ctx.Write(m_HitZoneIdx);
      ctx.Write(m_FinisherType);
      ctx.Send();
    }
#endif
  }
 
  void CheckMeleeItem()
  {
    if (m_Weapon)
    {
      ItemBase item = ItemBase.Cast(m_Weapon.ProcessMeleeItemDamage(GetWeaponMode()));
 
      if (item && item.GetHierarchyRootPlayer())
        PlayerBase.Cast(item.GetHierarchyRootPlayer()).SetCheckMeleeItem(item);
      else if (m_Weapon && m_Weapon.GetHierarchyRootPlayer())
        PlayerBase.Cast(m_Weapon.GetHierarchyRootPlayer()).SetCheckMeleeItem(ItemBase.Cast(m_Weapon));
    }
  }
 
  // ------------------------------------------------------------
  // protected
  // ------------------------------------------------------------
 
  protected int SelectWeaponMode(InventoryItem weapon)
  {
    if (weapon)
    {
      if (weapon.IsInherited(Weapon))
      {
        switch (m_HitType)
        {
        case EMeleeHitType.WPN_HIT:
          return 0;
        case EMeleeHitType.WPN_HIT_BUTTSTOCK:
          return 1;
        case EMeleeHitType.WPN_STAB:
          return 2;
        }
      }
      else
      {
        switch (m_HitType)
        {
        case EMeleeHitType.LIGHT:
          return weapon.GetMeleeMode();
        case EMeleeHitType.HEAVY:
          return weapon.GetMeleeHeavyMode();
        case EMeleeHitType.SPRINT:
          return weapon.GetMeleeSprintMode();
        }
      }
    }
 
    switch (m_HitType)
    {
    case EMeleeHitType.HEAVY:
      return 1;
    case EMeleeHitType.SPRINT:
      return 2;
    }
 
    return 0; 
  }
 
  protected float GetWeaponRange(InventoryItem weapon, int weaponMode)
  {
    if (weapon)
      return weapon.GetMeleeCombatData().GetModeRange(weaponMode);
    else
      return m_DZPlayer.GetMeleeCombatData().GetModeRange(weaponMode);
  }
 
  protected float GetRange()
  {
    return m_WeaponRange + RANGE_EXTENDER_NORMAL;
  }
 
  protected float GetAngle()
  {
    if (m_SprintAttack)
      return TARGETING_ANGLE_SPRINT;
    else
      return TARGETING_ANGLE_NORMAL;
  }
 
  protected void TargetSelection()
  {
    // Prepare common variables
    PlayerBase player = PlayerBase.Cast(m_DZPlayer);
    vector pos = m_DZPlayer.GetPosition();
    vector rayStart = m_DZPlayer.GetBonePositionWS(m_DZPlayer.GetBoneIndexByName("Head"));
 
    vector cameraPos, cameraRot, cameraDir;
    m_DZPlayer.GetCurrentCameraTransform(cameraPos, cameraDir, cameraRot);
    vector dir = MiscGameplayFunctions.GetHeadingVector(player);
    dir[1] = cameraDir[1];
 
    // Calculate max distances
    float dist = GetRange();
    float angle = GetAngle();
    float dist2 = Math.SqrFloat(dist);
 
    // There's generally 2 TargetSelection calls per animation
    // First to obtain target to move towards during animation
    // Second one is to see if that target is still in range before applying damage to it
    // m_WasHit means the hit event occured, so this is the second call
 
    if (m_WasHit && GetFinisherType() == -1)
    {
      // See if the component is still in range
      if (CanObjectBeTargeted(m_TargetObject) && (vector.DistanceSq(rayStart, m_TargetObject.GetDamageZonePos(m_HitZoneName)) <= dist2))
      {
        m_AllTargetObjects.Insert(m_TargetObject);
        // This result should still be cached, so no need to fill it in again
        return;
      }
    }
 
    // Find a new target
    InternalResetTarget();
 
    Object target;
    vector hitPos;
    int hitZone;
 
    // First pass - Prefer what the player is looking at (only aligneable ones, we will try for nonaligneable later)
    if (HitZoneSelectionRaycastHelper(hitPos, hitZone, target))
    {
      if (m_ForceUntargetable)
      {
        SetTarget(target, hitPos, hitZone);
        return;
      }
 
      if (CanObjectBeTargeted(target) && vector.DistanceSq(rayStart, hitPos) <= dist2)
      {
        m_AllTargetObjects.Insert(target);
 
        SetTarget(target, hitPos, hitZone);
        return;
      }
    }
 
    // Second pass - Try to obtain something aligneable closeby the player watching direction
    MeleeTargetData targetData = m_MeleeTargeting.GetMeleeTargetEx(new MeleeTargetSettings(pos, dist * 0.75, angle, TARGETING_MIN_HEIGHT, TARGETING_MAX_HEIGHT, rayStart, dir, TARGETING_RAY_RADIUS_EX, m_DZPlayer, m_TargetableObjects), m_AllTargetObjects, m_BlacklistedDamageZones);
 
    if (targetData)
    {
      SetTarget(targetData.Obj, targetData.HitPos, targetData.HitComponent);
      return;
    }
 
    // Third pass - We found no aligneable target, check if the target that we are directly looking at is nonalignable (big)
    if (CanObjectBeTargeted(target, true) && vector.DistanceSq(rayStart, hitPos) <= dist2)
    {
      m_AllTargetObjects.Insert(target);
 
      SetTarget(target, hitPos, hitZone);
      return;
    }
  }
 
  protected int TrySelectFinisherType(InventoryItem weapon, EntityAI target)
  {
    if (m_WasHit)
      return -1;
 
    if (target)
    {
      vector dir = target.GetPosition() - m_DZPlayer.GetPosition();
 
      IEntity hitEntity;
      vector hitPos, hitNormal;
 
      float moveFraction = m_DZPlayer.CollisionMoveTest(dir, vector.Zero, 1.0, target, hitEntity, hitPos, hitNormal);
      if (moveFraction < 1.0)
        return -1;
    }
 
    if (target && target.CanBeBackstabbed() && weapon && (weapon.IsMeleeFinisher() || m_HitType == EMeleeHitType.WPN_STAB) && !weapon.IsRuined())
    {
      bool playGenericFinisherAnimation = false;
      ZombieBase targetZombie = ZombieBase.Cast(target);
      if (targetZombie && m_DebugForcedFinisherType == -1)
      {
        if (!IsEntityBehindEntityInAngle(m_DZPlayer, target, 60))
          return -1;
 
        int mindState = targetZombie.GetMindStateSynced();
        if (mindState >= DayZInfectedConstants.MINDSTATE_DISTURBED)
          return -1;
      }
 
      PlayerBase targetPlayer = PlayerBase.Cast(target);
      if (targetZombie)
        playGenericFinisherAnimation = targetZombie.IsCrawling();
      else if (targetPlayer)
        playGenericFinisherAnimation = targetPlayer.IsInProne();
      else
        playGenericFinisherAnimation = true;
 
      if (weapon.IsWeapon())
        return EMeleeHitType.WPN_STAB_FINISHER;
      else if (playGenericFinisherAnimation)
        return EMeleeHitType.FINISHER_GENERIC;
      else //specific hit depending on the component hit (gotten from the target)
        return DetermineSpecificFinisherType(ItemBase.Cast(weapon));
    }
 
    return -1;
  }
 
  protected int DetermineSpecificFinisherType(ItemBase weapon)
  {
    if (m_DebugForcedFinisherType > -1)
    {
      array<int> finishers = {
        EMeleeHitType.FINISHER_LIVERSTAB,
        EMeleeHitType.FINISHER_NECKSTAB
      };
 
      return finishers[m_DebugForcedFinisherType];
    }
 
    if (!weapon || !weapon.GetValidFinishers() || weapon.GetValidFinishers().Count() == 0)
      return EMeleeHitType.FINISHER_LIVERSTAB;
 
    PlayerBase player = PlayerBase.Cast(m_DZPlayer);
    int idx = Math.Round(Math.Lerp(0, weapon.GetValidFinishers().Count() - 1, player.GetRandomGeneratorSyncManager().GetRandom01(RandomGeneratorSyncUsage.RGSGeneric)));
    return weapon.GetValidFinishers()[idx];
  }
 
  protected void InternalResetTarget()
  {
    m_TargetObject = null;
    m_HitPositionWS = vector.Zero;
    m_HitZoneIdx = -1;
    m_HitZoneName = "";
    SetFinisherType(-1);
  }
 
  protected void SetTarget(Object obj, vector hitPos, int hitZone)
  {
    if (obj)
    {
      m_TargetObject = obj;
      m_HitPositionWS = hitPos;
      m_HitZoneIdx = hitZone;
      m_HitZoneName = m_TargetObject.GetDamageZoneNameByComponentIndex(m_HitZoneIdx);
    }
  }
 
  protected bool CanObjectBeTargeted(Object obj, bool checkNonAligneAble = false)
  {
    return obj && obj.IsAlive() && (obj.IsAnyInherited(m_TargetableObjects) || (checkNonAligneAble && obj.IsAnyInherited(m_NonAlignableObjects)));
  }
 
  protected bool HitZoneSelectionRaycastHelper(out vector hitPos, out int hitZone, out Object target)
  {
    return HitZoneSelectionRaycast(hitPos, hitZone, target, false);
    // Not sure if desired, as it can give some results that feel a little odd
    // But it will depend entirely on the player and situation..
    // I guess the crosshair is hidden while melee anyways though
    // || ( m_DZPlayer.IsInThirdPerson() && HitZoneSelectionRaycast(hitPos, hitZone, target, true);
  }
 
  protected bool HitZoneSelectionRaycast(out vector hitPos, out int hitZone, out Object target, bool useCamera)
  {
    PlayerBase player = PlayerBase.Cast(m_DZPlayer);
 
    vector pos;
    vector dir;
    vector playerDir;
    if (useCamera)
    {
      // What the player camera is looking at (crosshair)
      vector cameraRotation;
      player.GetCurrentCameraTransform(pos, dir, cameraRotation);
      playerDir = dir;
    }
    else
    {
      // What the player himself is looking at
      playerDir = MiscGameplayFunctions.GetHeadingVector(player);
      dir = GetGame().GetCurrentCameraDirection();
      MiscGameplayFunctions.GetHeadBonePos(player, pos);
    }
 
    if (vector.Dot(dir, playerDir) < 0.5)
      return false;
 
    m_RayStart = pos;
    m_RayEnd = m_RayStart + GetRange() * dir;
 
    // raycast
    set<Object> hitObjects = new set<Object>;
    vector hitNormal;
 
    if (DayZPhysics.RaycastRV(m_RayStart, m_RayEnd, hitPos, hitNormal, hitZone, hitObjects, null, player, false, false, ObjIntersectIFire) && hitObjects.Count() > 0)
    {
      target = hitObjects[0];
      m_ForceUntargetable = false;
 
      PlayerBase playerTarget = PlayerBase.Cast(target);
      if (playerTarget && playerTarget.IsInVehicle())
      {
        if (vector.DistanceSq(pos, hitPos) > Math.SqrFloat(GetRange() * 0.5))
        {
          m_ForceUntargetable = true;
          target = null;
          hitPos = vector.Zero;
          hitZone = -1;
        }
      }
 
      return true;
    }
 
    return false;
  }
 
  protected void HitZoneSelection()
  {
    Object cursorTarget = null;
    PlayerBase player = PlayerBase.Cast(m_DZPlayer);
 
    // ray properties
    vector pos;
    vector cameraDirection = GetGame().GetCurrentCameraDirection();
 
    MiscGameplayFunctions.GetHeadBonePos(player, pos);
    m_RayStart = pos;
    m_RayEnd = pos + cameraDirection * TARGETING_RAY_DIST;
    m_RayEndShort = pos + cameraDirection * TARGETING_RAY_DIST_SHORT;
 
    // raycast
    set<Object> hitObjects = new set<Object>;
    int hitComponentIndex;
    float hitFraction;
    vector start, end, hitNormal, hitPosObstructed;
    PhxInteractionLayers collisionLayerMask = PhxInteractionLayers.DEFAULT;
 
    if (!DayZPhysics.RaycastRV(m_RayStart, m_RayEndShort, m_HitPositionWS, hitNormal, m_HitZoneIdx, hitObjects, null, player, false, false, ObjIntersectIFire) && !DayZPhysics.RaycastRV(m_RayStart, m_RayEnd, m_HitPositionWS, hitNormal, m_HitZoneIdx, hitObjects, null, player, false, false, ObjIntersectIFire, TARGETING_RAY_RADIUS))
    {
      m_HitZoneIdx = -1;
      //Print("HitZoneSelection failed");
    }
    else if (hitObjects.Count() > 0)
    {
      cursorTarget = hitObjects.Get(0);
 
      vector playerPos = m_DZPlayer.GetPosition();
      vector hitPos = m_HitPositionWS;
      playerPos[1] = 0;
      hitPos[1] = 0;
 
      if (cursorTarget.IsAnyInherited(m_NonAlignableObjects) && vector.Distance(playerPos, hitPos) <= GetWeaponRange(m_Weapon, GetWeaponMode()))
      {
        if (m_TargetObject == null)
          m_TargetObject = cursorTarget;
      }
 
      if (cursorTarget == m_TargetObject)
      {
        m_HitZoneName = cursorTarget.GetDamageZoneNameByComponentIndex(m_HitZoneIdx);
        //Print("hit object: " + m_TargetObject + " | component idx: " + m_HitZoneIdx + " | hitzone name: " + m_HitZoneName);
      }
      else
      {
        if (m_TargetObject == DayZInfected.Cast(m_TargetObject) || m_TargetObject == PlayerBase.Cast(m_TargetObject))
          m_HitZoneName = DEFAULT_HIT_ZONE; //Default to torso if no zone is targeted
      }
    }
    else
    {
      m_HitZoneIdx = -1;
      //Print("HitZoneSelection failed");
    }
  }
 
  protected bool IsObstructed(Object object)
  {
    // check direct visibility of object (obstruction check)
    PhxInteractionLayers collisionLayerMask = PhxInteractionLayers.BUILDING | PhxInteractionLayers.DOOR | PhxInteractionLayers.VEHICLE | PhxInteractionLayers.ROADWAY | PhxInteractionLayers.TERRAIN | PhxInteractionLayers.ITEM_SMALL | PhxInteractionLayers.ITEM_LARGE | PhxInteractionLayers.FENCE;
    int hitComponentIndex;
    float hitFraction;
    vector start, end, hitNormal, hitPosObstructed;
    Object hitObject = null;
    PlayerBase player = PlayerBase.Cast(m_DZPlayer);
 
    if (object)
    {
      MiscGameplayFunctions.GetHeadBonePos(player, start);
      end = start + MiscGameplayFunctions.GetHeadingVector(player) * vector.Distance(player.GetPosition(), object.GetPosition());
 
      if (end == start)
        return true; 
 
      return DayZPhysics.RayCastBullet(start, end, collisionLayerMask, null, hitObject, hitPosObstructed, hitNormal, hitFraction);
    }
 
    return false;
  }
 
  private bool IsEntityBehindEntityInAngle(EntityAI source, EntityAI target, float angle)
  {
    vector targetDirection = target.GetDirection();
    ZombieBase targetZombie;
    if (Class.CastTo(targetZombie, target))
    {
      targetDirection = Vector(targetZombie.GetOrientationSynced(), 0, 0);
      targetDirection = targetDirection.AnglesToVector();
    }
    vector toSourceDirection = (source.GetPosition() - target.GetPosition());
 
    targetDirection[1] = 0;
    toSourceDirection[1] = 0;
 
    targetDirection.Normalize();
    toSourceDirection.Normalize();
 
    float cosFi = vector.Dot(targetDirection, toSourceDirection);
    vector cross = targetDirection * toSourceDirection;
 
    int hitDir = Math.Acos(cosFi) * Math.RAD2DEG;
 
    if (cross[1] < 0)
      hitDir = -hitDir;
 
    return hitDir <= (-180 + angle) || hitDir >= (180 - angle);
  }
 
#ifdef DIAG_DEVELOPER
  // ------------------------------------------------------------
  // DEBUG
  // ------------------------------------------------------------
  protected ref array<Shape> dbgConeShapes = new array<Shape>();
  protected ref array<Shape> dbgTargets = new array<Shape>();
  protected ref array<Shape> hitPosShapes = new array<Shape>();
 
  void Debug(InventoryItem weapon, EMeleeHitType hitType)
  {
    CleanAllDebugShapes();
 
    if (!DiagMenu.GetBool(DiagMenuIDs.MELEE_DEBUG))
      return;
 
    if (DiagMenu.GetBool(DiagMenuIDs.MELEE_CONTINUOUS) && (!GetGame().IsMultiplayer() || !GetGame().IsServer()))
      Update(weapon, hitType);
 
    if (DiagMenu.GetBool(DiagMenuIDs.MELEE_SHOW_TARGETS))
      ShowDebugMeleeTarget();
 
    if (DiagMenu.GetBool(DiagMenuIDs.MELEE_DRAW_TARGETS))
      DrawDebugTargets();
 
    if (DiagMenu.GetBool(DiagMenuIDs.MELEE_DRAW_RANGE))
    {
      DrawDebugMeleeHitPosition();
      DrawDebugMeleeCone();
    }
 
    if (DiagMenu.GetBool(DiagMenuIDs.MELEE_DRAW_BLOCK_RANGE_AI))
      DrawDebugBlockCone(GameConstants.AI_MAX_BLOCKABLE_ANGLE, COLOR_GREEN);
 
    if (DiagMenu.GetBool(DiagMenuIDs.MELEE_DRAW_BLOCK_RANGE_PVP))
      DrawDebugBlockCone(GameConstants.PVP_MAX_BLOCKABLE_ANGLE, COLOR_YELLOW);
  }
 
  int DebugGetForcedFinisherType()
  {
    return m_DebugForcedFinisherType;
  }
 
  void DebugSetForcedFinisherType(int pFinisherType)
  {
    m_DebugForcedFinisherType = pFinisherType;
  }
 
  protected void ShowDebugMeleeTarget()
  {
    int windowPosX = 0;
    int windowPosY = 500;
 
    DbgUI.Begin("Melee Target", windowPosX, windowPosY);
    HumanCommandMelee2 hmc2 = m_DZPlayer.GetCommand_Melee2();
    if (hmc2)
      DbgUI.Text("Current combo: " + hmc2.GetComboCount());
 
    if (m_PreviousTargetObject)
    {
      DbgUI.Text("Previous Character: " + m_PreviousTargetObject.GetDisplayName());
      DbgUI.Text("Previous HitZone: " + m_PreviousHitZoneName + "(" + m_PreviousHitZoneIdx + ")");
      DbgUI.Text("Previous HitPosWS:" + m_PreviousHitPositionWS);
      DbgUI.Text("Previous Distance:" + vector.Distance(m_PreviousHitPositionWS, m_DZPlayer.GetPosition()));
    }
 
    if (m_TargetObject)
    {
      DbgUI.Text("Character: " + m_TargetObject.GetDisplayName());
      DbgUI.Text("HitZone: " + m_HitZoneName + "(" + m_HitZoneIdx + ")");
      DbgUI.Text("HitPosWS:" + m_HitPositionWS);
      DbgUI.Text("Distance:" + vector.Distance(m_HitPositionWS, m_DZPlayer.GetPosition()));
    }
    DbgUI.End();
  }
 
  protected void DrawDebugTargets()
  {
    DrawDebugTargetsHelper(m_AllPreviousTargetObjects, m_PreviousTargetObject, COLOR_RED_A, COLOR_YELLOW_A);
    DrawDebugTargetsHelper(m_AllTargetObjects, m_TargetObject, COLOR_RED, COLOR_YELLOW);
  }
 
  protected void DrawDebugTargetsHelper(array<Object> allTargets, Object target, int colorMainTarget, int colorTarget)
  {
    for (int i = 0; i < allTargets.Count(); ++i)
    {
      if (m_TargetObject && allTargets.Count())
      {
        Object obj = allTargets[i];
        vector w_pos = obj.GetPosition();
        // sphere pos tweaks
        vector w_pos_sphr = w_pos;
        w_pos_sphr[1] = w_pos_sphr[1] + 1.8;
        // line pos tweaks
        vector w_pos_lend = w_pos;
        w_pos_lend[1] = w_pos_lend[1] + 1.8;
 
        if (obj == m_TargetObject)
        {
          dbgTargets.Insert(Debug.DrawSphere(w_pos_sphr, 0.05, colorMainTarget, ShapeFlags.NOOUTLINE));
          dbgTargets.Insert(Debug.DrawLine(w_pos, w_pos_lend, colorMainTarget));
        }
        else
        {
          dbgTargets.Insert(Debug.DrawSphere(w_pos_sphr, 0.05, colorTarget, ShapeFlags.NOOUTLINE));
          dbgTargets.Insert(Debug.DrawLine(w_pos, w_pos_lend, colorTarget));
        }
      }
    }
  }
 
  protected void DrawDebugMeleeHitPosition()
  {
    if (m_PreviousTargetObject)
      hitPosShapes.Insert(Debug.DrawSphere(m_PreviousHitPositionWS, 0.15, COLOR_YELLOW_A, ShapeFlags.NOOUTLINE | ShapeFlags.TRANSP));
 
    if (m_TargetObject)
      hitPosShapes.Insert(Debug.DrawSphere(m_HitPositionWS, 0.15, COLOR_YELLOW, ShapeFlags.NOOUTLINE | ShapeFlags.TRANSP));
  }
 
  protected void DrawDebugMeleeCone()
  {
    // cone settings
    float dist = GetRange();
    vector start = m_DZPlayer.GetPosition();
 
    vector normDir = MiscGameplayFunctions.GetHeadingVector(PlayerBase.Cast(m_DZPlayer));
    normDir[1] = 0;
    normDir.Normalize();
    float playerAngle = -Math.Atan2(normDir[0], normDir[2]);
 
    dbgConeShapes.InsertArray(Debug.DrawCone(start, dist, GetAngle() * Math.DEG2RAD, playerAngle + Math.PI_HALF, COLOR_BLUE));
  }
 
  protected void DrawDebugBlockCone(float angle, int color)
  {
    // cone settings
    float dist = 3;
    vector start = m_DZPlayer.GetPosition();
 
    vector dir = GetGame().GetCurrentCameraDirection();
    dir[1] = 0;
    dir.Normalize();
    float playerAngle = -Math.Atan2(dir[0], dir[2]);
 
    dbgConeShapes.InsertArray(Debug.DrawCone(start, dist, angle * Math.DEG2RAD, playerAngle + Math.PI_HALF, color));
  }
 
  protected void CleanAllDebugShapes()
  {
    CleanupDebugShapes(dbgTargets);
    CleanupDebugShapes(dbgConeShapes);
    CleanupDebugShapes(hitPosShapes);
  }
 
  protected void CleanupDebugShapes(array<Shape> shapes)
  {
    for (int it = 0; it < shapes.Count(); ++it)
      Debug.RemoveShape(shapes[it]);
 
    shapes.Clear();
  }
#endif
}