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