from typing import Callable, Union, Dict, Set from BaseClasses import MultiWorld from ..generic.Rules import add_rule, set_rule from .Locations import location_table from .Options import SM64Options from .Regions import connect_regions, SM64Levels, sm64_level_to_paintings, sm64_paintings_to_level,\ sm64_level_to_secrets, sm64_secrets_to_level, sm64_entrances_to_level, sm64_level_to_entrances from .Items import action_item_table def shuffle_dict_keys(world, dictionary: dict) -> dict: keys = list(dictionary.keys()) values = list(dictionary.values()) world.random.shuffle(keys) return dict(zip(keys, values)) def fix_reg(entrance_map: Dict[SM64Levels, str], entrance: SM64Levels, invalid_regions: Set[str], swapdict: Dict[SM64Levels, str], world): if entrance_map[entrance] in invalid_regions: # Unlucky :C replacement_regions = [(rand_entrance, rand_region) for rand_entrance, rand_region in swapdict.items() if rand_region not in invalid_regions] rand_entrance, rand_region = world.random.choice(replacement_regions) old_dest = entrance_map[entrance] entrance_map[entrance], entrance_map[rand_entrance] = rand_region, old_dest swapdict[entrance], swapdict[rand_entrance] = rand_region, old_dest swapdict.pop(entrance) def set_rules(world, options: SM64Options, player: int, area_connections: dict, star_costs: dict, move_rando_bitvec: int): randomized_level_to_paintings = sm64_level_to_paintings.copy() randomized_level_to_secrets = sm64_level_to_secrets.copy() valid_move_randomizer_start_courses = [ "Bob-omb Battlefield", "Jolly Roger Bay", "Cool, Cool Mountain", "Big Boo's Haunt", "Lethal Lava Land", "Shifting Sand Land", "Dire, Dire Docks", "Snowman's Land" ] # Excluding WF, HMC, WDW, TTM, THI, TTC, and RR if options.area_rando >= 1: # Some randomization is happening, randomize Courses randomized_level_to_paintings = shuffle_dict_keys(world,sm64_level_to_paintings) # If not shuffling later, ensure a valid start course on move randomizer if options.area_rando < 3 and move_rando_bitvec > 0: swapdict = randomized_level_to_paintings.copy() invalid_start_courses = {course for course in randomized_level_to_paintings.values() if course not in valid_move_randomizer_start_courses} fix_reg(randomized_level_to_paintings, SM64Levels.BOB_OMB_BATTLEFIELD, invalid_start_courses, swapdict, world) fix_reg(randomized_level_to_paintings, SM64Levels.WHOMPS_FORTRESS, invalid_start_courses, swapdict, world) if options.area_rando == 2: # Randomize Secrets as well randomized_level_to_secrets = shuffle_dict_keys(world,sm64_level_to_secrets) randomized_entrances = {**randomized_level_to_paintings, **randomized_level_to_secrets} if options.area_rando == 3: # Randomize Courses and Secrets in one pool randomized_entrances = shuffle_dict_keys(world, randomized_entrances) # Guarantee first entrance is a course swapdict = randomized_entrances.copy() if move_rando_bitvec == 0: fix_reg(randomized_entrances, SM64Levels.BOB_OMB_BATTLEFIELD, sm64_secrets_to_level.keys(), swapdict, world) else: invalid_start_courses = {course for course in randomized_entrances.values() if course not in valid_move_randomizer_start_courses} fix_reg(randomized_entrances, SM64Levels.BOB_OMB_BATTLEFIELD, invalid_start_courses, swapdict, world) fix_reg(randomized_entrances, SM64Levels.WHOMPS_FORTRESS, invalid_start_courses, swapdict, world) # Guarantee BITFS is not mapped to DDD fix_reg(randomized_entrances, SM64Levels.BOWSER_IN_THE_FIRE_SEA, {"Dire, Dire Docks"}, swapdict, world) # Guarantee COTMC is not mapped to HMC, cuz thats impossible. If BitFS -> HMC, also no COTMC -> DDD. if randomized_entrances[SM64Levels.BOWSER_IN_THE_FIRE_SEA] == "Hazy Maze Cave": fix_reg(randomized_entrances, SM64Levels.CAVERN_OF_THE_METAL_CAP, {"Hazy Maze Cave", "Dire, Dire Docks"}, swapdict, world) else: fix_reg(randomized_entrances, SM64Levels.CAVERN_OF_THE_METAL_CAP, {"Hazy Maze Cave"}, swapdict, world) # Destination Format: LVL | AREA with LVL = LEVEL_x, AREA = Area as used in sm64 code # Cast to int to not rely on availability of SM64Levels enum. Will cause crash in MultiServer otherwise area_connections.update({int(entrance_lvl): int(sm64_entrances_to_level[destination]) for (entrance_lvl,destination) in randomized_entrances.items()}) randomized_entrances_s = {sm64_level_to_entrances[entrance_lvl]: destination for (entrance_lvl,destination) in randomized_entrances.items()} rf = RuleFactory(world, options, player, move_rando_bitvec) connect_regions(world, player, "Menu", randomized_entrances_s["Bob-omb Battlefield"]) connect_regions(world, player, "Menu", randomized_entrances_s["Whomp's Fortress"], lambda state: state.has("Power Star", player, 1)) connect_regions(world, player, "Menu", randomized_entrances_s["Jolly Roger Bay"], lambda state: state.has("Power Star", player, 3)) connect_regions(world, player, "Menu", randomized_entrances_s["Cool, Cool Mountain"], lambda state: state.has("Power Star", player, 3)) connect_regions(world, player, "Menu", randomized_entrances_s["Big Boo's Haunt"], lambda state: state.has("Power Star", player, 12)) connect_regions(world, player, "Menu", randomized_entrances_s["The Princess's Secret Slide"], lambda state: state.has("Power Star", player, 1)) connect_regions(world, player, randomized_entrances_s["Jolly Roger Bay"], randomized_entrances_s["The Secret Aquarium"], rf.build_rule("SF/BF | TJ & LG | MOVELESS & TJ")) connect_regions(world, player, "Menu", randomized_entrances_s["Tower of the Wing Cap"], lambda state: state.has("Power Star", player, 10)) connect_regions(world, player, "Menu", randomized_entrances_s["Bowser in the Dark World"], lambda state: state.has("Power Star", player, star_costs["FirstBowserDoorCost"])) connect_regions(world, player, "Menu", "Basement", lambda state: state.has("Basement Key", player) or state.has("Progressive Key", player, 1)) connect_regions(world, player, "Basement", randomized_entrances_s["Hazy Maze Cave"]) connect_regions(world, player, "Basement", randomized_entrances_s["Lethal Lava Land"]) connect_regions(world, player, "Basement", randomized_entrances_s["Shifting Sand Land"]) connect_regions(world, player, "Basement", randomized_entrances_s["Dire, Dire Docks"], lambda state: state.has("Power Star", player, star_costs["BasementDoorCost"])) connect_regions(world, player, "Hazy Maze Cave", randomized_entrances_s["Cavern of the Metal Cap"]) connect_regions(world, player, "Basement", randomized_entrances_s["Vanish Cap under the Moat"], rf.build_rule("GP")) connect_regions(world, player, "Basement", randomized_entrances_s["Bowser in the Fire Sea"], lambda state: state.has("Power Star", player, star_costs["BasementDoorCost"]) and state.can_reach("DDD: Board Bowser's Sub", 'Location', player)) connect_regions(world, player, "Menu", "Second Floor", lambda state: state.has("Second Floor Key", player) or state.has("Progressive Key", player, 2)) connect_regions(world, player, "Second Floor", randomized_entrances_s["Snowman's Land"]) connect_regions(world, player, "Second Floor", randomized_entrances_s["Wet-Dry World"]) connect_regions(world, player, "Second Floor", randomized_entrances_s["Tall, Tall Mountain"]) connect_regions(world, player, "Second Floor", randomized_entrances_s["Tiny-Huge Island (Tiny)"]) connect_regions(world, player, "Second Floor", randomized_entrances_s["Tiny-Huge Island (Huge)"]) connect_regions(world, player, "Tiny-Huge Island (Tiny)", "Tiny-Huge Island") connect_regions(world, player, "Tiny-Huge Island (Huge)", "Tiny-Huge Island") connect_regions(world, player, "Second Floor", "Third Floor", lambda state: state.has("Power Star", player, star_costs["SecondFloorDoorCost"])) connect_regions(world, player, "Third Floor", randomized_entrances_s["Tick Tock Clock"], rf.build_rule("LG/TJ/SF/BF/WK")) connect_regions(world, player, "Third Floor", randomized_entrances_s["Rainbow Ride"], rf.build_rule("TJ/SF/BF")) connect_regions(world, player, "Third Floor", randomized_entrances_s["Wing Mario over the Rainbow"], rf.build_rule("TJ/SF/BF")) connect_regions(world, player, "Third Floor", "Bowser in the Sky", lambda state: state.has("Power Star", player, star_costs["StarsToFinish"])) # Course Rules # Bob-omb Battlefield rf.assign_rule("BoB: Island", "CANN | CANNLESS & WC & TJ | CAPLESS & CANNLESS & LJ") rf.assign_rule("BoB: Mario Wings to the Sky", "CANN & WC | CAPLESS & CANN") rf.assign_rule("BoB: Behind Chain Chomp's Gate", "GP | MOVELESS") # Whomp's Fortress rf.assign_rule("WF: Tower", "GP") rf.assign_rule("WF: Chip Off Whomp's Block", "GP") rf.assign_rule("WF: Shoot into the Wild Blue", "WK & TJ/SF | CANN") rf.assign_rule("WF: Fall onto the Caged Island", "CL & {WF: Tower} | MOVELESS & TJ | MOVELESS & LJ | MOVELESS & CANN") rf.assign_rule("WF: Blast Away the Wall", "CANN | CANNLESS & LG") # Jolly Roger Bay rf.assign_rule("JRB: Upper", "TJ/BF/SF/WK | MOVELESS & LG") rf.assign_rule("JRB: Red Coins on the Ship Afloat", "CL/CANN/TJ | MOVELESS & BF/WK") rf.assign_rule("JRB: Blast to the Stone Pillar", "CANN+CL | CANNLESS & MOVELESS | CANN & MOVELESS") rf.assign_rule("JRB: Through the Jet Stream", "MC | CAPLESS") # Cool, Cool Mountain rf.assign_rule("CCM: Wall Kicks Will Work", "TJ/WK & CANN | CANNLESS & TJ/WK | MOVELESS") # Big Boo's Haunt rf.assign_rule("BBH: Third Floor", "WK+LG | MOVELESS & WK") rf.assign_rule("BBH: Roof", "LJ | MOVELESS") rf.assign_rule("BBH: Secret of the Haunted Books", "KK | MOVELESS") rf.assign_rule("BBH: Seek the 8 Red Coins", "BF/WK/TJ/SF") rf.assign_rule("BBH: Eye to Eye in the Secret Room", "VC") # Haze Maze Cave rf.assign_rule("HMC: Red Coin Area", "CL & WK/LG/BF/SF/TJ | MOVELESS & WK") rf.assign_rule("HMC: Pit Islands", "TJ+CL | MOVELESS & WK & TJ/LJ | MOVELESS & WK+SF+LG") rf.assign_rule("HMC: Metal-Head Mario Can Move!", "LJ+MC | CAPLESS & LJ+TJ | CAPLESS & MOVELESS & LJ/TJ/WK") rf.assign_rule("HMC: Navigating the Toxic Maze", "WK/SF/BF/TJ") rf.assign_rule("HMC: Watch for Rolling Rocks", "WK") # Lethal Lava Land rf.assign_rule("LLL: Upper Volcano", "CL") # Shifting Sand Land rf.assign_rule("SSL: Upper Pyramid", "CL & TJ/BF/SF/LG | MOVELESS") rf.assign_rule("SSL: Stand Tall on the Four Pillars", "TJ+WC+GP | CANN+WC+GP | TJ/SF/BF & CAPLESS | MOVELESS") rf.assign_rule("SSL: Free Flying for 8 Red Coins", "TJ+WC | CANN+WC | TJ/SF/BF & CAPLESS | MOVELESS & CAPLESS") # Dire, Dire Docks rf.assign_rule("DDD: Pole-Jumping for Red Coins", "CL & {{Bowser in the Fire Sea Key}} | TJ+DV+LG+WK & MOVELESS") rf.assign_rule("DDD: Through the Jet Stream", "MC | CAPLESS") rf.assign_rule("DDD: Collect the Caps...", "VC+MC | CAPLESS & VC") # Snowman's Land rf.assign_rule("SL: Snowman's Big Head", "BF/SF/CANN/TJ") rf.assign_rule("SL: In the Deep Freeze", "WK/SF/LG/BF/CANN/TJ") rf.assign_rule("SL: Into the Igloo", "VC & TJ/SF/BF/WK/LG | MOVELESS & VC") # Wet-Dry World rf.assign_rule("WDW: Top", "WK/TJ/SF/BF | MOVELESS") rf.assign_rule("WDW: Downtown", "NAR & LG & TJ/SF/BF | CANN | MOVELESS & TJ+DV") rf.assign_rule("WDW: Go to Town for Red Coins", "WK | MOVELESS & TJ") rf.assign_rule("WDW: Quick Race Through Downtown!", "VC & WK/BF | VC & TJ+LG | MOVELESS & VC & TJ") rf.assign_rule("WDW: Bob-omb Buddy", "TJ | SF+LG | NAR & BF/SF") # Tall, Tall Mountain rf.assign_rule("TTM: Top", "MOVELESS & TJ | LJ/DV & LG/KK | MOVELESS & WK & SF/LG | MOVELESS & KK/DV") rf.assign_rule("TTM: Blast to the Lonely Mushroom", "CANN | CANNLESS & LJ | MOVELESS & CANNLESS") # Tiny-Huge Island rf.assign_rule("THI: 1Up Block THI Small near Start", "NAR | {THI: Pipes}") rf.assign_rule("THI: Pipes", "NAR | LJ/TJ/DV/LG | MOVELESS & BF/SF/KK") rf.assign_rule("THI: Large Top", "NAR | LJ/TJ/DV | MOVELESS") rf.assign_rule("THI: Wiggler's Red Coins", "WK") rf.assign_rule("THI: Make Wiggler Squirm", "GP | MOVELESS & DV") # Tick Tock Clock rf.assign_rule("TTC: Lower", "LG/TJ/SF/BF/WK") rf.assign_rule("TTC: Upper", "CL | MOVELESS & WK") rf.assign_rule("TTC: Top", "TJ+LG | MOVELESS & WK/TJ") rf.assign_rule("TTC: Stop Time for Red Coins", "NAR | {TTC: Lower}") # Rainbow Ride rf.assign_rule("RR: Maze", "WK | LJ & SF/BF/TJ | MOVELESS & LG/TJ") rf.assign_rule("RR: Bob-omb Buddy", "WK | MOVELESS & LG") rf.assign_rule("RR: Swingin' in the Breeze", "LG/TJ/BF/SF | MOVELESS") rf.assign_rule("RR: Tricky Triangles!", "LG/TJ/BF/SF | MOVELESS") rf.assign_rule("RR: Cruiser", "WK/SF/BF/LG/TJ") rf.assign_rule("RR: House", "TJ/SF/BF/LG") rf.assign_rule("RR: Somewhere Over the Rainbow", "CANN") # Cavern of the Metal Cap rf.assign_rule("Cavern of the Metal Cap Red Coins", "MC | CAPLESS") # Vanish Cap Under the Moat rf.assign_rule("Vanish Cap Under the Moat Switch", "WK/TJ/BF/SF/LG | MOVELESS") rf.assign_rule("Vanish Cap Under the Moat Red Coins", "TJ/BF/SF/LG/WK & VC | CAPLESS & WK") # Bowser in the Fire Sea rf.assign_rule("BitFS: Upper", "CL") rf.assign_rule("Bowser in the Fire Sea Red Coins", "LG/WK") rf.assign_rule("Bowser in the Fire Sea 1Up Block Near Poles", "LG/WK") # Wing Mario Over the Rainbow rf.assign_rule("Wing Mario Over the Rainbow Red Coins", "TJ+WC") rf.assign_rule("Wing Mario Over the Rainbow 1Up Block", "TJ+WC") # Bowser in the Sky rf.assign_rule("BitS: Top", "CL+TJ | CL+SF+LG | MOVELESS & TJ+WK+LG") # 100 Coin Stars if options.enable_coin_stars: rf.assign_rule("BoB: 100 Coins", "CANN & WC | CANNLESS & WC & TJ") rf.assign_rule("WF: 100 Coins", "GP | MOVELESS") rf.assign_rule("JRB: 100 Coins", "GP & {JRB: Upper}") rf.assign_rule("HMC: 100 Coins", "GP") rf.assign_rule("SSL: 100 Coins", "{SSL: Upper Pyramid} | GP") rf.assign_rule("DDD: 100 Coins", "GP & {{DDD: Pole-Jumping for Red Coins}}") rf.assign_rule("SL: 100 Coins", "VC | CAPLESS") rf.assign_rule("WDW: 100 Coins", "GP | {WDW: Downtown}") rf.assign_rule("TTC: 100 Coins", "GP") rf.assign_rule("THI: 100 Coins", "GP") rf.assign_rule("RR: 100 Coins", "GP & WK") # Castle Stars add_rule(world.get_location("Toad (Basement)", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, 12)) add_rule(world.get_location("Toad (Second Floor)", player), lambda state: state.can_reach("Second Floor", 'Region', player) and state.has("Power Star", player, 25)) add_rule(world.get_location("Toad (Third Floor)", player), lambda state: state.can_reach("Third Floor", 'Region', player) and state.has("Power Star", player, 35)) if star_costs["MIPS1Cost"] > star_costs["MIPS2Cost"]: (star_costs["MIPS2Cost"], star_costs["MIPS1Cost"]) = (star_costs["MIPS1Cost"], star_costs["MIPS2Cost"]) rf.assign_rule("MIPS 1", "DV | MOVELESS") rf.assign_rule("MIPS 2", "DV | MOVELESS") add_rule(world.get_location("MIPS 1", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, star_costs["MIPS1Cost"])) add_rule(world.get_location("MIPS 2", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, star_costs["MIPS2Cost"])) world.completion_condition[player] = lambda state: state.can_reach("BitS: Top", 'Region', player) if options.completion_type == "last_bowser_stage": world.completion_condition[player] = lambda state: state.can_reach("BitS: Top", 'Region', player) elif options.completion_type == "all_bowser_stages": world.completion_condition[player] = lambda state: state.can_reach("Bowser in the Dark World", 'Region', player) and \ state.can_reach("BitFS: Upper", 'Region', player) and \ state.can_reach("BitS: Top", 'Region', player) class RuleFactory: world: MultiWorld player: int move_rando_bitvec: bool area_randomizer: bool capless: bool cannonless: bool moveless: bool token_table = { "TJ": "Triple Jump", "DJ": "Triple Jump", "LJ": "Long Jump", "BF": "Backflip", "SF": "Side Flip", "WK": "Wall Kick", "DV": "Dive", "GP": "Ground Pound", "KK": "Kick", "CL": "Climb", "LG": "Ledge Grab", "WC": "Wing Cap", "MC": "Metal Cap", "VC": "Vanish Cap" } class SM64LogicException(Exception): pass def __init__(self, world, options: SM64Options, player: int, move_rando_bitvec: int): self.world = world self.player = player self.move_rando_bitvec = move_rando_bitvec self.area_randomizer = options.area_rando > 0 self.capless = not options.strict_cap_requirements self.cannonless = not options.strict_cannon_requirements self.moveless = not options.strict_move_requirements def assign_rule(self, target_name: str, rule_expr: str): target = self.world.get_location(target_name, self.player) if target_name in location_table else self.world.get_entrance(target_name, self.player) cannon_name = "Cannon Unlock " + target_name.split(':')[0] try: rule = self.build_rule(rule_expr, cannon_name) except RuleFactory.SM64LogicException as exception: raise RuleFactory.SM64LogicException( f"Error generating rule for {target_name} using rule expression {rule_expr}: {exception}") if rule: set_rule(target, rule) def build_rule(self, rule_expr: str, cannon_name: str = '') -> Callable: expressions = rule_expr.split(" | ") rules = [] for expression in expressions: or_clause = self.combine_and_clauses(expression, cannon_name) if or_clause is True: return None if or_clause is not False: rules.append(or_clause) if rules: if len(rules) == 1: return rules[0] else: return lambda state: any(rule(state) for rule in rules) else: return None def combine_and_clauses(self, rule_expr: str, cannon_name: str) -> Union[Callable, bool]: expressions = rule_expr.split(" & ") rules = [] for expression in expressions: and_clause = self.make_lambda(expression, cannon_name) if and_clause is False: return False if and_clause is not True: rules.append(and_clause) if rules: if len(rules) == 1: return rules[0] return lambda state: all(rule(state) for rule in rules) else: return True def make_lambda(self, expression: str, cannon_name: str) -> Union[Callable, bool]: if '+' in expression: tokens = expression.split('+') items = set() for token in tokens: item = self.parse_token(token, cannon_name) if item is True: continue if item is False: return False items.add(item) if items: return lambda state: state.has_all(items, self.player) else: return True if '/' in expression: tokens = expression.split('/') items = set() for token in tokens: item = self.parse_token(token, cannon_name) if item is True: return True if item is False: continue items.add(item) if items: return lambda state: state.has_any(items, self.player) else: return False if '{{' in expression: return lambda state: state.can_reach(expression[2:-2], "Location", self.player) if '{' in expression: return lambda state: state.can_reach(expression[1:-1], "Region", self.player) item = self.parse_token(expression, cannon_name) if item in (True, False): return item return lambda state: state.has(item, self.player) def parse_token(self, token: str, cannon_name: str) -> Union[str, bool]: if token == "CANN": return cannon_name if token == "CAPLESS": return self.capless if token == "CANNLESS": return self.cannonless if token == "MOVELESS": return self.moveless if token == "NAR": return not self.area_randomizer item = self.token_table.get(token, None) if not item: raise Exception(f"Invalid token: '{item}'") if item in action_item_table: if self.move_rando_bitvec & (1 << (action_item_table[item] - action_item_table['Double Jump'])) == 0: # This action item is not randomized. return True return item