def test_can_create_an_empty_grid(self):
game = GameOfLife(width=3, height=3, cell_size=1)
clist = game.cell_list(randomize=False)
self.assertEqual([[0, 0, 0], [0, 0, 0], [0, 0, 0]], clist)
class Console(UI):
def __init__(self, life: GameOfLife) -> None:
super().__init__(life)
def draw_borders(self, screen) -> None:
""" Отобразить рамку. """
screen.border(0)
def draw_grid(self, screen) -> None:
""" Отобразить состояние клеток. """
grid = self.life.curr_generation
for i in range(len(grid)):
for j in range(len([0])):
if grid[i][j] == 1:
screen.addstr(j + 1, i + 1, '*')
def run(self) -> None:
screen = curses.initscr()
# PUT YOUR CODE HERE
running = True
while running:
screen.clear()
self.draw_borders(screen)
self.draw_grid(screen)
self.life.step()
if self.life.is_max_generations_exceeded:
running = False
screen.refresh()
curses.endwin()
#if __name__ == '__main__':
life = GameOfLife((24, 80), max_generations=50)
ui = Console(life)
ui.run()
def test_is_max_generations_exceeded(self):
max_generations = 4
game = GameOfLife((self.rows, self.cols), max_generations=max_generations)
game.curr_generation = self.grid
for _ in range(max_generations-1):
game.step()
self.assertEqual(game.generations, max_generations)
self.assertTrue(game.is_max_generations_exceeded)
def test_prev_generation_is_correct(self):
game = GameOfLife((self.rows, self.cols))
for i in range(game.rows):
for j in range(game.cols):
game.curr_generation[i][j] = self.grid[i][j]
game.step()
self.assertEqual(game.prev_generation, self.grid)
def test_can_create_a_random_grid(self):
game = GameOfLife(width=3, height=3, cell_size=1)
random.seed(12345)
clist = game.cell_list(randomize=True)
self.assertEqual([[1, 0, 1], [1, 0, 1], [1, 0, 1]], clist)
def test_save(self):
path = Path('grid.txt')
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
game.save(path)
game = GameOfLife.from_file(path)
self.assertEqual(game.curr_generation, self.grid)
self.assertEqual((game.rows, game.cols), (self.rows, self.cols))
def test_get_neighbours_for_upper_side(self):
game = GameOfLife(width=self.width, height=self.height, cell_size=1)
game.clist = self.clist
neighbours = game.get_neighbours((0, 3))
self.assertEqual(5, len(neighbours))
self.assertEqual(4, sum(neighbours))
def test_get_neighbours_for_lower_right_corner(self):
game = GameOfLife(width=self.width, height=self.height, cell_size=1)
game.clist = self.clist
neighbours = game.get_neighbours((5, 7))
self.assertEqual(3, len(neighbours))
self.assertEqual(1, sum(neighbours))
def test_can_update(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
with open('steps.txt') as f:
steps = json.load(f)
num_updates = 0
for step in sorted(steps.keys(), key=int):
with self.subTest(step=step):
for _ in range(int(step) - num_updates):
game.curr_generation = game.get_next_generation()
num_updates += 1
self.assertEqual(steps[step], game.curr_generation)
def test_can_update(self):
game = GameOfLife(width=self.width, height=self.height, cell_size=1)
game.clist = self.clist
with open('steps.txt') as f:
steps = json.load(f)
num_updates = 0
for step in sorted(steps.keys(), key=int):
with self.subTest(step=step):
for _ in range(int(step)-num_updates):
game.clist = game.update_cell_list(game.clist)
num_updates += 1
self.assertEqual(steps[step], game.clist)
def test_get_neighbours_for_right_side(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
neighbours = game.get_neighbours((2, 7))
self.assertEqual(5, len(neighbours))
self.assertEqual(2, sum(neighbours))
def test_get_neighbours_for_upper_left_corner(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
neighbours = game.get_neighbours((0, 0))
self.assertEqual(3, len(neighbours))
self.assertEqual(2, sum(neighbours))
def test_get_neighbours_for_lower_right_corner(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
neighbours = game.get_neighbours((5, 7))
self.assertEqual(3, len(neighbours))
self.assertEqual(1, sum(neighbours))
def test_can_create_a_random_grid(self):
game = GameOfLife((3, 3))
random.seed(12345)
grid = game.create_grid(randomize=True)
self.assertEqual([[1, 0, 1], [1, 0, 1], [1, 0, 1]], grid)
def test_get_neighbours(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
neighbours = game.get_neighbours((2, 3))
self.assertEqual(8, len(neighbours))
self.assertEqual(4, sum(neighbours))
def test_is_not_changing(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
for _ in range(self.max_generations + 1):
game.step()
self.assertFalse(game.is_changing)
def test_can_create_an_empty_grid(self):
game = GameOfLife((3, 3))
grid = game.create_grid(randomize=False)
self.assertEqual([[0, 0, 0], [0, 0, 0], [0, 0, 0]], grid)
def main():
game = GameOfLife(size=(48, 64))
app = GUI(game)
app.run()
if event.type == QUIT:
running = False
elif event.type == KEYDOWN:
if event.key == K_SPACE:
pause = not pause
elif event.type == pygame.MOUSEBUTTONUP:
posx, posy = event.pos
posx //= self.cell_size
posy //= self.cell_size
self.life.curr_generation[posy][posx] = \
int(not bool(self.life.curr_generation[posy][posx]))
self.draw_grid()
pygame.display.flip()
if pause:
self.draw_grid()
self.draw_lines()
pygame.display.flip()
continue
self.draw_grid()
self.draw_lines()
self.life.step()
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == '__main__':
print('УПРАВЛЕНИЕ:\nПРОБЕЛ - ПАУЗА\nЛКМ/ПКМ - ЗАКРАСИТЬ КЛЕТКУ')
ui = GUI((GameOfLife((args.width, args.height), True, max_generations=args.max_generations)), cell_size=args.cell_size)
ui.run()
pygame.quit()
cols, rows, max_gen= 80, 25, 10
if len(sys.argv) <= 1:
print("default")
else:
for j in range(1, len(sys.argv), 2):
i = sys.argv[j]
if i == "--help":
print('input --rows <int> and --cols <int>\n'
'imput maximum of generations --max_generations <int>\n')
exit(1)
elif i == "--rows":
rows = int(sys.argv[j+1])
elif i == "--cols":
cols = int(sys.argv[j+1])
elif i == "--max_generations":
max_gen = int(sys.argv[j+1])
else:
print("Error")
exit(1)
life = GameOfLife((25, 80))
life = GameOfLife((rows, cols), max_generations=max_gen)
ui = GUI(life)
ui.run()
screen.addstr(i, 0, "|")
for i in range(1, self.life.rows + 1):
screen.addstr(i, self.life.cols + 1, "|")
def draw_grid(self, screen) -> None:
""" Отобразить состояние клеток. """
for i in range(self.life.rows):
for j in range(self.life.cols):
if self.life.curr_generation[i][j] == 0:
screen.addstr(i + 1, j + 1, " ")
else:
screen.addstr(i + 1, j + 1, "*")
def run(self) -> None:
screen = curses.initscr()
screen.clear()
self.draw_borders(screen)
screen.refresh()
while not self.life.is_max_generations_exceeded and self.life.is_changing:
self.draw_grid(screen)
screen.refresh()
self.life.step()
curses.endwin()
if __name__ == '__main__':
life = GameOfLife((24, 80), max_generations=50)
ui = Console(life)
ui.run()
x = pos[0] // self.cell_size
y = pos[1] // self.cell_size
if self.life.curr_generation[y][x] == 0:
self.life.curr_generation[y][x] = 1
else:
self.life.curr_generation[y][x] = 0
self.draw_grid()
pygame.display.flip()
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
paused = False
if event.type == QUIT:
running = False
paused = False
exitflag = 1
# Выполнение одного шага игры (обновление состояния ячеек)
self.life.step()
# Отрисовка списка клеток
if exitflag == 0:
self.draw_grid()
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == "__main__":
life = GameOfLife((50, 100), True, max_generations=200)
gui = GUI(life)
gui.run()
break
try:
if keyboard.is_pressed('q'):
a.append('q')
except Exception:
pass
try:
if keyboard.is_pressed('s'):
a.append('s')
except Exception:
pass
for event in a:
if event == 'q':
running = False
if event == 's':
self.life.save("save.txt")
if self.life.is_max_generations_exceeded == True or self.life.is_changing == False:
running = False
self.draw_grid(screen)
self.life.step()
screen.refresh()
curses.endwin()
if __name__ == "__main__":
life = GameOfLife((24, 50), True, max_generations=200)
ui = Console(life)
ui.run()
screen.refresh()
window = curses.newwin(self.life.rows + 2, self.life.cols + 2)
self.draw_borders(window)
window.timeout(1)
window.nodelay(True)
running = True
paused = False
while running:
curr_el = window.getch()
if curr_el == ord("\n"):
paused = False if paused else True
elif curr_el == ord("S"):
self.life.save(self.save_path)
elif curr_el == curses.ascii.ESC:
running = False
if not paused:
self.draw_grid(window)
window.refresh()
self.life.step()
time.sleep(1)
curses.endwin()
if __name__ == "__main__":
life = GameOfLife((15, 30), randomize=True)
ui = Console(life, save_path=pathlib.Path("fileui.txt"))
ui.run()
self.screen.fill(pygame.Color('white'))
running = True
pause = False
while running:
if not pause:
running = self.life.step()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
pause = not pause
if event.type == MOUSEBUTTONUP:
mouse_pos = event.pos
x, y = mouse_pos
self.life.curr_generation[y // self.cell_size][
x // self.cell_size] = 1
self.draw_grid()
pygame.display.flip()
if event.type == pygame.QUIT:
running = False
self.draw_grid()
self.draw_lines()
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == '__main__':
game = GameOfLife(randomize=True)
gui = GUI(game)
gui.run()
rectangle(screen, 0,0, self.life.rows+1, self.life.cols+1)
pass
def draw_grid(self, screen) -> None:
for i in range(self.life.rows):
for j in range(self.life.cols):
if self.life.curr_generation[i][j] == 1:
screen.addch(i+1, j+1, '*')
else:
screen.addch(i+1, j+1, ' ')
pass
def run(self) -> None:
screen = curses.initscr()
running = True
while running:
self.draw_borders(screen)
self.draw_grid(screen)
if self.life.is_changing and self.life.is_max_generations_exceeded:
self.life.step()
else:
running = False
screen.refresh()
time.sleep(1/self.speed)
curses.endwin()
pass
life = GameOfLife((20, 20), max_generations=255)
ui = Console(life)
ui.run()
def main():
game = GameOfLife(size=(32, 80))
app = Console(game)
app.run()
def test_prev_generation_is_correct(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
game.step()
self.assertEqual(game.prev_generation, self.grid)
while paused:
for event in pygame.event.get():
if event.type == QUIT:
running = False
paused = False
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
click_pos = pygame.mouse.get_pos()
x = click_pos[0] // self.cell_size
y = click_pos[1] // self.cell_size
self.life.curr_generation[y][x] = (
self.life.curr_generation[y][x] + 1) % 2
self.draw_lines()
self.draw_grid()
pygame.display.flip()
if event.type == pygame.KEYDOWN:
if event.key == K_RSHIFT:
paused = not paused
self.life.step()
if self.life.is_max_generations_exceeded or not self.life.is_changing:
running = False
clock.tick(self.speed)
pygame.quit()
if __name__ == '__main__':
game = GameOfLife((12, 16), max_generations=50)
gui = GUI(game)
gui.run()
def test_is_changing(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
game.step()
self.assertTrue(game.is_changing)
