Added name symbol validation.

cogs/slash_commands.py

@@ -50,7 +50,7 @@ class SlashCommands(commands.Cog):
         print("a")
 
     @app_commands.command(
-        name="domt5-pingme",
+        name="dom5-pingme",
         description="Signs you up to be pinged for a game. Run the command again to not get pinged anymore.",
     )
     async def pingme(self, interaction: discord.Interaction, name: str):

servermanager.py

@@ -8,17 +8,15 @@ load_dotenv()
 SERVER_PATH = os.getenv("SERVERPATH")
 
 
-def create_server(name, port, channel):
+def create_server(name: str, port: int, channel: int, command: str):
     if is_port_in_use(port):
         return "ERROR_PORT_IN_USE"
     os.mkdir("games/" + name)
-    # print(SERVER_PATH)
-    # print(server_command_builder(name, port, channel))
     game = Dom5game(name, channel, [], 0, {})
     game.to_json()
     try:
         p = subprocess.Popen(
-            server_command_builder(name, port),
+            command,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.STDOUT,
         )
@@ -38,7 +36,7 @@ def get_nations():
 
         era_match = re.match(r"-+ Era (\d+) -+", line)
         if era_match:
-            current_era = f"Era {era_match.group(1)}"
+            current_era = f"{era_match.group(1)}"
             nations[current_era] = {}
             continue
 
@@ -55,11 +53,12 @@ def get_nations():
 def server_command_builder(
     name: str,
     port: int,
-    era: int,
-    closed_slots: list[int] = [],
-    ai_slots: list[tuple[int, int]] = [],
+    era: int,  # 1 EA, 2 MA, 3 LA
+    ai_slots: list[
+        tuple[int, int]
+    ] = [],  # list of nations that will be ai tuple format: NationID, AI Level (1-6), 0 being closed
     client_start: bool = True,
-    teams: list[tuple[int, int, int]] = [],
+    teams: list[tuple[int, int, int]] = [],  # list of teams with format nation id,
     clustered_start: bool = False,
     team_game: bool = False,
     mapfile: str = "",
@@ -89,23 +88,54 @@ def server_command_builder(
     thrones: tuple[int, int, int] = (1, 1, 1),
     required_apoints: int = 0,
     cataclysm: int = 0,
+    vwrap: bool = True,
+    hwrap: bool = True,
 ):
+    available_nations = get_nations()
+
+    # TODO change < ranges to =<
     if (not ((random_map == 0) ^ (mapfile == ""))) or random_map not in {0, 10, 15, 20}:
         return "ERROR_MAP"
 
     if not (0 < era < 4):
         return "ERROR_ERA"
 
-    ai_indexes = [t[1] for t in ai_slots]
+    ai_indexes = [t[0] for t in ai_slots]
     if not (len(ai_indexes) == len(set(ai_indexes))):
         return "ERROR_AIS"
 
-    if bool(set(closed_slots) & set(ai_indexes)):
-        return "ERROR_CLOSED_AIS"
+        # if bool(set(closed_slots) & set(ai_indexes)):
+        # return "ERROR_CLOSED_AIS"
 
     if required_apoints == 0:
         required_apoints = thrones[0] + (2 * thrones[1]) + (3 * thrones[2]) - 1
 
+    if not (0 <= research_difficulty < 5):
+        return "ERROR_RESEARCH"
+    if not (4 < hof_size < 16):
+        return "ERROR_HOF"
+    if not (2 < global_slots < 10):
+        return "ERROR_GLOBALS"
+    if not (0 <= inde_strength <= 9):
+        return "ERROR_INDEP"
+    if not (0 <= magic_sites <= 75):
+        return "ERROR_MAGICSITES"
+    if not (1 <= event_rarity <= 2):
+        return "ERROR_EVENTS"
+    if not (50 <= richness <= 300):
+        return "ERROR_RICHNESS"
+    if not (50 <= recruitment <= 300):
+        return "ERROR_RECRUITMENT"
+    if not (50 <= resources <= 300):
+        return "ERROR_RESOURCES"
+    if not (50 <= supplies <= 300):
+        return "ERROR_SUPPLIES"
+    if not (1 <= start_prov <= 9):
+        return "ERROR_STARTPROV"
+    if not (0 <= story_events <= 2):
+        return "ERROR_STORYEVENTS"
+    if not (1 <= new_ai_lvl <= 6):
+        return "ERROR_NEWAIS"
     command = [
         SERVER_PATH,
         " -TS ",
@@ -115,11 +145,14 @@ def server_command_builder(
         " --statuspage ",
         os.getcwd() + "/games/" + name + "/turnstats.html",
         " --era ",
-        era,
+        str(era),
     ]
     if team_game:
         for team in teams:
-            # TODO Check valid inputs
+            # TODO: Can team have more than one disciple and pretender?
+            if team[0] not in available_nations[str(era)]:
+                return "ERROR_INVALID_NATION"
+
             command.append(
                 " --team " + str(team[0]) + " " + str(team[1]) + " " + str(team[2])
             )
@@ -132,8 +165,88 @@ def server_command_builder(
         command.append(" --cataclysm " + str(cataclysm))
     if conq_all:
         command.append(" --conqall")
+    if not research_difficulty == 2:
+        command.append(" --research " + str(research_difficulty))
+    if not random_start_research:
+        command.append(" --norandres")
+    if not hof_size == 10:
+        command.append(" --hof_size " + str(hof_size))
+    if not global_slots == 5:
+        command.append(" --globals " + str(global_slots))
+    if not inde_strength == 5:
+        command.append(" --indepstr " + str(inde_strength))
+    if not magic_sites == 40:
+        command.append(" --magisites " + str(magic_sites))
+    command.append(" --eventrarity " + str(event_rarity))
+    if not richness == 100:
+        command.append(" --richness " + str(richness))
+    if not resources == 100:
+        command.append(" --resources" + str(resources))
+    if not recruitment == 100:
+        command.append(" --recruitment" + str(recruitment))
+    if not supplies == 100:
+        command.append(" --supplies" + str(supplies))
+    if not masterpass == "":
+        command.append(" --masterpass " + masterpass)
+    # i am going insane
+    if not start_prov == 1:
+        command.append(" --startprov " + str(start_prov))
+    if renaming:
+        command.append(" --renaming")
+    if score_graphs:
+        command.append(" --scoregraphs")
+    if no_nation_info:
+        command.append(" --nonationinfo")
+    if no_cheat_det:
+        command.append(" --nocheatdet")
+    if no_artifact_rest:
+        command.append(" --noartrest")
+    if story_events == 1:
+        command.append(" --storyevents")
+    elif story_events == 2:
+        command.append(" --allstoryevents")
+    command.append(" --newailvl " + str(new_ai_lvl))
+    if no_new_ai:
+        command.append(" --nonewai")
+    if conq_all:
+        command.append(" --conqall")
+    command.append(
+        " --thrones " + str(thrones[0]) + " " + str(thrones[1]) + " " + str(thrones[2])
+    )
+    command.append(" --requiredap " + str(required_apoints))
+    if not cataclysm == 0:
+        command.append(" --cataclysm " + str(cataclysm))
+    if vwrap:
+        command.append(" --vwrap")
+    if not hwrap:
+        command.append(" --nohwrap")
+    if ai_slots:
+        added_ais = []
+        for ai in ai_slots:
+            if ai[0] not in available_nations[str(era)]:
+                return "ERROR_INVALID_NATION"
+            if ai[0] in added_ais:
+                return "ERROR_DUPLICATE_AI"
+            match ai[1]:
+                case 0:
+                    command.append(" --closed " + str(ai[0]))
+                case 1:
+                    command.append(" --easyai " + str(ai[0]))
+                case 2:
+                    command.append(" --normai " + str(ai[0]))
+                case 3:
+                    command.append(" --diffai " + str(ai[0]))
+                case 4:
+                    command.append(" --mightyai " + str(ai[0]))
+                case 5:
+                    command.append(" --masterai " + str(ai[0]))
+                case 6:
+                    command.append(" --impai " + str(ai[0]))
+                case _:
+                    return "ERROR_INVALID_AI"
+            added_ais.append(ai[0])
 
-    return command
+    return "".join(command)
 
 
 def is_port_in_use(port: int) -> bool:

webui.py

@@ -1,6 +1,10 @@
 from nicegui import ui
 from bot_instance import bot
+import re
 from dom5game import Dom5game
+import servermanager
+import os
+from dotenv import load_dotenv
 
 
 def create_ui():
@@ -11,8 +15,9 @@ def create_ui():
         rows.append({"Name": game.name, "Turn": game.turn})
 
     pages.add("/", lambda: main_page(rows))
-
-    ui.run(reload=False)
+    pages.add("/create", lambda: creator_page())
+    # ui.dark_mode().enable()
+    ui.run(reload=False, show=False)
 
 
 def main_page(rows):
@@ -29,3 +34,200 @@ def game_page(game_name: str):
         if game.players[player] not in {"AI", "Eliminated"}:
             rows.append({"Player": player, "Status": game.players[player]})
     ui.table(rows=rows, title=game_name)
+
+
+# hell
+def creator_page():
+    # Game Name
+    name = ui.input(
+        label="Game Name",
+        validation={
+            "Game with that name already exists": lambda value: not (
+                os.path.isdir("games/" + value)
+            ),
+            "Name contains an invalid symbol": lambda value: bool(
+                re.match("^[A-Za-z0-9_-]*$", value)
+            ),
+        },
+    )
+    # Port
+    load_dotenv()
+    port_min = int(os.getenv("PORT_MIN", 1024))
+    port_max = int(os.getenv("PORT_MAX", 65535))
+    port = ui.input(
+        label="Port",
+        validation={
+            f"Port must be between {str(port_min)} and {str(port_max)}": lambda value: value.isdigit()
+            and port_min <= int(value) <= port_max,
+            "Port in use": lambda value: value.isdigit()
+            and not servermanager.is_port_in_use(int(value)),
+        },
+    )
+    # Era + AI
+    # This sucks but idk how else to move the radio selector above the table
+    ai_slots = []
+    era_container = ui.row()
+    table_container = ui.column()
+    with era_container:
+        era = (
+            ui.radio({1: "Early Age", 2: "Middle Age", 3: "Late Age"})
+            .props("inline")
+            .on_value_change(
+                lambda e: create_ai_table(e.value, table_container, ai_slots)
+            )
+        )
+
+    # client_start = ui.checkbox("Allow clients to start the game")
+    checkbox_container = ui.row()
+    with checkbox_container:
+        team_game = ui.checkbox("Disciple Game")
+        clustered_start = ui.checkbox("Clustered Spawns (Disciple games only)")
+        random_start_research = ui.checkbox("Random Start Research")
+        score_graphs = ui.checkbox("Score Graphs")
+        renaming = ui.checkbox("Allow Renaming", value=True)
+        no_nation_info = ui.checkbox("No Info About Other Nations")
+        no_cheat_det = ui.checkbox("Disable Anticheat")
+        no_artifact_rest = ui.checkbox("Disable Artifact Forge Limit")
+        no_new_ai = ui.checkbox("Disable Becoming AI Controlled")
+        vwrap = ui.checkbox("North South Wrapping")
+        hwrap = ui.checkbox("East West Wrapping")
+    description_container = ui.row()
+    toggle_container = ui.row()
+    # TODO: Are these containers still needed?
+    with toggle_container:
+        event_rarity = ui.toggle({1: "Common", 2: "Rare"}, value=1)
+        random_map = ui.toggle([10, 15, 20], value=15)
+    with description_container:
+        ui.label("Event Rarity")
+        # TODO: Fix Padding
+        ui.label("Provinces per player:")
+    with ui.row():
+        ui.label("Gold Multiplier:").classes("w-36")
+        richness = ui.input(
+            validation={
+                "Value must be between 50 and 300": lambda value: value.isdigit()
+                and 50 <= int(value) <= 300,
+            },
+            value="100",
+        )
+    with ui.row():
+        ui.label("Resource Multiplier:").classes("w-36")
+        resources = ui.input(
+            validation={
+                "Value must be between 50 and 300": lambda value: value.isdigit()
+                and 50 <= int(value) <= 300,
+            },
+            value="100",
+        )
+    with ui.row():
+        ui.label("Recruitment Multiplier:").classes("w-36")
+        recruitment = ui.input(
+            validation={
+                "Value must be between 50 and 300": lambda value: value.isdigit()
+                and 50 <= int(value) <= 300,
+            },
+            value="100",
+        )
+    with ui.row():
+        ui.label("Supplies Multiplier:").classes("w-36")
+        supplies = ui.input(
+            validation={
+                "Value must be between 50 and 300": lambda value: value.isdigit()
+                and 50 <= int(value) <= 300,
+            },
+            value="100",
+        )
+
+    # TODO: REMOVE THIS it is just for testing
+    ui.button(
+        "Generate String",
+        on_click=lambda: print(
+            servermanager.server_command_builder(
+                name=name.value,
+                port=int(port.value),
+                era=int(era.value),
+                ai_slots=ai_slots,
+                random_map=int(random_map.value),
+                event_rarity=int(event_rarity.value),
+                hwrap=hwrap.value,
+                vwrap=vwrap.value,
+                no_new_ai=no_new_ai.value,
+                no_artifact_rest=no_artifact_rest.value,
+                no_cheat_det=no_cheat_det.value,
+                renaming=renaming.value,
+                score_graphs=score_graphs.value,
+                random_start_research=random_start_research.value,
+                clustered_start=clustered_start.value,
+                team_game=team_game.value,
+                no_nation_info=no_nation_info.value,
+                recruitment=int(recruitment.value),
+                resources=int(resources.value),
+                richness=int(richness.value),
+                supplies=int(supplies.value),
+            )
+        ),
+    )
+
+
+def create_ai_table(era, table_container, ai_slots):
+    # TODO: move this somewhere else
+    AI_LEVELS = [
+        "Human",
+        "Easy",
+        "Normal",
+        "Difficult",
+        "Mighty",
+        "Master",
+        "Impossible",
+        "Closed",
+    ]
+    table_container.clear()
+    nations = servermanager.get_nations()
+    with table_container:
+        with ui.card().classes("w-full"):
+            with ui.row().classes("font-bold w-full"):
+                ui.label("ID").classes("w-16")
+                ui.label("Nation").classes("w-104")
+                ui.label("AI Level")
+        ui.separator()
+        with ui.row().classes("items-center, w-full"):
+            ui.label("All").classes("w-124")
+            master_select = ui.select(
+                AI_LEVELS,
+                value="Human",
+            )
+
+        for nation_id, nation in nations[str(era)].items():
+            nation_name, title = nation["name"]
+
+            with ui.row().classes("items-center w-full"):
+                ui.label(str(nation_id)).classes("w-16")
+                ui.label(nation_name + ", " + title).classes("w-104")
+                # TODO: Random nations?
+                # Although that logic should probably go into servermanager.py
+                ui.select(
+                    AI_LEVELS,
+                    value="Human",
+                    on_change=lambda e, nid=nation_id: set_ai_level(
+                        e.value, nid, ai_slots
+                    ),
+                ).bind_value_from(master_select)
+
+
+def set_ai_level(value, nid, ai_slots):
+    level_map = {
+        "Closed": 0,
+        "Easy": 1,
+        "Normal": 2,
+        "Difficult": 3,
+        "Mighty": 4,
+        "Master": 5,
+        "Impossible": 6,
+    }
+    for ai in ai_slots:
+        if ai[0] == nid:
+            ai_slots.remove(ai)
+    if value == "Human":
+        return
+
+    ai_slots.append((nid, level_map[value]))