def __init__(self, sess, reuse=True, num_unrolls=1, game_state=None, net_scope=None): if net_scope is None: with tf.name_scope('agent'): with tf.variable_scope('nav_global_network', reuse=reuse): self.network = FreeSpaceNetwork(constants.GRU_SIZE, 1, num_unrolls) self.network.create_net() else: with tf.variable_scope(net_scope, reuse=True): self.network = FreeSpaceNetwork(constants.GRU_SIZE, 1, 1) self.network.create_net(add_loss=False) if game_state is None: self.game_state = GameState(sess=sess) else: self.game_state = game_state self.action_util = self.game_state.action_util self.gt_graph = None self.sess = sess self.num_steps = 0 self.global_step_id = 0 self.num_unrolls = num_unrolls self.pose_indicator = np.zeros( (constants.TERMINAL_CHECK_PADDING * 2 + 1, constants.TERMINAL_CHECK_PADDING * 2 + 1)) self.times = np.zeros(2)
class Game: def __init__(self, slack_client): self.slack_client = slack_client self.game_state = GameState(slack_client) self.invalid_handler = InvalidHandler(self.game_state) def process(self, data): # TODO: quit handler try: is_invalid = self.invalid_handler.is_invalid(data) if is_invalid and not isinstance(self.game_state.handler, InvalidHandler): self.game_state.interrupt_handler(self.invalid_handler) self.invalid_handler.request_invalid_confirmation(data['user']) else: if self.game_state.handler: self.game_state.handler.process(data) except GameEndException: self.__init__(self.slack_client) def tick(self): try: if self.game_state.handler: self.game_state.handler.tick() except GameEndException: self.__init__(self.slack_client)
def __init__(self, p, n, grid=None, interactive=False): """ (TippyGameState, str, int, list of list of int, bool) -> NoneType Initialize TippyGameState self with player p and a grid. If no grid is provided, initialize an empty grid of sidelength n. """ GameState.__init__(self, p) self.instructions = ('Players take turns placing an x or an o on the ' 'board. The first player to complete a tippy ' 'wins.') if interactive: n = int(input('Sidelength of the board?')) # Initialize the empty grid if one is not passed on. if not grid: row = [] self.grid = [] for i in range(n): row += [0] for i in range(n): self.grid.append(row[:]) else: self.grid = grid self.over = (self.winner(self.opponent()) or self.possible_next_moves() == [])
class Service(object): """ Handles the game logic. """ def __init__(self): self.state = None self.tick = 0 def new_game(self): self.state = GameState() def move(self, character_id, coordinates): result = self.state.move_character(character_id, coordinates) return result def character_location(self, character_id): return self.state.character_location(character_id) def interact(self): pass def inc_tick(self): self.state.progress() self.tick += 1 def dispatch_command(self, command_obj): if command_obj.id == CommandIds.MOVE: result = self.move(command_obj.character_id, command_obj.coordinates) return result elif command_id == CommandIds.INTERACT: pass else: pass
def test_serialization(self): for s in self.SERIALIZATION_FIXTURES: self.assertEqual(repr(GameState.from_string(s)), s, "Invalid deserialize & serialize transformation") for _ in range(10): game_state = GameStateFactory.build_with_creatures() s = repr(game_state) self.assertEqual(repr(GameState.from_string(s)), s, "Invalid deserialize & serialize transformation")
class Game (object): def __init__ (self): self.game_state = GameState() self.display = Display() self.player_input = PlayerInput() #game loop def run (self): while self.game_state.get_state() is not "quit": self.draw_screen() self.get_input () def draw_screen(self): self.title() self.game_state.draw (self.display) def title (self): self.display.draw_text("\t╔╦╗┬ ┬┌─┐ ╔═╗┬ ┬┌─┐ ╔═╗┌─┐ ╔╦╗┬ ┬┌─┐┌┬┐┬ ┬") self.display.draw_text("\t ║ ├─┤├┤ ║╣ └┬┘├┤ ║ ║├┤ ║ ├─┤│ │ │ ├─┤") self.display.draw_text("\t ╩ ┴ ┴└─┘ ╚═╝ ┴ └─┘ ╚═╝└ ╩ ┴ ┴└─┘ ┴ ┴ ┴") def get_input (self): self.game_state.get_input(self.player_input)
def __init__(self, p, interactive=False, board=[], turn=0): '''(TippyGameState, str, bool, list of list of str, int) -> None Type Initialize TippyGameState self with a empty board on the first turn ''' GameState.__init__(self, p) ''' Create a 2D board. ' ' means empty, 'x' means a x piece on the board, 'o' means a o piece on the board ''' self.board = deepcopy(board) if interactive: size = int(input('Enter board size. 3 or greater\n')) while size < 3: print('It has to be greater or equal to 3') size = int(input('Enter board size. 3 or greater\n')) self.board = [[TippyGameState.EMPTY] * size for i in range(size)] if p == 'p1': self.P1 = TippyGameState.PIECES[turn] self.P2 = TippyGameState.PIECES[turn - 1] else: self.P2 = TippyGameState.PIECES[turn] self.P1 = TippyGameState.PIECES[turn - 1] self.turn = turn self.over = self.game_over() self.instructions = ('play to form a s-shaped or z-shaped tippy' '\n' 'on your turn, you can choose a coordinate ' 'on the board with no x or o piece on it')
def __init__(self, p, interactive=False, grid_num=None, _grid=None): ''' (TippyState, str)-> NoneType Initialize the class TippyState with grid_num as the size of the grid to be played on to form a Tippy. ''' if interactive: start_grid_num = input('Maximum grid number which is equal ' 'or greater than 3? ') while not start_grid_num.isnumeric(): start_grid_num = input('Maximum grid number which is equal ' 'or greater than 3? ') grid_num = randint(3, int(start_grid_num)) GameState.__init__(self, p) self.grid_num = grid_num self.instructions = ('On your turn, you may place at any position ' 'so long as the row number and column number ' 'not greater than the grid number.') self._grid = {} if _grid is None: for i in range(grid_num + 1): for j in range(grid_num + 1): if j == 0: self._grid[(i, j)] = i elif i == 0: self._grid[(i, j)] = j else: self._grid[(i, j)] = ' ' else: self._grid = _grid self.over = not self.possible_next_moves()
def __init__(self, p, interactive=False, board_size=3, current_board=None): ''' (TippyGameState, str, int, list) -> NoneType Initialize TippyGameState self with board_size '3x3' Assume: '3x3' <= board_size is an str p in {'p1', 'p2'} ''' if interactive: board_size = int(input('Board size? ')) GameState.__init__(self, p) if not current_board: # if board is not created, create it self.current_board = [] for x in range(board_size): d = [] for y in range(board_size): d.append('_ ') self.current_board.append(d) self.board_size = board_size else: self.current_board = deepcopy(current_board) self.board_size = len(self.current_board) # check if the game is over self.over = self.winner(self.next_player) or self.winner( self.opponent()) or self.possible_next_moves() == [] self.instructions = ('On your turn, you may put your symbol' 'on any empty position of the game board ')
def testEntireDeckNoCountMultiRound(self): # The entire deck should be neutral deck = Deck(1, 4, 13) dealerHand = Hand(1) for _ in range(6): dealerHand.addCard(deck.take()) playerHandMap = {} for i in range(3): hand = Hand(1) for _ in range(6): hand.addCard(deck.take()) playerHandMap[hand] = i self.assertEqual(52 - 6 * 4, deck.numActiveCards()) gameState = GameState(playerHandMap, dealerHand, deck) self.agent.gameOver(gameState, playerHandMap.keys()[0], 1) dealerHand = Hand(1) for _ in range(7): dealerHand.addCard(deck.take()) playerHandMap = {} for i in range(3): hand = Hand(1) for _ in range(7): hand.addCard(deck.take()) playerHandMap[hand] = i self.assertEqual(0, deck.numActiveCards()) gameState = GameState(playerHandMap, dealerHand, deck) self.agent.gameOver(gameState, playerHandMap.keys()[0], 1) self.assertEqual(0, self.agent.count)
def set_node_children(new_state1: GameState, node: list) -> None: """helper function of the itrative minimax. set the children of the node as formed [new_state1, [], None]. Cannot provide examples since depend on GameState. """ for move in new_state1.get_possible_moves(): new_node = [new_state1.make_move(move), [], None] node[1].append(new_node)
def get_commands(game_state: GameState): for fleet in game_state.get_enemy_fleets(): target = game_state.get_planet(fleet.destination_planet) # if targeting my planet if target.player == game_state.current_player: pass return []
def get_planet_plus_fleets(game_state: GameState, planet_id: int): return (game_state.get_planet(planet_id).ships + sum([ fleet.ships for fleet in game_state.get_enemy_fleets() if fleet.destination_planet == planet_id ]) - sum([ fleet.ships for fleet in game_state.get_my_fleets() if fleet.destination_planet == planet_id ]))
def go_over_all_states(self, game: StonehengeGame, state: GameState): possibles = state.get_possible_moves() if possibles: [ self.go_over_all_states(game, state.make_move(game.str_to_move(m))) for m in possibles ]
def test_score_meld_nothing(self): # Given a meld that has no value gs = GameState() meld = (Card.from_string("4♦"), Card.from_string("J♣")) # When the meld is scored score = gs.score_meld(meld) # The returned score is 0 self.assertEqual(score, 0)
def test_score_meld_match_pair(self): # Given a meld with a matching pair (two cards of same rank) gs = GameState() meld = tuple(Deck.all_from_string(["2♦", "2♦"])) # When the meld is scored score = gs.score_meld(meld) # Then the score returned is 2 self.assertEqual(score, 2)
def test_blast(self): with patch('application.Application') as perm_mock: perm_mock.game_engine = None game_state = GameState(perm_mock) creep = Creep(50, 62, game_state.world.ways[0], 1) tower = Tower(50, 62, 'laser') game_state.blast(tower, creep) self.assertEqual(creep.health, 99)
def test_score_meld_flush(self): # Given a meld with four cards of the same suit gs = GameState() meld = tuple(Deck.all_from_string(["3♠", "7♠", "4♠", "5♠"])) # When the meld is scored score = gs.score_meld(meld) # Then the score returned is 4 self.assertEqual(score, 4)
def test_kill_game(self): with patch('application.Application') as perm_mock: perm_mock.game_engine = None game_state = GameState(perm_mock) game_state.gamer.life = 0 game_state.kill_game() self.assertEqual(game_state.application.state_continuous, False) self.assertEqual(game_state.application.ending_message, 'You lose')
def __init__(self, width, height): super().__init__(width, height) # register handler for additions to history buffer GameState().onAddLangNode += self.langNodeAddedHandler() # register handler for clearing out buffer vars when area resets GameState().onClearBuffer += self.clearBufferHandler() # register handler for game settings change GameState().onSettingChange += self.settingsChangeHandler()
def test_score_meld_15(self): # Given a meld that adds up to 15 gs = GameState() meld = (Card.from_string("5♦"), Card.from_string("J♣")) # When the meld is scored score = gs.score_meld(meld) # The returned score is 2 self.assertEqual(score, 2)
def test_need_next_cell(self): with patch('application.Application') as perm_mock: perm_mock.game_engine = None game_state = GameState(perm_mock) game_state.world.creeps[0].current_pos = [20, 20] game_state.world.creeps[0].move_to = [20, 20] self.assertEqual(game_state.need_next_cell(game_state.world.creeps[0]), True)
def __init__(self, thread_index, global_network, initial_learning_rate, max_global_time_step): self.thread_index = thread_index self.learning_rate_input = tf.placeholder("float") self.max_global_time_step = max_global_time_step self.local_network = GameACNetwork(ACTION_SIZE) self.local_network.prepare_loss(ENTROPY_BETA) # policy self.policy_trainer = AccumTrainer() self.policy_trainer.prepare_minimize( self.local_network.policy_loss, self.local_network.get_policy_vars()) self.policy_accum_gradients = self.policy_trainer.accumulate_gradients( ) self.policy_reset_gradients = self.policy_trainer.reset_gradients() self.policy_applier = RMSPropApplier( learning_rate=self.learning_rate_input, decay=0.99, momentum=0.0, epsilon=RMSP_EPSILON) self.policy_apply_gradients = self.policy_applier.apply_gradients( global_network.get_policy_vars(), self.policy_trainer.get_accum_grad_list()) # value self.value_trainer = AccumTrainer() self.value_trainer.prepare_minimize( self.local_network.value_loss, self.local_network.get_value_vars()) self.value_accum_gradients = self.value_trainer.accumulate_gradients() self.value_reset_gradients = self.value_trainer.reset_gradients() self.value_applier = RMSPropApplier( learning_rate=self.learning_rate_input, decay=0.99, momentum=0.0, epsilon=RMSP_EPSILON) self.value_apply_gradients = self.value_applier.apply_gradients( global_network.get_value_vars(), self.value_trainer.get_accum_grad_list()) self.sync = self.local_network.sync_from(global_network) self.game_state = GameState(113 * thread_index) self.local_t = 0 self.initial_learning_rate = initial_learning_rate self.episode_reward = 0 # thread0 will record score for TensorBoard if self.thread_index == 0: self.score_input = tf.placeholder(tf.int32) tf.scalar_summary("score", self.score_input)
def test_serialization(self): for s in self.SERIALIZATION_FIXTURES: self.assertEqual(repr(GameState.from_string(s)), s, 'Invalid deserialize & serialize transformation') for _ in range(10): game_state = GameStateFactory.build_with_creatures() s = repr(game_state) self.assertEqual(repr(GameState.from_string(s)), s, 'Invalid deserialize & serialize transformation')
def test_get_highest_rank(self): self.state = GameState(self.pelda) self.assertEqual('K', self.state.get_highest_rank()) self.pelda["players"][1]["hole_cards"][0]["rank"] = "A" self.assertEqual('A', self.state.get_highest_rank()) self.pelda["players"][1]["hole_cards"][0]["rank"] = "7" self.assertEqual('K', self.state.get_highest_rank()) self.pelda["players"][1]["hole_cards"][1]["rank"] = "J" self.assertEqual('J', self.state.get_highest_rank())
def update(self, timestep, keypresses): if self.inMessageMode: self.messageTimer += timestep if self.messageTimer >= self.messageThreshold: self.messageTimer = 0.0 self.inMessageMode = False if not self.inMessageMode and GameState().hasMessage(): self.inMessageMode = True self.messageText = GameState().popMessage()
def test_score_meld_straight(self): # Given a meld that has a straight of three cards of different suits gs = GameState() meld = (Card.from_string("3♦"), Card.from_string("2♣"), Card.from_string("4♦")) # When the meld is scored score = gs.score_meld(meld) # The returned score is 3 self.assertEqual(score, 3)
def __init__(self, thread_index, global_network, initial_learning_rate, learning_rate_input, grad_applier, max_global_time_step, device, action_size, gamma, local_t_max, entropy_beta, agent_type, performance_log_interval, log_level, random_seed): self.thread_index = thread_index self.learning_rate_input = learning_rate_input self.max_global_time_step = max_global_time_step self.action_size = action_size self.gamma = gamma self.local_t_max = local_t_max self.agent_type = agent_type self.performance_log_interval = performance_log_interval self.log_level = log_level if self.agent_type == 'LSTM': self.local_network = GameACLSTMNetwork(self.action_size, thread_index, device) else: self.local_network = GameACFFNetwork(self.action_size, thread_index, device) self.local_network.prepare_loss(entropy_beta) with tf.device(device): var_refs = [] variables = self.local_network.get_vars() for v in variables: var_refs.append(v) self.gradients = tf.gradients(self.local_network.total_loss, var_refs, gate_gradients=False, aggregation_method=None, colocate_gradients_with_ops=False) self.apply_gradients = grad_applier.apply_gradients( global_network.get_vars(), self.gradients) self.sync = self.local_network.sync_from(global_network) np.random.seed(random_seed) self.game_state = GameState(random_seed * thread_index, self.action_size) self.local_t = 0 self.initial_learning_rate = initial_learning_rate self.learn_rate = self.initial_learning_rate self.reset_counters() self.episode = 0 # variable controling log output self.prev_local_t = 0
def test_is_placement_legal_third_turn_second_queen_not_legal(self): move1 = Move(MoveType.PLACE, Creature.QUEEN, (0, 0)) move2 = Move(MoveType.PLACE, Creature.QUEEN, (1, 0)) game_state = GameState() game_state.execute(move1) game_state.execute(move2) result, msg = game_state.is_placement_legal(Creature.QUEEN, (-1, 0)) self.assertFalse(result) self.assertEqual(msg, IllegalPlacement.creature_unavailable)
def test_is_placement_legal_second_turn_non_adjacent_not_legal(self): move = Move(MoveType.PLACE, Creature.QUEEN, (0, 0)) game_state = GameState() game_state.execute(move) for coord in [(20, 20), (-2, -2)]: result, msg = game_state.is_placement_legal(Creature.ANT, coord) self.assertFalse(result) self.assertEqual(msg, IllegalPlacement.no_friendly_tile_adjacent)
def test_is_placement_legal_second_turn_adjacent_is_legal(self): move = Move(MoveType.PLACE, Creature.QUEEN, (0, 0)) game_state = GameState() game_state.execute(move) for coord in Board.get_neighbouring_coordinates((0, 0)): result, msg = game_state.is_placement_legal(Creature.ANT, coord) self.assertTrue(result) self.assertTrue(msg is None)
def __init__(self, num_players, robot_turn): self.num_players = num_players self.scores = [0] * num_players self.robot_turn = robot_turn self.turn = 0 self.state = GameState(num_players, robot_turn, initial_board_state) self.prev_board_state = None #self.get_new_board_state() self.current_image_info = None
def _inventoryChangeHandler(*args, **kwargs): # refresh currentInventoryList by scanning for all items in Game State inventory currentInventoryList = [] for itemdata in self.inventoryList: # TODO refactor for efficiency if itemdata[0] in GameState().inventory and int( GameState().inventory[itemdata[0]]) > 0: currentInventoryList.append(itemdata) self.currentInventoryList = currentInventoryList
def new_game(self, map_name: str = "training0"): """ Create a new game. """ if map_name: game_options = {"mapName": map_name} else: game_options = "" self.game_state = GameState(api.new_game(self.api_key, game_options))
def test_entity_manager_checking(self): id_doublon_detected = False try: EntityManager.check_all() except Exception: id_doublon_detected = True if not id_doublon_detected: raise "Entity manager has missed an id doublon" GameState.set_value("entities.1.id", 1) EntityManager.check_all()
def __init__(self, move=None, parent=None, game: GameState = None): self.parent = parent self.move = move self.children = [] self.wins = 0 self.visits = 0 self.state = game.get_state() self.untried_moves = game.get_moves() self.player = game.player
def main(): # Initialise screen pygame.init() screen = pygame.display.set_mode(common.RESOLUTION, FULLSCREEN) pygame.display.set_caption('Super Geek Fighter II Turbo') # Start the camera capture = cv.CaptureFromCAM(0) background = pygame.image.load(common.BACKGROUND_IMAGE).convert() background = pygame.transform.scale(background, common.RESOLUTION) # calibrate the camera with the projection calibration_state = CalibrationState(screen, capture) transform_mat = calibration_state.run() reference_img = calibration_state.make_background(background, transform_mat) music_started = False try: while True: tutorial_state = TutorialState(screen, background, capture, reference_img, transform_mat) tutorial_state.run() players_height = [tutorial_state.player1_height, tutorial_state.player2_height] total_win = False wins = {'Player 1': 0, 'Player 2': 0} pgmusic.start_music_thread() music_started = True while not total_win: countdown_state = CountdownState(screen, background, capture, reference_img, transform_mat) countdown_state.run() game_state = GameState(screen, background, capture, reference_img, transform_mat, wins, players_height) game_state.run() winning_player = None if game_state.player2.dead: winning_player = game_state.player1 winning_player.name = 'Player 1' if game_state.player1.dead: winning_player = game_state.player2 winning_player.name = 'Player 2' # TODO: What if both die at the same time? if winning_player: wins[winning_player.name] += 1 winning_state = WinningState(screen, background, capture, reference_img, transform_mat, wins, winning_player, game_state.sprites) winning_state.run() total_win = winning_state.big_win pgmusic.fadeout() music_started = False except InterruptedException: print 'Bye bye!' finally: if music_started: pgmusic.fadeout()
def test_equality(self): game_state1 = GameStateFactory.build_with_creatures(9) game_state2 = GameStateFactory.build_with_creatures(8) self.assertNotEqual(game_state1, game_state2) game_state2.battleground = game_state1.battleground self.assertEqual(game_state1, game_state2) game_state1 = GameState.from_string("20/20 (1/0): vs 1/2") game_state2 = GameState.from_string("20/20 (1/0): vs 1/2") self.assertEqual(game_state1, game_state2)
def __init__(self): GameState.__init__(self, GameState.STATE_MENU, GameState.STATE_LOAD) self.player_num = 1 self.background = None self.title = None self.title_rect = None self.init_background() self.text_helper = TextHelper() item_objects_ss = SpriteSheet("data/item_objects.png") self.selector_frame = item_objects_ss.get_image(coords.TITLE_SELECTOR, constants.IMG_MULTIPLIER)
def play_whist(record_game): players, partners = get_players_and_partners() game_state = GameState(players, partners) dealer_index = 0 while not game_state.is_game_over(): play_deal(game_state, dealer_index) dealer_index = (dealer_index + 1) % NUM_PLAYERS print 'The game is over! Final scores:' game_state.print_scores() if record_game: outfile = open(GAME_RECORD_FILE, 'a') outfile.write(game_state.get_team_scores_str()) outfile.close()
class Game(object): def __init__(self): self.clock = pygame.time.Clock() self.display = Display() self.game_state = GameState() self.control_state = ControlState() def run(self): pygame.init() while True: self.control_state.update() self.game_state.update(self.control_state) self.display.update(self.game_state) self.clock.tick(60)
def read_dialog_script(dialog): """ Reads in JSON array of dialog boxes to be spoken """ if not dialog: # Return if no dialog given (i.e. no intro script) return logging.debug(pprint.pformat(dialog)) for line in dialog: char = Character.load_character(line['character']) speech_box(line['text'], speaker=char.name) if 'unlocks' in line: from game_state import GameState GameState.update(line['unlocks'])
def __init__(self, p, interactive=False, current_total=0): ''' (SubtractSquareState, int, str) -> NoneType Initialize SubtractSquareState self with current_total the number to decrease to 0. Assume: 0 <= current_total is an int p in {'p1', 'p2'} ''' if interactive: current_total = randint(1, int(input('Maximum starting value? '))) GameState.__init__(self, p) self.current_total = current_total self.instructions = ('On your turn, you may remove any number so long ' 'as it is (a) a perfect square, and ' '(b) no more than the current number.')
def move(self): """ Initiates move. """ from game_state import GameState # Load destinations for the current location from the current GAME_MAP destinations = GameState.GAME_MAP.get_destinations_for_location(self.tag) # Display list box for the possible destinations selection = ui.list_box("Move to...", destinations) # If selection is None then we go back if not selection: return # Updates the current location in the GameState GameState.update_current_location(selection) GameState.CURRENT_LOCATION.start()
def test_get_next_states(self): for fixture in self.NEXT_STATES_FIXTURES: game_state = GameState.from_string(fixture[0]) expected_next_states = fixture[1] iterator = self.strategy.get_next_states(game_state) next_states = map(repr, iterator) self.assertEqual(set(expected_next_states), set(next_states), 'incorrect get_next_states for %r' % game_state)
def test_dfs_walk(self): strategy = BruteForceStrategy() for game_state_string, expected_outcome in self.GET_OUTCOME_TESTS: game_state = GameState.from_string(game_state_string) dfs_walk = DFSWalk(strategy) outcome = dfs_walk.walk(game_state) self.assertEqual(outcome, expected_outcome, 'incorrect outcome for %s' % game_state)
def test_get_highest_rank(self): self.state = GameState(self.pelda) self.assertEqual('K',self.state.get_highest_rank()) self.pelda["players"][1]["hole_cards"][0]["rank"] = "A" self.assertEqual('A',self.state.get_highest_rank()) self.pelda["players"][1]["hole_cards"][0]["rank"] = "7" self.assertEqual('K',self.state.get_highest_rank()) self.pelda["players"][1]["hole_cards"][1]["rank"] = "J" self.assertEqual('J',self.state.get_highest_rank())
def __init__(self, p, interactive=False, dimension=3): """(TippyGameState, str, bool, int -> NoneType Initialize TippyGameState self. Assume: p in {'p1', 'p2'} and dimension is an int that >= 3 """ if interactive: dimension = int(input("How many columns and rows do you" " want the grid to have:")) self.grid = [[0 for i in range(dimension)] for j in range(dimension)] GameState.__init__(self, p) self.instruction = ("In your turn, you may place a placeholder" " (cross or circle) at a position that has" " not been taken, until you form a tippy") self.dimension = dimension self.interactive = interactive self.over = False
def main(): string = sys.argv[1] print '=== Analyzing GameTree for %s ===' % string root = GameState.from_string(string) strategy = BruteForceStrategy() dfs_walk = DFSWalk(strategy) outcome = dfs_walk.walk(root) print 'Outcome of %s is %+d' % (root, outcome) print 'Iterated through %d nodes' % len(dfs_walk.visited)
def test_is_over(self): game_state = GameState.from_string("20/20 (0/0): vs ") self.assertFalse(game_state.is_over) with self.assertRaises(ValueError): game_state.outcome game_state = GameState.from_string("0/20 (0/0): vs ") self.assertTrue(game_state.is_over) self.assertEqual(game_state.outcome, Outcome.Loss) game_state = GameState.from_string("1/-2 (0/0): vs ") self.assertTrue(game_state.is_over) self.assertEqual(game_state.outcome, Outcome.Win) game_state = GameState.from_string("1/-2 (0/1): vs ") self.assertTrue(game_state.is_over) self.assertEqual(game_state.outcome, Outcome.Loss) game_state = GameState.from_string("0/0 (0/0): vs ") self.assertTrue(game_state.is_over) self.assertEqual(game_state.outcome, Outcome.Draw)
def __init__(self, p, interactive=False, board=[], turn=0): '''(TippyGameState, str, int, int) -> None Type ''' GameState.__init__(self, p) ''' Create a 2D board. ' ' means empty, 'x' means a x piece on the board, 'o' means a o piece on the board ''' self.board = deepcopy(board) if interactive: size = int(input('Enter the size of the board\n')) self.board = [ [self.EMPTY] * size for i in range(size)] if p == 'p1': self.P1 = self.PIECES[turn] self.P2 = self.PIECES[turn - 1] else: self.P2 = self.PIECES[turn] self.P1 = self.PIECES[turn - 1] self.turn = turn #change self.instructions = 'play the goddamn game'
def __init__(self, thread_index, global_network, initial_learning_rate, max_global_time_step): self.thread_index = thread_index self.learning_rate_input = tf.placeholder("float") self.max_global_time_step = max_global_time_step self.local_network = GameACNetwork(ACTION_SIZE) self.local_network.prepare_loss(ENTROPY_BETA) # policy self.policy_trainer = AccumTrainer() self.policy_trainer.prepare_minimize( self.local_network.policy_loss, self.local_network.get_policy_vars() ) self.policy_accum_gradients = self.policy_trainer.accumulate_gradients() self.policy_reset_gradients = self.policy_trainer.reset_gradients() self.policy_applier = RMSPropApplier(learning_rate = self.learning_rate_input, decay = 0.99, momentum = 0.0, epsilon = RMSP_EPSILON ) self.policy_apply_gradients = self.policy_applier.apply_gradients( global_network.get_policy_vars(), self.policy_trainer.get_accum_grad_list() ) # value self.value_trainer = AccumTrainer() self.value_trainer.prepare_minimize( self.local_network.value_loss, self.local_network.get_value_vars() ) self.value_accum_gradients = self.value_trainer.accumulate_gradients() self.value_reset_gradients = self.value_trainer.reset_gradients() self.value_applier = RMSPropApplier(learning_rate = self.learning_rate_input, decay = 0.99, momentum = 0.0, epsilon = RMSP_EPSILON ) self.value_apply_gradients = self.value_applier.apply_gradients( global_network.get_value_vars(), self.value_trainer.get_accum_grad_list() ) self.sync = self.local_network.sync_from(global_network) self.game_state = GameState(113 * thread_index) self.local_t = 0 self.initial_learning_rate = initial_learning_rate self.episode_reward = 0 # thread0 will record score for TensorBoard if self.thread_index == 0: self.score_input = tf.placeholder(tf.int32) tf.scalar_summary("score", self.score_input)
def __init__(self, game_info, sound_manager): GameState.__init__(self, GameState.STATE_GAME, GameState.STATE_LOAD) self.game_info = game_info self.sound_manager = sound_manager self.game_info.set_timer_in_seconds(300) self.mario_game_time = -1 self.world_shift = 0 self.player = Player(self.sound_manager, game_info) self.active_sprite_list = pygame.sprite.Group() self.active_sprite_list.add(self.player) self.level = Level(game_info, self.player, self.sound_manager) if constants.DEBUG: self.debug_overlay = DebugOverlay(self.game_info, self.player) self.sound_manager.play_music(constants.MUSIC_MAIN_THEME)
def __init__(self, p, interactive=False, board_length=0, moves_p1=[], moves_p2=[]): ''' (TippyGameState, str, bool, str) -> NoneType Initialize TippyGameState self with board_length as the dimension of the board Assume: 3 <= board_length is an int p in {'p1', 'p2'} ''' if interactive: board_length = int(input('What board size do you want? ')) GameState.__init__(self, p) self.board_length = board_length self.instructions = ('Tippy is a variation of tic-tac-toe. '+ 'Win the game by forming a z shape in four grids.') self.moves_p1 = moves_p1 self.moves_p2 = moves_p2 if (self.winner('p1') or self.winner('p2') or self.possible_next_moves() == []): self.over = True
def play_oracle_whist(num_iters=1000, silent=True): # random.seed(42) oracles = ['Oracle1', 'Oracle2'] opponents = ['Opponent1', 'Opponent2'] players, partners, oracle_name = get_oracle_players_and_partners(oracles, opponents) oracle_wins = 0 opponent_wins = 0 points_for = 0 points_against = 0 for i in xrange(num_iters): game_state = GameState(players, partners) dealer_index = 0 while not game_state.is_game_over(): play_oracle_deal(game_state, dealer_index, oracle_name, silent=silent) dealer_index = (dealer_index + 1) % NUM_PLAYERS #raw_input() if not silent: print 'The game is over! Final scores:' game_state.print_scores() oracle_score = sum([game_state.scores[oracle] for oracle in oracles]) opp_score = sum([game_state.scores[opp] for opp in opponents]) if oracle_score > opp_score: print "Game %s: oracles win" % (i+1) oracle_wins += 1 else: print "Game %s: opponents win" % (i+1) opponent_wins += 1 points_for += oracle_score points_against += opp_score print "Oracle record: %s-%s" % (oracle_wins, opponent_wins) print "Points for: %s" % points_for print "Points against: %s" % points_against
def test_process(self): game_state = GameState(0) before_s_t = np.array( game_state.s_t ) for i in range(1000): bef1 = game_state.s_t[:,:, 1] bef2 = game_state.s_t[:,:, 2] bef3 = game_state.s_t[:,:, 3] game_state.process(1) game_state.update() aft0 = game_state.s_t[:,:, 0] aft1 = game_state.s_t[:,:, 1] aft2 = game_state.s_t[:,:, 2] # values should be shifted self.assertTrue( (bef1.flatten() == aft0.flatten()).all() ) self.assertTrue( (bef2.flatten() == aft1.flatten()).all() ) self.assertTrue( (bef3.flatten() == aft2.flatten()).all() ) # all element should be less [0.0~1.0] self.assertTrue( np.less_equal(bef1, 1.0).all() ) self.assertTrue( np.less_equal(bef2, 1.0).all() ) self.assertTrue( np.less_equal(bef3, 1.0).all() ) self.assertTrue( np.greater_equal(bef1, 0.0).all() ) self.assertTrue( np.greater_equal(bef2, 0.0).all() ) self.assertTrue( np.greater_equal(bef3, 0.0).all() ) self.assertTrue( np.less_equal(aft0, 1.0).all() ) self.assertTrue( np.less_equal(aft1, 1.0).all() ) self.assertTrue( np.less_equal(aft2, 1.0).all() ) self.assertTrue( np.greater_equal(aft0, 0.0).all() ) self.assertTrue( np.greater_equal(aft1, 0.0).all() ) self.assertTrue( np.greater_equal(aft2, 0.0).all() )
def __init__(self, thread_index, global_network, initial_learning_rate, learning_rate_input, grad_applier, max_global_time_step, device): self.thread_index = thread_index self.learning_rate_input = learning_rate_input self.max_global_time_step = max_global_time_step if NETWORK_TYPE == 'LSTM': self.local_network = GameACLSTMNetwork(ACTION_SIZE, thread_index, device) elif NETWORK_TYPE == 'DILATED': self.local_network = GameACDilatedNetwork(ACTION_SIZE, device) elif NETWORK_TYPE == 'CONV': self.local_network = GameACFFNetwork(ACTION_SIZE, device) self.local_network.prepare_loss(ENTROPY_BETA) # TODO: don't need accum trainer anymore with batch self.trainer = AccumTrainer(device) self.trainer.prepare_minimize( self.local_network.total_loss, self.local_network.get_vars() ) self.accum_gradients = self.trainer.accumulate_gradients() self.reset_gradients = self.trainer.reset_gradients() self.apply_gradients = grad_applier.apply_gradients( global_network.get_vars(), self.trainer.get_accum_grad_list() ) self.sync = self.local_network.sync_from(global_network) self.game_state = GameState(113 * thread_index) self.local_t = 0 self.initial_learning_rate = initial_learning_rate self.episode_reward = 0
def __init__(self, thread_index, global_network, initial_learning_rate, learning_rate_input, grad_applier, max_global_time_step, device): self.thread_index = thread_index self.learning_rate_input = learning_rate_input self.max_global_time_step = max_global_time_step if USE_LSTM: self.local_network = GameACLSTMNetwork(ACTION_SIZE, thread_index, device) else: self.local_network = GameACFFNetwork(ACTION_SIZE, thread_index, device) self.local_network.prepare_loss(ENTROPY_BETA) with tf.device(device): var_refs = [v._ref() for v in self.local_network.get_vars()] self.gradients = tf.gradients( self.local_network.total_loss, var_refs, gate_gradients=False, aggregation_method=None, colocate_gradients_with_ops=False) self.apply_gradients = grad_applier.apply_gradients( global_network.get_vars(), self.gradients ) self.sync = self.local_network.sync_from(global_network) self.game_state = GameState(113 * thread_index) self.local_t = 0 self.initial_learning_rate = initial_learning_rate self.episode_reward = 0 # variable controling log output self.prev_local_t = 0
def __init__(self, thread_index, global_network, initial_learning_rate, learning_rate_input, grad_applier, max_global_time_step, device): self.thread_index = thread_index self.learning_rate_input = learning_rate_input self.max_global_time_step = max_global_time_step self.local_network = GameACNetwork(ACTION_SIZE, device) self.local_network.prepare_loss(ENTROPY_BETA) self.trainer = AccumTrainer(device) self.trainer.prepare_minimize( self.local_network.total_loss, self.local_network.get_vars() ) self.accum_gradients = self.trainer.accumulate_gradients() self.reset_gradients = self.trainer.reset_gradients() self.apply_gradients = grad_applier.apply_gradients( global_network.get_vars(), self.trainer.get_accum_grad_list() ) self.sync = self.local_network.sync_from(global_network) self.game_state = GameState(113 * thread_index) self.local_t = 0 self.initial_learning_rate = initial_learning_rate self.episode_reward = 0
class MainState(StateSystem): def __init__(self): StateSystem.__init__(self) self.intro_state = IntroState(parent=self) self.game_state = GameState(parent=self) self.show_instructions() return def handle_event(self, event): StateSystem.handle_event(self, event) if event.type == pygame.KEYDOWN: if event.key == pygame.K_n: self.new_game() elif event.key == pygame.K_p: self.pause_game() elif event.key == pygame.K_r: self.resume_game() elif event.key == pygame.K_i: self.show_instructions() return def new_game(self): self.child_state = self.game_state self.game_state.new_game() self.refresh_screen = True return def resume_game(self): self.child_state = self.game_state self.game_state.unpause() self.refresh_screen = True return def pause_game(self): self.child_state = self.game_state self.game_state.pause() self.refresh_screen = True return def show_instructions(self): self.child_state = self.intro_state self.refresh_screen = True return