ActionTargets Class Reference

Collaboration diagram for ActionTargets:

Private Member Functions
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 Private Member Functions
static array< Object >	GetVicinityObjects ()

Private Attributes
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

Static Private Attributes
vector	m_RayStart
	objects in vicinity

Detailed Description

Definition at line 169 of file ActionTargets.c.

Constructor & Destructor Documentation

ActionTargets()

void ActionTargets::ActionTargets ( PlayerBase player )

inlineprivate

Definition at line 171 of file ActionTargets.c.

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

References m_Player, m_VicinityObjects, and VicinityObjects().

Member Function Documentation

CalculateRayStart()

vector ActionTargets::CalculateRayStart ( )

private

DEPRECATED.

Clear()

void ActionTargets::Clear ( )

inlineprivate

Definition at line 185 of file ActionTargets.c.

  {
    m_Targets.Clear();
  }

References m_Targets.

ComputeUtility()

float ActionTargets::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

Definition at line 402 of file ActionTargets.c.

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

References c_MaxTargetDistance, c_UtilityMaxDistFromRaySqr, c_UtilityMaxValue, vector::DistanceSq(), DistSqrPoint2Line(), and m_Player.

DistSqrPoint2Line()

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

inlineprivate

distance between point and line

Definition at line 445 of file ActionTargets.c.

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

References vector::DistanceSq(), and vector::Dot().

Referenced by ComputeUtility().

FilterObstructedObjects()

void ActionTargets::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

Definition at line 490 of file ActionTargets.c.

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

References IsObjectObstructedCache(), IsObstructedEx(), m_RayStart, m_VicinityObjects, and OBSTRUCTED_COUNT_THRESHOLD.

Referenced by FilterObstructedObjectsEx().

FilterObstructedObjectsEx()

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

inlineprivate

Definition at line 461 of file ActionTargets.c.

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

References c_DistanceDelta, c_MaxTargetDistance, FilterObstructedObjects(), g_Game, DiagMenu::GetBool(), GROUPING_COUNT_THRESHOLD, m_RayStart, and m_VicinityObjects.

FindIndexForStoring()

int ActionTargets::FindIndexForStoring ( float value )

inlineprivate

binary search algorithm

Definition at line 381 of file ActionTargets.c.

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

References m_Targets.

Referenced by StoreTarget().

GetTarget()

ActionTarget ActionTargets::GetTarget ( int index )

inlineprivate

returns action target at index

Definition at line 369 of file ActionTargets.c.

  { return m_Targets.Get(index); }

References m_Targets.

GetTargetsCount()

int ActionTargets::GetTargetsCount ( )

inlineprivate

returns count of founded targets

Definition at line 365 of file ActionTargets.c.

  { return m_Targets.Count(); }

References m_Targets.

GetVicinityObjects()

static array< Object > ActionTargets::GetVicinityObjects ( )

inlinestaticprivate

Definition at line 180 of file ActionTargets.c.

  {
    return m_VicinityObjects.GetVicinityObjects();
  }

References m_VicinityObjects.

IsObstructed()

bool ActionTargets::IsObstructed ( Object object )

inlineprivate

Definition at line 353 of file ActionTargets.c.

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

References IsObjectObstructedCache(), IsObstructedEx(), and m_RayStart.

IsObstructedEx()

bool ActionTargets::IsObstructedEx ( Object object, IsObjectObstructedCache cache )

inlineprivate

Definition at line 359 of file ActionTargets.c.

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

Referenced by FilterObstructedObjects(), and IsObstructed().

StoreTarget()

void ActionTargets::StoreTarget ( ActionTarget pActionTarget )

inlineprivate

inserts action into sorted array based on utility

Definition at line 373 of file ActionTargets.c.

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

References FindIndexForStoring(), and m_Targets.

Update()

void ActionTargets::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)

Definition at line 190 of file ActionTargets.c.

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

Member Data Documentation

c_ConeAngle

const float ActionTargets::c_ConeAngle = 30.0

private

Definition at line 717 of file ActionTargets.c.

c_ConeHeightMax

const float ActionTargets::c_ConeHeightMax = 2.0

private

Definition at line 719 of file ActionTargets.c.

c_ConeHeightMin

const float ActionTargets::c_ConeHeightMin = -0.5

private

Definition at line 718 of file ActionTargets.c.

c_DistanceDelta

const float ActionTargets::c_DistanceDelta = 0.3

private

Definition at line 720 of file ActionTargets.c.

Referenced by FilterObstructedObjectsEx().

c_MaxActionDistance

const float ActionTargets::c_MaxActionDistance = UAMaxDistances.DEFAULT

private

Definition at line 716 of file ActionTargets.c.

c_MaxTargetDistance

const float ActionTargets::c_MaxTargetDistance = 3.0

private

Definition at line 715 of file ActionTargets.c.

Referenced by ComputeUtility(), and FilterObstructedObjectsEx().

c_RayDistance

const float ActionTargets::c_RayDistance = 5.0

private

searching properties

Definition at line 714 of file ActionTargets.c.

c_UtilityMaxDistFromRaySqr

const float ActionTargets::c_UtilityMaxDistFromRaySqr = 0.8 * 0.8

private

Definition at line 724 of file ActionTargets.c.

Referenced by ComputeUtility().

c_UtilityMaxValue

const float ActionTargets::c_UtilityMaxValue = 10000

private

utility constants

Definition at line 723 of file ActionTargets.c.

Referenced by ComputeUtility().

CE_CENTER

const string ActionTargets::CE_CENTER = "ce_center"

private

p3d

Definition at line 727 of file ActionTargets.c.

GROUPING_COUNT_THRESHOLD

const int ActionTargets::GROUPING_COUNT_THRESHOLD = 10

private

Definition at line 732 of file ActionTargets.c.

Referenced by FilterObstructedObjectsEx().

HEIGHT_OFFSET

const float ActionTargets::HEIGHT_OFFSET = 0.2

private

Definition at line 728 of file ActionTargets.c.

m_HitPos

vector ActionTargets::m_HitPos

private

Definition at line 708 of file ActionTargets.c.

m_Player

PlayerBase ActionTargets::m_Player

private

player owner

Definition at line 696 of file ActionTargets.c.

Referenced by ActionTargets(), and ComputeUtility().

m_RayEnd

vector ActionTargets::m_RayEnd

private

Definition at line 707 of file ActionTargets.c.

m_RayStart

vector ActionTargets::m_RayStart

staticprivate

objects in vicinity

Definition at line 706 of file ActionTargets.c.

Referenced by FilterObstructedObjects(), FilterObstructedObjectsEx(), and IsObstructed().

m_Targets

ref array<ref ActionTarget> ActionTargets::m_Targets

private

selected & sorted targets by utility function

Definition at line 699 of file ActionTargets.c.

Referenced by Clear(), FindIndexForStoring(), GetTarget(), GetTargetsCount(), and StoreTarget().

OBSTRUCTED_COUNT_THRESHOLD

const int ActionTargets::OBSTRUCTED_COUNT_THRESHOLD = 3

private

misc

Definition at line 731 of file ActionTargets.c.

Referenced by FilterObstructedObjects().

---

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

• scripts/4_World/Classes/UserActionsComponent/ActionTargets.c