terrassumptions/server/game_api.py

from flask import Blueprint, abort, request, jsonify

import db
import lib

game = Blueprint("game", __name__)


def require_game(game_id):
    g = db.Game.query.get(game_id)
    if g is None:
        abort(404)
    return g


def require_player(game_id):
    auth = request.headers.get("Authorization", type=str)
    if auth is None:
        abort(401)
    try:
        pid = int(auth.split(maxsplit=1)[-1])
    except ValueError:
        abort(401)
    player = db.Player.query.get(pid)
    if player is None:
        abort(404)
    return player


@game.route("", methods=["PUT"])
def create_game():
    timer = request.json.get("timer", None)
    if not isinstance(timer, int) or timer <= 0:
        abort(400)

    rounds = request.json.get("rounds", None)
    if not isinstance(rounds, int) or rounds <= 0:
        abort(400)

    only_america = request.json.get("onlyAmerica", False)
    if not isinstance(only_america, bool):
        abort(400)

    new_game = db.Game.create(timer, rounds, only_america=only_america)

    return jsonify({"gameId": new_game.game_id})


@game.route("/<game_id>")
def game_settings(game_id):
    g = require_game(game_id)
    return jsonify(g.to_dict())


@game.route("/<game_id>/config")
def game_config(game_id):
    g = require_game(game_id)
    return jsonify({
        "timer": g.timer,
        "rounds": g.rounds,
        "onlyAmerica": g.only_america,
    })


@game.route("/<game_id>/coords")
def coords(game_id):
    g = require_game(game_id)
    return jsonify({
        str(c.round_number): {
            "lat": c.latitude,
            "lng": c.longitude,
        } for c in g.coordinates
    })


@game.route("/<game_id>/players")
def players(game_id):
    g = require_game(game_id)
    return jsonify({"players": [p.to_dict() for p in g.players]})


@game.route("/<game_id>/linked", methods=["GET", "POST"])
def link_game(game_id):
    g = require_game(game_id)
    if request.method == "GET":
        return jsonify({"linkedGame": g.linked_game})

    link_id = request.json.get("linkedGame", None)
    if link_id is None or db.Game.query.get(link_id) is None:
        abort(401)
    
    g.link(link_id)
    return "", 201


@game.route("/<game_id>/join", methods=["POST"])
def join(game_id):
    name = request.json.get("playerName", None)
    if name is None:
        abort(400)

    g = require_game(game_id)

    if db.Player.query.filter(db.Player.game_id == game_id, db.Player.player_name == name).first() is not None:
        abort(409)

    p = g.join(name)
    return jsonify({
        "playerId": str(p.player_id)
    }), 201


@game.route("/<game_id>/current")
def current_round(game_id):
    g = require_game(game_id)
    player = require_player(game_id)
    cur_rnd = player.get_current_round()
    if cur_rnd is None:
        coord = None
    else:
        lookup = db.Coordinate.query.get((game_id, cur_rnd))
        cur_rnd = str(cur_rnd)
        if lookup is None:
            coord = None
        else:
            coord = {
                "lat": lookup.latitude,
                "lng": lookup.longitude,
            }
    return jsonify({
        "currentRound": cur_rnd,
        "coord": coord,
        "timer": g.timer,
    })


@game.route("/<game_id>/guesses/<int:round_num>", methods=["POST"])
def make_guess(game_id, round_num):
    player = require_player(game_id)
    if round_num != player.get_current_round():
        abort(409)

    timed_out = request.json.get("timeout", False)
    if timed_out:
        player.add_timeout(round_num)
        db.session.commit()
        return jsonify({
            "score": 0,
            "totalScore": player.get_total_score(),
            "distance": None,
        }), 201

    try:
        lat = float(request.json.get("lat", None))
        lng = float(request.json.get("lng", None))
        remaining = int(request.json.get("timeRemaining", None))
    except ValueError:
        abort(400)

    target = db.Coordinate.query.get((game_id, round_num))
    if target is None:
        abort(400)

    guess_score, distance = lib.score((target.latitude, target.longitude), (lat, lng))
    player.add_guess(round_num, lat, lng, guess_score, remaining)
    return jsonify({
        "score": guess_score,
        "totalScore": player.get_total_score(),
        "distance": distance,
    }), 201