public IGridPosition[,] Populate()
{
var grid = new IGridPosition[_gameSettings.GridSettings.Horizontal, _gameSettings.GridSettings.Vertical];
for (var i = 0; i < _gameSettings.GridSettings.Horizontal; i++)
{
for (var j = 0; j < _gameSettings.GridSettings.Vertical; j++)
{
var gem = _gameSettings.GetRandomGem(_container);
gem.SetPosition(i, j);
grid[i, j] = gem;
}
}
grid = ReplaceMatches(grid);
var hasMove = CheckAvailableGame(grid);
if (!hasMove)
{
Clear(grid);
return(Populate());
}
return(grid);
}
private IGridPosition[,] GetNoSequenceGrid()
{
var grid = new IGridPosition[4, 4];
grid[0, 0] = new GridTestElement(0, 0, 1);
grid[1, 0] = new GridTestElement(1, 0, 2);
grid[2, 0] = new GridTestElement(2, 0, 3);
grid[3, 0] = new GridTestElement(3, 0, 4);
grid[0, 1] = new GridTestElement(0, 1, 4);
grid[1, 1] = new GridTestElement(1, 1, 3);
grid[2, 1] = new GridTestElement(2, 1, 2);
grid[3, 1] = new GridTestElement(3, 1, 1);
grid[0, 2] = new GridTestElement(0, 2, 1);
grid[1, 2] = new GridTestElement(1, 2, 2);
grid[2, 2] = new GridTestElement(2, 2, 3);
grid[3, 2] = new GridTestElement(3, 2, 4);
grid[0, 3] = new GridTestElement(0, 3, 1);
grid[1, 3] = new GridTestElement(1, 3, 2);
grid[2, 3] = new GridTestElement(2, 3, 3);
grid[3, 3] = new GridTestElement(3, 3, 1);
return(grid);
}
public bool CheckAvailableGame(IGridPosition[,] grid)
{
var result = _sequenceChecker.CheckForNextMove(grid, out var element);
_nextMoveElement = element;
return(result);
}
private List <IGridPosition> CheckHorizontal(IGridPosition[,] grid, IGridPosition element)
{
foreach (var gridPosition in grid)
{
if (gridPosition == null)
{
return(new List <IGridPosition>());
}
}
var id = element.Id;
var list = new List <IGridPosition>();
var validList = new List <IGridPosition>();
for (var i = 0; i < grid.GetLength(0); i++)
{
var value = grid[i, element.Y];
if (value.Id == id)
{
list.Add(value);
if (list.Count >= _streakCount)
{
validList = list.ToList();
}
}
else
{
list.Clear();
}
}
return(validList);
}
public GridPositionSnapshot(IGridPosition gridElement)
{
Position = gridElement.Transform.position;
EulerAngles = gridElement.Transform.eulerAngles;
X = gridElement.X;
Y = gridElement.Y;
}
/// <summary>
/// Updates the display object, effectively moving the visual display of the drone with the current id
/// </summary>
/// <param name="droneId"></param>
/// <param name="currentPosition"></param>
public void UpdateDroneWithNewPosition(int droneId, IGridPosition currentPosition)
{
var droneWithPosition = _drones.Query(droneId);
droneWithPosition.Current.Reset();
var displayObject = Communicaiton.Instance.GetDisplayObjectAt(currentPosition.X, currentPosition.Y);
displayObject.AsDrone();
droneWithPosition.Current = displayObject;
}
public ICell GetCell(IGridPosition gridPosition)
{
if (gridPosition == null) throw new ArgumentNullException("gridPosition");
if (!IsValidGridPosition(gridPosition)) throw new ArgumentOutOfRangeException("gridPosition");
var isCellAlive = IsCellAlive(gridPosition);
//int getNumberOfAdjacentCells = GetNumberOfAdjacentCells(gridPosition);
var cell = new Cell(new Position(gridPosition.Row, gridPosition.Column), isCellAlive);
//cell.Neighbours = getNumberOfAdjacentCells;
return cell;
}
public IGridPosition[,] UpdateGrid(IGridPosition[,] grid)
{
var newGrid = new IGridPosition[grid.GetLength(0), grid.GetLength(1)];
foreach (var gem in grid)
{
newGrid[gem.X, gem.Y] = gem;
}
return(newGrid);
}
private List <IGridPosition> CheckVertical(IGridPosition[,] grid, int line, int streakCount = 0)
{
foreach (var gridPosition in grid)
{
if (gridPosition == null)
{
return(new List <IGridPosition>());
}
}
if (streakCount == 0)
{
streakCount = _streakCount;
}
IGridPosition lastValue = null;
var list = new List <IGridPosition>();
var validList = new List <IGridPosition>();
for (var i = 0; i < grid.GetLength(1); i++)
{
var value = grid[line, i];
if (lastValue == null)
{
AddValue(value);
continue;
}
if (value.Id == lastValue.Id)
{
AddValue(value);
if (list.Count >= streakCount)
{
validList = list.ToList();
}
}
else
{
list.Clear();
AddValue(value);
}
}
return(validList);
void AddValue(IGridPosition value)
{
list.Add(value);
lastValue = value;
}
}
/// <summary>
/// Get a path list from one position to another
/// </summary>
/// <param name="currentX"></param>
/// <param name="currentY"></param>
/// <param name="targetX"></param>
/// <param name="targetY"></param>
/// <returns></returns>
public IGridPosition[] GetPath(int currentX, int currentY, int targetX, int targetY)
{
// This is the issue with external libraries not using interfaces
var positionList = _grid.GetPath(new Position(currentX, currentY),
new Position(targetX, targetY), MovementPatterns.Full);
var wantedList = new IGridPosition[positionList.Length];
for (var i = 0; i < positionList.Length; i++)
{
wantedList[i] = new GridPosition(positionList[i].X, positionList[i].Y);
}
return(wantedList);
}
public SequenceType IsMovementValid(IGridPosition[,] grid, IGridPosition first, IGridPosition second, out List <IGridPosition> elementsList)
{
var firstValid = CheckForSequence(grid, first, out var firstList);
var secondValid = CheckForSequence(grid, second, out var secondList);
if (firstValid != SequenceType.None)
{
elementsList = firstList;
return(firstValid);
}
if (secondValid != SequenceType.None)
{
elementsList = secondList;
return(secondValid);
}
elementsList = null;
return(SequenceType.None);
}
public SequenceType CheckForSequence(IGridPosition[,] grid, IGridPosition element, out List <IGridPosition> sequenceList)
{
//since 1 element can't trigger horizontal and vertical at same time,
//I decided to give preference to horizontal.
var horizontal = CheckHorizontal(grid, element);
if (horizontal.Count >= _streakCount)
{
sequenceList = horizontal;
return(SequenceType.Horizontal);
}
var vertical = CheckVertical(grid, element);
if (vertical.Count >= _streakCount)
{
sequenceList = vertical;
return(SequenceType.Vertical);
}
sequenceList = null;
return(SequenceType.None);
}
//this is not efficient but I couldn't find the deterministic algorithm.
public bool CheckForNextMove(IGridPosition[,] grid, out IGridPosition availableElement)
{
//check horizontal require column length
for (var i = 0; i < grid.GetLength(1); i++)
{
var h = CheckHorizontal(grid, i, 2);
for (var j = 0; j < h.Count; j++)
{
var gridItem = h[j];
var neighbors = grid.GetDiagonalNeighbors(gridItem.X, gridItem.Y);
IGridPosition first;
IGridPosition second;
IGridPosition sameLine;
//if first, we want left diagonals
if (j == 0)
{
first = neighbors[0];
second = neighbors[1];
sameLine = grid.SafeGetAt(gridItem.X - 2, gridItem.Y);
}
//if second, we want right diagonals
else
{
first = neighbors[2];
second = neighbors[3];
sameLine = grid.SafeGetAt(gridItem.X + 2, gridItem.Y);
}
if (first != null && !h.Contains(first) && first.Id == gridItem.Id)
{
Debug.Log($"Available game at: X:{gridItem.X} Y: {gridItem.Y} in up!");
availableElement = first;
return(true);
}
if (second != null && !h.Contains(second) && second.Id == gridItem.Id)
{
Debug.Log($"Available game at: X:{gridItem.X} Y: {gridItem.Y} in down!");
availableElement = second;
return(true);
}
if (sameLine != null && !h.Contains(sameLine) && sameLine.Id == gridItem.Id)
{
Debug.Log($"Available game at: X:{gridItem.X} Y: {gridItem.Y} in same line!");
availableElement = sameLine;
return(true);
}
}
}
//check vertical require line length
for (var i = 0; i < grid.GetLength(0); i++)
{
var h = CheckVertical(grid, i, 2);
for (var j = 0; j < h.Count; j++)
{
var gridItem = h[j];
var neighbors = grid.GetDiagonalNeighbors(gridItem.X, gridItem.Y);
IGridPosition first;
IGridPosition second;
IGridPosition sameColumn;
//if first, we want down diagonals
if (j == 0)
{
first = neighbors[1];
second = neighbors[3];
sameColumn = grid.SafeGetAt(gridItem.X, gridItem.Y - 2);
}
//if second, we want up diagonals
else
{
first = neighbors[0];
second = neighbors[2];
sameColumn = grid.SafeGetAt(gridItem.X, gridItem.Y + 2);
}
if (first != null && !h.Contains(first) && first.Id == gridItem.Id)
{
Debug.Log($"Available game at: X:{gridItem.X} Y:{gridItem.Y} in left!");
availableElement = first;
return(true);
}
if (second != null && !h.Contains(second) && second.Id == gridItem.Id)
{
Debug.Log($"Available game at: X:{gridItem.X} Y:{gridItem.Y} in right!");
availableElement = second;
return(true);
}
if (sameColumn != null && !h.Contains(sameColumn) && sameColumn.Id == gridItem.Id)
{
Debug.Log($"Available game at: X:{gridItem.X} Y: {gridItem.Y} in same line!");
availableElement = sameColumn;
return(true);
}
}
}
Debug.Log("No available game!");
availableElement = null;
return(false);
}
private bool IsValidGridPosition(IGridPosition gridPosition)
{
return (gridPosition.Column < _gridSize.Columns && gridPosition.Row < _gridSize.Rows);
}
public void SetCell(IGridPosition gridPosition, bool alive)
{
if (gridPosition == null) throw new ArgumentNullException("gridPosition");
if (!IsValidGridPosition(gridPosition)) throw new ArgumentOutOfRangeException("gridPosition");
_gridDataContainer[gridPosition.Row, gridPosition.Column] = alive;
}
/// <summary>
/// Gets a path list a drone can use from the current position back to this port
/// </summary>
/// <param name="currentDronePosition"></param>
/// <returns></returns>
public IGridPosition[] GetPathToPort(IGridPosition currentDronePosition)
{
return(Map.GetPath(currentDronePosition.X, currentDronePosition.Y, PositionX, PositionY));
}
/// <summary>
/// Gets the path from one location back to the reference port
/// </summary>
/// <param name="currentDronePosition"></param>
/// <returns></returns>
public IGridPosition[] GetPathToPort(IGridPosition currentDronePosition)
{
return(_currentPort.GetPathToPort(currentDronePosition));
}
/// <summary>
/// Updates the port with the new drone position
/// </summary>
/// <param name="droneId"></param>
/// <param name="currentPosition"></param>
public void UpdatePortWithNewPosition(int droneId, IGridPosition currentPosition)
{
_currentPort.UpdateDroneWithNewPosition(droneId, currentPosition);
}
public static GridPositionSnapshot GetSnapshot(this IGridPosition gridPosition) => new GridPositionSnapshot(gridPosition);
public bool IsCellAlive(IGridPosition gridPosition)
{
if (gridPosition == null) throw new ArgumentNullException("gridPosition");
if (!IsValidGridPosition(gridPosition)) throw new ArgumentOutOfRangeException("gridPosition");
return _gridDataContainer[gridPosition.Row, gridPosition.Column];
}
