def record_roll(player, roll: 'Roll', game_id: str, is_winning_play: bool, roll_num: int):
move = Move()
# move.player_id = player.id
# move.roll_id = roll.id
move.game_id = game_id
move.is_winning_play = is_winning_play
move.roll_number = roll_num
def play(self, board):
rowInp = int(raw_input("Linha: "))
colInp = int(raw_input("Coluna: "))
move = Move(rowInp, colInp)
while move not in board.valid_moves(self.color):
print "Movimento invalido. Insira um valido"
print board
rowInp = int(raw_input("Linha: "))
colInp = int(raw_input("Coluna: "))
move = Move(rowInp, colInp)
return move
def play(self, board):
start = timer()
self.target = start+3
self.overtime = False
bb = bb_from(board, self.color)
# print bb
bbmove = None
self.last_time = 0
self.last_cost, self.last_move = None, None
depth = 0
while ((self.target - timer()) > 0.1 and depth < self.MAX_DEPTH):
depth += 1
before = timer()
cost, move = self.negascout(1, depth, self.inf_neg, self.inf_pos, bb)
if self.overtime:
depth -= 1
break
self.last_cost, self.last_move = cost, move
if abs(cost) > 9998: # endgame
break
self.last_time = timer() - before
# print "reached depth ", depth
# print Move(*bbm_to_tuple(self.last_move))
next_move = Move(*bbm_to_tuple(self.last_move))
end = timer()
self.update_time(end-start)
return next_move
def play(self, board):
start = timer()
self.target = start + 3
self.overtime = False
bb = bb_from(board, self.color)
bbmove = None
self.last_time = 0
self.last_cost, self.last_move = None, None
depth = 0
while (depth < self.MAX_DEPTH):
depth += 1
before = timer()
cost, move = self.negamax(1, depth, self.inf_neg, self.inf_pos, bb)
if self.overtime:
depth -= 1
break
self.last_cost, self.last_move = cost, move
self.last_time = timer() - before
if abs(cost) > 9999: # endgame
if cost > 0:
print('ganhei')
elif cost < 0:
print('perdi')
else:
print('empatei')
break
print("reached depth ", depth)
next_move = Move(*bbm_to_tuple(self.last_move))
end = timer()
self.update_time(end - start)
return next_move
def threaded_client(conn, player):
global current_game
conn.send(pickle.dumps(player))
reply = ""
# Client listening loop
while True:
try:
# Limit of bits that can be received per message
data = pickle.loads(conn.recv(2048 * 2))
if not data:
print("Disconnected (id = {})".format(player.id))
break
# Processing player in menu screen
elif player.state == "choosing":
# Handshake: getting Hello message from client and sending game_list
if data == "Hello":
reply = process_handshake(player, game_list)
# New game: getting game objects and sending its id
elif type(data) is Game:
current_game += 1
reply = process_new_game(player, data, current_game,
game_list)
# Join game: getting game id and sending it back if available to join
elif type(data) == int:
reply = process_join_game(player, data, game_list)
conn.sendall(pickle.dumps(reply))
# Processing player while joined the game
elif player.state == "joined":
# Observing game list
if type(data) == int:
reply = game_list
game = [game for game in game_list if game.id == data][0]
conn.sendall(pickle.dumps(reply))
# If all players joined than start the game
if game.max_players <= len(game.current_players):
player.state = "playing"
move = Move(None, None)
game_state = GameState(game.id, 0, 1, None,
game.current_players[0], move)
conn.sendall(pickle.dumps(game_state))
# Processing player while playing the game
elif player.state == "playing":
pass
except (socket.error, EOFError) as e:
break
print("Lost connection (id = {})".format(player.id))
process_disconnect(player, game_list)
conn.close()
def play(self, board): start = timer() bb = bb_from(board, self.color) bbmove = self.negamax(1, self.MAX_DEPTH, self.inf_neg, self.inf_pos, bb)[1] next_move = Move(*bbm_to_tuple(bbmove)) end = timer() self.update_time(end-start) return next_move
def valid_moves(self, color):
ret = []
for i in range(1, 9):
for j in range(1, 9):
if self.board[i][j] == Board.EMPTY:
for direction in Board.DIRECTIONS:
move = Move(i, j)
bracket = self._find_bracket(move, color, direction)
if bracket:
ret += [move]
return ret
def get_game_history(self, request):
"""Get user's guess history"""
game = get_by_urlsafe(request.urlsafe_game_key, Game)
moves = Move.query(ancestor=game.key).order(Move.time)
if moves.count():
return AllGameHistory(history=[move.to_form() for move in moves])
else:
raise endpoints.NotFoundException(
'Game does not have any moves logged')
def valid_moves(self, color):
"""Retorna os movimentos validos para o jogador de cor 'color'."""
ret = []
for i in range(1, 9):
for j in range(1, 9):
if self.board[i][j] == Board.EMPTY:
for direction in Board.DIRECTIONS:
move = Move(i, j)
bracket = self._find_bracket(move, color, direction)
if bracket:
ret += [move]
return ret
def take_action(self, action):
"""Modifies the game state by performing an action.
Args:
action: String representing the action performed by the user.
Returns:
A string explaining the result of the action."""
plant_ref = self.plant.get()
try:
plant_ref.interact(action)
plant_ref.put()
if plant_ref.dead:
self.end_game(plant_ref.yielded())
except NotImplementedError as e:
raise e
move = Move(date=datetime.now(), action=action, result=plant_ref.look)
move.put()
self.moves.append(move.key)
self.put()
def better_valid_moves(self, board, color):
from models.move import Move
ret = []
for i in range(1, 9):
for j in range(1, 9):
if board.board[i][j] == board.EMPTY:
for direction in board.DIRECTIONS:
move = Move(i, j)
bracket = board._find_bracket(move, color, direction)
if bracket and move not in ret:
ret += [move]
return ret
def take_action(self, action):
"""Modifies the game state by performing an action.
Args:
action: String representing the action performed by the user.
Returns:
A string explaining the result of the action."""
plant_ref = self.plant.get()
try:
plant_ref.interact(action)
plant_ref.put()
if plant_ref.dead:
self.end_game(plant_ref.yielded())
except NotImplementedError as e:
raise e
move = Move(date=datetime.now(),
action=action,
result=plant_ref.look)
move.put()
self.moves.append(move.key)
self.put()
def record_roll(player, roll: 'Roll', game_id: str, is_winning_play: bool,
roll_num: int):
session = session_factory.create_session()
move = Move()
move.player_id = player.id
move.roll_id = roll.id
move.game_id = game_id
move.is_winning_play = is_winning_play
move.roll_number = roll_num
session.add(move)
session.commit()
session.close()
def moves_to_form(self):
"""Puts the moves into a message for return via API"""
moves_qry = Move.query(
Move.game_key == self.key).order(Move.move_number)
form_items_list = []
moves = moves_qry.fetch(read_policy=STRONG_CONSISTENCY)
i = 1
for move in moves:
move_form = MoveForm()
move_form.board = move.board_string
move_form.move_number = move.move_number
form_items_list.append(move_form)
i = i+1
moves_form = MovesForm()
moves_form.items = form_items_list
return moves_form
def record_roll(player, roll: 'Roll', game_id: str, is_winning_play: bool, roll_num: int):
session = session_factory.create_session()
move = Move()
move.player_id = player.id
move.roll_id = roll.id
move.game_id = game_id
move.is_winning_play = is_winning_play
move.roll_number = roll_num
session.add(move)
session.commit()
session.close()
def find_decent_move(self, active_team_lst, enemy_lst, safe_spots_lst):
true_lst = []
false_lst = []
ordered_pieces = []
# sort_lst = []
# opening = False
for piece in active_team_lst:
if piece.name == "king_w" or piece.name == "king_b":
true_lst.append(piece)
if piece.moved is False:
false_lst.append(piece)
else:
true_lst.append(piece)
ordered_pieces = random.sample(false_lst, len(false_lst)) + true_lst
potential_attack_decisions = []
non_attack_decisions = []
for piece in ordered_pieces:
valid_moves = piece.all_valid_moves(piece.pos.x, piece.pos.y,
enemy_lst + active_team_lst)
temp_potential_attacks = self.set_up_attack(
piece, valid_moves, self.get_enemy_cordinates(enemy_lst),
active_team_lst + enemy_lst, safe_spots_lst)
if len(temp_potential_attacks) > 0:
potential_attack_decisions.append(
(temp_potential_attacks, piece))
elif len(valid_moves) > 0:
non_attack_decisions.append((valid_moves, piece))
moves = []
if len(potential_attack_decisions) > 0:
decision = random.choice(potential_attack_decisions)
else:
decision = random.choice(non_attack_decisions)
for move in decision[0]:
# if move in safe_spots_lst:
moves.append(move)
if len(moves) > 0:
move = Move(random.choice(moves), 0, decision[1])
return move
def count_valid_moves(self, board, color):
my_count = 0
opp_count = 0
for i in range(1, 9):
for j in range(1, 9):
if board.board[i][j] == board.EMPTY:
for direction in board.DIRECTIONS:
move = Move(i, j)
my_bracket = board._find_bracket(
move, color, direction)
if my_bracket:
my_count += 1
opp_bracket = board._find_bracket(
move, board._opponent(color), direction)
if opp_bracket:
opp_count += 1
return [my_count, opp_count]
def play(self, board):
while True:
try:
rowInp = int(raw_input("Linha: "))
colInp = int(raw_input("Coluna: "))
move = Move(rowInp, colInp)
if move not in board.valid_moves(self.color):
raise
break
except:
print "Movimento invalido. Insira um valor valido"
# move = Move(rowInp, colInp)
# while move not in board.valid_moves(self.color):
# print "Movimento invalido.Insira um valido"
# print board
# rowInp = int(raw_input("Linha: "))
# colInp = int(raw_input("Coluna: "))
# move = Move(rowInp, colInp)
return move
def offense(self, safe_spots_lst, active_team_lst, enemy_lst):
best_attacks = []
for blk_piece in active_team_lst:
spots = blk_piece.all_valid_moves(blk_piece.pos.x, blk_piece.pos.y,
enemy_lst + active_team_lst)
for wht_piece in enemy_lst:
pos = (wht_piece.pos.x, wht_piece.pos.y)
if pos in spots and self.weigh_attack(
wht_piece, blk_piece, safe_spots_lst, enemy_lst,
active_team_lst) is True:
move = Move((wht_piece.pos.x, wht_piece.pos.y),
wht_piece.value, blk_piece)
# if self.opening_moves(move.piece, active_team_lst) is True:
# move.score += 100
move.score += wht_piece.value * 2
best_attacks.append(move)
best_attacks = sorted(best_attacks,
key=lambda x: x.score,
reverse=True)
return best_attacks
def defense(self, active_team_lst, enemy_lst):
threatened_pcs_lst = self.all_threatened_pcs(active_team_lst,
enemy_lst)
safe_spots = self.all_safe_spots(enemy_lst, active_team_lst)
if not threatened_pcs_lst:
return [], safe_spots
threatened_piece = self.determine_pc_to_defend(threatened_pcs_lst)
valid_moves = []
for spot in threatened_piece.all_valid_moves(
threatened_piece.pos.x, threatened_piece.pos.y,
active_team_lst + enemy_lst):
if spot in safe_spots:
enemy = self.check_for_enemy(enemy_lst, spot)
if enemy:
value = (threatened_piece.value * 3) + enemy.value # + 200
else:
value = threatened_piece.value * 3 # + 100
valid_moves.append(Move(spot, value, threatened_piece))
valid_moves = sorted(valid_moves, key=lambda x: x.score, reverse=True)
if len(valid_moves) > 2:
return valid_moves[:2], safe_spots
return valid_moves, safe_spots
def play(self, board):
score = board.score()
really_important_moves = [Move(1,1), Move(1,8), Move(8,1), Move(8,8)]
if(score[0] + score[1] < 45):
forbiden_moves = [Move(1,2), Move(2,2), Move(2,1),
Move(1,7), Move(2,7), Move(2,8),
Move(7,1), Move(7,2), Move(8,2),
Move(8,7), Move(7,7), Move(7,8)]
moves = board.valid_moves(self.color)
moves = self.filter_unique_moves(moves)
best_move = []
score_goal = 2
lowest_score_until_now = sys.maxint
for move in range(len(moves)):
if moves[move] in forbiden_moves:
continue
if moves[move] in really_important_moves:
return moves[move]
local_board = board.get_clone()
local_board.play(moves[move], self.color)
local_score = local_board.score()
if self.color == '■':
if local_score[0] < 2:
continue
if local_score[0] == 2:
lowest_score_until_now = local_score[0]
best_move = moves[move]
continue
if local_score[0] < lowest_score_until_now:
lowest_score_until_now = local_score[0]
best_move = moves[move]
else:
if local_score[1] < 2:
continue
if local_score[1] == 2:
lowest_score_until_now = local_score[1]
best_move = moves[move]
continue
if local_score[1] < lowest_score_until_now:
lowest_score_until_now = local_score[1]
best_move = moves[move]
if best_move == []:
best_move = random.choice(moves)
return best_move
else:
forbiden_moves = [Move(1,2), Move(2,2), Move(2,1),
Move(1,7), Move(2,7), Move(2,8),
Move(7,1), Move(7,2), Move(8,2),
Move(8,7), Move(7,7), Move(7,8)]
moves = board.valid_moves(self.color)
moves = self.filter_unique_moves(moves)
best_move = []
highest_score_until_now = -sys.maxint - 1
for move in range(len(moves)):
if moves[move] in forbiden_moves:
continue
if moves[move] in really_important_moves:
return moves[move]
local_board = board.get_clone()
local_board.play(moves[move], self.color)
local_score = local_board.score()
if self.color == '■':
if local_score[0] > highest_score_until_now:
highest_score_until_now = local_score[0]
best_move = moves[move]
else:
if local_score[1] > highest_score_until_now:
highest_score_until_now = local_score[1]
best_move = moves[move]
if best_move == []:
best_move = random.choice(moves)
return best_move
def play(self, board):
score = board.score()
really_important_moves = [
Move(1, 1), Move(1, 8),
Move(8, 1), Move(8, 8)
]
forbiden_moves = [
Move(1, 2),
Move(2, 2),
Move(2, 1),
Move(1, 7),
Move(2, 7),
Move(2, 8),
Move(7, 1),
Move(7, 2),
Move(8, 2),
Move(8, 7),
Move(7, 7),
Move(7, 8)
]
if (score[0] + score[1] < 45):
moves = board.valid_moves(self.color)
moves = self.filter_unique_moves(moves)
best_move = []
score_goal = 2
lowest_score_until_now = sys.maxint
for move in range(len(moves)):
if moves[move] in forbiden_moves:
continue
if moves[move] in really_important_moves:
return moves[move]
local_board = board.get_clone()
local_board.play(moves[move], self.color)
local_score = local_board.score()
if self.color == '■':
if local_score[0] < 2:
continue
opp_moves = local_board.valid_moves(
board._opponent(self.color))
opp_moves = self.filter_unique_moves(opp_moves)
pre_corner_boards = self.calculate_pre_corner_boards(
local_board, opp_moves, 3, board._opponent(self.color))
if pre_corner_boards == None:
pre_corner_boards = 0
theta = 0.5
heuristic = theta * pre_corner_boards + (
1 - theta) * local_score[0]
if local_score[0] == 2:
lowest_score_until_now = local_score[0]
best_move = moves[move]
else:
if local_score[1] < 2:
continue
opp_moves = local_board.valid_moves(
board._opponent(self.color))
opp_moves = self.filter_unique_moves(opp_moves)
pre_corner_boards = self.calculate_pre_corner_boards(
local_board, opp_moves, 3, board._opponent(self.color))
if pre_corner_boards == None:
pre_corner_boards = 0
theta = 0.5
heuristic = theta * pre_corner_boards + (
1 - theta) * local_score[1]
if local_score[0] == 2:
lowest_score_until_now = local_score[0]
best_move = moves[move]
if heuristic < lowest_score_until_now:
lowest_score_until_now = heuristic
best_move = moves[move]
if best_move == []:
best_move = random.choice(moves)
return best_move
else:
moves = board.valid_moves(self.color)
moves = self.filter_unique_moves(moves)
best_move = []
highest_score_until_now = -sys.maxint - 1
for move in range(len(moves)):
if moves[move] in forbiden_moves:
continue
if moves[move] in really_important_moves:
return moves[move]
local_board = board.get_clone()
local_board.play(moves[move], self.color)
local_score = local_board.score()
if self.color == '■':
if local_score[0] > highest_score_until_now:
highest_score_until_now = local_score[0]
best_move = moves[move]
else:
if local_score[1] > highest_score_until_now:
highest_score_until_now = local_score[1]
best_move = moves[move]
if best_move == []:
best_move = random.choice(moves)
return best_move
def calculate_pre_corner_boards(self, board, moves, level, color):
forbiden_moves = [
Move(1, 2),
Move(2, 2),
Move(2, 1),
Move(1, 7),
Move(2, 7),
Move(2, 8),
Move(7, 1),
Move(7, 2),
Move(8, 2),
Move(8, 7),
Move(7, 7),
Move(7, 8)
]
pre_corner_boards = 0
level = level - 1
if level == 0:
return 0
if self.color == color:
for move in moves:
local_board = board.get_clone()
if move in forbiden_moves:
pre_corner_boards += 1
local_board.play(move, self.color)
opp_moves = local_board.valid_moves(board._opponent(
self.color))
opp_moves = self.filter_unique_moves(opp_moves)
pre_corner_boards += self.calculate_pre_corner_boards(
local_board, opp_moves, level, board._opponent(self.color))
return pre_corner_boards
else:
for move in moves:
local_board = board.get_clone()
local_board.play(move, board._opponent(self.color))
new_moves = local_board.valid_moves(self.color)
new_moves = self.filter_unique_moves(new_moves)
pre_corner_boards += self.calculate_pre_corner_boards(
local_board, new_moves, level, self.color)
return pre_corner_boards
def make_guess(cls, game, player, guess):
"""Checks players turn and processes players guess"""
from utils import get_player_by_game
move = Move(
parent=game.key,
player=player.key,
name=player.name,
guess=guess,
match=False,
game_over=False
)
# check to make sure it is the players turns
if player.name != game.turn:
move.message = "Sorry, it is not your turn. {} please make a move".format(
game.turn)
return move
else:
# set player1 and player2
player_index = game.player_names.index(player.name)
if player_index == 0:
opponent = get_player_by_game(game.player_names[1], game)
else:
opponent = get_player_by_game(game.player_names[0], game)
# create a list of card values only
pl_values = [x['rank'] for x in player.hand]
opp_values = [x['rank'] for x in opponent.hand]
# make sure player has their guess in their own hand
if guess not in pl_values:
move.message = "Sorry, {} does not have a {} in hand. Please guess again.".format(
player.name, guess)
return move
else:
player.history.append(guess)
# check to see if guess is in player2 hand
if guess in opp_values:
move.match = True
move.message = "Match, please go again."
# find card in players hand
pl_index = pl_values.index(guess)
pl_card = player.hand[pl_index]
opp_index = opp_values.index(guess)
opp_card = opponent.hand[opp_index]
# add match to player1 matches
player.matches.append(pl_card)
player.matches.append(opp_card)
# remove cards from both players hands
player.hand.remove(pl_card)
opponent.hand.remove(opp_card)
player.num_matches += 1
player.put()
opponent.put()
if player.check_game_over(game.matches_to_win):
game.end_game(player, opponent)
move.game_over = True
move.message = "Game over, {} is the winner".format(
player.name)
return move
if opponent.check_game_over(game.matches_to_win):
game.end_game(opponent, player)
move.game_over = True
move.message = "Game over, {} is the winner".format(
opponent.name)
return move
return move
else:
# add the go fish card to players hand and remove from deck
card = random.choice(game.deck)
game.deck.remove(card)
player.hand.append(card)
player.put()
# check from matches and if game is over
player.check_pairs()
# change game turn
game.turn = opponent.name
game.put()
move.message = "No match, Go fish. {} drew {}".format(
player.name, card, player.hand)
return move
