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