Класс VicinityItemManager

Закрытые члены
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 VicinityItemManager	GetInstance ()

Закрытые данные
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 ref VicinityItemManager	s_Instance

Подробное описание

Методы

AddVicinityCargos()

void AddVicinityCargos ( CargoBase object )

inlineprivate

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

Перекрестные ссылки INDEX_NOT_FOUND и m_VicinityCargos.

Используется в RefreshVicinityItems().

AddVicinityItems()

void AddVicinityItems ( Object object )

inlineprivate

    {
        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);
    }

Перекрестные ссылки GameInventory::CheckManipulatedObjectsDistances(), GetGame(), GetPlayer(), INDEX_NOT_FOUND, m_VicinityItems и VICINITY_CONE_REACH_DISTANCE.

Используется в RefreshVicinityItems().

CanIgnoreDistanceCheck()

bool CanIgnoreDistanceCheck ( EntityAI entity_ai )

inlineprivate

    {
        return MiscGameplayFunctions.CanIgnoreDistanceCheck(entity_ai);
    }

Используется в RefreshVicinityItems().

ExcludeFromContainer_Phase1()

bool ExcludeFromContainer_Phase1 ( Object actor_in_radius )

inlineprivate

If in free camera, allow viewing of inventory

    {
        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;
    }

Перекрестные ссылки Class::CastTo(), vector::Dot(), GetGame() и GetPlayer().

Используется в RefreshVicinityItems().

ExcludeFromContainer_Phase2()

bool ExcludeFromContainer_Phase2 ( Object object_in_radius )

inlineprivate

    {
        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;
        
        return false;
    }

Перекрестные ссылки Class::CastTo(), GetGame() и GetPlayer().

Используется в RefreshVicinityItems().

ExcludeFromContainer_Phase3()

bool ExcludeFromContainer_Phase3 ( Object object_in_cone )

inlineprivate

    {
        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;
 
        return false;
    }

Перекрестные ссылки Class::CastTo(), GetGame() и GetPlayer().

Используется в RefreshVicinityItems().

GetInstance()

static VicinityItemManager GetInstance ( )

inlinestaticprivate

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

Перекрестные ссылки s_Instance.

Используется в MissionBase::HideInventory(), OnShow() и VicinityContainer::UpdateInterval().

GetVicinityCargos()

array< CargoBase > GetVicinityCargos ( )

inlineprivate

    {
        return m_VicinityCargos;
    }

Перекрестные ссылки m_VicinityCargos.

GetVicinityItems()

array< EntityAI > GetVicinityItems ( )

inlineprivate

    {
        return m_VicinityItems;
    }

Перекрестные ссылки m_VicinityItems.

Init()

void Init ( )

inlineprivate

    {
    }

IsObstructed()

bool IsObstructed ( Object filtered_object )

inlineprivate

    {
        return MiscGameplayFunctions.IsObjectObstructed(filtered_object);
    }

Используется в RefreshVicinityItems().

RefreshVicinityItems()

void 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

    {
        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);
        }
    }

Перекрестные ссылки 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 и VICINITY_LARGE_ACTOR_DISTANCE.

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

ResetRefreshCounter()

void ResetRefreshCounter ( )

inlineprivate

    {
        m_RefreshCounter = 0;
    }

Перекрестные ссылки m_RefreshCounter.

Update()

void Update ( float delta_time )

inlineprivate

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

Перекрестные ссылки m_RefreshCounter, RefreshVicinityItems() и UPDATE_FREQUENCY.

Поля

CE_CENTER

const string CE_CENTER = "ce_center"

private

CONE_HEIGHT_MAX

const float CONE_HEIGHT_MAX = 3.0

private

Используется в RefreshVicinityItems().

CONE_HEIGHT_MIN

const float CONE_HEIGHT_MIN = -0.5

private

Используется в RefreshVicinityItems().

HEIGHT_OFFSET

const float HEIGHT_OFFSET = 0.2

private

m_RefreshCounter

float m_RefreshCounter

private

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

m_VicinityCargos

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

private

Используется в AddVicinityCargos(), GetVicinityCargos() и RefreshVicinityItems().

m_VicinityItems

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

private

Используется в AddVicinityItems(), GetVicinityItems() и RefreshVicinityItems().

OBJECT_OBSTRUCTION_WEIGHT

const int OBJECT_OBSTRUCTION_WEIGHT = 10000

private

s_Instance

ref VicinityItemManager s_Instance

staticprivate

Используется в GetInstance().

UPDATE_FREQUENCY

const float UPDATE_FREQUENCY = 0.25

private

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

VICINITY_ACTOR_DISTANCE

const float VICINITY_ACTOR_DISTANCE = 2.0

private

Используется в RefreshVicinityItems().

VICINITY_CONE_ANGLE

const float VICINITY_CONE_ANGLE = 30

private

Используется в RefreshVicinityItems().

VICINITY_CONE_DISTANCE

const float VICINITY_CONE_DISTANCE = 2.0

private

Используется в RefreshVicinityItems().

VICINITY_CONE_RADIANS

const float VICINITY_CONE_RADIANS = 0.5

private

VICINITY_CONE_REACH_DISTANCE

const float VICINITY_CONE_REACH_DISTANCE = 2.0

private

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

VICINITY_DISTANCE

const float VICINITY_DISTANCE = 0.5

private

Используется в RefreshVicinityItems().

VICINITY_LARGE_ACTOR_DISTANCE

const float VICINITY_LARGE_ACTOR_DISTANCE = 3.0

private

Используется в RefreshVicinityItems().

---

Объявления и описания членов класса находятся в файле:

• D:/Ishodniki/scripts/5_Mission/GUI/InventoryNew/VicinityItemManager.c