gametypes: better managing

All gametype information is now in one file

Author: em92

contrib/set_rating.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 import argparse
+
 from qllr.db import db_connect
 
 parser = argparse.ArgumentParser()

qllr/blueprints/scoreboard/methods.py

@@ -4,6 +4,7 @@
 
 from qllr.common import DATETIME_FORMAT, convert_timestamp_to_tuple
 from qllr.exceptions import MatchNotFound
+from qllr.gametypes import GAMETYPE_RULES
 from qllr.settings import USE_AVG_PERF
 
 
@@ -236,10 +237,13 @@ async def get_scoreboard(con: Connection, match_id: str):
     """
     weapons_available = await con.fetchval(query, match_id)
 
+    rules = GAMETYPE_RULES[summary["gt_short"]]
     return {
         "summary": summary,
         "player_stats": {"weapons": player_weapon_stats, "medals": player_medal_stats},
         "team_stats": {"overall": overall_stats},
         "weapons_available": weapons_available,
         "medals_available": medals_available,
+        "medals_in_scoreboard_mid": rules.medals_in_scoreboard_mid(),
+        "medals_in_scoreboard_right": rules.medals_in_scoreboard_right(),
     }

qllr/db.py

@@ -1,6 +1,6 @@
 import asyncio
-from collections.abc import MutableMapping
 from collections import OrderedDict
+from collections.abc import MutableMapping
 from typing import List
 from urllib.parse import urlparse
 

qllr/gametypes.py

@@ -0,0 +1,120 @@
+GAMETYPE_RULES = {}
+
+
+def detect_by_match_report(data):
+    for short, gt in GAMETYPE_RULES.items():
+        if gt.force_by_match_report(data):
+            return short
+
+    return data["game_meta"]["G"]
+
+
+class AbstractGametype:
+    def calculate_player_perf(self, player_data, time_factor):
+        raise NotImplementedError()  # pragma: nocover
+
+    def force_by_match_report(self, data):
+        return False
+
+    def override_min_player_count(self):
+        return None
+
+    def extra_factor(self, matches, wins, losses):
+        return 1
+
+    def medals_in_scoreboard_mid(self):
+        return []
+
+    def medals_in_scoreboard_right(self):
+        return []
+
+
+# gametype rules are defined below
+
+
+class GametypeAD(AbstractGametype):
+    def calc_player_perf(self, player_data, time_factor):
+        frags_count = int(player_data["scoreboard-kills"])
+        capture_count = int(player_data["medal-captures"])
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        return (damage_dealt / 100 + frags_count + capture_count) * time_factor
+
+    def medals_in_scoreboard_mid(self):
+        return ["captures", "defends"]
+
+
+class GametypeCA(AbstractGametype):
+    def calc_player_perf(self, player_data, time_factor):
+        frags_count = int(player_data["scoreboard-kills"])
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        return (damage_dealt / 100 + 0.25 * frags_count) * time_factor
+
+
+class GametypeCTF(AbstractGametype):
+    def calc_player_perf(self, player_data, time_factor):
+        score = int(player_data["scoreboard-score"])
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        damage_taken = int(player_data["scoreboard-destroyed"])
+        win = 1 if "win" in player_data else 0
+
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        return (
+            (damage_dealt / damage_taken * (score + damage_dealt / 20) * time_factor)
+            / 2.35
+            + win * 300,
+        )
+
+    def medals_in_scoreboard_mid(self):
+        return ["captures", "assists", "defends"]
+
+
+class GametypeFT(AbstractGametype):
+    def calc_player_perf(self, player_data, time_factor):
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        frags_count = int(player_data["scoreboard-kills"])
+        deaths_count = int(player_data["scoreboard-deaths"])
+        assists_count = int(player_data["medal-assists"])
+
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        return (
+            damage_dealt / 100 + 0.5 * (frags_count - deaths_count) + 2 * assists_count
+        ) * time_factor
+
+    def medals_in_scoreboard_mid(self):
+        return ["assists"]
+
+
+class GametypeTDM(AbstractGametype):
+    def calc_player_perf(self, player_data, time_factor):
+        damage_dealt = int(player_data["scoreboard-pushes"])
+        frags_count = int(player_data["scoreboard-kills"])
+        deaths_count = int(player_data["scoreboard-deaths"])
+        damage_taken = int(player_data["scoreboard-destroyed"])
+
+        return (
+            0.5 * (frags_count - deaths_count)
+            + 0.004 * (damage_dealt - damage_taken)
+            + 0.003 * damage_dealt
+        ) * time_factor
+
+    def extra_factor(self, matches, wins, losses):
+        return 1 + (0.15 * (wins / matches - losses / matches))
+
+    def medals_in_scoreboard_right(self):
+        return ["excellent", "impressive"]
+
+
+class GametypeTDM2V2(GametypeTDM):
+    def force_by_match_report(self, data):
+        return data["game_meta"]["G"] == "tdm" and len(data["players"]) == 4
+
+    def override_min_player_count(self):
+        return 4
+
+
+GAMETYPE_RULES["ad"] = GametypeAD()
+GAMETYPE_RULES["ca"] = GametypeCA()
+GAMETYPE_RULES["ctf"] = GametypeCTF()
+GAMETYPE_RULES["ft"] = GametypeFT()
+GAMETYPE_RULES["tdm"] = GametypeTDM()
+GAMETYPE_RULES["tdm2v2"] = GametypeTDM2V2()

qllr/settings.py

@@ -2,6 +2,8 @@
 from starlette.datastructures import URL, CommaSeparatedStrings
 from trueskill import MU, SIGMA
 
+from .gametypes import GAMETYPE_RULES
+
 config = Config(".env")
 
 SUPPORTED_GAMETYPES = ("ad", "ca", "ctf", "ft", "tdm", "tdm2v2")
@@ -34,6 +36,5 @@
     )
 
 INITIAL_R2_VALUE = INITIAL_R1_MEAN.copy()
-MIN_PLAYER_COUNT_IN_MATCH_TO_RATE["tdm2v2"] = 4
 
 AVG_PERF_GAMETYPES = [gt for gt in SUPPORTED_GAMETYPES if USE_AVG_PERF[gt]]

qllr/submission.py

@@ -9,6 +9,7 @@
 from .common import log_exception
 from .db import cache, db_connect, get_db_pool
 from .exceptions import *
+from .gametypes import GAMETYPE_RULES, detect_by_match_report
 from .settings import (
     INITIAL_R1_DEVIATION,
     INITIAL_R1_MEAN,
@@ -89,10 +90,6 @@ def parse_stats_submission(body):
     return {"game_meta": game_meta, "players": players, "teams": teams}
 
 
-def is_tdm2v2(data):
-    return data["game_meta"]["G"] == "tdm" and len(data["players"]) == 4
-
-
 async def get_factory_id(con: Connection, factory: str):
     stmt = await con.prepare(
         "SELECT factory_id FROM factories WHERE factory_short = $1"
@@ -129,44 +126,13 @@ def count_player_match_perf(gametype, player_data, match_duration):
             player_data[k] = 0
 
     alive_time = int(player_data["alivetime"])
-    score = int(player_data["scoreboard-score"])
-    damage_dealt = int(player_data["scoreboard-pushes"])
-    damage_taken = int(player_data["scoreboard-destroyed"])
-    frags_count = int(player_data["scoreboard-kills"])
-    deaths_count = int(player_data["scoreboard-deaths"])
-    capture_count = int(player_data["medal-captures"])
-    defends_count = int(player_data["medal-defends"])
-    assists_count = int(player_data["medal-assists"])
-    win = 1 if "win" in player_data else 0
 
     if alive_time < match_duration / 2:
         return None
     else:
         time_factor = 1200.0 / alive_time
 
-    return {
-        "ad": (damage_dealt / 100 + frags_count + capture_count) * time_factor,
-        "ca": (damage_dealt / 100 + 0.25 * frags_count) * time_factor,
-        "ctf": (damage_dealt / damage_taken * (score + damage_dealt / 20) * time_factor)
-        / 2.35
-        + win * 300,
-        "ft": (
-            damage_dealt / 100 + 0.5 * (frags_count - deaths_count) + 2 * assists_count
-        )
-        * time_factor,
-        "tdm2v2": (
-            0.5 * (frags_count - deaths_count)
-            + 0.004 * (damage_dealt - damage_taken)
-            + 0.003 * damage_dealt
-        )
-        * time_factor,
-        "tdm": (
-            0.5 * (frags_count - deaths_count)
-            + 0.004 * (damage_dealt - damage_taken)
-            + 0.003 * damage_dealt
-        )
-        * time_factor,
-    }[gametype]
+    return GAMETYPE_RULES[gametype].calc_player_perf(player_data, time_factor)
 
 
 def count_multiple_players_match_perf(gametype, all_players_data, match_duration):
@@ -195,12 +161,6 @@ def count_multiple_players_match_perf(gametype, all_players_data, match_duration
 async def _calc_ratings_avg_perf(
     con: Connection, match_id: str, gametype_id: int, map_id: Optional[int] = None
 ):
-    def extra_factor(gametype, matches, wins, losses):
-        try:
-            return {"tdm": (1 + (0.15 * (wins / matches - losses / matches)))}[gametype]
-        except KeyError:
-            return 1
-
     if map_id is None:
         ratings_subquery = """
             SELECT steam_id, r2_value AS rating
@@ -279,7 +239,8 @@ def extra_factor(gametype, matches, wins, losses):
 
             row = await con.fetchrow(query, steam_id, gametype_id, match_id)
             gametype = [k for k, v in cache.GAMETYPE_IDS.items() if v == gametype_id][0]
-            new_rating = row[3] * extra_factor(gametype, row[0], row[1], row[2])
+            rules = GAMETYPE_RULES[gametype]
+            new_rating = row[3] * rules.extra_factor(row[0], row[1], row[2])
 
         result[steam_id] = {"old": old_rating, "new": new_rating, "team": team}
 
@@ -543,13 +504,10 @@ async def _submit_match(data):
         raise InvalidMatchReport("Match id not given")
 
     try:
-        gametype = data["game_meta"]["G"]
+        gametype = detect_by_match_report(data)
     except KeyError:
         raise InvalidMatchReport("Gametype not given")
 
-    if is_tdm2v2(data):
-        gametype = "tdm2v2"
-
     if gametype not in cache.GAMETYPE_IDS:
         raise InvalidMatchReport("Gametype not accepted: {}".format(gametype))
 

templates/scoreboard.html

@@ -46,20 +46,15 @@
     <th class="s s1">Score</th>
     <th class="s s1">Frags</th>
     <th class="s s1">Deaths</th>
-    {% if gametype in ("ctf", "ad") %}
-    <th class="s s1">Captures</th>
-    {% if gametype != "ad" %}
-    <th class="s s1">Assists</th>
-    {% endif %}
-    <th class="s s1">Defends</th>
-    {% endif %}
+    {% for m in medals_in_scoreboard_mid %}
+    <th class="s s1" style="text-transform: capitalize">{{ m }}</th>
+    {% endfor %}
     <th class="s s1">Damage Dealt</th>
     <th class="s s1">Damage Taken</th>
     <th class="s s1">Time</th>
-    {% if gametype == "tdm" %}
-    <th class="s s1">Excellent</th>
-    <th class="s s1">Impressive</th>
-    {% endif %}
+    {% for m in medals_in_scoreboard_right %}
+    <th class="s s1" style="text-transform: capitalize">{{ m }}</th>
+    {% endfor %}
     <th class="s s1">Old rating</th>
     <th class="s s1">New rating</th>
     <th class="s s1">Diff</th>
@@ -76,20 +71,15 @@
     <td class="s s1">{{ player['stats']['score'] }}</td>
     <td class="s s1">{{ player['stats']['frags'] }}</td>
     <td class="s s1">{{ player['stats']['deaths'] }}</td>
-    {% if gametype in ("ctf", "ad") %}
-    <td class="s s1">{{ medal( player, 'captures' ) }}</td>
-    {% if gametype != "ad" %}
-    <td class="s s1">{{ medal( player, 'assists' ) }}</td>
-    {% endif %}
-    <td class="s s1">{{ medal( player, 'defends' ) }}</td>
-    {% endif %}
+    {% for m in medals_in_scoreboard_mid %}
+    <td class="s s1">{{ medal(player, m) }}</td>
+    {% endfor %}
     <td class="s s1">{{ player['stats']['damage_dealt'] }}</td>
     <td class="s s1">{{ player['stats']['damage_taken'] }}</td>
     <td class="s s1">{{ player['stats']['alive_time'] | seconds_to_mmss }}</td>
-    {% if gametype == "tdm" %}
-    <td class="s s1">{{ medal( player, 'excellent' ) }}</td>
-    <td class="s s1">{{ medal( player, 'impressive' ) }}</td>
-    {% endif %}
+    {% for m in medals_in_scoreboard_right %}
+    <td class="s s1">{{ medal(player, m) }}</td>
+    {% endfor %}
     <td class="s s1">{{ rating( player['rating'], 'old' ) }}</td>
     <td class="s s1">{{ rating( player['rating'], 'new' ) }}</td>
     <td class="s s1">{{ rating_diff( player['rating'] ) }}</td>

tests/samples/scoreboard_sample02.json

@@ -1,4 +1,9 @@
 {
+    "medals_in_scoreboard_mid": [
+        "captures",
+        "defends"
+    ],
+    "medals_in_scoreboard_right": [],
     "medals_available": [
         "combokill",
         "defends",

tests/samples/scoreboard_sample03.json

@@ -1,4 +1,9 @@
 {
+    "medals_in_scoreboard_mid": [
+        "captures",
+        "defends"
+    ],
+    "medals_in_scoreboard_right": [],
     "medals_available": [
         "accuracy",
         "captures",

tests/samples/scoreboard_sample08.json

@@ -1,4 +1,9 @@
 {
+    "medals_in_scoreboard_mid": [],
+    "medals_in_scoreboard_right": [
+        "excellent",
+        "impressive"
+    ],
     "medals_available": [
         "combokill",
         "excellent",
@@ -471,4 +476,4 @@
         "rg",
         "pg"
     ]
-}
+}