monorail
/
Archipelago
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

another round of optimizations and cleanup including some I/O multithreading 

also alias sprite names with their file names as that's an often done mistake
This commit is contained in:
Fabian Dill 2020-08-21 18:35:48 +02:00
parent 6d3a7487e0
commit 45268b18f3
3 changed files with 263 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
BaseClasses.py
View File

@ -983,7 +983,8 @@ class Location(object):
return self.always_allow(state, item) or (self.parent_region.can_fill(item) and self.item_rule(item) and (not check_access or self.can_reach(state))) return self.always_allow(state, item) or (self.parent_region.can_fill(item) and self.item_rule(item) and (not check_access or self.can_reach(state)))
def can_reach(self, state: CollectionState) -> bool: def can_reach(self, state: CollectionState) -> bool:
if self.parent_region.can_reach(state) and self.access_rule(state): # self.access_rule computes faster on average, so placing it first for faster abort
if self.access_rule(state) and self.parent_region.can_reach(state):
return True return True
return False return False

29
Main.py
View File

@ -7,6 +7,7 @@ import os
import random import random
import time import time
import zlib import zlib
import concurrent.futures
from BaseClasses import World, CollectionState, Item, Region, Location, Shop from BaseClasses import World, CollectionState, Item, Region, Location, Shop
from Items import ItemFactory from Items import ItemFactory
@ -244,16 +245,15 @@ def main(args, seed=None):
Patch.create_patch_file(rompath) Patch.create_patch_file(rompath)
return player, team, bytes(rom.name).decode() return player, team, bytes(rom.name).decode()
pool = concurrent.futures.ThreadPoolExecutor()
if not args.suppress_rom: if not args.suppress_rom:
import concurrent.futures
futures = [] rom_futures = []
with concurrent.futures.ThreadPoolExecutor() as pool:
for team in range(world.teams): for team in range(world.teams):
for player in range(1, world.players + 1): for player in range(1, world.players + 1):
futures.append(pool.submit(_gen_rom, team, player)) rom_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): def get_entrance_to_region(region: Region):
for entrance in region.entrances: for entrance in region.entrances:
@ -276,6 +276,11 @@ def main(args, seed=None):
precollected_items = [[] for player in range(world.players)] precollected_items = [[] for player in range(world.players)]
for item in world.precollected_items: for item in world.precollected_items:
precollected_items[item.player - 1].append(item.code) precollected_items[item.player - 1].append(item.code)
def write_multidata(roms):
for future in roms:
rom_name = future.result()
rom_names.append(rom_name)
multidata = zlib.compress(json.dumps({"names": parsed_names, multidata = zlib.compress(json.dumps({"names": parsed_names,
# backwards compat for < 2.4.1 # backwards compat for < 2.4.1
"roms": [(slot, team, list(name.encode())) "roms": [(slot, team, list(name.encode()))
@ -297,16 +302,16 @@ def main(args, seed=None):
with open(output_path('%s.multidata' % outfilebase), 'wb') as f: with open(output_path('%s.multidata' % outfilebase), 'wb') as f:
f.write(multidata) f.write(multidata)
pool.submit(write_multidata, rom_futures)
if not args.skip_playthrough: if not args.skip_playthrough:
logger.info('Calculating playthrough.') logger.info('Calculating playthrough.')
create_playthrough(world) create_playthrough(world)
pool.shutdown() # wait for all queued tasks to complete
if args.create_spoiler: 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)) world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
logger.info('Done. Enjoy.') logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
logger.debug('Total Time: %s', time.perf_counter() - start)
return world return world

382
Rom.py
View File

@ -11,6 +11,7 @@ import struct
import sys import sys
import subprocess import subprocess
import threading import threading
import concurrent.futures
from BaseClasses import CollectionState, ShopType, Region, Location from BaseClasses import CollectionState, ShopType, Region, Location
from Dungeons import dungeon_music_addresses from Dungeons import dungeon_music_addresses
@ -38,7 +39,7 @@ class LocalRom(object):
self.patch_base_rom() self.patch_base_rom()
self.orig_buffer = self.buffer.copy() self.orig_buffer = self.buffer.copy()
def write_byte(self, address: int, value): def write_byte(self, address: int, value: int):
self.buffer[address] = value self.buffer[address] = value
def write_bytes(self, startaddress: int, values): def write_bytes(self, startaddress: int, values):
@ -62,22 +63,12 @@ class LocalRom(object):
self.buffer = bytearray(stream.read()) self.buffer = bytearray(stream.read())
@staticmethod @staticmethod
def fromJsonRom(rom, file, rom_size=0x200000): def verify(buffer, expected: str = RANDOMIZERBASEHASH) -> bool:
ret = LocalRom(file, True, rom.name, rom.hash)
ret.buffer.extend(bytearray([0x00]) * (rom_size - len(ret.buffer)))
for address, values in rom.patches.items():
ret.write_bytes(int(address), values)
return ret
@staticmethod
def verify(buffer, expected=RANDOMIZERBASEHASH):
buffermd5 = hashlib.md5() buffermd5 = hashlib.md5()
buffermd5.update(buffer) buffermd5.update(buffer)
return expected == buffermd5.hexdigest() return expected == buffermd5.hexdigest()
def patch_base_rom(self): def patch_base_rom(self):
if os.path.isfile(local_path('basepatch.sfc')): if os.path.isfile(local_path('basepatch.sfc')):
with open(local_path('basepatch.sfc'), 'rb') as stream: with open(local_path('basepatch.sfc'), 'rb') as stream:
buffer = bytearray(stream.read()) buffer = bytearray(stream.read())
@ -128,24 +119,24 @@ class LocalRom(object):
inv = crc ^ 0xFFFF inv = crc ^ 0xFFFF
self.write_bytes(0x7FDC, [inv & 0xFF, (inv >> 8) & 0xFF, crc & 0xFF, (crc >> 8) & 0xFF]) self.write_bytes(0x7FDC, [inv & 0xFF, (inv >> 8) & 0xFF, crc & 0xFF, (crc >> 8) & 0xFF])
def get_hash(self): def get_hash(self) -> str:
h = hashlib.md5() h = hashlib.md5()
h.update(self.buffer) h.update(self.buffer)
return h.hexdigest() return h.hexdigest()
def write_int16(rom, address, value): def write_int16(self, address: int, value: int):
rom.write_bytes(address, int16_as_bytes(value)) self.write_bytes(address, int16_as_bytes(value))
def write_int32(rom, address, value): def write_int32(self, address: int, value: int):
rom.write_bytes(address, int32_as_bytes(value)) self.write_bytes(address, int32_as_bytes(value))
def write_int16s(rom, startaddress, values): def write_int16s(self, startaddress: int, values):
for i, value in enumerate(values): for i, value in enumerate(values):
write_int16(rom, startaddress + (i * 2), value) self.write_int16(startaddress + (i * 2), value)
def write_int32s(rom, startaddress, values): def write_int32s(self, startaddress: int, values):
for i, value in enumerate(values): for i, value in enumerate(values):
write_int32(rom, startaddress + (i * 4), value) self.write_int32(startaddress + (i * 4), value)
def read_rom(stream) -> bytearray: def read_rom(stream) -> bytearray:
@ -160,13 +151,17 @@ check_lock = threading.Lock()
def check_enemizer(enemizercli): def check_enemizer(enemizercli):
with check_lock:
if getattr(check_enemizer, "done", None): if getattr(check_enemizer, "done", None):
return return
if not os.path.exists(enemizercli) and not os.path.exists(enemizercli + ".exe"): if not os.path.exists(enemizercli) and not os.path.exists(enemizercli + ".exe"):
raise Exception(f"Enemizer not found at {enemizercli}, please install it." raise Exception(f"Enemizer not found at {enemizercli}, please install it."
f"Such as https://github.com/Ijwu/Enemizer/releases") f"Such as https://github.com/Ijwu/Enemizer/releases")
if sys.platform == "win32": if sys.platform == "win32":
# the win32api calls appear to not be threadsafe, which is the reason for the lock
with check_lock:
# some time may have passed since the lock was acquired, as such a quick re-check doesn't hurt
if getattr(check_enemizer, "done", None):
return
try: try:
import pythoncom import pythoncom
from win32com.client import Dispatch from win32com.client import Dispatch
@ -185,10 +180,11 @@ def check_enemizer(enemizercli):
raise Exception( raise Exception(
f"Enemizer found at {enemizercli} is outdated ({info}), please update your Enemizer. " f"Enemizer found at {enemizercli} is outdated ({info}), please update your Enemizer. "
f"Such as https://github.com/Ijwu/Enemizer/releases") f"Such as https://github.com/Ijwu/Enemizer/releases")
check_enemizer.done = True check_enemizer.done = True
def patch_enemizer(world, player: int, rom: LocalRom, enemizercli, random_sprite_on_hit): def patch_enemizer(world, player: int, rom: LocalRom, enemizercli, random_sprite_on_hit: bool):
check_enemizer(enemizercli) check_enemizer(enemizercli)
randopatch_path = os.path.abspath(output_path(f'enemizer_randopatch_{player}.sfc')) randopatch_path = os.path.abspath(output_path(f'enemizer_randopatch_{player}.sfc'))
options_path = os.path.abspath(output_path(f'enemizer_options_{player}.json')) options_path = os.path.abspath(output_path(f'enemizer_options_{player}.json'))
@ -323,14 +319,13 @@ def patch_enemizer(world, player: int, rom: LocalRom, enemizercli, random_sprite
if random_sprite_on_hit: if random_sprite_on_hit:
_populate_sprite_table() _populate_sprite_table()
sprites = list(_sprite_table.values()) sprites = list(set(_sprite_table.values())) # convert to list and remove dupes
if sprites: if sprites:
while len(sprites) < 32: while len(sprites) < 32:
sprites.extend(sprites) sprites.extend(sprites)
world.rom_seeds[player].shuffle(sprites) world.rom_seeds[player].shuffle(sprites)
for i, path in enumerate(sprites[:32]): for i, sprite in enumerate(sprites[:32]):
sprite = Sprite(path)
rom.write_bytes(0x300000 + (i * 0x8000), sprite.sprite) rom.write_bytes(0x300000 + (i * 0x8000), sprite.sprite)
rom.write_bytes(0x307000 + (i * 0x8000), sprite.palette) rom.write_bytes(0x307000 + (i * 0x8000), sprite.palette)
rom.write_bytes(0x307078 + (i * 0x8000), sprite.glove_palette) rom.write_bytes(0x307078 + (i * 0x8000), sprite.glove_palette)
@ -345,21 +340,24 @@ def patch_enemizer(world, player: int, rom: LocalRom, enemizercli, random_sprite
_sprite_table = {} _sprite_table = {}
def _populate_sprite_table(): def _populate_sprite_table():
if not _sprite_table: if not _sprite_table:
for dir in [local_path('data/sprites/alttpr'), local_path('data/sprites/custom')]: def load_sprite_from_file(file):
for file in os.listdir(dir):
filepath = os.path.join(dir, file) filepath = os.path.join(dir, file)
if not os.path.isfile(filepath):
continue
sprite = Sprite(filepath) sprite = Sprite(filepath)
if sprite.valid: if sprite.valid:
_sprite_table[sprite.name.lower()] = filepath _sprite_table[sprite.name.lower()] = sprite
_sprite_table[os.path.basename(filepath).split(".")[0]] = sprite # alias for filename base
with concurrent.futures.ThreadPoolExecutor() as pool:
for dir in [local_path('data/sprites/alttpr'), local_path('data/sprites/custom')]:
for file in os.listdir(dir):
pool.submit(load_sprite_from_file, file)
def get_sprite_from_name(name, local_random=random): def get_sprite_from_name(name, local_random=random):
_populate_sprite_table() _populate_sprite_table()
name = name.lower() name = name.lower()
if name in ['random', 'randomonhit']: if name in ['random', 'randomonhit']:
return Sprite(local_random.choice(list(_sprite_table.values()))) return local_random.choice(list(_sprite_table.values()))
return Sprite(_sprite_table[name]) if name in _sprite_table else None return _sprite_table.get(name, None)
class Sprite(object): class Sprite(object):
default_palette = [255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157, default_palette = [255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
@ -508,8 +506,10 @@ class Sprite(object):
return list(zip(*[iter(arr)] * size)) return list(zip(*[iter(arr)] * size))
def make_int16(pair): def make_int16(pair):
return pair[1]<<8 | pair[0] return pair[1]<<8 | pair[0]
def expand_color(i): def expand_color(i):
return ((i & 0x1F) * 8, (i >> 5 & 0x1F) * 8, (i >> 10 & 0x1F) * 8) return ((i & 0x1F) * 8, (i >> 5 & 0x1F) * 8, (i >> 10 & 0x1F) * 8)
raw_palette = self.palette raw_palette = self.palette
if raw_palette is None: if raw_palette is None:
raw_palette = Sprite.default_palette raw_palette = Sprite.default_palette
@ -519,6 +519,9 @@ class Sprite(object):
# split into palettes of 15 colors # split into palettes of 15 colors
return array_chunk(palette_as_colors, 15) return array_chunk(palette_as_colors, 15)
def __hash__(self):
return hash(self.name)
def patch_rom(world, rom, player, team, enemized): def patch_rom(world, rom, player, team, enemized):
local_random = world.rom_seeds[player] local_random = world.rom_seeds[player]
@ -588,40 +591,41 @@ def patch_rom(world, rom, player, team, enemized):
room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = exit.addresses room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = exit.addresses
# room id is deliberately not written # room id is deliberately not written
rom.write_byte(0x15B8C + offset, ow_area) rom.write_byte(0x15B8C + offset, ow_area)
write_int16(rom, 0x15BDB + 2 * offset, vram_loc) rom.write_int16(0x15BDB + 2 * offset, vram_loc)
write_int16(rom, 0x15C79 + 2 * offset, scroll_y) rom.write_int16(0x15C79 + 2 * offset, scroll_y)
write_int16(rom, 0x15D17 + 2 * offset, scroll_x) rom.write_int16(0x15D17 + 2 * offset, scroll_x)
# for positioning fixups we abuse the roomid as a way of identifying which exit data we are appling # for positioning fixups we abuse the roomid as a way of identifying which exit data we are appling
# Thanks to Zarby89 for originally finding these values # Thanks to Zarby89 for originally finding these values
# todo fix screen scrolling # todo fix screen scrolling
if world.shuffle[player] not in ['insanity', 'insanity_legacy', 'madness_legacy'] and \ if world.shuffle[player] not in ['insanity', 'insanity_legacy', 'madness_legacy'] and \
exit.name in ['Eastern Palace Exit', 'Tower of Hera Exit', 'Thieves Town Exit', 'Skull Woods Final Section Exit', 'Ice Palace Exit', 'Misery Mire Exit', exit.name in ['Eastern Palace Exit', 'Tower of Hera Exit', 'Thieves Town Exit',
'Palace of Darkness Exit', 'Swamp Palace Exit', 'Ganons Tower Exit', 'Desert Palace Exit (North)', 'Agahnims Tower Exit', 'Spiral Cave Exit (Top)', 'Skull Woods Final Section Exit', 'Ice Palace Exit', 'Misery Mire Exit',
'Palace of Darkness Exit', 'Swamp Palace Exit', 'Ganons Tower Exit',
'Desert Palace Exit (North)', 'Agahnims Tower Exit', 'Spiral Cave Exit (Top)',
'Superbunny Cave Exit (Bottom)', 'Turtle Rock Ledge Exit (East)']: 'Superbunny Cave Exit (Bottom)', 'Turtle Rock Ledge Exit (East)']:
# For exits that connot be reached from another, no need to apply offset fixes. # For exits that connot be reached from another, no need to apply offset fixes.
write_int16(rom, 0x15DB5 + 2 * offset, link_y) # same as final else rom.write_int16(0x15DB5 + 2 * offset, link_y) # same as final else
elif room_id == 0x0059 and world.fix_skullwoods_exit[player]: elif room_id == 0x0059 and world.fix_skullwoods_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x00F8) rom.write_int16(0x15DB5 + 2 * offset, 0x00F8)
elif room_id == 0x004a and world.fix_palaceofdarkness_exit[player]: elif room_id == 0x004a and world.fix_palaceofdarkness_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x0640) rom.write_int16(0x15DB5 + 2 * offset, 0x0640)
elif room_id == 0x00d6 and world.fix_trock_exit[player]: elif room_id == 0x00d6 and world.fix_trock_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x0134) rom.write_int16(0x15DB5 + 2 * offset, 0x0134)
elif room_id == 0x000c and world.fix_gtower_exit: # fix ganons tower exit point elif room_id == 0x000c and world.fix_gtower_exit: # fix ganons tower exit point
write_int16(rom, 0x15DB5 + 2 * offset, 0x00A4) rom.write_int16(0x15DB5 + 2 * offset, 0x00A4)
else: else:
write_int16(rom, 0x15DB5 + 2 * offset, link_y) rom.write_int16(0x15DB5 + 2 * offset, link_y)
write_int16(rom, 0x15E53 + 2 * offset, link_x) rom.write_int16(0x15E53 + 2 * offset, link_x)
write_int16(rom, 0x15EF1 + 2 * offset, camera_y) rom.write_int16(0x15EF1 + 2 * offset, camera_y)
write_int16(rom, 0x15F8F + 2 * offset, camera_x) rom.write_int16(0x15F8F + 2 * offset, camera_x)
rom.write_byte(0x1602D + offset, unknown_1) rom.write_byte(0x1602D + offset, unknown_1)
rom.write_byte(0x1607C + offset, unknown_2) rom.write_byte(0x1607C + offset, unknown_2)
write_int16(rom, 0x160CB + 2 * offset, door_1) rom.write_int16(0x160CB + 2 * offset, door_1)
write_int16(rom, 0x16169 + 2 * offset, door_2) rom.write_int16(0x16169 + 2 * offset, door_2)
elif isinstance(exit.addresses, list): elif isinstance(exit.addresses, list):
# is hole # is hole
for address in exit.addresses: for address in exit.addresses:
@ -706,7 +710,7 @@ def patch_rom(world, rom, player, team, enemized):
rom.write_byte(0x34FD6, 0x80) rom.write_byte(0x34FD6, 0x80)
overflow_replacement = GREEN_TWENTY_RUPEES overflow_replacement = GREEN_TWENTY_RUPEES
# Rupoor negative value # Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost) rom.write_int16(0x180036, world.rupoor_cost)
# Set stun items # Set stun items
rom.write_byte(0x180180, 0x02) # Hookshot only rom.write_byte(0x180180, 0x02) # Hookshot only
elif world.difficulty_adjustments[player] == 'expert': elif world.difficulty_adjustments[player] == 'expert':
@ -726,7 +730,7 @@ def patch_rom(world, rom, player, team, enemized):
rom.write_byte(0x34FD6, 0x80) rom.write_byte(0x34FD6, 0x80)
overflow_replacement = GREEN_TWENTY_RUPEES overflow_replacement = GREEN_TWENTY_RUPEES
# Rupoor negative value # Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost) rom.write_int16(0x180036, world.rupoor_cost)
# Set stun items # Set stun items
rom.write_byte(0x180180, 0x00) # Nothing rom.write_byte(0x180180, 0x00) # Nothing
else: else:
@ -745,7 +749,7 @@ def patch_rom(world, rom, player, team, enemized):
#Enable catching fairies #Enable catching fairies
rom.write_byte(0x34FD6, 0xF0) rom.write_byte(0x34FD6, 0xF0)
# Rupoor negative value # Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost) rom.write_int16(0x180036, world.rupoor_cost)
# Set stun items # Set stun items
rom.write_byte(0x180180, 0x03) # All standard items rom.write_byte(0x180180, 0x03) # All standard items
#Set overflow items for progressive equipment #Set overflow items for progressive equipment
@ -906,37 +910,37 @@ def patch_rom(world, rom, player, team, enemized):
ERtimeincrease = ERtimeincrease + 15 ERtimeincrease = ERtimeincrease + 15
if world.clock_mode[player] == False: if world.clock_mode[player] == False:
rom.write_bytes(0x180190, [0x00, 0x00, 0x00]) # turn off clock mode rom.write_bytes(0x180190, [0x00, 0x00, 0x00]) # turn off clock mode
write_int32(rom, 0x180200, 0) # red clock adjustment time (in frames, sint32) rom.write_int32(0x180200, 0) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 0) # blue clock adjustment time (in frames, sint32) rom.write_int32(0x180204, 0) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 0) # green clock adjustment time (in frames, sint32) rom.write_int32(0x180208, 0) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32) rom.write_int32(0x18020C, 0) # starting time (in frames, sint32)
elif world.clock_mode[player] == 'ohko': elif world.clock_mode[player] == 'ohko':
rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality
write_int32(rom, 0x180200, 0) # red clock adjustment time (in frames, sint32) rom.write_int32(0x180200, 0) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 0) # blue clock adjustment time (in frames, sint32) rom.write_int32(0x180204, 0) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 0) # green clock adjustment time (in frames, sint32) rom.write_int32(0x180208, 0) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32) rom.write_int32(0x18020C, 0) # starting time (in frames, sint32)
elif world.clock_mode[player] == 'countdown-ohko': elif world.clock_mode[player] == 'countdown-ohko':
rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality
write_int32(rom, 0x180200, -100 * 60 * 60 * 60) # red clock adjustment time (in frames, sint32) rom.write_int32(0x180200, -100 * 60 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32) rom.write_int32(0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32) rom.write_int32(0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
if world.difficulty_adjustments[player] == 'normal': if world.difficulty_adjustments[player] == 'normal':
write_int32(rom, 0x18020C, (10 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32) rom.write_int32(0x18020C, (10 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32)
else: else:
write_int32(rom, 0x18020C, int((5 + ERtimeincrease / 2) * 60 * 60)) # starting time (in frames, sint32) rom.write_int32(0x18020C, int((5 + ERtimeincrease / 2) * 60 * 60)) # starting time (in frames, sint32)
if world.clock_mode[player] == 'stopwatch': if world.clock_mode[player] == 'stopwatch':
rom.write_bytes(0x180190, [0x02, 0x01, 0x00]) # set stopwatch mode rom.write_bytes(0x180190, [0x02, 0x01, 0x00]) # set stopwatch mode
write_int32(rom, 0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32) rom.write_int32(0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32) rom.write_int32(0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32) rom.write_int32(0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32) rom.write_int32(0x18020C, 0) # starting time (in frames, sint32)
if world.clock_mode[player] == 'countdown': if world.clock_mode[player] == 'countdown':
rom.write_bytes(0x180190, [0x01, 0x01, 0x00]) # set countdown, with no reset available rom.write_bytes(0x180190, [0x01, 0x01, 0x00]) # set countdown, with no reset available
write_int32(rom, 0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32) rom.write_int32(0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32) rom.write_int32(0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32) rom.write_int32(0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, (40 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32) rom.write_int32(0x18020C, (40 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32)
# set up goals for treasure hunt # set up goals for treasure hunt
rom.write_bytes(0x180165, [0x0E, 0x28] if world.treasure_hunt_icon[player] == 'Triforce Piece' else [0x0D, 0x28]) rom.write_bytes(0x180165, [0x0E, 0x28] if world.treasure_hunt_icon[player] == 'Triforce Piece' else [0x0D, 0x28])
@ -1234,8 +1238,10 @@ def patch_rom(world, rom, player, team, enemized):
return reveal_bytes.get(location.parent_region.dungeon.name, 0x0000) return reveal_bytes.get(location.parent_region.dungeon.name, 0x0000)
return 0x0000 return 0x0000
write_int16(rom, 0x18017A, get_reveal_bytes('Green Pendant') if world.mapshuffle[player] else 0x0000) # Sahasrahla reveal rom.write_int16(0x18017A,
write_int16(rom, 0x18017C, get_reveal_bytes('Crystal 5')|get_reveal_bytes('Crystal 6') if world.mapshuffle[player] else 0x0000) # Bomb Shop Reveal get_reveal_bytes('Green Pendant') if world.mapshuffle[player] else 0x0000) # Sahasrahla reveal
rom.write_int16(0x18017C, get_reveal_bytes('Crystal 5') | get_reveal_bytes('Crystal 6') if world.mapshuffle[
player] else 0x0000) # Bomb Shop Reveal
rom.write_byte(0x180172, 0x01 if world.keyshuffle[player] == "universal" else 0x00) # universal keys rom.write_byte(0x180172, 0x01 if world.keyshuffle[player] == "universal" else 0x00) # universal keys
rom.write_byte(0x180175, 0x01 if world.retro[player] else 0x00) # rupee bow rom.write_byte(0x180175, 0x01 if world.retro[player] else 0x00) # rupee bow
@ -1243,9 +1249,12 @@ def patch_rom(world, rom, player, team, enemized):
rom.write_byte(0x180178, 0x32 if world.retro[player] else 0x00) # silver arrow cost rom.write_byte(0x180178, 0x32 if world.retro[player] else 0x00) # silver arrow cost
rom.write_byte(0x301FC, 0xDA if world.retro[player] else 0xE1) # rupees replace arrows under pots rom.write_byte(0x301FC, 0xDA if world.retro[player] else 0xE1) # rupees replace arrows under pots
rom.write_byte(0x30052, 0xDB if world.retro[player] else 0xE2) # replace arrows in fish prize from bottle merchant rom.write_byte(0x30052, 0xDB if world.retro[player] else 0xE2) # replace arrows in fish prize from bottle merchant
rom.write_bytes(0xECB4E, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3, 0x7E]) # Thief steals rupees instead of arrows rom.write_bytes(0xECB4E, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3,
rom.write_bytes(0xF0D96, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3, 0x7E]) # Pikit steals rupees instead of arrows 0x7E]) # Thief steals rupees instead of arrows
rom.write_bytes(0xEDA5, [0x35, 0x41] if world.retro[player] else [0x43, 0x44]) # Chest game gives rupees instead of arrows rom.write_bytes(0xF0D96, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3,
0x7E]) # Pikit steals rupees instead of arrows
rom.write_bytes(0xEDA5,
[0x35, 0x41] if world.retro[player] else [0x43, 0x44]) # Chest game gives rupees instead of arrows
digging_game_rng = local_random.randint(1, 30) # set rng for digging game digging_game_rng = local_random.randint(1, 30) # set rng for digging game
rom.write_byte(0x180020, digging_game_rng) rom.write_byte(0x180020, digging_game_rng)
rom.write_byte(0xEFD95, digging_game_rng) rom.write_byte(0xEFD95, digging_game_rng)
@ -1263,14 +1272,14 @@ def patch_rom(world, rom, player, team, enemized):
rom.write_bytes(0x6D313, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E]) rom.write_bytes(0x6D313, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
rom.write_byte(0x18004E, 0) # Escape Fill (nothing) rom.write_byte(0x18004E, 0) # Escape Fill (nothing)
write_int16(rom, 0x180183, 300) # Escape fill rupee bow rom.write_int16(0x180183, 300) # Escape fill rupee bow
rom.write_bytes(0x180185, [0, 0, 0]) # Uncle respawn refills (magic, bombs, arrows) rom.write_bytes(0x180185, [0, 0, 0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,0,0]) # Zelda respawn refills (magic, bombs, arrows) rom.write_bytes(0x180188, [0,0,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,0,0]) # Mantle respawn refills (magic, bombs, arrows) rom.write_bytes(0x18018B, [0,0,0]) # Mantle respawn refills (magic, bombs, arrows)
if world.mode[player] == 'standard': if world.mode[player] == 'standard':
if uncle_location.item is not None and uncle_location.item.name in ['Bow', 'Progressive Bow']: if uncle_location.item is not None and uncle_location.item.name in ['Bow', 'Progressive Bow']:
rom.write_byte(0x18004E, 1) # Escape Fill (arrows) rom.write_byte(0x18004E, 1) # Escape Fill (arrows)
write_int16(rom, 0x180183, 300) # Escape fill rupee bow rom.write_int16(0x180183, 300) # Escape fill rupee bow
rom.write_bytes(0x180185, [0, 0, 70]) # Uncle respawn refills (magic, bombs, arrows) rom.write_bytes(0x180185, [0, 0, 70]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,0,10]) # Zelda respawn refills (magic, bombs, arrows) rom.write_bytes(0x180188, [0,0,10]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,0,10]) # Mantle respawn refills (magic, bombs, arrows) rom.write_bytes(0x18018B, [0,0,10]) # Mantle respawn refills (magic, bombs, arrows)
@ -1945,117 +1954,118 @@ def set_inverted_mode(world, player, rom):
rom.write_byte(snes_to_pc(0x05AF79), 0xF0) rom.write_byte(snes_to_pc(0x05AF79), 0xF0)
rom.write_byte(snes_to_pc(0x0DB3C5), 0xC6) rom.write_byte(snes_to_pc(0x0DB3C5), 0xC6)
rom.write_byte(snes_to_pc(0x07A3F4), 0xF0) # duck rom.write_byte(snes_to_pc(0x07A3F4), 0xF0) # duck
write_int16s(rom, snes_to_pc(0x02E849), [0x0043, 0x0056, 0x0058, 0x006C, 0x006F, 0x0070, 0x007B, 0x007F, 0x001B]) # dw flute rom.write_int16s(snes_to_pc(0x02E849),
write_int16(rom, snes_to_pc(0x02E8D5), 0x07C8) [0x0043, 0x0056, 0x0058, 0x006C, 0x006F, 0x0070, 0x007B, 0x007F, 0x001B]) # dw flute
write_int16(rom, snes_to_pc(0x02E8F7), 0x01F8) rom.write_int16(snes_to_pc(0x02E8D5), 0x07C8)
rom.write_int16(snes_to_pc(0x02E8F7), 0x01F8)
rom.write_byte(snes_to_pc(0x08D40C), 0xD0) # morph proof rom.write_byte(snes_to_pc(0x08D40C), 0xD0) # morph proof
# the following bytes should only be written in vanilla # the following bytes should only be written in vanilla
# or they'll overwrite the randomizer's shuffles # or they'll overwrite the randomizer's shuffles
if world.shuffle[player] == 'vanilla': if world.shuffle[player] == 'vanilla':
rom.write_byte(0xDBB73 + 0x23, 0x37) # switch AT and GT rom.write_byte(0xDBB73 + 0x23, 0x37) # switch AT and GT
rom.write_byte(0xDBB73 + 0x36, 0x24) rom.write_byte(0xDBB73 + 0x36, 0x24)
write_int16(rom, 0x15AEE + 2*0x38, 0x00E0) rom.write_int16(0x15AEE + 2 * 0x38, 0x00E0)
write_int16(rom, 0x15AEE + 2*0x25, 0x000C) rom.write_int16(0x15AEE + 2 * 0x25, 0x000C)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']: if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(0x15B8C, 0x6C) rom.write_byte(0x15B8C, 0x6C)
rom.write_byte(0xDBB73 + 0x00, 0x53) # switch bomb shop and links house rom.write_byte(0xDBB73 + 0x00, 0x53) # switch bomb shop and links house
rom.write_byte(0xDBB73 + 0x52, 0x01) rom.write_byte(0xDBB73 + 0x52, 0x01)
rom.write_byte(0xDBB73 + 0x15, 0x06) # bumper and old man cave rom.write_byte(0xDBB73 + 0x15, 0x06) # bumper and old man cave
write_int16(rom, 0x15AEE + 2*0x17, 0x00F0) rom.write_int16(0x15AEE + 2 * 0x17, 0x00F0)
rom.write_byte(0xDBB73 + 0x05, 0x16) rom.write_byte(0xDBB73 + 0x05, 0x16)
write_int16(rom, 0x15AEE + 2*0x07, 0x00FB) rom.write_int16(0x15AEE + 2 * 0x07, 0x00FB)
rom.write_byte(0xDBB73 + 0x2D, 0x17) rom.write_byte(0xDBB73 + 0x2D, 0x17)
write_int16(rom, 0x15AEE + 2*0x2F, 0x00EB) rom.write_int16(0x15AEE + 2 * 0x2F, 0x00EB)
rom.write_byte(0xDBB73 + 0x06, 0x2E) rom.write_byte(0xDBB73 + 0x06, 0x2E)
write_int16(rom, 0x15AEE + 2*0x08, 0x00E6) rom.write_int16(0x15AEE + 2 * 0x08, 0x00E6)
rom.write_byte(0xDBB73 + 0x16, 0x5E) rom.write_byte(0xDBB73 + 0x16, 0x5E)
rom.write_byte(0xDBB73 + 0x6F, 0x07) # DDM fairy to old man cave rom.write_byte(0xDBB73 + 0x6F, 0x07) # DDM fairy to old man cave
write_int16(rom, 0x15AEE + 2*0x18, 0x00F1) rom.write_int16(0x15AEE + 2 * 0x18, 0x00F1)
rom.write_byte(0x15B8C + 0x18, 0x43) rom.write_byte(0x15B8C + 0x18, 0x43)
write_int16(rom, 0x15BDB + 2 * 0x18, 0x1400) rom.write_int16(0x15BDB + 2 * 0x18, 0x1400)
write_int16(rom, 0x15C79 + 2 * 0x18, 0x0294) rom.write_int16(0x15C79 + 2 * 0x18, 0x0294)
write_int16(rom, 0x15D17 + 2 * 0x18, 0x0600) rom.write_int16(0x15D17 + 2 * 0x18, 0x0600)
write_int16(rom, 0x15DB5 + 2 * 0x18, 0x02E8) rom.write_int16(0x15DB5 + 2 * 0x18, 0x02E8)
write_int16(rom, 0x15E53 + 2 * 0x18, 0x0678) rom.write_int16(0x15E53 + 2 * 0x18, 0x0678)
write_int16(rom, 0x15EF1 + 2 * 0x18, 0x0303) rom.write_int16(0x15EF1 + 2 * 0x18, 0x0303)
write_int16(rom, 0x15F8F + 2 * 0x18, 0x0685) rom.write_int16(0x15F8F + 2 * 0x18, 0x0685)
rom.write_byte(0x1602D + 0x18, 0x0A) rom.write_byte(0x1602D + 0x18, 0x0A)
rom.write_byte(0x1607C + 0x18, 0xF6) rom.write_byte(0x1607C + 0x18, 0xF6)
write_int16(rom, 0x160CB + 2 * 0x18, 0x0000) rom.write_int16(0x160CB + 2 * 0x18, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x18, 0x0000) rom.write_int16(0x16169 + 2 * 0x18, 0x0000)
write_int16(rom, 0x15AEE + 2 * 0x3D, 0x0003) # pyramid exit and houlihan rom.write_int16(0x15AEE + 2 * 0x3D, 0x0003) # pyramid exit and houlihan
rom.write_byte(0x15B8C + 0x3D, 0x5B) rom.write_byte(0x15B8C + 0x3D, 0x5B)
write_int16(rom, 0x15BDB + 2 * 0x3D, 0x0B0E) rom.write_int16(0x15BDB + 2 * 0x3D, 0x0B0E)
write_int16(rom, 0x15C79 + 2 * 0x3D, 0x075A) rom.write_int16(0x15C79 + 2 * 0x3D, 0x075A)
write_int16(rom, 0x15D17 + 2 * 0x3D, 0x0674) rom.write_int16(0x15D17 + 2 * 0x3D, 0x0674)
write_int16(rom, 0x15DB5 + 2 * 0x3D, 0x07A8) rom.write_int16(0x15DB5 + 2 * 0x3D, 0x07A8)
write_int16(rom, 0x15E53 + 2 * 0x3D, 0x06E8) rom.write_int16(0x15E53 + 2 * 0x3D, 0x06E8)
write_int16(rom, 0x15EF1 + 2 * 0x3D, 0x07C7) rom.write_int16(0x15EF1 + 2 * 0x3D, 0x07C7)
write_int16(rom, 0x15F8F + 2 * 0x3D, 0x06F3) rom.write_int16(0x15F8F + 2 * 0x3D, 0x06F3)
rom.write_byte(0x1602D + 0x3D, 0x06) rom.write_byte(0x1602D + 0x3D, 0x06)
rom.write_byte(0x1607C + 0x3D, 0xFA) rom.write_byte(0x1607C + 0x3D, 0xFA)
write_int16(rom, 0x160CB + 2 * 0x3D, 0x0000) rom.write_int16(0x160CB + 2 * 0x3D, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x3D, 0x0000) rom.write_int16(0x16169 + 2 * 0x3D, 0x0000)
write_int16(rom, snes_to_pc(0x02D8D4), 0x112) # change sactuary spawn point to dark sanc rom.write_int16(snes_to_pc(0x02D8D4), 0x112) # change sactuary spawn point to dark sanc
rom.write_bytes(snes_to_pc(0x02D8E8), [0x22, 0x22, 0x22, 0x23, 0x04, 0x04, 0x04, 0x05]) rom.write_bytes(snes_to_pc(0x02D8E8), [0x22, 0x22, 0x22, 0x23, 0x04, 0x04, 0x04, 0x05])
write_int16(rom, snes_to_pc(0x02D91A), 0x0400) rom.write_int16(snes_to_pc(0x02D91A), 0x0400)
write_int16(rom, snes_to_pc(0x02D928), 0x222E) rom.write_int16(snes_to_pc(0x02D928), 0x222E)
write_int16(rom, snes_to_pc(0x02D936), 0x229A) rom.write_int16(snes_to_pc(0x02D936), 0x229A)
write_int16(rom, snes_to_pc(0x02D944), 0x0480) rom.write_int16(snes_to_pc(0x02D944), 0x0480)
write_int16(rom, snes_to_pc(0x02D952), 0x00A5) rom.write_int16(snes_to_pc(0x02D952), 0x00A5)
write_int16(rom, snes_to_pc(0x02D960), 0x007F) rom.write_int16(snes_to_pc(0x02D960), 0x007F)
rom.write_byte(snes_to_pc(0x02D96D), 0x14) rom.write_byte(snes_to_pc(0x02D96D), 0x14)
rom.write_byte(snes_to_pc(0x02D974), 0x00) rom.write_byte(snes_to_pc(0x02D974), 0x00)
rom.write_byte(snes_to_pc(0x02D97B), 0xFF) rom.write_byte(snes_to_pc(0x02D97B), 0xFF)
rom.write_byte(snes_to_pc(0x02D982), 0x00) rom.write_byte(snes_to_pc(0x02D982), 0x00)
rom.write_byte(snes_to_pc(0x02D989), 0x02) rom.write_byte(snes_to_pc(0x02D989), 0x02)
rom.write_byte(snes_to_pc(0x02D990), 0x00) rom.write_byte(snes_to_pc(0x02D990), 0x00)
write_int16(rom, snes_to_pc(0x02D998), 0x0000) rom.write_int16(snes_to_pc(0x02D998), 0x0000)
write_int16(rom, snes_to_pc(0x02D9A6), 0x005A) rom.write_int16(snes_to_pc(0x02D9A6), 0x005A)
rom.write_byte(snes_to_pc(0x02D9B3), 0x12) rom.write_byte(snes_to_pc(0x02D9B3), 0x12)
# keep the old man spawn point at old man house unless shuffle is vanilla # keep the old man spawn point at old man house unless shuffle is vanilla
if world.shuffle[player] in ['vanilla', 'dungeonsfull', 'dungeonssimple']: if world.shuffle[player] in ['vanilla', 'dungeonsfull', 'dungeonssimple']:
rom.write_bytes(snes_to_pc(0x308350), [0x00, 0x00, 0x01]) rom.write_bytes(snes_to_pc(0x308350), [0x00, 0x00, 0x01])
write_int16(rom, snes_to_pc(0x02D8DE), 0x00F1) rom.write_int16(snes_to_pc(0x02D8DE), 0x00F1)
rom.write_bytes(snes_to_pc(0x02D910), [0x1F, 0x1E, 0x1F, 0x1F, 0x03, 0x02, 0x03, 0x03]) rom.write_bytes(snes_to_pc(0x02D910), [0x1F, 0x1E, 0x1F, 0x1F, 0x03, 0x02, 0x03, 0x03])
write_int16(rom, snes_to_pc(0x02D924), 0x0300) rom.write_int16(snes_to_pc(0x02D924), 0x0300)
write_int16(rom, snes_to_pc(0x02D932), 0x1F10) rom.write_int16(snes_to_pc(0x02D932), 0x1F10)
write_int16(rom, snes_to_pc(0x02D940), 0x1FC0) rom.write_int16(snes_to_pc(0x02D940), 0x1FC0)
write_int16(rom, snes_to_pc(0x02D94E), 0x0378) rom.write_int16(snes_to_pc(0x02D94E), 0x0378)
write_int16(rom, snes_to_pc(0x02D95C), 0x0187) rom.write_int16(snes_to_pc(0x02D95C), 0x0187)
write_int16(rom, snes_to_pc(0x02D96A), 0x017F) rom.write_int16(snes_to_pc(0x02D96A), 0x017F)
rom.write_byte(snes_to_pc(0x02D972), 0x06) rom.write_byte(snes_to_pc(0x02D972), 0x06)
rom.write_byte(snes_to_pc(0x02D979), 0x00) rom.write_byte(snes_to_pc(0x02D979), 0x00)
rom.write_byte(snes_to_pc(0x02D980), 0xFF) rom.write_byte(snes_to_pc(0x02D980), 0xFF)
rom.write_byte(snes_to_pc(0x02D987), 0x00) rom.write_byte(snes_to_pc(0x02D987), 0x00)
rom.write_byte(snes_to_pc(0x02D98E), 0x22) rom.write_byte(snes_to_pc(0x02D98E), 0x22)
rom.write_byte(snes_to_pc(0x02D995), 0x12) rom.write_byte(snes_to_pc(0x02D995), 0x12)
write_int16(rom, snes_to_pc(0x02D9A2), 0x0000) rom.write_int16(snes_to_pc(0x02D9A2), 0x0000)
write_int16(rom, snes_to_pc(0x02D9B0), 0x0007) rom.write_int16(snes_to_pc(0x02D9B0), 0x0007)
rom.write_byte(snes_to_pc(0x02D9B8), 0x12) rom.write_byte(snes_to_pc(0x02D9B8), 0x12)
rom.write_bytes(0x180247, [0x00, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00]) rom.write_bytes(0x180247, [0x00, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00])
write_int16(rom, 0x15AEE + 2 * 0x06, 0x0020) # post aga hyrule castle spawn rom.write_int16(0x15AEE + 2 * 0x06, 0x0020) # post aga hyrule castle spawn
rom.write_byte(0x15B8C + 0x06, 0x1B) rom.write_byte(0x15B8C + 0x06, 0x1B)
write_int16(rom, 0x15BDB + 2 * 0x06, 0x00AE) rom.write_int16(0x15BDB + 2 * 0x06, 0x00AE)
write_int16(rom, 0x15C79 + 2 * 0x06, 0x0610) rom.write_int16(0x15C79 + 2 * 0x06, 0x0610)
write_int16(rom, 0x15D17 + 2 * 0x06, 0x077E) rom.write_int16(0x15D17 + 2 * 0x06, 0x077E)
write_int16(rom, 0x15DB5 + 2 * 0x06, 0x0672) rom.write_int16(0x15DB5 + 2 * 0x06, 0x0672)
write_int16(rom, 0x15E53 + 2 * 0x06, 0x07F8) rom.write_int16(0x15E53 + 2 * 0x06, 0x07F8)
write_int16(rom, 0x15EF1 + 2 * 0x06, 0x067D) rom.write_int16(0x15EF1 + 2 * 0x06, 0x067D)
write_int16(rom, 0x15F8F + 2 * 0x06, 0x0803) rom.write_int16(0x15F8F + 2 * 0x06, 0x0803)
rom.write_byte(0x1602D + 0x06, 0x00) rom.write_byte(0x1602D + 0x06, 0x00)
rom.write_byte(0x1607C + 0x06, 0xF2) rom.write_byte(0x1607C + 0x06, 0xF2)
write_int16(rom, 0x160CB + 2 * 0x06, 0x0000) rom.write_int16(0x160CB + 2 * 0x06, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x06, 0x0000) rom.write_int16(0x16169 + 2 * 0x06, 0x0000)
write_int16(rom, snes_to_pc(0x02E87B), 0x00AE) # move flute splot 9 rom.write_int16(snes_to_pc(0x02E87B), 0x00AE) # move flute splot 9
write_int16(rom, snes_to_pc(0x02E89D), 0x0610) rom.write_int16(snes_to_pc(0x02E89D), 0x0610)
write_int16(rom, snes_to_pc(0x02E8BF), 0x077E) rom.write_int16(snes_to_pc(0x02E8BF), 0x077E)
write_int16(rom, snes_to_pc(0x02E8E1), 0x0672) rom.write_int16(snes_to_pc(0x02E8E1), 0x0672)
write_int16(rom, snes_to_pc(0x02E903), 0x07F8) rom.write_int16(snes_to_pc(0x02E903), 0x07F8)
write_int16(rom, snes_to_pc(0x02E925), 0x067D) rom.write_int16(snes_to_pc(0x02E925), 0x067D)
write_int16(rom, snes_to_pc(0x02E947), 0x0803) rom.write_int16(snes_to_pc(0x02E947), 0x0803)
write_int16(rom, snes_to_pc(0x02E969), 0x0000) rom.write_int16(snes_to_pc(0x02E969), 0x0000)
write_int16(rom, snes_to_pc(0x02E98B), 0xFFF2) rom.write_int16(snes_to_pc(0x02E98B), 0xFFF2)
rom.write_byte(snes_to_pc(0x1AF696), 0xF0) # bat sprite retreat rom.write_byte(snes_to_pc(0x1AF696), 0xF0) # bat sprite retreat
rom.write_byte(snes_to_pc(0x1AF6B2), 0x33) rom.write_byte(snes_to_pc(0x1AF6B2), 0x33)
rom.write_bytes(snes_to_pc(0x1AF730), [0x6A, 0x9E, 0x0C, 0x00, 0x7A, 0x9E, 0x0C, rom.write_bytes(snes_to_pc(0x1AF730), [0x6A, 0x9E, 0x0C, 0x00, 0x7A, 0x9E, 0x0C,
@ -2063,7 +2073,7 @@ def set_inverted_mode(world, player, rom):
0x0C, 0x00, 0x7A, 0xAE, 0x0C, 0x00, 0x8A, 0x0C, 0x00, 0x7A, 0xAE, 0x0C, 0x00, 0x8A,
0xAE, 0x0C, 0x00, 0x67, 0x97, 0x0C, 0x00, 0xAE, 0x0C, 0x00, 0x67, 0x97, 0x0C, 0x00,
0x8D, 0x97, 0x0C, 0x00]) 0x8D, 0x97, 0x0C, 0x00])
write_int16s(rom, snes_to_pc(0x0FF1C8), [0x190F, 0x190F, 0x190F, 0x194C, 0x190F, rom.write_int16s(snes_to_pc(0x0FF1C8), [0x190F, 0x190F, 0x190F, 0x194C, 0x190F,
0x194B, 0x190F, 0x195C, 0x594B, 0x194C, 0x194B, 0x190F, 0x195C, 0x594B, 0x194C,
0x19EE, 0x19EE, 0x194B, 0x19EE, 0x19EE, 0x19EE, 0x19EE, 0x194B, 0x19EE, 0x19EE,
0x19EE, 0x594B, 0x190F, 0x595C, 0x190F, 0x19EE, 0x594B, 0x190F, 0x595C, 0x190F,
@ -2071,38 +2081,38 @@ def set_inverted_mode(world, player, rom):
0x19EE, 0x195C, 0x19EE, 0x19EE, 0x19EE, 0x19EE, 0x195C, 0x19EE, 0x19EE, 0x19EE,
0x19EE, 0x595C, 0x595B, 0x190F, 0x190F, 0x19EE, 0x595C, 0x595B, 0x190F, 0x190F,
0x190F]) 0x190F])
write_int16s(rom, snes_to_pc(0x0FA480), [0x190F, 0x196B, 0x9D04, 0x9D04, 0x196B, rom.write_int16s(snes_to_pc(0x0FA480), [0x190F, 0x196B, 0x9D04, 0x9D04, 0x196B,
0x190F, 0x9D04, 0x9D04]) 0x190F, 0x9D04, 0x9D04])
write_int16s(rom, snes_to_pc(0x1bb810), [0x00BE, 0x00C0, 0x013E]) rom.write_int16s(snes_to_pc(0x1bb810), [0x00BE, 0x00C0, 0x013E])
write_int16s(rom, snes_to_pc(0x1bb836), [0x001B, 0x001B, 0x001B]) rom.write_int16s(snes_to_pc(0x1bb836), [0x001B, 0x001B, 0x001B])
write_int16(rom, snes_to_pc(0x308300), 0x0140) # new pyramid hole entrance rom.write_int16(snes_to_pc(0x308300), 0x0140) # new pyramid hole entrance
write_int16(rom, snes_to_pc(0x308320), 0x001B) rom.write_int16(snes_to_pc(0x308320), 0x001B)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']: if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(snes_to_pc(0x308340), 0x7B) rom.write_byte(snes_to_pc(0x308340), 0x7B)
write_int16(rom, snes_to_pc(0x1af504), 0x148B) rom.write_int16(snes_to_pc(0x1af504), 0x148B)
write_int16(rom, snes_to_pc(0x1af50c), 0x149B) rom.write_int16(snes_to_pc(0x1af50c), 0x149B)
write_int16(rom, snes_to_pc(0x1af514), 0x14A4) rom.write_int16(snes_to_pc(0x1af514), 0x14A4)
write_int16(rom, snes_to_pc(0x1af51c), 0x1489) rom.write_int16(snes_to_pc(0x1af51c), 0x1489)
write_int16(rom, snes_to_pc(0x1af524), 0x14AC) rom.write_int16(snes_to_pc(0x1af524), 0x14AC)
write_int16(rom, snes_to_pc(0x1af52c), 0x54AC) rom.write_int16(snes_to_pc(0x1af52c), 0x54AC)
write_int16(rom, snes_to_pc(0x1af534), 0x148C) rom.write_int16(snes_to_pc(0x1af534), 0x148C)
write_int16(rom, snes_to_pc(0x1af53c), 0x548C) rom.write_int16(snes_to_pc(0x1af53c), 0x548C)
write_int16(rom, snes_to_pc(0x1af544), 0x1484) rom.write_int16(snes_to_pc(0x1af544), 0x1484)
write_int16(rom, snes_to_pc(0x1af54c), 0x5484) rom.write_int16(snes_to_pc(0x1af54c), 0x5484)
write_int16(rom, snes_to_pc(0x1af554), 0x14A2) rom.write_int16(snes_to_pc(0x1af554), 0x14A2)
write_int16(rom, snes_to_pc(0x1af55c), 0x54A2) rom.write_int16(snes_to_pc(0x1af55c), 0x54A2)
write_int16(rom, snes_to_pc(0x1af564), 0x14A0) rom.write_int16(snes_to_pc(0x1af564), 0x14A0)
write_int16(rom, snes_to_pc(0x1af56c), 0x54A0) rom.write_int16(snes_to_pc(0x1af56c), 0x54A0)
write_int16(rom, snes_to_pc(0x1af574), 0x148E) rom.write_int16(snes_to_pc(0x1af574), 0x148E)
write_int16(rom, snes_to_pc(0x1af57c), 0x548E) rom.write_int16(snes_to_pc(0x1af57c), 0x548E)
write_int16(rom, snes_to_pc(0x1af584), 0x14AE) rom.write_int16(snes_to_pc(0x1af584), 0x14AE)
write_int16(rom, snes_to_pc(0x1af58c), 0x54AE) rom.write_int16(snes_to_pc(0x1af58c), 0x54AE)
rom.write_byte(snes_to_pc(0x00DB9D), 0x1A) # castle hole graphics rom.write_byte(snes_to_pc(0x00DB9D), 0x1A) # castle hole graphics
rom.write_byte(snes_to_pc(0x00DC09), 0x1A) rom.write_byte(snes_to_pc(0x00DC09), 0x1A)
rom.write_byte(snes_to_pc(0x00D009), 0x31) rom.write_byte(snes_to_pc(0x00D009), 0x31)
rom.write_byte(snes_to_pc(0x00D0e8), 0xE0) rom.write_byte(snes_to_pc(0x00D0e8), 0xE0)
rom.write_byte(snes_to_pc(0x00D1c7), 0x00) rom.write_byte(snes_to_pc(0x00D1c7), 0x00)
write_int16(rom, snes_to_pc(0x1BE8DA), 0x39AD) rom.write_int16(snes_to_pc(0x1BE8DA), 0x39AD)
rom.write_byte(0xF6E58, 0x80) # no whirlpool under castle gate rom.write_byte(0xF6E58, 0x80) # no whirlpool under castle gate
rom.write_bytes(0x0086E, [0x5C, 0x00, 0xA0, 0xA1]) # TR tail rom.write_bytes(0x0086E, [0x5C, 0x00, 0xA0, 0xA1]) # TR tail
rom.write_bytes(snes_to_pc(0x1BC67A), [0x2E, 0x0B, 0x82]) # add warps under rocks rom.write_bytes(snes_to_pc(0x1BC67A), [0x2E, 0x0B, 0x82]) # add warps under rocks
@ -2112,25 +2122,25 @@ def set_inverted_mode(world, player, rom):
rom.write_bytes(snes_to_pc(0x1BC3DF), [0xD8, 0xD1]) rom.write_bytes(snes_to_pc(0x1BC3DF), [0xD8, 0xD1])
rom.write_bytes(snes_to_pc(0x1BD1D8), [0xA8, 0x02, 0x82, 0xFF, 0xFF]) rom.write_bytes(snes_to_pc(0x1BD1D8), [0xA8, 0x02, 0x82, 0xFF, 0xFF])
rom.write_bytes(snes_to_pc(0x1BC85A), [0x50, 0x0F, 0x82]) rom.write_bytes(snes_to_pc(0x1BC85A), [0x50, 0x0F, 0x82])
write_int16(rom, 0xDB96F + 2 * 0x35, 0x001B) # move pyramid exit door rom.write_int16(0xDB96F + 2 * 0x35, 0x001B) # move pyramid exit door
write_int16(rom, 0xDBA71 + 2 * 0x35, 0x06A4) rom.write_int16(0xDBA71 + 2 * 0x35, 0x06A4)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']: if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(0xDBB73 + 0x35, 0x36) rom.write_byte(0xDBB73 + 0x35, 0x36)
rom.write_byte(snes_to_pc(0x09D436), 0xF3) # remove castle gate warp rom.write_byte(snes_to_pc(0x09D436), 0xF3) # remove castle gate warp
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']: if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
write_int16(rom, 0x15AEE + 2 * 0x37, 0x0010) # pyramid exit to new hc area rom.write_int16(0x15AEE + 2 * 0x37, 0x0010) # pyramid exit to new hc area
rom.write_byte(0x15B8C + 0x37, 0x1B) rom.write_byte(0x15B8C + 0x37, 0x1B)
write_int16(rom, 0x15BDB + 2 * 0x37, 0x0418) rom.write_int16(0x15BDB + 2 * 0x37, 0x0418)
write_int16(rom, 0x15C79 + 2 * 0x37, 0x0679) rom.write_int16(0x15C79 + 2 * 0x37, 0x0679)
write_int16(rom, 0x15D17 + 2 * 0x37, 0x06B4) rom.write_int16(0x15D17 + 2 * 0x37, 0x06B4)
write_int16(rom, 0x15DB5 + 2 * 0x37, 0x06C6) rom.write_int16(0x15DB5 + 2 * 0x37, 0x06C6)
write_int16(rom, 0x15E53 + 2 * 0x37, 0x0738) rom.write_int16(0x15E53 + 2 * 0x37, 0x0738)
write_int16(rom, 0x15EF1 + 2 * 0x37, 0x06E6) rom.write_int16(0x15EF1 + 2 * 0x37, 0x06E6)
write_int16(rom, 0x15F8F + 2 * 0x37, 0x0733) rom.write_int16(0x15F8F + 2 * 0x37, 0x0733)
rom.write_byte(0x1602D + 0x37, 0x07) rom.write_byte(0x1602D + 0x37, 0x07)
rom.write_byte(0x1607C + 0x37, 0xF9) rom.write_byte(0x1607C + 0x37, 0xF9)
write_int16(rom, 0x160CB + 2 * 0x37, 0x0000) rom.write_int16(0x160CB + 2 * 0x37, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x37, 0x0000) rom.write_int16(0x16169 + 2 * 0x37, 0x0000)
rom.write_bytes(snes_to_pc(0x1BC387), [0xDD, 0xD1]) rom.write_bytes(snes_to_pc(0x1BC387), [0xDD, 0xD1])
rom.write_bytes(snes_to_pc(0x1BD1DD), [0xA4, 0x06, 0x82, 0x9E, 0x06, 0x82, 0xFF, 0xFF]) rom.write_bytes(snes_to_pc(0x1BD1DD), [0xA4, 0x06, 0x82, 0x9E, 0x06, 0x82, 0xFF, 0xFF])
rom.write_byte(0x180089, 0x01) # open TR after exit rom.write_byte(0x180089, 0x01) # open TR after exit
@ -2146,9 +2156,9 @@ def patch_shuffled_dark_sanc(world, rom, player):
rom.write_byte(0x180241, 0x01) rom.write_byte(0x180241, 0x01)
rom.write_byte(0x180248, door_index + 1) rom.write_byte(0x180248, door_index + 1)
write_int16(rom, 0x180250, room_id) rom.write_int16(0x180250, room_id)
rom.write_byte(0x180252, ow_area) rom.write_byte(0x180252, ow_area)
write_int16s(rom, 0x180253, [vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x]) rom.write_int16s(0x180253, [vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x])
rom.write_bytes(0x180262, [unknown_1, unknown_2, 0x00]) rom.write_bytes(0x180262, [unknown_1, unknown_2, 0x00])
InconvenientDungeonEntrances = {'Turtle Rock': 'Turtle Rock Main', InconvenientDungeonEntrances = {'Turtle Rock': 'Turtle Rock Main',