TUNIC: Grass Randomizer

worlds/tunic/__init__.py

@@ -1,19 +1,20 @@
-from typing import Dict, List, Any, Tuple, TypedDict, ClassVar, Union
+from typing import Dict, List, Any, Tuple, TypedDict, ClassVar, Union, Set
 from logging import warning
-from BaseClasses import Region, Location, Item, Tutorial, ItemClassification, MultiWorld, CollectionState
+from BaseClasses import Region, Location, Item, Tutorial, ItemClassification, MultiWorld, CollectionState, LocationProgressType
 from .items import (item_name_to_id, item_table, item_name_groups, fool_tiers, filler_items, slot_data_item_names,
                     combat_items)
-from .locations import location_table, location_name_groups, location_name_to_id, hexagon_locations
+from .locations import location_table, location_name_groups, standard_location_name_to_id, hexagon_locations, sphere_one
 from .rules import set_location_rules, set_region_rules, randomize_ability_unlocks, gold_hexagon
 from .er_rules import set_er_location_rules
 from .regions import tunic_regions
 from .er_scripts import create_er_regions
+from .grass import grass_location_table, grass_location_name_to_id, grass_location_name_groups, excluded_grass_locations
 from .er_data import portal_mapping, RegionInfo, tunic_er_regions
 from .options import (TunicOptions, EntranceRando, tunic_option_groups, tunic_option_presets, TunicPlandoConnections,
                       LaurelsLocation, LogicRules, LaurelsZips, IceGrappling, LadderStorage)
 from .combat_logic import area_data, CombatState
 from worlds.AutoWorld import WebWorld, World
-from Options import PlandoConnection
+from Options import PlandoConnection, OptionError
 from decimal import Decimal, ROUND_HALF_UP
 from settings import Group, Bool
 
@@ -22,7 +23,11 @@ class TunicSettings(Group):
     class DisableLocalSpoiler(Bool):
         """Disallows the TUNIC client from creating a local spoiler log."""
 
+    class LimitGrassRando(Bool):
+        """Limits the impact of Grass Randomizer on the multiworld by disallowing local_fill percentages below 95."""
+
     disable_local_spoiler: Union[DisableLocalSpoiler, bool] = False
+    limit_grass_rando: Union[LimitGrassRando, bool] = True
 
 
 class TunicWeb(WebWorld):
@@ -73,18 +78,21 @@ class TunicWorld(World):
     settings: ClassVar[TunicSettings]
     item_name_groups = item_name_groups
     location_name_groups = location_name_groups
+    location_name_groups.update(grass_location_name_groups)
 
     item_name_to_id = item_name_to_id
-    location_name_to_id = location_name_to_id
+    location_name_to_id = standard_location_name_to_id.copy()
+    location_name_to_id.update(grass_location_name_to_id)
 
+    player_location_table: Dict[str, int]
     ability_unlocks: Dict[str, int]
     slot_data_items: List[TunicItem]
     tunic_portal_pairs: Dict[str, str]
     er_portal_hints: Dict[int, str]
     seed_groups: Dict[str, SeedGroup] = {}
     shop_num: int = 1  # need to make it so that you can walk out of shops, but also that they aren't all connected
     er_regions: Dict[str, RegionInfo]  # absolutely needed so outlet regions work
-
+    local_filler: List[TunicItem]
     # so we only loop the multiworld locations once
     # if these are locations instead of their info, it gives a memory leak error
     item_link_locations: Dict[int, Dict[str, List[Tuple[int, str]]]] = {}
@@ -127,10 +135,20 @@ def generate_early(self) -> None:
                 self.options.hexagon_quest.value = passthrough["hexagon_quest"]
                 self.options.entrance_rando.value = passthrough["entrance_rando"]
                 self.options.shuffle_ladders.value = passthrough["shuffle_ladders"]
+                self.options.grass_randomizer.value = passthrough["grass_randomizer"]
                 self.options.fixed_shop.value = self.options.fixed_shop.option_false
                 self.options.laurels_location.value = self.options.laurels_location.option_anywhere
                 self.options.combat_logic.value = passthrough["combat_logic"]
 
+        self.player_location_table = standard_location_name_to_id.copy()
+
+        if self.options.grass_randomizer:
+            if self.settings.limit_grass_rando and self.options.local_fill < 95 and self.multiworld.players > 1:
+                raise OptionError(f"TUNIC: Player {self.player_name} has their Grass Fill option set too low. "
+                                  f"They must either bring it above 95% or the host needs to disable limit_grass_rando "
+                                  f"in their host.yaml settings")
+            self.player_location_table.update(grass_location_name_to_id)
+
     @classmethod
     def stage_generate_early(cls, multiworld: MultiWorld) -> None:
         tunic_worlds: Tuple[TunicWorld] = multiworld.get_game_worlds("TUNIC")
@@ -236,6 +254,14 @@ def create_items(self) -> None:
                 self.get_location("Secret Gathering Place - 10 Fairy Reward").place_locked_item(laurels)
             items_to_create["Hero's Laurels"] = 0
 
+        if self.options.grass_randomizer:
+            items_to_create["Grass"] = len(grass_location_table)
+            tunic_items.append(self.create_item("Glass Cannon", ItemClassification.progression))
+            items_to_create["Glass Cannon"] = 0
+            for grass_location in excluded_grass_locations:
+                self.get_location(grass_location).place_locked_item(self.create_item("Grass"))
+            items_to_create["Grass"] -= len(excluded_grass_locations)
+
         if self.options.keys_behind_bosses:
             for rgb_hexagon, location in hexagon_locations.items():
                 hex_item = self.create_item(gold_hexagon if self.options.hexagon_quest else rgb_hexagon)
@@ -321,8 +347,57 @@ def remove_filler(amount: int) -> None:
             if tunic_item.name in slot_data_item_names:
                 self.slot_data_items.append(tunic_item)
 
+        # pull out the filler so that we can place it manually during pre_fill
+        self.local_filler = []
+        if self.options.grass_randomizer and self.options.local_fill > 0 and self.multiworld.players > 1:
+            # skip items marked local or non-local, let fill deal with them in its own way
+            # discard grass from non_local if it's meant to be limited
+            if self.settings.limit_grass_rando:
+                self.options.non_local_items.value.discard("Grass")
+            all_filler: List[TunicItem] = []
+            non_filler: List[TunicItem] = []
+            for tunic_item in tunic_items:
+                if (tunic_item.classification in [ItemClassification.filler, ItemClassification.trap]
+                        and tunic_item.name not in self.options.local_items
+                        and tunic_item.name not in self.options.non_local_items):
+                    all_filler.append(tunic_item)
+                else:
+                    non_filler.append(tunic_item)
+            amount_to_local_fill = int(self.options.local_fill.value * len(all_filler) / 100)
+            self.local_filler = all_filler[:amount_to_local_fill]
+            del all_filler[:amount_to_local_fill]
+            tunic_items = all_filler + non_filler
+
         self.multiworld.itempool += tunic_items
 
+    @classmethod
+    def stage_pre_fill(cls, multiworld: MultiWorld) -> None:
+        tunic_grass_worlds: List[TunicWorld] = [world for world in multiworld.get_game_worlds("TUNIC")
+                                                if world.options.grass_randomizer]
+        if tunic_grass_worlds:
+            tunic_players_with_grass: List[int] = [world.player for world in tunic_grass_worlds]
+
+            grass_filler_items: List[TunicItem] = []
+            for world in tunic_grass_worlds:
+                grass_filler_items.extend(world.local_filler)
+
+            if grass_filler_items:
+                # we need to reserve a couple locations so that we don't fill up every sphere 1 location
+                reserved_locations: Set[str] = set(multiworld.random.sample(sphere_one, 2))
+                unfilled_locations = [loc for loc in multiworld.get_unfilled_locations_for_players(
+                    location_names=[], players=tunic_players_with_grass) if loc.progress_type != LocationProgressType.PRIORITY
+                                      and loc.name not in reserved_locations]
+
+                grass_filler_count = len(grass_filler_items)
+                # in case you plando or priority a bunch of locations
+                if len(unfilled_locations) < grass_filler_count:
+                    raise Exception("Not enough locations for TUNIC grass randomizer players to place grass fill into TUNIC "
+                                    "locations. This is likely due to excessive priority locations or plando.")
+
+                locations_to_grass_fill = multiworld.random.sample(unfilled_locations, grass_filler_count)
+                for loc in locations_to_grass_fill:
+                    multiworld.push_item(loc, grass_filler_items.pop(), collect=False)
+
     def create_regions(self) -> None:
         self.tunic_portal_pairs = {}
         self.er_portal_hints = {}
@@ -337,7 +412,8 @@ def create_regions(self) -> None:
                 self.ability_unlocks["Pages 52-53 (Icebolt)"] = passthrough["Hexagon Quest Icebolt"]
 
         # Ladders and Combat Logic uses ER rules with vanilla connections for easier maintenance
-        if self.options.entrance_rando or self.options.shuffle_ladders or self.options.combat_logic:
+        if (self.options.entrance_rando or self.options.shuffle_ladders or self.options.combat_logic
+                or self.options.grass_randomizer):
             portal_pairs = create_er_regions(self)
             if self.options.entrance_rando:
                 # these get interpreted by the game to tell it which entrances to connect
@@ -353,7 +429,7 @@ def create_regions(self) -> None:
                 region = self.get_region(region_name)
                 region.add_exits(exits)
 
-            for location_name, location_id in self.location_name_to_id.items():
+            for location_name, location_id in self.player_location_table.items():
                 region = self.get_region(location_table[location_name].region)
                 location = TunicLocation(self.player, location_name, location_id, region)
                 region.locations.append(location)
@@ -366,7 +442,8 @@ def create_regions(self) -> None:
 
     def set_rules(self) -> None:
         # same reason as in create_regions, could probably be put into create_regions
-        if self.options.entrance_rando or self.options.shuffle_ladders or self.options.combat_logic:
+        if (self.options.entrance_rando or self.options.shuffle_ladders or self.options.combat_logic
+                or self.options.grass_randomizer):
             set_er_location_rules(self)
         else:
             set_region_rules(self)
@@ -454,6 +531,7 @@ def fill_slot_data(self) -> Dict[str, Any]:
             "maskless": self.options.maskless.value,
             "entrance_rando": int(bool(self.options.entrance_rando.value)),
             "shuffle_ladders": self.options.shuffle_ladders.value,
+            "grass_randomizer": self.options.grass_randomizer.value,
             "combat_logic": self.options.combat_logic.value,
             "Hexagon Quest Prayer": self.ability_unlocks["Pages 24-25 (Prayer)"],
             "Hexagon Quest Holy Cross": self.ability_unlocks["Pages 42-43 (Holy Cross)"],

worlds/tunic/er_data.py

@@ -627,14 +627,16 @@ class DeadEnd(IntEnum):
     "Beneath the Well Back": RegionInfo("Sewer"),  # the back two portals, and all 4 upper chests
     "West Garden before Terry": RegionInfo("Archipelagos Redux"),  # the lower entry point, near hero grave
     "West Garden after Terry": RegionInfo("Archipelagos Redux"),  # after Terry, up until next chompignons
+    "West Garden West Combat": RegionInfo("Archipelagos Redux"),  # for grass rando basically
     "West Garden at Dagger House": RegionInfo("Archipelagos Redux"),  # just outside magic dagger house
-    "West Garden South Checkpoint": RegionInfo("Archipelagos Redux"),
+    "West Garden South Checkpoint": RegionInfo("Archipelagos Redux"),  # the checkpoint and the blue lines area
     "Magic Dagger House": RegionInfo("archipelagos_house", dead_end=DeadEnd.all_cats),
-    "West Garden Portal": RegionInfo("Archipelagos Redux", dead_end=DeadEnd.restricted, outlet_region="West Garden by Portal"),
+    "West Garden Portal": RegionInfo("Archipelagos Redux", dead_end=DeadEnd.restricted,
+                                     outlet_region="West Garden by Portal"),
     "West Garden by Portal": RegionInfo("Archipelagos Redux", dead_end=DeadEnd.restricted),
     "West Garden Portal Item": RegionInfo("Archipelagos Redux", dead_end=DeadEnd.restricted),
     "West Garden Laurels Exit Region": RegionInfo("Archipelagos Redux"),
-    "West Garden before Boss": RegionInfo("Archipelagos Redux"),  # main west garden
+    "West Garden before Boss": RegionInfo("Archipelagos Redux"),  # up the ladder before garden knight
     "West Garden after Boss": RegionInfo("Archipelagos Redux"),
     "West Garden Hero's Grave Region": RegionInfo("Archipelagos Redux", outlet_region="West Garden before Terry"),
     "Ruined Atoll": RegionInfo("Atoll Redux"),
@@ -1152,8 +1154,10 @@ class DeadEnd(IntEnum):
     "West Garden after Terry": {
         "West Garden before Terry":
             [],
-        "West Garden South Checkpoint":
+        "West Garden West Combat":
             [],
+        "West Garden South Checkpoint":
+            [["Hyperdash"]],
         "West Garden Laurels Exit Region":
             [["LS1"]],
     },
@@ -1163,6 +1167,8 @@ class DeadEnd(IntEnum):
         "West Garden at Dagger House":
             [],
         "West Garden after Terry":
+            [["Hyperdash"]],
+        "West Garden West Combat":
             [],
     },
     "West Garden before Boss": {

worlds/tunic/er_rules.py

@@ -1,12 +1,13 @@
 from typing import Dict, FrozenSet, Tuple, TYPE_CHECKING
 from worlds.generic.Rules import set_rule, add_rule, forbid_item
+from BaseClasses import Region, CollectionState
 from .options import IceGrappling, LadderStorage, CombatLogic
 from .rules import (has_ability, has_sword, has_melee, has_ice_grapple_logic, has_lantern, has_mask, can_ladder_storage,
                     laurels_zip, bomb_walls)
 from .er_data import Portal, get_portal_outlet_region
 from .ladder_storage_data import ow_ladder_groups, region_ladders, easy_ls, medium_ls, hard_ls
 from .combat_logic import has_combat_reqs
-from BaseClasses import Region, CollectionState
+from .grass import set_grass_location_rules
 
 if TYPE_CHECKING:
     from . import TunicWorld
@@ -534,7 +535,6 @@ def get_paired_portal(portal_sd: str) -> Tuple[str, str]:
     regions["Dark Tomb Upper"].connect(
         connecting_region=regions["Dark Tomb Entry Point"])
 
-    # ice grapple through the wall, get the little secret sound to trigger
     regions["Dark Tomb Upper"].connect(
         connecting_region=regions["Dark Tomb Main"],
         rule=lambda state: has_ladder("Ladder in Dark Tomb", state, world)
@@ -556,11 +556,24 @@ def get_paired_portal(portal_sd: str) -> Tuple[str, str]:
     wg_after_to_before_terry = regions["West Garden after Terry"].connect(
         connecting_region=regions["West Garden before Terry"])
 
-    regions["West Garden after Terry"].connect(
-        connecting_region=regions["West Garden South Checkpoint"])
-    wg_checkpoint_to_after_terry = regions["West Garden South Checkpoint"].connect(
+    wg_after_terry_to_west_combat = regions["West Garden after Terry"].connect(
+        connecting_region=regions["West Garden West Combat"])
+    regions["West Garden West Combat"].connect(
         connecting_region=regions["West Garden after Terry"])
 
+    wg_checkpoint_to_west_combat = regions["West Garden South Checkpoint"].connect(
+        connecting_region=regions["West Garden West Combat"])
+    regions["West Garden West Combat"].connect(
+        connecting_region=regions["West Garden South Checkpoint"])
+
+    # if not laurels, it goes through the west combat region instead
+    regions["West Garden after Terry"].connect(
+        connecting_region=regions["West Garden South Checkpoint"],
+        rule=lambda state: state.has(laurels, player))
+    regions["West Garden South Checkpoint"].connect(
+        connecting_region=regions["West Garden after Terry"],
+        rule=lambda state: state.has(laurels, player))
+
     wg_checkpoint_to_dagger = regions["West Garden South Checkpoint"].connect(
         connecting_region=regions["West Garden at Dagger House"])
     regions["West Garden at Dagger House"].connect(
@@ -1381,12 +1394,16 @@ def ls_connect(origin_name: str, portal_sdt: str) -> None:
         set_rule(wg_after_to_before_terry,
                  lambda state: state.has_any({laurels, ice_dagger}, player)
                  or has_combat_reqs("West Garden", state, player))
-        # laurels through, probably to the checkpoint, or just fight
-        set_rule(wg_checkpoint_to_after_terry,
-                 lambda state: state.has(laurels, player) or has_combat_reqs("West Garden", state, player))
-        set_rule(wg_checkpoint_to_before_boss,
+
+        set_rule(wg_after_terry_to_west_combat,
+                 lambda state: has_combat_reqs("West Garden", state, player))
+        set_rule(wg_checkpoint_to_west_combat,
                  lambda state: has_combat_reqs("West Garden", state, player))
 
+        # maybe a little too generous? probably fine though
+        set_rule(wg_checkpoint_to_before_boss,
+                 lambda state: state.has(laurels, player) or has_combat_reqs("West Garden", state, player))
+
         add_rule(btv_front_to_main,
                  lambda state: has_combat_reqs("Beneath the Vault", state, player))
         add_rule(btv_back_to_main,
@@ -1507,6 +1524,9 @@ def ls_connect(origin_name: str, portal_sdt: str) -> None:
 def set_er_location_rules(world: "TunicWorld") -> None:
     player = world.player
 
+    if world.options.grass_randomizer:
+        set_grass_location_rules(world)
+
     forbid_item(world.get_location("Secret Gathering Place - 20 Fairy Reward"), fairies, player)
 
     # Ability Shuffle Exclusive Rules
@@ -1831,6 +1851,8 @@ def combat_logic_to_loc(loc_name: str, combat_req_area: str, set_instead: bool =
         combat_logic_to_loc("West Garden - [Central Lowlands] Chest Beneath Faeries", "West Garden")
         combat_logic_to_loc("West Garden - [Central Lowlands] Chest Beneath Save Point", "West Garden")
         combat_logic_to_loc("West Garden - [West Highlands] Upper Left Walkway", "West Garden")
+        combat_logic_to_loc("West Garden - [Central Highlands] Holy Cross (Blue Lines)", "West Garden")
+        combat_logic_to_loc("West Garden - [Central Highlands] Behind Guard Captain", "West Garden")
 
         # with combat logic on, I presume the player will want to be able to see to avoid the spiders
         set_rule(world.get_location("Beneath the Fortress - Bridge"),

worlds/tunic/er_scripts.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Set, Tuple, TYPE_CHECKING
 from BaseClasses import Region, ItemClassification, Item, Location
-from .locations import location_table
+from .locations import all_locations
 from .er_data import Portal, portal_mapping, traversal_requirements, DeadEnd, RegionInfo
 from .er_rules import set_er_region_rules
 from Options import PlandoConnection
@@ -53,8 +53,8 @@ def create_er_regions(world: "TunicWorld") -> Dict[Portal, Portal]:
 
     set_er_region_rules(world, regions, portal_pairs)
 
-    for location_name, location_id in world.location_name_to_id.items():
-        region = regions[location_table[location_name].er_region]
+    for location_name, location_id in world.player_location_table.items():
+        region = regions[all_locations[location_name].er_region]
         location = TunicERLocation(world.player, location_name, location_id, region)
         region.locations.append(location)