def kill(): try: msg = request.json["msg"].upper() killer = Player.all().filter('username ='******'game =', game)\ .filter('killer =', killer)\ .filter('is_complete =', False).get() if msg == old_game_history_success.confirm_msg: will_be_last_kill = None if GameHistory.all().filter("game =", game).filter("is_complete =", False).count() == 2: will_be_last_kill = True old_target = old_game_history_success.target old_game_history_success.is_complete = True old_game_history_success.put() old_game_history_failure = GameHistory.all()\ .filter('game =', game)\ .filter('killer =', old_target)\ .filter('is_complete =', False).get() old_game_history_failure.is_complete = True old_game_history_failure.put() if will_be_last_kill: game_player = GamePlayer.all().filter('game =', game).filter('player =', killer).get() game_player.is_winner = True game_player.put() return jsonify({"success": True, "info": "Your enemy has been slain! "}) new_target = old_game_history_failure.target GameHistory(killer=killer, target=new_target, game=game, is_complete=False, confirm_msg=msg_generator()).put() return jsonify({"success": True, "info": "Your enemy has been slain! "}) else: return jsonify({"success": False, "info": "The message is incorrect. Are you trying to game the system?!"}) except: # TODO: please handle exceptions in a more proper way return jsonify({"success": False, "info": "Something is fundamentally wrong. ", "Data received by server": str(request.data)})
def new_game(self, request): """Creates new game""" player_one = User.query(User.name == request.player_one_name).get() player_two = User.query(User.name == request.player_two_name).get() if not player_one: raise endpoints.NotFoundException('Player one "' + request.player_one_name + '" does not exist!') if not player_two: raise endpoints.NotFoundException('Player two "' + request.player_two_name + '" does not exist!') game = Game.new_game(player_one.key, player_two.key, request.freak_factor) # Increment active count of games taskqueue.add(url='/tasks/increment_active_games') message = "Game created successfully" game_history = GameHistory(parent=game.key) game_history.history.append(game) game_history.messages.append(message) game_history.put() return game.to_form(message)
def get_game_history(self, request): """Returns the move history for a specified game.""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game: game_history = (GameHistory.query(GameHistory.game == game.key) .order(GameHistory.turn)) if game_history: return GameHistory.to_form(game_history) else: raise endpoints.NotFoundException( 'No bids have been raised for this game yet') else: raise endpoints.NotFoundException('Game not found!')
def _capture_game_snapshot(game, char): # game history is per game, so parent should be game and not the user # game history id history_id = GameHistory.allocate_ids(size=1, parent=game.key)[0] # game history key generated using history_id and game as its ancestor history_key = ndb.Key(GameHistory, history_id, parent=game.key) game_history = GameHistory(key=history_key, step_char=char, game_snapshot=game) # save game history game_history.put()
def make_move(self, request): """Makes a move. Returns a game state with message""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game.game_over: return game.to_form('Game already over!') if (game.whos_turn == 1 and game.player_one.get().name != request.player_name) or \ (game.whos_turn == 2 and game.player_two.get().name != request.player_name): return game.to_form('Please wait your turn!') try: game.move(request.move_row, request.move_col) game.put() except ValueError as error: return game.to_form(error.message) if game.game_over is True: taskqueue.add(url='/tasks/decrement_active_games') message = "Thank you for playing. " + \ request.player_name + " has won the game." else: message = "Move accepted. Please wait for your next turn." game_history = GameHistory.query(ancestor=game.key).get() game_history.history.append(game) game_history.messages.append(message) game_history.put() return game.to_form(message)
def make_move(self, request): """Makes a move. Returns a game state with message""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game.game_over: return game.to_form('Game already over!') """Hangman Game Logic""" word = list(request.guess)[0] target = list(game.target) miss = list(game.miss) current = list(game.current) valid = False inMissList = False message = '' game_history = GameHistory.query(GameHistory.game == game.key).get() """Check whether the input word is in miss list""" for index,t in enumerate(miss): if t == word: inMissList = True game.attempts_remaining -= 1 message = 'You already guessed that letter and it is not right! Try again, but a new one this time.' break """Check whether the input word is in target list""" for index,t in enumerate(target): if word == t: valid = True message = 'Correct!' current[index] = word break game.current = ''.join(current) """Update miss list""" if valid == False and inMissList == False: game.attempts_remaining -= 1 miss.append(word) game.miss =''.join(miss) game.put() message = 'Nice try! But it is not a valid word' """Compare between current and target""" if game.attempts_remaining < 1: game_history.addHistory(valid,word,'lose') game.end_game(False) message = 'Game over!' else: if target == current: game.end_game(True) game_history.addHistory(valid,word,'win') message = 'You Win!' else: game_history.addHistory(valid,word,'pending') game.put() return game.to_form(message)
def get_game_history(self,request): """Return game history for a specific game""" game = get_by_urlsafe(request.urlsafe_game_key,Game) if not game: raise endpoints.NotFoundException('Game not found!') gameHistory = GameHistory.query(GameHistory.game == game.key).get() return HistoryForms(items=[history.to_form() for history in gameHistory.histories])
def cancel_game(self, request): game = get_by_urlsafe(request.urlsafe_game_key, Game) if not game: raise endpoints.NotFoundException('Game not found!') if game.game_over is True: raise endpoints.ForbiddenException( 'You can not cancel this game as it is already over!') # Save the game. # A game with no winner and with game_over=True is a cancelled game. game.game_over = True game.put() # Decrement active games taskqueue.add(url='/tasks/decrement_active_games') message = "The game was cancelled successfuly." # Update game history game_history = GameHistory.query(ancestor=game.key).get() game_history.history.append(game) game_history.messages.append(message) game_history.put() return StringMessage(message=message)
def get_game_history(self, request): """Return game history for a specific game""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if not game: raise endpoints.NotFoundException('Game not found!') gameHistory = GameHistory.query(GameHistory.game == game.key).get() return HistoryForms( items=[history.to_form() for history in gameHistory.histories])
def new_game(self, request): """Creates new game""" user = User.query(User.name == request.user_name).get() if not user: raise endpoints.NotFoundException( 'A User with that name does not exist!') try: game = Game.new_game(user.key, request.word) GameHistory.new_game_history(game.key) except ValueError: raise endpoints.BadRequestException('Invalid word') # Use a task queue to update the average attempts remaining. # This operation is not needed to complete the creation of a new game # so it is performed out of sequence. taskqueue.add(url='/tasks/cache_average_attempts') return game.to_form('Good luck playing Hangman!')
def get_game_history(game): # query by kind query = GameHistory.query(ancestor=game.key) # order by timestamp query.order(GameHistory.step_timestamp) return query.fetch()
def get_game_history(self, request): """ This function returns the chronological game history based on a url safe game key. The 'turn' value uses computer counting, so the first move done will have a turn value of 0. """ histories = GameHistory.query(GameHistory.game_url_safekey == request.urlsafe_game_key).order(GameHistory.turn).fetch() return GameHistories(items=[history.to_form() for history in histories])
class SolitaireAPI(remote.Service): @endpoints.method(request_message=USER_REQUEST, response_message=StringMessage, path='user', name='create_user', http_method='POST') def create_user(self, request): """Create a new user""" # Check that user already exists if User.query(User.user_name == request.user_name).get(): raise endpoints.ConflictException( "A user with that name already exists") # Create a new user user = User(user_name=request.user_name, email=request.email) user.put() return StringMessage( message="User {} created!".format(request.user_name)) @endpoints.method(request_message=NEW_GAME_REQUEST, response_message=GameForm, path='game', name='new_game', http_method='POST') def new_game(self, request): """Create a new game""" user = User.query(User.user_name == request.user_name).get() if not user: raise endpoints.NotFoundException( "A user with that name does not exist") game = SolitaireGame(None, None, None, None, False) game.new_game() # Convert card stacks to JSON game_json = to_json(game) try: game_db = Game.new_game(user=user.key, piles=game_json['piles'], foundations=game_json['foundations'], deck=game_json['deck'], open_deck=game_json['open_deck']) except Exception, e: logging.error(str(e)) # Save game history GameHistory.new_history(game=game_db.key, sequence=game_db.moves, game_over=game_db.game_over, piles=game_db.piles, foundations=game_db.foundations, deck=game_db.deck, open_deck=game_db.open_deck) return game_db.to_form('New game created!')
def get_game_history(self, request): """Return every moves of the game""" game_histories = GameHistory.query(ancestor=ndb.Key( urlsafe=request.urlsafe_game_key)).fetch() if not game_histories: raise endpoints.NotFoundException("No Game Histories found") return GameHistoryForms( items=[history.to_form() for history in game_histories])
def cancel_game(self, request): """This function delete a game. Input: Game safe url key""" game = utils.get_by_urlsafe(request.urlsafekey, Game) if game.status == "over": raise endpoints.ConflictException('Cannot delete a Game over') for hist in GameHistory.query(GameHistory.game == game.key): hist.key.delete() game.key.delete() return MessageForm(message=" Game cancelled")
def getUserGameHistory(self, request): """ returns all moves made and corresponding game state per move for a given user """ game_history = GameHistory.query(GameHistory.game_id == request.game_id, GameHistory.user_id == request.user_id).fetch() game_history_forms = GameHistoryForms(moves = [ move.to_form() for move in game_history ]) if len(game_history) == 0: game_history_forms = [GameHistoryForm(user_id="There's No Games For Selected User ID")] return GameHistoryForms(moves=game_history_forms) return game_history_forms
def get_game(game_id): game = Game.get_by_id(int(game_id)) if game is None: return jsonify({'success': False, 'info': None}) info = to_dict(game) people = [game_player.player.username for game_player in game.players] info['success'] = True info['participants'] = str(people) game_history = GameHistory.all().filter('game =', game).filter('is_complete =', False) info['survivors'] = [record.killer.username for record in game_history] return jsonify({'success': True, 'info': info}) # does not render a page, just returns a Json
def make_move(self, request): """Makes a move. Returns a game state with message""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game.game_over: return game.to_form('Game already over!') """Hangman Game Logic""" word = list(request.guess)[0] target = list(game.target) miss = list(game.miss) current = list(game.current) valid = False inMissList = False message = '' game_history = GameHistory.query(GameHistory.game == game.key).get() """Check whether the input word is in miss list""" for index, t in enumerate(miss): if t == word: inMissList = True game.attempts_remaining -= 1 message = 'You already guessed that letter and it is not right! Try again, but a new one this time.' break """Check whether the input word is in target list""" for index, t in enumerate(target): if word == t: valid = True message = 'Correct!' current[index] = word break game.current = ''.join(current) """Update miss list""" if valid == False and inMissList == False: game.attempts_remaining -= 1 miss.append(word) game.miss = ''.join(miss) game.put() message = 'Nice try! But it is not a valid word' """Compare between current and target""" if game.attempts_remaining < 1: game_history.addHistory(valid, word, 'lose') game.end_game(False) message = 'Game over!' else: if target == current: game.end_game(True) game_history.addHistory(valid, word, 'win') message = 'You Win!' else: game_history.addHistory(valid, word, 'pending') game.put() return game.to_form(message)
def _cache_game_move(game, position, message, urlsafe_game_key): """Populates memcache with the actual moves of the Game""" if not game.game_over: history = memcache.get(MEMCACHE_GAME_HISTORY_PREFIX + urlsafe_game_key) or [] game_history = GameHistory(username=game.current_player, position=position, message=message) history.append(game_history) memcache.set(MEMCACHE_GAME_HISTORY_PREFIX + urlsafe_game_key, history)
def make_move(self, request): """Makes a move. Returns a game state with message""" game = get_by_urlsafe(request.urlsafe_game_key, Game) # Check if the game is finished if game.game_over: return game.to_form('Game already finished!') # Only alphabetic character is allowed if not request.guess.isalpha(): return game.to_form('Only alphabetic character is allowed!') guess = request.guess.upper() # Only one character is allowed if len(guess) != 1: return game.to_form('Only one character allowed') # We will check if the character is already used game_key = ndb.Key(Game, request.urlsafe_game_key) ls = GameHistory.query(ancestor=game_key).filter( GameHistory.guess == guess).count() if ls != 0: return game.to_form('Character already used' + guess) found = False temp = list(game.guess_word) temp_wimp = list(game.word_in_progress) for i, val in enumerate(temp): if val == guess: temp_wimp[i] = guess found = True msg = 'Key found ' + guess GameHistory.create_game_history(request.urlsafe_game_key, guess, found, i, 'Found') game.word_in_progress = ''.join(temp_wimp) if found is False: GameHistory.create_game_history(request.urlsafe_game_key, guess, found, -1, 'Not found') game.attempts_remaining -= 1 msg = 'Character not found in word: ' + request.guess if game.word_in_progress == game.guess_word: game.end_game(True) msg = 'You win' if game.attempts_remaining < 1: game.end_game(False) GameHistory.create_game_history(request.urlsafe_game_key, guess, found, -1, 'Not attempts remaining you lose') return game.to_form(msg + ' Game over!') else: game.put() return game.to_form(msg)
def get_game_history(self, request): """Return the game history.""" game = get_by_urlsafe(request.urlsafe_game_key, Game) # If the game dose't exist throw exception. if not game: raise endpoints.NotFoundException('Game not found!') game_key = ndb.Key(Game, request.urlsafe_game_key) return GameHistoryForms(items=[ game_history.to_form() for game_history in GameHistory.query( ancestor=game_key).order(GameHistory.date_created) ])
def game_history(self, request): game = get_by_urlsafe(request.urlsafe_game_key, Game) if not game: raise endpoints.NotFoundException('Game not found!') game_history = GameHistory.query(ancestor=game.key).get() items = [] for index, item in enumerate(game_history.history): items.append(item.to_form(game_history.messages[index])) return GameForms(items=items)
def make_move(self, request): """ Make a move. This function requires a url safe game key and allows the user to make a guess as to whether the 3rd generated number is inside or outside the 1st and 2nd generated number. The input for this MUST be either 'inside' or 'outside' or an error will be thrown. """ game = get_by_urlsafe(request.urlsafe_game_key, Game) if request.guess != 'inside' and request.guess != 'outside': raise endpoints.BadRequestException('Must guess inside or outside') if game.game_over: return game.to_form('Game already over!') sorting_list = [game.first_random_number, game.second_random_number] sorting_list = sorted(sorting_list, key=int) first_random_number = sorting_list[0] second_random_number = sorting_list[1] third_random_number = game.third_random_number max_guess = game.max_guess turn = game.streak if first_random_number == second_random_number or \ third_random_number == second_random_number or \ third_random_number == first_random_number: # tie is auto lose msg = 'tie' elif first_random_number < third_random_number < second_random_number: msg = 'inside' elif third_random_number < first_random_number or \ third_random_number > second_random_number: msg = 'outside' if request.guess != msg or msg == 'tie': alert = "Sorry, you lost!" game.end_game() elif request.guess == msg: alert = "You're correct!" # max + 1 because of computer counting. game.first_random_number = random.choice(range(1, max_guess+1)) game.second_random_number = random.choice(range(1, max_guess+1)) game.third_random_number = random.choice(range(1, max_guess+1)) game.streak += 1 game.put() history = GameHistory.new_record(game.key, request.urlsafe_game_key, \ request.guess, turn, alert) history.put() return game.to_form(alert)
def cancel_game(self, request): """Delete a game from the database""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game: if not game.game_over: game_history = GameHistory.query(ancestor=game.key).fetch() for h in game_history: h.key.delete() game.key.delete() return StringMessage(message="The game has been deleted!") else: raise endpoints.ForbiddenException( "Not allowed to delete a completed game") else: raise endpoints.NotFoundException("Game not found")
def get_game_status(): info = {"target": None, "in_game": False, "game_exists": False, "msg": None, "player_exists": False, "game_completed": False, "time_left": None} try: game = Game.get_by_id(int(request.args["game_id"])) if game is None: info["msg"] = "Game does not exists. " return jsonify(info) info["game_exists"] = True killer = Player.all().filter('username ='******'game =', game).filter('player =', killer).get() if player_in is None: info["msg"] = "Player trying to kill is not in this game. " return jsonify(info) info["in_game"] = True if GameHistory.all().filter("game =", game).filter("is_complete =", False).count() == 0: info["game_completed"] = True game_player = GamePlayer.all().filter('game =', game).filter('is_winner =', True).get() info["winner_name"] = str(game_player.player.username) return jsonify(info) to_kill_game_history = GameHistory.all().filter('killer =', killer).filter('game =', game).filter('is_complete', False).get() be_killed_game_history = GameHistory.all().filter('target =', killer).filter('game =', game).filter('is_complete', False).get() if to_kill_game_history is None: return jsonify(info) else: info["time_left"] = to_kill_game_history.assign_date + timedelta(hours=1) info["target"] = to_kill_game_history.target.username info["msg"] = be_killed_game_history.confirm_msg return jsonify(info) except: # info["time_left"] = str(datetime.datetime.now()) info["msg"] = "Something is fundamentally wrong. " return jsonify(info)
def make_a_move(self, request): """ This function enables a player to move during the race. Input: game safe url key, player username, number render by the Dice""" if request.dice not in diceValue: raise endpoints.NotFoundException('Invalid Dice Number') game = utils.get_by_urlsafe(request.game_urlsafekey, Game) if game.status != "start": raise endpoints.NotFoundException( 'This game is either over or save!! Resume if saved') player = Position.query( Position.game == game.key, Position.player == utils.get_by_username( request.player).key).get() if not player.isPlayingNow: raise endpoints.NotFoundException( 'This player does not have token to play now') # Who is Player and who is Opponent ? Current user is always the # PLAYER if game.player == player.player: opponent = Position.query(Position.game == game.key, Position.player == game.opponent).get() elif game.opponent == player.player: opponent = Position.query(Position.game == game.key, Position.player == game.player).get() # IMPORTANT !!!! # player and opponent are key objects in POSITION model # change position player.position = utils.move(player.position, request.dice) self._updateScore(game, player) # remove token player.isPlayingNow = False player.put() game_status = "Token False. Time for your opponent to play!" # Opponent is given token to play opponent.isPlayingNow = True msg = "Player %s played %s; Distance Moved:%s; Points earned: %s " % ( request.player, request.dice, player.position, player.position) GameHistory(game=game.key, message=msg).put() # Opponent loose its position as first if player.position == opponent.position: opponent.position -= 1 # GAME Over if player.position == 100: opponent.isPlayingNow = False game.gameOver(player) GameHistory(game=game.key, message="Player %s WON" % request.player).put() game_status = "GAME OVER, YOU WON THE RACE!!!!!" opponent.put() return MakeMoveForm( player=request.player, dice=request.dice, position=player.position, score=Score.query(Score.game == game.key, Score.player == player.player).get().score, status=game_status)
def get_game_history(self, request): """This function returns all moves in a game.""" game = utils.get_by_urlsafe(request.game_urlsafekey, Game) games = GameHistory.query(GameHistory.game == game.key).order( GameHistory.date) return ListGameHistory(history=[game.toForm() for game in games])
def make_move(self, request): """Make a move""" action = request.action origin = request.origin destination = request.destination card_position = request.card_position # If action is MOVE, the source and destination # field cannot be empty if action == Action.MOVE: if not origin or not destination: raise endpoints.BadRequestException( 'Souce and Destination must not be empty for MOVE action') if not card_position: card_position = -1 # If action is SHOW, the source field cannot be empty if action == Action.SHOW: if not origin: raise endpoints.BadRequestException( 'Souce must not be empty for SHOW action') # Load the game from DB game_db = get_by_urlsafe(request.urlsafe_game_key, Game) if not game_db: raise endpoints.NotFoundException("The Game does not exist") # If game is over, copy to form and return if game_db.game_over: return game_db.to_form('Game already over') # Create Python game object game = to_python(piles=game_db.piles, foundations=game_db.foundations, deck=game_db.deck, open_deck=game_db.open_deck, game_over=game_db.game_over) # Make the move # To track whether any cards are moved or upturned changed = False if action == Action.DEAL: game.deal() changed = True game_db.moves += 1 game.print_game() if action == Action.MOVE: changed = game.move(origin=str(origin), destination=str(destination), card_position=card_position) if changed: game_db.moves += 1 else: game.print_game() raise endpoints.BadRequestException("Illigal move. Try again.") game.print_game() if action == Action.SHOW: changed = game.show_top(str(origin)) if changed: game_db.moves += 1 else: game.print_game() raise endpoints.BadRequestException('Could not show the card.') game.print_game() # Convert the game to JSON format game_json = to_json(game) # If changed, update the fields and save in DB if changed: game_db.piles = game_json['piles'] game_db.foundations = game_json['foundations'] game_db.deck = game_json['deck'] game_db.open_deck = game_json['open_deck'] game_db.game_over = game_json['game_over'] game_db.put() GameHistory.new_history(game=game_db.key, sequence=game_db.moves, game_over=game_db.game_over, piles=game_db.piles, foundations=game_db.foundations, deck=game_db.deck, open_deck=game_db.open_deck) if game_db.game_over: game_db.save_game() return game_db.to_form('Made a move')
def makeMove(self, request): """ Asigns specific move to a user for a specific game_id, as long as its available It also checks if the move is valid, returning the appropiate message for each situation. It also keeps track of every valid move made by a user """ x = request.x y = request.y game_id = request.game_id user_id = request.user_id game = Game.query(Game.game_id == game_id).get() queried_move = Move.query(Move.x == x, Move.y == y, Move.game_id == game_id).fetch(1) all_moves = Move.query(Game.game_id==game_id) if game == None : print("\n\nInvalid Move, Wrong Game ID\n\n") return StringMessage(message = "Invalid Move, Wrong Game ID" ) winner_id = GuessANumberApi._check_winning_condition(game_id) if winner_id != False and winner_id != "no_winners_yet": print("\n\n Game Won By {0} \n\n".format(winner_id)) game.finish_game(winner_id, "game_won") return StringMessage(message = "\n\n Game Won By {0} \n\n".format(winner_id), game_state="game_won", winner_id=winner_id) available_moves = Move.query(Move.available == True, Move.game_id == game_id).fetch() if len(available_moves) == 0: print("\n\n Game Ended, No more moves left {0} \n\n".format(game_id)) game.finish_game(winner_id, "no_more_moves") return StringMessage(message = "\n\n Game Ended, No more moves left {0} \n\n".format(game_id), game_state="no_more_moves", winner_id=winner_id or "") if user_id == None or user_id not in [game.player1, game.player2]: print("\n\nInvalid move parameters\n\n") return StringMessage(message = "Invalid Move, Wrong User ID" ) if len(queried_move) == 0: print("\n\nInvalid move parameters\n\n") return StringMessage(message = "Invalid move parameters, Wrong Game ID or Move out of range" ) if user_id == game.last_play_user_id: print("\n\n This Player already moved\n\n") return StringMessage(message = "Invalid move, This Player already moved" ) move = queried_move[0] if move.available != True: print("\n\nMove already done by: {0} \n\n".format(move.user_id)) return StringMessage(message = "Move {0} has already been made by User with ID: : {1}" .format(move.description, move.user_id) ) move.user_id = user_id move.available = False move.put() game.last_play_user_id = user_id game.put() GuessANumberApi._show_game_picture(game_id) state = GuessANumberApi._check_game_state(game_id) if state == False: state = "no_winners_yet" string_move = "[{0},{1}]".format(move.x, move.y) saved_move = GameHistory(game_id = game.game_id, user_id = user_id, move = string_move, game_state = state) saved_move.put() print(saved_move) # Final Winning Check winner_id = GuessANumberApi._check_winning_condition(game_id) if winner_id != False and winner_id != "no_winners_yet": print("\n\n Game Won By {0} \n\n".format(winner_id)) game.finish_game(winner_id, "game_won") return StringMessage(message = "\n\n Game Won By {0} \n\n".format(winner_id), game_state="game_won", winner_id=winner_id) return StringMessage(message = "New Move {0} assigned to {1} Game ID: {2}, x:{3} and y:{4}" .format(move.description, user_id, game_id, x, y), game_state="game_active", winner_id="" )
def raise_bid(self, request): """Makes a move. Returns a game state with message""" game = get_by_urlsafe(request.urlsafe_game_key, Game) # Validity logic if game.game_over or game.cancelled: return game.to_form('Game already over!') bidding_player = Player.query( Player.game == game.key, Player.order == game.bid_player % game.players + 1).get() bidding_user = bidding_player.user.get() if bidding_user.password != request.password: return game.to_form('Invalid password.') if (game.bid_face == game.die_faces and game.bid_total == game.dice_total * game.players): return game.to_form('Already at max possible bid. Bid cannot be ' 'rasied. Call liar to end game.') if request.bid_face < 1 or request.bid_face > game.die_faces: return game.to_form('Invalid face number. Must be between 1 ' 'and ' + str(game.die_faces) + '.') if request.bid_face < game.bid_face: return game.to_form('Invalid dice face. Must be greater than or ' 'equal to the current dice face bid:%d.' % (game.bid_face)) if (request.bid_face == game.bid_face and request.bid_total <= game.bid_total): return game.to_form('Invalid bid. If not raising dice face, ' 'must raise dice total') # Game logic game.bid_face = request.bid_face game.bid_total = request.bid_total game.turn += 1 # Update player info if game.bid_player == game.players: game.bid_player = 1 else: game.bid_player += 1 game.put() # Record History game_history = GameHistory(game=game.key, turn=game.turn, player=bidding_player.key, bid_face=game.bid_face, bid_total=game.bid_total) game_history.put() # Find the next player next_player = Player.query( Player.game == game.key, Player.order == game.bid_player % game.players + 1).get() next_user = next_player.user.get() if next_user.email is not None: task_params = ({ 'email': next_user.email, 'user_name': next_user.user_name, 'game_key': game.key.urlsafe(), 'dice': Dice.query(Dice.player == next_player.key) .order(Dice.face), 'bid_face': game.bid_face, 'bid_total': game.bid_total, 'bid_player': bidding_user.user_name}) taskqueue.add( params=task_params, url='/tasks/send_your_turn' ) return game.to_form('Current bid is now face: %d, number %d. It is ' '%s\'s turn.' % (request.bid_face, request.bid_total, next_user.user_name))
def get_game_history(self,request): """Return moves for specified game""" game = get_by_urlsafe(request.urlsafe_game_key, Game) return GameHistoryForms(items = [record.to_form() for record in \ GameHistory.query(GameHistory.game == game.key).order(GameHistory.movecount)])