MiscGameplayFunctions.c

Go to the documentation of this file.

class TurnItemIntoItemLambda extends ReplaceItemWithNewLambda
{
  bool m_TransferAgents;
  bool m_TransferVariables;
  bool m_TransferHealth;
  bool m_ExcludeQuantity;
  float m_quantity_override;
 
  void TurnItemIntoItemLambda(EntityAI old_item, string new_item_type, PlayerBase player)
  {
    SetTransferParams();
  }
 
  void SetTransferParams(bool transfer_agents = true, bool transfer_variables = true, bool transfer_health = true, bool exclude_quantity = false, float quantity_override = -1)
  {
    m_TransferAgents = transfer_agents;
    m_TransferVariables = transfer_variables;
    m_TransferHealth = transfer_health;
    m_ExcludeQuantity = exclude_quantity;
    m_quantity_override = quantity_override;
  }
 
  override void CopyOldPropertiesToNew(notnull EntityAI old_item, EntityAI new_item)
  {
    super.CopyOldPropertiesToNew(old_item, new_item);
 
    if (new_item)
    {
      MiscGameplayFunctions.TransferItemProperties(old_item, new_item, m_TransferAgents, m_TransferVariables, m_TransferHealth, m_ExcludeQuantity);
      MiscGameplayFunctions.TransferInventory(old_item, new_item, m_Player);
 
      //quantity override
      if (ItemBase.Cast(new_item) && m_quantity_override != -1)
      {
        m_quantity_override = Math.Max(m_quantity_override, 0);
        ItemBase.Cast(new_item).SetQuantity(m_quantity_override);
      }
    }
    else
      Debug.LogError("TurnItemIntoItemLambda: failed to create new item", "static");
  }
 
  override void VerifyItemTypeBySlotType()
  {
    if (m_NewLocation.GetType() == InventoryLocationType.ATTACHMENT && m_OldItem.ConfigIsExisting("ChangeIntoOnAttach"))
    {
      string str;
      int idx = -1;
      TStringArray inventory_slots = new TStringArray;
      TIntArray inventory_slots_idx = new TIntArray;
      TStringArray attach_types = new TStringArray;
 
      m_OldItem.ConfigGetTextArray("ChangeInventorySlot", inventory_slots);
      if (inventory_slots.Count() < 1) //is string
      {
        inventory_slots_idx.Insert(InventorySlots.GetSlotIdFromString(m_OldItem.ConfigGetString("ChangeInventorySlot")));
        attach_types.Insert(m_OldItem.ConfigGetString("ChangeIntoOnAttach"));
      }
      else //is array
      {
        inventory_slots_idx.Clear();
        for (int i = 0; i < inventory_slots.Count(); i++)
          inventory_slots_idx.Insert(InventorySlots.GetSlotIdFromString(inventory_slots.Get(i)));
        m_OldItem.ConfigGetTextArray("ChangeIntoOnAttach", attach_types);
      }
 
      idx = m_NewLocation.GetSlot();
      str = attach_types.Get(inventory_slots_idx.Find(idx));
      if (str != "")
        m_NewItemType = str;
    }
  }
 
  override void OnSuccess(EntityAI new_item)
  {
    super.OnSuccess(new_item);
    if (m_Player)
      m_Player.GetItemAccessor().OnItemInHandsChanged();
  }
};
 
class TurnItemIntoItemLambdaAnimSysNotifyLambda extends TurnItemIntoItemLambda
{
  override void OnSuccess(EntityAI new_item)
  {
    super.OnSuccess(new_item);
    if (m_Player)
      m_Player.GetItemAccessor().OnItemInHandsChanged();
  }
}
 
class TurnItemIntoItemLambdaRestrainLambda extends TurnItemIntoItemLambdaAnimSysNotifyLambda
{
  override void OnSuccess(EntityAI new_item)
  {
    super.OnSuccess(new_item);
    m_Player.SetRestrained(true);
  }
}
 
class DropEquipAndDestroyRootLambda : ReplaceItemWithNewLambdaBase
{
  PlayerBase m_Player;
 
  void DropEquipAndDestroyRootLambda(EntityAI old_item, string new_item_type, PlayerBase player)
  {
    m_Player = player;
  }
 
  override void CopyOldPropertiesToNew(notnull EntityAI old_item, EntityAI new_item)
  {
    super.CopyOldPropertiesToNew(old_item, new_item);
 
    InventoryLocation understash_src = m_NewLocation; // m_NewLocation is a backup of original old_item's src before the operation started
 
    array<EntityAI> children = new array<EntityAI>;
    old_item.GetInventory().EnumerateInventory(InventoryTraversalType.LEVELORDER, children);
    int count = children.Count();
    for (int i = 0; i < count; i++)
    {
      EntityAI child = children.Get(i);
      if (child)
      {
        InventoryLocation child_src = new InventoryLocation;
        child.GetInventory().GetCurrentInventoryLocation(child_src);
 
        InventoryLocation child_dst = new InventoryLocation;
        //@TODO: modify _dst with place on gnd?
 
        vector m4[4];
        Math3D.MatrixIdentity4(m4);
 
        GameInventory.PrepareDropEntityPos(old_item, child, m4, false, -1);
 
        child_dst.SetGround(child, m4);
 
        m_Player.LocalTakeToDst(child_src, child_dst);
 
        GetGame().RemoteObjectTreeCreate(child); // this forces server to send CreateVehicle Message to client. This is needed for preserving the appearance of network operations on client (so that DeleteObject(old) arrives before CreateVehicle(new)). @NOTE: this does not delete the object on server, only it's network representation.
      }
    }
  }
}
 
class MoveEquipToExistingItemAndDestroyOldRootLambda : ReplaceItemWithNewLambdaBase
{
  PlayerBase m_Player;
  EntityAI m_NewItem;
 
  void MoveEquipToExistingItemAndDestroyOldRootLambda(EntityAI old_item, string new_item_type, PlayerBase player, EntityAI new_item)
  {
    m_Player = player;
    m_NewItem = new_item;
    if (new_item_type != string.Empty)
      Error("MoveEquipAndDestroyRootLambda expects new_item_type to be empty");
  }
 
  override protected void RemoveNetworkObjectInfo()
  {
    super.RemoveNetworkObjectInfo();
    GetGame().RemoteObjectTreeDelete(m_NewItem);
  }
  override protected void UndoRemoveNetworkObjectInfo()
  {
    super.UndoRemoveNetworkObjectInfo();
    GetGame().RemoteObjectTreeCreate(m_NewItem);
  }
 
  override void CopyOldPropertiesToNew(notnull EntityAI old_item, EntityAI new_item)
  {
    // @NOTE: new_item is NULL, this lambda does not create new entity
    super.CopyOldPropertiesToNew(old_item, new_item);
 
    MiscGameplayFunctions.TransferInventory(old_item, m_NewItem, m_Player);
  }
 
  override protected void CreateNetworkObjectInfo(EntityAI new_item)
  {
    super.CreateNetworkObjectInfo(new_item);
    GetGame().RemoteObjectTreeCreate(m_NewItem);
  }
};
 
enum TransferInventoryResult
{
  Ok, DroppedSome
};
 
enum ThrowEntityFlags
{
  NONE = 0,
  SPLIT = 1, //< Splits the item when it has quantity, recommended to use when called on an attachment
}
 
class MiscGameplayFunctions
{
  static float Truncate(float value, int decimals = 2)
  {
    int multiplier = Math.Pow(10, decimals);
    return Math.Clamp(Math.Floor(value * multiplier), float.LOWEST, float.MAX) / multiplier;
  }
  static string TruncateToS(float value, int decimals = 2)
  {
    return Truncate(value, decimals).ToString();
  }
  static vector TruncateVec(vector value, int decimals = 2)
  {
    int multiplier = Math.Pow(10, decimals);
    float v1 = Math.Clamp(Math.Floor(value[0] * multiplier), float.LOWEST, float.MAX) / multiplier;
    float v2 = Math.Clamp(Math.Floor(value[1] * multiplier), float.LOWEST, float.MAX) / multiplier;
    float v3 = Math.Clamp(Math.Floor(value[2] * multiplier), float.LOWEST, float.MAX) / multiplier;
    return Vector(v1, v2, v3);
  }
 
  static string TruncateVecToS(vector value, int decimals = 2, string delimiter = " ")
  {
    return MiscGameplayFunctions.TruncateToS(value[0], decimals) + delimiter + MiscGameplayFunctions.TruncateToS(value[1], decimals) + delimiter + MiscGameplayFunctions.TruncateToS(value[2], decimals));
  }
 
  static string GetColorString(float r, float g, float b, float a)
  {
    return string.Format("#(argb,8,8,3)color(%1,CO)", string.Format("%1,%2,%3,%4", r, g, b, a));
  }
 
  static string ValueToBar(float value, string bar = "[----------]", string mark = "x")
  {
    int length = bar.Length() - 2;
    float index = Math.Lerp(0, length, value);
    index = Math.Round(index);
    index = Math.Clamp(index, 0, length);
 
    return InsertAtPos(bar, mark, index);
  }
 
  static string InsertAtPos(string base, string insert, int pos)
  {
    int length_first = pos + 1;
    int length_base = base.Length();
    int length_second = length_base - length_first;
    string first = base.Substring(0, length_first);
    string second = base.Substring(pos + 1, length_second);
    return first + insert + second;
  }
 
  static void TransferItemProperties(EntityAI source, notnull EntityAI target, bool transfer_agents = true, bool transfer_variables = true, bool transfer_health = true, bool exclude_quantity = false)
  {
    ItemBase target_ib = ItemBase.Cast(target);
    ItemBase source_ib = ItemBase.Cast(source);
 
    if (transfer_agents) target_ib.TransferAgents(source.GetAgents());
 
    if (transfer_variables)
      MiscGameplayFunctions.TransferItemVariables(source_ib, target_ib, exclude_quantity);
 
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
    {
      if (transfer_health)
        target_ib.SetHealth01("", "", source.GetHealth01("", ""));
    }
  }
 
  static void TransferItemVariables(ItemBase source, ItemBase target, bool exclude_quantity = false)
  {
    target.TransferVariablesFloat(source.GetVariablesFloat());
    //target.TransferVariablesString( source.GetVariablesString() );
    if (exclude_quantity)
      target.RemoveItemVariable(VARIABLE_QUANTITY);
    else if (source.IsMagazine() && target.IsMagazine())
    {
      Magazine source_mag = Magazine.Cast(source);
      Magazine target_mag = Magazine.Cast(target);
 
      target_mag.ServerSetAmmoCount(source_mag.GetAmmoCount());
    }
 
    if (source.IsWeapon() && target.IsWeapon())
    {
      Weapon_Base source_wpn = Weapon_Base.Cast(source);
      Weapon_Base target_wpn = Weapon_Base.Cast(target);
 
      target_wpn.CopyWeaponStateFrom(source_wpn);
    }
    else if (source.HasEnergyManager() && target.HasEnergyManager())
    {
      ComponentEnergyManager ems = source.GetCompEM();
      ComponentEnergyManager emt = target.GetCompEM();
 
      emt.SetEnergy(ems.GetEnergy());
 
      if (ems.IsSwitchedOn())
        emt.SwitchOn();
    }
    else if (source.CanDecay() && target.CanDecay())
    {
      Edible_Base source_edb = Edible_Base.Cast(source);
      Edible_Base target_edb = Edible_Base.Cast(target);
 
      target_edb.TransferFoodStage(source_edb);
    }
  }
 
  static TransferInventoryResult TransferInventory(EntityAI sourceItem, EntityAI targetItem, PlayerBase player)
  {
    TransferInventoryResult result = TransferInventoryResult.Ok;
 
    array<EntityAI> children = new array<EntityAI>;
    sourceItem.GetInventory().EnumerateInventory(InventoryTraversalType.LEVELORDER, children);
    int count = children.Count();
    for (int i = 0; i < count; i++)
    {
      EntityAI child = children.Get(i);
      if (child)
      {
        InventoryLocation child_src = new InventoryLocation;
        child.GetInventory().GetCurrentInventoryLocation(child_src);
 
        InventoryLocation child_dst = new InventoryLocation;
        child_dst.Copy(child_src);
        child_dst.SetParent(targetItem);
 
        bool drop = false;
 
        if (GameInventory.LocationCanAddEntity(child_dst))
        {
          // try to move it to the same exact place in dst
          targetItem.GetInventory().TakeToDst(InventoryMode.LOCAL, child_src, child_dst);
        }
        else
        {
          drop = true; // or drop otherwise
        }
 
        if (drop)
        {
          player.LocalDropEntity(child);
          GetGame().RemoteObjectTreeCreate(child);
          result = TransferInventoryResult.DroppedSome;
        }
      }
    }
    return result;
  }
 
  static void UnlimitedAmmoDebugCheck(Weapon_Base weapon)
  {
    if (ItemBase.GetDebugActionsMask() & DebugActionType.UNLIMITED_AMMO)
    {
      Magazine magazine;
      if (GetGame().IsServer())
      {
        magazine = weapon.GetMagazine(weapon.GetCurrentMuzzle());
 
        if (magazine)
        {
          if (magazine.GetAmmoCount() <= 5)
            magazine.ServerSetAmmoMax();
        }
      }
      else
      {
        magazine = weapon.GetMagazine(weapon.GetCurrentMuzzle());
 
        if (magazine)
        {
          if (magazine.GetAmmoCount() <= 5)
            magazine.LocalSetAmmoMax();
        }
 
      }
    }
  }
 
 
  static void TurnItemIntoItem(notnull ItemBase old_item, string new_item_type, notnull PlayerBase player)
  {
    TurnItemIntoItemEx(player, new TurnItemIntoItemLambda(old_item, new_item_type, player));
  }
 
  static void TurnItemIntoItemEx(notnull PlayerBase player, ReplaceItemWithNewLambdaBase lambda)
  {
    player.ServerReplaceItemWithNew(lambda);
  }
 
  static void TurnItemInHandsIntoItem(notnull ItemBase old_item, string new_item_type, notnull PlayerBase player)
  {
    TurnItemInHandsIntoItemEx(player, new TurnItemIntoItemLambda(old_item, new_item_type, player));
  }
 
  static void TurnItemInHandsIntoItemEx(notnull PlayerBase player, ReplaceItemWithNewLambdaBase lambda)
  {
    player.ServerReplaceItemInHandsWithNew(lambda);
  }
 
  static array<ItemBase> CreateItemBasePiles(string item_name, vector ground_position, float quantity, float health, bool floaty_spawn = false)
  {
    array<ItemBase> item_piles;
    float max_stack_size;
    ItemBase pile;
 
    item_piles = new array<ItemBase>;
    max_stack_size = g_Game.ConfigGetInt("cfgVehicles " + item_name + " varStackMax");
    if (max_stack_size < 1)
      max_stack_size = g_Game.ConfigGetInt("cfgVehicles " + item_name + " varQuantityMax");
    if (max_stack_size < 1)
      max_stack_size = 1;
 
    int full_piles_count = Math.Floor(quantity / max_stack_size);
    int rest = quantity - (full_piles_count * max_stack_size);
 
    for (int i = 0; i < full_piles_count; i++)
    {
      if (floaty_spawn)
        pile = ItemBase.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_CREATEPHYSICS | ECE_UPDATEPATHGRAPH));
      else
        pile = ItemBase.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_PLACE_ON_SURFACE));
      pile.SetQuantity(max_stack_size);
      pile.SetHealth(health);
      item_piles.Insert(pile);
    }
    if (rest > 0)
    {
      if (floaty_spawn)
        pile = ItemBase.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_CREATEPHYSICS | ECE_UPDATEPATHGRAPH));
      else
        pile = ItemBase.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_PLACE_ON_SURFACE));
      pile.SetQuantity(rest);
      pile.SetHealth(health);
      item_piles.Insert(pile);
    }
    return item_piles;
  }
 
  static array<Magazine> CreateMagazinePiles(string item_name, vector ground_position, float quantity, float health)
  {
    array<Magazine> items;
    float stack_size;
    Magazine pile;
 
    items = new array<Magazine>;
    stack_size = g_Game.ConfigGetInt("cfgMagazines " + item_name + " count");
 
    int piles_count = Math.Floor(quantity / stack_size);
    int rest = quantity - (piles_count * stack_size);
 
    for (int i = 0; i < piles_count; i++)
    {
      pile = Magazine.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_PLACE_ON_SURFACE));
      pile.ServerSetAmmoCount(stack_size);
      items.Insert(pile);
    }
    if (rest > 0)
    {
      pile = Magazine.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_PLACE_ON_SURFACE));
      pile.ServerSetAmmoCount(rest);
      items.Insert(pile);
    }
    return items;
  }
 
  static array<Magazine> CreateMagazinePilesFromBullet(string bullet_type, vector ground_position, float quantity, float health)
  {
    array<Magazine> items;
    items = new array<Magazine>;
    float stack_size;
    Magazine pile;
    string item_name;
    if (!g_Game.ConfigGetText("cfgAmmo " + bullet_type + " spawnPileType", item_name))
      return items;
 
    stack_size = g_Game.ConfigGetInt("cfgMagazines " + item_name + " count");
 
    if (stack_size > 0)
    {
      int piles_count = Math.Floor(quantity / stack_size);
      int rest = quantity - (piles_count * stack_size);
 
      for (int i = 0; i < piles_count; i++)
      {
        pile = Magazine.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_PLACE_ON_SURFACE));
        pile.ServerSetAmmoCount(stack_size);
        items.Insert(pile);
      }
      if (rest > 0)
      {
        pile = Magazine.Cast(GetGame().CreateObjectEx(item_name, ground_position, ECE_PLACE_ON_SURFACE));
        pile.ServerSetAmmoCount(rest);
        items.Insert(pile);
      }
    }
    return items;
  }
 
  static int GetHealthLevelForAmmo(string class_name, float health)
  {
    float health_normalized = health / 100;
    string config_path = CFG_WEAPONSPATH + " " + class_name + " DamageSystem" + " GlobalHealth" + " healthLabels";
    CachedObjectsArrays.ARRAY_FLOAT.Clear();
    GetGame().ConfigGetFloatArray(config_path, CachedObjectsArrays.ARRAY_FLOAT);
    for (int i = 0; i < CachedObjectsArrays.ARRAY_FLOAT.Count(); i++)
    {
      if (health_normalized >= CachedObjectsArrays.ARRAY_FLOAT.Get(i))
        return i;
    }
    return -1;
  }
 
  static float GetTypeMaxGlobalHealth(string class_name, string health_type = "Health")
  {
    float max_health;
    string cfg_path;
 
    if (GetGame().ConfigIsExisting(CFG_VEHICLESPATH + " " + class_name))
      cfg_path = CFG_VEHICLESPATH;
    else if (GetGame().ConfigIsExisting(CFG_WEAPONSPATH + " " + class_name))
      cfg_path = CFG_WEAPONSPATH;
    else if (GetGame().ConfigIsExisting(CFG_MAGAZINESPATH + " " + class_name))
      cfg_path = CFG_MAGAZINESPATH;
    cfg_path = cfg_path + " " + class_name + " DamageSystem GlobalHealth " + health_type + " hitpoints";
    max_health = GetGame().ConfigGetFloat(cfg_path);
 
    return max_health;
  }
 
  static bool GetProjectedCursorPos3d(out vector position, Weapon_Base weapon)
  {
    vector usti_hlavne_position = weapon.GetSelectionPositionMS("usti hlavne");
    vector konec_hlavne_position = weapon.GetSelectionPositionMS("konec hlavne");
    vector end_point = weapon.ModelToWorld(usti_hlavne_position);
    vector begin_point = weapon.ModelToWorld(konec_hlavne_position);
    vector contact_dir;
    int contact_component;
 
    vector aim_point = end_point - begin_point;
    aim_point = aim_point.Normalized() * PROJECTED_CURSOR_DISTANCE;
    aim_point = aim_point + end_point;
 
    if (DayZPhysics.RaycastRV(begin_point, aim_point, position, contact_dir, contact_component, null, null, null, false, false, ObjIntersectFire))
      return true;
    return false;
  }
 
  static void GetHeadBonePos(notnull PlayerBase player, out vector pos)
  {
    // Get position of head for starting trace pos, otherwise use sane default
    int headBoneIdx = player.GetBoneIndexByName("Head");
    if (headBoneIdx == -1)
      pos = player.GetPosition()[1] + 1.6;
    else
      pos = player.GetBonePositionWS(headBoneIdx);
  }
 
  static vector GetHeadingVector(notnull PlayerBase player)
  {
    vector dir = vector.Zero;
    float headingAngle = GetHeadingAngle(player);
    dir[0] = Math.Cos(headingAngle + Math.PI_HALF);
    dir[2] = Math.Sin(headingAngle + Math.PI_HALF);
 
    return dir.Normalized();
  }
 
  static float GetHeadingAngle(notnull DayZPlayerImplement player)
  {
    HumanInputController hic = player.GetInputController();
    float headingAngle = hic.GetHeadingAngle();
 
    return headingAngle;
  }
 
  static float GetEnergyMetabolicSpeed(int movement_speed)
  {
    float speed;
    switch (movement_speed)
    {
    case DayZPlayerConstants.MOVEMENTIDX_WALK:
      speed = PlayerConstants.METABOLIC_SPEED_ENERGY_WALK;
      break;
    case DayZPlayerConstants.MOVEMENTIDX_RUN:
      speed = PlayerConstants.METABOLIC_SPEED_ENERGY_JOG;
      break;
    case DayZPlayerConstants.MOVEMENTIDX_SPRINT:
      speed = PlayerConstants.METABOLIC_SPEED_ENERGY_SPRINT;
      break;
    default:
      speed = 0;
      break;
    }
 
    speed += PlayerConstants.METABOLIC_SPEED_ENERGY_BASAL;
    return speed;
  }
 
  static float GetWaterMetabolicSpeed(int movement_speed)
  {
    float speed;
    switch (movement_speed)
    {
    case DayZPlayerConstants.MOVEMENTIDX_WALK:
      speed = PlayerConstants.METABOLIC_SPEED_WATER_WALK;
      break;
    case DayZPlayerConstants.MOVEMENTIDX_RUN:
      speed = PlayerConstants.METABOLIC_SPEED_WATER_JOG;
      break;
    case DayZPlayerConstants.MOVEMENTIDX_SPRINT:
      speed = PlayerConstants.METABOLIC_SPEED_WATER_SPRINT;
      break;
    default:
      speed = 0;
      break;
    }
 
    speed += PlayerConstants.METABOLIC_SPEED_WATER_BASAL;
    return speed;
  }
 
  static string ObtainRestrainItemTargetClassname(notnull EntityAI entity)
  {
    return entity.ConfigGetString("OnRestrainChange");
  }
 
  static void TransformRestrainItem(EntityAI current_item, EntityAI tool, PlayerBase player_source, PlayerBase player_target, bool destroy = false)
  {
    bool type;
 
    if (tool)
    {
      //is unrestrain and not struggle
      type = tool.ConfigGetBool("RestrainUnlockType");
    }
    string new_item_name = current_item.ConfigGetString("OnRestrainChange");
 
    if (new_item_name != "")
    {
      if (player_target)
      {
        if (player_target.IsAlive())
          MiscGameplayFunctions.TurnItemIntoItemEx(player_target, new ReplaceAndDestroyLambdaEx(current_item, new_item_name, player_target, type));
        else
          MiscGameplayFunctions.TurnItemIntoItemEx(player_source, new DestroyItemInCorpsesHandsAndCreateNewOnGndLambda(current_item, new_item_name, player_target, type));
      }
      else
        MiscGameplayFunctions.TurnItemIntoItemEx(player_target, new ReplaceAndDestroyLambdaEx(current_item, new_item_name, player_target, type));
    }
    else
      Error("current_item:" + current_item + ", tool:" + tool + ". No value for 'OnRestrainChange' config parameter");
  }
 
  static bool IsValueInRange(float value, float from, float to)
  {
    return (value >= from) && (value <= to);
  }
 
  static bool IsPlayerOrientedTowardPos(notnull DayZPlayerImplement player, vector target_pos, float cone_angle)
  {
    if (player)
    {
      vector player_dir = player.GetDirection();
      vector to_target_dir = target_pos - player.GetPosition();
 
      player_dir[1] = 0;
      to_target_dir[1] = 0;
 
      player_dir.Normalize();
      to_target_dir.Normalize();
 
      float cos_fi = vector.Dot(player_dir, to_target_dir);
      vector cross = player_dir * to_target_dir;
 
      int dir = Math.Acos(cos_fi) * Math.RAD2DEG;
 
      if (cross[1] < 0)
        dir = -dir;
 
      if ((dir <= cone_angle && dir >= -cone_angle) || Math.AbsFloat(dir) == 90)
        return true;
    }
 
    return false;
  }
 
  //TODO
  static string SanitizeString(string input)
  {
    int max_length = 512;
    string output = input;
 
    output = output.Substring(0, Math.Clamp(max_length, 0, output.Length()));
    return output;
  }
 
  // deprecated - dont use
  static bool ComplexBuildCollideCheckClient(PlayerBase player, ActionTarget target, ItemBase item, string partName = "")
  {
    return true;
  }
 
  static bool ComplexBuildCollideCheckClient(PlayerBase player, ActionTarget target, ItemBase item, int constraction_index)
  {
    BaseBuildingBase base_building = BaseBuildingBase.Cast(target.GetObject());
    if (base_building)
    {
      Construction construction = base_building.GetConstruction();
      if (construction && BuildCondition(player, target, item, false, constraction_index))
      {
        ConstructionActionData construction_action_data = player.GetConstructionActionData();
        string partName;
        if (item)
          partName = construction_action_data.GetBuildPartAtIndex(constraction_index).GetPartName();
        else
          partName = construction_action_data.GetBuildPartNoToolAtIndex(constraction_index).GetPartName();
        bool boo;
        if (base_building.PerformRoofCheckForBase(partName, player, boo) && boo)
          return false;
        if (player.IsPlacingLocal() || player.IsPlacingServer())
          return false;
 
        /*float distance_root = vector.DistanceSq(target.GetCursorHitPos(), player.GetPosition());
 
          if (!CfgGameplayHandler.GetDisableDistanceCheck() && distance_root < UAMaxDistances.BASEBUILDING_SHORT)
          {
          return false;
          } */
        return !construction.IsColliding(partName);
      }
    }
    return false;
  }
 
  // deprecated - dont use
  static bool BuildCondition(PlayerBase player, ActionTarget target, ItemBase item, bool camera_check)
  {
    return true;
  }
 
  static bool BuildCondition(PlayerBase player, ActionTarget target, ItemBase item, bool camera_check, int constraction_index)
  {
    Object targetObject = target.GetObject();
    if (targetObject && targetObject.CanUseConstruction())
    {
      BaseBuildingBase base_building = BaseBuildingBase.Cast(targetObject);
      ConstructionActionData construction_action_data = player.GetConstructionActionData();
      construction_action_data.SetTarget(targetObject);
 
      ConstructionPart constrution_part;
      if (item)
        constrution_part = construction_action_data.GetBuildPartAtIndex(constraction_index);
      else
        constrution_part = construction_action_data.GetBuildPartNoToolAtIndex(constraction_index);
 
      //Debug
      /*
        if ( constrution_part )
        {
        Construction construction = base_building.GetConstruction();
        construction.IsColliding( constrution_part.GetPartName() );
        }
      */
 
      if (constrution_part)
      {
        //camera and position checks
        bool position_check = (base_building.MustBeBuiltFromOutside() && !base_building.IsPlayerInside(player, constrution_part.GetMainPartName())) || (!base_building.MustBeBuiltFromOutside() && base_building.IsPlayerInside(player, constrution_part.GetMainPartName()));
        if (position_check && !player.GetInputController().CameraIsFreeLook())
        {
          //Camera check (client-only)
          if (camera_check)
          {
            if (GetGame() && (!GetGame().IsDedicatedServer()))
              return !base_building.IsFacingCamera(constrution_part.GetMainPartName());
          }
 
          return true;
        }
      }
    }
 
    return false;
  }
 
  static void IsUnderRoofFromToCalculation(EntityAI entity, out vector from, out vector to, float height = GameConstants.ROOF_CHECK_RAYCAST_DIST)
  {
    vector minMax[2];
    entity.GetCollisionBox(minMax);
 
    vector size = Vector(0, 0, 0);
    //size[1] = minMax[1][1] - minMax[0][1];
    float from_override = entity.HeightStartCheckOverride();
    if (from_override > 0.0)
      size[1] = from_override;
    else
      size[1] = minMax[1][1] - minMax[0][1];
 
    from = entity.GetPosition() + size;
    if (entity.HeightCheckOverride() > 0)
      to = entity.GetPosition() + Vector(0, entity.HeightCheckOverride(), 0);
    else
    {
      vector ceiling = "0 0 0";
      ceiling[1] = height;
      to = from + ceiling; //+size ??? offset to cast same distance
    }
  }
 
  static bool IsUnderRoof(EntityAI entity, float height = GameConstants.ROOF_CHECK_RAYCAST_DIST)
  {
    return IsUnderRoofEx(entity, height, ObjIntersectView);
  }
 
  static bool IsUnderRoofEx(EntityAI entity, float height = GameConstants.ROOF_CHECK_RAYCAST_DIST, int geometry = ObjIntersectView)
  {
    vector from;
    vector to;
 
    IsUnderRoofFromToCalculation(entity, from, to, height);
 
    vector contact_pos;
    vector contact_dir;
 
    int contact_component;
    //set<Object> hit_object = new set<Object>;
    bool boo = DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component, /*hit_object*/NULL, NULL, entity, false, false, geometry, 0.25);
 
    /*if (boo)
      {
      Debug.DrawSphere(from , 0.8,Colors.YELLOW, ShapeFlags.ONCE);
      Debug.DrawSphere(to , 0.8,Colors.RED, ShapeFlags.ONCE);
      }
      else
      {
      Debug.DrawSphere(from , 0.8,Colors.GREEN, ShapeFlags.ONCE);
      Debug.DrawSphere(to , 0.8,Colors.RED, ShapeFlags.ONCE);
      }*/
 
    return boo;
  }
 
  // cooking equipment effects (get position for steam particle)
  static vector GetSteamPosition(EntityAI parent)
  {
    vector particle_pos;
    float steam_offset = 0;
 
    if (parent)
    {
      particle_pos = parent.GetPosition();
 
      if (parent.IsInherited(PortableGasStove))
        steam_offset = 0.2;
      else if (parent.IsInherited(FireplaceBase))
      {
        FireplaceBase fireplace = FireplaceBase.Cast(parent);
 
        if (fireplace.IsBaseFireplace())
          steam_offset = 0.8;
        else if (fireplace.IsBarrelWithHoles())
          steam_offset = 1.1;
        else if (fireplace.IsFireplaceIndoor())
          steam_offset = 0.45;
        else if (fireplace.IsIndoorOven())
          steam_offset = 0.9;
      }
    }
 
    particle_pos[1] = particle_pos[1] + steam_offset;
 
    return particle_pos;
  }
 
  static void DropAllItemsInInventoryInBounds(ItemBase ib, vector halfExtents)
  {
    if (!GetGame().IsServer())
      return;
    array<EntityAI> items = new array<EntityAI>;
    ib.GetInventory().EnumerateInventory(InventoryTraversalType.LEVELORDER, items);
 
    vector direction = ib.GetDirection();
    float dot = vector.Dot(direction, vector.Forward);
 
    float angle = Math.Acos(dot);
    if (direction[0] < 0)
      angle = -angle;
 
    float cos = Math.Cos(angle);
    float sin = Math.Sin(angle);
 
    EntityAI item;
    int count = items.Count();
    for (int i = 0; i < count; ++i)
    {
      item = items.Get(i);
      if (item)
        ib.GetInventory().DropEntityInBounds(InventoryMode.SERVER, ib, item, halfExtents, angle, cos, sin);
    }
  }
 
  static void ThrowAllItemsInInventory(notnull EntityAI parent, int flags)
  {
    vector position = parent.GetPosition();
    vector orientation = parent.GetOrientation();
    vector rotation_matrix[3];
    float direction[4];
 
    vector minmax[2];
    parent.GetCollisionBox(minmax);
 
    Math3D.YawPitchRollMatrix(orientation, rotation_matrix);
    Math3D.MatrixToQuat(rotation_matrix, direction);
 
    vector randomPos;
    for (int i = 0; i < parent.GetInventory().AttachmentCount(); ++i)
    {
      randomPos = Vector(position[0] + Math.RandomFloat(minmax[0][0], minmax[1][0]),
                         position[1] + Math.RandomFloat(minmax[0][1], minmax[1][1]),
                         position[2] + Math.RandomFloat(minmax[0][2], minmax[1][2]));
 
      ThrowEntityFromInventory(parent.GetInventory().GetAttachmentFromIndex(i), randomPos, direction, -GetVelocity(parent), ThrowEntityFlags.NONE);
    }
 
    for (int j = 0; j < parent.GetInventory().GetCargo().GetItemCount(); ++j)
    {
      randomPos = Vector(position[0] + Math.RandomFloat(minmax[0][0], minmax[1][0]),
                         position[1] + Math.RandomFloat(minmax[0][1], minmax[1][1]),
                         position[2] + Math.RandomFloat(minmax[0][2], minmax[1][2]));
 
      ThrowEntityFromInventory(parent.GetInventory().GetCargo().GetItem(j), randomPos, direction, -GetVelocity(parent), ThrowEntityFlags.NONE);
    }
  }
 
  static void ThrowEntityFromInventory(notnull EntityAI entity, vector position, float direction[4], vector force, int flags)
  {
    InventoryMode invMode = InventoryMode.SERVER;
    if (!GetGame().IsMultiplayer())
      invMode = InventoryMode.LOCAL;
 
    ItemBase entityIB;
    if (CastTo(entityIB, entity))
    {
      InventoryLocation dst = new InventoryLocation;
      dst.SetGroundEx(entity, position, direction);
 
      if ((flags & ThrowEntityFlags.SPLIT) && entityIB.CanBeSplit())
      {
        for (int l = 0; l < entityIB.GetQuantity(); ++l)
        {
          ItemBase new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, entityIB.GetType(), ECE_NONE, RF_DEFAULT));
 
          if (new_item)
          {
            MiscGameplayFunctions.TransferItemProperties(entityIB, new_item);
            entityIB.AddQuantity(-1);
            new_item.SetQuantity(1);
            new_item.ThrowPhysically(null, force, false);
          }
        }
      }
      else
      {
        float stackable = entityIB.GetTargetQuantityMax();
        if (!(stackable == 0 || stackable >= entityIB.GetQuantity()))
        {
          while (entityIB.GetQuantity() > stackable)
          {
            InventoryLocation spltDst = new InventoryLocation;
            position[1] = position[1] + 0.1;
            spltDst.SetGroundEx(entity, position, direction);
 
            ItemBase splitItem = entityIB.SplitIntoStackMaxToInventoryLocationEx(spltDst);
            splitItem.ThrowPhysically(null, force, false);
          }
        }
 
        InventoryLocation src = new InventoryLocation;
        entity.GetInventory().GetCurrentInventoryLocation(src);
 
        entity.GetInventory().TakeToDst(invMode, src, dst);
        entityIB.ThrowPhysically(null, force, false);
      }
    }
    else
    {
      entity.GetInventory().DropEntity(invMode, entity.GetHierarchyRoot(), entity);
      dBodyApplyImpulse(entity, force);
    }
  }
 
  static float GetCurrentItemHeatIsolation(ItemBase pItem)
  {
    float wetFactor;
    float healthFactor;
 
    float heatIsolation = pItem.GetHeatIsolation(); 
    float itemHealthLabel = pItem.GetHealthLevel(); 
    float itemWetness = pItem.GetWet(); 
 
    if (itemWetness >= GameConstants.STATE_DRY && itemWetness < GameConstants.STATE_DAMP)
      wetFactor = GameConstants.ENVIRO_ISOLATION_WETFACTOR_DRY;
    else if (itemWetness >= GameConstants.STATE_DAMP && itemWetness < GameConstants.STATE_WET)
      wetFactor = GameConstants.ENVIRO_ISOLATION_WETFACTOR_DAMP;
    else if (itemWetness >= GameConstants.STATE_WET && itemWetness < GameConstants.STATE_SOAKING_WET)
      wetFactor = GameConstants.ENVIRO_ISOLATION_WETFACTOR_WET;
    else if (itemWetness >= GameConstants.STATE_SOAKING_WET && itemWetness < GameConstants.STATE_DRENCHED)
      wetFactor = GameConstants.ENVIRO_ISOLATION_WETFACTOR_SOAKED;
    else if (itemWetness >= GameConstants.STATE_DRENCHED)
      wetFactor = GameConstants.ENVIRO_ISOLATION_WETFACTOR_DRENCHED;
 
    switch (itemHealthLabel)
    {
    case GameConstants.STATE_PRISTINE:
      healthFactor = GameConstants.ENVIRO_ISOLATION_HEALTHFACTOR_PRISTINE;
      break;
 
    case GameConstants.STATE_WORN:
      healthFactor = GameConstants.ENVIRO_ISOLATION_HEALTHFACTOR_WORN;
      break;
 
    case GameConstants.STATE_DAMAGED:
      healthFactor = GameConstants.ENVIRO_ISOLATION_HEALTHFACTOR_DAMAGED;
      break;
 
    case GameConstants.STATE_BADLY_DAMAGED:
      healthFactor = GameConstants.ENVIRO_ISOLATION_HEALTHFACTOR_B_DAMAGED;
      break;
 
    case GameConstants.STATE_RUINED:
      healthFactor = GameConstants.ENVIRO_ISOLATION_HEALTHFACTOR_RUINED;
      break;
    }
 
    heatIsolation *= healthFactor;
    heatIsolation *= wetFactor;
 
    return heatIsolation;
  }
 
  static void FilterObstructingObjects(array<Object> potentiallyObstructingObjects, out array<Object> obstructingObjects)
  {
    if (!obstructingObjects)
      obstructingObjects = new array<Object>;
 
    for (int i = 0; i < potentiallyObstructingObjects.Count(); ++i)
    {
      Object obj = potentiallyObstructingObjects[i];
      if (obj && (obj.CanObstruct() || obj.CanProxyObstruct()))
        obstructingObjects.Insert(obj);
    }
  }
 
  static bool CanIgnoreDistanceCheck(Object obj)
  {
    return obj.IsTransport() || obj.CanUseConstruction();
  }
 
  static void FilterObstructedObjectsByGrouping(vector origin, float range, float distanceDelta, array<Object> objects, array<Object> obstructingObjects, out array<Object> filteredObjects, bool doDistanceCheck = false, bool checkIfDistanceCanBeIgnored = false, float maxDist = 0)
  {
    array<Object> vicinityObjects = new array<Object>;
    vicinityObjects.Copy(objects);
 
    int i = 0;
    int j = 0;
    int k = 0;
    int mCount = vicinityObjects.Count();
 
    if (!filteredObjects)
      filteredObjects = new array<Object>;
 
    // Remove objects that are too far from the player anyways
    if (doDistanceCheck)
    {
      for (i = vicinityObjects.Count() - 1; i >= 0; --i)
      {
        Object obj = vicinityObjects[i];
        if (obj && !CanIgnoreDistanceCheck(obj) && vector.DistanceSq(origin, obj.GetPosition()) > maxDist * maxDist)
          vicinityObjects.Remove(i);
      }
    }
 
    // Sort obstructingObjects to have the furthest one first
    array<Object> sortedObstructingObjects = new array<Object>;
    array<float> distanceHelper = new array<float>;
    array<float> distanceHelperUnsorted = new array<float>;
    float distance, dist1, dist2;
 
    for (i = 0; i < obstructingObjects.Count(); ++i)
    {
      distance = vector.DistanceSq(obstructingObjects[i].GetWorldPosition(), origin);
      distanceHelper.Insert(distance);
    }
 
    distanceHelperUnsorted.Copy(distanceHelper);
    distanceHelper.Sort();
 
    for (i = distanceHelper.Count() - 1; i >= 0; --i)
      sortedObstructingObjects.Insert(obstructingObjects[distanceHelperUnsorted.Find(distanceHelper[i])]);
 
    array<ref array<Object>> tempGroups = new array<ref array<Object>>;
    array<ref array<Object>> objectGroups = new array<ref array<Object>>;
    array<Object> group;
 
    float cos = Math.Cos(90);
    float sin = Math.Sin(90);
 
    // Iterate through sorted obstructingObjects
    for (i = 0; i < sortedObstructingObjects.Count(); ++i)
    {
      Object obstrObj = sortedObstructingObjects[i];
      vector worldPos = obstrObj.GetWorldPosition();
      vector min, max;
      vector minMax[2];
      if (obstrObj.GetCollisionBox(minMax))
      {
        min = minMax[0];
        max = minMax[1];
        max = max * (obstrObj.GetOrientation() * range);
 
        vector center, dx, dy, dz, half;
        center = (min + max) * 0.5;
        dz = obstrObj.GetOrientation();
        dx = vector.RotateAroundZero(dz, vector.Up, cos, sin);
        dy = vector.RotateAroundZero(dz, vector.Aside, cos, sin);
        half = (max - min) * 0.5;
        half = Vector(Math.AbsFloat(half[0]), Math.AbsFloat(half[1]), Math.AbsFloat(half[2]));
 
        group = new array<Object>;
 
        // Group objects within the above box
        for (j = vicinityObjects.Count() - 1; j >= 0; --j)
        {
          Object vicObj = vicinityObjects[j];
          if (vicObj)
          {
            vector d = vicObj.GetWorldPosition() - worldPos + center;
            if (Math.AbsFloat(vector.Dot(d, dx)) <= half[0] && Math.AbsFloat(vector.Dot(d, dy)) <= half[1] && Math.AbsFloat(vector.Dot(d, dz)) <= half[2])
            {
              group.Insert(vicObj);
              vicinityObjects.Remove(j);
            }
          }
        }
 
        if (group.Count() > 0)
          tempGroups.Insert(group);
      }
    }
 
    // Go through the objects grouped by obstruction to split them by distance too
    for (i = 0; i < tempGroups.Count(); ++i)
      SplitArrayIntoGroupsByDistance(tempGroups[i], objectGroups, distanceDelta);
 
    // Split initial groups by distance
    SplitArrayIntoGroupsByDistance(vicinityObjects, objectGroups, distanceDelta);
 
    // Raycast accordingly to groups
    IsObjectObstructedCache cache = new IsObjectObstructedCache(origin, mCount);
    for (i = 0; i < objectGroups.Count(); ++i)
    {
      array<Object> objectGroup = objectGroups[i];
      Object sampleObject = objectGroup[0];
 
      if (!IsObjectObstructedEx(sampleObject, cache))
        filteredObjects.InsertAll(objectGroup);
 
      cache.ClearCache();
    }
  }
 
  static void SplitArrayIntoGroupsByDistance(array<Object> objects, array<ref array<Object>> objectGroups, float squaredDistanceDelta)
  {
    array<Object> group;
    for (int i = 0; i < objects.Count();)
    {
      Object obj1 = objects[i];
      if (obj1)
      {
        group = new array<Object>;
        group.Insert(obj1);
        for (int j = objects.Count() - 1; j > i; --j)
        {
          Object obj2 = objects[j];
          if (obj1 && obj2)
          {
            vector start = obj1.GetWorldPosition();
            vector end = obj2.GetWorldPosition();
 
            float distance = vector.DistanceSq(start, end);
            if (distance < squaredDistanceDelta)
            {
              group.Insert(obj2);
              objects.Remove(j);
            }
          }
        }
        objectGroups.Insert(group);
        objects.Remove(i);
        continue;
      }
      ++i;
    }
  }
 
  static bool IsObjectObstructed(Object object, bool doDistanceCheck = false, vector distanceCheckPos = "0 0 0", float maxDist = 0)
  {
    vector rayStart;
    MiscGameplayFunctions.GetHeadBonePos(PlayerBase.Cast(GetGame().GetPlayer()), rayStart);
    IsObjectObstructedCache cache = new IsObjectObstructedCache(rayStart, 1);
 
    return IsObjectObstructedEx(object, cache, doDistanceCheck, distanceCheckPos, maxDist);
  }
 
  static bool IsObjectObstructedEx(Object object, IsObjectObstructedCache cache, bool doDistanceCheck = false, vector distanceCheckPos = "0 0 0", float maxDist = 0)
  {
    if (!object)
      return true;
 
    PlayerBase player = PlayerBase.Cast(g_Game.GetPlayer());
    if (doDistanceCheck && vector.DistanceSq(player.GetPosition(), distanceCheckPos) > maxDist * maxDist)
      return true;
 
    cache.ObjectCenterPos = object.GetCenter();
 
    return IsObjectObstructedFilterEx(object, cache, player);
  }
 
  static bool IsObjectObstructedProxy(Object object, IsObjectObstructedCache cache, PlayerBase player)
  {
    if (object.CanProxyObstruct())
    {
      RaycastRVParams rayInput = new RaycastRVParams(cache.RaycastStart, cache.ObjectCenterPos, player);
      DayZPhysics.RaycastRVProxy(rayInput, cache.HitProxyObjects);
      if (cache.HitProxyObjects)
      {
        if (cache.HitProxyObjects.Count() > 0)
        {
          if (cache.HitProxyObjects[0].hierLevel > 0)
          {
            // ignores attachments on player
            if (!cache.HitProxyObjects[0].parent.IsMan())
            {
              if (cache.HitProxyObjects[0].parent)
              {
                EntityAI proxyParent = EntityAI.Cast(cache.HitProxyObjects[0].parent);
                if (proxyParent.GetInventory() && proxyParent.GetInventory().GetCargo())
                  return true;
              }
            }
          }
        }
      }
    }
    return false;
  }
 
  static bool IsObjectObstructedFilter(Object object, IsObjectObstructedCache cache, PlayerBase player)
  {
    for (int m = 0; m < cache.HitObjects.Count(); m++)
    {
      Object hit_object = cache.HitObjects.Get(m);
 
      if (hit_object.CanObstruct())
        return true;
 
      //4.3. ignore item if items are big and heavy >= OBJECT_OBSTRUCTION_WEIGHT
      //EntityAI eai;
      //if ( Class.CastTo( eai, hit_object ) )
      //{
      // if ( eai.GetWeight() >= OBJECT_OBSTRUCTION_WEIGHT )
      // {
      // if ( eai != filtered_object && eai.GetHierarchyRoot() != filtered_object )
      // {
      // //Print("!!!!!obstacle vaha: " + hit_object);
      // is_obstructed = true;
      // }
      // }
      //}
    }
 
    return false;
  }
 
  static bool IsObjectObstructedFilterEx(Object object, IsObjectObstructedCache cache, PlayerBase player, int geometryTypeOverride = -1)
  {
    //first proxy geometries
    RaycastRVParams rayInput = new RaycastRVParams(cache.RaycastStart, cache.ObjectCenterPos, player);
    rayInput.flags = CollisionFlags.ALLOBJECTS;
    if (geometryTypeOverride != -1)
      rayInput.type = geometryTypeOverride; //default 'ObjIntersectView'
    DayZPhysics.RaycastRVProxy(rayInput, cache.HitProxyObjects);
    int count;
    int i;
 
    if (cache.HitProxyObjects)
    {
      count = cache.HitProxyObjects.Count();
      Object parent;
      for (i = 0; i < count; i++)
      {
        if (cache.HitProxyObjects[i].hierLevel > 0) //parent has to exist, skipping nullcheck
        {
          parent = cache.HitProxyObjects[i].parent;
          if (parent && !parent.IsMan() && parent.CanProxyObstruct())
          {
            if (parent != object || (parent == object && object.CanProxyObstructSelf()))
              return true;
          }
        }
      }
    }
 
    //second, regular raycast
    int geometry = ObjIntersectFire; //default for the RV raycast
    if (geometryTypeOverride != -1)
      geometry = geometryTypeOverride;
    DayZPhysics.RaycastRV(cache.RaycastStart, cache.ObjectCenterPos, cache.ObjectContactPos, cache.ObjectContactDir, cache.ContactComponent, cache.HitObjects, object, GetGame().GetPlayer(), false, false, geometry, 0.0, CollisionFlags.ALLOBJECTS);
    count = cache.HitObjects.Count();
    for (i = 0; i < count; i++)
    {
      if (cache.HitObjects[i].CanObstruct())
        return true;
    }
 
    return false;
  }
 
  //Inflict absolute damage to item (used on tools when completing actions)
  static void DealAbsoluteDmg(ItemBase item, float dmg)
  {
    item.DecreaseHealth(dmg, false);
  }
 
  //Function used to normailze values, enter the used value and the max value (max will become 1)
  static float Normalize(int val, int maxVal)
  {
    if (maxVal == 0)
    {
      Debug.LogError("Division by 0 is not allowed");
      return 0;
    }
 
    return val / maxVal;
  }
 
  static float Bobbing(float period, float amplitude, float elapsedTime)
  {
    //Prevent division by 0
    if (period == 0)
      period = 1;
 
    elapsedTime /= period;
 
    float cycle;
    cycle += elapsedTime;
    cycle = FModulus(cycle, 360);
    cycle = Math.Sin(cycle) * amplitude;
 
    return cycle;
  }
 
  // DEPRECATED, use Math.ModFloat directly instead
  static float FModulus(float x, float y)
  {
    return Math.ModFloat(x, y);
  }
 
  static void RemoveSplint(PlayerBase player)
  {
    EntityAI entity = player.GetInventory().CreateInInventory("Splint");
    if (!entity)
      entity = player.SpawnEntityOnGroundOnCursorDir("Splint", 0.5);
 
    EntityAI attachment;
    ItemBase new_item = ItemBase.Cast(entity);
    Class.CastTo(attachment, player.GetItemOnSlot("Splint_Right"));
    if (attachment && attachment.GetType() == "Splint_Applied")
    {
      if (new_item)
      {
        MiscGameplayFunctions.TransferItemProperties(attachment, new_item);
 
        if (GetGame().IsServer())
        {
          //Lower health level of splint after use
          if (new_item.GetHealthLevel() < 4)
          {
            int newDmgLevel = new_item.GetHealthLevel() + 1;
 
            float max = new_item.GetMaxHealth("", "");
 
            switch (newDmgLevel)
            {
            case GameConstants.STATE_BADLY_DAMAGED:
              new_item.SetHealth("", "", max * GameConstants.DAMAGE_BADLY_DAMAGED_VALUE);
              break;
 
            case GameConstants.STATE_DAMAGED:
              new_item.SetHealth("", "", max * GameConstants.DAMAGE_DAMAGED_VALUE);
              break;
 
            case GameConstants.STATE_WORN:
              new_item.SetHealth("", "", max * GameConstants.DAMAGE_WORN_VALUE);
              break;
 
            case GameConstants.STATE_RUINED:
              new_item.SetHealth("", "", max * GameConstants.DAMAGE_RUINED_VALUE);
              break;
 
            default:
              break;
            }
          }
        }
      }
 
      attachment.Delete();
    }
  }
 
  static void TeleportCheck(notnull PlayerBase player, notnull array<ref array<float>> safe_positions)
  {
    if (player.GetSimulationTimeStamp() < 20 && !player.IsPersistentFlag(PersistentFlag.AREA_PRESENCE))
    {
      //simulation time is bellow a threshold, which means the player has recently connected,
      //the player does not have the AREA_PRESENCE flag set, which means they were not inside the area when they disconnected,
      //that means they just spawned into a contaminated area, lets move them somewhere safe
      vector player_pos = player.GetPosition();
      vector closest_safe_pos = MiscGameplayFunctions.GetClosestSafePos(player_pos, safe_positions);
 
      if (player_pos != closest_safe_pos)
      {
        closest_safe_pos[1] = GetGame().SurfaceY(closest_safe_pos[0], closest_safe_pos[2]);
 
        player.SetPosition(closest_safe_pos); //...so lets teleport them somewhere safe
        //DeveloperTeleport.SetPlayerPosition(player, closest_safe_pos);
        GetGame().RPCSingleParam(player, ERPCs.RPC_WARNING_TELEPORT, null, true, player.GetIdentity());
      }
 
      player.SetPersistentFlag(PersistentFlag.AREA_PRESENCE, false);
    }
  }
 
 
  static vector GetClosestSafePos(vector to_pos, notnull array<ref array<float>> positions)
  {
    vector closest_pos = to_pos;
    float smallest_dist = float.MAX;
    foreach (array<float> pos: positions)
    {
      vector vpos = "0 0 0";
      vpos[0] = pos[0];
      vpos[2] = pos[1];
 
      to_pos[1] = 0;
      float dist = vector.DistanceSq(to_pos, vpos);//2d dist sq
      if (dist < smallest_dist)
      {
        smallest_dist = dist;
        closest_pos = vpos;
      }
    }
    return closest_pos;
  }
 
  static void GenerateAINoiseAtPosition(vector position, float lifeTime, NoiseParams noiseParams)
  {
    if (GetGame().IsServer())
    {
      NoiseSystem noise = GetGame().GetNoiseSystem();
      if (noise)
        noise.AddNoiseTarget(position, lifeTime, noiseParams);
    }
  }
 
  static float GetMinValue(array<float> pArray)
  {
    float minValue = 0.0;
    for (int i = 0; i < pArray.Count(); i++)
    {
      if (minValue == 0 || pArray.Get(i) < minValue)
        minValue = pArray.Get(i);
    }
 
    return minValue;
  }
 
  static float GetMaxValue(array<float> pArray)
  {
    float maxValue = 0.0;
    for (int i = 0; i < pArray.Count(); i++)
    {
      if (maxValue == 0 || pArray.Get(i) > maxValue)
        maxValue = pArray.Get(i);
    }
 
    return maxValue;
  }
 
  static string GetItemDisplayName(string type)
  {
    return GetGame().ConfigGetTextOut("CfgVehicles " + type + " displayName");
  }
 
  static bool IsComponentInSelection(array<Selection> pSelection, string pCompName)
  {
    if (pSelection.Count() == 0 || pCompName.Length() == 0)
      return false;
 
    for (int i = 0; i < pSelection.Count(); ++i)
    {
      pCompName.ToLower();
      if (pSelection[i] && pSelection[i].GetName() == pCompName)
        return true;
    }
 
    return false;
  }
 
  static int GetComponentIndex(array<Selection> pSelection, string pCompName)
  {
    if (!MiscGameplayFunctions.IsComponentInSelection(pSelection, pCompName))
      return INDEX_NOT_FOUND;
 
    for (int i = 0; i < pSelection.Count(); ++i)
    {
      pCompName.ToLower();
      if (pSelection[i] && pSelection[i].GetName() == pCompName)
        return i;
    }
 
    return INDEX_NOT_FOUND;
  }
 
  static void RemoveAllAttachedChildrenByTypename(notnull EntityAI parent, array<typename> listOfTypenames)
  {
    if (listOfTypenames.Count() > 0)
    {
      Object child = Object.Cast(parent.GetChildren());
      while (child)
      {
        Object childToRemove = child;
        child = Object.Cast(child.GetSibling());
 
        if (childToRemove.IsAnyInherited(listOfTypenames))
        {
          vector pos = childToRemove.GetPosition();
          parent.RemoveChild(childToRemove, false);
 
          vector m4[4];
          Math3D.MatrixIdentity4(m4);
          m4[3] = pos;
          childToRemove.SetTransform(m4);
          childToRemove.PlaceOnSurface();
        }
      }
    }
  }
  static void GetAttachedChildren(IEntity parent, array<IEntity> outputObjects)
  {
    IEntity child = parent.GetChildren();
    while (child)
    {
      outputObjects.Insert(child);
      child = child.GetSibling();
    }
  }
 
  static void SoakItemInsideParentContainingLiquidAboveThreshold(notnull ItemBase item, notnull ItemBase parent, float liquidQuantityThresholdPercentage = 0.05)
  {
    if (g_Game.IsServer())
    {
      if (parent.GetLiquidType() != 0 && parent.GetQuantityNormalized() > liquidQuantityThresholdPercentage)
        item.SetWetMax();
    }
  }
}
 
class DestroyItemInCorpsesHandsAndCreateNewOnGndLambda : ReplaceAndDestroyLambda
{
  // @NOTE m_Player == target player - i.e. restrained one
  void DestroyItemInCorpsesHandsAndCreateNewOnGndLambda(EntityAI old_item, string new_item_type, PlayerBase player, bool destroy = false)
  {
    InventoryLocation gnd = new InventoryLocation;
    vector mtx[4];
    if (old_item)
      old_item.GetTransform(mtx);
    else
      player.GetTransform(mtx);
    gnd.SetGround(NULL, mtx);
    OverrideNewLocation(gnd);
  }
 
  protected override void RemoveOldItemFromLocation()
  {
    super.RemoveOldItemFromLocation();
    m_Player.GetHumanInventory().OnEntityInHandsDestroyed(m_OldLocation);
  }
}
 
// This was created since IsObjectObstructed is often called multiple times in one frame
// And apparently it seems that keeping this data in one struct seems to be more efficient than creating the variables dozens of times per frame
class IsObjectObstructedCache // Pretending this is a struct
{
  // Outside data
  vector RaycastStart = "0 0 0";
  int TotalObjects = 0;
 
  // Inside data
  vector ObjectCenterPos = "0 0 0";
  vector ObjectContactPos = "0 0 0";
  vector ObjectContactDir = "0 0 0";
  int ContactComponent = -1;
  ref array<ref RaycastRVResult> HitProxyObjects = new array<ref RaycastRVResult>;
  ref set<Object> HitObjects = new set<Object>;
 
  void IsObjectObstructedCache(vector rayCastStart, int totalObjects)
  {
    RaycastStart = rayCastStart;
    TotalObjects = totalObjects;
  }
 
  // Only inside data
  void ClearCache()
  {
    ObjectCenterPos = "0 0 0";
    ObjectContactPos = "0 0 0";
    ObjectContactDir = "0 0 0";
    ContactComponent = -1;
    HitProxyObjects.Clear();
    HitObjects.Clear();
  }
}