Core: add some more types

BaseClasses.py

@@ -586,7 +586,7 @@ class CollectionState(object):
         return any(shop.region.player == player and shop.has(item) and shop.region.can_reach(self) for
                    shop in self.world.shops)
 
-    def item_count(self, item, player: int) -> int:
+    def item_count(self, item: str, player: int) -> int:
         return self.prog_items[item, player]
 
     def has_triforce_pieces(self, count: int, player: int) -> bool:
@@ -713,23 +713,23 @@ class CollectionState(object):
     def has_turtle_rock_medallion(self, player: int) -> bool:
         return self.has(self.world.required_medallions[player][1], player)
 
-    def can_boots_clip_lw(self, player):
+    def can_boots_clip_lw(self, player: int):
         if self.world.mode[player] == 'inverted':
             return self.has('Pegasus Boots', player) and self.has('Moon Pearl', player)
         return self.has('Pegasus Boots', player)
 
-    def can_boots_clip_dw(self, player):
+    def can_boots_clip_dw(self, player: int):
         if self.world.mode[player] != 'inverted':
             return self.has('Pegasus Boots', player) and self.has('Moon Pearl', player)
         return self.has('Pegasus Boots', player)
 
-    def can_get_glitched_speed_lw(self, player):
+    def can_get_glitched_speed_lw(self, player: int):
         rules = [self.has('Pegasus Boots', player), any([self.has('Hookshot', player), self.has_sword(player)])]
         if self.world.mode[player] == 'inverted':
             rules.append(self.has('Moon Pearl', player))
         return all(rules)
 
-    def can_superbunny_mirror_with_sword(self, player):
+    def can_superbunny_mirror_with_sword(self, player: int):
         return self.has('Magic Mirror', player) and self.has_sword(player)
 
     def can_get_glitched_speed_dw(self, player: int):
@@ -758,7 +758,7 @@ class CollectionState(object):
 
         return changed
 
-    def remove(self, item):
+    def remove(self, item: Item):
         changed = self.world.worlds[item.player].remove(self, item)
         if changed:
             # invalidate caches, nothing can be trusted anymore now
@@ -776,14 +776,14 @@ class RegionType(int, Enum):
     Dungeon = 4
 
     @property
-    def is_indoors(self):
+    def is_indoors(self) -> bool:
         """Shorthand for checking if Cave or Dungeon"""
         return self in (RegionType.Cave, RegionType.Dungeon)
 
 
 class Region(object):
 
-    def __init__(self, name: str, type, hint, player: int, world: Optional[MultiWorld] = None):
+    def __init__(self, name: str, type: str, hint, player: int, world: Optional[MultiWorld] = None):
         self.name = name
         self.type = type
         self.entrances = []
@@ -798,12 +798,12 @@ class Region(object):
         self.hint_text = hint
         self.player = player
 
-    def can_reach(self, state: CollectionState):
+    def can_reach(self, state: CollectionState) -> bool:
         if state.stale[self.player]:
             state.update_reachable_regions(self.player)
         return self in state.reachable_regions[self.player]
 
-    def can_reach_private(self, state: CollectionState):
+    def can_reach_private(self, state: CollectionState) -> bool:
         for entrance in self.entrances:
             if entrance.can_reach(state):
                 if not self in state.path:
@@ -831,7 +831,7 @@ class Entrance(object):
         self.player = player
         self.hide_path = False
 
-    def can_reach(self, state):
+    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:
                 state.path[self] = (self.name, state.path.get(self.parent_region, (self.parent_region.name, None)))
@@ -839,7 +839,7 @@ class Entrance(object):
 
         return False
 
-    def connect(self, region, addresses=None, target=None):
+    def connect(self, region: Region, addresses=None, target = None):
         self.connected_region = region
         self.target = target
         self.addresses = addresses
@@ -865,11 +865,11 @@ class Dungeon(object):
         self.world = None
 
     @property
-    def boss(self):
+    def boss(self) -> Optional[Boss]:
         return self.bosses.get(None, None)
 
     @boss.setter
-    def boss(self, value):
+    def boss(self, value: Optional[Boss]):
         self.bosses[None] = value
 
     @property
@@ -896,7 +896,7 @@ class Dungeon(object):
 
 
 class Boss():
-    def __init__(self, name, enemizer_name, defeat_rule, player: int):
+    def __init__(self, name: str, enemizer_name: str, defeat_rule, player: int):
         self.name = name
         self.enemizer_name = enemizer_name
         self.defeat_rule = defeat_rule

Main.py

@@ -321,8 +321,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     logger.warning("Location Accessibility requirements not fulfilled.")
 
             # retrieve exceptions via .result() if they occured.
-            if multidata_task:
-                multidata_task.result()
+            multidata_task.result()
             for i, future in enumerate(concurrent.futures.as_completed(output_file_futures), start=1):
                 if i % 10 == 0 or i == len(output_file_futures):
                     logger.info(f'Generating output files ({i}/{len(output_file_futures)}).')

worlds/alttp/EntranceShuffle.py

@@ -1796,6 +1796,7 @@ def link_inverted_entrances(world, player):
     if world.get_entrance('Inverted Ganons Tower', player).connected_region.name != 'Ganons Tower (Entrance)':
         world.ganonstower_vanilla[player] = False
 
+
 def connect_simple(world, exitname, regionname, player):
     world.get_entrance(exitname, player).connect(world.get_region(regionname, player))
 
@@ -1820,6 +1821,7 @@ def connect_entrance(world, entrancename: str, exitname: str, player: int):
     entrance.connect(region, addresses, target)
     world.spoiler.set_entrance(entrance.name, exit.name if exit is not None else region.name, 'entrance', player)
 
+
 def connect_exit(world, exitname, entrancename, player):
     entrance = world.get_entrance(entrancename, player)
     exit = world.get_entrance(exitname, player)