def new_game(cls, request): """Creates and returns a new game""" gplus_user = get_endpoints_current_user() user = User.query(User.email == gplus_user.email()).get() if request.total_rounds not in ROUNDS_OPTIONS: raise endpoints.BadRequestException('Invalid total number of rounds.' ' Must be a number contained in the set: {0}.'.format(ROUNDS_OPTIONS)) game = Game(user=user.key, total_rounds=request.total_rounds, remaining_rounds=request.total_rounds) game.put() return game.to_form()
def post_game(): data = request.get_json() # TODO create decorator that returns user from header auth_header = request.headers.get('Authorization') user = jwt.decode(auth_header.split(" ")[1], os.environ.get('SECRET_KEY'))['user'] user_id = json.loads(user)['id'] try: game = Game(name=data['name'], description=data['description'], board_size=data['boardSize'], game_room=data['gameRoom'], player_white=user_id) db.session.add(game) db.session.commit() new_game_notice(room=game.game_room, game=game_schema.dumps(game)) response = { 'status': 'success', 'message': 'Game created', 'game': game.id } return jsonify(response), 201 except Exception as e: print('error') print(e) print(e.__dict__) response = { 'status': 'fail', 'message': 'There was an error. Please try again.' } return jsonify(response), 401
def _GetAllGames(self, all_game_lists): index = 'A' games_list = [] for item in all_game_lists: team_vs = GetOneElementByClass(item, 'div', 'team_vs') team_details_div = GetElementsByClass(team_vs, 'div', 'txt') team_score_a = GetOneElementByClass( team_details_div[0], 'span', 'num') team_score_b = GetOneElementByClass( team_details_div[1], 'span', 'num') team_score_a = GetTextOfItem(team_score_a, '0') team_score_b = GetTextOfItem(team_score_b, '0') team_name_a = GetTextOfItem(team_details_div[0].find('a')) team_name_b = GetTextOfItem(team_details_div[1].find('a')) team_a = Team(name=team_name_a, score=team_score_a) team_b = Team(name=team_name_b, score=team_score_b) team_vs_time = GetOneElementByClass(team_vs, 'span', 'b') team_vs_time = GetTextOfItem(team_vs_time, ' 未开始') games_list.append(Game(index, team_a, team_b, team_vs_time)) index = chr(ord(index) + 1) return games_list
def on_client_connect(self, websocket, path): logging.debug("New connection from: {}".format( websocket.remote_address)) id = hash("{}{}".format(websocket.remote_address, datetime.datetime.utcnow().isoformat())) client = Client(id, websocket) if len(self.pending_clients) == (Game.NUM_CLIENTS_TO_GAME - 1): # start the game logging.debug("Start the new game") players = [client] + self.pending_clients self.pending_clients = [] asyncio.ensure_future(Game(players, self.loop).start(), loop=self.loop) logging.debug("New game session was started") else: self.pending_clients.append(client) try: yield from websocket.send(greeting(id)) while True: message = yield from websocket.recv() logging.debug("Client({}) sent an request: {}".format( id, message)) client.received_command(message) except websockets.ConnectionClosed: logging.debug("Client({}) disconnected".format(id)) if client in self.pending_clients: self.pending_clients.remove(client)
def getGame(page_data): json_data = json.loads(page_data) game = json_data['gameData'] game_id = json_data['gamePk'] db_game = Game.query.filter_by(game_id=game_id).first() if db_game: new_game = db_game else: params = { 'game_id': game['game']['pk'], 'type': game['game']['type'], 'start_time': datetime.strptime(game['datetime']['dateTime'], '%Y-%m-%dT%H:%M:%SZ'), 'end_time': datetime.strptime(game['datetime']['endDateTime'], '%Y-%m-%dT%H:%M:%SZ'), 'game_state': game['status']['abstractGameState'], 'game_state_id': game['status']['codedGameState'] } new_game = Game(params) db.session.add(new_game) db.session.commit() return new_game
def main(): while True: print("Welcome to The Fun Game !!!\n") game = Game() game.rounds = 5 print( "1. Single player (Player vs Bot)\n2. Double player (Player vs Player)\n" "3. Demo (KindBot vs Evil Bot)\n4. Exit") choice = input("Enter your option : ") if choice in ["1", "2", "3"]: game.initialize(int(choice)) elif choice == "4": exit() else: print("Enter a valid option")
def get_user_games(cls): """Returns all of the current User's active games""" gplus_user = get_endpoints_current_user() user = User.query(User.email == gplus_user.email()).get() active_games = Game.query() \ .filter(Game.user == user.key) \ .filter(Game.game_over == False) return GameForms(games=[game.to_form() for game in active_games])
def __init__(self, parent): super().__init__() self._game = Game() self._history = History() self._game_view = GameView() self._status_view = StatusView() self._history_view = HistoryView() parent.setCentralWidget(self._game_view) parent.addDockWidget(Qt.TopDockWidgetArea, self._status_view) parent.addDockWidget(Qt.RightDockWidgetArea, self._history_view) # Make Connections for row in self._game_view.squares: for square in row: # TODO: Look into why a lambda function is necessary; the method itself doesn't work square.clicked.connect( lambda coords: self.handle_square_click(coords)) # Set up the initial state of the board self._game_view.update_squares(self._game.board) message = self.create_status_message("") self._status_view.update_message(message)
def get(self): """Send a reminder email to each User with incomplete active games. Called every 24 hours using a cron job""" app_id = app_identity.get_application_id() games = Game.query(Game.game_over == False) users = [] for game in games: user = game.user.get() if user not in users: # Limit emails to 1 per user per day users.append(user) for user in users: subject = 'This is a reminder!' body = 'Hello {}, come back and finish your game of Rock, Paper, Scissors!'.format(user.displayName) mail.send_mail('noreply@{}.appspotmail.com'.format(app_id), user.email, subject, body)
from models.Game import Game if __name__ == '__main__': game = Game() game.start_game()
import random import time from models.enum.direction import Direction from models.Game import Game from models.q_learn import Q_Learn from sklearn.preprocessing import StandardScaler game = Game() game.update() game.highest = game.highest_tile() def play(): while (game.game_over() is False): r = random.randint(1, 4) if r is 1: next_state, _, _, _ = game.move(Direction.RIGHT) if r is 2: next_state, _, _, _ = game.move(Direction.LEFT) if r is 3: next_state, _, _, _ = game.move(Direction.DOWN) if r is 4: next_state, _, _, _ = game.move(Direction.UP) #game.replay() def manual(): while game.game_over() is False:
from models.Game import Game if __name__ == '__main__': game = Game() game.start()
def main(): game = Game() game.init() while True: game.update()
def create_game(): data = request.get_json() game = Game(**data).save() return Response(game.to_json(), mimetype="application/json", status=200)
""" application/__init__.py """ from flask import Flask from flask_socketio import SocketIO from os import urandom app = Flask(__name__) app.debug = True app.secret_key = urandom(24) socketio = SocketIO(app) from models.Game import Game game = Game() import application.comm, application.views
parser.add_argument("--port", "-P", help="Server port to connect to", type=int, default=5555) parser.add_argument("--heuristic", help="Which heuristic to use", type=str, default="monogroup") args = parser.parse_args() if __name__ == "__main__": try: assert args.heuristic in HEURISTICS game = Game(args.host, args.port, args.name) print("// You are playing {}".format(game.type)) turn = 0 while game.is_running: game.update_map() sleep(1) if game.is_running: turn += 1 moves = alphabeta_search(game.type, game.get_map(), d=4, heuristic_played=args.heuristic) try: game.send_move(moves) except ValueError as exception:
class GameController(QObject): def __init__(self, parent): super().__init__() self._game = Game() self._history = History() self._game_view = GameView() self._status_view = StatusView() self._history_view = HistoryView() parent.setCentralWidget(self._game_view) parent.addDockWidget(Qt.TopDockWidgetArea, self._status_view) parent.addDockWidget(Qt.RightDockWidgetArea, self._history_view) # Make Connections for row in self._game_view.squares: for square in row: # TODO: Look into why a lambda function is necessary; the method itself doesn't work square.clicked.connect( lambda coords: self.handle_square_click(coords)) # Set up the initial state of the board self._game_view.update_squares(self._game.board) message = self.create_status_message("") self._status_view.update_message(message) @Slot(tuple) def handle_square_click(self, coords): """ Validates a piece selection; updates the Board. """ if self.is_complete(): message = self.create_status_message("") self._status_view.update_message(message) return source = self._game.board.selected # Catch gutter selections try: target = self.get_piece(coords) except IllegalMove as e: message = self.create_status_message(str(e)) self._status_view.update_message(message) return # Deselection if source == target: self._game.board.selected = None self._game_view.update_selection(None) return # Selection if source is None: try: self.select_piece(target) except IllegalMove as e: message = self.create_status_message(str(e)) self._status_view.update_message(message) finally: return # Make move try: self._game.make_move(source, target) except IllegalMove as e: message = self.create_status_message(str(e)) self._status_view.update_message(message) return message = self.create_status_message("") self._status_view.update_message(message) self._game_view.update_squares(self._game.board) # Update history self._history.add_move(source, target) origin_center, destination_center = self._history.get_last_move() self._history_view.add_move(origin_center, destination_center) def select_piece(self, target): """ Selects a 3x3 piece to be moved. """ if self.is_piece_empty(target): raise IllegalMove("This piece has no stones.") if not self.is_player_piece(target): raise IllegalMove("This piece is not the active player's.") self._game.board.selected = target self._game_view.update_selection(target) def get_piece(self, center): """ Accepts center coordinates (row, col) for a piece and returns it as a dictionary in the form {(row, col): stone}. """ try: # Prevents index wraparound if 0 in center: raise IndexError piece = {} squares = self._game.board.squares for row, col in product(range(-1, 2), range(-1, 2)): coords = center[0] + row, center[1] + col piece[coords[0], coords[1]] = squares[coords[0]][coords[1]] except IndexError: raise IllegalMove("Cannot select from the gutter.") return piece def is_player_piece(self, piece): """ Returns True if the given piece belongs solely to the active player. """ player_stone = self._game.active_player.stone stone_set = set(piece.values()) - {""} return stone_set == set(player_stone) def is_complete(self): """ Returns true if the game has been won. """ return self._game.game_state != "UNFINISHED" def create_status_message(self, status_message): """ Creates a message from the model's state for the status view. """ message = "" if self._game.game_state == "UNFINISHED": message += "{}'s turn".format( self._game.active_player.color.title()) if status_message: message += "; " else: message += self._game.game_state.replace("_", " ").title() return message + status_message @staticmethod def is_piece_empty(piece): """ Returns true if a 3x3 piece contains no stones. """ for stone in piece.values(): if stone: return False return True
import threading import time import PySimpleGUI as sg from file.MoveReader import MoveReader from file.MoveWriter import MoveWriter from models.AI import AILvl1, AILvl2, AILvl3 from models.Builder import Builder from models.Game import Game # Get new Game instance game = Game() # Initialize MoveWriter (set (default) writing location) MoveWriter.init() # Set PySimpleGUI theme -> Dark or Light + Color + Number sg.change_look_and_feel('DarkBlack1') # Wait after move wait = 0.5 # Depth for MiniMax algorithm depth = 3 # Play-by-play between two bots play_by_play = False # Main Menu ====================================================================================== # Make main menu layout menu_layout = [ #matrica sa svim izborima
def get_games(): games = Game.objects().to_json() return Response(games, mimetype="application/json", status=200)