Hologram.c

Go to the documentation of this file.

class Hologram
{
#ifdef SERVER
  protected const int SPAWN_FLAGS = ECE_CREATEPHYSICS;
#else
  protected const int SPAWN_FLAGS = ECE_LOCAL;
#endif
 
 
#ifdef DIAG_DEVELOPER
  string m_CollisionDetails;
#endif
 
  protected const string SUFFIX_MATERIAL_DEPLOYABLE = "_deployable.rvmat";
  protected const string SUFFIX_MATERIAL_UNDEPLOYABLE = "_undeployable.rvmat";
  protected const string SUFFIX_MATERIAL_POWERED = "_powered.rvmat";
 
  protected ItemBase m_Parent;
  protected EntityAI m_Projection;
  protected PlayerBase m_Player;
  protected ProjectionTrigger m_ProjectionTrigger;
  protected string m_ProjectionTypename;
 
  protected bool m_IsColliding;
  protected bool m_IsCollidingGPlot;
  protected bool m_IsSlope;
  protected bool m_IsCollidingPlayer;
  protected bool m_IsFloating;
  protected bool m_UpdatePosition;
  protected bool m_IsHidden;
 
  protected vector m_DefaultOrientation;
  protected vector m_Rotation;
  protected vector m_y_p_r_previous;
  protected vector m_ContactDir;
  protected vector m_FromAdjusted;
  protected const string ANIMATION_PLACING = "Placing";
  protected const string ANIMATION_INVENTORY = "Inventory";
  protected const string SELECTION_PLACING = "placing";
  protected const string SELECTION_INVENTORY = "inventory";
 
  protected const float SMALL_PROJECTION_RADIUS = 1;
  protected const float SMALL_PROJECTION_GROUND = 2;
  protected const float DISTANCE_SMALL_PROJECTION = 1; 
  protected const float LARGE_PROJECTION_DISTANCE_LIMIT = 6;
  protected const float PROJECTION_TRANSITION_MIN = 1;
  protected const float PROJECTION_TRANSITION_MAX = 0.25;
  protected const float LOOKING_TO_SKY = 0.75;
  static const float DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF = 1.5;
 
  protected float m_SlopeTolerance;
  protected bool m_AlignToTerrain;
  protected vector m_YawPitchRollLimit;
  protected int m_ContactComponent;
 
  protected ref set<string> m_SelectionsToRefresh = new set<string>;
 
  // Watchtower correction variables
  // These watchtower component names should be corrected when colliding with them as they are supposed to be "trigger boxes", not colliders
  static const protected ref array<string> m_WatchtowerIgnoreComponentNames = new array<string>;
 
  // These watchtower components are supposed to be trigger boxes, but should block placement on them (currently only the boxes above the stairs)
  static const protected ref array<string> m_WatchtowerBlockedComponentNames = new array<string>;
 
  void Hologram(PlayerBase player, vector pos, ItemBase item)
  {
    m_Player = player;
    m_Parent = item;
    m_Projection = null;
 
    m_ProjectionTrigger = null;
    m_UpdatePosition = true;
    m_ContactComponent = -1;
 
    m_Rotation = "0 0 0";
    m_FromAdjusted = "0 0 0";
 
    // If the static names are empty, generate the needed names
    // Refer to their definitions to see why these are required
    if (m_WatchtowerIgnoreComponentNames.Count() == 0)
    {
      string baseStringBegin = Watchtower.BASE_VIEW_NAME;
      string baseIgnoreStringEnd = Watchtower.BASE_WALL_NAME;
 
      int floors = Watchtower.MAX_WATCHTOWER_FLOORS;
      int walls = Watchtower.MAX_WATCHTOWER_WALLS;
 
      string compName;
      for (int i = 1; i < floors + 1; ++i)
      {
        compName = baseStringBegin + i.ToString();
        for (int j = 1; j < walls + 1; ++j)
          m_WatchtowerIgnoreComponentNames.Insert(compName + baseIgnoreStringEnd + j.ToString());
 
        if (i != 1)
          m_WatchtowerBlockedComponentNames.Insert(compName);
        else
          m_WatchtowerIgnoreComponentNames.Insert(compName);
      }
    }
 
    string configPathProjectionTypename = string.Format("CfgVehicles %1 projectionTypename", m_Parent.GetType());
    if (GetGame().ConfigIsExisting(configPathProjectionTypename))
      m_ProjectionTypename = GetGame().ConfigGetTextOut(configPathProjectionTypename);
 
    EntityAI projectionEntity;
    if (GetGame().IsMultiplayer() && GetGame().IsServer())
    {
      projectionEntity = EntityAI.Cast(GetGame().CreateObjectEx(ProjectionBasedOnParent(), pos, ECE_PLACE_ON_SURFACE));
      projectionEntity.SetAllowDamage(false);
      SetProjectionEntity(projectionEntity);
      SetAnimations();
    }
    else
    {
      projectionEntity = EntityAI.Cast(GetGame().CreateObjectEx(ProjectionBasedOnParent(), pos, ECE_TRACE | ECE_LOCAL));
      if (projectionEntity == null)
      {
        ErrorEx(string.Format("Cannot create hologram entity from config class %1", ProjectionBasedOnParent()), ErrorExSeverity.WARNING);
        return;
      }
 
      SetProjectionEntity(projectionEntity);
      SetAnimations();
      CreateTrigger();
      RefreshTrigger();
    }
 
    if (ItemBase.Cast(projectionEntity))
      ItemBase.Cast(GetProjectionEntity()).SetIsHologram(true);
 
    string configPathSlope = string.Format("CfgVehicles %1 slopeTolerance", GetProjectionEntity().GetType());
    if (GetGame().ConfigIsExisting(configPathSlope))
      m_SlopeTolerance = GetGame().ConfigGetFloat(configPathSlope);
 
    string configPathAlign = string.Format("CfgVehicles %1 alignHologramToTerain", GetProjectionEntity().GetType());
    if (GetGame().ConfigIsExisting(configPathAlign))
      m_AlignToTerrain = GetGame().ConfigGetInt(configPathAlign);
 
    string configPathOrientationLimit = string.Format("CfgVehicles %1 yawPitchRollLimit", GetProjectionEntity().GetType());
    if (GetGame().ConfigIsExisting(configPathOrientationLimit))
      m_YawPitchRollLimit = GetGame().ConfigGetVector(configPathOrientationLimit);
  }
 
  void ~Hologram()
  {
    if (GetGame())
    {
      if (m_Projection)
        GetGame().ObjectDelete(m_Projection);
 
      if (m_ProjectionTrigger)
        GetGame().ObjectDelete(m_ProjectionTrigger);
    }
 
#ifdef DIAG_DEVELOPER
    DestroyDebugCollisionBox();
#endif
  }
 
  void SetAnimations()
  {
    if (m_Projection.HasAnimation(ANIMATION_PLACING))
    {
      m_Projection.SetAnimationPhase(ANIMATION_PLACING, 0);
      SetSelectionToRefresh(SELECTION_PLACING);
 
      if (m_Projection.HasAnimation(ANIMATION_INVENTORY))
        m_Projection.SetAnimationPhase(ANIMATION_INVENTORY, 1);
    }
    else
    {
      UpdateSelections();
      SetSelectionToRefresh(SELECTION_INVENTORY);
    }
  }
 
  // Updates selections on hologram object so they reflect the state of the parent object's selections.
  void UpdateSelections()
  {
    string cfg_access = "CfgVehicles " + m_Projection.GetType() + " AnimationSources ";
 
    if (GetGame().ConfigIsExisting(cfg_access))
    {
      int cfg_access_count = g_Game.ConfigGetChildrenCount(cfg_access);
 
      for (int i = 0; i < cfg_access_count; ++i)
      {
        string found_anim;
        GetGame().ConfigGetChildName(cfg_access, i, found_anim);
 
        float anim_phase = m_Parent.GetAnimationPhase(found_anim);
        m_Projection.SetAnimationPhase(found_anim, anim_phase);
      }
    }
  }
 
  string ProjectionBasedOnParent()
  {
    return GetProjectionName(m_Parent);
  }
 
  string GetProjectionName(ItemBase item)
  {
    if (m_ProjectionTypename != "")
      return m_ProjectionTypename;
 
    if (!item)
      return "";
 
    if (item.CanMakeGardenplot())
      return "GardenPlotPlacing";
 
    //Camping & Base building
    if (item.IsInherited(TentBase) || item.IsBasebuildingKit())
      return item.GetType() + "Placing";
 
    return item.GetType();
  }
 
  static bool DoesHaveProjection(ItemBase item)
  {
    return item && (item.IsDeployable() || item.CanMakeGardenplot() || item.IsInherited(DeployableContainer_Base));
  }
 
  // update loop for visuals and collisions of the hologram
  void UpdateHologram(float timeslice)
  {
    if (!m_Parent)
    {
      m_Player.TogglePlacingLocal();
 
      return;
    }
 
    if (IsRestrictedFromAdvancedPlacing())
    {
      m_Player.TogglePlacingLocal();
 
      return;
    }
 
    if (!GetUpdatePosition())
      return;
 
 
#ifdef DIAG_DEVELOPER
    DebugConfigValues();
    DestroyDebugCollisionBox();
#endif
 
    // update hologram position
    SetProjectionPosition(GetProjectionEntityPosition(m_Player));
    SetProjectionOrientation(AlignProjectionOnTerrain(timeslice));
 
    EvaluateCollision();
    RefreshTrigger();
    CheckPowerSource();
    RefreshVisual();
 
    m_Projection.OnHologramBeingPlaced(m_Player);
  }
 
  vector AlignProjectionOnTerrain(float timeslice)
  {
    vector y_p_r;
 
    if (m_AlignToTerrain)
    {
      vector projection_orientation_angles = GetDefaultOrientation() + GetProjectionRotation();
      vector mat0[3];
      vector mat1[3];
      vector mat2[3];
      vector projection_position = m_Projection.GetPosition();
      vector normal;
 
      if (m_ContactDir.Length() > 0)
        normal = m_ContactDir;
      else
        normal = GetGame().SurfaceGetNormal(projection_position[0], projection_position[2]);
 
      vector angles = normal.VectorToAngles();
      angles[1] = angles[1] + 270;
 
      angles[0] = Math.Clamp(angles[0], 0, 360);
      angles[1] = Math.Clamp(angles[1], 0, 360);
      angles[2] = Math.Clamp(angles[2], 0, 360);
 
      projection_orientation_angles[0] = projection_orientation_angles[0] + (360 - angles[0]);
 
      Math3D.YawPitchRollMatrix(projection_orientation_angles, mat0);
      Math3D.YawPitchRollMatrix(angles, mat1);
      Math3D.MatrixMultiply3(mat1, mat0, mat2);
 
      y_p_r = Math3D.MatrixToAngles(mat2);
    }
    else
    {
      y_p_r = GetDefaultOrientation() + GetProjectionRotation();
 
      if (y_p_r[0] > 180)
        y_p_r[0] = y_p_r[0] - 360;
 
      if (y_p_r[0] < -180)
        y_p_r[0] = y_p_r[0] + 360;
    }
 
    return SmoothProjectionMovement(y_p_r, timeslice);
  }
 
  vector SmoothProjectionMovement(vector y_p_r, float timeslice)
  {
    if (m_y_p_r_previous)
    {
      if (Math.AbsFloat(y_p_r[0] - m_y_p_r_previous[0]) > 100)
      {
        if (y_p_r[0] > 0)
          m_y_p_r_previous[0] = m_y_p_r_previous[0] + 360;
 
        if (y_p_r[0] < 0)
          m_y_p_r_previous[0] = m_y_p_r_previous[0] - 360;
      }
 
      y_p_r[0] = Math.Lerp(m_y_p_r_previous[0], y_p_r[0], 15 * timeslice);
      y_p_r[1] = Math.Lerp(m_y_p_r_previous[1], y_p_r[1], 15 * timeslice);
      y_p_r[2] = Math.Lerp(m_y_p_r_previous[2], y_p_r[2], 15 * timeslice);
    }
 
    m_y_p_r_previous = y_p_r;
 
    return y_p_r;
  }
 
  void CreateTrigger()
  {
    Class.CastTo(m_ProjectionTrigger, g_Game.CreateObjectEx("ProjectionTrigger", GetProjectionPosition(), SPAWN_FLAGS));
 
    m_ProjectionTrigger.SetOrientation(GetProjectionOrientation());
    m_ProjectionTrigger.SetParentObject(this);
    m_ProjectionTrigger.SetParentOwner(m_Player);
 
    RefreshVisual();
  }
 
  void RefreshTrigger()
  {
    vector min_max[2];
    GetProjectionCollisionBox(min_max);
 
    m_ProjectionTrigger.SetPosition(GetProjectionPosition());
    m_ProjectionTrigger.SetOrientation(GetProjectionOrientation());
    m_ProjectionTrigger.SetExtents(min_max[0], min_max[1]);
  }
 
#ifdef DIAG_DEVELOPER
  void DebugText(string header, bool mustBeTrue = false, bool condition = true, string info = "")
  {
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      int color = 0xFFFFFFFF;
 
      if (mustBeTrue && !condition || !mustBeTrue && condition)
        color = COLOR_RED;
 
      string text = header + condition + info;
      DbgUI.ColoredText(color, text);
    }
  }
 
  protected float m_PitchOverride;
  protected float m_RollOverride;
  void DebugConfigValues()
  {
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      m_PitchOverride = m_YawPitchRollLimit[1];
      m_RollOverride = m_YawPitchRollLimit[2];
 
      DbgUI.InputFloat("slopeTolerance override", m_SlopeTolerance);
      DbgUI.SameLine();
      DbgUI.InputFloat("pitch limit override", m_PitchOverride);
      DbgUI.SameLine();
      DbgUI.InputFloat("roll limit override", m_RollOverride);
 
      m_YawPitchRollLimit[1] = m_PitchOverride;
      m_YawPitchRollLimit[2] = m_RollOverride;
    }
  }
#endif
 
  void EvaluateCollision(ItemBase action_item = null)
  {
#ifdef DIAG_DEVELOPER
    m_CollisionDetails = "";
#endif
 
    if (!m_Player.CanPlaceItem(m_Projection))
    {
#ifdef DIAG_DEVELOPER
      m_CollisionDetails += "[Player]";
#endif
      SetIsColliding(true);
 
    }
    else if (IsFloating() || IsHidden() || IsCollidingBBox(action_item) || IsCollidingPlayer() || IsClippingRoof() || !IsBaseViable() || IsCollidingGPlot() || IsCollidingZeroPos() || IsCollidingAngle() || !IsPlacementPermitted() || !HeightPlacementCheck() || IsUnderwater() || IsInTerrain())
      SetIsColliding(true);
    else if (m_Projection.IsInherited(TrapSpawnBase))
    {
#ifdef DIAG_DEVELOPER
      DebugText("Inherits from TrapSpawnBase, checking IsPlaceableAtposition", true);
#endif
 
      TrapSpawnBase trapSpawnBase;
      Class.CastTo(trapSpawnBase, m_Projection);
      SetIsColliding(!trapSpawnBase.IsPlaceableAtPosition(m_Projection.GetPosition()));
    }
    else if (m_Projection.IsInherited(TrapBase))
    {
#ifdef DIAG_DEVELOPER
      DebugText("Inherits from TrapBase, checking IsPlaceableAtposition", true);
#endif
      TrapBase trapBase;
      Class.CastTo(trapBase, m_Projection);
      SetIsColliding(!trapBase.IsPlaceableAtPosition(m_Projection.GetPosition()));
    }
    else
      SetIsColliding(false);
  }
 
  bool IsClippingRoof()
  {
    if (CfgGameplayHandler.GetDisableIsClippingRoofCheck())
      return false;
    if (GetGame().IsServer() && GetGame().IsMultiplayer())
      return false;
 
    //Some locations allow you to look up and attempt placing the hologram on the bottom side of a floor - most notably the floors of a watchtower
    //This check also prevents some very unnatural placements
 
    bool b1 = m_Projection.GetPosition()[1] > GetGame().GetCurrentCameraPosition()[1];
    bool b2 = false;
#ifdef DIAG_DEVELOPER
    vector from, to;
#endif
    if (m_Projection.DoPlacingHeightCheck())
    {
      b2 = MiscGameplayFunctions.IsUnderRoofEx(m_Projection, GameConstants.ROOF_CHECK_RAYCAST_DIST, ObjIntersectFire);
#ifdef DIAG_DEVELOPER
      MiscGameplayFunctions.IsUnderRoofFromToCalculation(m_Projection, from, to);
      DrawArrow(from, to, !b2);
#endif
    }
 
#ifdef DIAG_DEVELOPER
    DebugText("IsClippingRoof: ", false, b1, " | (projection height) " + m_Projection.GetPosition()[1] + " > (camera height) " + GetGame().GetCurrentCameraPosition()[1]);
    DebugText("IsClippingRoof: ", false, b2, " | (DoPlacingHeightCheck) " + m_Projection.DoPlacingHeightCheck() + " && (IsUnderRoof) " + MiscGameplayFunctions.IsUnderRoof(m_Projection) + " | from: " + from[1] + " | to: " + to[1]);
#endif
 
    return b1 || b2;
  }
 
  bool IsCollidingAngle()
  {
    if (CfgGameplayHandler.GetDisableIsCollidingAngleCheck())
      return false;
    vector projection_orientation = m_Projection.GetOrientation();
    bool isTrue = Math.AbsFloat(projection_orientation[1]) > m_YawPitchRollLimit[1] || Math.AbsFloat(projection_orientation[2]) > m_YawPitchRollLimit[2];
#ifdef DIAG_DEVELOPER
    DebugText("IsCollidingAngle: ", false, isTrue, " | (proj pitch) " + Math.AbsFloat(projection_orientation[1]) + " > (pitch limit) " + m_YawPitchRollLimit[1] + " | (proj roll) " + Math.AbsFloat(projection_orientation[2]) + " > (roll limit) " + m_YawPitchRollLimit[2]);
#endif
 
    return isTrue;
  }
 
#ifdef DIAG_DEVELOPER
  protected Shape m_CollisionBox;
  protected void DrawDebugCollisionBox(vector min_max[2], int color)
  {
    vector mat[4];
    m_Projection.GetTransform(mat);
    m_CollisionBox = Debug.DrawBox(min_max[0], min_max[1], color);
    m_CollisionBox.SetMatrix(mat);
  }
 
  protected void DestroyDebugCollisionBox()
  {
    if (m_CollisionBox)
    {
      m_CollisionBox.Destroy();
      m_CollisionBox = NULL;
    }
  }
#endif
 
  bool IsCollidingBBox(ItemBase action_item = null)
  {
    if (CfgGameplayHandler.GetDisableIsCollidingBBoxCheck())
      return false;
 
    vector center;
    vector relativeOffset; //we need to lift BBox, because it is calculated from the bottom of projection, and not from the middle
    vector absoluteOffset = "0 0.05 0"; //we need to lift BBox even more, because it colliddes with house floors due to various reasons (probably geometry or float imperfections)
    vector orientation = GetProjectionOrientation();
    vector edgeLength;
    vector minMax[2];
    array<Object> excludedObjects = new array<Object>();
    array<Object> collidedObjects = new array<Object>();
 
    GetProjectionCollisionBox(minMax);
    relativeOffset[1] = (minMax[1][1] - minMax[0][1]) * 0.5;
    center = m_Projection.GetPosition() + relativeOffset + absoluteOffset;
    edgeLength = GetCollisionBoxSize(minMax);
    excludedObjects.Insert(m_Projection);
    excludedObjects.Insert(m_Player);
 
    if (action_item)
      excludedObjects.Insert(action_item);
 
    //add is construction check
    // Base building objects behave in a way that causes this test to generate false positives
    bool isTrue = GetGame().IsBoxCollidingGeometry(center, orientation, edgeLength, ObjIntersectFire, ObjIntersectGeom, excludedObjects, collidedObjects);
#ifdef DIAG_DEVELOPER
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      string text = "";
      foreach (Object object: collidedObjects)
        text += " | " + Object.GetDebugName(object);
 
      DebugText("IsCollidingBBox: ", false, isTrue, text);
 
      int color = 0x01FFFFFF;
      if (isTrue)
        color = 0x33F22613;
 
      DrawDebugCollisionBox(minMax, color);
    }
#endif
 
    return isTrue;
  }
 
  bool IsBaseViable()
  {
    //This function is not required to solve server-side fixes for clipping, saves calculations and potential false negatives
    if (GetGame().IsServer() && GetGame().IsMultiplayer())
      return true;
 
    if (CfgGameplayHandler.GetDisableIsBaseViableCheck())
      return true;
 
    vector from_left_close = m_Projection.CoordToParent(GetLeftCloseProjectionVector());
    vector to_left_close_down = from_left_close + "0 -1 0";
 
    vector from_right_close = m_Projection.CoordToParent(GetRightCloseProjectionVector());
    vector to_right_close_down = from_right_close + "0 -1 0";
 
    vector from_left_far = m_Projection.CoordToParent(GetLeftFarProjectionVector());
    vector to_left_far_down = from_left_far + "0 -1 0";
 
    vector from_right_far = m_Projection.CoordToParent(GetRightFarProjectionVector());
    vector to_right_far_down = from_right_far + "0 -1 0";
 
    vector contact_pos_left_close;
    vector contact_pos_right_close;
    vector contact_pos_left_far;
    vector contact_pos_right_far;
    vector contact_dir_left_close;
    vector contact_dir_right_close;
    vector contact_dir_left_far;
    vector contact_dir_right_far;
    int contact_component_left_close;
    int contact_component_right_close;
    int contact_component_left_far;
    int contact_component_right_far;
    set<Object> results_left_close = new set<Object>;
    set<Object> results_right_close = new set<Object>;
    set<Object> results_left_far = new set<Object>;
    set<Object> results_right_far = new set<Object>;
    Object obj_left_close;
    Object obj_right_close;
    Object obj_left_far;
    Object obj_right_far;
 
    //Not sure what the intention here was before, but it boiled down to a very bloated version of what you see here right now
    DayZPhysics.RaycastRV(from_left_close, to_left_close_down, contact_pos_left_close, contact_dir_left_close, contact_component_left_close, results_left_close, null, m_Projection, false, false, ObjIntersectFire);
    if (results_left_close.Count() > 0)
      obj_left_close = results_left_close[results_left_close.Count() - 1];
 
    DayZPhysics.RaycastRV(from_right_close, to_right_close_down, contact_pos_right_close, contact_dir_right_close, contact_component_right_close, results_right_close, null, m_Projection, false, false, ObjIntersectFire);
    if (results_right_close.Count() > 0)
      obj_right_close = results_right_close[results_right_close.Count() - 1];
 
    DayZPhysics.RaycastRV(from_left_far, to_left_far_down, contact_pos_left_far, contact_dir_left_far, contact_component_left_far, results_left_far, null, m_Projection, false, false, ObjIntersectFire);
    if (results_left_far.Count() > 0)
      obj_left_far = results_left_far[results_left_far.Count() - 1];
 
    DayZPhysics.RaycastRV(from_right_far, to_right_far_down, contact_pos_right_far, contact_dir_right_far, contact_component_right_far, results_right_far, null, m_Projection, false, false, ObjIntersectFire);
    if (results_right_far.Count() > 0)
      obj_right_far = results_right_far[results_right_far.Count() - 1];
 
    return IsBaseIntact(obj_left_close, obj_right_close, obj_left_far, obj_right_far) && IsBaseStatic(obj_left_close) && IsBaseFlat(contact_pos_left_close, contact_pos_right_close, contact_pos_left_far, contact_pos_right_far);
  }
 
  bool IsCollidingGPlot()
  {
    if (CfgGameplayHandler.GetDisableIsCollidingGPlotCheck())
      return false;
 
#ifdef DIAG_DEVELOPER
    DebugText("IsCollidingGPlot: ", false, m_IsCollidingGPlot);
#endif
 
    return m_IsCollidingGPlot;
  }
 
  bool IsCollidingZeroPos()
  {
    vector origin = Vector(0, 0, 0);
    bool isTrue = GetProjectionPosition() == origin;
#ifdef DIAG_DEVELOPER
    DebugText("IsCollidingZeroPos: ", false, isTrue);
#endif
 
    return isTrue;
  }
 
  bool IsBehindObstacle()
  {
    ErrorEx("Deprecated check - do not use", ErrorExSeverity.WARNING);
    return false;
  }
 
  //This function only takes one of the found objects since IsBaseIntact already verifies that all of them are either null or the same object
  bool IsBaseStatic(Object objectToCheck)
  {
    //check if the object below hologram is dynamic object. Dynamic objects like barrels can be taken to hands
    //and item which had been placed on top of them, would stay floating in the air
#ifdef DIAG_DEVELOPER
    if (objectToCheck == null)
      DebugText("IsBaseStatic(must be true): ", true, true, " | objectToCheck is null (this is good)");
    else
      DebugText("IsBaseStatic(must be true): ", true, IsObjectStatic(objectToCheck));
#endif
    return objectToCheck == null || IsObjectStatic(objectToCheck);
  }
 
  bool IsObjectStatic(Object obj)
  {
    return obj.IsBuilding() || obj.IsPlainObject() || (!m_Parent.IsInherited(KitBase) && obj.IsInherited(BaseBuildingBase) && (m_WatchtowerBlockedComponentNames.Find(obj.GetActionComponentName(m_ContactComponent, LOD.NAME_VIEW)) == -1));
  }
 
  bool IsBaseIntact(Object under_left_close, Object under_right_close, Object under_left_far, Object under_right_far)
  {
    bool isTrue = (under_left_close == under_right_close && under_right_close == under_left_far && under_left_far == under_right_far);
#ifdef DIAG_DEVELOPER
    DebugText("IsBaseIntact(must be true and all equal): ", true, isTrue, " | ulc: " + Object.GetDebugName(under_left_close) + " | urc: " + Object.GetDebugName(under_right_close) + " | ulf: " + Object.GetDebugName(under_left_far) + " | urf: " + Object.GetDebugName(under_right_far));
    if (!isTrue)
    {
      array<bool> conditions = new array<bool>();
      conditions.Insert(under_left_close == null);
      conditions.Insert(under_right_close == null);
      conditions.Insert(under_left_far == null);
      conditions.Insert(under_right_far == null);
 
      int amountOfNull = 0;
      if (!under_left_close)
        ++amountOfNull;
      if (!under_right_close)
        ++amountOfNull;
      if (!under_left_far)
        ++amountOfNull;
      if (!under_right_far)
        ++amountOfNull;
 
      if (amountOfNull < 3)
        for (int i = 0; i < conditions.Count(); ++i)
          conditions[i] = !conditions[i];
 
      DrawBaseSpheres(conditions);
    }
#endif
 
    return isTrue;
  }
 
#ifdef DIAG_DEVELOPER
  void DrawArrow(vector from, vector to, bool condition)
  {
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      int color = 0xFFFFFFFF;
      if (!condition)
        color = COLOR_RED;
 
      Debug.DrawArrow(from, to, 1, color, ShapeFlags.ONCE);
    }
  }
 
  void DrawSphere(vector pos, bool condition)
  {
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      int color = 0x01FFFFFF;
      if (!condition)
        color = 0x99F22613;
 
      Debug.DrawSphere(pos, 1, color, ShapeFlags.ONCE | ShapeFlags.TRANSP | ShapeFlags.NOOUTLINE);
    }
  }
 
  void DrawBaseSpheres(array<bool> conditions)
  {
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      array<vector> positions = new array<vector>();
      positions.Insert(m_Projection.CoordToParent(GetLeftCloseProjectionVector()));
      positions.Insert(m_Projection.CoordToParent(GetRightCloseProjectionVector()));
      positions.Insert(m_Projection.CoordToParent(GetLeftFarProjectionVector()));
      positions.Insert(m_Projection.CoordToParent(GetRightFarProjectionVector()));
 
      for (int i = 0; i < positions.Count(); ++i)
        DrawSphere(positions[i], conditions[i]);
    }
  }
 
  void DrawDebugArrow(float start, float dist, int color = 0xFF1FFFFF)
  {
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
    {
      vector from = m_Player.GetPosition() + start * MiscGameplayFunctions.GetHeadingVector(m_Player);
      vector to = m_Player.GetPosition() + dist * MiscGameplayFunctions.GetHeadingVector(m_Player);
 
      Debug.DrawArrow(from, to, 0.5, 0xFF1FFFFF, ShapeFlags.ONCE | ShapeFlags.TRANSP);
    }
  }
#endif
 
  bool IsBaseFlat(vector contact_pos_left_close, vector contact_pos_right_close, vector contact_pos_left_far, vector contact_pos_right_far)
  {
    vector projection_pos = GetProjectionPosition();
    float slope_pos_left_close = Math.AbsFloat(projection_pos[1] - contact_pos_left_close[1]);
    float slope_pos_right_close = Math.AbsFloat(projection_pos[1] - contact_pos_right_close[1]);
    float slope_pos_left_far = Math.AbsFloat(projection_pos[1] - contact_pos_left_far[1]);
    float slope_pos_right_far = Math.AbsFloat(projection_pos[1] - contact_pos_right_far[1]);
 
    bool isTrue = slope_pos_left_close < m_SlopeTolerance && slope_pos_right_close < m_SlopeTolerance && slope_pos_left_far < m_SlopeTolerance && slope_pos_right_far < m_SlopeTolerance;
#ifdef DIAG_DEVELOPER
    DebugText("IsBaseFlat(must be true): ", true, isTrue, " (slope < slopeTolerance) | slopeTolerance:  " + m_SlopeTolerance + " | lc: " + slope_pos_left_close + " | rc: " + slope_pos_right_close + " | lf: " + slope_pos_left_far + " | rf: " + slope_pos_right_far);
    DrawArrow(projection_pos, contact_pos_left_close, slope_pos_left_close < m_SlopeTolerance);
    DrawArrow(projection_pos, contact_pos_right_close, slope_pos_right_close < m_SlopeTolerance);
    DrawArrow(projection_pos, contact_pos_left_far, slope_pos_left_far < m_SlopeTolerance);
    DrawArrow(projection_pos, contact_pos_right_far, slope_pos_right_far < m_SlopeTolerance);
#endif
 
    return isTrue;
  }
 
  bool IsPlacementPermitted()
  {
    if (CfgGameplayHandler.GetDisableIsPlacementPermittedCheck())
      return true;
 
    bool isTrue = m_Parent && m_Parent.CanBePlaced(m_Player, GetProjectionPosition());
 
#ifdef DIAG_DEVELOPER
    DebugText("IsPlacementPermitted(must be true): ", true, isTrue, " (Note: ItemBase::CanBePlaced() return value)");
#endif
    return isTrue;
  }
 
  bool HeightPlacementCheck()
  {
    if (CfgGameplayHandler.GetDisableHeightPlacementCheck())
      return true;
    if (GetProjectionEntity()) //simple height check
    {
      vector playerpos = m_Player.GetPosition();
      vector projectionpos = GetProjectionPosition();
      float delta1 = playerpos[1] - projectionpos[1];
 
      if (delta1 > DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF || delta1 < -DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF)
      {
#ifdef DIAG_DEVELOPER
        DebugText("HeightPlacementCheck(must be true): ", true, false, " | Height difference between item and player is larger than " + DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF);
#endif
        return false;
      }
    }
#ifdef DIAG_DEVELOPER
    DebugText("HeightPlacementCheck(must be true): ", true, true);
#endif
    return true;
  }
 
  bool IsUnderwater()
  {
    if (CfgGameplayHandler.GetDisableIsUnderwaterCheck())
      return false;
    // Fast check middle of object
    string type;
    int liquid;
    g_Game.SurfaceUnderObject(m_Projection, type, liquid);
 
    if (liquid == LIQUID_WATER)
    {
#ifdef DIAG_DEVELOPER
      DebugText("IsUnderwater: ", false, true, " | Surface under object is water");
#endif
      return true;
    }
 
    // Check every corner of the object
    vector left_close = m_Projection.CoordToParent(GetLeftCloseProjectionVector());
    vector right_close = m_Projection.CoordToParent(GetRightCloseProjectionVector());
    vector left_far = m_Projection.CoordToParent(GetLeftFarProjectionVector());
    vector right_far = m_Projection.CoordToParent(GetRightFarProjectionVector());
    bool surface_sea_water = IsSurfaceSea(left_close) || IsSurfaceSea(right_close) || IsSurfaceSea(left_far) || IsSurfaceSea(right_far);
 
#ifdef DIAG_DEVELOPER
    // I'd rather duplicate this on internal than introduce (even) more raycasts than needed on retail..
    float lc = g_Game.GetWaterDepth(left_close);
    float rc = g_Game.GetWaterDepth(right_close);
    float lf = g_Game.GetWaterDepth(left_far);
    float rf = g_Game.GetWaterDepth(right_far);
    bool isTrue = (lc > 0 || rc > 0 || lf > 0 || rf > 0 || surface_sea_water);
    DebugText("IsUnderwater: ", false, isTrue, " surface_sea_water: " + surface_sea_water + " | (all must be less than zero) | lc: " + lc + " | rc: " + rc + " | lf: " + lf + " | rf: " + rf);
    //DebugText("Corner Height: ", false, true, " lc: " + left_close[1] + " | rc: " + right_close[1] + " | lf: " + left_far[1] + " | rf: " + right_far[1]);
    if (isTrue)
    {
      array<bool> conditions = {lc <= 0, rc <= 0, lf <= 0, rf <= 0};
      DrawBaseSpheres(conditions);
    }
#endif
 
    return (surface_sea_water || g_Game.GetWaterDepth(left_close) > 0 || g_Game.GetWaterDepth(right_close) > 0 || g_Game.GetWaterDepth(left_far) > 0 || g_Game.GetWaterDepth(right_far) > 0);
  }
 
  bool IsInTerrain()
  {
    if (CfgGameplayHandler.GetDisableIsInTerrainCheck())
      return false;
    vector fromHeightOffset = "0 0.3 0";
    vector toHeightOffset = "0 1 0";
 
    vector from_left_close = m_Projection.CoordToParent(GetLeftCloseProjectionVector()) + fromHeightOffset;
    vector to_left_close_down = from_left_close + toHeightOffset;
 
    vector from_right_close = m_Projection.CoordToParent(GetRightCloseProjectionVector()) + fromHeightOffset;
    vector to_right_close_down = from_right_close + toHeightOffset;
 
    vector from_left_far = m_Projection.CoordToParent(GetLeftFarProjectionVector()) + fromHeightOffset;
    vector to_left_far_down = from_left_far + toHeightOffset;
 
    vector from_right_far = m_Projection.CoordToParent(GetRightFarProjectionVector()) + fromHeightOffset;
    vector to_right_far_down = from_right_far + toHeightOffset;
 
    vector contact_pos_left_close;
    vector contact_pos_right_close;
    vector contact_pos_left_far;
    vector contact_pos_right_far;
 
    vector contact_dir_left_close;
    vector contact_dir_right_close;
    vector contact_dir_left_far;
    vector contact_dir_right_far;
 
    int contact_component_left_close;
    int contact_component_right_close;
    int contact_component_left_far;
    int contact_component_right_far;
 
#ifdef DIAG_DEVELOPER
    // I'd rather duplicate this on internal than introduce (even) more raycasts than needed on retail..
    set<Object> lcO = new set<Object>();
    set<Object> rcO = new set<Object>();
    set<Object> lfO = new set<Object>();
    set<Object> rfO = new set<Object>();
    bool lc = DayZPhysics.RaycastRV(from_left_close, to_left_close_down, contact_pos_left_close, contact_dir_left_close, contact_component_left_close, lcO, m_Projection, m_Projection, false, true, ObjIntersectFire);
    bool rc = DayZPhysics.RaycastRV(from_right_close, to_right_close_down, contact_pos_right_close, contact_dir_right_close, contact_component_right_close, rcO, m_Projection, m_Projection, false, true, ObjIntersectFire);
    bool lf = DayZPhysics.RaycastRV(from_left_far, to_left_far_down, contact_pos_left_far, contact_dir_left_far, contact_component_left_far, lfO, m_Projection, m_Projection, false, true, ObjIntersectFire);
    bool rf = DayZPhysics.RaycastRV(from_right_far, to_right_far_down, contact_pos_right_far, contact_dir_right_far, contact_component_right_far, rfO, m_Projection, m_Projection, false, true, ObjIntersectFire);
    bool isTrue = (lc || rc || lf || rf);
    string text = "";
    if (isTrue)
    {
      if (lc)
        text += " | lc";
      if (rc)
        text += " | rc";
      if (lf)
        text += " | lf";
      if (rf)
        text += " | rf";
 
      if (lcO.Count() > 0)
        text += " | lcO: " + lcO[0];
      if (rcO.Count() > 0)
        text += " | rcO: " + rcO[0];
      if (lfO.Count() > 0)
        text += " | lfO: " + lfO[0];
      if (rfO.Count() > 0)
        text += " | rfO: " + rfO[0];
 
      array<bool> conditions = {!lc, !rc, !lf, !rf};
      DrawBaseSpheres(conditions);
    }
    DebugText("IsInTerrain: ", false, isTrue, text);
#endif
 
    if (DayZPhysics.RaycastRV(from_left_close, to_left_close_down, contact_pos_left_close, contact_dir_left_close, contact_component_left_close, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire))
      return true;
 
    if (DayZPhysics.RaycastRV(from_right_close, to_right_close_down, contact_pos_right_close, contact_dir_right_close, contact_component_right_close, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire))
      return true;
 
    if (DayZPhysics.RaycastRV(from_left_far, to_left_far_down, contact_pos_left_far, contact_dir_left_far, contact_component_left_far, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire))
      return true;
 
    if (DayZPhysics.RaycastRV(from_right_far, to_right_far_down, contact_pos_right_far, contact_dir_right_far, contact_component_right_far, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire))
      return true;
 
    return false;
  }
 
  void CheckPowerSource()
  {
    //in range of its power source.
    if (m_Player && m_Parent && m_Parent.HasEnergyManager() && m_Parent.GetCompEM().IsPlugged())
    {
      // Unplug the device when the player is too far from the power source.
      m_Parent.GetCompEM().UpdatePlugState();
 
      // Delete local hologram when plug is rippled out and advanced placement is active
      if (GetGame().IsMultiplayer() && GetGame().IsClient())
      {
        if (!m_Parent.GetCompEM().IsPlugged())
          m_Player.TogglePlacingLocal();
      }
    }
  }
 
  EntityAI PlaceEntity(EntityAI entity_for_placing)
  {
    //string-based comparison
    if (entity_for_placing.IsInherited(TentBase) || entity_for_placing.IsBasebuildingKit())
      return entity_for_placing;
 
    if (m_Projection.IsInherited(GardenPlotPlacing))
    {
      Class.CastTo(entity_for_placing, GetGame().CreateObjectEx("GardenPlot", m_Projection.GetPosition(), ECE_OBJECT_SWAP));
      return entity_for_placing;
    }
 
    //inheritance comparison
    if (!GetProjectionEntity().IsKindOf(m_Parent.GetType()))
      Class.CastTo(entity_for_placing, GetGame().CreateObjectEx(m_Projection.GetType(), m_Projection.GetPosition(), ECE_OBJECT_SWAP));
 
    return entity_for_placing;
  }
 
  protected void GetProjectionCollisionBox(out vector min_max[2])
  {
    if (!m_Projection.GetCollisionBox(min_max) && m_Projection.MemoryPointExists("box_placing_min"))
    {
      min_max[0] = m_Projection.GetMemoryPointPos("box_placing_min");
      min_max[1] = m_Projection.GetMemoryPointPos("box_placing_max");
      //Debug.DrawSphere(m_Projection.ModelToWorld(min_max[0]) , 0.8,Colors.RED, ShapeFlags.ONCE);
      //Debug.DrawSphere(m_Projection.ModelToWorld(min_max[1]), 0.8,Colors.RED, ShapeFlags.ONCE);
    }
  }
 
  protected vector GetCollisionBoxSize(vector min_max[2])
  {
    vector box_size = Vector(1, 1, 1);
 
    box_size[0] = min_max[1][0] - min_max[0][0];
    box_size[2] = min_max[1][2] - min_max[0][2];
    box_size[1] = min_max[1][1] - min_max[0][1];
 
    return box_size;
  }
 
  vector GetLeftCloseProjectionVector()
  {
    vector min_max[2];
    GetProjectionCollisionBox(min_max);
 
    return min_max[0];
  }
 
  vector GetRightCloseProjectionVector()
  {
    vector min_max[2];
    GetProjectionCollisionBox(min_max);
    min_max[1][1] = min_max[0][1];
    min_max[1][2] = min_max[0][2];
 
    return min_max[1];
  }
 
  vector GetLeftFarProjectionVector()
  {
    vector min_max[2];
    GetProjectionCollisionBox(min_max);
    min_max[0][2] = min_max[1][2];
 
    return min_max[0];
  }
 
  vector GetRightFarProjectionVector()
  {
    vector min_max[2];
    GetProjectionCollisionBox(min_max);
    min_max[1][1] = min_max[0][1];
 
    return min_max[1];
  }
 
  // Replaced by IsUnderwater, currently unused
  bool IsSurfaceWater(vector position)
  {
    CGame game = GetGame();
    return game.SurfaceIsSea(position[0], position[2]) || game.SurfaceIsPond(position[0], position[2]);
  }
 
  bool IsSurfaceSea(vector position)
  {
    CGame game = GetGame();
    return game.SurfaceIsSea(position[0], position[2]);
  }
 
  protected vector GetProjectionEntityPosition(PlayerBase player)
  {
    float minProjectionDistance;
    float maxProjectionDistance;
    m_ContactDir = vector.Zero;
    vector minMax[2];
    float projectionRadius = GetProjectionRadius();
    float cameraToPlayerDistance = vector.Distance(GetGame().GetCurrentCameraPosition(), player.GetPosition());
 
    if (projectionRadius < SMALL_PROJECTION_RADIUS) // objects with radius smaller than 1m
    {
      minProjectionDistance = SMALL_PROJECTION_RADIUS;
      maxProjectionDistance = SMALL_PROJECTION_RADIUS * 2;
    }
    else
    {
      minProjectionDistance = projectionRadius;
      maxProjectionDistance = projectionRadius * 2;
      maxProjectionDistance = Math.Clamp(maxProjectionDistance, SMALL_PROJECTION_RADIUS, LARGE_PROJECTION_DISTANCE_LIMIT);
    }
 
    vector from = GetGame().GetCurrentCameraPosition();
    //adjusts raycast origin to player head approx. level (limits results behind the character)
    if (DayZPlayerCamera3rdPerson.Cast(player.GetCurrentCamera()))
    {
      vector head_pos;
      MiscGameplayFunctions.GetHeadBonePos(player, head_pos);
      float dist = vector.Distance(head_pos, from);
      from = from + GetGame().GetCurrentCameraDirection() * dist;
    }
 
    vector to = from + (GetGame().GetCurrentCameraDirection() * (maxProjectionDistance + cameraToPlayerDistance));
    vector contactPosition;
    set<Object> hitObjects = new set<Object>();
 
    DayZPhysics.RaycastRV(from, to, contactPosition, m_ContactDir, m_ContactComponent, hitObjects, player, m_Projection, false, false, ObjIntersectFire);
 
    bool contactHitProcessed = false;
    if (!CfgGameplayHandler.GetDisableIsCollidingBBoxCheck())
    {
      if (hitObjects.Count() > 0)
      {
        if (hitObjects[0].IsInherited(Watchtower))
        {
          contactHitProcessed = true;
          contactPosition = CorrectForWatchtower(m_ContactComponent, contactPosition, player, hitObjects[0]);
        }
 
        if (!contactHitProcessed && hitObjects[0].IsInherited(InventoryItem))
          contactPosition = hitObjects[0].GetPosition();
      }
    }
 
    static const float raycastOriginOffsetOnFail = 0.25;
    static const float minDistFromStart = 0.01;
    // Camera isn't correctly positioned in some cases, leading to raycasts hitting the object directly behind the camera
    if ((hitObjects.Count() > 0) && (vector.DistanceSq(from, contactPosition) < minDistFromStart))
    {
      from = contactPosition + GetGame().GetCurrentCameraDirection() * raycastOriginOffsetOnFail;
      DayZPhysics.RaycastRV(from, to, contactPosition, m_ContactDir, m_ContactComponent, hitObjects, player, m_Projection, false, false, ObjIntersectFire);
    }
 
    bool isFloating = SetHologramPosition(player.GetPosition(), minProjectionDistance, maxProjectionDistance, contactPosition);
    SetIsFloating(isFloating);
 
#ifdef DIAG_DEVELOPER
    DrawDebugArrow(minProjectionDistance, maxProjectionDistance);
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
      Debug.DrawSphere(GetProjectionPosition(), 0.1, 0x99FF0000, ShapeFlags.ONCE | ShapeFlags.TRANSP | ShapeFlags.NOOUTLINE);
#endif
 
    m_FromAdjusted = from;
 
    return contactPosition;
  }
 
  protected bool SetHologramPosition(vector startPosition, float minProjectionDistance, float maxProjectionDistance, inout vector contactPosition)
  {
    float playerToProjectionDistance = vector.Distance(startPosition, contactPosition);
    vector playerToProjection;
 
#ifdef DIAG_DEVELOPER
    DebugText("SetHologramPosition::startPosition: ", false, m_IsHidden, string.Format(" | %1", startPosition));
    DebugText("SetHologramPosition::contactPosition [in]: ", false, m_IsHidden, string.Format(" | %1", contactPosition));
    DebugText("SetHologramPosition::minProjectionDistance: ", false, m_IsHidden, string.Format(" | %1", minProjectionDistance));
    DebugText("SetHologramPosition::maxProjectionDistance: ", false, m_IsHidden, string.Format(" | %1", maxProjectionDistance));
    DebugText("SetHologramPosition::playerToProjectionDistance: ", false, m_IsHidden, string.Format(" | %1", playerToProjectionDistance));
#endif
 
    //hologram is at min distance from player
    if (playerToProjectionDistance <= minProjectionDistance)
    {
      playerToProjection = contactPosition - startPosition;
      playerToProjection.Normalize();
      //prevents the hologram to go underground/floor while hologram exceeds minProjectionDistance
      playerToProjection[1] = playerToProjection[1] + PROJECTION_TRANSITION_MIN;
 
      contactPosition = startPosition + (playerToProjection * minProjectionDistance);
 
#ifdef DIAG_DEVELOPER
      DebugText("SetHologramPosition::contactPosition[out] (< minProjectDistance): ", false, m_IsHidden, string.Format(" | %1", contactPosition));
#endif
 
      return true;
    }
    //hologram is at max distance from player
    else if (playerToProjectionDistance >= maxProjectionDistance)
    {
      playerToProjection = contactPosition - startPosition;
      playerToProjection.Normalize();
      //prevents the hologram to go underground/floor while hologram exceeds maxProjectionDistance
      playerToProjection[1] = playerToProjection[1] + PROJECTION_TRANSITION_MAX;
 
      contactPosition = startPosition + (playerToProjection * maxProjectionDistance);
 
#ifdef DIAG_DEVELOPER
      DebugText("SetHologramPosition::contactPosition[out] (< maxProjectionDistance): ", false, m_IsHidden, string.Format(" | %1", contactPosition));
#endif
 
      return true;
    }
 
    return false;
  }
 
  bool IsFenceOrWatchtowerKit()
  {
    return m_Parent.IsBasebuildingKit() || m_Parent.IsInherited(TentBase);
  }
 
  vector CorrectForWatchtower(int contactComponent, vector contactPos, PlayerBase player, Object hitObject)
  {
    // Raycast has hit one of the trigger boxes that show construction prompts, so projection would be floating in the air without this correction
    if (m_WatchtowerIgnoreComponentNames.Find(hitObject.GetActionComponentName(contactComponent, LOD.NAME_VIEW)) != -1)
      contactPos[1] = hitObject.GetActionComponentPosition(contactComponent, LOD.NAME_VIEW)[1];
 
    return contactPos;
  }
 
  //This function is currently unused
  bool IsProjectionTrap()
  {
    return m_Projection.IsInherited(TrapBase) || m_Projection.IsInherited(TrapSpawnBase);
  }
 
  float GetProjectionDiameter()
  {
    float diameter;
    float radius;
    vector diagonal;
    vector min_max[2];
 
    GetProjectionCollisionBox(min_max);
    diagonal = GetCollisionBoxSize(min_max);
    diameter = diagonal.Length();
 
    return diameter;
  }
 
  float GetProjectionRadius()
  {
    float diameter;
    float radius;
    vector diagonal;
    vector min_max[2];
 
    GetProjectionCollisionBox(min_max);
    diagonal = GetCollisionBoxSize(min_max);
    diameter = diagonal.Length();
    radius = diameter / 2;
 
    return radius;
  }
 
  void SetUpdatePosition(bool state)
  {
    m_UpdatePosition = state;
  }
 
  bool GetUpdatePosition()
  {
    return m_UpdatePosition;
  }
 
  EntityAI GetParentEntity()
  {
    return m_Parent;
  }
 
  void SetProjectionEntity(EntityAI projection)
  {
    m_Projection = projection;
  }
 
  EntityAI GetProjectionEntity()
  {
    return m_Projection;
  }
 
  void SetIsFloating(bool is_floating)
  {
    m_IsFloating = is_floating;
  }
 
  void SetIsColliding(bool is_colliding)
  {
#ifdef DIAG_DEVELOPER
    DebugText("Is colliding: ", false, is_colliding, m_CollisionDetails);
#endif
    m_IsColliding = is_colliding;
  }
 
  void SetIsHidden(bool is_hidden)
  {
    m_IsHidden = is_hidden;
  }
 
  void SetIsCollidingPlayer(bool is_colliding)
  {
    m_IsCollidingPlayer = is_colliding;
  }
 
  void SetIsCollidingGPlot(bool is_colliding_gplot)
  {
    m_IsCollidingGPlot = is_colliding_gplot;
  }
 
  bool IsFloating()
  {
#ifdef DIAG_DEVELOPER
    DebugText("IsFloating: ", false, m_IsFloating);
#endif
    return m_IsFloating;
  }
 
  bool IsColliding()
  {
    return m_IsColliding;
  }
 
  bool IsHidden()
  {
#ifdef DIAG_DEVELOPER
    DebugText("IsHidden: ", false, m_IsHidden);
#endif
    return m_IsHidden;
  }
 
  bool IsCollidingPlayer()
  {
    if (CfgGameplayHandler.GetDisableIsCollidingPlayerCheck())
      return false;
#ifdef DIAG_DEVELOPER
    DebugText("IsCollidingPlayer: ", false, m_IsCollidingPlayer);
#endif
    return m_IsCollidingPlayer;
  }
 
  void SetProjectionPosition(vector position)
  {
    m_Projection.SetPosition(position);
 
    if (IsFloating())
      m_Projection.SetPosition(SetOnGround(position));
  }
 
  void SetProjectionOrientation(vector orientation)
  {
    m_Projection.SetOrientation(orientation);
  }
 
  vector GetProjectionRotation()
  {
    return m_Rotation;
  }
 
  void AddProjectionRotation(float addition)
  {
    m_Rotation[0] = m_Rotation[0] + addition;
  }
 
  void SubtractProjectionRotation(float subtraction)
  {
    m_Rotation[0] = m_Rotation[0] - subtraction;
  }
 
  vector SetOnGround(vector position)
  {
    vector from = position;
    vector ground;
    vector player_to_projection_vector;
    float projection_diameter = GetProjectionDiameter();
 
    ground = Vector(0, -Math.Max(projection_diameter, SMALL_PROJECTION_GROUND), 0);
 
    vector to = from + ground;
    vector contact_pos = to;
 
    RaycastRVParams rayInput = new RaycastRVParams(from, to, m_Projection);
    rayInput.flags = CollisionFlags.ALLOBJECTS;
    array<ref RaycastRVResult> results = new array<ref RaycastRVResult>;
 
    if (DayZPhysics.RaycastRVProxy(rayInput, results))
    {
      RaycastRVResult res;
      for (int i = 0; i < results.Count(); i++)
      {
        res = results.Get(i);
        if (res.entry || (!res.obj && !res.parent))
        {
          contact_pos = res.pos;
          break;
        }
      }
    }
 
    //LOS check
    if (contact_pos != "0 0 0")
    {
      vector check_pos;
      vector check_dir;
      int check_component = -1;
      set<Object> hit_object = new set<Object>;
      to = contact_pos;
      to[1] = to[1] + 0.1;
      from = m_FromAdjusted;
 
      if (DayZPhysics.RaycastRV(from, to, check_pos, check_dir, check_component, hit_object, null, m_Player, false, false, ObjIntersectFire))
      {
        if ((hit_object.Count() > 0) && (!hit_object[0].IsInherited(Watchtower) || (hit_object[0].IsInherited(Watchtower) && (m_WatchtowerIgnoreComponentNames.Find(hit_object[0].GetActionComponentName(check_component, LOD.NAME_VIEW)) == -1))))
          contact_pos = "0 0 0";
      }
    }
 
    HideWhenClose(contact_pos);
 
    return contact_pos;
  }
 
  vector HideWhenClose(vector pos)
  {
    //if the hologram is too close to player when he looks to the sky, send the projection to away
    vector cam_dir = GetGame().GetCurrentCameraDirection();
 
    if (cam_dir[1] > LOOKING_TO_SKY)
      pos = "0 0 0";
 
    return pos;
  }
 
  vector GetProjectionPosition()
  {
    if (m_Projection)
      return m_Projection.GetPosition();
 
    return vector.Zero;
  }
 
  vector GetProjectionOrientation()
  {
    if (m_Projection)
      return m_Projection.GetOrientation();
 
    return vector.Zero;
  }
 
  vector GetDefaultOrientation()
  {
    m_DefaultOrientation = GetGame().GetCurrentCameraDirection().VectorToAngles();
    m_DefaultOrientation[1] = 0;
 
    if (!GetParentEntity().PlacementCanBeRotated())
      m_DefaultOrientation = vector.Zero;
 
    return m_DefaultOrientation;
  }
 
  int GetHiddenSelection(string selection)
  {
    int idx = m_Projection.GetHiddenSelectionIndex(selection);
 
    if (idx != -1)
      return idx;
    else
      return 0;
  }
 
  // the function accepts string
  void SetSelectionToRefresh(string selection)
  {
    m_SelectionsToRefresh.Insert(selection);
  }
 
  //overloaded function to accept array of strings
  void SetSelectionToRefresh(array<string> selection)
  {
    foreach (string s : selection)
      m_SelectionsToRefresh.Insert(s);
  }
 
  void RefreshVisual()
  {
    if (m_Projection)
    {
      static const string textureName = "#(argb,8,8,3)color(0.5,0.5,0.5,0.75,ca)";
 
      int hidden_selection = 0;
      string selection_to_refresh;
      string config_material = string.Format("CfgVehicles %1 hologramMaterial", m_Projection.GetType());
      string hologram_material = GetGame().ConfigGetTextOut(config_material);
      string config_model = string.Format("CfgVehicles %1 hologramMaterialPath", m_Projection.GetType());
      string hologram_material_path = string.Format("%1\\%2%3", GetGame().ConfigGetTextOut(config_model), hologram_material, CorrectMaterialPathName());
 
      for (int i = 0; i < m_SelectionsToRefresh.Count(); ++i)
      {
        selection_to_refresh = m_SelectionsToRefresh.Get(i);
        hidden_selection = GetHiddenSelection(selection_to_refresh);
        m_Projection.SetObjectTexture(hidden_selection, textureName);
        m_Projection.SetObjectMaterial(hidden_selection, hologram_material_path);
      }
    }
  }
 
  // Returns correct string to append to material path name
  string CorrectMaterialPathName()
  {
    if (IsColliding() || IsFloating())
      return SUFFIX_MATERIAL_UNDEPLOYABLE;
    else if (m_Parent.HasEnergyManager())
    {
      ComponentEnergyManager comp_em = m_Parent.GetCompEM();
      string SEL_CORD_PLUGGED = m_Parent.GetCompEM().SEL_CORD_PLUGGED;
      string SEL_CORD_FOLDED = m_Parent.GetCompEM().SEL_CORD_FOLDED;
 
      if (comp_em.IsPlugged() && comp_em.IsEnergySourceAtReach(GetProjectionPosition()))
      {
        m_Projection.SetAnimationPhase(SEL_CORD_PLUGGED, 0);
        m_Projection.SetAnimationPhase(SEL_CORD_FOLDED, 1);
        return SUFFIX_MATERIAL_POWERED;
      }
      else
      {
        m_Projection.SetAnimationPhase(SEL_CORD_PLUGGED, 1);
        m_Projection.SetAnimationPhase(SEL_CORD_FOLDED, 0);
      }
    }
 
    return SUFFIX_MATERIAL_DEPLOYABLE;
  }
 
  private bool IsRestrictedFromAdvancedPlacing()
  {
    if (m_Player.IsJumpInProgress())
      return true;
    if (m_Player.IsSwimming())
      return true;
    if (m_Player.IsClimbingLadder())
      return true;
    if (m_Player.IsRaised())
      return true;
    if (m_Player.IsClimbing())
      return true;
    if (m_Player.IsRestrained())
      return true;
    if (m_Player.IsUnconscious())
      return true;
 
    return false;
  }
};
 
class ProjectionTrigger extends Trigger
{
  protected int m_TriggerUpdateMs;
  protected Hologram m_ParentObj;
  protected PlayerBase m_Player;
 
  override void OnEnter(Object obj)
  {
    //Print("OnEnter");
    if (m_ParentObj)
    {
      m_ParentObj.SetIsCollidingPlayer(true);
      m_TriggerUpdateMs = 50;
    }
  }
 
  override void OnLeave(Object obj)
  {
    //Print("OnLeave");
    if (m_ParentObj)
      m_ParentObj.SetIsCollidingPlayer(false);
  }
 
  override protected void UpdateInsiders(int timeout)
  {
    super.UpdateInsiders(m_TriggerUpdateMs);
  }
 
  void SetParentObject(Hologram projection)
  {
    m_ParentObj = projection;
  }
 
  void SetParentOwner(PlayerBase player)
  {
    m_Player = player;
  }
}