def __getitem__(self, item): row, col = item[0], item[1] if row < 0 or row > len(self.prev_board) - 1: return Cell(None) if col < 0 or col > len(self.prev_board) - 1: return Cell(None) return self.prev_board[row][col]
def __init__(self, height, width): ''' Create a new playing area of (height, width) cells. ''' # Set up the grid and schedule. # Use SimultaneousActivation which simulates all the cells # computing their next state simultaneously. This needs to # be done because each cell's next state depends on the current # state of all its neighbors -- before they've changed. self.schedule = SimultaneousActivation(self) # Use a simple grid, where edges wrap around. self.grid = Grid(height, width, torus=True) # Place a cell at each location, with some initialized to # ALIVE and some to DEAD. for (contents, x, y) in self.grid.coord_iter(): cell = Cell((x, y), self) if random() < .1: cell.state = cell.ALIVE self.grid.place_agent(cell, (x, y)) self.schedule.add(cell) self.running = True
def __init__(self, height, width): ''' Create a new playing area of (height, width) cells. ''' # Set up the grid and schedule. # Use SimultaneousActivation which simulates all the cells # computing their next state simultaneously. This needs to # be done because each cell's next state depends on the current # state of all its neighbors -- before they've changed. self.schedule = SimultaneousActivation(self) # Use a simple grid, where edges wrap around. self.grid = Grid(height, width, torus=True) # Place a cell at each location, with some initialized to # ALIVE and some to DEAD. for (contents, x, y) in self.grid.coord_iter(): cell = Cell((x, y), self) if random() < .1: cell.state = cell.ALIVE self.grid.place_agent(cell, (x, y)) self.schedule.add(cell) self.running = True
def __toggle(self): if self['bg'] == "white": self['bg'] = "black" self.__cell = Cell(True) else: self['bg'] = "white" self.__cell = Cell(False)
def update(self): for row in range(len(self.board)): for col in range(len(self.board)): cell_neighbours = self.get_neighbour_states(row, col) if self[row, col].will_survive(cell_neighbours): self[row, col] = Cell(ALIVE) else: self[row, col] = Cell(DEAD) self.prev_board = deepcopy(self.board) return self
def register_cell(sid): try: print('new cell') new_cell = Cell(game=game_of_life, client_id=sid) spirits.append(new_cell) except: print("error registering cell")
def get_new_state(self, grid): new_grid = [[Cell(False) for _ in range(len(grid[0]))] for _ in range(len(grid))] for i in range(len(grid)): for j in range(len(grid[0])): nb_neighbours = self.count_neighbours(grid, i, j) if nb_neighbours == 2: new_grid[i][j].is_alive = grid[i][j].is_alive elif nb_neighbours == 3: new_grid[i][j].is_alive = True return new_grid
def read_from_file(self, filename: str): """ Reads the board from an input file """ if self.__check_file_status(filename): with open(filename, 'r') as file_handler: lines = file_handler.readlines() self.__num_rows = int(lines[0]) self.__num_cols = int(lines[1]) for line in lines[2:]: row = [] tokens = list(line)[:-1] for token in tokens: cell = None if token == '*': cell = Cell(False) elif token == 'o': cell = Cell(True) else: raise RuntimeError(f'Token {token} not allowed') row.append(cell) self.__board.append(row)
def update_board(self): """ Updates the board with a new iteration of the game """ new_board = [] for idx in range(0, self.__num_rows): new_row = [] for jdx in range(0, self.__num_cols): is_alive = self.__is_going_to_be_alive(idx, jdx) new_row.append(Cell(is_alive)) new_board.append(new_row) self.__board.clear() self.__board = new_board
def test_cell_is_dead_next_generation_if_lt_stable_count(self): cell = Cell() min_stable = Cell.STABLE_NEIGHBOR_RANGE[0] is_alive_next_gen = cell.is_alive_next_generation(min_stable - 1) self.assertFalse(is_alive_next_gen)
def test_cell_is_still_alive_next_gen_if_in_stable_neighborhood(self): for i in Cell.STABLE_NEIGHBOR_RANGE: with self.subTest(stable_neighbor_count=i): cell = Cell() cell.is_alive_next_generation(i) self.assertTrue(cell.is_alive_next_generation)
def test_get_str_death(self): death_cell = Cell(False) self.assertEqual(str(death_cell), '*')
def test_create_death_cell(self): death_cell = Cell(False) self.assertFalse(death_cell.get_alive_status())
def test_dead_cell_is_dead_next_gen_if_gt_fertile_neighbor_count(self): cell = Cell(alive=False) gt_fertile_count = Cell.FERTILE_NEIGHBOR_COUNT + 1 is_alive_next_gen = cell.is_alive_next_generation(gt_fertile_count) self.assertFalse(is_alive_next_gen)
def test_stay_alive(self): cell = Cell(ALIVE) neighbours2 = [1, 1, 0, 0, 0, 0, None, None] self.assertTrue(cell.will_survive(neighbours2)) neighbours3 = [1, 1, 1, 0, 0, 0, None, None] self.assertTrue(cell.will_survive(neighbours3))
def test_will_not_be_born(self): cell = Cell(DEAD) neighbours = [1, 1, 0, 0, 0, 0, 0,] self.assertFalse(cell.will_survive(neighbours)) neighbours = [1, 1, 1, 1, 0, 0, 0] self.assertFalse(cell.will_survive(neighbours))
def test_create_life(self): cell = Cell(DEAD) neighbours = [1, 1, 1, 0, 0, 0, 0, None, None] self.assertTrue(cell.will_survive(neighbours))
def test_is_alive(self): alive_cell = Cell(ALIVE) self.assertTrue(alive_cell.is_alive) dead_cell = Cell(DEAD) self.assertFalse(dead_cell.is_alive)
def initialize_grid(h, w): return [[Cell(False) for _ in range(w)] for _ in range(h)]
def test_should_not_change_cells_if_all_cells_are_dead(): grid_manager = GridManager() grid = [[Cell(False) for _ in range(1)] for _ in range(1)] new_grid = grid_manager.get_new_state(grid) assert new_grid[0][0].is_alive is False
def test_cell_is_dead_from_overcrowding_next_gen_if_gt_stable_count(self): cell = Cell() max_stable = Cell.STABLE_NEIGHBOR_RANGE[-1] is_alive_next_gen = cell.is_alive_next_generation(max_stable + 1) self.assertFalse(is_alive_next_gen)
def test_dead_cell_in_fertile_neighboorhood_is_alive_next_generation(self): cell = Cell(alive=False) is_alive_next_generation = cell.is_alive_next_generation( Cell.FERTILE_NEIGHBOR_COUNT) self.assertTrue(is_alive_next_generation)
def test_will_not_survive_underpopulation(self): cell = Cell(ALIVE) neighbours = [1, 0, 0, 0, 0, 0, 0] self.assertFalse(cell.will_survive(neighbours))
def test_a_new_cell_is_alive(self): cell = Cell() self.assertTrue(cell.is_alive)
def set_alive_cells(self, coords: list): for row, col in coords: self.board[row][col] = Cell(ALIVE) self.prev_board[row][col] = Cell(ALIVE) return self
def __init__(self, size): self.board = [] for i in range(size): self.board.append([Cell(DEAD) for j in range(size)]) self.prev_board = deepcopy(self.board)
def __init__(self, *args, **kargs): Button.__init__(self, *args, **kargs) self.__cell = Cell(False) self['command'] = self.__toggle
def test_get_str_alive(self): alive_cell = Cell(True) self.assertEqual(str(alive_cell), 'o')
def test_a_dead_cell_is_not_alive(self): cell = Cell() cell.die() self.assertFalse(cell.is_alive)
def test_create_a_cell(self): alive_cell = Cell(True) self.assertTrue(alive_cell.get_alive_status())
def test_a_cell_can_be_set_dead(self): cell = Cell(alive=False) self.assertFalse(cell.is_alive)