def get_computer_move(): state = json.load(request.body) print(state) board_array = state['game_board'] to_play_id = state['to_play_id'] current_state = GameState(board_array, to_play_id) _, preds, moves = ai_player.get_preds(current_state) computer_move = np.argmax(preds) board_array[computer_move] = to_play_id new_game_state = GameState(board_array, -to_play_id) to_play = 'player2' if state['to_play'] == 'player1' else 'player1' rv = { 'player1': state['player1'], 'player2': state['player2'], 'game_board': new_game_state.board, 'endgame': new_game_state.isEndGame, 'to_play': to_play, 'legal_moves': new_game_state._allowedActions(), 'to_play_id': -to_play_id } if rv[to_play] == 'assisted': _, preds, moves = ai_player.get_preds(new_game_state) print(preds) print(list(np.argpartition(preds, -3)[-3:])) rv['legal_moves'] = list(np.argpartition(preds, -3)[-3:]) return json.dumps(rv)
def test_end_game(self): grid_shape = GRID_SHAPE game_state = GameState(grid_shape=grid_shape, currentPlayer=PLAYER_1, board=np.full(grid_shape, PLAYER_1, dtype=np.int8)) is_end_game = game_state.checkForEndGame() self.assertEqual(is_end_game, True) game_state = GameState(grid_shape=grid_shape, currentPlayer=PLAYER_1, board=np.full(grid_shape, NONE, dtype=np.int8)) is_end_game = game_state.checkForEndGame() self.assertEqual(is_end_game, False)
def create_phase_loader(self) -> PhaseLoader: if not self.tiles: location_map = DEFAULT_LOCATIONS else: location_map = self.load_tiles(self.tiles) assert self._location_spec in {LocationTransformer.ROLL_SPEC, LocationTransformer.DIRECT_SPEC}, \ f'Unknown location spec {self._location_spec}' location_transformer = LocationTransformer(self._location_spec, location_map) assert 0 < len(self.players) == len(self.cards) <= 5, 'Improper number of players/cards' assert len(set(self.players)) == len(self.players), 'Players not unique' player_hands = dict(zip(self.players, self.cards)) assert self.governor_location is not None and self.smuggler_location is not None, \ 'Missing location of governor or smuggler' governor_location = location_transformer.apply(self.governor_location) smuggler_location = location_transformer.apply(self.smuggler_location) assert sum(self.small_demand.values()) == sum(self.large_demand.values()) == 5, 'Missing large or small demand' game_state = GameState( self.players, location_map, self.small_demand, self.large_demand, governor_location, smuggler_location, player_hands, ) return PhaseLoader(game_state, location_transformer)
def test_id(self): """Je transforme les victoires de test_victory_true_4 en id""" """Puis je crée un GameState à partir de cet id""" """Et je teste si le nouveau GameState est égal à l'ancien""" for ligne in range(GRID_SHAPE[0] + 1 - NB_TOKENS_VICTORY, GRID_SHAPE[0]): for column in range(0, GRID_SHAPE[1] + 1 - NB_TOKENS_VICTORY): #On aligne 4 PLAYER_1 dans la diagonale dont le point de départ (bas,gauche) est (ligne,column) board = np.full(GRID_SHAPE, NONE, dtype=np.int8) for i, j in zip(range(ligne, ligne - NB_TOKENS_VICTORY, -1), range(column, column + NB_TOKENS_VICTORY)): board[i, j] = PLAYER_1 board[0:i, j] = PLAYER_2 board[i, 0:j] = PLAYER_2 #On remplit les lignes sous ligne avec PLAYER_2 board[0:ligne - 3, :] = PLAYER_2 game_state = GameState(currentPlayer=PLAYER_1, board=board) id = game_state.id new_game_state = GameState.from_id(id, board.shape) # See https://stackoverflow.com/questions/3302949/best-way-to-assert-for-numpy-array-equality self.assertIsNone( np.testing.assert_array_equal(new_game_state.board, game_state.board)) self.assertEqual(new_game_state.currentPlayer, game_state.currentPlayer)
def route(game_id,data,userid,username): command = None params = [] if data: command = COMMAND_MAPPINGS.get(data[0].lower()) if len(data) > 1: params = data[1:] if command: game_state = GameState() game_state.load(game_id) try: return command(commands.Game(game_state), params,userid,username).to_json() finally: game_state.save(game_id) return {'text': u"""Usage: /slack command, where commands are: reset [confirm]: reset the game if "confirm" is passed as the parameter setup [add|remove]: display the current setup. If add is the parameter, add rest of text as setup text. If remove, remove the nth item. pool [reroll|setup]: show the current dice pool. if setup passed as a parameter, setup the initial pool. if reroll passed in, reroll all dice in the pool. register [name]: register your player name with the game unregister [name]: unregister yourself or the specified user status: output current status to channel take [color number]: take a die from the pool give [color number] [user]: give a die to another player. use "pool" as player name to return to the pool. roll: roll all your dice and give the aggregate score spend: spend one your dice (so you no longer have it)"""}
def play(): req = json.load(request.body) print(req) state = req['current_state'] board_array = state['game_board'] board_array[req['move']] = 1 if state['to_play'] == 'player1' else -1 to_play_id = -state['to_play_id'] new_game_state = GameState(board_array, to_play_id) to_play = 'player2' if state['to_play'] == 'player1' else 'player1' rv = { 'player1': state['player1'], 'player2': state['player2'], 'game_board': new_game_state.board, 'endgame': new_game_state.isEndGame, 'to_play': to_play, 'legal_moves': new_game_state._allowedActions(), 'to_play_id': to_play_id } if rv[to_play] == 'assisted': _, preds, moves = ai_player.get_preds(new_game_state) print(preds) print(list(np.argpartition(preds, -3)[-3:])) rv['legal_moves'] = list(np.argpartition(preds, -3)[-3:]) return json.dumps(rv)
def _game_state(board): return GameState(board=board, offense=None, defense=None, turn_count=1, move_count=1, to_move=None)
def is_winner(self, player: str) -> bool: """ Check if player is the winner """ enemy = GameState(player).get_next_player() return self.is_over(self.current_state)\ and self.current_state.hands[enemy][LEFT_HAND] == 0 \ and self.current_state.hands[enemy][RIGHT_HAND] == 0
def test_game_starts_at_default_start(self): from game import GameState game = new_game(configuration={'default': 'test'}) test = GameState('test') game.add_state(test) self.assertEquals('test', game.state) self.assertEquals('sms', game.type)
def test_act_game_mid_3(self): """PLAYER_2 should chose action 4, in order to win""" """Because whatever PLAYER_1 does after that, PLAYER_2 wins""" agent = self.init_random_agent(mcts_sims=5000) board = np.full(config.GRID_SHAPE, config.NONE, dtype=np.int8) # X = PLAYER_1 , O = PLAYER_2 #['-', '-', '-', '-', '-', '-', '-'] #['-', '-', '-', '-', '-', '-', '-'] #['-', '-', '-', 'X', '-', '-', '-'] #['-', '-', '-', 'O', '-', '-', '-'] #['X', 'X', '-', 'X', '-', '-', '-'] #['X', 'O', '-', 'O', '-', 'O', '-'] board[0, 0] = board[1, 0] = board[1, 1] = board[1, 3] = board[3, 3] = config.PLAYER_1 board[0, 1] = board[0, 3] = board[2, 3] = board[0, 5] = config.PLAYER_2 game_state = GameState(grid_shape=config.GRID_SHAPE, currentPlayer=config.PLAYER_2, board=board) # act(game_state, 1) : learning mode # act(game_state, 0) : deterministic action, pi, MCTS_value, NN_value = agent.act(game_state, 1) self.assertEqual(action, 4) self.assertNotEqual(MCTS_value, config.VALUE_VICTORY)
def board_demo(): gs = GameState() zidaan_player = gs.players['Zidaan'] zidaan_player.create_unit(Worker, location=3) zidaan_player.create_unit(Worker, location=5) zidaan_player.create_unit(Combat, location=0) zidaan_player.create_unit(Combat, location=11) zidaan_player.create_unit(Hero, location=10) print("\n=============== BOARD DEMO ===============") print("\nZidaan Resource Layout") zidaan_player.board.display('board') print("\nZidaan Unit Layout") zidaan_player.board.display('units') print("\nPlayer Resource Count BEFORE Gathering") zidaan_player.display_resource_count() print("\nPlayer Resource Count AFTER Gathering") zidaan_player.gather_resources() zidaan_player.display_resource_count() print("")
def start(player_token, gm_token, state_file_path, name, token_path): logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) if Path(state_file_path).exists(): with open(state_file_path, 'r') as f: game_state = json.load(f) logger.info('Loaded existing state.') else: game_state = GameState(name) logger.info('Created new state.') session.state = game_state session.player_token = player_token session.gm_token = gm_token session.state_file_path = state_file_path initialize_handlers() with open(token_path, 'r') as f: telegram_token = f.read() start_server(telegram_token)
def test_angle(): state = GameState(1, 1) print "Convert 45 to simple ", state.angle_to_simp(45) print "Convert 45 to geo ", state.angle_to_geo(45) print "Convert 90 to simple ", state.angle_to_simp(90) print "Convert 90 to geo ", state.angle_to_geo(90) print "Convert 270 to simple ", state.angle_to_simp(270) print "Convert 270 to geo ", state.angle_to_geo(270)
def init_new_game(self): self.game = GameState(self.display, level=([(2, 2)] if self.dev else None)) self.game.listen('menu-click', self.on_menu_click) self.game.listen('game-over', self.on_game_over) self.solver.game = self.game self.game_over_state.game = self.game
def test_victory_false_3(self): grid_shape = GRID_SHAPE board = np.full(grid_shape, NONE, dtype=np.int8) board[0, 3] = PLAYER_1 game_state = GameState(grid_shape=grid_shape, currentPlayer=PLAYER_1, board=board) is_victory = game_state._isVictory(3, PLAYER_1) self.assertEqual(is_victory, False)
def _verify_aimulator(desc, board, colors, exp_move): strat = create_ai_strat(colors) game_state = GameState(board=board, offense=None, defense=None, to_move=None, move_count=None, turn_count=None) # sort the moves since we're not currently differentiating on which tile # was touched for the AI eq_(sorted(exp_move), sorted(strat(game_state)))
def __init__(self): super().__init__() self.setWindowTitle('Space Invaders') self.ui = GUI() self.setFixedSize(Constants.WINDOW_WIDTH, Constants.WINDOW_HEIGHT) self.setWindowIcon(self.ui.icon) self.current_mode = WindowMode.CHOICE_LEVEL self.update_timer = QtCore.QTimer() self.update_timer.timeout.connect(self.update) self.update_timer.start(10) self.button_record = Rectangle(90, 430, 430, 53) self.button_select = Rectangle(90, 500, 430, 53) self.current_level = 0 try: levels = AllLevels(AllLevels.LEVELS_FILE) except EmptyLevelsFile as e: QtWidgets.QMessageBox.critical( self, "Failed to launch the game", f"{AllLevels.LEVELS_FILE} is empty. Write levels for the game", QtWidgets.QMessageBox.Ok) sys.exit(8) except Exception as e: QtWidgets.QMessageBox.critical( self, "Failed to launch the game", f"{AllLevels.LEVELS_FILE} not found: \n{e}", QtWidgets.QMessageBox.Ok) sys.exit(7) self.count_levels = levels.get_count_level() self.game = GameState(levels, QtCore.QTimer.stop, QtCore.QTimer.start) self.game.init_game(**self.get_game_timer()) self.update_timer = QtCore.QTimer() self.update_timer.timeout.connect(self.update_timeout) self.update_timer.start(10) self.previous_score = self.game.score self.previous_ship_live = self.game.ship.live self.previous_game_mode = self.game.current_mode self.music = Music() self.music.play_background() self.scoreboard = Scoreboard(self.count_levels) self.current_player = None self.names_players = self.scoreboard.get_players() self.show() self.show_name_choice()
def test_coord(): state = GameState(1, 1) pt = [0, 0] state.pt_to_geo(pt) print "origin ", pt pt = [1, 0] state.pt_to_geo(pt) print "x limit ", pt pt = [0, 1] state.pt_to_geo(pt) print "y limit ", pt
def setup_the_game(): """ This is the game in a nutshell, Setup our Game state add a default dungeon tell GameState how to create new players. before_first_request ensures this is only called once. """ app.game = GameState() app.game.set_dungeon(Dungeon(HERE(__file__, "maps/base_map.json"))) app.game.set_player_class(Player)
def setUp(self): self.game = Game( GameState({ 'game': { 'users': { '12456': { 'name': 'Test', 'slack_name': 'Bar' } } } }), 'game')
def betRequest(self, game_state): game = GameState(game_state) logger = Logger(game) player = game.our_player hole_cards = player.hole_cards community_cards = game.community_cards bet = player.bet stack = player.stack current_buy_in = game.current_buy_in minimum_raise = game.minimum_raise if len(community_cards) == 0: try: score = Preflop(game_state).score() if score > 14: logger.all_in("Chen > 14") return 4000 if score > 10: logger.check("Chen said it's fine (raise)") return current_buy_in - bet + minimum_raise if score < 6: logger.fold("Chen score is low") return 0 logger.check("Chen says we should check") return current_buy_in - bet except: print('WTF?') pass if hole_cards[0].rank == hole_cards[1].rank: if hole_cards[0].rank_value > 7: logger.all_in("high cards") return 1000 if hole_cards[0].rank_value > 9 or hole_cards[1].rank_value > 9: if current_buy_in > 400 and bet < 200: logger.fold("high card, high stakes, low money") return 0 logger.check("at least one high card") return current_buy_in - bet if current_buy_in > 350 and bet < 80: logger.fold("high stakes, low money") return 0 logger.check("no reason to stop now") return current_buy_in - bet
def maxValue(self, game, depth, max_depth): bestScore = -1 bestMove = 0 state = GameState(game.getGrid(), game.getScore(), game.isGameOver()) for move in self.moves: newGame = Game2048(prev_state=state) if newGame.moveIsValid(move): newGame.move(move) value = self.expectedValue(newGame, depth, max_depth) if value > bestScore: bestScore = value bestMove = move return bestMove, bestScore
def expectedValue(self, game, depth, max_depth): state = GameState(game.getGrid(), game.getScore(), game.isGameOver()) emptyTiles = game.getEmptyTiles() n_empty = len(emptyTiles) score = 0 for tile in emptyTiles: for tileValue, prob in zip([2, 4], [0.9, 0.1]): newGame = Game2048(prev_state=state) newGame.placeTile(tile, tileValue) if depth < max_depth: move, value = self.maxValue(newGame, depth + 1, max_depth) else: value = self.evaluate(newGame) score += (prob / n_empty) * value return score
def test_get_valid_moves(): '''(5 points) get_valid_moves()''' g = TicTacToe() # game b = np.array([[1, 0, -1], [-1, 1, 0], [1, 0, -1]]) s = GameState(b, x=1) m = g.get_valid_moves(s) assert type(m) == list assert len(m) == 3 for i in m: assert i == (0, 1) or i == (1, 2) or i == (2, 1) assert m[0] != m[1] and m[1] != m[2] s = GameState(np.zeros((3, 3)), x=1) m = g.get_valid_moves(s) assert len(m) == 9 b = np.array([[1, 0, -1], [0, 0, 0], [1, 0, -1]]) s = GameState(b, x=1) m = g.get_valid_moves(s) assert len(m) == 5 for i in m: assert i == (0, 1) or i == (1, 0) or i == (1, 1) or i == ( 1, 2) or i == (2, 1)
def who_starts(board, player1, player2): black_count = 0 for row in board: for field in board: if field == BLACK_TOKEN: black_count += 1 if black_count == 0: print(player2.name + ' plays as X') state = GameState(np.array(board).flatten(), 1) action, pi, MCTS_value, NN_value = player2.act(state, 1) return action elif black_count == 1: print(player1.name + ' plays as X') print('CALL ME IF YOU WILL NEED HELP, PRESS space') global player2_tokens player2_tokens = WHITE_TOKEN return 1
def nextMoveRecur(self, game, depth, max_depth, base=0.9): bestScore = -1 bestMove = 0 state = GameState(game.getGrid(), game.getScore(), game.isGameOver()) for move in self.moves: newGame = Game2048(prev_state=state) if (newGame.moveIsValid(move)): newGame.move(move) score = self.evaluate(newGame) if depth <= max_depth: my_move, my_score = self.nextMoveRecur( newGame, depth + 1, max_depth) score += my_score * pow(base, depth + 1) if score > bestScore: bestMove = move bestScore = score return (bestMove, bestScore)
def __init__(self, layout=Layout.CLASSIC): initial_board = [[None] * COLS for i in range(ROWS)] self.lasers = {Color.SILVER: (), Color.RED: ()} # The sphinx locations for each player for i, row in enumerate(layout): for j, square in enumerate(row): if square: # square is a three digit number indicating the color, kind, and direction of a piece color = Color(square // 100) kind = Kind((square // 10) % 10) direction = Direction(square % 10) initial_board[i][j] = Piece(color, kind, direction) if kind == Kind.SPHINX: self.lasers[color] = (i, j) self.initial = GameState(to_move=Color.SILVER, utility=0, board=initial_board, moves=[])
def __init__(self, model): if model is None: #create new model # init garbage = GameState() shape = garbage.board.shape output_size = garbage.action_size() del garbage # Neural net input_board = Input(shape=shape) input_board_reshaped = Reshape( (shape[0], shape[1], 1))(input_board) conv1 = Activation('relu')(BatchNormalization(axis=3)( Conv2D(nnet_args.filters, (4, 4), padding='same')(input_board_reshaped))) conv2 = Activation('relu')(BatchNormalization(axis=3)(Conv2D( nnet_args.filters, (3, 3), padding='same')(conv1))) conv3 = Activation('relu')(BatchNormalization(axis=3)(Conv2D( nnet_args.filters, (3, 3), padding='same')(conv2))) conv4 = Activation('relu')(BatchNormalization(axis=3)(Conv2D( nnet_args.filters, (3, 3), padding='same')(conv3))) #conv4 -> pi conv_pi = Activation('relu')(BatchNormalization(axis=3)(Conv2D( nnet_args.pi_filters, (1, 1))(conv4))) conv_pi_flat = Flatten()(conv_pi) pi = Dense(output_size, activation='softmax', name='pi')(conv_pi_flat) #conv4 -> v conv_v = Activation('relu')(BatchNormalization(axis=3)(Conv2D( nnet_args.v_filters, (1, 1))(conv4))) conv_v_flat = Flatten()(conv_v) hidden_v = Dense(nnet_args.hidden_dense, activation='relu')(conv_v_flat) v = Dense(1, activation='sigmoid', name='v')(hidden_v) self.model = Model(inputs=input_board, outputs=[pi, v]) self.model.compile( loss=['categorical_crossentropy', 'mean_squared_error'], optimizer=Adam(nnet_args.lr)) #maybe todo loss function else: self.model = load_model(global_args.save_dir + str(model) + '.h5')
def getBoard(self): """ Gets the tile value for each tile in the grid """ self.window = ImageGrab.grab() newGrid = [0 for _ in range(16)] for index, coord in enumerate(TILE_COORDINATES): try: newGrid[index] = self.getTileValue(coord) state = GameState(newGrid, 0, self.gameOver) self.game = Game2048(prev_state=state) except KeyError: print(self.window.getpixel(coord)) self.gameOver = True break return self.game, self.gameOver
def callback(): ip = request.environ.get('REMOTE_ADDR') if request.query.new: gamedata[ip] = GameState(int(request.query.first), []) if gamedata[ip].first == GameState.AI: nx, ny = GameState.GRID_SIZE/2, GameState.GRID_SIZE/2 gamedata[ip].move((nx, ny)) return {'x': nx, 'y': ny} elif request.query.end: if ip in gamedata: del gamedata[ip] else: x = int(request.query.x) y = int(request.query.y) gamedata[ip].move((x, y)) nx, ny = agent.getAction(gamedata[ip]) gamedata[ip].move((nx, ny)) return {'x': nx, 'y': ny}