Merge pull request ArchipelagoMW#2 from alwaysintreble/generic-entrance-rando

Author: BadMagic100

.gitignore

@@ -9,12 +9,14 @@
 *.apmc
 *.apz5
 *.aptloz
+*.apemerald
 *.pyc
 *.pyd
 *.sfc
 *.z64
 *.n64
 *.nes
+*.smc
 *.sms
 *.gb
 *.gbc

BaseClasses.py

@@ -116,6 +116,11 @@ def extend(self, regions: Iterable[Region]):
             for region in regions:
                 self.region_cache[region.player][region.name] = region
 
+        def add_group(self, new_id: int):
+            self.region_cache[new_id] = {}
+            self.entrance_cache[new_id] = {}
+            self.location_cache[new_id] = {}
+
         def __iter__(self) -> Iterator[Region]:
             for regions in self.region_cache.values():
                 yield from regions.values()
@@ -223,6 +228,7 @@ def add_group(self, name: str, game: str, players: Set[int] = frozenset()) -> Tu
                 return group_id, group
         new_id: int = self.players + len(self.groups) + 1
 
+        self.regions.add_group(new_id)
         self.game[new_id] = game
         self.player_types[new_id] = NetUtils.SlotType.group
         world_type = AutoWorld.AutoWorldRegister.world_types[game]
@@ -621,7 +627,7 @@ class CollectionState():
     additional_copy_functions: List[Callable[[CollectionState, CollectionState], CollectionState]] = []
 
     def __init__(self, parent: MultiWorld, allow_partial_entrances: bool = False):
-        self.prog_items = {player: Counter() for player in parent.player_ids}
+        self.prog_items = {player: Counter() for player in parent.get_all_ids()}
         self.multiworld = parent
         self.reachable_regions = {player: set() for player in parent.get_all_ids()}
         self.blocked_connections = {player: set() for player in parent.get_all_ids()}
@@ -656,10 +662,9 @@ def update_reachable_regions(self, player: int):
             if new_region in rrp:
                 bc.remove(connection)
             elif connection.can_reach(self):
-                if not self.allow_partial_entrances:
-                    assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
-                elif not new_region:
+                if self.allow_partial_entrances and not new_region:
                     continue
+                assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
                 rrp.add(new_region)
                 bc.remove(connection)
                 bc.update(new_region.exits)
@@ -716,37 +721,43 @@ def sweep_for_events(self, key_only: bool = False, locations: Optional[Iterable[
                 assert isinstance(event.item, Item), "tried to collect Event with no Item"
                 self.collect(event.item, True, event)
 
+    # item name related
     def has(self, item: str, player: int, count: int = 1) -> bool:
         return self.prog_items[player][item] >= count
 
-    def has_all(self, items: Set[str], player: int) -> bool:
+    def has_all(self, items: Iterable[str], player: int) -> bool:
         """Returns True if each item name of items is in state at least once."""
         return all(self.prog_items[player][item] for item in items)
 
-    def has_any(self, items: Set[str], player: int) -> bool:
+    def has_any(self, items: Iterable[str], player: int) -> bool:
         """Returns True if at least one item name of items is in state at least once."""
         return any(self.prog_items[player][item] for item in items)
 
     def count(self, item: str, player: int) -> int:
         return self.prog_items[player][item]
 
+    def item_count(self, item: str, player: int) -> int:
+        Utils.deprecate("Use count instead.")
+        return self.count(item, player)
+
+    # item name group related
     def has_group(self, item_name_group: str, player: int, count: int = 1) -> bool:
         found: int = 0
+        player_prog_items = self.prog_items[player]
         for item_name in self.multiworld.worlds[player].item_name_groups[item_name_group]:
-            found += self.prog_items[player][item_name]
+            found += player_prog_items[item_name]
             if found >= count:
                 return True
         return False
 
     def count_group(self, item_name_group: str, player: int) -> int:
         found: int = 0
+        player_prog_items = self.prog_items[player]
         for item_name in self.multiworld.worlds[player].item_name_groups[item_name_group]:
-            found += self.prog_items[player][item_name]
+            found += player_prog_items[item_name]
         return found
 
-    def item_count(self, item: str, player: int) -> int:
-        return self.prog_items[player][item]
-
+    # Item related
     def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
         if location:
             self.locations_checked.add(location)
@@ -774,7 +785,7 @@ def remove(self, item: Item):
 
 
 class Entrance:
-    class Type(IntEnum):
+    class EntranceType(IntEnum):
         ONE_WAY = 1
         TWO_WAY = 2
 
@@ -785,13 +796,13 @@ class Type(IntEnum):
     parent_region: Optional[Region]
     connected_region: Optional[Region] = None
     er_group: str
-    er_type: Type
+    er_type: EntranceType
     # LttP specific, TODO: should make a LttPEntrance
     addresses = None
     target = None
 
-    def __init__(self, player: int, name: str = '', parent: Region = None,
-                 er_group: str = 'Default', er_type: Type = Type.ONE_WAY):
+    def __init__(self, player: int, name: str = "", parent: Region = None,
+                 er_group: str = "Default", er_type: EntranceType = EntranceType.ONE_WAY):
         self.name = name
         self.parent_region = parent
         self.player = player
@@ -800,7 +811,7 @@ def __init__(self, player: int, name: str = '', parent: Region = None,
 
     def can_reach(self, state: CollectionState) -> bool:
         if self.parent_region.can_reach(state) and self.access_rule(state):
-            if not self.hide_path and not self in state.path:
+            if not self.hide_path and self not in state.path:
                 state.path[self] = (self.name, state.path.get(self.parent_region, (self.parent_region.name, None)))
             return True
 
@@ -812,7 +823,7 @@ def connect(self, region: Region, addresses: Any = None, target: Any = None) ->
         self.addresses = addresses
         region.entrances.append(self)
 
-    def is_valid_source_transition(self, state: ERPlacementState) -> bool:
+    def is_valid_source_transition(self, state: "ERPlacementState") -> bool:
         """
         Determines whether this is a valid source transition, that is, whether the entrance
         randomizer is allowed to pair it to place any other regions. By default, this is the
@@ -823,7 +834,7 @@ def is_valid_source_transition(self, state: ERPlacementState) -> bool:
         """
         return self.can_reach(state.collection_state)
 
-    def can_connect_to(self, other: Entrance, state: ERPlacementState) -> bool:
+    def can_connect_to(self, other: Entrance, state: "ERPlacementState") -> bool:
         """
         Determines whether a given Entrance is a valid target transition, that is, whether
         the entrance randomizer is allowed to pair this Entrance to that Entrance.

CommonClient.py

@@ -737,7 +737,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         elif 'InvalidGame' in errors:
             ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
-            raise Exception('Server reported your client version as incompatible')
+            raise Exception('Server reported your client version as incompatible. '
+                            'This probably means you have to update.')
         elif 'InvalidItemsHandling' in errors:
             raise Exception('The item handling flags requested by the client are not supported')
         # last to check, recoverable problem