Core: rename world to multiworld (#931)

* rename references to `Multiworld` in core to `multiworld` instead of `world`

* fix smz3

* fix oot

* fix low hanging fruit

* revert mysteriously broken spacing in world api.md

* fix more randomly broken spacing

* hate

* that better be all of it

* begrudgingly move over smw

* ._.

* missed some worlds

* this is getting tedious now

* Missed some self.world definitions

Co-authored-by: espeon65536 <espeon65536@gmail.com>
Co-authored-by: Zach Parks <zach@alliware.com>

test/TestBase.py

@@ -11,18 +11,18 @@ from worlds.alttp.Items import ItemFactory
 
 
 class TestBase(unittest.TestCase):
-    world: MultiWorld
+    multiworld: MultiWorld
     _state_cache = {}
 
     def get_state(self, items):
-        if (self.world, tuple(items)) in self._state_cache:
-            return self._state_cache[self.world, tuple(items)]
-        state = CollectionState(self.world)
+        if (self.multiworld, tuple(items)) in self._state_cache:
+            return self._state_cache[self.multiworld, tuple(items)]
+        state = CollectionState(self.multiworld)
         for item in items:
             item.classification = ItemClassification.progression
             state.collect(item)
         state.sweep_for_events()
-        self._state_cache[self.world, tuple(items)] = state
+        self._state_cache[self.multiworld, tuple(items)] = state
         return state
 
     def get_path(self, state, region):
@@ -44,11 +44,11 @@ class TestBase(unittest.TestCase):
             items = item_pool[0]
             all_except = item_pool[1] if len(item_pool) > 1 else None
             state = self._get_items(item_pool, all_except)
-            path = self.get_path(state, self.world.get_location(location, 1).parent_region)
+            path = self.get_path(state, self.multiworld.get_location(location, 1).parent_region)
             with self.subTest(msg="Reach Location", location=location, access=access, items=items,
                               all_except=all_except, path=path, entry=i):
 
-                self.assertEqual(self.world.get_location(location, 1).can_reach(state), access)
+                self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access)
 
             # check for partial solution
             if not all_except and access:  # we are not supposed to be able to reach location with partial inventory
@@ -56,18 +56,18 @@ class TestBase(unittest.TestCase):
                     with self.subTest(msg="Location reachable without required item", location=location,
                                       items=item_pool[0], missing_item=missing_item, entry=i):
                         state = self._get_items_partial(item_pool, missing_item)
-                        self.assertEqual(self.world.get_location(location, 1).can_reach(state), False)
+                        self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), False)
 
     def run_entrance_tests(self, access_pool):
         for i, (entrance, access, *item_pool) in enumerate(access_pool):
             items = item_pool[0]
             all_except = item_pool[1] if len(item_pool) > 1 else None
             state = self._get_items(item_pool, all_except)
-            path = self.get_path(state, self.world.get_entrance(entrance, 1).parent_region)
+            path = self.get_path(state, self.multiworld.get_entrance(entrance, 1).parent_region)
             with self.subTest(msg="Reach Entrance", entrance=entrance, access=access, items=items,
                               all_except=all_except, path=path, entry=i):
 
-                self.assertEqual(self.world.get_entrance(entrance, 1).can_reach(state), access)
+                self.assertEqual(self.multiworld.get_entrance(entrance, 1).can_reach(state), access)
 
             # check for partial solution
             if not all_except and access:  # we are not supposed to be able to reach location with partial inventory
@@ -75,11 +75,11 @@ class TestBase(unittest.TestCase):
                     with self.subTest(msg="Entrance reachable without required item", entrance=entrance,
                                       items=item_pool[0], missing_item=missing_item, entry=i):
                         state = self._get_items_partial(item_pool, missing_item)
-                        self.assertEqual(self.world.get_entrance(entrance, 1).can_reach(state), False)
+                        self.assertEqual(self.multiworld.get_entrance(entrance, 1).can_reach(state), False)
 
     def _get_items(self, item_pool, all_except):
         if all_except and len(all_except) > 0:
-            items = self.world.itempool[:]
+            items = self.multiworld.itempool[:]
             items = [item for item in items if
                      item.name not in all_except and not ("Bottle" in item.name and "AnyBottle" in all_except)]
             items.extend(ItemFactory(item_pool[0], 1))

test/dungeons/TestDungeon.py

@@ -14,46 +14,46 @@ from worlds import AutoWorld
 
 class TestDungeon(unittest.TestCase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
         self.starting_regions = []  # Where to start exploring
         self.remove_exits = []      # Block dungeon exits
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        create_regions(self.world, 1)
-        create_dungeons(self.world, 1)
-        create_shops(self.world, 1)
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        create_regions(self.multiworld, 1)
+        create_dungeons(self.multiworld, 1)
+        create_shops(self.multiworld, 1)
         for exitname, regionname in mandatory_connections:
-            connect_simple(self.world, exitname, regionname, 1)
-        connect_simple(self.world, 'Big Bomb Shop', 'Big Bomb Shop', 1)
-        self.world.get_region('Menu', 1).exits = []
-        self.world.swamp_patch_required[1] = True
-        self.world.worlds[1].set_rules()
-        self.world.worlds[1].create_items()
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
+            connect_simple(self.multiworld, exitname, regionname, 1)
+        connect_simple(self.multiworld, 'Big Bomb Shop', 'Big Bomb Shop', 1)
+        self.multiworld.get_region('Menu', 1).exits = []
+        self.multiworld.swamp_patch_required[1] = True
+        self.multiworld.worlds[1].set_rules()
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
 
     def run_tests(self, access_pool):
         for exit in self.remove_exits:
-            self.world.get_entrance(exit, 1).connected_region = self.world.get_region('Menu', 1)
+            self.multiworld.get_entrance(exit, 1).connected_region = self.multiworld.get_region('Menu', 1)
 
         for location, access, *item_pool in access_pool:
             items = item_pool[0]
             all_except = item_pool[1] if len(item_pool) > 1 else None
             with self.subTest(location=location, access=access, items=items, all_except=all_except):
                 if all_except and len(all_except) > 0:
-                    items = self.world.itempool[:]
+                    items = self.multiworld.itempool[:]
                     items = [item for item in items if item.name not in all_except and not ("Bottle" in item.name and "AnyBottle" in all_except)]
                     items.extend(ItemFactory(item_pool[0], 1))
                 else:
                     items = ItemFactory(items, 1)
-                state = CollectionState(self.world)
-                state.reachable_regions[1].add(self.world.get_region('Menu', 1))
+                state = CollectionState(self.multiworld)
+                state.reachable_regions[1].add(self.multiworld.get_region('Menu', 1))
                 for region_name in self.starting_regions:
-                    region = self.world.get_region(region_name, 1)
+                    region = self.multiworld.get_region(region_name, 1)
                     state.reachable_regions[1].add(region)
                     for exit in region.exits:
                         if exit.connected_region is not None:
@@ -63,4 +63,4 @@ class TestDungeon(unittest.TestCase):
                     item.classification = ItemClassification.progression
                     state.collect(item)
 
-                self.assertEqual(self.world.get_location(location, 1).can_reach(state), access)
+                self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access)

test/general/TestFill.py

@@ -27,7 +27,7 @@ def generate_multi_world(players: int = 1) -> MultiWorld:
 
 
 class PlayerDefinition(object):
-    world: MultiWorld
+    multiworld: MultiWorld
     id: int
     menu: Region
     locations: List[Location]
@@ -36,7 +36,7 @@ class PlayerDefinition(object):
     regions: List[Region]
 
     def __init__(self, world: MultiWorld, id: int, menu: Region, locations: List[Location] = [], prog_items: List[Item] = [], basic_items: List[Item] = []):
-        self.world = world
+        self.multiworld = world
         self.id = id
         self.menu = menu
         self.locations = locations
@@ -48,7 +48,7 @@ class PlayerDefinition(object):
         region_tag = "_region" + str(len(self.regions))
         region_name = "player" + str(self.id) + region_tag
         region = Region("player" + str(self.id) + region_tag, RegionType.Generic,
-                        "Region Hint", self.id, self.world)
+                        "Region Hint", self.id, self.multiworld)
         self.locations += generate_locations(size, self.id, None, region, region_tag)
 
         entrance = Entrance(self.id, region_name + "_entrance", parent)
@@ -57,7 +57,7 @@ class PlayerDefinition(object):
         entrance.access_rule = access_rule
 
         self.regions.append(region)
-        self.world.regions.append(region)
+        self.multiworld.regions.append(region)
 
         return region
 

test/general/__init__.py

@@ -7,15 +7,15 @@ gen_steps = ["generate_early", "create_regions", "create_items", "set_rules", "g
 
 
 def setup_default_world(world_type) -> MultiWorld:
-    world = MultiWorld(1)
-    world.game[1] = world_type.game
-    world.player_name = {1: "Tester"}
-    world.set_seed()
+    multiworld = MultiWorld(1)
+    multiworld.game[1] = world_type.game
+    multiworld.player_name = {1: "Tester"}
+    multiworld.set_seed()
     args = Namespace()
     for name, option in world_type.option_definitions.items():
         setattr(args, name, {1: option.from_any(option.default)})
-    world.set_options(args)
-    world.set_default_common_options()
+    multiworld.set_options(args)
+    multiworld.set_default_common_options()
     for step in gen_steps:
-        call_all(world, step)
-    return world
+        call_all(multiworld, step)
+    return multiworld

test/inverted/TestInverted.py

@@ -14,23 +14,23 @@ from worlds import AutoWorld
 
 class TestInverted(TestBase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        self.world.mode[1] = "inverted"
-        create_inverted_regions(self.world, 1)
-        create_dungeons(self.world, 1)
-        create_shops(self.world, 1)
-        link_inverted_entrances(self.world, 1)
-        self.world.worlds[1].create_items()
-        self.world.required_medallions[1] = ['Ether', 'Quake']
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
-        self.world.get_location('Agahnim 1', 1).item = None
-        self.world.get_location('Agahnim 2', 1).item = None
-        mark_light_world_regions(self.world, 1)
-        self.world.worlds[1].set_rules()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        self.multiworld.mode[1] = "inverted"
+        create_inverted_regions(self.multiworld, 1)
+        create_dungeons(self.multiworld, 1)
+        create_shops(self.multiworld, 1)
+        link_inverted_entrances(self.multiworld, 1)
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.required_medallions[1] = ['Ether', 'Quake']
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
+        self.multiworld.get_location('Agahnim 1', 1).item = None
+        self.multiworld.get_location('Agahnim 2', 1).item = None
+        mark_light_world_regions(self.multiworld, 1)
+        self.multiworld.worlds[1].set_rules()

test/inverted/TestInvertedBombRules.py

@@ -14,16 +14,16 @@ from worlds import AutoWorld
 class TestInvertedBombRules(unittest.TestCase):
 
     def setUp(self):
-        self.world = MultiWorld(1)
-        self.world.mode[1] = "inverted"
+        self.multiworld = MultiWorld(1)
+        self.multiworld.mode[1] = "inverted"
         args = Namespace
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-            self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        create_inverted_regions(self.world, 1)
-        create_dungeons(self.world, 1)
+            self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        create_inverted_regions(self.multiworld, 1)
+        create_dungeons(self.multiworld, 1)
 
     #TODO: Just making sure I haven't missed an entrance.  It would be good to test the rules make sense as well.
     def testInvertedBombRulesAreComplete(self):
@@ -31,9 +31,9 @@ class TestInvertedBombRules(unittest.TestCase):
         must_exits = list(Inverted_LW_Entrances_Must_Exit + Inverted_LW_Dungeon_Entrances_Must_Exit)
         for entrance_name in (entrances + must_exits):
             if entrance_name not in ['Desert Palace Entrance (East)', 'Spectacle Rock Cave', 'Spectacle Rock Cave (Bottom)']:
-                entrance = self.world.get_entrance(entrance_name, 1)
-                connect_entrance(self.world, entrance_name, 'Inverted Big Bomb Shop', 1)
-                set_inverted_big_bomb_rules(self.world, 1)
+                entrance = self.multiworld.get_entrance(entrance_name, 1)
+                connect_entrance(self.multiworld, entrance_name, 'Inverted Big Bomb Shop', 1)
+                set_inverted_big_bomb_rules(self.multiworld, 1)
                 entrance.connected_region.entrances.remove(entrance)
                 entrance.connected_region = None
 
@@ -45,9 +45,9 @@ class TestInvertedBombRules(unittest.TestCase):
 
     def testInvalidEntrances(self):
         for entrance_name in ['Desert Palace Entrance (East)', 'Spectacle Rock Cave', 'Spectacle Rock Cave (Bottom)']:
-            entrance = self.world.get_entrance(entrance_name, 1)
-            connect_entrance(self.world, entrance_name, 'Inverted Big Bomb Shop', 1)
+            entrance = self.multiworld.get_entrance(entrance_name, 1)
+            connect_entrance(self.multiworld, entrance_name, 'Inverted Big Bomb Shop', 1)
             with self.assertRaises(Exception):
-                set_inverted_big_bomb_rules(self.world, 1)
+                set_inverted_big_bomb_rules(self.multiworld, 1)
             entrance.connected_region.entrances.remove(entrance)
             entrance.connected_region = None

test/inverted_minor_glitches/TestInvertedMinor.py

@@ -15,24 +15,24 @@ from worlds import AutoWorld
 
 class TestInvertedMinor(TestBase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.mode[1] = "inverted"
-        self.world.logic[1] = "minorglitches"
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        create_inverted_regions(self.world, 1)
-        create_dungeons(self.world, 1)
-        create_shops(self.world, 1)
-        link_inverted_entrances(self.world, 1)
-        self.world.worlds[1].create_items()
-        self.world.required_medallions[1] = ['Ether', 'Quake']
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
-        self.world.get_location('Agahnim 1', 1).item = None
-        self.world.get_location('Agahnim 2', 1).item = None
-        mark_light_world_regions(self.world, 1)
-        self.world.worlds[1].set_rules()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.mode[1] = "inverted"
+        self.multiworld.logic[1] = "minorglitches"
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        create_inverted_regions(self.multiworld, 1)
+        create_dungeons(self.multiworld, 1)
+        create_shops(self.multiworld, 1)
+        link_inverted_entrances(self.multiworld, 1)
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.required_medallions[1] = ['Ether', 'Quake']
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
+        self.multiworld.get_location('Agahnim 1', 1).item = None
+        self.multiworld.get_location('Agahnim 2', 1).item = None
+        mark_light_world_regions(self.multiworld, 1)
+        self.multiworld.worlds[1].set_rules()

test/inverted_owg/TestInvertedOWG.py

@@ -16,26 +16,26 @@ from worlds import AutoWorld
 
 class TestInvertedOWG(TestBase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.logic[1] = "owglitches"
-        self.world.mode[1] = "inverted"
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        create_inverted_regions(self.world, 1)
-        create_dungeons(self.world, 1)
-        create_shops(self.world, 1)
-        link_inverted_entrances(self.world, 1)
-        self.world.worlds[1].create_items()
-        self.world.required_medallions[1] = ['Ether', 'Quake']
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
-        self.world.get_location('Agahnim 1', 1).item = None
-        self.world.get_location('Agahnim 2', 1).item = None
-        self.world.precollected_items[1].clear()
-        self.world.itempool.append(ItemFactory('Pegasus Boots', 1))
-        mark_light_world_regions(self.world, 1)
-        self.world.worlds[1].set_rules()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.logic[1] = "owglitches"
+        self.multiworld.mode[1] = "inverted"
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        create_inverted_regions(self.multiworld, 1)
+        create_dungeons(self.multiworld, 1)
+        create_shops(self.multiworld, 1)
+        link_inverted_entrances(self.multiworld, 1)
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.required_medallions[1] = ['Ether', 'Quake']
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
+        self.multiworld.get_location('Agahnim 1', 1).item = None
+        self.multiworld.get_location('Agahnim 2', 1).item = None
+        self.multiworld.precollected_items[1].clear()
+        self.multiworld.itempool.append(ItemFactory('Pegasus Boots', 1))
+        mark_light_world_regions(self.multiworld, 1)
+        self.multiworld.worlds[1].set_rules()

test/minecraft/TestMinecraft.py

@@ -30,28 +30,28 @@ def MCItemFactory(items, player: int):
 class TestMinecraft(TestBase):
 
     def setUp(self):
-        self.world = MultiWorld(1)
-        self.world.game[1] = "Minecraft"
-        self.world.worlds[1] = MinecraftWorld(self.world, 1)
+        self.multiworld = MultiWorld(1)
+        self.multiworld.game[1] = "Minecraft"
+        self.multiworld.worlds[1] = MinecraftWorld(self.multiworld, 1)
         exclusion_pools = ['hard', 'unreasonable', 'postgame']
         for pool in exclusion_pools:
-            setattr(self.world, f"include_{pool}_advancements", {1: False})
-        setattr(self.world, "advancement_goal", {1: AdvancementGoal(30)})
-        setattr(self.world, "egg_shards_required", {1: EggShardsRequired(0)})
-        setattr(self.world, "egg_shards_available", {1: EggShardsAvailable(0)})
-        setattr(self.world, "required_bosses", {1: BossGoal(1)}) # ender dragon
-        setattr(self.world, "shuffle_structures", {1: ShuffleStructures(False)})
-        setattr(self.world, "bee_traps", {1: BeeTraps(0)})
-        setattr(self.world, "combat_difficulty", {1: CombatDifficulty(1)}) # normal
-        setattr(self.world, "structure_compasses", {1: Toggle(False)})
-        setattr(self.world, "death_link", {1: Toggle(False)})
-        AutoWorld.call_single(self.world, "create_regions", 1)
-        AutoWorld.call_single(self.world, "generate_basic", 1)
-        AutoWorld.call_single(self.world, "set_rules", 1)
+            setattr(self.multiworld, f"include_{pool}_advancements", {1: False})
+        setattr(self.multiworld, "advancement_goal", {1: AdvancementGoal(30)})
+        setattr(self.multiworld, "egg_shards_required", {1: EggShardsRequired(0)})
+        setattr(self.multiworld, "egg_shards_available", {1: EggShardsAvailable(0)})
+        setattr(self.multiworld, "required_bosses", {1: BossGoal(1)}) # ender dragon
+        setattr(self.multiworld, "shuffle_structures", {1: ShuffleStructures(False)})
+        setattr(self.multiworld, "bee_traps", {1: BeeTraps(0)})
+        setattr(self.multiworld, "combat_difficulty", {1: CombatDifficulty(1)}) # normal
+        setattr(self.multiworld, "structure_compasses", {1: Toggle(False)})
+        setattr(self.multiworld, "death_link", {1: Toggle(False)})
+        AutoWorld.call_single(self.multiworld, "create_regions", 1)
+        AutoWorld.call_single(self.multiworld, "generate_basic", 1)
+        AutoWorld.call_single(self.multiworld, "set_rules", 1)
 
     def _get_items(self, item_pool, all_except):
         if all_except and len(all_except) > 0:
-            items = self.world.itempool[:]
+            items = self.multiworld.itempool[:]
             items = [item for item in items if
                      item.name not in all_except and not ("Bottle" in item.name and "AnyBottle" in all_except)]
             items.extend(MCItemFactory(item_pool[0], 1))

test/minor_glitches/TestMinor.py

@@ -15,23 +15,23 @@ from worlds import AutoWorld
 
 class TestMinor(TestBase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.logic[1] = "minorglitches"
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        self.world.worlds[1].er_seed = 0
-        self.world.worlds[1].create_regions()
-        self.world.worlds[1].create_items()
-        self.world.required_medallions[1] = ['Ether', 'Quake']
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.logic[1] = "minorglitches"
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        self.multiworld.worlds[1].er_seed = 0
+        self.multiworld.worlds[1].create_regions()
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.required_medallions[1] = ['Ether', 'Quake']
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(
             ['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1',
              'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
-        self.world.get_location('Agahnim 1', 1).item = None
-        self.world.get_location('Agahnim 2', 1).item = None
-        mark_dark_world_regions(self.world, 1)
-        self.world.worlds[1].set_rules()
+        self.multiworld.get_location('Agahnim 1', 1).item = None
+        self.multiworld.get_location('Agahnim 2', 1).item = None
+        mark_dark_world_regions(self.multiworld, 1)
+        self.multiworld.worlds[1].set_rules()

test/owg/TestVanillaOWG.py

@@ -16,23 +16,23 @@ from worlds import AutoWorld
 
 class TestVanillaOWG(TestBase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        self.world.logic[1] = "owglitches"
-        self.world.worlds[1].er_seed = 0
-        self.world.worlds[1].create_regions()
-        self.world.worlds[1].create_items()
-        self.world.required_medallions[1] = ['Ether', 'Quake']
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
-        self.world.get_location('Agahnim 1', 1).item = None
-        self.world.get_location('Agahnim 2', 1).item = None
-        self.world.precollected_items[1].clear()
-        self.world.itempool.append(ItemFactory('Pegasus Boots', 1))
-        mark_dark_world_regions(self.world, 1)
-        self.world.worlds[1].set_rules()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        self.multiworld.logic[1] = "owglitches"
+        self.multiworld.worlds[1].er_seed = 0
+        self.multiworld.worlds[1].create_regions()
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.required_medallions[1] = ['Ether', 'Quake']
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
+        self.multiworld.get_location('Agahnim 1', 1).item = None
+        self.multiworld.get_location('Agahnim 2', 1).item = None
+        self.multiworld.precollected_items[1].clear()
+        self.multiworld.itempool.append(ItemFactory('Pegasus Boots', 1))
+        mark_dark_world_regions(self.multiworld, 1)
+        self.multiworld.worlds[1].set_rules()

test/vanilla/TestVanilla.py

@@ -14,21 +14,21 @@ from worlds import AutoWorld
 
 class TestVanilla(TestBase):
     def setUp(self):
-        self.world = MultiWorld(1)
+        self.multiworld = MultiWorld(1)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
-        self.world.set_options(args)
-        self.world.set_default_common_options()
-        self.world.logic[1] = "noglitches"
-        self.world.difficulty_requirements[1] = difficulties['normal']
-        self.world.worlds[1].er_seed = 0
-        self.world.worlds[1].create_regions()
-        self.world.worlds[1].create_items()
-        self.world.required_medallions[1] = ['Ether', 'Quake']
-        self.world.itempool.extend(get_dungeon_item_pool(self.world))
-        self.world.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
-        self.world.get_location('Agahnim 1', 1).item = None
-        self.world.get_location('Agahnim 2', 1).item = None
-        mark_dark_world_regions(self.world, 1)
-        self.world.worlds[1].set_rules()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
+        self.multiworld.logic[1] = "noglitches"
+        self.multiworld.difficulty_requirements[1] = difficulties['normal']
+        self.multiworld.worlds[1].er_seed = 0
+        self.multiworld.worlds[1].create_regions()
+        self.multiworld.worlds[1].create_items()
+        self.multiworld.required_medallions[1] = ['Ether', 'Quake']
+        self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
+        self.multiworld.itempool.extend(ItemFactory(['Green Pendant', 'Red Pendant', 'Blue Pendant', 'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], 1))
+        self.multiworld.get_location('Agahnim 1', 1).item = None
+        self.multiworld.get_location('Agahnim 2', 1).item = None
+        mark_dark_world_regions(self.multiworld, 1)
+        self.multiworld.worlds[1].set_rules()

test/worlds/test_base.py

@@ -22,29 +22,29 @@ class WorldTestBase(unittest.TestCase):
     def world_setup(self, seed: typing.Optional[int] = None) -> None:
         if not hasattr(self, "game"):
             raise NotImplementedError("didn't define game name")
-        self.world = MultiWorld(1)
-        self.world.game[1] = self.game
-        self.world.player_name = {1: "Tester"}
-        self.world.set_seed(seed)
+        self.multiworld = MultiWorld(1)
+        self.multiworld.game[1] = self.game
+        self.multiworld.player_name = {1: "Tester"}
+        self.multiworld.set_seed(seed)
         args = Namespace()
         for name, option in AutoWorld.AutoWorldRegister.world_types[self.game].option_definitions.items():
             setattr(args, name, {
                 1: option.from_any(self.options.get(name, getattr(option, "default")))
             })
-        self.world.set_options(args)
-        self.world.set_default_common_options()
+        self.multiworld.set_options(args)
+        self.multiworld.set_default_common_options()
         for step in gen_steps:
-            call_all(self.world, step)
+            call_all(self.multiworld, step)
 
     def collect_all_but(self, item_names: typing.Union[str, typing.Iterable[str]]) -> None:
         if isinstance(item_names, str):
             item_names = (item_names,)
-        for item in self.world.get_items():
+        for item in self.multiworld.get_items():
             if item.name not in item_names:
-                self.world.state.collect(item)
+                self.multiworld.state.collect(item)
 
     def get_item_by_name(self, item_name: str) -> Item:
-        for item in self.world.get_items():
+        for item in self.multiworld.get_items():
             if item.name == item_name:
                 return item
         raise ValueError("No such item")
@@ -52,7 +52,7 @@ class WorldTestBase(unittest.TestCase):
     def get_items_by_name(self, item_names: typing.Union[str, typing.Iterable[str]]) -> typing.List[Item]:
         if isinstance(item_names, str):
             item_names = (item_names,)
-        return [item for item in self.world.itempool if item.name in item_names]
+        return [item for item in self.multiworld.itempool if item.name in item_names]
 
     def collect_by_name(self, item_names: typing.Union[str, typing.Iterable[str]]) -> typing.List[Item]:
         """ collect all of the items in the item pool that have the given names """
@@ -64,21 +64,21 @@ class WorldTestBase(unittest.TestCase):
         if isinstance(items, Item):
             items = (items,)
         for item in items:
-            self.world.state.collect(item)
+            self.multiworld.state.collect(item)
 
     def remove(self, items: typing.Union[Item, typing.Iterable[Item]]) -> None:
         if isinstance(items, Item):
             items = (items,)
         for item in items:
-            if item.location and item.location.event and item.location in self.world.state.events:
-                self.world.state.events.remove(item.location)
-            self.world.state.remove(item)
+            if item.location and item.location.event and item.location in self.multiworld.state.events:
+                self.multiworld.state.events.remove(item.location)
+            self.multiworld.state.remove(item)
 
     def can_reach_location(self, location: str) -> bool:
-        return self.world.state.can_reach(location, "Location", 1)
+        return self.multiworld.state.can_reach(location, "Location", 1)
 
     def count(self, item_name: str) -> int:
-        return self.world.state.count(item_name, 1)
+        return self.multiworld.state.count(item_name, 1)
 
     def assertAccessDependency(self,
                                locations: typing.List[str],
@@ -86,8 +86,8 @@ class WorldTestBase(unittest.TestCase):
         all_items = [item_name for item_names in possible_items for item_name in item_names]
 
         self.collect_all_but(all_items)
-        for location in self.world.get_locations():
-            self.assertEqual(self.world.state.can_reach(location), location.name not in locations)
+        for location in self.multiworld.get_locations():
+            self.assertEqual(self.multiworld.state.can_reach(location), location.name not in locations)
         for item_names in possible_items:
             items = self.collect_by_name(item_names)
             for location in locations:
@@ -95,4 +95,4 @@ class WorldTestBase(unittest.TestCase):
             self.remove(items)
 
     def assertBeatable(self, beatable: bool):
-        self.assertEqual(self.world.can_beat_game(self.world.state), beatable)
+        self.assertEqual(self.multiworld.can_beat_game(self.multiworld.state), beatable)

test/worlds/zillion/TestOptions.py

@@ -9,7 +9,7 @@ class OptionsTest(ZillionTestBase):
 
     def test_validate_default(self) -> None:
         self.world_setup()
-        validate(self.world, 1)
+        validate(self.multiworld, 1)
 
     def test_vblr_ap_to_zz(self) -> None:
         """ all of the valid values for the AP options map to valid values for ZZ options """
@@ -20,7 +20,7 @@ class OptionsTest(ZillionTestBase):
             for value in vblr_class.name_lookup.values():
                 self.options = {option_name: value}
                 self.world_setup()
-                zz_options, _item_counts = validate(self.world, 1)
+                zz_options, _item_counts = validate(self.multiworld, 1)
                 assert getattr(zz_options, option_name) in VBLR_CHOICES
 
     # TODO: test validate with invalid combinations of options

test/worlds/zillion/__init__.py

@@ -13,7 +13,7 @@ class ZillionTestBase(WorldTestBase):
         This makes sure that gun 3 is required by making all the canisters
         in O-7 (including key word canisters) require gun 3.
         """
-        zz_world = cast(ZillionWorld, self.world.worlds[1])
+        zz_world = cast(ZillionWorld, self.multiworld.worlds[1])
         assert zz_world.zz_system.randomizer
         for zz_loc_name, zz_loc in zz_world.zz_system.randomizer.locations.items():
             if zz_loc_name.startswith("r15c6"):