Wind Waker: Support for Universal Tracker.

worlds/tww/Items.py

@@ -267,6 +267,8 @@ def dungeon_item(self) -> Optional[str]:
     "WT Compass":                TWWItemData("Compass",   IC.filler,                     153,  1, 0x85),
 
     "Victory":                   TWWItemData("Event",     IC.progression,               None,  1, None),
+    # Universal Tracker Item, keep at the bottom
+    "Glitched":                  TWWItemData("Event",     IC.progression,               None,  1, None),
 }
 
 ISLAND_NUMBER_TO_CHART_NAME = {

worlds/tww/Rules.py

@@ -3,7 +3,7 @@
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
-from BaseClasses import MultiWorld
+from BaseClasses import CollectionState, MultiWorld
 from worlds.AutoWorld import LogicMixin
 from worlds.generic.Rules import set_rule
 
@@ -74,6 +74,49 @@ def _tww_precise_3(self, player: int) -> bool:
     def _tww_tuner_logic_enabled(self, player: int) -> bool:
         return self.multiworld.worlds[player].logic_tuner_logic_enabled
 
+def mix_in_universal_tracker_logic() -> None:
+    """
+    Mix in Universal Tracker-specific logic methods that include glitched item checks.
+    This replaces the normal logic difficulty methods with UT versions on the CollectionState class.
+    """
+    # If already mixed in (CollectionState methods have been replaced), return early
+    if getattr(CollectionState, "_tww_ut_logic_mixed_in", False):
+        return
+
+    def _tww_obscure_1(self, player: int) -> bool:
+        return self.multiworld.worlds[player].logic_obscure_1 or self.has("Glitched", player)
+
+    def _tww_obscure_2(self, player: int) -> bool:
+        return self.multiworld.worlds[player].logic_obscure_2 or self.has("Glitched", player)
+
+    def _tww_obscure_3(self, player: int) -> bool:
+        return self.multiworld.worlds[player].logic_obscure_3 or self.has("Glitched", player)
+
+    def _tww_precise_1(self, player: int) -> bool:
+        return self.multiworld.worlds[player].logic_precise_1 or self.has("Glitched", player)
+
+    def _tww_precise_2(self, player: int) -> bool:
+        return self.multiworld.worlds[player].logic_precise_2 or self.has("Glitched", player)
+
+    def _tww_precise_3(self, player: int) -> bool:
+        return self.multiworld.worlds[player].logic_precise_3 or self.has("Glitched", player)
+
+    mix_in_methods = {k: v for k, v in locals().items() if k.startswith("_tww_")}
+
+    if len(mix_in_methods) != 6:
+        raise Exception(f"Expected 6 mix-in methods to replace, but got {len(mix_in_methods)}")
+
+    for k, v in mix_in_methods.items():
+        if not hasattr(TWWLogic, k):
+            raise Exception(f"{k} must be present on TWWLogic")
+        if not hasattr(CollectionState, k):
+            raise Exception(f"{k} must be present on CollectionState")
+        # Replace the normal mixed-in method with the Universal Tracker version.
+        setattr(CollectionState, k, v)
+
+    # Mark that mixing has been completed
+    CollectionState._tww_ut_logic_mixed_in = True
+
 
 def set_rules(world: "TWWWorld") -> None:  # noqa: F405
     """

worlds/tww/TWWClient.py

@@ -86,7 +86,7 @@
 CLIFF_PLATEAU_ISLES_HIGHEST_ISLE_DUMMY_STAGE_NAME = "CliPlaH"
 
 # Data storage key
-AP_VISITED_STAGE_NAMES_KEY_FORMAT = "tww_visited_stages_%i"
+AP_VISITED_STAGE_NAMES_KEY_FORMAT = "tww_visited_stages_%i_%i"
 
 
 class TWWCommandProcessor(ClientCommandProcessor):
@@ -207,13 +207,13 @@ def on_package(self, cmd: str, args: dict[str, Any]) -> None:
             if "death_link" in args["slot_data"]:
                 Utils.async_start(self.update_death_link(bool(args["slot_data"]["death_link"])))
             # Request the connected slot's dictionary (used as a set) of visited stages.
-            visited_stages_key = AP_VISITED_STAGE_NAMES_KEY_FORMAT % self.slot
+            visited_stages_key = AP_VISITED_STAGE_NAMES_KEY_FORMAT % (self.slot, self.team)
             Utils.async_start(self.send_msgs([{"cmd": "Get", "keys": [visited_stages_key]}]))
         elif cmd == "Retrieved":
             requested_keys_dict = args["keys"]
             # Read the connected slot's dictionary (used as a set) of visited stages.
             if self.slot is not None:
-                visited_stages_key = AP_VISITED_STAGE_NAMES_KEY_FORMAT % self.slot
+                visited_stages_key = AP_VISITED_STAGE_NAMES_KEY_FORMAT % (self.slot, self.team)
                 if visited_stages_key in requested_keys_dict:
                     visited_stages = requested_keys_dict[visited_stages_key]
                     # If it has not been set before, the value in the response will be `None`.
@@ -249,21 +249,38 @@ async def update_visited_stages(self, newly_visited_stage_name: str) -> None:
         """
         Update the server's data storage of the visited stage names to include the newly visited stage name.
 
+        This sends two types of messages:
+        1. A dict-based update to tww_visited_stages_<slot> for PopTracker compatibility
+        2. Individual SET messages for tww_<team>_<slot>_<stagename> to trigger server-side reconnection
+
         :param newly_visited_stage_name: The name of the stage recently visited.
         """
         if self.slot is not None:
-            visited_stages_key = AP_VISITED_STAGE_NAMES_KEY_FORMAT % self.slot
-            await self.send_msgs(
-                [
-                    {
-                        "cmd": "Set",
-                        "key": visited_stages_key,
-                        "default": {},
-                        "want_reply": False,
-                        "operations": [{"operation": "update", "value": {newly_visited_stage_name: True}}],
-                    }
-                ]
-            )
+            messages_to_send = []
+
+            # Message 1: Update the visited_stages dict (for PopTracker)
+            visited_stages_key = AP_VISITED_STAGE_NAMES_KEY_FORMAT % (self.slot, self.team)
+            messages_to_send.append({
+                "cmd": "Set",
+                "key": visited_stages_key,
+                "default": {},
+                "want_reply": False,
+                "operations": [{"operation": "update", "value": {newly_visited_stage_name: True}}],
+            })
+
+            # Message 2: Set individual stage key to trigger server-side world callback
+            # This matches the format expected by reconnect_found_entrances(): <GAME_ABBR>_<team>_<slot>_<stagename>
+            if self.team is not None:
+                stage_key = f"tww_{self.team}_{self.slot}_{newly_visited_stage_name}"
+                messages_to_send.append({
+                    "cmd": "Set",
+                    "key": stage_key,
+                    "default": 0,
+                    "want_reply": False,
+                    "operations": [{"operation": "replace", "value": 1}],
+                })
+
+            await self.send_msgs(messages_to_send)
 
     def update_salvage_locations_map(self) -> None:
         """

worlds/tww/Tracker.py

@@ -0,0 +1,90 @@
+"""
+Universal Tracker support for The Wind Waker randomizer.
+
+This module contains all Universal Tracker-specific logic including:
+- Deferred entrance tracking and reconnection
+- UT generation detection and handling
+- Option restoration from UT slot_data
+"""
+
+from typing import Any, NamedTuple
+
+# Universal Tracker multiworld attribute names
+UT_RE_GEN_PASSTHROUGH_ATTR = "re_gen_passthrough"
+UT_GENERATION_IS_FAKE_ATTR = "generation_is_fake"
+UT_ENFORCE_DEFERRED_CONNECTIONS_ATTR = "enforce_deferred_connections"
+
+# Wind Waker game name for UT identification
+WIND_WAKER_GAME_NAME = "The Wind Waker"
+
+class DatastorageParsed(NamedTuple):
+    """Parsed datastorage key for deferred entrance tracking."""
+    team: int
+    player: int
+    stage_name: str
+
+def is_ut_generation(multiworld: Any) -> bool:
+    """
+    Check if the current generation is a Universal Tracker generation.
+
+    :param multiworld: The MultiWorld object.
+    :return: True if UT is active, False otherwise.
+    """
+    return hasattr(multiworld, UT_GENERATION_IS_FAKE_ATTR) and getattr(multiworld, UT_GENERATION_IS_FAKE_ATTR)
+
+def get_ut_slot_data(multiworld: Any, game_name: str = WIND_WAKER_GAME_NAME) -> dict[str, Any] | None:
+    """
+    Get the slot_data from re_gen_passthrough for the given game.
+
+    :param multiworld: The MultiWorld object.
+    :param game_name: The game name to look up (defaults to "The Wind Waker").
+    :return: The slot_data dict if available, None otherwise.
+    """
+    re_gen_passthrough = getattr(multiworld, UT_RE_GEN_PASSTHROUGH_ATTR, {})
+    if not re_gen_passthrough or game_name not in re_gen_passthrough:
+        return None
+    return re_gen_passthrough[game_name]
+
+def should_defer_entrances(multiworld: Any, has_randomized_entrances: bool) -> bool:
+    """
+    Check if entrances should be deferred based on UT and server settings.
+
+    :param multiworld: The MultiWorld object.
+    :param has_randomized_entrances: Whether the world has randomized entrances.
+    :return: True if entrances should be deferred, False otherwise.
+    """
+    # Only defer entrances during UT regeneration
+    if not is_ut_generation(multiworld):
+        return False
+
+    # Check if server has deferred connections enabled
+    deferred_enabled = getattr(
+        multiworld,
+        UT_ENFORCE_DEFERRED_CONNECTIONS_ATTR,
+        None
+    ) in ("on", "default")
+
+    # Only defer if entrances are actually randomized
+    return deferred_enabled and has_randomized_entrances
+
+
+def parse_datastorage_key(key: str) -> DatastorageParsed | None:
+    """
+    Parse a datastorage key and return parsed components or None if invalid.
+
+    Expected format: tww_<team>_<player>_<stagename>
+
+    :param key: The datastorage key to parse.
+    :return: DatastorageParsed with team, player, stage_name, or None if invalid.
+    """
+    parts = key.split("_")
+    min_parts = 4
+    if len(parts) < min_parts or parts[0] != "tww":
+        return None
+    try:
+        team = int(parts[1])
+        player = int(parts[2])
+        stage_name = "_".join(parts[3:])
+        return DatastorageParsed(team=team, player=player, stage_name=stage_name)
+    except (ValueError, IndexError):
+        return None