add windows batches

Author: Pzixel

.gitignore

@@ -5,6 +5,8 @@ __pycache__/
 .pytest_cache/
 .mypy_cache/
 .tmp_spawningtool/
+drop-log.txt
+install-log.txt
 *.egg-info/
 dist/
 build/

Drop replays here.bat

@@ -0,0 +1,23 @@
+@echo off
+setlocal
+set "ROOT=%~dp0"
+set "LOG=%ROOT%drop-log.txt"
+set "PYTHONPATH=%ROOT%src;%PYTHONPATH%"
+echo Running sc2-replay-salt...>"%LOG%"
+echo.>>"%LOG%"
+echo Working on your replay file. This can take a moment...
+
+if exist "%ROOT%.venv\Scripts\python.exe" (
+    "%ROOT%.venv\Scripts\python.exe" -m sc2_replay_salt --easy --no-prompt %* >>"%LOG%" 2>>&1
+) else (
+    where py >nul 2>nul
+    if %ERRORLEVEL%==0 (
+    py -3 -m sc2_replay_salt --easy --no-prompt %* >>"%LOG%" 2>>&1
+    ) else (
+    python -m sc2_replay_salt --easy --no-prompt %* >>"%LOG%" 2>>&1
+    )
+)
+
+echo.
+type "%LOG%"
+echo.

Install once.bat

@@ -0,0 +1,43 @@
+@echo off
+setlocal
+set "ROOT=%~dp0"
+set "LOG=%ROOT%install-log.txt"
+
+echo Setting up sc2-replay-salt...
+echo Setup log for sc2-replay-salt>"%LOG%"
+echo.>>"%LOG%"
+
+where py >nul 2>nul
+if %ERRORLEVEL%==0 (
+    set "PY=py -3"
+) else (
+    set "PY=python"
+)
+
+if not exist "%ROOT%.venv\Scripts\python.exe" (
+    echo Creating the private Python environment...
+    %PY% -m venv "%ROOT%.venv" >>"%LOG%" 2>>&1
+    if errorlevel 1 goto failed
+)
+
+echo Updating the installer tools...
+"%ROOT%.venv\Scripts\python.exe" -m pip --disable-pip-version-check install --upgrade pip setuptools wheel >>"%LOG%" 2>>&1
+if errorlevel 1 goto failed
+
+echo Installing the replay reader...
+"%ROOT%.venv\Scripts\python.exe" -m pip --disable-pip-version-check install --no-build-isolation -e "%ROOT%." >>"%LOG%" 2>>&1
+if errorlevel 1 goto failed
+
+echo.
+echo Ready. You can now drop .SC2Replay files onto "Drop replays here.bat".
+echo.
+pause
+exit /b 0
+
+:failed
+echo.
+echo Setup failed, but the details were saved to install-log.txt.
+echo Make sure Python 3.10 or newer is installed, then run this file again.
+echo.
+pause
+exit /b 1

README.md

@@ -2,6 +2,16 @@
 
 Decode StarCraft II replay files and print a readable build order for a selected player.
 
+## Easiest Use
+
+For a normal Windows workflow:
+
+1. Double-click `Install once.bat`.
+2. Drag one or more `.SC2Replay` files onto `Drop replays here.bat`.
+3. Open the `build order.txt` file created next to each replay.
+
+The drop script writes both the readable build order and the SALT import string. The first time it sees a replay with multiple players, it asks which player to analyze and remembers that name for future replays. If it cannot ask, it writes one file per player so the user still gets a result. By default it extracts roughly the first 9 minutes, which is usually the useful practice window for a build order.
+
 ## Setup
 
 Recommended:
@@ -69,9 +79,15 @@ python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --player 2
 python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --player SomeName
 ```
 
-If a replay has multiple players and the terminal is interactive, the tool asks which player to analyze. In non-interactive usage it falls back to the first player.
+If a replay has multiple players and the terminal is interactive, the tool asks which player to analyze. The selected player is remembered in your user profile and reused when that player appears in future replays. In non-interactive usage it falls back to the remembered player when possible, otherwise the first player.
+
+Print the readable table and SALT import string together:
+
+```powershell
+python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --player 2 --both
+```
 
-Print a SALT import string instead of the table:
+Print only a SALT import string:
 
 ```powershell
 python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --player 2 --salt
@@ -84,6 +100,7 @@ By default the table omits starting-state units, worker production, temporary sp
 
 ```powershell
 python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --max-minutes 8
+python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --full-game
 python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --include-workers
 python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --include-starting-state
 python -m sc2_replay_salt "C:\path\to\game.SC2Replay" --include-type-changes

src/sc2_replay_salt/cli.py

@@ -4,68 +4,104 @@
 import os
 import sys
 from pathlib import Path
+from typing import Sequence
 
 from dotenv import load_dotenv
 
-from .build_order import BuildOrderOptions, format_build_order, player_refs, replay_paths, resolve_player
+from .build_order import BuildOrderItem, BuildOrderOptions, PlayerRef, format_build_order, player_refs, replay_paths, resolve_player
+from .defaults import load_defaults, save_defaults
 from .replaystats import compare_reference, fetch_reference, format_comparison
 from .salt import format_salt_encoding
 from .sc2reader_backend import build_order_for_replay, load_replay, replay_players, replay_time_scale
 
 
+DEFAULT_MAX_MINUTES = 9.0
+ALL_PLAYERS = object()
+
+
 def main(argv: list[str] | None = None) -> int:
     load_dotenv()
     parser = argparse.ArgumentParser(description="Print a readable build order from StarCraft II replay files.")
-    parser.add_argument("path", type=Path, help="Replay file or directory containing .SC2Replay files.")
-    parser.add_argument("--player", help="Player id or exact player name. Defaults to the first player.")
+    parser.add_argument("paths", nargs="*", type=Path, help="Replay files or folders containing .SC2Replay files.")
+    parser.add_argument("--player", help="Player id or exact player name. Defaults to the remembered player when possible.")
     parser.add_argument("--limit", type=int, help="Maximum number of replays to analyze from a directory.")
     parser.add_argument("--no-prompt", action="store_true", help="Do not ask for a player in interactive terminals.")
     parser.add_argument("--include-starting-state", action="store_true", help="Include units present at frame 0.")
     parser.add_argument("--include-type-changes", action="store_true", help="Include every unit type-change event.")
     parser.add_argument("--include-workers", action="store_true", help="Include worker production.")
-    parser.add_argument("--max-minutes", type=float, help="Only print events up to this game minute.")
+    parser.add_argument("--max-minutes", type=float, help=f"Only print events up to this game minute. Defaults to {DEFAULT_MAX_MINUTES:g}.")
+    parser.add_argument("--full-game", action="store_true", help="Do not apply the default 9-minute build-order limit.")
     parser.add_argument("--salt", action="store_true", help="Print SALT encoding instead of a readable build order.")
+    parser.add_argument("--both", action="store_true", help="Print readable build order and SALT encoding together.")
     parser.add_argument("--salt-title", help="Title to embed in SALT output. Defaults to the replay file name.")
+    parser.add_argument("--easy", action="store_true", help="Friendly drag-and-drop mode: write build-order text files next to the replays.")
     parser.add_argument("--compare-replaystats", help="SC2ReplayStats replay URL to compare decoded state against.")
     parser.add_argument("--replaystats-team", type=int, default=0, help="SC2ReplayStats team slot to compare, zero-based.")
     args = parser.parse_args(argv)
 
+    if not args.paths:
+        message = "Drop one or more .SC2Replay files onto 'Drop replays here.bat' or pass a replay path."
+        print(message, file=sys.stderr if not args.easy else sys.stdout)
+        return 2
+
+    defaults = load_defaults()
     try:
-        paths = replay_paths(args.path)
-    except FileNotFoundError:
-        print(f"Path does not exist: {args.path}", file=sys.stderr)
+        paths = _collect_replay_paths(args.paths)
+    except FileNotFoundError as exc:
+        print(f"Path does not exist: {exc}", file=sys.stderr)
         return 2
 
     if args.limit is not None:
         paths = paths[: args.limit]
     if not paths:
-        print(f"No .SC2Replay files found in {args.path}", file=sys.stderr)
+        print("No .SC2Replay files found.", file=sys.stderr)
         return 2
 
     exit_code = 0
+    max_seconds = _max_seconds(args.max_minutes, args.full_game)
     options = BuildOrderOptions(
         include_starting_state=args.include_starting_state,
         include_type_changes=args.include_type_changes,
         include_workers=args.include_workers,
-        max_seconds=args.max_minutes * 60 if args.max_minutes is not None else None,
+        max_seconds=max_seconds,
     )
     for index, path in enumerate(paths):
-        if index:
+        if index and not args.easy:
             print("\n" + "=" * 72 + "\n")
         try:
-            player_selector = args.player or _prompt_for_player(path, args.no_prompt)
+            player_selector = args.player or _player_selector(
+                path,
+                args.no_prompt,
+                defaults,
+                all_on_no_prompt=args.easy,
+            )
+            if args.easy and player_selector is ALL_PLAYERS:
+                _write_easy_outputs_for_all_players(path, options, args.salt_title, defaults)
+                continue
+            if player_selector is ALL_PLAYERS:
+                player_selector = None
             replay, player, items = build_order_for_replay(path, player_selector, options)
             replay_name = str(getattr(replay, "filename", None) or path.name)
-            if args.salt:
-                print(format_salt_encoding(items, args.salt_title or Path(replay_name).stem))
+            salt_title = args.salt_title or Path(replay_name).stem
+            if args.easy or args.both:
+                output = format_combined_output(replay_name, player, items, salt_title)
+            elif args.salt:
+                output = format_salt_encoding(items, salt_title)
             else:
-                print(format_build_order(replay_name, player, items))
+                output = format_build_order(replay_name, player, items)
+
+            _remember_player(defaults, player.name)
+            if args.easy:
+                output_path = _easy_output_path(path)
+                output_path.write_text(output + "\n", encoding="utf-8")
+                print(f"Wrote {output_path}")
+            else:
+                print(output)
             if args.compare_replaystats:
                 reference = fetch_reference(
                     args.compare_replaystats,
                     session_id=os.getenv("SC2REPLAYSTATS_PHPSESSID"),
                 )
-                max_seconds = int(args.max_minutes * 60) if args.max_minutes is not None else None
                 result = compare_reference(
                     list(getattr(replay, "tracker_events", None) or []),
                     player,
@@ -83,20 +119,99 @@ def main(argv: list[str] | None = None) -> int:
     return exit_code
 
 
-def _prompt_for_player(path: Path, no_prompt: bool) -> str | None:
-    if no_prompt or not sys.stdin.isatty():
+def format_combined_output(
+    replay_name: str,
+    player: PlayerRef,
+    items: Sequence[BuildOrderItem],
+    salt_title: str,
+) -> str:
+    return f"{format_build_order(replay_name, player, items)}\n\nSALT:\n{format_salt_encoding(items, salt_title)}"
+
+
+def _collect_replay_paths(paths: Sequence[Path]) -> list[Path]:
+    replay_files: list[Path] = []
+    for path in paths:
+        replay_files.extend(replay_paths(path))
+    return replay_files
+
+
+def _write_easy_outputs_for_all_players(
+    path: Path,
+    options: BuildOrderOptions,
+    salt_title: str | None,
+    defaults: dict[str, object],
+) -> None:
+    replay = load_replay(path)
+    refs = player_refs(replay_players(replay))
+    for ref in refs:
+        replay, player, items = build_order_for_replay(path, str(ref.pid), options)
+        replay_name = str(getattr(replay, "filename", None) or path.name)
+        output = format_combined_output(replay_name, player, items, salt_title or Path(replay_name).stem)
+        output_path = _easy_output_path(path, player)
+        output_path.write_text(output + "\n", encoding="utf-8")
+        print(f"Wrote {output_path}")
+
+
+def _max_seconds(max_minutes: float | None, full_game: bool) -> float | None:
+    if full_game:
         return None
+    return (max_minutes if max_minutes is not None else DEFAULT_MAX_MINUTES) * 60
 
+
+def _player_selector(
+    path: Path,
+    no_prompt: bool,
+    defaults: dict[str, object],
+    all_on_no_prompt: bool = False,
+) -> str | object | None:
+    remembered = _remembered_player(defaults)
     replay = load_replay(path)
     refs = player_refs(replay_players(replay))
+    if remembered:
+        for ref in refs:
+            if ref.name.casefold() == remembered.casefold() or str(ref.pid) == remembered:
+                return remembered
+
+    if no_prompt or not sys.stdin.isatty():
+        if all_on_no_prompt and len(refs) > 1:
+            return ALL_PLAYERS
+        return None
+
     if len(refs) <= 1:
         return None
 
     print(f"{path.name} has multiple players:")
     for ref in refs:
         print(f"  {ref.label}")
-    choice = input("Analyze player id/name [default first]: ").strip()
+    try:
+        choice = input("Analyze player id/name [default first; remembered next time]: ").strip()
+    except EOFError:
+        return ALL_PLAYERS
     if not choice:
         return None
     resolve_player(refs, choice)
     return choice
+
+
+def _remembered_player(defaults: dict[str, object]) -> str | None:
+    player = defaults.get("player")
+    return player if isinstance(player, str) and player.strip() else None
+
+
+def _remember_player(defaults: dict[str, object], player: str) -> None:
+    if defaults.get("player") == player:
+        return
+    defaults["player"] = player
+    try:
+        save_defaults(defaults)
+    except OSError:
+        pass
+
+
+def _easy_output_path(path: Path, player: PlayerRef | None = None) -> Path:
+    player_suffix = f" - {_safe_filename_part(player.name)}" if player is not None else ""
+    return path.with_name(f"{path.stem}{player_suffix} build order.txt")
+
+
+def _safe_filename_part(value: str) -> str:
+    return "".join(character if character not in '<>:"/\\|?*' else "_" for character in value).strip() or "player"

src/sc2_replay_salt/defaults.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+CONFIG_ENV = "SC2_REPLAY_SALT_CONFIG"
+
+
+def config_path() -> Path:
+    override = os.getenv(CONFIG_ENV)
+    if override:
+        return Path(override)
+
+    appdata = os.getenv("APPDATA")
+    if appdata:
+        return Path(appdata) / "sc2-replay-salt" / "defaults.json"
+    return Path.home() / ".sc2-replay-salt" / "defaults.json"
+
+
+def load_defaults() -> dict[str, Any]:
+    path = config_path()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def save_defaults(defaults: dict[str, Any]) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(defaults, indent=2, sort_keys=True), encoding="utf-8")