518 lines
25 KiB
Python
518 lines
25 KiB
Python
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
|