TUNIC: Grass Randomizer

worlds/tunic/__init__.py

@@ -1,17 +1,18 @@
-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
+from BaseClasses import Region, Location, Item, Tutorial, ItemClassification, MultiWorld, LocationProgressType
 from .items import item_name_to_id, item_table, item_name_groups, fool_tiers, filler_items, slot_data_item_names
-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 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
 
@@ -20,7 +21,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 grass_fill percentages below 95."""
+
     disable_local_spoiler: Union[DisableLocalSpoiler, bool] = False
+    limit_grass_rando: Union[LimitGrassRando, bool] = True
 
 
 class TunicWeb(WebWorld):
@@ -71,18 +76,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]]]] = {}
@@ -125,9 +133,19 @@ 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.player_location_table = standard_location_name_to_id.copy()
+
+        if self.options.grass_randomizer:
+            if self.settings.limit_grass_rando and self.options.grass_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")
@@ -193,7 +211,6 @@ def create_item(self, name: str, classification: ItemClassification = None) -> T
         return TunicItem(name, classification or item_data.classification, self.item_name_to_id[name], self.player)
 
     def create_items(self) -> None:
-
         tunic_items: List[TunicItem] = []
         self.slot_data_items = []
 
@@ -222,6 +239,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.multiworld.get_location(grass_location, self.player).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)
@@ -302,8 +327,50 @@ 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.grass_fill > 0 and self.multiworld.players > 1:
+            # skip items marked local or non-local, let fill deal with them in its own way
+            all_filler = []
+            non_filler = []
+            amount_to_local_fill = int(self.options.grass_fill.value * len(all_filler) / 100)
+            for item in tunic_items:
+                if item.classification in [ItemClassification.filler, ItemClassification.trap] and item.name not in self.options.local_items and item.name not in self.options.non_local_items:
+                    if len(self.local_filler) < amount_to_local_fill:
+                        self.local_filler.append(item)
+                    else:
+                        all_filler.append(item)
+                else:
+                    non_filler.append(item)
+
+            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]
+        tunic_players_with_grass: List[int] = [world.player for world in tunic_grass_worlds]
+        # 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_fill: List[TunicItem] = []
+        for world in tunic_grass_worlds:
+            grass_fill.extend(world.local_filler)
+
+        grass_filler_count = len(grass_fill)
+        # 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_fill.pop(), collect=False)
+
     def create_regions(self) -> None:
         self.tunic_portal_pairs = {}
         self.er_portal_hints = {}
@@ -318,7 +385,7 @@ def create_regions(self) -> None:
                 self.ability_unlocks["Pages 52-53 (Icebolt)"] = passthrough["Hexagon Quest Icebolt"]
 
         # ladder rando uses ER with vanilla connections, so that we're not managing more rules files
-        if self.options.entrance_rando or self.options.shuffle_ladders:
+        if self.options.entrance_rando or self.options.shuffle_ladders 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
@@ -334,7 +401,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)
@@ -346,14 +413,14 @@ def create_regions(self) -> None:
             victory_region.locations.append(victory_location)
 
     def set_rules(self) -> None:
-        if self.options.entrance_rando or self.options.shuffle_ladders:
+        if self.options.entrance_rando or self.options.shuffle_ladders or self.options.grass_randomizer:
             set_er_location_rules(self)
         else:
             set_region_rules(self)
             set_location_rules(self)
 
     def get_filler_item_name(self) -> str:
-        return self.random.choice(filler_items)
+        return self.random.choice([item for item in filler_items if item != "Grass"])
 
     def extend_hint_information(self, hint_data: Dict[int, Dict[int, str]]) -> None:
         if self.options.entrance_rando:
@@ -421,6 +488,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,
             "Hexagon Quest Prayer": self.ability_unlocks["Pages 24-25 (Prayer)"],
             "Hexagon Quest Holy Cross": self.ability_unlocks["Pages 42-43 (Holy Cross)"],
             "Hexagon Quest Icebolt": self.ability_unlocks["Pages 52-53 (Icebolt)"],

worlds/tunic/er_rules.py

@@ -6,6 +6,7 @@
 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 BaseClasses import Region, CollectionState
+from .grass import set_grass_location_rules
 
 if TYPE_CHECKING:
     from . import TunicWorld
@@ -1222,6 +1223,10 @@ def ls_connect(origin_name: str, portal_sdt: str) -> None:
 
 def set_er_location_rules(world: "TunicWorld") -> None:
     player = world.player
+    options = world.options
+
+    if options.grass_randomizer:
+        set_grass_location_rules(world)
 
     forbid_item(world.get_location("Secret Gathering Place - 20 Fairy Reward"), fairies, player)
 

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
@@ -37,8 +37,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)