private (int[, ], bool[, ]) PlaceSplotch(int[,] grid, int posW, int posD, int mag)
{
Vector3 center = new Vector3(posW, 0, posD);
Vector3 position = new Vector3(0, 0, 0);
// iterate the vicinity of the splotch center
foreach ((int countW, int countD) in Itr.IterationRange(posW - mag - splotchRimWidth, posW + mag + splotchRimWidth,
posD - mag - splotchRimWidth, posD + mag + splotchRimWidth))
{
position = new Vector3(countW, 0, countD);
// if it is on the rim
if ((GetDistance(position, center) >= (float)mag) &&
((GetDistance(position, center) <= (float)mag + splotchRimWidth)))
{
if (grid[countW, countD] == 1) // if there is a block
{
grid[countW, countD] = (int)LibraryElements.Elements.RingRim;
gridLock[countW, countD] = true;
}
}
else if ((GetDistance(position, center) < mag)) // if it is inside the radius
{
grid[countW, countD] = 0;
gridLock[countW, countD] = true;
}
}
grid[posW, posD] = (int)LibraryElements.Elements.Obelisk;
return(grid, gridLock);
}
private bool CheckForOverlaps(bool[,] grid, int posW, int posD, int mag)
{
bool result = true;
Vector3 center = new Vector3(posW, 0, posD);
Vector3 position = new Vector3(0, 0, 0);
// iterate the vicinity of the splotch center
foreach ((int countW, int countD) in Itr.IterationRange(posW - mag - splotchRimWidth, posW + mag + splotchRimWidth,
posD - mag - splotchRimWidth, posD + mag + splotchRimWidth))
{
if ((GetDistance(position, center) <= mag)) // if it is inside the radius
{
if (!grid[countW, countD]) // if the position is not 0, then there is already a massive index there; so the whole checked space is unavailable
{
result = false;
break;
}
}
if (!result)
{
break;
}
}
return(result);
}
public static List <(int, int)> FindPattern(ref int[,] grid, ref bool[,] gridLock, int[,] pattern)
{
List <(int, int)> result = new List <(int, int)>();
List <(int, int)> countedPositions = new List <(int, int)>();
(int width, int depth) = Grids.Dim(grid);
int patternWidth = pattern.GetLength(0);
int patternDepth = pattern.GetLength(1);
// 1.
foreach ((int countW, int countD) in Itr.IterationRange(1, width - patternWidth, 1, depth - patternDepth))
{
if (countedPositions.Contains((countW, countD)) || gridLock[countW, countD])
{
continue;
}
// overlay at position
bool match = Overlay(grid, gridLock, pattern, countW, countD, countedPositions);
if (match)
{
MarkAsCounted(pattern, ref grid, ref gridLock, countW, countD, ref countedPositions);
result.Add((countW, countD));
}
}
return(result);
}
public static int[,] GenerateGridWithFill(int width, int depth, int fill)
{
int[,] result = new int[width, depth];
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
result[countW, countD] = fill;
}
return(result);
}
public static int[,] Copy(int[,] origin)
{
int[,] target = new int[origin.GetLength(0), origin.GetLength(1)];
foreach ((int countA, int countB) in Itr.Iteration(origin.GetLength(0), origin.GetLength(1)))
{
target[countA, countB] = origin[countA, countB];
}
return(target);
}
private Cell[,] CreateCellsGrid(int floorCellWidth, int floorCellDepth)
{
Cell[,] gridCells = new Cell[floorCellWidth, floorCellDepth];
foreach ((int countW, int countD) in Itr.Iteration(floorCellWidth, floorCellDepth))
{
gridCells[countW, countD] = new Cell(cellCols, cellRows, cellMin, cellMax, (int)LibraryElements.Elements.Basic);
}
return(gridCells);
}
/// <summary>
/// Mark position of a cell for processing
/// </summary>
/// <remarks>
/// posW, posD, object type, empty/block, poi
/// </remarks>
// private void MarkPosition(int[,] grid, int posW, int posD, int index)
// {
// grid[posW, posD] = index;
// }
private int[,] FillGrid(int[,] origin, int value)
{
int[,] target = new int[origin.GetLength(0), origin.GetLength(1)];
foreach ((int countA, int countB) in Itr.Iteration(origin.GetLength(0), origin.GetLength(1)))
{
target[countA, countB] = value;
}
return(target);
}
private int[,] RotatePattern(int[,] pattern, int angle)
{
(int width, int depth) = Grids.Dim(pattern);
int[,] rotatedPattern = Grids.Blank(pattern);
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
rotatedPattern[countD, width - countW - 1] = pattern[countW, countD];
}
return(rotatedPattern);
}
public static int[,] MarkPattern(int[,] grid, bool[,] gridLock, int posW, int posD, int[,] pattern, int index)
{
// mark the pattern on the grid
// mark all the cells of the pattern as 100 - to be avoided in the future
foreach ((int countW, int countD) in Itr.Iteration(pattern.GetLength(0), pattern.GetLength(1)))
{
grid[posW + countW, posD + countD] = 100;
}
grid[posW, posD] = index;
Debug.Log($"marked obj at {posW} / {posD}");
return(grid);
}
private int GetWeight(int[,] pattern)
{
int counter = 0;
foreach ((int countW, int countD) in Itr.Iteration(pattern.GetLength(0), pattern.GetLength(1)))
{
if (pattern[countW, countD] == 1)
{
counter++;
}
}
return(counter);
}
internal static int[,] Flatten(int[,] grid, int flat)
{
(int width, int depth) = Grids.Dim(grid);
int[,] result = new int[width, depth];
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
if (grid[countW, countD] != flat)
{
result[countW, countD] = 1;
}
else
{
result[countW, countD] = 0;
}
}
return(result);
}
public static int[,] CreateBasicGrid(int floorCellWidth, int floorCellDepth, int cellCols, int cellRows, Cell[,] gridCells)
{
int[,] gridBase = new int[floorCellWidth * cellCols, floorCellDepth *cellRows];
foreach ((int countW, int countD) in Itr.Iteration(floorCellWidth, floorCellDepth))
{
Cell currentCell = gridCells[countW, countD];
foreach ((int cellW, int cellD) in Itr.Iteration(currentCell.Width, currentCell.Depth))
{
int posW = countW * cellCols + cellW;
int posD = countD * cellRows + cellD;
int value = currentCell.Grid()[cellW, cellD];
gridBase[posW, posD] = value;
}
}
Debug.Log("Basic ON");
return(gridBase);
}
internal static int[,] AddNbrs(int[,] grid, int minCount)
{
(int width, int depth) = Grids.Dim(grid);
int[,] result = Copy(grid);
int[] pos = new int[4] {
0, 1, 0, -1
};
foreach ((int countW, int countD) in Itr.IterationRange(1, width - 1, 1, depth - 1))
{
if (result[countW, countD] == 1)
{
continue;
}
int nbrs = 0;
bool mark = false;
for (int count = 0; count < 4; count += 1)
{
int nbrW = countW + pos[(count + 3) % 4];
int nbrD = countD + pos[count];
if (grid[nbrW, nbrD] != 0)
{
nbrs++;
if (nbrs >= minCount)
{
mark = true;
break;
}
}
}
if (mark)
{
result[countW, countD] = 1;
}
}
return(result);
}
internal static int[,] ApplyMask(int[,] gridBase, int[,] gridMask, bool[,] gridLock)
{
// sanity check
if (gridBase.GetLength(0) != gridMask.GetLength(0) ||
gridBase.GetLength(1) != gridMask.GetLength(1))
{
throw new ArgumentException("Grid dimentions don't match");
}
(int width, int depth) = Grids.Dim(gridBase);
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
if (gridLock[countW, countD])
{
gridBase[countW, countD] = gridMask[countW, countD];
}
}
return(gridBase);
}
private void ColorizeGrid(int[,] grid)
{
// DBG only while WIP
// Colorize POI
// Get library and palette
Palette palette = FindObjectOfType <Palette>();
// Iterate elements grid
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
Transform obj = gridElements[countW, countD];
if (obj == null)
{
continue;
}
// gridElements[countW, countD].GetChild(0).GetComponent<MeshRenderer>().material.color = palette.palette[grid[countW, countD]];
gridElements[countW, countD].GetChild(0).GetComponent <MeshRenderer>().material.color = biomeColors[grid[countW, countD]];
}
Debug.Log("Colorize");
}
internal static int[,] ApplyMaskIndex(int[,] gridBase, bool[,] gridLock, int[,] gridMask, int indexMask, int indexBase)
{
// Applies mask to grid - translate indexMask from mask to indexBase in grid
// sanity check
if (gridBase.GetLength(0) != gridMask.GetLength(0) ||
gridBase.GetLength(1) != gridMask.GetLength(1))
{
throw new ArgumentException("Grid dimentions don't match");
}
(int width, int depth) = Grids.Dim(gridBase);
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
if (gridMask[countW, countD] == indexMask)
{
gridBase[countW, countD] = indexBase;
gridLock[countW, countD] = true;
}
}
return(gridBase);
}
private void MaterializeFloor(int[,] grid)
{
// clear all previously created objects
foreach (Transform obj in mapHolder)
{
Destroy(obj.gameObject);
}
(int width, int depth) = Grids.Dim(finalGrid);
gridFloor = new Transform[width, depth];
gridElements = new Transform[width, depth];
// Get Biome Index
// place floor everywhere
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
int biomeIndex = gridBiomes[countW, countD];
Transform floor = library.GetElement(biomeIndex, 0);
gridElements[countW, countD] = Instantiate(floor, new Vector3(countW, 0, countD), Quaternion.identity, floorHolder);
// gridFloor[countW, countD] = Instantiate(floor, new Vector3(countW, 0, countD), Quaternion.identity, floorHolder);
}
// Iterate finalGrid
// if 0 - skip
// if not -- place an object
// HERE
foreach ((int countW, int countD) in Itr.Iteration(width, depth))
{
Transform obj;
if (grid[countW, countD] == 0)
{
continue;
}
// if (grid[countW, countD] != 0)
// {
// Debug.Log($"obj at: {countW}/{countD} -- {grid[countW, countD]}");
// }
// DBG Trying with the collection
// obj = mapElements[grid[countW, countD]];
int biomeIndex = gridBiomes[countW, countD];
int elementIndex = grid[countW, countD];
obj = library.GetElement(biomeIndex, elementIndex);
// obj = library.elementPool[elementIndex].prefab; // FIXME
int positionX = countW;
int positionY = countD;
Quaternion rotation = Quaternion.identity;
Vector3 position = new Vector3(positionX, 0, positionY);
// position = new Vector3(positionX + 0.5f, 0, positionY + 0.5f);
// obj.GetChild(0).transform.rotation = Quaternion.Euler(0, Random.Range(0.0f, 360.0f), 0);
gridElements[positionX, positionY] = Instantiate(obj, position, rotation);
gridElements[positionX, positionY].parent = mapHolder;
}
Debug.Log("Materialize");
}
public void CreateSpawns(int[,] grid, float maxPointDeviation)
{
// Select an available point for starting the flood
Vector3 floodPoint = ScoutAround(grid, new Vector3(grid.GetLength(0) / 2, 0, grid.GetLength(1) / 2));
// Floodfill the plane
List <Vector3> floodPlane = FloodThePlane(grid, floodPoint);
// TODO - check if we flooded at least half the plane
int planeSize = grid.GetLength(0) * grid.GetLength(1);
if (floodPlane.Count < planeSize / 2)
{
// Debug.Log($"Flooded only {floodPlane.Count} out of {planeSize} cells");
return;
}
int[,] floodGrid = new int[grid.GetLength(0), grid.GetLength(1)];
// The grid needs to be reversed
foreach ((int cols, int rows) in Itr.Iteration(grid.GetLength(0), grid.GetLength(1)))
{
floodGrid[cols, rows] = 1;
}
// Get the list into a grid
foreach (Vector3 point in floodPlane)
{
floodGrid[(int)point.x, (int)point.z] = 0;
}
// Select random starting poins
Vector3 leftSeedPoint = new Vector3(floodGrid.GetLength(0) / 4, 0, floodGrid.GetLength(1) / 2);
Vector3 rightSeedPoint = new Vector3(floodGrid.GetLength(0) / 2, 0, floodGrid.GetLength(1) / 4) * 3;
Vector3 deviationLeft = Random.insideUnitCircle.normalized;
Vector3 deviationRight = Random.insideUnitCircle.normalized;
Vector3 randomLeftNormal = new Vector3(deviationLeft.x, 0, deviationLeft.z);
Vector3 randomRightNormal = new Vector3(deviationRight.z, 0, deviationRight.z);
float randomLeftMagnitude = Random.Range(0, maxPointDeviation * floodGrid.GetLength(1));
float randomRightMagnitude = Random.Range(0, maxPointDeviation * floodGrid.GetLength(1));
Vector3 randomLeft = randomLeftNormal * randomLeftMagnitude;
Vector3 randomRight = randomRightNormal * randomRightMagnitude;
leftSeedPoint = ScoutAround(floodGrid, leftSeedPoint + new Vector3(randomLeft.x, 0, randomLeft.z));
rightSeedPoint = ScoutAround(floodGrid, rightSeedPoint + new Vector3(randomRight.x, 0, randomRight.z));
// Select a random point for left start
// Debug.Log($"left: {leftSeedPoint}");
// Debug.Log($"right: {rightSeedpoint}");
// Place markers
// Transform start = Instantiate(playerOne, leftSeedPoint, Quaternion.identity);
playerOne.transform.position = leftSeedPoint;
playerOne.gameObject.SetActive(true);
//start.parent = spawnPoints;
// Transform end = Instantiate(playerTwo, rightSeedpoint, Quaternion.identity);
playerTwo.transform.position = rightSeedPoint;
playerTwo.gameObject.SetActive(true);
//end.parent = spawnPoints;
Debug.Log($"SeedPoint One at: {leftSeedPoint}");
Debug.Log($"SeedPoint One at: {rightSeedPoint}");
Debug.Log($"Player One at: {playerOne.transform.position.x} / {playerOne.transform.position.z}");
Debug.Log($"Player Two at: {playerTwo.transform.position.x} / {playerTwo.transform.position.z}");
// TODO include a check for same position
// if the position of the players is the same - there are no 2 different viable starting positions - restart the whole map
}
