def setupTree(self):
'''Set up the full tree which shows all of the game states'''
self.tree = Tree()
self.tree.root.data = GameState(self.startState)
node = self.tree.root
while node is not None:
if -1 in node.data.state:
nodestate = deepcopy(node.data.state)
index = nodestate.index(-1)
node.data.state[index] = -2
node = self.tree.addNode(node)
#node = self.tree.findNode(nodeid)
if len([k for k in nodestate if k == -1 or k == -2]) % 2:
#if len(node.id) % 2 == 0:
nodestate[index] = 'X'
else:
nodestate[index] = 'O'
for i in range(len(nodestate)):
if nodestate[i] == -2:
nodestate[i] = -1
node.data = GameState(nodestate)
#node.depth = len(node.id)-1 #depth is 0-based
else:
node = node.parent
self.tree.prune(self.tree.root,
filters()) #prune the tree with the filters
def __init__(self):
super().__init__()
# Game state
self.gameState = GameState()
# Rendering properties
self.cellSize = Vector2(64,64)
# Layers
self.layers = [
ArrayLayer(self.cellSize,"assets/level/ground.png",self.gameState,self.gameState.ground,0),
ArrayLayer(self.cellSize,"assets/level/walls.png",self.gameState,self.gameState.walls),
UnitsLayer(self.cellSize,"assets/level/units.png",self.gameState,self.gameState.units),
BulletsLayer(self.cellSize,"assets/level/explosions.png",self.gameState,self.gameState.bullets),
ExplosionsLayer(self.cellSize,"assets/level/explosions.png"),
SoundLayer("assets/sound/170274__knova__rifle-fire-synthetic.wav","assets/sound/110115__ryansnook__small-explosion.wav")
]
# All layers listen to game state events
for layer in self.layers:
self.gameState.addObserver(layer)
# Controls
self.playerUnit = self.gameState.units[0]
self.gameOver = False
self.commands = [ ]
def reset(self):
"""Resets all interal attributes and returns an initial state."""
self.curr_trial = 0
starting_state = GameState()
starting_state.goalStar = self.starSequence[
0] #set goal start to first in starSequence
self.state = starting_state
return starting_state
def blank_state(self):
"""Called after an episode of 4 key presses. Sets the interal state
to a blank game state and increments the curr_trial counter."""
self.curr_trial += 1
new_state = GameState()
new_state.goalStar = self.starSequence[self.curr_trial]
self.state = new_state
return self.state
def rob_tile(self, tile_id):
if self.state.name != "ROBBING" or not self.board.can_rob_tile(
tile_id):
return False
if not self.board.players_on_tile(tile_id):
self.state = GameState("IN_TURN")
else:
self.state = GameState("ROBBING_PLAYER", {"tile": tile_id})
return True
def __setup(self):
board = self.__create_board(
) if self.__test_board is None else self.__test_board
player_ids = [player.get_player_id() for player in self.__player_seq]
player_penguin_colors = {
player_id: PENGUIN_COLORS[i]
for i, player_id in enumerate(player_ids)
}
self.__current_game_state = GameState(board, player_penguin_colors,
player_ids)
def test_keeps(self):
board = Board._board_in_play([(S, ['5G', '6G']), (F, ['1A', '2A'])])
players = [GameStatePlayer._test_gsplayer("foo", 200, dict([('American', 3), ('Festival', 5)]), set())]
player = RandomPlayer('foo')
keeps = player.keep(GameState._game_state_in_progress(players, board), [A])
self.assertEquals(len(keeps), 1)
keeps = player.keep(GameState._game_state_in_progress(players, board), [A, F])
self.assertEquals(len(keeps), 2)
def test_is_pos_out_of_bounds(self):
# tests out of bounds checker (row or col is either < 0 or >= # of rows or columns, since python indexing is
#0-based)
board = Board(4, 3, {})
state = GameState(board, {1: "black", 2: "white"}, [1, 2])
assert not state.is_pos_out_of_bounds([0, 0])
assert state.is_pos_out_of_bounds([-1, 0])
assert state.is_pos_out_of_bounds([0, -1])
assert state.is_pos_out_of_bounds([10002, 0])
assert state.is_pos_out_of_bounds([1, 10000])
def __init__(self):
self.tree = None
self.player = 1 #game start with player 1
self.player1Human = False
self.player2Human = False
self.gameover = False
self.template = StateTemplate()
#self.startState = [1,2,0,2,0,0,-2,0,1,1,2,1,2,1,1,2]
#self.startState = [1,0,0,2,0,0,0,0,0,1,1,1,-2,0,2,2]
#startState = [-1,-1,0,-2,-1,0,2,0,1,0,0,-2,0,0,0,0]
startState = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.state = GameState(startState)
def start_turn(self):
if self.state.name != "START_TURN":
return False
self.roll_dice()
r = sum(self.last_roll)
if r == 7:
p_over = self.players_over_max()
if p_over:
self.state = GameState("GIVE_AWAY", {"players_over": p_over})
else:
self.state = GameState("ROBBING")
else:
self.distribute_cards(r)
self.state = GameState("IN_TURN")
def play_cards(self) -> Tuple[np.ndarray, np.ndarray]:
state = GameState()
self._players, shuffle_indices = shuffle_list(self._players)
self._deal_cards()
state.predictions = np.array(
[player.make_prediction() for player in self._players])
player_index = 0
for blie_index in range(9):
state.current_blie_index = blie_index
state.set_starting_player_of_blie(player_index)
table_suit = -1
for i in range(4):
played_card = self._players[player_index].play_card(
state, table_suit)
if table_suit < 0:
table_suit = played_card[-1]
state.add_card(played_card, player_index)
player_index = (player_index + 1) % 4
table = np.reshape(
state.blies_history[state.current_blie_index][:8], (4, 2))
winning_index = get_winning_card_index(table, player_index)
points_on_table = get_points_from_table(table, blie_index == 8)
state.points_made[winning_index] += points_on_table
player_index = winning_index
assert np.sum(state.points_made) == 157
self._players = reverse_shuffle(self._players, shuffle_indices)
predictions = reverse_shuffle(state.predictions, shuffle_indices)
points_made = reverse_shuffle(state.points_made, shuffle_indices)
return np.array(predictions), np.array(points_made)
def play():
state = GameState()
while state.GetMoves() != []:
#print(str(state))
#TODO to implement to String state
if state.player_moved == 1:
m = UTC(root_state=state, itermax=1000, verbose=False)
else:
m = UTC(root_state=state, itermax=100, verbose=False)
#do the best chosen move
state.DoMove(m)
if state.GetResult(state.player_moved) == 0.0:
print("Player" + str(state.player_moved) + "wins!")
else:
print("Player" + str(3 - state.player_moved) + "wins!")
def boot_evaluation(eval_fn, maps, solution):
# Just give the player the 'heavy boots' ability off the bat
states = [(m, GameState(m)) for m in maps]
for _, state in states:
state.update_obtained_points(5)
return evaluate(eval_fn, states, solution)
def test_board_to_json(monkeypatch):
board = Board.create()
board_json = json.dumps(dataclasses.asdict(board))
# print(board_json) TODO: compare expected output
state = GameState.create(board)
state_json = json.dumps(dataclasses.asdict(state))
def get_q_table(q_table_empty, agent, iter_count=10000, lr=0.05, gamma=0.9):
state = GameState()
state_x_as_first = state
states_x_as_second = []
rows, cols = np.where(state.board == 0)
for i in range(len(rows)):
state_copy = copy.deepcopy(state)
x_pos = rows[i]
y_pos = cols[i]
state_copy.board[x_pos][y_pos] = game_state.o
states_x_as_second.append(state_copy)
q_table = q_table_empty
x_as_first_iter_count = iter_count // 2
x_as_second_iter_count = x_as_first_iter_count // actions_count
play_from_state(state_x_as_first, x_as_first_iter_count, lr, gamma,
q_table, agent, game_state.o)
for s in states_x_as_second:
play_from_state(s, x_as_second_iter_count, lr, gamma, q_table, agent,
game_state.x)
return q_table
def year_of_plenty(self, res1, res2):
if self.state.name != "YEAR_OF_PLENTY":
return False
self.active_player().hand.add(res1)
self.active_player().hand.add(res2)
self.state = GameState("IN_TURN")
return True
def test_do_not_move_piece_to_end_on_bigger_dice(monkeypatch):
# Given we have started the game and a piece is in the safe zone
board = Board.create(players=[0, 2], pieces_per_player=1)
state = GameState.create(board)
dice = Dice()
monkeypatch.setattr(dice, "roll", lambda: 5)
game = GameEngine(board, dice)
state.board.pieces[0].progress = board.end_progress - 3
# When we roll the dice with 5 which is bigger then we need to
# get to the goal
new_state = game.play(GameMove.roll_dice(player=0))
# Then the piece should not go to the goal and it should be the
# next player turn
assert new_state == game.get_state()
assert new_state.number == 1
assert new_state.dice == 5
assert new_state.valid_actions == [
GameMove.roll_dice(player=2),
]
assert new_state.board.pieces == [
Piece(number=0, player=0, progress=board.end_progress - 3),
Piece(number=0, player=2, progress=0),
]
assert new_state.winners == []
def test_play_roll_dice_3(monkeypatch):
# Given
board = Board.create(players=[1, 3])
state = GameState.create(board)
dice = Dice()
monkeypatch.setattr(dice, "roll", lambda: 3)
game = GameEngine(board, dice)
# When
new_state = game.play(GameMove.roll_dice(player=1))
# Then
assert new_state == game.get_state()
assert new_state.number == 1
assert new_state.dice == 3
assert new_state.valid_actions == [GameMove.roll_dice(player=3)]
# And When
new_state = game.play(GameMove.roll_dice(player=3))
# Then
assert new_state == game.get_state()
assert new_state.number == 2
assert new_state.dice == 3
assert new_state.valid_actions == [GameMove.roll_dice(player=1)]
def testReader():
sleep(1)
gs = GameState(ScreenInterpreter(speed=0.2))
player = Player(gs)
while True:
gs.update()
print("Gold: ", gs.getGold())
print("Level: ", gs.getLevel())
print("Store: ", gs.getStore())
print("xp: ", gs.getXpToLevelUp())
print("Hp: ", gs.getHp())
player.randomAction()
sleep(0.1)
def test_which_action_to_take_one_turn(self):
board = Board(2, 5, {}, num_of_fish_per_tile=2)
state = GameState(board, {1: "black", 2: "white"}, [2, 1],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], [1, 3]], 2: [[1, 0], [1, 1], [1, 2], [1, 4]]})
strategy = Strategy(state, 2)
assert strategy.which_action_to_take(1) == ((1, 2), (0, 3))
def test_zig_zag(self):
board = Board(2, 5, {0: [0, 1]}, num_of_fish_per_tile=2)
state = GameState(board, {1: "black", 2: "white"}, [2, 1],
penguin_posns={1: [[0, 0], [0, 1], [0,2], []], 2: [[1, 0], [1, 1], [], []]})
strategy = Strategy(state, 2)
assert strategy.zig_zag() == [0,3]
state = GameState(board, {1: "black", 2: "white"}, [1, 2],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], []], 2: [[1, 0], [1, 1], [0, 3], []]})
strategy = Strategy(state, 1)
assert strategy.zig_zag() == [0,4]
state = GameState(board, {1: "black", 2: "white"}, [2, 1],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], [0, 4]], 2: [[1, 0], [1, 1], [0, 3], []]})
strategy = Strategy(state, 2)
assert strategy.zig_zag() == [1,2]
def init():
initial_board_state = GameState(state=Board(), next_to_move=1)
root = MonteCarloTreeSearchNode(state=initial_board_state, parent=None)
mcts = MonteCarloTreeSearch(root)
best_node = mcts.best_action(100)
c_state = best_node.state
c_board = c_state.board
return c_state, c_board
def test_buy_stock(self):
board = Board._board_in_play([(S, ['5G', '6G']), (F, ['1A', '2A'])])
players = [GameStatePlayer._test_gsplayer("foo", 200, dict([('American', 3), ('Festival', 5)]), set())]
player = OrderedPlayer('foo')
buys = player._buy_stock(GameState._game_state_in_progress(players, board))
self.assertEquals(buys, ['American'])
def pass_turn(self):
if self.state.name != "IN_TURN":
return False
self.active_id = (self.active_id + 1) % self.num_players
if self.active_id == self.starting_id:
self.turn += 1
self.state = GameState("START_TURN")
return True
def build_structure(self, structure):
if self.state.name != "IN_TURN":
return False
cost = h.required_hand(structure)
if self.active_player().can_build(structure, cost):
self.state = GameState("BUILDING", {"structure": structure})
return True
return False
def test_game_tree_complete_depth(self):
# tests that the depth of the complete game tree is as expected
board = Board(2, 5, {}, num_of_fish_per_tile=2)
state = GameState(board, {1: "black", 2: "white"}, [2, 1],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], [1, 3]], 2: [[1, 0], [1, 1], [1, 2], [1, 4]]})
game = GameTree(state)
game.next_layer()
game.next_layer()
assert game.next_layer() == "Game Done"
def get(self):
user = users.get_current_user()
if not user:
json.dump(dict(error="not signed in"), self.response.out)
return
application.sendMessageAll({'action': 'reset'})
application.gameState = GameState()
application.setupHandlers(application.gameState)
def __init__(self):
self.gameState = GameState()
self.setupHandlers(self.gameState)
handlers = [(r"/", MainHandler),
(r"/currentBoard", CurrentBoardHandler),
(r"/action", ActionHandler), (r"/reset", ResetHandler)]
settings = dict(debug=True)
webapp.WSGIApplication.__init__(self, handlers, **settings)
def test_which_action_invalid_input(self):
board = Board(2, 5, {}, num_of_fish_per_tile=2)
state = GameState(board, {1: "black", 2: "white"}, [2, 1],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], [1, 3]], 2: [[1, 0], [1, 1], [1, 2], [1, 4]]})
strategy = Strategy(state, 2)
with self.assertRaises(ValueError):
strategy.which_action_to_take(0)
def test_which_action_to_take_tiebreaker(self):
# tests both cases of the tiebreaker
board = Board(2, 5, {})
state = GameState(board, {1: "black", 2: "white"}, [1, 2],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], [1, 3]], 2: [[1, 0], [1, 1], [1, 2], [1, 4]]})
strategy = Strategy(state, 1)
assert strategy.which_action_to_take(1) == ((1, 3), (0, 3))
def play_dev_card(self, card):
if self.state.name != "IN_TURN" or not self.active_player(
).development.has(card) or card == VICTORY_POINT:
return False
self.active_player().play_dev(card)
if card == ROAD_BUILDING and not self.active_player().can_place_piece(
ROAD):
return False
elif card == ROAD_BUILDING:
self.state = GameState("ROAD_BUILDING", {"remaining_roads": 2})
elif card == MONOPOLY:
self.state = GameState("MONOPOLY")
elif card == YEAR_OF_PLENTY:
self.state = GameState("YEAR_OF_PLENTY")
else:
self.update_largest_army()
self.state = GameState("ROBBING")
return True
def test_execute_action_illegal(self):
# tests the behavior of execute_action with regards to an illegal move
board = Board(4, 5, {}, num_of_fish_per_tile=2)
state = GameState(board, {1: "black", 2: "white"}, [2, 1],
penguin_posns={1: [[0, 0], [0, 1], [0, 2], [1, 3]], 2: [[1, 0], [1, 1], [1, 2], [1, 4]]})
game = GameTree(state)
game.next_layer()
assert not game.execute_action(((-1,0), (3,0)))
assert not game.execute_action(((1, 0), (4, 0)))
def test_get_sellbacks_merge(self):
player1 = GameStatePlayer._test_gsplayer("joe", 6000, {A:5}, [t5A])
player2 = GameStatePlayer._test_gsplayer("obama", 6000, {S:4}, [])
player3 = GameStatePlayer._test_gsplayer("kerry", 6000, {W:4}, [])
player4 = GameStatePlayer._test_gsplayer("romney", 6000, {W:4}, [])
player5 = GameStatePlayer._test_gsplayer("ryan", 6000, {W:4}, [])
player6 = GameStatePlayer._test_gsplayer("mumblesmenino", 6000, {W:4}, [])
board = Board._board_in_play([(A, [t4A, t3A]), (S, [t6A, t7A]), (W, [t5B, t5C])])
gt = GameTree(GameState._game_state_in_progress([player1, player2, player3, player4, player5, player6], board))
self.assertEqual(len(list(gt.get_sellbacks(t5A, A))), (2**2)**6)
def test_buy_stock(self):
board = Board._board_in_play([(S, ['5G', '6G'])])
players = [GameStatePlayer._test_gsplayer("foo", 6000, dict([('Sackson', 3)]), set(['2B']))]
player = RandomPlayer('foo')
buys = player._buy_stock(GameState._game_state_in_progress(players, board))
self.assertTrue(len(buys)<=2)
if len(buys)!=0:
self.assertTrue(buys[0]!='Worldwide')
def test_tile_placement(self):
board_singleton = Board._board_in_play(dict([]))
players_singleton = [GameStatePlayer._test_gsplayer("foo", 6000, dict([]), set(['2B', '1A', '3D']))]
player = OrderedPlayer('foo')
tile, hotel, movetype = player._place_tile(GameState._game_state_in_progress(players_singleton, board_singleton))
self.assertEquals(tile, '1A')
self.assertEquals(hotel, None)
self.assertEquals(movetype, SINGLETON)
test_board = [(C, ['3E', '4E']), (I, ['5G', '3G', '4G'])]
board_merge = Board._board_in_play(test_board)
players_merge = [GameStatePlayer._test_gsplayer("foo", 6000, dict([]), set(['3F', '6G', '3H']))]
tile, hotel, movetype = player._place_tile(GameState._game_state_in_progress(players_merge, board_merge))
self.assertEquals(tile, '3F')
self.assertEquals(hotel, "Imperial")
self.assertEquals(movetype, MERGE)
def get(self):
s = GameState()
s.get_board().dump(self.response.out)
def test_get_sellbacks_no_merge(self):
gt = GameTree(GameState._game_state_in_progress([GameStatePlayer._test_gsplayer("joe", 6000, {A:5}, [t5A])],
Board()))
self.assertEqual(gt.get_sellbacks(t5A, None), [{}])
