diff --git a/test/bases.py b/test/bases.py
index 2d4111d19356..07a3e6008629 100644
--- a/test/bases.py
+++ b/test/bases.py
@@ -10,7 +10,7 @@
 from worlds.AutoWorld import World, call_all
 
 from BaseClasses import Location, MultiWorld, CollectionState, ItemClassification, Item
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 
 
 class TestBase(unittest.TestCase):
@@ -91,15 +91,15 @@ def _get_items(self, item_pool, all_except):
             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))
+            items.extend(item_factory(item_pool[0], self.multiworld.worlds[1]))
         else:
-            items = ItemFactory(item_pool[0], 1)
+            items = item_factory(item_pool[0], self.multiworld.worlds[1])
         return self.get_state(items)
 
     def _get_items_partial(self, item_pool, missing_item):
         new_items = item_pool[0].copy()
         new_items.remove(missing_item)
-        items = ItemFactory(new_items, 1)
+        items = item_factory(new_items, self.multiworld.worlds[1])
         return self.get_state(items)
 
 
diff --git a/test/general/test_items.py b/test/general/test_items.py
index 1612937225f2..82b6030379d6 100644
--- a/test/general/test_items.py
+++ b/test/general/test_items.py
@@ -8,7 +8,7 @@ class TestBase(unittest.TestCase):
     def test_create_item(self):
         """Test that a world can successfully create all items in its datapackage"""
         for game_name, world_type in AutoWorldRegister.world_types.items():
-            proxy_world = world_type(None, 0)  # this is identical to MultiServer.py creating worlds
+            proxy_world = setup_solo_multiworld(world_type, ()).worlds[1]
             for item_name in world_type.item_name_to_id:
                 with self.subTest("Create Item", item_name=item_name, game_name=game_name):
                     item = proxy_world.create_item(item_name)
diff --git a/worlds/AutoWorld.py b/worlds/AutoWorld.py
index dd0f46f6a6d1..d39da3398c53 100644
--- a/worlds/AutoWorld.py
+++ b/worlds/AutoWorld.py
@@ -296,6 +296,7 @@ class World(metaclass=AutoWorldRegister):
     """path it was loaded from"""
 
     def __init__(self, multiworld: "MultiWorld", player: int):
+        assert multiworld is not None
         self.multiworld = multiworld
         self.player = player
 
diff --git a/worlds/alttp/Dungeons.py b/worlds/alttp/Dungeons.py
index c886fce92079..f0b8c2d971b0 100644
--- a/worlds/alttp/Dungeons.py
+++ b/worlds/alttp/Dungeons.py
@@ -7,7 +7,7 @@
 from Fill import fill_restrictive
 
 from .Bosses import BossFactory, Boss
-from .Items import ItemFactory
+from .Items import item_factory
 from .Regions import lookup_boss_drops, key_drop_data
 from .Options import small_key_shuffle
 
@@ -81,90 +81,90 @@ def make_dungeon(name, default_boss, dungeon_regions, big_key, small_keys, dunge
         return dungeon
 
     ES = make_dungeon('Hyrule Castle', None, ['Hyrule Castle', 'Sewers', 'Sewer Drop', 'Sewers (Dark)', 'Sanctuary'],
-                      ItemFactory('Big Key (Hyrule Castle)', player),
-                      ItemFactory(['Small Key (Hyrule Castle)'] * 4, player),
-                      [ItemFactory('Map (Hyrule Castle)', player)])
+                      item_factory('Big Key (Hyrule Castle)', world),
+                      item_factory(['Small Key (Hyrule Castle)'] * 4, world),
+                      [item_factory('Map (Hyrule Castle)', world)])
     EP = make_dungeon('Eastern Palace', 'Armos Knights', ['Eastern Palace'],
-                      ItemFactory('Big Key (Eastern Palace)', player),
-                      ItemFactory(['Small Key (Eastern Palace)'] * 2, player),
-                      ItemFactory(['Map (Eastern Palace)', 'Compass (Eastern Palace)'], player))
+                      item_factory('Big Key (Eastern Palace)', world),
+                      item_factory(['Small Key (Eastern Palace)'] * 2, world),
+                      item_factory(['Map (Eastern Palace)', 'Compass (Eastern Palace)'], world))
     DP = make_dungeon('Desert Palace', 'Lanmolas',
                       ['Desert Palace North', 'Desert Palace Main (Inner)', 'Desert Palace Main (Outer)',
-                       'Desert Palace East'], ItemFactory('Big Key (Desert Palace)', player),
-                      ItemFactory(['Small Key (Desert Palace)'] * 4, player),
-                      ItemFactory(['Map (Desert Palace)', 'Compass (Desert Palace)'], player))
+                       'Desert Palace East'], item_factory('Big Key (Desert Palace)', world),
+                      item_factory(['Small Key (Desert Palace)'] * 4, world),
+                      item_factory(['Map (Desert Palace)', 'Compass (Desert Palace)'], world))
     ToH = make_dungeon('Tower of Hera', 'Moldorm',
                        ['Tower of Hera (Bottom)', 'Tower of Hera (Basement)', 'Tower of Hera (Top)'],
-                       ItemFactory('Big Key (Tower of Hera)', player),
-                       [ItemFactory('Small Key (Tower of Hera)', player)],
-                       ItemFactory(['Map (Tower of Hera)', 'Compass (Tower of Hera)'], player))
+                       item_factory('Big Key (Tower of Hera)', world),
+                       [item_factory('Small Key (Tower of Hera)', world)],
+                       item_factory(['Map (Tower of Hera)', 'Compass (Tower of Hera)'], world))
     PoD = make_dungeon('Palace of Darkness', 'Helmasaur King',
                        ['Palace of Darkness (Entrance)', 'Palace of Darkness (Center)',
                         'Palace of Darkness (Big Key Chest)', 'Palace of Darkness (Bonk Section)',
                         'Palace of Darkness (North)', 'Palace of Darkness (Maze)',
                         'Palace of Darkness (Harmless Hellway)', 'Palace of Darkness (Final Section)'],
-                       ItemFactory('Big Key (Palace of Darkness)', player),
-                       ItemFactory(['Small Key (Palace of Darkness)'] * 6, player),
-                       ItemFactory(['Map (Palace of Darkness)', 'Compass (Palace of Darkness)'], player))
+                       item_factory('Big Key (Palace of Darkness)', world),
+                       item_factory(['Small Key (Palace of Darkness)'] * 6, world),
+                       item_factory(['Map (Palace of Darkness)', 'Compass (Palace of Darkness)'], world))
     TT = make_dungeon('Thieves Town', 'Blind', ['Thieves Town (Entrance)', 'Thieves Town (Deep)', 'Blind Fight'],
-                      ItemFactory('Big Key (Thieves Town)', player),
-                      ItemFactory(['Small Key (Thieves Town)'] * 3, player),
-                      ItemFactory(['Map (Thieves Town)', 'Compass (Thieves Town)'], player))
+                      item_factory('Big Key (Thieves Town)', world),
+                      item_factory(['Small Key (Thieves Town)'] * 3, world),
+                      item_factory(['Map (Thieves Town)', 'Compass (Thieves Town)'], world))
     SW = make_dungeon('Skull Woods', 'Mothula', ['Skull Woods Final Section (Entrance)', 'Skull Woods First Section',
                                                  'Skull Woods Second Section', 'Skull Woods Second Section (Drop)',
                                                  'Skull Woods Final Section (Mothula)',
                                                  'Skull Woods First Section (Right)',
                                                  'Skull Woods First Section (Left)', 'Skull Woods First Section (Top)'],
-                      ItemFactory('Big Key (Skull Woods)', player),
-                      ItemFactory(['Small Key (Skull Woods)'] * 5, player),
-                      ItemFactory(['Map (Skull Woods)', 'Compass (Skull Woods)'], player))
+                      item_factory('Big Key (Skull Woods)', world),
+                      item_factory(['Small Key (Skull Woods)'] * 5, world),
+                      item_factory(['Map (Skull Woods)', 'Compass (Skull Woods)'], world))
     SP = make_dungeon('Swamp Palace', 'Arrghus',
                       ['Swamp Palace (Entrance)', 'Swamp Palace (First Room)', 'Swamp Palace (Starting Area)',
                        'Swamp Palace (West)', 'Swamp Palace (Center)', 'Swamp Palace (North)'],
-                      ItemFactory('Big Key (Swamp Palace)', player),
-                      ItemFactory(['Small Key (Swamp Palace)'] * 6, player),
-                      ItemFactory(['Map (Swamp Palace)', 'Compass (Swamp Palace)'], player))
+                      item_factory('Big Key (Swamp Palace)', world),
+                      item_factory(['Small Key (Swamp Palace)'] * 6, world),
+                      item_factory(['Map (Swamp Palace)', 'Compass (Swamp Palace)'], world))
     IP = make_dungeon('Ice Palace', 'Kholdstare',
                       ['Ice Palace (Entrance)', 'Ice Palace (Second Section)', 'Ice Palace (Main)', 'Ice Palace (East)',
-                       'Ice Palace (East Top)', 'Ice Palace (Kholdstare)'], ItemFactory('Big Key (Ice Palace)', player),
-                      ItemFactory(['Small Key (Ice Palace)'] * 6, player),
-                      ItemFactory(['Map (Ice Palace)', 'Compass (Ice Palace)'], player))
+                       'Ice Palace (East Top)', 'Ice Palace (Kholdstare)'], item_factory('Big Key (Ice Palace)', world),
+                      item_factory(['Small Key (Ice Palace)'] * 6, world),
+                      item_factory(['Map (Ice Palace)', 'Compass (Ice Palace)'], world))
     MM = make_dungeon('Misery Mire', 'Vitreous',
                       ['Misery Mire (Entrance)', 'Misery Mire (Main)', 'Misery Mire (West)', 'Misery Mire (Final Area)',
-                       'Misery Mire (Vitreous)'], ItemFactory('Big Key (Misery Mire)', player),
-                      ItemFactory(['Small Key (Misery Mire)'] * 6, player),
-                      ItemFactory(['Map (Misery Mire)', 'Compass (Misery Mire)'], player))
+                       'Misery Mire (Vitreous)'], item_factory('Big Key (Misery Mire)', world),
+                      item_factory(['Small Key (Misery Mire)'] * 6, world),
+                      item_factory(['Map (Misery Mire)', 'Compass (Misery Mire)'], world))
     TR = make_dungeon('Turtle Rock', 'Trinexx',
                       ['Turtle Rock (Entrance)', 'Turtle Rock (First Section)', 'Turtle Rock (Chain Chomp Room)',
                        'Turtle Rock (Pokey Room)',
                        'Turtle Rock (Second Section)', 'Turtle Rock (Big Chest)', 'Turtle Rock (Crystaroller Room)',
                        'Turtle Rock (Dark Room)', 'Turtle Rock (Eye Bridge)', 'Turtle Rock (Trinexx)'],
-                      ItemFactory('Big Key (Turtle Rock)', player),
-                      ItemFactory(['Small Key (Turtle Rock)'] * 6, player),
-                      ItemFactory(['Map (Turtle Rock)', 'Compass (Turtle Rock)'], player))
+                      item_factory('Big Key (Turtle Rock)', world),
+                      item_factory(['Small Key (Turtle Rock)'] * 6, world),
+                      item_factory(['Map (Turtle Rock)', 'Compass (Turtle Rock)'], world))
 
     if multiworld.mode[player] != 'inverted':
         AT = make_dungeon('Agahnims Tower', 'Agahnim', ['Agahnims Tower', 'Agahnim 1'], None,
-                          ItemFactory(['Small Key (Agahnims Tower)'] * 4, player), [])
+                          item_factory(['Small Key (Agahnims Tower)'] * 4, world), [])
         GT = make_dungeon('Ganons Tower', 'Agahnim2',
                           ['Ganons Tower (Entrance)', 'Ganons Tower (Tile Room)', 'Ganons Tower (Compass Room)',
                            'Ganons Tower (Hookshot Room)', 'Ganons Tower (Map Room)', 'Ganons Tower (Firesnake Room)',
                            'Ganons Tower (Teleport Room)', 'Ganons Tower (Bottom)', 'Ganons Tower (Top)',
                            'Ganons Tower (Before Moldorm)', 'Ganons Tower (Moldorm)', 'Agahnim 2'],
-                          ItemFactory('Big Key (Ganons Tower)', player),
-                          ItemFactory(['Small Key (Ganons Tower)'] * 8, player),
-                          ItemFactory(['Map (Ganons Tower)', 'Compass (Ganons Tower)'], player))
+                          item_factory('Big Key (Ganons Tower)', world),
+                          item_factory(['Small Key (Ganons Tower)'] * 8, world),
+                          item_factory(['Map (Ganons Tower)', 'Compass (Ganons Tower)'], world))
     else:
         AT = make_dungeon('Inverted Agahnims Tower', 'Agahnim', ['Inverted Agahnims Tower', 'Agahnim 1'], None,
-                          ItemFactory(['Small Key (Agahnims Tower)'] * 4, player), [])
+                          item_factory(['Small Key (Agahnims Tower)'] * 4, world), [])
         GT = make_dungeon('Inverted Ganons Tower', 'Agahnim2',
                           ['Inverted Ganons Tower (Entrance)', 'Ganons Tower (Tile Room)',
                            'Ganons Tower (Compass Room)', 'Ganons Tower (Hookshot Room)', 'Ganons Tower (Map Room)',
                            'Ganons Tower (Firesnake Room)', 'Ganons Tower (Teleport Room)', 'Ganons Tower (Bottom)',
                            'Ganons Tower (Top)', 'Ganons Tower (Before Moldorm)', 'Ganons Tower (Moldorm)',
-                           'Agahnim 2'], ItemFactory('Big Key (Ganons Tower)', player),
-                          ItemFactory(['Small Key (Ganons Tower)'] * 8, player),
-                          ItemFactory(['Map (Ganons Tower)', 'Compass (Ganons Tower)'], player))
+                           'Agahnim 2'], item_factory('Big Key (Ganons Tower)', world),
+                          item_factory(['Small Key (Ganons Tower)'] * 8, world),
+                          item_factory(['Map (Ganons Tower)', 'Compass (Ganons Tower)'], world))
 
     GT.bosses['bottom'] = BossFactory('Armos Knights', player)
     GT.bosses['middle'] = BossFactory('Lanmolas', player)
@@ -259,7 +259,7 @@ def fill_dungeons_restrictive(multiworld: MultiWorld):
                 if not key_drop_shuffle and player not in multiworld.groups:
                     for key_loc in key_drop_data:
                         key_data = key_drop_data[key_loc]
-                        all_state_base.remove(ItemFactory(key_data[3], player))
+                        all_state_base.remove(item_factory(key_data[3], multiworld.worlds[player]))
                         loc = multiworld.get_location(key_loc, player)
 
                         if loc in all_state_base.events:
diff --git a/worlds/alttp/ItemPool.py b/worlds/alttp/ItemPool.py
index bb5bbaa61a02..7a82d4c6be3d 100644
--- a/worlds/alttp/ItemPool.py
+++ b/worlds/alttp/ItemPool.py
@@ -9,8 +9,8 @@
 from .Bosses import place_bosses
 from .Dungeons import get_dungeon_item_pool_player
 from .EntranceShuffle import connect_entrance
-from .Items import ItemFactory, GetBeemizerItem, trap_replaceable, item_name_groups
-from .Options import small_key_shuffle, compass_shuffle, big_key_shuffle, map_shuffle, TriforcePiecesMode
+from .Items import item_factory, GetBeemizerItem, trap_replaceable, item_name_groups
+from .Options import small_key_shuffle, compass_shuffle, big_key_shuffle, map_shuffle, TriforcePiecesMode, LTTPBosses
 from .StateHelpers import has_triforce_pieces, has_melee_weapon
 from .Regions import key_drop_data
 
@@ -240,9 +240,9 @@ def generate_itempool(world):
     if multiworld.timer[player] in ['ohko', 'timed_ohko']:
         multiworld.can_take_damage[player] = False
     if multiworld.goal[player] in ['pedestal', 'triforce_hunt', 'local_triforce_hunt']:
-        multiworld.push_item(multiworld.get_location('Ganon', player), ItemFactory('Nothing', player), False)
+        multiworld.push_item(multiworld.get_location('Ganon', player), item_factory('Nothing', world), False)
     else:
-        multiworld.push_item(multiworld.get_location('Ganon', player), ItemFactory('Triforce', player), False)
+        multiworld.push_item(multiworld.get_location('Ganon', player), item_factory('Triforce', world), False)
 
     if multiworld.goal[player] in ['triforce_hunt', 'local_triforce_hunt']:
         region = multiworld.get_region('Light World', player)
@@ -252,7 +252,7 @@ def generate_itempool(world):
 
         region.locations.append(loc)
 
-        multiworld.push_item(loc, ItemFactory('Triforce', player), False)
+        multiworld.push_item(loc, item_factory('Triforce', world), False)
         loc.event = True
         loc.locked = True
 
@@ -271,7 +271,7 @@ def generate_itempool(world):
     ]
     for location_name, event_name in event_pairs:
         location = multiworld.get_location(location_name, player)
-        event = ItemFactory(event_name, player)
+        event = item_factory(event_name, world)
         multiworld.push_item(location, event, False)
         location.event = location.locked = True
 
@@ -287,7 +287,7 @@ def generate_itempool(world):
         treasure_hunt_icon, additional_triforce_pieces = get_pool_core(multiworld, player)
 
     for item in precollected_items:
-        multiworld.push_precollected(ItemFactory(item, player))
+        multiworld.push_precollected(item_factory(item, world))
 
     if multiworld.mode[player] == 'standard' and not has_melee_weapon(multiworld.state, player):
         if "Link's Uncle" not in placed_items:
@@ -326,9 +326,9 @@ def generate_itempool(world):
                 multiworld.escape_assist[player].append('bombs')
 
     for (location, item) in placed_items.items():
-        multiworld.get_location(location, player).place_locked_item(ItemFactory(item, player))
+        multiworld.get_location(location, player).place_locked_item(item_factory(item, world))
 
-    items = ItemFactory(pool, player)
+    items = item_factory(pool, world)
     # convert one Progressive Bow into Progressive Bow (Alt), in ID only, for ganon silvers hint text
     if multiworld.worlds[player].has_progressive_bows:
         for item in items:
@@ -349,7 +349,7 @@ def generate_itempool(world):
 
     for key_loc in key_drop_data:
         key_data = key_drop_data[key_loc]
-        drop_item = ItemFactory(key_data[3], player)
+        drop_item = item_factory(key_data[3], world)
         if not multiworld.key_drop_shuffle[player]:
             if drop_item in dungeon_items:
                 dungeon_items.remove(drop_item)
@@ -370,7 +370,7 @@ def generate_itempool(world):
             loc.address = None
         elif "Small" in key_data[3] and multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal:
             # key drop shuffle and universal keys are on. Add universal keys in place of key drop keys.
-            multiworld.itempool.append(ItemFactory(GetBeemizerItem(multiworld, player, 'Small Key (Universal)'), player))
+            multiworld.itempool.append(item_factory(GetBeemizerItem(multiworld, player, 'Small Key (Universal)'), world))
     dungeon_item_replacements = sum(difficulties[multiworld.difficulty[player]].extras, []) * 2
     multiworld.random.shuffle(dungeon_item_replacements)
 
@@ -382,7 +382,7 @@ def generate_itempool(world):
                 or (multiworld.map_shuffle[player] == map_shuffle.option_start_with and item.type == 'Map')):
             dungeon_items.pop(x)
             multiworld.push_precollected(item)
-            multiworld.itempool.append(ItemFactory(dungeon_item_replacements.pop(), player))
+            multiworld.itempool.append(item_factory(dungeon_item_replacements.pop(), world))
     multiworld.itempool.extend([item for item in dungeon_items])
 
     set_up_shops(multiworld, player)
@@ -394,7 +394,7 @@ def generate_itempool(world):
                           location.shop_slot is not None]
         for location in shop_locations:
             if location.shop.inventory[location.shop_slot]["item"] == "Single Arrow":
-                location.place_locked_item(ItemFactory("Single Arrow", player))
+                location.place_locked_item(item_factory("Single Arrow", world))
             else:
                 shop_items += 1
     else:
@@ -406,9 +406,9 @@ def generate_itempool(world):
         multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal) * 0.5
     for _ in range(shop_items):
         if multiworld.random.random() < chance_100:
-            items.append(ItemFactory(GetBeemizerItem(multiworld, player, "Rupees (100)"), player))
+            items.append(item_factory(GetBeemizerItem(multiworld, player, "Rupees (100)"), world))
         else:
-            items.append(ItemFactory(GetBeemizerItem(multiworld, player, "Rupees (50)"), player))
+            items.append(item_factory(GetBeemizerItem(multiworld, player, "Rupees (50)"), world))
 
     multiworld.random.shuffle(items)
     pool_count = len(items)
@@ -431,7 +431,7 @@ def generate_itempool(world):
                 new_items += ["Arrow Upgrade (+5)"] * 6
                 new_items.append("Arrow Upgrade (+5)" if progressive else "Arrow Upgrade (+10)")
 
-    items += [ItemFactory(item, player) for item in new_items]
+    items += [item_factory(item, world) for item in new_items]
     removed_filler = []
 
     multiworld.random.shuffle(items)  # Decide what gets tossed randomly.
@@ -444,22 +444,22 @@ def generate_itempool(world):
         else:
             # no more junk to remove, condense progressive items
             def condense_items(items, small_item, big_item, rem, add):
-                small_item = ItemFactory(small_item, player)
+                small_item = item_factory(small_item, world)
                 # while (len(items) >= pool_count + rem - 1  # minus 1 to account for the replacement item
                 #         and items.count(small_item) >= rem):
                 if items.count(small_item) >= rem:
                     for _ in range(rem):
                         items.remove(small_item)
-                        removed_filler.append(ItemFactory(small_item.name, player))
-                    items += [ItemFactory(big_item, player) for _ in range(add)]
+                        removed_filler.append(item_factory(small_item.name, world))
+                    items += [item_factory(big_item, world) for _ in range(add)]
                     return True
                 return False
 
             def cut_item(items, item_to_cut, minimum_items):
-                item_to_cut = ItemFactory(item_to_cut, player)
+                item_to_cut = item_factory(item_to_cut, world)
                 if items.count(item_to_cut) > minimum_items:
                     items.remove(item_to_cut)
-                    removed_filler.append(ItemFactory(item_to_cut.name, player))
+                    removed_filler.append(item_factory(item_to_cut.name, world))
                     return True
                 return False
 
@@ -551,7 +551,7 @@ def set_up_take_anys(world, player):
     if swords:
         sword = world.random.choice(swords)
         world.itempool.remove(sword)
-        world.itempool.append(ItemFactory('Rupees (20)', player))
+        world.itempool.append(item_factory('Rupees (20)', world))
         old_man_take_any.shop.add_inventory(0, sword.name, 0, 0)
         loc_name = "Old Man Sword Cave"
         location = ALttPLocation(player, loc_name, shop_table_by_location[loc_name], parent=old_man_take_any)
@@ -577,7 +577,7 @@ def set_up_take_anys(world, player):
         location = ALttPLocation(player, take_any.name, shop_table_by_location[take_any.name], parent=take_any)
         location.shop_slot = 1
         take_any.locations.append(location)
-        location.place_locked_item(ItemFactory("Boss Heart Container", player))
+        location.place_locked_item(item_factory("Boss Heart Container", world))
 
 
 def get_pool_core(world, player: int):
diff --git a/worlds/alttp/Items.py b/worlds/alttp/Items.py
index 8e513552ad10..cb44f35d58f1 100644
--- a/worlds/alttp/Items.py
+++ b/worlds/alttp/Items.py
@@ -1,6 +1,7 @@
 import typing
 
 from BaseClasses import ItemClassification as IC
+from worlds.AutoWorld import World
 
 
 def GetBeemizerItem(world, player: int, item):
@@ -17,13 +18,10 @@ def GetBeemizerItem(world, player: int, item):
     if not world.beemizer_trap_chance[player] or world.random.random() > (world.beemizer_trap_chance[player] / 100):
         return "Bee" if isinstance(item, str) else world.create_item("Bee", player)
     else:
-        return "Bee Trap" if isinstance(item, str) else world.create_item("Bee Trap", player)        
+        return "Bee Trap" if isinstance(item, str) else world.create_item("Bee Trap", player)
 
 
-# should be replaced with direct world.create_item(item) call in the future
-def ItemFactory(items: typing.Union[str, typing.Iterable[str]], player: int):
-    from worlds.alttp import ALTTPWorld
-    world = ALTTPWorld(None, player)
+def item_factory(items: typing.Union[str, typing.Iterable[str]], world: World):
     ret = []
     singleton = False
     if isinstance(items, str):
diff --git a/worlds/alttp/Rom.py b/worlds/alttp/Rom.py
index ff4947bb0198..6ef1f0db1947 100644
--- a/worlds/alttp/Rom.py
+++ b/worlds/alttp/Rom.py
@@ -34,7 +34,7 @@
     DeathMountain_texts, \
     LostWoods_texts, WishingWell_texts, DesertPalace_texts, MountainTower_texts, LinksHouse_texts, Lumberjacks_texts, \
     SickKid_texts, FluteBoy_texts, Zora_texts, MagicShop_texts, Sahasrahla_names
-from .Items import ItemFactory, item_table, item_name_groups, progression_items
+from .Items import item_table, item_name_groups, progression_items
 from .EntranceShuffle import door_addresses
 from .Options import small_key_shuffle
 
@@ -996,7 +996,7 @@ def credits_digit(num):
     rom.write_byte(0x18003A, 0x01 if world.dark_world_light_cone else 0x00)
 
     GREEN_TWENTY_RUPEES = 0x47
-    GREEN_CLOCK = ItemFactory('Green Clock', player).code
+    GREEN_CLOCK = item_table["Green Clock"].item_code
 
     rom.write_byte(0x18004F, 0x01)  # Byrna Invulnerability: on
 
@@ -1777,13 +1777,13 @@ def write_custom_shops(rom, world, player):
             if item['player'] and world.game[item['player']] != "A Link to the Past":  # item not native to ALTTP
                 item_code = get_nonnative_item_sprite(world.worlds[item['player']].item_name_to_id[item['item']])
             else:
-                item_code = ItemFactory(item['item'], player).code
+                item_code = item_table[item["item"]].item_code
                 if item['item'] == 'Single Arrow' and item['player'] == 0 and world.retro_bow[player]:
                     rom.write_byte(0x186500 + shop.sram_offset + slot, arrow_mask)
 
             item_data = [shop_id, item_code] + price_data + \
-                        [item['max'], ItemFactory(item['replacement'], player).code if item['replacement'] else 0xFF] + \
-                        replacement_price_data + [0 if item['player'] == player else min(ROM_PLAYER_LIMIT, item['player'])]
+                        [item["max"], item_table[item["replacement"]].item_code if item["replacement"] else 0xFF] + \
+                        replacement_price_data + [0 if item["player"] == player else min(ROM_PLAYER_LIMIT, item["player"])]
             items_data.extend(item_data)
 
     rom.write_bytes(0x184800, shop_data)
diff --git a/worlds/alttp/Rules.py b/worlds/alttp/Rules.py
index b86a793fb937..c3156116e407 100644
--- a/worlds/alttp/Rules.py
+++ b/worlds/alttp/Rules.py
@@ -8,7 +8,7 @@
 
 from . import OverworldGlitchRules
 from .Bosses import GanonDefeatRule
-from .Items import ItemFactory, item_name_groups, item_table, progression_items
+from .Items import item_factory, item_name_groups, item_table, progression_items
 from .Options import small_key_shuffle
 from .OverworldGlitchRules import no_logic_rules, overworld_glitches_rules
 from .Regions import LTTPRegionType, location_table
@@ -1181,7 +1181,7 @@ def tr_big_key_chest_keys_needed(state):
                         forbid_item(world.get_location(location, player), 'Big Key (Turtle Rock)', player)
                 else:
                     # A key is required in the Big Key Chest to prevent a possible softlock.  Place an extra key to ensure 100% locations still works
-                    item = ItemFactory('Small Key (Turtle Rock)', player)
+                    item = item_factory('Small Key (Turtle Rock)', world.worlds[player])
                     location = world.get_location('Turtle Rock - Big Key Chest', player)
                     location.place_locked_item(item)
                     location.event = True
diff --git a/worlds/alttp/test/__init__.py b/worlds/alttp/test/__init__.py
index 5baaa7e88e61..49033a6ce36a 100644
--- a/worlds/alttp/test/__init__.py
+++ b/worlds/alttp/test/__init__.py
@@ -14,3 +14,4 @@ def world_setup(self):
         for name, option in AutoWorldRegister.world_types["A Link to the Past"].options_dataclass.type_hints.items():
             setattr(args, name, {1: option.from_any(getattr(option, "default"))})
         self.multiworld.set_options(args)
+        self.world = self.multiworld.worlds[1]
diff --git a/worlds/alttp/test/dungeons/TestDungeon.py b/worlds/alttp/test/dungeons/TestDungeon.py
index 1f8288ace07f..128f8b41b75e 100644
--- a/worlds/alttp/test/dungeons/TestDungeon.py
+++ b/worlds/alttp/test/dungeons/TestDungeon.py
@@ -2,7 +2,7 @@
 from worlds.alttp.Dungeons import get_dungeon_item_pool
 from worlds.alttp.EntranceShuffle import mandatory_connections, connect_simple
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from worlds.alttp.Regions import create_regions
 from worlds.alttp.Shops import create_shops
 from worlds.alttp.test import LTTPTestBase
@@ -24,10 +24,10 @@ def setUp(self):
         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.world.set_rules()
+        self.world.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))
+        self.multiworld.itempool.extend(item_factory(['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'], self.world))
 
     def run_tests(self, access_pool):
         for exit in self.remove_exits:
@@ -40,9 +40,9 @@ def run_tests(self, access_pool):
                 if all_except and len(all_except) > 0:
                     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))
+                    items.extend(item_factory(item_pool[0], self.world))
                 else:
-                    items = ItemFactory(items, 1)
+                    items = item_factory(items, self.world)
                 state = CollectionState(self.multiworld)
                 state.reachable_regions[1].add(self.multiworld.get_region('Menu', 1))
                 for region_name in self.starting_regions:
diff --git a/worlds/alttp/test/inverted/TestInverted.py b/worlds/alttp/test/inverted/TestInverted.py
index f2c585e46500..069639e81b9d 100644
--- a/worlds/alttp/test/inverted/TestInverted.py
+++ b/worlds/alttp/test/inverted/TestInverted.py
@@ -2,7 +2,7 @@
 from worlds.alttp.EntranceShuffle import link_inverted_entrances
 from worlds.alttp.InvertedRegions import create_inverted_regions
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from worlds.alttp.Regions import mark_light_world_regions
 from worlds.alttp.Shops import create_shops
 from test.TestBase import TestBase
@@ -18,14 +18,14 @@ def setUp(self):
         self.multiworld.bombless_start[1].value = True
         self.multiworld.shuffle_capacity_upgrades[1].value = True
         create_inverted_regions(self.multiworld, 1)
-        self.multiworld.worlds[1].create_dungeons()
+        self.world.create_dungeons()
         create_shops(self.multiworld, 1)
         link_inverted_entrances(self.multiworld, 1)
-        self.multiworld.worlds[1].create_items()
+        self.world.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.itempool.extend(item_factory(['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'], self.world))
         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()
+        self.world.set_rules()
diff --git a/worlds/alttp/test/inverted_minor_glitches/TestInvertedMinor.py b/worlds/alttp/test/inverted_minor_glitches/TestInvertedMinor.py
index 0219332e0748..21dbae6933ea 100644
--- a/worlds/alttp/test/inverted_minor_glitches/TestInvertedMinor.py
+++ b/worlds/alttp/test/inverted_minor_glitches/TestInvertedMinor.py
@@ -2,7 +2,7 @@
 from worlds.alttp.EntranceShuffle import link_inverted_entrances
 from worlds.alttp.InvertedRegions import create_inverted_regions
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from worlds.alttp.Regions import mark_light_world_regions
 from worlds.alttp.Shops import create_shops
 from test.TestBase import TestBase
@@ -19,14 +19,14 @@ def setUp(self):
         self.multiworld.shuffle_capacity_upgrades[1].value = True
         self.multiworld.difficulty_requirements[1] = difficulties['normal']
         create_inverted_regions(self.multiworld, 1)
-        self.multiworld.worlds[1].create_dungeons()
+        self.world.create_dungeons()
         create_shops(self.multiworld, 1)
         link_inverted_entrances(self.multiworld, 1)
-        self.multiworld.worlds[1].create_items()
+        self.world.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.itempool.extend(item_factory(['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'], self.world))
         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()
+        self.world.set_rules()
diff --git a/worlds/alttp/test/inverted_owg/TestInvertedOWG.py b/worlds/alttp/test/inverted_owg/TestInvertedOWG.py
index 849f06098a44..138324a9ff97 100644
--- a/worlds/alttp/test/inverted_owg/TestInvertedOWG.py
+++ b/worlds/alttp/test/inverted_owg/TestInvertedOWG.py
@@ -2,7 +2,7 @@
 from worlds.alttp.EntranceShuffle import link_inverted_entrances
 from worlds.alttp.InvertedRegions import create_inverted_regions
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from worlds.alttp.Regions import mark_light_world_regions
 from worlds.alttp.Shops import create_shops
 from test.TestBase import TestBase
@@ -19,16 +19,16 @@ def setUp(self):
         self.multiworld.shuffle_capacity_upgrades[1].value = True
         self.multiworld.difficulty_requirements[1] = difficulties['normal']
         create_inverted_regions(self.multiworld, 1)
-        self.multiworld.worlds[1].create_dungeons()
+        self.world.create_dungeons()
         create_shops(self.multiworld, 1)
         link_inverted_entrances(self.multiworld, 1)
-        self.multiworld.worlds[1].create_items()
+        self.world.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.itempool.extend(item_factory(['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'], self.world))
         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))
+        self.multiworld.itempool.append(item_factory('Pegasus Boots', self.world))
         mark_light_world_regions(self.multiworld, 1)
-        self.multiworld.worlds[1].set_rules()
+        self.world.set_rules()
diff --git a/worlds/alttp/test/minor_glitches/TestMinor.py b/worlds/alttp/test/minor_glitches/TestMinor.py
index c7de74d3a6c3..547509d58ca6 100644
--- a/worlds/alttp/test/minor_glitches/TestMinor.py
+++ b/worlds/alttp/test/minor_glitches/TestMinor.py
@@ -1,7 +1,7 @@
 from worlds.alttp.Dungeons import get_dungeon_item_pool
 from worlds.alttp.InvertedRegions import mark_dark_world_regions
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from test.TestBase import TestBase
 
 from worlds.alttp.test import LTTPTestBase
@@ -14,15 +14,15 @@ def setUp(self):
         self.multiworld.bombless_start[1].value = True
         self.multiworld.shuffle_capacity_upgrades[1].value = True
         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.world.er_seed = 0
+        self.world.create_regions()
+        self.world.create_items()
         self.multiworld.required_medallions[1] = ['Ether', 'Quake']
         self.multiworld.itempool.extend(get_dungeon_item_pool(self.multiworld))
-        self.multiworld.itempool.extend(ItemFactory(
+        self.multiworld.itempool.extend(item_factory(
             ['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))
+             'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'], self.world))
         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()
+        self.world.set_rules()
diff --git a/worlds/alttp/test/options/TestOpenPyramid.py b/worlds/alttp/test/options/TestOpenPyramid.py
index 895ecb95a949..c7912c43d72b 100644
--- a/worlds/alttp/test/options/TestOpenPyramid.py
+++ b/worlds/alttp/test/options/TestOpenPyramid.py
@@ -1,5 +1,5 @@
-from test.TestBase import WorldTestBase
-from ...Items import ItemFactory
+from test.bases import WorldTestBase
+from ...Items import item_factory
 
 
 class PyramidTestBase(WorldTestBase):
@@ -32,6 +32,6 @@ def testGanonGoalAccess(self):
         self.assertFalse(self.can_reach_entrance("Pyramid Hole"))
         self.collect_by_name(["Hammer", "Progressive Glove", "Moon Pearl"])
         self.assertFalse(self.can_reach_entrance("Pyramid Hole"))
-        self.multiworld.state.collect(ItemFactory("Beat Agahnim 2", 1))
+        self.collect(item_factory("Beat Agahnim 2", self.multiworld.worlds[1]))
         self.assertTrue(self.can_reach_entrance("Pyramid Hole"))
 
diff --git a/worlds/alttp/test/owg/TestVanillaOWG.py b/worlds/alttp/test/owg/TestVanillaOWG.py
index 1f8f2707edaa..aafc04a77e46 100644
--- a/worlds/alttp/test/owg/TestVanillaOWG.py
+++ b/worlds/alttp/test/owg/TestVanillaOWG.py
@@ -1,7 +1,7 @@
 from worlds.alttp.Dungeons import get_dungeon_item_pool
 from worlds.alttp.InvertedRegions import mark_dark_world_regions
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from test.TestBase import TestBase
 
 from worlds.alttp.test import LTTPTestBase
@@ -19,10 +19,10 @@ def setUp(self):
         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.itempool.extend(item_factory(['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'], self.world))
         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))
+        self.multiworld.itempool.append(item_factory('Pegasus Boots', self.world))
         mark_dark_world_regions(self.multiworld, 1)
-        self.multiworld.worlds[1].set_rules()
\ No newline at end of file
+        self.world.set_rules()
diff --git a/worlds/alttp/test/vanilla/TestVanilla.py b/worlds/alttp/test/vanilla/TestVanilla.py
index 3f4fbad8c2b6..e79b4f2ea3f8 100644
--- a/worlds/alttp/test/vanilla/TestVanilla.py
+++ b/worlds/alttp/test/vanilla/TestVanilla.py
@@ -1,7 +1,7 @@
 from worlds.alttp.Dungeons import get_dungeon_item_pool
 from worlds.alttp.InvertedRegions import mark_dark_world_regions
 from worlds.alttp.ItemPool import difficulties
-from worlds.alttp.Items import ItemFactory
+from worlds.alttp.Items import item_factory
 from test.TestBase import TestBase
 from worlds.alttp.test import LTTPTestBase
 
@@ -18,8 +18,8 @@ def setUp(self):
         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.itempool.extend(item_factory(['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'], self.world))
         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()
\ No newline at end of file
+        self.world.set_rules()