Класс ActionTargets

Закрытые члены
void	ActionTargets (PlayerBase player)
void	Clear ()
void	Update ()
bool	IsObstructed (Object object)
bool	IsObstructedEx (Object object, IsObjectObstructedCache cache)
int	GetTargetsCount ()
	returns count of founded targets
ActionTarget	GetTarget (int index)
	returns action target at index
void	StoreTarget (ActionTarget pActionTarget)
	inserts action into sorted array based on utility
int	FindIndexForStoring (float value)
	binary search algorithm
float	ComputeUtility (Object pTarget, vector pRayStart, vector pRayEnd, Object cursorTarget, vector hitPos)
	computes utility of target
float	DistSqrPoint2Line (vector pPoint, vector pL1, vector pL2)
	distance between point and line
void	FilterObstructedObjectsEx (Object cursor_target, array< Object > vicinityObjects)
void	FilterObstructedObjects (Object cursor_target)
vector	CalculateRayStart ()
	DEPRECATED.

Закрытые статические члены
static array< Object >	GetVicinityObjects ()

Закрытые данные
PlayerBase	m_Player
	player owner
ref array< ref ActionTarget >	m_Targets
	selected & sorted targets by utility function
vector	m_RayEnd
vector	m_HitPos
const float	c_RayDistance = 5.0
	searching properties
const float	c_MaxTargetDistance = 3.0
const float	c_MaxActionDistance = UAMaxDistances.DEFAULT
const float	c_ConeAngle = 30.0
const float	c_ConeHeightMin = -0.5
const float	c_ConeHeightMax = 2.0
const float	c_DistanceDelta = 0.3
const float	c_UtilityMaxValue = 10000
	utility constants
const float	c_UtilityMaxDistFromRaySqr = 0.8 * 0.8
const string	CE_CENTER = "ce_center"
	p3d
const float	HEIGHT_OFFSET = 0.2
const int	OBSTRUCTED_COUNT_THRESHOLD = 3
	misc
const int	GROUPING_COUNT_THRESHOLD = 10

Закрытые статические данные
vector	m_RayStart
	objects in vicinity

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

Конструктор(ы)

ActionTargets()

void ActionTargets ( PlayerBase player )

inlineprivate

    {
        m_Player = player;
        m_VicinityObjects = new VicinityObjects;
        m_Targets = new array<ref ActionTarget>;
        
        m_Debug = false;
    }

Перекрестные ссылки m_Player, m_VicinityObjects и VicinityObjects().

Методы

CalculateRayStart()

vector CalculateRayStart ( )

private

DEPRECATED.

Clear()

void Clear ( )

inlineprivate

    {
        m_Targets.Clear();
    }

ComputeUtility()

float ComputeUtility ( Object pTarget, vector pRayStart, vector pRayEnd, Object cursorTarget, vector hitPos )

inlineprivate

computes utility of target

out of reach

ground and static objects

basebuilding objects

    {
        if (vector.DistanceSq(hitPos, m_Player.GetPosition()) > c_MaxTargetDistance * c_MaxTargetDistance)
            return -1;
 
        if (pTarget)
        {
            if ( pTarget == cursorTarget )
            {
                if ( pTarget.GetType() == string.Empty )
                    return 0.01;
 
                if ( pTarget.IsBuilding() )
                    return 0.25;
 
                if ( pTarget.IsTransport() )
                    return 0.25;
                
                if (pTarget.CanUseConstruction())
                    return 0.85;
 
                if ( pTarget.IsWell() )
                    return 0.9;
 
                vector playerPosXZ = m_Player.GetPosition();
                vector hitPosXZ = hitPos;
                playerPosXZ[1] = 0;
                hitPosXZ[1] = 0;
                if ( vector.DistanceSq(playerPosXZ, hitPosXZ) <= c_MaxTargetDistance * c_MaxTargetDistance )
                    return c_UtilityMaxValue;
            }
 
            float distSqr = DistSqrPoint2Line(pTarget.GetPosition(), pRayStart, pRayEnd);
            return (c_UtilityMaxDistFromRaySqr - distSqr) / c_UtilityMaxDistFromRaySqr;
        }
 
        return -1;
    }

Перекрестные ссылки c_MaxTargetDistance, c_UtilityMaxDistFromRaySqr, c_UtilityMaxValue, vector::DistanceSq(), DistSqrPoint2Line() и m_Player.

DistSqrPoint2Line()

float DistSqrPoint2Line ( vector pPoint, vector pL1, vector pL2 )

inlineprivate

distance between point and line

    {
        vector v = pL2 - pL1;
        vector w = pPoint - pL1;
    
        float c1 = vector.Dot(w,v);
        float c2 = vector.Dot(v,v);
 
        if ( c1 <= 0 || c2 == 0 )
            return vector.DistanceSq(pPoint, pL1);
 
        float b = c1 / c2;  
        vector nearestPoint = pL1 + (v * b);
        return vector.DistanceSq(pPoint, nearestPoint);     
    }

Перекрестные ссылки vector::DistanceSq() и vector::Dot().

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

FilterObstructedObjects()

void FilterObstructedObjects ( Object cursor_target )

inlineprivate

check if targets are not obstructed (eg.: wall)

check for object obstruction(if the object is not a proxy - has no parent)

when the number of obstructed items is higher than OBSTRUCTED_COUNT_THRESHOLD remove do no run obstruction check and skip these items

obstruction check

    {
        int numObstructed = 0;
        int mCount = m_VicinityObjects.Count();
        IsObjectObstructedCache cache = new IsObjectObstructedCache(m_RayStart, mCount);
        mCount--;
    
        for ( int i = mCount; i >= 0; --i )
        {
            Object object = m_VicinityObjects.GetObject(i);
            Object parent = m_VicinityObjects.GetParent(i);
 
            if (object && !parent)
            {
                if (numObstructed > OBSTRUCTED_COUNT_THRESHOLD && object != cursor_target)
                {
                    m_VicinityObjects.Remove(object);
                    continue;
                }
 
                if (object != cursor_target && IsObstructedEx(object, cache))
                {
                    m_VicinityObjects.Remove(object);
                    numObstructed++;
                }
 
                cache.ClearCache();
            }
        }
    }

Перекрестные ссылки IsObjectObstructedCache(), IsObstructedEx(), m_RayStart, m_VicinityObjects и OBSTRUCTED_COUNT_THRESHOLD.

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

FilterObstructedObjectsEx()

void FilterObstructedObjectsEx ( Object cursor_target, array< Object > vicinityObjects )

inlineprivate

    {
        #ifdef DIAG_DEVELOPER
        if (DiagMenu.GetBool(DiagMenuIDs.MISC_ACTION_TARGETS_DEBUG))
            CleanupDebugShapes(obstruction);
        #endif
 
        array<Object> obstructingObjects = new array<Object>;
        MiscGameplayFunctions.FilterObstructingObjects(vicinityObjects, obstructingObjects);
        
        if ( obstructingObjects.Count() > 0 )
        {
            PlayerBase player = PlayerBase.Cast(g_Game.GetPlayer());
                    
            int numObstructed = 0;
            int mCount = m_VicinityObjects.Count();
            
            if (mCount > GROUPING_COUNT_THRESHOLD)
            {
                array<Object> filteredObjects = new array<Object>;
                MiscGameplayFunctions.FilterObstructedObjectsByGrouping(m_RayStart, c_MaxTargetDistance, c_DistanceDelta, m_VicinityObjects.GetRawVicinityObjects(), vicinityObjects, filteredObjects);
                m_VicinityObjects.ClearVicinityObjects();
                m_VicinityObjects.TransformToVicinityObjects(filteredObjects);
            }
            else
            {
                FilterObstructedObjects(cursor_target);
            }
        }
    }

Перекрестные ссылки c_DistanceDelta, c_MaxTargetDistance, FilterObstructedObjects(), g_Game, DiagMenu::GetBool(), GROUPING_COUNT_THRESHOLD, m_RayStart и m_VicinityObjects.

FindIndexForStoring()

int FindIndexForStoring ( float value )

inlineprivate

binary search algorithm

    {
        int left = 0;
        int right = m_Targets.Count() - 1;
        while ( left <= right )
        {
            int middle = (left + right) / 2;
            float middleValue = m_Targets.Get(middle).GetUtility();
            
            if ( middleValue == value )
                return middle;
            else if ( middleValue < value )
                right = middle - 1;
            else
                left = middle + 1;
        }
        
        return left;
    }

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

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

GetTarget()

ActionTarget GetTarget ( int index )

inlineprivate

returns action target at index

        { return m_Targets.Get(index); }

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

GetTargetsCount()

int GetTargetsCount ( )

inlineprivate

returns count of founded targets

        { return m_Targets.Count(); }

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

GetVicinityObjects()

static array< Object > GetVicinityObjects ( )

inlinestaticprivate

    {
        return m_VicinityObjects.GetVicinityObjects();
    }

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

IsObstructed()

bool IsObstructed ( Object object )

inlineprivate

    {
        IsObjectObstructedCache cache = new IsObjectObstructedCache(m_RayStart, 1);
        return IsObstructedEx(object, cache);
    }

Перекрестные ссылки IsObjectObstructedCache(), IsObstructedEx() и m_RayStart.

IsObstructedEx()

bool IsObstructedEx ( Object object, IsObjectObstructedCache cache )

inlineprivate

    {
        return MiscGameplayFunctions.IsObjectObstructedEx(object, cache);
    }

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

StoreTarget()

void StoreTarget ( ActionTarget pActionTarget )

inlineprivate

inserts action into sorted array based on utility

    {
        int index = FindIndexForStoring(pActionTarget.GetUtility());
        m_Targets.InsertAt(pActionTarget, index);
        //Print("StoreTarget; object: " + pActionTarget.GetObject() + " | parent: " + pActionTarget.GetParent() + " | idx: " + index);
    }

Перекрестные ссылки FindIndexForStoring() и m_Targets.

Update()

void Update ( )

inlineprivate

clear state

camera & ray properties

if the cursor target is a proxy

ignores attachments on player

spacial search

removes player from the vicinity

transformation of array of Objects to hashmap (VicinityObjects)

removes Vicinity objects that are not directly visible from player position

select & sort targets based on utility function

action target for surface actions (lowest utility)

    {   
        int i;
        
        m_VicinityObjects.ClearVicinityObjects();
        Clear();
 
        Object cursorTarget = null;
        EntityAI cursorTargetEntity = null;
        array<Object> vicinityObjects = new array<Object>;
        
        int hitComponentIndex;
        vector playerPos = m_Player.GetPosition();
        vector headingDirection = MiscGameplayFunctions.GetHeadingVector(m_Player);
 
        m_RayStart = GetGame().GetCurrentCameraPosition();
        m_RayEnd = m_RayStart + GetGame().GetCurrentCameraDirection() * c_RayDistance;
 
        RaycastRVParams rayInput = new RaycastRVParams(m_RayStart, m_RayEnd, m_Player);
        rayInput.flags = CollisionFlags.ALLOBJECTS;
        //rayInput.sorted = true;
        array<ref RaycastRVResult> results = new array<ref RaycastRVResult>;
 
        if ( DayZPhysics.RaycastRVProxy(rayInput, results) )
        {
            if ( results.Count() > 0 )
            {
                array<float> distance_helper = new array<float>;
                array<float> distance_helper_unsorted = new array<float>;
                float distance;
                
                for (i = 0; i < results.Count(); i++)
                {
                    distance = vector.DistanceSq(results[i].pos, m_RayStart);
                    distance_helper.Insert(distance);
                    //Print("#" + i + " " + results.Get(i).obj);
                }
                //Print("--------------");
                distance_helper_unsorted.Copy(distance_helper);
                distance_helper.Sort();
                
                RaycastRVResult res;
                
                
                for ( i = 0; i < results.Count(); i++)
                {
                    res = results.Get(distance_helper_unsorted.Find(distance_helper[i])); //closest object
                    
                    cursorTarget = res.obj;
                    Class.CastTo(cursorTargetEntity,cursorTarget);
                    if (cursorTarget && !cursorTarget.CanBeActionTarget())
                        continue;
                    if ( res.hierLevel > 0 )
                    {
                        if ( !res.parent.IsMan() )
                        {
                            m_VicinityObjects.StoreVicinityObject(res.obj, res.parent);
                            //Print("storing, 1st pass (hier > 0): " + res.obj);
                        }
                        else
                            continue;
                    }
                    else
                    {
                        m_VicinityObjects.StoreVicinityObject(res.obj, null);
                        //Print("storing, 1st pass: " + res.obj);
                    }
                    
                    m_HitPos = res.pos;
                    hitComponentIndex = res.component;
                    break;
                }
            }
            //else
                //Print("NO RESULTS FOUND!");
        }
        else
        {
            //Print("CAST UNSUCCESFUL");
            cursorTarget = null;
            m_HitPos = vector.Zero;
            hitComponentIndex = -1;
        }
        
        //Print(cursorTarget);
        
        DayZPlayerCamera camera = m_Player.GetCurrentCamera();
        if (camera && camera.GetCurrentPitch() <= -45) // Spatial search is a contributor to very heavy searching, limit it to when we are at least looking down
            DayZPlayerUtils.GetEntitiesInCone(playerPos, headingDirection, c_ConeAngle, c_MaxTargetDistance, c_ConeHeightMin, c_ConeHeightMax, vicinityObjects);
        
        vicinityObjects.RemoveItem(m_Player);
 
        //Print("m_VicinityObjects before" + m_VicinityObjects.Count());
        m_VicinityObjects.TransformToVicinityObjects(vicinityObjects);
        //Print("m_VicinityObjects after" + m_VicinityObjects.Count());
        
        FilterObstructedObjectsEx(cursorTarget, vicinityObjects);
        
        for ( i = 0; i < m_VicinityObjects.Count(); i++ )
        {
            Object object = m_VicinityObjects.GetObject(i);
            Object parent = m_VicinityObjects.GetParent(i);
 
            float utility = ComputeUtility(object, m_RayStart, m_RayEnd, cursorTarget, m_HitPos);
            if ( utility > 0 )
            {
                int targetComponent = -1;
                targetComponent = hitComponentIndex;
 
                ActionTarget at = new ActionTarget(object, parent, targetComponent, m_HitPos, utility);
                StoreTarget(at);
            }
            /*else
                Print("utility < 0; object: " + object + " | parent: " + parent);*/
        }
 
        if (m_HitPos == vector.Zero)
        {
            vector      contact_pos, contact_dir, hitNormal;
            int         contactComponent;
            float       hitFraction;
            Object      hitObject;
            
            m_RayEnd = m_RayStart + GetGame().GetCurrentCameraDirection() * c_RayDistance * 3;
            
            PhxInteractionLayers collisionLayerMask = PhxInteractionLayers.ROADWAY|PhxInteractionLayers.TERRAIN|PhxInteractionLayers.WATERLAYER;
            DayZPhysics.RayCastBullet(m_RayStart,m_RayEnd,collisionLayerMask,null,hitObject,contact_pos,hitNormal,hitFraction);
            m_HitPos = contact_pos;
        }
        
        m_Targets.Insert(new ActionTarget(null, null, -1, m_HitPos, 0));
 
#ifdef DIAG_DEVELOPER
        if (DiagMenu.GetBool(DiagMenuIDs.MISC_ACTION_TARGETS_DEBUG))
        {
            ShowDebugActionTargets(true);
            DrawDebugActionTargets(true);
            DrawDebugCone(true);
            DrawDebugRay(true);
            DrawSelectionPos(DiagMenu.GetBool(DiagMenuIDs.MISC_ACTION_TARGETS_SELPOS_DEBUG));
        }
        else
        {
            ShowDebugActionTargets(false);
            DrawDebugActionTargets(false);
            DrawDebugCone(false);
            DrawDebugRay(false);
            DrawSelectionPos(false);
        }
#endif
        //Print("--------------");
    }

Поля

c_ConeAngle

const float c_ConeAngle = 30.0

private

c_ConeHeightMax

const float c_ConeHeightMax = 2.0

private

c_ConeHeightMin

const float c_ConeHeightMin = -0.5

private

c_DistanceDelta

const float c_DistanceDelta = 0.3

private

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

c_MaxActionDistance

const float c_MaxActionDistance = UAMaxDistances.DEFAULT

private

c_MaxTargetDistance

const float c_MaxTargetDistance = 3.0

private

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

c_RayDistance

const float c_RayDistance = 5.0

private

searching properties

c_UtilityMaxDistFromRaySqr

const float c_UtilityMaxDistFromRaySqr = 0.8 * 0.8

private

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

c_UtilityMaxValue

const float c_UtilityMaxValue = 10000

private

utility constants

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

CE_CENTER

const string CE_CENTER = "ce_center"

private

p3d

GROUPING_COUNT_THRESHOLD

const int GROUPING_COUNT_THRESHOLD = 10

private

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

HEIGHT_OFFSET

const float HEIGHT_OFFSET = 0.2

private

m_HitPos

vector m_HitPos

private

m_Player

PlayerBase m_Player

private

player owner

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

m_RayEnd

vector m_RayEnd

private

m_RayStart

vector m_RayStart

staticprivate

objects in vicinity

Используется в FilterObstructedObjects(), FilterObstructedObjectsEx() и IsObstructed().

m_Targets

ref array<ref ActionTarget> m_Targets

private

selected & sorted targets by utility function

Используется в FindIndexForStoring(), GetTarget(), GetTargetsCount() и StoreTarget().

OBSTRUCTED_COUNT_THRESHOLD

const int OBSTRUCTED_COUNT_THRESHOLD = 3

private

misc

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

---

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

• D:/Ishodniki/scripts/4_World/Classes/UserActionsComponent/ActionTargets.c