Cleanup bosses.py

Bosses.py

@@ -1,19 +1,22 @@
 import logging
+from typing import Optional
 
 from BaseClasses import Boss
 from Fill import FillError
 
-def BossFactory(boss, player):
+
+def BossFactory(boss: str, player: int) -> Optional[Boss]:
     if boss is None:
         return None
     if boss in boss_table:
         enemizer_name, defeat_rule = boss_table[boss]
         return Boss(boss, enemizer_name, defeat_rule, player)
 
-    logging.getLogger('').error('Unknown Boss: %s', boss)
+    logging.error('Unknown Boss: %s', boss)
     return None
 
-def ArmosKnightsDefeatRule(state, player):
+
+def ArmosKnightsDefeatRule(state, player: int):
     # Magic amounts are probably a bit overkill
     return (
             state.has_melee_weapon(player) or
@@ -25,7 +28,8 @@ def ArmosKnightsDefeatRule(state, player):
             state.has('Blue Boomerang', player) or
             state.has('Red Boomerang', player))
 
-def LanmolasDefeatRule(state, player):
+
+def LanmolasDefeatRule(state, player: int):
     return (
             state.has_melee_weapon(player) or
             state.has('Fire Rod', player) or
@@ -34,14 +38,17 @@ def LanmolasDefeatRule(state, player):
             state.has('Cane of Byrna', player) or
             state.can_shoot_arrows(player))
 
-def MoldormDefeatRule(state, player):
+
+def MoldormDefeatRule(state, player: int):
     return state.has_melee_weapon(player)
 
-def HelmasaurKingDefeatRule(state, player):
+
+def HelmasaurKingDefeatRule(state, player: int):
     # TODO: technically possible with the hammer
     return state.has_sword(player) or state.can_shoot_arrows(player)
 
-def ArrghusDefeatRule(state, player):
+
+def ArrghusDefeatRule(state, player: int):
     if not state.has('Hookshot', player):
         return False
     # TODO: ideally we would have a check for bow and silvers, which combined with the
@@ -50,11 +57,12 @@ def ArrghusDefeatRule(state, player):
     if state.has_melee_weapon(player):
         return True
 
-    return ((state.has('Fire Rod', player) and (state.can_shoot_arrows(player) or state.can_extend_magic(player, 12))) or #assuming mostly gitting two puff with one shot
+    return ((state.has('Fire Rod', player) and (state.can_shoot_arrows(player) or state.can_extend_magic(player,
+                                                                                                         12))) or  # assuming mostly gitting two puff with one shot
             (state.has('Ice Rod', player) and (state.can_shoot_arrows(player) or state.can_extend_magic(player, 16))))
 
 
-def MothulaDefeatRule(state, player):
+def MothulaDefeatRule(state, player: int):
     return (
             state.has_melee_weapon(player) or
             (state.has('Fire Rod', player) and state.can_extend_magic(player, 10)) or
@@ -65,10 +73,12 @@ def MothulaDefeatRule(state, player):
             state.can_get_good_bee(player)
     )
 
-def BlindDefeatRule(state, player):
+
+def BlindDefeatRule(state, player: int):
     return state.has_melee_weapon(player) or state.has('Cane of Somaria', player) or state.has('Cane of Byrna', player)
 
-def KholdstareDefeatRule(state, player):
+
+def KholdstareDefeatRule(state, player: int):
     return (
             (
                     state.has('Fire Rod', player) or
@@ -91,19 +101,23 @@ def KholdstareDefeatRule(state, player):
             )
     )
 
-def VitreousDefeatRule(state, player):
+
+def VitreousDefeatRule(state, player: int):
     return state.can_shoot_arrows(player) or state.has_melee_weapon(player)
 
-def TrinexxDefeatRule(state, player):
+
+def TrinexxDefeatRule(state, player: int):
     if not (state.has('Fire Rod', player) and state.has('Ice Rod', player)):
         return False
     return state.has('Hammer', player) or state.has('Tempered Sword', player) or state.has('Golden Sword', player) or \
            (state.has('Master Sword', player) and state.can_extend_magic(player, 16)) or \
            (state.has_sword(player) and state.can_extend_magic(player, 32))
 
-def AgahnimDefeatRule(state, player):
+
+def AgahnimDefeatRule(state, player: int):
     return state.has_sword(player) or state.has('Hammer', player) or state.has('Bug Catching Net', player)
 
+
 boss_table = {
     'Armos Knights': ('Armos', ArmosKnightsDefeatRule),
     'Lanmolas': ('Lanmola', LanmolasDefeatRule),
@@ -119,9 +133,8 @@ boss_table = {
     'Agahnim2': ('Agahnim2', AgahnimDefeatRule)
 }
 
-anywhere_bosses = ["Moldorm", "Helmasaur King", "Mothula", "Vitreous"]
 
-def can_place_boss(world, player, boss, dungeon_name, level=None):
+def can_place_boss(world, player: int, boss: str, dungeon_name: str, level: Optional[str] = None) -> bool:
     if world.swords[player] in ['swordless'] and boss == 'Kholdstare' and dungeon_name != 'Ice Palace':
         return False
 
@@ -143,7 +156,13 @@ def can_place_boss(world, player, boss, dungeon_name, level=None):
         return False
     return True
 
-def place_bosses(world, player):
+
+def place_boss(world, player: int, boss: str, location: str, level: Optional[str]):
+    logging.debug('Placing boss %s at %s', boss, location + (' (' + level + ')' if level else ''))
+    world.get_dungeon(location, player).bosses[level] = BossFactory(boss, player)
+
+
+def place_bosses(world, player: int):
     if world.boss_shuffle[player] == 'none':
         return
     # Most to least restrictive order
@@ -182,12 +201,12 @@ def place_bosses(world, player):
 
     all_bosses = sorted(boss_table.keys())  # sorted to be deterministic on older pythons
     placeable_bosses = [boss for boss in all_bosses if boss not in ['Agahnim', 'Agahnim2', 'Ganon']]
-
+    anywhere_bosses = [boss for boss in placeable_bosses if all(
+        can_place_boss(world, player, boss, loc, level) for loc, level in boss_locations)]
     if world.boss_shuffle[player] in ["basic", "normal"]:
         # temporary hack for swordless kholdstare:
         if world.swords[player] == 'swordless':
-            world.get_dungeon('Ice Palace', player).boss = BossFactory('Kholdstare', player)
+            place_boss(world, player, 'Kholdstare', 'Ice Palace', None)
-            logging.getLogger('').debug('Placing boss Kholdstare at Ice Palace')
             boss_locations.remove(['Ice Palace', None])
             placeable_bosses.remove('Kholdstare')
 
@@ -200,43 +219,44 @@ def place_bosses(world, player):
 
         world.random.shuffle(bosses)
         for [loc, level] in boss_locations:
-            loc_text = loc + (' ('+level+')' if level else '')
             boss = next((b for b in bosses if can_place_boss(world, player, b, loc, level)), None)
             if not boss:
+                loc_text = loc + (' (' + level + ')' if level else '')
                 raise FillError('Could not place boss for location %s' % loc_text)
             bosses.remove(boss)
+            place_boss(world, player, boss, loc, level)
 
-            logging.debug('Placing boss %s at %s', boss, loc_text)
-            world.get_dungeon(loc, player).bosses[level] = BossFactory(boss, player)
     elif world.boss_shuffle[player] == "chaos":  # all bosses chosen at random
         for [loc, level] in boss_locations:
-            loc_text = loc + (' ('+level+')' if level else '')
             try:
                 boss = world.random.choice(
                     [b for b in placeable_bosses if can_place_boss(world, player, b, loc, level)])
             except IndexError:
+                loc_text = loc + (' (' + level + ')' if level else '')
                 raise FillError('Could not place boss for location %s' % loc_text)
+            else:
+                place_boss(world, player, boss, loc, level)
 
-            logging.debug('Placing boss %s at %s', boss, loc_text)
-            world.get_dungeon(loc, player).bosses[level] = BossFactory(boss, player)
     elif world.boss_shuffle[player] == "singularity":
-        if world.swords[player] == 'swordless':
         boss = world.random.choice(anywhere_bosses)
-        else:
+        for loc, level in boss_locations:
-            boss = world.random.choice(anywhere_bosses + ["Kholdstare"])
+            place_boss(world, player, boss, loc, level)
-        for [loc, level] in boss_locations:
+
-            logging.debug('Placing boss %s at %s', boss, loc + (' ('+level+')' if level else ''))
-            world.get_dungeon(loc, player).bosses[level] = BossFactory(boss, player)
     elif world.boss_shuffle[player] == "duality":
-        if world.swords[player] == 'swordless':
+        # pick a boss that can only appear in some places
-            used_anywhere_bosses = anywhere_bosses
+        limited_boss = world.random.choice([boss for boss in placeable_bosses if boss not in anywhere_bosses])
+
+        remaining_boss_locations = []
+        for loc, level in boss_locations:
+            #place that boss where it can go
+            if can_place_boss(world, player, limited_boss, loc, level):
+                place_boss(world, player, limited_boss, loc, level)
             else:
-            used_anywhere_bosses = anywhere_bosses + ["Kholdstare"]
+                remaining_boss_locations.append((loc, level))
-
+        #pick a boss to go into the remaining locations
-        limited_boss = world.random.choice([boss for boss in placeable_bosses if boss not in used_anywhere_bosses])
+        remaining_boss = world.random.choice([boss for boss in placeable_bosses if all(
-        anywhere_boss = world.random.choice(used_anywhere_bosses)
+            can_place_boss(world, player, boss, loc, level) for loc, level in remaining_boss_locations)])
-
+        logging.info([boss for boss in placeable_bosses if all(
-        for [loc, level] in boss_locations:
+            can_place_boss(world, player, boss, loc, level) for loc, level in remaining_boss_locations)])
-            boss = limited_boss if can_place_boss(world, player, limited_boss, loc, level) else anywhere_boss
+        for loc, level in remaining_boss_locations:
-            logging.debug('Placing boss %s at %s', boss, loc + (' ('+level+')' if level else ''))
+            place_boss(world, player, remaining_boss, loc, level)
-            world.get_dungeon(loc, player).bosses[level] = BossFactory(boss, player)