Feature/#1032 working veto system

server/__init__.py

@@ -126,6 +126,7 @@
 from .gameconnection import GameConnection
 from .geoip_service import GeoIpService
 from .ladder_service import LadderService
+from .ladder_service.veto_system import VetoService
 from .ladder_service.violation_service import ViolationService
 from .lobbyconnection import LobbyConnection
 from .message_queue_service import MessageQueueService
@@ -157,6 +158,7 @@
     "RatingService",
     "RatingService",
     "ServerInstance",
+    "VetoService",
     "ViolationService",
     "game_service",
     "protocol",
@@ -204,6 +206,7 @@ def __init__(
             party_service=self.services["party_service"],
             rating_service=self.services["rating_service"],
             oauth_service=self.services["oauth_service"],
+            veto_service=self.services["veto_service"],
         )
 
     def write_broadcast(

server/config.py

@@ -137,7 +137,9 @@ def __init__(self):
         self.GEO_IP_DATABASE_MAX_AGE_DAYS = 22
 
         self.LADDER_1V1_OUTCOME_OVERRIDE = True
-        self.LADDER_ANTI_REPETITION_LIMIT = 2
+        self.LADDER_ANTI_REPETITION_LIMIT = 1
+        self.LADDER_ANTI_REPETITION_WEIGHT_BASE_THRESHOLDS = [0.75, 0.5]
+        self.LADDER_ANTI_REPETITION_REPEAT_COUNTS_FACTOR = 0.8
         self.LADDER_SEARCH_EXPANSION_MAX = 0.25
         self.LADDER_SEARCH_EXPANSION_STEP = 0.05
         self.LADDER_TOP_PLAYER_SEARCH_EXPANSION_MAX = 0.3

server/db/models.py

@@ -295,10 +295,14 @@
 
 matchmaker_queue_map_pool = Table(
     "matchmaker_queue_map_pool", metadata,
-    Column("matchmaker_queue_id",   Integer,    ForeignKey("matchmaker_queue.id"),  nullable=False),
-    Column("map_pool_id",           Integer,    ForeignKey("map_pool.id"),          nullable=False),
-    Column("min_rating",            Integer),
-    Column("max_rating",            Integer),
+    Column("id",                       Integer, primary_key=True),
+    Column("matchmaker_queue_id",      Integer, ForeignKey("matchmaker_queue.id"), nullable=False),
+    Column("map_pool_id",              Integer, ForeignKey("map_pool.id"),         nullable=False),
+    Column("min_rating",               Integer),
+    Column("max_rating",               Integer),
+    Column("veto_tokens_per_player",   Integer, nullable=False),
+    Column("max_tokens_per_map",       Integer, nullable=False),
+    Column("minimum_maps_after_veto",  Float,   nullable=False),
 )
 
 teamkills = Table(

server/ladder_service/ladder_service.py

@@ -8,7 +8,15 @@
 import re
 import statistics
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Coroutine, Optional
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Coroutine,
+    Optional,
+    cast
+)
 
 import aiocron
 import humanize
@@ -37,16 +45,23 @@
 from server.games import InitMode, LadderGame
 from server.games.ladder_game import GameClosedError
 from server.ladder_service.game_name import game_name
+from server.ladder_service.veto_system import VetoService
 from server.ladder_service.violation_service import ViolationService
 from server.matchmaker import (
     MapPool,
     MatchmakerQueue,
+    MatchmakerQueueMapPool,
     OnMatchedCallback,
     Search
 )
 from server.metrics import MatchLaunch
 from server.players import Player, PlayerState
-from server.types import GameLaunchOptions, Map, NeroxisGeneratedMap
+from server.types import (
+    GameLaunchOptions,
+    Map,
+    MapPoolMap,
+    NeroxisGeneratedMap
+)
 
 if TYPE_CHECKING:
     from server.lobbyconnection import LobbyConnection
@@ -66,12 +81,14 @@ def __init__(
         database: FAFDatabase,
         game_service: GameService,
         violation_service: ViolationService,
+        veto_service: VetoService,
     ):
         self._db = database
         self._informed_players: set[Player] = set()
         self.game_service = game_service
         self.queues: dict[str, MatchmakerQueue] = {}
         self.violation_service = violation_service
+        self.veto_service = veto_service
 
         self._searches: dict[Player, dict[str, Search]] = defaultdict(dict)
         self._allow_new_searches = True
@@ -106,7 +123,7 @@ async def update_data(self) -> None:
                 queue.team_size = info["team_size"]
                 queue.rating_peak = await self.fetch_rating_peak(info["rating_type"])
             queue.map_pools.clear()
-            for map_pool_id, min_rating, max_rating in info["map_pools"]:
+            for matchmaker_queue_map_pool_id, map_pool_id, min_rating, max_rating, veto_tokens_per_player, max_tokens_per_map, minimum_maps_after_veto in info["map_pools"]:
                 map_pool_name, map_list = map_pool_maps[map_pool_id]
                 if not map_list:
                     self._logger.warning(
@@ -116,21 +133,32 @@ async def update_data(self) -> None:
                         name
                     )
                 queue.add_map_pool(
-                    MapPool(map_pool_id, map_pool_name, map_list),
-                    min_rating,
-                    max_rating
+                    MatchmakerQueueMapPool(
+                        matchmaker_queue_map_pool_id,
+                        MapPool(map_pool_id, map_pool_name, cast(list[MapPoolMap], map_list)),
+                        min_rating,
+                        max_rating,
+                        veto_tokens_per_player,
+                        max_tokens_per_map,
+                        minimum_maps_after_veto
+                    )
                 )
         # Remove queues that don't exist anymore
         for queue_name in list(self.queues.keys()):
             if queue_name not in db_queues:
                 self.queues[queue_name].shutdown()
                 del self.queues[queue_name]
 
+        affected_players = self.veto_service.update_pools_veto_config(self.queues)
+        for player in affected_players:
+            self.cancel_search(player)
+
     async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
         result = await conn.execute(
             select(
                 map_pool.c.id,
                 map_pool.c.name,
+                map_pool_map_version.c.id.label("map_pool_map_version_id"),
                 map_pool_map_version.c.weight,
                 map_pool_map_version.c.map_params,
                 map_version.c.id.label("map_id"),
@@ -159,6 +187,7 @@ async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
                 map_list.append(
                     Map(
                         id=row.map_id,
+                        map_pool_map_version_id=row.map_pool_map_version_id,
                         folder_name=folder_name,
                         ranked=row.ranked,
                         weight=row.weight,
@@ -170,7 +199,7 @@ async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
                     map_type = params["type"]
                     if map_type == "neroxis":
                         map_list.append(
-                            NeroxisGeneratedMap.of(params, row.weight)
+                            NeroxisGeneratedMap.of(params, row.weight, row.map_pool_map_version_id)
                         )
                     else:
                         self._logger.warning(
@@ -197,9 +226,13 @@ async def fetch_matchmaker_queues(self, conn):
                 matchmaker_queue.c.technical_name,
                 matchmaker_queue.c.team_size,
                 matchmaker_queue.c.params,
+                matchmaker_queue_map_pool.c.id.label("matchmaker_queue_map_pool_id"),
                 matchmaker_queue_map_pool.c.map_pool_id,
                 matchmaker_queue_map_pool.c.min_rating,
                 matchmaker_queue_map_pool.c.max_rating,
+                matchmaker_queue_map_pool.c.veto_tokens_per_player,
+                matchmaker_queue_map_pool.c.max_tokens_per_map,
+                matchmaker_queue_map_pool.c.minimum_maps_after_veto,
                 game_featuredMods.c.gamemod,
                 leaderboard.c.technical_name.label("rating_type")
             )
@@ -228,9 +261,13 @@ async def fetch_matchmaker_queues(self, conn):
                 info["team_size"] = row.team_size
                 info["params"] = json.loads(row.params) if row.params else None
                 info["map_pools"].append((
+                    row.matchmaker_queue_map_pool_id,
                     row.map_pool_id,
                     row.min_rating,
-                    row.max_rating
+                    row.max_rating,
+                    row.veto_tokens_per_player,
+                    row.max_tokens_per_map,
+                    row.minimum_maps_after_veto
                 ))
             except Exception:
                 self._logger.warning(
@@ -532,10 +569,25 @@ def get_displayed_rating(player: Player) -> float:
             )
             rating = func(ratings)
 
-            pool = queue.get_map_pool_for_rating(rating)
-            if not pool:
+            map_pool = queue.get_map_pool_for_rating(rating)
+            if not map_pool:
                 raise RuntimeError(f"No map pool available for rating {rating}!")
-            game_map = pool.choose_map(played_map_ids)
+
+            self._logger.debug(
+                "______queue.map_pools[map_pool.id]________________: %s",
+                queue.map_pools[map_pool.id],
+            )
+            initial_weights = self.veto_service.generate_initial_weights_for_match(
+                all_players,
+                queue.map_pools[map_pool.id],
+            )
+            self._logger.debug(
+                "______initial_weights________________: %s",
+                initial_weights,
+            )
+            game_map = map_pool.choose_map(played_map_ids, initial_weights)
+
+            self._logger.debug("______game_map________________: %s", game_map)
 
             game = self.game_service.create_game(
                 game_class=LadderGame,
@@ -587,7 +639,8 @@ def make_game_options(player: Player) -> GameLaunchOptions:
                     game_options=game_options,
                     team=game.get_player_option(player.id, "Team"),
                     faction=game.get_player_option(player.id, "Faction"),
-                    map_position=game.get_player_option(player.id, "StartSpot")
+                    map_position=game.get_player_option(player.id, "StartSpot"),
+                    map_pool_map_version_id=game_map.map_pool_map_version_id
                 )
 
             await self.launch_match(game, host, all_guests, make_game_options)