Example #1
0
 def test_close_lobby(self):
     self.client1.emit("create_game", "player1")
     access_code = self.client1.get_received()[0]['args']
     self.client2.emit("join_game", access_code, "player2")
     game = db_util.get_game(access_code)
     self.assertIsNone(game['players'][0]['start_room'])
     self.client1.emit('close_lobby', access_code)
     game = db_util.get_game(access_code)
     self.assertIsNotNone(game['players'][0]['start_room'])
Example #2
0
def join_game(access_code, player_name):
    """
    Find a game with the access code, and add the player to it
    """

    # find the game or error
    game = db_util.get_game(access_code)
    if game is None:
        send('game not found')
        return

    if game['state'] != 'waiting_for_players':
        send('game is in progress')
        return

    # create a player
    player = db_util.create_player(player_name)

    # add to the list of players
    db.games.update_one({'access_code': access_code},
                        {'$push': {
                            'players': player
                        }})

    join_room(access_code)
    emit('lobby_update',
         {'players': db_util.get_players_in_lobby(access_code)},
         room=access_code)
Example #3
0
File: views.py Project: tomik/honey
def _view_game(game_id, init_path, game_edit_form=None, comment_form=None):
    """
    Views existing game on given (comment) path.

    When there are errors with comment for instance of this one can be passed in and errors displayed.
    """
    game = db.get_game(game_id)
    if not game:
        abort(404)
    # fetch games owner
    db.annotate(game)
    comments=list(db.get_comments_for_game(game_id))
    for comment in comments:
        db.annotate(comment)
    # forms
    if not comment_form:
        comment_form = forms.CommentForm()
    user = db.get_user_by_username(session.get("username", None))
    typeahead_players = []
    if user and game.is_owner(user) and not game_edit_form:
        game_edit_form = forms.GameEditForm.form_factory(game.type)()
        # hint for inputting players names
        typeahead_players = dict([(player.name, player.rank) for player in db.get_players()])
    print game.nodes
    return render_template("view_game.html",
        game=game,
        init_path=init_path,
        comments=comments,
        comment_paths=[(str(c["_id"]), c["path"]) for c in comments],
        comment_form=comment_form,
        typeahead_players=typeahead_players,
        game_edit_form=game_edit_form)
Example #4
0
def message(roomid, person):
    print(request.form)
    game = db.get_game(roomid)
    for person_ in game.players:
        if "".join(person_.searchname.split(" ")).lower() == person.lower(
        ) or person_.dm or person.lower() == "all":
            person_.messages.append((request.form["msg"], request.form["from"],
                                     request.form["to_"]))
    return ("", 204)
Example #5
0
File: views.py Project: tomik/honey
def view_sgf(game_id):
    """Views sgf for game identified by game_id"""
    game = db.get_game(game_id)
    if not game:
        abort(404)
    annotated_comments = [db.annotate(c) for c in db.get_comments_for_game(game_id)]
    # this changes the game itself
    # but that is fine since we don't intend to save it
    game = db.patch_game_with_comments(game, annotated_comments)
    response = make_response(sgf.makeSgf([game.export()]))
    response.headers["Content-type"] = "text/plain"
    return response
Example #6
0
File: views.py Project: tomik/honey
def post_update(game_id):
    """Posts game tree updates for given game. Requires login. Called via ajax."""
    game = db.get_game(game_id)
    if not game:
        abort(404)
    username = session["username"]
    user = db.get_user_by_username(username)
    try:
        update_data = json.loads(request.form.get("update_data"))
    except:
        return jsonify(err="Invalid encoding.")
    if not db.sync_game_update(game, update_data, user):
        return jsonify(err="You don't have permission to perform this action.")
    return jsonify(err=None)
Example #7
0
File: views.py Project: tomik/honey
def edit_game(game_id):
    """Edit game meta information."""
    game = db.get_game(game_id)
    if not game:
        abort(404)
    user = db.get_user_by_username(session["username"])
    if not user:
        abort(500)
    # protection
    if not game.is_owner(user):
        app.logger.warning("Unauthorized game edit: user(%s) game(%s)" % (user.username, game._id))
        abort(500)
    form = forms.GameEditForm.form_factory(game.type)(request.form)
    if form.validate_on_submit():
        form.update_game(game)
        return redirect(url_for("view_game", game_id=game._id))
    return _view_game(game._id, [], game_edit_form=form)
Example #8
0
File: views.py Project: tomik/honey
def post_comment(game_id):
    """Posts comment for given game and path. Requires login. Called via ajax."""
    game = db.get_game(game_id)
    if not game:
        abort(404)
    form = forms.CommentForm(request.form)
    if form.validate_on_submit():
        username = session["username"]
        user = db.get_user_by_username(username)
        if not user:
            app.logger.warning("comment without user")
            abort(500)
        comment = db.create_comment(user._id, game_id, form.short_path, form.comment.data)
        db.annotate(comment)
        can_delete_comment = comment.is_owner(user)
        comment_template = app.jinja_env.from_string(
            """
            {%% from 'macros.html' import render_comment_in_game %%} {{ render_comment_in_game(comment, %s) }}
            """ % can_delete_comment)
        return jsonify(err=None, comment_id = str(comment["_id"]), comment_path=comment["path"], comment_html = comment_template.render(comment=comment))
    return jsonify(err="Invalid comment.")
Example #9
0
def close_lobby(access_code):
    """
    Close the lobby and direct each player to their starting room
    """
    game = db_util.get_game(access_code)
    num_players = len(game['players'])
    rooms = gl.get_shuffled_rooms(num_players)
    cards = gl.get_shuffled_card_indices(num_players)

    for room, card, player in zip(rooms, cards, game['players']):
        player['start_room'] = room
        player['card'] = card

    # update the players with their rooms and change the game state
    game = db.games.find_one_and_update(
        {'access_code': access_code},
        {'$set': {
            'players': game['players'],
            'state': 'readying_rooms'
        }},
        return_document=ReturnDocument.AFTER)

    emit('game_update', game, room=access_code)
Example #10
0
def update(roomid, name):
    game = db.get_game(roomid).getJSONUpdate(name)
    return game
Example #11
0
    def __init__(self):
        """Create game object from data in db"""

        self.load_data(db.get_game())
        self.comment_units = self.load_units("comment")
        self.link_units = self.load_units("link")
Example #12
0
    def __init__(self):
        """Create game object from data in db"""

        self.load_data(db.get_game())
        self.comment_units = self.load_units("comment")
        self.link_units = self.load_units("link")