DayZAnimal.c

Go to the documentation of this file.

class DayZCreatureAnimInterface
{
  private void DayZCreatureAnimInterface() {}
  private void ~DayZCreatureAnimInterface() {}
 
  //-----------------------------------------------------
  // Binds, returns -1 when error, otherwise if ok
 
  proto native TAnimGraphCommand BindCommand(string pCommandName);
 
  proto native TAnimGraphVariable BindVariableFloat(string pVariable);
  proto native TAnimGraphVariable BindVariableInt(string pVariable);
  proto native TAnimGraphVariable BindVariableBool(string pVariable);
 
  proto native TAnimGraphTag BindTag(string pTagName);
 
  proto native TAnimGraphEvent BindEvent(string pEventName);
}
 
class DayZCreature extends EntityAI
{
#ifdef _DAYZ_CREATURE_DEBUG_SHADOW
  proto native void DebugSetShadow(DayZCreature creature);
#endif
 
  proto native bool RegisterAnimationEvent(string event_name, string function_name);
 
  proto native void SetAnimationInstanceByName(string animation_instance_name, int instance_uuid, float duration);
  proto native int GetCurrentAnimationInstanceUUID();
 
  proto native DayZCreatureAnimInterface GetAnimInterface();
 
 
  proto native void UpdateSimulationPrecision(int simLOD);
 
  //---------------------------------------------------------
  // helper functions for disabling simulation upon death
  proto native void StartDeath();
  proto native void ResetDeath();
 
  proto native void ResetDeathCooldown();
  proto native bool IsDeathProcessed();
  proto native bool IsDeathConditionMet();
 
  //---------------------------------------------------------
  // bone transforms
 
  proto native int GetBoneIndexByName(string pBoneName);
 
  override bool IsDayZCreature()
  {
    return true;
  }
 
  override bool CanBeSkinned()
  {
    return true;
  }
 
  override bool IsIgnoredByConstruction()
  {
    return IsRuined();
  }
 
  override bool IsManagingArrows()
  {
    return true;
  }
 
  override void AddArrow(Object arrow, int componentIndex, vector closeBonePosWS, vector closeBoneRotWS)
  {
    CachedObjectsArrays.ARRAY_STRING.Clear();
    GetActionComponentNameList(componentIndex, CachedObjectsArrays.ARRAY_STRING, "fire");
 
    int pivot = -1;
 
 
    for (int i = 0; i < CachedObjectsArrays.ARRAY_STRING.Count() && pivot == -1; i++)
      pivot = GetBoneIndexByName(CachedObjectsArrays.ARRAY_STRING.Get(i));
 
    vector parentTransMat[4];
    vector arrowTransMat[4];
 
    if (pivot == -1)
      GetTransform(parentTransMat);
    else
    {
      vector rotMatrix[3];
      Math3D.YawPitchRollMatrix(closeBoneRotWS * Math.RAD2DEG, rotMatrix);
 
      parentTransMat[0] = rotMatrix[0];
      parentTransMat[1] = rotMatrix[1];
      parentTransMat[2] = rotMatrix[2];
      parentTransMat[3] = closeBonePosWS;
    }
 
    arrow.GetTransform(arrowTransMat);
    Math3D.MatrixInvMultiply4(parentTransMat, arrowTransMat, arrowTransMat);
    // orthogonalize matrix - parent might be skewed
    Math3D.MatrixOrthogonalize4(arrowTransMat);
    arrow.SetTransform(arrowTransMat);
 
    AddChild(arrow, pivot);
  }
 
  override bool HasFixedActionTargetCursorPosition()
  {
    return true;
  }
 
  //-------------------------------------------------------------
  // these functions are for modded overide in script command mods
 
  bool ModCommandHandlerBefore(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
  {
    return false;
  }
 
  bool ModCommandHandlerInside(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
  {
    return false;
  }
 
  bool ModCommandHandlerAfter(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
  {
    return false;
  }
}
 
class DayZCreatureAI extends DayZCreature
{
  proto native AIAgent GetAIAgent();
 
  proto native bool IsSoundInsideBuilding();
#ifdef DIAG_DEVELOPER
  proto native void DebugDisableAIControl();
  proto native void DebugRestoreAIControl();
#endif
  proto native void AddDamageSphere(string bone_name, string ammo_name, float radius, float duration, bool invertTeams);
 
  proto native DayZCreatureAIType GetCreatureAIType();
  proto native void InitAIAgent(AIGroup group);
  proto native void DestroyAIAgent();
 
  int m_EffectTriggerCount;//how many effect triggers is this AI inside of(overlapping triggers)
 
  protected DayZPlayer m_CinematicPlayer;
 
 
  void DayZCreatureAI()
  {
    RegisterAnimEvents();
    SetFlags(EntityFlags.TOUCHTRIGGERS, false);
  }
 
 
  void IncreaseEffectTriggerCount()
  {
    m_EffectTriggerCount++;
  }
 
  void DecreaseEffectTriggerCount()
  {
    m_EffectTriggerCount--;
  }
 
  void AddDamageSphere(AnimDamageParams damage_params)
  {
    AddDamageSphere(damage_params.m_sBoneName, damage_params.m_sAmmoName, damage_params.m_fRadius, damage_params.m_fDuration, damage_params.m_bInvertTeams);
  }
 
  override void EEKilled(Object killer)
  {
    super.EEKilled(killer);
    CreateComponent(COMP_TYPE_BODY_STAGING); // TO DO: This is never called on clients in multiplayer! That's why skinning doesn't work properly in MP. DAYZ-28269
  }
 
  AnimBootsType GetBootsType()
  {
    return AnimBootsType.None;
  }
 
  AbstractWave PlaySound(SoundObject so, SoundObjectBuilder sob)
  {
    if (so == NULL)
      return NULL;
 
    so.SetPosition(GetPosition());
    AbstractWave wave = GetGame().GetSoundScene().Play3D(so, sob);
    return wave;
  }
 
  void OnSoundEvent(int event_id, string event_user_string)
  {
    AnimSoundEvent sound_event = GetCreatureAIType().GetSoundEvent(event_id);
    if (sound_event != NULL)
      ProcessSoundEvent(sound_event);
  }
 
  void OnSoundVoiceEvent(int event_id, string event_user_string)
  {
    AnimSoundVoiceEvent voice_event = GetCreatureAIType().GetSoundVoiceEvent(event_id);
    if (voice_event != NULL)
      ProcessSoundVoiceEvent(voice_event);
  }
 
  void OnStepEvent(int event_id, string event_user_string)
  {
    AnimStepEvent step_event = GetCreatureAIType().GetStepEvent(event_id);
    if (step_event != NULL)
      ProcessStepEvent(step_event);
  }
 
  void OnDamageEvent(int event_id, string event_user_string)
  {
    AnimDamageEvent damage_event = GetCreatureAIType().GetDamageEvent(event_id);
    if (damage_event != NULL)
      ProcessDamageEvent(damage_event);
  }
 
  protected void RegisterAnimEvents()
  {
    if (!RegisterAnimationEvent("Sound", "OnSoundEvent"))
      Print("Error registering anim. event (Sound)");
 
    if (!RegisterAnimationEvent("SoundVoice", "OnSoundVoiceEvent"))
      Print("Error registering anim. event (SoundVoice)");
 
    if (!GetGame().IsDedicatedServer())
    {
      if (!RegisterAnimationEvent("Step", "OnStepEvent"))
        Print("Error registering anim. event (Step)");
    }
 
    if (!RegisterAnimationEvent("Damage", "OnDamageEvent"))
      Print("Error registering anim. event (Damage)");
  }
 
  private void ProcessSoundEvent(AnimSoundEvent sound_event)
  {
    if (!GetGame().IsDedicatedServer())
    {
      SoundObjectBuilder objectBuilder = sound_event.GetSoundBuilder();
      if (NULL != objectBuilder)
      {
        objectBuilder.AddEnvSoundVariables(GetPosition());
        SoundObject soundObject = objectBuilder.BuildSoundObject();
        PlaySound(soundObject, objectBuilder);
      }
    }
 
    if (GetGame().IsServer())
    {
      if (sound_event.m_NoiseParams != NULL)
        GetGame().GetNoiseSystem().AddNoise(this, sound_event.m_NoiseParams);
    }
  }
 
  private void ProcessSoundVoiceEvent(AnimSoundVoiceEvent sound_event)
  {
    if (!GetGame().IsDedicatedServer())
    {
      SoundObjectBuilder objectBuilder = sound_event.GetSoundBuilder();
      if (NULL != objectBuilder)
      {
        objectBuilder.AddEnvSoundVariables(GetPosition());
        SoundObject soundObject = objectBuilder.BuildSoundObject();
        AttenuateSoundIfNecessary(soundObject);
        PlaySound(soundObject, objectBuilder);
      }
    }
 
    if (GetGame().IsServer())
    {
      if (sound_event.m_NoiseParams != NULL)
        GetGame().GetNoiseSystem().AddNoise(this, sound_event.m_NoiseParams);
    }
  }
 
  private void ProcessStepEvent(AnimStepEvent step_event)
  {
    SoundObjectBuilder soundBuilder = step_event.GetSoundBuilder(GetSurfaceType().Hash());
    if (soundBuilder == NULL)
      return;
 
    soundBuilder.AddEnvSoundVariables(GetPosition());
    SoundObject soundObject = soundBuilder.BuildSoundObject();
    AttenuateSoundIfNecessary(soundObject);
    PlaySound(soundObject, soundBuilder);
 
    //TODO effects
  }
 
  private void ProcessDamageEvent(AnimDamageEvent damage_event)
  {
    AddDamageSphere(damage_event.m_DamageParams);
  }
 
  protected void AttenuateSoundIfNecessary(SoundObject soundObject)
  {
    if (GetGame().GetPlayer() != NULL && (IsSoundInsideBuilding() != GetGame().GetPlayer().IsSoundInsideBuilding() || GetGame().GetPlayer().IsCameraInsideVehicle()))
      soundObject.SetKind(WaveKind.WAVEATTALWAYS);
    else
      soundObject.SetKind(WaveKind.WAVEEFFECTEX);
  }
 
  bool ResistContaminatedEffect()
  {
    return false;
  }
 
  // ================
  // EASTER EGG
  // ================
 
  //Used for easter egg sound selection
  bool IsDanger()
  {
    return false;
  }
 
  string CaptureSound()
  {
    return "";
  }
 
  string ReleaseSound()
  {
    return "";
  }
 
  // ================
  // CINEMATIC CONTROLLER
  // ================
 
  void CinematicTakeControl(DayZPlayer player)
  {
    m_CinematicPlayer = player;
  }
 
  bool CinematicCanJump()
  {
    return true;
  }
 
  override bool ModCommandHandlerBefore(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
  {
    if (!m_CinematicPlayer)
      return super.ModCommandHandlerBefore(pDt, pCurrentCommandID, pCurrentCommandFinished);
 
    UAInterface input = m_CinematicPlayer.GetInputInterface();
 
    DayZCreatureAIInputController controller;
    GetGame().GameScript.CallFunction(this, "GetInputController", controller, 0);
 
    if (!input || !controller)
      return super.ModCommandHandlerBefore(pDt, pCurrentCommandID, pCurrentCommandFinished);
 
    float movementX = input.SyncedValue_ID(UAAimRight) - input.SyncedValue_ID(UAAimLeft);
 
    float maxTurnSpeed = 100.0;
    movementX = Math.Clamp(movementX * maxTurnSpeed * pDt, -180, 180);
 
    if (input.SyncedValue_ID(UALookAround) > 0)
      movementX = 0;
 
    bool isJump = input.SyncedValue_ID(UAGetOver) > 0;
    bool isMove = input.SyncedValue_ID(UAMoveForward) > 0;
 
    bool isRest = input.SyncedValue_ID(UAMoveBack) > 0;
    bool isSleep = input.SyncedValue_ID(UAReloadMagazine) > 0;
 
    float heading = GetOrientation()[0] + movementX;
 
    int iAlert = 0;
    float fAlert = 0;
    int iSpeed = 0;
    float fSpeed = 0;
 
    if (isMove)
    {
      iAlert = 1;
      fAlert = 0.2;
 
      bool isSprint = input.SyncedValue_ID(UATurbo) > 0;
      bool isJog = input.SyncedValue_ID(UAWalkRunTemp) > 0;
      bool isWalk = !isSprint && !isJog;
      if (isSprint)
      {
        iSpeed = 3;
      }
      else if (isJog)
      {
        iSpeed = 2;
      }
      else if (isWalk)
      {
        iSpeed = 1;
      }
    }
 
    DayZAnimalInputController animalController;
    if (Class.CastTo(animalController, controller))
    {
      animalController.OverrideBehaviourSlot(true, DayZAnimalBehaviourSlot.NON_SPECIFIC_THREAT);
      animalController.OverrideBehaviourAction(true, DayZAnimalBehaviourAction.TRAVELING_INPUT);
 
      if (!isMove)
      {
        if (isRest)
        {
          iSpeed = 0;
          animalController.OverrideBehaviourAction(true, DayZAnimalBehaviourAction.IDLE1_INPUT);
        }
 
        if (isSleep)
        {
          iSpeed = 0;
          animalController.OverrideBehaviourAction(true, DayZAnimalBehaviourAction.WALKING_INPUT);
        }
      }
    }
 
    bool lowVel = GetVelocity(this).Length() < 0.5;
    if (iSpeed > 0 && lowVel)
    {
      iAlert = 4;
      fAlert = 1.0;
 
      iSpeed = 3;
    }
 
    if (animalController)
    {
      switch (iSpeed)
      {
      case 0:
        fSpeed = 0;
        break;
      case 1:
        fSpeed = 2;
        break;
      case 2:
        fSpeed = 3;
        break;
      case 3:
        fSpeed = 5;
        break;
      }
    }
 
    controller.OverrideTurnSpeed(true, Math.PI2 / pDt);
    controller.OverrideMovementSpeed(true, fSpeed);
    controller.OverrideHeading(true, heading * Math.DEG2RAD);
    controller.OverrideAlertLevel(true, true, iAlert, fAlert);
 
    if (CinematicCanJump() && isJump)
      controller.OverrideJump(true, 101, 2.0);
 
    return true;
  }
}
 
enum DayZAnimalConstants
{
  COMMANDID_MOVE,
  COMMANDID_JUMP,
  COMMANDID_DEATH,
  COMMANDID_HIT,
  COMMANDID_ATTACK,
  COMMANDID_SCRIPT,
};
 
class DayZAnimalCommandMove extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandAttack extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandJump extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandLookAt extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandBehaviourModifier extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandHit extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandDeath extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandAnimCallback extends AnimCommandBase
{
 
}
 
class DayZAnimalCommandScript extends AnimCommandBase
{
  //void DayZAnimalCommandScript(DayZAnimal pAnimal)
 
  //---------------------------------------------------------------
  // usable everywhere
 
  proto native void SetFlagFinished(bool pFinished);
 
  //---------------------------------------------------------------
  // PrePhys Update
 
  proto native bool PrePhys_GetTranslation(out vector pOutTransl); // vec3 in local space !
  proto native bool PrePhys_GetRotation(out float pOutRot[4]); // quaternion in local space !
  proto native void PrePhys_SetTranslation(vector pInTransl); // vec3 in local space !
  proto native void PrePhys_SetRotation(float pInRot[4]); // quaternion in local space !
 
  //---------------------------------------------------------------
  // PostPhys Update
 
  bool PostPhysUpdate(float pDt);
 
  proto native void PostPhys_GetPosition(out vector pOutTransl); 
  proto native void PostPhys_GetRotation(out float pOutRot[4]); 
  proto native void PostPhys_SetPosition(vector pInTransl); 
  proto native void PostPhys_SetRotation(float pInRot[4]); 
  proto native void PostPhys_LockRotation(); 
}
 
class DayZAnimal extends DayZCreatureAI
{
 
  protected ref array<ref DayZAIHitComponent> m_HitComponentsForAI;
  protected string m_DefaultHitComponent;
  protected string m_DefaultHitPositionComponent;
  protected vector m_DefaultHitPosition;
 
  proto native DayZAnimalInputController GetInputController();
 
  proto native void StartCommand_Death(int pType, int pDirection);
  proto native void StartCommand_Move();
  proto native void StartCommand_Jump();
  proto native void StartCommand_Attack();
  proto native void StartCommand_Hit(int pType, int pDirection);
 
  proto native DayZAnimalCommandScript StartCommand_Script(DayZAnimalCommandScript pInfectedCommand);
  proto native DayZAnimalCommandScript StartCommand_ScriptInst(typename pCallbackClass);
  proto native DayZAnimalCommandScript GetCommand_Script();
 
  proto native void SignalAIAttackStarted();
  proto native void SignalAIAttackEnded();
 
  void DayZAnimal()
  {
    // testing: animals have no inventory by default
    //GetInventory().LockInventory(LOCK_FROM_SCRIPT); // Hides animals from vicinity in inventory. Remove this if wanted otherwise.
 
    m_HitComponentsForAI = new array<ref DayZAIHitComponent>;
 
    RegisterHitComponentsForAI();
 
    m_DefaultHitPosition = SetDefaultHitPosition(GetDefaultHitPositionComponent());
  }
 
  override bool IsHealthVisible()
  {
    return false;
  }
 
  override bool IsAnimal()
  {
    return true;
  }
 
  override bool IsInventoryVisible()
  {
    return false;
  }
 
  override int GetHideIconMask()
  {
    return EInventoryIconVisibility.HIDE_VICINITY;
    /*
      if (IsAlive())
      {
      return EInventoryIconVisibility.HIDE_VICINITY;
      }
      return super.GetHideIconMask();
    */
  }
 
  void CommandHandler(float dt, int currentCommandID, bool currentCommandFinished)
  {
    DayZAnimalInputController inputController = GetInputController();
 
    if (ModCommandHandlerBefore(dt, currentCommandID, currentCommandFinished))
      return;
 
    if (HandleDeath(currentCommandID, inputController))
      return;
 
    if (currentCommandFinished)
    {
      if (currentCommandID == DayZAnimalConstants.COMMANDID_ATTACK)
        SignalAIAttackEnded();
 
      StartCommand_Move();
 
      return;
    }
 
    if (ModCommandHandlerInside(dt, currentCommandID, currentCommandFinished))
      return;
 
    if (HandleDamageHit(currentCommandID))
    {
      if (currentCommandID == DayZAnimalConstants.COMMANDID_ATTACK)
        SignalAIAttackEnded();
      return;
    }
 
    if (currentCommandID == DayZAnimalConstants.COMMANDID_MOVE)
    {
      if (inputController.IsJump())
      {
        StartCommand_Jump();
        return;
      }
 
      if (inputController.IsAttack())
      {
        StartCommand_Attack();
        SignalAIAttackStarted();
        return;
      }
    }
 
    if (ModCommandHandlerAfter(dt, currentCommandID, currentCommandFinished))
      return;
  }
 
  bool m_DamageHitToProcess = false;
  int m_DamageHitType = 0;
  int m_DamageHitDirection = 0;
 
  bool HandleDeath(int currentCommandID, DayZAnimalInputController inputController)
  {
    if (inputController.IsDead())
    {
      if (currentCommandID == DayZAnimalConstants.COMMANDID_DEATH)
        return true;
 
      if (m_DamageHitToProcess)
      {
        m_DamageHitToProcess = false;
 
        StartCommand_Death(m_DamageHitType, m_DamageHitDirection);
      }
      else
        StartCommand_Death(0, 0);
 
      return true;
    }
 
    return false;
  }
 
  bool HandleDamageHit(int currentCommandID)
  {
    if (m_DamageHitToProcess)
    {
      m_DamageHitToProcess = false;
 
      if (currentCommandID != DayZAnimalConstants.COMMANDID_HIT)
        StartCommand_Hit(m_DamageHitType, m_DamageHitDirection);
      return true;
    }
    return false;
  }
 
  override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
  {
    super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
    m_TransportHitRegistered = false;
 
    int transferShockToDamageCoef = g_Game.ConfigGetInt(string.Format("%1 %2 DamageApplied transferShockToDamage", CFG_AMMO, ammo));
    if (transferShockToDamageCoef == 1)
    {
      //Print("DayZAnimal | EEHitBy | nonlethal hit");
      AddHealth("", "Health", -ConvertNonlethalDamage(damageResult.GetDamage(dmgZone, "Shock"), damageType));
    }
    else
    {
      ComponentAnimalBleeding animal_bleeding = ComponentAnimalBleeding.Cast(GetComponent(COMP_TYPE_ANIMAL_BLEEDING));
      animal_bleeding.CreateWound(damageResult, dmgZone, ammo);
    }
 
    int type = 0;
    int direction = 0;
    if (ComputeDamageHitParams(source, dmgZone, ammo, type, direction) == true)
      QueueDamageHit(type, direction);
 
  }
 
  void QueueDamageHit(int type, int direction)
  {
    m_DamageHitToProcess = true;
    m_DamageHitType = type;
    m_DamageHitDirection = direction;
  }
 
  bool ComputeDamageHitParams(EntityAI source, string dmgZone, string ammo, out int type, out int direction)
  {
    type = 0; // not used right now
 
    float angleDeg = ComputeHitDirectionAngleDeg(source);
    direction = TranslateHitAngleDegToDirectionIndex(angleDeg);
 
    direction += FindComponentDirectionOffset(dmgZone);
 
    return true;
  }
 
  float ComputeHitDirectionAngleDeg(EntityAI source)
  {
    vector targetDirection = GetDirection();
    vector toSourceDirection = (source.GetPosition() - GetPosition());
 
    targetDirection[1] = 0;
    toSourceDirection[1] = 0;
 
    targetDirection.Normalize();
    toSourceDirection.Normalize();
 
    float cosFi = vector.Dot(targetDirection, toSourceDirection);
    vector cross = targetDirection * toSourceDirection;
 
    float dirAngleDeg = Math.Acos(cosFi) * Math.RAD2DEG;
    if (cross[1] < 0)
      dirAngleDeg = -dirAngleDeg;
 
    return dirAngleDeg;
  }
 
  int TranslateHitAngleDegToDirectionIndex(float angleDeg)
  {
    if (angleDeg >= -20 && angleDeg <= 20) // front
      return 1;
    else if (angleDeg < 0) // left
      return 2;
 
    return 3; // right
  }
 
  int FindComponentDirectionOffset(string component)
  {
    const int directionCount = 4;
 
    int offset = 0;
    if (component.Length() == 0)
      offset = 0;
    else if (component == "Zone_Head")
      offset = directionCount;
    else if (component == "Zone_Chest" || component == "Zone_Legs_Front" || component == "Zone_Spine_Front" || component == "Zone_Neck")
      offset = 2 * directionCount;
    else
      offset = 3 * directionCount;
 
    return offset;
  }
 
  //-------------------------------------------------------------
 
  override protected void EOnContact(IEntity other, Contact extra)
  {
    if (!IsAlive())
      return;
 
    Transport transport = Transport.Cast(other);
    if (transport)
    {
      if (GetGame().IsServer())
        RegisterTransportHit(transport);
    }
  }
 
  void RegisterHitComponentsForAI()
  {
    m_DefaultHitComponent = "Zone_Chest";
    m_DefaultHitPositionComponent = "Pelvis";
 
    DayZAIHitComponentHelpers.RegisterHitComponent(m_HitComponentsForAI, "Zone_Chest", 50);
  }
 
  override string GetHitComponentForAI()
  {
    string hitComp;
 
    if (DayZAIHitComponentHelpers.SelectMostProbableHitComponent(m_HitComponentsForAI, hitComp))
      return hitComp;
 
    return GetDefaultHitComponent();
  }
 
  override string GetDefaultHitComponent()
  {
    return m_DefaultHitComponent;
  }
 
  override string GetDefaultHitPositionComponent()
  {
    return m_DefaultHitPositionComponent;
  }
 
  override vector GetDefaultHitPosition()
  {
    return m_DefaultHitPosition;
  }
 
  protected vector SetDefaultHitPosition(string pSelection)
  {
    return GetSelectionPositionMS(pSelection);
  }
 
  override protected float ConvertNonlethalDamage(float damage, DamageType damageType)
  {
    switch (damageType)
    {
    case DamageType.CLOSE_COMBAT:
      return damage * GameConstants.NL_DAMAGE_CLOSECOMBAT_CONVERSION_ANIMALS;
    case DamageType.FIRE_ARM:
      return damage * GameConstants.NL_DAMAGE_FIREARM_CONVERSION_ANIMALS;
    }
 
    return super.ConvertNonlethalDamage(damage, damageType);
  }
}