Ejemplo n.º 1
0
async def test_remove_game_connection(game: Game, players, mock_game_connection):
    game.state = GameState.LOBBY
    mock_game_connection.player = players.hosting
    mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    game.add_game_connection(mock_game_connection)
    await game.remove_game_connection(mock_game_connection)
    assert players.hosting not in game.players
Ejemplo n.º 2
0
async def test_remove_game_connection(game: Game, players, mock_game_connection):
    game.state = GameState.LOBBY
    mock_game_connection.player = players.hosting
    mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    game.add_game_connection(mock_game_connection)
    await game.remove_game_connection(mock_game_connection)
    assert players.hosting not in game.players
Ejemplo n.º 3
0
async def test_initialized_game_not_allowed_to_end(game: Game):
    await game.clear_data()
    game.state = GameState.INITIALIZING

    game.on_game_end()

    assert game.state is GameState.INITIALIZING
Ejemplo n.º 4
0
async def test_initialized_game_not_allowed_to_end(game: Game):
    await game.clear_data()
    game.state = GameState.INITIALIZING

    game.on_game_end()

    assert game.state is GameState.INITIALIZING
Ejemplo n.º 5
0
async def check_game_settings(game: Game, settings: List[Tuple[str, Any, ValidityState]]):
    for key, value, expected in settings:
        old = game.gameOptions.get(key)
        game.gameOptions[key] = value
        await game.validate_game_settings()
        assert game.validity is expected
        game.gameOptions[key] = old
Ejemplo n.º 6
0
def test_add_game_connection_throws_if_not_lobby_state(game: Game, players, mock_game_connection):
    game.state = GameState.INITIALIZING
    mock_game_connection.player = players.hosting
    mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    with pytest.raises(GameError):
        game.add_game_connection(mock_game_connection)

    assert players.hosting not in game.players
Ejemplo n.º 7
0
def test_add_game_connection_throws_if_not_connected_to_host(game: Game, players, mock_game_connection):
    game.state = GameState.LOBBY
    mock_game_connection.player = players.hosting
    mock_game_connection.state = GameConnectionState.INITIALIZED
    with pytest.raises(GameError):
        game.add_game_connection(mock_game_connection)

    assert players.hosting not in game.players
Ejemplo n.º 8
0
def test_add_game_connection_throws_if_not_connected_to_host(game: Game, players, mock_game_connection):
    game.state = GameState.LOBBY
    mock_game_connection.player = players.hosting
    mock_game_connection.state = GameConnectionState.INITIALIZED
    with pytest.raises(GameError):
        game.add_game_connection(mock_game_connection)

    assert players.hosting not in game.players
Ejemplo n.º 9
0
def test_add_game_connection_throws_if_not_lobby_state(game: Game, players, mock_game_connection):
    game.state = GameState.INITIALIZING
    mock_game_connection.player = players.hosting
    mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    with pytest.raises(GameError):
        game.add_game_connection(mock_game_connection)

    assert players.hosting not in game.players
Ejemplo n.º 10
0
async def test_game_end_when_no_more_connections(game: Game, mock_game_connection):
    game.state = GameState.LOBBY

    game.on_game_end = CoroMock()
    mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    game.add_game_connection(mock_game_connection)
    await game.remove_game_connection(mock_game_connection)

    game.on_game_end.assert_any_call()
Ejemplo n.º 11
0
async def test_game_end_when_no_more_connections(game: Game, mock_game_connection):
    game.state = GameState.LOBBY

    game.on_game_end = CoroMock()
    mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    game.add_game_connection(mock_game_connection)
    await game.remove_game_connection(mock_game_connection)

    game.on_game_end.assert_any_call()
Ejemplo n.º 12
0
async def test_compute_rating_raises_game_error(game: Game, players):
    game.state = GameState.LOBBY
    add_connected_players(game, [players.hosting, players.joining])
    # add_connected_players sets this, so we need to unset it again
    del game._player_options[players.hosting.id]["Team"]
    game.set_player_option(players.joining.id, "Team", 1)
    await game.launch()

    with pytest.raises(GameError):
        game.compute_rating(rating=RatingType.LADDER_1V1)
Ejemplo n.º 13
0
async def test_game_is_invalid_due_to_desyncs(game: Game, players):
    game.state = GameState.LOBBY
    add_connected_players(game, [players.hosting, players.joining])
    game.host = players.hosting

    await game.launch()
    game.desyncs = 30
    await game.on_game_end()

    assert game.validity is ValidityState.TOO_MANY_DESYNCS
Ejemplo n.º 14
0
async def test_game_is_invalid_due_to_desyncs(game: Game, players):
    await game.clear_data()
    game.state = GameState.LOBBY
    add_connected_players(game, [players.hosting, players.joining])
    game.host = players.hosting

    await game.launch()
    game.desyncs = 30
    await game.on_game_end()

    assert game.validity is ValidityState.TOO_MANY_DESYNCS
Ejemplo n.º 15
0
async def test_game_sim_ends_when_no_more_connections(game: Game, players):
    game.state = GameState.LOBBY
    host_conn = add_connected_player(game, players.hosting)
    join_conn = add_connected_player(game, players.joining)
    game.host = players.hosting

    await game.launch()

    await game.remove_game_connection(host_conn)
    await game.remove_game_connection(join_conn)
    assert game.ended
Ejemplo n.º 16
0
async def test_game_sim_ends_when_connections_ended_sim(game: Game, players):
    game.state = GameState.LOBBY
    host_conn = add_connected_player(game, players.hosting)
    join_conn = add_connected_player(game, players.joining)
    game.host = players.hosting

    await game.launch()

    host_conn.finished_sim = True
    join_conn.finished_sim = True
    await game.check_sim_end()
    assert game.ended
Ejemplo n.º 17
0
async def test_game_ends_in_mutually_agreed_draw(game: Game):
    game.state = GameState.LOBBY
    players = add_players(game, 2)

    await game.launch()
    game.launched_at = time.time()-60*60

    await game.add_result(players[0], 0, 'mutual_draw', 0)
    await game.add_result(players[1], 1, 'mutual_draw', 0)
    await game.on_game_end()

    assert game.validity is ValidityState.MUTUAL_DRAW
Ejemplo n.º 18
0
async def test_game_not_ends_in_unilatery_agreed_draw(game: Game, players):
    game.state = GameState.LOBBY
    add_players(game, 2)

    await game.launch()
    game.launched_at = time.time() - 60 * 60

    await game.add_result(players.hosting, 0, 'mutual_draw', 0)
    await game.add_result(players.joining, 1, 'victory', 10)
    await game.on_game_end()

    assert game.validity is not ValidityState.MUTUAL_DRAW
Ejemplo n.º 19
0
async def test_game_not_ends_in_unilatery_agreed_draw(game: Game, players):
    game.state = GameState.LOBBY
    add_players(game, 2)

    await game.launch()
    game.launched_at = time.time()-60*60

    await game.add_result(players.hosting, 0, 'mutual_draw', 0)
    await game.add_result(players.joining, 1, 'victory', 10)
    await game.on_game_end()

    assert game.validity is not ValidityState.MUTUAL_DRAW
Ejemplo n.º 20
0
async def test_game_sim_ends_when_no_more_connections(game: Game, players):
    await game.clear_data()
    game.state = GameState.LOBBY
    host_conn = add_connected_player(game, players.hosting)
    join_conn = add_connected_player(game, players.joining)
    game.host = players.hosting

    await game.launch()

    await game.remove_game_connection(host_conn)
    await game.remove_game_connection(join_conn)
    assert game.ended
Ejemplo n.º 21
0
async def test_game_ends_in_mutually_agreed_draw(game: Game):
    game.state = GameState.LOBBY
    players = add_players(game, 2)

    await game.launch()
    game.launched_at = time.time() - 60 * 60

    await game.add_result(players[0], 0, 'mutual_draw', 0)
    await game.add_result(players[1], 1, 'mutual_draw', 0)
    await game.on_game_end()

    assert game.validity is ValidityState.MUTUAL_DRAW
Ejemplo n.º 22
0
async def test_compute_rating_computes_ladder_ratings(game: Game, players):
    game.state = GameState.LOBBY
    players.hosting.ratings[RatingType.LADDER_1V1] = Rating(1500, 250)
    players.joining.ratings[RatingType.LADDER_1V1] = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    await game.add_result(players.hosting.id, 0, 'victory', 1)
    await game.add_result(players.joining.id, 1, 'defeat', 0)
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 1)
    groups = game.compute_rating(rating=RatingType.LADDER_1V1)
    assert players.hosting in groups[0]
    assert players.joining in groups[1]
Ejemplo n.º 23
0
async def test_game_sim_ends_when_connections_ended_sim(game: Game, players):
    await game.clear_data()
    game.state = GameState.LOBBY
    host_conn = add_connected_player(game, players.hosting)
    join_conn = add_connected_player(game, players.joining)
    game.host = players.hosting

    await game.launch()

    host_conn.finished_sim = True
    join_conn.finished_sim = True
    await game.check_sim_end()
    assert game.ended
Ejemplo n.º 24
0
async def test_game_launch_freezes_players(game: Game, players):
    game.state = GameState.LOBBY
    host_conn = add_connected_player(game, players.hosting)
    game.host = players.hosting
    add_connected_player(game, players.joining)

    await game.launch()

    assert game.state is GameState.LIVE
    assert game.players == {players.hosting, players.joining}

    await game.remove_game_connection(host_conn)
    assert game.players == {players.hosting, players.joining}
Ejemplo n.º 25
0
async def test_game_launch_freezes_players(game: Game, players):
    await game.clear_data()
    game.state = GameState.LOBBY
    host_conn = add_connected_player(game, players.hosting)
    game.host = players.hosting
    add_connected_player(game, players.joining)

    await game.launch()

    assert game.state == GameState.LIVE
    assert game.players == {players.hosting, players.joining}

    await game.remove_game_connection(host_conn)
    assert game.players == {players.hosting, players.joining}
Ejemplo n.º 26
0
async def test_report_army_stats_sends_stats_for_defeated_player(
        game: Game, game_add_players):
    game.state = GameState.LOBBY
    players = game_add_players(game, 2)

    await game.launch()
    await game.add_result(0, 1, 'defeat', -1)

    with open("tests/data/game_stats_simple_win.json", "r") as stats_file:
        stats = stats_file.read()

    game.report_army_stats(stats)

    game._game_stats_service.process_game_stats.assert_called_once_with(
        players[1], game, stats)
Ejemplo n.º 27
0
async def test_game_outcomes_no_results(game: Game, players):
    await game.clear_data()

    game.state = GameState.LOBBY
    players.hosting.ladder_rating = Rating(1500, 250)
    players.joining.ladder_rating = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 1)

    host_outcome = game.outcome(players.hosting)
    guest_outcome = game.outcome(players.joining)
    assert host_outcome is None
    assert guest_outcome is None
Ejemplo n.º 28
0
async def test_compute_rating_computes_global_ratings(game: Game, players):
    await game.clear_data()

    game.state = GameState.LOBBY
    players.hosting.global_rating = Rating(1500, 250)
    players.joining.global_rating = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    await game.add_result(players.hosting, 0, 'victory', 1)
    await game.add_result(players.joining, 1, 'defeat', 0)
    game.set_player_option(players.hosting.id, 'Team', 2)
    game.set_player_option(players.joining.id, 'Team', 3)
    groups = game.compute_rating()
    assert players.hosting in groups[0]
    assert players.joining in groups[1]
Ejemplo n.º 29
0
async def test_compute_rating_computes_ladder_ratings(game: Game, players):
    await game.clear_data()

    game.state = GameState.LOBBY
    players.hosting.ladder_rating = Rating(1500, 250)
    players.joining.ladder_rating = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    await game.add_result(players.hosting, 0, 'victory', 1)
    await game.add_result(players.joining, 1, 'defeat', 0)
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 1)
    groups = game.compute_rating(rating='ladder')
    assert players.hosting in groups[0]
    assert players.joining in groups[1]
Ejemplo n.º 30
0
def add_connected_players(game: Game, players):
    """
    Utility to add players with army and StartSpot indexed by a list
    """
    for army, player in enumerate(players):
        add_connected_player(game, player)
        game.set_player_option(player.id, 'Army', army)
        game.set_player_option(player.id, 'StartSpot', army)
        game.set_player_option(player.id, 'Team', army)
        game.set_player_option(player.id, 'Faction', 0)
        game.set_player_option(player.id, 'Color', 0)
    game.host = players[0]
Ejemplo n.º 31
0
def add_connected_players(game: Game, players):
    """
    Utility to add players with army and StartSpot indexed by a list
    """
    for army, player in enumerate(players):
        add_connected_player(game, player)
        game.set_player_option(player.id, 'Army', army)
        game.set_player_option(player.id, 'StartSpot', army)
        game.set_player_option(player.id, 'Team', army)
        game.set_player_option(player.id, 'Faction', 0)
        game.set_player_option(player.id, 'Color', 0)
    game.host = players[0]
Ejemplo n.º 32
0
    def create_game(self,
                    visibility=VisibilityState.PUBLIC,
                    game_mode: str=None,
                    host: Player=None,
                    name: str=None,
                    mapname: str=None,
                    password: str=None):
        """
        Main entrypoint for creating new games
        """
        id = self.createUuid()
        args = {
            "id": id,
            "host": host,
            "name": name,
            "map": mapname,
            "game_mode": game_mode,
            "game_service": self,
            "game_stats_service": self.game_stats_service
        }
        if game_mode == 'ladder1v1':
            game = LadderGame(**args)
        elif game_mode == 'coop':
            game = CoopGame(**args)
        elif game_mode == 'faf' or game_mode == 'fafbeta' or game_mode == 'equilibrium':
            game = CustomGame(**args)
        else:
            game = Game(**args)
        self.games[id] = game

        game.visibility = visibility
        game.password = password

        self.mark_dirty(game)
        return game
Ejemplo n.º 33
0
async def test_hashing(game):
    assert {
        game: 1,
        Game(game.id, mock.Mock(), mock.Mock(), mock.Mock()): 1
    } == {
        game: 1
    }
Ejemplo n.º 34
0
async def test_game_outcomes_no_results(game: Game, database, players):
    game.state = GameState.LOBBY
    players.hosting.ratings[RatingType.LADDER_1V1] = Rating(1500, 250)
    players.joining.ratings[RatingType.LADDER_1V1] = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 1)

    host_outcome = game.get_player_outcome(players.hosting)
    guest_outcome = game.get_player_outcome(players.joining)
    assert host_outcome is GameOutcome.UNKNOWN
    assert guest_outcome is GameOutcome.UNKNOWN

    await game.on_game_end()
    expected_scores = {(players.hosting.id, 0), (players.joining.id, 0)}
    assert await game_player_scores(database, game) == expected_scores
Ejemplo n.º 35
0
async def test_game_outcomes(game: Game, players):
    await game.clear_data()

    game.state = GameState.LOBBY
    players.hosting.ladder_rating = Rating(1500, 250)
    players.joining.ladder_rating = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    await game.add_result(players.hosting, 0, 'victory', 1)
    await game.add_result(players.joining, 1, 'defeat', 0)
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 1)

    host_outcome = game.outcome(players.hosting)
    guest_outcome = game.outcome(players.joining)
    assert host_outcome is GameOutcome.VICTORY
    assert guest_outcome is GameOutcome.DEFEAT
Ejemplo n.º 36
0
async def test_game_outcomes_conflicting(game: Game, database, players):
    game.state = GameState.LOBBY
    players.hosting.ratings[RatingType.LADDER_1V1] = Rating(1500, 250)
    players.joining.ratings[RatingType.LADDER_1V1] = Rating(1500, 250)
    add_connected_players(game, [players.hosting, players.joining])
    await game.launch()
    await game.add_result(players.hosting.id, 0, 'victory', 1)
    await game.add_result(players.joining.id, 1, 'victory', 0)
    await game.add_result(players.hosting.id, 0, 'defeat', 1)
    await game.add_result(players.joining.id, 1, 'defeat', 0)
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 1)

    host_outcome = game.get_player_outcome(players.hosting)
    guest_outcome = game.get_player_outcome(players.joining)
    assert host_outcome is GameOutcome.CONFLICTING
    assert guest_outcome is GameOutcome.CONFLICTING
Ejemplo n.º 37
0
async def test_report_army_stats_sends_stats_for_defeated_player(game: Game):
    game.id = 43
    game.state = GameState.LOBBY
    players = [
        Player(id=1, login='******', global_rating=(1500, 500)),
        Player(id=2, login='******', global_rating=(1500, 500))
    ]
    add_connected_players(game, players)

    await game.launch()
    await game.add_result(0, 1, 'defeat', -1)

    with open("tests/data/game_stats_simple_win.json", "r") as stats_file:
        stats = stats_file.read()

    await game.report_army_stats(stats)

    game._game_stats_service.process_game_stats.assert_called_once_with(players[1], game, stats)
Ejemplo n.º 38
0
async def test_report_army_stats_sends_stats_for_defeated_player(game: Game):
    game.id = 43
    game.state = GameState.LOBBY
    players = [
        Player(id=1, login='******', global_rating=(1500, 500)),
        Player(id=2, login='******', global_rating=(1500, 500))
    ]
    add_connected_players(game, players)

    await game.launch()
    await game.add_result(0, 1, 'defeat', -1)

    with open("tests/data/game_stats_simple_win.json", "r") as stats_file:
        stats = stats_file.read()

    await game.report_army_stats(stats)

    game._game_stats_service.process_game_stats.assert_called_once_with(players[1], game, stats)
Ejemplo n.º 39
0
async def test_validate_game_settings(game: Game):
    settings = [
        ('Victory', Victory.SANDBOX, ValidityState.WRONG_VICTORY_CONDITION),
        ('FogOfWar', 'none', ValidityState.NO_FOG_OF_WAR),
        ('CheatsEnabled', 'true', ValidityState.CHEATS_ENABLED),
        ('PrebuiltUnits', 'On', ValidityState.PREBUILT_ENABLED),
        ('NoRushOption', 20, ValidityState.NORUSH_ENABLED),
        ('RestrictedCategories', 1, ValidityState.BAD_UNIT_RESTRICTIONS),
        ('TeamLock', 'unlocked', ValidityState.UNLOCKED_TEAMS)
    ]

    game.state = GameState.LOBBY
    add_players(game, 2)

    await check_game_settings(game, settings)

    game.validity = ValidityState.VALID
    await game.validate_game_settings()
    assert game.validity is ValidityState.VALID
Ejemplo n.º 40
0
async def test_validate_game_settings(game: Game):
    settings = [
        ('Victory', Victory.SANDBOX, Victory.DEMORALIZATION, ValidityState.WRONG_VICTORY_CONDITION),
        ('FogOfWar', 'none', 'explored', ValidityState.NO_FOG_OF_WAR),
        ('CheatsEnabled', 'true', 'false', ValidityState.CHEATS_ENABLED),
        ('PrebuiltUnits', 'On', 'Off', ValidityState.PREBUILT_ENABLED),
        ('NoRushOption', 20, 'Off', ValidityState.NORUSH_ENABLED),
        ('RestrictedCategories', 1, 0, ValidityState.BAD_UNIT_RESTRICTIONS)
    ]

    for data in settings:
        key, value, default, expected = data
        game.gameOptions[key] = value
        await game.validate_game_settings()
        assert game.validity is expected
        game.gameOptions[key] = default

    game.validity = ValidityState.VALID
    await game.validate_game_settings()
    assert game.validity is ValidityState.VALID
Ejemplo n.º 41
0
async def test_validate_game_settings(game: Game):
    settings = [
        ('Victory', Victory.SANDBOX, Victory.DEMORALIZATION,
         ValidityState.WRONG_VICTORY_CONDITION),
        ('FogOfWar', 'none', 'explored', ValidityState.NO_FOG_OF_WAR),
        ('CheatsEnabled', 'true', 'false', ValidityState.CHEATS_ENABLED),
        ('PrebuiltUnits', 'On', 'Off', ValidityState.PREBUILT_ENABLED),
        ('NoRushOption', 20, 'Off', ValidityState.NORUSH_ENABLED),
        ('RestrictedCategories', 1, 0, ValidityState.BAD_UNIT_RESTRICTIONS)
    ]

    for data in settings:
        key, value, default, expected = data
        game.gameOptions[key] = value
        await game.validate_game_settings()
        assert game.validity is expected
        game.gameOptions[key] = default

    game.validity = ValidityState.VALID
    await game.validate_game_settings()
    assert game.validity is ValidityState.VALID
Ejemplo n.º 42
0
async def test_compute_rating_balanced_teamgame(game: Game, player_factory):
    game.state = GameState.LOBBY
    players = [(player_factory(login=f"{i}",
                               player_id=i,
                               global_rating=rating,
                               with_lobby_connection=False), result, team)
               for i, (rating, result, team) in enumerate([
                   (Rating(1500, 250), 0, 2),
                   (Rating(1700, 120), 0, 2),
                   (Rating(1200, 72), 0, 3),
                   (Rating(1200, 72), 0, 3),
               ], 1)]
    add_connected_players(game, [player for player, _, _ in players])
    for player, _, team in players:
        game.set_player_option(player.id, 'Team', team)
        game.set_player_option(player.id, 'Army', player.id - 1)
    await game.launch()
    for player, result, team in players:
        await game.add_result(player, player.id - 1,
                              'victory' if team == 2 else 'defeat', result)
    result = game.compute_rating()
    for team in result:
        for player, new_rating in team.items():
            assert player in game.players
            assert new_rating != Rating(*player.ratings[RatingType.GLOBAL])
Ejemplo n.º 43
0
async def test_compute_rating_balanced_teamgame(game: Game, create_player):
    await game.clear_data()

    game.state = GameState.LOBBY
    players = [(
        create_player(**info), result, team
    ) for info, result, team in [
        (dict(login='******', id=1, global_rating=Rating(1500, 250.7)), 0,
         1),
        (dict(login='******', id=2, global_rating=Rating(1700, 120.1)), 0,
         1),
        (dict(login='******', id=3, global_rating=Rating(1200, 72.02)),
         0, 2),
        (dict(login='******', id=4, global_rating=Rating(1200, 72.02)), 0,
         2),
    ]]
    add_connected_players(game, [player for player, _, _ in players])
    for player, _, team in players:
        game.set_player_option(player.id, 'Team', team)
        game.set_player_option(player.id, 'Army', player.id - 1)
    await game.launch()
    for player, result, _ in players:
        await game.add_result(player, player.id - 1, 'score', result)
    result = game.compute_rating()
    for team in result:
        for player, new_rating in team.items():
            assert player in game.players
            assert new_rating != Rating(*player.global_rating)
Ejemplo n.º 44
0
async def test_report_army_stats_sends_stats_for_defeated_player(game: Game):
    game.state = GameState.LOBBY
    players = add_players(game, 2)

    await game.launch()
    await game.add_result(0, 1, 'defeat', -1)

    with open("tests/data/game_stats_simple_win.json", "r") as stats_file:
        stats = stats_file.read()

    await game.report_army_stats(stats)

    game._game_stats_service.process_game_stats.assert_called_once_with(players[1], game, stats)
Ejemplo n.º 45
0
async def test_validate_game_settings_coop(coop_game: Game):
    settings = [
        ('Victory', Victory.DEMORALIZATION, ValidityState.WRONG_VICTORY_CONDITION),
        ('TeamSpawn', 'open', ValidityState.SPAWN_NOT_FIXED),
        ('RevealedCivilians', 'Yes', ValidityState.CIVILIANS_REVEALED),
        ('Difficulty', 1, ValidityState.WRONG_DIFFICULTY),
        ('Expansion', 0, ValidityState.EXPANSION_DISABLED),
    ]

    await check_game_settings(coop_game, settings)

    coop_game.validity = ValidityState.VALID
    await coop_game.validate_game_settings()
    assert coop_game.validity is ValidityState.VALID
Ejemplo n.º 46
0
async def test_clear_slot(game: Game, mock_game_connection: GameConnection):
    game.state = GameState.LOBBY
    players = [
        Player(id=1, login='******', global_rating=(1500, 500)),
        Player(id=2, login='******', global_rating=(1500, 500))
    ]
    add_connected_players(game, players)
    game.set_ai_option('rush', 'StartSpot', 3)

    game.clear_slot(0)
    game.clear_slot(3)

    assert game.get_player_option(1, 'StartSpot') == -1
    assert game.get_player_option(1, 'Team') == -1
    assert game.get_player_option(1, 'Army') == -1
    assert game.get_player_option(2, 'StartSpot') == 1
    assert 'rush' not in game.AIs
Ejemplo n.º 47
0
async def test_clear_slot(game: Game, mock_game_connection: GameConnection):
    game.state = GameState.LOBBY
    players = [
        Player(id=1, login='******', global_rating=(1500, 500)),
        Player(id=2, login='******', global_rating=(1500, 500))
    ]
    add_connected_players(game, players)
    game.set_ai_option('rush', 'StartSpot', 3)


    game.clear_slot(0)
    game.clear_slot(3)

    assert game.get_player_option(1, 'StartSpot') == -1
    assert game.get_player_option(1, 'Team') == -1
    assert game.get_player_option(1, 'Army') == -1
    assert game.get_player_option(2, 'StartSpot') == 1
    assert 'rush' not in game.AIs
Ejemplo n.º 48
0
async def test_compute_rating_balanced_teamgame(game: Game, create_player):
    await game.clear_data()

    game.state = GameState.LOBBY
    players = [
        (create_player(**info), result, team) for info, result, team in [
            (dict(login='******', id=1, global_rating=Rating(1500, 250.7)), 0, 1),
            (dict(login='******', id=2, global_rating=Rating(1700, 120.1)), 0, 1),
            (dict(login='******', id=3, global_rating=Rating(1200, 72.02)), 0, 2),
            (dict(login='******', id=4, global_rating=Rating(1200, 72.02)), 0, 2),
        ]
    ]
    add_connected_players(game, [player for player, _, _ in players])
    for player, _, team in players:
        game.set_player_option(player.id, 'Team', team)
        game.set_player_option(player.id, 'Army', player.id - 1)
    await game.launch()
    for player, result, _ in players:
        await game.add_result(player, player.id - 1, 'score', result)
    result = game.compute_rating()
    for team in result:
        for player, new_rating in team.items():
            assert player in game.players
            assert new_rating != Rating(*player.global_rating)
Ejemplo n.º 49
0
def test_invalid_get_player_option_key(game: Game, players):
    assert game.get_player_option(players.hosting.id, -1) is None
Ejemplo n.º 50
0
async def test_update_ratings(game: Game, players, db_pool, player_service, game_service):
    player_service.players[players.hosting.id] = players.hosting
    game.state = GameState.LOBBY
    add_connected_player(game, players.hosting)
    await game.update_ratings()
    assert players.hosting.global_rating == (2000, 125)
Ejemplo n.º 51
0
def add_connected_player(game: Game, player):
    game.game_service.player_service[player.id] = player
    gc = game_connection(state=GameConnectionState.CONNECTED_TO_HOST, player=player)
    game.set_player_option(player.id, 'Army', 0)
    game.set_player_option(player.id, 'StartSpot', 0)
    game.set_player_option(player.id, 'Team', 0)
    game.set_player_option(player.id, 'Faction', 0)
    game.set_player_option(player.id, 'Color', 0)
    game.add_game_connection(gc)
    return gc
Ejemplo n.º 52
0
def test_add_game_connection(game: Game, players, game_connection):
    game.state = GameState.LOBBY
    game_connection.player = players.hosting
    game_connection.state = GameConnectionState.CONNECTED_TO_HOST
    game.add_game_connection(game_connection)
    assert players.hosting in game.players
Ejemplo n.º 53
0
def game(loop, game_service, game_stats_service):
    game = Game(42, game_service, game_stats_service)
    yield game
    loop.run_until_complete(game.clear_data())
Ejemplo n.º 54
0
async def test_players_exclude_observers(game: Game):
    game.state = GameState.LOBBY
    players = add_players(game, 2)

    obs = Player(id=3, login='******', global_rating=(1500, 500))

    game.game_service.player_service[obs.id] = obs
    gc = mock_game_connection(state=GameConnectionState.CONNECTED_TO_HOST, player=obs)
    game.set_player_option(obs.id, 'Army', -1)
    game.set_player_option(obs.id, 'StartSpot', -1)
    game.set_player_option(obs.id, 'Team', 0)
    game.set_player_option(obs.id, 'Faction', 0)
    game.set_player_option(obs.id, 'Color', 0)
    game.add_game_connection(gc)
    await game.launch()

    assert game.players == frozenset(players)
Ejemplo n.º 55
0
async def test_game_marked_dirty_when_timed_out(game: Game):
    game.state = GameState.INITIALIZING
    game.sleep = CoroMock()
    await game.timeout_game()
    assert game.state == GameState.ENDED
    assert game in game.game_service.dirty_games
Ejemplo n.º 56
0
def test_game_teams_represents_active_teams(game: Game, players):
    game.state = GameState.LOBBY
    add_connected_players(game, [players.hosting, players.joining])
    game.set_player_option(players.hosting.id, 'Team', 1)
    game.set_player_option(players.joining.id, 'Team', 2)
    assert game.teams == {1, 2}