Add first draft of recall waiving limit requirements for ranking custom games

Author: Hdt80bro

server/games/custom_game.py

@@ -3,6 +3,7 @@
 from server.rating import RatingType
 
 from .game import Game
+from .game_results import ArmyOutcome
 from .typedefs import GameType, InitMode, ValidityState
 
 
@@ -18,9 +19,25 @@ def __init__(self, id, *args, **kwargs):
         new_kwargs.update(kwargs)
         super().__init__(id, *args, **new_kwargs)
 
-    async def _run_pre_rate_validity_checks(self):
+    async def _run_pre_rate_validity_checks(self, team_army_outcomes: list[set[ArmyOutcome]]):
         assert self.launched_at is not None
 
+        # if there were connection issues, they are likely to show up early in
+        # the match and manifest as players quitting out - in these cases, we
+        # grant a grace period to custom games before we count them as ranked
         limit = len(self.players) * 60
-        if not self.enforce_rating and time.time() - self.launched_at < limit:
+        duration = time.time() - self.launched_at
+
+        # As we only get extremely limited data (the army results), our lens of
+        # what can look like "quitting out" is rather large (i.e. the player is
+        # "defeated").
+        # In other words, only if a team unaminously recalled would we know
+        # there weren't any connection issues.
+        looks_like_quitting = {ArmyOutcome.DEFEAT, ArmyOutcome.UNKNOWN, ArmyOutcome.CONFLICTING}
+        all_outcomes = {}
+        for outcome in team_army_outcomes:
+            all_outcomes |= outcome
+        possible_conn_issues = len(all_outcomes & looks_like_quitting) > 0
+
+        if not self.enforce_rating and (possible_conn_issues and duration < limit):
             await self.mark_invalid(ValidityState.TOO_SHORT)

server/games/game.py

@@ -487,7 +487,7 @@ async def on_game_finish(self):
 
             self.game_service.mark_dirty(self)
 
-    async def _run_pre_rate_validity_checks(self):
+    async def _run_pre_rate_validity_checks(self, team_army_results: list[set[ArmyOutcome]]):
         pass
 
     async def process_game_results(self):
@@ -504,8 +504,6 @@ async def resolve_game_results(self) -> EndedGameInfo:
         if self.state not in (GameState.LIVE, GameState.ENDED):
             raise GameError("Cannot rate game that has not been launched.")
 
-        await self._run_pre_rate_validity_checks()
-
         basic_info = self.get_basic_info()
 
         team_army_results = [
@@ -518,6 +516,8 @@ async def resolve_game_results(self) -> EndedGameInfo:
             {self.get_player_outcome(player) for player in team}
             for team in basic_info.teams
         ]
+        
+        await self._run_pre_rate_validity_checks(team_player_partial_outcomes)
 
         try:
             # TODO: Remove override once game result messages are reliable

server/games/game_results.py

@@ -18,6 +18,7 @@ class ArmyOutcome(Enum):
     """
     VICTORY = "VICTORY"
     DEFEAT = "DEFEAT"
+    RECALL = "RECALL" # treated the same as `DEFEAT` except for conn issues
     DRAW = "DRAW"
     UNKNOWN = "UNKNOWN"
     CONFLICTING = "CONFLICTING"
@@ -29,6 +30,7 @@ class ArmyReportedOutcome(Enum):
     """
     VICTORY = "VICTORY"
     DEFEAT = "DEFEAT"
+    RECALL = "RECALL"
     DRAW = "DRAW"
     # This doesn't seem to be reported by the game anymore
     MUTUAL_DRAW = "MUTUAL_DRAW"

tests/unit_tests/test_custom_game.py

@@ -12,6 +12,29 @@ async def custom_game(database, game_service, game_stats_service):
     return CustomGame(42, database, game_service, game_stats_service)
 
 
+
+async def test_rate_game_early_recall(
+    custom_game: CustomGame,
+    player_factory
+):
+    custom_game.state = GameState.LOBBY
+    players = [
+        player_factory("Dostya", player_id=1, global_rating=(1500, 500)),
+        player_factory("Rhiza", player_id=2, global_rating=(1500, 500)),
+    ]
+    add_connected_players(custom_game, players)
+    custom_game.set_player_option(1, "Team", 2)
+    custom_game.set_player_option(2, "Team", 3)
+    await custom_game.launch()
+    await custom_game.add_result(0, 0, "victory", 5)
+    await custom_game.add_result(0, 1, "recall", -5)
+
+    custom_game.launched_at = time.time() - 60  # seconds
+
+    await custom_game.on_game_finish()
+    assert custom_game.validity == ValidityState.VALID
+
+
 async def test_rate_game_early_abort_no_enforce(
     custom_game: CustomGame,
     player_factory

tests/unit_tests/test_game_resolution.py

@@ -37,68 +37,39 @@ def testresolve():
 def test_ranks_all_1v1_possibilities():
     """
     Document expectations for all outcomes of 1v1 games.
-    Assumes that the order of teams doesn't matter.
-    With five possible outcomes there are 15 possibilities.
+    With six possible outcomes there are 36 possibilities.
     """
-    team_outcomes = [{ArmyOutcome.VICTORY}, {ArmyOutcome.VICTORY}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.VICTORY}, {ArmyOutcome.DEFEAT}]
-    ranks = resolve_game(team_outcomes)
-    assert ranks == [GameOutcome.VICTORY, GameOutcome.DEFEAT]
-
-    team_outcomes = [{ArmyOutcome.VICTORY}, {ArmyOutcome.DRAW}]
-    resolve_game(team_outcomes)
-    assert ranks == [GameOutcome.VICTORY, GameOutcome.DEFEAT]
-
-    team_outcomes = [{ArmyOutcome.VICTORY}, {ArmyOutcome.UNKNOWN}]
-    ranks = resolve_game(team_outcomes)
-    assert ranks == [GameOutcome.VICTORY, GameOutcome.DEFEAT]
 
-    team_outcomes = [{ArmyOutcome.VICTORY}, {ArmyOutcome.CONFLICTING}]
-    ranks = resolve_game(team_outcomes)
-    assert ranks == [GameOutcome.VICTORY, GameOutcome.DEFEAT]
-
-    team_outcomes = [{ArmyOutcome.DEFEAT}, {ArmyOutcome.DEFEAT}]
-    ranks = resolve_game(team_outcomes)
-    assert ranks == [GameOutcome.DRAW, GameOutcome.DRAW]
-
-    team_outcomes = [{ArmyOutcome.DEFEAT}, {ArmyOutcome.DRAW}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.DEFEAT}, {ArmyOutcome.UNKNOWN}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.DEFEAT}, {ArmyOutcome.CONFLICTING}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.DRAW}, {ArmyOutcome.DRAW}]
-    ranks = resolve_game(team_outcomes)
-    assert ranks == [GameOutcome.DRAW, GameOutcome.DRAW]
-
-    team_outcomes = [{ArmyOutcome.DRAW}, {ArmyOutcome.UNKNOWN}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.DRAW}, {ArmyOutcome.CONFLICTING}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.UNKNOWN}, {ArmyOutcome.UNKNOWN}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.UNKNOWN}, {ArmyOutcome.CONFLICTING}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
-
-    team_outcomes = [{ArmyOutcome.CONFLICTING}, {ArmyOutcome.CONFLICTING}]
-    with pytest.raises(GameResolutionError):
-        resolve_game(team_outcomes)
+    ERROR = 0
+    DRAW = 1
+    WIN = 2
+    LOSS = 3
+    #        Victory  Defeat   Recall   Draw     Unknown  Conflicting
+    grid = [[ERROR,   WIN,     WIN,     WIN,     WIN,     WIN  ]  # Victory
+            [LOSS,    DRAW,    DRAW,    ERROR,   ERROR,   ERROR]  # Defeat
+            [LOSS,    DRAW,    DRAW,    ERROR,   ERROR,   ERROR]  # Recall
+            [LOSS,    ERROR,   ERROR,   DRAW,    ERROR,   ERROR]  # Draw
+            [LOSS,    ERROR,   ERROR,   ERROR,   ERROR,   ERROR]  # Unknown
+            [LOSS,    ERROR,   ERROR,   ERROR,   ERROR,   ERROR]] # Conflicting
+    outcome_list = [ArmyOutcome.VICTORY, ArmyOutcome.DEFEAT, ArmyOutcome.RECALL,
+            ArmyOutcome.DRAW, ArmyOutcome.UNKNOWN, ArmyOutcome.CONFLICTING]
+
+    win_resolution = [GameOutcome.VICTORY, GameOutcome.DEFEAT]
+    draw_resolution = [GameOutcome.DRAW, GameOutcome.DRAW]
+    loss_resolution = [GameOutcome.DEFEAT, GameOutcome.VICTORY]
+
+    for outcome1, row in grid:
+        for outcome2, resolution in row:
+            team_outcomes = [{outcome_list[outcome1]}, {outcome_list[outcome2]}]
+            if resolution == ERROR:
+                with pytest.raises(GameResolutionError):
+                    resolve_game(team_outcomes)
+            elif resolution == WIN:
+                assert resolve_game(team_outcomes) == win_resolution
+            elif resolution == DRAW:
+                assert resolve_game(team_outcomes) == draw_resolution
+            elif resolution == LOSS:
+                assert resolve_game(team_outcomes) == loss_resolution
 
 
 def test_team_outcome_ignores_unknown():

tests/unit_tests/test_game_results.py

@@ -19,6 +19,7 @@ def game_results():
 def test_reported_result_to_resolved():
     assert ArmyReportedOutcome.VICTORY.to_resolved() is ArmyOutcome.VICTORY
     assert ArmyReportedOutcome.DEFEAT.to_resolved() is ArmyOutcome.DEFEAT
+    assert ArmyReportedOutcome.RECALL.to_resolved() is ArmyOutcome.RECALL
     assert ArmyReportedOutcome.DRAW.to_resolved() is ArmyOutcome.DRAW
     assert ArmyReportedOutcome.MUTUAL_DRAW.to_resolved() is ArmyOutcome.DRAW