public virtual Cell GetCell(Vector2Int terrainPos, bool isForMap = false)
{
Cell cell = null;
Chunk chunk = GetChunk(terrainPos);
// Check ChunksForMap
if (chunk == null && isForMap)
{
Vector2Int chunkPos = TerrainPosToChunk(terrainPos);
ChunksForMap.TryGetValue(chunkPos, out chunk);
}
// Get cell from the chunk if it exists
if (chunk != null)
{
Vector2Int posInChunk = new Vector2Int(LC_Math.Mod(terrainPos.x, ChunkSize),
LC_Math.Mod(terrainPos.y, ChunkSize));
cell = chunk.Cells[posInChunk.x, posInChunk.y];
}
return(cell);
}
/// <summary>
/// <para>Calculates a pseudo-random direction based on lastDirection and a random value.</para>
/// <para>If the random value is greater than sameDirectionProbability it will compute a diferent direction.</para>
/// <para>For that, it will test alternate directions trying to minimize the turn from the lastDirection.</para>
/// <para>If no direction is possible, returns Vector2Int.zero.</para>
/// </summary>
/// <param name="origin">Original position.</param>
/// <param name="lastDirection">Last direction. Must be a normalized vector.</param>
/// <param name="randGenerator">Random generator for the direction.</param>
/// <param name="sameDirectionProbability">Probability of conserve the lastDirection.</param>
/// <param name="isPositionAccessible">>Method to check if a position is accessible.</param>
/// <returns>The new direction or, if no one is possible, Vector2Int.zero.</returns>
public static Vector2Int PseudorandomDirection(Vector2Int origin, Vector2Int lastDirection, System.Random randGenerator, float sameDirectionProbability, IsPositionAccessible isPositionAccessible)
{
Vector2Int nextDirection = Vector2Int.zero;
lastDirection = lastDirection.TransformToDirection();
float sameDirectionProb = Mathf.Clamp(sameDirectionProbability, 0, 100);
bool useSameDirection = RandomDouble(randGenerator, 0, 100) <= sameDirectionProb;
// If is possible continue in the same direction ( not 0,0 )
if (useSameDirection && !lastDirection.Equals(Vector2Int.zero) && IsPossibleDirection(origin, lastDirection, isPositionAccessible))
{
nextDirection = lastDirection;
}
// Search a new random direction different of last
else
{
int lastDirectionIdx = EightDirections2D.IndexOf(lastDirection);
// If any previous direction is possible, assign one random
if (lastDirectionIdx == -1)
{
lastDirectionIdx = randGenerator.Next(0, EightDirections2D.Count);
}
// Check the possible directions incrementing the offset relative to lastDirection
int idx;
bool turnRight;
Vector2Int possibleDirection;
for (int offset = 1; offset < EightDirections2D.Count / 2 && nextDirection == Vector2Int.zero; offset++)
{
turnRight = randGenerator.Next(0, 2) == 0;
idx = LC_Math.Mod(lastDirectionIdx + (turnRight ? offset : -offset), EightDirections2D.Count);
possibleDirection = EightDirections2D[idx];
if (IsPossibleDirection(origin, possibleDirection, isPositionAccessible))
{
nextDirection = possibleDirection;
}
else
{
idx = LC_Math.Mod(lastDirectionIdx + (!turnRight ? offset : -offset), EightDirections2D.Count);
possibleDirection = EightDirections2D[idx];
if (IsPossibleDirection(origin, possibleDirection, isPositionAccessible))
{
nextDirection = possibleDirection;
}
}
}
// If any other direction isn't possible, check the opposite of last direction
if (nextDirection == Vector2Int.zero)
{
possibleDirection = lastDirection * -1;
if (IsPossibleDirection(origin, possibleDirection, isPositionAccessible))
{
nextDirection = possibleDirection;
}
}
}
return(nextDirection);
}
