Allow user to exclude locations

logic/logic.py

@@ -201,6 +201,28 @@ def set_prerandomization_item_location(self, location_name, item_name):
     assert location_name in self.item_locations
     self.prerandomization_item_locations[location_name] = item_name
 
+  def get_num_charts_excluded(self):
+    return Logic.get_num_charts_excluded_static(self.item_locations, self.options)
+
+  @staticmethod
+  def get_num_charts_excluded_static(item_locations: dict[str, dict], options: Options):
+    if options.randomize_charts:
+      num_charts_excluded = sum(location_name.endswith(" - Sunken Treasure") for location_name in options.excluded_locations)
+    else:
+      # Only count excluded sunken treasures that would actually be a progress location.
+      num_charts_excluded = 0
+      for location_name in options.excluded_locations:
+        if location_name not in item_locations or not location_name.endswith(" - Sunken Treasure"):
+          continue
+        original_item = item_locations[location_name]["Original item"]
+        is_triforce_shard = original_item.startswith("Triforce Shard ")
+        if is_triforce_shard and options.progression_triforce_charts:
+          num_charts_excluded += 1
+        elif not is_triforce_shard and options.progression_treasure_charts:
+          num_charts_excluded += 1
+
+    return num_charts_excluded
+
   def get_num_progression_locations(self):
     return Logic.get_num_progression_locations_static(self.item_locations, self.options)
 
@@ -213,10 +235,18 @@ def get_num_progression_locations_static(item_locations: dict[str, dict], option
       filter_sunken_treasure=True
     )
     num_progress_locations = len(progress_locations)
+
+    max_sunken_treasure_locations = 0
     if options.progression_triforce_charts:
-      num_progress_locations += 8
+      max_sunken_treasure_locations += 8
     if options.progression_treasure_charts:
-      num_progress_locations += 41
+      max_sunken_treasure_locations += 41
+
+    num_charts_excluded = Logic.get_num_charts_excluded_static(item_locations, options)
+    if options.randomize_charts:
+      num_progress_locations += min(max_sunken_treasure_locations, 49 - num_charts_excluded)
+    else:
+      num_progress_locations += max_sunken_treasure_locations - num_charts_excluded
 
     return num_progress_locations
 
@@ -261,13 +291,17 @@ def get_max_required_bosses_banned_locations(self):
   def get_progress_and_non_progress_locations(self):
     all_locations = list(self.item_locations.keys())
     progress_locations = self.filter_locations_for_progression(all_locations, filter_sunken_treasure=True)
+    excluded_locations_set = set(self.options.excluded_locations)
     nonprogress_locations = []
     for location_name in all_locations:
       if location_name in progress_locations:
         continue
 
       types = self.item_locations[location_name]["Types"]
       if "Sunken Treasure" in types:
+        if location_name in excluded_locations_set:
+          nonprogress_locations.append(location_name)
+          continue
         chart_name = self.chart_name_for_location(location_name)
         if "Triforce Chart" in chart_name:
           if self.options.progression_triforce_charts:
@@ -481,19 +515,28 @@ def check_item_is_useful(self, item_name, inaccessible_undone_item_locations):
     self.cached_items_are_useful[item_name] = False
     return False
 
-  def filter_locations_for_progression(self, locations_to_filter: list[str], filter_sunken_treasure=False):
+  def filter_locations_for_progression(self, locations_to_filter: list[str], filter_sunken_treasure=False, filter_excluded_locations=True, filter_excluded_sunken_treasure=True):
     return Logic.filter_locations_for_progression_static(
       locations_to_filter,
       self.item_locations,
       self.options,
-      filter_sunken_treasure=filter_sunken_treasure
+      filter_sunken_treasure=filter_sunken_treasure,
+      filter_excluded_locations=filter_excluded_locations,
+      filter_excluded_sunken_treasure=filter_excluded_sunken_treasure,
     )
 
   @staticmethod
-  def filter_locations_for_progression_static(locations_to_filter: list[str], item_locations: dict[str, dict], options: Options, filter_sunken_treasure=False):
+  def filter_locations_for_progression_static(locations_to_filter: list[str], item_locations: dict[str, dict], options: Options, filter_sunken_treasure=False, filter_excluded_locations=True, filter_excluded_sunken_treasure=True):
+    excluded_locations_set = set(options.excluded_locations)
     filtered_locations = []
     for location_name in locations_to_filter:
       types = item_locations[location_name]["Types"]
+
+      # If the location is excluded, filter it out of progression locations.
+      # However, have special handling for sunken treasure locations as they may not yet be finalized as being progression.
+      if filter_excluded_locations and location_name in excluded_locations_set and ("Sunken Treasure" not in types or filter_excluded_sunken_treasure):
+        continue
+
       if "No progression" in types:
         continue
       if "Consumables only" in types:
@@ -624,27 +667,28 @@ def filter_items_valid_for_location(self, items, location_name):
     return valid_items
 
   @staticmethod
-  def load_and_parse_item_locations() -> dict[str, dict]:
-    if Logic.initial_item_locations is not None:
-      return copy.deepcopy(Logic.initial_item_locations)
-
-    with open(os.path.join(LOGIC_PATH, "item_locations.txt")) as f:
-      item_locations = yaml.load(f)
-
-    for location_name in item_locations:
-      req_string = item_locations[location_name]["Need"]
-      if req_string is None:
-        raise Exception("Requirements are blank for location \"%s\"" % location_name)
-      item_locations[location_name]["Need"] = Logic.parse_logic_expression(req_string)
+  def load_and_parse_item_locations(deepcopy: bool = True) -> dict[str, dict]:
+    if Logic.initial_item_locations is None:
+      with open(os.path.join(LOGIC_PATH, "item_locations.txt")) as f:
+        item_locations = yaml.load(f)
 
-      types_string = item_locations[location_name]["Types"]
-      types = types_string.split(",")
-      types = [type.strip() for type in types]
-      item_locations[location_name]["Types"] = types
-
-    Logic.initial_item_locations = copy.deepcopy(item_locations)
-    return item_locations
+      for location_name in item_locations:
+        req_string = item_locations[location_name]["Need"]
+        if req_string is None:
+          raise Exception("Requirements are blank for location \"%s\"" % location_name)
+        item_locations[location_name]["Need"] = Logic.parse_logic_expression(req_string)
+
+        types_string = item_locations[location_name]["Types"]
+        types = types_string.split(",")
+        types = [type.strip() for type in types]
+        item_locations[location_name]["Types"] = types
+
+      Logic.initial_item_locations = copy.deepcopy(item_locations)
 
+    if deepcopy:
+      return copy.deepcopy(Logic.initial_item_locations)
+    return Logic.initial_item_locations
+
   def load_and_parse_macros(self):
     if Logic.initial_macros is not None:
       self.macros = copy.deepcopy(Logic.initial_macros)
@@ -764,11 +808,15 @@ def make_useless_progress_items_nonprogress(self):
     filter_sunken_treasure = True
     if self.options.progression_triforce_charts or self.options.progression_treasure_charts:
       filter_sunken_treasure = False
+    filter_excluded_sunken_treasure = True
+    if self.rando.charts.is_enabled() and not self.rando.fully_initialized:
+      filter_excluded_sunken_treasure = False
     progress_locations = Logic.filter_locations_for_progression_static(
       list(self.item_locations.keys()),
       self.item_locations,
       self.options,
-      filter_sunken_treasure=filter_sunken_treasure
+      filter_sunken_treasure=filter_sunken_treasure,
+      filter_excluded_sunken_treasure=filter_excluded_sunken_treasure,
     )
 
     items_needed = {}

options/wwrando_options.py

@@ -22,6 +22,15 @@ class TrickDifficulty(StrEnum):
 
 @dataclass
 class Options(BaseOptions):
+  def validate(self):
+    super().validate()
+
+    if self.excluded_locations:
+      from logic.logic import Logic
+
+      valid_locations = set(Logic.load_and_parse_item_locations(deepcopy=False).keys())
+      self.excluded_locations = sorted({loc for loc in self.excluded_locations if loc in valid_locations})
+
   #region Progress locations
   progression_dungeons: bool = option(
     default=True,
@@ -138,6 +147,16 @@ class Options(BaseOptions):
     description="Miscellaneous locations that don't fit into any of the above categories (outdoors chests, wind shrine, Cyclos, etc).<br>"
       "<u>If this is not checked, they will still be randomized</u>, but will only contain optional items you don't need to beat the game.",
   )
+
+  progression_locations: list[str] = option(
+    default_factory=lambda: [],
+    permalink=False,
+    description="Randomized locations that can have progress items.",
+  )
+  excluded_locations: list[str] = option(
+    default_factory=lambda: [],
+    description="Randomized locations that cannot have progress items.",
+  )
   #endregion
 
   #region Modes

randomizer.py

@@ -4,6 +4,7 @@
 from random import Random
 import hashlib
 import sys
+import zlib
 from typing import TypeVar, Callable
 from io import BytesIO
 import string
@@ -238,9 +239,22 @@ def __init__(self, seed, clean_iso_path, randomized_output_folder, options: Opti
     num_progress_locations = self.logic.get_num_progression_locations()
     max_required_bosses_banned_locations = self.logic.get_max_required_bosses_banned_locations()
     self.all_randomized_progress_items = self.logic.unplaced_progress_items.copy()
-    if num_progress_locations - max_required_bosses_banned_locations < len(self.all_randomized_progress_items):
+    num_progress_items = len(self.all_randomized_progress_items)
+
+    # If sunken treasure locations are progression, we need to take into account locations that are excluded and adjust the progress item count.
+    if options.progression_triforce_charts or options.progression_treasure_charts:
+      num_charts_excluded = self.logic.get_num_charts_excluded()
+      if options.randomize_charts:
+        max_sunken_treasure_locations = 0
+        if options.progression_triforce_charts:
+          max_sunken_treasure_locations += 8
+        if options.progression_treasure_charts:
+          max_sunken_treasure_locations += 41
+        num_progress_items -= max(0, max_sunken_treasure_locations + num_charts_excluded - 49)
+
+    if num_progress_locations - max_required_bosses_banned_locations < num_progress_items:
       error_message = "Not enough progress locations to place all progress items.\n\n"
-      error_message += "Total progress items: %d\n" % len(self.all_randomized_progress_items)
+      error_message += "Total progress items: %d\n" % num_progress_items
       error_message += "Progress locations with current options: %d\n" % num_progress_locations
       if max_required_bosses_banned_locations > 0:
         error_message += "Maximum Required Bosses Mode banned locations: %d\n" % max_required_bosses_banned_locations
@@ -529,14 +543,20 @@ def encode_permalink(cls, seed: str, options: Options):
       elif option.name == "randomized_gear":
         # Handled above.
         continue
+      elif option.name == "excluded_locations":
+        assert issubclass(typing.get_origin(option.type) or option.type, list)
+        value_set = set(value)
+        for location_name in Logic.load_and_parse_item_locations(deepcopy=False):
+          bit = location_name in value_set
+          bitswriter.write(bit, 1)
       else:
         raise Exception(f"Option {option.name} of type {option.type} is not currently supported by the permalink system.")
 
     bitswriter.flush()
 
     for byte in bitswriter.bytes:
       permalink += struct.pack(">B", byte)
-    base64_encoded_permalink = base64.b64encode(permalink).decode("ascii")
+    base64_encoded_permalink = base64.b64encode(zlib.compress(permalink)).decode("ascii")
     return base64_encoded_permalink
 
   @classmethod
@@ -545,7 +565,11 @@ def decode_permalink(cls, base64_encoded_permalink: str, options: Options = None
     if not base64_encoded_permalink:
       raise Exception(f"Permalink is blank.")
 
-    permalink = base64.b64decode(base64_encoded_permalink)
+    raw_permalink = base64.b64decode(base64_encoded_permalink)
+    try:
+      permalink = zlib.decompress(raw_permalink)
+    except zlib.error:
+      permalink = raw_permalink
     given_version_num, seed, options_bytes = permalink.split(b"\0", 2)
     given_version_num = given_version_num.decode("ascii")
     seed = seed.decode("ascii")
@@ -616,6 +640,14 @@ def decode_permalink(cls, base64_encoded_permalink: str, options: Options = None
       elif option.name == "randomized_gear":
         # Handled above.
         continue
+      elif option.name == "excluded_locations":
+        assert issubclass(typing.get_origin(option.type) or option.type, list)
+        excluded_list = []
+        for location_name in Logic.load_and_parse_item_locations(deepcopy=False):
+          excluded = bitsreader.read(1)
+          if excluded == 1:
+            excluded_list.append(location_name)
+        options.excluded_locations = sorted(excluded_list)
       else:
         raise Exception(f"Option {option.name} of type {option.type} is not currently supported by the permalink system.")
 
@@ -1017,7 +1049,7 @@ def get_log_header(self):
     non_disabled_options = [
       option.name for option in Options.all()
       if self.options[option.name] not in [False, [], {}]
-      and option.name != "randomized_gear" # Just takes up space
+      and option.name not in ["randomized_gear", "progression_locations"] # Just takes up space
     ]
     option_strings = []
     for option_name in non_disabled_options:

randomizers/items.py

@@ -36,6 +36,8 @@ def progress_save_text(self) -> str:
     return "Saving items..."
 
   def _randomize(self):
+    self.logic.initialize_from_randomizer_state()
+
     if not self.options.keylunacy:
       self.randomize_dungeon_items()