MapNavigationBehaviour.c

См. документацию.

enum EMapNavigationType
{
    BASIC  = 0,
    COMPASS  = 1,
    GPS  = 2,
    ALL      = 4
}
 
class MapNavigationBehaviour
{
    const int RANDOM_DEVIATION_MIN                      = 4;
    const int RANDOM_DEVIATION_MAX                      = 15;
    
    static const int DISPLAY_GRID_POS_MAX_CHARS_COUNT   = 3;
    static const int DISPLAY_ALT_MAX_CHARS_COUNT         = 4;
    
    protected static const string GRID_SIZE_CFG_PATH  = "CfgWorlds %1 Grid Zoom1 stepX";
 
    protected int                   m_RandomPositionDeviationX;
    protected int                   m_RandomPositionDeviationZ;
    protected EMapNavigationType  m_NavigationType;
    protected PlayerBase          m_Player;
    
    protected ref array<EntityAI>    m_GPSInPossessionArr;
    protected ref array<EntityAI>    m_CompassInPossessionArr;
    
    void MapNavigationBehaviour(PlayerBase pPlayer, EMapNavigationType pNavigationType = EMapNavigationType.BASIC)
    {
        m_Player                    = pPlayer;
        m_NavigationType            = pNavigationType;
        
        m_GPSInPossessionArr        = new array<EntityAI>();
        m_CompassInPossessionArr    = new array<EntityAI>();
    }
    
    protected void SetNavigationType(EMapNavigationType pType)
    {
        m_NavigationType = m_NavigationType | pType;
    }
    
    protected void UnsetNavigationType(EMapNavigationType pType)
    {
        m_NavigationType = m_NavigationType & ~pType;
    }
 
    EMapNavigationType GetNavigationType()
    {
        return m_NavigationType;
    }
    
    void OnItemInPlayerPossession(EntityAI item)
    {
        if (item.IsInherited(ItemGPS))
        {
            if (m_GPSInPossessionArr.Find(item) == INDEX_NOT_FOUND)
            {
                m_GPSInPossessionArr.Insert(item);
                SetNavigationType(EMapNavigationType.GPS);
            }
        }
        
        if (item.IsInherited(ItemCompass))
        {
            if (m_CompassInPossessionArr.Find(item) == INDEX_NOT_FOUND)
            {
                m_CompassInPossessionArr.Insert(item);
                SetNavigationType(EMapNavigationType.COMPASS);
            }
        }
    }
    
    void OnItemNotInPlayerPossession(EntityAI item)
    {
        if (item.IsInherited(ItemGPS))
        {
            m_GPSInPossessionArr.RemoveItem(item);
            if (m_GPSInPossessionArr.Count() == 0)
            {
                UnsetNavigationType(EMapNavigationType.GPS);
            }
        }
        
        if (item.IsInherited(ItemCompass))
        {
            m_CompassInPossessionArr.RemoveItem(item);
            if (m_CompassInPossessionArr.Count() == 0)
            {
                UnsetNavigationType(EMapNavigationType.COMPASS);
            }
        }
    }
    
    void RandomizePosition()
    {
        m_RandomPositionDeviationX    = RandomizedDeviation();
        m_RandomPositionDeviationZ    = RandomizedDeviation();
    }
    
    protected float RandomizedDeviation()
    {
        Math.Randomize(GetWorldTime() + Math.RandomIntInclusive(2, 4096));
        if ((Math.RandomIntInclusive(0, 10) % 2) == 0)
        {
            return Math.RandomIntInclusive(-RANDOM_DEVIATION_MAX, -RANDOM_DEVIATION_MIN);
        }
        else
        {
            return Math.RandomIntInclusive(RANDOM_DEVIATION_MIN, RANDOM_DEVIATION_MAX);
        }
    }
    
    vector GetPositionRandomized()
    {
        vector realPosition = m_Player.GetPosition();
        vector randomizedPosition = Vector(realPosition[0] + m_RandomPositionDeviationX, realPosition[1], realPosition[2] + m_RandomPositionDeviationZ);
 
        return randomizedPosition;
    }
    
    vector GetPositionReal()
    {
        return m_Player.GetPosition();
    }
    
    static array<int> OrderedPositionNumbersFromGridCoords(EntityAI pEntity)
    {
        float gridSize = GetGame().ConfigGetFloat(string.Format(GRID_SIZE_CFG_PATH, GetGame().GetWorldName()));
        int gridX, gridZ;
        GetGame().GetWorld().GetGridCoords(pEntity.GetPosition(), gridSize, gridX, gridZ);
        
        gridX = Math.AbsInt(gridX);
        gridZ = Math.AbsInt(gridZ);
        
        array<int> positions  = new array<int>();
        string gridXStr         = gridX.ToStringLen(DISPLAY_GRID_POS_MAX_CHARS_COUNT);
        string gridZStr         = gridZ.ToStringLen(DISPLAY_GRID_POS_MAX_CHARS_COUNT);
        
        int i = 0;
        int gridCoordNumber;
        for (i = 0; i < gridXStr.Length(); ++i)
        {
            gridCoordNumber = gridXStr.Get(i).ToInt();
            if (IsOutOfMap(pEntity))
            {
                gridCoordNumber = -1;
            }
 
            positions.Insert(gridCoordNumber);
        }
 
        for (i = 0; i < gridZStr.Length(); ++i)
        {
            gridCoordNumber = gridZStr.Get(i).ToInt();
            if (IsOutOfMap(pEntity))
            {
                gridCoordNumber = -1;
            }
 
            positions.Insert(gridCoordNumber);
        }
        
        return positions;
    }
    
    static array<int> OrderedAltitudeNumbersPosition(EntityAI pEntity)
    {
        array<int> altArray = new array<int>();
        float altF          = pEntity.GetPosition()[1];
        int altI            = Math.Round(altF); 
        string altString    = altI.ToStringLen(DISPLAY_ALT_MAX_CHARS_COUNT);
        
        for (int i = 0; i < altString.Length(); ++i)
        {
            altArray.Insert(altString.Get(i).ToInt());
        }
        
        return altArray;
    }
    
    static bool IsOutOfMap(EntityAI pEntity)
    {
        vector worldPos = pEntity.GetPosition();
 
        if (worldPos[0] < 0 || worldPos[0] > GetGame().GetWorld().GetWorldSize() || worldPos[2] < 0 || worldPos[2] > GetGame().GetWorld().GetWorldSize())
        {
            return true;
        }
        
        return false;
    }
}