DayZPlayerUtils.c

Go to the documentation of this file.

enum QueryFlags
{
  NONE,
  STATIC,
  DYNAMIC,
  ORIGIN_DISTANCE,
  ONLY_ROADWAYS,
}
 
// *************************************************************************************
// ! DayZPlayerUtils - some utils used for dayz player - static functions
// *************************************************************************************
class DayZPlayerUtils
{
  //--------------------------------------------------
  // Debug Draw
 
  static proto native void EnableDebugDraw(bool pEnable);
  static proto native void DrawDebugText(string text, vector pos, float size);
 
  static proto native void DrawStartFrame();
  static proto native void DrawDebugBox(vector pos, float size, int color);
 
 
  //--------------------------------------------------
  // animation override
 
  static proto native bool DebugOverrideAnimationTranslation(string pAnimName, vector pTranslation);
 
  static proto native bool DebugOverrideAnimationRotation(string pAnimName, vector pRotation);
 
  static proto native bool DebugOverrideAnimationSpeed(string pAnimName, float pSpeed);
 
 
  //--------------------------------------------------
  //
 
 
 
  static proto float LinearRangeClamp(float pValueX, float pValueY, float pLimits[]);
 
 
  //--------------------------------------------------
  // From Physics World
 
  static proto native void PhysicsGetEntitiesInBox(vector min, vector max, notnull out array<EntityAI> entList);
 
 
  //--------------------------------------------------
  // From Scene
 
  static proto native void SceneGetEntitiesInBox(vector min, vector max, notnull out array<EntityAI> entList, int flags = QueryFlags.DYNAMIC);
 
 
  //--------------------------------------------------
  // Custom player functions
 
  static proto native void GetEntitiesInCone(vector pos, vector dir, float angle, float dist, float minHeigh, float maxHeight, out array<Object> entList);
 
 
  static Object GetMeleeTarget(vector pos, vector dir, float angle, float dist, float minHeight, float maxHeight, EntityAI pToIgnore, array<typename> targetableObjects, out array<Object> allTargets = NULL)
  {
    // Print("In: GetFightTarget");
    InitCachedEntList();
 
    GetEntitiesInCone(pos, dir, angle, dist, minHeight, maxHeight, m_CachedEntList);
 
    Object ret = NULL;
    Object obj = NULL;
 
    float retVal = dist * 2; // max value
    float tgAngle = Math.Tan(Math.DEG2RAD * angle);
 
    // DrawStartFrame();
 
    foreach (auto ent: m_CachedEntList)
    {
      if (ent == pToIgnore)
        continue;
 
      Class.CastTo(obj, ent);
      if (obj)
      {
        // check for targetable objects
        if (!obj.IsAnyInherited(targetableObjects))
          continue;
 
        if (!obj.IsAlive())
          continue;
      }
 
      vector entpos = ent.GetPosition();
 
      vector diff = entpos - pos;
      float cDistSq = diff.LengthSq();
      if (cDistSq > dist * dist) // out of distance
      {
        //Print("out of distance");
        continue;
      }
 
      float frontDist = diff[0] * dir[0] + diff[2] * dir[2];
      if (frontDist < 0.1) // behind the pos/dist half plane or further than dist
      {
        //Print("behind the pos/dist half plane or further than dist");
        continue;
      }
 
      vector project = pos + dir * frontDist;
      vector posdiff = Vector(project[0] - entpos[0], 0, project[2] - entpos[2]);
      float sideDist = posdiff.LengthSq();
 
      if (sideDist > tgAngle) // out of cone
      {
        //Print("out of cone");
        continue;
      }
 
      float sum = frontDist + sideDist;
      if (sum < retVal)
      {
        ret = ent;
        retVal = sum;
      }
      else
      {
        //Print("sum !< retVal");
      }
 
      // string txt     = project.ToString() + ": " + sum.ToString();
      // DrawDebugBox(project,0.01,0xffff0000);
      // DrawDebugBox(entpos,0.01,0xffff0000);
      // DrawDebugText(txt, project, 1.0);
      allTargets.Insert(ent);
    }
 
    return ret;
  }
 
  static proto native bool PlayerCanChangeStance(DayZPlayer pPlayer, int pTargetStance, bool forceCheck = false);
 
 
  static proto native bool FindMagazinesForAmmo(DayZPlayer player, string ammoTypeName, out array<Magazine> mags);
 
  /*static bool HandleEjectMagazine (DayZPlayer player, Weapon weapon, int muzzleIndex)
    {
    int slotId = weapon.GetSlotFromMuzzleIndex(muzzleIndex);
    EntityAI att = weapon.FindAttachment(slotId);
    if (att)
    {
      InventoryLocation loc = new InventoryLocation;
      if (player.FindFreeLocationFor(att, loc))
      {
        return weapon.EjectMagazine(muzzleIndex, loc);
      }
    }
    return false;
    }*/
 
  static Magazine SelectStoreCartridge(DayZPlayer player, Weapon_Base weapon, int muzzleIndex, Magazine exclude_mag, float damage, string magTypeName)
  {
    if (damage < 1.0)
    {
      // find suitable heap / mag (but not the excluded one)
      ref array<Magazine> mags = new array<Magazine>;
      if (DayZPlayerUtils.FindMagazinesForAmmo(player, magTypeName, mags))
      {
        int sz = mags.Count();
        for (int i = 0; i < sz; ++i)
        {
          Magazine mag_i = mags.Get(i);
          if (mag_i != exclude_mag && mag_i.CanAddCartridges(1))
            return mag_i;
        }
      }
 
      // create a new one in inventory
      InventoryLocation inv_loc = new InventoryLocation;
      if (player.GetInventory().FindFirstFreeLocationForNewEntity(magTypeName, FindInventoryLocationType.ANY, inv_loc))
      {
        EntityAI eai_inv = SpawnEntity(magTypeName, inv_loc, ECE_IN_INVENTORY, RF_DEFAULT);
        if (eai_inv && eai_inv.IsInherited(Magazine))
        {
          Magazine mag_inv;
          if (Class.CastTo(mag_inv, eai_inv))
          {
            mag_inv.ServerSetAmmoCount(0);
            return mag_inv;
          }
        }
      }
    }
 
    vector pos = player.GetPosition();
    EntityAI eai_gnd = player.SpawnEntityOnGroundPos(magTypeName, pos);
    if (eai_gnd && eai_gnd.IsInherited(Magazine))
    {
      Magazine mag_gnd;
      if (Class.CastTo(mag_gnd, eai_gnd))
      {
        mag_gnd.ServerSetAmmoCount(0);
        return mag_gnd;
      }
    }
 
    return NULL;
  }
 
  static bool HandleDropMagazine(DayZPlayer player, Magazine mag)
  {
    vector m4[4];
    Math3D.MatrixIdentity4(m4);
 
    GameInventory.PrepareDropEntityPos(player, mag, m4, false, -1);
    InventoryLocation il_mag_next = new InventoryLocation;
    il_mag_next.SetGround(mag, m4);
    InventoryLocation il_mag_curr = new InventoryLocation;
    if (mag.GetInventory().GetCurrentInventoryLocation(il_mag_curr))
      return GameInventory.LocationSyncMoveEntity(il_mag_curr, il_mag_next);
    else
    {
      Error("DayZPlayerUtils::HandleDropMagazine - cannot get current inv location of mag=" + mag);
      return false;
    }
  }
 
  static bool HandleDropCartridge(DayZPlayer player, float damage, string cartTypeName, string magTypeName)
  {
    vector pos = player.GetPosition();
    EntityAI entityGround = player.SpawnEntityOnGroundPos(magTypeName, pos);
    if (entityGround && entityGround.IsInherited(Magazine))
    {
      Magazine magazineGround;
      if (Class.CastTo(magazineGround, entityGround))
      {
        magazineGround.ServerSetAmmoCount(0);
        magazineGround.SetHealth("", "", (1 - damage) * magazineGround.GetMaxHealth());
        if (magazineGround.ServerStoreCartridge(damage, cartTypeName))
          return true;
      }
    }
 
    return false;
  }
 
  static bool HandleStoreCartridge(DayZPlayer player, Weapon_Base weapon, int muzzleIndex, float damage, string cartTypeName, string magTypeName, bool CanDrop = true)
  {
    if (damage < 1.0)
    {
      array<Magazine> magazines = new array<Magazine>();
      if (DayZPlayerUtils.FindMagazinesForAmmo(player, magTypeName, magazines))
      {
        int healthLevel = -1;
        float testHeatlh = 1 - damage;
        foreach (Magazine magazine : magazines)
        {
          if (healthLevel == -1)
          {
            if (magazine.CanAddCartridges(1))
            {
              int numberOfHealthLevels = magazine.GetNumberOfHealthLevels();
              for (int i = 1; i < numberOfHealthLevels; i++)
              {
                if (magazine.GetHealthLevelValue(i) < testHeatlh)
                {
                  healthLevel = i - 1;
                  break;
                }
              }
            }
          }
 
          if (magazine.GetHealthLevel() == healthLevel)
          {
            if (magazine.ServerStoreCartridge(damage, cartTypeName))
              return true;
          }
        }
      }
 
      InventoryLocation inventoryLocation = new InventoryLocation();
      if (player.GetInventory().FindFirstFreeLocationForNewEntity(magTypeName, FindInventoryLocationType.ANY, inventoryLocation))
      {
        EntityAI entityInventory = SpawnEntity(magTypeName, inventoryLocation, ECE_IN_INVENTORY, RF_DEFAULT);
        if (entityInventory && entityInventory.IsInherited(Magazine))
        {
          Magazine magazineInventory;
          if (Class.CastTo(magazineInventory, entityInventory))
          {
            magazineInventory.ServerSetAmmoCount(0);
            magazineInventory.SetHealth("", "", (1 - damage) * magazineInventory.GetMaxHealth());
            if (magazineInventory.ServerStoreCartridge(damage, cartTypeName))
              return true;
          }
        }
      }
 
      if (CanDrop)
        return HandleDropCartridge(player, damage, cartTypeName, magTypeName);
    }
 
    return false;
  }
 
  static proto native bool InitComponentCollisions(Human player, array<ref ComponentCollisionBox> boxes, array<ref ComponentCollisionCapsule> capsules);
 
  static proto native bool IsComponentCollisionInitialized();
 
  static proto native void ClearComponentCollisions();
 
  static proto native vector GetMemoryPointPositionBoneRelative(DayZPlayer pPlayer, int pBoneIndex, int pPointIndex);
 
  static void InitPlayerComponentCollisions(Human player)
  {
    if (IsComponentCollisionInitialized())
      Error("DayZPlayerUtils.InitComponentCollisions: already initialized!");
 
    array<ref ComponentCollisionBox> b = new array<ref ComponentCollisionBox>;
    b.Insert(new ComponentCollisionBox(0.40, 0.31, 0.31, "Pelvis", "Spine2"));
    b.Insert(new ComponentCollisionBox(0.40, 0.31, 0.31, "Spine3", "Neck"));
 
    array<ref ComponentCollisionCapsule> c = new array<ref ComponentCollisionCapsule>;
    c.Insert(new ComponentCollisionCapsule(0.11, "Neck1", "Head"));
    c.Insert(new ComponentCollisionCapsule(0.09, "LeftArm", "LeftArmRoll"));
    c.Insert(new ComponentCollisionCapsule(0.08, "LeftForeArm", "LeftHand"));
    c.Insert(new ComponentCollisionCapsule(0.09, "RightArm", "RightArmRoll"));
    c.Insert(new ComponentCollisionCapsule(0.08, "RightForeArm", "RightHand"));
    c.Insert(new ComponentCollisionCapsule(0.11, "LeftUpLeg", "LeftUpLegRoll"));
    c.Insert(new ComponentCollisionCapsule(0.10, "LeftLeg", "LeftFoot"));
    c.Insert(new ComponentCollisionCapsule(0.11, "RightUpLeg", "RightUpLegRoll"));
    c.Insert(new ComponentCollisionCapsule(0.10, "RightLeg", "RightFoot"));
 
    DayZPlayerUtils.InitComponentCollisions(player, b, c);
  }
 
  static int ConvertStanceMaskToStanceIdx(int stanceMask)
  {
    switch (stanceMask)
    {
    case stanceMask &DayZPlayerConstants.STANCEMASK_PRONE:
      return DayZPlayerConstants.STANCEIDX_PRONE;
 
    case stanceMask &DayZPlayerConstants.STANCEMASK_CROUCH:
      return DayZPlayerConstants.STANCEIDX_CROUCH;
 
    case stanceMask &DayZPlayerConstants.STANCEMASK_ERECT:
      return DayZPlayerConstants.STANCEIDX_ERECT;
 
    case stanceMask &DayZPlayerConstants.STANCEMASK_RAISEDPRONE:
      return DayZPlayerConstants.STANCEIDX_RAISEDPRONE;
 
    case stanceMask &DayZPlayerConstants.STANCEMASK_RAISEDCROUCH:
      return DayZPlayerConstants.STANCEIDX_RAISEDCROUCH;
 
    case stanceMask &DayZPlayerConstants.STANCEMASK_RAISEDERECT:
      return DayZPlayerConstants.STANCEIDX_RAISEDERECT;
    }
 
    return -1;
  }
 
  static EWaterLevels CheckWaterLevel(DayZPlayer pPlayer, out vector waterLevel)
  {
    SHumanCommandSwimSettings swimData = pPlayer.GetDayZPlayerType().CommandSwimSettingsW();
    vector pp = pPlayer.GetPosition();
    waterLevel = HumanCommandSwim.WaterLevelCheck(pPlayer, pp);
 
    if (waterLevel[1] < swimData.m_fToCrouchLevel)
      return EWaterLevels.LEVEL_LOW;
    else if (waterLevel[1] >= swimData.m_fToCrouchLevel && waterLevel[1] < swimData.m_fToErectLevel)
      return EWaterLevels.LEVEL_CROUCH;
    else// if (waterLevel[1] >= swimData.m_fToErectLevel)
    {
      if (waterLevel[0] >= swimData.m_fWaterLevelIn && waterLevel[1] >= swimData.m_fWaterLevelIn)
        return EWaterLevels.LEVEL_SWIM_START;
      else
        return EWaterLevels.LEVEL_ERECT;
    }
  }
 
  //------------------------------------------------
  // private data
 
 
  private static ref array<Object> m_CachedEntList;
 
 
  private void DayZPlayerUtils() {};
 
  private static void InitCachedEntList()
  {
    if (m_CachedEntList == NULL)
      m_CachedEntList = new array<Object>;
 
    m_CachedEntList.Clear();
  }
}
 
class ComponentCollisionBox
{
  vector m_Offset;
  string m_BoneName0;
  string m_BoneName1;
 
  void ComponentCollisionBox(float x, float y, float z, string b0, string b1)
  {
    m_Offset[0] = x;
    m_Offset[1] = y;
    m_Offset[2] = z;
    m_BoneName0 = b0;
    m_BoneName1 = b1;
  }
};
 
class ComponentCollisionCapsule
{
  float m_Radius;
  string m_BoneName0;
  string m_BoneName1;
 
  void ComponentCollisionCapsule(float r, string b0, string b1)
  {
    m_Radius = r;
    m_BoneName0 = b0;
    m_BoneName1 = b1;
  }
};