public void CellEnsureCellIsAlive() { // object initializer syntax // use public setters when creating new instance Cell my_cell = new Cell { IsAlive = true }; Assert.IsTrue(my_cell.IsAlive); }
public CellBoard(bool[,] start) { Cell current; size = start.GetLength(1); for (int i = 0; i < start.GetLength(0); i++) { for (int j = 0; j < start.GetLength(1); j++) { current = new Cell(start[i,j]); currentBoard.Add(current); if (j == 0) { current.Left = null; current.TopLeft = null; try { currentBoard[currentBoard.Count - 2].Right = null; } catch (ArgumentOutOfRangeException) { } try { currentBoard[currentBoard.Count - start.GetLength(1) - 2].BottomRight = null; } catch (ArgumentOutOfRangeException) { } } else { try { current.Left = currentBoard[currentBoard.Count - 2]; } catch (Exception) { } try { current.TopLeft = currentBoard[currentBoard.Count - start.GetLength(1) - 2]; } catch (ArgumentOutOfRangeException) { current.TopLeft = null; } try { currentBoard[currentBoard.Count - 2].Right = current; } catch (ArgumentOutOfRangeException) { } try { currentBoard[currentBoard.Count - start.GetLength(1) - 2].BottomRight = current; } catch (ArgumentOutOfRangeException) { } } if (j == start.GetLength(1) - 1) { current.TopRight = null; try { currentBoard[currentBoard.Count - start.GetLength(1)].BottomLeft = null; } catch (ArgumentOutOfRangeException) { } } else { try { current.TopRight = currentBoard[currentBoard.Count - start.GetLength(1)]; } catch (ArgumentOutOfRangeException) { } try { currentBoard[currentBoard.Count - start.GetLength(1)].BottomLeft = current; } catch (ArgumentOutOfRangeException) { } } try { current.Top = currentBoard[currentBoard.Count - start.GetLength(1) - 1]; } catch (ArgumentOutOfRangeException) { } try { currentBoard[currentBoard.Count - start.GetLength(1) - 1].Bottom = current; } catch (ArgumentOutOfRangeException) { } } } }
public void CellEnsureCellIsDead() { // object initializer syntax // use public setters when creating new instance Cell my_cell = new Cell(); Assert.IsFalse(my_cell.IsAlive); }
// Mark a cell to be removed if live neighborsCount < 2 || > 3 public void ApplyKillRules(Cell cell, int numLiveNeighbors) { if(numLiveNeighbors > 3 || numLiveNeighbors < 2) { cell.MarkForChange = true; } }
public void CellConstructorTest() { Cell cell = new Cell(1, 2); Assert.AreEqual(cell.LocationX, 1); Assert.AreEqual(cell.LocationY, 2); Assert.AreEqual(cell.NeighborCount, 0); }
public void CellEnsureCellIsAlive() { // Object Initializer Syntax // Use public setters when creating new instance // Use {} instead of () Cell cell = new Cell { IsAlive = true }; Assert.IsTrue(cell.IsAlive); }
public void CellEnsureWeCanProvidePosition() { int x = 1; int y = 2; Cell my_cell = new Cell {X = x, Y = y}; Assert.AreEqual(x, my_cell.X); Assert.AreEqual(y, my_cell.Y); }
public bool Equals(Cell comparison) { // If parameter is null return false: if ((object)comparison == null) { return false; } // Return true if the fields match: return (Row == comparison.Row) && (Col == comparison.Row); }
public void CanApplyKillRules() { List<Cell> alive = new List<Cell>(); alive.Add(new Cell ( 1, 2 )); alive.Add(new Cell ( 2, 2 )); alive.Add(new Cell ( 2, 3 )); alive.Add(new Cell ( 4, 3 )); GameBoard board = new GameBoard(alive); Cell cellToKill = new Cell(1, 2); board.ApplyKillRules(cellToKill, 4); Assert.IsTrue(cellToKill.MarkForChange); }
public bool checkCellCollectionForCell(List<Cell> cellCollection, Cell cellInQuestion) { foreach (Cell cell in cellCollection) { if (cellInQuestion.LocationX == cell.LocationX && cellInQuestion.LocationY == cell.LocationY) { return true; } } return false; }
public GameOfLife(int i, int j) { cells = new Cell[i, j]; for (int h = 0; h < i; h++) { for (int k = 0; k < j; k++) { cells[h, k] = new Cell(h, k); } } this.RemoveOffGridNeighbors(); }
public Cell(Cell oldCell) { Grid.SetColumn(this, oldCell.col); Grid.SetRow(this, oldCell.row); row = oldCell.row; col = oldCell.col; Width = oldCell.Width; Height = oldCell.Height; _geometry = oldCell._geometry; isLiving = oldCell.isLiving; this.Fill = oldCell.Fill; }
public Form1() { InitializeComponent(); cells = new Cell[cellborder,cellborder]; for (int x = 0; x < cellborder; x++) { for (int y = 0; y < cellborder; y++) { cells[x, y] = new Cell(); } } }
private bool IsAlive(Cell c) { bool result = false; foreach (var cell in cells) { if (c.X == cell.X && c.Y == cell.Y) { result = true; break; } } return result; }
public BoundedWorld(int width, int height) { cells = new Cell[height, width]; Width = width; Height = height; for (int row = 0; row < Height; row++) { for (int col = 0; col < Width; col++) { cells[row, col] = new Cell(); } } }
public void GetLiveNeighborsTest() { Cell newCell = new Cell { X = 0, Y = 0 }; Cell anotherCell = new Cell { X = 1, Y = 0 }; World world = new World(); world.AddCell(0, 0); world.AddCell(0,1); world.AddCell(2,3); world.AddCell(-1, -1); List<Cell>actual = world.GetLiveNeighbors(world.GetCell(0,0).X, world.GetCell(0, 0).Y); Assert.AreEqual(2,actual.Count); }
public void CellEnsureWeCanProvidePosition() { int x = 1; int y = 2; Cell my_cell = new Cell { X = x, Y = y}; /* The same as: Cell my_cell = new Cell(); my_cell.X = x; my_cell.Y = y; */ Assert.AreEqual(x, my_cell.X); Assert.AreEqual(y, my_cell.Y); }
public List<Cell> AliveNeighbors(int x, int y) { List<Cell> neighbors = new List<Cell>(); Cell above = null; Cell below = null; below = new Cell { X = x, Y = y - 1 }; above = new Cell { X = x, Y = y + 1 }; if (cells.Exists(c => c.X==above.X && c.Y == above.Y)) { neighbors.Add(above); } if (cells.Exists(c => c.X == below.X && c.Y == below.Y)) { neighbors.Add(below); } return neighbors; }
// Constructor with just height, width & algorithm rules creates random board public GameOfLife(int height, int width, string rules) { RulesParser(rules); Random rand = new Random(); this.height = height; this.width = width; gameBoard = new Cell[height, width]; for (int y = 0; y < height; y++) { ObservableCollection<bool> row = new ObservableCollection<bool> { }; for (int x = 0; x < width; x++) { double check = rand.NextDouble(); bool cellAlive = check >= 0.5; gameBoard[y, x] = new Cell(cellAlive) { Y = y, X = x }; if (cellAlive) activeCells.Add(gameBoard[y, x]); row.Add(cellAlive); } cellList.Add(row); } }
public void CalculateAppropriateNeighborCoordinatesForCellAt0x0() { Cell ATestCell = new Cell(0, 0); List<int[]> TestNeighbors = new List<int[]>(); TestNeighbors.Add(new int[] { -1, -1 }); TestNeighbors.Add(new int[] { -1, 0 }); TestNeighbors.Add(new int[] { -1, 1 }); TestNeighbors.Add(new int[] { 0, -1 }); TestNeighbors.Add(new int[] { 0, 1 }); TestNeighbors.Add(new int[] { 1, -1 }); TestNeighbors.Add(new int[] { 1, 0 }); TestNeighbors.Add(new int[] { 1, 1 }); List<int[]> ActualNeighbors = ATestCell.Neighbors; CollectionAssert.AreEquivalent(TestNeighbors[0], ActualNeighbors[0]); CollectionAssert.AreEquivalent(TestNeighbors[1], ActualNeighbors[1]); CollectionAssert.AreEquivalent(TestNeighbors[2], ActualNeighbors[2]); CollectionAssert.AreEquivalent(TestNeighbors[3], ActualNeighbors[3]); CollectionAssert.AreEquivalent(TestNeighbors[4], ActualNeighbors[4]); CollectionAssert.AreEquivalent(TestNeighbors[5], ActualNeighbors[5]); CollectionAssert.AreEquivalent(TestNeighbors[6], ActualNeighbors[6]); CollectionAssert.AreEquivalent(TestNeighbors[7], ActualNeighbors[7]); }
public void CalculateAppropriateNeighborCoordinatesForCellAt2x2() { Cell ATestCell = new Cell(2, 2); PrivateObject ATestCellObj = new PrivateObject(ATestCell); List<int[]> TestNeighbors = new List<int[]>(); TestNeighbors.Add(new int[] { 1, 1 }); TestNeighbors.Add(new int[] { 1, 2 }); TestNeighbors.Add(new int[] { 1, 3 }); TestNeighbors.Add(new int[] { 2, 1 }); TestNeighbors.Add(new int[] { 2, 3 }); TestNeighbors.Add(new int[] { 3, 1 }); TestNeighbors.Add(new int[] { 3, 2 }); TestNeighbors.Add(new int[] { 3, 3 }); List<int[]> ActualNeighbors = ATestCell.Neighbors; CollectionAssert.AreEquivalent(TestNeighbors[0], ActualNeighbors[0]); CollectionAssert.AreEquivalent(TestNeighbors[1], ActualNeighbors[1]); CollectionAssert.AreEquivalent(TestNeighbors[2], ActualNeighbors[2]); CollectionAssert.AreEquivalent(TestNeighbors[3], ActualNeighbors[3]); CollectionAssert.AreEquivalent(TestNeighbors[4], ActualNeighbors[4]); CollectionAssert.AreEquivalent(TestNeighbors[5], ActualNeighbors[5]); CollectionAssert.AreEquivalent(TestNeighbors[6], ActualNeighbors[6]); CollectionAssert.AreEquivalent(TestNeighbors[7], ActualNeighbors[7]); }
public void CellHasColProperty() { Cell cell = new Cell(false, 1, 0,10); Assert.AreEqual(0, cell.Col); }
// Return the Count of alive neighbors public int NeighborsAliveCount(Cell cell) { int aliveCount = 0; List<Cell> neighbors = GenerateNeighborsList(cell); foreach(var neighbor in neighbors) { if (AliveCells.Contains(neighbor)) { aliveCount++; } else { ressurectionCellCandidates.Add(neighbor); } } return aliveCount; }
// Returns lists of lists of all neighbor coordinates from the input list public List<Cell> GenerateNeighborsList(Cell cell) { List<Cell> neighbors = new List<Cell>(); neighbors.Add(new Cell (cell.Row - 1, cell.Col - 1 )); neighbors.Add(new Cell (cell.Row - 1, cell.Col)); neighbors.Add(new Cell (cell.Row - 1, cell.Col + 1)); neighbors.Add(new Cell (cell.Row, cell.Col - 1 )); neighbors.Add(new Cell (cell.Row, cell.Col + 1 )); neighbors.Add(new Cell (cell.Row + 1, cell.Col - 1 )); neighbors.Add(new Cell (cell.Row + 1, cell.Col )); neighbors.Add(new Cell (cell.Row + 1, cell.Col + 1 )); return neighbors; }
public void CanCreateCell() { Cell cell = new Cell(false,0,0,10); Assert.IsNotNull(cell); }
public void CellEnsureCellHasAPosition() { Cell my_cell = new Cell(); Assert.AreEqual(0, my_cell.X); Assert.AreEqual(0, my_cell.Y); }
public void CellHasAliveProperty() { Cell cell = new Cell(false, 1, 0,10); Assert.AreEqual(false, cell.Alive); }
public void CellHasRowProperty() { Cell cell = new Cell(false, 5, 0,10); Assert.AreEqual(5, cell.Row); }
public void CellHasNeighbors() { Cell cell = new Cell(false, 0, 0,10); Assert.IsNotNull(cell.Neighbors); }
public void CellHasCorrectNumberOfNeighbors() { Cell cell = new Cell(false, 4, 4,10); Assert.AreEqual(8, cell.Neighbors.Count); }