def test_draw_and_check_no_match(self):
game_state = GameState(1)
domino = Domino(2, 3)
game_state.dominoes.append(domino)
player = Player(0, TestBot())
self.assertFalse(game_state.draw_domino_and_check_for_start(player, Domino(12, 12)))
self.assertEqual(1, len(player.dominoes))
self.assertEqual(domino, player.dominoes.pop())
def h(self, game: GameState):
if game.terminal():
return game.winner()
for _ in range(self.nbr_rollouts):
self.do_rollout(game)
return self.h_score(self.choose(game))
def test_draw_domino(self):
game_state = GameState(1)
domino = Domino(2, 3)
game_state.dominoes.append(domino)
player = Player(0, TestBot())
self.assertTrue(game_state.draw_domino(player))
self.assertEqual(1, len(player.dominoes))
self.assertEqual(domino, player.dominoes.pop())
def setUp(self) -> None:
self.map0 = '../game_states/game0_repr.json'
self.game_state = GameState(self.map0)
self.ih = InputHandler(self.game_state)
self.map1 = '../game_states/game1_cake.json'
self.game_state1 = GameState(self.map1)
self.ih1 = InputHandler(self.game_state1)
def _simulate(self, node: GameState):
"Returns the reward for a random simulation (to completion) of `node`"
invert_reward = True
while True:
if node.terminal():
reward = node.reward()
return 1 - reward if invert_reward else reward
node = node.push(node.random_move())
invert_reward = not invert_reward
def test_draw_and_check_match(self):
game_state = GameState(1)
# This is the next tile that the player will draw after drawing and placing the starting tile
domino = Domino(2, 3)
game_state.dominoes.append(domino)
game_state.dominoes.append(Domino(12, 12))
player = Player(0, TestBot())
self.assertTrue(game_state.draw_domino_and_check_for_start(player, Domino(12, 12)))
self.assertEqual(1, len(player.dominoes))
self.assertEqual(domino, player.dominoes.pop())
def test_place_domino(self):
game_state = GameState(1)
player = Player(0, TestBot())
domino = Domino(2, 3)
player.dominoes.append(domino)
train = Train(0, 2, player)
game_state.place_domino(train, domino, player)
self.assertEqual(0, len(player.dominoes))
self.assertEqual(domino, game_state.played.pop())
self.assertEqual(1, game_state.played_count[2])
self.assertEqual(1, game_state.played_count[3])
self.assertEqual(0, game_state.played_count[0])
def choose(self, node: GameState):
def score(n):
if self.N[n] == 0:
return float("-inf") # avoid unseen moves
return self.Q[n] / self.N[n] # average reward
"Choose the best successor of node. (Choose a move in the game)"
if node.terminal():
raise RuntimeError(f"choose called on terminal node {node}")
if node not in self.children:
return node.random_child()
return max(self.children[node], key=score)
def enter_pressed(self, e):
try:
GameState(join(parent_path, self.tkvar.get()))
self.retun_val = self.tkvar.get()
self.window.destroy()
except Exception as e:
self.label.config(text='' + str(e))
class Application:
def __init__(self):
self.running = True
self.window = Window(self, 900, 600, 'Boxes')
self.game_state = GameState(self)
def run(self):
"""
Main function of the game
:return: None
"""
self.window.init()
self.game_state.preupdate()
while self.running:
self.game_state.update()
self.window.display()
def run():
try:
config_files = MainUtils.get_config_files()
game_state_file = _select(config_files, "the game")
game_state = GameState(MainUtils.get_game_state_path(game_state_file))
game = GameConsole(game_state)
game.run_console()
except GameStateFileException as e:
print(f"Failed to read game configuration file: {e}")
def do_rollout(self, node: GameState):
node = node.__copy__()
"Make the tree one layer better. (Train for one iteration.)"
path = self._select(node)
leaf = path[-1]
self._expand(leaf)
if self.heuristic is None:
reward = self._simulate(leaf.__copy__())
else:
reward = self.heuristic.h(node)
self._backpropagate(path, reward)
def __init__(self):
"""!
@pre none
@post The members of the Battleship object are initialized, including the game view and state. The number of ships and opponent are determined and stored in the game state.
"""
self.view = BattleshipView()
self.gs = GameState()
self.gs.msg = "Awaiting number of ships..."
self.view.draw(self.gs)
self.gs.numShipsPerPlayer = self.view.get_num_ships()
self.gs.playerType = self.view.get_player_type()
if not self.gs.playerType == 1:
self.AI = AI(self.gs.playerType)
def action(self, game: GameState):
if game.game_over():
return None
possibleMoves = game.legal_moves()
boards = game.children()
win_h = self.win_heuristic(boards)
if not win_h == -1:
return possibleMoves[win_h], 1
evals = self.heuristic.hs(boards)
evals = self.default_heuristic(boards, evals)
if self.variance:
if not game.turn():
evals = [1 - e for e in evals]
total = sum(evals)
evals = [e / total for e in evals]
choice = random.random()
s = 0
for idx, e in enumerate(evals):
s += e
if choice <= s:
bestIdx = idx
break
else:
if game.turn():
bestIdx = np.argmax(evals)
else:
bestIdx = np.argmin(evals)
bestMove = possibleMoves[bestIdx]
return bestMove, evals[bestIdx]
def play(next_bet: Callable[[GameState], Optional[Bet]],
end_of_game: Callable[[GameState], bool] = ExitStrategy.exit,
initial_units: int = 1000) -> GameState:
state = GameState.initial_state(initial_units)
bet = next_bet(state)
while state.can_play(bet) and not end_of_game(state):
state = state.place_bets(bet)
winning_number = Roulette.roll()
state = state.end_of_round(
winning_number,
Roulette.evaluate(state.bet.selection, winning_number)
if bet else 0)
bet = next_bet(state)
return state
def play(self, game: GameState, verbose=False):
if self.alternate:
temp = self.actionModel1
self.actionModel1 = self.actionModel2
self.actionModel2 = temp
states = []
hs = []
if verbose:
print(game)
while not game.game_over():
actingModel = self.actionModel1 if game.turn() else self.actionModel2
move, h = actingModel.action(game)
states.append(game.__copy__())
hs.append(h)
game.push(move)
if verbose:
print("move: " + str(move) + " h: " + str(h))
print(game)
return game.winner(), states, hs
def init_game(game_path):
game_state = GameState(game_path)
return GameGUI(game_state)
def action(self, game: GameState):
print(game.__str__())
moves = game.legal_moves()
print(game.moves_str())
inp = int(input())
return moves[inp], 0
class Game:
"""
The Game of Mexican Train! Yay! \m/
"""
def __init__(self, player_count):
"""
Create a Game for the specified number of players.
:param player_count: How many players are playing.
"""
self.game_state = GameState(player_count)
def play(self, print_each_round=False):
"""
Play the game!
:param print_each_round: Flag to print out the results of each round.
"""
for cur_round in range(12, -1, -1):
self.game_state.start_round(cur_round)
self.play_round()
if print_each_round:
self.print_round(cur_round)
self.game_state.clean_up_after_round()
def play_round(self):
"""
Play the current round.
"""
while not self.game_state.round_over:
self.take_turn()
self.check_for_victory()
self.game_state.next_player()
def take_turn(self):
"""
Take a turn for the current active player, as determined by the GameState.
"""
player = self.game_state.current_player
player.can_play = True
bot_game_state = BotGameState(self.game_state, player)
drew = False
played = False
done = False
first = player.turn == 0
player.bot.start_turn(player.turn)
while not done:
valid_moves = bot_game_state.get_all_valid_moves()
if len(valid_moves) == 0:
if not played and not drew:
domino = self.game_state.draw_domino(player)
if not domino:
player.can_play = False
done = True
else:
bot_game_state.draw_domino(domino)
drew = True
else:
done = True
else:
move = player.bot.get_move(bot_game_state)
if not self.validate_move(move, player):
player.bot.report_invalid_move(move)
shuffle(valid_moves)
move = valid_moves.pop()
if move.domino.is_double:
drew = False
played = False
else:
played = True
self.do_move(player, move)
bot_game_state.do_move(move)
if played and not first:
done = True
player.turn += 1
def validate_move(self, move: BotMove, player: Player) -> bool:
"""
Validate if a move can be played.
:param move: The move to attempt
:param player: The player attempting the move
:return: True if the move is legal, False otherwise.
"""
return self.get_train_from_move(move).is_valid_play(move.domino, player) and \
player.dominoes.count(move.domino) > 0 and \
self.game_state.played.count(move.domino) == 0
def get_train_from_move(self, move: BotMove) -> Train:
"""
Helper method to extract the train from the game state for a given BotMove.
This is required as the BotMove only contains a reference to the BotTrain.
:param move: The BotMove to get the train for.
:return: The corresponding Train.
"""
return self.game_state.trains[move.train.identity.train_id]
def do_move(self, player: Player, move: BotMove):
"""
Actually execute a move!
:param player: The player making the move.
:param move: The move the player is attempting to make.
:return: True if the move was executed successfully.
"""
if player.dominoes.count(move.domino) == 0:
raise RuntimeError(
"Cannot add Domino that player doesn't have! \n Move: {} \n Dominoes {} \n {} \n Played {}".
format(move, player.dominoes, self.get_train_from_move(move), self.game_state.played))
if self.game_state.played.count(move.domino) > 0:
raise RuntimeError(
"Cannot play a domino that has already been played! \n Move: {} \n Dominoes {} \n {} \n Played {}".
format(move, player.dominoes, self.get_train_from_move(move), self.game_state.played))
train = self.get_train_from_move(move)
if train.add_domino(move.domino, player):
player.dominoes.remove(move.domino)
self.game_state.played.append(move.domino)
return True
return False
def check_for_victory(self):
"""
Check to see if somebody has won. If so tell every player that the round is over.
"""
player = self.game_state.current_player
if len(player.dominoes) == 0:
self.game_state.round_over = True
self.game_state.round_winner = player
for p in self.game_state.players:
p.end_round(p == player)
else:
all_cannot_play = True
for player in self.game_state.players:
if player.can_play:
all_cannot_play = False
break
if all_cannot_play:
inter_players = iter(self.game_state.players)
min_player = next(inter_players)
min_player.score += min_player.calc_score()
for p in inter_players:
if len(p.dominoes) < len(min_player.dominoes) or \
(len(p.dominoes) == len(min_player.dominoes) and p.calc_score() < min_player.calc_score()):
min_player = p
self.game_state.round_over = True
self.game_state.round_winner = min_player
for p in self.game_state.players:
p.end_round(p == min_player)
def print_round(self, round_numb: int):
"""
Format the output for the round and print it to the console.
:param round_numb: The current round number.
"""
output = "Mexican Train! - Round {} Winner: Player {}!\n". \
format(round_numb, str(self.game_state.round_winner.identity.id))
output += '\n'.join([str(player) for player in self.game_state.players])
output += '\n'
output += '\n'.join([str(train) for train in self.game_state.trains])
output += '\n===========================================\n\n'
print(output)
def get_stats(self):
"""
Create a map of player ID to victories + score, for tracking across multiple games.
:return:
"""
return {player.identity.id: [player.victories, player.score] for player in self.game_state.players}
def test_draw_and_check_none_to_draw(self):
game_state = GameState(1)
player = Player(0, TestBot())
# Need to use a lambda here or the test just fails with the RuntimeError
self.assertRaises(RuntimeError, lambda: game_state.draw_domino_and_check_for_start(player, Domino(12, 12)))
self.assertEqual(0, len(player.dominoes))
def test_draw_domino_none_to_draw(self):
game_state = GameState(1)
player = Player(0, TestBot())
self.assertFalse(game_state.draw_domino(player))
self.assertEqual(0, len(player.dominoes))
def _expand(self, node: GameState):
"Update the `children` dict with the children of `node`"
if node in self.children:
return # already expanded
self.children[node] = set(node.children())
def h_score(self, game: GameState):
s = self._score(game)
return 1 - s if game.turn() else s
def __init__(self):
self.running = True
self.window = Window(self, 900, 600, 'Boxes')
self.game_state = GameState(self)
def __init__(self, player_count):
"""
Create a Game for the specified number of players.
:param player_count: How many players are playing.
"""
self.game_state = GameState(player_count)
from src.Expectimax import Expectimax
# Parsing command line arguments
parser = argparse.ArgumentParser()
parser.add_argument('-s', dest='size', type=int)
parser.add_argument('-b', dest='blanks', action='store_true')
parser.add_argument('-e', dest='expectimax', action='store_true')
parser.add_argument('-p', dest='prune', action='store_true')
results = parser.parse_args()
if not results.size:
results.size = 15
rules = ScrabbleRules(blanks=results.blanks, size=results.size)
state = GameState(blanks=results.blanks, size=results.size)
view = View()
agent_0 = Agent()
agent_1 = Agent()
state.add_agent(0, agent_0)
state.add_agent(1, agent_1)
state.place('A', [(results.size // 2, results.size // 2)], 0, rules)
state.draw(0)
state.draw(1)
# Play
agents = [0, 1]
try:
while True:
for agent in agents:
def test_draw_and_check_match_last_tile(self):
game_state = GameState(1)
game_state.dominoes.append(Domino(12, 12))
player = Player(0, TestBot())
self.assertTrue(game_state.draw_domino_and_check_for_start(player, Domino(12, 12)))
self.assertEqual(0, len(player.dominoes))