def copy_world(world):
# ToDo: Not good yet
ret = World(world.shuffle, world.logic, world.mode, world.difficulty, world.goal)
ret.required_medallions = list(world.required_medallions)
create_regions(ret)
# connect copied world
for region in world.regions:
for entrance in region.entrances:
ret.get_entrance(entrance.name).connect(ret.get_region(region.name))
set_rules(ret)
# fill locations
for location in world.get_locations():
if location.item is not None:
item = Item(location.item.name, location.item.advancement, location.item.key)
ret.get_location(location.name).item = item
item.location = ret.get_location(location.name)
# copy remaining itempool. No item in itempool should have an assigned location
for item in world.itempool:
ret.itempool.append(Item(item.name, item.advancement, item.key))
# copy progress items in state
ret.state.prog_items = list(world.state.prog_items)
return ret
def setUp(self):
self.world = World(1, {1: 'vanilla'}, {1: 'owglitches'}, {1: 'open'},
{1: 'random'}, {1: 'normal'}, {1: 'normal'},
{1: False}, {1: 'on'}, {1: 'ganon'}, 'balanced',
{1: 'items'}, True, {1: False}, False, None,
{1: False})
self.world.difficulty_requirements[1] = difficulties['normal']
create_regions(self.world, 1)
create_dungeons(self.world, 1)
create_shops(self.world, 1)
link_entrances(self.world, 1)
generate_itempool(self.world, 1)
self.world.required_medallions[1] = ['Ether', 'Quake']
self.world.itempool.extend(get_dungeon_item_pool(self.world))
self.world.itempool.extend(
ItemFactory([
'Green Pendant', 'Red Pendant', 'Blue Pendant',
'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2',
'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'
], 1))
self.world.get_location('Agahnim 1', 1).item = None
self.world.get_location('Agahnim 2', 1).item = None
self.world.precollected_items.clear()
self.world.itempool.append(ItemFactory('Pegasus Boots', 1))
mark_dark_world_regions(self.world, 1)
set_rules(self.world, 1)
def setUp(self):
self.world = World(1, {1: 'vanilla'}, {1: 'noglitches'}, {1: 'open'},
{1: 'random'}, {1: 'normal'}, {1: 'normal'},
{1: False}, {1: 'on'}, {1: 'ganon'}, 'balanced',
{1: 'items'}, True, {1: False}, False, None,
{1: False})
self.starting_regions = [] # Where to start exploring
self.remove_exits = [] # Block dungeon exits
self.world.difficulty_requirements[1] = difficulties['normal']
create_regions(self.world, 1)
create_dungeons(self.world, 1)
create_shops(self.world, 1)
for exitname, regionname in mandatory_connections:
connect_simple(self.world, exitname, regionname, 1)
connect_simple(self.world, 'Big Bomb Shop', 'Big Bomb Shop', 1)
self.world.get_region('Menu', 1).exits = []
self.world.swamp_patch_required[1] = True
set_rules(self.world, 1)
generate_itempool(self.world, 1)
self.world.itempool.extend(get_dungeon_item_pool(self.world))
self.world.itempool.extend(
ItemFactory([
'Green Pendant', 'Red Pendant', 'Blue Pendant',
'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2',
'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'
], 1))
def copy_world(world):
# ToDo: Not good yet
ret = World(world.bridge, world.open_forest, world.open_door_of_time, world.place_dungeon_items, world.check_beatable_only, world.hints)
ret.seed = world.seed
ret.can_take_damage = world.can_take_damage
create_regions(ret)
create_dungeons(ret)
# connect copied world
for region in world.regions:
copied_region = ret.get_region(region.name)
for entrance in region.entrances:
ret.get_entrance(entrance.name).connect(copied_region)
# fill locations
for location in world.get_locations():
if location.item is not None:
item = Item(location.item.name, location.item.advancement, location.item.priority, location.item.type)
ret.get_location(location.name).item = item
item.location = ret.get_location(location.name)
if location.event:
ret.get_location(location.name).event = True
# copy remaining itempool. No item in itempool should have an assigned location
for item in world.itempool:
ret.itempool.append(Item(item.name, item.advancement, item.priority, item.type))
# copy progress items in state
ret.state.prog_items = list(world.state.prog_items)
set_rules(ret)
return ret
def setUp(self):
self.world = World(1, 'vanilla', 'noglitches', 'open', 'random',
'normal', 'normal', 'none', 'on', 'ganon',
'balanced', True, False, False, False, False, False,
False, False, False, None, 'none', False)
self.world.difficulty_requirements = difficulties['normal']
create_regions(self.world, 1)
create_dungeons(self.world, 1)
link_entrances(self.world, 1)
set_rules(self.world, 1)
def copy_world(world):
# ToDo: Not good yet
ret = World(world.shuffle, world.logic, world.mode, world.difficulty, world.timer, world.progressive, world.goal, world.algorithm, world.place_dungeon_items, world.check_beatable_only, world.shuffle_ganon, world.quickswap, world.fastmenu, world.disable_music, world.keysanity, world.retro, world.custom, world.customitemarray)
ret.required_medallions = list(world.required_medallions)
ret.swamp_patch_required = world.swamp_patch_required
ret.ganon_at_pyramid = world.ganon_at_pyramid
ret.treasure_hunt_count = world.treasure_hunt_count
ret.treasure_hunt_icon = world.treasure_hunt_icon
ret.sewer_light_cone = world.sewer_light_cone
ret.light_world_light_cone = world.light_world_light_cone
ret.dark_world_light_cone = world.dark_world_light_cone
ret.seed = world.seed
ret.can_access_trock_eyebridge = world.can_access_trock_eyebridge
ret.can_take_damage = world.can_take_damage
ret.difficulty_requirements = world.difficulty_requirements
ret.fix_fake_world = world.fix_fake_world
ret.lamps_needed_for_dark_rooms = world.lamps_needed_for_dark_rooms
create_regions(ret)
create_dungeons(ret)
copy_dynamic_regions_and_locations(world, ret)
for shop in world.shops:
copied_shop = ret.get_region(shop.region.name).shop
copied_shop.active = shop.active
copied_shop.inventory = copy.copy(shop.inventory)
# connect copied world
for region in world.regions:
copied_region = ret.get_region(region.name)
copied_region.is_light_world = region.is_light_world
copied_region.is_dark_world = region.is_dark_world
for entrance in region.entrances:
ret.get_entrance(entrance.name).connect(copied_region)
# fill locations
for location in world.get_locations():
if location.item is not None:
item = Item(location.item.name, location.item.advancement, location.item.priority, location.item.type)
ret.get_location(location.name).item = item
item.location = ret.get_location(location.name)
if location.event:
ret.get_location(location.name).event = True
# copy remaining itempool. No item in itempool should have an assigned location
for item in world.itempool:
ret.itempool.append(Item(item.name, item.advancement, item.priority, item.type))
# copy progress items in state
ret.state.prog_items = list(world.state.prog_items)
set_rules(ret)
return ret
def copy_world(world):
# ToDo: Not good yet
ret = World(world.shuffle, world.logic, world.mode, world.difficulty,
world.timer, world.progressive, world.goal, world.algorithm,
world.place_dungeon_items, world.check_beatable_only,
world.shuffle_ganon, world.quickswap, world.fastmenu,
world.keysanity)
ret.required_medallions = list(world.required_medallions)
ret.swamp_patch_required = world.swamp_patch_required
ret.ganon_at_pyramid = world.ganon_at_pyramid
ret.treasure_hunt_count = world.treasure_hunt_count
ret.treasure_hunt_icon = world.treasure_hunt_icon
ret.sewer_light_cone = world.sewer_light_cone
ret.light_world_light_cone = world.light_world_light_cone
ret.dark_world_light_cone = world.dark_world_light_cone
ret.seed = world.seed
ret.can_access_trock_eyebridge = world.can_access_trock_eyebridge
create_regions(ret)
create_dungeons(ret)
# connect copied world
for region in world.regions:
for entrance in region.entrances:
ret.get_entrance(entrance.name).connect(ret.get_region(
region.name))
# fill locations
for location in world.get_locations():
if location.item is not None:
item = Item(location.item.name, location.item.advancement,
location.item.priority, location.item.type)
ret.get_location(location.name).item = item
item.location = ret.get_location(location.name)
if location.event:
ret.get_location(location.name).event = True
# copy remaining itempool. No item in itempool should have an assigned location
for item in world.itempool:
ret.itempool.append(
Item(item.name, item.advancement, item.priority, item.type))
# copy progress items in state
ret.state.prog_items = list(world.state.prog_items)
set_rules(ret)
return ret
def copy(self):
ret = World(self.settings)
ret.skipped_trials = copy.copy(self.skipped_trials)
ret.dungeon_mq = copy.copy(self.dungeon_mq)
ret.big_poe_count = copy.copy(self.big_poe_count)
ret.can_take_damage = self.can_take_damage
ret.shop_prices = copy.copy(self.shop_prices)
ret.keys_placed = self.keys_placed
ret.id = self.id
from Regions import create_regions
from Dungeons import create_dungeons
from Rules import set_rules, set_shop_rules
create_regions(ret)
create_dungeons(ret)
set_rules(ret)
# connect copied world
for region in self.regions:
copied_region = ret.get_region(region.name)
for entrance in region.entrances:
ret.get_entrance(entrance.name).connect(copied_region)
# fill locations
for location in self.get_locations():
if location.item is not None:
item = Item(location.item.name, location.item.advancement,
location.item.priority, location.item.type)
item.world = location.item.world
ret.get_location(location.name).item = item
item.location = ret.get_location(location.name)
item.location.locked = location.locked
# copy remaining itempool. No item in itempool should have an assigned location
for item in self.itempool:
new_item = Item(item.name, item.advancement, item.priority,
item.type)
new_item.world = item.world
ret.itempool.append(new_item)
# copy progress items in state
ret.state.prog_items = copy.copy(self.state.prog_items)
set_shop_rules(ret)
return ret
def build_world_graphs(settings, window=dummy_window()):
logger = logging.getLogger('')
worlds = []
for i in range(0, settings.world_count):
worlds.append(World(i, settings))
window.update_status('Creating the Worlds')
for id, world in enumerate(worlds):
logger.info('Generating World %d.' % (id + 1))
window.update_progress(0 + 1 * (id + 1) / settings.world_count)
logger.info('Creating Overworld')
if settings.logic_rules == 'glitched':
overworld_data = os.path.join(data_path('Glitched World'),
'Overworld.json')
else:
overworld_data = os.path.join(data_path('World'), 'Overworld.json')
# Compile the json rules based on settings
world.load_regions_from_json(overworld_data)
create_dungeons(world)
world.create_internal_locations()
if settings.shopsanity != 'off':
world.random_shop_prices()
world.set_scrub_prices()
window.update_progress(0 + 4 * (id + 1) / settings.world_count)
logger.info('Calculating Access Rules.')
set_rules(world)
window.update_progress(0 + 5 * (id + 1) / settings.world_count)
logger.info('Generating Item Pool.')
generate_itempool(world)
set_shop_rules(world)
set_drop_location_names(world)
world.fill_bosses()
if settings.triforce_hunt:
settings.distribution.configure_triforce_hunt(worlds)
logger.info('Setting Entrances.')
set_entrances(worlds)
return worlds
def setUp(self):
self.world = World(1, 'vanilla', 'noglitches', 'inverted', 'random',
'normal', 'normal', 'none', 'on', 'ganon',
'balanced', True, False, False, False, False, False,
False, False, False, None, 'none', False)
self.world.difficulty_requirements = difficulties['normal']
create_inverted_regions(self.world, 1)
create_dungeons(self.world, 1)
link_inverted_entrances(self.world, 1)
generate_itempool(self.world, 1)
self.world.required_medallions[1] = ['Ether', 'Quake']
self.world.itempool.extend(get_dungeon_item_pool(self.world))
self.world.itempool.extend(
ItemFactory([
'Green Pendant', 'Red Pendant', 'Blue Pendant',
'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2',
'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'
], 1))
self.world.get_location('Agahnim 1', 1).item = None
self.world.get_location('Agahnim 2', 1).item = None
mark_light_world_regions(self.world)
set_rules(self.world, 1)
def setUp(self):
self.world = World(1, 'vanilla', 'noglitches', 'open', 'random',
'normal', 'normal', 'none', 'on', 'ganon',
'balanced', True, False, False, False, False, False,
False, False, False, None, 'none', False)
self.starting_regions = []
self.world.difficulty_requirements = difficulties['normal']
create_regions(self.world, 1)
create_dungeons(self.world, 1)
for exitname, regionname in mandatory_connections:
connect_simple(self.world, exitname, regionname, 1)
connect_simple(self.world, self.world.get_entrance('Big Bomb Shop', 1),
self.world.get_region('Big Bomb Shop', 1), 1)
self.world.swamp_patch_required[1] = True
set_rules(self.world, 1)
generate_itempool(self.world, 1)
self.world.itempool.extend(get_dungeon_item_pool(self.world))
self.world.itempool.extend(
ItemFactory([
'Green Pendant', 'Red Pendant', 'Blue Pendant',
'Beat Agahnim 1', 'Beat Agahnim 2', 'Crystal 1', 'Crystal 2',
'Crystal 3', 'Crystal 4', 'Crystal 5', 'Crystal 6', 'Crystal 7'
], 1))
def copy_world(world):
# ToDo: Not good yet
ret = World(world.players, world.shuffle, world.logic, world.mode,
world.swords, world.difficulty, world.difficulty_adjustments,
world.timer, world.progressive, world.goal, world.algorithm,
world.accessibility, world.shuffle_ganon, world.retro,
world.custom, world.customitemarray, world.hints)
ret.teams = world.teams
ret.player_names = copy.deepcopy(world.player_names)
ret.remote_items = world.remote_items.copy()
ret.required_medallions = world.required_medallions.copy()
ret.swamp_patch_required = world.swamp_patch_required.copy()
ret.ganon_at_pyramid = world.ganon_at_pyramid.copy()
ret.powder_patch_required = world.powder_patch_required.copy()
ret.ganonstower_vanilla = world.ganonstower_vanilla.copy()
ret.treasure_hunt_count = world.treasure_hunt_count.copy()
ret.treasure_hunt_icon = world.treasure_hunt_icon.copy()
ret.sewer_light_cone = world.sewer_light_cone.copy()
ret.light_world_light_cone = world.light_world_light_cone
ret.dark_world_light_cone = world.dark_world_light_cone
ret.seed = world.seed
ret.can_access_trock_eyebridge = world.can_access_trock_eyebridge.copy()
ret.can_access_trock_front = world.can_access_trock_front.copy()
ret.can_access_trock_big_chest = world.can_access_trock_big_chest.copy()
ret.can_access_trock_middle = world.can_access_trock_middle.copy()
ret.can_take_damage = world.can_take_damage
ret.difficulty_requirements = world.difficulty_requirements.copy()
ret.fix_fake_world = world.fix_fake_world.copy()
ret.lamps_needed_for_dark_rooms = world.lamps_needed_for_dark_rooms
ret.mapshuffle = world.mapshuffle.copy()
ret.compassshuffle = world.compassshuffle.copy()
ret.keyshuffle = world.keyshuffle.copy()
ret.bigkeyshuffle = world.bigkeyshuffle.copy()
ret.crystals_needed_for_ganon = world.crystals_needed_for_ganon.copy()
ret.crystals_needed_for_gt = world.crystals_needed_for_gt.copy()
ret.open_pyramid = world.open_pyramid.copy()
ret.boss_shuffle = world.boss_shuffle.copy()
ret.enemy_shuffle = world.enemy_shuffle.copy()
ret.enemy_health = world.enemy_health.copy()
ret.enemy_damage = world.enemy_damage.copy()
ret.beemizer = world.beemizer.copy()
ret.timer = world.timer.copy()
ret.shufflepots = world.shufflepots.copy()
for player in range(1, world.players + 1):
if world.mode[player] != 'inverted':
create_regions(ret, player)
else:
create_inverted_regions(ret, player)
create_shops(ret, player)
create_dungeons(ret, player)
copy_dynamic_regions_and_locations(world, ret)
# copy bosses
for dungeon in world.dungeons:
for level, boss in dungeon.bosses.items():
ret.get_dungeon(dungeon.name, dungeon.player).bosses[level] = boss
for shop in world.shops:
copied_shop = ret.get_region(shop.region.name, shop.region.player).shop
copied_shop.inventory = copy.copy(shop.inventory)
# connect copied world
for region in world.regions:
copied_region = ret.get_region(region.name, region.player)
copied_region.is_light_world = region.is_light_world
copied_region.is_dark_world = region.is_dark_world
for exit in copied_region.exits:
old_connection = world.get_entrance(exit.name,
exit.player).connected_region
exit.connect(
ret.get_region(old_connection.name, old_connection.player))
# fill locations
for location in world.get_locations():
if location.item is not None:
item = Item(location.item.name,
location.item.advancement,
location.item.priority,
location.item.type,
player=location.item.player)
ret.get_location(location.name, location.player).item = item
item.location = ret.get_location(location.name, location.player)
item.world = ret
if location.event:
ret.get_location(location.name, location.player).event = True
if location.locked:
ret.get_location(location.name, location.player).locked = True
# copy remaining itempool. No item in itempool should have an assigned location
for item in world.itempool:
ret.itempool.append(
Item(item.name,
item.advancement,
item.priority,
item.type,
player=item.player))
for item in world.precollected_items:
ret.push_precollected(ItemFactory(item.name, item.player))
# copy progress items in state
ret.state.prog_items = world.state.prog_items.copy()
ret.state.stale = {player: True for player in range(1, world.players + 1)}
for player in range(1, world.players + 1):
set_rules(ret, player)
return ret
def main(args, seed=None):
if args.outputpath:
os.makedirs(args.outputpath, exist_ok=True)
output_path.cached_path = args.outputpath
start = time.process_time()
# initialize the world
world = World(args.multi, args.shuffle, args.logic, args.mode, args.swords,
args.difficulty, args.item_functionality, args.timer,
args.progressive, args.goal, args.algorithm,
args.accessibility, args.shuffleganon, args.retro,
args.custom, args.customitemarray, args.hints)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
world.remote_items = args.remote_items.copy()
world.mapshuffle = args.mapshuffle.copy()
world.compassshuffle = args.compassshuffle.copy()
world.keyshuffle = args.keyshuffle.copy()
world.bigkeyshuffle = args.bigkeyshuffle.copy()
world.crystals_needed_for_ganon = {
player: random.randint(0, 7) if args.crystals_ganon[player] == 'random'
else int(args.crystals_ganon[player])
for player in range(1, world.players + 1)
}
world.crystals_needed_for_gt = {
player: random.randint(0, 7) if args.crystals_gt[player] == 'random'
else int(args.crystals_gt[player])
for player in range(1, world.players + 1)
}
world.open_pyramid = args.openpyramid.copy()
world.boss_shuffle = args.shufflebosses.copy()
world.enemy_shuffle = args.shuffleenemies.copy()
world.enemy_health = args.enemy_health.copy()
world.enemy_damage = args.enemy_damage.copy()
world.beemizer = args.beemizer.copy()
world.rom_seeds = {
player: random.randint(0, 999999999)
for player in range(1, world.players + 1)
}
logger.info('ALttP Entrance Randomizer Version %s - Seed: %s\n',
__version__, world.seed)
parsed_names = parse_player_names(args.names, world.players, args.teams)
world.teams = len(parsed_names)
for i, team in enumerate(parsed_names, 1):
if world.players > 1:
logger.info('%s%s',
'Team%d: ' % i if world.teams > 1 else 'Players: ',
', '.join(team))
for player, name in enumerate(team, 1):
world.player_names[player].append(name)
logger.info('')
for player in range(1, world.players + 1):
world.difficulty_requirements[player] = difficulties[
world.difficulty[player]]
if world.mode[player] == 'standard' and world.enemy_shuffle[
player] != 'none':
world.escape_assist[player].append(
'bombs'
) # enemized escape assumes infinite bombs available and will likely be unbeatable without it
for tok in filter(None, args.startinventory[player].split(',')):
item = ItemFactory(tok.strip(), player)
if item:
world.push_precollected(item)
if world.mode[player] != 'inverted':
create_regions(world, player)
else:
create_inverted_regions(world, player)
create_shops(world, player)
create_dungeons(world, player)
logger.info('Shuffling the World about.')
for player in range(1, world.players + 1):
if world.mode[player] != 'inverted':
link_entrances(world, player)
mark_light_world_regions(world, player)
else:
link_inverted_entrances(world, player)
mark_dark_world_regions(world, player)
logger.info('Generating Item Pool.')
for player in range(1, world.players + 1):
generate_itempool(world, player)
logger.info('Calculating Access Rules.')
for player in range(1, world.players + 1):
set_rules(world, player)
logger.info('Placing Dungeon Prizes.')
fill_prizes(world)
logger.info('Placing Dungeon Items.')
shuffled_locations = None
if args.algorithm in ['balanced', 'vt26'] or any(
list(args.mapshuffle.values()) +
list(args.compassshuffle.values()) +
list(args.keyshuffle.values()) +
list(args.bigkeyshuffle.values())):
shuffled_locations = world.get_unfilled_locations()
random.shuffle(shuffled_locations)
fill_dungeons_restrictive(world, shuffled_locations)
else:
fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(
world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt21':
distribute_items_cutoff(world, 1)
elif args.algorithm == 'vt22':
distribute_items_cutoff(world, 0.66)
elif args.algorithm == 'freshness':
distribute_items_staleness(world)
elif args.algorithm == 'vt25':
distribute_items_restrictive(world, False)
elif args.algorithm == 'vt26':
distribute_items_restrictive(world, True, shuffled_locations)
elif args.algorithm == 'balanced':
distribute_items_restrictive(world, True)
if world.players > 1:
logger.info('Balancing multiworld progression.')
balance_multiworld_progression(world)
logger.info('Patching ROM.')
outfilebase = 'ER_%s' % (args.outputname
if args.outputname else world.seed)
rom_names = []
jsonout = {}
if not args.suppress_rom:
for team in range(world.teams):
for player in range(1, world.players + 1):
sprite_random_on_hit = type(
args.sprite[player]) is str and args.sprite[player].lower(
) == 'randomonhit'
use_enemizer = (world.boss_shuffle[player] != 'none'
or world.enemy_shuffle[player] != 'none'
or world.enemy_health[player] != 'default'
or world.enemy_damage[player] != 'default'
or args.shufflepots[player]
or sprite_random_on_hit)
rom = JsonRom() if args.jsonout or use_enemizer else LocalRom(
args.rom)
patch_rom(world, rom, player, team, use_enemizer)
if use_enemizer and (args.enemizercli or not args.jsonout):
patch_enemizer(world, player, rom, args.rom,
args.enemizercli, args.shufflepots[player],
sprite_random_on_hit)
if not args.jsonout:
rom = LocalRom.fromJsonRom(rom, args.rom, 0x400000)
if args.race:
patch_race_rom(rom)
rom_names.append((player, team, list(rom.name)))
world.spoiler.hashes[(player,
team)] = get_hash_string(rom.hash)
apply_rom_settings(
rom, args.heartbeep[player], args.heartcolor[player],
args.quickswap[player], args.fastmenu[player],
args.disablemusic[player], args.sprite[player],
args.ow_palettes[player], args.uw_palettes[player])
if args.jsonout:
jsonout[f'patch_t{team}_p{player}'] = rom.patches
else:
mcsb_name = ''
if all([
world.mapshuffle[player],
world.compassshuffle[player],
world.keyshuffle[player],
world.bigkeyshuffle[player]
]):
mcsb_name = '-keysanity'
elif [
world.mapshuffle[player],
world.compassshuffle[player],
world.keyshuffle[player],
world.bigkeyshuffle[player]
].count(True) == 1:
mcsb_name = '-mapshuffle' if world.mapshuffle[
player] else '-compassshuffle' if world.compassshuffle[
player] else '-keyshuffle' if world.keyshuffle[
player] else '-bigkeyshuffle'
elif any([
world.mapshuffle[player],
world.compassshuffle[player],
world.keyshuffle[player],
world.bigkeyshuffle[player]
]):
mcsb_name = '-%s%s%s%sshuffle' % (
'M' if world.mapshuffle[player] else '',
'C' if world.compassshuffle[player] else '',
'S' if world.keyshuffle[player] else '',
'B' if world.bigkeyshuffle[player] else '')
outfilepname = f'_T{team+1}' if world.teams > 1 else ''
if world.players > 1:
outfilepname += f'_P{player}'
if world.players > 1 or world.teams > 1:
outfilepname += f"_{world.player_names[player][team].replace(' ', '_')}" if world.player_names[
player][team] != 'Player %d' % player else ''
outfilesuffix = (
'_%s_%s-%s-%s-%s%s_%s-%s%s%s%s%s' %
(world.logic[player], world.difficulty[player],
world.difficulty_adjustments[player],
world.mode[player], world.goal[player],
"" if world.timer in ['none', 'display'] else "-" +
world.timer, world.shuffle[player], world.algorithm,
mcsb_name, "-retro" if world.retro[player] else "",
"-prog_" + world.progressive
if world.progressive in ['off', 'random'] else "",
"-nohints" if not world.hints[player] else "")
) if not args.outputname else ''
rom.write_to_file(
output_path(
f'{outfilebase}{outfilepname}{outfilesuffix}.sfc'))
multidata = zlib.compress(
json.dumps({
"names":
parsed_names,
"roms":
rom_names,
"remote_items": [
player for player in range(1, world.players + 1)
if world.remote_items[player]
],
"locations": [((location.address, location.player),
(location.item.code, location.item.player))
for location in world.get_filled_locations()
if type(location.address) is int]
}).encode("utf-8"))
if args.jsonout:
jsonout["multidata"] = list(multidata)
else:
with open(output_path('%s_multidata' % outfilebase), 'wb') as f:
f.write(multidata)
if args.create_spoiler and not args.jsonout:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
if not args.skip_playthrough:
logger.info('Calculating playthrough.')
create_playthrough(world)
if args.jsonout:
print(json.dumps({**jsonout, 'spoiler': world.spoiler.to_json()}))
elif args.create_spoiler and not args.skip_playthrough:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.process_time() - start)
return world
def main(seed=None, shuffle='default', logic='noglitches', mode='standard', difficulty='normal', goal='ganon', algo='regular', spoiler=True, base_rom='Open_Base_Rom.sfc'):
start = time.clock()
# initialize the world
world = World(shuffle, logic, mode, difficulty, goal)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = seed
random.seed(world.seed)
world.spoiler += 'ALttP Entrance Randomizer Version %s - Seed: %s\n\n' % (__version__, world.seed)
world.spoiler += 'Logic: %s Mode: %s Goal: %s Entrance Shuffle: %s Filling Algorithm: %s\n\n' % (logic, mode, goal, shuffle, algo) # todo
logger.info(world.spoiler)
create_regions(world)
logger.info('Shuffling the World about.')
world.spoiler += link_entrances(world)
logger.info('Calculating Access Rules.')
world.spoiler += set_rules(world)
logger.info('Generating Item Pool and placing Dungeon Items.')
world.spoiler += generate_itempool(world)
logger.info('Fill the world.')
if algo == 'flood':
flood_items(world) # different algo, biased towards early game progress items
else:
distribute_items(world)
world.spoiler += print_location_spoiler(world)
logger.info('Calculating playthrough.')
world.spoiler += create_playthrough(world)
logger.info('Patching ROM.')
rom = bytearray(open(base_rom, 'rb').read())
patched_rom = patch_rom(world, rom)
outfilebase = 'ER_%s_%s_%s_%s' % (world.mode, world.goal, world.shuffle, world.seed)
with open('%s.sfc' % outfilebase, 'wb') as outfile:
outfile.write(patched_rom)
if spoiler:
with open('%s_Spoiler.txt' % outfilebase, 'w') as outfile:
outfile.write(world.spoiler)
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s' % (time.clock() - start))
return world
def main(args, seed=None):
if args.outputpath:
os.makedirs(args.outputpath, exist_ok=True)
output_path.cached_path = args.outputpath
start = time.perf_counter()
# initialize the world
world = World(args.multi, args.shuffle, args.logic, args.mode, args.swords,
args.difficulty, args.item_functionality, args.timer,
args.progressive.copy(), args.goal, args.algorithm,
args.accessibility, args.shuffleganon, args.retro,
args.custom, args.customitemarray, args.hints)
logger = logging.getLogger('')
world.seed = get_seed(seed)
random.seed(world.seed)
world.remote_items = args.remote_items.copy()
world.mapshuffle = args.mapshuffle.copy()
world.compassshuffle = args.compassshuffle.copy()
world.keyshuffle = args.keyshuffle.copy()
world.bigkeyshuffle = args.bigkeyshuffle.copy()
world.crystals_needed_for_ganon = {
player: random.randint(0, 7) if args.crystals_ganon[player] == 'random'
else int(args.crystals_ganon[player])
for player in range(1, world.players + 1)
}
world.crystals_needed_for_gt = {
player: random.randint(0, 7) if args.crystals_gt[player] == 'random'
else int(args.crystals_gt[player])
for player in range(1, world.players + 1)
}
world.open_pyramid = args.openpyramid.copy()
world.boss_shuffle = args.shufflebosses.copy()
world.enemy_shuffle = args.shuffleenemies.copy()
world.enemy_health = args.enemy_health.copy()
world.enemy_damage = args.enemy_damage.copy()
world.beemizer = args.beemizer.copy()
world.timer = args.timer.copy()
world.shufflepots = args.shufflepots.copy()
world.progressive = args.progressive.copy()
world.dungeon_counters = args.dungeon_counters.copy()
world.glitch_boots = args.glitch_boots.copy()
world.triforce_pieces_available = args.triforce_pieces_available.copy()
world.triforce_pieces_required = args.triforce_pieces_required.copy()
world.progression_balancing = {
player: not balance
for player, balance in args.skip_progression_balancing.items()
}
world.rom_seeds = {
player: random.randint(0, 999999999)
for player in range(1, world.players + 1)
}
logger.info('ALttP Berserker\'s Multiworld Version %s - Seed: %s\n',
__version__, world.seed)
parsed_names = parse_player_names(args.names, world.players, args.teams)
world.teams = len(parsed_names)
for i, team in enumerate(parsed_names, 1):
if world.players > 1:
logger.info('%s%s',
'Team%d: ' % i if world.teams > 1 else 'Players: ',
', '.join(team))
for player, name in enumerate(team, 1):
world.player_names[player].append(name)
logger.info('')
for player in range(1, world.players + 1):
world.difficulty_requirements[player] = difficulties[
world.difficulty[player]]
if world.mode[player] == 'standard' and world.enemy_shuffle[
player] != 'none':
world.escape_assist[player].append(
'bombs'
) # enemized escape assumes infinite bombs available and will likely be unbeatable without it
for tok in filter(None, args.startinventory[player].split(',')):
item = ItemFactory(tok.strip(), player)
if item:
world.push_precollected(item)
world.local_items[player] = {
item.strip()
for item in args.local_items[player].split(',')
}
world.triforce_pieces_available[player] = max(
world.triforce_pieces_available[player],
world.triforce_pieces_required[player])
if world.mode[player] != 'inverted':
create_regions(world, player)
else:
create_inverted_regions(world, player)
create_shops(world, player)
create_dungeons(world, player)
logger.info('Shuffling the World about.')
for player in range(1, world.players + 1):
if world.mode[player] != 'inverted':
link_entrances(world, player)
mark_light_world_regions(world, player)
else:
link_inverted_entrances(world, player)
mark_dark_world_regions(world, player)
logger.info('Generating Item Pool.')
for player in range(1, world.players + 1):
generate_itempool(world, player)
logger.info('Calculating Access Rules.')
for player in range(1, world.players + 1):
set_rules(world, player)
logger.info('Placing Dungeon Prizes.')
fill_prizes(world)
logger.info('Placing Dungeon Items.')
shuffled_locations = None
if args.algorithm in ['balanced', 'vt26'] or any(
list(args.mapshuffle.values()) +
list(args.compassshuffle.values()) +
list(args.keyshuffle.values()) +
list(args.bigkeyshuffle.values())):
shuffled_locations = world.get_unfilled_locations()
random.shuffle(shuffled_locations)
fill_dungeons_restrictive(world, shuffled_locations)
else:
fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(
world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt21':
distribute_items_cutoff(world, 1)
elif args.algorithm == 'vt22':
distribute_items_cutoff(world, 0.66)
elif args.algorithm == 'freshness':
distribute_items_staleness(world)
elif args.algorithm == 'vt25':
distribute_items_restrictive(world, False)
elif args.algorithm == 'vt26':
distribute_items_restrictive(world, True, shuffled_locations)
elif args.algorithm == 'balanced':
distribute_items_restrictive(world, True)
if world.players > 1:
balance_multiworld_progression(world)
logger.info('Patching ROM.')
outfilebase = 'BM_%s' % (args.outputname
if args.outputname else world.seed)
rom_names = []
def _gen_rom(team: int, player: int):
sprite_random_on_hit = type(
args.sprite[player]) is str and args.sprite[player].lower(
) == 'randomonhit'
use_enemizer = (world.boss_shuffle[player] != 'none'
or world.enemy_shuffle[player] != 'none'
or world.enemy_health[player] != 'default'
or world.enemy_damage[player] != 'default'
or args.shufflepots[player] or sprite_random_on_hit)
rom = LocalRom(args.rom)
patch_rom(world, rom, player, team, use_enemizer)
if use_enemizer:
patch_enemizer(world, player, rom, args.enemizercli,
sprite_random_on_hit)
if args.race:
patch_race_rom(rom)
world.spoiler.hashes[(player, team)] = get_hash_string(rom.hash)
apply_rom_settings(rom, args.heartbeep[player],
args.heartcolor[player], args.quickswap[player],
args.fastmenu[player], args.disablemusic[player],
args.sprite[player], args.ow_palettes[player],
args.uw_palettes[player])
mcsb_name = ''
if all([
world.mapshuffle[player], world.compassshuffle[player],
world.keyshuffle[player], world.bigkeyshuffle[player]
]):
mcsb_name = '-keysanity'
elif [
world.mapshuffle[player], world.compassshuffle[player],
world.keyshuffle[player], world.bigkeyshuffle[player]
].count(True) == 1:
mcsb_name = '-mapshuffle' if world.mapshuffle[
player] else '-compassshuffle' if world.compassshuffle[
player] else '-keyshuffle' if world.keyshuffle[
player] else '-bigkeyshuffle'
elif any([
world.mapshuffle[player], world.compassshuffle[player],
world.keyshuffle[player], world.bigkeyshuffle[player]
]):
mcsb_name = '-%s%s%s%sshuffle' % (
'M' if world.mapshuffle[player] else '',
'C' if world.compassshuffle[player] else '',
'S' if world.keyshuffle[player] else '',
'B' if world.bigkeyshuffle[player] else '')
outfilepname = f'_T{team + 1}' if world.teams > 1 else ''
if world.players > 1:
outfilepname += f'_P{player}'
if world.players > 1 or world.teams > 1:
outfilepname += f"_{world.player_names[player][team].replace(' ', '_')}" if world.player_names[
player][team] != 'Player%d' % player else ''
outfilesuffix = (
'_%s_%s-%s-%s-%s%s_%s-%s%s%s%s%s' %
(world.logic[player], world.difficulty[player],
world.difficulty_adjustments[player], world.mode[player],
world.goal[player],
"" if world.timer[player] in [False, 'display'] else "-" +
world.timer[player], world.shuffle[player], world.algorithm,
mcsb_name, "-retro" if world.retro[player] else "",
"-prog_" + world.progressive[player] if world.progressive[player]
in ['off', 'random'] else "", "-nohints" if
not world.hints[player] else "")) if not args.outputname else ''
rompath = output_path(
f'{outfilebase}{outfilepname}{outfilesuffix}.sfc')
rom.write_to_file(rompath)
if args.create_diff:
import Patch
Patch.create_patch_file(rompath)
return (player, team, list(rom.name))
if not args.suppress_rom:
import concurrent.futures
futures = []
with concurrent.futures.ThreadPoolExecutor() as pool:
for team in range(world.teams):
for player in range(1, world.players + 1):
futures.append(pool.submit(_gen_rom, team, player))
for future in futures:
rom_name = future.result()
rom_names.append(rom_name)
def get_entrance_to_region(region: Region):
for entrance in region.entrances:
if entrance.parent_region.type in (RegionType.DarkWorld,
RegionType.LightWorld):
return entrance
for entrance in region.entrances: # BFS might be better here, trying DFS for now.
return get_entrance_to_region(entrance.parent_region)
# collect ER hint info
er_hint_data = {
player: {}
for player in range(1, world.players + 1)
if world.shuffle[player] != "vanilla"
}
from Regions import RegionType
for region in world.regions:
if region.player in er_hint_data and region.locations:
main_entrance = get_entrance_to_region(region)
for location in region.locations:
if type(location.address
) == int: # skips events and crystals
if lookup_vanilla_location_to_entrance[
location.address] != main_entrance.name:
er_hint_data[region.player][
location.address] = main_entrance.name
precollected_items = [[] for player in range(world.players)]
for item in world.precollected_items:
precollected_items[item.player - 1].append(item.code)
multidata = zlib.compress(
json.dumps({
"names":
parsed_names,
"roms":
rom_names,
"remote_items": [
player for player in range(1, world.players + 1)
if world.remote_items[player]
],
"locations": [((location.address, location.player),
(location.item.code, location.item.player))
for location in world.get_filled_locations()
if type(location.address) is int],
"server_options":
get_options()["server_options"],
"er_hint_data":
er_hint_data,
"precollected_items":
precollected_items
}).encode("utf-8"), 9)
with open(output_path('%s.multidata' % outfilebase), 'wb') as f:
f.write(multidata)
if not args.skip_playthrough:
logger.info('Calculating playthrough.')
create_playthrough(world)
if args.create_spoiler:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.perf_counter() - start)
return world
def generate(settings, window):
logger = logging.getLogger('')
worlds = []
for i in range(0, settings.world_count):
worlds.append(World(i, settings))
window.update_status('Creating the Worlds')
for id, world in enumerate(worlds):
logger.info('Generating World %d.' % (id + 1))
window.update_progress(0 + 1 * (id + 1) / settings.world_count)
logger.info('Creating Overworld')
if settings.logic_rules == 'glitched':
overworld_data = os.path.join(data_path('Glitched World'),
'Overworld.json')
else:
overworld_data = os.path.join(data_path('World'), 'Overworld.json')
# Compile the json rules based on settings
world.load_regions_from_json(overworld_data)
create_dungeons(world)
world.create_internal_locations()
if settings.shopsanity != 'off':
world.random_shop_prices()
world.set_scrub_prices()
window.update_progress(0 + 4 * (id + 1) / settings.world_count)
logger.info('Calculating Access Rules.')
set_rules(world)
window.update_progress(0 + 5 * (id + 1) / settings.world_count)
logger.info('Generating Item Pool.')
generate_itempool(world)
set_shop_rules(world)
set_drop_location_names(world)
world.fill_bosses()
if settings.triforce_hunt:
settings.distribution.configure_triforce_hunt(worlds)
logger.info('Setting Entrances.')
set_entrances(worlds)
window.update_status('Placing the Items')
logger.info('Fill the world.')
distribute_items_restrictive(window, worlds)
window.update_progress(35)
spoiler = Spoiler(worlds)
if settings.create_spoiler:
window.update_status('Calculating Spoiler Data')
logger.info('Calculating playthrough.')
create_playthrough(spoiler)
window.update_progress(50)
if settings.create_spoiler or settings.hints != 'none':
window.update_status('Calculating Hint Data')
logger.info('Calculating hint data.')
State.update_required_items(spoiler)
buildGossipHints(spoiler, worlds)
window.update_progress(55)
spoiler.build_file_hash()
return spoiler
def main(settings, window=dummy_window()):
start = time.process_time()
logger = logging.getLogger('')
worlds = []
allowed_tricks = {}
for trick in logic_tricks.values():
settings.__dict__[
trick['name']] = trick['name'] in settings.allowed_tricks
settings.load_distribution()
# we load the rom before creating the seed so that error get caught early
if settings.compress_rom == 'None' and not settings.create_spoiler:
raise Exception(
'`No Output` must have spoiler enabled to produce anything.')
if settings.compress_rom != 'None':
window.update_status('Loading ROM')
rom = Rom(settings.rom)
if not settings.world_count:
settings.world_count = 1
if settings.world_count < 1 or settings.world_count > 255:
raise Exception('World Count must be between 1 and 255')
if settings.player_num > settings.world_count or settings.player_num < 1:
if settings.compress_rom not in ['None', 'Patch']:
raise Exception('Player Num must be between 1 and %d' %
settings.world_count)
else:
settings.player_num = 1
logger.info('OoT Randomizer Version %s - Seed: %s\n\n', __version__,
settings.seed)
settings.remove_disabled()
random.seed(settings.numeric_seed)
settings.resolve_random_settings()
for i in range(0, settings.world_count):
worlds.append(World(settings))
window.update_status('Creating the Worlds')
for id, world in enumerate(worlds):
world.id = id
world.distribution = settings.distribution.world_dists[id]
logger.info('Generating World %d.' % id)
window.update_progress(0 + 1 * (id + 1) / settings.world_count)
logger.info('Creating Overworld')
# Determine MQ Dungeons
dungeon_pool = list(world.dungeon_mq)
dist_num_mq = world.distribution.configure_dungeons(
world, dungeon_pool)
if world.mq_dungeons_random:
for dungeon in dungeon_pool:
world.dungeon_mq[dungeon] = random.choice([True, False])
world.mq_dungeons = list(world.dungeon_mq.values()).count(True)
else:
mqd_picks = random.sample(dungeon_pool,
world.mq_dungeons - dist_num_mq)
for dung in mqd_picks:
world.dungeon_mq[dung] = True
if settings.logic_rules == 'glitched':
overworld_data = os.path.join(data_path('Glitched World'),
'Overworld.json')
else:
overworld_data = os.path.join(data_path('World'), 'Overworld.json')
world.load_regions_from_json(overworld_data)
create_dungeons(world)
if settings.shopsanity != 'off':
world.random_shop_prices()
world.set_scrub_prices()
window.update_progress(0 + 4 * (id + 1) / settings.world_count)
logger.info('Calculating Access Rules.')
set_rules(world)
window.update_progress(0 + 5 * (id + 1) / settings.world_count)
logger.info('Generating Item Pool.')
generate_itempool(world)
set_shop_rules(world)
set_drop_location_names(world)
logger.info('Setting Entrances.')
set_entrances(worlds)
window.update_status('Placing the Items')
logger.info('Fill the world.')
distribute_items_restrictive(window, worlds)
window.update_progress(35)
spoiler = Spoiler(worlds)
cosmetics_log = None
if settings.create_spoiler:
window.update_status('Calculating Spoiler Data')
logger.info('Calculating playthrough.')
create_playthrough(spoiler)
window.update_progress(50)
if settings.create_spoiler or settings.hints != 'none':
window.update_status('Calculating Hint Data')
State.update_required_items(spoiler)
for world in worlds:
world.update_useless_areas(spoiler)
buildGossipHints(spoiler, world)
window.update_progress(55)
spoiler.build_file_hash()
logger.info('Patching ROM.')
settings_string_hash = hashlib.sha1(
settings.settings_string.encode('utf-8')).hexdigest().upper()[:5]
if settings.output_file:
outfilebase = settings.output_file
elif settings.world_count > 1:
outfilebase = 'OoT_%s_%s_W%d' % (settings_string_hash, settings.seed,
settings.world_count)
else:
outfilebase = 'OoT_%s_%s' % (settings_string_hash, settings.seed)
output_dir = default_output_path(settings.output_dir)
if settings.compress_rom == 'Patch':
rng_state = random.getstate()
file_list = []
window.update_progress(65)
for world in worlds:
if settings.world_count > 1:
window.update_status('Patching ROM: Player %d' %
(world.id + 1))
patchfilename = '%sP%d.zpf' % (outfilebase, world.id + 1)
else:
window.update_status('Patching ROM')
patchfilename = '%s.zpf' % outfilebase
random.setstate(rng_state)
patch_rom(spoiler, world, rom, outfilebase)
cosmetics_log = patch_cosmetics(settings, rom)
window.update_progress(65 + 20 *
(world.id + 1) / settings.world_count)
window.update_status('Creating Patch File')
output_path = os.path.join(output_dir, patchfilename)
file_list.append(patchfilename)
create_patch_file(rom, output_path)
rom.restore()
window.update_progress(65 + 30 *
(world.id + 1) / settings.world_count)
if settings.create_cosmetics_log and cosmetics_log:
window.update_status('Creating Cosmetics Log')
if settings.world_count > 1:
cosmetics_log_filename = "%sP%d_Cosmetics.txt" % (
outfilebase, world.id + 1)
else:
cosmetics_log_filename = '%s_Cosmetics.txt' % outfilebase
cosmetics_log.to_file(
os.path.join(output_dir, cosmetics_log_filename))
file_list.append(cosmetics_log_filename)
cosmetics_log = None
if settings.world_count > 1:
window.update_status('Creating Patch Archive')
output_path = os.path.join(output_dir, '%s.zpfz' % outfilebase)
with zipfile.ZipFile(output_path, mode="w") as patch_archive:
for file in file_list:
file_path = os.path.join(output_dir, file)
patch_archive.write(file_path,
file.replace(outfilebase, ''),
compress_type=zipfile.ZIP_DEFLATED)
for file in file_list:
os.remove(os.path.join(output_dir, file))
logger.info("Created patchfile at: %s" % output_path)
window.update_progress(95)
elif settings.compress_rom != 'None':
window.update_status('Patching ROM')
patch_rom(spoiler, worlds[settings.player_num - 1], rom, outfilebase)
cosmetics_log = patch_cosmetics(settings, rom)
window.update_progress(65)
window.update_status('Saving Uncompressed ROM')
if settings.world_count > 1:
filename = "%sP%d.z64" % (outfilebase, settings.player_num)
else:
filename = '%s.z64' % outfilebase
output_path = os.path.join(output_dir, filename)
rom.write_to_file(output_path)
if settings.compress_rom == 'True':
window.update_status('Compressing ROM')
logger.info('Compressing ROM.')
if is_bundled():
compressor_path = "."
else:
compressor_path = "Compress"
if platform.system() == 'Windows':
if 8 * struct.calcsize("P") == 64:
compressor_path += "\\Compress.exe"
else:
compressor_path += "\\Compress32.exe"
elif platform.system() == 'Linux':
if platform.uname()[4] == 'aarch64' or platform.uname(
)[4] == 'arm64':
compressor_path += "/Compress_ARM64"
else:
compressor_path += "/Compress"
elif platform.system() == 'Darwin':
compressor_path += "/Compress.out"
else:
compressor_path = ""
logger.info('OS not supported for compression')
output_compress_path = output_path[:output_path.
rfind('.')] + '-comp.z64'
if compressor_path != "":
run_process(
window, logger,
[compressor_path, output_path, output_compress_path])
os.remove(output_path)
logger.info("Created compessed rom at: %s" % output_compress_path)
else:
logger.info("Created uncompessed rom at: %s" % output_path)
window.update_progress(95)
for world in worlds:
for info in setting_infos:
world.settings.__dict__[info.name] = world.__dict__[info.name]
settings.distribution.update_spoiler(spoiler)
if settings.create_spoiler:
window.update_status('Creating Spoiler Log')
spoiler_path = os.path.join(output_dir,
'%s_Spoiler.json' % outfilebase)
settings.distribution.to_file(spoiler_path)
logger.info("Created spoiler log at: %s" %
('%s_Spoiler.json' % outfilebase))
else:
window.update_status('Creating Settings Log')
settings_path = os.path.join(output_dir,
'%s_Settings.json' % outfilebase)
settings.distribution.to_file(settings_path)
logger.info("Created settings log at: %s" %
('%s_Settings.json' % outfilebase))
if settings.create_cosmetics_log and cosmetics_log:
window.update_status('Creating Cosmetics Log')
if settings.world_count > 1 and not settings.output_file:
filename = "%sP%d_Cosmetics.txt" % (outfilebase,
settings.player_num)
else:
filename = '%s_Cosmetics.txt' % outfilebase
cosmetic_path = os.path.join(output_dir, filename)
cosmetics_log.to_file(cosmetic_path)
logger.info("Created cosmetic log at: %s" % cosmetic_path)
window.update_progress(100)
if cosmetics_log and cosmetics_log.error:
window.update_status(
'Success: Rom patched successfully. Some cosmetics could not be applied.'
)
else:
window.update_status('Success: Rom patched successfully')
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.process_time() - start)
return worlds[settings.player_num - 1]
def main(args, seed=None):
if args.outputpath:
os.makedirs(args.outputpath, exist_ok=True)
output_path.cached_path = args.outputpath
start = time.perf_counter()
# initialize the world
world = World(args.multi, args.shuffle, args.logic, args.mode, args.swords,
args.difficulty, args.item_functionality, args.timer,
args.progressive.copy(), args.goal, args.algorithm,
args.accessibility, args.shuffleganon, args.retro,
args.custom, args.customitemarray, args.hints)
logger = logging.getLogger('')
world.seed = get_seed(seed)
if args.race:
world.secure()
else:
world.random.seed(world.seed)
world.remote_items = args.remote_items.copy()
world.mapshuffle = args.mapshuffle.copy()
world.compassshuffle = args.compassshuffle.copy()
world.keyshuffle = args.keyshuffle.copy()
world.bigkeyshuffle = args.bigkeyshuffle.copy()
world.crystals_needed_for_ganon = {
player: world.random.randint(0, 7) if args.crystals_ganon[player]
== 'random' else int(args.crystals_ganon[player])
for player in range(1, world.players + 1)
}
world.crystals_needed_for_gt = {
player: world.random.randint(0, 7) if args.crystals_gt[player]
== 'random' else int(args.crystals_gt[player])
for player in range(1, world.players + 1)
}
world.open_pyramid = args.open_pyramid.copy()
world.boss_shuffle = args.shufflebosses.copy()
world.enemy_shuffle = args.enemy_shuffle.copy()
world.enemy_health = args.enemy_health.copy()
world.enemy_damage = args.enemy_damage.copy()
world.killable_thieves = args.killable_thieves.copy()
world.bush_shuffle = args.bush_shuffle.copy()
world.tile_shuffle = args.tile_shuffle.copy()
world.beemizer = args.beemizer.copy()
world.timer = args.timer.copy()
world.countdown_start_time = args.countdown_start_time.copy()
world.red_clock_time = args.red_clock_time.copy()
world.blue_clock_time = args.blue_clock_time.copy()
world.green_clock_time = args.green_clock_time.copy()
world.shufflepots = args.shufflepots.copy()
world.progressive = args.progressive.copy()
world.dungeon_counters = args.dungeon_counters.copy()
world.glitch_boots = args.glitch_boots.copy()
world.triforce_pieces_available = args.triforce_pieces_available.copy()
world.triforce_pieces_required = args.triforce_pieces_required.copy()
world.shop_shuffle = args.shop_shuffle.copy()
world.shop_shuffle_slots = args.shop_shuffle_slots.copy()
world.progression_balancing = {
player: not balance
for player, balance in args.skip_progression_balancing.items()
}
world.shuffle_prizes = args.shuffle_prizes.copy()
world.sprite_pool = args.sprite_pool.copy()
world.dark_room_logic = args.dark_room_logic.copy()
world.plando_items = args.plando_items.copy()
world.plando_texts = args.plando_texts.copy()
world.plando_connections = args.plando_connections.copy()
world.restrict_dungeon_item_on_boss = args.restrict_dungeon_item_on_boss.copy(
)
world.required_medallions = args.required_medallions.copy()
world.rom_seeds = {
player: random.Random(world.random.randint(0, 999999999))
for player in range(1, world.players + 1)
}
logger.info('ALttP Berserker\'s Multiworld Version %s - Seed: %s\n',
__version__, world.seed)
parsed_names = parse_player_names(args.names, world.players, args.teams)
world.teams = len(parsed_names)
for i, team in enumerate(parsed_names, 1):
if world.players > 1:
logger.info('%s%s',
'Team%d: ' % i if world.teams > 1 else 'Players: ',
', '.join(team))
for player, name in enumerate(team, 1):
world.player_names[player].append(name)
logger.info('')
for player in range(1, world.players + 1):
world.difficulty_requirements[player] = difficulties[
world.difficulty[player]]
if world.open_pyramid[player] == 'goal':
world.open_pyramid[player] = world.goal[player] in {
'crystals', 'ganontriforcehunt', 'localganontriforcehunt',
'ganonpedestal'
}
elif world.open_pyramid[player] == 'auto':
world.open_pyramid[player] = world.goal[player] in {'crystals', 'ganontriforcehunt', 'localganontriforcehunt', 'ganonpedestal'} and \
(world.shuffle[player] in {'vanilla', 'dungeonssimple', 'dungeonsfull'} or not world.shuffle_ganon)
else:
world.open_pyramid[player] = {
'on': True,
'off': False,
'yes': True,
'no': False
}.get(world.open_pyramid[player], world.open_pyramid[player])
for tok in filter(None, args.startinventory[player].split(',')):
item = ItemFactory(tok.strip(), player)
if item:
world.push_precollected(item)
# item in item_table gets checked in mystery, but not CLI - so we double-check here
world.local_items[player] = {
item.strip()
for item in args.local_items[player].split(',')
if item.strip() in item_table
}
world.non_local_items[player] = {
item.strip()
for item in args.non_local_items[player].split(',')
if item.strip() in item_table
}
# enforce pre-defined local items.
if world.goal[player] in [
"localtriforcehunt", "localganontriforcehunt"
]:
world.local_items[player].add('Triforce Piece')
# items can't be both local and non-local, prefer local
world.non_local_items[player] -= world.local_items[player]
# dungeon items can't be in non-local if the appropriate dungeon item shuffle setting is not set.
if not world.mapshuffle[player]:
world.non_local_items[player] -= item_name_groups['Maps']
if not world.compassshuffle[player]:
world.non_local_items[player] -= item_name_groups['Compasses']
if not world.keyshuffle[player]:
world.non_local_items[player] -= item_name_groups['Small Keys']
if not world.bigkeyshuffle[player]:
world.non_local_items[player] -= item_name_groups['Big Keys']
# Not possible to place pendants/crystals out side of boss prizes yet.
world.non_local_items[player] -= item_name_groups['Pendants']
world.non_local_items[player] -= item_name_groups['Crystals']
world.triforce_pieces_available[player] = max(
world.triforce_pieces_available[player],
world.triforce_pieces_required[player])
if world.mode[player] != 'inverted':
create_regions(world, player)
else:
create_inverted_regions(world, player)
create_shops(world, player)
create_dungeons(world, player)
logger.info('Shuffling the World about.')
for player in range(1, world.players + 1):
if world.logic[player] not in ["noglitches", "minorglitches"] and world.shuffle[player] in \
{"vanilla", "dungeonssimple", "dungeonsfull", "simple", "restricted", "full"}:
world.fix_fake_world[player] = False
if world.mode[player] != 'inverted':
link_entrances(world, player)
mark_light_world_regions(world, player)
else:
link_inverted_entrances(world, player)
mark_dark_world_regions(world, player)
plando_connect(world, player)
logger.info('Generating Item Pool.')
for player in range(1, world.players + 1):
generate_itempool(world, player)
logger.info('Calculating Access Rules.')
for player in range(1, world.players + 1):
set_rules(world, player)
logger.info("Running Item Plando")
distribute_planned(world)
logger.info('Placing Dungeon Prizes.')
fill_prizes(world)
logger.info('Placing Dungeon Items.')
if args.algorithm in ['balanced', 'vt26'] or any(
list(args.mapshuffle.values()) +
list(args.compassshuffle.values()) +
list(args.keyshuffle.values()) +
list(args.bigkeyshuffle.values())):
fill_dungeons_restrictive(world)
else:
fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(
world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt25':
distribute_items_restrictive(world, False)
elif args.algorithm == 'vt26':
distribute_items_restrictive(world, True)
elif args.algorithm == 'balanced':
distribute_items_restrictive(world, True)
logger.info("Filling Shop Slots")
ShopSlotFill(world)
if world.players > 1:
balance_multiworld_progression(world)
logger.info('Patching ROM.')
outfilebase = 'BM_%s' % (args.outputname
if args.outputname else world.seed)
rom_names = []
def _gen_rom(team: int, player: int):
use_enemizer = (world.boss_shuffle[player] != 'none'
or world.enemy_shuffle[player]
or world.enemy_health[player] != 'default'
or world.enemy_damage[player] != 'default'
or world.shufflepots[player]
or world.bush_shuffle[player]
or world.killable_thieves[player])
rom = LocalRom(args.rom)
patch_rom(world, rom, player, team, use_enemizer)
if use_enemizer:
patch_enemizer(world, team, player, rom, args.enemizercli)
if args.race:
patch_race_rom(rom, world, player)
world.spoiler.hashes[(player, team)] = get_hash_string(rom.hash)
palettes_options = {}
palettes_options['dungeon'] = args.uw_palettes[player]
palettes_options['overworld'] = args.ow_palettes[player]
palettes_options['hud'] = args.hud_palettes[player]
palettes_options['sword'] = args.sword_palettes[player]
palettes_options['shield'] = args.shield_palettes[player]
palettes_options['link'] = args.link_palettes[player]
apply_rom_settings(rom, args.heartbeep[player],
args.heartcolor[player], args.quickswap[player],
args.fastmenu[player], args.disablemusic[player],
args.sprite[player], palettes_options, world,
player, True)
mcsb_name = ''
if all([
world.mapshuffle[player], world.compassshuffle[player],
world.keyshuffle[player], world.bigkeyshuffle[player]
]):
mcsb_name = '-keysanity'
elif [
world.mapshuffle[player], world.compassshuffle[player],
world.keyshuffle[player], world.bigkeyshuffle[player]
].count(True) == 1:
mcsb_name = '-mapshuffle' if world.mapshuffle[player] else \
'-compassshuffle' if world.compassshuffle[player] else \
'-universal_keys' if world.keyshuffle[player] == "universal" else \
'-keyshuffle' if world.keyshuffle[player] else '-bigkeyshuffle'
elif any([
world.mapshuffle[player], world.compassshuffle[player],
world.keyshuffle[player], world.bigkeyshuffle[player]
]):
mcsb_name = '-%s%s%s%sshuffle' % (
'M' if world.mapshuffle[player] else '',
'C' if world.compassshuffle[player] else '',
'U' if world.keyshuffle[player] == "universal" else
'S' if world.keyshuffle[player] else '',
'B' if world.bigkeyshuffle[player] else '')
outfilepname = f'_T{team + 1}' if world.teams > 1 else ''
outfilepname += f'_P{player}'
outfilepname += f"_{world.player_names[player][team].replace(' ', '_')}" \
if world.player_names[player][team] != 'Player%d' % player else ''
outfilestuffs = {
"logic": world.logic[player], # 0
"difficulty": world.difficulty[player], # 1
"item_functionality": world.item_functionality[player], # 2
"mode": world.mode[player], # 3
"goal": world.goal[player], # 4
"timer": str(world.timer[player]), # 5
"shuffle": world.shuffle[player], # 6
"algorithm": world.algorithm, # 7
"mscb": mcsb_name, # 8
"retro": world.retro[player], # 9
"progressive": world.progressive, # A
"hints": 'True' if world.hints[player] else 'False' # B
}
# 0 1 2 3 4 5 6 7 8 9 A B
outfilesuffix = (
'_%s_%s-%s-%s-%s%s_%s-%s%s%s%s%s' % (
# 0 1 2 3 4 5 6 7 8 9 A B C
# _noglitches_normal-normal-open-ganon-ohko_simple-balanced-keysanity-retro-prog_random-nohints
# _noglitches_normal-normal-open-ganon _simple-balanced-keysanity-retro
# _noglitches_normal-normal-open-ganon _simple-balanced-keysanity -prog_random
# _noglitches_normal-normal-open-ganon _simple-balanced-keysanity -nohints
outfilestuffs["logic"], # 0
outfilestuffs["difficulty"], # 1
outfilestuffs["item_functionality"], # 2
outfilestuffs["mode"], # 3
outfilestuffs["goal"], # 4
"" if outfilestuffs["timer"] in ['False', 'none', 'display']
else "-" + outfilestuffs["timer"], # 5
outfilestuffs["shuffle"], # 6
outfilestuffs["algorithm"], # 7
outfilestuffs["mscb"], # 8
"-retro" if outfilestuffs["retro"] == "True" else "", # 9
"-prog_" + outfilestuffs["progressive"] if
outfilestuffs["progressive"] in ['off', 'random'] else "", # A
"-nohints" if not outfilestuffs["hints"] == "True" else ""
) # B
) if not args.outputname else ''
rompath = output_path(
f'{outfilebase}{outfilepname}{outfilesuffix}.sfc')
rom.write_to_file(rompath, hide_enemizer=True)
if args.create_diff:
Patch.create_patch_file(rompath)
return player, team, bytes(rom.name).decode()
pool = concurrent.futures.ThreadPoolExecutor()
multidata_task = None
check_accessibility_task = pool.submit(world.fulfills_accessibility)
if not args.suppress_rom:
rom_futures = []
for team in range(world.teams):
for player in range(1, world.players + 1):
rom_futures.append(pool.submit(_gen_rom, team, player))
def get_entrance_to_region(region: Region):
for entrance in region.entrances:
if entrance.parent_region.type in (RegionType.DarkWorld,
RegionType.LightWorld):
return entrance
for entrance in region.entrances: # BFS might be better here, trying DFS for now.
return get_entrance_to_region(entrance.parent_region)
# collect ER hint info
er_hint_data = {
player: {}
for player in range(1, world.players + 1)
if world.shuffle[player] != "vanilla" or world.retro[player]
}
from Regions import RegionType
for region in world.regions:
if region.player in er_hint_data and region.locations:
main_entrance = get_entrance_to_region(region)
for location in region.locations:
if type(location.address
) == int: # skips events and crystals
if location.address >= SHOP_ID_START + 33: continue
if lookup_vanilla_location_to_entrance[
location.address] != main_entrance.name:
er_hint_data[region.player][
location.address] = main_entrance.name
ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle',
'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
'Tower of Hera', 'Palace of Darkness', 'Swamp Palace',
'Skull Woods', 'Thieves Town', 'Ice Palace',
'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total")
checks_in_area = {
player: {area: list()
for area in ordered_areas}
for player in range(1, world.players + 1)
}
for player in range(1, world.players + 1):
checks_in_area[player]["Total"] = 0
for location in [
loc for loc in world.get_filled_locations()
if type(loc.address) is int
]:
main_entrance = get_entrance_to_region(location.parent_region)
if location.parent_region.dungeon:
dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
'Inverted Ganons Tower': 'Ganons Tower'}\
.get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
checks_in_area[location.player][dungeonname].append(
location.address)
elif main_entrance.parent_region.type == RegionType.LightWorld:
checks_in_area[location.player]["Light World"].append(
location.address)
elif main_entrance.parent_region.type == RegionType.DarkWorld:
checks_in_area[location.player]["Dark World"].append(
location.address)
checks_in_area[location.player]["Total"] += 1
oldmancaves = []
takeanyregions = [
"Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3",
"Take-Any #4"
]
for index, take_any in enumerate(takeanyregions):
for region in [
world.get_region(take_any, player)
for player in range(1, world.players + 1)
if world.retro[player]
]:
item = ItemFactory(
region.shop.inventory[(
0 if take_any == "Old Man Sword Cave" else 1)]['item'],
region.player)
player = region.player
location_id = SHOP_ID_START + total_shop_slots + index
main_entrance = get_entrance_to_region(region)
if main_entrance.parent_region.type == RegionType.LightWorld:
checks_in_area[player]["Light World"].append(location_id)
else:
checks_in_area[player]["Dark World"].append(location_id)
checks_in_area[player]["Total"] += 1
er_hint_data[player][location_id] = main_entrance.name
oldmancaves.append(
((location_id, player), (item.code, player)))
precollected_items = [[] for player in range(world.players)]
for item in world.precollected_items:
precollected_items[item.player - 1].append(item.code)
FillDisabledShopSlots(world)
def write_multidata(roms):
for future in roms:
rom_name = future.result()
rom_names.append(rom_name)
multidatatags = ["ER"]
if args.race:
multidatatags.append("Race")
if args.create_spoiler:
multidatatags.append("Spoiler")
if not args.skip_playthrough:
multidatatags.append("Play through")
minimum_versions = {"server": (1, 0, 0)}
minimum_versions["clients"] = client_versions = []
for (slot, team, name) in rom_names:
if world.shop_shuffle_slots[slot]:
client_versions.append([team, slot, [3, 6, 1]])
multidata = zlib.compress(
json.dumps({
"names":
parsed_names,
# backwards compat for < 2.4.1
"roms": [(slot, team, list(name.encode()))
for (slot, team, name) in rom_names],
"rom_strings":
rom_names,
"remote_items": [
player for player in range(1, world.players + 1)
if world.remote_items[player]
],
"locations":
[((location.address, location.player),
(location.item.code, location.item.player))
for location in world.get_filled_locations()
if type(location.address) is int] + oldmancaves,
"checks_in_area":
checks_in_area,
"server_options":
get_options()["server_options"],
"er_hint_data":
er_hint_data,
"precollected_items":
precollected_items,
"version":
_version_tuple,
"tags":
multidatatags,
"minimum_versions":
minimum_versions
}).encode("utf-8"),
9)
with open(output_path('%s.multidata' % outfilebase), 'wb') as f:
f.write(multidata)
multidata_task = pool.submit(write_multidata, rom_futures)
if not check_accessibility_task.result():
if not world.can_beat_game():
raise Exception("Game appears is unbeatable. Aborting.")
else:
logger.warning(
"Location Accessibility requirements not fulfilled.")
if not args.skip_playthrough:
logger.info('Calculating playthrough.')
create_playthrough(world)
if multidata_task:
multidata_task.result() # retrieve exception if one exists
pool.shutdown() # wait for all queued tasks to complete
if args.create_spoiler: # needs spoiler.hashes to be filled, that depend on rom_futures being done
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
return world
def main(settings, window=dummy_window()):
start = time.clock()
logger = logging.getLogger('')
# verify that the settings are valid
if settings.free_scarecrow:
verify_scarecrow_song_str(settings.scarecrow_song,
settings.ocarina_songs)
# initialize the world
worlds = []
if settings.compress_rom == 'None':
settings.create_spoiler = True
settings.update()
if not settings.world_count:
settings.world_count = 1
if settings.world_count < 1:
raise Exception('World Count must be at least 1')
if settings.player_num > settings.world_count or settings.player_num < 1:
raise Exception('Player Num must be between 1 and %d' %
settings.world_count)
for i in range(0, settings.world_count):
worlds.append(World(settings))
random.seed(worlds[0].numeric_seed)
logger.info('OoT Randomizer Version %s - Seed: %s\n\n', __version__,
worlds[0].seed)
window.update_status('Creating the Worlds')
for id, world in enumerate(worlds):
world.id = id
logger.info('Generating World %d.' % id)
window.update_progress(0 + (((id + 1) / settings.world_count) * 1))
logger.info('Creating Overworld')
if world.quest == 'master':
for dungeon in world.dungeon_mq:
world.dungeon_mq[dungeon] = True
elif world.quest == 'mixed':
for dungeon in world.dungeon_mq:
world.dungeon_mq[dungeon] = random.choice([True, False])
else:
for dungeon in world.dungeon_mq:
world.dungeon_mq[dungeon] = False
create_regions(world)
window.update_progress(0 + (((id + 1) / settings.world_count) * 2))
logger.info('Creating Dungeons')
create_dungeons(world)
window.update_progress(0 + (((id + 1) / settings.world_count) * 3))
logger.info('Linking Entrances')
link_entrances(world)
if settings.shopsanity != 'off':
world.random_shop_prices()
window.update_progress(0 + (((id + 1) / settings.world_count) * 4))
logger.info('Calculating Access Rules.')
set_rules(world)
window.update_progress(0 + (((id + 1) / settings.world_count) * 5))
logger.info('Generating Item Pool.')
generate_itempool(world)
window.update_status('Placing the Items')
logger.info('Fill the world.')
distribute_items_restrictive(window, worlds)
window.update_progress(35)
if settings.create_spoiler:
window.update_status('Calculating Spoiler Data')
logger.info('Calculating playthrough.')
create_playthrough(worlds)
window.update_progress(50)
if settings.hints != 'none':
window.update_status('Calculating Hint Data')
CollectionState.update_required_items(worlds)
buildGossipHints(worlds[settings.player_num - 1])
window.update_progress(55)
logger.info('Patching ROM.')
if settings.world_count > 1:
outfilebase = 'OoT_%s_%s_W%dP%d' % (
worlds[0].settings_string, worlds[0].seed, worlds[0].world_count,
worlds[0].player_num)
else:
outfilebase = 'OoT_%s_%s' % (worlds[0].settings_string, worlds[0].seed)
output_dir = default_output_path(settings.output_dir)
if settings.compress_rom != 'None':
window.update_status('Patching ROM')
rom = LocalRom(settings)
patch_rom(worlds[settings.player_num - 1], rom)
window.update_progress(65)
rom_path = os.path.join(output_dir, '%s.z64' % outfilebase)
window.update_status('Saving Uncompressed ROM')
rom.write_to_file(rom_path)
if settings.compress_rom == 'True':
window.update_status('Compressing ROM')
logger.info('Compressing ROM.')
compressor_path = ""
if platform.system() == 'Windows':
if 8 * struct.calcsize("P") == 64:
compressor_path = "Compress\\Compress.exe"
else:
compressor_path = "Compress\\Compress32.exe"
elif platform.system() == 'Linux':
compressor_path = "Compress/Compress"
elif platform.system() == 'Darwin':
compressor_path = "Compress/Compress.out"
else:
logger.info('OS not supported for compression')
run_process(window, logger, [
compressor_path, rom_path,
os.path.join(output_dir, '%s-comp.z64' % outfilebase)
])
os.remove(rom_path)
window.update_progress(95)
if settings.create_spoiler:
window.update_status('Creating Spoiler Log')
worlds[settings.player_num - 1].spoiler.to_file(
os.path.join(output_dir, '%s_Spoiler.txt' % outfilebase))
window.update_progress(100)
window.update_status('Success: Rom patched successfully')
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.clock() - start)
return worlds[settings.player_num - 1]
def main(settings):
start = time.clock()
# initialize the world
worlds = []
if not settings.world_count:
settings.world_count = 1
if settings.world_count < 1:
raise Exception('World Count must be at least 1')
if settings.player_num > settings.world_count or settings.player_num < 1:
raise Exception('Player Num must be between 1 and %d' %
settings.world_count)
for i in range(0, settings.world_count):
worlds.append(World(settings))
logger = logging.getLogger('')
random.seed(worlds[0].numeric_seed)
logger.info('OoT Randomizer Version %s - Seed: %s\n\n', __version__,
worlds[0].seed)
for id, world in enumerate(worlds):
world.id = id
logger.info('Generating World %d.' % id)
logger.info('Creating Overworld')
create_regions(world)
logger.info('Creating Dungeons')
create_dungeons(world)
logger.info('Linking Entrances')
link_entrances(world)
logger.info('Calculating Access Rules.')
set_rules(world)
logger.info('Generating Item Pool.')
generate_itempool(world)
logger.info('Fill the world.')
distribute_items_restrictive(worlds)
if settings.create_spoiler:
logger.info('Calculating playthrough.')
create_playthrough(worlds)
CollectionState.update_required_items(worlds)
logger.info('Patching ROM.')
if settings.world_count > 1:
outfilebase = 'OoT_%s_%s_W%dP%d' % (
worlds[0].settings_string, worlds[0].seed, worlds[0].world_count,
worlds[0].player_num)
else:
outfilebase = 'OoT_%s_%s' % (worlds[0].settings_string, worlds[0].seed)
output_dir = default_output_path(settings.output_dir)
if not settings.suppress_rom:
rom = LocalRom(settings)
patch_rom(worlds[settings.player_num - 1], rom)
rom_path = os.path.join(output_dir, '%s.z64' % outfilebase)
rom.write_to_file(rom_path)
if settings.compress_rom:
logger.info('Compressing ROM.')
if platform.system() == 'Windows':
subprocess.call([
"Compress\\Compress.exe", rom_path,
os.path.join(output_dir, '%s-comp.z64' % outfilebase)
])
elif platform.system() == 'Linux':
subprocess.call([
"Compress/Compress", rom_path,
os.path.join(output_dir, '%s-comp.z64' % outfilebase)
])
elif platform.system() == 'Darwin':
subprocess.call(
["Compress/Compress.out", ('%s.z64' % outfilebase)])
else:
logger.info('OS not supported for compression')
if settings.create_spoiler:
worlds[settings.player_num - 1].spoiler.to_file(
os.path.join(output_dir, '%s_Spoiler.txt' % outfilebase))
os.remove('hints.txt')
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.clock() - start)
return worlds[settings.player_num - 1]
def main(args, seed=None):
start = time.clock()
# initialize the world
world = World('vanilla', 'noglitches', 'standard', 'normal', 'none', 'on',
'ganon', 'freshness', False, False, False, args.quickswap,
args.fastmenu, False)
logger = logging.getLogger('')
hasher = hashlib.md5()
with open(args.plando, 'rb') as plandofile:
buf = plandofile.read()
hasher.update(buf)
world.seed = int(hasher.hexdigest(), 16) % 1000000000
random.seed(world.seed)
logger.info('ALttP Plandomizer Version %s - Seed: %s\n\n' %
(__version__, args.plando))
create_regions(world)
create_dungeons(world)
link_entrances(world)
logger.info('Calculating Access Rules.')
set_rules(world)
logger.info('Fill the world.')
text_patches = []
fill_world(world, args.plando, text_patches)
if world.get_entrance(
'Dam').connected_region.name != 'Dam' or world.get_entrance(
'Swamp Palace'
).connected_region.name != 'Swamp Palace (Entrance)':
world.swamp_patch_required = True
logger.info('Calculating playthrough.')
try:
create_playthrough(world)
except RuntimeError:
if args.ignore_unsolvable:
pass
else:
raise
logger.info('Patching ROM.')
if args.sprite is not None:
sprite = bytearray(open(args.sprite, 'rb').read())
else:
sprite = None
rom = LocalRom(args.rom)
patch_rom(world, rom, logic_hash, args.heartbeep, sprite)
for textname, texttype, text in text_patches:
if texttype == 'text':
write_string_to_rom(rom, textname, text)
elif texttype == 'credit':
write_credits_string_to_rom(rom, textname, text)
outfilebase = 'Plando_%s_%s' % (os.path.splitext(
os.path.basename(args.plando))[0], world.seed)
rom.write_to_file('%s.sfc' % outfilebase)
if args.create_spoiler:
world.spoiler.to_file('%s_Spoiler.txt' % outfilebase)
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s' % (time.clock() - start))
return world
def main(args, seed=None):
start = time.clock()
# initialize the world
world = World(args.shuffle, args.logic, args.mode, args.difficulty, args.timer, args.progressive, args.goal, args.algorithm, not args.nodungeonitems, args.beatableonly, args.shuffleganon, args.quickswap, args.fastmenu, args.disablemusic, args.keysanity, args.retro, args.custom, args.customitemarray)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
logger.info('ALttP Entrance Randomizer Version %s - Seed: %s\n\n', __version__, world.seed)
world.difficulty_requirements = difficulties[world.difficulty]
create_regions(world)
create_dungeons(world)
logger.info('Shuffling the World about.')
link_entrances(world)
mark_light_world_regions(world)
logger.info('Calculating Access Rules.')
set_rules(world)
logger.info('Generating Item Pool.')
generate_itempool(world)
logger.info('Placing Dungeon Items.')
shuffled_locations = None
if args.algorithm in ['balanced', 'vt26'] or args.keysanity:
shuffled_locations = world.get_unfilled_locations()
random.shuffle(shuffled_locations)
fill_dungeons_restrictive(world, shuffled_locations)
else:
fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt21':
distribute_items_cutoff(world, 1)
elif args.algorithm == 'vt22':
distribute_items_cutoff(world, 0.66)
elif args.algorithm == 'freshness':
distribute_items_staleness(world)
elif args.algorithm == 'vt25':
distribute_items_restrictive(world, 0)
elif args.algorithm == 'vt26':
distribute_items_restrictive(world, gt_filler(world), shuffled_locations)
elif args.algorithm == 'balanced':
distribute_items_restrictive(world, gt_filler(world))
logger.info('Calculating playthrough.')
create_playthrough(world)
logger.info('Patching ROM.')
if args.sprite is not None:
if isinstance(args.sprite, Sprite):
sprite = args.sprite
else:
sprite = Sprite(args.sprite)
else:
sprite = None
outfilebase = 'ER_%s_%s-%s-%s%s_%s-%s%s%s%s_%s' % (world.logic, world.difficulty, world.mode, world.goal, "" if world.timer in ['none', 'display'] else "-" + world.timer, world.shuffle, world.algorithm, "-keysanity" if world.keysanity else "", "-retro" if world.retro else "", "-prog_" + world.progressive if world.progressive in ['off', 'random'] else "", world.seed)
if not args.suppress_rom:
if args.jsonout:
rom = JsonRom()
else:
rom = LocalRom(args.rom)
patch_rom(world, rom, bytearray(logic_hash), args.heartbeep, args.heartcolor, sprite)
if args.jsonout:
print(json.dumps({'patch': rom.patches, 'spoiler': world.spoiler.to_json()}))
else:
rom.write_to_file(args.jsonout or output_path('%s.sfc' % outfilebase))
if args.create_spoiler and not args.jsonout:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.clock() - start)
return world
def main(args):
start_time = time.perf_counter()
# initialize the world
world = World(1, 'vanilla', 'noglitches', 'standard', 'normal', 'none',
'on', 'ganon', 'freshness', False, False, False, False,
False, False, None, False)
world.player_names[1].append("Player1")
logger = logging.getLogger('')
hasher = hashlib.md5()
with open(args.plando, 'rb') as plandofile:
buf = plandofile.read()
hasher.update(buf)
world.seed = int(hasher.hexdigest(), 16) % 1000000000
random.seed(world.seed)
logger.info('ALttP Plandomizer Version %s - Seed: %s\n\n', __version__,
args.plando)
world.difficulty_requirements[1] = difficulties[world.difficulty[1]]
create_regions(world, 1)
create_dungeons(world, 1)
link_entrances(world, 1)
logger.info('Calculating Access Rules.')
set_rules(world, 1)
logger.info('Fill the world.')
text_patches = []
fill_world(world, args.plando, text_patches)
if world.get_entrance(
'Dam', 1).connected_region.name != 'Dam' or world.get_entrance(
'Swamp Palace',
1).connected_region.name != 'Swamp Palace (Entrance)':
world.swamp_patch_required[1] = True
logger.info('Calculating playthrough.')
try:
create_playthrough(world)
except RuntimeError:
if args.ignore_unsolvable:
pass
else:
raise
logger.info('Patching ROM.')
rom = LocalRom(args.rom)
patch_rom(world, rom, 1, 1, False)
apply_rom_settings(rom, args.heartbeep, args.heartcolor, args.quickswap,
args.fastmenu, args.disablemusic, args.sprite,
args.ow_palettes, args.uw_palettes)
for textname, texttype, text in text_patches:
if texttype == 'text':
write_string_to_rom(rom, textname, text)
#elif texttype == 'credit':
# write_credits_string_to_rom(rom, textname, text)
outfilebase = 'Plando_%s_%s' % (os.path.splitext(
os.path.basename(args.plando))[0], world.seed)
rom.write_to_file('%s.sfc' % outfilebase)
if args.create_spoiler:
world.spoiler.to_file('%s_Spoiler.txt' % outfilebase)
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.perf_counter() - start_time)
return world
def main(args, seed=None):
start = time.clock()
# initialize the world
world = World(args.shuffle, args.logic, args.mode, args.difficulty,
args.goal, args.algorithm, not args.nodungeonitems,
args.beatableonly)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
world.spoiler += 'ALttP Entrance Randomizer Version %s - Seed: %s\n\n' % (
__version__, world.seed)
world.spoiler += 'Logic: %s Mode: %s Goal: %s Entrance Shuffle: %s Filling Algorithm: %s\n\n' % (
args.logic, args.mode, args.goal, args.shuffle, args.algorithm) # todo
logger.info(world.spoiler)
create_regions(world)
logger.info('Shuffling the World about.')
world.spoiler += link_entrances(world)
logger.info('Generating Item Pool.')
world.spoiler += generate_itempool(world)
logger.info('Calculating Access Rules.')
world.spoiler += set_rules(world)
logger.info('Placing Dungeon Items.')
world.spoiler += fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(
world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt21':
distribute_items_cutoff(world, 1)
elif args.algorithm == 'vt22':
distribute_items_cutoff(world, 0.66)
elif args.algorithm == 'freshness':
distribute_items_staleness(world)
elif args.algorithm == 'restrictive':
distribute_items_restrictive(world,
10 if world.goal is not 'starhunt' else 0)
world.spoiler += print_location_spoiler(world)
logger.info('Calculating playthrough.')
world.spoiler += create_playthrough(world)
logger.info('Patching ROM.')
if args.sprite is not None:
sprite = bytearray(open(args.sprite, 'rb').read())
else:
sprite = None
outfilebase = 'ER_%s_%s_%s_%s_%s_%s' % (world.mode, world.goal,
world.shuffle, world.difficulty,
world.algorithm, world.seed)
if not args.suppress_rom:
if args.jsonout:
rom = JsonRom()
else:
rom = LocalRom(args.rom)
patch_rom(world, rom, bytearray(logic_hash), args.quickswap,
args.heartbeep, sprite)
rom.write_to_file(args.jsonout or '%s.sfc' % outfilebase)
if args.create_spoiler:
with open('%s_Spoiler.txt' % outfilebase, 'w') as outfile:
outfile.write(world.spoiler)
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s' % (time.clock() - start))
return world
def main(args, seed=None):
start = time.perf_counter()
# initialize the world
world = World(args.multi, args.shuffle, args.logic, args.mode, args.swords,
args.difficulty, args.item_functionality, args.timer,
args.progressive, args.goal, args.algorithm,
not args.nodungeonitems, args.accessibility,
args.shuffleganon, args.quickswap, args.fastmenu,
args.disablemusic, args.keysanity, args.retro, args.custom,
args.customitemarray, args.shufflebosses, args.hints)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
world.crystals_needed_for_ganon = random.randint(
0, 7) if args.crystals_ganon == 'random' else int(args.crystals_ganon)
world.crystals_needed_for_gt = random.randint(
0, 7) if args.crystals_gt == 'random' else int(args.crystals_gt)
world.rom_seeds = {
player: random.randint(0, 999999999)
for player in range(1, world.players + 1)
}
logger.info('ALttP Entrance Randomizer Version %s - Seed: %s\n\n',
__version__, world.seed)
world.difficulty_requirements = difficulties[world.difficulty]
if world.mode != 'inverted':
for player in range(1, world.players + 1):
create_regions(world, player)
create_dungeons(world, player)
else:
for player in range(1, world.players + 1):
create_inverted_regions(world, player)
create_dungeons(world, player)
logger.info('Shuffling the World about.')
if world.mode != 'inverted':
for player in range(1, world.players + 1):
link_entrances(world, player)
mark_light_world_regions(world)
else:
for player in range(1, world.players + 1):
link_inverted_entrances(world, player)
mark_dark_world_regions(world)
logger.info('Generating Item Pool.')
for player in range(1, world.players + 1):
generate_itempool(world, player)
logger.info('Calculating Access Rules.')
for player in range(1, world.players + 1):
set_rules(world, player)
logger.info('Placing Dungeon Prizes.')
fill_prizes(world)
logger.info('Placing Dungeon Items.')
shuffled_locations = None
if args.algorithm in ['balanced', 'vt26'] or args.keysanity:
shuffled_locations = world.get_unfilled_locations()
random.shuffle(shuffled_locations)
fill_dungeons_restrictive(world, shuffled_locations)
else:
fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(
world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt21':
distribute_items_cutoff(world, 1)
elif args.algorithm == 'vt22':
distribute_items_cutoff(world, 0.66)
elif args.algorithm == 'freshness':
distribute_items_staleness(world)
elif args.algorithm == 'vt25':
distribute_items_restrictive(world, 0)
elif args.algorithm == 'vt26':
distribute_items_restrictive(world, gt_filler(world),
shuffled_locations)
elif args.algorithm == 'balanced':
distribute_items_restrictive(world, gt_filler(world))
if world.players > 1:
logger.info('Balancing multiworld progression.')
balance_multiworld_progression(world)
logger.info('Patching ROM.')
if args.sprite is not None:
if isinstance(args.sprite, Sprite):
sprite = args.sprite
else:
sprite = Sprite(args.sprite)
else:
sprite = None
outfilebase = 'ER_%s_%s-%s-%s-%s%s_%s-%s%s%s%s%s_%s' % (
world.logic, world.difficulty, world.difficulty_adjustments,
world.mode, world.goal, "" if world.timer in ['none', 'display'] else
"-" + world.timer, world.shuffle, world.algorithm, "-keysanity"
if world.keysanity else "", "-retro" if world.retro else "", "-prog_" +
world.progressive if world.progressive in ['off', 'random'] else "",
"-nohints" if not world.hints else "", world.seed)
use_enemizer = args.enemizercli and (
args.shufflebosses != 'none' or args.shuffleenemies
or args.enemy_health != 'default' or args.enemy_health != 'default'
or args.enemy_damage or args.shufflepalette or args.shufflepots)
jsonout = {}
if not args.suppress_rom:
if world.players > 1:
raise NotImplementedError(
"Multiworld rom writes have not been implemented")
else:
player = 1
local_rom = None
if args.jsonout:
rom = JsonRom()
else:
if use_enemizer:
local_rom = LocalRom(args.rom)
rom = JsonRom()
else:
rom = LocalRom(args.rom)
patch_rom(world, player, rom)
enemizer_patch = []
if use_enemizer:
enemizer_patch = get_enemizer_patch(
world, player, rom, args.rom, args.enemizercli,
args.shuffleenemies, args.enemy_health, args.enemy_damage,
args.shufflepalette, args.shufflepots)
if args.jsonout:
jsonout['patch'] = rom.patches
if use_enemizer:
jsonout['enemizer' % player] = enemizer_patch
else:
if use_enemizer:
local_rom.patch_enemizer(
rom.patches,
os.path.join(os.path.dirname(args.enemizercli),
"enemizerBasePatch.json"), enemizer_patch)
rom = local_rom
apply_rom_settings(rom, args.heartbeep, args.heartcolor,
world.quickswap, world.fastmenu,
world.disable_music, sprite)
rom.write_to_file(output_path('%s.sfc' % outfilebase))
if args.create_spoiler and not args.jsonout:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
if not args.skip_playthrough:
logger.info('Calculating playthrough.')
create_playthrough(world)
if args.jsonout:
print(json.dumps({**jsonout, 'spoiler': world.spoiler.to_json()}))
elif args.create_spoiler and not args.skip_playthrough:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.perf_counter() - start)
return world
def main(args, seed=None):
start = time.clock()
# initialize the world
world = World(args.shuffle, args.logic, args.mode, args.difficulty,
args.goal, args.algorithm, not args.nodungeonitems,
args.beatableonly, args.shuffleganon, args.quickswap)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
logger.info('ALttP Entrance Randomizer Version %s - Seed: %s\n\n' %
(__version__, world.seed))
create_regions(world)
logger.info('Shuffling the World about.')
link_entrances(world)
logger.info('Calculating Access Rules.')
set_rules(world)
logger.info('Generating Item Pool.')
generate_itempool(world)
logger.info('Placing Dungeon Items.')
fill_dungeons(world)
logger.info('Fill the world.')
if args.algorithm == 'flood':
flood_items(
world) # different algo, biased towards early game progress items
elif args.algorithm == 'vt21':
distribute_items_cutoff(world, 1)
elif args.algorithm == 'vt22':
distribute_items_cutoff(world, 0.66)
elif args.algorithm == 'freshness':
distribute_items_staleness(world)
elif args.algorithm == 'vt25':
distribute_items_restrictive(world, 0)
logger.info('Calculating playthrough.')
create_playthrough(world)
logger.info('Patching ROM.')
if args.sprite is not None:
sprite = bytearray(open(args.sprite, 'rb').read())
else:
sprite = None
outfilebase = 'ER_%s_%s-%s-%s_%s-%s%s%s_%s' % (
world.logic, world.difficulty, world.mode, world.goal, world.shuffle,
world.algorithm, "-quickswap" if world.quickswap else "",
"-shuffleganon" if world.shuffle_ganon else "", world.seed)
if not args.suppress_rom:
if args.jsonout:
rom = JsonRom()
else:
rom = LocalRom(args.rom)
patch_rom(world, rom, bytearray(logic_hash), args.heartbeep, sprite)
if args.jsonout:
print(
json.dumps({
'patch': rom.patches,
'spoiler': world.spoiler.to_json()
}))
else:
rom.write_to_file(args.jsonout or '%s.sfc' % outfilebase)
if args.create_spoiler and not args.jsonout:
world.spoiler.to_file('%s_Spoiler.txt' % outfilebase)
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s' % (time.clock() - start))
return world
def main(args, seed=None):
start = time.clock()
# initialize the world
world = World(args.bridge, args.open_forest, args.open_door_of_time,
not args.nodungeonitems, args.beatableonly, args.hints)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
logger.info('OoT Randomizer Version %s - Seed: %s\n\n', __version__,
world.seed)
create_regions(world)
create_dungeons(world)
logger.info('Shuffling the World about.')
link_entrances(world)
logger.info('Calculating Access Rules.')
set_rules(world)
logger.info('Generating Item Pool.')
generate_itempool(world)
logger.info('Placing Dungeon Items.')
shuffled_locations = None
shuffled_locations = world.get_unfilled_locations()
random.shuffle(shuffled_locations)
fill_dungeons_restrictive(world, shuffled_locations)
logger.info('Fill the world.')
distribute_items_restrictive(world)
logger.info('Calculating playthrough.')
create_playthrough(world)
logger.info('Patching ROM.')
outfilebase = 'OoT_%s%s%s%s_%s' % (
world.bridge, "-openforest" if world.open_forest else "",
"-opendoor" if world.open_door_of_time else "",
"-beatableonly" if world.check_beatable_only else "", world.seed)
if not args.suppress_rom:
rom = LocalRom(args.rom)
patch_rom(world, rom)
rom.write_to_file(output_path('%s.z64' % outfilebase))
if args.compress_rom:
logger.info('Compressing ROM.')
if platform.system() == 'Windows':
subprocess.call([
"Compress\Compress.exe",
(output_path('%s.z64' % outfilebase)),
(output_path('%s-comp.z64' % outfilebase))
])
elif platform.system() == 'Linux':
subprocess.call(
["Compress/Compress", ('%s.z64' % outfilebase)])
elif platform.system() == 'Darwin':
subprocess.call(
["Compress/Compress.out", ('%s.z64' % outfilebase)])
else:
logger.info('OS not supported for compression')
if args.create_spoiler:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.clock() - start)
return world
def main(args, seed=None):
start = time.clock()
# initialize the world
world = World(args.shuffle, args.bridge, args.open_forest, not args.nodungeonitems, args.beatableonly)
logger = logging.getLogger('')
if seed is None:
random.seed(None)
world.seed = random.randint(0, 999999999)
else:
world.seed = int(seed)
random.seed(world.seed)
logger.info('ALttP Entrance Randomizer Version %s - Seed: %s\n\n', __version__, world.seed)
create_regions(world)
create_dungeons(world)
logger.info('Shuffling the World about.')
link_entrances(world)
logger.info('Calculating Access Rules.')
set_rules(world)
logger.info('Generating Item Pool.')
generate_itempool(world)
logger.info('Placing Dungeon Items.')
shuffled_locations = None
shuffled_locations = world.get_unfilled_locations()
random.shuffle(shuffled_locations)
fill_dungeons_restrictive(world, shuffled_locations)
logger.info('Fill the world.')
distribute_items_restrictive(world)
logger.info('Calculating playthrough.')
create_playthrough(world)
logger.info('Patching ROM.')
outfilebase = 'OoT_%s_%s_%s' % (world.shuffle, world.bridge, world.seed)
if not args.suppress_rom:
rom = LocalRom(args.rom)
patch_rom(world, rom)
rom.write_to_file(output_path('%s.z64' % outfilebase))
if args.create_spoiler:
world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.')
logger.debug('Total Time: %s', time.clock() - start)
return world
