Tournament: remove_on_death added to remove planes permanently from a match

Author: karel26

core/mizfile.py

@@ -647,7 +647,7 @@ def check_where(reference: dict, config: Union[list, str], debug: bool, **kwargs
 
         if isinstance(config, list):
             for cfg in config:
-                self.modify(cfg)
+                self.modify(cfg, **kwargs)
             return
 
         # enable debug logging

plugins/tournament/README.md

@@ -40,6 +40,7 @@ DEFAULT:
   time_to_choose: 600       # The time squadrons have to choose their customizations for the next round.
   sudden_death: false       # true: add one decisive round after the configured rounds were played if no winner was found. false: wait until the best out of X is reached.
   balance_multiplier: true  # true: use a sophisticated multiplier for credit points, based on the Trueskill™️ difference
+  remove_on_death: .*       # optional: if set, any unit name that matches this regular expression will result in the removal of this unit in the next rounds of the same match
   presets:
     file: presets_tournament.yaml
     initial:                # presets that have to be applied to any mission
@@ -65,6 +66,9 @@ DEFAULT:
 > The system is based on an "upset bonus system" which allows multipliers between 0.5 and 2.5, depending on the
 > situation.
 
+> [!IMPORTANT]
+> The remove_on_death needs you to have single unit groups in your mission.
+
 > [!WARNING]
 > The streamer channel above will receive all information about what's going on in your match. 
 > You do NOT want any of the participating parties to have access to this channel!

plugins/tournament/commands.py

@@ -1217,13 +1217,22 @@ async def prepare_mission(self, server: Server, match_id: int, mission_id: Optio
             async with conn.transaction():
                 # apply the squadron presets
                 for side in ['blue', 'red']:
+                    # apply persistent presets
                     async for row in await conn.execute(f"""
-                        SELECT preset, num FROM tm_choices c 
+                        SELECT preset, config FROM tm_persistent_choices c
+                        JOIN tm_matches m ON c.match_id = m.match_id AND c.squadron_id = m.squadron_{side}
+                        WHERE m.match_id = %s 
+                    """, (match_id,)):
+                        self.log.debug(f"Applying persistent preset for side {side}: {row[0]} ...")
+                        miz.apply_preset(all_presets[row[0]], side=side, **row[1])
+                    # apply choices
+                    async for row in await conn.execute(f"""
+                        SELECT preset, config FROM tm_choices c 
                         JOIN tm_matches m ON c.match_id = m.match_id AND c.squadron_id = m.squadron_{side}
                         WHERE m.match_id = %(match_id)s AND m.choices_{side}_ack = TRUE
                     """, {"match_id": match_id}):
                         self.log.debug(f"Applying custom preset for side {side}: {row[0]} ...")
-                        miz.apply_preset(all_presets[row[0]], side=side.upper(), num=row[1])
+                        miz.apply_preset(all_presets[row[0]], side=side.upper(), **row[1])
 
                 # delete the choices from the database and update the acknoledgement
                 await conn.execute("DELETE FROM tm_choices WHERE match_id = %s", (match_id,))
@@ -1329,7 +1338,7 @@ async def start(self, interaction: discord.Interaction, tournament_id: int, matc
                         channel = self.bot.get_channel(channels[side])
                         await channel.send(_("You can now use {} to chose your customizations!\n"
                                              "If you do not want to change anything, "
-                                             "please run it and say 'No Change'").format(
+                                             "please run it and say 'Skip this round'").format(
                             (await utils.get_command(self.bot, group=self.match.name,
                                                      name=self.customize.name)).mention))
                     else:
@@ -1357,7 +1366,11 @@ async def start(self, interaction: discord.Interaction, tournament_id: int, matc
         # Starting the server up again
         messages.append(_("Starting server {} ...").format(match['server_name']))
         await msg.edit(content='\n'.join(messages))
-        await server.startup(modify_mission=False, use_orig=False)
+        try:
+            await server.startup(modify_mission=False, use_orig=False)
+        except (TimeoutError, asyncio.TimeoutError):
+            await interaction.followup.send(_("Error during starting the server: Timeout."), ephemeral=True)
+            return
         # Check if we need to forward Tacview
         results = config.get('channels', {}).get('results', -1)
         if results > 0:
@@ -1563,7 +1576,8 @@ async def customize(self, interaction: discord.Interaction):
                     break
                 else:
                     await interaction.followup.send(_("{} has to be used in the respective coalition channel.").format(
-                        (await utils.get_command(self.bot, group=self.match.name, name=self.customize.name)).mention))
+                        (await utils.get_command(self.bot, group=self.match.name, name=self.customize.name)).mention),
+                        ephemeral=True)
                     return
 
         # check if a match is running
@@ -1598,8 +1612,7 @@ async def customize(self, interaction: discord.Interaction):
                     ephemeral=True)):
                 await interaction.followup.send(
                     _("Your choices were saved.\n"
-                      "If you want them to be applied to the next round, press 'Confirm & Buy'."),
-                    ephemeral=ephemeral)
+                      "If you want them to be applied to the next round, press 'Confirm & Buy'."))
                 return
 
             async with self.apool.connection() as conn:
@@ -1620,10 +1633,13 @@ async def customize(self, interaction: discord.Interaction):
                             AND match_id = %(match_id)s
                     """, {"match_id": match_id, "squadron_id": squadron_id})
             if view.acknowledged is True:
-                await interaction.followup.send(_("Thanks, your selection will now be applied."), ephemeral=True)
+                embed = await view.render()
+                embed.description = embed.title
+                embed.title = _("Your selection will now be applied.")
+                embed.set_footer(text=None)
+                await interaction.followup.send(embed=embed, ephemeral=True)
             else:
-                await interaction.followup.send(_("You decided to not buy any customizations in this round."),
-                                                ephemeral=True)
+                await interaction.followup.send(_("You decided to not buy any customizations in this round."))
         finally:
             try:
                 await msg.delete()

plugins/tournament/db/tables.sql

@@ -60,10 +60,18 @@ CREATE TABLE tm_choices (
     match_id INTEGER,
     squadron_id INTEGER,
     preset TEXT NOT NULL,
-    num INTEGER NOT NULL,
+    config JSON,
     PRIMARY KEY (match_id, squadron_id, preset),
     FOREIGN KEY (match_id) REFERENCES tm_matches(match_id) ON DELETE CASCADE
 );
+CREATE TABLE tm_persistent_choices (
+    choice_id SERIAL PRIMARY KEY,
+    match_id INTEGER,
+    squadron_id INTEGER,
+    preset TEXT NOT NULL,
+    config JSON,
+    FOREIGN KEY (match_id) REFERENCES tm_matches(match_id) ON DELETE CASCADE
+);
 CREATE TABLE tm_tickets (
     tournament_id INTEGER,
     squadron_id INTEGER,

plugins/tournament/db/update_v3.6.sql

@@ -0,0 +1,10 @@
+CREATE TABLE tm_persistent_choices (
+    choice_id SERIAL PRIMARY KEY,
+    match_id INTEGER,
+    squadron_id INTEGER,
+    preset TEXT NOT NULL,
+    config JSON,
+    FOREIGN KEY (match_id) REFERENCES tm_matches(match_id) ON DELETE CASCADE
+);
+ALTER TABLE tm_choices DROP COLUMN num;
+ALTER TABLE tm_choices ADD COLUMN config JSON;

plugins/tournament/listener.py

@@ -1,10 +1,12 @@
 import asyncio
 import discord
+import re
 
 from core import EventListener, event, Server, utils, get_translation, Coalition, DataObjectFactory, PersistentReport, \
     Player
 from datetime import datetime, timedelta
 from psycopg.errors import UniqueViolation
+from psycopg.types.json import Json
 from trueskill import Rating
 from typing import TYPE_CHECKING, Optional
 
@@ -35,6 +37,7 @@ def __init__(self, plugin: "Tournament"):
         self.ratings: dict[int, Rating] = {}
         self.squadron_credits: dict[int, int] = {}
         self.round_started: dict[str, bool] = {}
+        self.tasks: dict[str, asyncio.Task] = {}
 
     async def audit(self, server: Server, message: str):
         config = self.get_config(server)
@@ -173,7 +176,7 @@ 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:
-            asyncio.create_task(self.countdown_with_warnings(server, config['delayed_start']))
+            self.tasks[server.name] = asyncio.create_task(self.countdown_with_warnings(server, config['delayed_start']))
         else:
             self.round_started[server.name] = True
 
@@ -241,20 +244,23 @@ async def onMissionEvent(self, server: Server, data: dict) -> None:
             else:
                 player = server.get_player(name=initiator['name'])
                 await server.kick(player, "All seats are taken, you are not allowed to join anymore!")
+
         elif data['eventName'] == 'S_EVENT_SHOT':
             initiator = server.get_player(name=data['initiator']['name'])
             target = server.get_player(name=data['target']['name'])
             if target:
                 asyncio.create_task(self.inform_streamer(server, _("{} player {} shot an {} at {} player {}").format(
                     initiator.coalition.value.title(), initiator.display_name, data['weapon']['name'],
                     target.coalition.value, target.display_name), coalition=initiator.coalition))
+
         elif data['eventName'] == 'S_EVENT_HIT':
             initiator = server.get_player(name=data['initiator']['name'])
             target = server.get_player(name=data['target']['name'])
             if target:
                 asyncio.create_task(self.inform_streamer(server, _("{} player {} hit {} player {} with an {}").format(
                     initiator.coalition.value.title(), initiator.display_name, target.coalition.value,
                     target.display_name, data['weapon']['name']), coalition=initiator.coalition))
+
         elif data['eventName'] == 'S_EVENT_PLAYER_LEAVE_UNIT':
             if not data['initiator']:
                 return
@@ -263,6 +269,24 @@ async def onMissionEvent(self, server: Server, data: dict) -> None:
                 asyncio.create_task(self.inform_streamer(server, _("{} player {} is out!").format(
                     player.coalition.value.title(), player.display_name), coalition=player.coalition))
 
+        elif data['eventName'] in ['S_EVENT_UNIT_LOST']:
+            config = self.get_config(server)
+            pattern = config.get('remove_on_death')
+            initiator = server.get_player(name=data['initiator']['name'])
+            if pattern and re.match(pattern, initiator.unit_name):
+                match_id = await self.get_active_match(server)
+                match = await self.plugin.get_match(match_id)
+                squadron_id = match[f'squadron_{initiator.coalition.value}']
+                async with self.apool.connection() as conn:
+                    async with conn.transaction():
+                        await conn.execute("""
+                            INSERT INTO tm_persistent_choices (match_id, squadron_id, preset, config)
+                            VALUES (%s, %s, %s, %s)
+                        """, (match_id, squadron_id, 'disable_group', Json({"group": initiator.group_name})))
+                asyncio.create_task(server.sendPopupMessage(
+                    initiator.coalition, _("Unit {} is lost an will be permanently removed from the match.").format(
+                        initiator.unit_name)))
+
     async def calculate_balance(self, server: Server, winner: str, winner_squadron: Squadron,
                                 loser_squadron: Squadron) -> None:
         winner_coalition = Coalition.RED if winner == 'red' else Coalition.BLUE
@@ -370,6 +394,8 @@ async def check_tournament_finished(self, tournament_id: int) -> bool:
     async def onMatchFinished(self, server: Server, data: dict) -> None:
         winner = data['winner'].lower()
         match_id = await self.get_active_match(server)
+        if self.tasks.get(server.name):
+            self.tasks.pop(server.name).cancel()
 
         # do we have a winner?
         if winner in ['blue', 'red']:

plugins/tournament/schemas/tournament_schema.yaml

@@ -18,6 +18,7 @@ schema;element_schema:
     auto_join: {type: bool, nullable: false}
     delayed_start: {type: int, nullable: false, range: {min: 0}}
     time_to_choose: {type: int, nullable: false, range: {min: 300, max: 900}}
+    remove_on_death: {type: str, nullable: false, range: {min: 1}}
     sudden_death: {type: bool, nullable: false}
     balance_multiplier: {type: bool, nullable: false}
     presets:

plugins/tournament/version.py

@@ -1 +1 @@
-__version__ = "3.6"
+__version__ = "3.7"

plugins/tournament/view.py

@@ -2,6 +2,8 @@
 import numpy as np
 import re
 
+from psycopg.types.json import Json
+
 from core import get_translation, utils
 from discord import SelectOption
 from discord.ui import Select, Button, Modal, TextInput, View
@@ -179,13 +181,13 @@ async def get_tickets(self) -> dict[str, int]:
     async def render(self) -> discord.Embed:
         squadron = await self.plugin.get_squadron(self.match_id, self.squadron_id)
         embed = discord.Embed(colour=discord.Colour.blue(),
-                              title=_("You have {} credit points.").format(squadron.points))
+                              title=_("You have {} credit points left to spend.").format(squadron.points))
         embed.description = ("Here you can select the presets to change the upcoming mission to your request.\n"
                              "Please keep in mind, that you will have to pay credit points, "
                              "according to the requested presets price.")
         async with self.plugin.apool.connection() as conn:
             cursor = await conn.execute("""
-                SELECT preset, num FROM tm_choices WHERE match_id = %s AND squadron_id = %s
+                SELECT preset, config FROM tm_choices WHERE match_id = %s AND squadron_id = %s
             """, (self.match_id, self.squadron_id))
             already_selected = [x for x in await cursor.fetchall()]
         if not already_selected:
@@ -199,7 +201,7 @@ async def render(self) -> discord.Embed:
                 presets.append(preset)
                 cost = self.config['presets']['choices'][preset]['costs']
                 costs.append(cost)
-                number.append(choice[1])
+                number.append(choice[1]['num'])
             embed.add_field(name="Your selection", value="\n".join(presets))
             embed.add_field(name="Costs in Credits", value="\n".join([str(x) for x in costs]))
             embed.add_field(name="Count", value="\n".join([str(x) for x in number]))
@@ -277,9 +279,9 @@ async def add_choice(self, interaction: discord.Interaction):
             async with self.plugin.apool.connection() as conn:
                 async with conn.transaction():
                     await conn.execute("""
-                        INSERT INTO tm_choices (match_id, squadron_id, preset, num) 
+                        INSERT INTO tm_choices (match_id, squadron_id, preset, config) 
                         VALUES (%s, %s, %s, %s)
-                    """, (self.match_id, self.squadron_id, choice, num))
+                    """, (self.match_id, self.squadron_id, choice, Json({"num": num})))
                     if ticket_name:
                         # invalidate the ticket
                         await conn.execute("""
@@ -307,9 +309,9 @@ async def remove_choice(self, interaction: discord.Interaction):
                 cursor = await conn.execute("""
                     DELETE FROM tm_choices 
                     WHERE match_id = %s AND squadron_id = %s AND preset = %s
-                    RETURNING num
+                    RETURNING config
                 """, (self.match_id, self.squadron_id, choice))
-                num = (await cursor.fetchone())[0]
+                num = (await cursor.fetchone())[0]['num']
                 if ticket_name:
                     # return the ticket
                     await conn.execute("""