Класс DayZInfected

Защищенные члены
void	ZombieBase ()
void	Init ()
override void	OnVariablesSynchronized ()
	synced variable(s) handler
override void	EOnInit (IEntity other, int extra)
override bool	IsZombie ()
override bool	IsDanger ()
override bool	IsZombieMilitary ()
bool	IsMale ()
override bool	CanBeBackstabbed ()
override AnimBootsType	GetBootsType ()
override bool	CanBeSkinned ()
override bool	IsHealthVisible ()
override bool	IsRefresherSignalingViable ()
override bool	IsSelfAdjustingTemperature ()
override string	GetHitComponentForAI ()
	returns hit component for attacking AI
override string	GetDefaultHitComponent ()
	returns default hit component (fallback)
override vector	GetDefaultHitPosition ()
vector	SetDefaultHitPosition (string pSelection)
override array< string >	GetSuitableFinisherHitComponents ()
	returns suitable hit components for finisher attacks; DEPRECATED
int	GetMindStateSynced ()
int	GetOrientationSynced ()
	returns rounded zombie yaw for sync purposes
void	CommandHandler (float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
void	CommandHandlerDebug (float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
void	HandleMove (int pCurrentCommandID)
void	HandleOrientation (float pDt, int pCurrentCommandID)
bool	HandleDeath (int pCurrentCommandID)
bool	EvaluateDeathAnimationEx (EntityAI pSource, ZombieHitData data, out int pAnimType, out float pAnimHitDir)
bool	EvaluateDeathAnimation (EntityAI pSource, string pComponent, string pAmmoType, out int pAnimType, out float pAnimHitDir)
int	GetVaultType (float height)
bool	HandleVault (int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
bool	HandleMindStateChange (int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
void	HandleSoundEvents ()
AbstractWave	ProcessVoiceFX (string pSoundSetName)
override void	OnSoundVoiceEvent (int event_id, string event_user_string)
void	ProcessSoundVoiceEvent (AnimSoundVoiceEvent sound_event, out AbstractWave aw)
bool	FightLogic (int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
bool	ChaseAttackLogic (int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
bool	FightAttackLogic (int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt)
int	GetAttackPitch (EntityAI target)
bool	HandleCrawlTransition (int pCurrentCommandID)
bool	EvaluateCrawlTransitionAnimation (EntityAI pSource, string pComponent, string pAmmoType, out int pAnimType)
bool	HandleDamageHit (int pCurrentCommandID)
bool	EvaluateDamageHitAnimation (EntityAI pSource, string pComponent, string pAmmoType, out bool pHeavyHit, out int pAnimType, out float pAnimHitDir)
	selects animation type and direction based on damage system data
float	ComputeHitDirectionAngle (EntityAI pSource)
float	ComputeHitDirectionAngleEx (EntityAI pSource, int invertHitDir=0)
override void	EEHitBy (TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
override void	EEHitByRemote (int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos)
void	DebugSound (string s)
	sound debug messages
void	EOnContact (IEntity other, Contact extra)
override bool	CanReceiveAttachment (EntityAI attachment, int slotId)
override vector	GetCenter ()
override bool	IsBeingBackstabbed ()
	returns true if backstab is in progress; used for suspending of AI targeting and other useful things besides
override void	SetBeingBackstabbed (int backstabType)
bool	IsCrawling ()
	returns true if crawling; 'DayZInfectedCommandCrawl' is only for the transition, after that it remains 'DayZInfectedCommandMove' (unreliable)
void	OnRecoverFromDeath ()
override void	AddArrow (Object arrow, int componentIndex, vector closeBonePosWS, vector closeBoneRotWS)
override bool	IsManagingArrows ()
override ArrowManagerBase	GetArrowManager ()

Защищенные данные
int	m_StanceVariation = 0
	server / singleplayer properties
int	m_LastMindState = -1
float	m_LastMovementSpeed = -1
bool	m_KnuckleLand = false
float	m_KnuckleOutTimer = 0
int	m_MindState = -1
int	m_OrientationLocal = -1
int	m_OrientationSynced = -1
float	m_OrientationTimer
float	m_MovementSpeed = -1
vector	m_DefaultHitPosition
float	m_DeltaTime
AbstractWave	m_LastSoundVoiceAW
ref InfectedSoundEventHandler	m_InfectedSoundEventHandler
ref array< Object >	m_AllTargetObjects
ref array< typename >	m_TargetableObjects
bool	m_IsCrawling
bool	m_FinisherInProgress = false
ref ArrowManagerBase	m_ArrowManager
float	m_DamageHitDirection = 0
int	m_DeathType = 0
int	m_ActiveVaultType = -1
EntityAI	m_ActualTarget = null
float	m_AttackCooldownTime = 0
DayZInfectedAttackType	m_ActualAttackType = null
int	m_CrawlTransition = -1
bool	m_DamageHitToProcess = false
bool	m_DamageHitHeavy = false
int	m_DamageHitType = 0
float	m_ShockDamage = 0
const float	HIT_INTERVAL_MIN = 0.3
float	m_HitElapsedTime = HIT_INTERVAL_MIN

Закрытые данные
const float	TARGET_CONE_ANGLE_CHASE = 20
const float	TARGET_CONE_ANGLE_FIGHT = 30
const float	ORIENTATION_SYNC_THRESHOLD = 30
const float	SHOCK_TO_STUN_MULTIPLIER = 2.82

Подробное описание

Методы

AddArrow()

override void AddArrow ( Object arrow, int componentIndex, vector closeBonePosWS, vector closeBoneRotWS )

inlineprotected

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

Перекрестные ссылки AddChild(), CachedObjectsArrays::ARRAY_STRING, GetBoneIndexByName(), Math3D::MatrixInvMultiply4(), Math3D::MatrixOrthogonalize4(), Math::RAD2DEG и Math3D::YawPitchRollMatrix().

CanBeBackstabbed()

override bool CanBeBackstabbed ( )

inlineprotected

    {
        return true;
    }

CanBeSkinned()

override bool CanBeSkinned ( )

inlineprotected

    {
        return false;
    }

CanReceiveAttachment()

override bool CanReceiveAttachment ( EntityAI attachment, int slotId )

inlineprotected

    {
        if ( !IsAlive() )
        {
            return false;
        }
        return super.CanReceiveAttachment(attachment, slotId);
    }

ChaseAttackLogic()

bool ChaseAttackLogic ( int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt )

inlineprotected

do not attack players in vehicle - hotfix

target is outside the targeting cone; skip attack

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

Перекрестные ссылки DayZPlayerUtils(), vector::Distance(), GetPosition, m_AllTargetObjects, DayZInfectedAttackType::m_Cooldown, DayZInfectedAttackType::m_Distance, DayZInfectedAttackType::m_Subtype, m_TargetableObjects и DayZInfectedAttackType::m_Type.

CommandHandler()

void CommandHandler ( float pDt, int pCurrentCommandID, bool pCurrentCommandFinished )

inlineprotected

CommandHandler

for mods

handle death

movement handler (just for sync now)

handle finished commands

default behaviour after finish is to start move

for mods

crawl transition

damage hits

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

Перекрестные ссылки ModCommandHandlerAfter(), ModCommandHandlerBefore() и ModCommandHandlerInside().

CommandHandlerDebug()

void CommandHandlerDebug ( float pDt, int pCurrentCommandID, bool pCurrentCommandFinished )

inlineprotected

CommandHandlerDebug

    {
        if ( GetPluginManager() )
        {
            PluginDayZInfectedDebug infectedDebug = PluginDayZInfectedDebug.Cast(GetPluginManager().GetPluginByType(PluginDayZInfectedDebug));
            if ( infectedDebug )
                infectedDebug.CommandHandler(this);
        }   
    }

Перекрестные ссылки GetPluginManager().

ComputeHitDirectionAngle()

float ComputeHitDirectionAngle ( EntityAI pSource )

inlineprotected

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

Перекрестные ссылки Math::Acos(), vector::Dot(), GetPosition и Math::RAD2DEG.

ComputeHitDirectionAngleEx()

float ComputeHitDirectionAngleEx ( EntityAI pSource, int invertHitDir = 0 )

inlineprotected

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

Перекрестные ссылки Math::Acos(), vector::Dot(), GetPosition и Math::RAD2DEG.

DebugSound()

void DebugSound ( string s )

inlineprotected

sound debug messages

    {
        //Print(s);
    }

EEHitBy()

override void EEHitBy ( TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef )

inlineprotected

Events from damage system

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

Перекрестные ссылки component.

EEHitByRemote()

override void EEHitByRemote ( int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos )

inlineprotected

    {
        super.EEHitByRemote(damageType, source, component, dmgZone, ammo, modelPos);
    }

Перекрестные ссылки component.

EOnContact()

void EOnContact ( IEntity other, Contact extra )

inlineprotected

Phx contact event

    {
        if ( !IsAlive() )
            return;
 
        Transport transport = Transport.Cast(other);
        if ( transport )
        {
            if ( GetGame().IsServer() )
            {
                RegisterTransportHit(transport);
            }           
        }
    }

Перекрестные ссылки GetGame().

EOnInit()

override void EOnInit ( IEntity other, int extra )

inlineprotected

    {
        if ( !GetGame().IsMultiplayer() || GetGame().IsServer() )
        {
            m_StanceVariation = Math.RandomInt(0, 4);
    
            DayZInfectedCommandMove moveCommand = GetCommand_Move();
            moveCommand.SetStanceVariation(m_StanceVariation);
        }
    }

Перекрестные ссылки GetGame() и Math::RandomInt().

EvaluateCrawlTransitionAnimation()

bool EvaluateCrawlTransitionAnimation ( EntityAI pSource, string pComponent, string pAmmoType, out int pAnimType )

inlineprotected

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

Перекрестные ссылки vector::Dot() и GetPosition.

EvaluateDamageHitAnimation()

bool EvaluateDamageHitAnimation ( EntityAI pSource, string pComponent, string pAmmoType, out bool pHeavyHit, out int pAnimType, out float pAnimHitDir )

inlineprotected

selects animation type and direction based on damage system data

heavy hit

anim type

direction

shock GetDamage

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

Перекрестные ссылки GetGame().

EvaluateDeathAnimation()

bool EvaluateDeathAnimation ( EntityAI pSource, string pComponent, string pAmmoType, out int pAnimType, out float pAnimHitDir )

inlineprotected

anim type

direction

add some impulse if needed

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

Перекрестные ссылки dBodyApplyImpulse() и GetGame().

EvaluateDeathAnimationEx()

bool EvaluateDeathAnimationEx ( EntityAI pSource, ZombieHitData data, out int pAnimType, out float pAnimHitDir )

inlineprotected

    {
        bool ret = EvaluateDeathAnimation(pSource,data.m_DamageZone,data.m_AmmoType,pAnimType,pAnimHitDir);
                
        return ret;
    }

FightAttackLogic()

bool FightAttackLogic ( int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt )

inlineprotected

do not attack players in vehicle - hotfix

target is outside the targeting cone; skip attack

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

Перекрестные ссылки GameConstants::AI_ATTACKSPEED, DayZPlayerUtils(), vector::Distance(), GetPosition, m_AllTargetObjects, DayZInfectedAttackType::m_Cooldown, DayZInfectedAttackType::m_Distance, DayZInfectedAttackType::m_Subtype, m_TargetableObjects и DayZInfectedAttackType::m_Type.

FightLogic()

bool FightLogic ( int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt )

inlineprotected

player is in block stance and facing the infected

infected is playing heavy attack - decrease the dmg to light

override hit pos by pos defined in type

infected is playing light attack - do not send damage, play animation instead

override hit pos by pos defined in type

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

Перекрестные ссылки Math::AbsFloat(), GameConstants::AI_MAX_BLOCKABLE_ANGLE, Math3D::AngleFromPosition(), vector::DistanceSq(), EntityAI::GetMeleeTargetType(), GetPosition, DayZInfectedAttackType::m_AmmoType, DayZInfectedAttackType::m_Distance, DayZInfectedAttackType::m_IsHeavy и Math::RAD2DEG.

GetArrowManager()

override ArrowManagerBase GetArrowManager ( )

inlineprotected

    {
        return m_ArrowManager;
    }

Перекрестные ссылки m_ArrowManager.

GetAttackPitch()

int GetAttackPitch ( EntityAI target )

inlineprotected

no default hit pos fallback

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

Перекрестные ссылки Math::AbsFloat(), GetPosition и vector::Zero.

GetBootsType()

override AnimBootsType GetBootsType ( )

inlineprotected

    {
        return AnimBootsType.Boots;
    }

GetCenter()

override vector GetCenter ( )

inlineprotected

    {
        return GetBonePositionWS( GetBoneIndexByName( "spine3" ) );
    }

Перекрестные ссылки GetBoneIndexByName().

GetDefaultHitComponent()

override string GetDefaultHitComponent ( )

inlineprotected

returns default hit component (fallback)

    {
        return GetDayZInfectedType().GetDefaultHitComponent();
    }

GetDefaultHitPosition()

override vector GetDefaultHitPosition ( )

inlineprotected

    {
        return m_DefaultHitPosition;
    }

GetHitComponentForAI()

override string GetHitComponentForAI ( )

inlineprotected

returns hit component for attacking AI

    {
        return GetDayZInfectedType().GetHitComponentForAI();
    }

GetMindStateSynced()

int GetMindStateSynced ( )

inlineprotected

    {
        return m_MindState;
    }

GetOrientationSynced()

int GetOrientationSynced ( )

inlineprotected

returns rounded zombie yaw for sync purposes

    {
        return m_OrientationSynced;
    }

GetSuitableFinisherHitComponents()

override array< string > GetSuitableFinisherHitComponents ( )

inlineprotected

returns suitable hit components for finisher attacks; DEPRECATED

    {
        return GetDayZInfectedType().GetSuitableFinisherHitComponents();
    }

GetVaultType()

int GetVaultType ( float height )

inlineprotected

    {
        if ( height <= 0.6 )
            return 0;
        else if ( height <= 1.1 )
            return 1;
        else if ( height <= 1.6 )
            return 2;
        else 
            return 3;
    }

HandleCrawlTransition()

bool HandleCrawlTransition ( int pCurrentCommandID )

inlineprotected

    {
        if ( m_CrawlTransition != -1 )
        {
            StartCommand_Crawl(m_CrawlTransition);
            
            m_CrawlTransition = -1;
            m_IsCrawling = true;
            SetSynchDirty();
            return true;
        }
 
        return pCurrentCommandID == DayZInfectedConstants.COMMANDID_CRAWL;
    }

HandleDamageHit()

bool HandleDamageHit ( int pCurrentCommandID )

inlineprotected

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

Перекрестные ссылки Math::RandomIntInclusive().

HandleDeath()

bool HandleDeath ( int pCurrentCommandID )

inlineprotected

    {
        if ( !IsAlive() || m_FinisherInProgress )
        {
            StartCommand_Death(m_DeathType, m_DamageHitDirection);
            m_MovementSpeed = -1;
            m_MindState = -1;
            SetSynchDirty();
            return true;
        }
 
        return false;
    }   

HandleMindStateChange()

bool HandleMindStateChange ( int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt )

inlineprotected

Mind state change

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

HandleMove()

void HandleMove ( int pCurrentCommandID )

inlineprotected

HandleMove

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

Перекрестные ссылки Math::AbsFloat().

HandleOrientation()

void HandleOrientation ( float pDt, int pCurrentCommandID )

inlineprotected

HandleOrientation

    {
        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)
            {
                m_OrientationSynced = yaw;
                SetSynchDirty();
            }
        }
    }

Перекрестные ссылки Math::AbsInt(), Math::Atan2(), Math::Cos(), Math::DEG2RAD, GetOrientation(), Math::NormalizeAngle(), Math::RAD2DEG, Math::Round() и Math::Sin().

HandleSoundEvents()

void HandleSoundEvents ( )

inlineprotected

Sound (client only)

no sound handler - bail out

infected is dead

stop all sounds

    {
        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()));
    }

HandleVault()

bool HandleVault ( int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt )

inlineprotected

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

Init()

void Init ( )

inlineprotected

sets default hit position and cache it here (mainly for impact particles)

client only

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

Перекрестные ссылки GetDefaultHitPositionComponent(), GetGame(), InfectedSoundEventHandler(), m_AllTargetObjects, m_ArrowManager и m_TargetableObjects.

IsBeingBackstabbed()

override bool IsBeingBackstabbed ( )

inlineprotected

returns true if backstab is in progress; used for suspending of AI targeting and other useful things besides

    {
        return m_FinisherInProgress;
    }

IsCrawling()

bool IsCrawling ( )

inlineprotected

returns true if crawling; 'DayZInfectedCommandCrawl' is only for the transition, after that it remains 'DayZInfectedCommandMove' (unreliable)

    {
        return m_IsCrawling;
    }

IsDanger()

override bool IsDanger ( )

inlineprotected

    {
        return true;
    }

IsHealthVisible()

override bool IsHealthVisible ( )

inlineprotected

    {
        return false;
    }

IsMale()

bool IsMale ( )

inlineprotected

    {
        return true;
    }

IsManagingArrows()

override bool IsManagingArrows ( )

inlineprotected

    {
        return true;
    }

IsRefresherSignalingViable()

override bool IsRefresherSignalingViable ( )

inlineprotected

    {
        return false;
    }

IsSelfAdjustingTemperature()

override bool IsSelfAdjustingTemperature ( )

inlineprotected

    {
        return IsAlive();
    }

IsZombie()

override bool IsZombie ( )

inlineprotected

    {
        return true;
    }

IsZombieMilitary()

override bool IsZombieMilitary ( )

inlineprotected

    {
        return false;
    }

OnRecoverFromDeath()

void OnRecoverFromDeath ( )

inlineprotected

    {
        // enable AI simulation again
        GetAIAgent().SetKeepInIdle(false);
 
        // reset flag
        m_FinisherInProgress = false;
    }

OnSoundVoiceEvent()

override void OnSoundVoiceEvent ( int event_id, string event_user_string )

inlineprotected

stop state sound when playing anim SoundVoice

stop playing of old SoundVoice from anim (if any)

play new SoundVoice from anim

    {
        //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();
        }
    }

Перекрестные ссылки AbstractWave::Stop().

OnVariablesSynchronized()

override void OnVariablesSynchronized ( )

inlineprotected

synced variable(s) handler

    {
        DebugSound("[Infected @ " + this + "][OnVariablesSynchronized]");
        HandleSoundEvents();
        
        if ( m_OrientationLocal != m_OrientationSynced )
        {
            m_OrientationLocal = m_OrientationSynced;
        }
    }

ProcessSoundVoiceEvent()

void ProcessSoundVoiceEvent ( AnimSoundVoiceEvent sound_event, out AbstractWave aw )

inlineprotected

    {
        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, NoiseAIEvaluate.GetNoiseReduction(GetGame().GetWeather()));
        }
    }

Перекрестные ссылки GetGame(), NoiseAIEvaluate::GetNoiseReduction(), GetPosition, PlaySound() и SoundObject().

ProcessVoiceFX()

AbstractWave ProcessVoiceFX ( string pSoundSetName )

inlineprotected

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

Перекрестные ссылки GetGame(), PlaySound(), SoundObject() и SoundObjectBuilder().

SetBeingBackstabbed()

override void SetBeingBackstabbed ( int backstabType )

inlineprotected

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

SetDefaultHitPosition()

vector SetDefaultHitPosition ( string pSelection )

inlineprotected

    {
        return GetSelectionPositionMS(pSelection);
    }

ZombieBase()

void ZombieBase ( )

inlineprotected

    {
        Init();
    }

Перекрестные ссылки Init().

Поля

HIT_INTERVAL_MIN

const float HIT_INTERVAL_MIN = 0.3

protected

m_ActiveVaultType

int m_ActiveVaultType = -1

protected

HandleVault

m_ActualAttackType

DayZInfectedAttackType m_ActualAttackType = null

protected

m_ActualTarget

EntityAI m_ActualTarget = null

protected

Combat

m_AllTargetObjects

ref array<Object> m_AllTargetObjects

protected

m_ArrowManager

ref ArrowManagerBase m_ArrowManager

protected

m_AttackCooldownTime

float m_AttackCooldownTime = 0

protected

m_CrawlTransition

int m_CrawlTransition = -1

protected

Crawl transition

m_DamageHitDirection

float m_DamageHitDirection = 0

protected

HandleDeath

m_DamageHitHeavy

bool m_DamageHitHeavy = false

protected

m_DamageHitToProcess

bool m_DamageHitToProcess = false

protected

Damage hits

m_DamageHitType

int m_DamageHitType = 0

protected

m_DeathType

int m_DeathType = 0

protected

m_DefaultHitPosition

vector m_DefaultHitPosition

protected

m_DeltaTime

float m_DeltaTime

protected

m_FinisherInProgress

bool m_FinisherInProgress = false

protected

m_HitElapsedTime

float m_HitElapsedTime = HIT_INTERVAL_MIN

protected

m_InfectedSoundEventHandler

ref InfectedSoundEventHandler m_InfectedSoundEventHandler

protected

m_IsCrawling

bool m_IsCrawling

protected

m_KnuckleLand

bool m_KnuckleLand = false

protected

m_KnuckleOutTimer

float m_KnuckleOutTimer = 0

protected

m_LastMindState

int m_LastMindState = -1

protected

m_LastMovementSpeed

float m_LastMovementSpeed = -1

protected

m_LastSoundVoiceAW

AbstractWave m_LastSoundVoiceAW

protected

m_MindState

int m_MindState = -1

protected

m_MovementSpeed

float m_MovementSpeed = -1

protected

m_OrientationLocal

int m_OrientationLocal = -1

protected

m_OrientationSynced

int m_OrientationSynced = -1

protected

m_OrientationTimer

float m_OrientationTimer

protected

m_ShockDamage

float m_ShockDamage = 0

protected

m_StanceVariation

int m_StanceVariation = 0

protected

server / singleplayer properties

m_TargetableObjects

ref array<typename> m_TargetableObjects

protected

ORIENTATION_SYNC_THRESHOLD

const float ORIENTATION_SYNC_THRESHOLD = 30

private

SHOCK_TO_STUN_MULTIPLIER

const float SHOCK_TO_STUN_MULTIPLIER = 2.82

private

TARGET_CONE_ANGLE_CHASE

const float TARGET_CONE_ANGLE_CHASE = 20

private

TARGET_CONE_ANGLE_FIGHT

const float TARGET_CONE_ANGLE_FIGHT = 30

private

---

Объявления и описания членов класса находятся в файле:

• D:/Ishodniki/scripts/4_World/Entities/Creatures/Infected/ZombieBase.c