import configparser import os import shutil import sys import threading import time import webbrowser import re from dataclasses import dataclass from pathlib import Path from typing import Dict, List, Tuple import tkinter as tk from tkinter import messagebox, ttk, filedialog from steam_required_ids import extract_required_item_ids, resolve_workshop_names, expand_required_ids_recursive from sealoader_version import __version__ # Minimal dark theme colors BG = "#16181c" PANEL_BG = "#1f232a" FG = "#e6e6e6" MUTED = "#a0a6ad" ACCENT = "#4f8cff" DEFAULT_INI_PATH = str(Path.home() / "AppData" / "LocalLow" / "Triassic Games" / "Sea Power" / "usersettings.ini") @dataclass class InstalledMod: mod_id: str enabled: bool def read_installed_mods(ini_path: str) -> Dict[str, InstalledMod]: parser = configparser.ConfigParser() parser.optionxform = str if not os.path.exists(ini_path): raise FileNotFoundError(f"usersettings.ini not found at: {ini_path}") parser.read(ini_path, encoding="utf-8") if "[LoadOrder]" in "\n".join(open(ini_path, encoding="utf-8").readlines()): section = "LoadOrder" else: section = "LoadOrder" if section not in parser: return {} mods: Dict[str, InstalledMod] = {} for key, value in parser[section].items(): if not key.lower().startswith("mod"): continue # Format: ModXDirectory=, parts = value.split(",") if not parts: continue left_token = parts[0].strip() # Prefer numeric Workshop ID if present at start, else keep full token num_prefix = "" for ch in left_token: if ch.isdigit(): num_prefix += ch else: break mod_id = num_prefix if num_prefix else left_token enabled = False if len(parts) > 1: enabled = parts[1].strip().lower() == "true" mods[mod_id] = InstalledMod(mod_id=mod_id, enabled=enabled) return mods def _get_enabled_mod_ids_from_ini(ini_path: str) -> set[str]: try: mods = read_installed_mods(ini_path) except FileNotFoundError: return set() return {mid for mid, m in mods.items() if m.enabled} def _get_all_mod_ids_from_ini(ini_path: str) -> set[str]: try: mods = read_installed_mods(ini_path) except FileNotFoundError: return set() return set(mods.keys()) def _find_steamapps_dir_from_game_path(game_path: str) -> Path | None: p = Path(game_path).resolve() for parent in [p] + list(p.parents): if parent.name.lower() == "common" and parent.parent.name.lower() == "steamapps": return parent.parent if parent.name.lower() == "steamapps": return parent return None def _detect_app_id(steamapps_dir: Path, installdir_name: str) -> str | None: target = installdir_name.lower() for acf in steamapps_dir.glob("appmanifest_*.acf"): try: text = acf.read_text(encoding="utf-8", errors="ignore") except Exception: continue if '"installdir"' in text: for line in text.splitlines(): if '"installdir"' in line: parts = [seg for seg in line.split('"') if seg.strip()] if parts: val = parts[-1].strip().lower() if val == target: return acf.stem.replace("appmanifest_", "") return None def read_installed_mods_from_workshop(game_path: str, ini_path: str) -> Dict[str, InstalledMod]: if not game_path: return {} steamapps = _find_steamapps_dir_from_game_path(game_path) if not steamapps or not steamapps.exists(): return {} installdir = Path(game_path).name app_id = _detect_app_id(steamapps, installdir) if not app_id: return {} workshop_dir = steamapps / "workshop" / "content" / app_id if not workshop_dir.exists(): return {} enabled_ids = _get_enabled_mod_ids_from_ini(ini_path) mods: Dict[str, InstalledMod] = {} try: for child in workshop_dir.iterdir(): if child.is_dir() and child.name.isdigit(): mid = child.name mods[mid] = InstalledMod(mod_id=mid, enabled=(mid in enabled_ids)) except Exception: pass return mods def enable_mods_in_ini(ini_path: str, ids_to_enable: List[str]) -> Tuple[int, int]: parser = configparser.ConfigParser() parser.optionxform = str parser.read(ini_path, encoding="utf-8") section = "LoadOrder" if section not in parser: raise ValueError("[LoadOrder] section not found in usersettings.ini") # Backup before changes backup_path = ini_path + ".bak" shutil.copyfile(ini_path, backup_path) enabled_count = 0 missing_count = 0 # Determine next index for new Mod entries next_idx = 1 for key, _ in parser[section].items(): m = re.match(r"Mod(\d+)Directory", key, re.IGNORECASE) if m: try: next_idx = max(next_idx, int(m.group(1)) + 1) except Exception: pass # Maintain order and preserve original left token (may include name after ID) items = list(parser[section].items()) # Maintain order for target_id in ids_to_enable: found_key = None for key, value in items: if not key.lower().startswith("mod"): continue parts = value.split(",") if not parts: continue left_token = parts[0].strip() # Extract numeric prefix for matching num_prefix = "" for ch in left_token: if ch.isdigit(): num_prefix += ch else: break mod_id = num_prefix if num_prefix else left_token if mod_id == target_id: found_key = key current_enabled = False if len(parts) > 1: current_enabled = parts[1].strip().lower() == "true" if not current_enabled: # Preserve original left token, only toggle enabled flag new_value = f"{left_token},True" parser[section][key] = new_value enabled_count += 1 break if not found_key: # Append new entry at bottom for this workshop ID, disabled status will be set to True new_key = f"Mod{next_idx}Directory" parser[section][new_key] = f"{target_id},True" next_idx += 1 enabled_count += 1 with open(ini_path, "w", encoding="utf-8") as f: parser.write(f) return enabled_count, missing_count class SeaLoaderApp(tk.Tk): def __init__(self, ini_path: str): super().__init__() self.title("SeaLoader") self.configure(bg=BG) self.geometry("960x560") self.minsize(800, 480) self.ini_path = ini_path self.installed_mods: Dict[str, InstalledMod] = {} self.required_ids: List[str] = [] self.installed_names_map: Dict[str, str] = {} self._icon_img = None self._did_flash_fetch = False self._did_flash_enable = False self._style() self._layout() self._load_installed_mods() # App icon from PNG (optional) try: icon_path = self._resource_path("SeaLoader.png") if icon_path.exists(): self._icon_img = tk.PhotoImage(file=str(icon_path)) self.iconphoto(True, self._icon_img) except Exception: pass # Help shortcut try: self.bind("", lambda e: self._on_help()) except Exception: pass # Guide: when URL is filled, flash Fetch try: self.url_var.trace_add('write', self._on_url_changed) except Exception: pass # Load saved game path (if any) and auto-load mods try: saved = self._load_saved_game_path() if saved: self.game_path_var.set(saved) self._load_installed_mods() except Exception: pass # Check for updates asynchronously threading.Thread(target=self._check_for_updates_async, daemon=True).start() def _style(self) -> None: style = ttk.Style(self) try: style.theme_use("clam") except Exception: pass style.configure("TFrame", background=BG) style.configure("Panel.TFrame", background=PANEL_BG) style.configure("TLabel", background=PANEL_BG, foreground=FG) style.configure("Header.TLabel", background=BG, foreground=FG, font=("Segoe UI", 12, "bold")) style.configure("TButton", background=PANEL_BG, foreground=FG, borderwidth=0) style.map("TButton", background=[("active", ACCENT)]) style.configure("TEntry", fieldbackground=PANEL_BG, foreground=FG, insertcolor=FG) style.configure("TScrollbar", background=PANEL_BG, troughcolor=BG) style.configure("Treeview", background=PANEL_BG, fieldbackground=PANEL_BG, foreground=FG, borderwidth=0) style.configure("Treeview.Heading", background=PANEL_BG, foreground=MUTED) # Flash styles style.configure("Flash.TEntry", fieldbackground="#2b3a5a", foreground=FG, insertcolor=FG) style.configure("Flash.TButton", background=ACCENT, foreground="#0d1117") def _layout(self) -> None: top = ttk.Frame(self, style="TFrame") top.pack(fill=tk.X, padx=12, pady=(12, 6)) url_label = ttk.Label(top, text="Workshop URL:", style="TLabel") url_label.pack(side=tk.LEFT) self.url_var = tk.StringVar() self.url_entry = ttk.Entry(top, textvariable=self.url_var, width=70) self.url_entry.pack(side=tk.LEFT, padx=8, fill=tk.X, expand=True) self.fetch_btn = ttk.Button(top, text="Fetch Required Mods", command=self._on_fetch) self.fetch_btn.pack(side=tk.LEFT) # Game path row path_row = ttk.Frame(self, style="TFrame") path_row.pack(fill=tk.X, padx=12, pady=(0, 6)) ttk.Label(path_row, text="Game Path:", style="TLabel").pack(side=tk.LEFT) self.game_path_var = tk.StringVar() self.game_path_entry = ttk.Entry(path_row, textvariable=self.game_path_var, width=70) self.game_path_entry.pack(side=tk.LEFT, padx=8, fill=tk.X, expand=True) ttk.Button(path_row, text="Browse", command=self._browse_game_path).pack(side=tk.LEFT) main = ttk.Frame(self, style="TFrame") main.pack(fill=tk.BOTH, expand=True, padx=12, pady=6) left_panel = ttk.Frame(main, style="Panel.TFrame") left_panel.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) right_panel = ttk.Frame(main, style="Panel.TFrame") right_panel.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(8, 0)) left_header = ttk.Label(left_panel, text="Installed Mods", style="Header.TLabel") left_header.pack(anchor="w", padx=8, pady=8) self.installed_tree = self._create_tree(left_panel, ["Mod ID", "Name", "Status"], [0.30, 0.50, 0.20]) self.installed_tree.pack(fill=tk.BOTH, expand=True, padx=8, pady=(0, 8)) right_header = ttk.Label(right_panel, text="Scenario Required Mods", style="Header.TLabel") right_header.pack(anchor="w", padx=8, pady=8) self.required_tree = self._create_tree(right_panel, ["Mod ID", "Name", "Status"], [0.25, 0.60, 0.15]) self.required_tree.pack(fill=tk.BOTH, expand=True, padx=8, pady=(0, 8)) bottom = ttk.Frame(self, style="TFrame") bottom.pack(fill=tk.X, padx=12, pady=(0, 12)) self.enable_btn = ttk.Button(bottom, text="Enable Matching Mods", command=self._on_enable) self.enable_btn.pack(side=tk.LEFT) self.disable_all_btn = ttk.Button(bottom, text="Disable All Mods", command=self._on_disable_all) self.disable_all_btn.pack(side=tk.LEFT, padx=(8, 0)) self.help_btn = ttk.Button(bottom, text="Help", command=self._on_help) self.subscribe_btn = ttk.Button(bottom, text="Subscribe Missing Mods", command=self._on_subscribe_missing) self.subscribe_btn.pack(side=tk.RIGHT, padx=(0, 8)) self.help_btn.pack(side=tk.RIGHT) # Footer attribution footer = ttk.Frame(self, style="TFrame") footer.pack(fill=tk.X, padx=12, pady=(0, 10)) self._footer_icon = self._load_png_icon("hrsys.png", max_px=18) if self._footer_icon is not None: icon_lbl = ttk.Label(footer, image=self._footer_icon, style="TLabel") icon_lbl.pack(side=tk.LEFT) icon_lbl.bind("", lambda e: self._open_link("https://hudsonriggs.systems")) link_lbl = ttk.Label(footer, text="Created by HudsonRiggs.Systems", style="TLabel", foreground=MUTED) link_lbl.pack(side=tk.LEFT, padx=(6, 0)) link_lbl.bind("", lambda e: self._open_link("https://hudsonriggs.systems")) # Update label (hidden by default) self.update_var = tk.StringVar(value="") self.update_lbl = ttk.Label(footer, textvariable=self.update_var, style="TLabel", foreground=ACCENT) self.update_lbl.pack(side=tk.RIGHT) def _create_tree(self, parent, columns: List[str], ratios: List[float]): tree = ttk.Treeview(parent, columns=columns, show="headings", height=12) for col in columns: tree.heading(col, text=col) tree.column(col, width=50, anchor=tk.W, stretch=True) vsb = ttk.Scrollbar(parent, orient="vertical", command=tree.yview) tree.configure(yscrollcommand=vsb.set) tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) vsb.pack(side=tk.LEFT, fill=tk.Y) self._bind_auto_columns(parent, tree, ratios) return tree def _bind_auto_columns(self, container, tree: ttk.Treeview, ratios: List[float]) -> None: ratios = [r / sum(ratios) for r in ratios] def on_resize(event): # Reserve some space for vertical scrollbar and paddings total = max(event.width - 18, 100) for col, ratio in zip(tree["columns"], ratios): tree.column(col, width=int(total * ratio)) container.bind("", on_resize, add="+") def _load_installed_mods(self) -> None: try: game_path = self.game_path_var.get().strip() if hasattr(self, "game_path_var") else "" if game_path: self.installed_mods = read_installed_mods_from_workshop(game_path, self.ini_path) else: self.installed_mods = {} except FileNotFoundError as e: messagebox.showerror("SeaLoader", str(e)) self.installed_mods = {} self._refresh_installed_list() self._resolve_installed_names_async() def _browse_game_path(self) -> None: path = filedialog.askdirectory(title="Select Sea Power install folder (steamapps/common/Sea Power)") if path: self.game_path_var.set(path) # Auto-load mods when path selected self._load_installed_mods() # Flash the URL box to guide next step self._flash_widget(self.url_entry, entry=True) # Persist selection try: self._save_game_path(path) except Exception: pass def _refresh_installed_list(self) -> None: for row in self.installed_tree.get_children(): self.installed_tree.delete(row) ini_ids = _get_all_mod_ids_from_ini(self.ini_path) for mod in self.installed_mods.values(): if mod.enabled: status = "Enabled" else: status = "Disabled" if mod.mod_id in ini_ids else "Disabled (Not in INI)" display_name = self.installed_names_map.get(mod.mod_id, "") self.installed_tree.insert("", tk.END, values=(mod.mod_id, display_name, status)) def _resolve_installed_names_async(self) -> None: ids = [mid for mid in self.installed_mods.keys() if mid.isdigit()] ids_to_lookup = [mid for mid in ids if mid not in self.installed_names_map] if not ids_to_lookup: return def task(): try: names = resolve_workshop_names(ids_to_lookup) except Exception: names = {} def update(): if names: self.installed_names_map.update(names) self._refresh_installed_list() self.after(0, update) threading.Thread(target=task, daemon=True).start() def _on_fetch(self) -> None: url = self.url_var.get().strip() if not url: messagebox.showwarning("SeaLoader", "Please paste a Workshop URL.") return self.fetch_btn.configure(state=tk.DISABLED) self.enable_btn.configure(state=tk.DISABLED) def task(): try: base_ids = extract_required_item_ids(url) ids = expand_required_ids_recursive(base_ids) # Reuse installed cache to reduce API calls names_map = {i: self.installed_names_map[i] for i in ids if i in self.installed_names_map} ids_to_lookup = [i for i in ids if i not in names_map] if ids_to_lookup: fetched = resolve_workshop_names(ids_to_lookup) names_map.update(fetched) except Exception as exc: self.after(0, lambda: messagebox.showerror("SeaLoader", f"Failed to fetch IDs: {exc}")) self.after(0, lambda: self.fetch_btn.configure(state=tk.NORMAL)) self.after(0, lambda: self.enable_btn.configure(state=tk.NORMAL)) return def update(): self.required_ids = ids self._refresh_required_list(names_map) self.fetch_btn.configure(state=tk.NORMAL) self.enable_btn.configure(state=tk.NORMAL) # Flash Enable button to guide next step self._maybe_flash_enable() self.after(0, update) threading.Thread(target=task, daemon=True).start() def _refresh_required_list(self, names_map: Dict[str, str] | None = None) -> None: for row in self.required_tree.get_children(): self.required_tree.delete(row) installed_ids = set(self.installed_mods.keys()) names_map = names_map or {} for mod_id in self.required_ids: status = "Installed" if mod_id in installed_ids else "Missing" display_name = names_map.get(mod_id, "") self.required_tree.insert("", tk.END, values=(mod_id, display_name, status)) def _on_enable(self) -> None: if not self.required_ids: messagebox.showinfo("SeaLoader", "No required mods loaded. Fetch from URL first.") return try: enabled_count, missing_count = enable_mods_in_ini(self.ini_path, self.required_ids) except Exception as exc: messagebox.showerror("SeaLoader", f"Failed to update INI: {exc}") return # Reload to reflect changes self._load_installed_mods() self._refresh_required_list() msg_lines = [f"Enabled {enabled_count} mod(s)."] if missing_count: msg_lines.append(f"{missing_count} required mod(s) not found in usersettings.ini.") else: msg_lines.append("All required mods were found.") messagebox.showinfo("SeaLoader", "\n".join(msg_lines)) def _on_help(self) -> None: ini_hint = ( f"Default INI: {self.ini_path}\n\n" ) text = ( "Usage:\n\n" "1) Paste a Steam Workshop URL at the top and click 'Fetch Required Mods'.\n" " - Right list shows required Mod IDs, names and whether they are installed.\n" "2) Installed mods load automatically from usersettings.ini (left list).\n" "3) Click 'Subscribe Missing Mods' to subscribe to any missing Workshop items in Steam.\n" " - Steam desktop must be running and signed in; downloads happen in the background.\n" "4) Click 'Enable Matching Mods' to turn on any installed required mods.\n" " - A .bak backup of usersettings.ini is created before changes.\n\n" "Tips:\n" "- Run with a custom INI path: python sealoader_gui.py \"\"\n" "- Press F1 to open this help.\n\n" + ini_hint ) messagebox.showinfo("SeaLoader Help", text) def _resource_path(self, name: str) -> Path: try: base = getattr(sys, "_MEIPASS", None) if base: return Path(base) / name except Exception: pass return Path(__file__).resolve().parent / name def _open_link(self, url: str) -> None: try: webbrowser.open(url) except Exception: pass def _load_png_icon(self, filename: str, max_px: int = 18): try: png_path = self._resource_path(filename) if not png_path.exists(): return None img = tk.PhotoImage(file=str(png_path)) # Downscale if needed using integer subsample sx = max(img.width() // max_px, 1) sy = max(img.height() // max_px, 1) scale = max(sx, sy) if scale > 1: img = img.subsample(scale, scale) return img except Exception: return None def _on_disable_all(self) -> None: confirm = messagebox.askyesno("SeaLoader", "Disable all mods in usersettings.ini?") if not confirm: return try: self._disable_all_mods() except Exception as exc: messagebox.showerror("SeaLoader", f"Failed to disable all mods: {exc}") return self._load_installed_mods() messagebox.showinfo("SeaLoader", "All mods disabled.") def _disable_all_mods(self) -> None: parser = configparser.ConfigParser() parser.optionxform = str parser.read(self.ini_path, encoding="utf-8") section = "LoadOrder" if section not in parser: raise ValueError("[LoadOrder] section not found in usersettings.ini") shutil.copyfile(self.ini_path, self.ini_path + ".bak") for key, value in list(parser[section].items()): if not key.lower().startswith("mod"): continue parts = value.split(",") if not parts: continue left_token = parts[0].strip() parser[section][key] = f"{left_token},False" with open(self.ini_path, "w", encoding="utf-8") as f: parser.write(f) def _on_subscribe_missing(self) -> None: if not self.required_ids: messagebox.showinfo("SeaLoader", "Fetch a Workshop URL first to determine missing mods.") return installed_ids = set(self.installed_mods.keys()) missing = [i for i in self.required_ids if i not in installed_ids] if not missing: messagebox.showinfo("SeaLoader", "No missing mods to subscribe.") return self.subscribe_btn.configure(state=tk.DISABLED) # Process one-by-one with remaining counter in the dialog self._subscribe_queue = list(missing) self._subscribe_next() def _subscribe_next(self) -> None: queue: List[str] = getattr(self, "_subscribe_queue", []) if not queue: self.subscribe_btn.configure(state=tk.NORMAL) messagebox.showinfo("SeaLoader", "Finished opening subscriptions in Steam.") return mod_id = queue[0] remaining = len(queue) - 1 try: self._open_link(f"steam://subscribe/{mod_id}") time.sleep(0.2) self._open_link(f"steam://openurl/https://steamcommunity.com/sharedfiles/filedetails/?id={mod_id}") except Exception: pass # Show per-item info and proceed when dismissed messagebox.showinfo("SeaLoader", f"Opened subscribe for {mod_id}.\n{remaining} remaining.") # Advance queue and continue queue.pop(0) self._subscribe_queue = queue self.after(0, self._subscribe_next) # Guided flashing helpers def _flash_widget(self, widget: ttk.Widget, entry: bool = False, cycles: int = 6, interval_ms: int = 300) -> None: try: normal_style = widget.cget('style') or ("TEntry" if entry else "TButton") flash_style = "Flash.TEntry" if entry else "Flash.TButton" state = {"on": True, "count": cycles * 2} def tick(): if state["count"] <= 0: widget.configure(style=normal_style) return widget.configure(style=flash_style if state["on"] else normal_style) state["on"] = not state["on"] state["count"] -= 1 self.after(interval_ms, tick) tick() except Exception: try: widget.focus_set() except Exception: pass def _on_url_changed(self, *_args): if not self._did_flash_fetch and self.url_var.get().strip(): self._did_flash_fetch = True self._flash_widget(self.fetch_btn, entry=False) def _maybe_flash_enable(self) -> None: if self.required_ids and not self._did_flash_enable: self._did_flash_enable = True self._flash_widget(self.enable_btn, entry=False) # Simple storage for game path next to INI def _storage_file_path(self) -> Path: try: ini_dir = Path(self.ini_path).resolve().parent except Exception: ini_dir = Path.cwd() return ini_dir / "sealoader_game_path.txt" def _save_game_path(self, path: str) -> None: p = self._storage_file_path() p.write_text(path.strip(), encoding="utf-8") def _load_saved_game_path(self) -> str: p = self._storage_file_path() if p.exists(): return p.read_text(encoding="utf-8").strip() return "" # Update checker def _check_for_updates_async(self) -> None: try: import requests # Configure your Gitea server/repo here owner_repo = os.getenv("SEALOADER_REPO", "HudsonRiggs/SeaLoader") server = os.getenv("SEALOADER_GITEA", "https://git.hudsonriggs.systems") url = f"{server}/api/v1/repos/{owner_repo}/releases/latest" resp = requests.get(url, timeout=10) if resp.status_code != 200: return data = resp.json() latest = data.get("tag_name") or data.get("name") or "" if latest and latest != __version__: def show(): self.update_var.set(f"Update available: {latest} (current {__version__})") # Flash the label self._flash_widget(self.update_lbl, entry=False, cycles=8, interval_ms=400) # Click opens latest release self.update_lbl.bind("", lambda e: self._open_link(data.get("html_url") or f"{server}/{owner_repo}/releases")) self.after(0, show) except Exception: pass def main() -> None: ini_path = DEFAULT_INI_PATH if len(sys.argv) > 1: ini_path = sys.argv[1] app = SeaLoaderApp(ini_path) app.mainloop() if __name__ == "__main__": main()