beta

server/ladder_service/ladder_service.py

@@ -33,6 +33,7 @@
 from server.decorators import with_logger
 from server.exceptions import DisabledError
 from server.game_service import GameService
+from server.player_service import PlayerService
 from server.games import InitMode, LadderGame
 from server.games.ladder_game import GameClosedError
 from server.ladder_service.game_name import game_name
@@ -59,11 +60,13 @@ def __init__(
         self,
         database: FAFDatabase,
         game_service: GameService,
+        player_service: PlayerService,
         violation_service: ViolationService,
     ):
         self._db = database
         self._informed_players: set[Player] = set()
         self.game_service = game_service
+        self.player_service = player_service
         self.queues = {}
         self.violation_service = violation_service
 
@@ -75,6 +78,7 @@ async def initialize(self) -> None:
         self._update_cron = aiocron.crontab("*/10 * * * *", func=self.update_data)
 
     async def update_data(self) -> None:
+        prev_pools_veto_data = self.get_pools_veto_data()
         async with self._db.acquire() as conn:
             map_pool_maps = await self.fetch_map_pools(conn)
             db_queues = await self.fetch_matchmaker_queues(conn)
@@ -122,6 +126,10 @@ async def update_data(self) -> None:
             if queue_name not in db_queues:
                 self.queues[queue_name].shutdown()
                 del self.queues[queue_name]
+        current_pools_veto_data = self.get_pools_veto_data()
+        if (current_pools_veto_data != prev_pools_veto_data):
+            for player in self.player_service.all_players:
+                await player.update_vetoes(current_pools_veto_data)
 
     async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
         result = await conn.execute(
@@ -164,6 +172,7 @@ async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
                 try:
                     params = json.loads(row.map_params)
                     map_type = params["type"]
+                    params.map_pool_map_version_id = row.map_pool_map_version_id
                     if map_type == "neroxis":
                         map_list.append(
                             NeroxisGeneratedMap.of(params, row.weight)
@@ -538,19 +547,17 @@ def get_displayed_rating(player: Player) -> float:
             pool, _, _, veto_tokens_per_player, max_tokens_per_map, minimum_maps_after_veto = queue.map_pools[pool.id]
 
             vetoesMap = defaultdict(int)
-            tokensTotalPerPlayer = defaultdict(int)
 
             for (id, map) in pool.maps.items():
                 for player in all_players:
                     vetoesMap[map.map_pool_map_version_id] += player.vetoes.get(map.map_pool_map_version_id, 0)
-                    tokensTotalPerPlayer[player.id] += player.vetoes.get(map.map_pool_map_version_id, 0)
-
-            for player in all_players:
-                if (tokensTotalPerPlayer[player.id] > veto_tokens_per_player):
-                    raise RuntimeError(f"Player {player.id} has too many vetoes!")
 
             if (max_tokens_per_map == 0):
                 max_tokens_per_map = self.calculate_dynamic_tokens_per_map(minimum_maps_after_veto, vetoesMap.values())
+                if (max_tokens_per_map == 0):
+                    self._logger.error("calculate_dynamic_tokens_per_map received impossible vetoes setup, all vetoes cancelled for a match")
+                    vetoesMap = {}
+                    max_tokens_per_map = 1
 
             game_map = pool.choose_map(played_map_ids, vetoesMap, max_tokens_per_map)
 
@@ -720,8 +727,15 @@ def calculate_dynamic_tokens_per_map(self, M: float, tokens: list[int]) -> float
             if (result <= upperLimit):
                 return result
 
-        raise Exception("Failed to calculate dynamic tokens per map: impossible vetoes setup")
+        return 0
 
+    def get_pools_veto_data(self) -> list[tuple[list[int], int, int]]:
+        result = []
+        for queue in self.queues.values():
+            for map_pool, min_rating, max_rating, veto_tokens_per_player, max_tokens_per_map, minimum_maps_after_veto in queue.map_pools.values():
+                result.append(([map.map_pool_map_version_id for map in map_pool.maps.values()], veto_tokens_per_player, max_tokens_per_map))
+        return result
+
     async def get_game_history(
         self,
         players: list[Player],

server/lobbyconnection.py

@@ -1317,7 +1317,7 @@ async def command_set_party_factions(self, message):
 
     async def command_set_player_vetoes(self, message):
         converted =  {v['map_pool_map_version_id']: v['veto_tokens_applied'] for v in message["vetoes"]}
-        self.player.vetoes = converted
+        await self.player.update_vetoes(self.ladder_service.get_pools_veto_data(), converted)
 
     async def send_warning(self, message: str, fatal: bool = False):
         """

server/matchmaker/map_pool.py

@@ -57,7 +57,7 @@ def choose_map(self, played_map_ids: Iterable[int] = (), vetoesMap = None, max_t
         least_common_ids = {id_ for id_, _ in least_common}     
 
         #multiply weight by 2 if map is least common and not vetoed by anyone
-        mapList = list((map.map_pool_map_version_id, map, 2 if (map.id in least_common_ids) and (vetoesMap.get(map.map_pool_map_version_id) == 0) else 1) for id, map in self.maps.items())
+        mapList = list((map.map_pool_map_version_id, map, 2 if (map.id in least_common_ids) and (vetoesMap.get(map.map_pool_map_version_id,0) == 0) else 1) for id, map in self.maps.items())
 
         weights = [max(0, (1 - vetoesMap.get(id, 0) / max_tokens_per_map) * map.weight * least_common_multiplier) for id, map, least_common_multiplier in mapList]
         map = random.choices(mapList, weights=weights, k=1)[0][1]

server/players.py

@@ -98,10 +98,36 @@ def vetoes(self) -> dict[int, int]:
     def vetoes(self, value: dict[int, int]) -> None:
         if not isinstance(value, dict):
             raise ValueError("Vetoes must be a dictionary")
-        if not all(isinstance(key, int) and isinstance(val, int) for key, val in value.items()):
-            raise ValueError("Vetoes dictionary must contain only integer keys and values")
+        if not all(isinstance(key, int) and isinstance(val, int) and val >= 0 for key, val in value.items()):
+            raise ValueError("Incorrect vetoes dictonary")
         self._vetoes = value            
 
+    async def update_vetoes(self, pools_vetodata: list[tuple[list[int], int, int]], current: dict = None) -> None:
+        if current is None:
+            current = self.vetoes
+        fixedVetoes = {}
+        vetoDatas = [] 
+        for (map_pool_map_version_ids, veto_tokens_per_player, max_tokens_per_map) in pools_vetodata:
+            sum = 0
+            for id in map_pool_map_version_ids:
+                new_tokens_applied = max(current.get(id, 0),0)
+                if (sum + new_tokens_applied > veto_tokens_per_player or (max_tokens_per_map > 0 and new_tokens_applied > max_tokens_per_map)):
+                    new_tokens_applied = min(veto_tokens_per_player - sum, max_tokens_per_map)
+                if (new_tokens_applied == 0):
+                    continue
+                vetoDatas.append({"map_pool_map_version_id": id, "veto_tokens_applied": new_tokens_applied})
+                fixedVetoes[id] = new_tokens_applied
+                sum += new_tokens_applied
+        if fixedVetoes == self.vetoes == current:
+            return
+        self.vetoes = fixedVetoes
+        if self.lobby_connection is None:
+            return
+        await self.lobby_connection.send({
+            "command": "vetoes_changed",
+            "vetoesData": vetoDatas
+        })
+
     def power(self) -> int:
         """An artifact of the old permission system. The client still uses this
         number to determine if a player gets a special category in the user list

server/types.py

@@ -94,8 +94,10 @@ def of(cls, params: dict, weight: int = 1):
             raise Exception("spawns is not a multiple of 2")
 
         version = params["version"]
+        map_pool_map_version_id = params["map_pool_map_version_id"]
         return cls(
             cls._get_id(version, spawns, map_size_pixels),
+            map_pool_map_version_id,
             version,
             spawns,
             map_size_pixels,