Server implemented.

Author: mikeckennedy

.gitignore

@@ -104,3 +104,4 @@ ENV/
 .idea
 days/91-93-sqlalchemy/demo/persistent_rps/db/rock_paper_scissors.sqlite
 days/91-93-sqlalchemy/demo/persistent_rps_starter/.vscode/settings.json
+rock_paper_scissors.sqlite

days/97-99-online-game-api/demo_app/web/app.py

@@ -1,29 +1,32 @@
 import flask
+from game_logic import game_decider, game_service
+from views import game_api, home
 
 app = flask.Flask(__name__)
 
 
 def main():
-    app.run(debug=True)
+    build_starter_data()
+    build_views()
+    run_web_app()
+
 
+def build_views():
+    game_api.build_views(app)
+    home.build_views(app)
 
-@app.route('/')
-def index():
-    return "Hello world!!!"
 
+def build_starter_data():
+    roll_names = game_decider.all_roll_names()
+    game_service.init_rolls(roll_names)
 
-@app.route('/api/test', methods=['GET'])
-def api_test():
-    data = {
-        'name': 'Michael',
-        'day': 97
-    }
-    return flask.jsonify(data)
+    computer = game_service.find_player('computer')
+    if not computer:
+        game_service.create_player('computer')
 
 
-@app.errorhandler(404)
-def not_found(_):
-    return "The page was not found."
+def run_web_app():
+    app.run(debug=True)
 
 
 if __name__ == '__main__':

days/97-99-online-game-api/demo_app/web/game_logic/game.py

@@ -1 +1,72 @@
-# TODO: Game logic.
+from collections import defaultdict
+
+from game_logic import game_service, game_decider
+from game_logic.game_decider import Decision
+from game_logic.models.player import Player
+from game_logic.models.roll import Roll
+
+
+class GameRound:
+
+    def __init__(self, game_id: str, player1: Player, player2: Player,
+                 p1_roll: Roll, p2_roll: Roll):
+        self.p2_roll = p2_roll
+        self.p1_roll = p1_roll
+        self.game_id = game_id
+        self.player1 = player1
+        self.player2 = player2
+
+        self.decision_p1_to_p2 = None
+        history = game_service.get_game_history(game_id)
+        self.round = len(history) // 2 + 1
+        self.player1_wins = GameRound.count_wins(self.player1, history)
+        self.player2_wins = GameRound.count_wins(self.player2, history)
+        self.WIN_COUNT_MIN = 3
+        self.PLAY_COUNT_MIN = 5
+        self.is_over = game_service.is_game_over(game_id)
+
+    def play(self):
+        if self.is_over:
+            raise Exception("Game is already over, cannot play further.")
+
+        d = game_decider.decide(self.p1_roll, self.p2_roll)
+        self.decision_p1_to_p2 = d
+
+        self.record_roll(d, self.player1, self.p1_roll, self.player1_wins)
+        self.record_roll(d.reversed(), self.player2, self.p2_roll, self.player2_wins)
+
+        print("RECORDING ROUND")
+        print("Player 1: {}, prior wins {}, outcome: {}".format(self.p1_roll.name, self.player1_wins, d))
+        print("Player 2: {}, prior wins {}, outcome: {}".format(self.p2_roll.name, self.player2_wins, d.reversed()))
+        print()
+
+        self.is_over = game_service.is_game_over(self.game_id)
+
+    def record_roll(self, decision: Decision, player: Player, roll: Roll, win_count: int):
+        final_round_candidate = self.round >= self.PLAY_COUNT_MIN and win_count + 1 >= self.WIN_COUNT_MIN
+        wins_game = final_round_candidate and decision == Decision.win
+
+        game_service.record_roll(player, roll, self.game_id, wins_game, self.round)
+
+    @staticmethod
+    def count_wins(player, history):
+        grouped_moves = defaultdict(list)
+
+        for h in history:
+            grouped_moves[h.roll_number].append(h)
+
+        win_count = 0
+        for rnd_data in grouped_moves.values():
+            if len(rnd_data) != 2:
+                continue
+
+            player_move = [m for m in rnd_data if m.player_id == player.id][0]
+            opponent_move = [m for m in rnd_data if m.player_id != player.id][0]
+
+            player_roll = game_service.find_roll_by_id(player_move.roll_id)
+            opponent_roll = game_service.find_roll_by_id(opponent_move.roll_id)
+
+            if game_decider.decide(player_roll, opponent_roll) == Decision.win:
+                win_count += 1
+
+        return win_count

days/97-99-online-game-api/demo_app/web/game_logic/game_service.py

@@ -136,8 +136,7 @@ def create_roll(name: str) -> 'Roll':
     session.commit()
     session.close()
 
-    roll = session.query(Roll).filter(Roll.id == roll.id).first()
-    return roll
+    return find_roll(name)
 
 
 def find_roll_by_id(roll_id):

days/97-99-online-game-api/demo_app/web/views/game_api.py

@@ -0,0 +1,129 @@
+import random
+import uuid
+
+import flask
+from game_logic import game_service
+from game_logic.game import GameRound
+
+
+def build_views(app):
+    @app.route('/api/game/users/<user>', methods=['GET'])
+    def find_user(user: str):
+        player = game_service.find_player(user)
+        if not player:
+            flask.abort(404)
+        return flask.jsonify(player.to_json())
+
+    @app.route('/api/game/users', methods=['PUT'])
+    def create_user():
+        try:
+            if not flask.request.json \
+                    or 'user' not in flask.request.json \
+                    or not flask.request.json.get('user'):
+                raise Exception("Invalid request: no value for user.")
+
+            username = flask.request.json.get('user').strip()
+            player = game_service.create_player(username)
+
+            return flask.jsonify(player.to_json())
+
+        except Exception as x:
+            flask.abort(flask.Response(
+                response="Invalid request: {}".format(x),
+                status=400
+            ))
+
+    @app.route('/api/game/games', methods=['POST'])
+    def create_game():
+        return flask.jsonify({'game_id': str(uuid.uuid4())})
+
+    @app.route('/api/game/rolls', methods=['GET'])
+    def all_rolls():
+        rolls = [r.name for r in game_service.all_rolls()]
+        return flask.jsonify(rolls)
+
+    @app.route('/api/game/<game_id>/status', methods=['GET'])
+    def game_status(game_id: str):
+        is_over = game_service.is_game_over(game_id)
+        history = game_service.get_game_history(game_id)
+
+        if not history:
+            flask.abort(404)
+
+        roll_lookup = {r.id: r for r in game_service.all_rolls()}
+        player_lookup = {p.id: p for p in game_service.all_players()}
+
+        player1 = game_service.find_player_by_id(history[0].player_id)
+        player2 = game_service.find_player_by_id(history[1].player_id)
+
+        wins_p1 = game_service.count_round_wins(player1.id, game_id)
+        wins_p2 = game_service.count_round_wins(player2.id, game_id)
+
+        data = {
+            'is_over': is_over,
+            'moves': [h.to_json(roll_lookup[h.roll_id], player_lookup[h.player_id]) for h in history],
+            'player1': player1.to_json(),
+            'player2': player2.to_json(),
+            'winner': player1.to_json() if wins_p1 >= wins_p2 else player2.to_json()
+        }
+
+        return flask.jsonify(data)
+
+    @app.route('/api/game/top_scores', methods=['GET'])
+    def top_scores():
+        players = game_service.all_players()
+        wins = [
+            {'player': p.to_json(), 'score': game_service.get_win_count(p)}
+            for p in players
+        ]
+
+        wins.sort(key=lambda wn: -wn.get('score'))
+        return flask.jsonify(wins[:10])
+
+    @app.route('/api/game/play_round', methods=['POST'])
+    def play_round():
+        try:
+            db_roll, db_user, game_id = validate_round_request()
+            computer_player = game_service.find_player('computer')
+            computer_roll = random.choice(game_service.all_rolls())
+
+            game = GameRound(game_id, db_user, computer_player, db_roll, computer_roll)
+            game.play()
+
+            return flask.jsonify({
+                'roll': db_roll.to_json(),
+                'computer_roll': computer_roll.to_json(),
+                'player': db_user.to_json(),
+                'opponent': computer_player.to_json(),
+                'round_outcome': str(game.decision_p1_to_p2),
+                'is_final_round': game.is_over,
+                'round_number': game.round
+            })
+        except Exception as x:
+            # raise x
+            flask.abort(flask.Response(response='Invalid request: {}'.format(x), status=400))
+
+    def validate_round_request():
+        if not flask.request.json:
+            raise Exception("Invalid request: no JSON body.")
+        game_id = flask.request.json.get('game_id')
+        if not game_id:
+            raise Exception("Invalid request: No game_id value")
+        user = flask.request.json.get('user')
+        if not user:
+            raise Exception("Invalid request: No user value")
+        db_user = game_service.find_player(user)
+        if not db_user:
+            raise Exception("Invalid request: No user with name {}".format(user))
+        roll = flask.request.json.get('roll')
+        if not roll:
+            raise Exception("Invalid request: No roll value")
+        db_roll = game_service.find_roll(roll)
+        if not db_roll:
+            raise Exception("Invalid request: No roll with name {}".format(roll))
+
+        is_over = game_service.is_game_over(game_id)
+        if is_over:
+            raise Exception("This game is already over.")
+
+        return db_roll, db_user, game_id

days/97-99-online-game-api/demo_app/web/views/home.py

@@ -0,0 +1,13 @@
+import flask
+
+
+def build_views(app):
+    @app.route('/')
+    def index():
+        return "Hello world!!!"
+
+    @app.errorhandler(404)
+    def not_found(_):
+        return flask.Response("The page was not found.", status=404)
+
+