vicinityitemmanager.c

Go to the documentation of this file.

class VicinityItemManager
{
 private const float UPDATE_FREQUENCY = 0.25;
 private const float VICINITY_DISTANCE = 0.5;
 private const float VICINITY_ACTOR_DISTANCE = 2.0;
 private const float VICINITY_LARGE_ACTOR_DISTANCE = 3.0;
 private const float VICINITY_CONE_DISTANCE = 2.0;
 private const float VICINITY_CONE_REACH_DISTANCE = 2.0;
 private const float VICINITY_CONE_ANGLE = 30;
 private const float VICINITY_CONE_RADIANS = 0.5;
 private const string CE_CENTER = "ce_center";
 private const float HEIGHT_OFFSET = 0.2;
 private const int OBJECT_OBSTRUCTION_WEIGHT = 10000; //in grams
 private const float CONE_HEIGHT_MIN = -0.5;
 private const float CONE_HEIGHT_MAX = 3.0;
 
 private ref array<EntityAI> m_VicinityItems = new array<EntityAI>();
 private ref array<CargoBase> m_VicinityCargos = new array<CargoBase>();
 private float m_RefreshCounter;
 private static ref VicinityItemManager s_Instance;
 
 static VicinityItemManager GetInstance ()
 {
 if (!s_Instance)
 s_Instance = new VicinityItemManager();
 
 return s_Instance;
 }
 
 void Init()
 {
 }
 
 array<EntityAI> GetVicinityItems()
 {
 return m_VicinityItems;
 }
 
 void AddVicinityItems(Object object)
 {
 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);
 }
 
 array<CargoBase> GetVicinityCargos()
 {
 return m_VicinityCargos;
 }
 
 void AddVicinityCargos(CargoBase object)
 {
 if (m_VicinityCargos.Find(object) == INDEX_NOT_FOUND)
 {
 m_VicinityCargos.Insert(object);
 }
 }
 
 void ResetRefreshCounter()
 {
 m_RefreshCounter = 0;
 }
 
 void Update(float delta_time)
 {
 m_RefreshCounter += delta_time;
 
 if (m_RefreshCounter >= UPDATE_FREQUENCY)
 {
 RefreshVicinityItems();
 m_RefreshCounter = 0;
 }
 }
 
 bool ExcludeFromContainer_Phase1(Object actor_in_radius)
 {
 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;
 }
 
 bool ExcludeFromContainer_Phase2(Object object_in_radius)
 {
 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;
 }
 
 bool ExcludeFromContainer_Phase3(Object object_in_cone)
 {
 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;
 }
 
 bool CanIgnoreDistanceCheck(EntityAI entity_ai)
 {
 return MiscGameplayFunctions.CanIgnoreDistanceCheck(entity_ai);
 }
 
 //per frame call
 void RefreshVicinityItems()
 {
 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);
 }
 }
 
 bool IsObstructed(Object filtered_object)
 {
 return MiscGameplayFunctions.IsObjectObstructed(filtered_object);
 }
 
#ifdef DIAG_DEVELOPER
 //Debug functions
 
 ref array<Shape> rayShapes = new array<Shape>();
 
 private void DebugActorsSphereDraw(float radius)
 {
 CleanupDebugShapes(rayShapes);
 
 rayShapes.Insert(Debug.DrawSphere( GetGame().GetPlayer().GetPosition(), radius, COLOR_GREEN, ShapeFlags.TRANSP|ShapeFlags.WIREFRAME));
 }
 
 private void DebugObjectsSphereDraw(float radius)
 { 
 rayShapes.Insert(Debug.DrawSphere(GetGame().GetPlayer().GetPosition(), radius, COLOR_GREEN, ShapeFlags.TRANSP|ShapeFlags.WIREFRAME));
 }
 
 private void DebugRaycastDraw(vector start, vector end)
 {
 rayShapes.Insert(Debug.DrawArrow(start, end, 0.5, COLOR_YELLOW));
 }
 
 private void DebugConeDraw(vector start, float cone_angle)
 {
 vector endL, endR;
 float playerAngle;
 float xL,xR,zL,zR;
 
 playerAngle = MiscGameplayFunctions.GetHeadingAngle(PlayerBase.Cast(GetGame().GetPlayer()));
 
 endL = start;
 endR = start;
 xL = VICINITY_CONE_REACH_DISTANCE * Math.Cos( playerAngle + Math.PI_HALF + cone_angle * Math.DEG2RAD ); // x
 zL = VICINITY_CONE_REACH_DISTANCE * Math.Sin( playerAngle + Math.PI_HALF + cone_angle * Math.DEG2RAD ); // z
 xR = VICINITY_CONE_REACH_DISTANCE * Math.Cos( playerAngle + Math.PI_HALF - cone_angle * Math.DEG2RAD ); // x
 zR = VICINITY_CONE_REACH_DISTANCE * Math.Sin( playerAngle + Math.PI_HALF - cone_angle * Math.DEG2RAD ); // z
 endL[0] = endL[0] + xL;
 endL[2] = endL[2] + zL;
 endR[0] = endR[0] + xR;
 endR[2] = endR[2] + zR;
 
 rayShapes.Insert(Debug.DrawLine(start, endL, COLOR_GREEN));
 rayShapes.Insert(Debug.DrawLine(start, endR, COLOR_GREEN)) ;
 rayShapes.Insert(Debug.DrawLine(endL, endR, COLOR_GREEN));
 }
 
 private void CleanupDebugShapes(array<Shape> shapesArr)
 {
 foreach (Shape shape : shapesArr)
 Debug.RemoveShape(shape);
 
 shapesArr.Clear();
 }
#endif
}