Grinch-AP/worlds/stardew_valley/locations.py

import csv
import enum
from dataclasses import dataclass
from random import Random
from typing import Optional, Dict, Protocol, List, FrozenSet, Iterable

from . import data
from .bundles.bundle_room import BundleRoom
from .data.fish_data import special_fish, get_fish_for_mods
from .data.museum_data import all_museum_items
from .data.villagers_data import get_villagers_for_mods
from .mods.mod_data import ModNames
from .options import ExcludeGingerIsland, Friendsanity, ArcadeMachineLocations, SpecialOrderLocations, Cropsanity, Fishsanity, Museumsanity, FestivalLocations, \
    SkillProgression, BuildingProgression, ToolProgression, ElevatorProgression, BackpackProgression
from .options import StardewValleyOptions, Craftsanity, Chefsanity, Cooksanity, Shipsanity, Monstersanity
from .strings.goal_names import Goal
from .strings.quest_names import ModQuest
from .strings.region_names import Region
from .strings.villager_names import NPC, ModNPC

LOCATION_CODE_OFFSET = 717000


class LocationTags(enum.Enum):
    MANDATORY = enum.auto()
    BUNDLE = enum.auto()
    COMMUNITY_CENTER_BUNDLE = enum.auto()
    CRAFTS_ROOM_BUNDLE = enum.auto()
    PANTRY_BUNDLE = enum.auto()
    FISH_TANK_BUNDLE = enum.auto()
    BOILER_ROOM_BUNDLE = enum.auto()
    BULLETIN_BOARD_BUNDLE = enum.auto()
    VAULT_BUNDLE = enum.auto()
    COMMUNITY_CENTER_ROOM = enum.auto()
    BACKPACK = enum.auto()
    TOOL_UPGRADE = enum.auto()
    HOE_UPGRADE = enum.auto()
    PICKAXE_UPGRADE = enum.auto()
    AXE_UPGRADE = enum.auto()
    WATERING_CAN_UPGRADE = enum.auto()
    TRASH_CAN_UPGRADE = enum.auto()
    FISHING_ROD_UPGRADE = enum.auto()
    THE_MINES_TREASURE = enum.auto()
    CROPSANITY = enum.auto()
    ELEVATOR = enum.auto()
    SKILL_LEVEL = enum.auto()
    FARMING_LEVEL = enum.auto()
    FISHING_LEVEL = enum.auto()
    FORAGING_LEVEL = enum.auto()
    COMBAT_LEVEL = enum.auto()
    MINING_LEVEL = enum.auto()
    BUILDING_BLUEPRINT = enum.auto()
    STORY_QUEST = enum.auto()
    ARCADE_MACHINE = enum.auto()
    ARCADE_MACHINE_VICTORY = enum.auto()
    JOTPK = enum.auto()
    JUNIMO_KART = enum.auto()
    HELP_WANTED = enum.auto()
    TRAVELING_MERCHANT = enum.auto()
    FISHSANITY = enum.auto()
    MUSEUM_MILESTONES = enum.auto()
    MUSEUM_DONATIONS = enum.auto()
    FRIENDSANITY = enum.auto()
    FESTIVAL = enum.auto()
    FESTIVAL_HARD = enum.auto()
    SPECIAL_ORDER_BOARD = enum.auto()
    SPECIAL_ORDER_QI = enum.auto()
    REQUIRES_QI_ORDERS = enum.auto()
    GINGER_ISLAND = enum.auto()
    WALNUT_PURCHASE = enum.auto()

    BABY = enum.auto()
    MONSTERSANITY = enum.auto()
    MONSTERSANITY_GOALS = enum.auto()
    MONSTERSANITY_PROGRESSIVE_GOALS = enum.auto()
    MONSTERSANITY_MONSTER = enum.auto()
    SHIPSANITY = enum.auto()
    SHIPSANITY_CROP = enum.auto()
    SHIPSANITY_FISH = enum.auto()
    SHIPSANITY_FULL_SHIPMENT = enum.auto()
    COOKSANITY = enum.auto()
    COOKSANITY_QOS = enum.auto()
    CHEFSANITY = enum.auto()
    CHEFSANITY_QOS = enum.auto()
    CHEFSANITY_PURCHASE = enum.auto()
    CHEFSANITY_FRIENDSHIP = enum.auto()
    CHEFSANITY_SKILL = enum.auto()
    CHEFSANITY_STARTER = enum.auto()
    CRAFTSANITY = enum.auto()
    # Mods
    # Skill Mods
    LUCK_LEVEL = enum.auto()
    BINNING_LEVEL = enum.auto()
    COOKING_LEVEL = enum.auto()
    SOCIALIZING_LEVEL = enum.auto()
    MAGIC_LEVEL = enum.auto()
    ARCHAEOLOGY_LEVEL = enum.auto()


@dataclass(frozen=True)
class LocationData:
    code_without_offset: Optional[int]
    region: str
    name: str
    mod_name: Optional[str] = None
    tags: FrozenSet[LocationTags] = frozenset()

    @property
    def code(self) -> Optional[int]:
        return LOCATION_CODE_OFFSET + self.code_without_offset if self.code_without_offset is not None else None


class StardewLocationCollector(Protocol):
    def __call__(self, name: str, code: Optional[int], region: str) -> None:
        raise NotImplementedError


def load_location_csv() -> List[LocationData]:
    try:
        from importlib.resources import files
    except ImportError:
        from importlib_resources import files

    with files(data).joinpath("locations.csv").open() as file:
        reader = csv.DictReader(file)
        return [LocationData(int(location["id"]) if location["id"] else None,
                             location["region"],
                             location["name"],
                             str(location["mod_name"]) if location["mod_name"] else None,
                             frozenset(LocationTags[group]
                                       for group in location["tags"].split(",")
                                       if group))
                for location in reader]


events_locations = [
    LocationData(None, Region.farm_house, Goal.grandpa_evaluation),
    LocationData(None, Region.community_center, Goal.community_center),
    LocationData(None, Region.mines_floor_120, Goal.bottom_of_the_mines),
    LocationData(None, Region.skull_cavern_100, Goal.cryptic_note),
    LocationData(None, Region.beach, Goal.master_angler),
    LocationData(None, Region.museum, Goal.complete_museum),
    LocationData(None, Region.farm_house, Goal.full_house),
    LocationData(None, Region.island_west, Goal.greatest_walnut_hunter),
    LocationData(None, Region.adventurer_guild, Goal.protector_of_the_valley),
    LocationData(None, Region.shipping, Goal.full_shipment),
    LocationData(None, Region.kitchen, Goal.gourmet_chef),
    LocationData(None, Region.farm, Goal.craft_master),
    LocationData(None, Region.shipping, Goal.legend),
    LocationData(None, Region.farm, Goal.mystery_of_the_stardrops),
    LocationData(None, Region.farm, Goal.allsanity),
    LocationData(None, Region.qi_walnut_room, Goal.perfection),
]

all_locations = load_location_csv() + events_locations
location_table: Dict[str, LocationData] = {location.name: location for location in all_locations}
locations_by_tag: Dict[LocationTags, List[LocationData]] = {}


def initialize_groups():
    for location in all_locations:
        for tag in location.tags:
            location_group = locations_by_tag.get(tag, list())
            location_group.append(location)
            locations_by_tag[tag] = location_group


initialize_groups()


def extend_cropsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.cropsanity == Cropsanity.option_disabled:
        return

    cropsanity_locations = [item for item in locations_by_tag[LocationTags.CROPSANITY] if not item.mod_name or item.mod_name in options.mods]
    cropsanity_locations = filter_ginger_island(options, cropsanity_locations)
    randomized_locations.extend(cropsanity_locations)


def extend_quests_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.quest_locations < 0:
        return

    story_quest_locations = locations_by_tag[LocationTags.STORY_QUEST]
    story_quest_locations = filter_disabled_locations(options, story_quest_locations)
    randomized_locations.extend(story_quest_locations)

    for i in range(0, options.quest_locations.value):
        batch = i // 7
        index_this_batch = i % 7
        if index_this_batch < 4:
            randomized_locations.append(
                location_table[f"Help Wanted: Item Delivery {(batch * 4) + index_this_batch + 1}"])
        elif index_this_batch == 4:
            randomized_locations.append(location_table[f"Help Wanted: Fishing {batch + 1}"])
        elif index_this_batch == 5:
            randomized_locations.append(location_table[f"Help Wanted: Slay Monsters {batch + 1}"])
        elif index_this_batch == 6:
            randomized_locations.append(location_table[f"Help Wanted: Gathering {batch + 1}"])


def extend_fishsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions, random: Random):
    prefix = "Fishsanity: "
    fishsanity = options.fishsanity
    active_fish = get_fish_for_mods(options.mods.value)
    if fishsanity == Fishsanity.option_none:
        return
    elif fishsanity == Fishsanity.option_legendaries:
        fish_locations = [location_table[f"{prefix}{fish.name}"] for fish in active_fish if fish.legendary]
        randomized_locations.extend(filter_disabled_locations(options, fish_locations))
    elif fishsanity == Fishsanity.option_special:
        randomized_locations.extend(location_table[f"{prefix}{special.name}"] for special in special_fish)
    elif fishsanity == Fishsanity.option_randomized:
        fish_locations = [location_table[f"{prefix}{fish.name}"] for fish in active_fish if random.random() < 0.4]
        randomized_locations.extend(filter_disabled_locations(options, fish_locations))
    elif fishsanity == Fishsanity.option_all:
        fish_locations = [location_table[f"{prefix}{fish.name}"] for fish in active_fish]
        randomized_locations.extend(filter_disabled_locations(options, fish_locations))
    elif fishsanity == Fishsanity.option_exclude_legendaries:
        fish_locations = [location_table[f"{prefix}{fish.name}"] for fish in active_fish if not fish.legendary]
        randomized_locations.extend(filter_disabled_locations(options, fish_locations))
    elif fishsanity == Fishsanity.option_exclude_hard_fish:
        fish_locations = [location_table[f"{prefix}{fish.name}"] for fish in active_fish if fish.difficulty < 80]
        randomized_locations.extend(filter_disabled_locations(options, fish_locations))
    elif options.fishsanity == Fishsanity.option_only_easy_fish:
        fish_locations = [location_table[f"{prefix}{fish.name}"] for fish in active_fish if fish.difficulty < 50]
        randomized_locations.extend(filter_disabled_locations(options, fish_locations))


def extend_museumsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions, random: Random):
    prefix = "Museumsanity: "
    if options.museumsanity == Museumsanity.option_none:
        return
    elif options.museumsanity == Museumsanity.option_milestones:
        randomized_locations.extend(locations_by_tag[LocationTags.MUSEUM_MILESTONES])
    elif options.museumsanity == Museumsanity.option_randomized:
        randomized_locations.extend(location_table[f"{prefix}{museum_item.item_name}"]
                                    for museum_item in all_museum_items if random.random() < 0.4)
    elif options.museumsanity == Museumsanity.option_all:
        randomized_locations.extend(location_table[f"{prefix}{museum_item.item_name}"] for museum_item in all_museum_items)


def extend_friendsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    island_villagers = [NPC.leo, ModNPC.lance]
    if options.friendsanity == Friendsanity.option_none:
        return

    randomized_locations.append(location_table[f"Spouse Stardrop"])
    extend_baby_locations(randomized_locations)
    exclude_ginger_island = options.exclude_ginger_island == ExcludeGingerIsland.option_true
    exclude_non_bachelors = options.friendsanity == Friendsanity.option_bachelors
    exclude_locked_villagers = options.friendsanity == Friendsanity.option_starting_npcs or \
                               options.friendsanity == Friendsanity.option_bachelors
    include_post_marriage_hearts = options.friendsanity == Friendsanity.option_all_with_marriage
    heart_size = options.friendsanity_heart_size
    for villager in get_villagers_for_mods(options.mods.value):
        if not villager.available and exclude_locked_villagers:
            continue
        if not villager.bachelor and exclude_non_bachelors:
            continue
        if villager.name in island_villagers and exclude_ginger_island:
            continue
        heart_cap = 8 if villager.bachelor else 10
        if include_post_marriage_hearts and villager.bachelor:
            heart_cap = 14
        for heart in range(1, 15):
            if heart > heart_cap:
                break
            if heart % heart_size == 0 or heart == heart_cap:
                randomized_locations.append(location_table[f"Friendsanity: {villager.name} {heart} <3"])
    if not exclude_non_bachelors:
        for heart in range(1, 6):
            if heart % heart_size == 0 or heart == 5:
                randomized_locations.append(location_table[f"Friendsanity: Pet {heart} <3"])


def extend_baby_locations(randomized_locations: List[LocationData]):
    baby_locations = [location for location in locations_by_tag[LocationTags.BABY]]
    randomized_locations.extend(baby_locations)


def extend_festival_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.festival_locations == FestivalLocations.option_disabled:
        return

    festival_locations = locations_by_tag[LocationTags.FESTIVAL]
    randomized_locations.extend(festival_locations)
    extend_hard_festival_locations(randomized_locations, options)


def extend_hard_festival_locations(randomized_locations, options: StardewValleyOptions):
    if options.festival_locations != FestivalLocations.option_hard:
        return

    hard_festival_locations = locations_by_tag[LocationTags.FESTIVAL_HARD]
    randomized_locations.extend(hard_festival_locations)


def extend_special_order_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.special_order_locations == SpecialOrderLocations.option_disabled:
        return

    include_island = options.exclude_ginger_island == ExcludeGingerIsland.option_false
    board_locations = filter_disabled_locations(options, locations_by_tag[LocationTags.SPECIAL_ORDER_BOARD])
    randomized_locations.extend(board_locations)
    if options.special_order_locations == SpecialOrderLocations.option_board_qi and include_island:
        include_arcade = options.arcade_machine_locations != ArcadeMachineLocations.option_disabled
        qi_orders = [location for location in locations_by_tag[LocationTags.SPECIAL_ORDER_QI] if
                     include_arcade or LocationTags.JUNIMO_KART not in location.tags]
        randomized_locations.extend(qi_orders)


def extend_walnut_purchase_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.exclude_ginger_island == ExcludeGingerIsland.option_true:
        return
    randomized_locations.append(location_table["Repair Ticket Machine"])
    randomized_locations.append(location_table["Repair Boat Hull"])
    randomized_locations.append(location_table["Repair Boat Anchor"])
    randomized_locations.append(location_table["Open Professor Snail Cave"])
    randomized_locations.append(location_table["Complete Island Field Office"])
    randomized_locations.extend(locations_by_tag[LocationTags.WALNUT_PURCHASE])


def extend_mandatory_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    mandatory_locations = [location for location in locations_by_tag[LocationTags.MANDATORY]]
    filtered_mandatory_locations = filter_disabled_locations(options, mandatory_locations)
    randomized_locations.extend(filtered_mandatory_locations)


def extend_situational_quest_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.quest_locations < 0:
        return
    if ModNames.distant_lands in options.mods:
        if ModNames.alecto in options.mods:
            randomized_locations.append(location_table[ModQuest.WitchOrder])
        else:
            randomized_locations.append(location_table[ModQuest.CorruptedCropsTask])


def extend_bundle_locations(randomized_locations: List[LocationData], bundle_rooms: List[BundleRoom]):
    for room in bundle_rooms:
        room_location = f"Complete {room.name}"
        if room_location in location_table:
            randomized_locations.append(location_table[room_location])
        for bundle in room.bundles:
            randomized_locations.append(location_table[bundle.name])


def extend_backpack_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.backpack_progression == BackpackProgression.option_vanilla:
        return
    backpack_locations = [location for location in locations_by_tag[LocationTags.BACKPACK]]
    filtered_backpack_locations = filter_modded_locations(options, backpack_locations)
    randomized_locations.extend(filtered_backpack_locations)


def extend_elevator_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.elevator_progression == ElevatorProgression.option_vanilla:
        return
    elevator_locations = [location for location in locations_by_tag[LocationTags.ELEVATOR]]
    filtered_elevator_locations = filter_modded_locations(options, elevator_locations)
    randomized_locations.extend(filtered_elevator_locations)


def extend_monstersanity_locations(randomized_locations: List[LocationData], options):
    monstersanity = options.monstersanity
    if monstersanity == Monstersanity.option_none:
        return
    if monstersanity == Monstersanity.option_one_per_monster or monstersanity == Monstersanity.option_split_goals:
        monster_locations = [location for location in locations_by_tag[LocationTags.MONSTERSANITY_MONSTER]]
        filtered_monster_locations = filter_disabled_locations(options, monster_locations)
        randomized_locations.extend(filtered_monster_locations)
        return
    goal_locations = [location for location in locations_by_tag[LocationTags.MONSTERSANITY_GOALS]]
    filtered_goal_locations = filter_disabled_locations(options, goal_locations)
    randomized_locations.extend(filtered_goal_locations)
    if monstersanity != Monstersanity.option_progressive_goals:
        return
    progressive_goal_locations = [location for location in locations_by_tag[LocationTags.MONSTERSANITY_PROGRESSIVE_GOALS]]
    filtered_progressive_goal_locations = filter_disabled_locations(options, progressive_goal_locations)
    randomized_locations.extend(filtered_progressive_goal_locations)


def extend_shipsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    shipsanity = options.shipsanity
    if shipsanity == Shipsanity.option_none:
        return
    if shipsanity == Shipsanity.option_everything:
        ship_locations = [location for location in locations_by_tag[LocationTags.SHIPSANITY]]
        filtered_ship_locations = filter_disabled_locations(options, ship_locations)
        randomized_locations.extend(filtered_ship_locations)
        return
    shipsanity_locations = set()
    if shipsanity == Shipsanity.option_fish or shipsanity == Shipsanity.option_full_shipment_with_fish:
        shipsanity_locations = shipsanity_locations.union({location for location in locations_by_tag[LocationTags.SHIPSANITY_FISH]})
    if shipsanity == Shipsanity.option_crops:
        shipsanity_locations = shipsanity_locations.union({location for location in locations_by_tag[LocationTags.SHIPSANITY_CROP]})
    if shipsanity == Shipsanity.option_full_shipment or shipsanity == Shipsanity.option_full_shipment_with_fish:
        shipsanity_locations = shipsanity_locations.union({location for location in locations_by_tag[LocationTags.SHIPSANITY_FULL_SHIPMENT]})

    filtered_shipsanity_locations = filter_disabled_locations(options, list(shipsanity_locations))
    randomized_locations.extend(filtered_shipsanity_locations)


def extend_cooksanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    cooksanity = options.cooksanity
    if cooksanity == Cooksanity.option_none:
        return
    if cooksanity == Cooksanity.option_queen_of_sauce:
        cooksanity_locations = (location for location in locations_by_tag[LocationTags.COOKSANITY_QOS])
    else:
        cooksanity_locations = (location for location in locations_by_tag[LocationTags.COOKSANITY])

    filtered_cooksanity_locations = filter_disabled_locations(options, cooksanity_locations)
    randomized_locations.extend(filtered_cooksanity_locations)


def extend_chefsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    chefsanity = options.chefsanity
    if chefsanity == Chefsanity.option_none:
        return

    chefsanity_locations_by_name = {}  # Dictionary to not make duplicates

    if chefsanity & Chefsanity.option_queen_of_sauce:
        chefsanity_locations_by_name.update({location.name: location for location in locations_by_tag[LocationTags.CHEFSANITY_QOS]})
    if chefsanity & Chefsanity.option_purchases:
        chefsanity_locations_by_name.update({location.name: location for location in locations_by_tag[LocationTags.CHEFSANITY_PURCHASE]})
    if chefsanity & Chefsanity.option_friendship:
        chefsanity_locations_by_name.update({location.name: location for location in locations_by_tag[LocationTags.CHEFSANITY_FRIENDSHIP]})
    if chefsanity & Chefsanity.option_skills:
        chefsanity_locations_by_name.update({location.name: location for location in locations_by_tag[LocationTags.CHEFSANITY_SKILL]})

    filtered_chefsanity_locations = filter_disabled_locations(options, list(chefsanity_locations_by_name.values()))
    randomized_locations.extend(filtered_chefsanity_locations)


def extend_craftsanity_locations(randomized_locations: List[LocationData], options: StardewValleyOptions):
    if options.craftsanity == Craftsanity.option_none:
        return

    craftsanity_locations = [craft for craft in locations_by_tag[LocationTags.CRAFTSANITY]]
    filtered_chefsanity_locations = filter_disabled_locations(options, craftsanity_locations)
    randomized_locations.extend(filtered_chefsanity_locations)


def create_locations(location_collector: StardewLocationCollector,
                     bundle_rooms: List[BundleRoom],
                     options: StardewValleyOptions,
                     random: Random):
    randomized_locations = []

    extend_mandatory_locations(randomized_locations, options)
    extend_bundle_locations(randomized_locations, bundle_rooms)
    extend_backpack_locations(randomized_locations, options)

    if options.tool_progression & ToolProgression.option_progressive:
        randomized_locations.extend(locations_by_tag[LocationTags.TOOL_UPGRADE])

    extend_elevator_locations(randomized_locations, options)

    if not options.skill_progression == SkillProgression.option_vanilla:
        for location in locations_by_tag[LocationTags.SKILL_LEVEL]:
            if location.mod_name is None or location.mod_name in options.mods:
                randomized_locations.append(location_table[location.name])

    if options.building_progression & BuildingProgression.option_progressive:
        for location in locations_by_tag[LocationTags.BUILDING_BLUEPRINT]:
            if location.mod_name is None or location.mod_name in options.mods:
                randomized_locations.append(location_table[location.name])

    if options.arcade_machine_locations != ArcadeMachineLocations.option_disabled:
        randomized_locations.extend(locations_by_tag[LocationTags.ARCADE_MACHINE_VICTORY])

    if options.arcade_machine_locations == ArcadeMachineLocations.option_full_shuffling:
        randomized_locations.extend(locations_by_tag[LocationTags.ARCADE_MACHINE])

    extend_cropsanity_locations(randomized_locations, options)
    extend_fishsanity_locations(randomized_locations, options, random)
    extend_museumsanity_locations(randomized_locations, options, random)
    extend_friendsanity_locations(randomized_locations, options)

    extend_festival_locations(randomized_locations, options)
    extend_special_order_locations(randomized_locations, options)
    extend_walnut_purchase_locations(randomized_locations, options)

    extend_monstersanity_locations(randomized_locations, options)
    extend_shipsanity_locations(randomized_locations, options)
    extend_cooksanity_locations(randomized_locations, options)
    extend_chefsanity_locations(randomized_locations, options)
    extend_craftsanity_locations(randomized_locations, options)
    extend_quests_locations(randomized_locations, options)
    extend_situational_quest_locations(randomized_locations, options)

    for location_data in randomized_locations:
        location_collector(location_data.name, location_data.code, location_data.region)


def filter_ginger_island(options: StardewValleyOptions, locations: Iterable[LocationData]) -> Iterable[LocationData]:
    include_island = options.exclude_ginger_island == ExcludeGingerIsland.option_false
    return (location for location in locations if include_island or LocationTags.GINGER_ISLAND not in location.tags)


def filter_qi_order_locations(options: StardewValleyOptions, locations: Iterable[LocationData]) -> Iterable[LocationData]:
    include_qi_orders = options.special_order_locations == SpecialOrderLocations.option_board_qi
    return (location for location in locations if include_qi_orders or LocationTags.REQUIRES_QI_ORDERS not in location.tags)


def filter_modded_locations(options: StardewValleyOptions, locations: Iterable[LocationData]) -> Iterable[LocationData]:
    return (location for location in locations if location.mod_name is None or location.mod_name in options.mods)


def filter_disabled_locations(options: StardewValleyOptions, locations: Iterable[LocationData]) -> Iterable[LocationData]:
    locations_island_filter = filter_ginger_island(options, locations)
    locations_qi_filter = filter_qi_order_locations(options, locations_island_filter)
    locations_mod_filter = filter_modded_locations(options, locations_qi_filter)
    return locations_mod_filter