Splatlogger 1.0.0__py3-none-any.whl

splatlogger/__main__.py

@@ -0,0 +1,4 @@
+from .cli import cli
+
+if __name__ == "__main__":
+    cli()

splatlogger/cemu_gecko.py

@@ -0,0 +1,85 @@
+# Splatlogger (c) 2025 Shadow Doggo.
+
+import struct
+
+import psutil
+from PyMemoryEditor import OpenProcess, ProcessIDNotExistsError  # type: ignore[import-untyped]
+
+
+class CemuGecko:
+    """Wrapper around PyMemoryEditor to provide Cemu memory access.
+    Compatible with existing code written for TCPGecko.
+    """
+
+    def __init__(self, pid: int):
+        cemu_pid = self._find_cemu_process() if pid == -1 else pid
+        if cemu_pid is None:
+            raise CemuGeckoError("Cemu process not found.")
+
+        try:
+            self._process = OpenProcess(pid=cemu_pid)
+        except ProcessIDNotExistsError as e:
+            raise CemuGeckoError("Invalid process ID.") from e
+
+        self._base_address = self._get_base_address()
+        if self._base_address == 0:
+            raise CemuGeckoError("Could not find Cemu's Wii U memory space.")
+
+    def close(self):
+        """Close the process handle."""
+        self._process.close()
+
+    def peek_raw(self, address: int, length: int) -> bytes:
+        """Read raw memory starting at address and ending at address + length.
+        Returns a bytes object.
+        """
+        if length <= 0:
+            raise ValueError("Reading memory requires a positive length (# of bytes).")
+
+        return self._process.read_process_memory(self._base_address + address, bytes, length)
+
+    def peek8(self, address: int, *, signed: bool = False) -> int:
+        """Get an 8-bit integer value stored at the specified address."""
+        return int.from_bytes(self.peek_raw(address, length=1), byteorder="big", signed=signed)
+
+    def peek16(self, address: int, *, signed: bool = False) -> int:
+        """Get a 16-bit integer value stored at the specified address."""
+        return int.from_bytes(self.peek_raw(address, length=2), byteorder="big", signed=signed)
+
+    def peek32(self, address: int, *, signed: bool = False) -> int:
+        """Get a 32-bit integer value stored at the specified address."""
+        return int.from_bytes(self.peek_raw(address, length=4), byteorder="big", signed=signed)
+
+    def peek_float(self, address: int) -> float:
+        """Get a floating point value stored at the specified address."""
+        return struct.unpack(">f", self.peek_raw(address, length=4))[0]
+
+    def read_string(self, address: int, length: int = 1, encoding: str = "utf-8") -> str:
+        return self.peek_raw(address, length).decode(encoding)
+
+    def _get_base_address(self) -> int:
+        # Find Cemu's Wii U memory space and verify the pattern of bytes at the start of the game's memory.
+        base_address = 0
+        for memory_region in self._process.get_memory_regions():
+            address = memory_region.address
+            if memory_region.size == 0x4E000000:
+                pattern = bytes.fromhex("02D4E7")
+                if self._process.read_process_memory(address + 0xE000000, bytes, bufflength=20).find(pattern) != -1:
+                    base_address = address - 0x2000000
+                    break
+
+        return base_address
+
+    @staticmethod
+    def _find_cemu_process() -> int | None:
+        for process in psutil.process_iter():
+            try:
+                if process.name().lower() in ("cemu", "cemu.exe", "xapfish", "xapfish.exe"):
+                    return process.pid
+            except (psutil.AccessDenied, psutil.NoSuchProcess):
+                continue
+
+        return None
+
+
+class CemuGeckoError(Exception): pass

splatlogger/cli.py

@@ -0,0 +1,76 @@
+# Splatlogger (c) 2025 Shadow Doggo.
+
+import argparse
+import platform
+import sys
+import webbrowser
+from pathlib import Path
+
+import userpaths
+from colorama import Fore, Style, just_fix_windows_console
+
+from . import utility_functions as uf
+from .splatlogger import VERSION, main
+from .tuples import Options
+
+
+def cli():
+    if platform.system() == "Windows":
+        just_fix_windows_console()
+
+    print(f"Splatlogger v{VERSION} by Shadow Doggo\n")
+
+    main(parse_args())
+
+
+def parse_args() -> Options:
+    parser = argparse.ArgumentParser(description="PID (Principal ID)/Network ID grabber and match logger for Splatoon")
+    add_parser_arguments(parser)
+
+    if len(sys.argv) == 1 and (args_path := Path(userpaths.get_my_documents()) / "Splatlogger/options.txt").is_file():
+        with open(args_path, encoding="utf-8") as args_f:
+            args = parser.parse_args(args_f.read().split())
+    elif len(sys.argv) == 1:
+        print(f'{Fore.YELLOW}No arguments were provided. Run "splatlogger -h" for help.{Style.RESET_ALL}'
+              "\nWould you like to open the README? (y/n)")
+        if input().lower() in ("y", "yes"):
+            webbrowser.open("https://codeberg.org/ShadowDoggo/Splatlogger/src/branch/main/README.md")
+        sys.exit()
+    else:
+        args = parser.parse_args()
+
+    stack_addr: int | None = None
+    if args.stack and args.cemu:
+        try:
+            stack_addr = int(args.stack, 16)
+        except ValueError:
+            uf.print_error("Invalid stack address. Please provide a valid hex value.")
+            sys.exit()
+
+    if args.log_level == "none" and args.silent:
+        uf.print_warning("You have disabled printing logs to the console as well as creating a log file. "
+                         "Are you sure this wasn't a mistake?\n")
+
+    return Options(ip=args.ip, log_level=args.log_level, auto_logging=args.auto in ("all", "latest"),
+                   log_latest=args.auto == "latest", cemu=args.cemu is not None, cemu_pid=args.cemu,
+                   ptr_offset=0x503000 if args.cemu else 0, spfn=args.service == "spfn", no_fetch=args.no_fetch,
+                   silent_logging=args.silent, stack=stack_addr)
+
+
+def add_parser_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--ip", help="Your Wii U's LAN IP address.")
+    parser.add_argument("-c", "--cemu",
+                        help="Switch to Cemu mode (optional: PID of the Cemu process).", metavar="PID",
+                        nargs="?", const=-1)
+    parser.add_argument("--log-level", help="Set how much data should be logged (see README).",
+                        choices=["none", "standard", "extended", "stats"], default="standard")
+    parser.add_argument("--service", help="Choose which network service you're using (Pretendo by default).",
+                        choices=["pretendo", "spfn"], default="pretendo")
+    parser.add_argument("-a", "--auto",
+                        help="Enable auto logging (see README).",
+                        choices=["all", "latest"], nargs="?", const="all")
+    parser.add_argument("--stack",
+                        help="Beginning address of the stack space for Default Core 1 (Cemu only, see README).",
+                        metavar="Address (in hex)")
+    parser.add_argument("-n", "--no-fetch", help="Disable fetching network IDs and Mii names.", action="store_true")
+    parser.add_argument("-s", "--silent", help="Disable printing logs to the console.", action="store_true")

splatlogger/enums.py

@@ -0,0 +1,33 @@
+# Splatlogger (c) 2025 Shadow Doggo.
+
+from enum import IntEnum
+
+
+class Pointers(IntEnum):
+    SESSION = 0x106EB980
+    STATIC_MEM = 0x106E0330
+    MAIN_MGR_BASE = 0x106E5814
+    MAIN_MGR_VS_GAME = 0x106E7FF8
+
+
+class Addresses(IntEnum):
+    # A bunch of data including player stats from the latest match somewhere on the stack.
+    # I'm not exactly sure what this is, but it works.
+    WIN_TEAM = 0x107AF914
+    STATS = 0x107AF944
+
+
+class Offsets(IntEnum):
+    SESSION_ID_IDX = 0xBD
+    SESSION_ID = 0xCC
+    MAINMGR_PLAYER_MGR = 0x268
+    MAINMGR_SCENE_INFO = 0x2A4
+    PLAYERMGR_PLAYER_COUNT = 0x320
+    SCENE_INFO_RESULTS_SHOWN = 0x330
+    STATICMEM_PLAYER_INFO_ARY = 0x10
+    STATICMEM_STAGE = 0x28
+    STATICMEM_MATCH_HOUR = 0x234
+    STATICMEM_VERSUS_MODE = 0x238
+    STATICMEM_VERSUS_RULE = 0x23C
+    CEMU_WIN_TEAM = 0xF556C
+    CEMU_STATS = 0xF559C

splatlogger/match_logger.py

@@ -0,0 +1,252 @@
+# Splatlogger (c) 2025 Shadow Doggo.
+
+import json
+import platform
+# import sys
+import time
+from datetime import datetime
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+import userpaths  # type: ignore[import-untyped]
+
+from . import utility_functions as uf
+from .cemu_gecko import CemuGecko
+from .enums import Addresses, Offsets
+from .tcpgecko import TCPGecko
+from .tuples import AccountInfo, CommonAddresses, Options, PlayerInfo
+
+
+class MatchLogger:
+    """Provides the match logging functionality of Splatlogger."""
+
+    def __init__(self, options: Options, gecko: TCPGecko | CemuGecko, static_mem_adr: int) -> None:
+        self._date = datetime.now()
+        self._log_path: Path = (Path(userpaths.get_my_documents()) /
+                                f"Splatlogger/logs/{self._date.strftime('%Y-%m-%d')}")
+        self._options = options
+        self._gecko = gecko
+        self._static_mem_adr = static_mem_adr
+        self._stats_offset: int | None = None
+        self._align = 2 if options.auto_logging else 0
+        names_path = resources.files(__package__).joinpath("resources", "names.json")
+        # names_path = Path(sys._MEIPASS) / "resources/names.json"
+        try:
+            with names_path.open("r", encoding="utf-8") as names_f:
+                self._names: dict[str, Any] = json.load(names_f)
+        except FileNotFoundError:
+            uf.exit_with_close("Couldn't find 'names.json'. The package may have been installed incorrectly.")
+
+    def create_new_log(self) -> None:
+        """Initialize a new log file."""
+        if not self._log_path.exists():
+            self._log_path.mkdir(parents=True)
+
+        self._write_log(log=f"Splatlogger log from {self._date.strftime('%Y-%m-%d %H:%M:%S')} "
+                            f"(UTC {uf.get_utc_offset(self._date):+})\n", mode="w")
+
+    def get_log_path(self) -> Path:
+        """Return the path to the current log file."""
+        if self._options.log_latest:
+            return self._log_path / f"{self._date.strftime('%Y-%m-%d')} log.txt"
+
+        return self._log_path / f"{self._date.strftime('%Y-%m-%d %H-%M-%S')} log.txt"
+
+    def log_match(self, date: datetime, session_id: int, match_count: int, player_info_list: list[PlayerInfo],
+                  adrs: CommonAddresses) -> None:
+        """Write player and match data to the log file.
+        A log file must be initialized before calling this method."""
+        disconnect = False
+
+        match_info = self._get_match_info()
+        versus_rule = match_info[3]
+        if self._options.log_level == "standard":
+            match_log = (f"\nMatch {match_count}\n\n{uf.player_table_header(self._options.spfn)}\n"
+                         if self._options.auto_logging else f"\n{uf.player_table_header(self._options.spfn)}\n")
+        else:
+            match_log = self._format_match_info(match_count, date, session_id, match_info)
+
+        for player_info in player_info_list:
+            match_log += self._format_match_log(player_info)
+
+            if self._options.log_level == "stats" and not disconnect:
+                if stats := self._get_player_stats(player_info, versus_rule, adrs):
+                    match_log += stats
+                else:
+                    disconnect = True
+
+        if self._options.log_level == "standard":
+            match_log += (
+                f"\nSession ID: {session_id if session_id != -1 else 'None'}\n"
+                f"Fetched at: {date.strftime('%Y-%m-%d %H:%M:%S')} (UTC {uf.get_utc_offset(date):+})\n"
+                if self._options.auto_logging else ""
+            )
+
+        self._write_log(log=match_log, mode="a")
+
+    def _get_name(self, name: str, value: int | str) -> str:
+        names = self._names.get(f"{name}_name", {})
+        if isinstance(names, dict):
+            return names.get(str(value), "Unknown")
+        return "Unknown"
+
+    def _write_log(self, log: str, mode: str) -> None:
+        with open(self.get_log_path(), mode, encoding="utf-8") as log_f:
+            log_f.write(log)
+
+    def _get_match_info(self) -> tuple[str, int, int, int]:
+        return (
+            self._gecko.read_string(self._static_mem_adr + Offsets.STATICMEM_STAGE, length=32).split("\u0000")[0],
+            self._gecko.peek8(self._static_mem_adr + Offsets.STATICMEM_MATCH_HOUR + 0x3),  # Read last byte as uint8
+            self._gecko.peek8(self._static_mem_adr + Offsets.STATICMEM_VERSUS_MODE + 0x3),
+            self._gecko.peek8(self._static_mem_adr + Offsets.STATICMEM_VERSUS_RULE + 0x3)
+        )
+
+    def _format_match_info(self, match_count: int, date: datetime, session_id: int,
+                           match_info: tuple[str, int, int, int]) -> str:
+        stage, match_hour, versus_mode, versus_rule = match_info
+
+        header = (
+            f"\n[Match {match_count}]\n"
+            f"{' ' * self._align}Time: {date.strftime('%Y-%m-%d %H:%M:%S')} (UTC {uf.get_utc_offset(date):+})\n"
+            if self._options.auto_logging and self._options.log_level != "standard" else "\n"
+        )
+
+        return (
+            f"{header}"
+            f"{' ' * self._align}Session ID: {session_id if session_id != -1 else 'None'}\n"
+            f"{' ' * self._align}Lobby type: {self._get_name('versus_mode', versus_mode)} "
+            f"({versus_mode})\n"
+            f"{' ' * self._align}Game mode: {self._get_name('versus_rule', versus_rule)} "
+            f"({versus_rule})\n"
+            f"{' ' * self._align}Stage: {self._get_name('stage', stage)} ({stage})\n"
+            f"{' ' * self._align}Match hour: {self._get_name('match_hour', match_hour)} ({match_hour})\n"
+        )
+
+    def _format_match_log(self, player_info: PlayerInfo) -> str:
+        network_id_type = "SFID" if self._options.spfn else "PNID"
+        indent = " " * (self._align + 2)
+
+        return (
+            uf.player_table_entry(player_info, AccountInfo(player_info.network_id, player_info.mii_name, "")) + "\n"
+        ) if self._options.log_level == "standard" else (
+            f"\n{' ' * self._align}[Player {player_info.idx + 1}]\n"
+            f"{indent}Name: {player_info.name}"
+            f"{f' (Mii name: {player_info.mii_name})' if not uf.compare_names(player_info.name, player_info.mii_name) else ''}\n"
+            f"{indent}PID: {player_info.pid}\n"
+            f"{indent}{network_id_type}: {player_info.network_id}\n"
+            f"{indent}Team: {self._get_name('team', player_info.team)} "
+            f"({player_info.team})\n"
+            f"{indent}Appearance: Gender: {self._get_name('gender', player_info.gender)} "
+            f"({player_info.gender}) | "
+            f"Skin tone: {self._get_name('skin_tone', player_info.skin_tone)} ({player_info.skin_tone}) | "
+            f"Eye color: {self._get_name('eye_color', player_info.eye_color)} ({player_info.eye_color})\n"
+            f"{indent}Gear: Headgear: {self._get_name('headgear', player_info.headgear)} "
+            f"({player_info.headgear}) | "
+            f"Clothes: {self._get_name('clothes', player_info.clothes)} ({player_info.clothes}) | "
+            f"Shoes: {self._get_name('shoes', player_info.shoes)} ({player_info.shoes})\n"
+            f"{indent}Weapons: Main: {self._get_name('weapon', player_info.weapon)} "
+            f"({player_info.weapon}) | "
+            f"Sub: {self._get_name('sub_weapon', player_info.sub_weapon)} ({player_info.sub_weapon}) | "
+            f"Special: {self._get_name('special_weapon', player_info.special_weapon)} "
+            f"({player_info.special_weapon})\n"
+            f"{indent}Level: {player_info.level}\n"
+            f"{indent}Rank: {self._get_name('rank', player_info.rank)} "
+            f"({player_info.rank})\n"
+        )
+
+    # If the player stats stuff looks overly complicated, that's because it is.
+    # Getting stuff from the stack reliably is a PITA.
+    def _get_player_stats(self, player_info: PlayerInfo, versus_rule: int, adrs: CommonAddresses) -> str | None:
+        stats_adr, win_team_adr = self._get_stats_addresses()
+
+        if player_info.idx == 0 and not self._wait_for_results(adrs):
+            return None
+
+        if not self._options.cemu:
+            # If on tiramisu/aroma, get stats offset after the first match is complete.
+            if self._stats_offset is None:
+                if (stats_offset := self._find_stats_offset(adrs.player_info_ary_adr)) is None:
+                    return None
+                self._stats_offset = stats_offset
+
+            stats_adr += self._stats_offset
+            win_team_adr += self._stats_offset
+
+        winning_team = self._gecko.peek32(win_team_adr)
+
+        return self._format_stats_log(player_info, winning_team, versus_rule,
+                                      self._read_player_stats(stats_adr, player_info.idx))
+
+    def _get_stats_addresses(self) -> tuple[int, int]:
+        stats_adr: int = Addresses.STATS
+        win_team_adr: int = Addresses.WIN_TEAM
+
+        if self._options.cemu and self._options.stack:
+            stats_adr = self._options.stack + Offsets.CEMU_STATS
+            win_team_adr = self._options.stack + Offsets.CEMU_WIN_TEAM
+        elif self._options.cemu:
+            # Assume default values if stack is not provided. These seem consistent across various systems.
+            stack_adr = 0xE101440 if platform.system() == "Windows" else 0xE175900
+            stats_adr = stack_adr + Offsets.CEMU_STATS
+            win_team_adr = stack_adr + Offsets.CEMU_WIN_TEAM
+
+        return stats_adr, win_team_adr
+
+    def _wait_for_results(self, adrs: CommonAddresses) -> bool:
+        for _ in range(200):
+            if not uf.is_player_in_vs_match():
+                return False
+
+            scene_info_adr = self._gecko.peek32(adrs.main_mgr_base_adr + Offsets.MAINMGR_SCENE_INFO)
+            if self._gecko.peek32(scene_info_adr + Offsets.SCENE_INFO_RESULTS_SHOWN) == 0:  # Some sort of timer?
+                return True
+
+            time.sleep(3)
+
+        return False
+
+    def _read_player_stats(self, stats_adr: int, player_idx: int) -> tuple[int, int, int]:
+        stats = self._gecko.peek_raw(stats_adr, length=0x124)
+        offset = player_idx * 0x20
+
+        points = uf.read_int(stats, offset + 0x3A, offset + 0x3C)
+        kills = uf.read_int(stats, offset + 0x3E, offset + 0x40)
+        deaths = uf.read_int(stats, offset + 0x42, offset + 0x44)
+
+        return points, kills, deaths
+
+    def _format_stats_log(self, player_info: PlayerInfo, winning_team: int, versus_rule: int,
+                          stats: tuple[int, int, int]) -> str:
+        indent = " " * (self._align + 2)
+        player_won = player_info.team == winning_team
+        points, kills, deaths = stats
+
+        points_log = ""
+        if versus_rule == 0:  # Only log points in turf war cause in ranked they're the same for all players.
+            if player_won:
+                points_log = f"{indent}Points: {points + 1000}p ({points}p w/o win bonus)\n"
+            else:
+                points_log = f"{indent}Points: {points}p\n"
+
+        return (
+            f"{points_log}"
+            f"{indent}K/D: {kills}/{deaths}\n"
+            f"{indent}Result: {'Win' if player_won else 'Lose'}\n"
+        )
+
+    def _find_stats_offset(self, player_info_ary_adr: int) -> int | None:
+        # Find pointer to the first player's PlayerInfo within the stats and calculate offset.
+        first_player_info_adr = self._gecko.peek32(player_info_ary_adr)
+
+        # Check default offsets of 0 and -0x38 first. The pointer is at 0x30.
+        if self._gecko.peek32(Addresses.STATS + 0x30) == first_player_info_adr:
+            return 0
+        if self._gecko.peek32(Addresses.STATS - 0x8) == first_player_info_adr:
+            return -0x38
+
+        search_space = self._gecko.peek_raw(Addresses.STATS - 0x100, length=0x200)
+        stats_offset = search_space.find(first_player_info_adr.to_bytes(length=4, byteorder="big"))
+
+        return None if stats_offset == -1 else stats_offset - 0x130