409f7d50d5
Customizer improvements: - Better logic around customized lobbies - Better logic around customized door types Fix to key doors that was causing extra key doors Generation improvement around crystal switches Fix bug in dungeon_only that wasn't using pot key locations (known issue still exists in pottery modes) Fixes an issue when keys are found in own dungeon for another player when using the bizhawk plugin
4233 lines
188 KiB
Python
4233 lines
188 KiB
Python
import RaceRandom as random
|
|
import collections
|
|
import itertools
|
|
from collections import defaultdict, deque
|
|
from functools import reduce
|
|
import logging
|
|
import math
|
|
import operator as op
|
|
import time
|
|
from typing import List
|
|
|
|
from BaseClasses import DoorType, Direction, CrystalBarrier, RegionType, Polarity, PolSlot, flooded_keys, Sector
|
|
from BaseClasses import Hook, hook_from_door, Door
|
|
from Regions import dungeon_events, flooded_keys_reverse
|
|
from Dungeons import split_region_starts
|
|
from RoomData import DoorKind
|
|
|
|
from source.dungeon.DungeonStitcher import generate_dungeon_find_proposal
|
|
from source.dungeon.DungeonStitcher import GenerationException as OtherGenException
|
|
|
|
|
|
class GraphPiece:
|
|
|
|
def __init__(self):
|
|
self.hanger_info = None
|
|
self.hanger_crystal = None
|
|
self.hooks = {}
|
|
self.visited_regions = set()
|
|
self.possible_bk_locations = set()
|
|
self.pinball_used = False
|
|
|
|
|
|
# Dungeons shouldn't be generated until all entrances are appropriately accessible
|
|
def pre_validate(builder, entrance_region_names, split_dungeon, world, player):
|
|
entrance_regions = convert_regions(entrance_region_names, world, player)
|
|
excluded = {}
|
|
for region in entrance_regions:
|
|
portal = next((x for x in world.dungeon_portals[player] if x.door.entrance.parent_region == region), None)
|
|
if portal and portal.destination:
|
|
excluded[region] = None
|
|
entrance_regions = [x for x in entrance_regions if x not in excluded.keys()]
|
|
proposed_map = {}
|
|
doors_to_connect = {}
|
|
all_regions = set()
|
|
bk_special = False
|
|
for sector in builder.sectors:
|
|
for door in sector.outstanding_doors:
|
|
doors_to_connect[door.name] = door
|
|
if world.mode[player] == 'standard' and builder.name == 'Hyrule Castle Dungeon':
|
|
all_regions.update([x for x in sector.regions if x.name != 'Hyrule Castle Behind Tapestry'])
|
|
else:
|
|
all_regions.update(sector.regions)
|
|
bk_special |= check_for_special(sector.regions)
|
|
bk_needed = False
|
|
for sector in builder.sectors:
|
|
bk_needed |= determine_if_bk_needed(sector, split_dungeon, bk_special, world, player)
|
|
paths = determine_paths_for_dungeon(world, player, all_regions, builder.name)
|
|
dungeon, hangers, hooks = gen_dungeon_info(builder.name, builder.sectors, entrance_regions, all_regions,
|
|
proposed_map, doors_to_connect, bk_needed, bk_special, world, player)
|
|
return check_valid(builder.name, dungeon, hangers, hooks, proposed_map, doors_to_connect, all_regions,
|
|
bk_needed, bk_special, paths, entrance_regions, world, player)
|
|
|
|
|
|
def generate_dungeon(builder, entrance_region_names, split_dungeon, world, player):
|
|
if builder.valid_proposal: # we made this earlier in gen, just use it
|
|
proposed_map = builder.valid_proposal
|
|
else:
|
|
proposed_map = generate_dungeon_find_proposal_old(builder, entrance_region_names, split_dungeon, world, player)
|
|
builder.valid_proposal = proposed_map
|
|
queue = collections.deque(proposed_map.items())
|
|
while len(queue) > 0:
|
|
a, b = queue.popleft()
|
|
connect_doors(a, b)
|
|
queue.remove((b, a))
|
|
if len(builder.sectors) == 0:
|
|
return Sector()
|
|
available_sectors = list(builder.sectors)
|
|
master_sector = available_sectors.pop()
|
|
for sub_sector in available_sectors:
|
|
master_sector.regions.extend(sub_sector.regions)
|
|
master_sector.outstanding_doors.clear()
|
|
master_sector.r_name_set = None
|
|
return master_sector
|
|
|
|
|
|
def generate_dungeon_find_proposal_old(builder, entrance_region_names, split_dungeon, world, player):
|
|
logger = logging.getLogger('')
|
|
name = builder.name
|
|
entrance_regions = convert_regions(entrance_region_names, world, player)
|
|
excluded = {}
|
|
for region in entrance_regions:
|
|
portal = next((x for x in world.dungeon_portals[player] if x.door.entrance.parent_region == region), None)
|
|
if portal:
|
|
if portal.destination:
|
|
excluded[region] = None
|
|
elif len(entrance_regions) > 1:
|
|
p_region = portal.door.entrance.connected_region
|
|
access_region = next(x.parent_region for x in p_region.entrances
|
|
if x.parent_region.type in [RegionType.LightWorld, RegionType.DarkWorld])
|
|
if ((access_region.name in world.inaccessible_regions[player] and
|
|
region.name not in world.enabled_entrances[player])
|
|
or (world.mode[player] == 'standard' and access_region.name != 'Hyrule Castle Courtyard'
|
|
and 'Hyrule Castle' in builder.name)):
|
|
excluded[region] = None
|
|
else: # for non-portals, holes and sewers in std
|
|
access_region = next((x.parent_region for x in region.entrances
|
|
if x.parent_region.type in [RegionType.LightWorld, RegionType.DarkWorld]
|
|
or x.parent_region.name == 'Sewer Drop'), None)
|
|
if access_region is None:
|
|
if builder.sewers_access is None:
|
|
excluded[region] = None
|
|
else:
|
|
if access_region.name == 'Sewer Drop':
|
|
if world.mode[player] == 'standard' and (builder.sewers_access is None
|
|
or builder.sewers_access.entrance.parent_region != region):
|
|
excluded[region] = None
|
|
access_region = next(x.parent_region for x in access_region.entrances)
|
|
if (access_region.name in world.inaccessible_regions[player] and
|
|
region.name not in world.enabled_entrances[player]):
|
|
excluded[region] = None
|
|
entrance_regions = [x for x in entrance_regions if x not in excluded.keys()]
|
|
doors_to_connect = {}
|
|
all_regions = set()
|
|
bk_special = False
|
|
for sector in builder.sectors:
|
|
for door in sector.outstanding_doors:
|
|
doors_to_connect[door.name] = door
|
|
all_regions.update(sector.regions)
|
|
bk_special |= check_for_special(sector.regions)
|
|
bk_needed = False
|
|
for sector in builder.sectors:
|
|
bk_needed |= determine_if_bk_needed(sector, split_dungeon, bk_special, world, player)
|
|
proposed_map = {}
|
|
choices_master = [[]]
|
|
depth = 0
|
|
dungeon_cache = {}
|
|
backtrack = False
|
|
itr = 0
|
|
attempt = 1
|
|
finished = False
|
|
# flag if standard and this is hyrule castle
|
|
paths = determine_paths_for_dungeon(world, player, all_regions, name)
|
|
while not finished:
|
|
# what are my choices?
|
|
itr += 1
|
|
if itr > 1000:
|
|
if attempt > 9:
|
|
raise GenerationException('Generation taking too long. Ref %s' % name)
|
|
proposed_map = {}
|
|
choices_master = [[]]
|
|
depth = 0
|
|
dungeon_cache = {}
|
|
backtrack = False
|
|
itr = 0
|
|
attempt += 1
|
|
logger.debug(f'Starting new attempt {attempt}')
|
|
if depth not in dungeon_cache.keys():
|
|
dungeon, hangers, hooks = gen_dungeon_info(name, builder.sectors, entrance_regions, all_regions, proposed_map,
|
|
doors_to_connect, bk_needed, bk_special, world, player)
|
|
dungeon_cache[depth] = dungeon, hangers, hooks
|
|
if len(proposed_map) != len(doors_to_connect) and builder.name == 'Hyrule Castle Dungeon':
|
|
check_regions = all_regions.difference({world.get_region('Hyrule Castle Behind Tapestry', player)})
|
|
else:
|
|
check_regions = all_regions
|
|
valid = check_valid(name, dungeon, hangers, hooks, proposed_map, doors_to_connect, check_regions,
|
|
bk_needed, bk_special, paths, entrance_regions, world, player)
|
|
else:
|
|
dungeon, hangers, hooks = dungeon_cache[depth]
|
|
valid = True
|
|
if valid:
|
|
if len(proposed_map) == len(doors_to_connect):
|
|
if dungeon['Origin'].pinball_used:
|
|
door = world.get_door('Skull Pinball WS', player)
|
|
room = world.get_room(door.roomIndex, player)
|
|
if room.doorList[door.doorListPos][1] == DoorKind.Trap:
|
|
room.change(door.doorListPos, DoorKind.Normal)
|
|
door.trapFlag = 0x0
|
|
door.blocked = False
|
|
finished = True
|
|
continue
|
|
prev_choices = choices_master[depth]
|
|
# make a choice
|
|
hanger, hook = make_a_choice(dungeon, hangers, hooks, prev_choices, name)
|
|
if hanger is None:
|
|
backtrack = True
|
|
else:
|
|
logger.debug(' ' * depth + "%d: Linking %s to %s", depth, hanger.name, hook.name)
|
|
proposed_map[hanger] = hook
|
|
proposed_map[hook] = hanger
|
|
last_choice = (hanger, hook)
|
|
choices_master[depth].append(last_choice)
|
|
depth += 1
|
|
choices_master.append([])
|
|
else:
|
|
backtrack = True
|
|
if backtrack:
|
|
backtrack = False
|
|
choices_master.pop()
|
|
dungeon_cache.pop(depth, None)
|
|
depth -= 1
|
|
if depth < 0:
|
|
raise GenerationException('Invalid dungeon. Ref %s' % name)
|
|
a, b = choices_master[depth][-1]
|
|
logger.debug(' ' * depth + "%d: Rescinding %s, %s", depth, a.name, b.name)
|
|
proposed_map.pop(a, None)
|
|
proposed_map.pop(b, None)
|
|
return proposed_map
|
|
|
|
|
|
def determine_if_bk_needed(sector, split_dungeon, bk_special, world, player):
|
|
if not split_dungeon or bk_special:
|
|
for region in sector.regions:
|
|
for ext in region.exits:
|
|
door = world.check_for_door(ext.name, player)
|
|
if door is not None and door.bigKey:
|
|
return True
|
|
return False
|
|
|
|
|
|
def check_for_special(regions):
|
|
for region in regions:
|
|
for loc in region.locations:
|
|
if loc.forced_big_key():
|
|
return True
|
|
return False
|
|
|
|
|
|
def gen_dungeon_info(name, available_sectors, entrance_regions, all_regions, proposed_map, valid_doors, bk_needed, bk_special, world, player):
|
|
# step 1 create dungeon: Dict<DoorName|Origin, GraphPiece>
|
|
dungeon = {}
|
|
start = ExplorationState(dungeon=name)
|
|
start.big_key_special = bk_special
|
|
group_flags, door_map = find_bk_groups(name, available_sectors, proposed_map, bk_special)
|
|
bk_flag = False if world.bigkeyshuffle[player] and not bk_special else bk_needed
|
|
|
|
def exception(d):
|
|
return name == 'Skull Woods 2' and d.name == 'Skull Pinball WS'
|
|
original_state = extend_reachable_state_improved(entrance_regions, start, proposed_map, all_regions,
|
|
valid_doors, bk_flag, world, player, exception)
|
|
dungeon['Origin'] = create_graph_piece_from_state(None, original_state, original_state, proposed_map, exception,
|
|
world, player)
|
|
either_crystal = True # if all hooks from the origin are either, explore all bits with either
|
|
for hook, crystal in dungeon['Origin'].hooks.items():
|
|
if crystal != CrystalBarrier.Either:
|
|
either_crystal = False
|
|
break
|
|
init_crystal = CrystalBarrier.Either if either_crystal else CrystalBarrier.Orange
|
|
hanger_set = set()
|
|
o_state_cache = {}
|
|
for sector in available_sectors:
|
|
for door in sector.outstanding_doors:
|
|
if door not in proposed_map.keys():
|
|
hanger_set.add(door)
|
|
bk_flag = group_flags[door_map[door]]
|
|
parent = door.entrance.parent_region
|
|
crystal_start = CrystalBarrier.Either if parent.crystal_switch else init_crystal
|
|
init_state = ExplorationState(crystal_start, dungeon=name)
|
|
init_state.big_key_special = start.big_key_special
|
|
o_state = extend_reachable_state_improved([parent], init_state, proposed_map, all_regions,
|
|
valid_doors, bk_flag, world, player, exception)
|
|
o_state_cache[door.name] = o_state
|
|
piece = create_graph_piece_from_state(door, o_state, o_state, proposed_map, exception, world, player)
|
|
dungeon[door.name] = piece
|
|
check_blue_states(hanger_set, dungeon, o_state_cache, proposed_map, all_regions, valid_doors,
|
|
group_flags, door_map, world, player, exception)
|
|
|
|
# catalog hooks: Dict<Hook, List<Door, Crystal, Door>>
|
|
# and hangers: Dict<Hang, List<Door>>
|
|
avail_hooks = defaultdict(list)
|
|
hangers = defaultdict(list)
|
|
for key, piece in dungeon.items():
|
|
door_hang = piece.hanger_info
|
|
if door_hang is not None:
|
|
hanger = hanger_from_door(door_hang)
|
|
hangers[hanger].append(door_hang)
|
|
for door, crystal in piece.hooks.items():
|
|
hook = hook_from_door(door)
|
|
avail_hooks[hook].append((door, crystal, door_hang))
|
|
|
|
# thin out invalid hanger
|
|
winnow_hangers(hangers, avail_hooks)
|
|
return dungeon, hangers, avail_hooks
|
|
|
|
|
|
def find_bk_groups(name, available_sectors, proposed_map, bk_special):
|
|
groups = {}
|
|
door_ids = {}
|
|
gid = 1
|
|
for sector in available_sectors:
|
|
if bk_special:
|
|
my_gid = None
|
|
for door in sector.outstanding_doors:
|
|
if door in proposed_map and proposed_map[door] in door_ids:
|
|
if my_gid:
|
|
merge_gid = door_ids[proposed_map[door]]
|
|
for door in door_ids.keys():
|
|
if door_ids[door] == merge_gid:
|
|
door_ids[door] = my_gid
|
|
groups[my_gid] = groups[my_gid] or groups[merge_gid]
|
|
else:
|
|
my_gid = door_ids[proposed_map[door]]
|
|
if not my_gid:
|
|
my_gid = gid
|
|
gid += 1
|
|
for door in sector.outstanding_doors:
|
|
door_ids[door] = my_gid
|
|
if my_gid not in groups.keys():
|
|
groups[my_gid] = False
|
|
for region in sector.regions:
|
|
for loc in region.locations:
|
|
if loc.forced_item and loc.item.bigkey and name in loc.item.name:
|
|
groups[my_gid] = True
|
|
else:
|
|
for door in sector.outstanding_doors:
|
|
door_ids[door] = gid
|
|
groups[gid] = False
|
|
return groups, door_ids
|
|
|
|
|
|
def check_blue_states(hanger_set, dungeon, o_state_cache, proposed_map, all_regions, valid_doors, group_flags, door_map,
|
|
world, player, exception):
|
|
not_blue = set()
|
|
not_blue.update(hanger_set)
|
|
doors_to_check = set()
|
|
doors_to_check.update(hanger_set) # doors to check, check everything on first pass
|
|
blue_hooks = []
|
|
blue_hangers = []
|
|
new_blues = True
|
|
while new_blues:
|
|
new_blues = False
|
|
for door in doors_to_check:
|
|
piece = dungeon[door.name]
|
|
for hook, crystal in piece.hooks.items():
|
|
if crystal != CrystalBarrier.Orange:
|
|
h_type = hook_from_door(hook)
|
|
if h_type not in blue_hooks:
|
|
new_blues = True
|
|
blue_hooks.append(h_type)
|
|
if piece.hanger_crystal == CrystalBarrier.Either:
|
|
h_type = hanger_from_door(piece.hanger_info)
|
|
if h_type not in blue_hangers:
|
|
new_blues = True
|
|
blue_hangers.append(h_type)
|
|
doors_to_check = set()
|
|
for door in not_blue: # am I now blue?
|
|
hang_type = hanger_from_door(door) # am I hangable on a hook?
|
|
hook_type = hook_from_door(door) # am I hookable onto a hanger?
|
|
if (hang_type in blue_hooks and not door.stonewall) or hook_type in blue_hangers:
|
|
bk_flag = group_flags[door_map[door]]
|
|
explore_blue_state(door, dungeon, o_state_cache[door.name], proposed_map, all_regions, valid_doors,
|
|
bk_flag, world, player, exception)
|
|
doors_to_check.add(door)
|
|
not_blue.difference_update(doors_to_check)
|
|
|
|
|
|
def explore_blue_state(door, dungeon, o_state, proposed_map, all_regions, valid_doors, bk_flag, world, player, exception):
|
|
parent = door.entrance.parent_region
|
|
blue_start = ExplorationState(CrystalBarrier.Blue, o_state.dungeon)
|
|
blue_start.big_key_special = o_state.big_key_special
|
|
b_state = extend_reachable_state_improved([parent], blue_start, proposed_map, all_regions, valid_doors, bk_flag,
|
|
world, player, exception)
|
|
dungeon[door.name] = create_graph_piece_from_state(door, o_state, b_state, proposed_map, exception, world, player)
|
|
|
|
|
|
def make_a_choice(dungeon, hangers, avail_hooks, prev_choices, name):
|
|
# choose a hanger
|
|
all_hooks = {}
|
|
origin = dungeon['Origin']
|
|
for key in avail_hooks.keys():
|
|
for hstuff in avail_hooks[key]:
|
|
all_hooks[hstuff[0]] = None
|
|
candidate_hangers = []
|
|
for key in hangers.keys():
|
|
candidate_hangers.extend(hangers[key])
|
|
candidate_hangers.sort(key=lambda x: x.name) # sorting to create predictable seeds
|
|
random.shuffle(candidate_hangers) # randomize if equal preference
|
|
stage_2_hangers = []
|
|
if len(prev_choices) > 0:
|
|
prev_hanger = prev_choices[0][0]
|
|
if prev_hanger in candidate_hangers:
|
|
stage_2_hangers.append(prev_hanger)
|
|
candidate_hangers.remove(prev_hanger)
|
|
hookable_hangers = collections.deque()
|
|
queue = collections.deque(candidate_hangers)
|
|
while len(queue) > 0:
|
|
c_hang = queue.popleft()
|
|
if c_hang in all_hooks.keys():
|
|
hookable_hangers.append(c_hang)
|
|
else:
|
|
stage_2_hangers.append(c_hang) # prefer hangers that are not hooks
|
|
# todo : prefer hangers with fewer hooks at some point? not sure about this
|
|
# this prefer hangers of the fewest type - to catch problems fast
|
|
hookable_hangers = sorted(hookable_hangers, key=lambda door: len(hangers[hanger_from_door(door)]), reverse=True)
|
|
origin_hangers = []
|
|
while len(hookable_hangers) > 0:
|
|
c_hang = hookable_hangers.pop()
|
|
if c_hang in origin.hooks.keys():
|
|
origin_hangers.append(c_hang)
|
|
else:
|
|
stage_2_hangers.append(c_hang) # prefer hangers that are not hooks on the 'origin'
|
|
stage_2_hangers.extend(origin_hangers)
|
|
|
|
hook = None
|
|
next_hanger = None
|
|
while hook is None:
|
|
if len(stage_2_hangers) == 0:
|
|
return None, None
|
|
next_hanger = stage_2_hangers.pop(0)
|
|
next_hanger_type = hanger_from_door(next_hanger)
|
|
hook_candidates = []
|
|
for door, crystal, orig_hang in avail_hooks[next_hanger_type]:
|
|
if filter_choices(next_hanger, door, orig_hang, prev_choices, hook_candidates):
|
|
hook_candidates.append(door)
|
|
if len(hook_candidates) > 0:
|
|
hook_candidates.sort(key=lambda x: x.name) # sort for deterministic seeds
|
|
hook = random.choice(tuple(hook_candidates))
|
|
elif name == 'Skull Woods 2' and next_hanger.name == 'Skull Pinball WS':
|
|
continue
|
|
else:
|
|
return None, None
|
|
|
|
return next_hanger, hook
|
|
|
|
|
|
def filter_choices(next_hanger, door, orig_hang, prev_choices, hook_candidates):
|
|
if (next_hanger, door) in prev_choices or (door, next_hanger) in prev_choices:
|
|
return False
|
|
return next_hanger != door and orig_hang != next_hanger and door not in hook_candidates
|
|
|
|
|
|
def check_valid(name, dungeon, hangers, hooks, proposed_map, doors_to_connect, all_regions,
|
|
bk_needed, bk_special, paths, entrance_regions, world, player):
|
|
# evaluate if everything is still plausible
|
|
|
|
# only origin is left in the dungeon and not everything is connected
|
|
if len(dungeon.keys()) <= 1 and len(proposed_map.keys()) < len(doors_to_connect):
|
|
return False
|
|
# origin has no more hooks, but not all doors have been proposed
|
|
if not world.bigkeyshuffle[player]:
|
|
possible_bks = len(dungeon['Origin'].possible_bk_locations)
|
|
if bk_special and check_for_special(dungeon['Origin'].visited_regions):
|
|
possible_bks = 1
|
|
true_origin_hooks = [x for x in dungeon['Origin'].hooks.keys() if not x.bigKey or possible_bks > 0 or not bk_needed]
|
|
if len(true_origin_hooks) == 0 and len(proposed_map.keys()) < len(doors_to_connect):
|
|
return False
|
|
if len(true_origin_hooks) == 0 and bk_needed and possible_bks == 0 and len(proposed_map.keys()) == len(doors_to_connect):
|
|
return False
|
|
for key in hangers.keys():
|
|
if len(hooks[key]) > 0 and len(hangers[key]) == 0:
|
|
return False
|
|
# todo: stonewall - check that there's no hook-only that is without a matching hanger
|
|
must_hang = defaultdict(list)
|
|
all_hooks = set()
|
|
for key in hooks.keys():
|
|
for hook in hooks[key]:
|
|
all_hooks.add(hook[0])
|
|
for key in hangers.keys():
|
|
for hanger in hangers[key]:
|
|
if hanger not in all_hooks:
|
|
must_hang[key].append(hanger)
|
|
for key in must_hang.keys():
|
|
if len(must_hang[key]) > len(hooks[key]):
|
|
return False
|
|
outstanding_doors = defaultdict(list)
|
|
for d in doors_to_connect.values():
|
|
if d not in proposed_map.keys():
|
|
outstanding_doors[hook_from_door(d)].append(d)
|
|
for key in outstanding_doors.keys():
|
|
opp_key = opposite_h_type(key)
|
|
if len(outstanding_doors[key]) > 0 and len(hangers[key]) == 0 and len(hooks[opp_key]) == 0:
|
|
return False
|
|
all_visited = set()
|
|
bk_possible = not bk_needed or (world.bigkeyshuffle[player] and not bk_special)
|
|
for piece in dungeon.values():
|
|
all_visited.update(piece.visited_regions)
|
|
if ((not bk_possible and len(piece.possible_bk_locations) > 0) or
|
|
(bk_special and check_for_special(piece.visited_regions))):
|
|
bk_possible = True
|
|
if len(all_regions.difference(all_visited)) > 0:
|
|
return False
|
|
if not bk_possible:
|
|
return False
|
|
if not valid_paths(name, paths, entrance_regions, doors_to_connect, all_regions, proposed_map,
|
|
bk_needed, bk_special, world, player):
|
|
return False
|
|
new_hangers_found = True
|
|
accessible_hook_types = []
|
|
hanger_matching = set()
|
|
all_hangers = set()
|
|
origin_hooks = set(dungeon['Origin'].hooks.keys())
|
|
for door_hook in origin_hooks:
|
|
h_type = hook_from_door(door_hook)
|
|
if h_type not in accessible_hook_types:
|
|
accessible_hook_types.append(h_type)
|
|
while new_hangers_found:
|
|
new_hangers_found = False
|
|
for hanger_set in hangers.values():
|
|
for hanger in hanger_set:
|
|
all_hangers.add(hanger)
|
|
h_type = hanger_from_door(hanger)
|
|
if (h_type in accessible_hook_types or hanger in origin_hooks) and hanger not in hanger_matching:
|
|
new_hangers_found = True
|
|
hanger_matching.add(hanger)
|
|
matching_hooks = dungeon[hanger.name].hooks.keys()
|
|
origin_hooks.update(matching_hooks)
|
|
for door_hook in matching_hooks:
|
|
new_h_type = hook_from_door(door_hook)
|
|
if new_h_type not in accessible_hook_types:
|
|
accessible_hook_types.append(new_h_type)
|
|
return len(all_hangers.difference(hanger_matching)) == 0
|
|
|
|
|
|
def valid_paths(name, paths, entrance_regions, valid_doors, all_regions, proposed_map,
|
|
bk_needed, bk_special, world, player):
|
|
for path in paths:
|
|
if type(path) is tuple:
|
|
target = path[1]
|
|
start_regions = []
|
|
for region in all_regions:
|
|
if path[0] == region.name:
|
|
start_regions.append(region)
|
|
break
|
|
else:
|
|
target = path
|
|
start_regions = entrance_regions
|
|
if not valid_path(name, start_regions, target, valid_doors, proposed_map, all_regions,
|
|
bk_needed, bk_special, world, player):
|
|
return False
|
|
return True
|
|
|
|
|
|
def valid_path(name, starting_regions, target, valid_doors, proposed_map, all_regions,
|
|
bk_needed, bk_special, world, player):
|
|
target_regions = set()
|
|
if type(target) is not list:
|
|
for region in all_regions:
|
|
if target == region.name:
|
|
target_regions.add(region)
|
|
break
|
|
else:
|
|
for region in all_regions:
|
|
if region.name in target:
|
|
target_regions.add(region)
|
|
|
|
start = ExplorationState(dungeon=name)
|
|
start.big_key_special = bk_special
|
|
bk_flag = False if world.bigkeyshuffle[player] and not bk_special else bk_needed
|
|
|
|
def exception(d):
|
|
return name == 'Skull Woods 2' and d.name == 'Skull Pinball WS'
|
|
original_state = extend_reachable_state_improved(starting_regions, start, proposed_map, all_regions,
|
|
valid_doors, bk_flag, world, player, exception)
|
|
|
|
for exp_door in original_state.unattached_doors:
|
|
if not exp_door.door.blocked:
|
|
return True # outstanding connection possible
|
|
for target in target_regions:
|
|
if original_state.visited_at_all(target):
|
|
return True
|
|
return False # couldn't find an outstanding door or the target
|
|
|
|
|
|
def determine_required_paths(world, player):
|
|
paths = {}
|
|
for name, builder in world.dungeon_layouts[player].items():
|
|
all_regions = builder.master_sector.regions
|
|
paths[name] = determine_paths_for_dungeon(world, player, all_regions, name)
|
|
return paths
|
|
|
|
|
|
boss_path_checks = ['Eastern Boss', 'Desert Boss', 'Hera Boss', 'Tower Agahnim 1', 'PoD Boss', 'Swamp Boss',
|
|
'Skull Boss', 'Ice Boss', 'Mire Boss', 'TR Boss', 'GT Agahnim 2']
|
|
|
|
# pinball is allowed to orphan you
|
|
drop_path_checks = ['Skull Pot Circle', 'Skull Left Drop', 'Skull Back Drop', 'Sewers Rat Path']
|
|
|
|
|
|
def determine_paths_for_dungeon(world, player, all_regions, name):
|
|
all_r_names = set(x.name for x in all_regions)
|
|
paths = []
|
|
non_hole_portals = []
|
|
for portal in world.dungeon_portals[player]:
|
|
if portal.door.entrance.parent_region in all_regions:
|
|
non_hole_portals.append(portal.door.entrance.parent_region.name)
|
|
if portal.destination:
|
|
paths.append(portal.door.entrance.parent_region.name)
|
|
if world.mode[player] == 'standard':
|
|
if name == 'Hyrule Castle':
|
|
paths.append('Hyrule Dungeon Cellblock')
|
|
paths.append(('Hyrule Dungeon Cellblock', 'Sanctuary'))
|
|
if name == 'Hyrule Castle Sewers':
|
|
paths.append('Sanctuary')
|
|
if name == 'Hyrule Castle Dungeon':
|
|
paths.append('Hyrule Dungeon Cellblock')
|
|
paths.append(('Hyrule Dungeon Cellblock', 'Hyrule Castle Throne Room'))
|
|
if world.doorShuffle[player] in ['basic'] and name == 'Thieves Town':
|
|
paths.append('Thieves Attic Window')
|
|
elif 'Thieves Attic Window' in all_r_names:
|
|
paths.append('Thieves Attic Window')
|
|
for boss in boss_path_checks:
|
|
if boss in all_r_names:
|
|
paths.append(boss)
|
|
if 'Thieves Boss' in all_r_names:
|
|
paths.append('Thieves Boss')
|
|
if world.get_dungeon("Thieves Town", player).boss.enemizer_name == 'Blind':
|
|
paths.append(('Thieves Blind\'s Cell', 'Thieves Boss'))
|
|
for drop_check in drop_path_checks:
|
|
if drop_check in all_r_names:
|
|
paths.append((drop_check, non_hole_portals))
|
|
return paths
|
|
|
|
|
|
def winnow_hangers(hangers, hooks):
|
|
removal_info = []
|
|
for hanger, door_set in hangers.items():
|
|
for door in door_set:
|
|
hook_set = hooks[hanger]
|
|
if len(hook_set) == 0:
|
|
removal_info.append((hanger, door))
|
|
else:
|
|
found_valid = False
|
|
for door_hook, crystal, orig_hanger in hook_set:
|
|
if orig_hanger != door:
|
|
found_valid = True
|
|
break
|
|
if not found_valid:
|
|
removal_info.append((hanger, door))
|
|
for hanger, door in removal_info:
|
|
hangers[hanger].remove(door)
|
|
|
|
|
|
def create_graph_piece_from_state(door, o_state, b_state, proposed_map, exception, world, player):
|
|
# todo: info about dungeon events - not sure about that
|
|
graph_piece = GraphPiece()
|
|
all_unattached = {}
|
|
for exp_d in o_state.unattached_doors:
|
|
all_unattached[exp_d.door] = exp_d.crystal
|
|
for exp_d in b_state.unattached_doors:
|
|
d = exp_d.door
|
|
if d in all_unattached.keys():
|
|
if all_unattached[d] != exp_d.crystal:
|
|
if all_unattached[d] == CrystalBarrier.Orange and exp_d.crystal == CrystalBarrier.Blue:
|
|
all_unattached[d] = CrystalBarrier.Null
|
|
elif all_unattached[d] == CrystalBarrier.Blue and exp_d.crystal == CrystalBarrier.Orange:
|
|
# the swapping case
|
|
logging.getLogger('').warning('Mismatched state @ %s (o:%s b:%s)', d.name, all_unattached[d],
|
|
exp_d.crystal)
|
|
elif all_unattached[d] == CrystalBarrier.Either:
|
|
all_unattached[d] = exp_d.crystal # pessimism, and if not this, leave it alone
|
|
else:
|
|
all_unattached[exp_d.door] = exp_d.crystal
|
|
h_crystal = door.crystal if door is not None else None
|
|
for d, crystal in all_unattached.items():
|
|
if (door is None or d != door) and (not d.blocked or exception(d))and d not in proposed_map.keys():
|
|
graph_piece.hooks[d] = crystal
|
|
if d == door:
|
|
h_crystal = crystal
|
|
graph_piece.hanger_info = door
|
|
graph_piece.hanger_crystal = h_crystal
|
|
graph_piece.visited_regions.update(o_state.visited_blue)
|
|
graph_piece.visited_regions.update(o_state.visited_orange)
|
|
graph_piece.visited_regions.update(b_state.visited_blue)
|
|
graph_piece.visited_regions.update(b_state.visited_orange)
|
|
graph_piece.possible_bk_locations.update(filter_for_potential_bk_locations(o_state.bk_found, world, player))
|
|
graph_piece.possible_bk_locations.update(filter_for_potential_bk_locations(b_state.bk_found, world, player))
|
|
graph_piece.pinball_used = o_state.pinball_used or b_state.pinball_used
|
|
return graph_piece
|
|
|
|
|
|
def filter_for_potential_bk_locations(locations, world, player):
|
|
return [x for x in locations if '- Big Chest' not in x.name and not reserved_location(x, world, player) and
|
|
not x.forced_item and not prize_or_event(x) and not blind_boss_unavail(x, locations, world, player)]
|
|
|
|
|
|
type_map = {
|
|
Hook.Stairs: Hook.Stairs,
|
|
Hook.North: Hook.South,
|
|
Hook.South: Hook.North,
|
|
Hook.West: Hook.East,
|
|
Hook.East: Hook.West
|
|
}
|
|
|
|
|
|
def opposite_h_type(h_type) -> Hook:
|
|
return type_map[h_type]
|
|
|
|
|
|
hang_dir_map = {
|
|
Direction.North: Hook.South,
|
|
Direction.South: Hook.North,
|
|
Direction.West: Hook.East,
|
|
Direction.East: Hook.West,
|
|
}
|
|
|
|
|
|
def hanger_from_door(door):
|
|
if door.type == DoorType.SpiralStairs:
|
|
return Hook.Stairs
|
|
if door.type in [DoorType.Normal, DoorType.Open, DoorType.StraightStairs, DoorType.Ladder]:
|
|
return hang_dir_map[door.direction]
|
|
return None
|
|
|
|
|
|
def connect_doors(a, b):
|
|
# Return on unsupported types.
|
|
if a.type in [DoorType.Hole, DoorType.Warp, DoorType.Interior, DoorType.Logical]:
|
|
return
|
|
# Connect supported types
|
|
if a.type in [DoorType.Normal, DoorType.SpiralStairs, DoorType.Open, DoorType.StraightStairs, DoorType.Ladder]:
|
|
if a.blocked:
|
|
connect_one_way(b.entrance, a.entrance)
|
|
elif b.blocked:
|
|
connect_one_way(a.entrance, b.entrance)
|
|
else:
|
|
connect_two_way(a.entrance, b.entrance)
|
|
dep_doors, target = [], None
|
|
if len(a.dependents) > 0:
|
|
dep_doors, target = a.dependents, b
|
|
elif len(b.dependents) > 0:
|
|
dep_doors, target = b.dependents, a
|
|
if target is not None:
|
|
target_region = target.entrance.parent_region
|
|
for dep in dep_doors:
|
|
connect_simple_door(dep, target_region)
|
|
return
|
|
# If we failed to account for a type, panic
|
|
raise RuntimeError('Unknown door type ' + a.type.name)
|
|
|
|
|
|
def connect_two_way(entrance, ext):
|
|
|
|
# if these were already connected somewhere, remove the backreference
|
|
if entrance.connected_region is not None:
|
|
entrance.connected_region.entrances.remove(entrance)
|
|
if ext.connected_region is not None:
|
|
ext.connected_region.entrances.remove(ext)
|
|
|
|
entrance.connect(ext.parent_region)
|
|
ext.connect(entrance.parent_region)
|
|
if entrance.parent_region.dungeon:
|
|
ext.parent_region.dungeon = entrance.parent_region.dungeon
|
|
x = entrance.door
|
|
y = ext.door
|
|
if x is not None:
|
|
x.dest = y
|
|
if y is not None:
|
|
y.dest = x
|
|
|
|
|
|
def connect_one_way(entrance, ext):
|
|
|
|
# if these were already connected somewhere, remove the backreference
|
|
if entrance.connected_region is not None:
|
|
entrance.connected_region.entrances.remove(entrance)
|
|
if ext.connected_region is not None:
|
|
ext.connected_region.entrances.remove(ext)
|
|
|
|
entrance.connect(ext.parent_region)
|
|
if entrance.parent_region.dungeon:
|
|
ext.parent_region.dungeon = entrance.parent_region.dungeon
|
|
x = entrance.door
|
|
y = ext.door
|
|
if x is not None:
|
|
x.dest = y
|
|
if y is not None:
|
|
y.dest = x
|
|
|
|
|
|
def connect_simple_door(exit_door, region):
|
|
exit_door.entrance.connect(region)
|
|
exit_door.dest = region
|
|
|
|
|
|
special_big_key_doors = ['Hyrule Dungeon Cellblock Door', "Thieves Blind's Cell Door"]
|
|
std_special_big_key_doors = ['Hyrule Castle Throne Room Tapestry'] + special_big_key_doors
|
|
|
|
|
|
def get_special_big_key_doors(world, player):
|
|
if world.mode[player] == 'standard':
|
|
return std_special_big_key_doors
|
|
return special_big_key_doors
|
|
|
|
|
|
class ExplorationState(object):
|
|
|
|
def __init__(self, init_crystal=CrystalBarrier.Orange, dungeon=None):
|
|
|
|
self.unattached_doors = []
|
|
self.avail_doors = []
|
|
self.event_doors = []
|
|
|
|
self.visited_orange = []
|
|
self.visited_blue = []
|
|
self.events = set()
|
|
self.crystal = init_crystal
|
|
|
|
# key region stuff
|
|
self.door_krs = {}
|
|
|
|
# key validation stuff
|
|
self.small_doors = []
|
|
self.big_doors = []
|
|
self.opened_doors = []
|
|
self.big_key_opened = False
|
|
self.big_key_special = False
|
|
|
|
self.found_locations = []
|
|
self.ttl_locations = 0
|
|
self.used_locations = 0
|
|
self.key_locations = 0
|
|
self.used_smalls = 0
|
|
self.bk_found = set()
|
|
|
|
self.non_door_entrances = []
|
|
self.dungeon = dungeon
|
|
self.pinball_used = False
|
|
|
|
self.prize_door_set = {}
|
|
self.prize_doors = []
|
|
self.prize_doors_opened = False
|
|
self.prize_received = False
|
|
|
|
def copy(self):
|
|
ret = ExplorationState(dungeon=self.dungeon)
|
|
ret.unattached_doors = list(self.unattached_doors)
|
|
ret.avail_doors = list(self.avail_doors)
|
|
ret.event_doors = list(self.event_doors)
|
|
ret.visited_orange = list(self.visited_orange)
|
|
ret.visited_blue = list(self.visited_blue)
|
|
ret.events = set(self.events)
|
|
ret.crystal = self.crystal
|
|
ret.door_krs = self.door_krs.copy()
|
|
|
|
ret.small_doors = list(self.small_doors)
|
|
ret.big_doors = list(self.big_doors)
|
|
ret.opened_doors = list(self.opened_doors)
|
|
ret.big_key_opened = self.big_key_opened
|
|
ret.big_key_special = self.big_key_special
|
|
ret.ttl_locations = self.ttl_locations
|
|
ret.key_locations = self.key_locations
|
|
ret.used_locations = self.used_locations
|
|
ret.used_smalls = self.used_smalls
|
|
ret.found_locations = list(self.found_locations)
|
|
ret.bk_found = set(self.bk_found)
|
|
|
|
ret.non_door_entrances = list(self.non_door_entrances)
|
|
ret.dungeon = self.dungeon
|
|
ret.pinball_used = self.pinball_used
|
|
|
|
ret.prize_door_set = dict(self.prize_door_set)
|
|
ret.prize_doors = list(self.prize_doors)
|
|
ret.prize_doors_opened = self.prize_doors_opened
|
|
ret.prize_received = self.prize_received
|
|
return ret
|
|
|
|
def init_zelda_event_doors(self, event_starts, player):
|
|
for entrance in event_starts:
|
|
event_door = Door(player, entrance.name, DoorType.Logical)
|
|
event_door.req_event = 'Zelda Drop Off'
|
|
event_door.entrance = entrance
|
|
event_door.crystal = CrystalBarrier.Orange # always start in orange
|
|
self.append_door_to_list(event_door, self.event_doors)
|
|
|
|
def next_avail_door(self):
|
|
self.avail_doors.sort(key=lambda x: 0 if x.flag else 1 if x.door.bigKey else 2)
|
|
exp_door = self.avail_doors.pop()
|
|
self.crystal = exp_door.crystal
|
|
return exp_door
|
|
|
|
def visit_region(self, region, key_region=None, key_checks=False, bk_flag=False):
|
|
if region.type != RegionType.Dungeon:
|
|
self.crystal = CrystalBarrier.Orange
|
|
if self.crystal == CrystalBarrier.Either:
|
|
if region not in self.visited_blue:
|
|
self.visited_blue.append(region)
|
|
if region not in self.visited_orange:
|
|
self.visited_orange.append(region)
|
|
elif self.crystal == CrystalBarrier.Orange:
|
|
self.visited_orange.append(region)
|
|
elif self.crystal == CrystalBarrier.Blue:
|
|
self.visited_blue.append(region)
|
|
if region.type == RegionType.Dungeon:
|
|
for location in region.locations:
|
|
if key_checks and location not in self.found_locations:
|
|
if location.forced_item and 'Small Key' in location.item.name:
|
|
self.key_locations += 1
|
|
if location.name not in dungeon_events and '- Prize' not in location.name and location.name not in ['Agahnim 1', 'Agahnim 2']:
|
|
self.ttl_locations += 1
|
|
if location not in self.found_locations:
|
|
self.found_locations.append(location)
|
|
if not bk_flag and (not location.forced_item or 'Big Key' in location.item.name):
|
|
self.bk_found.add(location)
|
|
if location.name in dungeon_events and location.name not in self.events:
|
|
if self.flooded_key_check(location):
|
|
self.perform_event(location.name, key_region)
|
|
if location.name in flooded_keys_reverse.keys() and self.location_found(
|
|
flooded_keys_reverse[location.name]):
|
|
self.perform_event(flooded_keys_reverse[location.name], key_region)
|
|
if '- Prize' in location.name:
|
|
self.prize_received = True
|
|
|
|
def flooded_key_check(self, location):
|
|
if location.name not in flooded_keys.keys():
|
|
return True
|
|
return flooded_keys[location.name] in [x.name for x in self.found_locations]
|
|
|
|
def location_found(self, location_name):
|
|
for l in self.found_locations:
|
|
if l.name == location_name:
|
|
return True
|
|
return False
|
|
|
|
def perform_event(self, location_name, key_region):
|
|
self.events.add(location_name)
|
|
queue = collections.deque(self.event_doors)
|
|
while len(queue) > 0:
|
|
exp_door = queue.popleft()
|
|
if exp_door.door.req_event == location_name:
|
|
self.avail_doors.append(exp_door)
|
|
self.event_doors.remove(exp_door)
|
|
if key_region is not None:
|
|
d_name = exp_door.door.name
|
|
if d_name not in self.door_krs.keys():
|
|
self.door_krs[d_name] = key_region
|
|
|
|
def add_all_entrance_doors_check_unattached(self, region, world, player):
|
|
door_list = [x for x in get_doors(world, region, player) if x.type in [DoorType.Normal, DoorType.SpiralStairs]]
|
|
door_list.extend(get_entrance_doors(world, region, player))
|
|
for door in door_list:
|
|
if self.can_traverse(door):
|
|
if door.dest is None and not self.in_door_list_ic(door, self.unattached_doors):
|
|
self.append_door_to_list(door, self.unattached_doors)
|
|
elif door.req_event is not None and door.req_event not in self.events and not self.in_door_list(door,
|
|
self.event_doors):
|
|
self.append_door_to_list(door, self.event_doors)
|
|
elif not self.in_door_list(door, self.avail_doors):
|
|
self.append_door_to_list(door, self.avail_doors)
|
|
for entrance in region.entrances:
|
|
door = world.check_for_door(entrance.name, player)
|
|
if door is None:
|
|
self.non_door_entrances.append(entrance)
|
|
|
|
def add_all_doors_check_unattached(self, region, world, player):
|
|
for door in get_doors(world, region, player):
|
|
if self.can_traverse(door):
|
|
if door.controller is not None:
|
|
door = door.controller
|
|
if door.dest is None and not self.in_door_list_ic(door, self.unattached_doors):
|
|
self.append_door_to_list(door, self.unattached_doors)
|
|
elif door.req_event is not None and door.req_event not in self.events and not self.in_door_list(door,
|
|
self.event_doors):
|
|
self.append_door_to_list(door, self.event_doors)
|
|
elif not self.in_door_list(door, self.avail_doors):
|
|
self.append_door_to_list(door, self.avail_doors)
|
|
|
|
def add_all_doors_check_proposed(self, region, proposed_map, valid_doors, flag, world, player, exception):
|
|
for door in get_doors(world, region, player):
|
|
if door.blocked and exception(door):
|
|
self.pinball_used = True
|
|
if self.can_traverse(door, exception):
|
|
if door.controller is not None:
|
|
door = door.controller
|
|
if door.dest is None and door not in proposed_map.keys() and door.name in valid_doors.keys():
|
|
if not self.in_door_list_ic(door, self.unattached_doors):
|
|
self.append_door_to_list(door, self.unattached_doors, flag)
|
|
else:
|
|
other = self.find_door_in_list(door, self.unattached_doors)
|
|
if self.crystal != other.crystal:
|
|
other.crystal = CrystalBarrier.Either
|
|
elif door.req_event is not None and door.req_event not in self.events and not self.in_door_list(door,
|
|
self.event_doors):
|
|
self.append_door_to_list(door, self.event_doors, flag)
|
|
elif not self.in_door_list(door, self.avail_doors):
|
|
self.append_door_to_list(door, self.avail_doors, flag)
|
|
|
|
def add_all_doors_check_key_region(self, region, key_region, world, player):
|
|
for door in get_doors(world, region, player):
|
|
if self.can_traverse(door):
|
|
if door.req_event is not None and door.req_event not in self.events and not self.in_door_list(door,
|
|
self.event_doors):
|
|
self.append_door_to_list(door, self.event_doors)
|
|
elif not self.in_door_list(door, self.avail_doors):
|
|
self.append_door_to_list(door, self.avail_doors)
|
|
if door.name not in self.door_krs.keys():
|
|
self.door_krs[door.name] = key_region
|
|
else:
|
|
if door.name not in self.door_krs.keys():
|
|
self.door_krs[door.name] = key_region
|
|
|
|
def add_all_doors_check_keys(self, region, key_door_proposal, world, player):
|
|
for door in get_doors(world, region, player):
|
|
if self.can_traverse(door):
|
|
if door.controller:
|
|
door = door.controller
|
|
if door in key_door_proposal and door not in self.opened_doors:
|
|
if not self.in_door_list(door, self.small_doors):
|
|
self.append_door_to_list(door, self.small_doors)
|
|
elif (door.bigKey or door.name in special_big_key_doors) and not self.big_key_opened:
|
|
if not self.in_door_list(door, self.big_doors):
|
|
self.append_door_to_list(door, self.big_doors)
|
|
elif door.req_event is not None and door.req_event not in self.events:
|
|
if not self.in_door_list(door, self.event_doors):
|
|
self.append_door_to_list(door, self.event_doors)
|
|
elif not self.in_door_list(door, self.avail_doors):
|
|
self.append_door_to_list(door, self.avail_doors)
|
|
|
|
def add_all_doors_check_big_keys(self, region, big_key_door_proposal, world, player):
|
|
for door in get_doors(world, region, player):
|
|
if self.can_traverse(door):
|
|
if door.controller:
|
|
door = door.controller
|
|
if (door in big_key_door_proposal
|
|
or door.name in get_special_big_key_doors(world, player)) and not self.big_key_opened:
|
|
if not self.in_door_list(door, self.big_doors):
|
|
self.append_door_to_list(door, self.big_doors)
|
|
elif door.req_event is not None and door.req_event not in self.events:
|
|
if not self.in_door_list(door, self.event_doors):
|
|
self.append_door_to_list(door, self.event_doors)
|
|
elif not self.in_door_list(door, self.avail_doors):
|
|
self.append_door_to_list(door, self.avail_doors)
|
|
|
|
def visited(self, region):
|
|
if self.crystal == CrystalBarrier.Either:
|
|
return region in self.visited_blue and region in self.visited_orange
|
|
elif self.crystal == CrystalBarrier.Orange:
|
|
return region in self.visited_orange
|
|
elif self.crystal == CrystalBarrier.Blue:
|
|
return region in self.visited_blue
|
|
return False
|
|
|
|
def visited_at_all(self, region):
|
|
return region in self.visited_blue or region in self.visited_orange
|
|
|
|
def found_forced_bk(self):
|
|
for location in self.found_locations:
|
|
if location.forced_big_key():
|
|
return True
|
|
return False
|
|
|
|
def can_traverse(self, door, exception=None):
|
|
if door.blocked:
|
|
return exception(door) if exception else False
|
|
if door.crystal not in [CrystalBarrier.Null, CrystalBarrier.Either]:
|
|
return self.crystal == CrystalBarrier.Either or door.crystal == self.crystal
|
|
return True
|
|
|
|
def count_locations_exclude_specials(self, world, player):
|
|
return count_locations_exclude_big_chest(self.found_locations, world, player)
|
|
|
|
def validate(self, door, region, world, player):
|
|
return self.can_traverse(door) and not self.visited(region) and valid_region_to_explore(region, self.dungeon,
|
|
world, player)
|
|
|
|
def in_door_list(self, door, door_list):
|
|
for d in door_list:
|
|
if d.door == door and d.crystal == self.crystal:
|
|
return True
|
|
return False
|
|
|
|
@staticmethod
|
|
def in_door_list_ic(door, door_list):
|
|
for d in door_list:
|
|
if d.door == door:
|
|
return True
|
|
return False
|
|
|
|
@staticmethod
|
|
def find_door_in_list(door, door_list):
|
|
for d in door_list:
|
|
if d.door == door:
|
|
return d
|
|
return None
|
|
|
|
def append_door_to_list(self, door, door_list, flag=False):
|
|
if door.crystal == CrystalBarrier.Null:
|
|
door_list.append(ExplorableDoor(door, self.crystal, flag))
|
|
else:
|
|
door_list.append(ExplorableDoor(door, door.crystal, flag))
|
|
|
|
def key_door_sort(self, d):
|
|
if d.door.smallKey:
|
|
if d.door in self.opened_doors:
|
|
return 1
|
|
else:
|
|
return 0
|
|
return 2
|
|
|
|
|
|
def count_locations_exclude_big_chest(locations, world, player):
|
|
cnt = 0
|
|
for loc in locations:
|
|
if ('- Big Chest' not in loc.name and not loc.forced_item and not reserved_location(loc, world, player)
|
|
and not prize_or_event(loc) and not blind_boss_unavail(loc, locations, world, player)):
|
|
cnt += 1
|
|
return cnt
|
|
|
|
|
|
def prize_or_event(loc):
|
|
return loc.name in dungeon_events or '- Prize' in loc.name or loc.name in ['Agahnim 1', 'Agahnim 2']
|
|
|
|
|
|
def reserved_location(loc, world, player):
|
|
return hasattr(world, 'item_pool_config') and loc.name in world.item_pool_config.reserved_locations[player]
|
|
|
|
|
|
def blind_boss_unavail(loc, locations, world, player):
|
|
if loc.name == "Thieves' Town - Boss":
|
|
return (loc.parent_region.dungeon.boss.name == 'Blind' and
|
|
(not any(x for x in locations if x.name == 'Suspicious Maiden') or
|
|
(world.get_region('Thieves Attic Window', player).dungeon.name == 'Thieves Town' and
|
|
not any(x for x in locations if x.name == 'Attic Cracked Floor'))))
|
|
return False
|
|
|
|
|
|
class ExplorableDoor(object):
|
|
|
|
def __init__(self, door, crystal, flag):
|
|
self.door = door
|
|
self.crystal = crystal
|
|
self.flag = flag
|
|
|
|
def __str__(self):
|
|
return str(self.__unicode__())
|
|
|
|
def __unicode__(self):
|
|
return '%s (%s)' % (self.door.name, self.crystal.name)
|
|
|
|
|
|
def extend_reachable_state_improved(search_regions, state, proposed_map, all_regions, valid_doors, bk_flag, world, player, exception):
|
|
local_state = state.copy()
|
|
for region in search_regions:
|
|
local_state.visit_region(region)
|
|
local_state.add_all_doors_check_proposed(region, proposed_map, valid_doors, False, world, player, exception)
|
|
while len(local_state.avail_doors) > 0:
|
|
explorable_door = local_state.next_avail_door()
|
|
if explorable_door.door.bigKey:
|
|
if bk_flag:
|
|
big_not_found = (not special_big_key_found(local_state) if local_state.big_key_special
|
|
else local_state.count_locations_exclude_specials(world, player) == 0)
|
|
if big_not_found:
|
|
continue # we can't open this door
|
|
if explorable_door.door in proposed_map:
|
|
connect_region = world.get_entrance(proposed_map[explorable_door.door].name, player).parent_region
|
|
else:
|
|
connect_region = world.get_entrance(explorable_door.door.name, player).connected_region
|
|
if connect_region is not None:
|
|
if valid_region_to_explore_in_regions(connect_region, all_regions, world, player) and not local_state.visited(
|
|
connect_region):
|
|
flag = explorable_door.flag or explorable_door.door.bigKey
|
|
local_state.visit_region(connect_region, bk_Flag=flag)
|
|
local_state.add_all_doors_check_proposed(connect_region, proposed_map, valid_doors, flag, world, player, exception)
|
|
return local_state
|
|
|
|
|
|
def special_big_key_found(state):
|
|
for location in state.found_locations:
|
|
if location.forced_item and location.forced_item.bigkey:
|
|
return True
|
|
return False
|
|
|
|
|
|
def valid_region_to_explore_in_regions(region, all_regions, world, player):
|
|
if region is None:
|
|
return False
|
|
return (region.type == RegionType.Dungeon and region in all_regions)\
|
|
or region.name in world.inaccessible_regions[player]\
|
|
or (region.name == 'Hyrule Castle Ledge' and world.mode[player] == 'standard')
|
|
|
|
|
|
# cross-utility methods
|
|
def valid_region_to_explore(region, name, world, player):
|
|
if region is None:
|
|
return False
|
|
return ((region.type == RegionType.Dungeon and region.dungeon and region.dungeon.name in name)
|
|
or region.name in world.inaccessible_regions[player]
|
|
or (region.name == 'Hyrule Castle Ledge' and world.mode[player] == 'standard'))
|
|
|
|
|
|
def get_doors(world, region, player):
|
|
res = []
|
|
for ext in region.exits:
|
|
door = world.check_for_door(ext.name, player)
|
|
if door is not None:
|
|
res.append(door)
|
|
return res
|
|
|
|
|
|
def get_dungeon_doors(region, world, player):
|
|
res = []
|
|
for ext in region.exits:
|
|
door = world.check_for_door(ext.name, player)
|
|
if door is not None and ext.parent_region.type == RegionType.Dungeon:
|
|
res.append(door)
|
|
return res
|
|
|
|
|
|
def get_entrance_doors(world, region, player):
|
|
res = []
|
|
for ext in region.entrances:
|
|
door = world.check_for_door(ext.name, player)
|
|
if door is not None:
|
|
res.append(door)
|
|
return res
|
|
|
|
|
|
def convert_regions(region_names, world, player):
|
|
region_list = []
|
|
for name in region_names:
|
|
region_list.append(world.get_region(name, player))
|
|
return region_list
|
|
|
|
|
|
# Begin crossed mode sector shuffle
|
|
|
|
class DungeonBuilder(object):
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.sectors = []
|
|
self.location_cnt = 0
|
|
self.location_set = set()
|
|
self.key_drop_cnt = 0
|
|
self.dungeon_items = None # during fill how many dungeon items are left
|
|
self.free_items = None # during fill how many dungeon items are left
|
|
self.bk_required = False
|
|
self.bk_provided = False
|
|
self.c_switch_required = False
|
|
self.c_switch_present = False
|
|
self.c_locked = False
|
|
self.dead_ends = 0
|
|
self.branches = 0
|
|
self.forced_loops = 0
|
|
self.total_conn_lack = 0
|
|
self.conn_needed = defaultdict(int)
|
|
self.conn_supplied = defaultdict(int)
|
|
self.conn_balance = defaultdict(int)
|
|
self.mag_needed = {}
|
|
self.unfulfilled = defaultdict(int)
|
|
self.all_entrances = None # used for sector segregation/branching
|
|
self.entrance_list = None # used for overworld accessibility
|
|
self.layout_starts = None # used for overworld accessibility
|
|
self.master_sector = None
|
|
self.path_entrances = None # used for pathing/key doors, I think
|
|
self.split_flag = False
|
|
|
|
self.candidates = None
|
|
self.total_keys = None
|
|
self.key_doors_num = None
|
|
self.combo_size = None
|
|
self.flex = 0
|
|
self.key_door_proposal = None
|
|
self.bk_door_proposal = None
|
|
self.trap_door_proposal = None
|
|
|
|
self.allowance = None
|
|
if 'Stonewall' in name:
|
|
self.allowance = 1
|
|
elif 'Prewall' in name:
|
|
orig_name = name[:-8]
|
|
if orig_name in dungeon_dead_end_allowance.keys():
|
|
self.allowance = dungeon_dead_end_allowance[orig_name]
|
|
if self.allowance is None:
|
|
self.allowance = 1
|
|
|
|
self.valid_proposal = None
|
|
self.split_dungeon_map = None
|
|
self.exception_list = []
|
|
|
|
self.throne_door = None
|
|
self.throne_sector = None
|
|
self.chosen_lobby = None
|
|
self.sewers_access = None
|
|
|
|
def polarity_complement(self):
|
|
pol = Polarity()
|
|
for sector in self.sectors:
|
|
pol += sector.polarity()
|
|
return pol.complement()
|
|
|
|
def polarity(self):
|
|
pol = Polarity()
|
|
for sector in self.sectors:
|
|
pol += sector.polarity()
|
|
return pol
|
|
|
|
def __str__(self):
|
|
return str(self.__unicode__())
|
|
|
|
def __unicode__(self):
|
|
return '%s' % self.name
|
|
|
|
|
|
def simple_dungeon_builder(name, sector_list):
|
|
define_sector_features(sector_list)
|
|
builder = DungeonBuilder(name)
|
|
dummy_pool = dict.fromkeys(sector_list)
|
|
global_pole = GlobalPolarity(dummy_pool)
|
|
for sector in sector_list:
|
|
assign_sector(sector, builder, dummy_pool, global_pole)
|
|
return builder
|
|
|
|
|
|
def create_dungeon_builders(all_sectors, connections_tuple, world, player, dungeon_pool,
|
|
dungeon_entrances=None, split_dungeon_entrances=None):
|
|
logger = logging.getLogger('')
|
|
logger.info('Shuffling Dungeon Sectors')
|
|
|
|
if dungeon_entrances is None:
|
|
dungeon_entrances = default_dungeon_entrances
|
|
if split_dungeon_entrances is None:
|
|
split_dungeon_entrances = split_region_starts
|
|
define_sector_features(all_sectors)
|
|
finished, dungeon_map, attempts = False, {}, 0
|
|
while not finished:
|
|
candidate_sectors = dict.fromkeys(all_sectors)
|
|
global_pole = GlobalPolarity(candidate_sectors)
|
|
|
|
dungeon_map = {}
|
|
for key in dungeon_pool:
|
|
current_dungeon = dungeon_map[key] = DungeonBuilder(key)
|
|
for r_name in dungeon_boss_sectors[key]:
|
|
assign_sector(find_sector(r_name, candidate_sectors), current_dungeon, candidate_sectors, global_pole)
|
|
if key == 'Hyrule Castle' and world.mode[player] == 'standard':
|
|
for r_name in ['Hyrule Dungeon Cellblock', 'Sanctuary', 'Hyrule Castle Throne Room']: # need to deliver zelda
|
|
assign_sector(find_sector(r_name, candidate_sectors), current_dungeon,
|
|
candidate_sectors, global_pole)
|
|
if key == 'Thieves Town' and world.get_dungeon("Thieves Town", player).boss.enemizer_name == 'Blind':
|
|
assign_sector(find_sector("Thieves Blind's Cell", candidate_sectors), current_dungeon,
|
|
candidate_sectors, global_pole)
|
|
entrances_map, potentials, connections = connections_tuple
|
|
accessible_sectors, reverse_d_map = set(), {}
|
|
for key in dungeon_pool:
|
|
current_dungeon = dungeon_map[key]
|
|
current_dungeon.all_entrances = dungeon_entrances[key]
|
|
for r_name in current_dungeon.all_entrances:
|
|
sector = find_sector(r_name, candidate_sectors)
|
|
assign_sector(sector, current_dungeon, candidate_sectors, global_pole)
|
|
if r_name in entrances_map[key]:
|
|
if sector:
|
|
accessible_sectors.add(sector)
|
|
else:
|
|
if not sector:
|
|
sector = find_sector(r_name, all_sectors)
|
|
reverse_d_map[sector] = key
|
|
if world.mode[player] == 'standard':
|
|
if 'Hyrule Castle' in dungeon_map:
|
|
current_dungeon = dungeon_map['Hyrule Castle']
|
|
standard_stair_check(dungeon_map, current_dungeon, candidate_sectors, global_pole)
|
|
|
|
complete_dungeons = {x: y for x, y in dungeon_map.items() if sum(len(sector.outstanding_doors) for sector in y.sectors) <= 0}
|
|
[dungeon_map.pop(key) for key in complete_dungeons.keys()]
|
|
|
|
if not dungeon_map:
|
|
dungeon_map.update(complete_dungeons)
|
|
return dungeon_map
|
|
|
|
# categorize sectors
|
|
identify_destination_sectors(accessible_sectors, reverse_d_map, dungeon_map, connections,
|
|
dungeon_entrances, split_dungeon_entrances)
|
|
for name, builder in dungeon_map.items():
|
|
calc_allowance_and_dead_ends(builder, connections_tuple, world, player)
|
|
|
|
if world.mode[player] == 'open' and world.shuffle[player] not in ['crossed', 'insanity']:
|
|
sanc = find_sector('Sanctuary', candidate_sectors)
|
|
if sanc: # only run if sanc if a candidate
|
|
lw_builders = []
|
|
for name in dungeon_pool:
|
|
for portal_name in dungeon_portals[name]:
|
|
if world.get_portal(portal_name, player).light_world:
|
|
lw_builders.append(dungeon_map[name])
|
|
break
|
|
# portals only - not drops for mirror stuff
|
|
sanc_builder = random.choice(lw_builders)
|
|
assign_sector(sanc, sanc_builder, candidate_sectors, global_pole)
|
|
|
|
retro_std_flag = world.bow_mode[player].startswith('retro') and world.mode[player] == 'standard'
|
|
non_hc_sectors = {}
|
|
free_location_sectors = {}
|
|
crystal_switches = {}
|
|
crystal_barriers = {}
|
|
polarized_sectors = {}
|
|
neutral_sectors = {}
|
|
for sector in candidate_sectors:
|
|
if retro_std_flag and 'Bow' in sector.item_logic: # these need to be distributed outside of HC
|
|
non_hc_sectors[sector] = None
|
|
elif world.mode[player] == 'standard' and 'Open Floodgate' in sector.item_logic:
|
|
non_hc_sectors[sector] = None
|
|
elif sector.chest_locations > 0:
|
|
free_location_sectors[sector] = None
|
|
elif sector.c_switch:
|
|
crystal_switches[sector] = None
|
|
elif sector.blue_barrier:
|
|
crystal_barriers[sector] = None
|
|
elif sector.polarity().is_neutral():
|
|
neutral_sectors[sector] = None
|
|
else:
|
|
polarized_sectors[sector] = None
|
|
if non_hc_sectors:
|
|
assign_non_hc_sectors(dungeon_map, non_hc_sectors, global_pole)
|
|
leftover = assign_location_sectors_minimal(dungeon_map, free_location_sectors, global_pole, world, player)
|
|
free_location_sectors = scatter_extra_location_sectors(dungeon_map, leftover, global_pole)
|
|
for sector in free_location_sectors:
|
|
if sector.c_switch:
|
|
crystal_switches[sector] = None
|
|
elif sector.blue_barrier:
|
|
crystal_barriers[sector] = None
|
|
elif sector.polarity().is_neutral():
|
|
neutral_sectors[sector] = None
|
|
else:
|
|
polarized_sectors[sector] = None
|
|
leftover = assign_crystal_switch_sectors(dungeon_map, crystal_switches, crystal_barriers, global_pole)
|
|
ensure_crystal_switches_reachable(dungeon_map, leftover, polarized_sectors, crystal_barriers, global_pole)
|
|
for sector in leftover:
|
|
if sector.polarity().is_neutral():
|
|
neutral_sectors[sector] = None
|
|
else:
|
|
polarized_sectors[sector] = None
|
|
# blue barriers
|
|
assign_crystal_barrier_sectors(dungeon_map, crystal_barriers, global_pole)
|
|
try:
|
|
# polarity:
|
|
if not global_pole.is_valid(dungeon_map):
|
|
# restart
|
|
raise NeutralizingException('Either free location/crystal assignment is already globally invalid')
|
|
logger.info(world.fish.translate("cli", "cli", "balance.doors"))
|
|
builder_info = dungeon_entrances, split_dungeon_entrances, connections_tuple, world, player
|
|
assign_polarized_sectors(dungeon_map, polarized_sectors, global_pole, builder_info)
|
|
# the rest
|
|
assign_the_rest(dungeon_map, neutral_sectors, global_pole, builder_info)
|
|
dungeon_map.update(complete_dungeons)
|
|
finished = True
|
|
except (NeutralizingException, GenerationException) as e:
|
|
attempts += 1
|
|
logger.debug(f'Attempt {attempts} failed with {str(e)}')
|
|
if attempts >= 10:
|
|
raise Exception('Could not find a valid seed quickly, something is likely horribly wrong.', e)
|
|
return dungeon_map
|
|
|
|
|
|
def standard_stair_check(dungeon_map, dungeon, candidate_sectors, global_pole):
|
|
# this is because there must be at least one non-dead stairway in hc to get out
|
|
# this check may not be necessary
|
|
filtered_sectors = [x for x in candidate_sectors if 'Open Floodgate' not in x.item_logic and
|
|
any(y for y in x.outstanding_doors if not y.dead and y.type == DoorType.SpiralStairs)]
|
|
valid = False
|
|
while not valid:
|
|
chosen_sector = random.choice(filtered_sectors)
|
|
filtered_sectors.remove(chosen_sector)
|
|
valid = global_pole.is_valid_choice(dungeon_map, dungeon, [chosen_sector])
|
|
if valid:
|
|
assign_sector(chosen_sector, dungeon, candidate_sectors, global_pole)
|
|
|
|
|
|
def identify_destination_sectors(accessible_sectors, reverse_d_map, dungeon_map, connections, dungeon_entrances, split_dungeon_entrances):
|
|
accessible_overworld, found_connections, explored = set(), set(), False
|
|
|
|
while not explored:
|
|
explored = True
|
|
for ent_name, region in connections.items():
|
|
if ent_name in found_connections:
|
|
continue
|
|
sector = find_sector(ent_name, reverse_d_map.keys())
|
|
if sector is None:
|
|
continue
|
|
if sector in accessible_sectors:
|
|
found_connections.add(ent_name)
|
|
accessible_overworld.add(region) # todo: drops don't give ow access
|
|
explored = False
|
|
elif region in accessible_overworld:
|
|
found_connections.add(ent_name)
|
|
accessible_sectors.add(sector)
|
|
explored = False
|
|
else:
|
|
d_name = reverse_d_map[sector]
|
|
if d_name not in dungeon_map:
|
|
return
|
|
if d_name not in split_dungeon_entrances:
|
|
for r_name in dungeon_entrances[d_name]:
|
|
ent_sector = find_sector(r_name, dungeon_map[d_name].sectors)
|
|
if ent_sector in accessible_sectors and ent_name not in dead_entrances:
|
|
sector.destination_entrance = True
|
|
found_connections.add(ent_name)
|
|
accessible_sectors.add(sector)
|
|
accessible_overworld.add(region)
|
|
explored = False
|
|
break
|
|
elif d_name in split_dungeon_entrances.keys():
|
|
split_section = None
|
|
for split_name, split_list in split_dungeon_entrances[d_name].items():
|
|
if ent_name in split_list:
|
|
split_section = split_name
|
|
break
|
|
if split_section:
|
|
for r_name in split_dungeon_entrances[d_name][split_section]:
|
|
ent_sector = find_sector(r_name, dungeon_map[d_name].sectors)
|
|
if ent_sector in accessible_sectors and ent_name not in dead_entrances:
|
|
sector.destination_entrance = True
|
|
found_connections.add(ent_name)
|
|
accessible_sectors.add(sector)
|
|
accessible_overworld.add(region)
|
|
explored = False
|
|
break
|
|
|
|
|
|
# todo: split version that adds allowance for potential entrances
|
|
def calc_allowance_and_dead_ends(builder, connections_tuple, world, player):
|
|
portals = world.dungeon_portals[player]
|
|
entrances_map, potentials, connections = connections_tuple
|
|
name = builder.name if not builder.split_flag else builder.name.rsplit(' ', 1)[0]
|
|
needed_connections = [x for x in builder.all_entrances if x not in entrances_map[name]]
|
|
starting_allowance = 0
|
|
used_sectors = set()
|
|
destination_entrances = [x.door.entrance.parent_region.name for x in portals if x.destination]
|
|
dead_ends = [x.door.entrance.parent_region.name for x in portals if x.deadEnd]
|
|
for entrance in entrances_map[name]:
|
|
sector = find_sector(entrance, builder.sectors)
|
|
if sector:
|
|
outflow_target = 0 if entrance not in drop_entrances_allowance else 1
|
|
if sector not in used_sectors and (sector.adj_outflow() > outflow_target or entrance in dead_ends):
|
|
if entrance not in destination_entrances:
|
|
starting_allowance += 1
|
|
else:
|
|
builder.branches -= 1
|
|
used_sectors.add(sector)
|
|
elif sector not in used_sectors:
|
|
if entrance in destination_entrances and sector.branches() > 0:
|
|
builder.branches -= 1
|
|
if entrance not in drop_entrances_allowance:
|
|
needed_connections.append(entrance)
|
|
if builder.sewers_access:
|
|
starting_allowance += 1
|
|
builder.allowance = starting_allowance
|
|
for entrance in needed_connections:
|
|
sector = find_sector(entrance, builder.sectors)
|
|
if sector and sector not in used_sectors: # ignore things on same sector
|
|
is_destination = entrance in destination_entrances
|
|
connect_able = False
|
|
if entrance in connections.keys():
|
|
enabling_region = connections[entrance]
|
|
check_list = list(potentials[enabling_region])
|
|
if enabling_region.name in ['Desert Ledge', 'Desert Palace Entrance (North) Spot']:
|
|
alternate = 'Desert Palace Entrance (North) Spot' if enabling_region.name == 'Desert Ledge' else 'Desert Ledge'
|
|
if world.get_region(alternate, player) in potentials:
|
|
check_list.extend(potentials[world.get_region(alternate, player)])
|
|
connecting_entrances = [x for x in check_list if x != entrance and x not in dead_entrances and x not in drop_entrances_allowance]
|
|
connect_able = len(connecting_entrances) > 0
|
|
if is_destination and sector.branches() == 0: #
|
|
builder.dead_ends += 1
|
|
if is_destination and sector.branches() > 0:
|
|
builder.branches -= 1
|
|
if connect_able and not is_destination:
|
|
builder.allowance += 1
|
|
used_sectors.add(sector)
|
|
|
|
|
|
def define_sector_features(sectors):
|
|
for sector in sectors:
|
|
for region in sector.regions:
|
|
for loc in region.locations:
|
|
if '- Prize' in loc.name or loc.name in ['Agahnim 1', 'Agahnim 2']:
|
|
pass
|
|
elif loc.forced_item and 'Small Key' in loc.item.name:
|
|
sector.key_only_locations += 1
|
|
elif loc.forced_item and loc.forced_item.bigkey:
|
|
sector.bk_provided = True
|
|
elif loc.name not in dungeon_events and not loc.forced_item:
|
|
sector.chest_locations += 1
|
|
sector.chest_location_set.add(loc.name)
|
|
if '- Big Chest' in loc.name or loc.name in ["Hyrule Castle - Zelda's Chest",
|
|
"Thieves' Town - Blind's Cell"]:
|
|
sector.bk_required = True
|
|
for ext in region.exits:
|
|
door = ext.door
|
|
if door is not None and not door.blocked:
|
|
if door.crystal == CrystalBarrier.Either:
|
|
sector.c_switch = True
|
|
elif door.crystal == CrystalBarrier.Orange:
|
|
sector.orange_barrier = True
|
|
elif door.crystal == CrystalBarrier.Blue:
|
|
sector.blue_barrier = True
|
|
if door.bigKey:
|
|
sector.bk_required = True
|
|
if region.name in ['PoD Mimics 2', 'PoD Bow Statue Right', 'PoD Mimics 1', 'GT Mimics 1', 'GT Mimics 2',
|
|
'Eastern Single Eyegore', 'Eastern Duo Eyegores']:
|
|
sector.item_logic.add('Bow')
|
|
if region.name in ['Swamp Lobby', 'Swamp Entrance']:
|
|
sector.item_logic.add('Open Floodgate')
|
|
|
|
|
|
def assign_sector(sector, dungeon, candidate_sectors, global_pole):
|
|
if sector:
|
|
del candidate_sectors[sector]
|
|
global_pole.consume(sector)
|
|
assign_sector_helper(sector, dungeon)
|
|
|
|
|
|
def assign_sector_helper(sector, builder):
|
|
builder.sectors.append(sector)
|
|
builder.location_cnt += sector.chest_locations
|
|
builder.key_drop_cnt += sector.key_only_locations
|
|
builder.location_set.update(sector.chest_location_set)
|
|
if sector.c_switch:
|
|
builder.c_switch_present = True
|
|
if sector.blue_barrier:
|
|
builder.c_switch_required = True
|
|
if sector.bk_required:
|
|
builder.bk_required = True
|
|
if sector.bk_provided:
|
|
builder.bk_provided = True
|
|
count_conn_needed_supplied(sector, builder.conn_needed, builder.conn_supplied)
|
|
builder.dead_ends += sector.dead_ends()
|
|
builder.branches += sector.branches()
|
|
if sector in builder.exception_list:
|
|
builder.exception_list.remove(sector)
|
|
else:
|
|
if builder.split_dungeon_map:
|
|
builder.split_dungeon_map = None
|
|
if builder.valid_proposal:
|
|
builder.valid_proposal = None
|
|
|
|
|
|
def count_conn_needed_supplied(sector, conn_needed, conn_supplied):
|
|
for door in sector.outstanding_doors:
|
|
# todo: destination sectors like skull 2 west should be
|
|
if (door.blocked or door.dead or sector.adj_outflow() <= 1) and not sector.is_entrance_sector():
|
|
conn_needed[hook_from_door(door)] += 1
|
|
# todo: stonewall
|
|
else: # todo: dungeons that need connections... skull, tr, hc, desert (when edges are done)
|
|
conn_supplied[hanger_from_door(door)] += 1
|
|
|
|
|
|
def find_sector(r_name, sectors):
|
|
for s in sectors:
|
|
if r_name in s.region_set():
|
|
return s
|
|
return None
|
|
|
|
|
|
def assign_non_hc_sectors(dungeon_map, non_hc_sectors, global_pole):
|
|
sector_list = list(non_hc_sectors)
|
|
random.shuffle(sector_list)
|
|
population = []
|
|
for name in dungeon_map:
|
|
if name != 'Hyrule Castle':
|
|
population.append(name)
|
|
choices = random.choices(population, k=len(sector_list))
|
|
for i, choice in enumerate(choices):
|
|
builder = dungeon_map[choice]
|
|
assign_sector(sector_list[i], builder, non_hc_sectors, global_pole)
|
|
|
|
|
|
def scatter_extra_location_sectors(dungeon_map, free_location_sectors, global_pole):
|
|
population = [n for n in dungeon_map.keys()]
|
|
k = round(len(free_location_sectors) * .50)
|
|
valid = False
|
|
choices = None
|
|
candidates = []
|
|
sector_list = list(free_location_sectors)
|
|
while not valid:
|
|
candidates = random.sample(sector_list, k=k)
|
|
choices = random.choices(population, k=len(candidates))
|
|
sector_dict = defaultdict(list)
|
|
for i, choice in enumerate(choices):
|
|
builder = dungeon_map[choice]
|
|
sector_dict[builder].append(candidates[i])
|
|
valid = global_pole.is_valid_multi_choice_2(dungeon_map, dungeon_map.values(), sector_dict)
|
|
for i, choice in enumerate(choices):
|
|
builder = dungeon_map[choice]
|
|
assign_sector(candidates[i], builder, free_location_sectors, global_pole)
|
|
return free_location_sectors
|
|
|
|
|
|
def assign_location_sectors_minimal(dungeon_map, free_location_sectors, global_pole, world, player):
|
|
valid = False
|
|
choices = defaultdict(list)
|
|
sector_list = list(free_location_sectors)
|
|
random.shuffle(sector_list)
|
|
orig_location_set = build_orig_location_set(dungeon_map)
|
|
num_dungeon_items = requested_dungeon_items(world, player)
|
|
d_idx = {builder.name: i for i, builder in enumerate(dungeon_map.values())}
|
|
next_sector = sector_list.pop()
|
|
while not valid:
|
|
choice, totals, location_set = weighted_random_location(dungeon_map, choices, orig_location_set, world, player)
|
|
if not choice:
|
|
break
|
|
choices[choice].append(next_sector)
|
|
if global_pole.is_valid_multi_choice_2(dungeon_map, dungeon_map.values(), choices):
|
|
idx = d_idx[choice.name]
|
|
totals[idx] += next_sector.chest_locations
|
|
location_set[choice.name].update(next_sector.chest_location_set)
|
|
valid = True
|
|
for d_name, idx in d_idx.items():
|
|
free_items = count_reserved_locations(world, player, location_set[d_name])
|
|
target = max(free_items, 2) + num_dungeon_items
|
|
if totals[idx] < target:
|
|
valid = False
|
|
break
|
|
if not valid:
|
|
if len(sector_list) == 0:
|
|
choices = defaultdict(list)
|
|
sector_list = list(free_location_sectors)
|
|
else:
|
|
next_sector = sector_list.pop()
|
|
else:
|
|
choices[choice].remove(next_sector)
|
|
for builder, choice_list in choices.items():
|
|
for choice in choice_list:
|
|
assign_sector(choice, builder, free_location_sectors, global_pole)
|
|
return free_location_sectors
|
|
|
|
|
|
def weighted_random_location(dungeon_map, choices, orig_location_set, world, player):
|
|
population = []
|
|
totals = []
|
|
location_set = {x: set(y) for x, y in orig_location_set.items()}
|
|
num_dungeon_items = requested_dungeon_items(world, player)
|
|
for i, dungeon_builder in enumerate(dungeon_map.values()):
|
|
ttl = dungeon_builder.location_cnt + sum(sector.chest_locations for sector in choices[dungeon_builder])
|
|
totals.append(ttl)
|
|
builder_set = location_set[dungeon_builder.name]
|
|
builder_set.update(set().union(*(s.chest_location_set for s in choices[dungeon_builder])))
|
|
free_items = count_reserved_locations(world, player, builder_set)
|
|
target = max(free_items, 2) + num_dungeon_items
|
|
if ttl < target:
|
|
population.append(dungeon_builder)
|
|
choice = random.choice(population) if len(population) > 0 else None
|
|
return choice, totals, location_set
|
|
|
|
|
|
# deprecated
|
|
def weighted_random_locations(dungeon_map, free_location_sectors):
|
|
population = []
|
|
ttl_assigned = 0
|
|
weights = []
|
|
totals = []
|
|
d_idx = {}
|
|
for i, dungeon_builder in enumerate(dungeon_map.values()):
|
|
population.append(dungeon_builder)
|
|
totals.append(dungeon_builder.location_cnt)
|
|
ttl_assigned += dungeon_builder.location_cnt
|
|
weights.append(6.375)
|
|
d_idx[dungeon_builder.name] = i
|
|
average = ttl_assigned / 13
|
|
for i, db in enumerate(population):
|
|
if db.location_cnt < average:
|
|
weights[i] += average - db.location_cnt
|
|
if db.location_cnt > average:
|
|
weights[i] = max(0, weights[i] - db.location_cnt + average)
|
|
|
|
choices = random.choices(population, weights, k=len(free_location_sectors))
|
|
return choices, d_idx, totals
|
|
|
|
|
|
def build_orig_location_set(dungeon_map):
|
|
orig_locations = {}
|
|
for name, builder in dungeon_map.items():
|
|
orig_locations[name] = set().union(*(s.chest_location_set for s in builder.sectors))
|
|
return orig_locations
|
|
|
|
|
|
def requested_dungeon_items(world, player):
|
|
num = 0
|
|
if not world.bigkeyshuffle[player]:
|
|
num += 1
|
|
if not world.compassshuffle[player]:
|
|
num += 1
|
|
if not world.mapshuffle[player]:
|
|
num += 1
|
|
return num
|
|
|
|
|
|
def count_reserved_locations(world, player, proposed_set):
|
|
if world.item_pool_config:
|
|
return len([x for x in proposed_set if x in world.item_pool_config.reserved_locations[player]])
|
|
return 2
|
|
|
|
|
|
def assign_crystal_switch_sectors(dungeon_map, crystal_switches, crystal_barriers, global_pole, assign_one=False):
|
|
population = []
|
|
some_c_switches_present = False
|
|
for name, builder in dungeon_map.items():
|
|
if builder.c_switch_required and not builder.c_switch_present and not builder.c_locked:
|
|
population.append(name)
|
|
if builder.c_switch_present and not builder.c_locked:
|
|
some_c_switches_present = True
|
|
if len(population) == 0: # nothing needs a switch
|
|
if assign_one and not some_c_switches_present: # something should have one
|
|
if len(crystal_switches) == 0:
|
|
raise GenerationException('No crystal switches to assign. Ref %s' % next(iter(dungeon_map.keys())))
|
|
valid, builder_choice, switch_choice = False, None, None
|
|
switch_candidates = list(crystal_switches)
|
|
switch_choice = random.choice(switch_candidates)
|
|
switch_candidates.remove(switch_choice)
|
|
builder_candidates = [name for name, builder in dungeon_map.items() if not builder.c_locked]
|
|
while not valid:
|
|
if len(builder_candidates) == 0:
|
|
if len(switch_candidates) == 0:
|
|
raise GenerationException('No where to assign crystal switch. Ref %s' % next(iter(dungeon_map.keys())))
|
|
switch_choice = random.choice(switch_candidates)
|
|
switch_candidates.remove(switch_choice)
|
|
builder_candidates = list(dungeon_map.keys())
|
|
choice = random.choice(builder_candidates)
|
|
builder_candidates.remove(choice)
|
|
builder_choice = dungeon_map[choice]
|
|
test_set = [switch_choice]
|
|
test_set.extend(crystal_barriers)
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder_choice, test_set)
|
|
assign_sector(switch_choice, builder_choice, crystal_switches, global_pole)
|
|
return crystal_switches
|
|
if len(crystal_switches) == 0:
|
|
raise GenerationException('No crystal switches to assign')
|
|
sector_list = list(crystal_switches)
|
|
if len(population) > len(sector_list):
|
|
raise GenerationException('Not enough crystal switch sectors for those needed')
|
|
choices = random.sample(sector_list, k=len(population))
|
|
for i, choice in enumerate(choices):
|
|
builder = dungeon_map[population[i]]
|
|
assign_sector(choice, builder, crystal_switches, global_pole)
|
|
return crystal_switches
|
|
|
|
|
|
def ensure_crystal_switches_reachable(dungeon_map, crystal_switches, polarized_sectors, crystal_barriers, global_pole):
|
|
invalid_builders = []
|
|
for name, builder in dungeon_map.items():
|
|
if builder.c_switch_present and builder.c_switch_required and not builder.c_locked:
|
|
invalid_builders.append(builder)
|
|
random.shuffle(invalid_builders)
|
|
while len(invalid_builders) > 0:
|
|
valid_builders = []
|
|
for builder in invalid_builders:
|
|
entrance_sectors = []
|
|
reachable_crystals = defaultdict()
|
|
for sector in builder.sectors:
|
|
if sector.equations is None:
|
|
sector.equations = calc_sector_equations(sector)
|
|
if sector.is_entrance_sector() and not sector.destination_entrance:
|
|
need_switch = True
|
|
for region in sector.get_start_regions():
|
|
if region.crystal_switch:
|
|
need_switch = False
|
|
break
|
|
any_benefit = False
|
|
for eq in sector.equations:
|
|
if len(eq.benefit) > 0:
|
|
any_benefit = True
|
|
break
|
|
if need_switch and any_benefit:
|
|
entrance_sectors.append(sector)
|
|
for eq in sector.equations:
|
|
if eq.c_switch:
|
|
reachable_crystals[hook_from_door(eq.door)] = True
|
|
valid_ent_sectors = []
|
|
random.shuffle(entrance_sectors)
|
|
for entrance_sector in entrance_sectors:
|
|
other_sectors = [x for x in builder.sectors if x != entrance_sector]
|
|
reachable, access = is_c_switch_reachable(entrance_sector, reachable_crystals, other_sectors)
|
|
if reachable:
|
|
valid_ent_sectors.append(entrance_sector)
|
|
else:
|
|
candidates = {}
|
|
for c in find_pol_cand_for_c_switch(access, reachable_crystals, polarized_sectors):
|
|
candidates[c] = 'Polarized'
|
|
for c in find_crystal_cand(access, crystal_switches):
|
|
candidates[c] = 'Crystals'
|
|
for c in find_pol_cand_for_c_switch(access, reachable_crystals, crystal_barriers):
|
|
candidates[c] = 'Barriers'
|
|
valid, sector, which_list = False, None, None
|
|
while not valid:
|
|
if len(candidates) <= 0:
|
|
raise GenerationException(f'need to provide more sophisticated crystal connection for {entrance_sector}')
|
|
# prioritize candidates
|
|
if any(x == 'Crystals' for x in candidates.values()):
|
|
cand_list = [x for x in candidates.items() if x[1] == 'Crystals']
|
|
else:
|
|
cand_list = list(candidates.items())
|
|
sector, which_list = random.choice(cand_list)
|
|
del candidates[sector]
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder, [sector])
|
|
if which_list == 'Polarized':
|
|
assign_sector(sector, builder, polarized_sectors, global_pole)
|
|
elif which_list == 'Crystals':
|
|
assign_sector(sector, builder, crystal_switches, global_pole)
|
|
elif which_list == 'Barriers':
|
|
assign_sector(sector, builder, crystal_barriers, global_pole)
|
|
entrance_sectors = [x for x in entrance_sectors if x not in valid_ent_sectors]
|
|
if len(entrance_sectors) == 0:
|
|
valid_builders.append(builder)
|
|
invalid_builders = [x for x in invalid_builders if x not in valid_builders]
|
|
|
|
|
|
def is_c_switch_reachable(entrance_sector, reachable_crystals, other_sectors):
|
|
current_access = {}
|
|
for eq in entrance_sector.equations:
|
|
if eq.total_cost() <= 0:
|
|
for key, door_list in eq.benefit.items():
|
|
for door in door_list:
|
|
if door not in eq.crystal_blocked.keys() or eq.crystal_blocked[door] != CrystalBarrier.Blue:
|
|
current_access[key] = True
|
|
break
|
|
for key, flag in current_access.items():
|
|
if opposite_h_type(key) in reachable_crystals.keys():
|
|
return True, {}
|
|
changed = True
|
|
while changed:
|
|
changed = False
|
|
for sector in other_sectors:
|
|
for eq in sector.equations:
|
|
key, cost_door = eq.cost
|
|
if key in current_access.keys() and current_access[key]:
|
|
for bene_key, door_list in eq.benefit.items():
|
|
for door in door_list:
|
|
block_dict = eq.crystal_blocked
|
|
if door not in block_dict.keys() or block_dict[door] != CrystalBarrier.Blue:
|
|
if bene_key not in current_access.keys():
|
|
current_access[bene_key] = True
|
|
changed = True
|
|
break
|
|
for key, flag in current_access.items():
|
|
if opposite_h_type(key) in reachable_crystals.keys():
|
|
return True, {}
|
|
return False, current_access
|
|
|
|
|
|
def find_pol_cand_for_c_switch(access, reachable_crystals, polarized_candidates):
|
|
candidates = []
|
|
for sector in polarized_candidates:
|
|
if pol_cand_matches_access_reach(sector, access, reachable_crystals):
|
|
candidates.append(sector)
|
|
return candidates
|
|
|
|
|
|
def pol_cand_matches_access_reach(sector, access, reachable_crystals):
|
|
if sector.equations is None:
|
|
sector.equations = calc_sector_equations(sector)
|
|
for eq in sector.equations:
|
|
key, cost_door = eq.cost
|
|
if key in access.keys() and access[key]:
|
|
for bene_key, door_list in eq.benefit.items():
|
|
for door in door_list:
|
|
if door not in eq.crystal_blocked.keys() or eq.crystal_blocked[door] != CrystalBarrier.Blue:
|
|
if opposite_h_type(bene_key) in reachable_crystals.keys():
|
|
return True
|
|
return False
|
|
|
|
|
|
def find_crystal_cand(access, crystal_switches):
|
|
candidates = []
|
|
for sector in crystal_switches:
|
|
if crystal_cand_matches_access(sector, access):
|
|
candidates.append(sector)
|
|
return candidates
|
|
|
|
|
|
def crystal_cand_matches_access(sector, access):
|
|
if sector.equations is None:
|
|
sector.equations = calc_sector_equations(sector)
|
|
for eq in sector.equations:
|
|
key, cost_door = eq.cost
|
|
if key in access.keys() and access[key] and eq.c_switch and len(sector.outstanding_doors) > 1:
|
|
return True
|
|
return False
|
|
|
|
|
|
def assign_crystal_barrier_sectors(dungeon_map, crystal_barriers, global_pole):
|
|
population = []
|
|
for name, builder in dungeon_map.items():
|
|
if builder.c_switch_present and not builder.c_locked:
|
|
population.append(name)
|
|
sector_list = list(crystal_barriers)
|
|
random.shuffle(sector_list)
|
|
choices = random.choices(population, k=len(sector_list))
|
|
for i, choice in enumerate(choices):
|
|
builder = dungeon_map[choice]
|
|
assign_sector(sector_list[i], builder, crystal_barriers, global_pole)
|
|
|
|
|
|
def identify_polarity_issues(dungeon_map):
|
|
unconnected_builders = {}
|
|
for name, builder in dungeon_map.items():
|
|
identify_polarity_issues_internal(name, builder, unconnected_builders)
|
|
return unconnected_builders
|
|
|
|
|
|
def identify_polarity_issues_internal(name, builder, unconnected_builders):
|
|
if len(builder.sectors) == 1:
|
|
return
|
|
else:
|
|
def sector_filter(x, y):
|
|
return x != y
|
|
# else:
|
|
# def sector_filter(x, y):
|
|
# return x != y and (x.outflow() > 1 or is_entrance_sector(builder, x))
|
|
connection_flags = {}
|
|
for slot in PolSlot:
|
|
connection_flags[slot] = {}
|
|
for slot2 in PolSlot:
|
|
connection_flags[slot][slot2] = False
|
|
for sector in builder.sectors:
|
|
others = [x for x in builder.sectors if sector_filter(x, sector)]
|
|
other_mag = sum_magnitude(others)
|
|
sector_mag = sector.magnitude()
|
|
check_flags(sector_mag, connection_flags)
|
|
unconnected_sector = True
|
|
for i in PolSlot:
|
|
if sector_mag[i.value] == 0 or other_mag[i.value] > 0 or self_connecting(sector, i, sector_mag):
|
|
unconnected_sector = False
|
|
break
|
|
if unconnected_sector:
|
|
for i in PolSlot:
|
|
if sector_mag[i.value] > 0 and other_mag[i.value] == 0 and not self_connecting(sector, i, sector_mag):
|
|
builder.mag_needed[i] = [x for x in PolSlot if other_mag[x.value] > 0]
|
|
if name not in unconnected_builders.keys():
|
|
unconnected_builders[name] = builder
|
|
ttl_mag = sum_magnitude(builder.sectors)
|
|
for slot in PolSlot:
|
|
for slot2 in PolSlot:
|
|
if ttl_mag[slot.value] > 0 and ttl_mag[slot2.value] > 0 and not connection_flags[slot][slot2]:
|
|
builder.mag_needed[slot] = [slot2]
|
|
builder.mag_needed[slot2] = [slot]
|
|
if name not in unconnected_builders.keys():
|
|
unconnected_builders[name] = builder
|
|
|
|
def self_connecting(sector, slot, magnitude):
|
|
return sector.polarity()[slot.value] == 0 and sum(magnitude) > magnitude[slot.value]
|
|
|
|
|
|
def check_flags(sector_mag, connection_flags):
|
|
for slot in PolSlot:
|
|
for slot2 in PolSlot:
|
|
if sector_mag[slot.value] > 0 and sector_mag[slot2.value] > 0:
|
|
connection_flags[slot][slot2] = True
|
|
if slot != slot2:
|
|
for check_slot in PolSlot: # transitivity check
|
|
if check_slot not in [slot, slot2] and connection_flags[slot2][check_slot]:
|
|
connection_flags[slot][check_slot] = True
|
|
connection_flags[check_slot][slot] = True
|
|
|
|
|
|
def identify_simple_branching_issues(dungeon_map):
|
|
problem_builders = {}
|
|
for name, builder in dungeon_map.items():
|
|
if name == 'Skull Woods 2': # i dislike this special case todo: identify destination entrances
|
|
builder.conn_supplied[Hook.West] += 1
|
|
builder.conn_needed[Hook.East] -= 1
|
|
builder.forced_loops = calc_forced_loops(builder.sectors)
|
|
if builder.dead_ends + builder.forced_loops * 2 > builder.branches + builder.allowance:
|
|
problem_builders[name] = builder
|
|
for h_type in Hook:
|
|
lack = builder.conn_balance[h_type] = builder.conn_supplied[h_type] - builder.conn_needed[h_type]
|
|
if lack < 0:
|
|
builder.total_conn_lack += -lack
|
|
problem_builders[name] = builder
|
|
return problem_builders
|
|
|
|
|
|
def calc_forced_loops(sector_list):
|
|
forced_loops = 0
|
|
for sector in sector_list:
|
|
h_mag = sector.hook_magnitude()
|
|
other_sectors = [x for x in sector_list if x != sector]
|
|
other_mag = sum_hook_magnitude(other_sectors)
|
|
loop_parts = 0
|
|
for hook in Hook:
|
|
opp = opposite_h_type(hook).value
|
|
if h_mag[hook.value] > other_mag[opp] and loop_present(hook, opp, h_mag, other_mag):
|
|
loop_parts += (h_mag[hook.value] - other_mag[opp]) / 2
|
|
forced_loops += math.floor(loop_parts)
|
|
return forced_loops
|
|
|
|
|
|
def loop_present(hook, opp, h_mag, other_mag):
|
|
if hook == Hook.Stairs:
|
|
return h_mag[hook.value] - other_mag[opp] >= 2
|
|
else:
|
|
return h_mag[opp] >= h_mag[hook.value] - other_mag[opp]
|
|
|
|
|
|
def is_satisfied(door_dict_list):
|
|
for door_dict in door_dict_list:
|
|
for door_list in door_dict.values():
|
|
if len(door_list) > 0:
|
|
return False
|
|
return True
|
|
|
|
|
|
# todo: maybe filter by used doors too
|
|
# todo: I want the number of door that match is accessible by still
|
|
def filter_match_deps(candidate, match_deps):
|
|
return [x for x in match_deps if x != candidate]
|
|
|
|
|
|
def sum_magnitude(sector_list):
|
|
result = [0] * len(PolSlot)
|
|
for sector in sector_list:
|
|
vector = sector.magnitude()
|
|
for i in range(len(result)):
|
|
result[i] = result[i] + vector[i]
|
|
return result
|
|
|
|
|
|
def sum_hook_magnitude(sector_list):
|
|
result = [0] * len(Hook)
|
|
for sector in sector_list:
|
|
vector = sector.hook_magnitude()
|
|
for i in range(len(result)):
|
|
result[i] = result[i] + vector[i]
|
|
return result
|
|
|
|
|
|
def sum_polarity(sector_list):
|
|
pol = Polarity()
|
|
for sector in sector_list:
|
|
pol += sector.polarity()
|
|
return pol
|
|
|
|
|
|
def assign_polarized_sectors(dungeon_map, polarized_sectors, global_pole, builder_info):
|
|
# step 1: fix polarity connection issues
|
|
unconnected_builders = identify_polarity_issues(dungeon_map)
|
|
while len(unconnected_builders) > 0:
|
|
for name, builder in unconnected_builders.items():
|
|
candidates = find_connection_candidates(builder.mag_needed, polarized_sectors)
|
|
valid, sector = False, None
|
|
while not valid:
|
|
if len(candidates) == 0:
|
|
raise GenerationException('Cross Dungeon Builder: Cannot find a candidate for connectedness. %s' % name)
|
|
sector = random.choice(candidates)
|
|
candidates.remove(sector)
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder, [sector])
|
|
assign_sector(sector, builder, polarized_sectors, global_pole)
|
|
builder.mag_needed = {}
|
|
unconnected_builders = identify_polarity_issues(unconnected_builders)
|
|
|
|
# step 2: fix dead ends
|
|
problem_builders = identify_simple_branching_issues(dungeon_map)
|
|
while len(problem_builders) > 0:
|
|
for name, builder in problem_builders.items():
|
|
candidates, charges = find_simple_branching_candidates(builder, polarized_sectors)
|
|
best = min(charges)
|
|
best_candidates = [x for i, x in enumerate(candidates) if charges[i] <= best]
|
|
valid, choice = False, None
|
|
while not valid:
|
|
if len(best_candidates) == 0:
|
|
if len(candidates) == 0:
|
|
raise GenerationException('Cross Dungeon Builder: Simple branch problems: %s' % name)
|
|
best = min(charges)
|
|
best_candidates = [x for i, x in enumerate(candidates) if charges[i] <= best]
|
|
choice = random.choice(best_candidates)
|
|
best_candidates.remove(choice)
|
|
i = candidates.index(choice)
|
|
candidates.pop(i)
|
|
charges.pop(i)
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder, [choice]) and valid_connected_assignment(builder, [choice])
|
|
assign_sector(choice, builder, polarized_sectors, global_pole)
|
|
builder.total_conn_lack = 0
|
|
builder.conn_balance.clear()
|
|
problem_builders = identify_simple_branching_issues(problem_builders)
|
|
|
|
# step 3: fix neutrality issues
|
|
polarity_step_3(dungeon_map, polarized_sectors, global_pole)
|
|
|
|
# step 4: fix dead ends again
|
|
neutral_choices: List[List] = neutralize_the_rest(polarized_sectors)
|
|
problem_builders = identify_branching_issues(dungeon_map, builder_info)
|
|
while len(problem_builders) > 0:
|
|
for name, builder in problem_builders.items():
|
|
candidates = find_branching_candidates(builder, neutral_choices, builder_info)
|
|
valid, choice, package = False, None, None
|
|
while not valid:
|
|
if len(candidates) <= 0:
|
|
raise GenerationException('Cross Dungeon Builder: Complex branch problems: %s' % name)
|
|
choice, package = random.choice(candidates)
|
|
candidates.remove((choice, package))
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder, choice) and valid_polarized_assignment(builder, choice)
|
|
neutral_choices.remove(choice)
|
|
for sector in choice:
|
|
assign_sector(sector, builder, polarized_sectors, global_pole)
|
|
if package:
|
|
builder.throne_door, builder.throne_sector, builder.chosen_lobby = package
|
|
builder.unfulfilled.clear()
|
|
problem_builders = identify_branching_issues(problem_builders, builder_info)
|
|
|
|
# step 5: assign randomly until gone - must maintain connectedness, neutral polarity, branching, lack, etc.
|
|
comb_w_replace = len(dungeon_map) ** len(neutral_choices)
|
|
combinations = None
|
|
if comb_w_replace <= 1000:
|
|
combinations = list(itertools.product(dungeon_map.keys(), repeat=len(neutral_choices)))
|
|
random.shuffle(combinations)
|
|
tries = 0
|
|
while len(polarized_sectors) > 0:
|
|
if tries > 1000 or (combinations and tries >= len(combinations)):
|
|
raise GenerationException('No valid assignment found. Ref: %s' % next(iter(dungeon_map.keys())))
|
|
if combinations:
|
|
choices = combinations[tries]
|
|
else:
|
|
choices = random.choices(list(dungeon_map.keys()), k=len(neutral_choices))
|
|
chosen_sectors = defaultdict(list)
|
|
for i, choice in enumerate(choices):
|
|
chosen_sectors[choice].extend(neutral_choices[i])
|
|
all_valid, package_map = True, {}
|
|
for name, sector_list in chosen_sectors.items():
|
|
flag, package = valid_assignment(dungeon_map[name], sector_list, builder_info)
|
|
if not flag:
|
|
all_valid = False
|
|
break
|
|
if package:
|
|
package_map[dungeon_map[name]] = package
|
|
if all_valid:
|
|
for i, choice in enumerate(choices):
|
|
builder = dungeon_map[choice]
|
|
for sector in neutral_choices[i]:
|
|
assign_sector(sector, builder, polarized_sectors, global_pole)
|
|
if builder in package_map:
|
|
builder.throne_door, builder.throne_sector, builder.chosen_lobby = package_map[builder]
|
|
tries += 1
|
|
|
|
|
|
def polarity_step_3(dungeon_map, polarized_sectors, global_pole):
|
|
# step 3a: fix odd builders
|
|
odd_builders = [x for x in dungeon_map.values() if sum_polarity(x.sectors).charge() % 2 != 0]
|
|
grouped_choices: List[List] = find_forced_groupings(polarized_sectors, dungeon_map)
|
|
random.shuffle(odd_builders)
|
|
odd_candidates = find_odd_sectors(grouped_choices)
|
|
tries = 0
|
|
while len(odd_builders) > 0:
|
|
if tries > 1000:
|
|
raise GenerationException('Unable to fix dungeon parity. Ref: %s' % next(iter(odd_builders)).name)
|
|
best_choices = None
|
|
best_charge = sum([x.polarity().charge() for x in dungeon_map.values()])
|
|
samples = 0
|
|
combos = ncr(len(odd_candidates), len(odd_builders))
|
|
sample_target = 100 if combos > 10 else combos * 2
|
|
while best_choices is None or samples < sample_target:
|
|
samples += 1
|
|
if len(odd_candidates) < len(odd_builders):
|
|
raise GenerationException(f'Unable to fix dungeon parity - not enough candidates.'
|
|
f' Ref: {next(iter(odd_builders)).name}')
|
|
choices = random.sample(odd_candidates, k=len(odd_builders))
|
|
valid = global_pole.is_valid_multi_choice(dungeon_map, odd_builders, choices)
|
|
charge = calc_total_charge(dungeon_map, odd_builders, choices)
|
|
if valid and charge < best_charge:
|
|
best_choices = choices
|
|
best_charge = charge
|
|
if samples > sample_target and best_choices is None:
|
|
best_choices = choices
|
|
best_charge = charge
|
|
samples = 0
|
|
all_valid = True
|
|
for i, candidate_list in enumerate(best_choices):
|
|
test_set = find_forced_connections(dungeon_map, candidate_list, polarized_sectors)
|
|
builder = odd_builders[i]
|
|
if ensure_test_set_connectedness(test_set, builder, polarized_sectors, dungeon_map, global_pole):
|
|
all_valid &= valid_branch_only(builder, candidate_list)
|
|
else:
|
|
all_valid = False
|
|
break
|
|
if not all_valid:
|
|
break
|
|
if all_valid:
|
|
for i, candidate_list in enumerate(best_choices):
|
|
builder = odd_builders[i]
|
|
for sector in candidate_list:
|
|
assign_sector(sector, builder, polarized_sectors, global_pole)
|
|
odd_builders = [x for x in dungeon_map.values() if sum_polarity(x.sectors).charge() % 2 != 0]
|
|
else:
|
|
tries += 1
|
|
|
|
# step 3b: neutralize all builders
|
|
parallel_full_neutralization(dungeon_map, polarized_sectors, global_pole)
|
|
|
|
|
|
def parallel_full_neutralization(dungeon_map, polarized_sectors, global_pole):
|
|
start = time.process_time()
|
|
builders = list(dungeon_map.values())
|
|
finished = all([x.polarity().is_neutral() for x in builders])
|
|
solution_list, current_depth = defaultdict(list), 1
|
|
complete_builders = [x for x in builders if x.polarity().is_neutral()]
|
|
avail_sectors = list(polarized_sectors)
|
|
while not finished:
|
|
builders_to_check = [x for x in builders if not (x.polarity()+sum_polarity(solution_list[x])).is_neutral()]
|
|
candidates, last_depth = find_exact_neutralizing_candidates_parallel_db(builders_to_check, solution_list,
|
|
avail_sectors, current_depth)
|
|
increment_depth = True
|
|
any_valid = False
|
|
for builder, candidate_list in candidates.items():
|
|
valid, sectors = False, None
|
|
while not valid:
|
|
if len(candidate_list) == 0:
|
|
increment_depth = False #need to look again at current level
|
|
break
|
|
sectors = random.choice(candidate_list)
|
|
candidate_list.remove(sectors)
|
|
proposal = solution_list.copy()
|
|
proposal[builder] = list(proposal[builder])
|
|
proposal[builder].extend(sectors)
|
|
valid = global_pole.is_valid_multi_choice_2(dungeon_map, builders, proposal)
|
|
if valid:
|
|
any_valid = True
|
|
solution_list[builder].extend(sectors)
|
|
for sector in sectors:
|
|
avail_sectors.remove(sector)
|
|
complete_builders.append(builder)
|
|
for other_builder, other_cand_list in candidates.items():
|
|
if other_builder not in complete_builders:
|
|
candidates_to_remove = list()
|
|
for candidate in other_cand_list:
|
|
for sector in sectors:
|
|
if sector in candidate:
|
|
candidates_to_remove.append(candidate)
|
|
break
|
|
other_cand_list[:] = [x for x in other_cand_list if x not in candidates_to_remove]
|
|
# remove sectors from other candidate lists
|
|
if not any_valid:
|
|
increment_depth = True
|
|
current_depth = last_depth + 1 if increment_depth else last_depth
|
|
finished = all([(x.polarity()+sum_polarity(solution_list[x])).is_neutral() for x in builders])
|
|
logging.getLogger('').info(f'-Balanced solution found in {time.process_time()-start}')
|
|
for builder, sectors in solution_list.items():
|
|
for sector in sectors:
|
|
assign_sector(sector, builder, polarized_sectors, global_pole)
|
|
|
|
|
|
def find_forced_connections(dungeon_map, candidate_list, polarized_sectors):
|
|
test_set = list(candidate_list)
|
|
other_sectors = [x for x in polarized_sectors if x not in candidate_list]
|
|
dungeon_hooks = defaultdict(int)
|
|
for name, builder in dungeon_map.items():
|
|
d_mag = sum_hook_magnitude(builder.sectors)
|
|
for val in Hook:
|
|
dungeon_hooks[val] += d_mag[val.value]
|
|
queue = deque(candidate_list)
|
|
while queue:
|
|
candidate = queue.popleft()
|
|
c_mag = candidate.hook_magnitude()
|
|
other_candidates = [x for x in candidate_list if x != candidate]
|
|
for val in Hook:
|
|
if c_mag[val.value] > 0:
|
|
opp = opposite_h_type(val)
|
|
o_val = opp.value
|
|
if sum_hook_magnitude(other_candidates)[o_val] == 0 and dungeon_hooks[opp] == 0 and not valid_self(c_mag, val, opp):
|
|
forced_sector = []
|
|
for sec in other_sectors:
|
|
if sec.hook_magnitude()[o_val] > 0:
|
|
forced_sector.append(sec)
|
|
if len(forced_sector) > 1:
|
|
break
|
|
if len(forced_sector) == 1:
|
|
test_set.append(forced_sector[0])
|
|
return test_set
|
|
|
|
|
|
def valid_self(c_mag, val, opp):
|
|
if val == Hook.Stairs:
|
|
return c_mag[val.value] > 2
|
|
else:
|
|
return c_mag[opp.value] > 0 and sum(c_mag) > 2
|
|
|
|
|
|
def ensure_test_set_connectedness(test_set, builder, polarized_sectors, dungeon_map, global_pole):
|
|
test_copy = list(test_set)
|
|
while not valid_connected_assignment(builder, test_copy):
|
|
dummy_builder = DungeonBuilder("Dummy Builder for " + builder.name)
|
|
dummy_builder.sectors = builder.sectors + test_copy
|
|
possibles = [x for x in polarized_sectors if x not in test_copy]
|
|
candidates = find_connected_candidates(possibles)
|
|
valid, sector = False, None
|
|
while not valid:
|
|
if len(candidates) == 0:
|
|
return False
|
|
sector = random.choice(candidates)
|
|
candidates.remove(sector)
|
|
t2 = test_copy+[sector]
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder, t2) and valid_branch_only(builder, t2)
|
|
test_copy.append(sector)
|
|
dummy_builder.sectors = builder.sectors + test_copy
|
|
test_set[:] = test_copy
|
|
return True
|
|
|
|
|
|
def calc_total_charge(dungeon_map, builders, sector_lists):
|
|
polarity_list = [x.polarity() for x in dungeon_map.values() if x not in builders]
|
|
for i, sectors in enumerate(sector_lists):
|
|
builder = builders[i]
|
|
polarity = builder.polarity() + sum_polarity(sectors)
|
|
polarity_list.append(polarity)
|
|
return sum([x.charge() for x in polarity_list])
|
|
|
|
|
|
class GlobalPolarity:
|
|
|
|
def __init__(self, candidate_sectors):
|
|
self.positives = [0, 0, 0]
|
|
self.negatives = [0, 0, 0]
|
|
self.evens = 0
|
|
self.odds = 0
|
|
for sector in candidate_sectors:
|
|
pol = sector.polarity()
|
|
if pol.charge() % 2 == 0:
|
|
self.evens += 1
|
|
else:
|
|
self.odds += 1
|
|
for slot in PolSlot:
|
|
if pol.vector[slot.value] < 0:
|
|
self.negatives[slot.value] += -pol.vector[slot.value]
|
|
elif pol.vector[slot.value] > 0:
|
|
self.positives[slot.value] += pol.vector[slot.value]
|
|
|
|
def copy(self):
|
|
gp = GlobalPolarity([])
|
|
gp.positives = self.positives.copy()
|
|
gp.negatives = self.negatives.copy()
|
|
gp.evens = self.evens
|
|
gp.odds = self.odds
|
|
return gp
|
|
|
|
def is_valid(self, dungeon_map):
|
|
polarities = [x.polarity() for x in dungeon_map.values()]
|
|
return self._check_parity(polarities) and self._is_valid_polarities(polarities)
|
|
|
|
def _check_parity(self, polarities):
|
|
local_evens = 0
|
|
local_odds = 0
|
|
for pol in polarities:
|
|
if pol.charge() % 2 == 0:
|
|
local_evens += 1
|
|
else:
|
|
local_odds += 1
|
|
if local_odds > self.odds:
|
|
return False
|
|
return True
|
|
|
|
def _is_valid_polarities(self, polarities):
|
|
positives = self.positives.copy()
|
|
negatives = self.negatives.copy()
|
|
for polarity in polarities:
|
|
for slot in PolSlot:
|
|
if polarity[slot.value] > 0 and slot != PolSlot.Stairs:
|
|
if negatives[slot.value] >= polarity[slot.value]:
|
|
negatives[slot.value] -= polarity[slot.value]
|
|
else:
|
|
return False
|
|
elif polarity[slot.value] < 0 and slot != PolSlot.Stairs:
|
|
if positives[slot.value] >= -polarity[slot.value]:
|
|
positives[slot.value] += polarity[slot.value]
|
|
else:
|
|
return False
|
|
elif slot == PolSlot.Stairs:
|
|
if positives[slot.value] >= polarity[slot.value]:
|
|
positives[slot.value] -= polarity[slot.value]
|
|
else:
|
|
return False
|
|
return True
|
|
|
|
def consume(self, sector):
|
|
polarity = sector.polarity()
|
|
if polarity.charge() % 2 == 0:
|
|
self.evens -= 1
|
|
else:
|
|
self.odds -= 1
|
|
for slot in PolSlot:
|
|
if polarity[slot.value] > 0 and slot != PolSlot.Stairs:
|
|
if self.positives[slot.value] >= polarity[slot.value]:
|
|
self.positives[slot.value] -= polarity[slot.value]
|
|
else:
|
|
raise GenerationException('Invalid assignment of %s' % sector.name)
|
|
elif polarity[slot.value] < 0 and slot != PolSlot.Stairs:
|
|
if self.negatives[slot.value] >= -polarity[slot.value]:
|
|
self.negatives[slot.value] += polarity[slot.value]
|
|
else:
|
|
raise GenerationException('Invalid assignment of %s' % sector.name)
|
|
elif slot == PolSlot.Stairs:
|
|
if self.positives[slot.value] >= polarity[slot.value]:
|
|
self.positives[slot.value] -= polarity[slot.value]
|
|
else:
|
|
raise GenerationException('Invalid assignment of %s' % sector.name)
|
|
|
|
def is_valid_choice(self, dungeon_map, builder, sectors):
|
|
proposal = self.copy()
|
|
non_neutral_polarities = [x.polarity() for x in dungeon_map.values() if not x.polarity().is_neutral() and x != builder]
|
|
current_polarity = builder.polarity() + sum_polarity(sectors)
|
|
non_neutral_polarities.append(current_polarity)
|
|
for sector in sectors:
|
|
proposal.consume(sector)
|
|
return proposal._check_parity(non_neutral_polarities) and proposal._is_valid_polarities(non_neutral_polarities)
|
|
|
|
def is_valid_multi_choice(self, dungeon_map, builders, sector_lists):
|
|
proposal = self.copy()
|
|
non_neutral_polarities = [x.polarity() for x in dungeon_map.values() if not x.polarity().is_neutral()
|
|
and x not in builders]
|
|
for i, sectors in enumerate(sector_lists):
|
|
builder = builders[i]
|
|
current_polarity = builder.polarity() + sum_polarity(sectors)
|
|
non_neutral_polarities.append(current_polarity)
|
|
for sector in sectors:
|
|
proposal.consume(sector)
|
|
return proposal._check_parity(non_neutral_polarities) and proposal._is_valid_polarities(non_neutral_polarities)
|
|
|
|
def is_valid_multi_choice_2(self, dungeon_map, builders, sector_dict):
|
|
proposal = self.copy()
|
|
non_neutral_polarities = [x.polarity() for x in dungeon_map.values() if not x.polarity().is_neutral()
|
|
and x not in builders]
|
|
for builder, sectors in sector_dict.items():
|
|
current_polarity = builder.polarity() + sum_polarity(sectors)
|
|
non_neutral_polarities.append(current_polarity)
|
|
for sector in sectors:
|
|
proposal.consume(sector)
|
|
return proposal._check_parity(non_neutral_polarities) and proposal._is_valid_polarities(non_neutral_polarities)
|
|
|
|
# def check_odd_polarities(self, candidate_sectors, dungeon_map):
|
|
# odd_candidates = [x for x in candidate_sectors if x.polarity().charge() % 2 != 0]
|
|
# odd_map = {n: x for (n, x) in dungeon_map.items() if sum_polarity(x.sectors).charge() % 2 != 0}
|
|
# gp = GlobalPolarity(odd_candidates)
|
|
# return gp.is_valid(odd_map)
|
|
|
|
|
|
def find_connection_candidates(mag_needed, sector_pool):
|
|
candidates = []
|
|
for sector in sector_pool:
|
|
if sector.branching_factor() < 2:
|
|
continue
|
|
mag = sector.magnitude()
|
|
matches = False
|
|
for slot, match_slot in mag_needed.items():
|
|
if mag[slot.value] > 0:
|
|
for i in PolSlot:
|
|
if i in match_slot and mag[i.value] > 0:
|
|
matches = True
|
|
break
|
|
if matches:
|
|
candidates.append(sector)
|
|
return candidates
|
|
|
|
|
|
def find_simple_branching_candidates(builder, sector_pool):
|
|
candidates = defaultdict(list)
|
|
charges = defaultdict(list)
|
|
outflow_needed = builder.dead_ends + builder.forced_loops * 2 > builder.branches + builder.allowance
|
|
total_needed = builder.dead_ends + builder.forced_loops * 2 - builder.branches + builder.allowance
|
|
original_lack = builder.total_conn_lack
|
|
best_lack = original_lack
|
|
for sector in sector_pool:
|
|
if outflow_needed and sector.branching_factor() <= 2:
|
|
continue
|
|
calc_sector_balance(sector)
|
|
ttl_lack = 0
|
|
for hook in Hook:
|
|
lack = builder.conn_balance[hook] + sector.conn_balance[hook]
|
|
if lack < 0:
|
|
ttl_lack += -lack
|
|
forced_loops = calc_forced_loops(builder.sectors + [sector])
|
|
net_outflow = builder.dead_ends + forced_loops * 2 + sector.dead_ends() - builder.branches - builder.allowance - sector.branches()
|
|
valid_branches = net_outflow < total_needed
|
|
if valid_branches and (ttl_lack < original_lack or original_lack >= 0):
|
|
candidates[ttl_lack].append(sector)
|
|
charges[ttl_lack].append((builder.polarity()+sector.polarity()).charge())
|
|
if ttl_lack < best_lack:
|
|
best_lack = ttl_lack
|
|
if best_lack == original_lack and not outflow_needed:
|
|
raise GenerationException('These candidates may not help at all')
|
|
if len(candidates[best_lack]) <= 0:
|
|
raise GenerationException('Nothing can fix the simple branching issue. Panic ensues.')
|
|
return candidates[best_lack], charges[best_lack]
|
|
|
|
|
|
def calc_sector_balance(sector): # todo: move to base class?
|
|
if sector.conn_balance is None:
|
|
sector.conn_balance = defaultdict(int)
|
|
for door in sector.outstanding_doors:
|
|
if door.blocked or door.dead or sector.branching_factor() <= 1:
|
|
sector.conn_balance[hook_from_door(door)] -= 1
|
|
else:
|
|
sector.conn_balance[hanger_from_door(door)] += 1
|
|
|
|
|
|
def find_odd_sectors(grouped_candidates):
|
|
return [x for x in grouped_candidates if sum_polarity(x).charge() % 2 != 0]
|
|
|
|
|
|
# This is related to the perfect sum problem in CS
|
|
# * Best algorithm so far - db for dynamic programming
|
|
# * Keeps track of unique deviations from neutral in the index
|
|
# * Another assumption is that solutions that take fewer sector are more ideal
|
|
# * When attempting to add depth and there are no more possibilities, this raises an Exception
|
|
# * Each depth should be checked before asking for another one
|
|
# An alterative approach would be to trim the db after deciding the candidate at the current depth will be
|
|
# part of the propsoal
|
|
def find_exact_neutralizing_candidates_parallel_db(builders, proposal, avail_sectors, current_depth):
|
|
candidate_map = defaultdict(list)
|
|
polarity_map = {}
|
|
for builder in builders:
|
|
polarity_map[builder] = builder.polarity() + sum_polarity(proposal[builder])
|
|
finished = False
|
|
db, index = create_db_for_depth(current_depth, avail_sectors)
|
|
while not finished:
|
|
depth_map = db[current_depth]
|
|
for builder in builders:
|
|
target = polarity_map[builder].complement()
|
|
if target in depth_map.keys():
|
|
finished = True
|
|
candidate_map[builder].extend(depth_map[target].keys())
|
|
if finished:
|
|
for builder in list(candidate_map.keys()):
|
|
try:
|
|
candidate_map[builder] = weed_candidates(builder, {0: candidate_map[builder]}, 0)
|
|
except NeutralizingException:
|
|
del candidate_map[builder]
|
|
if len(candidate_map) == 0:
|
|
finished = False
|
|
if not finished:
|
|
current_depth += 1
|
|
add_depth_to_db(db, index, current_depth, avail_sectors)
|
|
return candidate_map, current_depth
|
|
|
|
|
|
def create_db_for_depth(depth, avail_sectors):
|
|
db = {0: {Polarity(): {OrderedFrozenSet(): None}}}
|
|
db_index = {Polarity()}
|
|
for i in range(1, depth+1):
|
|
add_depth_to_db(db, db_index, i, avail_sectors)
|
|
return db, db_index
|
|
|
|
|
|
def add_depth_to_db(db, db_index, i, avail_sectors):
|
|
previous = db[i-1]
|
|
depth_map = defaultdict(dict)
|
|
index_additions = set()
|
|
for sector in avail_sectors:
|
|
sector_set = {sector}
|
|
sector_pol = sector.polarity()
|
|
for polarity, choices in previous.items():
|
|
combo_pol = sector_pol + polarity
|
|
if combo_pol not in db_index:
|
|
index_additions.add(combo_pol)
|
|
for choice in choices:
|
|
if sector in choice.frozen_set:
|
|
continue
|
|
new_set = choice.new_with_element(sector_set)
|
|
depth_map[combo_pol][new_set] = None
|
|
for addition in index_additions:
|
|
if len(depth_map[addition]) > 0:
|
|
db_index.add(addition)
|
|
else:
|
|
del depth_map[addition]
|
|
if len(depth_map) == 0:
|
|
raise NeutralizingException('There is not a solution for this particular combination. Crystal switch issue?') # restart required
|
|
db[i] = depth_map
|
|
|
|
|
|
class OrderedFrozenSet:
|
|
|
|
def __init__(self):
|
|
self.frozen_set = frozenset()
|
|
self.order = []
|
|
|
|
def __eq__(self, other):
|
|
return self.frozen_set == other.frozen_set
|
|
|
|
def __hash__(self):
|
|
return hash(self.frozen_set)
|
|
|
|
def __iter__(self):
|
|
return self.order.__iter__()
|
|
|
|
def __len__(self):
|
|
return len(self.order)
|
|
|
|
def new_with_element(self, elements):
|
|
ret = OrderedFrozenSet()
|
|
ret.frozen_set = frozenset(self.frozen_set | elements)
|
|
ret.order = list(self.order)
|
|
ret.order.extend(elements)
|
|
return ret
|
|
|
|
|
|
# this could be re-worked for the more complete solution
|
|
# i'm not sure it does a whole lot now
|
|
def weed_candidates(builder, candidates, best_charge):
|
|
official_cand = []
|
|
while len(official_cand) == 0:
|
|
if len(candidates.keys()) == 0:
|
|
raise NeutralizingException('Cross Dungeon Builder: Weeded out all candidates %s' % builder.name)
|
|
while best_charge not in candidates.keys():
|
|
best_charge += 1
|
|
candidate_list = candidates.pop(best_charge)
|
|
best_lack = None
|
|
for cand in candidate_list:
|
|
ttl_deads = 0
|
|
ttl_branches = 0
|
|
for sector in cand:
|
|
calc_sector_balance(sector)
|
|
ttl_deads += sector.dead_ends()
|
|
ttl_branches += sector.branches()
|
|
ttl_lack = 0
|
|
ttl_balance = 0
|
|
for hook in Hook:
|
|
bal = 0
|
|
for sector in cand:
|
|
bal += sector.conn_balance[hook]
|
|
lack = builder.conn_balance[hook] + bal
|
|
ttl_balance += lack
|
|
if lack < 0:
|
|
ttl_lack += -lack
|
|
forced_loops = calc_forced_loops(builder.sectors + list(cand))
|
|
if ttl_balance >= 0 and builder.dead_ends + ttl_deads + forced_loops * 2 <= builder.branches + ttl_branches + builder.allowance:
|
|
if best_lack is None or ttl_lack < best_lack:
|
|
best_lack = ttl_lack
|
|
official_cand = [cand]
|
|
elif ttl_lack == best_lack:
|
|
official_cand.append(cand)
|
|
|
|
# choose from among those that use less
|
|
best_len = None
|
|
cand_len = []
|
|
for cand in official_cand:
|
|
size = len(cand)
|
|
if best_len is None or size < best_len:
|
|
best_len = size
|
|
cand_len = [cand]
|
|
elif size == best_len:
|
|
cand_len.append(cand)
|
|
return cand_len
|
|
|
|
|
|
def find_branching_candidates(builder, neutral_choices, builder_info):
|
|
candidates = []
|
|
for choice in neutral_choices:
|
|
resolved, problem_list, package = check_for_valid_layout(builder, choice, builder_info)
|
|
if resolved:
|
|
candidates.append((choice, package))
|
|
return candidates
|
|
|
|
|
|
def find_connected_candidates(sector_pool):
|
|
candidates = []
|
|
for sector in sector_pool:
|
|
if sector.adj_outflow() >= 2:
|
|
candidates.append(sector)
|
|
return candidates
|
|
|
|
|
|
def neutralize_the_rest(sector_pool):
|
|
neutral_choices = []
|
|
main_pool = list(sector_pool)
|
|
failed_pool = []
|
|
r_size = 1
|
|
while len(main_pool) > 0 or len(failed_pool) > 0:
|
|
if len(main_pool) <= r_size:
|
|
main_pool.extend(failed_pool)
|
|
failed_pool.clear()
|
|
r_size += 1
|
|
candidate = random.choice(main_pool)
|
|
main_pool.remove(candidate)
|
|
if r_size > len(main_pool):
|
|
raise GenerationException("Cross Dungeon Builder: no more neutral pairings possible")
|
|
combinations = ncr(len(main_pool), r_size)
|
|
itr = 0
|
|
done = False
|
|
while not done:
|
|
ttl_polarity = candidate.polarity()
|
|
choice_set = kth_combination(itr, main_pool, r_size)
|
|
for choice in choice_set:
|
|
ttl_polarity += choice.polarity()
|
|
if ttl_polarity.is_neutral():
|
|
choice_set.append(candidate)
|
|
neutral_choices.append(choice_set)
|
|
main_pool = [x for x in main_pool if x not in choice_set]
|
|
failed_pool = [x for x in failed_pool if x not in choice_set]
|
|
done = True
|
|
else:
|
|
itr += 1
|
|
if itr >= combinations:
|
|
failed_pool.append(candidate)
|
|
done = True
|
|
return neutral_choices
|
|
|
|
|
|
# doesn't force a grouping when all in the found_list comes from the same sector
|
|
def find_forced_groupings(sector_pool, dungeon_map):
|
|
dungeon_hooks = {}
|
|
for name, builder in dungeon_map.items():
|
|
dungeon_hooks[name] = categorize_groupings(builder.sectors)
|
|
groupings = []
|
|
queue = deque(sector_pool)
|
|
skips = set()
|
|
while len(queue) > 0:
|
|
grouping = queue.popleft()
|
|
is_list = isinstance(grouping, List)
|
|
if not is_list and grouping in skips:
|
|
continue
|
|
grouping = grouping if is_list else [grouping]
|
|
hook_categories = categorize_groupings(grouping)
|
|
force_found = False
|
|
for val in Hook:
|
|
if val in hook_categories.keys():
|
|
required_doors, flexible_doors = hook_categories[val]
|
|
if len(required_doors) >= 1:
|
|
opp = opposite_h_type(val)
|
|
found_list = []
|
|
if opp in hook_categories.keys() and len(hook_categories[opp][1]) > 0:
|
|
found_list.extend(hook_categories[opp][1])
|
|
for name, hooks in dungeon_hooks.items():
|
|
if opp in hooks.keys() and len(hooks[opp][1]) > 0:
|
|
found_list.extend(hooks[opp][1])
|
|
other_sectors = [x for x in sector_pool if x not in grouping]
|
|
other_sector_cats = categorize_groupings(other_sectors)
|
|
if opp in other_sector_cats.keys() and len(other_sector_cats[opp][1]) > 0:
|
|
found_list.extend(other_sector_cats[opp][1])
|
|
if len(required_doors) == len(found_list):
|
|
forced_sectors = []
|
|
for sec in other_sectors:
|
|
cats = categorize_groupings([sec])
|
|
if opp in cats.keys() and len(cats[opp][1]) > 0:
|
|
forced_sectors.append(sec)
|
|
if len(forced_sectors) > 0:
|
|
grouping.extend(forced_sectors)
|
|
skips.update(forced_sectors)
|
|
merge_groups = []
|
|
for group in groupings:
|
|
for sector in group:
|
|
if sector in forced_sectors:
|
|
merge_groups.append(group)
|
|
for merge in merge_groups:
|
|
grouping = list(set(grouping).union(set(merge)))
|
|
groupings.remove(merge)
|
|
queue.append(grouping)
|
|
force_found = True
|
|
elif len(flexible_doors) == 1:
|
|
opp = opposite_h_type(val)
|
|
found_list = []
|
|
if opp in hook_categories.keys() and (len(hook_categories[opp][0]) > 0 or len(hook_categories[opp][1]) > 0):
|
|
found_list.extend(hook_categories[opp][0])
|
|
found_list.extend([x for x in hook_categories[opp][1] if x not in flexible_doors])
|
|
for name, hooks in dungeon_hooks.items():
|
|
if opp in hooks.keys() and (len(hooks[opp][0]) > 0 or len(hooks[opp][1]) > 0):
|
|
found_list.extend(hooks[opp][0])
|
|
found_list.extend(hooks[opp][1])
|
|
other_sectors = [x for x in sector_pool if x not in grouping]
|
|
other_sector_cats = categorize_groupings(other_sectors)
|
|
if opp in other_sector_cats.keys() and (len(other_sector_cats[opp][0]) > 0 or len(other_sector_cats[opp][1]) > 0):
|
|
found_list.extend(other_sector_cats[opp][0])
|
|
found_list.extend(other_sector_cats[opp][1])
|
|
if len(found_list) == 1:
|
|
forced_sectors = []
|
|
for sec in other_sectors:
|
|
cats = categorize_groupings([sec])
|
|
if opp in cats.keys() and (len(cats[opp][0]) > 0 or len(cats[opp][1]) > 0):
|
|
forced_sectors.append(sec)
|
|
if len(forced_sectors) > 0:
|
|
grouping.extend(forced_sectors)
|
|
skips.update(forced_sectors)
|
|
merge_groups = []
|
|
for group in groupings:
|
|
for sector in group:
|
|
if sector in forced_sectors:
|
|
merge_groups.append(group)
|
|
for merge in merge_groups:
|
|
grouping += merge
|
|
groupings.remove(merge)
|
|
queue.append(grouping)
|
|
force_found = True
|
|
if force_found:
|
|
break
|
|
if not force_found:
|
|
groupings.append(grouping)
|
|
return groupings
|
|
|
|
|
|
def categorize_groupings(sectors):
|
|
hook_categories = {}
|
|
for sector in sectors:
|
|
for door in sector.outstanding_doors:
|
|
hook = hook_from_door(door)
|
|
if hook not in hook_categories.keys():
|
|
hook_categories[hook] = ([], [])
|
|
if door.blocked or door.dead:
|
|
hook_categories[hook][0].append(door)
|
|
else:
|
|
hook_categories[hook][1].append(door)
|
|
return hook_categories
|
|
|
|
|
|
def valid_assignment(builder, sector_list, builder_info):
|
|
if not valid_entrance(builder, sector_list, builder_info):
|
|
return False, None
|
|
if not valid_c_switch(builder, sector_list):
|
|
return False, None
|
|
if not valid_polarized_assignment(builder, sector_list):
|
|
return False, None
|
|
resolved, problems, package = check_for_valid_layout(builder, sector_list, builder_info)
|
|
return resolved, package
|
|
|
|
|
|
def valid_entrance(builder, sector_list, builder_info):
|
|
is_dead_end = False
|
|
if len(builder.sectors) == 0:
|
|
is_dead_end = True
|
|
else:
|
|
entrances, splits, c_tuple, world, player = builder_info
|
|
if builder.name not in entrances.keys():
|
|
name_parts = builder.name.rsplit(' ', 1)
|
|
entrance_list = splits[name_parts[0]][name_parts[1]]
|
|
entrances = []
|
|
for sector in builder.sectors:
|
|
if sector.is_entrance_sector():
|
|
sector.region_set()
|
|
entrances.append(sector)
|
|
all_dead = True
|
|
for sector in entrances:
|
|
for region in entrance_list:
|
|
if region in sector.region_set():
|
|
portal = next((x for x in world.dungeon_portals[player] if x.door.entrance.parent_region.name == region), None)
|
|
if portal and not portal.deadEnd:
|
|
all_dead = False
|
|
break
|
|
if not all_dead:
|
|
break
|
|
is_dead_end = all_dead
|
|
return len(sector_list) == 0 if is_dead_end else True
|
|
|
|
|
|
def valid_c_switch(builder, sector_list):
|
|
if builder.c_switch_present:
|
|
return True
|
|
for sector in sector_list:
|
|
if sector.c_switch:
|
|
return True
|
|
if builder.c_switch_required:
|
|
return False
|
|
for sector in sector_list:
|
|
if sector.blue_barrier:
|
|
return False
|
|
return True
|
|
|
|
|
|
def valid_connected_assignment(builder, sector_list):
|
|
full_list = sector_list + builder.sectors
|
|
if len(full_list) == 1 and sum_magnitude(full_list) == [0, 0, 0]:
|
|
return True
|
|
for sector in full_list:
|
|
if sector.is_entrance_sector():
|
|
continue
|
|
others = [x for x in full_list if x != sector]
|
|
other_mag = sum_magnitude(others)
|
|
sector_mag = sector.magnitude()
|
|
hookable = False
|
|
for i in range(len(sector_mag)):
|
|
if sector_mag[i] > 0 and other_mag[i] > 0:
|
|
hookable = True
|
|
if not hookable:
|
|
return False
|
|
return True
|
|
|
|
|
|
def valid_branch_assignment(builder, sector_list):
|
|
if not valid_connected_assignment(builder, sector_list):
|
|
return False
|
|
return valid_branch_only(builder, sector_list)
|
|
|
|
|
|
def valid_branch_only(builder, sector_list):
|
|
forced_loops = calc_forced_loops(builder.sectors + sector_list)
|
|
ttl_deads = 0
|
|
ttl_branches = 0
|
|
for s in sector_list:
|
|
# calc_sector_balance(sector) # do I want to check lack here? see weed_candidates
|
|
ttl_deads += s.dead_ends()
|
|
ttl_branches += s.branches()
|
|
return builder.dead_ends + ttl_deads + forced_loops * 2 <= builder.branches + ttl_branches + builder.allowance
|
|
|
|
|
|
def valid_polarized_assignment(builder, sector_list):
|
|
if not valid_branch_assignment(builder, sector_list):
|
|
return False
|
|
return (sum_polarity(sector_list) + sum_polarity(builder.sectors)).is_neutral()
|
|
|
|
|
|
def assign_the_rest(dungeon_map, neutral_sectors, global_pole, builder_info):
|
|
comb_w_replace = len(dungeon_map) ** len(neutral_sectors)
|
|
combinations = None
|
|
if comb_w_replace <= 1000:
|
|
combinations = list(itertools.product(dungeon_map.keys(), repeat=len(neutral_sectors)))
|
|
random.shuffle(combinations)
|
|
tries = 0
|
|
while len(neutral_sectors) > 0:
|
|
if tries > 1000 or (combinations and tries >= len(combinations)):
|
|
raise GenerationException('No valid assignment found for "neutral" sectors. Ref: %s' % next(iter(dungeon_map.keys())))
|
|
# sector_list = list(neutral_sectors)
|
|
if combinations:
|
|
choices = combinations[tries]
|
|
else:
|
|
choices = random.choices(list(dungeon_map.keys()), k=len(neutral_sectors))
|
|
neutral_sector_list = list(neutral_sectors)
|
|
chosen_sectors = defaultdict(list)
|
|
for i, choice in enumerate(choices):
|
|
chosen_sectors[choice].append(neutral_sector_list[i])
|
|
all_valid, package_map = True, {}
|
|
for name, sector_list in chosen_sectors.items():
|
|
flag, package = valid_assignment(dungeon_map[name], sector_list, builder_info)
|
|
if not flag:
|
|
all_valid = False
|
|
break
|
|
if package:
|
|
package_map[dungeon_map[name]] = package
|
|
if all_valid:
|
|
for name, sector_list in chosen_sectors.items():
|
|
builder = dungeon_map[name]
|
|
for sector in sector_list:
|
|
assign_sector(sector, builder, neutral_sectors, global_pole)
|
|
if builder in package_map:
|
|
builder.throne_door, builder.throne_sector, builder.chosen_lobby = package_map[builder]
|
|
tries += 1
|
|
|
|
|
|
def split_dungeon_builder(builder, split_list, builder_info):
|
|
ents, splits, c_tuple, world, player = builder_info
|
|
if builder.split_dungeon_map and len(builder.exception_list) == 0:
|
|
for name, proposal in builder.valid_proposal.items():
|
|
builder.split_dungeon_map[name].valid_proposal = proposal
|
|
if builder.name == 'Hyrule Castle':
|
|
builder.chosen_lobby.outstanding_doors.remove(builder.throne_door)
|
|
builder.throne_sector.outstanding_doors.remove(world.get_door('Hyrule Castle Throne Room N', player))
|
|
return builder.split_dungeon_map # we made this earlier in gen, just use it
|
|
|
|
attempts, comb_w_replace, merge_attempt, merge_limit = 0, None, 0, len(split_list) - 1
|
|
while attempts < 5: # does not solve coin flips 3% of the time
|
|
try:
|
|
candidate_sectors = dict.fromkeys(builder.sectors)
|
|
if builder.name == 'Hyrule Castle':
|
|
throne_sector = find_sector('Hyrule Castle Throne Room', candidate_sectors)
|
|
chosen_lobbies = {r_name for x in split_list.values() for r_name in x}
|
|
choices = {}
|
|
for sector in candidate_sectors:
|
|
if sector.adj_outflow() > 1 and sector != throne_sector:
|
|
for door in sector.outstanding_doors:
|
|
if door.direction == Direction.South and door.entrance.parent_region not in chosen_lobbies:
|
|
choices[door] = sector
|
|
chosen_door = random.choice(list(choices.keys()))
|
|
split_list['Sewers'].append(chosen_door.entrance.parent_region.name)
|
|
choices[chosen_door].outstanding_doors.remove(chosen_door)
|
|
builder.throne_door = chosen_door
|
|
builder.throne_sector = throne_sector
|
|
builder.chosen_lobby = choices[chosen_door]
|
|
throne_sector.outstanding_doors.remove(world.get_door('Hyrule Castle Throne Room N', player))
|
|
|
|
global_pole = GlobalPolarity(candidate_sectors)
|
|
dungeon_map, sub_builder, merge_keys = {}, None, []
|
|
if merge_attempt > 0:
|
|
candidates = []
|
|
for name, split_entrances in split_list.items():
|
|
if len(split_entrances) > 1:
|
|
candidates.append(name)
|
|
continue
|
|
elif len(split_entrances) <= 0:
|
|
continue
|
|
r_name = split_entrances[0]
|
|
p = next((x for x in world.dungeon_portals[player] if x.door.entrance.parent_region.name == r_name), None)
|
|
if p and not p.deadEnd:
|
|
candidates.append(name)
|
|
merge_keys = random.sample(candidates, merge_attempt+1) if len(candidates) >= merge_attempt+1 else []
|
|
for name, split_entrances in split_list.items():
|
|
key = builder.name + ' ' + name
|
|
if merge_keys and name in merge_keys:
|
|
other_keys = [builder.name + ' ' + x for x in merge_keys if x != name]
|
|
other_key = next((x for x in other_keys if x in dungeon_map), None)
|
|
if other_key:
|
|
key = other_key
|
|
sub_builder = dungeon_map[other_key]
|
|
sub_builder.all_entrances.extend(split_entrances)
|
|
if key not in dungeon_map:
|
|
dungeon_map[key] = sub_builder = DungeonBuilder(key)
|
|
sub_builder.split_flag = True
|
|
sub_builder.all_entrances = list(split_entrances)
|
|
for r_name in split_entrances:
|
|
assign_sector(find_sector(r_name, candidate_sectors), sub_builder, candidate_sectors, global_pole)
|
|
if builder.name == 'Hyrule Castle':
|
|
assign_sector(find_sector('Hyrule Castle Throne Room', candidate_sectors),
|
|
dungeon_map['Hyrule Castle Dungeon'], candidate_sectors, global_pole)
|
|
assign_sector(find_sector('Hyrule Dungeon Cellblock', candidate_sectors),
|
|
dungeon_map['Hyrule Castle Dungeon'], candidate_sectors, global_pole)
|
|
dungeon_map['Hyrule Castle Dungeon'].throne_door = world.get_door('Hyrule Castle Throne Room N', player)
|
|
dungeon_map['Hyrule Castle Sewers'].sewers_access = builder.throne_door
|
|
if len(candidate_sectors) == 0:
|
|
return dungeon_map
|
|
comb_w_replace = len(dungeon_map) ** len(candidate_sectors)
|
|
return balance_split(candidate_sectors, dungeon_map, global_pole, builder_info)
|
|
except (GenerationException, NeutralizingException):
|
|
if comb_w_replace and comb_w_replace <= 10000 and not builder.throne_door:
|
|
attempts += 5 # all the combinations were tried already, no use repeating
|
|
else:
|
|
attempts += 1
|
|
if builder.throne_door:
|
|
previous = find_sector(builder.throne_door.entrance.parent_region.name, builder.sectors)
|
|
previous.outstanding_doors.append(builder.throne_door)
|
|
builder.throne_sector.outstanding_doors.append(world.get_door('Hyrule Castle Throne Room N', player))
|
|
split_list['Sewers'].remove(builder.throne_door.entrance.parent_region.name)
|
|
builder.throne_door = None
|
|
if attempts >= 5 and merge_attempt < merge_limit and builder.name != 'Hyrule Castle':
|
|
merge_attempt, attempts = merge_attempt + 1, 0
|
|
|
|
raise GenerationException('Unable to resolve in 5 attempts')
|
|
|
|
|
|
def balance_split(candidate_sectors, dungeon_map, global_pole, builder_info):
|
|
dungeon_entrances, split_dungeon_entrances, connections_tuple, world, player = builder_info
|
|
for name, builder in dungeon_map.items():
|
|
calc_allowance_and_dead_ends(builder, connections_tuple, world, player)
|
|
comb_w_replace = len(dungeon_map) ** len(candidate_sectors)
|
|
if comb_w_replace <= 10000:
|
|
combinations = list(itertools.product(dungeon_map.keys(), repeat=len(candidate_sectors)))
|
|
random.shuffle(combinations)
|
|
tries = 0
|
|
while tries < len(combinations):
|
|
choices = combinations[tries]
|
|
main_sector_list = list(candidate_sectors)
|
|
chosen_sectors = defaultdict(list)
|
|
for i, choice in enumerate(choices):
|
|
chosen_sectors[choice].append(main_sector_list[i])
|
|
all_valid, package_map = True, {}
|
|
for name, builder in dungeon_map.items():
|
|
flag, package = valid_assignment(builder, chosen_sectors[name], builder_info)
|
|
if not flag:
|
|
all_valid = False
|
|
break
|
|
if package:
|
|
package_map[builder] = package
|
|
if all_valid:
|
|
for name, sector_list in chosen_sectors.items():
|
|
builder = dungeon_map[name]
|
|
for sector in sector_list:
|
|
assign_sector(sector, builder, candidate_sectors, global_pole)
|
|
if builder in package_map:
|
|
builder.throne_door, builder.throne_sector, builder.chosen_lobby = package_map[builder]
|
|
return dungeon_map
|
|
tries += 1
|
|
raise GenerationException('Split Dungeon Builder: Impossible dungeon. Ref %s' % next(iter(dungeon_map.keys())))
|
|
|
|
# categorize sectors
|
|
check_for_forced_dead_ends(dungeon_map, candidate_sectors, global_pole)
|
|
check_for_forced_assignments(dungeon_map, candidate_sectors, global_pole)
|
|
check_for_forced_crystal(dungeon_map, candidate_sectors, global_pole)
|
|
crystal_switches, crystal_barriers, neutral_sectors, polarized_sectors = categorize_sectors(candidate_sectors)
|
|
leftover = assign_crystal_switch_sectors(dungeon_map, crystal_switches, crystal_barriers,
|
|
global_pole, len(crystal_barriers) > 0)
|
|
ensure_crystal_switches_reachable(dungeon_map, leftover, polarized_sectors, crystal_barriers, global_pole)
|
|
for sector in leftover:
|
|
if sector.polarity().is_neutral():
|
|
neutral_sectors[sector] = None
|
|
else:
|
|
polarized_sectors[sector] = None
|
|
# blue barriers
|
|
assign_crystal_barrier_sectors(dungeon_map, crystal_barriers, global_pole)
|
|
# polarity:
|
|
assign_polarized_sectors(dungeon_map, polarized_sectors, global_pole, builder_info)
|
|
# the rest
|
|
assign_the_rest(dungeon_map, neutral_sectors, global_pole, builder_info)
|
|
return dungeon_map
|
|
|
|
|
|
def check_for_forced_dead_ends(dungeon_map, candidate_sectors, global_pole):
|
|
dead_end_sectors = [x for x in candidate_sectors if x.branching_factor() <= 1]
|
|
other_sectors = [x for x in candidate_sectors if x not in dead_end_sectors]
|
|
for name, builder in dungeon_map.items():
|
|
other_sectors += builder.sectors
|
|
other_magnitude = sum_hook_magnitude(other_sectors)
|
|
dead_cnt = [0] * len(Hook)
|
|
for sector in dead_end_sectors:
|
|
hook_mag = sector.hook_magnitude()
|
|
for hook in Hook:
|
|
if hook_mag[hook.value] != 0:
|
|
dead_cnt[hook.value] += 1
|
|
for hook in Hook:
|
|
opp = opposite_h_type(hook).value
|
|
if dead_cnt[hook.value] > other_magnitude[opp]:
|
|
raise GenerationException('Impossible to satisfy all these dead ends')
|
|
elif dead_cnt[hook.value] == other_magnitude[opp]:
|
|
candidates = [x for x in dead_end_sectors if x.hook_magnitude()[hook.value] > 0]
|
|
for sector in other_sectors:
|
|
if sector.hook_magnitude()[opp] > 0 and sector.is_entrance_sector() and sector.branching_factor() == 2:
|
|
builder = None
|
|
for b in dungeon_map.values():
|
|
if sector in b.sectors:
|
|
builder = b
|
|
break
|
|
valid, candidate_sector = False, None
|
|
while not valid:
|
|
if len(candidates) == 0:
|
|
raise GenerationException('Split Dungeon Builder: Bad dead end %s' % builder.name)
|
|
candidate_sector = random.choice(candidates)
|
|
candidates.remove(candidate_sector)
|
|
valid = global_pole.is_valid_choice(dungeon_map, builder, [candidate_sector]) and check_crystal(candidate_sector, sector)
|
|
assign_sector(candidate_sector, builder, candidate_sectors, global_pole)
|
|
builder.c_locked = True
|
|
|
|
|
|
def check_crystal(dead_end, entrance):
|
|
if dead_end.blue_barrier and not entrance.c_switch and not dead_end.c_switch:
|
|
return False
|
|
if entrance.blue_barrier and not entrance.c_switch and not dead_end.c_switch:
|
|
return False
|
|
return True
|
|
|
|
|
|
def check_for_forced_assignments(dungeon_map, candidate_sectors, global_pole):
|
|
done = False
|
|
while not done:
|
|
done = True
|
|
magnitude = sum_hook_magnitude(candidate_sectors)
|
|
dungeon_hooks = {}
|
|
for name, builder in dungeon_map.items():
|
|
dungeon_hooks[name] = sum_hook_magnitude(builder.sectors)
|
|
for val in Hook:
|
|
if magnitude[val.value] == 1:
|
|
forced_sector = None
|
|
for sec in candidate_sectors:
|
|
if sec.hook_magnitude()[val.value] > 0:
|
|
forced_sector = sec
|
|
break
|
|
opp = opposite_h_type(val).value
|
|
other_sectors = [x for x in candidate_sectors if x != forced_sector]
|
|
if sum_hook_magnitude(other_sectors)[opp] == 0:
|
|
found_hooks = []
|
|
for name, hooks in dungeon_hooks.items():
|
|
if hooks[opp] > 0 and not dungeon_map[name].c_locked:
|
|
found_hooks.append(name)
|
|
if len(found_hooks) == 1:
|
|
done = False
|
|
assign_sector(forced_sector, dungeon_map[found_hooks[0]], candidate_sectors, global_pole)
|
|
|
|
|
|
def check_for_forced_crystal(dungeon_map, candidate_sectors, global_pole):
|
|
for name, builder in dungeon_map.items():
|
|
if check_for_forced_crystal_single(builder, candidate_sectors):
|
|
builder.c_switch_required = True
|
|
|
|
|
|
def check_for_forced_crystal_single(builder, candidate_sectors):
|
|
builder_doors = defaultdict(dict)
|
|
for sector in builder.sectors:
|
|
for door in sector.outstanding_doors:
|
|
builder_doors[hook_from_door(door)][door] = sector
|
|
if len(builder_doors) == 0:
|
|
return False
|
|
candidate_doors = defaultdict(dict)
|
|
for sector in candidate_sectors:
|
|
for door in sector.outstanding_doors:
|
|
candidate_doors[hook_from_door(door)][door] = sector
|
|
for hook in builder_doors.keys():
|
|
for door in builder_doors[hook].keys():
|
|
opp = opposite_h_type(hook)
|
|
if opp in builder_doors.keys():
|
|
for d, sector in builder_doors[opp].items():
|
|
if d != door and (not sector.blue_barrier or sector.c_switch):
|
|
return False
|
|
for d, sector in candidate_doors[opp].items():
|
|
if not sector.blue_barrier or sector.c_switch:
|
|
return False
|
|
return True
|
|
|
|
|
|
def categorize_sectors(candidate_sectors):
|
|
crystal_switches = {}
|
|
crystal_barriers = {}
|
|
polarized_sectors = {}
|
|
neutral_sectors = {}
|
|
for sector in candidate_sectors:
|
|
if sector.c_switch:
|
|
crystal_switches[sector] = None
|
|
elif sector.blue_barrier:
|
|
crystal_barriers[sector] = None
|
|
elif sector.polarity().is_neutral():
|
|
neutral_sectors[sector] = None
|
|
else:
|
|
polarized_sectors[sector] = None
|
|
return crystal_switches, crystal_barriers, neutral_sectors, polarized_sectors
|
|
|
|
|
|
class NeutralizingException(Exception):
|
|
pass
|
|
|
|
|
|
class GenerationException(Exception):
|
|
pass
|
|
|
|
|
|
class DoorEquation:
|
|
|
|
def __init__(self, door):
|
|
self.door = door
|
|
self.cost = None, None
|
|
self.benefit = defaultdict(list)
|
|
self.required = False
|
|
self.access_id = None
|
|
self.c_switch = False
|
|
self.crystal_blocked = {}
|
|
self.entrance_flag = False
|
|
|
|
def copy(self):
|
|
eq = DoorEquation(self.door)
|
|
eq.cost = self.cost
|
|
for key, doors in self.benefit.items():
|
|
eq.benefit[key] = doors.copy()
|
|
eq.required = self.required
|
|
eq.c_switch = self.c_switch
|
|
eq.crystal_blocked = self.crystal_blocked.copy()
|
|
return eq
|
|
|
|
def total_cost(self):
|
|
return 0 if self.cost[0] is None else 1
|
|
|
|
def gross(self, current_access):
|
|
key, cost_door = self.cost
|
|
if key is None:
|
|
# todo: could just be Orange as well (multiple entrance case)
|
|
crystal_access = current_access.access_door[None]
|
|
else:
|
|
crystal_access = None
|
|
for match_door, crystal in current_access.outstanding_doors.items():
|
|
if hook_from_door(match_door) == key:
|
|
if crystal_access is None or current_access._better_crystal(crystal_access, crystal):
|
|
crystal_access = crystal
|
|
ttl = 0
|
|
for key, door_list in self.benefit.items():
|
|
for door in door_list:
|
|
if door in current_access.outstanding_doors.keys() or door in current_access.proposed_connections.keys():
|
|
continue
|
|
if door in self.crystal_blocked.keys() and not self.c_switch:
|
|
if crystal_access == CrystalBarrier.Either or crystal_access == self.crystal_blocked[door]:
|
|
ttl += 1
|
|
else:
|
|
ttl += 1
|
|
return ttl
|
|
|
|
def profit(self, current_access):
|
|
return self.gross(current_access) - self.total_cost()
|
|
|
|
def neutral(self):
|
|
key, door = self.cost
|
|
if key is not None and len(self.benefit[key]) <= 0:
|
|
return False
|
|
return True
|
|
|
|
def neutral_profit(self):
|
|
key, door = self.cost
|
|
if key is not None:
|
|
if len(self.benefit[key]) < 1:
|
|
return False
|
|
if len(self.benefit[key]) > 1:
|
|
return True
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def can_cover_cost(self, current_access):
|
|
key, door = self.cost
|
|
if key is not None and current_access[key] < 1:
|
|
return False
|
|
return True
|
|
|
|
|
|
class DungeonAccess:
|
|
|
|
def __init__(self):
|
|
self.access = defaultdict(int)
|
|
self.door_access = {} # door -> crystal
|
|
self.door_sector_map = {} # door -> original sector
|
|
self.outstanding_doors = {}
|
|
self.blocked_doors = {}
|
|
self.door_access[None] = CrystalBarrier.Orange
|
|
self.proposed_connections = {}
|
|
self.reached_doors = set()
|
|
|
|
def can_cover_equation(self, equation):
|
|
key, door = equation.cost
|
|
if key is None:
|
|
return True
|
|
return self.access[key] >= 1
|
|
|
|
def can_pay(self, key):
|
|
if key is None:
|
|
return True
|
|
return self.access[key] >= 1
|
|
|
|
def adjust_for_equation(self, equation, sector):
|
|
if equation.cost[0] is None:
|
|
original_crystal = self.door_access[None]
|
|
for key, door_list in equation.benefit.items():
|
|
self.access[key] += len(door_list)
|
|
for door in door_list:
|
|
# I can't think of an entrance sector that forces blue
|
|
crystal_state = CrystalBarrier.Either if equation.c_switch else original_crystal
|
|
if crystal_state == CrystalBarrier.Either:
|
|
self.door_access[None] = CrystalBarrier.Either
|
|
self.door_access[door] = crystal_state
|
|
self.door_sector_map[door] = sector
|
|
self.outstanding_doors[door] = crystal_state
|
|
self.reached_doors.add(door)
|
|
else:
|
|
key, door = equation.cost
|
|
self.access[key] -= 1
|
|
# find the a matching connection
|
|
best_door, best_crystal = None, None
|
|
for match_door, crystal in self.outstanding_doors.items():
|
|
if hook_from_door(match_door) == key:
|
|
if best_door is None or self._better_crystal(best_crystal, crystal):
|
|
best_door = match_door
|
|
best_crystal = crystal
|
|
if best_door is None:
|
|
raise Exception('Something went terribly wrong I think')
|
|
# for match_door, crystal in self.blocked_doors.items():
|
|
# if hook_from_door(match_door) == key:
|
|
# if best_door is None or self._better_crystal(best_crystal, crystal):
|
|
# best_door = match_door
|
|
# best_crystal = crystal
|
|
self.door_sector_map[door] = sector
|
|
self.door_access[door] = best_crystal
|
|
self.reached_doors.add(door)
|
|
self.proposed_connections[door] = best_door
|
|
self.proposed_connections[best_door] = door
|
|
if best_door in self.outstanding_doors.keys():
|
|
del self.outstanding_doors[best_door]
|
|
elif best_door in self.blocked_doors.keys():
|
|
del self.blocked_doors[best_door]
|
|
self.reached_doors.add(best_door)
|
|
|
|
# todo: backpropagate crystal access
|
|
if equation.c_switch or best_crystal == CrystalBarrier.Either:
|
|
# if not equation.door.blocked:
|
|
self.door_access[door] = CrystalBarrier.Either
|
|
self.door_access[best_door] = CrystalBarrier.Either
|
|
queue = deque([best_door, door])
|
|
visited = set()
|
|
while len(queue) > 0:
|
|
next_door = queue.popleft()
|
|
visited.add(next_door)
|
|
curr_sector = self.door_sector_map[next_door]
|
|
next_eq = None
|
|
for eq in curr_sector.equations:
|
|
if eq.door == next_door:
|
|
next_eq = eq
|
|
break
|
|
if next_eq.entrance_flag:
|
|
crystal_state = self.door_access[next_door]
|
|
self.door_access[None] = crystal_state
|
|
for eq in curr_sector.equations:
|
|
cand_door = eq.door
|
|
crystal_state = self.door_access[None]
|
|
if cand_door in next_eq.crystal_blocked.keys():
|
|
crystal_state = next_eq.crystal_blocked[cand_door]
|
|
if cand_door not in visited:
|
|
self.door_access[cand_door] = crystal_state
|
|
if not cand_door.blocked:
|
|
if cand_door in self.outstanding_doors.keys():
|
|
self.outstanding_doors[cand_door] = crystal_state
|
|
if cand_door in self.proposed_connections.keys():
|
|
partner_door = self.proposed_connections[cand_door]
|
|
self.door_access[partner_door] = crystal_state
|
|
if partner_door in self.outstanding_doors.keys():
|
|
self.outstanding_doors[partner_door] = crystal_state
|
|
if partner_door not in visited:
|
|
queue.append(partner_door)
|
|
else:
|
|
for key, door_list in next_eq.benefit.items():
|
|
for cand_door in door_list:
|
|
crystal_state = self.door_access[next_door]
|
|
if cand_door in next_eq.crystal_blocked.keys():
|
|
crystal_state = next_eq.crystal_blocked[cand_door]
|
|
if cand_door in self.blocked_doors.keys():
|
|
needed_crystal = self.blocked_doors[cand_door]
|
|
if meets_crystal_requirment(crystal_state, needed_crystal):
|
|
del self.blocked_doors[cand_door]
|
|
if cand_door != door:
|
|
self.access[key] += 1
|
|
self.outstanding_doors[cand_door] = crystal_state
|
|
self.door_access[cand_door] = crystal_state
|
|
self.reached_doors.add(cand_door)
|
|
if cand_door not in visited:
|
|
self.door_access[cand_door] = crystal_state
|
|
if not cand_door.blocked:
|
|
if cand_door in self.outstanding_doors.keys():
|
|
self.outstanding_doors[cand_door] = crystal_state
|
|
if cand_door in self.proposed_connections.keys():
|
|
partner_door = self.proposed_connections[cand_door]
|
|
self.door_access[partner_door] = crystal_state
|
|
if partner_door in self.outstanding_doors.keys():
|
|
self.outstanding_doors[partner_door] = crystal_state
|
|
queue.append(cand_door)
|
|
queue.append(partner_door)
|
|
|
|
for key, door_list in equation.benefit.items():
|
|
for door in door_list:
|
|
crystal_access = self.door_access[best_door]
|
|
can_access = True
|
|
if door in equation.crystal_blocked.keys():
|
|
if crystal_access == CrystalBarrier.Either or crystal_access == equation.crystal_blocked[door]:
|
|
crystal_access = equation.crystal_blocked[door]
|
|
else:
|
|
self.blocked_doors[door] = equation.crystal_blocked[door]
|
|
can_access = False
|
|
self.door_sector_map[door] = sector
|
|
if can_access and door not in self.reached_doors:
|
|
self.access[key] += 1
|
|
self.door_access[door] = crystal_access
|
|
self.outstanding_doors[door] = crystal_access
|
|
self.reached_doors.add(door)
|
|
|
|
def _better_crystal(self, current_champ, contender):
|
|
if current_champ == CrystalBarrier.Either:
|
|
return False
|
|
elif contender == CrystalBarrier.Either:
|
|
return True
|
|
elif current_champ == CrystalBarrier.Blue:
|
|
return False
|
|
elif contender == CrystalBarrier.Blue:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def identify_branching_issues(dungeon_map, builder_info):
|
|
unconnected_builders = {}
|
|
for name, builder in dungeon_map.items():
|
|
resolved, unreached_doors, package = check_for_valid_layout(builder, [], builder_info)
|
|
if not resolved:
|
|
unconnected_builders[name] = builder
|
|
for hook, door_list in unreached_doors.items():
|
|
builder.unfulfilled[hook] += len(door_list)
|
|
elif package:
|
|
builder.throne_door, builder.throne_sector, builder.chosen_lobby = package
|
|
return unconnected_builders
|
|
|
|
|
|
def check_for_valid_layout(builder, sector_list, builder_info):
|
|
dungeon_entrances, split_dungeon_entrances, c_tuple, world, player = builder_info
|
|
if builder.name in split_dungeon_entrances.keys():
|
|
try:
|
|
temp_builder = DungeonBuilder(builder.name)
|
|
for s in sector_list + builder.sectors:
|
|
assign_sector_helper(s, temp_builder)
|
|
split_list = split_dungeon_entrances[builder.name]
|
|
builder.split_dungeon_map = split_dungeon_builder(temp_builder, split_list, builder_info)
|
|
builder.valid_proposal = {}
|
|
possible_regions = set()
|
|
for portal in world.dungeon_portals[player]:
|
|
if not portal.destination and portal.name in dungeon_portals[builder.name]:
|
|
possible_regions.add(portal.door.entrance.parent_region.name)
|
|
if builder.name in dungeon_drops.keys() and (builder.name != 'Hyrule Castle'
|
|
or world.mode[player] != 'standard'):
|
|
possible_regions.update(dungeon_drops[builder.name])
|
|
independents = find_independent_entrances(possible_regions, world, player)
|
|
for name, split_build in builder.split_dungeon_map.items():
|
|
name_bits = name.split(" ")
|
|
orig_name = " ".join(name_bits[:-1])
|
|
entrance_regions = split_dungeon_entrances[orig_name][name_bits[-1]]
|
|
# todo: this is hardcoded information for random entrances
|
|
for sector in split_build.sectors:
|
|
match_set = set(sector.region_set()).intersection(possible_regions)
|
|
if len(match_set) > 0:
|
|
for r_name in match_set:
|
|
if r_name not in entrance_regions:
|
|
entrance_regions.append(r_name)
|
|
# entrance_regions = [x for x in entrance_regions if x not in split_check_entrance_invalid]
|
|
split = any(x for x in independents if x not in entrance_regions)
|
|
proposal = generate_dungeon_find_proposal(split_build, entrance_regions, split, world, player)
|
|
# record split proposals
|
|
builder.valid_proposal[name] = proposal
|
|
package = None
|
|
if temp_builder.name == 'Hyrule Castle':
|
|
temp_builder.chosen_lobby.outstanding_doors.append(temp_builder.throne_door)
|
|
temp_builder.throne_sector.outstanding_doors.append(world.get_door('Hyrule Castle Throne Room N', player))
|
|
package = temp_builder.throne_door, temp_builder.throne_sector, temp_builder.chosen_lobby
|
|
split_list['Sewers'].remove(temp_builder.throne_door.entrance.parent_region.name)
|
|
builder.exception_list = list(sector_list)
|
|
return True, {}, package
|
|
except (GenerationException, NeutralizingException, OtherGenException) as e:
|
|
logging.getLogger('').info(f'Bailing on this layout for {builder.name}', exc_info=1)
|
|
builder.split_dungeon_map = None
|
|
builder.valid_proposal = None
|
|
if temp_builder.name == 'Hyrule Castle' and temp_builder.throne_door:
|
|
temp_builder.chosen_lobby.outstanding_doors.append(temp_builder.throne_door)
|
|
temp_builder.throne_sector.outstanding_doors.append(world.get_door('Hyrule Castle Throne Room N', player))
|
|
old_entrance = temp_builder.throne_door.entrance.parent_region.name
|
|
split_dungeon_entrances[builder.name]['Sewers'].remove(old_entrance)
|
|
unreached_doors = resolve_equations(builder, sector_list)
|
|
return False, unreached_doors, None
|
|
else:
|
|
unreached_doors = resolve_equations(builder, sector_list)
|
|
return len(unreached_doors) == 0, unreached_doors, None
|
|
|
|
|
|
def find_independent_entrances(entrance_regions, world, player):
|
|
independents = set()
|
|
for region in entrance_regions:
|
|
portal = next((x for x in world.dungeon_portals[player] if x.door.entrance.parent_region.name == region), None)
|
|
if portal:
|
|
if portal.destination:
|
|
continue
|
|
elif len(entrance_regions) > 1:
|
|
p_region = portal.door.entrance.connected_region
|
|
access_region = next(x.parent_region for x in p_region.entrances
|
|
if x.parent_region.type in [RegionType.LightWorld, RegionType.DarkWorld])
|
|
if access_region.name in world.inaccessible_regions[player]:
|
|
continue
|
|
else:
|
|
r = world.get_region(region, player)
|
|
access_region = next(x.parent_region for x in r.entrances
|
|
if x.parent_region.type in [RegionType.LightWorld, RegionType.DarkWorld]
|
|
or x.parent_region.name == 'Sewer Drop')
|
|
if access_region.name == 'Sewer Drop':
|
|
access_region = next(x.parent_region for x in access_region.entrances)
|
|
if access_region.name in world.inaccessible_regions[player]:
|
|
continue
|
|
independents.add(region)
|
|
return independents
|
|
|
|
|
|
def resolve_equations(builder, sector_list):
|
|
unreached_doors = defaultdict(list)
|
|
equations = {x: y for x, y in copy_door_equations(builder, sector_list).items() if len(y) > 0}
|
|
current_access = {}
|
|
sector_split = {} # those sectors that belong to a certain sector
|
|
if builder.name in split_region_starts.keys():
|
|
for name, region_list in split_region_starts[builder.name].items():
|
|
current_access[name] = DungeonAccess()
|
|
for r_name in region_list:
|
|
sector = find_sector(r_name, builder.sectors)
|
|
sector_split[sector] = name
|
|
else:
|
|
current_access[builder.name] = DungeonAccess()
|
|
|
|
# resolve all that provide more access
|
|
free_sector, eq_list, free_eq = find_free_equation(equations)
|
|
while free_eq is not None:
|
|
if free_sector in sector_split.keys():
|
|
access_id = sector_split[free_sector]
|
|
access = current_access[access_id]
|
|
else:
|
|
access_id = next(iter(current_access.keys()))
|
|
access = current_access[access_id]
|
|
resolve_equation(free_eq, eq_list, free_sector, access_id, access, equations)
|
|
free_sector, eq_list, free_eq = find_free_equation(equations)
|
|
while len(equations) > 0:
|
|
valid_access = next_access(current_access)
|
|
eq, eq_list, sector, access, access_id = None, None, None, None, None
|
|
if len(valid_access) == 1:
|
|
access_id, access = valid_access[0]
|
|
eq, eq_list, sector = find_priority_equation(equations, access_id, access)
|
|
elif len(valid_access) > 1:
|
|
access_id, access = valid_access[0]
|
|
eq, eq_list, sector = find_greedy_equation(equations, access_id, access, sector_split)
|
|
if eq:
|
|
resolve_equation(eq, eq_list, sector, access_id, access, equations)
|
|
else:
|
|
for sector, eq_list in equations.items():
|
|
for eq in eq_list:
|
|
unreached_doors[hook_from_door(eq.door)].append(eq.door)
|
|
return unreached_doors
|
|
valid_access = next_access(current_access)
|
|
for access_id, dungeon_access in valid_access:
|
|
access = dungeon_access.access
|
|
access[Hook.Stairs] = access[Hook.Stairs] % 2
|
|
ns_leftover = min(access[Hook.North], access[Hook.South])
|
|
access[Hook.North] -= ns_leftover
|
|
access[Hook.South] -= ns_leftover
|
|
ew_leftover = min(access[Hook.West], access[Hook.East])
|
|
access[Hook.East] -= ew_leftover
|
|
access[Hook.West] -= ew_leftover
|
|
if sum(access.values()) > 0:
|
|
for hook, num in access.items():
|
|
for i in range(num):
|
|
unreached_doors[hook].append('placeholder')
|
|
return unreached_doors
|
|
|
|
|
|
def next_access(current_access):
|
|
valid_ones = [(x, y) for x, y in current_access.items() if sum(y.access.values()) > 0]
|
|
valid_ones.sort(key=lambda x: sum(x[1].access.values()))
|
|
return valid_ones
|
|
|
|
|
|
# an equations with no change to access (check)
|
|
# the highest benefit equations, that can be paid for (check)
|
|
# 0-benefit required transforms
|
|
# 0-benefit transforms (how to pick between these?)
|
|
# negative benefit transforms (dead end)
|
|
def find_priority_equation(equations, access_id, current_access):
|
|
flex = calc_flex(equations, current_access)
|
|
required = calc_required(equations, current_access)
|
|
wanted_candidates = []
|
|
best_profit = None
|
|
all_candidates = []
|
|
local_profit_map = {}
|
|
|
|
for sector, eq_list in equations.items():
|
|
eq_list.sort(key=lambda eq: eq.profit(current_access), reverse=True)
|
|
best_local_profit = None
|
|
for eq in eq_list:
|
|
profit = eq.profit(current_access)
|
|
if current_access.can_cover_equation(eq) and (eq.access_id is None or eq.access_id == access_id):
|
|
# if eq.neutral_profit() or eq.neutral():
|
|
# return eq, eq_list, sector # don't need to compare - just use it now
|
|
if best_local_profit is None or profit > best_local_profit:
|
|
best_local_profit = profit
|
|
all_candidates.append((eq, eq_list, sector))
|
|
elif (best_profit is None or profit >= best_profit) and profit > 0:
|
|
if best_profit is None or profit > best_profit:
|
|
wanted_candidates = [eq]
|
|
best_profit = profit
|
|
else:
|
|
wanted_candidates.append(eq)
|
|
local_profit_map[sector] = best_local_profit
|
|
filtered_candidates = filter_requirements(all_candidates, equations, required, current_access)
|
|
filtered_candidates = [x for x in filtered_candidates if x[0].gross(current_access) > 0]
|
|
if len(filtered_candidates) == 0:
|
|
filtered_candidates = all_candidates # probably bad things
|
|
if len(filtered_candidates) == 0:
|
|
return None, None, None # can't pay for anything
|
|
if len(filtered_candidates) == 1:
|
|
return filtered_candidates[0]
|
|
|
|
neutral_candidates = [x for x in filtered_candidates if (x[0].neutral_profit() or x[0].neutral()) and x[0].profit(current_access) == local_profit_map[x[2]]]
|
|
if len(neutral_candidates) == 0:
|
|
neutral_candidates = filtered_candidates
|
|
if len(neutral_candidates) == 1:
|
|
return neutral_candidates[0]
|
|
|
|
filtered_candidates = filter_requirements(neutral_candidates, equations, required, current_access)
|
|
if len(filtered_candidates) == 0:
|
|
filtered_candidates = neutral_candidates
|
|
if len(filtered_candidates) == 1:
|
|
return filtered_candidates[0]
|
|
|
|
triplet_candidates = []
|
|
best_profit = None
|
|
for eq, eq_list, sector in filtered_candidates:
|
|
profit = eq.profit(current_access)
|
|
if best_profit is None or profit >= best_profit:
|
|
if best_profit is None or profit > best_profit:
|
|
triplet_candidates = [(eq, eq_list, sector)]
|
|
best_profit = profit
|
|
else:
|
|
triplet_candidates.append((eq, eq_list, sector))
|
|
|
|
filtered_candidates = filter_requirements(triplet_candidates, equations, required, current_access)
|
|
if len(filtered_candidates) == 0:
|
|
filtered_candidates = triplet_candidates
|
|
if len(filtered_candidates) == 1:
|
|
return filtered_candidates[0]
|
|
|
|
required_candidates = [x for x in filtered_candidates if x[0].required]
|
|
if len(required_candidates) == 0:
|
|
required_candidates = filtered_candidates
|
|
if len(required_candidates) == 1:
|
|
return required_candidates[0]
|
|
|
|
c_switch_candidates = [x for x in required_candidates if x[0].c_switch]
|
|
if len(c_switch_candidates) == 0:
|
|
c_switch_candidates = required_candidates
|
|
if len(c_switch_candidates) == 1:
|
|
return c_switch_candidates[0]
|
|
|
|
loop_candidates = find_enabling_switch_connections(current_access)
|
|
if len(loop_candidates) >= 1:
|
|
return loop_candidates[0] # just pick one
|
|
|
|
flexible_candidates = [x for x in c_switch_candidates if x[0].can_cover_cost(flex)]
|
|
if len(flexible_candidates) == 0:
|
|
flexible_candidates = c_switch_candidates
|
|
if len(flexible_candidates) == 1:
|
|
return flexible_candidates[0]
|
|
|
|
good_local_candidates = [x for x in flexible_candidates if local_profit_map[x[2]] == x[0].profit(current_access)]
|
|
if len(good_local_candidates) == 0:
|
|
good_local_candidates = flexible_candidates
|
|
if len(good_local_candidates) == 1:
|
|
return good_local_candidates[0]
|
|
|
|
leads_to_profit = [x for x in good_local_candidates if can_enable_wanted(x[0], wanted_candidates)]
|
|
if len(leads_to_profit) == 0:
|
|
leads_to_profit = good_local_candidates
|
|
if len(leads_to_profit) == 1:
|
|
return leads_to_profit[0]
|
|
|
|
cost_point = {x[0]: find_cost_point(x, current_access) for x in leads_to_profit}
|
|
best_point = max(cost_point.values())
|
|
cost_point_candidates = [x for x in leads_to_profit if cost_point[x[0]] == best_point]
|
|
if len(cost_point_candidates) == 0:
|
|
cost_point_candidates = leads_to_profit
|
|
return cost_point_candidates[0] # just pick one I guess
|
|
|
|
|
|
def find_enabling_switch_connections(current_access):
|
|
triad_list = []
|
|
# probably should check for loop/branches in builder at some stage
|
|
# - but this could indicate that a loop or branch is necessary
|
|
for cand_door, crystal in current_access.outstanding_doors.items():
|
|
for blocked_door, req_crystal in current_access.blocked_doors.items():
|
|
if hook_from_door(cand_door) == hanger_from_door(blocked_door):
|
|
if crystal == CrystalBarrier.Either or crystal == req_crystal:
|
|
sector, equation = current_access.door_sector_map[blocked_door], None
|
|
for eq in sector.equations:
|
|
if eq.door == blocked_door:
|
|
equation = eq.copy()
|
|
break
|
|
if equation:
|
|
triad_list.append((equation, [equation], sector))
|
|
return triad_list
|
|
|
|
|
|
def find_cost_point(eq_triplet, access):
|
|
cost_point = 0
|
|
key, cost_door = eq_triplet[0].cost
|
|
if cost_door is not None:
|
|
cost_point += access.access[key] - 1
|
|
return cost_point
|
|
|
|
|
|
def find_greedy_equation(equations, access_id, current_access, sector_split):
|
|
all_candidates = []
|
|
for sector, eq_list in equations.items():
|
|
if sector not in sector_split.keys() or sector_split[sector] == access_id:
|
|
eq_list.sort(key=lambda eq: eq.profit(current_access), reverse=True)
|
|
for eq in eq_list:
|
|
if current_access.can_cover_equation(eq) and (eq.access_id is None or eq.access_id == access_id):
|
|
all_candidates.append((eq, eq_list, sector))
|
|
if len(all_candidates) == 0:
|
|
return None, None, None # can't pay for anything
|
|
if len(all_candidates) == 1:
|
|
return all_candidates[0]
|
|
filtered_candidates = [x for x in all_candidates if x[0].profit(current_access) + 2 >= len(x[2].outstanding_doors)]
|
|
if len(filtered_candidates) == 0:
|
|
filtered_candidates = all_candidates # terrible! ugly dead ends
|
|
if len(filtered_candidates) == 1:
|
|
return filtered_candidates[0]
|
|
|
|
triplet_candidates = []
|
|
worst_profit = None
|
|
for eq, eq_list, sector in filtered_candidates:
|
|
profit = eq.profit(current_access)
|
|
if worst_profit is None or profit <= worst_profit:
|
|
if worst_profit is None or profit < worst_profit:
|
|
triplet_candidates = [(eq, eq_list, sector)]
|
|
worst_profit = profit
|
|
else:
|
|
triplet_candidates.append((eq, eq_list, sector))
|
|
if len(triplet_candidates) == 0:
|
|
triplet_candidates = filtered_candidates # probably bad things
|
|
return triplet_candidates[0] # just pick one?
|
|
|
|
|
|
def calc_required(equations, current_access):
|
|
ttl = sum(current_access.access.values())
|
|
local_profit_map = {}
|
|
for sector, eq_list in equations.items():
|
|
best_local_profit = None
|
|
for eq in eq_list:
|
|
profit = eq.profit(current_access)
|
|
if best_local_profit is None or profit > best_local_profit:
|
|
best_local_profit = profit
|
|
local_profit_map[sector] = best_local_profit
|
|
ttl += best_local_profit
|
|
if ttl == 0:
|
|
new_lists = {}
|
|
for sector, eq_list in equations.items():
|
|
if len(eq_list) > 1:
|
|
rem_list = []
|
|
for eq in eq_list:
|
|
if eq.profit(current_access) < local_profit_map[sector]:
|
|
rem_list.append(eq)
|
|
if len(rem_list) > 0:
|
|
new_lists[sector] = [x for x in eq_list if x not in rem_list]
|
|
for sector, eq_list in new_lists.items():
|
|
if len(eq_list) <= 1:
|
|
for eq in eq_list:
|
|
eq.required = True
|
|
equations[sector] = eq_list
|
|
required_costs = defaultdict(int)
|
|
required_benefits = defaultdict(int)
|
|
for sector, eq_list in equations.items():
|
|
for eq in eq_list:
|
|
if eq.required:
|
|
key, door = eq.cost
|
|
required_costs[key] += 1
|
|
for key, door_list in eq.benefit.items():
|
|
required_benefits[key] += len(door_list)
|
|
return required_costs, required_benefits
|
|
|
|
|
|
def calc_flex(equations, current_access):
|
|
flex_spending = defaultdict(int)
|
|
required_costs = defaultdict(int)
|
|
for sector, eq_list in equations.items():
|
|
for eq in eq_list:
|
|
if eq.required:
|
|
key, door = eq.cost
|
|
required_costs[key] += 1
|
|
for key in Hook:
|
|
flex_spending[key] = max(0, current_access.access[key]-required_costs[key])
|
|
return flex_spending
|
|
|
|
|
|
def filter_requirements(triplet_candidates, equations, required, current_access):
|
|
r_costs, r_exits = required
|
|
valid_candidates = []
|
|
for cand, cand_list, cand_sector in triplet_candidates:
|
|
valid = True
|
|
if not cand.required and not cand.c_switch:
|
|
potential_benefit = defaultdict(int)
|
|
benefit_counted = set()
|
|
potential_costs = defaultdict(int)
|
|
for h_type, benefit in current_access.access.items():
|
|
cur_cost = 1 if cand.cost[0] is not None else 0
|
|
if benefit - cur_cost > 0:
|
|
potential_benefit[h_type] += benefit - cur_cost
|
|
for h_type, benefit_list in cand.benefit.items():
|
|
potential_benefit[h_type] += len(benefit_list)
|
|
for sector, eq_list in equations.items():
|
|
if sector == cand_sector:
|
|
affected_doors = [d for x in cand.benefit.values() for d in x] + [cand.cost[1]]
|
|
adj_list = [x for x in eq_list if x.door not in affected_doors]
|
|
else:
|
|
adj_list = eq_list
|
|
for eq in adj_list:
|
|
for h_type, benefit_list in eq.benefit.items():
|
|
total_benefit = set(benefit_list) - benefit_counted
|
|
potential_benefit[h_type] += len(total_benefit)
|
|
benefit_counted.update(benefit_list)
|
|
h_type, cost_door = eq.cost
|
|
potential_costs[h_type] += 1
|
|
for h_type, requirement in r_costs.items():
|
|
if requirement > 0 and potential_benefit[h_type] < requirement:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
for h_type, requirement in r_exits.items():
|
|
if requirement > 0 and potential_costs[h_type] < requirement:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
valid_candidates.append((cand, cand_list, cand_sector))
|
|
return valid_candidates
|
|
|
|
|
|
def can_enable_wanted(test_eq, wanted_candidates):
|
|
for wanted in wanted_candidates:
|
|
covered = True
|
|
key, cost_door = wanted.cost
|
|
if len(test_eq.benefit[key]) < 1:
|
|
covered = False
|
|
if covered:
|
|
return True
|
|
return False
|
|
|
|
|
|
def resolve_equation(equation, eq_list, sector, access_id, current_access, equations):
|
|
if not current_access.can_pay(equation.cost[0]):
|
|
raise GenerationException('Cannot pay for this connection')
|
|
current_access.adjust_for_equation(equation, sector)
|
|
eq_list.remove(equation)
|
|
reached_doors = set(current_access.reached_doors)
|
|
reached_doors.update(current_access.blocked_doors.keys())
|
|
for r_eq in list(eq_list):
|
|
all_benefits_met = r_eq.door in reached_doors
|
|
for key in Hook:
|
|
fringe_list = [x for x in r_eq.benefit[key] if x not in reached_doors]
|
|
r_eq.benefit[key] = fringe_list
|
|
if len(fringe_list) > 0:
|
|
all_benefits_met = False
|
|
if all_benefits_met:
|
|
eq_list.remove(r_eq)
|
|
if len(eq_list) == 0 and sector in equations.keys():
|
|
del equations[sector]
|
|
else:
|
|
for eq in eq_list:
|
|
eq.access_id = access_id
|
|
|
|
|
|
def find_free_equation(equations):
|
|
for sector, eq_list in equations.items():
|
|
for eq in eq_list:
|
|
if eq.total_cost() <= 0:
|
|
return sector, eq_list, eq
|
|
return None, None, None
|
|
|
|
|
|
def copy_door_equations(builder, sector_list):
|
|
equations = {}
|
|
for sector in builder.sectors + sector_list:
|
|
sector.equations = calc_sector_equations(sector, builder.sewers_access)
|
|
curr_list = equations[sector] = []
|
|
for equation in sector.equations:
|
|
curr_list.append(equation.copy())
|
|
return equations
|
|
|
|
|
|
def calc_sector_equations(sector, sewers_flag=False):
|
|
equations = []
|
|
is_entrance = (sector.is_entrance_sector() and not sector.destination_entrance) or sewers_flag
|
|
if is_entrance:
|
|
flagged_equations = []
|
|
for door in sector.outstanding_doors:
|
|
equation, flag = calc_door_equation(door, sector, True, sewers_flag)
|
|
if flag:
|
|
flagged_equations.append(equation)
|
|
equations.append(equation)
|
|
for flagged_equation in flagged_equations:
|
|
for equation in equations:
|
|
for key, door_list in equation.benefit.items():
|
|
if flagged_equation.door in door_list and flagged_equation != equation:
|
|
door_list.remove(flagged_equation.door)
|
|
else:
|
|
for door in sector.outstanding_doors:
|
|
equation, flag = calc_door_equation(door, sector, False)
|
|
equations.append(equation)
|
|
return equations
|
|
|
|
|
|
def calc_door_equation(door, sector, look_for_entrance, sewers_flag=None):
|
|
if look_for_entrance and not door.blocked:
|
|
flag = sector.is_entrance_sector() or sewers_flag
|
|
if flag:
|
|
eq = DoorEquation(door)
|
|
eq.benefit[hook_from_door(door)].append(door)
|
|
eq.required = True
|
|
eq.c_switch = door.crystal == CrystalBarrier.Either
|
|
# exceptions for long entrances ???
|
|
# if door.name in ['PoD Dark Alley']:
|
|
eq.entrance_flag = True
|
|
return eq, flag
|
|
eq = DoorEquation(door)
|
|
eq.required = door.blocked or door.dead
|
|
eq.cost = (hanger_from_door(door), door)
|
|
eq.entrance_flag = sector.is_entrance_sector()
|
|
if not door.stonewall:
|
|
start_region = door.entrance.parent_region
|
|
visited = {(start_region, CrystalBarrier.Null)}
|
|
queue = deque([(start_region, CrystalBarrier.Null)])
|
|
found_events = set()
|
|
event_doors = set()
|
|
while len(queue) > 0:
|
|
region, crystal_barrier = queue.popleft()
|
|
if region.crystal_switch and crystal_barrier == CrystalBarrier.Null:
|
|
eq.c_switch = True
|
|
crystal_barrier = CrystalBarrier.Either
|
|
# todo: backtracking from double switch with orange on--
|
|
for loc in region.locations:
|
|
if loc.name in dungeon_events:
|
|
found_events.add(loc.name)
|
|
for d in event_doors:
|
|
if loc.name == d.req_event:
|
|
connect = d.entrance.connected_region
|
|
if connect is not None and connect.type == RegionType.Dungeon and valid_crystal(d, crystal_barrier):
|
|
cb_flag = crystal_barrier if d.crystal == CrystalBarrier.Null else d.crystal
|
|
cb_flag = CrystalBarrier.Null if cb_flag == CrystalBarrier.Either else cb_flag
|
|
if (connect, cb_flag) not in visited:
|
|
visited.add((connect, cb_flag))
|
|
queue.append((connect, cb_flag))
|
|
for ext in region.exits:
|
|
d = ext.door
|
|
if d is not None:
|
|
if d.controller is not None:
|
|
d = d.controller
|
|
if d is not door and d in sector.outstanding_doors and not d.blocked:
|
|
eq_list = eq.benefit[hook_from_door(d)]
|
|
if d not in eq_list:
|
|
eq_list.append(d)
|
|
crystal_barrier = crystal_barrier if d.crystal == CrystalBarrier.Null else d.crystal
|
|
if crystal_barrier != CrystalBarrier.Null:
|
|
if d in eq.crystal_blocked.keys() and eq.crystal_blocked[d] != crystal_barrier:
|
|
del eq.crystal_blocked[d]
|
|
else:
|
|
eq.crystal_blocked[d] = crystal_barrier
|
|
elif d.crystal == CrystalBarrier.Null:
|
|
if d in eq.crystal_blocked.keys() and eq.crystal_blocked[d] != crystal_barrier:
|
|
del eq.crystal_blocked[d]
|
|
if d.req_event is not None and d.req_event not in found_events:
|
|
event_doors.add(d)
|
|
else:
|
|
connect = ext.connected_region if ext.door.controller is None else d.entrance.parent_region
|
|
if connect is not None and connect.type == RegionType.Dungeon and valid_crystal(d, crystal_barrier):
|
|
cb_flag = crystal_barrier if d.crystal == CrystalBarrier.Null else d.crystal
|
|
cb_flag = CrystalBarrier.Null if cb_flag == CrystalBarrier.Either else cb_flag
|
|
if (connect, cb_flag) not in visited:
|
|
visited.add((connect, cb_flag))
|
|
queue.append((connect, cb_flag))
|
|
if len(eq.benefit) == 0:
|
|
eq.required = True
|
|
return eq, False
|
|
|
|
|
|
def meets_crystal_requirment(current_crystal, requirement):
|
|
if current_crystal == CrystalBarrier.Either:
|
|
return True
|
|
return current_crystal == requirement
|
|
|
|
|
|
def valid_crystal(door, current_crystal):
|
|
if door.crystal in [CrystalBarrier.Null, CrystalBarrier.Either]:
|
|
return True
|
|
if current_crystal in [CrystalBarrier.Either, CrystalBarrier.Null]:
|
|
return True
|
|
return door.crystal == current_crystal
|
|
|
|
|
|
# common functions - todo: move to a common place
|
|
def kth_combination(k, l, r):
|
|
if r == 0:
|
|
return []
|
|
elif len(l) == r:
|
|
return l
|
|
else:
|
|
i = ncr(len(l) - 1, r - 1)
|
|
if k < i:
|
|
return l[0:1] + kth_combination(k, l[1:], r - 1)
|
|
else:
|
|
return kth_combination(k - i, l[1:], r)
|
|
|
|
|
|
def ncr(n, r):
|
|
if r == 0:
|
|
return 1
|
|
r = min(r, n - r)
|
|
numerator = reduce(op.mul, range(n, n - r, -1), 1)
|
|
denominator = reduce(op.mul, range(1, r + 1), 1)
|
|
return int(numerator / denominator)
|
|
|
|
|
|
dungeon_boss_sectors = {
|
|
'Hyrule Castle': [],
|
|
'Eastern Palace': ['Eastern Boss'],
|
|
'Desert Palace': ['Desert Boss'],
|
|
'Tower of Hera': ['Hera Boss'],
|
|
'Agahnims Tower': ['Tower Agahnim 1'],
|
|
'Palace of Darkness': ['PoD Boss'],
|
|
'Swamp Palace': ['Swamp Boss'],
|
|
'Skull Woods': ['Skull Boss'],
|
|
'Thieves Town': ['Thieves Boss'],
|
|
'Ice Palace': ['Ice Boss'],
|
|
'Misery Mire': ['Mire Boss'],
|
|
'Turtle Rock': ['TR Boss'],
|
|
'Ganons Tower': ['GT Agahnim 2']
|
|
}
|
|
|
|
default_dungeon_entrances = {
|
|
'Hyrule Castle': ['Hyrule Castle Lobby', 'Hyrule Castle West Lobby', 'Hyrule Castle East Lobby', 'Sewers Rat Path',
|
|
'Sanctuary'],
|
|
'Eastern Palace': ['Eastern Lobby'],
|
|
'Desert Palace': ['Desert Back Lobby', 'Desert Main Lobby', 'Desert West Lobby', 'Desert East Lobby'],
|
|
'Tower of Hera': ['Hera Lobby'],
|
|
'Agahnims Tower': ['Tower Lobby'],
|
|
'Palace of Darkness': ['PoD Lobby'],
|
|
'Swamp Palace': ['Swamp Lobby'],
|
|
'Skull Woods': ['Skull 1 Lobby', 'Skull Pinball', 'Skull Left Drop', 'Skull Pot Circle', 'Skull 2 East Lobby',
|
|
'Skull 2 West Lobby', 'Skull Back Drop', 'Skull 3 Lobby'],
|
|
'Thieves Town': ['Thieves Lobby'],
|
|
'Ice Palace': ['Ice Lobby'],
|
|
'Misery Mire': ['Mire Lobby'],
|
|
'Turtle Rock': ['TR Main Lobby', 'TR Eye Bridge', 'TR Big Chest Entrance', 'TR Lazy Eyes'],
|
|
'Ganons Tower': ['GT Lobby']
|
|
}
|
|
|
|
drop_entrances = {
|
|
'Hyrule Castle': ['Sewers Rat Path'],
|
|
'Eastern Palace': [],
|
|
'Desert Palace': [],
|
|
'Tower of Hera': [],
|
|
'Agahnims Tower': [],
|
|
'Palace of Darkness': [],
|
|
'Swamp Palace': [],
|
|
'Skull Woods': ['Skull Pinball', 'Skull Left Drop', 'Skull Pot Circle', 'Skull Back Drop'],
|
|
'Thieves Town': [],
|
|
'Ice Palace': [],
|
|
'Misery Mire': [],
|
|
'Turtle Rock': [],
|
|
'Ganons Tower': []
|
|
}
|
|
|
|
|
|
# todo: calculate these for ER - the multi entrance dungeons anyway
|
|
dungeon_dead_end_allowance = {
|
|
'Hyrule Castle': 6,
|
|
'Eastern Palace': 1,
|
|
'Desert Palace': 2,
|
|
'Tower of Hera': 1,
|
|
'Agahnims Tower': 1,
|
|
'Palace of Darkness': 1,
|
|
'Swamp Palace': 1,
|
|
'Skull Woods': 3, # two allowed in skull 1, 1 in skull 3, 0 in skull 2
|
|
'Thieves Town': 1,
|
|
'Ice Palace': 1,
|
|
'Misery Mire': 1,
|
|
'Turtle Rock': 2, # this assumes one overworld connection
|
|
'Ganons Tower': 1,
|
|
'Desert Palace Back': 1,
|
|
'Desert Palace Main': 1,
|
|
'Skull Woods 1': 0,
|
|
'Skull Woods 2': 0,
|
|
'Skull Woods 3': 1,
|
|
}
|
|
|
|
drop_entrances_allowance = [
|
|
'Sewers Rat Path', 'Skull Pinball', 'Skull Left Drop', 'Skull Pot Circle', 'Skull Back Drop'
|
|
]
|
|
|
|
dead_entrances = [
|
|
'TR Big Chest Entrance'
|
|
]
|
|
|
|
split_check_entrance_invalid = [
|
|
'Desert East Lobby', 'Skull 2 West Lobby'
|
|
]
|
|
|
|
dungeon_portals = {
|
|
'Hyrule Castle': ['Hyrule Castle South', 'Hyrule Castle West', 'Hyrule Castle East', 'Sanctuary'],
|
|
'Eastern Palace': ['Eastern'],
|
|
'Desert Palace': ['Desert Back', 'Desert South', 'Desert West', 'Desert East'],
|
|
'Tower of Hera': ['Hera'],
|
|
'Agahnims Tower': ['Agahnims Tower'],
|
|
'Palace of Darkness': ['Palace of Darkness'],
|
|
'Swamp Palace': ['Swamp'],
|
|
'Skull Woods': ['Skull 1', 'Skull 2 East', 'Skull 2 West', 'Skull 3'],
|
|
'Thieves Town': ['Thieves Town'],
|
|
'Ice Palace': ['Ice'],
|
|
'Misery Mire': ['Mire'],
|
|
'Turtle Rock': ['Turtle Rock Main', 'Turtle Rock Lazy Eyes', 'Turtle Rock Chest', 'Turtle Rock Eye Bridge'],
|
|
'Ganons Tower': ['Ganons Tower']
|
|
}
|
|
|
|
dungeon_drops = {
|
|
'Hyrule Castle': ['Sewers Rat Path'],
|
|
'Skull Woods': ['Skull Pot Circle', 'Skull Pinball', 'Skull Left Drop', 'Skull Back Drop'],
|
|
}
|
|
|