Collaboration diagram for VicinityItemManager:

[legend]

Private Member Functions
void	Init ()

array< EntityAI >	GetVicinityItems ()

void	AddVicinityItems (Object object)

array< CargoBase >	GetVicinityCargos ()

void	AddVicinityCargos (CargoBase object)

void	ResetRefreshCounter ()

void	Update (float delta_time)

bool	ExcludeFromContainer_Phase1 (Object actor_in_radius)

bool	ExcludeFromContainer_Phase2 (Object object_in_radius)

bool	ExcludeFromContainer_Phase3 (Object object_in_cone)

bool	CanIgnoreDistanceCheck (EntityAI entity_ai)

void	RefreshVicinityItems ()

bool	IsObstructed (Object filtered_object)

Static Private Member Functions
static VicinityItemManager	GetInstance ()

Private Attributes
const float	UPDATE_FREQUENCY = 0.25

const float	VICINITY_DISTANCE = 0.5

const float	VICINITY_ACTOR_DISTANCE = 2.0

const float	VICINITY_LARGE_ACTOR_DISTANCE = 3.0

const float	VICINITY_CONE_DISTANCE = 2.0

const float	VICINITY_CONE_REACH_DISTANCE = 2.0

const float	VICINITY_CONE_ANGLE = 30

const float	VICINITY_CONE_RADIANS = 0.5

const string	CE_CENTER = "ce_center"

const float	HEIGHT_OFFSET = 0.2

const int	OBJECT_OBSTRUCTION_WEIGHT = 10000

const float	CONE_HEIGHT_MIN = -0.5

const float	CONE_HEIGHT_MAX = 3.0

ref array< EntityAI >	m_VicinityItems = new array<EntityAI>()

ref array< CargoBase >	m_VicinityCargos = new array<CargoBase>()

float	m_RefreshCounter

Static Private Attributes
static ref VicinityItemManager	s_Instance

Detailed Description

Definition at line 1 of file VicinityItemManager.c.

Member Function Documentation

◆ AddVicinityCargos()

void VicinityItemManager::AddVicinityCargos ( CargoBase object )

inlineprivate

Definition at line 62 of file VicinityItemManager.c.

  {
    if (m_VicinityCargos.Find(object) == INDEX_NOT_FOUND)
      m_VicinityCargos.Insert(object);
  }

References INDEX_NOT_FOUND, and m_VicinityCargos.

Referenced by RefreshVicinityItems().

◆ AddVicinityItems()

void VicinityItemManager::AddVicinityItems ( Object object )

inlineprivate

Definition at line 39 of file VicinityItemManager.c.

  {
    EntityAI entity = EntityAI.Cast(object);
    if (!entity)
      return;
 
    if (m_VicinityItems.Find(entity) != INDEX_NOT_FOUND)
      return;
 
    if (GameInventory.CheckManipulatedObjectsDistances(entity, GetGame().GetPlayer(), VICINITY_CONE_REACH_DISTANCE + 1.0) == false)
    {
      if (!FreeDebugCamera.GetInstance() || FreeDebugCamera.GetInstance().IsActive() == false)
        return;
    }
 
    m_VicinityItems.Insert(entity);
  }

References GameInventory::CheckManipulatedObjectsDistances(), GetGame(), GetPlayer(), INDEX_NOT_FOUND, m_VicinityItems, and VICINITY_CONE_REACH_DISTANCE.

Referenced by RefreshVicinityItems().

◆ CanIgnoreDistanceCheck()

bool VicinityItemManager::CanIgnoreDistanceCheck ( EntityAI entity_ai )

inlineprivate

Definition at line 193 of file VicinityItemManager.c.

  {
    return MiscGameplayFunctions.CanIgnoreDistanceCheck(entity_ai);
  }

Referenced by RefreshVicinityItems().

◆ ExcludeFromContainer_Phase1()

bool VicinityItemManager::ExcludeFromContainer_Phase1 ( Object actor_in_radius )

inlineprivate

If in free camera, allow viewing of inventory

Definition at line 84 of file VicinityItemManager.c.

  {
    EntityAI entity;
    if (!Class.CastTo(entity, actor_in_radius))
      return true;
 
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    if (entity == player)
      return true;
    if (entity.IsParticle())
      return true;
    if (entity.IsScriptedLight())
      return true;
    if (entity.IsBeingPlaced())
      return true;
    if (entity.IsHologram())
      return true;
    if (entity.IsMan() || entity.IsZombie() || entity.IsZombieMilitary())
    {
      //visibility cone check
      vector entityPosition = entity.GetPosition();
 
      if (entity && entity.IsMan())
      {
        PlayerBase vicinityPlayer = PlayerBase.Cast(entity);
        if (vicinityPlayer)
          entityPosition = vicinityPlayer.GetBonePositionWS(vicinityPlayer.GetBoneIndexByName("spine3"));
      }
      else if (entity && (entity.IsZombie() || entity.IsZombieMilitary()))
      {
        ZombieBase zombie = ZombieBase.Cast(entity);
        if (zombie)
          entityPosition = zombie.GetBonePositionWS(zombie.GetBoneIndexByName("spine3"));
      }
 
      if (FreeDebugCamera.GetInstance() && FreeDebugCamera.GetInstance().IsActive())
        return false;
 
      vector entityDirection = player.GetPosition() - entityPosition;
      entityDirection.Normalize();
      entityDirection[1] = 0; //ignore height
 
      vector playerDirection = MiscGameplayFunctions.GetHeadingVector(player);
      playerDirection.Normalize();
      playerDirection[1] = 0; //ignore height
 
      float dotRadians = vector.Dot(playerDirection, entityDirection);
      if (dotRadians > -0.5)
        return true;
    }
 
    return false;
  }

References Class::CastTo(), vector::Dot(), GetGame(), and GetPlayer().

Referenced by RefreshVicinityItems().

◆ ExcludeFromContainer_Phase2()

bool VicinityItemManager::ExcludeFromContainer_Phase2 ( Object object_in_radius )

inlineprivate

Definition at line 139 of file VicinityItemManager.c.

  {
    EntityAI entity;
 
    if (!Class.CastTo(entity, object_in_radius))
      return true;
    if (entity == PlayerBase.Cast(GetGame().GetPlayer()))
      return true;
    if (entity.IsParticle())
      return true;
    if (entity.IsScriptedLight())
      return true;
    if (entity.IsBeingPlaced())
      return true;
    if (entity.IsHologram())
      return true;
 
    ItemBase item;
    if (!Class.CastTo(item, object_in_radius))
      return true;
    if (!item.IsTakeable())
      return true;
 
    return false;
  }

References Class::CastTo(), GetGame(), and GetPlayer().

Referenced by RefreshVicinityItems().

◆ ExcludeFromContainer_Phase3()

bool VicinityItemManager::ExcludeFromContainer_Phase3 ( Object object_in_cone )

inlineprivate

Definition at line 165 of file VicinityItemManager.c.

  {
    EntityAI entity;
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
    //Print("---object in cone: " + object_in_cone);
    if (!Class.CastTo(entity, object_in_cone))
      return true;
    if (entity == player)
      return true;
    if (entity.IsParticle())
      return true;
    if (entity.IsScriptedLight())
      return true;
    if (entity.IsBeingPlaced())
      return true;
    if (entity.IsHologram())
      return true;
 
    ItemBase item;
    if (!Class.CastTo(item, object_in_cone) && !object_in_cone.IsTransport() && !PASBroadcaster.Cast(object_in_cone))
      return true;
    if (item && !item.IsTakeable())
      return true;
 
    return false;
  }

References Class::CastTo(), GetGame(), and GetPlayer().

Referenced by RefreshVicinityItems().

◆ GetInstance()

static VicinityItemManager VicinityItemManager::GetInstance ( )

inlinestaticprivate

Definition at line 22 of file VicinityItemManager.c.

  {
    if (!s_Instance)
      s_Instance = new VicinityItemManager();
 
    return s_Instance;
  }

References s_Instance.

Referenced by MissionBase::HideInventory(), OnShow(), and VicinityContainer::UpdateInterval().

◆ GetVicinityCargos()

array< CargoBase > VicinityItemManager::GetVicinityCargos ( )

inlineprivate

Definition at line 57 of file VicinityItemManager.c.

  {
    return m_VicinityCargos;
  }

References m_VicinityCargos.

◆ GetVicinityItems()

array< EntityAI > VicinityItemManager::GetVicinityItems ( )

inlineprivate

Definition at line 34 of file VicinityItemManager.c.

  {
    return m_VicinityItems;
  }

References m_VicinityItems.

◆ Init()

void VicinityItemManager::Init ( )

inlineprivate

Definition at line 30 of file VicinityItemManager.c.

31 {

32 }

◆ IsObstructed()

bool VicinityItemManager::IsObstructed ( Object filtered_object )

inlineprivate

Definition at line 386 of file VicinityItemManager.c.

  {
    return MiscGameplayFunctions.IsObjectObstructed(filtered_object);
  }

Referenced by RefreshVicinityItems().

◆ RefreshVicinityItems()

void VicinityItemManager::RefreshVicinityItems ( )

inlineprivate

If in free camera, override the position that the inventory gets generated from

If in free camera, don't worry about obstructed objects if there are any

Definition at line 199 of file VicinityItemManager.c.

  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
    array<Object> objectsInVicinity = new array<Object>();
    array<CargoBase> proxyCargos = new array<CargoBase>();
    array<Object> filteredObjects = new array<Object>();
    array<Object> allFoundObjects = new array<Object>();
    vector playerPosition = player.GetPosition();
    vector playerHeadPositionFixed = playerPosition;
    playerHeadPositionFixed[1] = playerPosition[1] + 1.6;
    vector headingDirection = MiscGameplayFunctions.GetHeadingVector(player);
 
    bool cameraActive = FreeDebugCamera.GetInstance() && FreeDebugCamera.GetInstance().IsActive();
    if (cameraActive)
    {
      playerPosition = FreeDebugCamera.GetInstance().GetPosition();
      playerHeadPositionFixed = playerPosition;
 
      float headingAngle = FreeDebugCamera.GetInstance().GetOrientation()[0] * Math.DEG2RAD;
 
      headingDirection[0] = Math.Cos(headingAngle);
      headingDirection[1] = 0;
      headingDirection[2] = Math.Sin(headingAngle);
      headingDirection.Normalize();
    }
 
    if (m_VicinityItems)
      m_VicinityItems.Clear();
 
    if (m_VicinityCargos)
      m_VicinityCargos.Clear();
 
    //1. GetAll actors in VICINITY_ACTOR_DISTANCE
    //DebugActorsSphereDraw(VICINITY_ACTOR_DISTANCE);
    GetGame().GetObjectsAtPosition3D(playerPosition, VICINITY_ACTOR_DISTANCE, objectsInVicinity, proxyCargos);
 
    // no filtering for cargo (initial implementation)
    foreach (CargoBase cargoObject : proxyCargos)
      AddVicinityCargos(cargoObject);
 
    //filter unnecessary and duplicate objects beforehand
    foreach (Object actorInRadius : objectsInVicinity)
    {
      if (allFoundObjects.Find(actorInRadius) == INDEX_NOT_FOUND)
        allFoundObjects.Insert(actorInRadius);
 
      if (ExcludeFromContainer_Phase1(actorInRadius))
        continue;
 
      if (filteredObjects.Find(actorInRadius) == INDEX_NOT_FOUND)
        filteredObjects.Insert(actorInRadius);
    }
 
    if (objectsInVicinity)
      objectsInVicinity.Clear();
 
    //2. GetAll Objects in VICINITY_DISTANCE
    GetGame().GetObjectsAtPosition3D(playerPosition, VICINITY_DISTANCE, objectsInVicinity, proxyCargos);
    //DebugObjectsSphereDraw(VICINITY_DISTANCE);
 
    //filter unnecessary and duplicate objects beforehand
    foreach (Object objectInRadius : objectsInVicinity)
    {
      if (allFoundObjects.Find(objectInRadius) == INDEX_NOT_FOUND)
        allFoundObjects.Insert(objectInRadius);
 
      if (ExcludeFromContainer_Phase2(objectInRadius))
        continue;
 
      if (filteredObjects.Find(objectInRadius) == INDEX_NOT_FOUND)
        filteredObjects.Insert(objectInRadius);
    }
 
    if (objectsInVicinity)
      objectsInVicinity.Clear();
 
    //3. Add objects from GetEntitiesInCone
    DayZPlayerUtils.GetEntitiesInCone(playerPosition, headingDirection, VICINITY_CONE_ANGLE, VICINITY_CONE_REACH_DISTANCE, CONE_HEIGHT_MIN, CONE_HEIGHT_MAX, objectsInVicinity);
    //DebugConeDraw(playerPosition, VICINITY_CONE_ANGLE);
 
    RaycastRVParams rayInput;
    array<ref RaycastRVResult> raycastResults = new array<ref RaycastRVResult>();
    //filter unnecessary and duplicate objects beforehand
    foreach (Object objectInCone : objectsInVicinity)
    {
      if (allFoundObjects.Find(objectInCone) == INDEX_NOT_FOUND)
        allFoundObjects.Insert(objectInCone);
 
      if (ExcludeFromContainer_Phase3(objectInCone))
        continue;
 
      if (filteredObjects.Find(objectInCone) == INDEX_NOT_FOUND)
      {
        //Test distance to closest component first
        rayInput = new RaycastRVParams(playerHeadPositionFixed, objectInCone.GetPosition());
        rayInput.flags = CollisionFlags.NEARESTCONTACT;
        rayInput.type = ObjIntersectView;
        rayInput.radius = 0.1;
        DayZPhysics.RaycastRVProxy(rayInput, raycastResults, {player});
 
        foreach (RaycastRVResult result : raycastResults)
        {
          if (vector.DistanceSq(result.pos, playerHeadPositionFixed) > VICINITY_CONE_REACH_DISTANCE * VICINITY_CONE_REACH_DISTANCE)
            continue;
 
          if (result.hierLevel > 0 && result.parent == objectInCone)
            filteredObjects.Insert(objectInCone);
          else if (result.hierLevel == 0 && result.obj == objectInCone)
            filteredObjects.Insert(objectInCone);
        }
      }
    }
 
    //4. Add large objects - particularly buildings and BaseBuildingBase
    BoxCollidingParams params = new BoxCollidingParams();
    vector boxEdgeLength = {
      VICINITY_LARGE_ACTOR_DISTANCE,
      VICINITY_LARGE_ACTOR_DISTANCE,
      VICINITY_LARGE_ACTOR_DISTANCE
    };
 
    params.SetParams(playerPosition, headingDirection.VectorToAngles(), boxEdgeLength * 2, ObjIntersect.View, ObjIntersect.Fire, true);
    array<ref BoxCollidingResult> results = new array<ref BoxCollidingResult>();
    if (GetGame().IsBoxCollidingGeometryProxy(params, {player}, results))
    {
      foreach (BoxCollidingResult bResult : results)
      {
        if (bResult.obj && (bResult.obj.CanObstruct() || bResult.obj.CanProxyObstruct()))
        {
          if (allFoundObjects.Find(bResult.obj) == INDEX_NOT_FOUND)
            allFoundObjects.Insert(bResult.obj);
        }
 
        if (bResult.parent && (bResult.parent.CanObstruct() || bResult.parent.CanProxyObstruct()))
        {
          if (allFoundObjects.Find(bResult.parent) == INDEX_NOT_FOUND)
            allFoundObjects.Insert(bResult.parent);
        }
      }
    }
 
    //5. Filter filtered objects with RayCast from the player ( head bone )
    array<Object> obstructingObjects = new array<Object>();
    MiscGameplayFunctions.FilterObstructingObjects(allFoundObjects, obstructingObjects);
 
    if (obstructingObjects.Count() > 0 && !cameraActive)
    {
      if (filteredObjects.Count() > 10)
      {
        vector rayStart;
        MiscGameplayFunctions.GetHeadBonePos(player, rayStart);
 
        array<Object> filteredObjectsGrouped = new array<Object>();
        MiscGameplayFunctions.FilterObstructedObjectsByGrouping(rayStart, VICINITY_CONE_DISTANCE, 0.3, filteredObjects, obstructingObjects, filteredObjectsGrouped, true, true, VICINITY_CONE_REACH_DISTANCE);
 
        foreach (Object object: filteredObjectsGrouped)
          AddVicinityItems(object);
      }
      else
      {
        foreach (Object filteredObjectClose: filteredObjects)
        {
          EntityAI entity;
          Class.CastTo(entity, filteredObjectClose);
 
          //distance check
          if (vector.DistanceSq(playerPosition, entity.GetPosition()) > VICINITY_CONE_REACH_DISTANCE * VICINITY_CONE_REACH_DISTANCE)
          {
            if (!CanIgnoreDistanceCheck(entity))
              continue;
          }
 
          if (!IsObstructed(filteredObjectClose))
            AddVicinityItems(filteredObjectClose);
        }
      }
    }
    else
    {
      foreach (Object filteredObject: filteredObjects)
        AddVicinityItems(filteredObject);
    }
  }

References AddVicinityCargos(), AddVicinityItems(), CanIgnoreDistanceCheck(), Class::CastTo(), CONE_HEIGHT_MAX, CONE_HEIGHT_MIN, Math::Cos(), DayZPlayerUtils(), Math::DEG2RAD, vector::DistanceSq(), ExcludeFromContainer_Phase1(), ExcludeFromContainer_Phase2(), ExcludeFromContainer_Phase3(), GetGame(), GetPlayer(), INDEX_NOT_FOUND, IsObstructed(), m_VicinityCargos, m_VicinityItems, DayZPhysics::RaycastRVProxy(), Math::Sin(), VICINITY_ACTOR_DISTANCE, VICINITY_CONE_ANGLE, VICINITY_CONE_DISTANCE, VICINITY_CONE_REACH_DISTANCE, VICINITY_DISTANCE, and VICINITY_LARGE_ACTOR_DISTANCE.

Referenced by Update().

◆ ResetRefreshCounter()

void VicinityItemManager::ResetRefreshCounter ( )

inlineprivate

Definition at line 68 of file VicinityItemManager.c.

  {
    m_RefreshCounter = 0;
  }

References m_RefreshCounter.

◆ Update()

void VicinityItemManager::Update ( float delta_time )

inlineprivate

Definition at line 73 of file VicinityItemManager.c.

  {
    m_RefreshCounter += delta_time;
 
    if (m_RefreshCounter >= UPDATE_FREQUENCY)
    {
      RefreshVicinityItems();
      m_RefreshCounter = 0;
    }
  }

References m_RefreshCounter, RefreshVicinityItems(), and UPDATE_FREQUENCY.

Member Data Documentation

◆ CE_CENTER

const string VicinityItemManager::CE_CENTER = "ce_center"

private

Definition at line 11 of file VicinityItemManager.c.

◆ CONE_HEIGHT_MAX

const float VicinityItemManager::CONE_HEIGHT_MAX = 3.0

private

Definition at line 15 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

◆ CONE_HEIGHT_MIN

const float VicinityItemManager::CONE_HEIGHT_MIN = -0.5

private

Definition at line 14 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

◆ HEIGHT_OFFSET

const float VicinityItemManager::HEIGHT_OFFSET = 0.2

private

Definition at line 12 of file VicinityItemManager.c.

◆ m_RefreshCounter

float VicinityItemManager::m_RefreshCounter

private

Definition at line 19 of file VicinityItemManager.c.

Referenced by ResetRefreshCounter(), and Update().

◆ m_VicinityCargos

ref array<CargoBase> VicinityItemManager::m_VicinityCargos = new array<CargoBase>()

private

Definition at line 18 of file VicinityItemManager.c.

Referenced by AddVicinityCargos(), GetVicinityCargos(), and RefreshVicinityItems().

◆ m_VicinityItems

ref array<EntityAI> VicinityItemManager::m_VicinityItems = new array<EntityAI>()

private

Definition at line 17 of file VicinityItemManager.c.

Referenced by AddVicinityItems(), GetVicinityItems(), and RefreshVicinityItems().

◆ OBJECT_OBSTRUCTION_WEIGHT

const int VicinityItemManager::OBJECT_OBSTRUCTION_WEIGHT = 10000

private

Definition at line 13 of file VicinityItemManager.c.

◆ s_Instance

ref VicinityItemManager VicinityItemManager::s_Instance

staticprivate

Definition at line 20 of file VicinityItemManager.c.

Referenced by GetInstance().

◆ UPDATE_FREQUENCY

const float VicinityItemManager::UPDATE_FREQUENCY = 0.25

private

Definition at line 3 of file VicinityItemManager.c.

Referenced by Update().

◆ VICINITY_ACTOR_DISTANCE

const float VicinityItemManager::VICINITY_ACTOR_DISTANCE = 2.0

private

Definition at line 5 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

◆ VICINITY_CONE_ANGLE

const float VicinityItemManager::VICINITY_CONE_ANGLE = 30

private

Definition at line 9 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

◆ VICINITY_CONE_DISTANCE

const float VicinityItemManager::VICINITY_CONE_DISTANCE = 2.0

private

Definition at line 7 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

◆ VICINITY_CONE_RADIANS

const float VicinityItemManager::VICINITY_CONE_RADIANS = 0.5

private

Definition at line 10 of file VicinityItemManager.c.

◆ VICINITY_CONE_REACH_DISTANCE

const float VicinityItemManager::VICINITY_CONE_REACH_DISTANCE = 2.0

private

Definition at line 8 of file VicinityItemManager.c.

Referenced by AddVicinityItems(), and RefreshVicinityItems().

◆ VICINITY_DISTANCE

const float VicinityItemManager::VICINITY_DISTANCE = 0.5

private

Definition at line 4 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

◆ VICINITY_LARGE_ACTOR_DISTANCE

const float VicinityItemManager::VICINITY_LARGE_ACTOR_DISTANCE = 3.0

private

Definition at line 6 of file VicinityItemManager.c.

Referenced by RefreshVicinityItems().

The documentation for this class was generated from the following file:

scripts/5_Mission/GUI/InventoryNew/VicinityItemManager.c

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Function Documentation

◆ AddVicinityCargos()

◆ AddVicinityItems()

◆ CanIgnoreDistanceCheck()

◆ ExcludeFromContainer_Phase1()

◆ ExcludeFromContainer_Phase2()

◆ ExcludeFromContainer_Phase3()

◆ GetInstance()

◆ GetVicinityCargos()

◆ GetVicinityItems()

◆ Init()

◆ IsObstructed()

◆ RefreshVicinityItems()

◆ ResetRefreshCounter()

◆ Update()

Member Data Documentation

◆ CE_CENTER

◆ CONE_HEIGHT_MAX

◆ CONE_HEIGHT_MIN

◆ HEIGHT_OFFSET

◆ m_RefreshCounter

◆ m_VicinityCargos

◆ m_VicinityItems

◆ OBJECT_OBSTRUCTION_WEIGHT

◆ s_Instance

◆ UPDATE_FREQUENCY

◆ VICINITY_ACTOR_DISTANCE

◆ VICINITY_CONE_ANGLE

◆ VICINITY_CONE_DISTANCE

◆ VICINITY_CONE_RADIANS

◆ VICINITY_CONE_REACH_DISTANCE

◆ VICINITY_DISTANCE

◆ VICINITY_LARGE_ACTOR_DISTANCE