Merge branch 'ArchipelagoMW:main' into tunic-randomizer

Author: silent-destroyer

BaseClasses.py

@@ -487,8 +487,10 @@ def get_placeable_locations(self, state=None, player=None) -> List[Location]:
     def get_unfilled_locations_for_players(self, location_names: List[str], players: Iterable[int]):
         for player in players:
             if not location_names:
-                location_names = [location.name for location in self.get_unfilled_locations(player)]
-            for location_name in location_names:
+                valid_locations = [location.name for location in self.get_unfilled_locations(player)]
+            else:
+                valid_locations = location_names
+            for location_name in valid_locations:
                 location = self._location_cache.get((location_name, player), None)
                 if location is not None and location.item is None:
                     yield location

Fill.py

@@ -51,7 +51,10 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
         items_to_place = [items.pop()
                           for items in reachable_items.values() if items]
         for item in items_to_place:
-            item_pool.remove(item)
+            for p, pool_item in enumerate(item_pool):
+                if pool_item is item:
+                    item_pool.pop(p)
+                    break
         maximum_exploration_state = sweep_from_pool(
             base_state, item_pool + unplaced_items)
 

MultiServer.py

@@ -2118,13 +2118,15 @@ def attrtype(input_text: str):
 async def console(ctx: Context):
     import sys
     queue = asyncio.Queue()
-    Utils.stream_input(sys.stdin, queue)
+    worker = Utils.stream_input(sys.stdin, queue)
     while not ctx.exit_event.is_set():
         try:
             # I don't get why this while loop is needed. Works fine without it on clients,
             # but the queue.get() for server never fulfills if the queue is empty when entering the await.
             while queue.qsize() == 0:
                 await asyncio.sleep(0.05)
+                if not worker.is_alive():
+                    return
             input_text = await queue.get()
             queue.task_done()
             ctx.commandprocessor(input_text)

Options.py

@@ -771,7 +771,7 @@ def verify(self, world: typing.Type[World], player_name: str, plando_options: "P
                                     f"Did you mean '{picks[0][0]}' ({picks[0][1]}% sure)")
 
 
-class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys):
+class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
     default: typing.Dict[str, typing.Any] = {}
     supports_weighting = False
 
@@ -789,8 +789,14 @@ def from_any(cls, data: typing.Dict[str, typing.Any]) -> OptionDict:
     def get_option_name(self, value):
         return ", ".join(f"{key}: {v}" for key, v in value.items())
 
-    def __contains__(self, item):
-        return item in self.value
+    def __getitem__(self, item: str) -> typing.Any:
+        return self.value.__getitem__(item)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return self.value.__iter__()
+
+    def __len__(self) -> int:
+        return self.value.__len__()
 
 
 class ItemDict(OptionDict):

PokemonClient.py

@@ -176,8 +176,10 @@ async def parse_locations(data: List, ctx: GBContext):
     elif (location_name_to_id["Fossil - Choice B"] in ctx.checked_locations and location_name_to_id["Fossil - Choice A"]
             not in ctx.checked_locations):
         hints.append("Fossil - Choice A")
-    hints = [location_name_to_id[loc] for loc in hints if loc not in ctx.auto_hints and location_name_to_id[loc] in
-             ctx.missing_locations and location_name_to_id[loc] not in ctx.locations_checked]
+    hints = [
+        location_name_to_id[loc] for loc in hints if location_name_to_id[loc] not in ctx.auto_hints and
+        location_name_to_id[loc] in ctx.missing_locations and location_name_to_id[loc] not in ctx.locations_checked
+    ]
     if hints:
         await ctx.send_msgs([{"cmd": "LocationScouts", "locations": hints, "create_as_hint": 2}])
     ctx.auto_hints.update(hints)

_speedups.pyx

@@ -16,6 +16,14 @@ from libc.stdint cimport int64_t, uint32_t
 from libcpp.set cimport set as std_set
 from collections import defaultdict
 
+cdef extern from *:
+    """
+    // avoid warning from cython-generated code with MSVC + pyximport
+    #ifdef _MSC_VER
+    #pragma warning( disable: 4551 )
+    #endif
+    """
+
 ctypedef uint32_t ap_player_t  # on AMD64 this is faster (and smaller) than 64bit ints
 ctypedef uint32_t ap_flags_t
 ctypedef int64_t ap_id_t

test/general/TestFill.py

@@ -433,6 +433,20 @@ def test_double_sweep(self):
         self.assertTrue(multi_world.state.prog_items[item.name, item.player], "Sweep did not collect - Test flawed")
         self.assertEqual(multi_world.state.prog_items[item.name, item.player], 1, "Sweep collected multiple times")
 
+    def test_correct_item_instance_removed_from_pool(self):
+        multi_world = generate_multi_world()
+        player1 = generate_player_data(multi_world, 1, 2, 2)
+
+        player1.prog_items[0].name = "Different_item_instance_but_same_item_name"
+        player1.prog_items[1].name = "Different_item_instance_but_same_item_name"
+        loc0 = player1.locations[0]
+
+        fill_restrictive(multi_world, multi_world.state,
+                         [loc0], player1.prog_items)
+
+        self.assertEqual(1, len(player1.prog_items))
+        self.assertIsNot(loc0.item, player1.prog_items[0], "Filled item was still present in item pool")
+
 
 class TestDistributeItemsRestrictive(unittest.TestCase):
     def test_basic_distribute(self):

worlds/alttp/__init__.py

@@ -782,6 +782,32 @@ def get_pre_fill_items(self):
                         res.append(item)
         return res
 
+    def fill_slot_data(self):
+        slot_data = {}
+        if not self.multiworld.is_race:
+            # all of these option are NOT used by the SNI- or Text-Client.
+            # they are used by the alttp-poptracker pack (https://github.com/StripesOO7/alttp-ap-poptracker-pack)
+            # for convenient auto-tracking of the generated settings and adjusting the tracker accordingly
+
+            slot_options = ["crystals_needed_for_gt", "crystals_needed_for_ganon", "open_pyramid",
+                            "bigkey_shuffle", "smallkey_shuffle", "compass_shuffle", "map_shuffle",
+                            "progressive", "swordless", "retro_bow", "retro_caves", "shop_item_slots",
+                            "boss_shuffle", "pot_shuffle", "enemy_shuffle"]
+
+            slot_data = {option_name: getattr(self.multiworld, option_name)[self.player].value for option_name in slot_options}
+
+            slot_data.update({
+                'mode': self.multiworld.mode[self.player],
+                'goal': self.multiworld.goal[self.player],
+                'dark_room_logic': self.multiworld.dark_room_logic[self.player],
+                'mm_medalion': self.multiworld.required_medallions[self.player][0],
+                'tr_medalion': self.multiworld.required_medallions[self.player][1],
+                'shop_shuffle': self.multiworld.shop_shuffle[self.player],
+                'entrance_shuffle': self.multiworld.shuffle[self.player]
+                }
+            )
+        return slot_data
+        
 
 def get_same_seed(world, seed_def: tuple) -> str:
     seeds: typing.Dict[tuple, str] = getattr(world, "__named_seeds", {})

worlds/dkc3/__init__.py

@@ -216,5 +216,8 @@ def create_item(self, name: str, force_non_progression=False) -> Item:
 
         return created_item
 
+    def get_filler_item_name(self) -> str:
+        return self.multiworld.random.choice(list(junk_table.keys()))
+
     def set_rules(self):
         set_rules(self.multiworld, self.player)

worlds/dlcquest/Rules.py

@@ -105,6 +105,8 @@ def set_basic_shuffled_items_rules(World_Options, player, world):
              lambda state: state.has("Sword", player) or state.has("Gun", player))
     set_rule(world.get_location("West Cave Sheep", player),
              lambda state: state.has("Sword", player) or state.has("Gun", player))
+    set_rule(world.get_location("Gun", player),
+             lambda state: state.has("Gun Pack", player))
 
     if World_Options[Options.TimeIsMoney] == Options.TimeIsMoney.option_required:
         set_rule(world.get_location("Sword", player),

worlds/doom_1993/Options.py

@@ -80,7 +80,7 @@ class Episode3(DefaultOnToggle):
     display_name = "Episode 3"
 
 
-class Episode4(DefaultOnToggle):
+class Episode4(Toggle):
     """Thy Flesh Consumed.
     If none of the episodes are chosen, Episode 1 will be chosen by default."""
     display_name = "Episode 4"