import logging import math from dataclasses import dataclass from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple, Union, cast from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region from .data import static_logic as static_witness_logic from .data.utils import weighted_sample from .player_items import WitnessItem if TYPE_CHECKING: from . import WitnessWorld CompactHintArgs = Tuple[Union[str, int], Union[str, int]] CompactHintData = Tuple[str, Union[str, int], Union[str, int]] @dataclass class WitnessLocationHint: location: Location hint_came_from_location: bool # If a hint gets added to a set twice, but once as an item hint and once as a location hint, those are the same def __hash__(self) -> int: return hash(self.location) def __eq__(self, other: Any) -> bool: if not isinstance(other, WitnessLocationHint): return False return self.location == other.location @dataclass class WitnessWordedHint: wording: str location: Optional[Location] = None area: Optional[str] = None area_amount: Optional[int] = None area_hunt_panels: Optional[int] = None vague_location_hint: bool = False def get_always_hint_items(world: "WitnessWorld") -> List[str]: always = [ "Boat", "Caves Shortcuts", "Progressive Dots", ] difficulty = world.options.puzzle_randomization discards = world.options.shuffle_discarded_panels wincon = world.options.victory_condition if discards: if difficulty == "sigma_expert" or difficulty == "umbra_variety": always.append("Arrows") else: always.append("Triangles") if wincon == "elevator": always += ["Mountain Bottom Floor Pillars Room Entry (Door)", "Mountain Bottom Floor Doors"] if wincon == "challenge": always += ["Challenge Entry (Panel)", "Caves Panels"] return always def get_always_hint_locations(world: "WitnessWorld") -> List[str]: always = [ "Challenge Vault Box", "Mountain Bottom Floor Discard", "Theater Eclipse EP", "Shipwreck Couch EP", "Mountainside Cloud Cycle EP", ] # Add Obelisk Sides that contain EPs that are meant to be hinted, if they are necessary to complete the Obelisk Side if "0x339B6" not in world.player_logic.COMPLETELY_DISABLED_ENTITIES: always.append("Town Obelisk Side 6") # Eclipse EP if "0x3388F" not in world.player_logic.COMPLETELY_DISABLED_ENTITIES: always.append("Treehouse Obelisk Side 4") # Couch EP if "0x335AE" not in world.player_logic.COMPLETELY_DISABLED_ENTITIES: always.append("Mountainside Obelisk Side 1") # Cloud Cycle EP. return always def get_priority_hint_items(world: "WitnessWorld") -> List[str]: priority = { "Caves Mountain Shortcut (Door)", "Caves Swamp Shortcut (Door)", "Swamp Entry (Panel)", "Swamp Laser Shortcut (Door)", } if world.options.shuffle_symbols: symbols = [ "Progressive Dots", "Progressive Stars", "Shapers", "Rotated Shapers", "Negative Shapers", "Arrows", "Triangles", "Eraser", "Black/White Squares", "Colored Squares", "Sound Dots", "Progressive Symmetry" ] priority.update(world.random.sample(symbols, 5)) if world.options.shuffle_lasers: lasers = [ "Symmetry Laser", "Town Laser", "Keep Laser", "Swamp Laser", "Treehouse Laser", "Monastery Laser", "Jungle Laser", "Quarry Laser", "Bunker Laser", "Shadows Laser", ] if world.options.shuffle_doors >= 2: priority.add("Desert Laser") priority.update(world.random.sample(lasers, 5)) else: lasers.append("Desert Laser") priority.update(world.random.sample(lasers, 6)) return sorted(priority) def get_priority_hint_locations(world: "WitnessWorld") -> List[str]: priority = [ "Tutorial Patio Floor", "Tutorial Patio Flowers EP", "Swamp Purple Underwater", "Shipwreck Vault Box", "Town RGB House Upstairs Left", "Town RGB House Upstairs Right", "Treehouse Green Bridge 7", "Treehouse Green Bridge Discard", "Shipwreck Discard", "Desert Vault Box", "Mountainside Vault Box", "Mountainside Discard", "Tunnels Theater Flowers EP", "Boat Shipwreck Green EP", "Quarry Stoneworks Control Room Left", ] # Add Obelisk Sides that contain EPs that are meant to be hinted, if they are necessary to complete the Obelisk Side if "0x33A20" not in world.player_logic.COMPLETELY_DISABLED_ENTITIES: priority.append("Town Obelisk Side 6") # Theater Flowers EP if "0x28B29" not in world.player_logic.COMPLETELY_DISABLED_ENTITIES: priority.append("Treehouse Obelisk Side 4") # Shipwreck Green EP if "0x33600" not in world.player_logic.COMPLETELY_DISABLED_ENTITIES: priority.append("Town Obelisk Side 2") # Tutorial Patio Flowers EP. return priority def try_getting_location_group_for_location(world: "WitnessWorld", hint_loc: Location) -> Tuple[str, str]: allow_regions = world.options.vague_hints == "experimental" possible_location_groups = { group_name: group_locations for group_name, group_locations in world.multiworld.worlds[hint_loc.player].location_name_groups.items() if hint_loc.name in group_locations } locations_in_that_world = { location.name for location in world.multiworld.get_locations(hint_loc.player) if not location.is_event } valid_location_groups: Dict[str, int] = {} # Find valid location groups. for group, locations in possible_location_groups.items(): if group == "Everywhere": continue present_locations = sum(location in locations_in_that_world for location in locations) valid_location_groups[group] = present_locations # If there are valid location groups, use a random one. if valid_location_groups: # If there are location groups with more than 1 location, remove any that only have 1. if any(num_locs > 1 for num_locs in valid_location_groups.values()): valid_location_groups = {name: num_locs for name, num_locs in valid_location_groups.items() if num_locs > 1} location_groups_with_weights = { # Listen. Just don't worry about it. :))) location_group: (x ** 0.6) * math.e ** (- (x / 7) ** 0.6) if x > 6 else x / 6 for location_group, x in valid_location_groups.items() } location_groups = list(location_groups_with_weights.keys()) weights = list(location_groups_with_weights.values()) return world.random.choices(location_groups, weights, k=1)[0], "Group" if allow_regions: return cast(Region, hint_loc.parent_region).name, "Region" return "Everywhere", "Everywhere" def word_direct_hint(world: "WitnessWorld", hint: WitnessLocationHint) -> WitnessWordedHint: location_name = hint.location.name if hint.location.player != world.player: location_name += " (" + world.multiworld.get_player_name(hint.location.player) + ")" item = hint.location.item item_name = "Nothing" if item is not None: item_name = item.name if item.player != world.player: item_name += " (" + world.multiworld.get_player_name(item.player) + ")" hint_text = "" area: Optional[str] = None if world.options.vague_hints: chosen_group, group_type = try_getting_location_group_for_location(world, hint.location) if hint.location.player == world.player: area = chosen_group # local locations should only ever return a location group, as Witness defines groups for every location. hint_text = f"{item_name} can be found in the {area} area." else: player_name = world.multiworld.get_player_name(hint.location.player) if group_type == "Everywhere": location_name = f"a location in {player_name}'s world" elif group_type == "Group": location_name = f"a \"{chosen_group}\" location in {player_name}'s world" elif group_type == "Region": origin_region_name = world.multiworld.worlds[hint.location.player].origin_region_name if chosen_group == origin_region_name: location_name = ( f"a location in the origin region of {player_name}'s world (\"{origin_region_name}\" region)" ) else: location_name = f"a location in {player_name}'s \"{chosen_group}\" region" if hint_text == "": if hint.hint_came_from_location: hint_text = f"{location_name} contains {item_name}." else: hint_text = f"{item_name} can be found at {location_name}." return WitnessWordedHint(hint_text, hint.location, area=area, vague_location_hint=bool(world.options.vague_hints)) def hint_from_item(world: "WitnessWorld", item_name: str, own_itempool: List["WitnessItem"]) -> Optional[WitnessLocationHint]: def get_real_location(multiworld: MultiWorld, location: Location) -> Location: """If this location is from an item_link pseudo-world, get the location that the item_link item is on. Return the original location otherwise / as a fallback.""" if location.player not in world.multiworld.groups: return location try: if not location.item: return location return multiworld.find_item(location.item.name, location.player) except StopIteration: return location locations = [ get_real_location(world.multiworld, item.location) for item in own_itempool if item.name == item_name and item.location ] if not locations: return None location_obj = world.random.choice(locations) return WitnessLocationHint(location_obj, False) def hint_from_location(world: "WitnessWorld", location: str) -> Optional[WitnessLocationHint]: return WitnessLocationHint(world.get_location(location), True) def get_item_and_location_names_in_random_order(world: "WitnessWorld", own_itempool: List["WitnessItem"]) -> Tuple[List[str], List[str]]: progression_item_names_in_this_world = [ item.name for item in own_itempool if item.advancement and item.code and item.location ] world.random.shuffle(progression_item_names_in_this_world) locations_in_this_world = [ location for location in world.multiworld.get_locations(world.player) if location.item and not location.is_event and location.progress_type != LocationProgressType.EXCLUDED ] world.random.shuffle(locations_in_this_world) if world.options.vague_hints: locations_in_this_world.sort(key=lambda location: cast(Item, location.item).advancement) location_names_in_this_world = [location.name for location in locations_in_this_world] return progression_item_names_in_this_world, location_names_in_this_world def make_always_and_priority_hints(world: "WitnessWorld", own_itempool: List["WitnessItem"], already_hinted_locations: Set[Location] ) -> Tuple[List[WitnessLocationHint], List[WitnessLocationHint]]: progression_items_in_this_world, locations_in_this_world = get_item_and_location_names_in_random_order( world, own_itempool ) always_items = [ item for item in get_always_hint_items(world) if item in progression_items_in_this_world ] priority_items = [ item for item in get_priority_hint_items(world) if item in progression_items_in_this_world ] if world.options.vague_hints: always_locations, priority_locations = [], [] else: always_locations = [ location for location in get_always_hint_locations(world) if location in locations_in_this_world ] priority_locations = [ location for location in get_priority_hint_locations(world) if location in locations_in_this_world ] # Get always and priority location/item hints always_location_hints = {hint_from_location(world, location) for location in always_locations} always_item_hints = {hint_from_item(world, item, own_itempool) for item in always_items} priority_location_hints = {hint_from_location(world, location) for location in priority_locations} priority_item_hints = {hint_from_item(world, item, own_itempool) for item in priority_items} # Combine the sets. This will get rid of duplicates always_hints_set = always_item_hints | always_location_hints priority_hints_set = priority_item_hints | priority_location_hints # Make sure priority hints doesn't contain any hints that are already always hints. priority_hints_set -= always_hints_set always_generator = [hint for hint in always_hints_set if hint and hint.location not in already_hinted_locations] priority_generator = [hint for hint in priority_hints_set if hint and hint.location not in already_hinted_locations] # Convert both hint types to list and then shuffle. Also, get rid of None and Tutorial Gate Open. always_hints = sorted(always_generator, key=lambda h: h.location) priority_hints = sorted(priority_generator, key=lambda h: h.location) world.random.shuffle(always_hints) world.random.shuffle(priority_hints) return always_hints, priority_hints def make_extra_location_hints(world: "WitnessWorld", hint_amount: int, own_itempool: List["WitnessItem"], already_hinted_locations: Set[Location], hints_to_use_first: List[WitnessLocationHint], unhinted_locations_for_hinted_areas: Dict[str, Set[Location]]) -> List[WitnessWordedHint]: progression_items_in_this_world, locations_in_this_world = get_item_and_location_names_in_random_order( world, own_itempool ) next_random_hint_is_location = world.random.randrange(0, 2) hints: List[WitnessWordedHint] = [] # This is a way to reverse a Dict[a,List[b]] to a Dict[b,a] area_reverse_lookup = { unhinted_location: hinted_area for hinted_area, unhinted_locations in unhinted_locations_for_hinted_areas.items() for unhinted_location in unhinted_locations } while len(hints) < hint_amount: if not progression_items_in_this_world and not locations_in_this_world and not hints_to_use_first: logging.warning(f"Ran out of items/locations to hint for player {world.player_name}.") break location_hint: Optional[WitnessLocationHint] if hints_to_use_first: location_hint = hints_to_use_first.pop() elif next_random_hint_is_location and locations_in_this_world: location_hint = hint_from_location(world, locations_in_this_world.pop()) elif not next_random_hint_is_location and progression_items_in_this_world: location_hint = hint_from_item(world, progression_items_in_this_world.pop(), own_itempool) # The list that the hint was supposed to be taken from was empty. # Try the other list, which has to still have something, as otherwise, all lists would be empty, # which would have triggered the guard condition above. else: next_random_hint_is_location = not next_random_hint_is_location continue if location_hint is None or location_hint.location in already_hinted_locations: continue # Don't hint locations in areas that are almost fully hinted out already if location_hint.location in area_reverse_lookup: area = area_reverse_lookup[location_hint.location] if len(unhinted_locations_for_hinted_areas[area]) == 1: continue del area_reverse_lookup[location_hint.location] unhinted_locations_for_hinted_areas[area] -= {location_hint.location} hints.append(word_direct_hint(world, location_hint)) already_hinted_locations.add(location_hint.location) next_random_hint_is_location = not next_random_hint_is_location return hints def choose_areas(world: "WitnessWorld", amount: int, locations_per_area: Dict[str, List[Location]], already_hinted_locations: Set[Location]) -> Tuple[List[str], Dict[str, Set[Location]]]: """ Choose areas to hint. This takes into account that some areas may already have had items hinted in them through location hints. When this happens, they are made less likely to receive an area hint. """ unhinted_locations_per_area = {} unhinted_location_percentage_per_area = {} for area_name, locations in locations_per_area.items(): not_yet_hinted_locations = sum(location not in already_hinted_locations for location in locations) unhinted_locations_per_area[area_name] = {loc for loc in locations if loc not in already_hinted_locations} unhinted_location_percentage_per_area[area_name] = not_yet_hinted_locations / len(locations) items_per_area = {area_name: [location.item for location in locations] for area_name, locations in locations_per_area.items()} areas = sorted(area for area in items_per_area if unhinted_location_percentage_per_area[area]) weights = [unhinted_location_percentage_per_area[area] for area in areas] amount = min(amount, len(weights)) hinted_areas = weighted_sample(world.random, areas, weights, amount) return hinted_areas, unhinted_locations_per_area def get_hintable_areas(world: "WitnessWorld") -> Tuple[Dict[str, List[Location]], Dict[str, List[Item]]]: potential_areas = list(static_witness_logic.ALL_AREAS_BY_NAME.keys()) locations_per_area = {} items_per_area = {} for area in potential_areas: regions = [ world.get_region(region) for region in static_witness_logic.ALL_AREAS_BY_NAME[area]["regions"] if region in world.player_regions.created_region_names ] locations = [location for region in regions for location in region.get_locations() if not location.is_event] if locations: locations_per_area[area] = locations items_per_area[area] = [location.item for location in locations] return locations_per_area, items_per_area def word_area_hint(world: "WitnessWorld", hinted_area: str, area_items: List[Item]) -> Tuple[str, int, Optional[int]]: """ Word the hint for an area using natural sounding language. This takes into account how much progression there is, how much of it is local/non-local, and whether there are any local lasers to be found in this area. """ local_progression = sum(item.player == world.player and item.advancement for item in area_items) non_local_progression = sum(item.player != world.player and item.advancement for item in area_items) laser_names = {"Symmetry Laser", "Desert Laser", "Quarry Laser", "Shadows Laser", "Town Laser", "Monastery Laser", "Jungle Laser", "Bunker Laser", "Swamp Laser", "Treehouse Laser", "Keep Laser", } local_lasers = sum( item.player == world.player and item.name in laser_names for item in area_items ) total_progression = non_local_progression + local_progression player_count = world.multiworld.players area_progression_word = "Both" if total_progression == 2 else "All" hint_string = f"In the {hinted_area} area, you will find " hunt_panels = None if world.options.victory_condition == "panel_hunt": hunt_panels = sum( static_witness_logic.ENTITIES_BY_HEX[hunt_entity]["area"]["name"] == hinted_area for hunt_entity in world.player_logic.HUNT_ENTITIES ) if not hunt_panels: hint_string += "no Hunt Panels and " elif hunt_panels == 1: hint_string += "1 Hunt Panel and " else: hint_string += f"{hunt_panels} Hunt Panels and " if not total_progression: hint_string += "no progression items." elif total_progression == 1: hint_string += "1 progression item." if player_count > 1: if local_lasers: hint_string += "\nThis item is a laser for this world." elif non_local_progression: other_player_str = "the other player" if player_count == 2 else "another player" hint_string += f"\nThis item is for {other_player_str}." else: hint_string += "\nThis item is for this world." else: if local_lasers: hint_string += "\nThis item is a laser." else: hint_string += f"{total_progression} progression items." if local_lasers == total_progression: sentence_end = (" for this world." if player_count > 1 else ".") hint_string += "\nAll of them are lasers" + sentence_end elif player_count > 1: if local_progression and non_local_progression: if non_local_progression == 1: other_player_str = "the other player" if player_count == 2 else "another player" hint_string += f"\nOne of them is for {other_player_str}." else: other_player_str = "the other player" if player_count == 2 else "other players" hint_string += f"\n{non_local_progression} of them are for {other_player_str}." elif non_local_progression: other_players_str = "the other player" if player_count == 2 else "other players" hint_string += f"\n{area_progression_word} of them are for {other_players_str}." elif local_progression: hint_string += f"\n{area_progression_word} of them are for this world." if local_lasers == 1: if not non_local_progression: hint_string += "\nAlso, one of them is a laser." else: hint_string += "\nAlso, one of them is a laser for this world." elif local_lasers: if not non_local_progression: hint_string += f"\nAlso, {local_lasers} of them are lasers." else: hint_string += f"\nAlso, {local_lasers} of them are lasers for this world." else: if local_lasers == 1: hint_string += "\nOne of them is a laser." elif local_lasers: hint_string += f"\n{local_lasers} of them are lasers." return hint_string, total_progression, hunt_panels def make_area_hints(world: "WitnessWorld", amount: int, already_hinted_locations: Set[Location] ) -> Tuple[List[WitnessWordedHint], Dict[str, Set[Location]]]: locs_per_area, items_per_area = get_hintable_areas(world) hinted_areas, unhinted_locations_per_area = choose_areas(world, amount, locs_per_area, already_hinted_locations) hints = [] for hinted_area in hinted_areas: hint_string, progression_amount, hunt_panels = word_area_hint(world, hinted_area, items_per_area[hinted_area]) hints.append( WitnessWordedHint(hint_string, None, f"hinted_area:{hinted_area}", progression_amount, hunt_panels) ) if len(hinted_areas) < amount: logging.warning(f"Was not able to make {amount} area hints for player {world.player_name}. " f"Made {len(hinted_areas)} instead, and filled the rest with random location hints.") return hints, unhinted_locations_per_area def create_all_hints(world: "WitnessWorld", hint_amount: int, area_hints: int, already_hinted_locations: Set[Location]) -> List[WitnessWordedHint]: generated_hints: List[WitnessWordedHint] = [] state = CollectionState(world.multiworld) # Keep track of already hinted locations. Consider early Tutorial as "already hinted" already_hinted_locations |= { loc for loc in world.multiworld.get_reachable_locations(state, world.player) if loc.address and static_witness_logic.ENTITIES_BY_NAME[loc.name]["area"]["name"] == "Tutorial (Inside)" } intended_location_hints = hint_amount - area_hints # First, make always and priority hints. always_hints, priority_hints = make_always_and_priority_hints( world, world.own_itempool, already_hinted_locations ) generated_always_hints = len(always_hints) possible_priority_hints = len(priority_hints) # Make as many always hints as possible always_hints_to_use = min(intended_location_hints, generated_always_hints) # Make up to half of the rest of the location hints priority hints, using up to half of the possibly priority hints remaining_location_hints = intended_location_hints - always_hints_to_use priority_hints_to_use = int(max(0.0, min(possible_priority_hints / 2, remaining_location_hints / 2))) for _ in range(always_hints_to_use): location_hint = always_hints.pop() generated_hints.append(word_direct_hint(world, location_hint)) already_hinted_locations.add(location_hint.location) for _ in range(priority_hints_to_use): location_hint = priority_hints.pop() generated_hints.append(word_direct_hint(world, location_hint)) already_hinted_locations.add(location_hint.location) location_hints_created_in_round_1 = len(generated_hints) unhinted_locations_per_area: Dict[str, Set[Location]] = {} # Then, make area hints. if area_hints: generated_area_hints, unhinted_locations_per_area = make_area_hints(world, area_hints, already_hinted_locations) generated_hints += generated_area_hints # If we don't have enough hints yet, recalculate always and priority hints, then fill with random hints if len(generated_hints) < hint_amount: remaining_needed_location_hints = hint_amount - len(generated_hints) # Save old values for used always and priority hints for later calculations amt_of_used_always_hints = always_hints_to_use amt_of_used_priority_hints = priority_hints_to_use # Recalculate how many always hints and priority hints are supposed to be used intended_location_hints = remaining_needed_location_hints + location_hints_created_in_round_1 always_hints_to_use = min(intended_location_hints, generated_always_hints) priority_hints_to_use = int(max(0.0, min(possible_priority_hints / 2, remaining_location_hints / 2))) # If we now need more always hints and priority hints than we thought previously, make some more. more_always_hints = always_hints_to_use - amt_of_used_always_hints more_priority_hints = priority_hints_to_use - amt_of_used_priority_hints extra_always_and_priority_hints: List[WitnessLocationHint] = [] for _ in range(more_always_hints): extra_always_and_priority_hints.append(always_hints.pop()) for _ in range(more_priority_hints): extra_always_and_priority_hints.append(priority_hints.pop()) generated_hints += make_extra_location_hints( world, hint_amount - len(generated_hints), world.own_itempool, already_hinted_locations, extra_always_and_priority_hints, unhinted_locations_per_area ) # If we still don't have enough for whatever reason, throw a warning, proceed with the lower amount if len(generated_hints) != hint_amount: logging.warning(f"Couldn't generate {hint_amount} hints for player {world.player_name}. " f"Generated {len(generated_hints)} instead.") return generated_hints def get_compact_hint_args(hint: WitnessWordedHint, local_player_number: int) -> CompactHintArgs: """ Arg reference: Area Hint: 1st Arg is the amount of area progression and hunt panels. 2nd Arg is the name of the area. Location Hint: 1st Arg is the location's address, second arg is the player number the location belongs to. Junk Hint: 1st Arg is -1, second arg is this slot's player number. """ # Is Area Hint if hint.area_amount is not None: area_amount = hint.area_amount hunt_panels = hint.area_hunt_panels area_and_hunt_panels = area_amount # Encode amounts together if hunt_panels: area_and_hunt_panels += 0x100 * hunt_panels return hint.area, area_and_hunt_panels location = hint.location # Is location hint if location and location.address is not None: if hint.vague_location_hint and location.player == local_player_number: assert hint.area is not None # A local vague location hint should have an area argument return location.address, "containing_area:" + hint.area return location.address, location.player # Scouting does not matter for other players (currently) # Is junk / undefined hint return -1, local_player_number def make_compact_hint_data(hint: WitnessWordedHint, local_player_number: int) -> CompactHintData: compact_arg_1, compact_arg_2 = get_compact_hint_args(hint, local_player_number) return hint.wording, compact_arg_1, compact_arg_2 def make_laser_hints(world: "WitnessWorld", laser_names: List[str]) -> Dict[str, WitnessWordedHint]: laser_hints_by_name = {} for item_name in laser_names: location_hint = hint_from_item(world, item_name, world.own_itempool) if not location_hint: continue laser_hints_by_name[item_name] = word_direct_hint(world, location_hint) return laser_hints_by_name