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 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 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