def draw_boards(primary_canvas, secondary_canvas, control_canvas, width, height, size, margin,
primary_board=None,
secondary_board=None):
primary_canvas.delete("all")
secondary_canvas.delete("all")
control_canvas.delete("all")
if primary_board is None:
primary_board = Board(width, height)
if secondary_board is None:
secondary_board = Board(width, height)
primary_graphic_board = GraphicBoard(primary_board, secondary_board, primary_canvas)
secondary_graphic_board = GraphicBoard(secondary_board, primary_board, secondary_canvas)
primary_graphic_board.draw_tiles(size=size,
sister_g_board=secondary_graphic_board,
margin=margin,
goal_board=secondary_board)
secondary_graphic_board.draw_tiles(size=size,
sister_g_board=primary_graphic_board,
margin=margin,
goal_board=primary_board)
draw_buttons(control_canvas, primary_canvas, secondary_canvas, primary_board, secondary_board,
primary_graphic_board, secondary_graphic_board)
def test_create_grid_height(self):
tested_board = Board()
default_height = tested_board.get_height()
board_4 = Board(100, 4)
height_4 = board_4.get_height()
self.assertEqual(default_height, 10)
self.assertEqual(height_4, 4, 10)
def test_grid_width(self):
default_board = Board()
default_width = default_board.get_width()
board_100 = Board(100, 4)
width_100 = board_100.get_width()
self.assertEqual(default_width, 10)
self.assertEqual(width_100, 100)
def __init__(self):
"""
Initializes the controller with the appropriate boards for each player.
"""
self._P1_Battle_Plan_Board = Board(Board.P1)
self._P1_Battle_Field_Board = Board(Board.P1)
self._P2_Battle_Plan_Board = Board(Board.P2)
self._P2_Battle_Field_Board = Board(Board.P2)
self._whos_turn = Board.P1 # Player One starts
def create_board(P1, P2, P3, *args):
board = Board()
P1 = board.get_player(P1)
P2 = board.get_player(P2)
P3 = board.get_player(P3)
A = board.add_node('A', player=P1, power=2)
L = board.add_node('L', player=P2, power=2)
P = board.add_node('P', player=P3, power=2)
B, C, D, E, F, G, H, I, J, K, M, N, O = board.get_empty_nodes(['B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
'M', 'N', 'O'])
board.add_paths([(A, B),
(A, C),
(A, D),
(B, E),
(C, F),
(D, G),
(E, H),
(F, I),
(F, J),
(G, K),
(H, L),
(I, L),
(J, P),
(K, P),
(L, M),
(M, N),
(N, O),
(O, P)
])
return board
def parse(self, content):
''' Parse the puzzle file's content into models '''
cars = {}
for each_line in content:
description = each_line.split()
# print(description)
index = int(description[0])
y_top_left = int(description[1])
x_top_left = int(description[2])
length = int(description[3])
orientation = int(description[4])
car = Car(index, y_top_left, x_top_left, length, orientation)
if orientation == Orientation.HORIZONTAL:
car.set_end_location(y_top_left, x_top_left+length-1)
else:
car.set_end_location(y_top_left+length-1, x_top_left)
cars[index] = car
self.puzzle_board = Board()
# It will print "Car x: top-left at (x,x) and has length x, orientation x."
# print(cars[0])
for key, car in cars.items():
occupied_locations = car.get_occupied_locations()
self.puzzle_board.add_car(car, occupied_locations)
def __init__(self, win):
self.win = win
self.board = Board()
self.selected_piece = None
self.turn = BLACK
self.valid_moves = {}
self._init_game()
def main():
print("hello world!")
board = Board()
board.begin(Color.RED)
print(board)
for x in board.get_playable_position():
print(x)
def render_POST(self, request):
name = request.get_argument("name")
repr = request.get_argument("repr")
repr_order = request.get_argument_int("repr_order", None)
classification = request.get_argument("classification") or None
description = request.get_argument("description") or None
write_group_uid = request.get_argument_int("write_group_uid")
write_group = request.dbsession\
.query(Group)\
.filter(Group.uid == write_group_uid)\
.one()
comment_group_uid = request.get_argument_int("comment_group_uid")
comment_group = request.dbsession\
.query(Group)\
.filter(Group.uid == comment_group_uid)\
.one()
enabled = request.get_argument("enabled") == "True"
board = Board(name, repr, write_group, comment_group)
board.repr_order = repr_order
board.classification = classification
board.description = description
board.enabled = enabled
request.dbsession.add(board)
request.dbsession.commit()
request.redirect("/admin/board")
return "redirected"
def __init__(self, playerOne=None, playerTwo=None):
"""Inits an instance of the Game class.
PlayerOne is always the human side of the game.
Args:
playerOne (Optional[model.player.Player]):
The human player (default is None).
playerTwo (Optional[model.player.Player]):
The AI player (default is None).
"""
self.playerOne = playerOne
self.playerTwo = playerTwo
self.listeners = list()
self.aiPlayer = self.playerOne if self.playerOne.isAi \
else self.playerTwo
self._board = Board()
self._uuid = None
self._moves = list()
self.status = Status.InProgress
self.nextPlayer = self.playerOne
dispatcher.connect(self._onAiMoveResponse, signal=Events.aiResponse)
def game_of_life_loop(board):
while True:
to_update = []
new_board = Board(cols, rows)
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
board.reset()
draw_grid(board)
draw_start_pattern(board)
return
for x in range(cols):
for y in range(rows):
cell = board.get_cell(x, y)
state = next_state(cell, board)
if state:
new_board.get_cell(x, y).alive = True
to_update.append(new_board.get_cell(x, y))
elif not state:
new_board.get_cell(x, y).alive = False
to_update.append(new_board.get_cell(x, y))
board = new_board
for s in to_update:
update_cell(s)
pygame.display.flip()
# Higher number, higher speed
clock.tick(12)
def _solve_puzzle(self):
self._label["text"] = "Working"
self._window.update()
try:
board = Board()
for row in range(Board.BOARD_SIZE):
for col in range(Board.BOARD_SIZE):
str_val = self._inputs[row][col].get()
if str_val == "":
int_val = 0
else:
int_val = int(str_val)
board.set_cell_value(row, col, int_val)
result = Solver().solve(board)
if not result.success:
self._label["text"] = "Failed"
return
self._label["text"] = "Success"
self._paint_board(result.solution)
except:
self._label["text"] = "Error"
async def _runHanabot(self):
"""
Initializes the hanabot AI and keeps it running.
"""
await asyncio.sleep(0.5)
self._hanabot = Hanabot(Board(self._sensoryBuffer.cvState['hand']))
await self._hanabot.react(self._sensoryBuffer, self._outputBuffer)
def __restart_game(self):
self.round_counter += 1
self.turn_counter = 0
self.board = Board()
self.checker = ResultChecker(self.board)
self.player_1_ctrl.set_board(self.board)
self.player_2_ctrl.set_board(self.board)
self.__generate_order_of_players()
self.__create_game()
def compute(self):
"""
Boucle principal de ce client. Cette boucle va générer des parties IA contre IA à l'infini. Entre chaque partie, il va envoyer l'exemple au serveur.
C 'est le client qui décide quel doit être le coef d'apprentissage à utiliser pour chaque exemple. Un exemple représente un tour.
"""
if not self.is_connected:
raise NotConnectedError()
try:
while True:
# Initialisation :
board = Board()
history_board = list()
history_choice = list()
history_actions = list()
current_player = list()
i = 0
while board.winner() == 0:
i += 1
# On joue selon l'IA
self.tree = Tree(board, self.ia, {
0: 1,
1: -1
}[board.current_player])
for _ in range(100):
self.tree.compute()
act = self.tree.get_best()
history_board.append(board.get_board_raw())
actions = board.getActions()
history_choice.append(actions.index(act))
history_actions.append(
board.get_actions_board_raw(actions))
current_player.append({0: 1, 1: -1}[board.current_player])
act.do(board=board)
print("Finish")
# Last action
# On envoie les actions 1 par 1 avec un coef d'apprentissage adapté.
for i in range(25):
if current_player[-1 * (i + 1)] == board.winner():
self.send(PUSH_EXEMPLE_OPCODE, exp(-1 * i * 0.075),
history_board[-1], history_actions[-1],
history_choice[-1], board.winner())
save_file = open(
"./log-client/{}-{}.data".format(
datetime.now().strftime("%m-%d_%H:%M:%S"), self.id),
"wb")
save_file.write(
dumps((history_board, history_choice, history_actions,
board.winner())))
save_file.close()
kernels = self.execute(GET_KERNEL_OPCODE)
self.ia.load_kernel(kernels)
except KeyboardInterrupt:
pass
def new_game(self):
self.dialog_new_game.exec()
if not self.ui.is_player2_human:
self.ai_player = AIPlayer('red', self.ui.difficulty)
else:
self.ai_player = None
self.board = Board()
self.over = False
self.active_player = 1
def single_ai_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
level = 1
isEnd = False
while True:
# give AI input, and let AI control snake
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
# catch event and control snake
eventHelper(my_snake, False)
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
if my_snake.is_dead([]) or isEnd:
break
# When snake eats the food
if status == 1:
score += my_board.foodWeight
total_score += 1
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
if score - level > level / 2:
level += 1
if level % 2 == 0:
my_snake.add_obstcles(level)
if level % 3 == 0:
my_snake.speed += 1
displayHelper(playSurface, fpsClock, level, food_loc, my_snake,
total_score, player_name)
game_end(total_score)
class TestState(unittest.TestCase):
rows = 2
cols = 2
board1 = Board([Node(0), Node(1), Node(2), Node(3)], rows, cols)
board2 = Board([Node(1), Node(0), Node(2), Node(3)], rows, cols)
board3 = Board([Node(1), Node(3), Node(0), Node(2)], rows, cols)
state1 = State(board1)
state2 = State(board2)
state3 = State(board3)
def test_board_only(self):
# given
start_state = self.state2
# when
solved_state = DFS().solve(start_state, h0)
# then
self.assertListEqual(self.board1.content,
solved_state.current_board.content)
def test_whole_state(self):
# given
start_state = self.state2
target_state = State(self.board1, [MoveLeft()], [self.board2])
# when
solved_state = DFS().solve(start_state, h0)
# then
self.assertEqual(target_state, solved_state)
def test_longer(self):
start_state = self.state3
# when
solved_state = DFS().solve(start_state, h0)
# then
self.assertEqual(sorted(start_state.current_board.content),
solved_state.current_board.content)
def create_board(P1, P2, *args):
board = Board()
P1 = board.get_player(P1)
P2 = board.get_player(P2)
A = board.add_node('A', player=P1, power=2)
B, C, D = board.get_empty_nodes(['B', 'C', 'D'])
E = board.add_node('E', player=P2, power=2)
board.add_paths([(A, B),
(B, C),
(C, D),
(D, E)])
return board
def __init__(self, player_count):
if player_count not in [1, 3, 4]:
raise InvalidPlayerCountException()
self.players = []
for i in range(0, player_count):
player = Player(i)
self.players.append(player)
shuffle(self.players)
self.board = Board()
self.dice = Dice()
self.screen = Tk()
self.gui = GUI(self, self.players[0])
self.turns = 0
def start_game(self):
"""The game is started with the selected settings.
The default settings are: human vs. human."""
# Change starting screen to Chess board
self.board = Board(square_width=self.view.square_width,
square_height=self.view.square_height,
is_flipped=self.is_flipped)
# Create players
self.board.player_list.append('Human')
if self.settings['vs_computer']: self.board.player_list.append('AI')
else: self.board.player_list.append('Human')
class TestState(unittest.TestCase):
rows = 2
cols = 2
board1 = Board([Node(0), Node(1), Node(2), Node(3)], rows, cols)
board11 = Board([Node(1), Node(0), Node(2), Node(3)], rows, cols)
board12 = Board([Node(2), Node(1), Node(0), Node(3)], rows, cols)
board111 = Board([Node(0), Node(1), Node(2), Node(3)], rows, cols)
board112 = Board([Node(1), Node(3), Node(2), Node(0)], rows, cols)
board121 = Board([Node(0), Node(1), Node(2), Node(3)], rows, cols)
board122 = Board([Node(2), Node(1), Node(3), Node(0)], rows, cols)
def test_single_iteration(self):
# given
initial_state = State(self.board1)
expected_states = [
State(self.board12, [MoveDown()], [self.board1]),
State(self.board11, [MoveRight()], [self.board1]),
]
# when
states = self._iterate(initial_state)
# then
self.assertListEqual(states, expected_states)
def test_two_iterations(self):
# given
initial_state = State(self.board1)
expected_states = [
State(self.board121, [MoveDown(), MoveUp()],
[self.board1, self.board12]),
State(self.board122, [MoveDown(), MoveRight()],
[self.board1, self.board12]),
State(self.board112, [MoveRight(), MoveDown()],
[self.board1, self.board11]),
State(self.board111, [MoveRight(), MoveLeft()],
[self.board1, self.board11]),
]
# when
states1 = self._iterate(initial_state)
states2 = [s for states in states1 for s in self._iterate(states)]
# then
self.assertListEqual(states2, expected_states)
def _iterate(self, state: State) -> List[State]:
states = []
for s in state.next_states():
states.append(s)
return states
def generate_puzzle():
start = time.time()
initial_actions = None
max_val = 16
while initial_actions is None:
print('k')
initial_actions = model.solver.generate(max_val)
board = Board(max_val)
board = board.apply_actions(initial_actions)
board_str = str(board)
print(board_str)
print(time.time() - start)
SudokuApp(board_str).run()
def post(self):
name = self.request.get('name')
desc = self.request.get('desc')
if name == '':
self.error(400)
else:
creator = getSecureUser(self.request)
if (creator is not None):
existingBoard = Board.query(Board.name == name).fetch()
if len(existingBoard) is 0:
admins = [creator]
newBoard = Board(name=name, desc=desc, admins=admins)
newBoard.put()
else:
self.error(409)
else:
self.error(401)
def main():
board = Board()
player_1 = AlphaBeta(Color.RED)
player_2 = AlphaBeta(Color.BLUE)
print(
"hellow world. \n Wecome to the cubo4 game.\n It's a two player game, it's begin now. Blue begin"
)
current_player = player_2
board.begin(player_1.color)
while True:
position = current_player.play(board)
print("player " + str(current_player.color) + " play " + str(position))
board.play(current_player.color, position)
win = board.win(current_player.color, position)
if win:
print("player" + str(current_player) + "win")
print(board)
return
if current_player == player_1:
current_player = player_2
else:
current_player = player_1
def duo_ai_mode():
global player1_name, player2_name, avatar1_image, avatar2_image
init_name()
final_score1 = 0
player1_name = player_name
avatar1_image = avatar_image
addPlayerData(player_name)
init_name()
final_score2 = 0
player2_name = player_name
avatar2_image = avatar_image
addPlayerData(player2_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
level = 1
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
op_snake = Snake(50, 50)
op_snake.obstacles = my_snake.obstacles
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
isEnd = False
# check input and go as the direction
while True:
# give AI input, and let AI control snake
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
# op is pure AI
dir = AI12(my_board, op_snake)
op_snake.turn(dir)
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitHelper()
elif event.type == pygame.KEYDOWN:
# determine the event of keyBoard
if event.key == pygame.K_RIGHT or event.key == ord('d'):
my_snake.turn(RIGHT)
if event.key == pygame.K_LEFT or event.key == ord('a'):
my_snake.turn(LEFT)
if event.key == pygame.K_UP or event.key == ord('w'):
my_snake.turn(UP)
if event.key == pygame.K_DOWN or event.key == ord('s'):
my_snake.turn(DOWN)
if event.key == ord('q'):
isEnd = True
if event.key == pygame.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.QUIT))
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status1 = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
# increase along the moving direction
draw_surface(playSurface, blackColour, op_snake.get_cells(), 10, 100)
status2 = op_snake.tick(my_board.food, [])
op_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
op_new_cells = op_snake.get_cells()
if my_snake.is_dead(op_new_cells) or op_snake.is_dead(
my_new_cells) or isEnd:
break
# When my snake eats the food
if status1 == 1 or status2 == 1:
score += my_board.foodWeight
if status1 == 1:
final_score1 += 1
else:
final_score2 += 1
my_board.new_food(my_new_cells, my_snake.obstacles, op_new_cells)
food_loc = [my_board.food]
if score - level > level / 2:
level += 1
if level % 2 == 0:
my_snake.add_obstcles(level)
if level % 3 == 0:
my_snake.speed += 1
playSurface.fill(blackColour)
pygame.draw.polygon(playSurface, greenColour,
[[99, 99], [99, 601], [601, 601], [601, 99]], 1)
show_message(playSurface, 'Score: ' + str(total_score), whiteColour,
40, 10, 10)
show_message(playSurface, 'Level: ' + str(level), whiteColour, 40, 10,
50)
screen.blit(avatar1_image, (20, 615))
show_message(playSurface, player1_name, whiteColour, 40, 100, 630)
screen.blit(avatar2_image, (20, 650))
show_message(playSurface, player2_name, whiteColour, 40, 100, 665)
draw_surface(playSurface, redColour, food_loc, 10, 100)
draw_surface(playSurface, greenColour, my_snake.obstacles, 10, 100)
draw_surface(playSurface, whiteColour, my_new_cells, 10, 100)
draw_surface(playSurface, greyColour, op_new_cells, 10, 100)
pygame.display.flip()
# speed is changeable
fpsClock.tick(my_snake.speed)
game_end(final_score1, final_score2)
def single_ai_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
isEnd = False
while True:
# give AI input, and let AI control snake
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitHelper()
elif event.type == pygame.KEYDOWN:
if event.key == ord('q'):
isEnd = True
if event.key == pygame.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.QUIT))
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
if my_snake.is_dead([]) or isEnd:
break
# When snake eats the food
if status == 1:
score += my_board.foodWeight
total_score += 1
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
playSurface.fill(blackColour)
pygame.draw.polygon(playSurface, greenColour,
[[99, 99], [99, 601], [601, 601], [601, 99]], 1)
show_message(playSurface, 'Score: ' + str(total_score), whiteColour,
40, 10, 10)
screen.blit(avatar_image, (20, 615))
show_message(playSurface, player_name, whiteColour, 40, 100, 630)
draw_surface(playSurface, redColour, food_loc, 10, 100)
draw_surface(playSurface, greenColour, my_snake.obstacles, 10, 100)
draw_surface(playSurface, whiteColour, my_new_cells, 10, 100)
pygame.display.flip()
# speed is changeable
fpsClock.tick(my_snake.speed)
game_end(total_score)
def standard_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
worm_loc = []
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
level = 1
score = 0
isEnd = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitHelper()
elif event.type == pygame.KEYDOWN:
# determine the event of keyBoard
if event.key == pygame.K_RIGHT or event.key == ord('d'):
my_snake.turn(RIGHT)
if event.key == pygame.K_LEFT or event.key == ord('a'):
my_snake.turn(LEFT)
if event.key == pygame.K_UP or event.key == ord('w'):
my_snake.turn(UP)
if event.key == pygame.K_DOWN or event.key == ord('s'):
my_snake.turn(DOWN)
if event.key == ord('q'):
isEnd = True
if event.key == pygame.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.QUIT))
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, my_board.wormhole)
#if all snake body disappeared, go to next level!
if my_snake.get_cells() == []:
my_snake.cells = [[1, 1], [1, 2],
[1, 3]] # reassign snake's position!
level += 1
score = 0
if level == 2:
for i in range(20, 30, 1):
my_snake.obstacles.append([i, 25])
elif level == 3:
for i in range(20, 30, 1):
my_snake.obstacles.append([i, 15])
my_snake.obstacles.append([i, 35])
worm_loc = []
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
if my_snake.is_dead([]) or isEnd:
break
if status == 1:
score += my_board.foodWeight
total_score += 1
if score > 1:
my_board.new_wormhole(my_new_cells, my_snake.obstacles, [])
worm_loc = [my_board.wormhole]
food_loc = []
else:
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
playSurface.fill(blackColour)
pygame.draw.polygon(playSurface, greenColour,
[[99, 99], [99, 601], [601, 601], [601, 99]], 1)
show_message(playSurface, 'Score: ' + str(total_score), whiteColour,
40, 10, 10)
show_message(playSurface, 'Level: ' + str(level), whiteColour, 40, 10,
50)
screen.blit(avatar_image, (20, 615))
show_message(playSurface, player_name, whiteColour, 40, 100, 630)
draw_surface(playSurface, redColour, food_loc, 10, 100)
draw_surface(playSurface, yellowColour, worm_loc, 10, 100)
draw_surface(playSurface, greenColour, my_snake.obstacles, 10, 100)
draw_surface(playSurface, whiteColour, my_new_cells, 10, 100)
pygame.display.flip()
# speed is changeable
fpsClock.tick(my_snake.speed)
game_end(total_score)
def __init__(self):
self.snake = Snake(self.len, self.len)
self.board = Board(self.len, self.len)
pygame.display.flip()
# Higher number, higher speed
clock.tick(12)
NEIGHBOURS = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0],
[1, 1]]
rowsz, colsz = 10, 10
cols, rows = 60, 60
size = w, h = rows * rowsz, cols * colsz
board = Board(cols, rows)
WHITE = (190, 190, 140)
ALIVE = (255, 0, 0)
DEAD = (180, 160, 100)
pygame.init()
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
# Glider
# board.get_cell(20,10).alive = True
# board.get_cell(20,12).alive = True
# board.get_cell(21,11).alive = True
# board.get_cell(21,12).alive = True
# board.get_cell(22,11).alive = True
