Пример #1
0
def populate_games():
    with app.open_resource('./testing/data/games.json') as gamedata:
        games = json.load(gamedata)['games']
        for g in games:
            Game.add_game(teams=g['teams'],
                          court=int(g['court']),
                          time=g['time'])
            scrs = g['score'].split(' ')
            Game.update_game(int(g['court']), g['time'],
                             g['winner'], scrs[0], scrs[1])
Пример #2
0
class GameController:
    def __init__(self, game_point, dice_amount, first_point_limit):
        self.game_point = game_point
        self.dice_amount = dice_amount
        self.first_point_limit = first_point_limit
        self.players = []
        
        self.manager_ui = ManagerUI(self)
        self.player_ui = PlayerUI(self)
        self.game_ui = GameUI(self, game_point)

    def register_player(self, name):
        self.players.append(Player(name))

    def start_game(self):
        for player in self.players:
            player.score = 0            # プレイヤーの得点を初期化する
            player.is_winner = False    # プレイヤーの勝利者判定をoffにする
        
        self.game = Game(self.players, self.game_point, self.dice_amount, self.first_point_limit)
        self.game.set_current_player(self.players[0])     # 最初のプレイヤーを ゲームのcurrentPlayerに編集
        self.new_turn()

    def get_players_count(self):
        return len(self.players)
    
    def new_turn(self):
        self.game.new_turn()
        
    def do_turn(self):
        return self.game.turn.do_turn()
    
    def end_turn(self):
        self.game.end_turn()
    
    def get_current_player(self):
        return self.game.current_player
    
    def next_player(self):
        self.game.next_player()

    def is_turn_bust(self):
        return self.game.is_turn_bust

    def is_turn_none_of_dice(self):
        return self.game.is_turn_none_of_dice

    def is_game_end(self):
        return self.game.is_game_end()
    
    def winner_check(self):
        _score = 0
        for player in self.players:
            if(player.score > _score):
                _score = player.score
                
        if(_score >= self.game_point):
            for player in self.players:
                if(_score == player.score):
                    player.is_winner = True
Пример #3
0
def start_new_game():
    new_game = Game()
    new_game_id = str(datetime.now())
    active_games[new_game_id] = new_game
    try:
        q = new_game.get_next_question()
    except IKnow as e:
        return jsonify(game_id=new_game_id,
                       question_type=QuestionTypes.FINAL.value,
                       movies=[m.serialize() for m in e.movie_list]), 200

    return jsonify(game_id=new_game_id,
                   question=q.text,
                   question_type=QuestionTypes.COMMON.value,
                   question_id=q.id), 200
Пример #4
0
def messages(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    if request.method == 'GET':
        since = request.GET.get('since', None)
        return json(Message.get_activities(request.user,
                                           thread,
                                           since=since))

    if request.method == 'POST':

        if not thread.profile_can_create(request.profile):
            return HttpResponse('Unauthorized', status=401)

        content = request.POST.get('content', None)
        if not content:
            return HttpResponse('Method Not Allowed - A message is required', status=405)

        # create the new message
        game = Game.get_by_uid(game_id)
        actor = Role.get_by_profile(game, request.profile)
        message = Message(actor=actor,
                          content=content,
                          thread=thread)
        message.put()
        return json(message)

    return HttpResponse('Method Not Allowed', status=405)
Пример #5
0
def end_game(request, game_id):
   
    t = datetime.now()

    game = Game.get_by_uid(game_id)
    last_round = game.get_current_round()
    
    if not game.is_over():
        logging.critical('game:%s game end task called but game is not over' % \
                         game.uid)
        raise FactionizeTaskException, 'game not yet in a completed state'

    if game.is_complete:
        logging.warning('game:%s game end task called on a game that is ' + \
                        'has already marked as complete. possibly a ' + \
                        'repeated message' % game.uid)
        raise FactionizeTaskException, 'game is already marked as complete'

    # do lots of processing here to assign various awards
    if game.is_innocent_victory():
        win = InnocentWin(thread=last_round.get_thread(role_vanillager))
    else:
        win = MafiaWin(thread=last_round.get_thread(role_vanillager))
    win.put()
    
    game.is_complete = True
    game.put()

    return HttpResponse('ok', status=200)
Пример #6
0
 def start_game(self):
     for player in self.players:
         player.score = 0            # プレイヤーの得点を初期化する
         player.is_winner = False    # プレイヤーの勝利者判定をoffにする
     
     self.game = Game(self.players, self.game_point, self.dice_amount, self.first_point_limit)
     self.game.set_current_player(self.players[0])     # 最初のプレイヤーを ゲームのcurrentPlayerに編集
     self.new_turn()
Пример #7
0
def join(request, game_id):
    game = Game.get_by_uid(game_id)
    if game is None:
        raise Http404

    now = datetime.now()
    if (game.started and game.started < now) or game.signup_deadline < now:
        return HttpResponse(status=401)

    if request.profile.key() not in game.signups:
        game.add_to_waitlist(request.profile)
    return redirect('/games/%s' % game.uid)
Пример #8
0
def start(request, game_id):
    game = Game.get_by_uid(game_id)
    if game.game_starter.uid != request.profile.uid:
        return HttpResponse(status=403)

    now = datetime.now()
    if (game.started and game.started < now) or game.signup_deadline < now:
        return HttpResponse(status=401)

    try:
        game.start_game()
    except FactionizeError, e:
        return HttpResponse('Cannot start game', status=401)
Пример #9
0
def view(request, game_id):
    game = Game.get_by_uid(game_id)
    if game is None:
        raise Http404

    current_round = game.get_current_round()
    rounds = game.get_rounds()
    threads = current_round.get_threads(request.profile)
    player_list = [r.player for r in game.get_active_roles()]

    context = dict(profile=request.profile,
                   player_list=player_list,
                   game=game,
                   current_round=current_round,
                   rounds=rounds,
                   threads=threads)
    context['serialized'] = json_encode(context)
    return render('game/view.html', context)
Пример #10
0
def vote_summary(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    game = Game.get_by_uid(game_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    # only deals with GET requests
    if not request.method == 'GET':
        raise Http404

    summaries = VoteSummary.all().filter('thread', thread)
    summaries = summaries.order('-total')
    data = []
    total_votes = 0
    for s in summaries:
        data.append(dict(profile=s.role.player,
                         total=s.total,
                         updated=s.updated))
        total_votes += s.total

    chart_data = dict(chxr="0,0,%s" % len(data),
                      chxt='y',
                      chbh='a',
                      chs='200x200',
                      cht='bhs',
                      chco='4D89F9',
                      chds="0,%s" % total_votes)

    player_labels = [s['profile'].name for s in data]
    player_labels.reverse()
    chart_data['chx1'] = "0:|%s" % "|".join(player_labels)
    chart_data['chd'] = "t:%s" % ",".join([str(s['total']) for s in data])

    chart_url = "http://chart.apis.google.com/chart?%s"
    chart_url = chart_url % urlencode(chart_data)

    return json(dict(thread=thread,
                     summaries=data,
                     chart_url=chart_url))
Пример #11
0
def index(request):
    if request.method == 'GET':
        games = Game.all()
        return render('game/list.html',
                      dict(games=games))

    elif request.method == 'POST':
        if not hasattr(request, 'user') or not request.user:
            login_url = users.create_login_url(request.get_full_path())
            return redirect(login_url)
        values = request.POST
        game = Game(name=values.get('name', 'Unnamed game'),
                    game_starter=request.profile,
                    signup_deadline=datetime.now() + timedelta(7),
                    signups=[])
        game.put()

        game.start_pregame()
        game.add_to_waitlist(request.profile)

        # redirect to the game
        return redirect('/games/%s' % game.uid)
Пример #12
0
def create(game_id=None):
    
    if game_id:
        abort(403)

    else:
        new_game = Game()
        print(request.json["general_data"])
        
        new_game.general_data = request.json["general_data"]
        new_game.character_data = request.json["character_data"]
        new_game.phases = request.json["phases"]

        
        new_game.save()
        
        return make_response(json.dumps(new_game), 201)
Пример #13
0
def votes(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    game = Game.get_by_uid(game_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    if request.method == 'GET':
        since = request.GET.get('since', None)
        return json(Vote.get_activities(request.user, thread, since=since))

    if request.method == 'POST':
        if not thread.profile_can_create(request.profile):
            return HttpResponse('Unauthorized', status=401)

        # find the target
        target_id = request.POST.get('target_id', None)
        if target_id is None:
            raise Exception('No target')

        target_profile = Profile.get_by_uid(target_id)
        target = Role.all().filter('player', target_profile)
        target = target.filter('game', game)
        target = target.fetch(1)[0]

        # find the last vote this user made (if any)
        game = Game.get_by_uid(game_id)
        actor = Role.get_by_profile(game, request.profile)

        last_vote = Vote.all().filter("thread", thread)
        last_vote = last_vote.filter("actor", actor)
        last_vote = last_vote.order("-created")
        try:
            last_vote = last_vote.fetch(1)[0]
        except IndexError, e:
            last_vote = None

        # if we found a vote, decrement that vote's counter
        if last_vote is not None:
            last_vote.decrement()

        # create the new vote
        vote = Vote(actor=actor,
                    target=target,
                    thread=thread)
        vote.put()

        # increment the counter
        vote.increment()

        if thread.name == role_vanillager:
            vote_count = Vote.all().filter('thread', thread).count()
            if not vote_count:
                # First vote in round
                c = Client(settings.BDM_SECRET, settings.BDM_KEY)
                eul = "profile:%s" % request.profile.uid
                c.post("named_transaction_group/613301/execute/%s" % eul)
                if thread.round.number == 1:
                    # First vote in game
                    c.post("named_transaction_group/613302/execute/%s" % eul)

        return json(vote)