dayzplayermeleefightlogic_lightheavy.c

Go to the documentation of this file.

enum EFightLogicCooldownCategory
{
 EVADE = 0
}
 
class DayZPlayerMeleeFightLogic_LightHeavy
{
 const float EVADE_COOLDOWN = 0.5;
 
 //
 const float CLOSE_TARGET_DISTANCE = 1.5;
 
 const string DUMMY_LIGHT_AMMO = "Dummy_Light";
 const string DUMMY_HEAVY_AMMO = "Dummy_Heavy";
 
 protected PlayerBase m_Player;
 protected ref DayZPlayerImplementMeleeCombat m_MeleeCombat;
 protected EMeleeHitType m_HitType;
 protected ref map <int, ref Timer> m_CooldownTimers;
 protected Mission m_Mission;
 
 protected bool m_IsInBlock;
 protected bool m_IsEvading;
 
 protected bool m_IsInComboRange; 
 protected bool m_WasPreviousHitProcessed;
 
 void DayZPlayerMeleeFightLogic_LightHeavy(DayZPlayerImplement player)
 {
 Init(player);
 }
 
 void Init(DayZPlayerImplement player)
 {
 m_DZPlayer = player;
 m_Player = PlayerBase.Cast(player);
 m_MeleeCombat = m_Player.GetMeleeCombat();
 m_Mission = GetGame().GetMission();
 
 m_IsInBlock = false;
 m_IsEvading = false;
 m_WasPreviousHitProcessed = false;
 m_HitType = EMeleeHitType.NONE;
 
 RegisterCooldowns();
 }
 
 void ~DayZPlayerMeleeFightLogic_LightHeavy() {}
 
 bool IsInBlock()
 {
 return m_IsInBlock;
 }
 
 void SetBlock(bool block)
 {
 m_IsInBlock = block;
 }
 
 bool IsEvading()
 {
 return m_IsEvading;
 }
 
 bool GetCurrentHitType()
 {
 return m_HitType;
 }
 
 bool CanFight()
 {
 if (m_Player.IsEmotePlaying())
 return false;
 
 if (m_Player.GetActionManager() && m_Player.GetActionManager().GetRunningAction())
 return false;
 
 return true;
 }
 
 protected void RegisterCooldowns()
 {
 m_CooldownTimers = new map<int, ref Timer>();
 m_CooldownTimers.Insert(EFightLogicCooldownCategory.EVADE, new Timer(CALL_CATEGORY_SYSTEM)); // evades
 }
 
 protected EMeleeHitType GetAttackTypeFromInputs(HumanInputController pInputs)
 {
 if (pInputs.IsMeleeFastAttackModifier() && m_Player.CanConsumeStamina(EStaminaConsumers.MELEE_HEAVY))
 {
 return EMeleeHitType.HEAVY;
 }
 
 return EMeleeHitType.LIGHT;
 }
 
 protected EMeleeHitType GetAttackTypeByWeaponAttachments(EntityAI pEntity)
 {
 if (!m_Player.CanConsumeStamina(EStaminaConsumers.MELEE_HEAVY))
 {
 return EMeleeHitType.NONE;
 }
 
 if (pEntity.HasBayonetAttached())
 {
 return EMeleeHitType.WPN_STAB;
 }
 else if (pEntity.HasButtstockAttached())
 {
 return EMeleeHitType.WPN_HIT_BUTTSTOCK;
 }
 
 return EMeleeHitType.WPN_HIT;
 }
 
 protected float GetAttackTypeByDistanceToTarget(EntityAI pTarget, EMeleeTargetType pTargetType = EMeleeTargetType.ALIGNABLE)
 {
 if (pTargetType == EMeleeTargetType.NONALIGNABLE)
 {
 return 1.0;
 }
 
 if (IsShortDistance(pTarget, Math.SqrFloat(CLOSE_TARGET_DISTANCE)))
 {
 return 1.0;
 }
 
 return 0.0;
 }
 
 bool HandleFightLogic(int pCurrentCommandID, HumanInputController pInputs, EntityAI pEntityInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 {
 HumanInventoryWithFSM invFSM = HumanInventoryWithFSM.Cast(m_Player.GetHumanInventory());
 if (invFSM && !invFSM.IsIdle())
 return false;
 
 HumanCommandMove hcm = m_Player.GetCommand_Move();
 InventoryItem itemInHands = InventoryItem.Cast(pEntityInHands);
 bool isFireWeapon = itemInHands && itemInHands.IsWeapon();
 
 if (HandleHitEvent(pCurrentCommandID, pInputs, itemInHands, pMovementState, pContinueAttack))
 return false;
 
 if ((pInputs.IsAttackButtonDown() && !isFireWeapon) || (pInputs.IsMeleeWeaponAttack() && isFireWeapon) || (pContinueAttack && isFireWeapon))
 {
 //Debug.MeleeLog(m_Player, string.Format("HandleFightLogic[1] attackButtonDown=%1, meleeWeaponAttack=%2, pContinueAttack=%3, isFireWeapon=%4", pInputs.IsAttackButtonDown(), pInputs.IsMeleeWeaponAttack(), pContinueAttack, isFireWeapon));
 
 if (m_IsInBlock || m_IsEvading)
 return false;
 
 if (itemInHands && !itemInHands.IsMeleeWeapon() && !isFireWeapon)
 return false;
 
 if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_MOVE)
 {
 //Debug.MeleeLog(m_Player, "HandleFightLogic[1a]");
 if (isFireWeapon)
 {
 return HandleInitialFirearmMelee(pCurrentCommandID, pInputs, itemInHands, pMovementState, pContinueAttack);
 }
 else
 {
 if (pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDERECT)
 {
 return HandleInitialMeleeErc(pCurrentCommandID, pInputs, itemInHands, pMovementState, pContinueAttack);
 }
 else if (pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
 {
 return HandleProneKick(pCurrentCommandID, pInputs, itemInHands, pMovementState, pContinueAttack);
 }
 else if (pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_ERECT && m_Player.IsSprintFull())
 {
 return HandleSprintAttack(pCurrentCommandID, pInputs, itemInHands, pMovementState, pContinueAttack);
 }
 }
 }
 else if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_MELEE2)
 {
 m_IsInComboRange = m_Player.GetCommand_Melee2().IsInComboRange();
 if (m_IsInComboRange)
 {
 return HandleComboHit(pCurrentCommandID, pInputs, itemInHands, pMovementState, pContinueAttack);
 }
 }
 }
 else if (!isFireWeapon && pCurrentCommandID == DayZPlayerConstants.COMMANDID_MOVE)
 {
 if (pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDERECT)
 {
 int roll = pInputs.IsMeleeLREvade();
 if (roll != 0)
 {
 if (!m_Player.CanConsumeStamina(EStaminaConsumers.MELEE_EVADE))
 {
 return false;
 }
 
 float angle;
 if (roll == 1)
 {
 angle = -90; // left
 }
 else
 {
 angle = 90; // right
 }
 
 // start melee evade
 m_IsEvading = true;
 SetCooldown(EVADE_COOLDOWN, EFightLogicCooldownCategory.EVADE);
 hcm.StartMeleeEvadeA(angle);
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_EVADE);
 
 //Inflict shock when sidestepping with broken legs
 if (m_Player.GetBrokenLegs() == eBrokenLegs.BROKEN_LEGS)
 {
 m_Player.m_ShockHandler.SetShock(PlayerConstants.BROKEN_LEGS_LIGHT_MELEE_SHOCK);
 m_Player.m_ShockHandler.CheckValue(true);
 }
 }
 }
 
 if (pInputs.IsWeaponRaised() && pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_CROUCH)
 {
 //Debug.MeleeLog(m_Player, "HandleFightLogic[2b]");
 if (DayZPlayerUtils.PlayerCanChangeStance(m_Player, DayZPlayerConstants.STANCEIDX_RAISEDERECT))
 {
 //Debug.MeleeLog(m_Player, "HandleFightLogic[2c]");
 hcm.ForceStance(DayZPlayerConstants.STANCEIDX_RAISEDERECT);
 
 return false;
 }
 }
 
 if (!isFireWeapon && (pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDERECT || pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE))
 {
 float angle2;
 
 if (hcm.GetCurrentInputAngle(angle2) && (angle2 < -130.0 || angle2 > 130))
 {
 hcm.SetMeleeBlock(true);
 SetBlock(true);
 }
 else
 {
 hcm.SetMeleeBlock(false);
 SetBlock(false);
 }
 }
 else
 {
 hcm.SetMeleeBlock(false);
 SetBlock(false);
 }
 }
 
 return false;
 }
 
 protected bool HandleHitEvent(int pCurrentCommandID, HumanInputController pInputs, InventoryItem itemInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 {
 if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_MELEE2)
 {
 HumanCommandMelee2 hmc2a = m_Player.GetCommand_Melee2();
 if (hmc2a)
 {
 if (hmc2a.WasHit())
 {
 //Debug.MeleeLog(m_Player, "HandleHitEvent[START]");
 //Debug.MeleeLog(m_Player, string.Format("HandleHitEvent[1] target=%1, hitPos=%2, hitZoneIdx=%3, finisherType=%4", m_MeleeCombat.GetTargetEntity(), m_MeleeCombat.GetHitPos().ToString(), m_MeleeCombat.GetHitZoneIdx(), m_MeleeCombat.GetFinisherType()));
 if (m_MeleeCombat.GetFinisherType() == -1)
 {
 //Debug.MeleeLog(m_Player, string.Format("HandleHitEvent[2] target=%1, hitPos=%2, hitZoneIdx=%3, finisherType=%4", m_MeleeCombat.GetTargetEntity(), m_MeleeCombat.GetHitPos().ToString(), m_MeleeCombat.GetHitZoneIdx(), m_MeleeCombat.GetFinisherType()));
 m_MeleeCombat.Update(itemInHands, m_HitType, true);
 }
 
 EvaluateHit(itemInHands); 
 
 //Get gloves
 ClothingBase gloves;
 if (m_HitType == EMeleeHitType.KICK)
 {
 //We kick so "gloves" will be the shoes
 gloves = ClothingBase.Cast(m_Player.GetItemOnSlot("FEET"));
 }
 else
 {
 gloves = ClothingBase.Cast(m_Player.GetItemOnSlot("GLOVES"));
 }
 
 //If we hit something, inflict damage
 DamageHands(m_Player, gloves, itemInHands);
 
 m_MeleeCombat.ResetTarget();
 
 EnableControls();
 
 m_WasPreviousHitProcessed = true;
 
 //Debug.MeleeLog(m_Player, "HandleHitEvent[END]");
 
 return true;
 }
 }
 }
 
 return false;
 }
 
 protected bool HandleInitialFirearmMelee(int pCurrentCommandID, HumanInputController pInputs, InventoryItem itemInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 { 
 Weapon_Base weapon = Weapon_Base.Cast(itemInHands);
 if (weapon.IsWaitingForActionFinish())
 return false; 
 
 HumanCommandMove hcm = m_Player.GetCommand_Move();
 
 if (hcm.GetCurrentMovementSpeed() <= 2.05 && (pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDERECT || pContinueAttack) && !m_Player.IsFighting())
 {
 m_HitType = GetAttackTypeByWeaponAttachments(itemInHands);
 if ( m_HitType == EMeleeHitType.NONE )
 return false; 
 
 m_MeleeCombat.Update(itemInHands, m_HitType);
 
 EntityAI target;
 EMeleeTargetType targetType;
 GetTargetData(target, targetType);
 float attackByDistance = GetAttackTypeByDistanceToTarget(target, targetType);
 
 m_Player.StartCommand_Melee2(target, m_HitType == EMeleeHitType.WPN_STAB, attackByDistance, m_MeleeCombat.GetHitPos()); 
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_HEAVY);
 DisableControls();
 
 pContinueAttack = false; // reset continueAttack flag
 
 return true;
 } 
 else if ( pMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDCROUCH )
 {
 if (hcm)
 {
 hcm.ForceStance(DayZPlayerConstants.STANCEIDX_RAISEDERECT);
 pContinueAttack = true;
 return false;
 }
 }
 
 return false;
 }
 
 protected bool HandleInitialMeleeErc(int pCurrentCommandID, HumanInputController pInputs, InventoryItem itemInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 {
 //Debug.MeleeLog(m_Player, "HandleInitialMeleeErc[1]");
 
 m_HitType = GetAttackTypeFromInputs(pInputs);
 m_MeleeCombat.Update(itemInHands, m_HitType);
 
 //Debug.MeleeLog(m_Player, string.Format("HandleInitialMeleeErc[2] %1", EnumTools.EnumToString(EMeleeHitType, m_HitType)));
 
 EntityAI target;
 EMeleeTargetType targetType;
 GetTargetData(target, targetType);
 float attackByDistance = GetAttackTypeByDistanceToTarget(target, targetType);
 
 // finisher attack hittype override
 int finisherType = m_MeleeCombat.GetFinisherType();
 if (finisherType != -1)
 {
 int animationType = DetermineFinisherAnimation(finisherType);
 if (animationType > -1)
 {
 //Debug.MeleeLog(m_Player, string.Format("HandleInitialMeleeErc[3a] target=%1, finisherType=%2, animationType=%3, hitPositionWS=%4", target, finisherType, animationType, m_MeleeCombat.GetHitPos().ToString()));
 m_Player.StartCommand_Melee2(target, animationType, attackByDistance, m_MeleeCombat.GetHitPos());
 }
 else
 {
 //Debug.MeleeLog(m_Player, string.Format("HandleInitialMeleeErc[3b] target=%1, finisherType=%2, animationType=%3, hitPositionWS=%4", target, finisherType, (m_HitType == EMeleeHitType.HEAVY).ToString(), m_MeleeCombat.GetHitPos().ToString()));
 m_Player.StartCommand_Melee2(target, m_HitType == EMeleeHitType.HEAVY, attackByDistance, m_MeleeCombat.GetHitPos());
 }
 
 m_HitType = finisherType;
 target.SetBeingBackstabbed(finisherType);
 }
 else
 {
 //Debug.MeleeLog(m_Player, string.Format("HandleInitialMeleeErc[3d] target=%1, animationType=%2, hitPositionWS=%3", target, (m_HitType == EMeleeHitType.HEAVY).ToString(), m_MeleeCombat.GetHitPos().ToString()));
 m_Player.StartCommand_Melee2(target, m_HitType == EMeleeHitType.HEAVY, attackByDistance, m_MeleeCombat.GetHitPos());
 }
 
 if (m_HitType == EMeleeHitType.HEAVY)
 {
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_HEAVY);
 if (m_Player.GetBrokenLegs() == eBrokenLegs.BROKEN_LEGS)
 { 
 m_Player.m_ShockHandler.SetShock(PlayerConstants.BROKEN_LEGS_HEAVY_MELEE_SHOCK);
 m_Player.m_ShockHandler.CheckValue(true);
 }
 }
 else
 {
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_LIGHT);
 if (m_Player.GetBrokenLegs() == eBrokenLegs.BROKEN_LEGS)
 {
 m_Player.m_ShockHandler.SetShock(PlayerConstants.BROKEN_LEGS_LIGHT_MELEE_SHOCK);
 m_Player.m_ShockHandler.CheckValue(true);
 }
 } 
 
 m_WasPreviousHitProcessed = false;
 
 DisableControls();
 
 return true;
 }
 
 protected bool HandleProneKick(int pCurrentCommandID, HumanInputController pInputs, InventoryItem itemInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 {
 HumanCommandWeapons hcw = m_Player.GetCommandModifier_Weapons();
 
 float hcw_angle = hcw.GetBaseAimingAngleLR();
 if ( ( hcw_angle < -90 || hcw_angle > 90 ) && m_Player.GetBrokenLegs() != eBrokenLegs.BROKEN_LEGS )
 {
 // targetting
 m_HitType = EMeleeHitType.KICK;
 m_MeleeCombat.Update(itemInHands, m_HitType);
 
 EntityAI target;
 EMeleeTargetType targetType;
 GetTargetData(target, targetType);
 float attackByDistance = GetAttackTypeByDistanceToTarget(target, targetType);
 
 // command
 m_Player.StartCommand_Melee2(target, false, attackByDistance, m_MeleeCombat.GetHitPos());
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_HEAVY);
 DisableControls();
 
 return true;
 }
 
 return false;
 }
 
 protected bool HandleSprintAttack(int pCurrentCommandID, HumanInputController pInputs, InventoryItem itemInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 {
 m_HitType = EMeleeHitType.SPRINT;
 m_MeleeCombat.Update(itemInHands, m_HitType);
 
 EntityAI target;
 EMeleeTargetType targetType;
 GetTargetData(target, targetType);
 float attackByDistance = GetAttackTypeByDistanceToTarget(target, targetType);
 
 //Debug.MeleeLog(m_Player, string.Format("HandleSprintAttack[1] target=%1, animationType=%2, hitPositionWS=%3", target, false, m_MeleeCombat.GetHitPos().ToString()));
 m_Player.StartCommand_Melee2(target, false, attackByDistance, m_MeleeCombat.GetHitPos());
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_HEAVY);
 DisableControls();
 
 return true;
 }
 
 protected bool HandleComboHit(int pCurrentCommandID, HumanInputController pInputs, InventoryItem itemInHands, HumanMovementState pMovementState, out bool pContinueAttack)
 {
 //Debug.MeleeLog(m_Player, "HandleComboHit::");
 
 if (m_HitType == EMeleeHitType.NONE)
 return false;
 
 if (m_MeleeCombat.GetFinisherType() > -1)
 return false;
 
 EntityAI target;
 EMeleeTargetType targetType;
 GetTargetData(target, targetType);
 float attackByDistance = GetAttackTypeByDistanceToTarget(target, targetType);
 
 if (itemInHands && itemInHands.IsWeapon())
 {
 m_HitType = GetAttackTypeByWeaponAttachments(itemInHands); 
 }
 else
 {
 m_HitType = GetAttackTypeFromInputs(pInputs);
 }
 
 //Debug.MeleeLog(m_Player, string.Format("HandleComboHit:: %1", EnumTools.EnumToString(EMeleeHitType, m_HitType)));
 if (m_WasPreviousHitProcessed)
 {
 m_MeleeCombat.Update(itemInHands, m_HitType);
 }
 
 bool isHeavy = (m_HitType == EMeleeHitType.HEAVY || m_HitType == EMeleeHitType.WPN_STAB); 
 m_Player.GetCommand_Melee2().ContinueCombo(isHeavy, attackByDistance, target, m_MeleeCombat.GetHitPos()); 
 DisableControls();
 
 if (m_Player.GetBrokenLegs() == eBrokenLegs.BROKEN_LEGS)
 {
 float shock = PlayerConstants.BROKEN_LEGS_HEAVY_MELEE_SHOCK;
 
 if (!isHeavy)
 shock = PlayerConstants.BROKEN_LEGS_LIGHT_MELEE_SHOCK;
 
 m_Player.m_ShockHandler.SetShock(PlayerConstants.BROKEN_LEGS_HEAVY_MELEE_SHOCK);
 m_Player.m_ShockHandler.CheckValue(true);
 }
 
 switch (m_HitType)
 {
 case EMeleeHitType.HEAVY:
 case EMeleeHitType.SPRINT:
 case EMeleeHitType.WPN_STAB:
 case EMeleeHitType.WPN_HIT_BUTTSTOCK:
 case EMeleeHitType.WPN_HIT:
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_HEAVY);
 break;
 default:
 m_Player.DepleteStamina(EStaminaModifiers.MELEE_LIGHT);
 break;
 }
 
 m_IsInComboRange = false;
 
 return true;
 }
 
 protected void EvaluateHit(InventoryItem weapon)
 {
 EntityAI target = m_MeleeCombat.GetTargetEntity();
 
 if (target)
 {
 if (target.IsInherited(DayZPlayer))
 {
 EvaluateHit_Player(weapon, target);
 }
 else if (target.IsInherited(DayZInfected))
 {
 EvaluateHit_Infected(weapon, target);
 }
 else if (target.GetMeleeTargetType() == EMeleeTargetType.NONALIGNABLE)
 {
 EvaluateHit_NonAlignableObjects(weapon, target);
 }
 else
 {
 EvaluateHit_Common(weapon, target);
 }
 
 m_MeleeCombat.CheckMeleeItem();
 }
 }
 
 protected void EvaluateHit_Player(InventoryItem weapon, Object target)
 {
 int hitZoneIdx = m_MeleeCombat.GetHitZoneIdx();
 int weaponMode = m_MeleeCombat.GetWeaponMode();
 int forcedWeaponMode = -1;
 vector hitPosWS;
 bool forcedDummy = false;
 
 PlayerBase targetPlayer = PlayerBase.Cast(target);
 if (targetPlayer)
 {
 vector targetPos = targetPlayer.GetPosition();
 vector agressorPos = m_Player.GetPosition();
 
 // We get the angle from which an infected hit the blocking player
 float hitAngle = Math.RAD2DEG * Math.AbsFloat(Math3D.AngleFromPosition(targetPos, MiscGameplayFunctions.GetHeadingVector(targetPlayer), agressorPos));
 
 if (targetPlayer.GetMeleeFightLogic() && targetPlayer.GetMeleeFightLogic().IsInBlock() && hitAngle <= GameConstants.PVP_MAX_BLOCKABLE_ANGLE)
 {
 if (weaponMode > 0)
 {
 forcedWeaponMode = --weaponMode; // Heavy -> Light shift
 }
 else
 forcedDummy = true; // dummy hits, cannot shift lower than 0
 }
 }
 
 EvaluateHit_Common(weapon, target, forcedDummy, forcedWeaponMode);
 }
 
 protected void EvaluateHit_Infected(InventoryItem weapon, Object target)
 {
 //If the finisher attack haven't been performed, then use normal hit
 if (!EvaluateFinisherAttack(weapon, target))
 EvaluateHit_Common(weapon, target);
 }
 
 protected bool EvaluateFinisherAttack(InventoryItem weapon, Object target)
 {
 //Debug.MeleeLog(m_Player, string.Format("EvaluateFinisherAttack[1] target=%1, hitPos=%2, hitZoneIdx=%3, finisherType=%4", m_MeleeCombat.GetTargetEntity(), m_MeleeCombat.GetHitPos().ToString(), m_MeleeCombat.GetHitZoneIdx(), m_MeleeCombat.GetFinisherType()));
 
 if (m_MeleeCombat.GetFinisherType() > -1)
 {
 if (GetGame().IsServer())
 DamageSystem.CloseCombatDamage(m_Player, target, m_MeleeCombat.GetHitZoneIdx(), DetermineFinisherAmmo(m_MeleeCombat.GetFinisherType()), m_MeleeCombat.GetHitPos(), ProcessDirectDamageFlags.NO_ATTACHMENT_TRANSFER);
 
 return true;
 }
 
 return false;
 }
 
 protected void EvaluateHit_Common(InventoryItem weapon, Object target, bool forcedDummy=false, int forcedWeaponMode = -1)
 {
 int hitZoneIdx = m_MeleeCombat.GetHitZoneIdx();
 int weaponMode = m_MeleeCombat.GetWeaponMode();
 vector hitPosWS;
 string ammo;
 
 if (forcedWeaponMode > -1)
 weaponMode = forcedWeaponMode;
 
 EntityAI targetEntity = EntityAI.Cast(target);
 
 if (!DummyHitSelector(m_HitType, ammo) && !forcedDummy)
 {
 if (hitZoneIdx >= 0)
 {
 hitPosWS = targetEntity.ModelToWorld(targetEntity.GetDefaultHitPosition());
 
 if (WeaponDestroyedCheck(weapon, ammo))
 {
 DamageSystem.CloseCombatDamage(m_Player, target, hitZoneIdx, ammo, hitPosWS);
 //Debug.MeleeLog(m_Player, string.Format("EvaluateHit_Common[a]::CloseCombatDamage:: target: %1, hitzone: %2, ammo: %3", target, hitZoneIdx, ammo));
 }
 else
 {
 m_Player.ProcessMeleeHit(weapon, weaponMode, target, hitZoneIdx, hitPosWS);
 //Debug.MeleeLog(m_Player, string.Format("EvaluateHit_Common[b]::ProcessMeleeHit:: target: %1, hitzone: %2, meleeMode: %3, forcedWeaponMode:%4", target, hitZoneIdx, weaponMode));
 }
 }
 }
 else
 {
 if (GetGame().IsServer() && targetEntity)
 {
 DummyHitSelector(m_HitType, ammo);
 hitPosWS = targetEntity.ModelToWorld(targetEntity.GetDefaultHitPosition()); 
 DamageSystem.CloseCombatDamage(m_Player, target, hitZoneIdx, ammo, hitPosWS);
 //Debug.MeleeLog(m_Player, string.Format("EvaluateHit_Common[c]::CloseCombatDamage:: target: %1, hitzone: %2, meleeMode: %3, ammo: %4", target, hitZoneIdx, weaponMode, ammo));
 }
 }
 }
 
 protected void EvaluateHit_NonAlignableObjects(InventoryItem weapon, Object target)
 {
 int hitZoneIdx = m_MeleeCombat.GetHitZoneIdx();
 vector hitPosWS;
 string ammo;
 
 if (hitZoneIdx >= 0)
 {
 if (WeaponDestroyedCheck(weapon,ammo))
 DamageSystem.CloseCombatDamage(m_Player, target, hitZoneIdx, ammo, m_MeleeCombat.GetHitPos());
 else
 m_Player.ProcessMeleeHit(weapon, m_MeleeCombat.GetWeaponMode(), target, hitZoneIdx, m_MeleeCombat.GetHitPos());
 }
 
 return;
 }
 
 bool WeaponDestroyedCheck(InventoryItem weapon, out string ammo)
 {
 if (!weapon)
 return false;
 
 Weapon_Base firearm = Weapon_Base.Cast(weapon);
 ItemBase bayonet = ItemBase.Cast(weapon.GetInventory().FindAttachment(weapon.GetBayonetAttachmentIdx()));
 
 if ( firearm && bayonet && bayonet.IsRuined() )
 {
 ammo = bayonet.GetRuinedMeleeAmmoType();
 return true;
 }
 else if (weapon.IsRuined())
 {
 ammo = weapon.GetRuinedMeleeAmmoType();
 return true;
 }
 else
 {
 return false;
 }
 }
 
 protected void GetTargetData(out EntityAI target, out EMeleeTargetType targetType)
 {
 target = m_MeleeCombat.GetTargetEntity();
 targetType = EMeleeTargetType.ALIGNABLE; 
 
 // If there is no hitzone defined, then we won't be able to hit the target anyways..
 if (m_MeleeCombat.GetHitZoneIdx() < 0)
 {
 target = null;
 }
 
 if ( target )
 {
 targetType = target.GetMeleeTargetType();
 }
 
 if ( targetType == EMeleeTargetType.NONALIGNABLE )
 {
 target = null;
 }
 }
 
 protected bool DummyHitSelector(EMeleeHitType hitType, out string ammoType)
 {
 switch (hitType)
 {
 case EMeleeHitType.KICK:
 ammoType = DUMMY_HEAVY_AMMO;
 return true;
 break;
 }
 
 ammoType = DUMMY_LIGHT_AMMO;
 
 return false;
 }
 
 protected bool IsBehindEntity(int angle, DayZPlayer source, Object target)
 {
 return false;
 }
 
 protected void SetCooldown(float time, EFightLogicCooldownCategory cooldownCategory)
 {
 if ( m_CooldownTimers.Get(cooldownCategory).IsRunning() )
 {
 m_CooldownTimers.Get(cooldownCategory).Stop();
 }
 
 Param1<int> param = new Param1<int>(cooldownCategory);
 m_CooldownTimers.Get(cooldownCategory).Run(time, this, "ResetCooldown", param);
 }
 
 protected void ResetCooldown(EFightLogicCooldownCategory cooldownCategory)
 {
 switch (cooldownCategory)
 {
 case EFightLogicCooldownCategory.EVADE:
 m_IsEvading = false;
 break;
 }
 }
 
 protected void EnableControls();
 protected void DisableControls();
 
 protected void DamageHands(DayZPlayer DZPlayer, ClothingBase gloves, InventoryItem itemInHands)
 {
 EntityAI target = m_MeleeCombat.GetTargetEntity();
 
 //We did not hit anything
 if (itemInHands || !target || !DZPlayer)
 return;
 
 //Check if server side
 if (GetGame().IsServer())
 {
 int randNum;
 
 //If gloves, damage gloves
 if (gloves && gloves.GetHealthLevel() < GameConstants.STATE_RUINED)
 {
 gloves.DecreaseHealth("", "", 1);
 }
 else
 {
 //Do not add bleeding if hitting player, zombie or animal
 if (PlayerBase.Cast(target) || DayZCreatureAI.Cast(target))
 return;
 
 BleedingSourcesManagerServer bleedingManager;
 
 //We don't inflict bleeding to hands when kicking
 if (m_HitType != EMeleeHitType.KICK)
 {
 //If no gloves, inflict hand damage and bleeding
 //m_Player.DecreaseHealth("hands", "", 10); IN CASE WE WANT TO DO STUFF WITH HAND HEALTH
 
 //Random bleeding source
 randNum = Math.RandomIntInclusive(1, 15);
 switch (randNum)
 {
 case 1:
 if (m_Player)
 {
 bleedingManager = m_Player.GetBleedingManagerServer();
 if (bleedingManager)
 bleedingManager.AttemptAddBleedingSourceBySelection("RightForeArmRoll");
 }
 break;
 
 case 2:
 if (m_Player)
 {
 bleedingManager = m_Player.GetBleedingManagerServer();
 if (bleedingManager)
 bleedingManager.AttemptAddBleedingSourceBySelection("LeftForeArmRoll");
 }
 break;
 }
 }
 else
 {
 //Random bleeding source
 randNum = Math.RandomIntInclusive(1, 15);
 //We only add bleeding to left foot as character kicks with left foot
 switch (randNum)
 {
 case 1:
 if (m_Player)
 {
 bleedingManager = m_Player.GetBleedingManagerServer();
 if (bleedingManager)
 bleedingManager.AttemptAddBleedingSourceBySelection("LeftToeBase");
 }
 break;
 
 case 2:
 if (m_Player)
 {
 bleedingManager = m_Player.GetBleedingManagerServer();
 if (bleedingManager)
 bleedingManager.AttemptAddBleedingSourceBySelection("LeftFoot");
 }
 break;
 }
 }
 }
 }
 }
 
 int GetFinisherType(InventoryItem weapon, EntityAI target)
 {
 return -1;
 }
 
 bool IsHitTypeFinisher(int type)
 {
 return false;
 }
 
 int DetermineFinisherAnimation(int finisher_type)
 {
 int animation = -1;
 
 switch (finisher_type)
 {
 case EMeleeHitType.FINISHER_LIVERSTAB:
 animation = HumanCommandMelee2.HIT_TYPE_FINISHER;
 break;
 
 case EMeleeHitType.FINISHER_NECKSTAB:
 animation = HumanCommandMelee2.HIT_TYPE_FINISHER_NECK;
 break;
 }
 
 return animation;
 }
 
 string DetermineFinisherAmmo(int finisher_type)
 {
 string ret = "";
 
 switch (finisher_type)
 {
 case EMeleeHitType.FINISHER_NECKSTAB:
 ret = "FinisherHitNeck";
 break;
 
 default:
 ret = "FinisherHit";
 break;
 }
 
 return ret;
 }
 
 int DetermineSpecificFinisherType(ItemBase weapon, int component)
 {
 return -1;
 }
 
 protected bool IsShortDistance(EntityAI pTarget, float pDistanceSq)
 {
 return pTarget && vector.DistanceSq(m_Player.GetPosition(), m_MeleeCombat.GetHitPos()) <= pDistanceSq || vector.DistanceSq(m_Player.GetBonePositionWS(m_Player.GetBoneIndexByName("Head")), m_MeleeCombat.GetHitPos()) <= pDistanceSq)
 }
 
 protected DayZPlayerImplement m_DZPlayer;
 protected bool m_IsFinisher;
}