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

См. определение в файле VicinityItemManager.c строка 208

    {
        PlayerBase player = PlayerBase.Cast(g_Game.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      = MiscGameplayFunctions.GetPlayerHeadPosition(player);
        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);
        g_Game.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
        g_Game.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)
            {
                //if (objectInCone.IsBuilding()) //TODO: redo, buildings will show only some attachment groups, similar to cars or BBB objects
                EntityAI ent;
                if (Class.CastTo(ent,objectInCone) && ent.GetInventory())
                {
                    //Print(ent.GetModelName());
                    filteredObjects.Insert(objectInCone);
                    continue;
                }
                
                rayInput        = new RaycastRVParams(playerHeadPositionFixed, objectInCone.GetPosition());
                rayInput.flags = CollisionFlags.ALLOBJECTS;
                rayInput.type   = ObjIntersectView;
                rayInput.radius = 0.1;
                DayZPhysics.RaycastRVProxy(rayInput, raycastResults, {player});
                //Debug.DrawLine(playerHeadPositionFixed,objectInCone.GetPosition(),COLOR_WHITE,ShapeFlags.ONCE);
                
                foreach (RaycastRVResult result : raycastResults)
                {
                    if (vector.DistanceSq(result.pos, playerPosition) > VICINITY_CONE_REACH_DISTANCE * VICINITY_CONE_REACH_DISTANCE)
                        continue;
                    
                    if (result.hierLevel > 0)
                    {
                        if (result.parent.CanProxyObstruct())
                            break;
                        
                        if (result.parent == objectInCone)
                        {
                            filteredObjects.Insert(objectInCone);
                            break;
                        }
                    }
                    else
                    {
                        if (result.obj == objectInCone)
                        {
                            filteredObjects.Insert(objectInCone);
                            break;
                        }
                    }
                }
            }
        }
        
        //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 (g_Game.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)
        {
            //obstructingObjects.Debug();
            if (filteredObjects.Count() > 10)
            {
                array<Object> filteredObjectsGrouped = new array<Object>();
                MiscGameplayFunctions.FilterObstructedObjectsByGrouping(playerHeadPositionFixed, 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);
        }
    }

Перекрестные ссылки AddVicinityCargos(), AddVicinityItems(), CanIgnoreDistanceCheck(), Class::CastTo(), CONE_HEIGHT_MAX, CONE_HEIGHT_MIN, Math::Cos(), DayZPlayerUtils(), Math::DEG2RAD, vector::DistanceSq(), ExcludeFromContainer_Phase1(), ExcludeFromContainer_Phase2(), ExcludeFromContainer_Phase3(), RaycastRVParams::flags, g_Game, INDEX_NOT_FOUND, IsObstructed(), m_VicinityCargos, m_VicinityItems, vector::Normalize(), RaycastRVParams::radius, DayZPhysics::RaycastRVProxy(), BoxCollidingParams::SetParams(), Math::Sin(), RaycastRVParams::type, vector::VectorToAngles(), VICINITY_ACTOR_DISTANCE, VICINITY_CONE_ANGLE, VICINITY_CONE_DISTANCE, VICINITY_CONE_REACH_DISTANCE, VICINITY_DISTANCE и VICINITY_LARGE_ACTOR_DISTANCE.

Используется в OnShow() и Update().