def test_board_execute_move_3_1_1():
board = Board(3)
board.execute_move([1, 1])
assert board.board == [[' ', ' ', ' '], [' ', 'X', ' '], [' ', ' ', ' ']]
assert board.turn == 2
assert board.gameover == False
def test_board_init_4():
board = Board(4)
assert board.board == [[' ', ' ', ' ', ' '], [' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ']]
assert board.turn == 1
assert board.gameover == False
def test_board_execute_move_invalid():
board = Board(3)
board.execute_move([1])
assert board.board == [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
assert board.turn == 1
assert board.gameover == False
def prepare_game(board_file: str, players: List[discord.User],
channel: discord.TextChannel) -> MonopolyCore.Monopoly:
players_class = []
for player in players:
players_class.append(Player.Player(player))
board = Board.Board(board_file)
return MonopolyCore.Monopoly(monopoly_bot, channel, players_class, board)
def main():
"""Run the XOD game loop."""
board = Board()
player_1 = CPU('X', 'O')
player_2 = CPU('O', 'X')
board.display()
while True:
player_1.move(board)
board.display()
winner = board.is_there_a_winner()
if winner == player_1.marker:
print('Player %s has won!' % winner)
break
elif winner == '-':
print('No winners.')
break
player_2.move(board)
board.display()
winner = board.is_there_a_winner()
if winner == player_2.marker:
print('Player %s has won!' % winner)
break
elif winner == '-':
print('No winners.')
break
def test_has_difference_true(self):
test_board = Board(dimension=n, color_count=m)
test_plate = [[
random.choice(string.ascii_uppercase) for i in range(n)
] for j in range(n)]
test_plate[0][0] = '1'
test_board.set_plate(plate=test_plate)
self.assertEqual(True, test_board.has_differences())
def test_current_player(self):
b = Board()
self.assertEqual(b.current_player(), 'p1')
b.tick()
self.assertEqual(b.current_player(), 'p2')
b.tick()
self.assertEqual(b.current_player(), 'p1')
def load_scenario(self):
"""Load the chosen Scenario."""
self.rendering_mode = RenderingMode.LOAD_SCENARIO
# Unpickle the Scenario file
self.scenario = load(open(self.scenario, "rb"))
# Log Version of the scenario and code
print("Loading Scenario Version %s with code base Version %s" %
(self.scenario.get_version(), __version__))
license = self.scenario.get_license()
if license is not None:
print("Scenario licensed as follows:")
print("")
print(license)
else:
print("No license provided in scenario file.")
# Get the logo to display (if any)
self.logo = self.scenario.get_logo()
# Load variables into memory
self.step = self.scenario.get_board_step()
self.height = self.scenario.get_logical_height() * self.step
self.width = self.scenario.get_logical_width() * self.step
self.board = Board(self.scenario)
self.robot = BeeBot(self.scenario)
self.clock = pygame.time.Clock()
buttons_on_the_left = True
self.create_buttons(buttons_on_the_left)
if buttons_on_the_left:
# Make space for:
# - the Buttons to the right of the map.
# - the CommandLog below the map.
self.size = (self.width + 400, self.height + 30)
# Create the empty CommandLog
self.command_log = CommandLog(Point(0, self.height),
(self.width, 30))
else:
# Make space for:
# - the Buttons below the map.
# - the CommandLog to the right of the map.
self.size = (self.width + 30, self.height + 400)
# Create the empty CommandLog
self.command_log = CommandLog(Point(self.width, 0),
(30, self.height))
# Only want to do this once, so sadly can't do it in the rendering
# loop without a potential race condition as
# size gets set by loading the Scenario
if self._rendering_running:
self.screen = pygame.display.set_mode(self.size)
def test_score_calculation(self):
current_state = [[0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 2, 2],
[0, 2, 4, 4]]
current_score = 0
test_board = Board(current_state)
test_board.move_board('down')
test_board_score = test_board.score
self.assertEqual(current_score + 4, test_board_score)
def test_score_calculation_multiple_merges(self):
current_state = [[0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 2, 2],
[0, 2, 4, 4]]
current_score = 0
test_board = Board(current_state)
test_board.move_board('left')
test_board_score = test_board.score
self.assertEqual(current_score + 12, test_board_score)
def test_move_left_restricted(self):
current_state = [[2, 0, 0, 0], [2, 0, 0, 0], [4, 2, 0, 0],
[4, 2, 0, 0]]
test_board = Board(current_state)
test_board.move_board('left')
next_state = test_board.board
self.assertEqual(next_state, current_state)
def test_random_spawn_on_stationary_board(self):
current_state = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 2],
[0, 2, 4, 4]]
test_board = Board(current_state)
test_board.move_board('down')
test_board.add_random_tile() # should not spawn a random tile
self.assertEqual(current_state, test_board.board)
def test_move_down_restricted(self):
current_state = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 2],
[0, 2, 4, 4]]
test_board = Board(current_state)
test_board.move_board('down')
next_state = test_board.board
self.assertEqual(next_state, current_state)
def test_move_right_restricted(self):
current_state = [[0, 0, 0, 2], [0, 0, 0, 2], [0, 0, 2, 4],
[0, 0, 2, 4]]
test_board = Board(current_state)
test_board.move_board('right')
next_state = test_board.board
self.assertEqual(next_state, current_state)
def train(input_size: int, hidden_size: int, num_classes: int, num_epochs: int,
num_games: int, batch_size: int, learning_rate: float,
mcts_iter: int):
# Create the model
input_shape = (6, 7, 2)
model = model_structure(hidden_size, input_shape)
model._make_predict_function()
# Train the model
for e in range(num_games):
# Create the board
b = Board()
# Create the players and the game
p1 = NNPlayer(1, b, model, training=True)
p2 = NNPlayer(2, b, model, training=True)
nn_g = NNRecordedGame_mp(b, p1, p2, mcts_iter)
nn_g.initialize()
# Play the game
nn_g.play_a_game(True)
# Get all winner's moves
# if nn_g.winner == p1.name:
# input_data, output_data = get_all_player_moves(nn_g, p1)
# elif nn_g.winner == p2.name:
# input_data, output_data = get_all_player_moves(nn_g, p2)
# else:
input_p1, output_p1 = get_all_player_moves(nn_g, p1)
input_p2, output_p2 = get_all_player_moves(nn_g, p2)
input_data = np.concatenate([input_p1, input_p2])
output_data = np.concatenate([output_p1, output_p2])
# build the batch
step = int(len(input_data) / batch_size)
if step > 0:
input_data = build_batch(input_data, step)
output_data = build_batch(output_data, step)
e_batch_size = batch_size
else:
e_batch_size = len(input_data)
# fit the model
model.fit(input_data,
output_data,
batch_size=e_batch_size,
epochs=num_epochs * (e + 1),
initial_epoch=num_epochs * e,
verbose=1)
# save the model every 100 games played
if e and e % 100 == 0:
model.save(f'{round(time.time())}_my_model.h5')
return model
def test_move_down(self):
current_state = [[0, 0, 0, 2], [0, 0, 0, 2], [0, 0, 2, 2],
[0, 0, 0, 2]]
test_board = Board(current_state)
test_board.move_board('down')
next_state = test_board.board
true_next_state = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 4],
[0, 0, 2, 4]]
self.assertEqual(next_state, true_next_state)
def test_move_left(self):
current_state = [[0, 0, 0, 2], [0, 0, 0, 2], [0, 0, 2, 2],
[0, 0, 0, 2]]
test_board = Board(current_state)
test_board.move_board('left')
next_state = test_board.board
true_next_state = [[2, 0, 0, 0], [2, 0, 0, 0], [4, 0, 0, 0],
[2, 0, 0, 0]]
self.assertEqual(next_state, true_next_state)
def test_board_check_win_ver():
board = Board(3)
board.execute_move([0, 0])
board.execute_move([0, 1])
board.execute_move([1, 0])
board.execute_move([1, 1])
board.execute_move([2, 0])
board.check_win()
assert board.board == [['X', 'O', ' '], ['X', 'O', ' '], ['X', ' ', ' ']]
assert board.gameover == True
def one_turn(self):
"""
Run one turn of the game.
Returns:
continue (bool): whether restart the game
"""
# initiate the board
board_size = self.view.get_board_size()
if board_size == {}:
board = Board()
else:
board = Board(mine_count=board_size["mine_count"],
width=board_size["width"],
height=board_size["height"])
while not board.is_game_finish():
operation = self.view.run(board.get_board())
if not board.update(operation["x"], operation["y"],
operation["flag"]):
self.view.draw(board.get_board())
return self.view.fail()
return self.view.win()
def acquireSample(state):
gui = GUI()
board = Board()
board.startDataAcquisition()
gui.loadImage(state)
time.sleep(10)
sample = board.getEGG_Data()
board.releaseBoardSession()
gui.closeImage()
return sample
def test_play_10_games_randomVSrandom(self):
board = Board()
player1 = RandomPlayer()
player2 = RandomPlayer()
match = Match()
cross_count, naught_count, draw_count = match.play(
player1, player2, 10)
self.assertGreaterEqual(cross_count, 0)
self.assertGreaterEqual(naught_count, 0)
self.assertGreaterEqual(draw_count, 0)
def __init__(self, tree, manager, dimension, numbered):
self.com_moves = []
self.user_moves = []
self.game = {'com': self.com_moves, 'user': self.user_moves}
self.tree = tree
self.manager = manager
self.dimension = dimension
self.game_board = Board(dimension, numbered)
fin_game = self.play()
if self.game_board.won:
manager.trainer(fin_game,
tree,
board=self.game_board,
dimension=self.dimension)
def test_board_check_win_diag():
board = Board(3)
board.execute_move([0, 0])
board.execute_move([0, 1])
board.execute_move([1, 1])
board.execute_move([1, 2])
board.execute_move([2, 2])
assert board.size == 3
assert board.board == [['X', 'O', ' '], [' ', 'X', 'O'], [' ', ' ', 'X']]
board.check_win()
assert board.gameover == True
def set_up_game() -> Game:
"""
This function sets up the logic and data structures for the game by
initializing relevant classes
"""
global GAME_MODE
game_board = Board(DIMENSION)
player1 = Human("Player 1", game_board)
if GAME_MODE == 0:
return Game(player1, Human("Player 2", game_board), game_board)
elif GAME_MODE == 1:
return Game(player1, EasyAI("Player 2", game_board), game_board)
elif GAME_MODE == 2:
return Game(player1, MediumAI("Player 2", game_board), game_board)
elif GAME_MODE == 3:
return Game(player1, HardAI("Player 2", game_board), game_board)
def fire(self, lograte, print_board=False):
for j in range(self.n_games):
if j % lograte == 0:
print(f'Playing Game {j + 1}')
b = Board()
self.player_one.board = b
self.player_two.board = b
g = Game(b, self.player_one, self.player_two)
g.play_a_game(print_board)
if j % lograte == 0:
print(f'Player {g.winner} won')
if g.winner is not None:
self.results[g.winner] += 1
print(f'Player {self.player_one.name} won'
f' {self.results[self.player_one.name]} times\n'
f'Player {self.player_two.name} won'
f' {self.results[self.player_two.name]} times')
def __init__(self):
# Set up frame and window
self.ROOT = Tk()
self.EMPTY_FOUNDATION = PhotoImage(file='assets\\foundation.png')
self.ROOT.config(pady=5)
self.ROOT.title("Baker's Dozen")
self.ROOT.geometry("1050x725")
# Create game board
self.mainboard = Board(self.ROOT)
# Place placeholders
self.place_placeholders()
# Start the main window loop
self.ROOT.mainloop()
def setUp(self):
"""
Create a minimal Scenario and use it to create a Board.
The Scenario is 5x5 (logical size) with the no BeeBot,
but one Obstacle and Goal.
"""
# Create the minimal Scenario
test_scenario = Scenario('Test')
test_scenario.set_board_step(150)
test_scenario.set_logical_width(5)
test_scenario.set_logical_height(8)
test_scenario.set_background('img/Default/background.jpg')
test_scenario.add_goal(0, 0)
test_scenario.add_obstacle(1, 1)
# Create the test Board
self.test_board = Board(test_scenario)
def load_scenario(self):
"""Load the chosen Scenario."""
self.rendering_mode = RenderingMode.LOAD_SCENARIO
# Unpickle the Scenario file
self.scenario = load(open(self.scenario, "rb"))
# Log Version of the scenario and code
print("Loading Scenario Version %s with code base Version %s" %
(self.scenario.get_version(), __version__))
license = self.scenario.get_license()
if license is not None:
print("Scenario licensed as follows:")
print("")
print(license)
else:
print("No license provided in scenario file.")
# Get the logo to display (if any)
self.logo = self.scenario.get_logo()
# Load variables into memory
self.step = self.scenario.get_board_step()
self.height = self.scenario.get_logical_height() * self.step
self.width = self.scenario.get_logical_width() * self.step
self.board = Board(self.scenario)
self.robot = BeeBot(self.scenario)
self.clock = pygame.time.Clock()
buttons_on_the_left = True
self.create_buttons(buttons_on_the_left)
if buttons_on_the_left:
self.size = (self.width + 400, self.height)
else:
self.size = (self.width, self.height + 400)
self.screen = pygame.display.set_mode(self.size)
def fire(self):
for j in range(self.n_games):
print(f'Playing Game {j + 1}')
b = Board()
self.player_one.board = b
self.player_two.board = b
rg = RecordedAIGame(b, self.player_one, self.player_two)
rg.initialize()
rg.play_a_game()
print(f'Player {rg.winner} won')
if rg.winner is not None:
self.results[rg.winner] += 1
actions, states, res = rg.export_final_results()
if res is 'ok' and b.plays > 3:
dim_s = states.shape[0]
last_states = states[np.array([dim_s - 2, dim_s - 1])]
self.states = np.append(self.states, last_states, axis=0)
last_actions = actions[np.array([dim_s - 2, dim_s - 1])]
self.actions = np.append(self.actions, last_actions, axis=0)
print(f'Player {self.player_one.name} won {self.results[self.player_one.name]} time'
f's\nPlayer {self.player_two.name} won {self.results[self.player_two.name]} tim'
f'es')
def set_up_new_game(self):
self.board = Board(self.display)
self.pieces = []
self.players = []
# For two teams, white and black
for t in [True, False]:
# Create a lay out the pieces
self.pieces.append(King(self.display, t))
self.pieces.append(Queen(self.display, t))
for p in range(8):
self.pieces.append(Pawn(self.display, t, p))
if p < 2:
self.pieces.append(Bishop(self.display, t, p))
self.pieces.append(Knight(self.display, t, p))
self.pieces.append(Rook(self.display, t, p))
# Also create a player for the team
#self.players.append(Player(t,True))
self.players.append(Player(t, t))
self.turn_counter = 0