Закрытые члены
void	Initialize ()

bool	ValidatePlayerRestrictedAreaPositions ()

bool	TranslateSafePositions ()

bool	IsValid ()

vector	GetCenterPos2D ()

vector	GetClosestSafePos3D (vector targetPos)

vector	GetRandomSafePos3D (vector targetPos)

Закрытые данные
bool	m_IsValid = false

int	m_LastUsedSafePosIdx = -1

ref array< vector >	m_TranslatedSafePositions3D

ref array< vector >	m_RandomizedSafePositions3D

vector	m_CenterPos2D

string	areaName = ""

ref array< ref array< ref array< float > > >	PRABoxes = new array<ref array<ref array<float>>>

ref array< ref array< ref array< float > > >	PRAPolygons = new array<ref array<ref array<float>>>
	3D, not used directly!

ref array< ref array< float > >	safePositions2D = new array<ref array<float>>

ref array< ref array< float > >	safePositions3D = new array<ref array<float>>

ref array< ref PRAShapeBoxData >	m_PRABoxDataTranslated = new array<ref PRAShapeBoxData>

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

Методы

◆ GetCenterPos2D()

vector GetCenterPos2D ( )

inlineprivate

    {
        return m_CenterPos2D;
    }

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

◆ GetClosestSafePos3D()

vector GetClosestSafePos3D ( vector targetPos )

inlineprivate

    {
        vector closestPos = targetPos;
        float smallestDist = float.MAX;
        float dist;
        
        foreach (vector pos : m_TranslatedSafePositions3D)
        {
            dist = vector.DistanceSq(targetPos, pos);
            if (dist < smallestDist)
            {
                smallestDist = dist;
                closestPos = pos;
            }
        }
        return closestPos;
    }

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

◆ GetRandomSafePos3D()

vector GetRandomSafePos3D ( vector targetPos )

inlineprivate

    {
        if (!m_RandomizedSafePositions3D || m_RandomizedSafePositions3D.Count() == 0)
        {
            m_RandomizedSafePositions3D = new array<vector>;
            m_RandomizedSafePositions3D.Copy(m_TranslatedSafePositions3D);
            m_LastUsedSafePosIdx = -1;
        }
        
        int count = m_RandomizedSafePositions3D.Count();
        m_LastUsedSafePosIdx++;
        
        if (m_LastUsedSafePosIdx == count)
        {
            m_RandomizedSafePositions3D.ShuffleArray();
            m_LastUsedSafePosIdx = 0;
        }
        
        return m_RandomizedSafePositions3D[m_LastUsedSafePosIdx];
    }

Перекрестные ссылки m_LastUsedSafePosIdx, m_RandomizedSafePositions3D и m_TranslatedSafePositions3D.

◆ Initialize()

void Initialize ( )

inlineprivate

    {
        if (m_IsValid)
            return;
        
        m_IsValid = false;
        m_IsValid |= ValidatePlayerRestrictedAreaPositions();
        m_IsValid |= TranslateSafePositions();
    }

Перекрестные ссылки m_IsValid, TranslateSafePositions() и ValidatePlayerRestrictedAreaPositions().

◆ IsValid()

bool IsValid ( )

inlineprivate

    {
        return m_IsValid;
    }

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

◆ TranslateSafePositions()

bool TranslateSafePositions ( )

inlineprivate

    {
        if (safePositions2D.Count() == 0 && safePositions3D.Count() == 0)
        {
            Debug.Log("Undefined safe positions for area: " + areaName,"n/a","n/a","","PlayerRestrictedAreaInstance");
            return false;
        }
        
        m_TranslatedSafePositions3D = new array<vector>;
        
        foreach (array<float> arr2d : safePositions2D)
        {
            m_TranslatedSafePositions3D.Insert(Vector(arr2d[0],GetGame().SurfaceY(arr2d[0],arr2d[1]),arr2d[1]));
        }
        
        foreach (array<float> arr3d : safePositions3D)
        {
            m_TranslatedSafePositions3D.Insert(Vector(arr3d[0],arr3d[1],arr3d[2]));
        }
        
        return true;
    }

Перекрестные ссылки areaName, GetGame(), Debug::Log(), m_TranslatedSafePositions3D, safePositions2D, safePositions3D и Vector().

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

◆ ValidatePlayerRestrictedAreaPositions()

bool ValidatePlayerRestrictedAreaPositions ( )

inlineprivate

    {
        if (PRABoxes.Count() == 0 && PRAPolygons.Count() == 0)
        {
            Debug.Log("No valid coordinates in 'PRABoxes' or 'PRAPolygons' for area: " + areaName,"n/a","n/a","","PlayerRestrictedAreaInstance");
            return false;
        }
        
        float xMin,zMin = float.MAX;
        float xMax,zMax = float.MIN;
        
        foreach (array<ref array<float>> boxFloatsData : PRABoxes)
        {
            if (boxFloatsData.Count() != 3)
            {
                Debug.Log("Invalid box defined in " + areaName + ". Box needs to have sizes, rotation, and position defined!","n/a","n/a","","PlayerRestrictedAreaInstance");
                return false;
            }
            
            array<float> boxVectors;
            //sizes
            boxVectors = boxFloatsData[0];
            if (boxVectors.Count() != 3)
            {
                Debug.Log("Invalid box defined in " + areaName + ". Box size needs to be in an XYZ format!","n/a","n/a","","PlayerRestrictedAreaInstance");
                return false;
            }
            
            //rotation
            boxVectors = boxFloatsData[1];
            if (boxVectors.Count() != 3)
            {
                Debug.Log("Invalid box defined in " + areaName + ". Box rotation needs to be in an XYZ format!","n/a","n/a","","PlayerRestrictedAreaInstance");
                return false;
            }
            
            //position
            boxVectors = boxFloatsData[2];
            if (boxVectors.Count() != 3)
            {
                Debug.Log("Invalid box defined in " + areaName + ". Box position needs to be in an XYZ format!","n/a","n/a","","PlayerRestrictedAreaInstance");
                return false;
            }
            
            //translate to data
            PRAShapeBoxData dta = new PRAShapeBoxData(boxFloatsData);
            if (dta)
            {
                m_PRABoxDataTranslated.Insert(dta);
                
                xMin = Math.Min(xMin,dta.m_Mins[0]);
                zMin = Math.Min(zMin,dta.m_Mins[2]);
                xMax = Math.Max(xMax,dta.m_Maxs[0]);
                zMax = Math.Max(zMax,dta.m_Maxs[2]);
            }
        }
        
        foreach (array<ref array<float>> polygonData : PRAPolygons)
        {
            if (polygonData.Count() < 3)
            {
                Debug.Log("Invalid polygon defined in " + areaName + ". At least 3 points necessary!","n/a","n/a","","PlayerRestrictedAreaInstance");
                return false;
            }
            
            foreach (array<float> polygonCoords : polygonData)
            {
                if (polygonCoords.Count() != 2)
                {
                    Debug.Log("Invalid polygon defined in " + areaName + ". Polygon coordinates need to be in a XZ format!","n/a","n/a","","PlayerRestrictedAreaInstance");
                    return false;
                }
                
                xMin = Math.Min(xMin,polygonCoords[0]);
                zMin = Math.Min(zMin,polygonCoords[1]);
                xMax = Math.Max(xMax,polygonCoords[0]);
                zMax = Math.Max(zMax,polygonCoords[1]);
            }
        }
        
        m_CenterPos2D = Vector(((xMin + xMax) / 2), 0, ((zMin + zMax) / 2));
        
        return true;
    }