Класс Hologram

Защищенные члены
void	Hologram (PlayerBase player, vector pos, ItemBase item)
void	~Hologram ()
void	SetAnimations ()
void	UpdateSelections ()
string	ProjectionBasedOnParent ()
string	GetProjectionName (ItemBase item)
void	UpdateHologram (float timeslice)
vector	AlignProjectionOnTerrain (float timeslice)
vector	SmoothProjectionMovement (vector y_p_r, float timeslice)
void	CreateTrigger ()
void	RefreshTrigger ()
void	EvaluateCollision (ItemBase action_item=null)
bool	IsClippingRoof ()
bool	IsCollidingAngle ()
bool	IsCollidingBBox (ItemBase action_item=null)
bool	IsBaseViable ()
bool	IsCollidingGPlot ()
bool	IsCollidingZeroPos ()
bool	IsBehindObstacle ()
	DEPRECATED.
bool	IsBaseStatic (Object objectToCheck)
bool	IsObjectStatic (Object obj)
bool	IsBaseIntact (Object under_left_close, Object under_right_close, Object under_left_far, Object under_right_far)
bool	IsBaseFlat (vector contact_pos_left_close, vector contact_pos_right_close, vector contact_pos_left_far, vector contact_pos_right_far)
bool	IsPlacementPermitted ()
	Checks if the item can be legally placed (usually checked by action as well)
bool	HeightPlacementCheck ()
	Checks height relative to player's position.
bool	IsUnderwater ()
bool	IsInTerrain ()
void	CheckPowerSource ()
EntityAI	PlaceEntity (EntityAI entity_for_placing)
void	GetProjectionCollisionBox (out vector min_max[2])
vector	GetCollisionBoxSize (vector min_max[2])
vector	GetLeftCloseProjectionVector ()
vector	GetRightCloseProjectionVector ()
vector	GetLeftFarProjectionVector ()
vector	GetRightFarProjectionVector ()
bool	IsSurfaceWater (vector position)
bool	IsSurfaceSea (vector position)
vector	GetProjectionEntityPosition (PlayerBase player)
bool	SetHologramPosition (vector startPosition, float minProjectionDistance, float maxProjectionDistance, inout vector contactPosition)
	Sets hologram position based on player and projection distance.
bool	IsFenceOrWatchtowerKit ()
vector	CorrectForWatchtower (int contactComponent, vector contactPos, PlayerBase player, Object hitObject)
bool	IsProjectionTrap ()
float	GetProjectionDiameter ()
float	GetProjectionRadius ()
void	SetUpdatePosition (bool state)
bool	GetUpdatePosition ()
EntityAI	GetParentEntity ()
void	SetProjectionEntity (EntityAI projection)
EntityAI	GetProjectionEntity ()
void	SetIsFloating (bool is_floating)
void	SetIsColliding (bool is_colliding)
void	SetIsHidden (bool is_hidden)
void	SetIsCollidingPlayer (bool is_colliding)
void	SetIsCollidingGPlot (bool is_colliding_gplot)
bool	IsFloating ()
bool	IsColliding ()
bool	IsHidden ()
bool	IsCollidingPlayer ()
void	SetProjectionPosition (vector position)
void	SetProjectionOrientation (vector orientation)
vector	GetProjectionRotation ()
void	AddProjectionRotation (float addition)
void	SubtractProjectionRotation (float subtraction)
vector	SetOnGround (vector position)
vector	HideWhenClose (vector pos)
vector	GetProjectionPosition ()
vector	GetProjectionOrientation ()
vector	GetDefaultOrientation ()
int	GetHiddenSelection (string selection)
void	SetSelectionToRefresh (string selection)
void	SetSelectionToRefresh (array< string > selection)
void	RefreshVisual ()
string	CorrectMaterialPathName ()

Защищенные статические члены
static bool	DoesHaveProjection (ItemBase item)
	DEPRECATED.

Защищенные данные
const int	SPAWN_FLAGS = ECE_LOCAL
const string	SUFFIX_MATERIAL_DEPLOYABLE = "_deployable.rvmat"
const string	SUFFIX_MATERIAL_UNDEPLOYABLE = "_undeployable.rvmat"
const string	SUFFIX_MATERIAL_POWERED = "_powered.rvmat"
const vector	PLACEMENT_RC_START_OFFSET = "0 1 0"
const vector	PLACEMENT_RC_END_OFFSET = "0 -2 0"
ItemBase	m_Parent
EntityAI	m_Projection
PlayerBase	m_Player
ProjectionTrigger	m_ProjectionTrigger
string	m_ProjectionTypename
bool	m_IsColliding
bool	m_IsCollidingGPlot
bool	m_IsSlope
bool	m_IsCollidingPlayer
bool	m_IsFloating
bool	m_UpdatePosition
bool	m_IsHidden
vector	m_DefaultOrientation
vector	m_Rotation
vector	m_y_p_r_previous
vector	m_ContactDir
vector	m_FromAdjusted
const string	ANIMATION_PLACING = "Placing"
const string	ANIMATION_INVENTORY = "Inventory"
const string	SELECTION_PLACING = "placing"
const string	SELECTION_INVENTORY = "inventory"
const float	SMALL_PROJECTION_RADIUS = 1
const float	SMALL_PROJECTION_GROUND = 2
const float	DISTANCE_SMALL_PROJECTION = 1
const float	LARGE_PROJECTION_DISTANCE_LIMIT = 6
	Deprecated.
const float	PROJECTION_TRANSITION_MIN = 1
const float	PROJECTION_TRANSITION_MAX = 0.25
const float	LOOKING_TO_SKY = 0.75
float	m_SlopeTolerance
bool	m_AlignToTerrain
vector	m_YawPitchRollLimit
int	m_ContactComponent
ref set< string >	m_SelectionsToRefresh = new set<string>

Статические защищенные данные
static const float	DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF = 1.5
ref array< string >	m_WatchtowerIgnoreComponentNames = new array<string>
ref array< string >	m_WatchtowerBlockedComponentNames = new array<string>

Закрытые члены
bool	IsRestrictedFromAdvancedPlacing ()

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

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

Hologram()

void Hologram ( PlayerBase player, vector pos, ItemBase item )

inlineprotected

    {   
        m_Player        = player;
        m_Parent        = item;
        m_Projection    = null;
 
        m_ProjectionTrigger = null;
        m_UpdatePosition    = true;
        m_ContactComponent  = -1;
 
        m_Rotation      = "0 0 0";
        m_FromAdjusted  = "0 0 0";
        
        // If the static names are empty, generate the needed names
        // Refer to their definitions to see why these are required
        if (m_WatchtowerIgnoreComponentNames.Count() == 0)
        {
            string baseStringBegin      = Watchtower.BASE_VIEW_NAME;
            string baseIgnoreStringEnd  = Watchtower.BASE_WALL_NAME;
 
            int floors  = Watchtower.MAX_WATCHTOWER_FLOORS;
            int walls   = Watchtower.MAX_WATCHTOWER_WALLS;
 
            string compName;
            for (int i = 1; i < floors + 1; ++i)
            {
                compName = baseStringBegin + i.ToString();
                for (int j = 1; j < walls + 1; ++j)
                    m_WatchtowerIgnoreComponentNames.Insert(compName + baseIgnoreStringEnd + j.ToString());
                
                if (i != 1)
                    m_WatchtowerBlockedComponentNames.Insert(compName);
                else
                    m_WatchtowerIgnoreComponentNames.Insert(compName);
            }
        }
 
        string configPathProjectionTypename = string.Format("CfgVehicles %1 projectionTypename", m_Parent.GetType());
        if (GetGame().ConfigIsExisting(configPathProjectionTypename))
        {
            m_ProjectionTypename = GetGame().ConfigGetTextOut(configPathProjectionTypename);
        }
 
        EntityAI projectionEntity;
        if (GetGame().IsMultiplayer() && GetGame().IsServer())
        {   
            projectionEntity = EntityAI.Cast(GetGame().CreateObjectEx(ProjectionBasedOnParent(), pos, ECE_PLACE_ON_SURFACE));
            projectionEntity.SetAllowDamage(false);
            SetProjectionEntity(projectionEntity);
            SetAnimations();
        }
        else
        {
            projectionEntity = EntityAI.Cast(GetGame().CreateObjectEx(ProjectionBasedOnParent(), pos, ECE_TRACE|ECE_LOCAL));
            if (projectionEntity == null)
            {
                ErrorEx(string.Format("Cannot create hologram entity from config class %1", ProjectionBasedOnParent()), ErrorExSeverity.WARNING);
                return;
            }
 
            SetProjectionEntity(projectionEntity);
            SetAnimations();
            CreateTrigger();
            RefreshTrigger();
        }
        
        if (ItemBase.Cast(projectionEntity))
        {
            ItemBase.Cast(GetProjectionEntity()).SetIsHologram(true);
        }
        
        string configPathSlope = string.Format("CfgVehicles %1 slopeTolerance", GetProjectionEntity().GetType());
        if (GetGame().ConfigIsExisting(configPathSlope))
        {
            m_SlopeTolerance = GetGame().ConfigGetFloat(configPathSlope);
        }
        
        string configPathAlign = string.Format("CfgVehicles %1 alignHologramToTerain", GetProjectionEntity().GetType());
        if (GetGame().ConfigIsExisting(configPathAlign))
        {
            m_AlignToTerrain = GetGame().ConfigGetInt(configPathAlign);
        }
        
        string configPathOrientationLimit = string.Format("CfgVehicles %1 yawPitchRollLimit", GetProjectionEntity().GetType());
        if (GetGame().ConfigIsExisting(configPathOrientationLimit))
        {
            m_YawPitchRollLimit = GetGame().ConfigGetVector(configPathOrientationLimit);
        }
    }

Перекрестные ссылки CreateTrigger(), ECE_LOCAL, ECE_PLACE_ON_SURFACE, ECE_TRACE, ErrorEx, GetGame(), GetProjectionEntity(), GetType(), m_AlignToTerrain, m_ContactComponent, m_FromAdjusted, m_Parent, m_Player, m_Projection, m_ProjectionTrigger, m_ProjectionTypename, m_Rotation, m_SlopeTolerance, m_UpdatePosition, m_WatchtowerBlockedComponentNames, m_WatchtowerIgnoreComponentNames, m_YawPitchRollLimit, ProjectionBasedOnParent(), RefreshTrigger(), SetAnimations() и SetProjectionEntity().

~Hologram()

void ~Hologram ( )

inlineprotected

    {
        if (GetGame())
        {
            if (m_Projection)
            {
                GetGame().ObjectDelete(m_Projection);
            }
    
            if (m_ProjectionTrigger)
            {
                GetGame().ObjectDelete(m_ProjectionTrigger);
            }
        }
        
        #ifdef DIAG_DEVELOPER
        DestroyDebugCollisionBox();
        #endif
    }

Перекрестные ссылки DestroyDebugCollisionBox(), GetGame(), m_Projection и m_ProjectionTrigger.

Методы

AddProjectionRotation()

void AddProjectionRotation ( float addition )

inlineprotected

    {   
        m_Rotation[0] = m_Rotation[0] + addition;
    }

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

AlignProjectionOnTerrain()

vector AlignProjectionOnTerrain ( float timeslice )

inlineprotected

    {
        vector y_p_r;
        
        if ( m_AlignToTerrain )
        {
            vector projection_orientation_angles = GetDefaultOrientation() + GetProjectionRotation();   
            vector mat0[3];
            vector mat1[3];
            vector mat2[3];
            vector projection_position = m_Projection.GetPosition();
            vector normal;
            
            if ( m_ContactDir.Length() > 0 )
            {
                normal = m_ContactDir;
            } 
            else
            {
                normal = GetGame().SurfaceGetNormal( projection_position[0], projection_position[2] );
            }
            
            vector angles = normal.VectorToAngles();
            angles[1] = angles[1] + 270;
                    
            angles[0] = Math.Clamp( angles[0], 0, 360 ); 
            angles[1] = Math.Clamp( angles[1], 0, 360 );
            angles[2] = Math.Clamp( angles[2], 0, 360 );
                
            projection_orientation_angles[0] = projection_orientation_angles[0] + ( 360 - angles[0] );
            
            Math3D.YawPitchRollMatrix( projection_orientation_angles, mat0 );
            Math3D.YawPitchRollMatrix( angles, mat1 );
            Math3D.MatrixMultiply3( mat1, mat0, mat2 ); 
            
            y_p_r = Math3D.MatrixToAngles( mat2 );
        }
        else
        {
            y_p_r = GetDefaultOrientation() + GetProjectionRotation();
            
            if ( y_p_r[0] > 180 )
            {
                y_p_r[0] = y_p_r[0] - 360;
            }
            
            if ( y_p_r[0] < -180 )
            {
                y_p_r[0] = y_p_r[0] + 360;
            }
        }   
        
        return SmoothProjectionMovement( y_p_r, timeslice );
    }

Перекрестные ссылки Math::Clamp(), GetDefaultOrientation(), GetGame(), GetProjectionRotation(), vector::Length(), m_AlignToTerrain, m_ContactDir, m_Projection, Math3D::MatrixMultiply3(), Math3D::MatrixToAngles(), SmoothProjectionMovement() и Math3D::YawPitchRollMatrix().

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

CheckPowerSource()

void CheckPowerSource ( )

inlineprotected

    {
        //in range of its power source.
        if (m_Player && m_Parent && m_Parent.HasEnergyManager() && m_Parent.GetCompEM().IsPlugged())
        {
            // Unplug the device when the player is too far from the power source.
            m_Parent.GetCompEM().UpdatePlugState();
            
            // Delete local hologram when plug is rippled out and advanced placement is active
            if (GetGame().IsMultiplayer() && GetGame().IsClient())
            {
                if (!m_Parent.GetCompEM().IsPlugged())
                    m_Player.TogglePlacingLocal();
            }
        }               
    }

Перекрестные ссылки GetGame(), m_Parent и m_Player.

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

CorrectForWatchtower()

vector CorrectForWatchtower ( int contactComponent, vector contactPos, PlayerBase player, Object hitObject )

inlineprotected

    {
        // Raycast has hit one of the trigger boxes that show construction prompts, so projection would be floating in the air without this correction
        if (m_WatchtowerIgnoreComponentNames.Find(hitObject.GetActionComponentName(contactComponent, LOD.NAME_VIEW)) != -1 )
            contactPos[1] = hitObject.GetActionComponentPosition(contactComponent, LOD.NAME_VIEW)[1];
        
        return contactPos;
    }

Перекрестные ссылки m_WatchtowerIgnoreComponentNames и LOD::NAME_VIEW.

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

CorrectMaterialPathName()

string CorrectMaterialPathName ( )

inlineprotected

    {
        if (IsColliding() || IsFloating())
        {
            return SUFFIX_MATERIAL_UNDEPLOYABLE;
        }
        else if (m_Parent.HasEnergyManager())
        {
            ComponentEnergyManager comp_em = m_Parent.GetCompEM();
            string SEL_CORD_PLUGGED = m_Parent.GetCompEM().SEL_CORD_PLUGGED;
            string SEL_CORD_FOLDED = m_Parent.GetCompEM().SEL_CORD_FOLDED;
            
            if (comp_em.IsPlugged() && comp_em.IsEnergySourceAtReach(GetProjectionPosition()))
            {
                m_Projection.SetAnimationPhase(SEL_CORD_PLUGGED, 0);
                m_Projection.SetAnimationPhase(SEL_CORD_FOLDED, 1); 
                return SUFFIX_MATERIAL_POWERED;
            }
            else
            {
                m_Projection.SetAnimationPhase(SEL_CORD_PLUGGED, 1);
                m_Projection.SetAnimationPhase(SEL_CORD_FOLDED, 0);
            }
        }
 
        return SUFFIX_MATERIAL_DEPLOYABLE;
    }

Перекрестные ссылки GetProjectionPosition(), IsColliding(), IsFloating(), m_Parent, m_Projection, ItemBase::SEL_CORD_FOLDED, ItemBase::SEL_CORD_PLUGGED, SUFFIX_MATERIAL_DEPLOYABLE, SUFFIX_MATERIAL_POWERED и SUFFIX_MATERIAL_UNDEPLOYABLE.

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

CreateTrigger()

void CreateTrigger ( )

inlineprotected

    {
        Class.CastTo(m_ProjectionTrigger, g_Game.CreateObjectEx("ProjectionTrigger", GetProjectionPosition(), SPAWN_FLAGS));
 
        m_ProjectionTrigger.SetOrientation(GetProjectionOrientation());
        m_ProjectionTrigger.SetParentObject(this);
        m_ProjectionTrigger.SetParentOwner(m_Player);
        
        RefreshVisual();
    }

Перекрестные ссылки Class::CastTo(), g_Game, GetProjectionOrientation(), GetProjectionPosition(), m_Player, m_ProjectionTrigger, RefreshVisual() и SPAWN_FLAGS.

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

DoesHaveProjection()

static bool DoesHaveProjection ( ItemBase item )

inlinestaticprotected

DEPRECATED.

    {
        return item && (item.IsDeployable() || item.CanMakeGardenplot() || item.IsInherited(DeployableContainer_Base));
    }

EvaluateCollision()

void EvaluateCollision ( ItemBase action_item = null )

inlineprotected

    {
        #ifdef DIAG_DEVELOPER
        m_CollisionDetails = "";
        #endif
 
        if (!m_Player.CanPlaceItem(m_Projection))
        {
            #ifdef DIAG_DEVELOPER
            m_CollisionDetails += "[Player]";
            #endif
            SetIsColliding(true);
            
        }
        else if (IsFloating() || IsHidden() || IsCollidingBBox(action_item) || IsCollidingPlayer() || IsClippingRoof() || !IsBaseViable() || IsCollidingGPlot() || IsCollidingZeroPos() || IsCollidingAngle() || !IsPlacementPermitted() || !HeightPlacementCheck() || IsUnderwater() || IsInTerrain())
        {
            SetIsColliding(true);
        }
        else if ( m_Projection.IsInherited( TrapSpawnBase ))
        {
            #ifdef DIAG_DEVELOPER
            DebugText("Inherits from TrapSpawnBase, checking IsPlaceableAtposition", true);
            #endif
 
            TrapSpawnBase trapSpawnBase;
            Class.CastTo(trapSpawnBase, m_Projection);
            SetIsColliding(!trapSpawnBase.IsPlaceableAtPosition(m_Projection.GetPosition()));
        }
        else if (m_Projection.IsInherited(TrapBase))
        {
            #ifdef DIAG_DEVELOPER
            DebugText("Inherits from TrapBase, checking IsPlaceableAtposition", true);
            #endif
            TrapBase trapBase;
            Class.CastTo(trapBase, m_Projection);
            SetIsColliding(!trapBase.IsPlaceableAtPosition(m_Projection.GetPosition()));
        }
        else
        {
            SetIsColliding(false);
        }
    }

Перекрестные ссылки Class::CastTo(), HeightPlacementCheck(), IsBaseViable(), IsClippingRoof(), IsCollidingAngle(), IsCollidingBBox(), IsCollidingGPlot(), IsCollidingPlayer(), IsCollidingZeroPos(), IsFloating(), IsHidden(), IsInTerrain(), IsPlacementPermitted(), IsUnderwater(), m_Player, m_Projection и SetIsColliding().

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

GetCollisionBoxSize()

vector GetCollisionBoxSize ( vector min_max[2] )

inlineprotected

    {
        vector box_size = Vector(1,1,1);
        
        box_size[0] = min_max[1][0] - min_max[0][0];
        box_size[2] = min_max[1][2] - min_max[0][2];
        box_size[1] = min_max[1][1] - min_max[0][1];
        
        return box_size;
    }

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

Используется в GetProjectionDiameter(), GetProjectionRadius() и IsCollidingBBox().

GetDefaultOrientation()

vector GetDefaultOrientation ( )

inlineprotected

    {
        m_DefaultOrientation = GetGame().GetCurrentCameraDirection().VectorToAngles();
        m_DefaultOrientation[1] = 0;
        
        if (!GetParentEntity().PlacementCanBeRotated())
        {
            m_DefaultOrientation = vector.Zero;
        }
        
        return m_DefaultOrientation;
    }

Перекрестные ссылки GetGame(), GetParentEntity(), m_DefaultOrientation и vector::Zero.

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

GetHiddenSelection()

int GetHiddenSelection ( string selection )

inlineprotected

    {   
        int idx = m_Projection.GetHiddenSelectionIndex(selection);
 
        if ( idx != -1 )
            return idx;
        else
            return 0;
    }

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

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

GetLeftCloseProjectionVector()

vector GetLeftCloseProjectionVector ( )

inlineprotected

    {
        vector min_max[2];
        GetProjectionCollisionBox( min_max );
 
        return min_max[0];
    }

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

Используется в IsBaseViable(), IsInTerrain() и IsUnderwater().

GetLeftFarProjectionVector()

vector GetLeftFarProjectionVector ( )

inlineprotected

    {
        vector min_max[2];
        GetProjectionCollisionBox( min_max );
        min_max[0][2] = min_max[1][2];
 
        return min_max[0];
    }

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

Используется в IsBaseViable(), IsInTerrain() и IsUnderwater().

GetParentEntity()

EntityAI GetParentEntity ( )

inlineprotected

    {
        return m_Parent;
    }

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

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

GetProjectionCollisionBox()

void GetProjectionCollisionBox ( out vector min_max[2] )

inlineprotected

    {
        if (!m_Projection.GetCollisionBox( min_max ) && m_Projection.MemoryPointExists("box_placing_min"))
        {
            min_max[0] = m_Projection.GetMemoryPointPos( "box_placing_min" );
            min_max[1] = m_Projection.GetMemoryPointPos( "box_placing_max" );
            //Debug.DrawSphere(m_Projection.ModelToWorld(min_max[0]) , 0.8,Colors.RED, ShapeFlags.ONCE);
            //Debug.DrawSphere(m_Projection.ModelToWorld(min_max[1]), 0.8,Colors.RED, ShapeFlags.ONCE);
        }
    }

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

Используется в GetLeftCloseProjectionVector(), GetLeftFarProjectionVector(), GetProjectionDiameter(), GetProjectionRadius(), GetRightCloseProjectionVector(), GetRightFarProjectionVector(), IsCollidingBBox() и RefreshTrigger().

GetProjectionDiameter()

float GetProjectionDiameter ( )

inlineprotected

    {       
        float diameter;
        float radius;
        vector diagonal;
        vector min_max[2];
 
        GetProjectionCollisionBox( min_max );
        diagonal = GetCollisionBoxSize( min_max );
        diameter = diagonal.Length();
 
        return diameter;    
    }

Перекрестные ссылки GetCollisionBoxSize() и GetProjectionCollisionBox().

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

GetProjectionEntity()

EntityAI GetProjectionEntity ( )

inlineprotected

    {
        return m_Projection;
    }

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

Используется в HeightPlacementCheck(), Hologram() и PlaceEntity().

GetProjectionEntityPosition()

vector GetProjectionEntityPosition ( PlayerBase player )

inlineprotected

will not push hologram up when there is direct hit of an item

    {
        float minProjectionDistance;
        float maxProjectionDistance; 
        m_ContactDir = vector.Zero;
        vector minMax[2];
        float projectionRadius = GetProjectionRadius();
        float cameraToPlayerDistance = vector.Distance(GetGame().GetCurrentCameraPosition(), player.GetPosition());
 
        if (projectionRadius < SMALL_PROJECTION_RADIUS) // objects with radius smaller than 1m
        {
            minProjectionDistance = SMALL_PROJECTION_RADIUS;
            maxProjectionDistance = SMALL_PROJECTION_RADIUS * 2;
        }
        else
        {
            minProjectionDistance = projectionRadius;
            maxProjectionDistance = projectionRadius * 2;
            maxProjectionDistance = Math.Clamp(maxProjectionDistance, SMALL_PROJECTION_RADIUS, LARGE_PROJECTION_DISTANCE_LIMIT);
        }
        
        vector from = GetGame().GetCurrentCameraPosition();
        vector to = from + (GetGame().GetCurrentCameraDirection() * (maxProjectionDistance + cameraToPlayerDistance));
        vector contactPosition;
        set<Object> hitObjects = new set<Object>();
 
        DayZPhysics.RaycastRV(from, to, contactPosition, m_ContactDir, m_ContactComponent, hitObjects, player, m_Projection, false, false, ObjIntersectFire);
        
        bool contactHitProcessed = false;
        if (!CfgGameplayHandler.GetDisableIsCollidingBBoxCheck())
        {
            if (hitObjects.Count() > 0)
            {
                if (hitObjects[0].IsInherited(Watchtower))
                {
                    contactHitProcessed = true;
                    contactPosition = CorrectForWatchtower(m_ContactComponent, contactPosition, player, hitObjects[0]);
                }
                
                if (!contactHitProcessed && hitObjects[0].IsInherited(InventoryItem))
                    contactPosition = hitObjects[0].GetPosition();
            }
        }
 
        static const float raycastOriginOffsetOnFail = 0.25;
        static const float minDistFromStart = 0.01;
        // Camera isn't correctly positioned in some cases, leading to raycasts hitting the object directly behind the camera
        if ((hitObjects.Count() > 0) && (vector.DistanceSq(from, contactPosition) < minDistFromStart))
        {
            from = contactPosition + GetGame().GetCurrentCameraDirection() * raycastOriginOffsetOnFail;
            DayZPhysics.RaycastRV(from, to, contactPosition, m_ContactDir, m_ContactComponent, hitObjects, player, m_Projection, false, false, ObjIntersectFire);
        }
 
        bool isFloating = SetHologramPosition(player.GetPosition(), minProjectionDistance, maxProjectionDistance, contactPosition);
        SetIsFloating(isFloating);
 
        #ifdef DIAG_DEVELOPER
        DrawDebugArrow(minProjectionDistance, maxProjectionDistance);
        if (DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM))
        {
            Debug.DrawSphere(GetProjectionPosition(), 0.1, 0x99FF0000, ShapeFlags.ONCE|ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE);
        }
        #endif
        
        m_FromAdjusted = from;
 
        return contactPosition;
    }

Перекрестные ссылки Math::Clamp(), CorrectForWatchtower(), vector::Distance(), vector::DistanceSq(), Debug::DrawSphere(), DiagMenu::GetBool(), CfgGameplayHandler::GetDisableIsCollidingBBoxCheck(), GetGame(), GetProjectionPosition(), GetProjectionRadius(), LARGE_PROJECTION_DISTANCE_LIMIT, m_ContactComponent, m_ContactDir, m_FromAdjusted, m_Projection, DayZPhysics::RaycastRV(), SetHologramPosition(), SetIsFloating(), SMALL_PROJECTION_RADIUS и vector::Zero.

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

GetProjectionName()

string GetProjectionName ( ItemBase item )

inlineprotected

configuration override

    {
        if (m_ProjectionTypename != "")
        {
            return m_ProjectionTypename;
        }
 
        if (!item)
        {
            return "";
        }
        
        if (item.CanMakeGardenplot())
        {
            return "GardenPlotPlacing";
        }
        
        //Camping & Base building
        if (item.IsInherited( TentBase ) || item.IsBasebuildingKit())
        {
            return item.GetType() + "Placing";
        }
        
        return item.GetType();
    }

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

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

GetProjectionOrientation()

vector GetProjectionOrientation ( )

inlineprotected

    {
        if (m_Projection)
            return m_Projection.GetOrientation();
        
        return vector.Zero;
    }

Перекрестные ссылки m_Projection и vector::Zero.

Используется в CreateTrigger(), IsCollidingBBox() и RefreshTrigger().

GetProjectionPosition()

vector GetProjectionPosition ( )

inlineprotected

    {
        if (m_Projection)
            return m_Projection.GetPosition();
        
        return vector.Zero;
    }

Перекрестные ссылки m_Projection и vector::Zero.

Используется в CorrectMaterialPathName(), CreateTrigger(), GetProjectionEntityPosition(), HeightPlacementCheck(), IsBaseFlat(), IsCollidingZeroPos(), IsPlacementPermitted() и RefreshTrigger().

GetProjectionRadius()

float GetProjectionRadius ( )

inlineprotected

    {       
        float diameter;
        float radius;
        vector diagonal;
        vector min_max[2];
 
        GetProjectionCollisionBox( min_max );
        diagonal = GetCollisionBoxSize( min_max );
        diameter = diagonal.Length();
        radius = diameter / 2;
 
        return radius;  
    }

Перекрестные ссылки GetCollisionBoxSize() и GetProjectionCollisionBox().

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

GetProjectionRotation()

vector GetProjectionRotation ( )

inlineprotected

    {
        return m_Rotation;
    }

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

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

GetRightCloseProjectionVector()

vector GetRightCloseProjectionVector ( )

inlineprotected

    {
        vector min_max[2];
        GetProjectionCollisionBox( min_max );
        min_max[1][1] = min_max[0][1];
        min_max[1][2] = min_max[0][2];
 
        return min_max[1];
    }

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

Используется в IsBaseViable(), IsInTerrain() и IsUnderwater().

GetRightFarProjectionVector()

vector GetRightFarProjectionVector ( )

inlineprotected

    {
        vector min_max[2];
        GetProjectionCollisionBox( min_max );
        min_max[1][1] = min_max[0][1]; 
 
        return min_max[1];
    }

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

Используется в IsBaseViable(), IsInTerrain() и IsUnderwater().

GetUpdatePosition()

bool GetUpdatePosition ( )

inlineprotected

    {
        return m_UpdatePosition;
    }

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

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

HeightPlacementCheck()

bool HeightPlacementCheck ( )

inlineprotected

Checks height relative to player's position.

    {
        if (CfgGameplayHandler.GetDisableHeightPlacementCheck())
            return true;
        if ( GetProjectionEntity() ) //simple height check
        {
            vector playerpos = m_Player.GetPosition();
            vector projectionpos = GetProjectionPosition();
            float delta1 = playerpos[1] - projectionpos[1];
            
            if ( delta1 > DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF || delta1 < -DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF )
            {
                #ifdef DIAG_DEVELOPER
                DebugText("HeightPlacementCheck(must be true): ", true, false, " | Height difference between item and player is larger than " + DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF);
                #endif
                return false;
            }
        }
        #ifdef DIAG_DEVELOPER
        DebugText("HeightPlacementCheck(must be true): ", true, true);
        #endif
        return true;
    }

Перекрестные ссылки DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF, CfgGameplayHandler::GetDisableHeightPlacementCheck(), GetProjectionEntity(), GetProjectionPosition() и m_Player.

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

HideWhenClose()

vector HideWhenClose ( vector pos )

inlineprotected

    {
        //if the hologram is too close to player when he looks to the sky, send the projection to away
        vector cam_dir = GetGame().GetCurrentCameraDirection();
 
        if( cam_dir[1] > LOOKING_TO_SKY )
        {
            pos = "0 0 0";
        }
 
        return pos;
    }

Перекрестные ссылки GetGame() и LOOKING_TO_SKY.

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

IsBaseFlat()

bool IsBaseFlat ( vector contact_pos_left_close, vector contact_pos_right_close, vector contact_pos_left_far, vector contact_pos_right_far )

inlineprotected

    {       
        vector projection_pos = GetProjectionPosition();
        float slope_pos_left_close = Math.AbsFloat(projection_pos[1] - contact_pos_left_close[1]);
        float slope_pos_right_close = Math.AbsFloat(projection_pos[1] - contact_pos_right_close[1]);
        float slope_pos_left_far = Math.AbsFloat(projection_pos[1] - contact_pos_left_far[1]);
        float slope_pos_right_far = Math.AbsFloat(projection_pos[1] - contact_pos_right_far[1]);
        
        bool isTrue = slope_pos_left_close < m_SlopeTolerance && slope_pos_right_close < m_SlopeTolerance && slope_pos_left_far < m_SlopeTolerance && slope_pos_right_far < m_SlopeTolerance;
        #ifdef DIAG_DEVELOPER
        DebugText("IsBaseFlat(must be true): ", true, isTrue, " (slope < slopeTolerance) | slopeTolerance:  " + m_SlopeTolerance + " | lc: " + slope_pos_left_close + " | rc: " + slope_pos_right_close + " | lf: " + slope_pos_left_far + " | rf: " + slope_pos_right_far);
        DrawArrow(projection_pos, contact_pos_left_close, slope_pos_left_close < m_SlopeTolerance);
        DrawArrow(projection_pos, contact_pos_right_close, slope_pos_right_close < m_SlopeTolerance);       
        DrawArrow(projection_pos, contact_pos_left_far, slope_pos_left_far < m_SlopeTolerance);
        DrawArrow(projection_pos, contact_pos_right_far, slope_pos_right_far < m_SlopeTolerance);
        #endif
 
        return isTrue;
        }

Перекрестные ссылки Math::AbsFloat(), GetProjectionPosition() и m_SlopeTolerance.

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

IsBaseIntact()

bool IsBaseIntact ( Object under_left_close, Object under_right_close, Object under_left_far, Object under_right_far )

inlineprotected

    {
        bool isTrue = (under_left_close == under_right_close && under_right_close == under_left_far && under_left_far == under_right_far);
        #ifdef DIAG_DEVELOPER
        DebugText("IsBaseIntact(must be true and all equal): ", true, isTrue, " | ulc: " + Object.GetDebugName(under_left_close) + " | urc: " + Object.GetDebugName(under_right_close) + " | ulf: " + Object.GetDebugName(under_left_far) + " | urf: " + Object.GetDebugName(under_right_far));
        if (!isTrue)
        {
            array<bool> conditions = new array<bool>();
            conditions.Insert(under_left_close == null);
            conditions.Insert(under_right_close == null);
            conditions.Insert(under_left_far == null);
            conditions.Insert(under_right_far == null);
            
            int amountOfNull = 0;
            if (!under_left_close)
                ++amountOfNull;
            if (!under_right_close)
                ++amountOfNull;
            if (!under_left_far)
                ++amountOfNull;
            if (!under_right_far)
                ++amountOfNull;
            
            if ( amountOfNull < 3 )
                for ( int i = 0; i < conditions.Count(); ++i)
                    conditions[i] = !conditions[i];
            
            DrawBaseSpheres(conditions);
        }
        #endif
 
        return isTrue;
    }

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

IsBaseStatic()

bool IsBaseStatic ( Object objectToCheck )

inlineprotected

    {   
        //check if the object below hologram is dynamic object. Dynamic objects like barrels can be taken to hands 
        //and item which had been placed on top of them, would stay floating in the air         
        #ifdef DIAG_DEVELOPER
        if (objectToCheck == null)
            DebugText("IsBaseStatic(must be true): ", true, true, " | objectToCheck is null (this is good)");
        else
            DebugText("IsBaseStatic(must be true): ", true, IsObjectStatic(objectToCheck));
        #endif
        return objectToCheck == null || IsObjectStatic(objectToCheck);
    }

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

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

IsBaseViable()

bool IsBaseViable ( )

inlineprotected

    {   
        //This function is not required to solve server-side fixes for clipping, saves calculations and potential false negatives
        if (GetGame().IsServer() && GetGame().IsMultiplayer())
            return true;
 
        if (CfgGameplayHandler.GetDisableIsBaseViableCheck())
            return true;
        
        
        
        vector from_left_close = m_Projection.CoordToParent(GetLeftCloseProjectionVector()) + PLACEMENT_RC_START_OFFSET;
        vector to_left_close_down = from_left_close + PLACEMENT_RC_END_OFFSET;
 
        vector from_right_close = m_Projection.CoordToParent(GetRightCloseProjectionVector()) + PLACEMENT_RC_START_OFFSET;
        vector to_right_close_down = from_right_close + PLACEMENT_RC_END_OFFSET;
 
        vector from_left_far = m_Projection.CoordToParent(GetLeftFarProjectionVector() + PLACEMENT_RC_START_OFFSET);
        vector to_left_far_down = from_left_far + PLACEMENT_RC_END_OFFSET;
 
        vector from_right_far = m_Projection.CoordToParent(GetRightFarProjectionVector()) + PLACEMENT_RC_START_OFFSET;
        vector to_right_far_down = from_right_far + PLACEMENT_RC_END_OFFSET;
        
        vector contact_pos_left_close;
        vector contact_pos_right_close;
        vector contact_pos_left_far;
        vector contact_pos_right_far;
        vector contact_dir_left_close;
        vector contact_dir_right_close;
        vector contact_dir_left_far;
        vector contact_dir_right_far;
        int contact_component_left_close;
        int contact_component_right_close;
        int contact_component_left_far;
        int contact_component_right_far;
        set<Object> results_left_close = new set<Object>;
        set<Object> results_right_close = new set<Object>;
        set<Object> results_left_far = new set<Object>;
        set<Object> results_right_far = new set<Object>;
        Object obj_left_close;
        Object obj_right_close;
        Object obj_left_far;
        Object obj_right_far;
                        
        //Not sure what the intention here was before, but it boiled down to a very bloated version of what you see here right now
        DayZPhysics.RaycastRV(from_left_close, to_left_close_down, contact_pos_left_close, contact_dir_left_close, contact_component_left_close, results_left_close, null, m_Projection, false, false, ObjIntersectFire);
        if (results_left_close.Count() > 0)
            obj_left_close = results_left_close[results_left_close.Count() - 1];
 
        DayZPhysics.RaycastRV(from_right_close, to_right_close_down, contact_pos_right_close, contact_dir_right_close, contact_component_right_close, results_right_close, null, m_Projection, false, false, ObjIntersectFire);
        if (results_right_close.Count() > 0)    
            obj_right_close = results_right_close[results_right_close.Count() - 1];
 
        DayZPhysics.RaycastRV(from_left_far, to_left_far_down, contact_pos_left_far, contact_dir_left_far, contact_component_left_far, results_left_far, null, m_Projection, false, false, ObjIntersectFire);
        if (results_left_far.Count() > 0) 
            obj_left_far = results_left_far[results_left_far.Count() - 1];
 
        DayZPhysics.RaycastRV(from_right_far, to_right_far_down, contact_pos_right_far, contact_dir_right_far, contact_component_right_far, results_right_far, null, m_Projection, false, false, ObjIntersectFire);
        if (results_right_far.Count() > 0)
            obj_right_far = results_right_far[results_right_far.Count() - 1];
        
        return IsBaseIntact(obj_left_close, obj_right_close, obj_left_far, obj_right_far ) && IsBaseStatic( obj_left_close ) && IsBaseFlat( contact_pos_left_close, contact_pos_right_close, contact_pos_left_far, contact_pos_right_far);
    }

Перекрестные ссылки CfgGameplayHandler::GetDisableIsBaseViableCheck(), GetGame(), GetLeftCloseProjectionVector(), GetLeftFarProjectionVector(), GetRightCloseProjectionVector(), GetRightFarProjectionVector(), IsBaseFlat(), IsBaseIntact(), IsBaseStatic(), m_Projection, PLACEMENT_RC_END_OFFSET, PLACEMENT_RC_START_OFFSET и DayZPhysics::RaycastRV().

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

IsBehindObstacle()

bool IsBehindObstacle ( )

inlineprotected

DEPRECATED.

    {           
        ErrorEx("Deprecated check - do not use", ErrorExSeverity.WARNING);
        return false;
    }

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

IsClippingRoof()

bool IsClippingRoof ( )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsClippingRoofCheck())
            return false;
        if (GetGame().IsServer() && GetGame().IsMultiplayer())
            return false;
        
        //Some locations allow you to look up and attempt placing the hologram on the bottom side of a floor - most notably the floors of a watchtower
        //This check also prevents some very unnatural placements
 
        bool b1 = m_Projection.GetPosition()[1] > GetGame().GetCurrentCameraPosition()[1];
        bool b2 = false;
        #ifdef DIAG_DEVELOPER
        vector from, to;
        #endif
        if (m_Projection.DoPlacingHeightCheck())
        {
            b2 = MiscGameplayFunctions.IsUnderRoofEx(m_Projection, GameConstants.ROOF_CHECK_RAYCAST_DIST, ObjIntersectFire);
            #ifdef DIAG_DEVELOPER           
            MiscGameplayFunctions.IsUnderRoofFromToCalculation(m_Projection, from, to);
            DrawArrow(from, to, !b2);
            #endif
        }
        
        #ifdef DIAG_DEVELOPER
        DebugText("IsClippingRoof: ", false, b1, " | (projection height) " + m_Projection.GetPosition()[1] + " > (camera height) " + GetGame().GetCurrentCameraPosition()[1]);
        DebugText("IsClippingRoof: ", false, b2, " | (DoPlacingHeightCheck) " + m_Projection.DoPlacingHeightCheck() + " && (IsUnderRoof) " + MiscGameplayFunctions.IsUnderRoof(m_Projection) + " | from: " + from[1] + " | to: " + to[1]);
        #endif
        
        return b1 || b2;
    }

Перекрестные ссылки CfgGameplayHandler::GetDisableIsClippingRoofCheck(), GetGame(), m_Projection и GameConstants::ROOF_CHECK_RAYCAST_DIST.

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

IsColliding()

bool IsColliding ( )

inlineprotected

    {
        return m_IsColliding;
    }

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

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

IsCollidingAngle()

bool IsCollidingAngle ( )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsCollidingAngleCheck())
            return false;
        vector projection_orientation = m_Projection.GetOrientation();      
        bool isTrue = Math.AbsFloat( projection_orientation[1] ) > m_YawPitchRollLimit[1] || Math.AbsFloat( projection_orientation[2] ) > m_YawPitchRollLimit[2];
        #ifdef DIAG_DEVELOPER
        DebugText("IsCollidingAngle: ", false, isTrue, " | (proj pitch) " + Math.AbsFloat( projection_orientation[1] ) + " > (pitch limit) " + m_YawPitchRollLimit[1] + " | (proj roll) " + Math.AbsFloat( projection_orientation[2] ) + " > (roll limit) " + m_YawPitchRollLimit[2]);
        #endif
 
        return isTrue;
    }

Перекрестные ссылки Math::AbsFloat(), CfgGameplayHandler::GetDisableIsCollidingAngleCheck(), m_Projection и m_YawPitchRollLimit.

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

IsCollidingBBox()

bool IsCollidingBBox ( ItemBase action_item = null )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsCollidingBBoxCheck())
            return false;
 
        vector center;
        vector relativeOffset; //we need to lift BBox, because it is calculated from the bottom of projection, and not from the middle
        vector absoluteOffset = "0 0.05 0"; //we need to lift BBox even more, because it colliddes with house floors due to various reasons (probably geometry or float imperfections)
        vector orientation = GetProjectionOrientation();
        vector edgeLength;
        vector minMax[2];
        array<Object> excludedObjects = new array<Object>();
        array<Object> collidedObjects = new array<Object>();
        
        GetProjectionCollisionBox(minMax);
        relativeOffset[1] = (minMax[1][1] - minMax[0][1]) * 0.5;
        center = m_Projection.GetPosition() + relativeOffset + absoluteOffset;
        edgeLength = GetCollisionBoxSize(minMax);
        excludedObjects.Insert(m_Projection);
        excludedObjects.Insert(m_Player);
 
        if (action_item)
            excludedObjects.Insert(action_item);
 
        //add is construction check
        // Base building objects behave in a way that causes this test to generate false positives
        bool isTrue = GetGame().IsBoxCollidingGeometry(center, orientation, edgeLength, ObjIntersectFire, ObjIntersectGeom, excludedObjects, collidedObjects);      
        #ifdef DIAG_DEVELOPER   
        if ( DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM) )
        {
            string text = "";
            foreach (Object object: collidedObjects)
                text += " | " + Object.GetDebugName(object);
 
            DebugText("IsCollidingBBox: ", false, isTrue, text);
        
            int color = 0x01FFFFFF;
            if (isTrue)
                color = 0x33F22613;
            
            DrawDebugCollisionBox(minMax, color);
        }
        #endif
 
        return isTrue;
    }

Перекрестные ссылки DrawDebugCollisionBox(), DiagMenu::GetBool(), GetCollisionBoxSize(), CfgGameplayHandler::GetDisableIsCollidingBBoxCheck(), GetGame(), GetProjectionCollisionBox(), GetProjectionOrientation(), m_Player и m_Projection.

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

IsCollidingGPlot()

bool IsCollidingGPlot ( )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsCollidingGPlotCheck())
            return false;
 
        #ifdef DIAG_DEVELOPER
        DebugText("IsCollidingGPlot: ", false, m_IsCollidingGPlot);
        #endif
 
        return m_IsCollidingGPlot;
    }

Перекрестные ссылки CfgGameplayHandler::GetDisableIsCollidingGPlotCheck() и m_IsCollidingGPlot.

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

IsCollidingPlayer()

bool IsCollidingPlayer ( )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsCollidingPlayerCheck())
            return false;
        #ifdef DIAG_DEVELOPER
        DebugText("IsCollidingPlayer: ", false, m_IsCollidingPlayer);
        #endif
        return m_IsCollidingPlayer;
    }

Перекрестные ссылки CfgGameplayHandler::GetDisableIsCollidingPlayerCheck() и m_IsCollidingPlayer.

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

IsCollidingZeroPos()

bool IsCollidingZeroPos ( )

inlineprotected

    {
        vector origin = Vector(0, 0, 0);
        bool isTrue = GetProjectionPosition() == origin;
        #ifdef DIAG_DEVELOPER
        DebugText("IsCollidingZeroPos: ", false, isTrue);
        #endif
 
        return isTrue;
    }

Перекрестные ссылки GetProjectionPosition() и Vector().

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

IsFenceOrWatchtowerKit()

bool IsFenceOrWatchtowerKit ( )

inlineprotected

    {
        return m_Parent.IsBasebuildingKit() || m_Parent.IsInherited(TentBase);
    }

Перекрестные ссылки ItemBase::IsBasebuildingKit() и m_Parent.

IsFloating()

bool IsFloating ( )

inlineprotected

    {
        #ifdef DIAG_DEVELOPER
        DebugText("IsFloating: ", false, m_IsFloating);
        #endif
        return m_IsFloating;
    }

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

Используется в CorrectMaterialPathName(), EvaluateCollision() и SetProjectionPosition().

IsHidden()

bool IsHidden ( )

inlineprotected

    {
        #ifdef DIAG_DEVELOPER
        DebugText("IsHidden: ", false, m_IsHidden);
        #endif
        return m_IsHidden;
    }

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

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

IsInTerrain()

bool IsInTerrain ( )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsInTerrainCheck())
            return false;
        vector fromHeightOffset = "0 0.3 0";
        vector toHeightOffset = "0 1 0";
        
        vector from_left_close = m_Projection.CoordToParent( GetLeftCloseProjectionVector() ) + fromHeightOffset;
        vector to_left_close_down = from_left_close + toHeightOffset;
 
        vector from_right_close = m_Projection.CoordToParent( GetRightCloseProjectionVector() ) + fromHeightOffset;
        vector to_right_close_down = from_right_close + toHeightOffset;
 
        vector from_left_far = m_Projection.CoordToParent( GetLeftFarProjectionVector() ) + fromHeightOffset;
        vector to_left_far_down = from_left_far + toHeightOffset;
 
        vector from_right_far = m_Projection.CoordToParent( GetRightFarProjectionVector() ) + fromHeightOffset;
        vector to_right_far_down = from_right_far + toHeightOffset;
 
        vector contact_pos_left_close;
        vector contact_pos_right_close;
        vector contact_pos_left_far;
        vector contact_pos_right_far;
        
        vector contact_dir_left_close;
        vector contact_dir_right_close;
        vector contact_dir_left_far;
        vector contact_dir_right_far;
        
        int contact_component_left_close;
        int contact_component_right_close;
        int contact_component_left_far;
        int contact_component_right_far;
        
        #ifdef DIAG_DEVELOPER
        // I'd rather duplicate this on internal than introduce (even) more raycasts than needed on retail..
        set<Object> lcO = new set<Object>();
        set<Object> rcO = new set<Object>();
        set<Object> lfO = new set<Object>();
        set<Object> rfO = new set<Object>();
        bool lc = DayZPhysics.RaycastRV( from_left_close, to_left_close_down, contact_pos_left_close, contact_dir_left_close, contact_component_left_close, lcO, m_Projection, m_Projection, false, true, ObjIntersectFire );
        bool rc = DayZPhysics.RaycastRV( from_right_close, to_right_close_down, contact_pos_right_close, contact_dir_right_close, contact_component_right_close, rcO, m_Projection, m_Projection, false, true, ObjIntersectFire );
        bool lf = DayZPhysics.RaycastRV( from_left_far, to_left_far_down, contact_pos_left_far, contact_dir_left_far, contact_component_left_far, lfO, m_Projection, m_Projection, false, true, ObjIntersectFire );
        bool rf = DayZPhysics.RaycastRV( from_right_far, to_right_far_down, contact_pos_right_far, contact_dir_right_far, contact_component_right_far, rfO, m_Projection, m_Projection, false, true, ObjIntersectFire );
        bool isTrue = ( lc || rc || lf || rf );
        string text = "";       
        if (isTrue)
        {
            if (lc)
                text += " | lc";
            if (rc)
                text += " | rc";
            if (lf)
                text += " | lf";
            if (rf)
                text += " | rf";
            
            if (lcO.Count() > 0)
                text += " | lcO: " + lcO[0];
            if (rcO.Count() > 0)
                text += " | rcO: " + rcO[0];
            if (lfO.Count() > 0)
                text += " | lfO: " + lfO[0];
            if (rfO.Count() > 0)
                text += " | rfO: " + rfO[0];
            
            array<bool> conditions = {!lc, !rc, !lf, !rf};
            DrawBaseSpheres(conditions);
        }
        DebugText("IsInTerrain: ", false, isTrue, text);
        #endif
 
        if (DayZPhysics.RaycastRV( from_left_close, to_left_close_down, contact_pos_left_close, contact_dir_left_close, contact_component_left_close, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire ))
            return true;
 
        if (DayZPhysics.RaycastRV( from_right_close, to_right_close_down, contact_pos_right_close, contact_dir_right_close, contact_component_right_close, NULL,m_Projection, m_Projection, false, true, ObjIntersectFire ))
            return true;
 
        if (DayZPhysics.RaycastRV( from_left_far, to_left_far_down, contact_pos_left_far, contact_dir_left_far, contact_component_left_far, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire ))
            return true;
 
        if (DayZPhysics.RaycastRV( from_right_far, to_right_far_down, contact_pos_right_far, contact_dir_right_far, contact_component_right_far, NULL, m_Projection, m_Projection, false, true, ObjIntersectFire ))
            return true;
        
        return false;
    }

Перекрестные ссылки CfgGameplayHandler::GetDisableIsInTerrainCheck(), GetLeftCloseProjectionVector(), GetLeftFarProjectionVector(), GetRightCloseProjectionVector(), GetRightFarProjectionVector(), m_Projection и DayZPhysics::RaycastRV().

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

IsObjectStatic()

bool IsObjectStatic ( Object obj )

inlineprotected

    {
        return obj.IsBuilding() || obj.IsPlainObject() || (!m_Parent.IsInherited(KitBase) && obj.IsInherited(BaseBuildingBase) && (m_WatchtowerBlockedComponentNames.Find(obj.GetActionComponentName(m_ContactComponent, LOD.NAME_VIEW)) == -1));
    }

Перекрестные ссылки m_ContactComponent, m_Parent, m_WatchtowerBlockedComponentNames и LOD::NAME_VIEW.

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

IsPlacementPermitted()

bool IsPlacementPermitted ( )

inlineprotected

Checks if the item can be legally placed (usually checked by action as well)

    {
        if (CfgGameplayHandler.GetDisableIsPlacementPermittedCheck())
            return true;
 
        bool isTrue = m_Parent && m_Parent.CanBePlaced(m_Player, GetProjectionPosition());
 
        #ifdef DIAG_DEVELOPER
        DebugText("IsPlacementPermitted(must be true): ", true, isTrue, " (Note: ItemBase::CanBePlaced() return value)");
        #endif
        return isTrue;
    }

Перекрестные ссылки ItemBase::CanBePlaced(), CfgGameplayHandler::GetDisableIsPlacementPermittedCheck(), GetProjectionPosition(), m_Parent и m_Player.

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

IsProjectionTrap()

bool IsProjectionTrap ( )

inlineprotected

    {
        return m_Projection.IsInherited( TrapBase ) || m_Projection.IsInherited( TrapSpawnBase );
    }

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

IsRestrictedFromAdvancedPlacing()

bool IsRestrictedFromAdvancedPlacing ( )

inlineprivate

    {
        if (m_Player.IsJumpInProgress())
            return true;
        if (m_Player.IsSwimming())
            return true;
        if (m_Player.IsClimbingLadder())
            return true;
        if (m_Player.IsRaised())
            return true;
        if (m_Player.IsClimbing())
            return true;
        if (m_Player.IsRestrained())
            return true;
        if (m_Player.IsUnconscious())
            return true;
        
        return false;
    }

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

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

IsSurfaceSea()

bool IsSurfaceSea ( vector position )

inlineprotected

    {
        CGame game = GetGame();
        return game.SurfaceIsSea( position[0], position[2] );
    }

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

IsSurfaceWater()

bool IsSurfaceWater ( vector position )

inlineprotected

    {
        CGame game = GetGame();
        return game.SurfaceIsSea( position[0], position[2] ) || game.SurfaceIsPond( position[0], position[2] );
    }

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

IsUnderwater()

bool IsUnderwater ( )

inlineprotected

    {
        if (CfgGameplayHandler.GetDisableIsUnderwaterCheck())
            return false;
        // Fast check middle of object
        string type;
        int liquid;
        g_Game.SurfaceUnderObjectCorrectedLiquid(m_Projection, type, liquid);
        
        if (liquid & (LIQUID_GROUP_WATER - LIQUID_SNOW))
        {
            #ifdef DIAG_DEVELOPER
            DebugText("IsUnderwater: ", false, true, " | Surface under object is water");
            #endif
            return true;
        }
        
        // Check every corner of the object
        vector left_close = m_Projection.CoordToParent( GetLeftCloseProjectionVector() );
        vector right_close = m_Projection.CoordToParent( GetRightCloseProjectionVector() );
        vector left_far = m_Projection.CoordToParent( GetLeftFarProjectionVector() );
        vector right_far = m_Projection.CoordToParent( GetRightFarProjectionVector() );
        float maxSea = g_Game.SurfaceGetSeaLevelMax() + 0.03;
        bool belowMaxSea = left_close[1] < maxSea || right_close[1] < maxSea || left_far[1] < maxSea || right_far[1] < maxSea;
        
        #ifdef DIAG_DEVELOPER
        // I'd rather duplicate this on internal than introduce (even) more raycasts than needed on retail..
        float lc = g_Game.GetWaterDepth(left_close);
        float rc = g_Game.GetWaterDepth(right_close);
        float lf = g_Game.GetWaterDepth(left_far);
        float rf = g_Game.GetWaterDepth(right_far);
        bool isTrue = (lc > 0 || rc > 0 || lf > 0 || rf > 0 || belowMaxSea);
        DebugText("IsUnderwater: ", false, isTrue, " belowMaxSea: " + belowMaxSea + " | (all must be less than zero) | lc: " + lc + " | rc: " + rc + " | lf: " + lf + " | rf: " + rf);
        //DebugText("Corner Height: ", false, true, " lc: " + left_close[1] + " | rc: " + right_close[1] + " | lf: " + left_far[1] + " | rf: " + right_far[1]);
        if (isTrue)
        {
            array<bool> conditions = {lc <= 0, rc <= 0, lf <= 0, rf <= 0};
            DrawBaseSpheres(conditions);
        }
        #endif
        
        return (belowMaxSea || g_Game.GetWaterDepth(left_close) > 0 || g_Game.GetWaterDepth(right_close) > 0 || g_Game.GetWaterDepth(left_far) > 0 || g_Game.GetWaterDepth(right_far) > 0); 
    }

Перекрестные ссылки g_Game, CfgGameplayHandler::GetDisableIsUnderwaterCheck(), GetLeftCloseProjectionVector(), GetLeftFarProjectionVector(), GetRightCloseProjectionVector(), GetRightFarProjectionVector(), LIQUID_GROUP_WATER, LIQUID_SNOW и m_Projection.

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

PlaceEntity()

EntityAI PlaceEntity ( EntityAI entity_for_placing )

inlineprotected

    {
        //string-based comparison
        if (entity_for_placing.IsInherited(TentBase) || entity_for_placing.IsBasebuildingKit() )
        {
            return entity_for_placing;
        }
        
        if (m_Projection.IsInherited(GardenPlotPlacing))
        {
            Class.CastTo(entity_for_placing, GetGame().CreateObjectEx( "GardenPlot", m_Projection.GetPosition(), ECE_OBJECT_SWAP ));
            return entity_for_placing;
        }
        
        //inheritance comparison
        if( !GetProjectionEntity().IsKindOf( m_Parent.GetType() ))
        {
            Class.CastTo(entity_for_placing, GetGame().CreateObjectEx( m_Projection.GetType(), m_Projection.GetPosition(), ECE_OBJECT_SWAP ));
        }
        
        return entity_for_placing;
    }

Перекрестные ссылки Class::CastTo(), ECE_OBJECT_SWAP, GetGame(), GetProjectionEntity(), m_Parent и m_Projection.

ProjectionBasedOnParent()

string ProjectionBasedOnParent ( )

inlineprotected

    {
        return GetProjectionName(m_Parent);
    }

Перекрестные ссылки GetProjectionName() и m_Parent.

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

RefreshTrigger()

void RefreshTrigger ( )

inlineprotected

    {
        vector min_max[2];
        GetProjectionCollisionBox( min_max );
 
        m_ProjectionTrigger.SetPosition(GetProjectionPosition());
        m_ProjectionTrigger.SetOrientation(GetProjectionOrientation());
        m_ProjectionTrigger.SetExtents(min_max[0], min_max[1]);
    }

Перекрестные ссылки GetProjectionCollisionBox(), GetProjectionOrientation(), GetProjectionPosition() и m_ProjectionTrigger.

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

RefreshVisual()

void RefreshVisual ( )

inlineprotected

    {
        if (m_Projection)
        {
            static const string textureName = "#(argb,8,8,3)color(0.5,0.5,0.5,0.75,ca)";
 
            int hidden_selection            = 0;
            string selection_to_refresh;
            string config_material          = string.Format("CfgVehicles %1 hologramMaterial", m_Projection.GetType());
            string hologram_material        = GetGame().ConfigGetTextOut(config_material);
            string config_model             = string.Format("CfgVehicles %1 hologramMaterialPath", m_Projection.GetType());
            string hologram_material_path   = string.Format("%1\\%2%3", GetGame().ConfigGetTextOut(config_model), hologram_material, CorrectMaterialPathName());
            
            for (int i = 0; i < m_SelectionsToRefresh.Count(); ++i)
            {
                selection_to_refresh = m_SelectionsToRefresh.Get(i);
                hidden_selection = GetHiddenSelection(selection_to_refresh);
                m_Projection.SetObjectTexture(hidden_selection, textureName);
                m_Projection.SetObjectMaterial(hidden_selection, hologram_material_path);
            }
        }
    }

Перекрестные ссылки CorrectMaterialPathName(), GetGame(), GetHiddenSelection(), m_Projection и m_SelectionsToRefresh.

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

SetAnimations()

void SetAnimations ( )

inlineprotected

    {
        if ( m_Projection.HasAnimation( ANIMATION_PLACING ) )
        {
            m_Projection.SetAnimationPhase( ANIMATION_PLACING, 0 );
            SetSelectionToRefresh( SELECTION_PLACING );
 
            if ( m_Projection.HasAnimation( ANIMATION_INVENTORY ) )
            {
                m_Projection.SetAnimationPhase( ANIMATION_INVENTORY, 1 );
            }
        }
        else
        {
            UpdateSelections();
            SetSelectionToRefresh( SELECTION_INVENTORY );
        }
    }

Перекрестные ссылки ANIMATION_INVENTORY, ANIMATION_PLACING, m_Projection, SELECTION_INVENTORY, SELECTION_PLACING, SetSelectionToRefresh() и UpdateSelections().

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

SetHologramPosition()

bool SetHologramPosition ( vector startPosition, float minProjectionDistance, float maxProjectionDistance, inout vector contactPosition )

inlineprotected

Sets hologram position based on player and projection distance.

Аргументы

startPosition	start position
minProjectionDistance	lower distance limit
maxProjectionDistance	higher distance limit
inout	contactPosition is position of the hologram contact with ground/object

Возвращает

true if hologram is floating (is on the near or far edge)

    {
        float playerToProjectionDistance = vector.Distance(startPosition, contactPosition);
        vector playerToProjection;
        
        #ifdef DIAG_DEVELOPER
        DebugText("SetHologramPosition::startPosition: ", false, m_IsHidden, string.Format(" | %1", startPosition));
        DebugText("SetHologramPosition::contactPosition [in]: ", false, m_IsHidden, string.Format(" | %1", contactPosition));
        DebugText("SetHologramPosition::minProjectionDistance: ", false, m_IsHidden, string.Format(" | %1", minProjectionDistance));
        DebugText("SetHologramPosition::maxProjectionDistance: ", false, m_IsHidden, string.Format(" | %1", maxProjectionDistance));
        DebugText("SetHologramPosition::playerToProjectionDistance: ", false, m_IsHidden, string.Format(" | %1", playerToProjectionDistance));
        #endif
 
        //hologram is at min distance from player
        if (playerToProjectionDistance <= minProjectionDistance)
        {
            playerToProjection = contactPosition - startPosition;
            playerToProjection.Normalize();
            //prevents the hologram to go underground/floor while hologram exceeds minProjectionDistance
            playerToProjection[1] = playerToProjection[1] + PROJECTION_TRANSITION_MIN;
            
            contactPosition = startPosition + (playerToProjection * minProjectionDistance);
            
            #ifdef DIAG_DEVELOPER
            DebugText("SetHologramPosition::contactPosition[out] (< minProjectDistance): ", false, m_IsHidden, string.Format(" | %1", contactPosition));
            #endif
 
            return true;
        }
        //hologram is at max distance from player
        else if (playerToProjectionDistance >= maxProjectionDistance)
        {
            playerToProjection = contactPosition - startPosition;
            playerToProjection.Normalize();
            //prevents the hologram to go underground/floor while hologram exceeds maxProjectionDistance
            playerToProjection[1] = playerToProjection[1] + PROJECTION_TRANSITION_MAX;
            
            contactPosition = startPosition + (playerToProjection * maxProjectionDistance);
            
            #ifdef DIAG_DEVELOPER
            DebugText("SetHologramPosition::contactPosition[out] (< maxProjectionDistance): ", false, m_IsHidden, string.Format(" | %1", contactPosition));
            #endif
        
            return true;
        }
        
        return false;
    }

Перекрестные ссылки vector::Distance(), m_IsHidden, PROJECTION_TRANSITION_MAX и PROJECTION_TRANSITION_MIN.

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

SetIsColliding()

void SetIsColliding ( bool is_colliding )

inlineprotected

    {
        #ifdef DIAG_DEVELOPER
        DebugText("Is colliding: ", false, is_colliding, m_CollisionDetails);
        #endif
        m_IsColliding = is_colliding;
    }

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

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

SetIsCollidingGPlot()

void SetIsCollidingGPlot ( bool is_colliding_gplot )

inlineprotected

    {
        m_IsCollidingGPlot = is_colliding_gplot;
    }

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

SetIsCollidingPlayer()

void SetIsCollidingPlayer ( bool is_colliding )

inlineprotected

    {
        m_IsCollidingPlayer = is_colliding;
    }

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

SetIsFloating()

void SetIsFloating ( bool is_floating )

inlineprotected

    {
        m_IsFloating = is_floating;
    }

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

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

SetIsHidden()

void SetIsHidden ( bool is_hidden )

inlineprotected

    {
        m_IsHidden = is_hidden;
    }

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

SetOnGround()

vector SetOnGround ( vector position )

inlineprotected

    {
        vector from = position;
        vector ground;
        vector player_to_projection_vector;
        float projection_diameter = GetProjectionDiameter();
            
        ground = Vector(0, -Math.Max(projection_diameter, SMALL_PROJECTION_GROUND), 0);
        
        vector to = from + ground;
        vector contact_pos = to;
        
        RaycastRVParams rayInput = new RaycastRVParams(from, to, m_Projection);
        rayInput.flags = CollisionFlags.ALLOBJECTS;
        array<ref RaycastRVResult> results = new array<ref RaycastRVResult>;
        
        if (DayZPhysics.RaycastRVProxy(rayInput, results))
        {
            RaycastRVResult res;
            for (int i = 0; i < results.Count(); i++)
            {
                res = results.Get(i);
                if (res.entry || (!res.obj && !res.parent))
                {
                    contact_pos = res.pos;
                    break;
                }
            }
        }
        
        //LOS check
        if (contact_pos != "0 0 0")
        {
            vector check_pos;
            vector check_dir;
            int check_component = -1;
            set<Object> hit_object = new set<Object>;
            to = contact_pos;
            to[1] = to[1] + 0.1;
            from = m_FromAdjusted;
            
            if (DayZPhysics.RaycastRV(from, to, check_pos, check_dir, check_component, hit_object, null, m_Player, false, false, ObjIntersectFire))
            {
                if ((hit_object.Count() > 0)&& (!hit_object[0].IsInherited(Watchtower) || (hit_object[0].IsInherited(Watchtower) && (m_WatchtowerIgnoreComponentNames.Find(hit_object[0].GetActionComponentName(check_component, LOD.NAME_VIEW)) == -1))))
                {
                    contact_pos = "0 0 0";
                }
            }
        }
        
        HideWhenClose(contact_pos);
 
        return contact_pos;
    }

Перекрестные ссылки GetProjectionDiameter(), HideWhenClose(), m_FromAdjusted, m_Player, m_Projection, m_WatchtowerIgnoreComponentNames, Math::Max(), LOD::NAME_VIEW, DayZPhysics::RaycastRV(), DayZPhysics::RaycastRVProxy(), SMALL_PROJECTION_GROUND и Vector().

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

SetProjectionEntity()

void SetProjectionEntity ( EntityAI projection )

inlineprotected

    {
        m_Projection = projection;
    }

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

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

SetProjectionOrientation()

void SetProjectionOrientation ( vector orientation )

inlineprotected

    {   
        m_Projection.SetOrientation(orientation);
    }

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

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

SetProjectionPosition()

void SetProjectionPosition ( vector position )

inlineprotected

    {
        m_Projection.SetPosition( position );
        
        if (IsFloating())
        {
            m_Projection.SetPosition(SetOnGround(position));
        }
    }

Перекрестные ссылки IsFloating(), m_Projection и SetOnGround().

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

SetSelectionToRefresh() [1/2]

void SetSelectionToRefresh ( array< string > selection )

inlineprotected

    {
        foreach (string s : selection)
            m_SelectionsToRefresh.Insert(s);
    }

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

SetSelectionToRefresh() [2/2]

void SetSelectionToRefresh ( string selection )

inlineprotected

    {
        m_SelectionsToRefresh.Insert( selection );
    }

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

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

SetUpdatePosition()

void SetUpdatePosition ( bool state )

inlineprotected

    {
        m_UpdatePosition = state;
    }

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

SmoothProjectionMovement()

vector SmoothProjectionMovement ( vector y_p_r, float timeslice )

inlineprotected

    {   
        if ( m_y_p_r_previous )
        {                   
            if ( Math.AbsFloat( y_p_r[0] - m_y_p_r_previous[0] ) > 100 )
            {                                               
                if ( y_p_r[0] > 0 )
                {       
                    m_y_p_r_previous[0] = m_y_p_r_previous[0] + 360; 
                }
                
                if ( y_p_r[0] < 0 )
                {       
                    m_y_p_r_previous[0] = m_y_p_r_previous[0] - 360;
                }
            }
            
            y_p_r[0] = Math.Lerp( m_y_p_r_previous[0], y_p_r[0], 15 * timeslice );
            y_p_r[1] = Math.Lerp( m_y_p_r_previous[1], y_p_r[1], 15 * timeslice );
            y_p_r[2] = Math.Lerp( m_y_p_r_previous[2], y_p_r[2], 15 * timeslice );
        }
        
        m_y_p_r_previous = y_p_r;
        
        return y_p_r;
    }

Перекрестные ссылки Math::AbsFloat(), Math::Lerp() и m_y_p_r_previous.

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

SubtractProjectionRotation()

void SubtractProjectionRotation ( float subtraction )

inlineprotected

    {   
        m_Rotation[0] = m_Rotation[0] - subtraction;
    }

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

UpdateHologram()

void UpdateHologram ( float timeslice )

inlineprotected

    {
        if (!m_Parent)
        {
            m_Player.TogglePlacingLocal();
            
            return;
        }
        
        if (IsRestrictedFromAdvancedPlacing())
        {
            m_Player.TogglePlacingLocal();
            
            return;
        }
 
        if (!GetUpdatePosition())
            return;
        
        
        #ifdef DIAG_DEVELOPER
        DebugConfigValues();
        DestroyDebugCollisionBox();
        #endif
 
        // update hologram position 
        SetProjectionPosition(GetProjectionEntityPosition(m_Player));
        SetProjectionOrientation(AlignProjectionOnTerrain(timeslice));
 
        EvaluateCollision();
        RefreshTrigger();
        CheckPowerSource();
        RefreshVisual();
 
        m_Projection.OnHologramBeingPlaced(m_Player);
    }

Перекрестные ссылки AlignProjectionOnTerrain(), CheckPowerSource(), DestroyDebugCollisionBox(), EvaluateCollision(), GetProjectionEntityPosition(), GetUpdatePosition(), IsRestrictedFromAdvancedPlacing(), m_Parent, m_Player, m_Projection, RefreshTrigger(), RefreshVisual(), SetProjectionOrientation() и SetProjectionPosition().

UpdateSelections()

void UpdateSelections ( )

inlineprotected

    {
        string cfg_access = "CfgVehicles " + m_Projection.GetType() + " AnimationSources ";
        
        if ( GetGame().ConfigIsExisting(cfg_access) )
        {
            int cfg_access_count = g_Game.ConfigGetChildrenCount(cfg_access);
 
            for ( int i = 0; i < cfg_access_count; ++i )
            {
                string found_anim;
                GetGame().ConfigGetChildName(cfg_access, i, found_anim);
                
                float anim_phase = m_Parent.GetAnimationPhase(found_anim);
                m_Projection.SetAnimationPhase(found_anim, anim_phase);
            }
        }
    }

Перекрестные ссылки g_Game, GetGame(), m_Parent и m_Projection.

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

Поля

ANIMATION_INVENTORY

const string ANIMATION_INVENTORY = "Inventory"

protected

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

ANIMATION_PLACING

const string ANIMATION_PLACING = "Placing"

protected

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

DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF

const float DEFAULT_MAX_PLACEMENT_HEIGHT_DIFF = 1.5

staticprotected

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

DISTANCE_SMALL_PROJECTION

const float DISTANCE_SMALL_PROJECTION = 1

protected

LARGE_PROJECTION_DISTANCE_LIMIT

const float LARGE_PROJECTION_DISTANCE_LIMIT = 6

protected

Deprecated.

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

LOOKING_TO_SKY

const float LOOKING_TO_SKY = 0.75

protected

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

m_AlignToTerrain

bool m_AlignToTerrain

protected

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

m_ContactComponent

int m_ContactComponent

protected

Используется в GetProjectionEntityPosition(), Hologram() и IsObjectStatic().

m_ContactDir

vector m_ContactDir

protected

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

m_DefaultOrientation

vector m_DefaultOrientation

protected

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

m_FromAdjusted

vector m_FromAdjusted

protected

Используется в GetProjectionEntityPosition(), Hologram() и SetOnGround().

m_IsColliding

bool m_IsColliding

protected

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

m_IsCollidingGPlot

bool m_IsCollidingGPlot

protected

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

m_IsCollidingPlayer

bool m_IsCollidingPlayer

protected

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

m_IsFloating

bool m_IsFloating

protected

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

m_IsHidden

bool m_IsHidden

protected

Используется в IsHidden(), SetHologramPosition() и SetIsHidden().

m_IsSlope

bool m_IsSlope

protected

m_Parent

ItemBase m_Parent

protected

Используется в CheckPowerSource(), CorrectMaterialPathName(), GetParentEntity(), Hologram(), IsFenceOrWatchtowerKit(), IsObjectStatic(), IsPlacementPermitted(), PlaceEntity(), ProjectionBasedOnParent(), UpdateHologram() и UpdateSelections().

m_Player

PlayerBase m_Player

protected

Используется в CheckPowerSource(), CreateTrigger(), EvaluateCollision(), HeightPlacementCheck(), Hologram(), IsCollidingBBox(), IsPlacementPermitted(), IsRestrictedFromAdvancedPlacing(), SetOnGround() и UpdateHologram().

m_Projection

EntityAI m_Projection

protected

Используется в AlignProjectionOnTerrain(), CorrectMaterialPathName(), EvaluateCollision(), GetHiddenSelection(), GetProjectionCollisionBox(), GetProjectionEntity(), GetProjectionEntityPosition(), GetProjectionOrientation(), GetProjectionPosition(), Hologram(), IsBaseViable(), IsClippingRoof(), IsCollidingAngle(), IsCollidingBBox(), IsInTerrain(), IsProjectionTrap(), IsUnderwater(), PlaceEntity(), RefreshVisual(), SetAnimations(), SetOnGround(), SetProjectionEntity(), SetProjectionOrientation(), SetProjectionPosition(), UpdateHologram(), UpdateSelections() и ~Hologram().

m_ProjectionTrigger

ProjectionTrigger m_ProjectionTrigger

protected

Используется в CreateTrigger(), Hologram(), RefreshTrigger() и ~Hologram().

m_ProjectionTypename

string m_ProjectionTypename

protected

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

m_Rotation

vector m_Rotation

protected

Используется в AddProjectionRotation(), GetProjectionRotation(), Hologram() и SubtractProjectionRotation().

m_SelectionsToRefresh

ref set<string> m_SelectionsToRefresh = new set<string>

protected

Используется в RefreshVisual(), SetSelectionToRefresh() и SetSelectionToRefresh().

m_SlopeTolerance

float m_SlopeTolerance

protected

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

m_UpdatePosition

bool m_UpdatePosition

protected

Используется в GetUpdatePosition(), Hologram() и SetUpdatePosition().

m_WatchtowerBlockedComponentNames

ref array<string> m_WatchtowerBlockedComponentNames = new array<string>

staticprotected

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

m_WatchtowerIgnoreComponentNames

ref array<string> m_WatchtowerIgnoreComponentNames = new array<string>

staticprotected

Используется в CorrectForWatchtower(), Hologram() и SetOnGround().

m_y_p_r_previous

vector m_y_p_r_previous

protected

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

m_YawPitchRollLimit

vector m_YawPitchRollLimit

protected

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

PLACEMENT_RC_END_OFFSET

const vector PLACEMENT_RC_END_OFFSET = "0 -2 0"

protected

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

PLACEMENT_RC_START_OFFSET

const vector PLACEMENT_RC_START_OFFSET = "0 1 0"

protected

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

PROJECTION_TRANSITION_MAX

const float PROJECTION_TRANSITION_MAX = 0.25

protected

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

PROJECTION_TRANSITION_MIN

const float PROJECTION_TRANSITION_MIN = 1

protected

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

SELECTION_INVENTORY

const string SELECTION_INVENTORY = "inventory"

protected

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

SELECTION_PLACING

const string SELECTION_PLACING = "placing"

protected

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

SMALL_PROJECTION_GROUND

const float SMALL_PROJECTION_GROUND = 2

protected

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

SMALL_PROJECTION_RADIUS

const float SMALL_PROJECTION_RADIUS = 1

protected

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

SPAWN_FLAGS

const int SPAWN_FLAGS = ECE_LOCAL

protected

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

SUFFIX_MATERIAL_DEPLOYABLE

const string SUFFIX_MATERIAL_DEPLOYABLE = "_deployable.rvmat"

protected

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

SUFFIX_MATERIAL_POWERED

const string SUFFIX_MATERIAL_POWERED = "_powered.rvmat"

protected

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

SUFFIX_MATERIAL_UNDEPLOYABLE

const string SUFFIX_MATERIAL_UNDEPLOYABLE = "_undeployable.rvmat"

protected

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

---

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

• D:/Ishodniki/scripts/4_World/Classes/Hologram.c