public void ConstructorTest() { Cell cell = new Cell(new Location(23, 34)); Assert.AreEqual(23, cell.X); Assert.AreEqual(34, cell.Y); Assert.AreEqual(Occupied.Empty, cell.IsOccupied); }
public void CopyConstructorTest() { Cell cell = new Cell(new Location(0, 0)); Cell newCell = new Cell(cell); Assert.AreEqual(cell.X, newCell.X); Assert.AreEqual(cell.Y, newCell.Y); Assert.AreEqual(cell.IsOccupied, newCell.IsOccupied); }
public void IsOccupiedYTest() { Cell cell = new Cell(new Location(0, 0)); cell.IsOccupied = Occupied.PlayerY; bool returnValue = cell.IsEmpty(); Assert.IsFalse(returnValue); returnValue = cell.IsPlayer(true); Assert.IsFalse(returnValue); returnValue = cell.IsPlayer(false); Assert.IsTrue(returnValue); }
/// <summary> /// number of steps needed to reach a cell is the min of the steps /// needed to reach a neighbour, plus one (unles it's filled) /// </summary> /// <param name="cell">the cell to update</param> /// <returns>true if work was done</returns> private bool UpdateCellFromNeighbour(Cell cell) { var neighbours = board.Neighbours(cell); int closest = this.MinVal(neighbours); if (cell.IsEmpty() && closest < PathLengthConstants.OffPath) { closest++; } if (closest < Value(cell.Location)) { this.SetValByLoc(cell.Location, closest); return true; } return false; }
public CellEventArgs(Cell cell) { this.cell = cell; }
private bool IsInLastRow(Cell cell) { if (playerX) { return cell.Y == (board.Size - 1); } return cell.X == (this.board.Size - 1); }
private void AddInProgressCell(Cell cell, int value) { // is this cell in progress already? int existingIndex = this.inProgressCells.IndexOf(cell); if (existingIndex > -1) { if (value >= this.inProgressCellDistances[existingIndex]) { // we've found another route to a cell already in progress // but it's not shorter, so it's of no interest return; } // a new and shorter route to an in-progress cell // remove it from it from its current position // and add it at the new position as below this.inProgressCells.RemoveAt(existingIndex); this.inProgressCellDistances.RemoveAt(existingIndex); } // add the cell, in the right sorted position bool added = false; int loopMax = this.inProgressCells.Count; // does not vary during loop for (int loopIndex = 0; loopIndex < loopMax; loopIndex++) { if (value < this.inProgressCellDistances[loopIndex]) { this.inProgressCells.Insert(loopIndex, cell); this.inProgressCellDistances.Insert(loopIndex, value); added = true; break; } } if (!added) { // put it on the end this.inProgressCells.Add(cell); this.inProgressCellDistances.Add(value); } vals[cell.X, cell.Y] = value; }
/// <summary> /// get the start (or end) row for player 1 (or 2) /// </summary> /// <param name="playerX">is the player queried player X</param> /// <param name="start">start row or end row</param> /// <returns>the cells in the row</returns> public Cell[] Row(bool playerX, bool start) { Cell[] result = new Cell[this.Size]; // first or last row/col int col = start ? 0 : this.Size - 1; for (int loopIndex = 0; loopIndex < this.Size; loopIndex++) { if (playerX) { result[loopIndex] = this.GetCellAt(loopIndex, col); } else { result[loopIndex] = this.GetCellAt(col, loopIndex); } } return result; }
public Cell[][] Neighbours2(Cell cell) { return this.Neighbours2(cell.Location); }
private static void TestNeighbour2Triplet(Cell cell, Cell[] triplet) { Assert.AreEqual(3, triplet.Length); NoNullsInCellArray(triplet); var testBoard = new HexBoardNeighbours(BoardSize); var testLoc = cell.Location; var neighbour2 = triplet[0].Location; var between1 = triplet[1].Location; var between2 = triplet[2].Location; Assert.IsTrue(testBoard.AreNeighbours(between1, between2)); Assert.IsTrue(testBoard.AreNeighbours(testLoc, between1)); Assert.IsTrue(testBoard.AreNeighbours(testLoc, between2)); Assert.IsTrue(testBoard.AreNeighbours(neighbour2, between1)); Assert.IsTrue(testBoard.AreNeighbours(neighbour2, between2)); // but not neighbours to each other Assert.IsFalse(testBoard.AreNeighbours(testLoc, neighbour2)); }
/// <summary> /// get an array of cells for an array of locations /// </summary> /// <param name="locations">the locations to process</param> /// <returns>the cells at the locations</returns> public Cell[] GetCellAt(Location[] locations) { if (locations == null) { return new Cell[0]; } Cell[] result = new Cell[locations.Length]; for (int loopIndex = 0; loopIndex < locations.Length; loopIndex++) { result[loopIndex] = this.GetCellAt(locations[loopIndex]); } return result; }
public void ToStringWithPlayerX() { Cell cell = new Cell(new Location(2, 3)); cell.IsOccupied = Occupied.PlayerX; string result = cell.ToString(); Assert.AreEqual("2,3 X", result); }
public void ToStringTest() { Cell cell = new Cell(new Location(0, 0)); string outValue = cell.ToString(); Assert.IsFalse(String.IsNullOrEmpty(outValue)); }
public void IsEmptyTest() { Cell cell = new Cell(new Location(0, 0)); bool returnValue = cell.IsEmpty(); Assert.IsTrue(returnValue); }
private static bool IsIncluded(Cell testCell, HexBoard board) { int boardSize = board.Size; int x = testCell.X; int y = testCell.Y; // corner cells are always in if (((x == 0) || (x == (boardSize - 1))) && ((y == 0) || (y == boardSize - 1))) { return true; } // cells along the edges if ((x == 0) || (x == (boardSize - 1))) { if ((y % EdgeInterval) == 0) { return true; } } if ((y == 0) || (y == (boardSize - 1))) { if ((x % EdgeInterval) == 0) { return true; } } // interior cells if ((x != 0) && (x != (boardSize - 1)) && (y != 0) && (y != (boardSize - 1))) { if (((x - 1) % InternalInterval == 0) && ((y - 1) % InternalInterval == 0)) { return true; } } // are any neighbours filled? var neighbours = board.Neighbours(testCell); foreach (Cell neighbourCell in neighbours) { if (!neighbourCell.IsEmpty()) { return true; } } return false; }
public Cell[][] GetCellsAt(Location[][] locs) { Cell[][] result = new Cell[locs.GetLength(0)][]; for (int loopIndex = 0; loopIndex < locs.GetLength(0); loopIndex++) { result[loopIndex] = this.GetCellAt(locs[loopIndex]); } return result; }
private static bool HasFilledNeighbour(Cell testCell, HexBoard board) { Cell[] neighbours = board.Neighbours(testCell); foreach (Cell neighbour in neighbours) { if (!neighbour.IsEmpty()) { return true; } } Cell[][] neighbours2 = board.Neighbours2(testCell); foreach (Cell[] triple in neighbours2) { if (!triple[0].IsEmpty()) { return true; } } return false; }
private static void DoTestNeighbour(Cell cell, Cell neibCell, HexBoard board) { Assert.IsTrue(cell.Location.ManhattanDistance(neibCell.Location) < 3, "Neigbour is too far away"); var neighboursTest = new HexBoardNeighbours(BoardSize); Assert.IsTrue(neighboursTest.AreNeighbours(cell.Location, neibCell.Location)); // reflexive. If B is a neighbour of A, then B's neighbours must include A var neibs = board.Neighbours(neibCell); int index = Array.IndexOf(neibs, cell); Assert.IsTrue(index >= 0, "Cell is not neighbour's neighbour"); }