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 = g_Game.ConfigGetFloat(string.Format(GRID_SIZE_CFG_PATH, g_Game.GetWorldName()));
		int gridX, gridZ;
		g_Game.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] > g_Game.GetWorld().GetWorldSize() || worldPos[2] < 0 || worldPos[2] > g_Game.GetWorld().GetWorldSize())
		{
			return true;
		}
		
		return false;
	}
}