Introduce a smart multiplier calculation

The matchmaking multiplier is calculated based on the online bots and the configured rating limits

Author: Torom

botli_dataclasses.py

@@ -253,10 +253,11 @@ class Matchmaking_Type:
     rated: bool
     variant: Variant
     perf_type: Perf_Type
-    multiplier: float
+    config_multiplier: int | None
+    multiplier: int
     weight: float
-    min_rating_diff: int
-    max_rating_diff: int
+    min_rating_diff: int | None
+    max_rating_diff: int | None
 
     def __post_init__(self) -> None:
         self.estimated_game_duration = timedelta(seconds=max(self.initial_time, 3) * 1.33 + self.increment * 94.48)

config.yml.default

@@ -170,7 +170,7 @@ matchmaking:
 #     rated: true                         # Whether matchmaking should play rated games. Default: true
 #     variant: standard                   # Chess variant (https://lichess.org/variant) to challenge. Default: standard
 #     weight: 100                         # Weight with which this type is selected. Default: Types are played according to their time control.
-#     multiplier: 15                      # Multiplier for calculating timeouts in matchmaking. Default: 15 * number of configured performance types.
+#     multiplier: 15                      # Multiplier for calculating timeouts in matchmaking. Default: smart multiplier calculation.
 #     min_rating_diff: 0                  # Minimum rating distance to opponent. Default: 0
 #     max_rating_diff: 300                # Maximum rating distance to opponent. Default: 10000
 

matchmaking.py

@@ -126,19 +126,13 @@ def _get_matchmaking_types(self) -> list[Matchmaking_Type]:
             rated = True if type_config.rated is None else type_config.rated
             variant = Variant.STANDARD if type_config.variant is None else Variant(type_config.variant)
             perf_type = self._variant_to_perf_type(variant, initial_time, increment)
-            multiplier = 15 if type_config.multiplier is None else type_config.multiplier
             weight = 1.0 if type_config.weight is None else type_config.weight
-            min_rating_diff = 0 if type_config.min_rating_diff is None else type_config.min_rating_diff
-            max_rating_diff = 10_000 if type_config.max_rating_diff is None else type_config.max_rating_diff
 
             matchmaking_types.append(Matchmaking_Type(name, initial_time, increment, rated, variant,
-                                                      perf_type, multiplier, weight, min_rating_diff, max_rating_diff))
+                                                      perf_type, type_config.multiplier, -1, weight,
+                                                      type_config.min_rating_diff, type_config.max_rating_diff))
 
-        perf_type_count = len({matchmaking_type.perf_type for matchmaking_type in matchmaking_types})
         for matchmaking_type, type_config in zip(matchmaking_types, self.config.matchmaking.types.values()):
-            if type_config.multiplier is None:
-                matchmaking_type.multiplier *= perf_type_count
-
             if type_config.weight is None:
                 matchmaking_type.weight /= matchmaking_type.estimated_game_duration.total_seconds()
 
@@ -147,14 +141,15 @@ def _get_matchmaking_types(self) -> list[Matchmaking_Type]:
         return matchmaking_types
 
     async def _call_update(self) -> bool:
-        if self.next_update <= datetime.now():
-            print('Updating online bots and rankings ...')
-            self.types.extend(self.suspended_types)
-            self.suspended_types.clear()
-            self.online_bots = await self._get_online_bots()
-            return True
+        if self.next_update > datetime.now():
+            return False
 
-        return False
+        print('Updating online bots and rankings ...')
+        self.types.extend(self.suspended_types)
+        self.suspended_types.clear()
+        self.online_bots = await self._get_online_bots()
+        self._set_multiplier()
+        return True
 
     async def _get_online_bots(self) -> list[Bot]:
         user_ratings = await self._get_user_ratings()
@@ -196,6 +191,36 @@ async def _get_user_ratings(self) -> dict[Perf_Type, int]:
 
         return performances
 
+    def _set_multiplier(self) -> None:
+        for matchmaking_type in self.types:
+            if matchmaking_type.config_multiplier:
+                matchmaking_type.multiplier = matchmaking_type.config_multiplier
+            else:
+                min_rating_diff = matchmaking_type.min_rating_diff if matchmaking_type.min_rating_diff else 0
+                max_rating_diff = matchmaking_type.max_rating_diff if matchmaking_type.max_rating_diff else 600
+
+                bot_count = self._get_bot_count(matchmaking_type.perf_type, min_rating_diff, max_rating_diff)
+                perf_type_count = len({matchmaking_type.perf_type for matchmaking_type in self.types})
+                matchmaking_type.multiplier = bot_count * perf_type_count
+
+    def _get_bot_count(self, perf_type: Perf_Type, min_rating_diff: int, max_rating_diff: int) -> int:
+        def bot_filter(bot: Bot) -> bool:
+            if perf_type not in bot.rating_diffs:
+                return False
+
+            if abs(bot.rating_diffs[perf_type]) > max_rating_diff:
+                return False
+
+            if abs(bot.rating_diffs[perf_type]) < min_rating_diff:
+                return False
+
+            if self.opponents.opponent_dict[bot.username][perf_type].multiplier > 1:
+                return False
+
+            return True
+
+        return sum(map(bot_filter, self.online_bots))
+
     def _variant_to_perf_type(self, variant: Variant, initial_time: int, increment: int) -> Perf_Type:
         if variant != Variant.STANDARD:
             return Perf_Type(variant)

opponents.py

@@ -69,11 +69,13 @@ def bot_filter(bot: Bot) -> bool:
             if matchmaking_type.perf_type not in bot.rating_diffs:
                 return False
 
-            if abs(bot.rating_diffs[matchmaking_type.perf_type]) > matchmaking_type.max_rating_diff:
-                return False
+            if matchmaking_type.max_rating_diff:
+                if abs(bot.rating_diffs[matchmaking_type.perf_type]) > matchmaking_type.max_rating_diff:
+                    return False
 
-            if abs(bot.rating_diffs[matchmaking_type.perf_type]) < matchmaking_type.min_rating_diff:
-                return False
+            if matchmaking_type.min_rating_diff:
+                if abs(bot.rating_diffs[matchmaking_type.perf_type]) < matchmaking_type.min_rating_diff:
+                    return False
 
             return True