DayZInfected Class Reference

Collaboration diagram for DayZInfected:

Protected Member Functions
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 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 ()

Protected Attributes
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

Private Attributes
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

Detailed Description

Definition at line 1 of file ZombieBase.c.

Member Function Documentation

AddArrow()

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

inlineprotected

Definition at line 1052 of file ZombieBase.c.

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

References AddChild(), CachedObjectsArrays::ARRAY_STRING, GetBoneIndexByName(), GetTransformWS(), Math3D::MatrixInvMultiply4(), Math3D::MatrixOrthogonalize4(), Math::RAD2DEG, and Math3D::YawPitchRollMatrix().

CanBeBackstabbed()

override bool DayZInfected::CanBeBackstabbed ( )

inlineprotected

Definition at line 120 of file ZombieBase.c.

  {
    return true;
  }

CanBeSkinned()

override bool DayZInfected::CanBeSkinned ( )

inlineprotected

Definition at line 131 of file ZombieBase.c.

  {
    return false;
  }

CanReceiveAttachment()

override bool DayZInfected::CanReceiveAttachment ( EntityAI attachment, int slotId )

inlineprotected

Definition at line 990 of file ZombieBase.c.

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

ChaseAttackLogic()

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

inlineprotected

do not attack players in vehicle - hotfix

target is outside the targeting cone; skip attack

Definition at line 641 of file ZombieBase.c.

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

References DayZPlayerUtils(), vector::Distance(), GetPosition, m_AllTargetObjects, DayZInfectedAttackType::m_Cooldown, DayZInfectedAttackType::m_Distance, DayZInfectedAttackType::m_Subtype, m_TargetableObjects, and DayZInfectedAttackType::m_Type.

CommandHandler()

void DayZInfected::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

Definition at line 190 of file ZombieBase.c.

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

References GetInputController(), ModCommandHandlerAfter(), ModCommandHandlerBefore(), ModCommandHandlerInside(), and StartCommand_Move().

CommandHandlerDebug()

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

inlineprotected

CommandHandlerDebug

Definition at line 257 of file ZombieBase.c.

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

References GetPluginManager().

ComputeHitDirectionAngle()

float DayZInfected::ComputeHitDirectionAngle ( EntityAI pSource )

inlineprotected

Definition at line 876 of file ZombieBase.c.

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

References Math::Acos(), vector::Dot(), GetPosition, and Math::RAD2DEG.

ComputeHitDirectionAngleEx()

float DayZInfected::ComputeHitDirectionAngleEx ( EntityAI pSource, int invertHitDir = 0 )

inlineprotected

Definition at line 897 of file ZombieBase.c.

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

References Math::Acos(), vector::Dot(), GetPosition, and Math::RAD2DEG.

DebugSound()

void DayZInfected::DebugSound ( string s )

inlineprotected

sound debug messages

Definition at line 967 of file ZombieBase.c.

  {
    //Print(s);
  }

EEHitBy()

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

inlineprotected

Events from damage system

Definition at line 928 of file ZombieBase.c.

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

References component.

EEHitByRemote()

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

inlineprotected

Definition at line 961 of file ZombieBase.c.

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

References component.

EOnContact()

void DayZInfected::EOnContact ( IEntity other, Contact extra )

inlineprotected

Phx contact event

Definition at line 977 of file ZombieBase.c.

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

References GetGame().

EOnInit()

override void DayZInfected::EOnInit ( IEntity other, int extra )

inlineprotected

Definition at line 89 of file ZombieBase.c.

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

References GetCommand_Move(), GetGame(), and Math::RandomInt().

EvaluateCrawlTransitionAnimation()

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

inlineprotected

Definition at line 773 of file ZombieBase.c.

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

References vector::Dot(), and GetPosition.

EvaluateDamageHitAnimation()

bool DayZInfected::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

Definition at line 849 of file ZombieBase.c.

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

References GetGame().

EvaluateDeathAnimation()

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

inlineprotected

anim type

direction

add some impulse if needed

Definition at line 343 of file ZombieBase.c.

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

References dBodyApplyImpulse(), and GetGame().

EvaluateDeathAnimationEx()

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

inlineprotected

Definition at line 336 of file ZombieBase.c.

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

FightAttackLogic()

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

inlineprotected

do not attack players in vehicle - hotfix

target is outside the targeting cone; skip attack

Definition at line 680 of file ZombieBase.c.

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

References GameConstants::AI_ATTACKSPEED, DayZPlayerUtils(), vector::Distance(), GetPosition, m_AllTargetObjects, DayZInfectedAttackType::m_Cooldown, DayZInfectedAttackType::m_Distance, DayZInfectedAttackType::m_Subtype, m_TargetableObjects, and DayZInfectedAttackType::m_Type.

FightLogic()

bool DayZInfected::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

Definition at line 578 of file ZombieBase.c.

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

References Math::AbsFloat(), GameConstants::AI_MAX_BLOCKABLE_ANGLE, Math3D::AngleFromPosition(), vector::DistanceSq(), EntityAI::GetMeleeTargetType(), GetPosition, DayZInfectedAttackType::m_AmmoType, DayZInfectedAttackType::m_Distance, DayZInfectedAttackType::m_IsHeavy, and Math::RAD2DEG.

GetArrowManager()

override ArrowManagerBase DayZInfected::GetArrowManager ( )

inlineprotected

Definition at line 1093 of file ZombieBase.c.

  {
    return m_ArrowManager;
  }

References m_ArrowManager.

GetAttackPitch()

int DayZInfected::GetAttackPitch ( EntityAI target )

inlineprotected

no default hit pos fallback

Definition at line 725 of file ZombieBase.c.

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

References Math::AbsFloat(), GetPosition, and vector::Zero.

GetBootsType()

override AnimBootsType DayZInfected::GetBootsType ( )

inlineprotected

Definition at line 126 of file ZombieBase.c.

  {
    return AnimBootsType.Boots;
  }

GetCenter()

override vector DayZInfected::GetCenter ( )

inlineprotected

Definition at line 997 of file ZombieBase.c.

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

References GetBoneIndexByName().

GetDefaultHitComponent()

override string DayZInfected::GetDefaultHitComponent ( )

inlineprotected

returns default hit component (fallback)

Definition at line 153 of file ZombieBase.c.

  {
    return GetDayZInfectedType().GetDefaultHitComponent();
  }

GetDefaultHitPosition()

override vector DayZInfected::GetDefaultHitPosition ( )

inlineprotected

Definition at line 158 of file ZombieBase.c.

  {
    return m_DefaultHitPosition;
  }

GetHitComponentForAI()

override string DayZInfected::GetHitComponentForAI ( )

inlineprotected

returns hit component for attacking AI

Definition at line 147 of file ZombieBase.c.

  {
    return GetDayZInfectedType().GetHitComponentForAI();
  }

GetMindStateSynced()

int DayZInfected::GetMindStateSynced ( )

inlineprotected

Definition at line 174 of file ZombieBase.c.

  {
    return m_MindState;
  }

GetOrientationSynced()

int DayZInfected::GetOrientationSynced ( )

inlineprotected

returns rounded zombie yaw for sync purposes

Definition at line 180 of file ZombieBase.c.

  {
    return m_OrientationSynced;
  }

GetSuitableFinisherHitComponents()

override array< string > DayZInfected::GetSuitableFinisherHitComponents ( )

inlineprotected

returns suitable hit components for finisher attacks; DEPRECATED

Definition at line 169 of file ZombieBase.c.

  {
    return GetDayZInfectedType().GetSuitableFinisherHitComponents();
  }

GetVaultType()

int DayZInfected::GetVaultType ( float height )

inlineprotected

Definition at line 374 of file ZombieBase.c.

  {
    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 DayZInfected::HandleCrawlTransition ( int pCurrentCommandID )

inlineprotected

Definition at line 758 of file ZombieBase.c.

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

HandleDamageHit()

bool DayZInfected::HandleDamageHit ( int pCurrentCommandID )

inlineprotected

Definition at line 814 of file ZombieBase.c.

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

References Math::RandomIntInclusive().

HandleDeath()

bool DayZInfected::HandleDeath ( int pCurrentCommandID )

inlineprotected

Definition at line 322 of file ZombieBase.c.

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

References StartCommand_Death().

HandleMindStateChange()

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

inlineprotected

Mind state change

Definition at line 423 of file ZombieBase.c.

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

References GetCommand_Move().

HandleMove()

void DayZInfected::HandleMove ( int pCurrentCommandID )

inlineprotected

HandleMove

Definition at line 271 of file ZombieBase.c.

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

References Math::AbsFloat(), and GetInputController().

HandleOrientation()

void DayZInfected::HandleOrientation ( float pDt, int pCurrentCommandID )

inlineprotected

HandleOrientation

Definition at line 286 of file ZombieBase.c.

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

References Math::AbsInt(), Math::Atan2(), Math::Cos(), Math::DEG2RAD, GetOrientation(), Math::NormalizeAngle(), Math::RAD2DEG, Math::Round(), and Math::Sin().

HandleSoundEvents()

void DayZInfected::HandleSoundEvents ( )

inlineprotected

Sound (client only)

no sound handler - bail out

infected is dead

stop all sounds

Definition at line 460 of file ZombieBase.c.

  {
    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 DayZInfected::HandleVault ( int pCurrentCommandID, DayZInfectedInputController pInputController, float pDt )

inlineprotected

Definition at line 386 of file ZombieBase.c.

  {
    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 DayZInfected::Init ( )

inlineprotected

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

client only

Definition at line 47 of file ZombieBase.c.

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

References GetDefaultHitPositionComponent(), GetGame(), InfectedSoundEventHandler(), m_AllTargetObjects, m_ArrowManager, and m_TargetableObjects.

IsBeingBackstabbed()

override bool DayZInfected::IsBeingBackstabbed ( )

inlineprotected

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

Definition at line 1003 of file ZombieBase.c.

  {
    return m_FinisherInProgress;
  }

IsCrawling()

bool DayZInfected::IsCrawling ( )

inlineprotected

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

Definition at line 1035 of file ZombieBase.c.

  {
    return m_IsCrawling;
  }

IsDanger()

override bool DayZInfected::IsDanger ( )

inlineprotected

Definition at line 105 of file ZombieBase.c.

  {
    return true;
  }

IsHealthVisible()

override bool DayZInfected::IsHealthVisible ( )

inlineprotected

Definition at line 136 of file ZombieBase.c.

  {
    return false;
  }

IsMale()

bool DayZInfected::IsMale ( )

inlineprotected

Definition at line 115 of file ZombieBase.c.

  {
    return true;
  }

IsManagingArrows()

override bool DayZInfected::IsManagingArrows ( )

inlineprotected

Definition at line 1088 of file ZombieBase.c.

  {
    return true;
  }

IsRefresherSignalingViable()

override bool DayZInfected::IsRefresherSignalingViable ( )

inlineprotected

Definition at line 141 of file ZombieBase.c.

  {
    return false;
  }

IsZombie()

override bool DayZInfected::IsZombie ( )

inlineprotected

Definition at line 100 of file ZombieBase.c.

  {
    return true;
  }

IsZombieMilitary()

override bool DayZInfected::IsZombieMilitary ( )

inlineprotected

Definition at line 110 of file ZombieBase.c.

  {
    return false;
  }

OnRecoverFromDeath()

void DayZInfected::OnRecoverFromDeath ( )

inlineprotected

Definition at line 1041 of file ZombieBase.c.

  {
    // enable AI simulation again
    GetAIAgent().SetKeepInIdle(false);
 
    // reset flag
    m_FinisherInProgress = false;
 
    //Print("DbgZombies | DumbZombie off: " + GetGame().GetTime());
  }

OnSoundVoiceEvent()

override void DayZInfected::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

Definition at line 521 of file ZombieBase.c.

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

References AbstractWave::Stop().

OnVariablesSynchronized()

override void DayZInfected::OnVariablesSynchronized ( )

inlineprotected

synced variable(s) handler

Definition at line 79 of file ZombieBase.c.

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

ProcessSoundVoiceEvent()

void DayZInfected::ProcessSoundVoiceEvent ( AnimSoundVoiceEvent sound_event, out AbstractWave aw )

inlineprotected

Definition at line 548 of file ZombieBase.c.

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

References GetGame(), GetPosition, PlaySound(), and SoundObject().

ProcessVoiceFX()

AbstractWave DayZInfected::ProcessVoiceFX ( string pSoundSetName )

inlineprotected

Definition at line 497 of file ZombieBase.c.

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

References GetGame(), PlaySound(), SoundObject(), and SoundObjectBuilder().

SetBeingBackstabbed()

override void DayZInfected::SetBeingBackstabbed ( int backstabType )

inlineprotected

Definition at line 1008 of file ZombieBase.c.

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

SetDefaultHitPosition()

vector DayZInfected::SetDefaultHitPosition ( string pSelection )

inlineprotected

Definition at line 163 of file ZombieBase.c.

  {
    return GetSelectionPositionMS(pSelection);
  }

ZombieBase()

void DayZInfected::ZombieBase ( )

inlineprotected

Definition at line 42 of file ZombieBase.c.

  {
    Init();
  }

References Init().

Member Data Documentation

HIT_INTERVAL_MIN

const float DayZInfected::HIT_INTERVAL_MIN = 0.3

protected

Definition at line 811 of file ZombieBase.c.

m_ActiveVaultType

int DayZInfected::m_ActiveVaultType = -1

protected

HandleVault

Definition at line 372 of file ZombieBase.c.

m_ActualAttackType

DayZInfectedAttackType DayZInfected::m_ActualAttackType = null

protected

Definition at line 576 of file ZombieBase.c.

m_ActualTarget

EntityAI DayZInfected::m_ActualTarget = null

protected

Combat

Definition at line 574 of file ZombieBase.c.

m_AllTargetObjects

ref array<Object> DayZInfected::m_AllTargetObjects

protected

Definition at line 29 of file ZombieBase.c.

m_ArrowManager

ref ArrowManagerBase DayZInfected::m_ArrowManager

protected

Definition at line 38 of file ZombieBase.c.

m_AttackCooldownTime

float DayZInfected::m_AttackCooldownTime = 0

protected

Definition at line 575 of file ZombieBase.c.

m_CrawlTransition

int DayZInfected::m_CrawlTransition = -1

protected

Crawl transition

Definition at line 756 of file ZombieBase.c.

m_DamageHitDirection

float DayZInfected::m_DamageHitDirection = 0

protected

HandleDeath

Definition at line 319 of file ZombieBase.c.

m_DamageHitHeavy

bool DayZInfected::m_DamageHitHeavy = false

protected

Definition at line 807 of file ZombieBase.c.

m_DamageHitToProcess

bool DayZInfected::m_DamageHitToProcess = false

protected

Damage hits

Definition at line 805 of file ZombieBase.c.

m_DamageHitType

int DayZInfected::m_DamageHitType = 0

protected

Definition at line 808 of file ZombieBase.c.

m_DeathType

int DayZInfected::m_DeathType = 0

protected

Definition at line 320 of file ZombieBase.c.

m_DefaultHitPosition

vector DayZInfected::m_DefaultHitPosition

protected

Definition at line 23 of file ZombieBase.c.

m_DeltaTime

float DayZInfected::m_DeltaTime

protected

Definition at line 24 of file ZombieBase.c.

m_FinisherInProgress

bool DayZInfected::m_FinisherInProgress = false

protected

Definition at line 36 of file ZombieBase.c.

m_HitElapsedTime

float DayZInfected::m_HitElapsedTime = HIT_INTERVAL_MIN

protected

Definition at line 812 of file ZombieBase.c.

m_InfectedSoundEventHandler

ref InfectedSoundEventHandler DayZInfected::m_InfectedSoundEventHandler

protected

Definition at line 27 of file ZombieBase.c.

m_IsCrawling

bool DayZInfected::m_IsCrawling

protected

Definition at line 34 of file ZombieBase.c.

m_KnuckleLand

bool DayZInfected::m_KnuckleLand = false

protected

Definition at line 14 of file ZombieBase.c.

m_KnuckleOutTimer

float DayZInfected::m_KnuckleOutTimer = 0

protected

Definition at line 15 of file ZombieBase.c.

m_LastMindState

int DayZInfected::m_LastMindState = -1

protected

Definition at line 11 of file ZombieBase.c.

m_LastMovementSpeed

float DayZInfected::m_LastMovementSpeed = -1

protected

Definition at line 12 of file ZombieBase.c.

m_LastSoundVoiceAW

AbstractWave DayZInfected::m_LastSoundVoiceAW

protected

Definition at line 26 of file ZombieBase.c.

m_MindState

int DayZInfected::m_MindState = -1

protected

Definition at line 17 of file ZombieBase.c.

m_MovementSpeed

float DayZInfected::m_MovementSpeed = -1

protected

Definition at line 21 of file ZombieBase.c.

m_OrientationLocal

int DayZInfected::m_OrientationLocal = -1

protected

Definition at line 18 of file ZombieBase.c.

m_OrientationSynced

int DayZInfected::m_OrientationSynced = -1

protected

Definition at line 19 of file ZombieBase.c.

m_OrientationTimer

float DayZInfected::m_OrientationTimer

protected

Definition at line 20 of file ZombieBase.c.

m_ShockDamage

float DayZInfected::m_ShockDamage = 0

protected

Definition at line 809 of file ZombieBase.c.

m_StanceVariation

int DayZInfected::m_StanceVariation = 0

protected

server / singleplayer properties

Definition at line 10 of file ZombieBase.c.

m_TargetableObjects

ref array<typename> DayZInfected::m_TargetableObjects

protected

Definition at line 30 of file ZombieBase.c.

ORIENTATION_SYNC_THRESHOLD

const float DayZInfected::ORIENTATION_SYNC_THRESHOLD = 30

private

Definition at line 5 of file ZombieBase.c.

SHOCK_TO_STUN_MULTIPLIER

const float DayZInfected::SHOCK_TO_STUN_MULTIPLIER = 2.82

private

Definition at line 7 of file ZombieBase.c.

TARGET_CONE_ANGLE_CHASE

const float DayZInfected::TARGET_CONE_ANGLE_CHASE = 20

private

Definition at line 3 of file ZombieBase.c.

TARGET_CONE_ANGLE_FIGHT

const float DayZInfected::TARGET_CONE_ANGLE_FIGHT = 30

private

Definition at line 4 of file ZombieBase.c.

---

The documentation for this class was generated from the following file:

• scripts/4_World/Entities/Creatures/Infected/ZombieBase.c