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}
