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)
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))
parser.add_argument('--width',
type=int,
default=640,
help='Enter width of window with game')
parser.add_argument('--height',
type=int,
default=480,
help='Enter height of window with game')
parser.add_argument('--cell_size',
type=int,
default=20,
help='Enter cell size')
args = parser.parse_args()
w = args.width > 0
h = args.height > 0
c = args.cell_size > 0
if w and h and c and args.width // args.cell_size > 0 and args.height // args.cell_size > 0:
gui = GUI(GameOfLife(
(args.width // args.cell_size, args.height // args.cell_size)),
cell_size=args.cell_size)
gui.run()
else:
print('The input received incorrect values. Tre again please')
if not w:
print('Incorrect value of width')
if not h:
print('Incorrect value of height')
if not c:
print('Incorrect value of cell_size')
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 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))
for j in range(len(life.curr_generation[i])):
screen.addch(i, j, ord('#'))
def run(self) -> None:
screen = curses.initscr()
life.create_grid()
curses.noecho()
curses.nodelay()
self.draw_borders(screen)
pause = False
while life.is_changing and not life.is_max_generations_exceed:
if screen.getch() == 32:
pause = not pause
if screen.getch() == int('q'):
break
if screen.getch() == int('s'):
self.life.save('mysave.txt')
if pause:
screen.refresh()
continue
self.draw_grid(screen)
life.step()
screen.refresh()
curses.endwin()
if __name__ == '__main__':
life = GameOfLife((24, 80), max_generations=50)
ui = Console(life)
ui.run()
def test_is_changing(self):
game = GameOfLife((self.rows, self.cols))
game.curr_generation = self.grid
game.step()
self.assertTrue(game.is_changing)
circle = (x - self.cell_size // 2, y - self.cell_size // 2)
pygame.draw.circle(self.screen, pygame.Color('black'), circle,
self.cell_size // 2)
def run(self) -> None:
pygame.init()
clock = pygame.time.Clock()
pygame.display.set_caption('Game of Life')
self.screen.fill(pygame.Color('white'))
running = True
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
self.screen.fill(pygame.Color('white'))
self.draw_lines()
self.draw_grid()
self.life.step()
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == "__main__":
game = GameOfLife(size=(50, 100))
gui = GUI(game)
gui.run()
while running:
screen.clear()
self.draw_borders(screen)
self.draw_grid(screen)
self.life.step()
if self.life.is_max_generations_exceed:
running = False
screen.refresh()
time.sleep(1 / 60)
screen.getch()
curses.endwin()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Console Game of life')
parser.add_argument('--rows', type=int, default=80, help='Number of rows')
parser.add_argument('--cols',
type=int,
default=30,
help='Number of columns')
parser.add_argument('--max-generations',
default=float('inf'),
type=int,
help='Maximum generation count')
args = parser.parse_args()
game = GameOfLife((args.cols, args.rows),
max_generations=args.max_generations)
console = Console(game)
console.run()
def test_get_neighbours_for_right_side(self):
game = GameOfLife(width=self.width, height=self.height, cell_size=1)
game.clist = self.clist
neighbours = game.get_neighbours((2,7))
self.assertEqual(5, len(neighbours))
self.assertEqual(2, sum(neighbours))
self.screen.border(0)
def draw_grid(self) -> None:
""" Отобразить состояние клеток. """
for i in range(self.life.rows):
for j in range(self.life.cols):
if self.life.curr_generation[i][j] == 1:
self.screen.addch(i + 1, j + 1, '*')
else:
self.screen.addch(i + 1, j + 1, ' ')
def run(self) -> None:
self.draw_borders()
running = True
while running:
self.draw_borders()
self.draw_grid()
self.screen.refresh()
time.sleep(0.5)
self.life.step()
curses.endwin()
if __name__ == "__main__":
game = GameOfLife(size=(10, 10), randomize=True)
console = Console(game)
console.run()
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_get_neighbours(self):
game = GameOfLife(width=self.width, height=self.height, cell_size=1)
game.clist = self.clist
neighbours = game.get_neighbours((2,3))
self.assertEqual(8, len(neighbours))
self.assertEqual(4, sum(neighbours))
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)
type=str,
default="white",
help="Enter color of dead cells")
parser.add_argument("--maxgenerations",
type=int,
default=50,
help="Enter max number of generations")
parser.add_argument("--grid_path",
type=Path,
default=None,
help="Load grid from file")
parser.add_argument("--randomize",
type=int,
default=1,
help="Should grid be randomized?")
arguments = parser.parse_args()
if arguments.grid_path is not None:
gui = GUI(GameOfLife.from_file(arguments.grid_path), arguments.size,
arguments.speed)
else:
gui = GUI(
GameOfLife(
(arguments.rows, arguments.cols),
arguments.randomize,
arguments.maxgenerations,
),
arguments.size,
arguments.speed,
)
gui.run()
for i in range(self.life.rows):
for j in range(self.life.cols):
if self.life.curr_generation[i][j] == 1:
screen.addstr(i + 1, j + 1, '*')
def run(self) -> None:
screen = curses.initscr()
curses.noecho()
curses.cbreak()
sleep_time = 0.5
while not self.life.is_max_generations_exceeded:
screen.clear()
self.draw_borders(screen)
self.draw_grid(screen)
screen.refresh()
time.sleep(sleep_time)
self.life.step()
time.sleep(sleep_time)
screen.clear()
screen.addstr(0, 0, 'The Game Is Over')
screen.refresh()
time.sleep(2)
curses.endwin()
if __name__ == '__main__':
life = GameOfLife((24, 24), max_generations=10)
ui = Console(life)
ui.run()
else:
for j in range(1, len(sys.argv), 2):
i = sys.argv[j]
if i == "--help":
print(
"\n Чтобы установить размер окна воспользуйтесь аргументами --rows <int> --cols <int>\n"
" Чтобы установить максимальное число поколений в игре воспользуйтесь аргументом --max_generations <int>\n"
" Приятной игры!\n")
exit(1)
elif i == "--rows":
sys_rows = int(sys.argv[j + 1])
elif i == "--cols":
sys_cols = int(sys.argv[j + 1])
elif i == "--max_generations":
sys_max_gen = int(sys.argv[j + 1])
else:
print("\nНеверный ключ командной строки: ", i, "\n")
exit(1)
life = GameOfLife((24, 80))
if sys_cols == 0:
sys_cols = 80
if sys_rows == 0:
sys_rows = 24
if sys_max_gen == 0:
sys_max_gen = 10
life = GameOfLife((sys_rows, sys_cols), max_generations=sys_max_gen)
ui = Console(life)
ui.run()
for event in pygame.event.get():
if event.type == pygame.constants.QUIT:
running = False
if event.type == pygame.constants.KEYDOWN and event.key == pygame.constants.K_SPACE:
paused = not paused
if event.type == pygame.constants.MOUSEBUTTONUP and event.button == 1:
position = pygame.mouse.get_pos()
x_pos = position[0] // self.cell_size
y_pos = position[1] // self.cell_size
if self.life.curr_generation[y_pos][x_pos] == 1:
self.life.curr_generation[y_pos][x_pos] = 0
else:
self.life.curr_generation[y_pos][x_pos] = 1
if event.type == pygame.constants.KEYDOWN and event.key == pygame.constants.K_s:
self.life.save(self.save_path)
self.draw_lines()
if not paused:
self.life.step()
self.draw_grid()
self.draw_lines()
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == "__main__":
life = GameOfLife((18, 25), randomize=True)
gui = GUI(life, save_path=pathlib.Path("filegui.txt"))
gui.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)
pygame.display.set_caption(
'Game of Life | Generations limit exceed')
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Console Game of life')
parser.add_argument('--width',
type=int,
default=640,
help='Screen width, px')
parser.add_argument('--height',
type=int,
default=480,
help='Screen height, px')
parser.add_argument('--cell-size',
type=int,
default=10,
help='Cell size, px')
parser.add_argument('--max-generations',
default=float('inf'),
type=int,
help='Maximum generation count')
args = parser.parse_args()
game = GameOfLife(
(args.height // args.cell_size, args.width // args.cell_size),
max_generations=args.max_generations)
gui = GUI(game, args.cell_size)
gui.run()
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)
if pause:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
pause = True
elif event.type == pygame.MOUSEBUTTONUP:
doc = event.pos
row = doc[1] // self.cell_size
col = doc[0] // self.cell_size
if self.life.curr_generation[row][col]:
self.life.curr_generation[row][col] = 0
else:
self.life.curr_generation[row][col] = 1
self.draw_grid()
pygame.display.flip()
else:
self.life.step()
self.draw_grid()
pygame.display.flip()
clock.tick(self.speed)
pygame.quit()
if __name__ == "__main__":
life = GameOfLife((20, 20), max_generations=500)
gui = GUI(life)
gui.run()
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)
type=int,
help="Maximum amount of generation. Default: 500")
parser.add_argument("--speed",
type=int,
help="Speed in pygame ticks. Default: 1")
args = parser.parse_args()
# Iterate over arguments to set defaults
# https://stackoverflow.com/questions/4075190/what-is-getattr-exactly-and-how-do-i-use-it
for arg in vars(args):
if not getattr(args, arg) and (arg == 'width' or arg == 'height'
or arg == 'max_generations'):
# setattr(x, 'y', val) is equivalent to `x.y = val`
setattr(args, arg, 500)
elif not getattr(args, arg) and (arg == 'cell_size'):
setattr(args, arg, 20)
elif not getattr(args, arg):
setattr(args, arg, 5)
game = GUI(
GameOfLife(
(args.height // args.cell_size, args.width // args.cell_size),
True, args.max_generations), args.cell_size, args.speed)
game.run()
# Run from save file
# if __name__ == '__main__':
# console = GUI(GameOfLife.from_file(pathlib.Path('Save.txt')))
# console.run()
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))
super().__init__(life)
self.screen = curses.initscr()
def draw_borders(self) -> None:
self.screen.border(0)
def draw_grid(self) -> None:
for i in range(1, len(self.life.curr_generation) - 1):
for j in range(1, len(self.life.curr_generation[i]) - 1):
if self.life.curr_generation[i][j]:
sign = "*"
else:
sign = " "
self.screen.addch(i, j, sign)
def run(self) -> None:
self.draw_borders()
running = True
while running:
self.draw_borders()
self.draw_grid()
self.screen.refresh()
sleep(0.3)
self.life.step()
curses.endwin()
if __name__ == "__main__":
life = GameOfLife((30, 30))
Console(life).run()
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))
elif event.type == MOUSEBUTTONUP:
i, j = event.pos
i = i // self.cell_size
j = j // self.cell_size
if self.life.curr_generation[j][i] == 0:
self.life.curr_generation[j][i] = 1
else:
self.life.curr_generation[j][i] = 0
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__':
ui = GUI(GameOfLife((15, 15), True, 30))
ui.run()
def main():
game = GameOfLife(size=(48, 64))
app = GUI(game)
app.run()
dest="it",
required=False,
default=1000,
help="Количество итераций")
parser.add_argument("--cell-size",
"-cs",
type=int,
dest="cs",
required=False,
default=10,
help="Размер ячейки")
parser.add_argument("--input-filename",
"-in",
type=str,
dest="in",
required=False,
help="Путь к файлу с входными данными")
return parser.parse_args()
if __name__ == '__main__':
args = vars(parse_args())
if args.get('in'):
life = GameOfLife.from_file(pathlib.Path(args['in']))
else:
life = GameOfLife((args['r'], args['c']), True, args['it'])
ui = GUI(life, cell_size=args['cs'])
ui.run()
