AAR added

Author: karel26

plugins/competitive/listener.py

@@ -70,6 +70,21 @@ def get_squadron(self, side: Side) -> Optional[Squadron]:
         # noinspection PyUnresolvedReferences
         return next((x.squadron for x in self.alive.get(side, []) if x.squadron), None)
 
+    def to_dict(self) -> dict:
+        return {
+            'match_id': self.match_id,
+            'started': self.started.isoformat() if self.started else None,
+            'finished': self.finished.isoformat() if self.finished else None,
+            'winner': self.winner.name if self.winner else None,
+            'alive': {
+                Side.BLUE.name: [p.ucid for p in self.alive.get(Side.BLUE, [])],
+                Side.RED.name: [p.ucid for p in self.alive.get(Side.RED, [])]
+            },
+            'log': {
+                x[0].isoformat(): x[1] for x in self.log
+            }
+        }
+
 
 class CompetitiveListener(EventListener["Competitive"]):
 
@@ -461,8 +476,8 @@ async def onMatchFinished(self, server: Server, data: dict) -> None:
         # restart the mission if configured
         config = self.get_config(server)
         if config.get('end_mission', False):
-            if data['winner'] in ['RED', 'BLUE']:
-                side = data['winner'].lower()
+            if data['winner'] in ['red', 'blue']:
+                side = data['winner']
             else:
                 side = 'none'  # it's a draw, needs to be different from a server shutdown
             await server.send_to_dcs({
@@ -509,7 +524,5 @@ async def check_matches(self):
 
                 asyncio.create_task(self.bot.bus.send_to_node({
                     "command": "onMatchFinished",
-                    "match_id": match.match_id,
-                    "winner": winner.name,
                     "server_name": server.name
-                }))
+                } | match.to_dict()))

plugins/competitive/reports.py

@@ -2,13 +2,17 @@
 import numpy as np
 
 from core import report
+from datetime import datetime, timezone
 from matplotlib import cm
 from psycopg.rows import dict_row
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 from ..userstats.filter import StatisticsFilter, CampaignFilter
 from ..userstats.highscore import compute_font_size
 
+if TYPE_CHECKING:
+    from plugins.competitive.listener import Match
+
 
 class HighscoreTrueSkill(report.GraphElement):
 
@@ -71,3 +75,15 @@ async def render(self, interaction: discord.Interaction, limit: int, flt: Statis
                     self.axes.set_xticks([])
                     self.axes.set_yticks([])
                     self.axes.text(0, 0, 'No data available.', ha='center', va='center', rotation=45, size=15)
+
+
+class MatchAAR(report.EmbedElement):
+
+    async def render(self, match: dict):
+        times = []
+        logs = []
+        for time, log in match['log']:
+            times.append(datetime.fromisoformat(time).replace(tzinfo=timezone.utc))
+            logs.append(log)
+        self.add_field(name="Time", value="\n".join([f"<t:{int(t.timestamp())}:T>" for t in times]))
+        self.add_field(name="Log", value="\n".join(logs))

plugins/tournament/listener.py

@@ -2,8 +2,7 @@
 import discord
 import re
 
-from core import EventListener, event, Server, utils, get_translation, Coalition, DataObjectFactory, PersistentReport, \
-    Player
+from core import EventListener, event, Server, utils, get_translation, Coalition, DataObjectFactory, Player, Report
 from datetime import datetime, timedelta
 from psycopg.errors import UniqueViolation
 from psycopg.types.json import Json
@@ -90,17 +89,20 @@ async def cleanup(self, server: Server):
         await server.shutdown()
         self.plugin.reset_serversettings(server)
 
-    async def render_highscore(self, server: Server):
+    async def render_aar(self, server: Server, match: dict):
         config = self.get_config(server)
         channel = self.bot.get_channel(config.get('channels', {}).get('results', -1))
         if not channel:
             return
 
         tournament = self.tournaments.get(server.name)
-        report = PersistentReport(self.bot, self.plugin_name, 'highscore.json',
-                                  embed_name=f"tournament_{tournament['tournament_id']}_highscore",
-                                  channel_id=channel.id)
-        await report.render(interaction=None, server_name=None, flt=CampaignFilter(period=tournament['name']))
+        report = Report(self.bot, self.plugin_name, 'aar.json')
+        env = await report.render(server_name=None, flt=CampaignFilter(period=tournament['name']), match=match)
+        try:
+            await channel.send(embed=env.embed, file=discord.File(env.buffer, filename='aar.png'))
+        finally:
+            if env.buffer:
+                env.buffer.close()
 
     async def processEvent(self, name: str, server: Server, data: dict) -> None:
         try:
@@ -113,6 +115,7 @@ async def processEvent(self, name: str, server: Server, data: dict) -> None:
     async def registerDCSServer(self, server: Server, data: dict) -> None:
         tournament_id = await self.get_active_tournament(server)
         if not tournament_id:
+            self.log.debug(f"registerDCSServer: No active tournament for {server.name}.")
             self.tournaments.pop(server.name, None)
             return
 
@@ -178,8 +181,10 @@ async def countdown_with_warnings(self, server: Server, delayed_start: int):
     async def onSimulationResume(self, server: Server, data: dict) -> None:
         config = self.get_config(server)
         if 'delayed_start' in config:
+            self.log.debug(f"onSimulationResume: Delayed start for {server.name} is set to {config['delayed_start']} seconds.")
             self.tasks[server.name] = asyncio.create_task(self.countdown_with_warnings(server, config['delayed_start']))
         else:
+            self.log.debug(f"onSimulationResume: Delayed start for {server.name} is not set.")
             self.round_started[server.name] = True
 
     async def disqualify(self, server: Server, player: Player, reason: str) -> None:
@@ -403,7 +408,7 @@ async def check_tournament_finished(self, tournament_id: int) -> bool:
 
     @event(name="onMatchFinished")
     async def onMatchFinished(self, server: Server, data: dict) -> None:
-        winner = data['winner'].lower()
+        winner = data['winner']
         match_id = await self.get_active_match(server)
         if self.tasks.get(server.name):
             self.tasks.pop(server.name).cancel()
@@ -442,8 +447,8 @@ async def onMatchFinished(self, server: Server, data: dict) -> None:
         # pause the server
         asyncio.create_task(server.current_mission.pause())
 
-        # update the highscore
-        asyncio.create_task(self.render_highscore(server))
+        # render an AAR
+        asyncio.create_task(self.render_aar(server, data))
 
         # check if the match is finished
         await self.check_match_finished(server, match_id)

plugins/tournament/reports/highscore.json plugins/tournament/reports/aar.jsonplugins/tournament/reports/highscore.json renamed to plugins/tournament/reports/aar.json

@@ -8,6 +8,9 @@
     }
   ],
   "elements": [
+    {
+      "class": "plugins.competitive.reports.MatchAAR"
+    },
     {
       "type": "Graph",
       "params": {