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
}