dayzinfectedtype.c

Go to the documentation of this file.

class DayZInfectedAttackType
{
 float m_Distance; // [m]
 int m_Pitch; // 1 = up, 0 = center, -1 = down
 int m_Type; // int argument for attack command
 float m_Subtype; // float argument for attack command
 string m_AmmoType; // ammotype from config
 int m_IsHeavy; // 0 - light attack; 1 - heavy attack; -> Heavy attack is not blockable
 float m_Cooldown; // [s]
 float m_Probability; // [0..1]
};
 
enum DayZInfectedAttackGroupType
{
 CHASE,
 FIGHT
}
 
class DayZInfectedType extends DayZCreatureAIType
{
 //--------------------------------------------------------
 // Public
 //--------------------------------------------------------
 void RegisterHitComponentsForAI()
 {
 m_HitComponentsForAI = new array<ref DayZAIHitComponent>;
 
 m_DefaultHitComponent = "Torso";
 m_DefaultHitPositionComponent = "Spine1";
 
 m_SuitableFinisherHitComponents = new array<string>;
 m_SuitableFinisherHitComponents.Insert("Head");
 m_SuitableFinisherHitComponents.Insert("Neck");
 m_SuitableFinisherHitComponents.Insert("Torso");
 
 DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "Head", 2);
 DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "LeftArm", 50);
 DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "Torso", 65);
 DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "RightArm", 50);
 DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "LeftLeg", 50);
 DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "RightLeg", 50);
 }
 
 void RegisterAttacks()
 {
 
 string lightAttPath = string.Format("cfgVehicles %1 AttackActions AttackShort ammoType", GetName());
 string heavyAttPath = string.Format("cfgVehicles %1 AttackActions AttackLong ammoType", GetName());
 string chaseAttPath = string.Format("cfgVehicles %1 AttackActions AttackRun ammoType", GetName());
 
 string lightAttAmmo;
 GetGame().ConfigGetText(lightAttPath, lightAttAmmo);
 string heavyAttAmmo;
 GetGame().ConfigGetText(heavyAttPath, heavyAttAmmo);
 string chaseAttAmmo;
 GetGame().ConfigGetText(chaseAttPath, chaseAttAmmo);
 
 m_ChaseAttacksGroup = new array<ref DayZInfectedAttackType>;
 
 RegisterAttack(DayZInfectedAttackGroupType.CHASE, /*3.0*/2.4, -1, 0, 1, chaseAttAmmo, 0, 0.3, 1.0); // center left & light
 RegisterAttack(DayZInfectedAttackGroupType.CHASE, /*3.0*/2.4, -1, 1, 1, chaseAttAmmo, 0, 0.4, 1.0); // center right & light
 
 m_FightAttacksGroup = new array<ref DayZInfectedAttackType>;
 
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.0*/1.7, 1, 0, 0, lightAttAmmo, 0, 0.3, 0.7); // up left & light
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.0*/1.7, 1, 1, 0, lightAttAmmo, 0, 0.4, 0.7); // up right & light
 
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.0*/1.7, 0, 0, 1, lightAttAmmo, 0, 0.1, 0.9); // center left & light
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.0*/1.7, 0, 1, 1, lightAttAmmo, 0, 0.2, 0.9); // center right & light
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.5*/1.4, 0, 2, 1, heavyAttAmmo, 0/*1*/, 0.3, 0.6); // center left & heavy
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.5*/1.4, 0, 3, 1, heavyAttAmmo, 0/*1*/, 0.4, 0.6); // center right & heavy
 
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.0*/1.7, -1, 0, 2, lightAttAmmo, 0, 0.2, 0.5); // down left & light
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.0*/1.7, -1, 1, 2, lightAttAmmo, 0, 0.3, 0.4); // down right & light
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.5*/1.4, -1, 2, 2, heavyAttAmmo, 0/*1*/, 0.5, 0.8); // down left & heavy
 RegisterAttack(DayZInfectedAttackGroupType.FIGHT, /*2.5*/1.4, -1, 3, 2, heavyAttAmmo, 0/*1*/, 0.6, 0.8); // down right & heavy
 }
 
 DayZInfectedAttackType ChooseAttack(DayZInfectedAttackGroupType pAttackGroupType, float pDistance, int pPitch)
 {
 array<ref DayZInfectedAttackType> attackGroup = GetAttackGroup(pAttackGroupType);
 float rnd;
 float highestUtility = -1;
 DayZInfectedAttackType mostSuitableAttack = null;
 
 Math.Randomize(GetWorldTime() + (int)pDistance);
 
 for (int i = 0; i < attackGroup.Count(); ++i)
 {
 rnd = Math.RandomFloat01();
 DayZInfectedAttackType attackType = attackGroup.Get(i);
 float utility = ComputeAttackUtility(attackType, pDistance, pPitch, rnd);
 if (utility <= 0)
 continue;
 
 if (utility > highestUtility)
 {
 mostSuitableAttack = attackType;
 highestUtility = utility;
 }
 }
 
 //Print("Most sutable attack selected: " + mostSuitableAttack);
 return mostSuitableAttack;
 }
 
 string GetHitComponentForAI()
 {
 string hitComp;
 
 if (DayZAIHitComponentHelpers.SelectMostProbableHitComponent(m_HitComponentsForAI, hitComp))
 {
 return hitComp;
 } 
 
 return GetDefaultHitComponent();
 }
 
 string GetDefaultHitComponent()
 {
 return m_DefaultHitComponent;
 }
 
 string GetDefaultHitPositionComponent()
 {
 return m_DefaultHitPositionComponent;
 }
 
 array<string> GetSuitableFinisherHitComponents()
 {
 return m_SuitableFinisherHitComponents;
 }
 
 //--------------------------------------------------------
 // Protected
 //--------------------------------------------------------
 
 protected void RegisterAttack(DayZInfectedAttackGroupType pAttackGroupType, float pDistance, int pPitch, int pType, float pSubtype, string pAmmoType, int pIsHeavy, float pCooldown, float pProbability)
 {
 DayZInfectedAttackType newType = new DayZInfectedAttackType();
 
 newType.m_Distance = pDistance;
 newType.m_Pitch = pPitch;
 newType.m_Type = pType; //If attack is left or right
 newType.m_Subtype = pSubtype; //If attack is center, down, up or run
 newType.m_AmmoType = pAmmoType;
 newType.m_IsHeavy = pIsHeavy;
 newType.m_Cooldown = pCooldown;
 newType.m_Probability = pProbability;
 
 GetAttackGroup(pAttackGroupType).Insert(newType);
 }
 
 protected float ComputeAttackUtility(DayZInfectedAttackType pAttackType, float pTargetDistance, int pPitch, float pProbability)
 {
 // pitch
 if (pAttackType.m_Pitch != pPitch)
 return 0;
 
 // distance
 float distDiff = pAttackType.m_Distance - pTargetDistance;
 if (distDiff < 0)
 return 0;
 
 float distDiffFrac = distDiff / 10;
 float utilityDistance = (1 - distDiffFrac) * 100; // distance is most important
 
 // probability
 float probDiff = pAttackType.m_Probability - pProbability;
 if (probDiff < 0)
 return 0;
 
 float utilityProbability = (1 - probDiff) * 10; // distance is most important
 
 // total
 float util = utilityDistance + utilityProbability;
 //Print("Attack Utility " + util);
 
 return util;
 }
 
 protected array<ref DayZInfectedAttackType> GetAttackGroup(DayZInfectedAttackGroupType pType)
 {
 switch (pType)
 {
 case DayZInfectedAttackGroupType.CHASE:
 return m_ChaseAttacksGroup;
 
 case DayZInfectedAttackGroupType.FIGHT:
 return m_FightAttacksGroup;
 }
 
 return NULL;
 }
 
 //--------------------------------------------------------
 // Members
 //--------------------------------------------------------
 
 private ref array<ref DayZInfectedAttackType> m_ChaseAttacksGroup;
 private ref array<ref DayZInfectedAttackType> m_FightAttacksGroup;
 
 protected ref array<ref DayZAIHitComponent> m_HitComponentsForAI;
 protected string m_DefaultHitComponent;
 protected string m_DefaultHitPositionComponent;
 protected ref array<string> m_SuitableFinisherHitComponents;
}