Splatlogger 1.2.3__tar.gz → 1.3.0__tar.gz

{splatlogger-1.2.3/src/Splatlogger.egg-info → splatlogger-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Splatlogger
-Version: 1.2.3
+Version: 1.3.0
 Summary: PID Grabber and player/match information logging tool for Splatoon
 Author-email: Shadow Doggo <shadowdoggo@protonmail.com>
 License-Expression: MIT
@@ -74,6 +74,7 @@ To enable Cemu support, install with the `cemu` extra:
 ```
 pip install "Splatlogger[cemu]"
 ```
+(use `pip install --upgrade` to update from an older version)
 
 Then run with:
 ```
@@ -102,7 +103,7 @@ python -m splatlogger --ip IP [options] / --cemu [PID] [options]
   - `none` - Don't create a log file.
   - `standard` - Log only basic player information, the same as what's printed to the console (default).
   - `extended` - Log all player information and additional match information.
-  - `stats` - Same as above with the addition of player stats (points, K/D, win/lose) and disconnect detection.
+  - `full` - Same as above with the addition of player stats (points, K/D, win/lose), disconnect detection, and match results.
 Requires the match to end to finish logging; if it ends abruptly, the stats won't be logged.
 
 - `--service` - Choose which network service you're using.
@@ -117,11 +118,6 @@ Also allows you to view information about the lobby/gathering while on the match
 
     (These options don't affect anything if the log level is set to `none`)
 
-- `--stack Address (in hex)` - (Cemu only, optional) Beginning address of the stack space for Default Core 1 (Debug > View PPC threads).
-Only required for logging stats. If the default values don't work, you'll need to specify this manually.
-
-  <img src="assets/stack.png" width="600" alt="(example)">
-
 - `-sl`, `--single-log` - Enable single log mode. When enabled, only one log file will be created for each day and logging will resume in that file
 instead of creating a new one for each logging session (default behavior for `--auto latest`).
 
@@ -149,7 +145,7 @@ ip = "192.168.1.50"
 # Target network service: "pretendo", "altendo", or "none"
 service = "pretendo"
 
-# Log level: "standard", "extended", "stats", or "none"
+# Log level: "standard", "extended", "full", or "none"
 log_level = "extended"
 
 # Auto logging: "all", "latest" (omit for manual logging)
@@ -168,9 +164,6 @@ single_log = true
 # Cemu process ID (set to -1 to find automatically)
 # Uncomment this option to enable Cemu mode
 # cemu = -1
-
-# Beginning address of the stack space for Default Core 1 (set only if stat logging doesn't work by default)
-# stack = "0xE101440"
 ```
 
 ### Troubleshooting
@@ -207,6 +200,10 @@ python scripts/build.py [--upx-dir path/to/upx]
 ```
 use `--upx-dir` if you're using UPX to compress the executable.
 
+You can also use `build.bat` on Windows and `build.sh` on Linux to handle everything automatically.
+
+(No builds or build script are provided for macOS as I don't have a Mac to test, and my attempts at virtualizing macOS have been unsuccessful.)
+
 ## Acknowledgments
 - NWPlayer123 for the reference implementation of a TCPGecko library.
 

{splatlogger-1.2.3 → splatlogger-1.3.0}/README.md

@@ -49,6 +49,7 @@ To enable Cemu support, install with the `cemu` extra:
 ```
 pip install "Splatlogger[cemu]"
 ```
+(use `pip install --upgrade` to update from an older version)
 
 Then run with:
 ```
@@ -77,7 +78,7 @@ python -m splatlogger --ip IP [options] / --cemu [PID] [options]
   - `none` - Don't create a log file.
   - `standard` - Log only basic player information, the same as what's printed to the console (default).
   - `extended` - Log all player information and additional match information.
-  - `stats` - Same as above with the addition of player stats (points, K/D, win/lose) and disconnect detection.
+  - `full` - Same as above with the addition of player stats (points, K/D, win/lose), disconnect detection, and match results.
 Requires the match to end to finish logging; if it ends abruptly, the stats won't be logged.
 
 - `--service` - Choose which network service you're using.
@@ -92,11 +93,6 @@ Also allows you to view information about the lobby/gathering while on the match
 
     (These options don't affect anything if the log level is set to `none`)
 
-- `--stack Address (in hex)` - (Cemu only, optional) Beginning address of the stack space for Default Core 1 (Debug > View PPC threads).
-Only required for logging stats. If the default values don't work, you'll need to specify this manually.
-
-  <img src="assets/stack.png" width="600" alt="(example)">
-
 - `-sl`, `--single-log` - Enable single log mode. When enabled, only one log file will be created for each day and logging will resume in that file
 instead of creating a new one for each logging session (default behavior for `--auto latest`).
 
@@ -124,7 +120,7 @@ ip = "192.168.1.50"
 # Target network service: "pretendo", "altendo", or "none"
 service = "pretendo"
 
-# Log level: "standard", "extended", "stats", or "none"
+# Log level: "standard", "extended", "full", or "none"
 log_level = "extended"
 
 # Auto logging: "all", "latest" (omit for manual logging)
@@ -143,9 +139,6 @@ single_log = true
 # Cemu process ID (set to -1 to find automatically)
 # Uncomment this option to enable Cemu mode
 # cemu = -1
-
-# Beginning address of the stack space for Default Core 1 (set only if stat logging doesn't work by default)
-# stack = "0xE101440"
 ```
 
 ### Troubleshooting
@@ -182,6 +175,10 @@ python scripts/build.py [--upx-dir path/to/upx]
 ```
 use `--upx-dir` if you're using UPX to compress the executable.
 
+You can also use `build.bat` on Windows and `build.sh` on Linux to handle everything automatically.
+
+(No builds or build script are provided for macOS as I don't have a Mac to test, and my attempts at virtualizing macOS have been unsuccessful.)
+
 ## Acknowledgments
 - NWPlayer123 for the reference implementation of a TCPGecko library.
 

{splatlogger-1.2.3 → splatlogger-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Splatlogger"
-version = "1.2.3"
+version = "1.3.0"
 authors = [
     { name="Shadow Doggo", email="shadowdoggo@protonmail.com" }
 ]

{splatlogger-1.2.3 → splatlogger-1.3.0/src/Splatlogger.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Splatlogger
-Version: 1.2.3
+Version: 1.3.0
 Summary: PID Grabber and player/match information logging tool for Splatoon
 Author-email: Shadow Doggo <shadowdoggo@protonmail.com>
 License-Expression: MIT
@@ -74,6 +74,7 @@ To enable Cemu support, install with the `cemu` extra:
 ```
 pip install "Splatlogger[cemu]"
 ```
+(use `pip install --upgrade` to update from an older version)
 
 Then run with:
 ```
@@ -102,7 +103,7 @@ python -m splatlogger --ip IP [options] / --cemu [PID] [options]
   - `none` - Don't create a log file.
   - `standard` - Log only basic player information, the same as what's printed to the console (default).
   - `extended` - Log all player information and additional match information.
-  - `stats` - Same as above with the addition of player stats (points, K/D, win/lose) and disconnect detection.
+  - `full` - Same as above with the addition of player stats (points, K/D, win/lose), disconnect detection, and match results.
 Requires the match to end to finish logging; if it ends abruptly, the stats won't be logged.
 
 - `--service` - Choose which network service you're using.
@@ -117,11 +118,6 @@ Also allows you to view information about the lobby/gathering while on the match
 
     (These options don't affect anything if the log level is set to `none`)
 
-- `--stack Address (in hex)` - (Cemu only, optional) Beginning address of the stack space for Default Core 1 (Debug > View PPC threads).
-Only required for logging stats. If the default values don't work, you'll need to specify this manually.
-
-  <img src="assets/stack.png" width="600" alt="(example)">
-
 - `-sl`, `--single-log` - Enable single log mode. When enabled, only one log file will be created for each day and logging will resume in that file
 instead of creating a new one for each logging session (default behavior for `--auto latest`).
 
@@ -149,7 +145,7 @@ ip = "192.168.1.50"
 # Target network service: "pretendo", "altendo", or "none"
 service = "pretendo"
 
-# Log level: "standard", "extended", "stats", or "none"
+# Log level: "standard", "extended", "full", or "none"
 log_level = "extended"
 
 # Auto logging: "all", "latest" (omit for manual logging)
@@ -168,9 +164,6 @@ single_log = true
 # Cemu process ID (set to -1 to find automatically)
 # Uncomment this option to enable Cemu mode
 # cemu = -1
-
-# Beginning address of the stack space for Default Core 1 (set only if stat logging doesn't work by default)
-# stack = "0xE101440"
 ```
 
 ### Troubleshooting
@@ -207,6 +200,10 @@ python scripts/build.py [--upx-dir path/to/upx]
 ```
 use `--upx-dir` if you're using UPX to compress the executable.
 
+You can also use `build.bat` on Windows and `build.sh` on Linux to handle everything automatically.
+
+(No builds or build script are provided for macOS as I don't have a Mac to test, and my attempts at virtualizing macOS have been unsuccessful.)
+
 ## Acknowledgments
 - NWPlayer123 for the reference implementation of a TCPGecko library.
 

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "1.2.3"
+__version__ = "1.3.0"
 __author__ = "Shadow Doggo"

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/__main__.py

@@ -3,6 +3,5 @@ try:
 except ImportError:
     from splatlogger.cli import cli
 
-
 if __name__ == "__main__":
     cli()

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/cli.py

@@ -7,7 +7,7 @@ import webbrowser
 from pathlib import Path
 
 import userpaths
-from colorama import Fore, Style, just_fix_windows_console
+from colorama import just_fix_windows_console
 from prompt_toolkit import PromptSession
 from prompt_toolkit.patch_stdout import patch_stdout
 
@@ -70,7 +70,7 @@ def command_listener(ctx: AppContext) -> None:
 
 
 def parse_args() -> Options:
-    parser = argparse.ArgumentParser(description="PID (Principal ID)/Network ID grabber and match logger for Splatoon")
+    parser = argparse.ArgumentParser(description="PID Grabber and player/match information logging tool for Splatoon")
     add_parser_arguments(parser)
 
     config_path = Path(userpaths.get_my_documents()) / "Splatlogger/config.toml"
@@ -83,28 +83,25 @@ def parse_args() -> Options:
     args = parser.parse_args()
 
     if not args.ip and not args.cemu:
-        print(
-            f'{Fore.YELLOW}No target (IP address or Cemu mode) was provided. Run "splatlogger -h" for help.{Style.RESET_ALL}'
-            "\nWould you like to open the README? (y/n)")
+        uf.print_warning("No target (IP address or Cemu mode) was provided. Run \"splatlogger -h\" for help.\n")
+        print("Would 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()
 
-    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")
+        uf.print_warning("Silent mode is enabled and no log level is set. No information will be logged.\n")
 
-    return Options(ip=args.ip, log_level=args.log_level, auto_logging=args.auto in ("all", "latest"),
-                   log_latest=args.auto == "latest", platform="cemu" if args.cemu else "wiiu", cemu_pid=args.cemu,
-                   service=args.service, silent_logging=args.silent, single_log=args.single_log, stack=stack_addr)
+    return Options(
+        ip=args.ip,
+        log_level=args.log_level,
+        auto_logging=args.auto in ("all", "latest"),
+        log_latest=args.auto == "latest",
+        platform="cemu" if args.cemu else "wiiu", cemu_pid=args.cemu,
+        service=args.service,
+        silent_logging=args.silent,
+        single_log=args.single_log
+    )
 
 
 def add_parser_arguments(parser: argparse.ArgumentParser) -> None:
@@ -113,15 +110,12 @@ def add_parser_arguments(parser: argparse.ArgumentParser) -> None:
                         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")
+                        choices=["none", "standard", "extended", "full"], default="standard")
     parser.add_argument("--service", help="Choose which network service you're using (Pretendo by default).",
                         choices=["none", "pretendo", "altendo"], 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("-sl", "--single-log", help="Enable single log file mode.", action="store_true")
     parser.add_argument("-s", "--silent", help="Disable printing logs to the console.", action="store_true")
 
@@ -136,7 +130,7 @@ CONFIG_TEMPLATE = """# Splatlogger Configuration
 # Target network service: "pretendo", "altendo", or "none"
 # service = "pretendo"
 
-# Log level: "standard", "extended", "stats", or "none"
+# Log level: "standard", "extended", "full", or "none"
 # log_level = "standard"
 
 # Auto logging: "all", "latest" (omit for manual logging)
@@ -155,9 +149,6 @@ CONFIG_TEMPLATE = """# Splatlogger Configuration
 # Cemu process ID (set to -1 to find automatically)
 # Uncomment this option to enable Cemu mode
 # cemu = -1
-
-# Beginning address of the stack space for Default Core 1 (set only if stat logging doesn't work by default)
-# stack = "0xE101440"
 """
 
 

splatlogger-1.3.0/src/splatlogger/enums.py

@@ -0,0 +1,137 @@
+# Splatlogger (c) 2025 Shadow Doggo.
+
+from enum import Enum, IntEnum
+
+
+class Pointers(IntEnum):
+    SESSION = 0x101E8980
+    STATIC_MEM = 0x101DD330
+    MAIN_MGR_BASE = 0x101E2814
+    MAIN_MGR_VS_GAME = 0x101E4FF8
+    FRAMEWORK = 0x101E80A8
+
+    def convert(self, platform: str) -> int:
+        return self.value + Offsets.WIIU_BSS_OFFSET if platform == "wiiu" else self.value
+
+
+class Offsets(IntEnum):
+    WIIU_BSS_OFFSET = 0x503000
+    SESSION_ID_IDX = 0xBD
+    SESSION_ID = 0xCC
+    SESSION_ACTIVE_STATION_LIST_SENTINEL = 0xD8
+    SESSION_ACTIVE_STATION_LIST_FIRST_NODE_PTR = 0xDC
+    SESSION_ACTIVE_STATION_LIST_COUNT = 0xE0
+    SESSION_STATION_NODE_CAPACITY = 0xFC
+    STATION_LIST_NODE_PREV_PTR = 0x0
+    STATION_LIST_NODE_NEXT_PTR = 0x4
+    STATION_LIST_NODE_STATION_ID = 0x8
+    STATION_LIST_NODE_SIZE = 0x10
+    MAINMGR_PLAYER_MGR_PTR = 0x268
+    PLAYERMGR_PLAYER_COUNT = 0x320
+    MAINMGR_VS_GAME_SEQ_MGR_VS_GAME_PTR = 0x2A4
+    MAINMGR_VS_GAME_PAGE_HANDLER_PTR = 0x2D8
+    SEQ_MGR_VS_GAME_FINAL_RESULT_PTR = 0xAA8
+    SEQ_MGR_VS_GAME_FINAL_RESULT_SCORE_PTR = 0x294
+    SCORE_OBJECT_TEAM_RESULTS_ARY_PTR = 0x10
+    TEAM_RESULTS_ARY_SIZE_REGULAR = 0x18
+    TEAM_RESULTS_ARY_SIZE_RANKED = 0x2C
+    TEAM_RESULTS_PAINT_PC = 0x4
+    TEAM_RESULTS_WON = 0xC
+    TEAM_RESULTS_RANKED_OBJ_COUNT = 0x10
+    TEAM_RESULTS_POINTS = 0x14
+    PAGE_HANDLER_RESULTS_PAGE_PTR = 0x118
+    PAGE_HANDLER_LEADERBOARD_PAGE_PTR = 0x11C
+    RESULTS_PAGE_PHASE = 0x1E8
+    LEADERBOARD_PAGE_SLOTS = 0x214
+    LEADERBOARD_PAGE_ROWS_PTR = 0x218
+    ROWS_PLAYER_STRIDE = 0x20
+    ROWS_PLAYER_IDX = 0x0
+    ROWS_PLAYER_PLAYERINFO_PTR = 0x4
+    ROWS_PLAYER_TEAM = 0x8
+    ROWS_PLAYER_POINTS = 0xC
+    ROWS_PLAYER_KILLS = 0x10
+    ROWS_PLAYER_DEATHS = 0x14
+    ROWS_PLAYER_LOCAL_PLAYER_FLAG = 0x1C
+    FRAMEWORK_PEER_MGR_PTR = 0x14
+    PEER_MGR_ID_MGR_PTR = 0x84
+    ID_MGR_SLOT_ARY_PTR = 0x8
+    SLOT_SIZE = 0x14
+    SLOT_STATE = 0x0
+    SLOT_PID = 0x4
+    SLOT_PLAYER_ID = 0x12
+    STATICMEM_PLAYER_INFO_ARY_PTR = 0x10
+    STATICMEM_STAGE = 0x28
+    STATICMEM_MATCH_HOUR = 0x234
+    STATICMEM_VERSUS_MODE = 0x238
+    STATICMEM_VERSUS_RULE = 0x23C
+    PLAYER_INFO_NAME = 0x6
+    PLAYER_INFO_NAME_LENGTH = 0x20
+    PLAYER_INFO_REGION = 0x2C
+    PLAYER_INFO_TEAM = 0x33
+    PLAYER_INFO_GENDER = 0x37
+    PLAYER_INFO_SKIN_TONE = 0x3B
+    PLAYER_INFO_EYE_COLOR = 0x3F
+    PLAYER_INFO_WEAPON_SET = 0x42
+    PLAYER_INFO_MAIN_WEAPON = 0x46
+    PLAYER_INFO_SUB_WEAPON = 0x4A
+    PLAYER_INFO_SPECIAL_WEAPON = 0x4F
+    PLAYER_INFO_SHOES = 0x54
+    PLAYER_INFO_CLOTHES = 0x70
+    PLAYER_INFO_HEADGEAR = 0x8C
+    PLAYER_INFO_INK_TANK = 0xAA
+    PLAYER_INFO_LEVEL = 0xAF
+    PLAYER_INFO_RANK = 0xB3
+    PLAYER_INFO_FEST_TEAM = 0xB7
+    PLAYER_INFO_FEST_ID = 0xBA
+    PLAYER_INFO_FEST_RANK = 0xBF
+    PLAYER_INFO_PID = 0xD0
+    PLAYER_INFO_FEST_POWER = 0xD6
+    PLAYER_INFO_SIZE = 0xD8
+
+
+class OffsetChains(Enum):
+    ID_MANAGER = (
+        Offsets.FRAMEWORK_PEER_MGR_PTR,
+        Offsets.PEER_MGR_ID_MGR_PTR,
+        0
+    )
+    ID_MANAGER_SLOT_ARRAY = (
+        Offsets.ID_MGR_SLOT_ARY_PTR,
+        0
+    )
+    RESULTS_PHASE_ADDRESS = (
+        Offsets.MAINMGR_VS_GAME_PAGE_HANDLER_PTR,
+        Offsets.PAGE_HANDLER_RESULTS_PAGE_PTR,
+        Offsets.RESULTS_PAGE_PHASE
+    )
+    LEADERBOARD_PAGE = (
+        Offsets.MAINMGR_VS_GAME_PAGE_HANDLER_PTR,
+        Offsets.PAGE_HANDLER_LEADERBOARD_PAGE_PTR,
+        0
+    )
+    TEAM_RESULTS_ARRAY = (
+        Offsets.MAINMGR_VS_GAME_SEQ_MGR_VS_GAME_PTR,
+        Offsets.SEQ_MGR_VS_GAME_FINAL_RESULT_PTR,
+        Offsets.SEQ_MGR_VS_GAME_FINAL_RESULT_SCORE_PTR,
+        Offsets.SCORE_OBJECT_TEAM_RESULTS_ARY_PTR,
+        0
+    )
+
+    @property
+    def offsets(self) -> list[int]:
+        return list(self.value)
+
+
+class VSMode(IntEnum):
+    REGULAR = 0
+    GACHI = 1
+    FEST = 2
+    PRIVATE = 3
+    PARTY = 4
+
+
+class VSRule(IntEnum):
+    TURF = 0
+    RAINMAKER = 1
+    ZONES = 2
+    TOWER = 3

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/match_logger.py

@@ -1,7 +1,6 @@
 # Splatlogger (c) 2025 Shadow Doggo.
 
 import json
-import platform
 import sys
 import time
 from datetime import datetime
@@ -12,8 +11,8 @@ from typing import Any
 import userpaths  # type: ignore[import-untyped]
 
 from . import utility_functions as uf
-from .enums import Addresses, Offsets, Pointers, VSMode, VSRule
-from .tuples import AccountInfo, AppContext, CommonAddresses, PlayerInfo
+from .enums import OffsetChains, Offsets, Pointers, VSMode, VSRule
+from .tuples import AccountInfo, AppContext, CommonAddresses, PlayerInfo, PlayerStats, MatchResults
 
 
 def get_resource_path(relative_path: str | Path) -> Path:
@@ -76,27 +75,38 @@ class MatchLogger:
         match_info = self._get_match_info()
         versus_mode, versus_rule = match_info[2], match_info[3]
         if self._ctx.options.log_level == "standard":
-            match_log = (f"\nMatch {match_count}\n\n{uf.player_table_header(self._ctx.options.service == 'altendo')}\n"
-                         if self._ctx.options.auto_logging or self._ctx.options.single_log else
-                         f"\n{uf.player_table_header(self._ctx.options.service == 'altendo')}\n")
+            match_log = (
+                f"\nMatch {match_count}\n\n{uf.player_table_header(self._ctx.options.service == 'altendo')}\n"
+                if self._ctx.options.auto_logging or self._ctx.options.single_log
+                else f"\n{uf.player_table_header(self._ctx.options.service == 'altendo')}\n"
+            )
         else:
             match_log = self._format_match_info(match_count, date, session_id, match_info)
 
-        dcd_players: list[int] = []
-        if self._ctx.options.log_level == "stats":
-            if self._wait_for_results(adrs):
-                dcd_players = self._check_for_dcs(session_id)
+        dcd_players: set[int] = set()
+        stats: list[PlayerStats] = []
+        match_results: MatchResults | None = None
+        if self._ctx.options.log_level == "full":
+            if self._wait_for_results(adrs, dcd_players):
+                stats = self._get_player_stats()
+                match_results = self._get_match_results(versus_rule)
             else:
                 disconnect = True
 
+        stats_by_idx = {row.idx: row for row in stats}
+
         for player_info in player_info_list:
             match_log += self._format_match_log(player_info, versus_mode)
 
-            if self._ctx.options.log_level == "stats" and not disconnect:
-                if stats := self._get_player_stats(player_info, versus_rule, adrs, dcd_players):
-                    match_log += stats
-                else:
-                    disconnect = True
+            if self._ctx.options.log_level == "full" and not disconnect:
+                if (player_stats := stats_by_idx.get(player_info.idx)) is not None:
+                    match_log += self._format_stats_log(
+                        player_info, match_results.winning_team if match_results else None,
+                        versus_rule, player_stats, dcd_players
+                    )
+
+        if match_results:
+            match_log += self._format_match_results(match_results, versus_rule)
 
         if self._ctx.options.log_level == "standard":
             match_log += (
@@ -120,12 +130,12 @@ class MatchLogger:
 
     def _get_match_info(self) -> tuple[str, int, int, int]:
         return (
-            self._ctx.gecko.read_string(self._ctx.static_mem_adr + Offsets.STATICMEM_STAGE, length=32).split("\u0000")[
-                0],
-            self._ctx.gecko.peek8(self._ctx.static_mem_adr + Offsets.STATICMEM_MATCH_HOUR + 0x3),
-            # Read last byte as uint8
-            self._ctx.gecko.peek8(self._ctx.static_mem_adr + Offsets.STATICMEM_VERSUS_MODE + 0x3),
-            self._ctx.gecko.peek8(self._ctx.static_mem_adr + Offsets.STATICMEM_VERSUS_RULE + 0x3)
+            self._ctx.gecko.read_string(self._ctx.static_mem_adr + Offsets.STATICMEM_STAGE, length=32)
+            .split("\u0000")[0],
+            # Read last byte as sint8
+            self._ctx.gecko.peek8(self._ctx.static_mem_adr + Offsets.STATICMEM_MATCH_HOUR + 0x3, signed=True),
+            self._ctx.gecko.peek8(self._ctx.static_mem_adr + Offsets.STATICMEM_VERSUS_MODE + 0x3, signed=True),
+            self._ctx.gecko.peek8(self._ctx.static_mem_adr + Offsets.STATICMEM_VERSUS_RULE + 0x3, signed=True)
         )
 
     def _format_match_info(self, match_count: int, date: datetime, session_id: int,
@@ -160,7 +170,7 @@ class MatchLogger:
         )
 
         return (
-                uf.player_table_entry(player_info, AccountInfo(player_info.network_id, player_info.mii_name, "")) + "\n"
+            uf.player_table_entry(player_info, AccountInfo(player_info.network_id, player_info.mii_name, "")) + "\n"
         ) if self._ctx.options.log_level == "standard" else (
             f"\n{' ' * self._align}[Player {player_info.idx + 1}]\n"
             f"{indent}Name: {player_info.name}"
@@ -191,83 +201,144 @@ class MatchLogger:
             f"{fest_info if vs_mode == VSMode.FEST else ''}"
         )
 
-    # 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,
-                          dcd_players: list[int]) -> str | None:
-        stats_adr, win_team_adr = self._get_stats_addresses()
-
-        if self._ctx.options.platform == "wiiu":
-            # If on console, 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._ctx.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),
-                                      dcd_players)
-
-    def _get_stats_addresses(self) -> tuple[int, int]:
-        stats_adr: int = Addresses.STATS
-        win_team_adr: int = Addresses.WIN_TEAM
-
-        if self._ctx.options.platform == "cemu" and self._ctx.options.stack:
-            stats_adr = self._ctx.options.stack + Offsets.CEMU_STATS
-            win_team_adr = self._ctx.options.stack + Offsets.CEMU_WIN_TEAM
-        elif self._ctx.options.platform == "cemu":
-            # Assume default values if stack is not provided. These seem consistent across various systems.
-            stack_adr = Addresses.CEMU_STACK_DEFAULT_WINDOWS \
-                if platform.system() == "Windows" else Addresses.CEMU_STACK_DEFAULT_LINUX
-            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):
+    def _format_match_results(self, match_results: MatchResults, versus_rule: int) -> str:
+        indent = ' ' * (self._align + 2)
+
+        if versus_rule in (VSRule.RAINMAKER, VSRule.ZONES, VSRule.TOWER):
+            return (
+                f"\n{' ' * self._align}[Match Results]\n"
+                f"{indent}Winner: {'Bravo' if match_results.winning_team == 1 else 'Alpha'}\n"
+                f"{indent}Alpha points: {match_results.alpha_points}\n"
+                f"{indent}Bravo points: {match_results.bravo_points}\n"
+                f"{indent}Alpha score: {100 - match_results.alpha_count}\n"
+                f"{indent}Bravo score: {100 - match_results.bravo_count}\n"
+            )
+        else:
+            return (
+                f"\n{' ' * self._align}[Match Results]\n"
+                f"{indent}Winner: {'Bravo' if match_results.winning_team == 1 else 'Alpha'}\n"
+                f"{indent}Alpha painted: {match_results.alpha_paint_pc / 10:.1f}%\n"
+                f"{indent}Bravo painted: {match_results.bravo_paint_pc / 10:.1f}%\n"
+                f"{indent}Alpha points: {match_results.alpha_points}\n"
+                f"{indent}Bravo points: {match_results.bravo_points}\n"
+            )
+
+    def _wait_for_results(self, adrs: CommonAddresses, dcd_players: set[int]) -> bool:
+        id_mgr_adr = self._ctx.gecko.resolve_pointer_chain(
+            Pointers.FRAMEWORK.convert(self._ctx.options.platform),
+            OffsetChains.ID_MANAGER.offsets
+        )
+        slots_count = 0
+        slot_ary_adr = 0
+        if id_mgr_adr != 0:
+            slots_count = self._ctx.gecko.peek32(id_mgr_adr)
+            slot_ary_adr = self._ctx.gecko.peek32(id_mgr_adr + Offsets.ID_MGR_SLOT_ARY_PTR)
+
+        for _ in range(300):
             if not self._is_player_in_vs_match():
                 return False
 
-            scene_info_adr = self._ctx.gecko.peek32(adrs.main_mgr_base_adr + Offsets.MAINMGR_SCENE_INFO)
-            if self._ctx.gecko.peek32(scene_info_adr + Offsets.SCENE_INFO_RESULTS_SHOWN) == 0:  # Some sort of timer?
-                return True
+            phase_adr = self._ctx.gecko.resolve_pointer_chain(
+                Pointers.MAIN_MGR_VS_GAME.convert(self._ctx.options.platform),
+                OffsetChains.RESULTS_PHASE_ADDRESS.offsets
+            )
 
-            time.sleep(3)
+            if phase_adr != 0:
+                phase = self._ctx.gecko.peek8(phase_adr)
+                if 2 <= phase <= 14:  # Judging/results states post fade-in.
+                    return True
+
+            dcd_players.update(self._check_for_dcs(slots_count, slot_ary_adr))
+
+            time.sleep(2)
 
         return False
 
-    def _read_player_stats(self, stats_adr: int, player_idx: int) -> tuple[int, int, int]:
-        stats = self._ctx.gecko.peek_raw(stats_adr, length=Offsets.STATS_BUFFER_LENGTH)
-        offset = player_idx * Offsets.STATS_PLAYER_STRIDE
+    def _get_player_stats(self) -> list[PlayerStats]:
+        leaderboard_page_adr = self._ctx.gecko.resolve_pointer_chain(
+            Pointers.MAIN_MGR_VS_GAME.convert(self._ctx.options.platform),
+            OffsetChains.LEADERBOARD_PAGE.offsets
+        )
+        if leaderboard_page_adr == 0:
+            return []
+
+        leaderboard_slots_num = self._ctx.gecko.peek32(leaderboard_page_adr + Offsets.LEADERBOARD_PAGE_SLOTS)
+        leaderboard_rows_adr = self._ctx.gecko.peek32(leaderboard_page_adr + Offsets.LEADERBOARD_PAGE_ROWS_PTR)
 
-        points = uf.read_int(stats, offset + Offsets.STATS_POINTS, 2)
-        kills = uf.read_int(stats, offset + Offsets.STATS_KILLS, 2)
-        deaths = uf.read_int(stats, offset + Offsets.STATS_DEATHS, 2)
+        if not 1 <= leaderboard_slots_num <= 8 or leaderboard_rows_adr == 0:
+            return []
 
-        return points, kills, deaths
+        size = leaderboard_slots_num * Offsets.ROWS_PLAYER_STRIDE
+        stats = self._ctx.gecko.peek_raw(leaderboard_rows_adr, length=size)
+        slots = []
+        for slot in range(leaderboard_slots_num):
+            offset = slot * Offsets.ROWS_PLAYER_STRIDE
+            idx = uf.read_int(stats, offset + Offsets.ROWS_PLAYER_IDX, 4, signed=True)
+            team = uf.read_int(stats, offset + Offsets.ROWS_PLAYER_TEAM, 4, signed=True)
+            if not 0 <= idx < 8 or team not in (0, 1): continue
+            points = uf.read_int(stats, offset + Offsets.ROWS_PLAYER_POINTS, 4)
+            kills = uf.read_int(stats, offset + Offsets.ROWS_PLAYER_KILLS, 4)
+            deaths = uf.read_int(stats, offset + Offsets.ROWS_PLAYER_DEATHS, 4)
+            local_player = uf.read_int(stats, offset + Offsets.ROWS_PLAYER_LOCAL_PLAYER_FLAG, 1) == 1
+
+            slots.append(PlayerStats(idx, team, points, kills, deaths, local_player))
+
+        return sorted(slots, key=lambda x: x.idx)
+
+    def _get_match_results(self, versus_rule: int) -> MatchResults | None:
+        team_results_ary_adr = self._ctx.gecko.resolve_pointer_chain(
+            Pointers.MAIN_MGR_VS_GAME.convert(self._ctx.options.platform),
+            OffsetChains.TEAM_RESULTS_ARRAY.offsets
+        )
+        if team_results_ary_adr == 0:
+            return None
+
+        if versus_rule in (VSRule.RAINMAKER, VSRule.ZONES, VSRule.TOWER):
+            alpha_results = self._ctx.gecko.peek_raw(team_results_ary_adr, Offsets.TEAM_RESULTS_ARY_SIZE_RANKED)
+            bravo_results = self._ctx.gecko.peek_raw(team_results_ary_adr + Offsets.TEAM_RESULTS_ARY_SIZE_RANKED,
+                                                     Offsets.TEAM_RESULTS_ARY_SIZE_RANKED)
+
+            return MatchResults(
+                winning_team=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_WON, 1),
+                alpha_paint_pc=uf.read_int(alpha_results, Offsets.TEAM_RESULTS_PAINT_PC, 4),
+                bravo_paint_pc=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_PAINT_PC, 4),
+                alpha_points=uf.read_int(alpha_results, Offsets.TEAM_RESULTS_POINTS, 4),
+                bravo_points=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_POINTS, 4),
+                alpha_count=uf.read_int(alpha_results, Offsets.TEAM_RESULTS_RANKED_OBJ_COUNT, 4),
+                bravo_count=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_RANKED_OBJ_COUNT, 4)
+            )
+
+        alpha_results = self._ctx.gecko.peek_raw(team_results_ary_adr, Offsets.TEAM_RESULTS_ARY_SIZE_REGULAR)
+        bravo_results = self._ctx.gecko.peek_raw(team_results_ary_adr + Offsets.TEAM_RESULTS_ARY_SIZE_REGULAR,
+                                                 Offsets.TEAM_RESULTS_ARY_SIZE_REGULAR)
+
+        return MatchResults(
+            winning_team=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_WON, 1),
+            alpha_paint_pc=uf.read_int(alpha_results, Offsets.TEAM_RESULTS_PAINT_PC, 4),
+            bravo_paint_pc=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_PAINT_PC, 4),
+            alpha_points=uf.read_int(alpha_results, Offsets.TEAM_RESULTS_POINTS, 4),
+            bravo_points=uf.read_int(bravo_results, Offsets.TEAM_RESULTS_POINTS, 4),
+            alpha_count=0,
+            bravo_count=0
+        )
 
-    def _format_stats_log(self, player_info: PlayerInfo, winning_team: int, versus_rule: int,
-                          stats: tuple[int, int, int], dcd_players: list) -> str:
+    def _format_stats_log(self, player_info: PlayerInfo, winning_team: int | None, versus_rule: int,
+                          stats: PlayerStats, dcd_players: set[int]) -> str:
         indent = " " * (self._align + 2)
-        player_won = player_info.team == winning_team
+        player_won = player_info.team == winning_team if winning_team is not None else None
         player_dcd = player_info.pid in dcd_players
-        points, kills, deaths = stats
 
         points_log = ""
         if versus_rule == VSRule.TURF:  # 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"
+                points_log = f"{indent}Points: {stats.points}p ({stats.points - 1000}p w/o win bonus)\n"
             else:
-                points_log = f"{indent}Points: {points}p\n"
+                points_log = f"{indent}Points: {stats.points}p\n"
 
         if player_dcd:
             result = "Disconnected"
+        elif player_won is None:
+            result = "Unknown"
         elif player_won:
             result = "Win"
         else:
@@ -275,47 +346,26 @@ class MatchLogger:
 
         return (
             f"{points_log}"
-            f"{indent}K/D: {kills}/{deaths}\n"
+            f"{indent}K/D: {stats.kills}/{stats.deaths}\n"
             f"{indent}Result: {result}\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._ctx.gecko.peek32(player_info_ary_adr)
-
-        # Check default offsets of 0 and -0x38 first. The pointer is at 0x30.
-        if self._ctx.gecko.peek32(Addresses.STATS + 0x30) == first_player_info_adr:
-            return 0
-        if self._ctx.gecko.peek32(Addresses.STATS - 0x8) == first_player_info_adr:
-            return -0x38
-
-        search_space = self._ctx.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
-
-    def _check_for_dcs(self, session_id: int) -> list[int]:
-        # Magic numbers here cause I have no idea what class/struct this belongs to,
-        # I just happened to find a pointer chain to it.
-        lobby_history_adr = self._ctx.gecko.resolve_pointer_chain(0x106EB0A0, [0xC, 0x78, 0x10])
-        if lobby_history_adr == 0:
-            return []
-
-        lobby_history = self._ctx.gecko.peek_raw(lobby_history_adr, length=0x1D0)
+    def _check_for_dcs(self, slots_count: int, slot_ary_adr: int) -> set[int]:
+        dcd_players: set[int] = set()
 
-        latest_player_status: dict[int, int] = {}
+        for offset in range(0, slots_count * 4, 4):
+            slot_adr = self._ctx.gecko.peek32(slot_ary_adr + offset)
+            if slot_adr == 0: continue
+            slot = self._ctx.gecko.peek_raw(slot_adr, Offsets.SLOT_SIZE)
 
-        offset = 0
-        while uf.read_int(lobby_history, offset, 4) not in (0, 0x6D):  # 0x6D acts as a separator
-            if uf.read_int(lobby_history, 0x8 + offset, 4) == session_id:
-                status = uf.read_int(lobby_history, 0x4 + offset, 4)
-                player_id = uf.read_int(lobby_history, 0xC + offset, 4)
-                latest_player_status[player_id] = status
+            state = uf.read_int(slot, Offsets.SLOT_STATE, 4)
+            pid = uf.read_int(slot, Offsets.SLOT_PID, 4)
+            player_id = uf.read_int(slot, Offsets.SLOT_PLAYER_ID, 1)
 
-            offset += 0x10
+            if state == 3 and player_id != 0xFF:
+                dcd_players.add(pid)
 
-        # I'm p sure 0x8 means the player left or got kicked and 0x7 means they abruptly disconnected from the mesh.
-        return [player_id for player_id, status in latest_player_status.items() if status == 0x7 or status == 0x8]
+        return dcd_players
 
     def _is_player_in_vs_match(self) -> bool:
-        return self._ctx.gecko.peek32(uf.convert_ptr(Pointers.MAIN_MGR_VS_GAME, self._ctx.options.platform)) != 0
+        return self._ctx.gecko.peek32(Pointers.MAIN_MGR_VS_GAME.convert(self._ctx.options.platform)) != 0

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/resources/names.json

@@ -5,12 +5,12 @@
   },
 
   "versus_mode_name": {
+    "-1": "?cNone",
     "0": "Regular Battle",
     "1": "Ranked Battle",
     "2": "Splatfest Battle",
     "3": "Private Battle",
-    "4": "Squad Battle",
-    "255": "None"
+    "4": "Squad Battle"
   },
 
   "versus_rule_name": {
@@ -18,8 +18,7 @@
     "0": "Turf War",
     "1": "Rainmaker",
     "2": "Splat Zones",
-    "3": "Tower Control",
-    "255": "None"
+    "3": "Tower Control"
   },
 
   "team_name": {

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/splatlogger.py

@@ -17,10 +17,10 @@ import userpaths  # type: ignore[import-untyped]
 
 from . import utility_functions as uf
 from .enums import Offsets, Pointers
+from .errors import SplatloggerError
 from .match_logger import MatchLogger
 from .tcpgecko import GeckoConnectionFailedError, TCPGecko
 from .tuples import AccountInfo, AppContext, CommonAddresses, Options, PlayerInfo
-from .errors import SplatloggerError
 
 if TYPE_CHECKING:
     from .cemu_gecko import CemuGecko
@@ -90,7 +90,8 @@ def command_lobby_info(ctx: AppContext) -> bool:
 
             # Not reading through names.json just for this.
             vs_modes = (
-                "Regular Battle", "Ranked Battle", "Splatfest Battle", "Private Battle", "Squad Battle")
+                "Regular Battle", "Ranked Battle", "Splatfest Battle", "Private Battle", "Squad Battle"
+            )
             vs_mode = ctx.gecko.peek8(ctx.static_mem_adr + Offsets.STATICMEM_VERSUS_MODE + 0x3)
             print(f"Lobby type: {vs_modes[vs_mode] if 0 <= vs_mode < len(vs_modes) else 'Unknown'}")
 
@@ -101,7 +102,7 @@ def command_lobby_info(ctx: AppContext) -> bool:
                     f"\n{'PID':<10} | {'ANID' if ctx.options.service == 'altendo' else 'PNID':<16}\n{'-' * 30}"
                 )
                 for player in players:
-                    print(f"{player[0]} | {player[1]}")
+                    print(f"{player[0]:<10} | {player[1]}")
         else:
             print("\nNo active session.")
     finally:
@@ -156,7 +157,7 @@ def create_tcpgecko_instance(options: Options) -> TCPGecko | CemuGecko:
 
 @uf.handle_gecko_errors
 def get_static_mem_adr(gecko: TCPGecko | CemuGecko, options: Options) -> int:
-    static_mem_adr = gecko.peek32(uf.convert_ptr(Pointers.STATIC_MEM, options.platform))
+    static_mem_adr = gecko.peek32(Pointers.STATIC_MEM.convert(options.platform))
     if static_mem_adr == 0:
         msg = (
             "Successfully opened Cemu process but could not read StaticMem address. "
@@ -229,13 +230,13 @@ def splatlog(ctx: AppContext, match_logger: MatchLogger | None, match_count: int
 
 @uf.handle_gecko_errors
 def get_common_addresses(ctx: AppContext) -> CommonAddresses:
-    return CommonAddresses(ctx.gecko.peek32(uf.convert_ptr(Pointers.MAIN_MGR_BASE, ctx.options.platform)),
-                           ctx.gecko.peek32(ctx.static_mem_adr + Offsets.STATICMEM_PLAYER_INFO_ARY))
+    return CommonAddresses(ctx.gecko.peek32(Pointers.MAIN_MGR_BASE.convert(ctx.options.platform)),
+                           ctx.gecko.peek32(ctx.static_mem_adr + Offsets.STATICMEM_PLAYER_INFO_ARY_PTR))
 
 
 @uf.handle_gecko_errors
 def get_session_id(ctx: AppContext) -> int:
-    if (session_adr := ctx.gecko.peek32(uf.convert_ptr(Pointers.SESSION, ctx.options.platform))) != 0:
+    if (session_adr := ctx.gecko.peek32(Pointers.SESSION.convert(ctx.options.platform))) != 0:
         session_id_idx = int.from_bytes(ctx.gecko.peek_raw(session_adr + Offsets.SESSION_ID_IDX,
                                                            length=1), byteorder="big")
         return ctx.gecko.peek32(session_adr + session_id_idx * 4 + Offsets.SESSION_ID)
@@ -246,10 +247,14 @@ def get_session_id(ctx: AppContext) -> int:
 @uf.handle_gecko_errors
 def get_player_count(ctx: AppContext, main_mgr_base_adr: int) -> int:
     if is_player_in_vs_match(ctx) or ctx.options.auto_logging:
-        player_count = ctx.gecko.resolve_pointer_chain(main_mgr_base_adr,
-                                                       [Offsets.MAINMGR_PLAYER_MGR, Offsets.PLAYERMGR_PLAYER_COUNT])
-        if player_count != 0:
-            return player_count
+        player_count_adr = ctx.gecko.resolve_pointer_chain(
+            main_mgr_base_adr + Offsets.MAINMGR_PLAYER_MGR_PTR,
+            [Offsets.PLAYERMGR_PLAYER_COUNT]
+        )
+        if player_count_adr != 0:
+            player_count = ctx.gecko.peek32(player_count_adr)
+            if 1 <= player_count <= 8:
+                return player_count
     else:
         uf.print_warning("You are currently not in a match. Logging previous match data "
                          "(Player 1 data will be your own, Session ID will be the current one).\n")
@@ -259,19 +264,19 @@ def get_player_count(ctx: AppContext, main_mgr_base_adr: int) -> int:
 
 @uf.handle_gecko_errors
 def is_player_in_vs_match(ctx: AppContext) -> bool:
-    return ctx.gecko.peek32(uf.convert_ptr(Pointers.MAIN_MGR_VS_GAME, ctx.options.platform)) != 0
+    return ctx.gecko.peek32(Pointers.MAIN_MGR_VS_GAME.convert(ctx.options.platform)) != 0
 
 
-def collect_player_info(ctx: AppContext, player_count: int, player_info_ary_adr: int) -> Iterator[
-    tuple[PlayerInfo, AccountInfo]]:
+def collect_player_info(ctx: AppContext, player_count: int,
+                        player_info_ary_adr: int) -> Iterator[tuple[PlayerInfo, AccountInfo]]:
     for player_idx in range(player_count):
         if player_info_tuple := get_player_info(ctx, player_idx, player_info_ary_adr):
             yield player_info_tuple
 
 
 @uf.handle_gecko_errors
-def get_player_info(ctx: AppContext, player_idx: int, player_info_ary_adr: int) -> tuple[
-                                                                                       PlayerInfo, AccountInfo] | None:
+def get_player_info(ctx: AppContext, player_idx: int,
+                    player_info_ary_adr: int) -> tuple[PlayerInfo, AccountInfo] | None:
     player_info_adr = ctx.gecko.peek32(player_info_ary_adr + player_idx * 0x4)
     if player_info_adr == 0:
         return None
@@ -290,17 +295,22 @@ def get_player_info(ctx: AppContext, player_idx: int, player_info_ary_adr: int)
 
 
 def decode_player_name(player_info_raw: bytes) -> str:
-    return clean(player_info_raw[Offsets.PLAYER_INFO_NAME:Offsets.PLAYER_INFO_NAME + Offsets.PLAYER_INFO_NAME_LENGTH]
-                 .decode("utf-16-be", errors="replace")
-                 .split("\u0000")[0],
-                 to_ascii=False, lower=False, no_line_breaks=True)
+    return clean(
+        player_info_raw[Offsets.PLAYER_INFO_NAME:Offsets.PLAYER_INFO_NAME + Offsets.PLAYER_INFO_NAME_LENGTH]
+        .decode("utf-16-be", errors="replace")
+        .split("\u0000")[0],
+        to_ascii=False,
+        lower=False,
+        no_line_breaks=True
+    )
 
 
 def get_player_account_info(ctx: AppContext, player_pid: int, player_name: str) -> AccountInfo:
     if ctx.options.service == "none":
         return AccountInfo("", player_name, "")
 
-    act_info = get_altendo_account_info(player_pid) if ctx.options.service == "altendo" else get_pn_account_info(player_pid)
+    act_info = get_altendo_account_info(player_pid) if ctx.options.service == "altendo" else get_pn_account_info(
+        player_pid)
     if act_info.request_error:
         return AccountInfo("", player_name, act_info.request_error)
 
@@ -316,7 +326,7 @@ def build_player_info(player_idx: int, player_pid: int, player_name: str, act_in
         name=player_name,
         mii_name=act_info.mii_name,
         region=uf.read_int(player_info_raw, Offsets.PLAYER_INFO_REGION, 4),
-        team=uf.read_int(player_info_raw, Offsets.PLAYER_INFO_TEAM, 1),
+        team=uf.read_int(player_info_raw, Offsets.PLAYER_INFO_TEAM, 1, signed=True),
         gender=uf.read_int(player_info_raw, Offsets.PLAYER_INFO_GENDER, 1),
         skin_tone=uf.read_int(player_info_raw, Offsets.PLAYER_INFO_SKIN_TONE, 1),
         eye_color=uf.read_int(player_info_raw, Offsets.PLAYER_INFO_EYE_COLOR, 1),
@@ -339,32 +349,40 @@ def build_player_info(player_idx: int, player_pid: int, player_name: str, act_in
 
 @uf.handle_gecko_errors
 def get_lobby_players(ctx: AppContext) -> list[tuple[int, str]] | None:
-    # The game stores the active players in the lobby in a doubly linked list with a sentinel node on each end.
-    head_node_adr = ctx.gecko.resolve_pointer_chain(uf.convert_ptr(Pointers.SESSION, ctx.options.platform),
-                                                    [Offsets.SESSION_LOBBY, Offsets.LOBBY_PLAYER_LIST_HEAD])
-    if head_node_adr == 0:
+    session_adr = ctx.gecko.peek32(Pointers.SESSION.convert(ctx.options.platform))
+    if session_adr == 0:
         return None
 
-    # The 'prev' pointer of the head node points to the sentinel node.
-    sentinel_node_adr = ctx.gecko.peek32(head_node_adr)
+    # Circular doubly linked list with a sentinel embedded in Session.
+    sentinel_adr = session_adr + Offsets.SESSION_ACTIVE_STATION_LIST_SENTINEL
+    header = ctx.gecko.peek_raw(sentinel_adr, 0xC)
+    current_node = uf.read_int(header, Offsets.STATION_LIST_NODE_NEXT_PTR, 4)
+    count = uf.read_int(header,
+                        Offsets.SESSION_ACTIVE_STATION_LIST_COUNT - Offsets.SESSION_ACTIVE_STATION_LIST_SENTINEL, 4)
+    capacity = ctx.gecko.peek32(session_adr + Offsets.SESSION_STATION_NODE_CAPACITY)
+
+    if not 0 <= count <= capacity <= 10:
+        return None
 
-    players = []
+    player_ids = []
+    previous_node = sentinel_adr
 
-    current_node = head_node_adr
-    count = 0
-    while current_node != sentinel_node_adr and current_node != 0 and count < 8:
-        node_data = ctx.gecko.peek_raw(current_node + 0x4, 8)
+    for _ in range(count):
+        if current_node == 0 or current_node == sentinel_adr:
+            return None
 
-        next_node = uf.read_int(node_data, 0x0, 4)
-        player_id = uf.read_int(node_data, 0x4, 4)
+        node = ctx.gecko.peek_raw(current_node, Offsets.STATION_LIST_NODE_SIZE)
+        if uf.read_int(node, Offsets.STATION_LIST_NODE_PREV_PTR, 4) != previous_node:
+            return None
 
+        player_id = uf.read_int(node, Offsets.STATION_LIST_NODE_STATION_ID, 4)
         if player_id != 0:
-            players.append((player_id, get_player_account_info(ctx, player_id, "").network_id))
+            player_ids.append(player_id)
 
-        current_node = next_node
-        count += 1
+        previous_node = current_node
+        current_node = uf.read_int(node, Offsets.STATION_LIST_NODE_NEXT_PTR, 4)
 
-    return players
+    return [(pid, get_player_account_info(ctx, pid, "").network_id) for pid in player_ids]
 
 
 def get_pn_account_info(player_pid: int) -> AccountInfo:

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/tuples.py

@@ -22,7 +22,6 @@ class Options(NamedTuple):
     service: str
     single_log: bool
     silent_logging: bool
-    stack: int | None
 
 
 @dataclass
@@ -72,3 +71,22 @@ class PlayerInfo(NamedTuple):
     fest_id: int
     fest_rank: int
     fest_power: int
+
+
+class PlayerStats(NamedTuple):
+    idx: int
+    team: int
+    points: int
+    kills: int
+    deaths: int
+    local_player: bool
+
+
+class MatchResults(NamedTuple):
+    winning_team: int
+    alpha_paint_pc: int
+    bravo_paint_pc: int
+    alpha_points: int
+    bravo_points: int
+    alpha_count: int
+    bravo_count: int

{splatlogger-1.2.3 → splatlogger-1.3.0}/src/splatlogger/utility_functions.py

@@ -13,7 +13,6 @@ from xml.etree import ElementTree
 import requests
 from colorama import Fore, Style
 
-from .enums import Offsets
 from .errors import SplatloggerError
 from .tcpgecko import GeckoConnectionClosedError, GeckoReadMemError, TCPGeckoError
 from .tuples import AccountInfo, PlayerInfo
@@ -32,21 +31,19 @@ def player_table_header(altendo: bool) -> str:
 
 
 def player_table_entry(player_info: PlayerInfo, act_info: AccountInfo) -> str:
-    return (f"Player {player_info.idx + 1} | "
-            f"{player_info.pid:<10} | "
-            f"{act_info.network_id:<16} | "
-            f"{player_info.name}"
-            f"{f' ({act_info.mii_name})' if not compare_names(player_info.name, act_info.mii_name) else ''}")
+    return (
+        f"Player {player_info.idx + 1} | "
+        f"{player_info.pid:<10} | "
+        f"{act_info.network_id:<16} | "
+        f"{player_info.name}"
+        f"{f' ({act_info.mii_name})' if not compare_names(player_info.name, act_info.mii_name) else ''}"
+    )
 
 
 def read_int(data: bytes, offset: int, length: int, *, signed: bool = False) -> int:
     return int.from_bytes(data[offset:offset + length], byteorder="big", signed=signed)
 
 
-def convert_ptr(address: int, platform: str):
-    return address + Offsets.WIIU_BSS_OFFSET if platform == "wiiu" else address
-
-
 def handle_gecko_errors(func: Callable[..., Any]) -> Any:
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any):

splatlogger-1.2.3/src/splatlogger/enums.py

@@ -1,81 +0,0 @@
-# Splatlogger (c) 2025 Shadow Doggo.
-
-from enum import IntEnum
-
-
-class Pointers(IntEnum):
-    SESSION = 0x101E8980
-    STATIC_MEM = 0x101DD330
-    MAIN_MGR_BASE = 0x101E2814
-    MAIN_MGR_VS_GAME = 0x101E4FF8
-
-
-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
-    CEMU_STACK_DEFAULT_WINDOWS = 0xE101440
-    CEMU_STACK_DEFAULT_LINUX = 0xE175900
-
-
-class Offsets(IntEnum):
-    WIIU_BSS_OFFSET = 0x503000
-    SESSION_LOBBY = 0xB0
-    SESSION_ID_IDX = 0xBD
-    SESSION_ID = 0xCC
-    LOBBY_PLAYER_LIST_HEAD = 0xA4
-    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
-    PLAYER_INFO_NAME = 0x6
-    PLAYER_INFO_NAME_LENGTH = 0x20
-    PLAYER_INFO_REGION = 0x2C
-    PLAYER_INFO_TEAM = 0x33
-    PLAYER_INFO_GENDER = 0x37
-    PLAYER_INFO_SKIN_TONE = 0x3B
-    PLAYER_INFO_EYE_COLOR = 0x3F
-    PLAYER_INFO_WEAPON_SET = 0x42
-    PLAYER_INFO_MAIN_WEAPON = 0x46
-    PLAYER_INFO_SUB_WEAPON = 0x4A
-    PLAYER_INFO_SPECIAL_WEAPON = 0x4F
-    PLAYER_INFO_SHOES = 0x54
-    PLAYER_INFO_CLOTHES = 0x70
-    PLAYER_INFO_HEADGEAR = 0x8C
-    PLAYER_INFO_INK_TANK = 0xAA
-    PLAYER_INFO_LEVEL = 0xAF
-    PLAYER_INFO_RANK = 0xB3
-    PLAYER_INFO_FEST_TEAM = 0xB7
-    PLAYER_INFO_FEST_ID = 0xBA
-    PLAYER_INFO_FEST_RANK = 0xBF
-    PLAYER_INFO_PID = 0xD0
-    PLAYER_INFO_FEST_POWER = 0xD6
-    PLAYER_INFO_SIZE = 0xD8
-    STATS_BUFFER_LENGTH = 0x124
-    STATS_PLAYER_STRIDE = 0x20
-    STATS_POINTS = 0x3A
-    STATS_KILLS = 0x3E
-    STATS_DEATHS = 0x42
-
-
-class VSMode(IntEnum):
-    REGULAR = 0
-    GACHI = 1
-    FEST = 2
-    PRIVATE = 3
-    PARTY = 4
-
-
-class VSRule(IntEnum):
-    TURF = 0
-    RAINMAKER = 1
-    ZONES = 2
-    TOWER = 3