ZombieBase.c

Go to the documentation of this file.

class ZombieBase extends DayZInfected
{
  const float TARGET_CONE_ANGLE_CHASE = 20;
  const float TARGET_CONE_ANGLE_FIGHT = 30;
  const float ORIENTATION_SYNC_THRESHOLD = 30; //threshold for local heading/orientation sync
 
  const float SHOCK_TO_STUN_MULTIPLIER = 2.82;
 
  protected int m_StanceVariation = 0;
  protected int m_LastMindState = -1;
  protected float m_LastMovementSpeed = -1;
 
  protected bool m_KnuckleLand = false;
  protected float m_KnuckleOutTimer = 0;
 
  protected int m_MindState = -1;
  protected int m_OrientationLocal = -1; //local 'companion' value for sync checking
  protected int m_OrientationSynced = -1;
  protected float m_OrientationTimer;
  protected float m_MovementSpeed = -1;
 
  protected vector m_DefaultHitPosition;
  protected float m_DeltaTime;
 
  protected AbstractWave m_LastSoundVoiceAW;
  protected ref InfectedSoundEventHandler m_InfectedSoundEventHandler;
 
  protected ref array<Object> m_AllTargetObjects;
  protected ref array<typename>m_TargetableObjects;
 
  //static ref map<int,ref array<string>>   m_FinisherSelectionMap; //! which selections in the FireGeometry trigger which finisher on hit (when applicable)
 
  protected bool m_IsCrawling; //'DayZInfectedCommandCrawl' is transition to crawl only, 'DayZInfectedCommandMove' used after that, hence this VARIABLE_WET
 
  protected bool m_FinisherInProgress = false; //is this object being backstabbed?
 
  protected ref ArrowManagerBase m_ArrowManager;
 
 
  //-------------------------------------------------------------
  void ZombieBase()
  {
    Init();
  }
 
  void Init()
  {
    SetEventMask(EntityEvent.INIT);
 
    m_IsCrawling = false;
 
    RegisterNetSyncVariableInt("m_MindState", -1, 4);
    RegisterNetSyncVariableInt("m_OrientationSynced", 0, 359);
    RegisterNetSyncVariableFloat("m_MovementSpeed", -1, 3);
    RegisterNetSyncVariableBool("m_IsCrawling");
 
    m_DefaultHitPosition = SetDefaultHitPosition(GetDayZInfectedType().GetDefaultHitPositionComponent());
 
    if (!GetGame().IsDedicatedServer())
    {
      m_LastSoundVoiceAW = null;
      m_InfectedSoundEventHandler = new InfectedSoundEventHandler(this);
    }
 
    m_AllTargetObjects = new array<Object>;
    m_TargetableObjects = new array<typename>;
    m_TargetableObjects.Insert(PlayerBase);
    m_TargetableObjects.Insert(AnimalBase);
 
    m_OrientationTimer = 0;
 
    m_ArrowManager = new ArrowManagerBase(this);
  }
 
  override void OnVariablesSynchronized()
  {
    DebugSound("[Infected @ " + this + "][OnVariablesSynchronized]");
    HandleSoundEvents();
 
    if (m_OrientationLocal != m_OrientationSynced)
      m_OrientationLocal = m_OrientationSynced;
  }
 
  //-------------------------------------------------------------
  override void EOnInit(IEntity other, int extra)
  {
    if (!GetGame().IsMultiplayer() || GetGame().IsServer())
    {
      m_StanceVariation = Math.RandomInt(0, 4);
 
      DayZInfectedCommandMove moveCommand = GetCommand_Move();
      moveCommand.SetStanceVariation(m_StanceVariation);
    }
  }
 
  override bool IsZombie()
  {
    return true;
  }
 
  override bool IsDanger()
  {
    return true;
  }
 
  override bool IsZombieMilitary()
  {
    return false;
  }
 
  bool IsMale()
  {
    return true;
  }
 
  override bool CanBeBackstabbed()
  {
    return true;
  }
 
  //-------------------------------------------------------------
  override AnimBootsType GetBootsType()
  {
    return AnimBootsType.Boots;
  }
 
  override bool CanBeSkinned()
  {
    return false;
  }
  //-------------------------------------------------------------
  override bool IsHealthVisible()
  {
    return false;
  }
  //-------------------------------------------------------------
  override bool IsRefresherSignalingViable()
  {
    return false;
  }
 
  override string GetHitComponentForAI()
  {
    return GetDayZInfectedType().GetHitComponentForAI();
  }
 
  override string GetDefaultHitComponent()
  {
    return GetDayZInfectedType().GetDefaultHitComponent();
  }
 
  override vector GetDefaultHitPosition()
  {
    return m_DefaultHitPosition;
  }
 
  protected vector SetDefaultHitPosition(string pSelection)
  {
    return GetSelectionPositionMS(pSelection);
  }
 
  override array<string> GetSuitableFinisherHitComponents()
  {
    return GetDayZInfectedType().GetSuitableFinisherHitComponents();
  }
 
  int GetMindStateSynced()
  {
    return m_MindState;
  }
 
  int GetOrientationSynced()
  {
    return m_OrientationSynced;
  }
 
  //-------------------------------------------------------------
 
  void CommandHandler(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
  {
    m_DeltaTime = pDt;
 
    if (ModCommandHandlerBefore(pDt, pCurrentCommandID, pCurrentCommandFinished))
      return;
 
    if (pCurrentCommandID != DayZInfectedConstants.COMMANDID_DEATH)
    {
      if (HandleDeath(pCurrentCommandID))
        return;
    }
    else if (!pCurrentCommandFinished)
      return;
 
 
    HandleMove(pCurrentCommandID);
    HandleOrientation(pDt, pCurrentCommandID);
 
    if (pCurrentCommandFinished)
    {
      DayZInfectedCommandMove moveCommand = StartCommand_Move();
      moveCommand.SetStanceVariation(m_StanceVariation);
 
      return;
    }
 
    if (ModCommandHandlerInside(pDt, pCurrentCommandID, pCurrentCommandFinished))
      return;
 
    if (HandleCrawlTransition(pCurrentCommandID))
      return;
 
    if (HandleDamageHit(pCurrentCommandID))
      return;
 
    DayZInfectedInputController inputController = GetInputController();
    if (inputController)
    {
      if (HandleVault(pCurrentCommandID, inputController, pDt))
        return;
 
      if (HandleMindStateChange(pCurrentCommandID, inputController, pDt))
        return;
 
      if (FightLogic(pCurrentCommandID, inputController, pDt))
        return;
    }
 
    if (ModCommandHandlerAfter(pDt, pCurrentCommandID, pCurrentCommandFinished))
      return;
  }
 
  //-------------------------------------------------------------
 
  void CommandHandlerDebug(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
  {
    if (GetPluginManager())
    {
      PluginDayZInfectedDebug infectedDebug = PluginDayZInfectedDebug.Cast(GetPluginManager().GetPluginByType(PluginDayZInfectedDebug));
      if (infectedDebug)
        infectedDebug.CommandHandler(this);
    }
  }
  //-------------------------------------------------------------
 
  void HandleMove(int pCurrentCommandID)
  {
    DayZInfectedInputController ic = GetInputController();
    m_MovementSpeed = ic.GetMovementSpeed();
    if (Math.AbsFloat(m_LastMovementSpeed - m_MovementSpeed) >= 0.9 && m_LastMovementSpeed != m_MovementSpeed)
      SetSynchDirty();
 
    m_LastMovementSpeed = m_MovementSpeed;
  }
 
  //-------------------------------------------------------------
 
  void HandleOrientation(float pDt, int pCurrentCommandID)
  {
    m_OrientationTimer += pDt;
 
    int yaw = Math.Round(GetOrientation()[0]);
    yaw = Math.NormalizeAngle(yaw);
 
    //atan2(sin(x-y), cos(x-y))
    float angleSourceRad = m_OrientationSynced * Math.DEG2RAD;
    float angleTargetRad = yaw * Math.DEG2RAD;
 
    float angleDiffRad = Math.Atan2(Math.Sin(angleTargetRad - angleSourceRad), Math.Cos(angleSourceRad - angleTargetRad));
    angleDiffRad *= Math.RAD2DEG;
    angleDiffRad = Math.Round(angleDiffRad);
 
    if (m_OrientationTimer >= 2.0 || m_OrientationSynced == -1 || Math.AbsInt(angleDiffRad) > ORIENTATION_SYNC_THRESHOLD)
    {
      m_OrientationTimer = 0.0;
 
      if (m_OrientationSynced == -1 || Math.AbsInt(angleDiffRad) > 5)
      {
        //Print("DbgSyncOrientation | HandleMove | original: " + m_OrientationSynced + " | target: " + yaw + " | diff: " + angleDiffRad);
        m_OrientationSynced = yaw;
        SetSynchDirty();
      }
    }
  }
 
  //-------------------------------------------------------------
 
  float m_DamageHitDirection = 0;
  int m_DeathType = 0;
 
  bool HandleDeath(int pCurrentCommandID)
  {
    if (!IsAlive() || m_FinisherInProgress)
    {
      StartCommand_Death(m_DeathType, m_DamageHitDirection);
      m_MovementSpeed = -1;
      m_MindState = -1;
      SetSynchDirty();
      return true;
    }
 
    return false;
  }
 
  bool EvaluateDeathAnimationEx(EntityAI pSource, ZombieHitData data, out int pAnimType, out float pAnimHitDir)
  {
    bool ret = EvaluateDeathAnimation(pSource, data.m_DamageZone, data.m_AmmoType, pAnimType, pAnimHitDir);
 
    return ret;
  }
 
  bool EvaluateDeathAnimation(EntityAI pSource, string pComponent, string pAmmoType, out int pAnimType, out float pAnimHitDir)
  {
    bool doPhxImpulse = GetGame().ConfigGetInt("cfgAmmo " + pAmmoType + " doPhxImpulse") > 0;
 
    pAnimType = doPhxImpulse;
 
    pAnimHitDir = ComputeHitDirectionAngle(pSource);
 
    if (doPhxImpulse)
    {
      vector impulse = 80 * m_TransportHitVelocity;
      impulse[1] = 80 * 1.5;
      //Print("Impulse: " + impulse.ToString());
 
      dBodyApplyImpulse(this, impulse);
    }
 
    return true;
  }
 
  //-------------------------------------------------------------
 
  int m_ActiveVaultType = -1;
 
  int GetVaultType(float height)
  {
    if (height <= 0.6)
      return 0;
    else if (height <= 1.1)
      return 1;
    else if (height <= 1.6)
      return 2;
    else
      return 3;
  }
 
  bool HandleVault(int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
  {
    if (pCurrentCommandID == DayZInfectedConstants.COMMANDID_VAULT)
    {
      DayZInfectedCommandVault vaultCmd = GetCommand_Vault();
      if (vaultCmd && vaultCmd.WasLand())
      {
        m_KnuckleOutTimer = 0;
        m_KnuckleLand = true;
      }
      if (m_KnuckleLand)
      {
        m_KnuckleOutTimer += pDt;
        if (m_KnuckleOutTimer > 2.0)
          StartCommand_Vault(-1);
      }
 
      return true;
    }
 
    if (pInputController.IsVault())
    {
      float vaultHeight = pInputController.GetVaultHeight();
      int vaultType = GetVaultType(vaultHeight);
      m_KnuckleLand = false;
      StartCommand_Vault(vaultType);
      return true;
    }
 
    return false;
  }
 
  //-------------------------------------------------------------
 
  bool HandleMindStateChange(int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
  {
    DayZInfectedCommandMove moveCommand = GetCommand_Move();
 
    m_MindState = pInputController.GetMindState();
    if (m_LastMindState != m_MindState)
    {
      switch (m_MindState)
      {
      case DayZInfectedConstants.MINDSTATE_CALM:
        if (moveCommand && !moveCommand.IsTurning())
          moveCommand.SetIdleState(0);
        break;
 
      case DayZInfectedConstants.MINDSTATE_DISTURBED:
        if (moveCommand && !moveCommand.IsTurning())
          moveCommand.SetIdleState(1);
        break;
 
      case DayZInfectedConstants.MINDSTATE_CHASE:
        if (moveCommand && !moveCommand.IsTurning() && (m_LastMindState < DayZInfectedConstants.MINDSTATE_CHASE))
          moveCommand.SetIdleState(2);
        break;
      }
 
      m_LastMindState = m_MindState;
      m_AttackCooldownTime = 0.0;
      SetSynchDirty();
    }
    return false;
  }
 
  //-------------------------------------------------------------
 
  protected void HandleSoundEvents()
  {
    if (!m_InfectedSoundEventHandler)
      return;
 
    if (!IsAlive())
    {
      m_InfectedSoundEventHandler.Stop();
      return;
    }
 
    switch (m_MindState)
    {
    case DayZInfectedConstants.MINDSTATE_CALM:
      m_InfectedSoundEventHandler.PlayRequest(EInfectedSoundEventID.MINDSTATE_CALM_MOVE);
      break;
    case DayZInfectedConstants.MINDSTATE_ALERTED:
      m_InfectedSoundEventHandler.PlayRequest(EInfectedSoundEventID.MINDSTATE_ALERTED_MOVE);
      break;
    case DayZInfectedConstants.MINDSTATE_DISTURBED:
      m_InfectedSoundEventHandler.PlayRequest(EInfectedSoundEventID.MINDSTATE_DISTURBED_IDLE);
      break
    case DayZInfectedConstants.MINDSTATE_CHASE:
      m_InfectedSoundEventHandler.PlayRequest(EInfectedSoundEventID.MINDSTATE_CHASE_MOVE);
      break;
    default:
      m_InfectedSoundEventHandler.Stop();
      break;
    }
 
    DebugSound("[Infected @ " + this + "][MindState]" + typename.EnumToString(DayZInfectedConstants, m_MindState));
    DebugSound("[Infected @ " + this + "][SoundEventID]" + typename.EnumToString(EInfectedSoundEventID, m_InfectedSoundEventHandler.GetCurrentStateEventID()));
  }
 
  AbstractWave ProcessVoiceFX(string pSoundSetName)
  {
    SoundParams soundParams;
    SoundObjectBuilder soundObjectBuilder;
    SoundObject soundObject;
    if (!GetGame().IsDedicatedServer())
    {
      soundParams = new SoundParams(pSoundSetName);
      if (!soundParams.IsValid())
      {
        //SoundError("Invalid sound set.");
        return null;
      }
 
      soundObjectBuilder = new SoundObjectBuilder(soundParams);
      soundObject = soundObjectBuilder.BuildSoundObject();
      AttenuateSoundIfNecessary(soundObject);
 
      return PlaySound(soundObject, soundObjectBuilder);
    }
 
    return null;
  }
 
  override void OnSoundVoiceEvent(int event_id, string event_user_string)
  {
    //super.OnSoundVoiceEvent(event_id, event_user_string);
    AnimSoundVoiceEvent voice_event = GetCreatureAIType().GetSoundVoiceEvent(event_id);
    if (voice_event != null)
    {
      if (m_InfectedSoundEventHandler) // && m_InfectedSoundEventHandler.IsPlaying())
      {
        m_InfectedSoundEventHandler.Stop();
        DebugSound("[Infected @ " + this + "][SoundEvent] InfectedSoundEventHandler - stop all");
      }
 
      if (m_LastSoundVoiceAW != null)
      {
        DebugSound("[Infected @ " + this + "][AnimVoiceEvent] Stopping LastAW");
        m_LastSoundVoiceAW.Stop();
      }
 
      ProcessSoundVoiceEvent(voice_event, m_LastSoundVoiceAW);
 
      HandleSoundEvents();
    }
  }
 
  protected void ProcessSoundVoiceEvent(AnimSoundVoiceEvent sound_event, out AbstractWave aw)
  {
    if (!GetGame().IsDedicatedServer())
    {
      SoundObjectBuilder objectBuilder = sound_event.GetSoundBuilder();
      if (NULL != objectBuilder)
      {
        objectBuilder.AddEnvSoundVariables(GetPosition());
        SoundObject soundObject = objectBuilder.BuildSoundObject();
        AttenuateSoundIfNecessary(soundObject);
        aw = PlaySound(soundObject, objectBuilder);
      }
    }
 
    if (GetGame().IsServer())
    {
      if (sound_event.m_NoiseParams != NULL)
        GetGame().GetNoiseSystem().AddNoise(this, sound_event.m_NoiseParams);
    }
  }
 
  //-------------------------------------------------------------
 
  EntityAI m_ActualTarget = null;
  float m_AttackCooldownTime = 0;
  DayZInfectedAttackType m_ActualAttackType = null;
 
  bool FightLogic(int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
  {
    if (pCurrentCommandID == DayZInfectedConstants.COMMANDID_MOVE)
    {
      // we attack only in chase & fight state
      int mindState = pInputController.GetMindState();
      if (mindState == DayZInfectedConstants.MINDSTATE_CHASE)
        return ChaseAttackLogic(pCurrentCommandID, pInputController, pDt);
      else if (mindState == DayZInfectedConstants.MINDSTATE_FIGHT)
        return FightAttackLogic(pCurrentCommandID, pInputController, pDt);
    }
    else if (pCurrentCommandID == DayZInfectedConstants.COMMANDID_ATTACK)
    {
      DayZInfectedCommandAttack attackCommand = GetCommand_Attack();
      if (attackCommand && attackCommand.WasHit())
      {
        if (m_ActualTarget != null)
        {
          if (m_ActualTarget.GetMeleeTargetType() == EMeleeTargetType.NONALIGNABLE)
            return false;
 
          bool playerInBlockStance = false;
          vector targetPos = m_ActualTarget.GetPosition();
          vector hitPosWS = targetPos;
          vector zombiePos = GetPosition();
 
          PlayerBase playerTarget = PlayerBase.Cast(m_ActualTarget);
          if (playerTarget)
            playerInBlockStance = playerTarget.GetMeleeFightLogic() && playerTarget.GetMeleeFightLogic().IsInBlock();
 
          if (vector.DistanceSq(targetPos, zombiePos) <= m_ActualAttackType.m_Distance * m_ActualAttackType.m_Distance)
          {
            if (playerInBlockStance && (Math.RAD2DEG * Math.AbsFloat(Math3D.AngleFromPosition(targetPos, MiscGameplayFunctions.GetHeadingVector(playerTarget), zombiePos))) <= GameConstants.AI_MAX_BLOCKABLE_ANGLE)
            {
              if (m_ActualAttackType.m_IsHeavy == 1)
              {
                hitPosWS = m_ActualTarget.ModelToWorld(m_ActualTarget.GetDefaultHitPosition()); 
                DamageSystem.CloseCombatDamageName(this, m_ActualTarget, m_ActualTarget.GetHitComponentForAI(), "MeleeZombie", hitPosWS);
              }
              else
              {
                hitPosWS = m_ActualTarget.ModelToWorld(m_ActualTarget.GetDefaultHitPosition());
                DamageSystem.CloseCombatDamageName(this, m_ActualTarget, m_ActualTarget.GetHitComponentForAI(), "Dummy_Light", hitPosWS);
              }
            }
            else
            {
              hitPosWS = m_ActualTarget.ModelToWorld(m_ActualTarget.GetDefaultHitPosition()); 
              DamageSystem.CloseCombatDamageName(this, m_ActualTarget, m_ActualTarget.GetHitComponentForAI(), m_ActualAttackType.m_AmmoType, hitPosWS);
            }
          }
        }
      }
 
      return true;
    }
 
    return false;
  }
 
  bool ChaseAttackLogic(int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
  {
    // always update target - it can be destroyed
    m_ActualTarget = pInputController.GetTargetEntity();
 
    PlayerBase pb = PlayerBase.Cast(m_ActualTarget);
    if (pb && pb.GetCommand_Vehicle())
      return false;
 
    if (m_ActualTarget == NULL)
      return false;
 
    vector targetPos = m_ActualTarget.GetPosition();
    if (!CanAttackToPosition(targetPos))
      return false;
 
    float targetDist = vector.Distance(targetPos, this.GetPosition());
    int pitch = GetAttackPitch(m_ActualTarget);
 
    m_ActualAttackType = GetDayZInfectedType().ChooseAttack(DayZInfectedAttackGroupType.CHASE, targetDist, pitch);
    if (m_ActualAttackType)
    {
      Object target = DayZPlayerUtils.GetMeleeTarget(this.GetPosition(), this.GetDirection(), TARGET_CONE_ANGLE_CHASE, m_ActualAttackType.m_Distance, -1.0, 2.0, this, m_TargetableObjects, m_AllTargetObjects);
      if (m_ActualTarget != target)
      {
        m_AllTargetObjects.Clear();
        return false;
      }
 
      StartCommand_Attack(m_ActualTarget, m_ActualAttackType.m_Type, m_ActualAttackType.m_Subtype);
      m_AttackCooldownTime = m_ActualAttackType.m_Cooldown;
      return true;
    }
 
    return false;
  }
 
  bool FightAttackLogic(int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
  {
    // always update target - it can be destroyed
    m_ActualTarget = pInputController.GetTargetEntity();
 
    PlayerBase pb = PlayerBase.Cast(m_ActualTarget);
    if (pb && pb.GetCommand_Vehicle())
      return false;
 
    if (m_AttackCooldownTime > 0)
    {
      m_AttackCooldownTime -= pDt * GameConstants.AI_ATTACKSPEED;
      return false;
    }
 
    if (m_ActualTarget == null)
      return false;
 
    vector targetPos = m_ActualTarget.GetPosition();
    float targetDist = vector.Distance(targetPos, this.GetPosition());
    int pitch = GetAttackPitch(m_ActualTarget);
 
    if (!CanAttackToPosition(targetPos))
      return false;
 
    m_ActualAttackType = GetDayZInfectedType().ChooseAttack(DayZInfectedAttackGroupType.FIGHT, targetDist, pitch);
    if (m_ActualAttackType)
    {
      Object target = DayZPlayerUtils.GetMeleeTarget(this.GetPosition(), this.GetDirection(), TARGET_CONE_ANGLE_FIGHT, m_ActualAttackType.m_Distance, -1.0, 2.0, this, m_TargetableObjects, m_AllTargetObjects);
      if (m_AllTargetObjects.Count() > 0 && m_AllTargetObjects[0] != m_ActualTarget)
      {
        m_AllTargetObjects.Clear();
        return false;
      }
 
      StartCommand_Attack(m_ActualTarget, m_ActualAttackType.m_Type, m_ActualAttackType.m_Subtype);
      m_AttackCooldownTime = m_ActualAttackType.m_Cooldown;
      return true;
    }
 
    return false;
  }
 
  int GetAttackPitch(EntityAI target)
  {
    vector attackRefPos;
 
    attackRefPos = target.GetDefaultHitPosition();
    if (attackRefPos != vector.Zero)
      attackRefPos = target.ModelToWorld(attackRefPos);
    else
      attackRefPos = target.GetPosition();
 
    // Now we have only erect stance, we need to get head position later too
    float headPosY = GetPosition()[1];
    headPosY += 1.8;
 
    float diff = Math.AbsFloat(attackRefPos[1] - headPosY);
 
    if (diff < 0.3)
      return 0;
 
    if (headPosY > attackRefPos[1])
      return -1;
    else
      return 1;
  }
 
  //-------------------------------------------------------------
 
  int m_CrawlTransition = -1;
 
  bool HandleCrawlTransition(int pCurrentCommandID)
  {
    if (m_CrawlTransition != -1)
    {
      StartCommand_Crawl(m_CrawlTransition);
 
      m_CrawlTransition = -1;
      m_IsCrawling = true;
      SetSynchDirty();
      return true;
    }
 
    return pCurrentCommandID == DayZInfectedConstants.COMMANDID_CRAWL;
  }
 
  bool EvaluateCrawlTransitionAnimation(EntityAI pSource, string pComponent, string pAmmoType, out int pAnimType)
  {
    pAnimType = -1;
    if (pComponent == "LeftLeg" && GetHealth(pComponent, "Health") == 0)
      pAnimType = 0;
    else if (pComponent == "RightLeg" && GetHealth(pComponent, "Health") == 0)
      pAnimType = 2;
 
    if (pAnimType != -1)
    {
      vector targetDirection = GetDirection();
      vector toSourceDirection = (pSource.GetPosition() - GetPosition());
 
      targetDirection[1] = 0;
      toSourceDirection[1] = 0;
 
      targetDirection.Normalize();
      toSourceDirection.Normalize();
 
      float cosFi = vector.Dot(targetDirection, toSourceDirection);
      if (cosFi >= 0) // front
        pAnimType++;
    }
 
    return pAnimType != -1;
  }
 
  //-------------------------------------------------------------
 
  bool m_DamageHitToProcess = false;
 
  bool m_DamageHitHeavy = false;
  int m_DamageHitType = 0;
  float m_ShockDamage = 0;
 
  const float HIT_INTERVAL_MIN = 0.3; // Minimum time in seconds before a COMMANDID_HIT to COMMANDID_HIT transition is allowed
  float m_HitElapsedTime = HIT_INTERVAL_MIN;
 
  bool HandleDamageHit(int pCurrentCommandID)
  {
    if (pCurrentCommandID == DayZInfectedConstants.COMMANDID_HIT)
    {
      // Throttle hit command up to a fixed rate
      if (m_HitElapsedTime < HIT_INTERVAL_MIN)
      {
        m_HitElapsedTime += m_DeltaTime;
        m_DamageHitToProcess = false;
        m_ShockDamage = 0;
        return false;
      }
    }
 
    if (m_DamageHitToProcess)
    {
      int randNum = Math.RandomIntInclusive(0, 100);
      float stunChange = SHOCK_TO_STUN_MULTIPLIER * m_ShockDamage;
 
      if (m_DamageHitHeavy || randNum <= stunChange || (m_MindState == DayZInfectedConstants.MINDSTATE_CALM || m_MindState == DayZInfectedConstants.MINDSTATE_DISTURBED))
      {
        StartCommand_Hit(m_DamageHitHeavy, m_DamageHitType, m_DamageHitDirection);
        m_HitElapsedTime = 0;
      }
 
      m_DamageHitToProcess = false;
      m_ShockDamage = 0;
      m_HeavyHitOverride = false;
      return true;
    }
 
    return false;
  }
 
  bool EvaluateDamageHitAnimation(EntityAI pSource, string pComponent, string pAmmoType, out bool pHeavyHit, out int pAnimType, out float pAnimHitDir)
  {
    int invertHitDir = 0; //Used to flip the heavy hit animation direction
 
    pHeavyHit = ((GetGame().ConfigGetInt("cfgAmmo " + pAmmoType + " hitAnimation") > 0) || m_HeavyHitOverride);
    invertHitDir = GetGame().ConfigGetInt("cfgAmmo " + pAmmoType + " invertHitDir");
 
    pAnimType = 0; // belly
 
    if (!pHeavyHit)
    {
      if (pComponent == "Torso") // body
        pAnimType = 1;
      else if (pComponent == "Head") // head
        pAnimType = 2;
    }
 
    //pAnimHitDir = ComputeHitDirectionAngle(pSource);
    pAnimHitDir = ComputeHitDirectionAngleEx(pSource, invertHitDir);
    //m_ShockDamage = GetGame().ConfigGetFloat( "CfgAmmo " + pAmmoType + " DamageApplied " + "Shock " + "damage");
    return true;
  }
 
  float ComputeHitDirectionAngle(EntityAI pSource)
  {
    vector targetDirection = GetDirection();
    vector toSourceDirection = (pSource.GetPosition() - GetPosition());
 
    targetDirection[1] = 0;
    toSourceDirection[1] = 0;
 
    targetDirection.Normalize();
    toSourceDirection.Normalize();
 
    float cosFi = vector.Dot(targetDirection, toSourceDirection);
    vector cross = targetDirection * toSourceDirection;
 
    float dirAngle = Math.Acos(cosFi) * Math.RAD2DEG;
    if (cross[1] < 0)
      dirAngle = -dirAngle;
 
    return dirAngle;
  }
 
  float ComputeHitDirectionAngleEx(EntityAI pSource, int invertHitDir = 0)
  {
    vector targetDirection = GetDirection();
    vector toSourceDirection = (pSource.GetPosition() - GetPosition());
 
    targetDirection[1] = 0;
    toSourceDirection[1] = 0;
 
    targetDirection.Normalize();
    toSourceDirection.Normalize();
 
    float cosFi = vector.Dot(targetDirection, toSourceDirection);
    vector cross = targetDirection * toSourceDirection;
 
    float dirAngle = Math.Acos(cosFi) * Math.RAD2DEG;
 
    // We will invert direction of the hit
    if (invertHitDir > 0)
      dirAngle -= 180;
 
    if (cross[1] < 0)
      dirAngle = -dirAngle;
 
    return dirAngle;
  }
 
  //-------------------------------------------------------------
 
  override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
  {
    super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
 
    m_TransportHitRegistered = false;
 
    if (!IsAlive())
    {
      ZombieHitData data = new ZombieHitData;
      data.m_Component = component;
      data.m_DamageZone = dmgZone;
      data.m_AmmoType = ammo;
      EvaluateDeathAnimationEx(source, data, m_DeathType, m_DamageHitDirection);
    }
    else
    {
      int crawlTransitionType = -1;
      if (EvaluateCrawlTransitionAnimation(source, dmgZone, ammo, crawlTransitionType))
      {
        m_CrawlTransition = crawlTransitionType;
        return;
      }
 
      if (EvaluateDamageHitAnimation(source, dmgZone, ammo, m_DamageHitHeavy, m_DamageHitType, m_DamageHitDirection))
      {
        if (dmgZone)
          m_ShockDamage = damageResult.GetDamage(dmgZone, "Shock");
        m_DamageHitToProcess = true;
        return;
      }
    }
  }
 
  override void EEHitByRemote(int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos)
  {
    super.EEHitByRemote(damageType, source, component, dmgZone, ammo, modelPos);
  }
 
  protected void DebugSound(string s)
  {
    //Print(s);
  }
 
  //-------------------------------------------------------------
 
  override protected void EOnContact(IEntity other, Contact extra)
  {
    if (!IsAlive())
      return;
 
    Transport transport = Transport.Cast(other);
    if (transport)
    {
      if (GetGame().IsServer())
        RegisterTransportHit(transport);
    }
  }
 
  override bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    if (!IsAlive())
      return false;
    return super.CanReceiveAttachment(attachment, slotId);
  }
 
  override vector GetCenter()
  {
    return GetBonePositionWS(GetBoneIndexByName("spine3"));
  }
 
  override bool IsBeingBackstabbed()
  {
    return m_FinisherInProgress;
  }
 
  override void SetBeingBackstabbed(int backstabType)
  {
    // disable AI simulation
    GetAIAgent().SetKeepInIdle(true);
 
    // select death animation
    switch (backstabType)
    {
    case EMeleeHitType.FINISHER_LIVERSTAB:
      m_DeathType = DayZInfectedDeathAnims.ANIM_DEATH_BACKSTAB;
      break;
 
    case EMeleeHitType.FINISHER_NECKSTAB:
      m_DeathType = DayZInfectedDeathAnims.ANIM_DEATH_NECKSTAB;
      break;
 
    default:
      m_DeathType = DayZInfectedDeathAnims.ANIM_DEATH_DEFAULT;
    }
 
    // set flag - death command will be executed
    m_FinisherInProgress = true;
 
    //Print("DbgZombies | DumbZombie on: " + GetGame().GetTime());
  }
 
  bool IsCrawling()
  {
    return m_IsCrawling;
  }
 
  // called from command death when stealth attack wan't successful
  void OnRecoverFromDeath()
  {
    // enable AI simulation again
    GetAIAgent().SetKeepInIdle(false);
 
    // reset flag
    m_FinisherInProgress = false;
 
    //Print("DbgZombies | DumbZombie off: " + GetGame().GetTime());
  }
 
  override void AddArrow(Object arrow, int componentIndex, vector closeBonePosWS, vector closeBoneRotWS)
  {
    CachedObjectsArrays.ARRAY_STRING.Clear();
    GetActionComponentNameList(componentIndex, CachedObjectsArrays.ARRAY_STRING, "fire");
 
    int pivot = -1;
 
 
    for (int i = 0; i < CachedObjectsArrays.ARRAY_STRING.Count() && pivot == -1; i++)
      pivot = GetBoneIndexByName(CachedObjectsArrays.ARRAY_STRING.Get(i));
 
    vector parentTransMat[4];
    vector arrowTransMat[4];
 
    if (pivot == -1)
      GetTransformWS(parentTransMat);
    else
    {
      vector rotMatrix[3];
      Math3D.YawPitchRollMatrix(closeBoneRotWS * Math.RAD2DEG, rotMatrix);
 
      parentTransMat[0] = rotMatrix[0];
      parentTransMat[1] = rotMatrix[1];
      parentTransMat[2] = rotMatrix[2];
      parentTransMat[3] = closeBonePosWS;
    }
 
    arrow.GetTransform(arrowTransMat);
    Math3D.MatrixInvMultiply4(parentTransMat, arrowTransMat, arrowTransMat);
    // orthogonalize matrix - parent might be skewed
    Math3D.MatrixOrthogonalize4(arrowTransMat);
    arrow.SetTransform(arrowTransMat);
 
    AddChild(arrow, pivot);
  }
 
  override bool IsManagingArrows()
  {
    return true;
  }
 
  override ArrowManagerBase GetArrowManager()
  {
    return m_ArrowManager;
  }
}
 
class ZombieHitData
{
  int m_Component;
  string m_DamageZone;
  string m_AmmoType;
}