Ejemplo n.º 1
0
def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
    if not baked_server_options:
        baked_server_options = get_options()["server_options"]
    if args.outputpath:
        os.makedirs(args.outputpath, exist_ok=True)
        output_path.cached_path = args.outputpath

    start = time.perf_counter()
    # initialize the world
    world = MultiWorld(args.multi)

    logger = logging.getLogger()
    world.set_seed(seed, args.race, str(args.outputname if args.outputname else world.seed))

    world.shuffle = args.shuffle.copy()
    world.logic = args.logic.copy()
    world.mode = args.mode.copy()
    world.difficulty = args.difficulty.copy()
    world.item_functionality = args.item_functionality.copy()
    world.timer = args.timer.copy()
    world.goal = args.goal.copy()
    world.open_pyramid = args.open_pyramid.copy()
    world.boss_shuffle = args.shufflebosses.copy()
    world.enemy_health = args.enemy_health.copy()
    world.enemy_damage = args.enemy_damage.copy()
    world.beemizer_total_chance = args.beemizer_total_chance.copy()
    world.beemizer_trap_chance = args.beemizer_trap_chance.copy()
    world.timer = args.timer.copy()
    world.countdown_start_time = args.countdown_start_time.copy()
    world.red_clock_time = args.red_clock_time.copy()
    world.blue_clock_time = args.blue_clock_time.copy()
    world.green_clock_time = args.green_clock_time.copy()
    world.dungeon_counters = args.dungeon_counters.copy()
    world.triforce_pieces_available = args.triforce_pieces_available.copy()
    world.triforce_pieces_required = args.triforce_pieces_required.copy()
    world.shop_shuffle = args.shop_shuffle.copy()
    world.shuffle_prizes = args.shuffle_prizes.copy()
    world.sprite_pool = args.sprite_pool.copy()
    world.dark_room_logic = args.dark_room_logic.copy()
    world.plando_items = args.plando_items.copy()
    world.plando_texts = args.plando_texts.copy()
    world.plando_connections = args.plando_connections.copy()
    world.required_medallions = args.required_medallions.copy()
    world.game = args.game.copy()
    world.player_name = args.name.copy()
    world.enemizer = args.enemizercli
    world.sprite = args.sprite.copy()
    world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.

    world.set_options(args)
    world.set_item_links()
    world.state = CollectionState(world)
    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, world.seed)

    logger.info("Found World Types:")
    longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
    numlength = 8
    for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
        if not cls.hidden:
            logger.info(f"  {name:{longest_name}}: {len(cls.item_names):3} "
                        f"Items (IDs: {min(cls.item_id_to_name):{numlength}} - "
                        f"{max(cls.item_id_to_name):{numlength}}) | "
                        f"{len(cls.location_names):3} "
                        f"Locations (IDs: {min(cls.location_id_to_name):{numlength}} - "
                        f"{max(cls.location_id_to_name):{numlength}})")

    AutoWorld.call_stage(world, "assert_generate")

    AutoWorld.call_all(world, "generate_early")

    logger.info('')

    for player in world.player_ids:
        for item_name, count in world.start_inventory[player].value.items():
            for _ in range(count):
                world.push_precollected(world.create_item(item_name, player))

    for player in world.player_ids:
        if player in world.get_game_players("A Link to the Past"):
            # enforce pre-defined local items.
            if world.goal[player] in ["localtriforcehunt", "localganontriforcehunt"]:
                world.local_items[player].value.add('Triforce Piece')

            # Not possible to place pendants/crystals out side of boss prizes yet.
            world.non_local_items[player].value -= item_name_groups['Pendants']
            world.non_local_items[player].value -= item_name_groups['Crystals']

        # items can't be both local and non-local, prefer local
        world.non_local_items[player].value -= world.local_items[player].value

    logger.info('Creating World.')
    AutoWorld.call_all(world, "create_regions")

    logger.info('Creating Items.')
    AutoWorld.call_all(world, "create_items")

    logger.info('Calculating Access Rules.')
    if world.players > 1:
        for player in world.player_ids:
            locality_rules(world, player)
        group_locality_rules(world)
    else:
        world.non_local_items[1].value = set()
        world.local_items[1].value = set()

    AutoWorld.call_all(world, "set_rules")

    for player in world.player_ids:
        exclusion_rules(world, player, world.exclude_locations[player].value)
        world.priority_locations[player].value -= world.exclude_locations[player].value
        for location_name in world.priority_locations[player].value:
            world.get_location(location_name, player).progress_type = LocationProgressType.PRIORITY

    AutoWorld.call_all(world, "generate_basic")

    # temporary home for item links, should be moved out of Main
    for group_id, group in world.groups.items():
        def find_common_pool(players: Set[int], shared_pool: Set[str]):
            classifications = collections.defaultdict(int)
            counters = {player: {name: 0 for name in shared_pool} for player in players}
            for item in world.itempool:
                if item.player in counters and item.name in shared_pool:
                    counters[item.player][item.name] += 1
                    classifications[item.name] |= item.classification

            for player in players.copy():
                if all([counters[player][item] == 0 for item in shared_pool]):
                    players.remove(player)
                    del(counters[player])

            if not players:
                return None, None

            for item in shared_pool:
                count = min(counters[player][item] for player in players)
                if count:
                    for player in players:
                        counters[player][item] = count
                else:
                    for player in players:
                        del(counters[player][item])
            return counters, classifications

        common_item_count, classifications = find_common_pool(group["players"], group["item_pool"])
        if not common_item_count:
            continue

        new_itempool = []
        for item_name, item_count in next(iter(common_item_count.values())).items():
            for _ in range(item_count):
                new_item = group["world"].create_item(item_name)
                # mangle together all original classification bits
                new_item.classification |= classifications[item_name]
                new_itempool.append(new_item)

        region = Region("Menu", RegionType.Generic, "ItemLink", group_id, world)
        world.regions.append(region)
        locations = region.locations = []
        for item in world.itempool:
            count = common_item_count.get(item.player, {}).get(item.name, 0)
            if count:
                loc = Location(group_id, f"Item Link: {item.name} -> {world.player_name[item.player]} {count}",
                               None, region)
                loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
                    state.has(item_name, group_id_, count_)

                locations.append(loc)
                loc.place_locked_item(item)
                common_item_count[item.player][item.name] -= 1
            else:
                new_itempool.append(item)

        itemcount = len(world.itempool)
        world.itempool = new_itempool

        while itemcount > len(world.itempool):
            items_to_add = []
            for player in group["players"]:
                if group["replacement_items"][player]:
                    items_to_add.append(AutoWorld.call_single(world, "create_item", player,
                                                                group["replacement_items"][player]))
                else:
                    items_to_add.append(AutoWorld.call_single(world, "create_filler", player))
            world.random.shuffle(items_to_add)
            world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])

    if any(world.item_links.values()):
        world._recache()
        world._all_state = None

    logger.info("Running Item Plando")

    for item in world.itempool:
        item.world = world

    distribute_planned(world)

    logger.info('Running Pre Main Fill.')

    AutoWorld.call_all(world, "pre_fill")

    logger.info(f'Filling the world with {len(world.itempool)} items.')

    if world.algorithm == 'flood':
        flood_items(world)  # different algo, biased towards early game progress items
    elif world.algorithm == 'balanced':
        distribute_items_restrictive(world)

    AutoWorld.call_all(world, 'post_fill')

    if world.players > 1:
        balance_multiworld_progression(world)

    logger.info(f'Beginning output...')
    outfilebase = 'AP_' + world.seed_name

    output = tempfile.TemporaryDirectory()
    with output as temp_dir:
        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
            check_accessibility_task = pool.submit(world.fulfills_accessibility)

            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
            for player in world.player_ids:
                # skip starting a thread for methods that say "pass".
                if AutoWorld.World.generate_output.__code__ is not world.worlds[player].generate_output.__code__:
                    output_file_futures.append(
                        pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))

            def get_entrance_to_region(region: Region):
                for entrance in region.entrances:
                    if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld, RegionType.Generic):
                        return entrance
                for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
                    return get_entrance_to_region(entrance.parent_region)

            # collect ER hint info
            er_hint_data = {player: {} for player in world.get_game_players("A Link to the Past") if
                            world.shuffle[player] != "vanilla" or world.retro_caves[player]}

            for region in world.regions:
                if region.player in er_hint_data and region.locations:
                    main_entrance = get_entrance_to_region(region)
                    for location in region.locations:
                        if type(location.address) == int:  # skips events and crystals
                            if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
                                er_hint_data[region.player][location.address] = main_entrance.name

            checks_in_area = {player: {area: list() for area in ordered_areas}
                              for player in range(1, world.players + 1)}

            for player in range(1, world.players + 1):
                checks_in_area[player]["Total"] = 0

            for location in world.get_filled_locations():
                if type(location.address) is int:
                    main_entrance = get_entrance_to_region(location.parent_region)
                    if location.game != "A Link to the Past":
                        checks_in_area[location.player]["Light World"].append(location.address)
                    elif location.parent_region.dungeon:
                        dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
                                       'Inverted Ganons Tower': 'Ganons Tower'} \
                            .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
                        checks_in_area[location.player][dungeonname].append(location.address)
                    elif location.parent_region.type == RegionType.LightWorld:
                        checks_in_area[location.player]["Light World"].append(location.address)
                    elif location.parent_region.type == RegionType.DarkWorld:
                        checks_in_area[location.player]["Dark World"].append(location.address)
                    elif main_entrance.parent_region.type == RegionType.LightWorld:
                        checks_in_area[location.player]["Light World"].append(location.address)
                    elif main_entrance.parent_region.type == RegionType.DarkWorld:
                        checks_in_area[location.player]["Dark World"].append(location.address)
                    checks_in_area[location.player]["Total"] += 1

            oldmancaves = []
            takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
            for index, take_any in enumerate(takeanyregions):
                for region in [world.get_region(take_any, player) for player in
                               world.get_game_players("A Link to the Past") if world.retro_caves[player]]:
                    item = world.create_item(
                        region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'],
                        region.player)
                    player = region.player
                    location_id = SHOP_ID_START + total_shop_slots + index

                    main_entrance = get_entrance_to_region(region)
                    if main_entrance.parent_region.type == RegionType.LightWorld:
                        checks_in_area[player]["Light World"].append(location_id)
                    else:
                        checks_in_area[player]["Dark World"].append(location_id)
                    checks_in_area[player]["Total"] += 1

                    er_hint_data[player][location_id] = main_entrance.name
                    oldmancaves.append(((location_id, player), (item.code, player)))

            FillDisabledShopSlots(world)

            def write_multidata():
                import NetUtils
                slot_data = {}
                client_versions = {}
                games = {}
                minimum_versions = {"server": AutoWorld.World.required_server_version, "clients": client_versions}
                slot_info = {}
                names = [[name for player, name in sorted(world.player_name.items())]]
                for slot in world.player_ids:
                    player_world: AutoWorld.World = world.worlds[slot]
                    minimum_versions["server"] = max(minimum_versions["server"], player_world.required_server_version)
                    client_versions[slot] = player_world.required_client_version
                    games[slot] = world.game[slot]
                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], world.game[slot],
                                                           world.player_types[slot])
                for slot, group in world.groups.items():
                    games[slot] = world.game[slot]
                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], world.game[slot], world.player_types[slot],
                                                           group_members=sorted(group["players"]))
                precollected_items = {player: [item.code for item in world_precollected if type(item.code) == int]
                                      for player, world_precollected in world.precollected_items.items()}
                precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}


                for slot in world.player_ids:
                    slot_data[slot] = world.worlds[slot].fill_slot_data()

                def precollect_hint(location):
                    entrance = er_hint_data.get(location.player, {}).get(location.address, "")
                    hint = NetUtils.Hint(location.item.player, location.player, location.address,
                                         location.item.code, False, entrance, location.item.flags)
                    precollected_hints[location.player].add(hint)
                    if location.item.player not in world.groups:
                        precollected_hints[location.item.player].add(hint)
                    else:
                        for player in world.groups[location.item.player]["players"]:
                            precollected_hints[player].add(hint)

                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in world.player_ids}
                for location in world.get_filled_locations():
                    if type(location.address) == int:
                        assert location.item.code is not None, "item code None should be event, " \
                                                               "location.address should then also be None"
                        locations_data[location.player][location.address] = \
                            location.item.code, location.item.player, location.item.flags
                        if location.name in world.start_location_hints[location.player]:
                            precollect_hint(location)
                        elif location.item.name in world.start_hints[location.item.player]:
                            precollect_hint(location)
                        elif any([location.item.name in world.start_hints[player]
                                  for player in world.groups.get(location.item.player, {}).get("players", [])]):
                            precollect_hint(location)

                multidata = {
                    "slot_data": slot_data,
                    "slot_info": slot_info,
                    "names": names,  # TODO: remove around 0.2.5 in favor of slot_info
                    "games": games,  # TODO: remove around 0.2.5 in favor of slot_info
                    "connect_names": {name: (0, player) for player, name in world.player_name.items()},
                    "remote_items": {player for player in world.player_ids if
                                     world.worlds[player].remote_items},
                    "remote_start_inventory": {player for player in world.player_ids if
                                               world.worlds[player].remote_start_inventory},
                    "locations": locations_data,
                    "checks_in_area": checks_in_area,
                    "server_options": baked_server_options,
                    "er_hint_data": er_hint_data,
                    "precollected_items": precollected_items,
                    "precollected_hints": precollected_hints,
                    "version": tuple(version_tuple),
                    "tags": ["AP"],
                    "minimum_versions": minimum_versions,
                    "seed_name": world.seed_name
                }
                AutoWorld.call_all(world, "modify_multidata", multidata)

                multidata = zlib.compress(pickle.dumps(multidata), 9)

                with open(os.path.join(temp_dir, f'{outfilebase}.archipelago'), 'wb') as f:
                    f.write(bytes([3]))  # version of format
                    f.write(multidata)

            multidata_task = pool.submit(write_multidata)
            if not check_accessibility_task.result():
                if not world.can_beat_game():
                    raise Exception("Game appears as unbeatable. Aborting.")
                else:
                    logger.warning("Location Accessibility requirements not fulfilled.")

            # retrieve exceptions via .result() if they occurred.
            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)}).')
                future.result()

        if args.spoiler > 1:
            logger.info('Calculating playthrough.')
            create_playthrough(world)

        if args.spoiler:
            world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))

        zipfilename = output_path(f"AP_{world.seed_name}.zip")
        logger.info(f'Creating final archive at {zipfilename}.')
        with zipfile.ZipFile(zipfilename, mode="w", compression=zipfile.ZIP_DEFLATED,
                             compresslevel=9) as zf:
            for file in os.scandir(temp_dir):
                zf.write(file.path, arcname=file.name)

    logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
    return world
Ejemplo n.º 2
0
def main(args, seed=None):
    if args.outputpath:
        os.makedirs(args.outputpath, exist_ok=True)
        output_path.cached_path = args.outputpath

    start = time.perf_counter()

    # initialize the world
    world = MultiWorld(args.multi)

    logger = logging.getLogger('')
    world.seed = get_seed(seed)
    if args.race:
        world.secure()
    else:
        world.random.seed(world.seed)

    world.shuffle = args.shuffle.copy()
    world.logic = args.logic.copy()
    world.mode = args.mode.copy()
    world.swordless = args.swordless.copy()
    world.difficulty = args.difficulty.copy()
    world.item_functionality = args.item_functionality.copy()
    world.timer = args.timer.copy()
    world.progressive = args.progressive.copy()
    world.goal = args.goal.copy()
    world.local_items = args.local_items.copy()
    if hasattr(args, "algorithm"):  # current GUI options
        world.algorithm = args.algorithm
        world.shuffleganon = args.shuffleganon
        world.custom = args.custom
        world.customitemarray = args.customitemarray

    world.accessibility = args.accessibility.copy()
    world.retro = args.retro.copy()

    world.hints = args.hints.copy()

    world.remote_items = args.remote_items.copy()
    world.mapshuffle = args.mapshuffle.copy()
    world.compassshuffle = args.compassshuffle.copy()
    world.keyshuffle = args.keyshuffle.copy()
    world.bigkeyshuffle = args.bigkeyshuffle.copy()
    world.crystals_needed_for_ganon = {
        player: world.random.randint(0, 7) if args.crystals_ganon[player]
        == 'random' else int(args.crystals_ganon[player])
        for player in range(1, world.players + 1)
    }
    world.crystals_needed_for_gt = {
        player: world.random.randint(0, 7) if args.crystals_gt[player]
        == 'random' else int(args.crystals_gt[player])
        for player in range(1, world.players + 1)
    }
    world.open_pyramid = args.open_pyramid.copy()
    world.boss_shuffle = args.shufflebosses.copy()
    world.enemy_shuffle = args.enemy_shuffle.copy()
    world.enemy_health = args.enemy_health.copy()
    world.enemy_damage = args.enemy_damage.copy()
    world.killable_thieves = args.killable_thieves.copy()
    world.bush_shuffle = args.bush_shuffle.copy()
    world.tile_shuffle = args.tile_shuffle.copy()
    world.beemizer = args.beemizer.copy()
    world.timer = args.timer.copy()
    world.countdown_start_time = args.countdown_start_time.copy()
    world.red_clock_time = args.red_clock_time.copy()
    world.blue_clock_time = args.blue_clock_time.copy()
    world.green_clock_time = args.green_clock_time.copy()
    world.shufflepots = args.shufflepots.copy()
    world.progressive = args.progressive.copy()
    world.dungeon_counters = args.dungeon_counters.copy()
    world.glitch_boots = args.glitch_boots.copy()
    world.triforce_pieces_available = args.triforce_pieces_available.copy()
    world.triforce_pieces_required = args.triforce_pieces_required.copy()
    world.shop_shuffle = args.shop_shuffle.copy()
    world.shop_shuffle_slots = args.shop_shuffle_slots.copy()
    world.progression_balancing = args.progression_balancing.copy()
    world.shuffle_prizes = args.shuffle_prizes.copy()
    world.sprite_pool = args.sprite_pool.copy()
    world.dark_room_logic = args.dark_room_logic.copy()
    world.plando_items = args.plando_items.copy()
    world.plando_texts = args.plando_texts.copy()
    world.plando_connections = args.plando_connections.copy()
    world.er_seeds = getattr(args, "er_seeds", {})
    world.restrict_dungeon_item_on_boss = args.restrict_dungeon_item_on_boss.copy(
    )
    world.required_medallions = args.required_medallions.copy()
    world.game = args.game.copy()
    import Options
    for hk_option in Options.hollow_knight_options:
        setattr(world, hk_option, getattr(args, hk_option, {}))
    for factorio_option in Options.factorio_options:
        setattr(world, factorio_option, getattr(args, factorio_option, {}))
    world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.

    world.rom_seeds = {
        player: random.Random(world.random.randint(0, 999999999))
        for player in range(1, world.players + 1)
    }

    for player in range(1, world.players + 1):
        world.er_seeds[player] = str(world.random.randint(0, 2**64))

        if "-" in world.shuffle[player]:
            shuffle, seed = world.shuffle[player].split("-", 1)
            world.shuffle[player] = shuffle
            if shuffle == "vanilla":
                world.er_seeds[player] = "vanilla"
            elif seed.startswith("group-") or args.race:
                # renamed from team to group to not confuse with existing team name use
                world.er_seeds[player] = get_same_seed(
                    world, (shuffle, seed, world.retro[player],
                            world.mode[player], world.logic[player]))
            else:  # not a race or group seed, use set seed as is.
                world.er_seeds[player] = seed
        elif world.shuffle[player] == "vanilla":
            world.er_seeds[player] = "vanilla"

    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__,
                world.seed)

    parsed_names = parse_player_names(args.names, world.players, args.teams)
    world.teams = len(parsed_names)
    for i, team in enumerate(parsed_names, 1):
        if world.players > 1:
            logger.info('%s%s',
                        'Team%d: ' % i if world.teams > 1 else 'Players: ',
                        ', '.join(team))
        for player, name in enumerate(team, 1):
            world.player_names[player].append(name)

    logger.info('')

    for player in world.alttp_player_ids:
        world.difficulty_requirements[player] = difficulties[
            world.difficulty[player]]

    for player in world.player_ids:
        for tok in filter(None, args.startinventory[player].split(',')):
            item = ItemFactory(tok.strip(), player)
            if item:
                world.push_precollected(item)

        # enforce pre-defined local items.
        if world.goal[player] in [
                "localtriforcehunt", "localganontriforcehunt"
        ]:
            world.local_items[player].add('Triforce Piece')

        # items can't be both local and non-local, prefer local
        world.non_local_items[player] -= world.local_items[player]

        # dungeon items can't be in non-local if the appropriate dungeon item shuffle setting is not set.
        if not world.mapshuffle[player]:
            world.non_local_items[player] -= item_name_groups['Maps']

        if not world.compassshuffle[player]:
            world.non_local_items[player] -= item_name_groups['Compasses']

        if not world.keyshuffle[player]:
            world.non_local_items[player] -= item_name_groups['Small Keys']

        if not world.bigkeyshuffle[player]:
            world.non_local_items[player] -= item_name_groups['Big Keys']

        # Not possible to place pendants/crystals out side of boss prizes yet.
        world.non_local_items[player] -= item_name_groups['Pendants']
        world.non_local_items[player] -= item_name_groups['Crystals']

    for player in world.hk_player_ids:
        hk_create_regions(world, player)

    for player in world.factorio_player_ids:
        factorio_create_regions(world, player)

    for player in world.alttp_player_ids:
        if world.open_pyramid[player] == 'goal':
            world.open_pyramid[player] = world.goal[player] in {
                'crystals', 'ganontriforcehunt', 'localganontriforcehunt',
                'ganonpedestal'
            }
        elif world.open_pyramid[player] == 'auto':
            world.open_pyramid[player] = world.goal[player] in {'crystals', 'ganontriforcehunt', 'localganontriforcehunt', 'ganonpedestal'} and \
                                         (world.shuffle[player] in {'vanilla', 'dungeonssimple', 'dungeonsfull'} or not world.shuffle_ganon)
        else:
            world.open_pyramid[player] = {
                'on': True,
                'off': False,
                'yes': True,
                'no': False
            }.get(world.open_pyramid[player], world.open_pyramid[player])

        world.triforce_pieces_available[player] = max(
            world.triforce_pieces_available[player],
            world.triforce_pieces_required[player])

        if world.mode[player] != 'inverted':
            create_regions(world, player)
        else:
            create_inverted_regions(world, player)
        create_shops(world, player)
        create_dungeons(world, player)

    logger.info('Shuffling the World about.')

    for player in world.alttp_player_ids:
        if world.logic[player] not in ["noglitches", "minorglitches"] and world.shuffle[player] in \
                {"vanilla", "dungeonssimple", "dungeonsfull", "simple", "restricted", "full"}:
            world.fix_fake_world[player] = False

        # seeded entrance shuffle
        old_random = world.random
        world.random = random.Random(world.er_seeds[player])

        if world.mode[player] != 'inverted':
            link_entrances(world, player)
            mark_light_world_regions(world, player)
        else:
            link_inverted_entrances(world, player)
            mark_dark_world_regions(world, player)

        world.random = old_random
        plando_connect(world, player)

    logger.info('Generating Item Pool.')

    for player in world.alttp_player_ids:
        generate_itempool(world, player)

    logger.info('Calculating Access Rules.')
    if world.players > 1:
        for player in world.player_ids:
            locality_rules(world, player)

    for player in world.alttp_player_ids:
        set_rules(world, player)

    for player in world.hk_player_ids:
        gen_hollow(world, player)

    for player in world.factorio_player_ids:
        gen_factorio(world, player)

    logger.info("Running Item Plando")

    for item in world.itempool:
        item.world = world

    distribute_planned(world)

    logger.info('Placing Dungeon Prizes.')

    fill_prizes(world)

    logger.info('Placing Dungeon Items.')

    if world.algorithm in ['balanced', 'vt26'] or any(
            list(args.mapshuffle.values()) +
            list(args.compassshuffle.values()) +
            list(args.keyshuffle.values()) +
            list(args.bigkeyshuffle.values())):
        fill_dungeons_restrictive(world)
    else:
        fill_dungeons(world)

    logger.info('Fill the world.')

    if world.algorithm == 'flood':
        flood_items(
            world)  # different algo, biased towards early game progress items
    elif world.algorithm == 'vt25':
        distribute_items_restrictive(world, False)
    elif world.algorithm == 'vt26':
        distribute_items_restrictive(world, True)
    elif world.algorithm == 'balanced':
        distribute_items_restrictive(world, True)

    logger.info("Filling Shop Slots")

    ShopSlotFill(world)

    if world.players > 1:
        balance_multiworld_progression(world)

    logger.info('Generating output files.')

    outfilebase = 'AP_%s' % (args.outputname
                             if args.outputname else world.seed)

    rom_names = []

    def _gen_rom(team: int, player: int):
        use_enemizer = (world.boss_shuffle[player] != 'none'
                        or world.enemy_shuffle[player]
                        or world.enemy_health[player] != 'default'
                        or world.enemy_damage[player] != 'default'
                        or world.shufflepots[player]
                        or world.bush_shuffle[player]
                        or world.killable_thieves[player])

        rom = LocalRom(args.rom)

        patch_rom(world, rom, player, team, use_enemizer)

        if use_enemizer:
            patch_enemizer(world, team, player, rom, args.enemizercli)

        if args.race:
            patch_race_rom(rom, world, player)

        world.spoiler.hashes[(player, team)] = get_hash_string(rom.hash)

        palettes_options = {}
        palettes_options['dungeon'] = args.uw_palettes[player]
        palettes_options['overworld'] = args.ow_palettes[player]
        palettes_options['hud'] = args.hud_palettes[player]
        palettes_options['sword'] = args.sword_palettes[player]
        palettes_options['shield'] = args.shield_palettes[player]
        palettes_options['link'] = args.link_palettes[player]

        apply_rom_settings(rom,
                           args.heartbeep[player],
                           args.heartcolor[player],
                           args.quickswap[player],
                           args.fastmenu[player],
                           args.disablemusic[player],
                           args.sprite[player],
                           palettes_options,
                           world,
                           player,
                           True,
                           reduceflashing=args.reduceflashing[player]
                           or args.race,
                           triforcehud=args.triforcehud[player])

        mcsb_name = ''
        if all([
                world.mapshuffle[player], world.compassshuffle[player],
                world.keyshuffle[player], world.bigkeyshuffle[player]
        ]):
            mcsb_name = '-keysanity'
        elif [
                world.mapshuffle[player], world.compassshuffle[player],
                world.keyshuffle[player], world.bigkeyshuffle[player]
        ].count(True) == 1:
            mcsb_name = '-mapshuffle' if world.mapshuffle[player] else \
                '-compassshuffle' if world.compassshuffle[player] else \
                '-universal_keys' if world.keyshuffle[player] == "universal" else \
                '-keyshuffle' if world.keyshuffle[player] else '-bigkeyshuffle'
        elif any([
                world.mapshuffle[player], world.compassshuffle[player],
                world.keyshuffle[player], world.bigkeyshuffle[player]
        ]):
            mcsb_name = '-%s%s%s%sshuffle' % (
                'M' if world.mapshuffle[player] else '',
                'C' if world.compassshuffle[player] else '',
                'U' if world.keyshuffle[player] == "universal" else
                'S' if world.keyshuffle[player] else '',
                'B' if world.bigkeyshuffle[player] else '')

        outfilepname = f'_T{team + 1}' if world.teams > 1 else ''
        outfilepname += f'_P{player}'
        outfilepname += f"_{world.player_names[player][team].replace(' ', '_')}" \
            if world.player_names[player][team] != 'Player%d' % player else ''
        outfilestuffs = {
            "logic": world.logic[player],  # 0
            "difficulty": world.difficulty[player],  # 1
            "item_functionality": world.item_functionality[player],  # 2
            "mode": world.mode[player],  # 3
            "goal": world.goal[player],  # 4
            "timer": str(world.timer[player]),  # 5
            "shuffle": world.shuffle[player],  # 6
            "algorithm": world.algorithm,  # 7
            "mscb": mcsb_name,  # 8
            "retro": world.retro[player],  # 9
            "progressive": world.progressive,  # A
            "hints": 'True' if world.hints[player] else 'False'  # B
        }
        #                  0  1  2  3  4 5  6  7 8 9 A B
        outfilesuffix = (
            '_%s_%s-%s-%s-%s%s_%s-%s%s%s%s%s' % (
                #  0          1      2      3    4     5    6      7     8        9         A     B           C
                # _noglitches_normal-normal-open-ganon-ohko_simple-balanced-keysanity-retro-prog_random-nohints
                # _noglitches_normal-normal-open-ganon     _simple-balanced-keysanity-retro
                # _noglitches_normal-normal-open-ganon     _simple-balanced-keysanity      -prog_random
                # _noglitches_normal-normal-open-ganon     _simple-balanced-keysanity                  -nohints
                outfilestuffs["logic"],  # 0
                outfilestuffs["difficulty"],  # 1
                outfilestuffs["item_functionality"],  # 2
                outfilestuffs["mode"],  # 3
                outfilestuffs["goal"],  # 4
                "" if outfilestuffs["timer"] in ['False', 'none', 'display']
                else "-" + outfilestuffs["timer"],  # 5
                outfilestuffs["shuffle"],  # 6
                outfilestuffs["algorithm"],  # 7
                outfilestuffs["mscb"],  # 8
                "-retro" if outfilestuffs["retro"] == "True" else "",  # 9
                "-prog_" + outfilestuffs["progressive"] if
                outfilestuffs["progressive"] in ['off', 'random'] else "",  # A
                "-nohints" if not outfilestuffs["hints"] == "True" else ""
            )  # B
        ) if not args.outputname else ''
        rompath = output_path(
            f'{outfilebase}{outfilepname}{outfilesuffix}.sfc')
        rom.write_to_file(rompath, hide_enemizer=True)
        if args.create_diff:
            Patch.create_patch_file(rompath)
        return player, team, bytes(rom.name)

    pool = concurrent.futures.ThreadPoolExecutor()
    multidata_task = None
    check_accessibility_task = pool.submit(world.fulfills_accessibility)
    if not args.suppress_rom:

        rom_futures = []
        mod_futures = []
        for team in range(world.teams):
            for player in world.alttp_player_ids:
                rom_futures.append(pool.submit(_gen_rom, team, player))
        for player in world.factorio_player_ids:
            mod_futures.append(
                pool.submit(
                    generate_mod, world, player,
                    str(args.outputname if args.outputname else world.seed)))

        def get_entrance_to_region(region: Region):
            for entrance in region.entrances:
                if entrance.parent_region.type in (RegionType.DarkWorld,
                                                   RegionType.LightWorld):
                    return entrance
            for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
                return get_entrance_to_region(entrance.parent_region)

        # collect ER hint info
        er_hint_data = {
            player: {}
            for player in range(1, world.players + 1)
            if world.shuffle[player] != "vanilla" or world.retro[player]
        }
        from worlds.alttp.Regions import RegionType
        for region in world.regions:
            if region.player in er_hint_data and region.locations:
                main_entrance = get_entrance_to_region(region)
                for location in region.locations:
                    if type(location.address
                            ) == int:  # skips events and crystals
                        if lookup_vanilla_location_to_entrance[
                                location.address] != main_entrance.name:
                            er_hint_data[region.player][
                                location.address] = main_entrance.name

        ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle',
                         'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
                         'Tower of Hera', 'Palace of Darkness', 'Swamp Palace',
                         'Skull Woods', 'Thieves Town', 'Ice Palace',
                         'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total")

        checks_in_area = {
            player: {area: list()
                     for area in ordered_areas}
            for player in range(1, world.players + 1)
        }

        for player in range(1, world.players + 1):
            checks_in_area[player]["Total"] = 0

        for location in [
                loc for loc in world.get_filled_locations()
                if type(loc.address) is int
        ]:
            main_entrance = get_entrance_to_region(location.parent_region)
            if location.game != Games.LTTP:
                checks_in_area[location.player]["Light World"].append(
                    location.address)
            elif location.parent_region.dungeon:
                dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
                               'Inverted Ganons Tower': 'Ganons Tower'}\
                    .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
                checks_in_area[location.player][dungeonname].append(
                    location.address)
            elif main_entrance.parent_region.type == RegionType.LightWorld:
                checks_in_area[location.player]["Light World"].append(
                    location.address)
            elif main_entrance.parent_region.type == RegionType.DarkWorld:
                checks_in_area[location.player]["Dark World"].append(
                    location.address)
            checks_in_area[location.player]["Total"] += 1

        oldmancaves = []
        takeanyregions = [
            "Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3",
            "Take-Any #4"
        ]
        for index, take_any in enumerate(takeanyregions):
            for region in [
                    world.get_region(take_any, player)
                    for player in range(1, world.players + 1)
                    if world.retro[player]
            ]:
                item = ItemFactory(
                    region.shop.inventory[(
                        0 if take_any == "Old Man Sword Cave" else 1)]['item'],
                    region.player)
                player = region.player
                location_id = SHOP_ID_START + total_shop_slots + index

                main_entrance = get_entrance_to_region(region)
                if main_entrance.parent_region.type == RegionType.LightWorld:
                    checks_in_area[player]["Light World"].append(location_id)
                else:
                    checks_in_area[player]["Dark World"].append(location_id)
                checks_in_area[player]["Total"] += 1

                er_hint_data[player][location_id] = main_entrance.name
                oldmancaves.append(
                    ((location_id, player), (item.code, player)))

        precollected_items = [[] for player in range(world.players)]
        for item in world.precollected_items:
            precollected_items[item.player - 1].append(item.code)

        FillDisabledShopSlots(world)

        def write_multidata(roms, mods):
            import base64
            for future in roms:
                rom_name = future.result()
                rom_names.append(rom_name)
            client_versions = {}
            minimum_versions = {
                "server": (0, 0, 3),
                "clients": client_versions
            }
            games = {}
            for slot in world.player_ids:
                client_versions[slot] = (0, 0, 3)
                games[slot] = world.game[slot]
            connect_names = {
                base64.b64encode(rom_name).decode(): (team, slot)
                for slot, team, rom_name in rom_names
            }

            for i, team in enumerate(parsed_names):
                for player, name in enumerate(team, 1):
                    if player not in world.alttp_player_ids:
                        connect_names[name] = (i, player)

            multidata = zlib.compress(
                pickle.dumps({
                    "games":
                    games,
                    "names":
                    parsed_names,
                    "connect_names":
                    connect_names,
                    "remote_items": {
                        player
                        for player in range(1, world.players + 1)
                        if world.remote_items[player]
                        or world.game[player] != "A Link to the Past"
                    },
                    "locations": {(location.address, location.player):
                                  (location.item.code, location.item.player)
                                  for location in world.get_filled_locations()
                                  if type(location.address) is int},
                    "checks_in_area":
                    checks_in_area,
                    "server_options":
                    get_options()["server_options"],
                    "er_hint_data":
                    er_hint_data,
                    "precollected_items":
                    precollected_items,
                    "version":
                    tuple(_version_tuple),
                    "tags": ["AP"],
                    "minimum_versions":
                    minimum_versions,
                    "seed_name":
                    str(args.outputname if args.outputname else world.seed)
                }), 9)

            with open(output_path('%s.archipelago' % outfilebase), 'wb') as f:
                f.write(bytes([1]))  # version of format
                f.write(multidata)
            for future in mods:
                future.result()  # collect errors if they occured

        multidata_task = pool.submit(write_multidata, rom_futures, mod_futures)
    if not check_accessibility_task.result():
        if not world.can_beat_game():
            raise Exception("Game appears as unbeatable. Aborting.")
        else:
            logger.warning(
                "Location Accessibility requirements not fulfilled.")
    if multidata_task:
        multidata_task.result()  # retrieve exception if one exists
    pool.shutdown()  # wait for all queued tasks to complete
    if not args.skip_playthrough:
        logger.info('Calculating playthrough.')
    create_playthrough(world)
    if args.create_spoiler:  # needs spoiler.hashes to be filled, that depend on rom_futures being done
        world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))

    logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
    return world