avalon-django/avalon/avalon_game/views.py

from io import BytesIO
import json
import math
import random
import qrcode

from django.db import transaction
from django.http import HttpResponse, Http404
from django.shortcuts import get_object_or_404, redirect, render
from django.views.decorators.http import require_safe,\
                                         require_POST,\
                                         require_http_methods
try:
    from django.urls import reverse
except ImportError:
    from django.core.urlresolvers import reverse

from .forms import NewGameForm, JoinGameForm, StartGameForm
from .helpers import mission_size, mission_size_string
from .models import Game, GameRound, MissionAction,\
                    Player, PlayerVote, VoteRound

# helpers to interpret arguments
def lookup_access_code(func):
    def with_game(request, access_code, *args, **kwargs):
        game = get_object_or_404(Game, access_code=access_code.lower())
        return func(request, game, *args, **kwargs)

    return with_game

def lookup_player_secret(func):
    def with_player(request, game, player_secret, *args, **kwargs):
        player = get_object_or_404(Player, game=game, secret_id=player_secret)
        return func(request, game, player, *args, **kwargs)

    return with_player

def nums_to_int(func):
    def with_int(request, game, player, round_num, vote_num, *args, **kwargs):
        return func(request, game, player, int(round_num), int(vote_num),
                    *args, **kwargs)

    return with_int

# views

@require_safe
def index(request):
    return render(request, 'index.html')

@require_http_methods(["HEAD", "GET", "POST"])
def enter_code(request):
    if request.method == 'POST':
        form = JoinGameForm(request.POST)
        if form.is_valid():
            game = form.cleaned_data.get('game')
            player = form.cleaned_data.get('player')
            if player is None:
                if game.game_phase == Game.GAME_PHASE_END:
                    return redirect('game_results',
                                    access_code=game.access_code)
                else:
                    return redirect('observe', access_code=game.access_code)
            return redirect('game',
                            access_code=game.access_code,
                            player_secret=player.secret_id)
    else:
        form = JoinGameForm()

    return render(request, 'join_game.html', {'form': form})

@require_http_methods(["HEAD", "GET", "POST"])
def new_game(request):
    if request.method == 'POST':
        form = NewGameForm(request.POST)
        if form.is_valid():
            game = Game.objects.create()
            name = form.cleaned_data.get('name')
            if name is None:
                return redirect('observe', access_code=game.access_code)
            player = Player.objects.create(game=game, name=name)
            return redirect('game',
                            access_code=game.access_code,
                            player_secret=player.secret_id)
    else:
        form = NewGameForm()

    return render(request, 'new_game.html', {'form': form})

@lookup_access_code
@require_safe
def join_game(request, game):
    if game.game_phase == Game.GAME_PHASE_END:
        return redirect('game_results', access_code=game.access_code)
    else:
        form = JoinGameForm(initial={'game': game.access_code})
        return render(request, 'join_game.html',
                      {'access_code': game.access_code, 'form': form})

@lookup_access_code
@require_safe
def qr_code(request, game):
    join_url = reverse('join_game', kwargs={'access_code': game.access_code})
    join_url = request.build_absolute_uri(join_url)
    img = qrcode.make(join_url)
    output = BytesIO()
    img.save(output, "PNG")
    return HttpResponse(output.getvalue(), content_type='image/png')

@lookup_access_code
@require_safe
def observe(request, game):
    if game.game_phase == game.GAME_PHASE_END and game.next_game is not None:
        return redirect('observe', access_code=game.next_game.access_code)
    return _game(request, game, None)

@lookup_access_code
@require_safe
def game_results(request, game):
    if game.game_phase != Game.GAME_PHASE_END:
        raise Http404()
    return _game(request, game, None, {'results_only': True})

def game_status_string(game, player):
    game_status_object = {}

    game_status_object['game_phase'] = game.game_phase_string()

    players = game.player_set.order_by('order', 'joined', 'name')
    num_players = players.count()

    if game.game_phase == Game.GAME_PHASE_LOBBY:
        game_status_object['players'] = [p.name for p in players]
        try:
            rounds = [mission_size_string(mission_size(num_players=num_players,
                                                       round_num=round_num))
                      for round_num in range(1,6)]
        except ValueError:
            rounds = ['' for round_num in range(1,6)]
        game_status_object['rounds'] = rounds
    elif game.game_phase == Game.GAME_PHASE_ROLE:
        game_status_object['times_started'] = game.times_started
        ready_players = game.player_set.filter(ready=True).order_by('order')
        game_status_object['ready'] = [{'name': p.name, 'order': p.order}
                                       for p in ready_players]
    else:
        vote_round = VoteRound.objects.get_current_vote_round(game)
        game_status_object['round_num'] = vote_round.game_round.round_num
        game_status_object['vote_num'] = vote_round.vote_num
    if game.game_phase == Game.GAME_PHASE_PICK\
            or game.game_phase == Game.GAME_PHASE_VOTE:
        chosen = vote_round.chosen.order_by('order').all()
        game_status_object['chosen'] = [p.name for p in chosen]
        game_status_object['you_chosen'] = player in chosen
    if game.game_phase == Game.GAME_PHASE_VOTE:
        votes_cast = vote_round.playervote_set.count()
        game_status_object['missing_votes_count'] = num_players - votes_cast
        player_vote = vote_round.playervote_set.filter(player=player)
        if player_vote:
            if player_vote.get().accept:
                game_status_object['player_vote'] = 'accept'
            else:
                game_status_object['player_vote'] = 'reject'
        else:
            game_status_object['player_vote'] = 'none'
    if game.game_phase == Game.GAME_PHASE_END and game.next_game is not None:
        game_status_object['next_game'] = game.next_game.access_code

    return json.dumps(game_status_object)

@lookup_access_code
@require_safe
@transaction.non_atomic_requests
def observe_status(request, game):
    return HttpResponse(game_status_string(game, None))

@lookup_access_code
@lookup_player_secret
@require_safe
@transaction.non_atomic_requests
def status(request, game, player):
    player.save()

    return HttpResponse(game_status_string(game, player))

def game_base_context(game, player):
    players = game.player_set.order_by('order', 'joined', 'name')
    num_players = players.count()

    context = {}

    context['status'] = game_status_string(game, player)
    context['access_code'] = game.access_code
    context['is_observer'] = player is None
    if player is not None:
        context['player_secret'] = player.secret_id
        context['player'] = player
    context['players'] = players
    context['num_players'] = num_players
    context['game_rounds'] = game.gameround_set.all().order_by('round_num')

    context['num_spies'] = len([p for p in players if p.is_spy()])
    spy_roles = [p.role_string() for p in players
                 if p.is_spy() and p.role != Player.ROLE_SPY]
    if spy_roles:
        spy_roles.sort()
        context['spy_roles'] = spy_roles
    context['num_resistance'] = len([p for p in players if not p.is_spy()])
    resistance_roles = [p.role_string() for p in players
                        if not p.is_spy() and p.role != Player.ROLE_GOOD]
    if resistance_roles and all(r is not None for r in resistance_roles):
        resistance_roles.sort()
        context['resistance_roles'] = resistance_roles

    if game.display_history is not None:
        context['display_history'] = game.display_history
    if game.private_voting is not None:
        context['private_voting'] = game.private_voting

    try:
        round_scores = {}
        for round_num in range(1, 6):
            round_scores[round_num] = {'mission_size': mission_size_string(mission_size(num_players=num_players, round_num=round_num)), 'result': ''}
        for game_round in game.gameround_set.all():
            round_scores[game_round.round_num]['result'] = game_round.result_string()
        context['round_scores'] = round_scores
    except ValueError:
        pass

    if game.game_phase != Game.GAME_PHASE_LOBBY:
        context['game_has_mordred'] = players.filter(role=Player.ROLE_MORDRED)\
                                             .exists()
        if player is None:
            context['visible_spies'] = []
        else:
            context['visible_spies'] = [p for p in players
                                        if player.sees_as_spy(p)]
            if player.is_percival():
                possible_merlins = " or ".join([p.name for p in players
                                                if p.appears_as_merlin()])
                context['possible_merlins'] = possible_merlins

    return context

def deterministic_random_boolean(seed):
    r = random.getstate()
    random.seed(seed)
    res = random.choice([True, False])
    random.setstate(r)
    return res

@lookup_access_code
@lookup_player_secret
@require_safe
def game(request, game, player):
    player.save() # update last_accessed

    return _game(request, game, player)

def _game(request, game, player, extra_context=None):
    context = game_base_context(game, player)
    if extra_context is not None:
        context.update(extra_context)

    if game.game_phase == Game.GAME_PHASE_LOBBY:
        context['form'] = StartGameForm()
        return render(request, 'lobby.html', context)
    elif game.game_phase == Game.GAME_PHASE_ROLE:
        context['times_started'] = game.times_started
        return render(request, 'role_phase.html', context)
    elif game.game_phase == Game.GAME_PHASE_PICK:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        assert vote_round.vote_status == VoteRound.VOTE_STATUS_WAITING
        context['chosen'] = vote_round.chosen.order_by('order').all()
        vote_rejected = not vote_round.is_first_vote()
        context['vote_rejected'] = vote_rejected
        if vote_rejected:
            context['previous_vote'] = vote_round.previous_vote().vote_totals()
        context['leader'] = vote_round.leader
        context['round_num'] = vote_round.game_round.round_num
        context['vote_num'] = vote_round.vote_num
        context['team_size'] = vote_round.game_round.num_players_on_mission()
        if vote_round.leader == player:
            return render(request, 'pick.html', context)
        else:
            return render(request, 'pick_wait.html', context)
    elif game.game_phase == Game.GAME_PHASE_VOTE:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        assert vote_round.vote_status == VoteRound.VOTE_STATUS_VOTING
        context['chosen'] = vote_round.chosen.order_by('order').all()
        context['leader'] = vote_round.leader
        round_num = vote_round.game_round.round_num
        context['round_num'] = round_num
        vote_num = vote_round.vote_num
        context['vote_num'] = vote_num
        player_vote = vote_round.playervote_set.filter(player=player)
        if player_vote:
            if player_vote.get().accept:
                context['player_vote'] = 'accept'
            else:
                context['player_vote'] = 'reject'
        player_votes = vote_round.playervote_set.count()
        num_players = context['num_players']
        context['missing_votes_count'] = num_players - player_votes
        if player is not None:
            seed = "%s-%s-%d-%d" % (game.access_code, player.secret_id,
                                    round_num, vote_num)
            context['swap_buttons'] = deterministic_random_boolean(seed)
        return render(request, 'vote.html', context)
    elif game.game_phase == Game.GAME_PHASE_MISSION:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        assert vote_round.vote_status == VoteRound.VOTE_STATUS_VOTED
        chosen = vote_round.chosen.order_by('order').all()
        context['chosen'] = chosen
        context['leader'] = vote_round.leader
        round_num = vote_round.game_round.round_num
        context['round_num'] = round_num
        vote_num = vote_round.vote_num
        context['vote_num'] = vote_num
        context['vote'] = vote_round.vote_totals()
        if player in chosen:
            game_round = vote_round.game_round
            mission_action = game_round.missionaction_set.filter(player=player)
            if mission_action:
                if mission_action.get().played_success:
                    context['mission_action'] = 'Pass'
                else:
                    context['mission_action'] = 'Fail'
            seed = "%s-%s-%d-%d" % (game.access_code, player.secret_id,
                                    round_num, vote_num)
            context['swap_buttons'] = deterministic_random_boolean(seed)
            return render(request, 'mission.html', context)
        else:
            return render(request, 'mission_wait.html', context)
    elif game.game_phase == Game.GAME_PHASE_ASSASSIN:
        if player is not None and player.is_assassin():
            context['targets'] = [p for p in context['players']
                                  if p != player and not player.sees_as_spy(p)]
            return render(request, 'assassinate.html', context)
        else:
            return render(request, 'assassinate_wait.html', context)
    elif game.game_phase == Game.GAME_PHASE_END:
        context['game_over'] = True
        res_wins = game.gameround_set.filter(mission_passed=True).count()
        res_won = res_wins == 3 and not game.player_assassinated.is_merlin()
        context['resistance_won'] = res_won

        if game.player_assassinated:
            context['player_assassinated'] = game.player_assassinated

        try:
            context['previous_game'] = game.previous_game
        except Game.DoesNotExist:
            pass
        if game.next_game:
            if game.next_game.game_phase != Game.GAME_PHASE_END:
                context['next_game_ongoing'] = True
            context['next_game'] = game.next_game

        return render(request, 'end.html', context)

@lookup_access_code
@lookup_player_secret
@require_POST
def leave(request, game, player):
    player.delete()
    num_players = game.player_set.count()
    if num_players == 0:
        game.delete()
    return redirect('index')

@lookup_access_code
@require_POST
def observe_start(request, game):
    return _start(request, game, None)

@lookup_access_code
@lookup_player_secret
@require_POST
def start(request, game, player):
    player.save() # update last_accessed

    return _start(request, game, player)

def _start(request, game, player):
    if game.game_phase != Game.GAME_PHASE_LOBBY:
        if player is None:
            return redirect('observe', access_code=game.access_code)
        else:
            return redirect('game', access_code=game.access_code,
                            player_secret=player.secret_id)

    players = game.player_set.all()
    num_players = players.count()

    form = StartGameForm(request.POST)
    if num_players < 5:
        form.add_error(None, "You must have at least 5 players to play!")
    elif num_players > 10:
        form.add_error(None, "You can't have more than 10 players to play!")

    if form.is_valid():
        num_spies = int(math.ceil(num_players / 3.0))
        spy_roles = []
        if form.cleaned_data.get('assassin'):
            spy_roles.append(Player.ROLE_ASSASSIN)
        if form.cleaned_data.get('morgana'):
            spy_roles.append(Player.ROLE_MORGANA)
        if form.cleaned_data.get('mordred'):
            spy_roles.append(Player.ROLE_MORDRED)
        if form.cleaned_data.get('oberon'):
            spy_roles.append(Player.ROLE_OBERON)
        if len(spy_roles) > num_spies:
            form.add_error(None, "There will only be %d spies. Select no more than that many special roles for spies." % num_spies)
        else:
            game.display_history = form.cleaned_data.get('display_history')
            game.private_voting = form.cleaned_data.get('private_voting')
            game.game_phase = Game.GAME_PHASE_ROLE
            game.times_started += 1

            resistance_roles = []
            if form.cleaned_data.get('merlin'):
                resistance_roles.append(Player.ROLE_MERLIN)
            if form.cleaned_data.get('percival'):
                resistance_roles.append(Player.ROLE_PERCIVAL)

            num_resistance = num_players - num_spies
            roles = spy_roles + resistance_roles +\
                    [Player.ROLE_SPY]*(num_spies - len(spy_roles)) +\
                    [Player.ROLE_GOOD]*(num_resistance - len(resistance_roles))
            assert len(roles) == num_players

            play_order = list(range(num_players))
            random.shuffle(play_order)
            random.shuffle(roles)

            for p, role, order in zip(players, roles, play_order):
                p.role = role
                p.order = order
                p.save()

            game.save()
            if player is None:
                return redirect('observe', access_code=game.access_code)
            else:
                return redirect('game', access_code=game.access_code,
                                player_secret=player.secret_id)
    context = game_base_context(game, player)
    context['form'] = form

    return render(request, 'lobby.html', context)

@lookup_access_code
@require_POST
def observe_cancel_game(request, game):
    if game.game_phase == Game.GAME_PHASE_ROLE:
        game.game_phase = Game.GAME_PHASE_LOBBY
        game.save()

    return redirect('observe', access_code=game.access_code)

@lookup_access_code
@lookup_player_secret
@require_POST
def cancel_game(request, game, player):
    if game.game_phase == Game.GAME_PHASE_ROLE:
        player.ready = False
        player.save()

        game.game_phase = Game.GAME_PHASE_LOBBY
        game.save()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@require_POST
def ready(request, game, player):
    if game.game_phase == Game.GAME_PHASE_ROLE:
        player.ready = True
        player.save()

        if not game.player_set.filter(ready=False):
            game.game_phase = Game.GAME_PHASE_PICK
            game.save()
            game_round = GameRound.objects.create(game=game, round_num=1)
            first_leader = Player.objects.get(game=game, order=0)
            vote_round = VoteRound.objects.create(game_round=game_round,
                                                  vote_num=1,
                                                  leader=first_leader)

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@nums_to_int
@require_POST
def choose(request, game, player, round_num, vote_num, who):
    player.save()

    if game.game_phase == Game.GAME_PHASE_PICK:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        if vote_round.vote_status == VoteRound.VOTE_STATUS_WAITING\
                and vote_round.game_round.round_num == round_num\
                and vote_round.vote_num == vote_num\
                and vote_round.leader == player:
            chosen_player = game.player_set.get(order=who)
            vote_round.chosen.add(chosen_player)
            vote_round.save()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@nums_to_int
@require_POST
def unchoose(request, game, player, round_num, vote_num, who):
    player.save()

    if game.game_phase == Game.GAME_PHASE_PICK:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        if vote_round.vote_status == VoteRound.VOTE_STATUS_WAITING\
                and vote_round.game_round.round_num == round_num\
                and vote_round.vote_num == vote_num\
                and vote_round.leader == player:
            chosen_player = game.player_set.get(order=who)
            vote_round.chosen.remove(chosen_player)
            vote_round.save()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@nums_to_int
@require_POST
def finalize_team(request, game, player, round_num, vote_num):
    player.save()

    if game.game_phase == Game.GAME_PHASE_PICK:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        if vote_round.vote_status == VoteRound.VOTE_STATUS_WAITING\
                and vote_round.game_round.round_num == round_num\
                and vote_round.vote_num == vote_num\
                and vote_round.leader == player\
                and vote_round.is_chosen_correct_size():
            vote_round.vote_status = VoteRound.VOTE_STATUS_VOTING
            vote_round.save()
            game.game_phase = Game.GAME_PHASE_VOTE
            game.save()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@nums_to_int
@require_POST
def retract_team(request, game, player, round_num, vote_num):
    player.save()

    if game.game_phase == Game.GAME_PHASE_VOTE:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        if vote_round.vote_status == VoteRound.VOTE_STATUS_VOTING\
                and vote_round.game_round.round_num == round_num\
                and vote_round.vote_num == vote_num\
                and vote_round.leader == player:
            vote_round.vote_status = VoteRound.VOTE_STATUS_WAITING
            vote_round.save()
            game.game_phase = Game.GAME_PHASE_PICK
            game.save()
            vote_round.playervote_set.all().delete()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@nums_to_int
@require_POST
def vote(request, game, player, round_num, vote_num, vote):
    player.save()

    if game.game_phase == Game.GAME_PHASE_VOTE:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        if vote_round.vote_status == VoteRound.VOTE_STATUS_VOTING\
                and vote_round.game_round.round_num == round_num\
                and vote_round.vote_num == vote_num:
            if vote == "cancel":
                try:
                    vote_round.playervote_set.get(player=player).delete()
                except PlayerVote.DoesNotExist:
                    pass
            else:
                accept = vote == "approve"
                vote_round.playervote_set\
                          .update_or_create(defaults={'accept': accept},
                                            player=player)
                team_approved = vote_round.team_approved()
                if team_approved is not None:
                    # All players voted, voting round is over.
                    vote_round.vote_status = VoteRound.VOTE_STATUS_VOTED
                    vote_round.save()
                    if team_approved:
                        # Team was approved
                        game.game_phase = Game.GAME_PHASE_MISSION
                    else:
                        # Team was rejected
                        if vote_round.is_final_vote():
                            game.game_phase = Game.GAME_PHASE_END
                        else:
                            game.game_phase = Game.GAME_PHASE_PICK
                            VoteRound.objects\
                                     .create(game_round=vote_round.game_round,
                                             vote_num=vote_round.vote_num+1,
                                             leader=vote_round.next_leader())
                game.save()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@require_POST
def mission(request, game, player, round_num, mission_action):
    round_num = int(round_num)

    player.save()

    if game.game_phase == Game.GAME_PHASE_MISSION:
        vote_round = VoteRound.objects.get_current_vote_round(game=game)
        game_round = vote_round.game_round
        if vote_round.vote_status == VoteRound.VOTE_STATUS_VOTED\
                and game_round.round_num == round_num\
                and player in vote_round.chosen.all():
            passed = mission_action == "success" or not player.is_spy()
            game_round.missionaction_set\
                      .update_or_create(defaults={'played_success': passed},
                                        player=player)
            num_on_mission = game_round.num_players_on_mission()
            if game_round.missionaction_set.count() == num_on_mission:
                num_fails_required = game_round.num_fails_required()
                fails = game_round.missionaction_set\
                                  .filter(played_success=False).count()
                game_round.mission_passed = fails < num_fails_required
                game_round.save()
                res_wins = game.gameround_set.filter(mission_passed=True)\
                                             .count()
                spy_wins = game.gameround_set.filter(mission_passed=False)\
                                             .count()
                if res_wins == 3:
                    # resistance wins... except for assassin
                    game.game_phase = Game.GAME_PHASE_ASSASSIN
                    game.save()
                elif spy_wins == 3:
                    # spies win
                    game.game_phase = Game.GAME_PHASE_END
                    game.save()
                else:
                    # another round
                    game.game_phase = Game.GAME_PHASE_PICK
                    game.save()
                    next_round_num = game_round.round_num+1
                    game_round = GameRound.objects\
                                          .create(game=game,
                                                  round_num=next_round_num)
                    next_leader = vote_round.next_leader()
                    vote_round = VoteRound.objects\
                                          .create(game_round=game_round,
                                                  vote_num=1,
                                                  leader=next_leader)

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@require_POST
def assassinate(request, game, player, target):
    player.save()

    if game.game_phase == Game.GAME_PHASE_ASSASSIN\
            and player.is_assassin():
        target_player = game.player_set.get(order=target)
        game.player_assassinated = target_player
        game.game_phase = Game.GAME_PHASE_END
        game.save()

    return redirect('game', access_code=game.access_code,
                    player_secret=player.secret_id)

@lookup_access_code
@lookup_player_secret
@require_safe
def next_game(request, game, player):
    if game.game_phase != Game.GAME_PHASE_END:
        raise Http404()
    next_game = game.create_or_get_next_game()
    if next_game.game_phase == Game.GAME_PHASE_LOBBY:
        try:
            next_player = Player.objects.get(game=next_game,
                                             name=player.name)
            if not next_player.is_expired():
                redirect('join_game', access_code=next_game.access_code)
        except Player.DoesNotExist:
            next_player = Player.objects.create(game=next_game,
                                                name=player.name)
        return redirect('game', access_code=next_game.access_code,
                        player_secret=next_player.secret_id)
    else:
        raise Http404()

@lookup_access_code
@require_safe
def observe_next_game(request, game):
    if game.game_phase != Game.GAME_PHASE_END:
        raise Http404()
    next_game = game.create_or_get_next_game()
    redirect('observe_game', access_code=next_game.access_code)