816 lines
32 KiB
Python
816 lines
32 KiB
Python
from .Utils import data_path, __version__
|
|
from .Colors import *
|
|
import logging
|
|
import worlds.oot.Music as music
|
|
import worlds.oot.Sounds as sfx
|
|
import worlds.oot.IconManip as icon
|
|
from .JSONDump import dump_obj, CollapseList, CollapseDict, AlignedDict, SortedDict
|
|
import json
|
|
|
|
logger = logging.getLogger('')
|
|
|
|
# Options are all lowercase and have underscores instead of spaces
|
|
# this needs to be undone for the oot generator
|
|
def format_cosmetic_option_result(option_result):
|
|
def format_word(word):
|
|
special_words = {
|
|
'nes': 'NES',
|
|
'gamecube': 'GameCube',
|
|
'of': 'of'
|
|
}
|
|
return special_words.get(word, word.capitalize())
|
|
words = option_result.split('_')
|
|
return ' '.join([format_word(word) for word in words])
|
|
|
|
|
|
def patch_targeting(rom, ootworld, symbols):
|
|
# Set default targeting option to Hold
|
|
if ootworld.default_targeting == 'hold':
|
|
rom.write_byte(0xB71E6D, 0x01)
|
|
else:
|
|
rom.write_byte(0xB71E6D, 0x00)
|
|
|
|
|
|
def patch_dpad(rom, ootworld, symbols):
|
|
# Display D-Pad HUD
|
|
if ootworld.display_dpad:
|
|
rom.write_byte(symbols['CFG_DISPLAY_DPAD'], 0x01)
|
|
else:
|
|
rom.write_byte(symbols['CFG_DISPLAY_DPAD'], 0x00)
|
|
|
|
|
|
def patch_dpad_info(rom, ootworld, symbols):
|
|
# Display D-Pad HUD in pause menu for either dungeon info or equips
|
|
if ootworld.dpad_dungeon_menu:
|
|
rom.write_byte(symbols['CFG_DPAD_DUNGEON_INFO_ENABLE'], 0x01)
|
|
else:
|
|
rom.write_byte(symbols['CFG_DPAD_DUNGEON_INFO_ENABLE'], 0x00)
|
|
|
|
|
|
def patch_music(rom, ootworld, symbols):
|
|
# patch music
|
|
if ootworld.background_music != 'normal' or ootworld.fanfares != 'normal':
|
|
music.restore_music(rom)
|
|
log, errors = music.randomize_music(rom, ootworld, {})
|
|
if errors:
|
|
logger.error(errors)
|
|
else:
|
|
music.restore_music(rom)
|
|
|
|
|
|
def patch_model_colors(rom, color, model_addresses):
|
|
main_addresses, dark_addresses = model_addresses
|
|
|
|
if color is None:
|
|
for address in main_addresses + dark_addresses:
|
|
original = rom.original.read_bytes(address, 3)
|
|
rom.write_bytes(address, original)
|
|
return
|
|
|
|
for address in main_addresses:
|
|
rom.write_bytes(address, color)
|
|
|
|
darkened_color = list(map(lambda light: int(max((light - 0x32) * 0.6, 0)), color))
|
|
for address in dark_addresses:
|
|
rom.write_bytes(address, darkened_color)
|
|
|
|
|
|
def patch_tunic_icon(rom, tunic, color):
|
|
# patch tunic icon colors
|
|
icon_locations = {
|
|
'Kokiri Tunic': 0x007FE000,
|
|
'Goron Tunic': 0x007FF000,
|
|
'Zora Tunic': 0x00800000,
|
|
}
|
|
|
|
if color is not None:
|
|
tunic_icon = icon.generate_tunic_icon(color)
|
|
else:
|
|
tunic_icon = rom.original.read_bytes(icon_locations[tunic], 0x1000)
|
|
|
|
rom.write_bytes(icon_locations[tunic], tunic_icon)
|
|
|
|
|
|
def patch_tunic_colors(rom, ootworld, symbols):
|
|
# patch tunic colors
|
|
tunics = [
|
|
('Kokiri Tunic', 'kokiri_color', 0x00B6DA38),
|
|
('Goron Tunic', 'goron_color', 0x00B6DA3B),
|
|
('Zora Tunic', 'zora_color', 0x00B6DA3E),
|
|
]
|
|
tunic_color_list = get_tunic_colors()
|
|
|
|
for tunic, tunic_setting, address in tunics:
|
|
tunic_option = format_cosmetic_option_result(ootworld.__dict__[tunic_setting])
|
|
|
|
# handle random
|
|
if tunic_option == 'Random Choice':
|
|
tunic_option = random.choice(tunic_color_list)
|
|
# handle completely random
|
|
if tunic_option == 'Completely Random':
|
|
color = generate_random_color()
|
|
# grab the color from the list
|
|
elif tunic_option in tunic_colors:
|
|
color = list(tunic_colors[tunic_option])
|
|
# build color from hex code
|
|
else:
|
|
color = hex_to_color(tunic_option)
|
|
tunic_option = 'Custom'
|
|
# "Weird" weirdshots will crash if the Kokiri Tunic Green value is > 0x99. Brickwall it.
|
|
if ootworld.logic_rules != 'glitchless' and tunic == 'Kokiri Tunic':
|
|
color[1] = min(color[1],0x98)
|
|
rom.write_bytes(address, color)
|
|
|
|
# patch the tunic icon
|
|
if [tunic, tunic_option] not in [['Kokiri Tunic', 'Kokiri Green'], ['Goron Tunic', 'Goron Red'], ['Zora Tunic', 'Zora Blue']]:
|
|
patch_tunic_icon(rom, tunic, color)
|
|
else:
|
|
patch_tunic_icon(rom, tunic, None)
|
|
|
|
|
|
def patch_navi_colors(rom, ootworld, symbols):
|
|
# patch navi colors
|
|
navi = [
|
|
# colors for Navi
|
|
('Navi Idle', 'navi_color_default',
|
|
[0x00B5E184], # Default (Player)
|
|
symbols.get('CFG_RAINBOW_NAVI_IDLE_INNER_ENABLED', None), symbols.get('CFG_RAINBOW_NAVI_IDLE_OUTER_ENABLED', None)),
|
|
('Navi Targeting Enemy', 'navi_color_enemy',
|
|
[0x00B5E19C, 0x00B5E1BC], # Enemy, Boss
|
|
symbols.get('CFG_RAINBOW_NAVI_ENEMY_INNER_ENABLED', None), symbols.get('CFG_RAINBOW_NAVI_ENEMY_OUTER_ENABLED', None)),
|
|
('Navi Targeting NPC', 'navi_color_npc',
|
|
[0x00B5E194], # NPC
|
|
symbols.get('CFG_RAINBOW_NAVI_NPC_INNER_ENABLED', None), symbols.get('CFG_RAINBOW_NAVI_NPC_OUTER_ENABLED', None)),
|
|
('Navi Targeting Prop', 'navi_color_prop',
|
|
[0x00B5E174, 0x00B5E17C, 0x00B5E18C, 0x00B5E1A4, 0x00B5E1AC,
|
|
0x00B5E1B4, 0x00B5E1C4, 0x00B5E1CC, 0x00B5E1D4], # Everything else
|
|
symbols.get('CFG_RAINBOW_NAVI_PROP_INNER_ENABLED', None), symbols.get('CFG_RAINBOW_NAVI_PROP_OUTER_ENABLED', None)),
|
|
]
|
|
|
|
navi_color_list = get_navi_colors()
|
|
rainbow_error = None
|
|
|
|
for navi_action, navi_setting, navi_addresses, rainbow_inner_symbol, rainbow_outer_symbol in navi:
|
|
navi_option_inner = format_cosmetic_option_result(ootworld.__dict__[navi_setting+'_inner'])
|
|
navi_option_outer = format_cosmetic_option_result(ootworld.__dict__[navi_setting+'_outer'])
|
|
|
|
# choose a random choice for the whole group
|
|
if navi_option_inner == 'Random Choice':
|
|
navi_option_inner = random.choice(navi_color_list)
|
|
if navi_option_outer == 'Random Choice':
|
|
navi_option_outer = random.choice(navi_color_list)
|
|
|
|
if navi_option_outer == 'Match Inner':
|
|
navi_option_outer = navi_option_inner
|
|
|
|
colors = []
|
|
option_dict = {}
|
|
for address_index, address in enumerate(navi_addresses):
|
|
address_colors = {}
|
|
colors.append(address_colors)
|
|
for index, (navi_part, option, rainbow_symbol) in enumerate([
|
|
('inner', navi_option_inner, rainbow_inner_symbol),
|
|
('outer', navi_option_outer, rainbow_outer_symbol),
|
|
]):
|
|
color = None
|
|
|
|
# set rainbow option
|
|
if rainbow_symbol is not None and option == 'Rainbow':
|
|
rom.write_byte(rainbow_symbol, 0x01)
|
|
color = [0x00, 0x00, 0x00]
|
|
elif rainbow_symbol is not None:
|
|
rom.write_byte(rainbow_symbol, 0x00)
|
|
elif option == 'Rainbow':
|
|
rainbow_error = "Rainbow Navi is not supported by this patch version. Using 'Completely Random' as a substitute."
|
|
option = 'Completely Random'
|
|
|
|
# completely random is random for every subgroup
|
|
if color is None and option == 'Completely Random':
|
|
color = generate_random_color()
|
|
|
|
# grab the color from the list
|
|
if color is None and option in NaviColors:
|
|
color = list(NaviColors[option][index])
|
|
|
|
# build color from hex code
|
|
if color is None:
|
|
color = hex_to_color(option)
|
|
option = 'Custom'
|
|
|
|
# Check color validity
|
|
if color is None:
|
|
raise Exception(f'Invalid {navi_part} color {option} for {navi_action}')
|
|
|
|
address_colors[navi_part] = color
|
|
option_dict[navi_part] = option
|
|
|
|
# write color
|
|
color = address_colors['inner'] + [0xFF] + address_colors['outer'] + [0xFF]
|
|
rom.write_bytes(address, color)
|
|
|
|
|
|
if rainbow_error:
|
|
logger.error(rainbow_error)
|
|
|
|
|
|
def patch_sword_trails(rom, ootworld, symbols):
|
|
# patch sword trail duration
|
|
rom.write_byte(0x00BEFF8C, ootworld.sword_trail_duration)
|
|
|
|
# patch sword trail colors
|
|
sword_trails = [
|
|
('Sword Trail', 'sword_trail_color',
|
|
[(0x00BEFF7C, 0xB0, 0x40, 0xB0, 0xFF), (0x00BEFF84, 0x20, 0x00, 0x10, 0x00)],
|
|
symbols.get('CFG_RAINBOW_SWORD_INNER_ENABLED', None), symbols.get('CFG_RAINBOW_SWORD_OUTER_ENABLED', None)),
|
|
]
|
|
|
|
sword_trail_color_list = get_sword_trail_colors()
|
|
rainbow_error = None
|
|
|
|
for trail_name, trail_setting, trail_addresses, rainbow_inner_symbol, rainbow_outer_symbol in sword_trails:
|
|
option_inner = format_cosmetic_option_result(ootworld.__dict__[trail_setting+'_inner'])
|
|
option_outer = format_cosmetic_option_result(ootworld.__dict__[trail_setting+'_outer'])
|
|
|
|
# handle random choice
|
|
if option_inner == 'Random Choice':
|
|
option_inner = random.choice(sword_trail_color_list)
|
|
if option_outer == 'Random Choice':
|
|
option_outer = random.choice(sword_trail_color_list)
|
|
|
|
if option_outer == 'Match Inner':
|
|
option_outer = option_inner
|
|
|
|
colors = []
|
|
option_dict = {}
|
|
for address_index, (address, inner_transparency, inner_white_transparency, outer_transparency, outer_white_transparency) in enumerate(trail_addresses):
|
|
address_colors = {}
|
|
colors.append(address_colors)
|
|
transparency_dict = {}
|
|
for index, (trail_part, option, rainbow_symbol, white_transparency, transparency) in enumerate([
|
|
('inner', option_inner, rainbow_inner_symbol, inner_white_transparency, inner_transparency),
|
|
('outer', option_outer, rainbow_outer_symbol, outer_white_transparency, outer_transparency),
|
|
]):
|
|
color = None
|
|
|
|
# set rainbow option
|
|
if rainbow_symbol is not None and option == 'Rainbow':
|
|
rom.write_byte(rainbow_symbol, 0x01)
|
|
color = [0x00, 0x00, 0x00]
|
|
elif rainbow_symbol is not None:
|
|
rom.write_byte(rainbow_symbol, 0x00)
|
|
elif option == 'Rainbow':
|
|
rainbow_error = "Rainbow Sword Trail is not supported by this patch version. Using 'Completely Random' as a substitute."
|
|
option = 'Completely Random'
|
|
|
|
# completely random is random for every subgroup
|
|
if color is None and option == 'Completely Random':
|
|
color = generate_random_color()
|
|
|
|
# grab the color from the list
|
|
if color is None and option in sword_trail_colors:
|
|
color = list(sword_trail_colors[option])
|
|
|
|
# build color from hex code
|
|
if color is None:
|
|
color = hex_to_color(option)
|
|
option = 'Custom'
|
|
|
|
# Check color validity
|
|
if color is None:
|
|
raise Exception(f'Invalid {trail_part} color {option} for {trail_name}')
|
|
|
|
# handle white transparency
|
|
if option == 'White':
|
|
transparency_dict[trail_part] = white_transparency
|
|
else:
|
|
transparency_dict[trail_part] = transparency
|
|
|
|
address_colors[trail_part] = color
|
|
option_dict[trail_part] = option
|
|
|
|
# write color
|
|
color = address_colors['outer'] + [transparency_dict['outer']] + address_colors['inner'] + [transparency_dict['inner']]
|
|
rom.write_bytes(address, color)
|
|
|
|
if rainbow_error:
|
|
logger.error(rainbow_error)
|
|
|
|
|
|
def patch_bombchu_trails(rom, ootworld, symbols):
|
|
# patch bombchu trail colors
|
|
bombchu_trails = [
|
|
('Bombchu Trail', 'bombchu_trail_color', get_bombchu_trail_colors(), bombchu_trail_colors,
|
|
(symbols['CFG_BOMBCHU_TRAIL_INNER_COLOR'], symbols['CFG_BOMBCHU_TRAIL_OUTER_COLOR'],
|
|
symbols['CFG_RAINBOW_BOMBCHU_TRAIL_INNER_ENABLED'], symbols['CFG_RAINBOW_BOMBCHU_TRAIL_OUTER_ENABLED'])),
|
|
]
|
|
|
|
patch_trails(rom, ootworld, bombchu_trails)
|
|
|
|
|
|
def patch_boomerang_trails(rom, ootworld, symbols):
|
|
# patch boomerang trail colors
|
|
boomerang_trails = [
|
|
('Boomerang Trail', 'boomerang_trail_color', get_boomerang_trail_colors(), boomerang_trail_colors,
|
|
(symbols['CFG_BOOM_TRAIL_INNER_COLOR'], symbols['CFG_BOOM_TRAIL_OUTER_COLOR'],
|
|
symbols['CFG_RAINBOW_BOOM_TRAIL_INNER_ENABLED'], symbols['CFG_RAINBOW_BOOM_TRAIL_OUTER_ENABLED'])),
|
|
]
|
|
|
|
patch_trails(rom, ootworld, boomerang_trails)
|
|
|
|
|
|
def patch_trails(rom, ootworld, trails):
|
|
for trail_name, trail_setting, trail_color_list, trail_color_dict, trail_symbols in trails:
|
|
color_inner_symbol, color_outer_symbol, rainbow_inner_symbol, rainbow_outer_symbol = trail_symbols
|
|
option_inner = format_cosmetic_option_result(ootworld.__dict__[trail_setting+'_inner'])
|
|
option_outer = format_cosmetic_option_result(ootworld.__dict__[trail_setting+'_outer'])
|
|
|
|
# handle random choice
|
|
if option_inner == 'Random Choice':
|
|
option_inner = random.choice(trail_color_list)
|
|
if option_outer == 'Random Choice':
|
|
option_outer = random.choice(trail_color_list)
|
|
|
|
if option_outer == 'Match Inner':
|
|
option_outer = option_inner
|
|
|
|
option_dict = {}
|
|
colors = {}
|
|
|
|
for index, (trail_part, option, rainbow_symbol, color_symbol) in enumerate([
|
|
('inner', option_inner, rainbow_inner_symbol, color_inner_symbol),
|
|
('outer', option_outer, rainbow_outer_symbol, color_outer_symbol),
|
|
]):
|
|
color = None
|
|
|
|
# set rainbow option
|
|
if option == 'Rainbow':
|
|
rom.write_byte(rainbow_symbol, 0x01)
|
|
color = [0x00, 0x00, 0x00]
|
|
else:
|
|
rom.write_byte(rainbow_symbol, 0x00)
|
|
|
|
# handle completely random
|
|
if color is None and option == 'Completely Random':
|
|
# Specific handling for inner bombchu trails for contrast purposes.
|
|
if trail_name == 'Bombchu Trail' and trail_part == 'inner':
|
|
fixed_dark_color = [0, 0, 0]
|
|
color = [0, 0, 0]
|
|
# Avoid colors which have a low contrast so the bombchu ticking is still visible
|
|
while contrast_ratio(color, fixed_dark_color) <= 4:
|
|
color = generate_random_color()
|
|
else:
|
|
color = generate_random_color()
|
|
|
|
# grab the color from the list
|
|
if color is None and option in trail_color_dict:
|
|
color = list(trail_color_dict[option])
|
|
|
|
# build color from hex code
|
|
if color is None:
|
|
color = hex_to_color(option)
|
|
option = 'Custom'
|
|
|
|
option_dict[trail_part] = option
|
|
colors[trail_part] = color
|
|
|
|
# write color
|
|
rom.write_bytes(color_symbol, color)
|
|
|
|
|
|
|
|
def patch_gauntlet_colors(rom, ootworld, symbols):
|
|
# patch gauntlet colors
|
|
gauntlets = [
|
|
('Silver Gauntlets', 'silver_gauntlets_color', 0x00B6DA44,
|
|
([0x173B4CC], [0x173B4D4, 0x173B50C, 0x173B514])), # GI Model DList colors
|
|
('Gold Gauntlets', 'golden_gauntlets_color', 0x00B6DA47,
|
|
([0x173B4EC], [0x173B4F4, 0x173B52C, 0x173B534])), # GI Model DList colors
|
|
]
|
|
gauntlet_color_list = get_gauntlet_colors()
|
|
|
|
for gauntlet, gauntlet_setting, address, model_addresses in gauntlets:
|
|
gauntlet_option = format_cosmetic_option_result(ootworld.__dict__[gauntlet_setting])
|
|
|
|
# handle random
|
|
if gauntlet_option == 'Random Choice':
|
|
gauntlet_option = random.choice(gauntlet_color_list)
|
|
# handle completely random
|
|
if gauntlet_option == 'Completely Random':
|
|
color = generate_random_color()
|
|
# grab the color from the list
|
|
elif gauntlet_option in gauntlet_colors:
|
|
color = list(gauntlet_colors[gauntlet_option])
|
|
# build color from hex code
|
|
else:
|
|
color = hex_to_color(gauntlet_option)
|
|
gauntlet_option = 'Custom'
|
|
rom.write_bytes(address, color)
|
|
if ootworld.correct_model_colors:
|
|
patch_model_colors(rom, color, model_addresses)
|
|
else:
|
|
patch_model_colors(rom, None, model_addresses)
|
|
|
|
def patch_shield_frame_colors(rom, ootworld, symbols):
|
|
# patch shield frame colors
|
|
shield_frames = [
|
|
('Mirror Shield Frame', 'mirror_shield_frame_color',
|
|
[0xFA7274, 0xFA776C, 0xFAA27C, 0xFAC564, 0xFAC984, 0xFAEDD4],
|
|
([0x1616FCC], [0x1616FD4])),
|
|
]
|
|
shield_frame_color_list = get_shield_frame_colors()
|
|
|
|
for shield_frame, shield_frame_setting, addresses, model_addresses in shield_frames:
|
|
shield_frame_option = format_cosmetic_option_result(ootworld.__dict__[shield_frame_setting])
|
|
|
|
# handle random
|
|
if shield_frame_option == 'Random Choice':
|
|
shield_frame_option = random.choice(shield_frame_color_list)
|
|
# handle completely random
|
|
if shield_frame_option == 'Completely Random':
|
|
color = [random.getrandbits(8), random.getrandbits(8), random.getrandbits(8)]
|
|
# grab the color from the list
|
|
elif shield_frame_option in shield_frame_colors:
|
|
color = list(shield_frame_colors[shield_frame_option])
|
|
# build color from hex code
|
|
else:
|
|
color = hex_to_color(shield_frame_option)
|
|
shield_frame_option = 'Custom'
|
|
for address in addresses:
|
|
rom.write_bytes(address, color)
|
|
if ootworld.correct_model_colors and shield_frame_option != 'Red':
|
|
patch_model_colors(rom, color, model_addresses)
|
|
else:
|
|
patch_model_colors(rom, None, model_addresses)
|
|
|
|
|
|
def patch_heart_colors(rom, ootworld, symbols):
|
|
# patch heart colors
|
|
hearts = [
|
|
('Heart Color', 'heart_color', symbols['CFG_HEART_COLOR'], 0xBB0994,
|
|
([0x14DA474, 0x14DA594, 0x14B701C, 0x14B70DC],
|
|
[0x14B70FC, 0x14DA494, 0x14DA5B4, 0x14B700C, 0x14B702C, 0x14B703C, 0x14B704C, 0x14B705C,
|
|
0x14B706C, 0x14B707C, 0x14B708C, 0x14B709C, 0x14B70AC, 0x14B70BC, 0x14B70CC])), # GI Model DList colors
|
|
]
|
|
heart_color_list = get_heart_colors()
|
|
|
|
for heart, heart_setting, symbol, file_select_address, model_addresses in hearts:
|
|
heart_option = format_cosmetic_option_result(ootworld.__dict__[heart_setting])
|
|
|
|
# handle random
|
|
if heart_option == 'Random Choice':
|
|
heart_option = random.choice(heart_color_list)
|
|
# handle completely random
|
|
if heart_option == 'Completely Random':
|
|
color = generate_random_color()
|
|
# grab the color from the list
|
|
elif heart_option in heart_colors:
|
|
color = list(heart_colors[heart_option])
|
|
# build color from hex code
|
|
else:
|
|
color = hex_to_color(heart_option)
|
|
heart_option = 'Custom'
|
|
rom.write_int16s(symbol, color) # symbol for ingame HUD
|
|
rom.write_int16s(file_select_address, color) # file select normal hearts
|
|
if heart_option != 'Red':
|
|
rom.write_int16s(file_select_address + 6, color) # file select DD hearts
|
|
else:
|
|
original_dd_color = rom.original.read_bytes(file_select_address + 6, 6)
|
|
rom.write_bytes(file_select_address + 6, original_dd_color)
|
|
if ootworld.correct_model_colors and heart_option != 'Red':
|
|
patch_model_colors(rom, color, model_addresses) # heart model colors
|
|
icon.patch_overworld_icon(rom, color, 0xF43D80) # Overworld Heart Icon
|
|
else:
|
|
patch_model_colors(rom, None, model_addresses)
|
|
icon.patch_overworld_icon(rom, None, 0xF43D80)
|
|
|
|
def patch_magic_colors(rom, ootworld, symbols):
|
|
# patch magic colors
|
|
magic = [
|
|
('Magic Meter Color', 'magic_color', symbols["CFG_MAGIC_COLOR"],
|
|
([0x154C654, 0x154CFB4], [0x154C65C, 0x154CFBC])), # GI Model DList colors
|
|
]
|
|
magic_color_list = get_magic_colors()
|
|
|
|
for magic_color, magic_setting, symbol, model_addresses in magic:
|
|
magic_option = format_cosmetic_option_result(ootworld.__dict__[magic_setting])
|
|
|
|
if magic_option == 'Random Choice':
|
|
magic_option = random.choice(magic_color_list)
|
|
|
|
if magic_option == 'Completely Random':
|
|
color = generate_random_color()
|
|
elif magic_option in magic_colors:
|
|
color = list(magic_colors[magic_option])
|
|
else:
|
|
color = hex_to_color(magic_option)
|
|
magic_option = 'Custom'
|
|
rom.write_int16s(symbol, color)
|
|
if magic_option != 'Green' and ootworld.correct_model_colors:
|
|
patch_model_colors(rom, color, model_addresses)
|
|
icon.patch_overworld_icon(rom, color, 0xF45650, data_path('icons/magicSmallExtras.raw')) # Overworld Small Pot
|
|
icon.patch_overworld_icon(rom, color, 0xF47650, data_path('icons/magicLargeExtras.raw')) # Overworld Big Pot
|
|
else:
|
|
patch_model_colors(rom, None, model_addresses)
|
|
icon.patch_overworld_icon(rom, None, 0xF45650)
|
|
icon.patch_overworld_icon(rom, None, 0xF47650)
|
|
|
|
def patch_button_colors(rom, ootworld, symbols):
|
|
buttons = [
|
|
('A Button Color', 'a_button_color', a_button_colors,
|
|
[('A Button Color', symbols['CFG_A_BUTTON_COLOR'],
|
|
None),
|
|
('Text Cursor Color', symbols['CFG_TEXT_CURSOR_COLOR'],
|
|
[(0xB88E81, 0xB88E85, 0xB88E9)]), # Initial Inner Color
|
|
('Shop Cursor Color', symbols['CFG_SHOP_CURSOR_COLOR'],
|
|
None),
|
|
('Save/Death Cursor Color', None,
|
|
[(0xBBEBC2, 0xBBEBC3, 0xBBEBD6), (0xBBEDDA, 0xBBEDDB, 0xBBEDDE)]), # Save Cursor / Death Cursor
|
|
('Pause Menu A Cursor Color', None,
|
|
[(0xBC7849, 0xBC784B, 0xBC784D), (0xBC78A9, 0xBC78AB, 0xBC78AD), (0xBC78BB, 0xBC78BD, 0xBC78BF)]), # Inner / Pulse 1 / Pulse 2
|
|
('Pause Menu A Icon Color', None,
|
|
[(0x845754, 0x845755, 0x845756)]),
|
|
('A Note Color', symbols['CFG_A_NOTE_COLOR'], # For Textbox Song Display
|
|
[(0xBB299A, 0xBB299B, 0xBB299E), (0xBB2C8E, 0xBB2C8F, 0xBB2C92), (0xBB2F8A, 0xBB2F8B, 0xBB2F96)]), # Pause Menu Song Display
|
|
]),
|
|
('B Button Color', 'b_button_color', b_button_colors,
|
|
[('B Button Color', symbols['CFG_B_BUTTON_COLOR'],
|
|
None),
|
|
]),
|
|
('C Button Color', 'c_button_color', c_button_colors,
|
|
[('C Button Color', symbols['CFG_C_BUTTON_COLOR'],
|
|
None),
|
|
('Pause Menu C Cursor Color', None,
|
|
[(0xBC7843, 0xBC7845, 0xBC7847), (0xBC7891, 0xBC7893, 0xBC7895), (0xBC78A3, 0xBC78A5, 0xBC78A7)]), # Inner / Pulse 1 / Pulse 2
|
|
('Pause Menu C Icon Color', None,
|
|
[(0x8456FC, 0x8456FD, 0x8456FE)]),
|
|
('C Note Color', symbols['CFG_C_NOTE_COLOR'], # For Textbox Song Display
|
|
[(0xBB2996, 0xBB2997, 0xBB29A2), (0xBB2C8A, 0xBB2C8B, 0xBB2C96), (0xBB2F86, 0xBB2F87, 0xBB2F9A)]), # Pause Menu Song Display
|
|
]),
|
|
('Start Button Color', 'start_button_color', start_button_colors,
|
|
[('Start Button Color', None,
|
|
[(0xAE9EC6, 0xAE9EC7, 0xAE9EDA)]),
|
|
]),
|
|
]
|
|
|
|
for button, button_setting, button_colors, patches in buttons:
|
|
button_option = format_cosmetic_option_result(ootworld.__dict__[button_setting])
|
|
color_set = None
|
|
colors = {}
|
|
|
|
# handle random
|
|
if button_option == 'Random Choice':
|
|
button_option = random.choice(list(button_colors.keys()))
|
|
# handle completely random
|
|
if button_option == 'Completely Random':
|
|
fixed_font_color = [10, 10, 10]
|
|
color = [0, 0, 0]
|
|
# Avoid colors which have a low contrast with the font inside buttons (eg. the A letter)
|
|
while contrast_ratio(color, fixed_font_color) <= 3:
|
|
color = generate_random_color()
|
|
# grab the color from the list
|
|
elif button_option in button_colors:
|
|
color_set = [button_colors[button_option]] if isinstance(button_colors[button_option][0], int) else list(button_colors[button_option])
|
|
color = color_set[0]
|
|
# build color from hex code
|
|
else:
|
|
color = hex_to_color(button_option)
|
|
button_option = 'Custom'
|
|
|
|
# apply all button color patches
|
|
for i, (patch, symbol, byte_addresses) in enumerate(patches):
|
|
if color_set is not None and len(color_set) > i and color_set[i]:
|
|
colors[patch] = color_set[i]
|
|
else:
|
|
colors[patch] = color
|
|
|
|
if symbol:
|
|
rom.write_int16s(symbol, colors[patch])
|
|
|
|
if byte_addresses:
|
|
for r_addr, g_addr, b_addr in byte_addresses:
|
|
rom.write_byte(r_addr, colors[patch][0])
|
|
rom.write_byte(g_addr, colors[patch][1])
|
|
rom.write_byte(b_addr, colors[patch][2])
|
|
|
|
|
|
def patch_sfx(rom, ootworld, symbols):
|
|
# Configurable Sound Effects
|
|
sfx_config = [
|
|
('sfx_navi_overworld', sfx.SoundHooks.NAVI_OVERWORLD),
|
|
('sfx_navi_enemy', sfx.SoundHooks.NAVI_ENEMY),
|
|
('sfx_low_hp', sfx.SoundHooks.HP_LOW),
|
|
('sfx_menu_cursor', sfx.SoundHooks.MENU_CURSOR),
|
|
('sfx_menu_select', sfx.SoundHooks.MENU_SELECT),
|
|
('sfx_nightfall', sfx.SoundHooks.NIGHTFALL),
|
|
('sfx_horse_neigh', sfx.SoundHooks.HORSE_NEIGH),
|
|
('sfx_hover_boots', sfx.SoundHooks.BOOTS_HOVER),
|
|
]
|
|
sound_dict = sfx.get_patch_dict()
|
|
sounds_keyword_label = {sound.value.keyword: sound.value.label for sound in sfx.Sounds}
|
|
sounds_label_keyword = {sound.value.label: sound.value.keyword for sound in sfx.Sounds}
|
|
|
|
for setting, hook in sfx_config:
|
|
selection = ootworld.__dict__[setting].replace('_', '-')
|
|
|
|
if selection == 'default':
|
|
for loc in hook.value.locations:
|
|
sound_id = rom.original.read_int16(loc)
|
|
rom.write_int16(loc, sound_id)
|
|
else:
|
|
if selection == 'random-choice':
|
|
selection = random.choice(sfx.get_hook_pool(hook)).value.keyword
|
|
elif selection == 'random-ear-safe':
|
|
selection = random.choice(sfx.get_hook_pool(hook, "TRUE")).value.keyword
|
|
elif selection == 'completely-random':
|
|
selection = random.choice(sfx.standard).value.keyword
|
|
sound_id = sound_dict[selection]
|
|
for loc in hook.value.locations:
|
|
rom.write_int16(loc, sound_id)
|
|
|
|
|
|
|
|
def patch_instrument(rom, ootworld, symbols):
|
|
# Player Instrument
|
|
instruments = {
|
|
#'none': 0x00,
|
|
'ocarina': 0x01,
|
|
'malon': 0x02,
|
|
'whistle': 0x03,
|
|
'harp': 0x04,
|
|
'grind_organ': 0x05,
|
|
'flute': 0x06,
|
|
#'another_ocarina': 0x07,
|
|
}
|
|
|
|
choice = ootworld.sfx_ocarina
|
|
if choice == 'random-choice':
|
|
choice = random.choice(list(instruments.keys()))
|
|
|
|
rom.write_byte(0x00B53C7B, instruments[choice])
|
|
rom.write_byte(0x00B4BF6F, instruments[choice]) # For Lost Woods Skull Kids' minigame in Lost Woods
|
|
|
|
|
|
legacy_cosmetic_data_headers = [
|
|
0x03481000,
|
|
0x03480810,
|
|
]
|
|
|
|
patch_sets = {}
|
|
global_patch_sets = [
|
|
patch_targeting,
|
|
patch_music,
|
|
patch_tunic_colors,
|
|
patch_navi_colors,
|
|
patch_sword_trails,
|
|
patch_gauntlet_colors,
|
|
patch_shield_frame_colors,
|
|
# patch_voices,
|
|
patch_sfx,
|
|
patch_instrument,
|
|
]
|
|
|
|
# 3.14.1
|
|
patch_sets[0x1F04FA62] = {
|
|
"patches": [
|
|
patch_dpad,
|
|
patch_sword_trails,
|
|
],
|
|
"symbols": {
|
|
"CFG_DISPLAY_DPAD": 0x0004,
|
|
"CFG_RAINBOW_SWORD_INNER_ENABLED": 0x0005,
|
|
"CFG_RAINBOW_SWORD_OUTER_ENABLED": 0x0006,
|
|
},
|
|
}
|
|
|
|
# 3.14.11
|
|
patch_sets[0x1F05D3F9] = {
|
|
"patches": patch_sets[0x1F04FA62]["patches"] + [],
|
|
"symbols": {**patch_sets[0x1F04FA62]["symbols"]},
|
|
}
|
|
|
|
# 4.5.7
|
|
patch_sets[0x1F0693FB] = {
|
|
"patches": patch_sets[0x1F05D3F9]["patches"] + [
|
|
patch_heart_colors,
|
|
patch_magic_colors,
|
|
],
|
|
"symbols": {
|
|
"CFG_MAGIC_COLOR": 0x0004,
|
|
"CFG_HEART_COLOR": 0x000A,
|
|
"CFG_DISPLAY_DPAD": 0x0010,
|
|
"CFG_RAINBOW_SWORD_INNER_ENABLED": 0x0011,
|
|
"CFG_RAINBOW_SWORD_OUTER_ENABLED": 0x0012,
|
|
}
|
|
}
|
|
|
|
# 5.2.6
|
|
patch_sets[0x1F073FC9] = {
|
|
"patches": patch_sets[0x1F0693FB]["patches"] + [
|
|
patch_button_colors,
|
|
],
|
|
"symbols": {
|
|
"CFG_MAGIC_COLOR": 0x0004,
|
|
"CFG_HEART_COLOR": 0x000A,
|
|
"CFG_A_BUTTON_COLOR": 0x0010,
|
|
"CFG_B_BUTTON_COLOR": 0x0016,
|
|
"CFG_C_BUTTON_COLOR": 0x001C,
|
|
"CFG_TEXT_CURSOR_COLOR": 0x0022,
|
|
"CFG_SHOP_CURSOR_COLOR": 0x0028,
|
|
"CFG_A_NOTE_COLOR": 0x002E,
|
|
"CFG_C_NOTE_COLOR": 0x0034,
|
|
"CFG_DISPLAY_DPAD": 0x003A,
|
|
"CFG_RAINBOW_SWORD_INNER_ENABLED": 0x003B,
|
|
"CFG_RAINBOW_SWORD_OUTER_ENABLED": 0x003C,
|
|
}
|
|
}
|
|
|
|
# 5.2.76
|
|
patch_sets[0x1F073FD8] = {
|
|
"patches": patch_sets[0x1F073FC9]["patches"] + [
|
|
patch_navi_colors,
|
|
patch_boomerang_trails,
|
|
patch_bombchu_trails,
|
|
],
|
|
"symbols": {
|
|
**patch_sets[0x1F073FC9]["symbols"],
|
|
"CFG_BOOM_TRAIL_INNER_COLOR": 0x003A,
|
|
"CFG_BOOM_TRAIL_OUTER_COLOR": 0x003D,
|
|
"CFG_BOMBCHU_TRAIL_INNER_COLOR": 0x0040,
|
|
"CFG_BOMBCHU_TRAIL_OUTER_COLOR": 0x0043,
|
|
"CFG_DISPLAY_DPAD": 0x0046,
|
|
"CFG_RAINBOW_SWORD_INNER_ENABLED": 0x0047,
|
|
"CFG_RAINBOW_SWORD_OUTER_ENABLED": 0x0048,
|
|
"CFG_RAINBOW_BOOM_TRAIL_INNER_ENABLED": 0x0049,
|
|
"CFG_RAINBOW_BOOM_TRAIL_OUTER_ENABLED": 0x004A,
|
|
"CFG_RAINBOW_BOMBCHU_TRAIL_INNER_ENABLED": 0x004B,
|
|
"CFG_RAINBOW_BOMBCHU_TRAIL_OUTER_ENABLED": 0x004C,
|
|
"CFG_RAINBOW_NAVI_IDLE_INNER_ENABLED": 0x004D,
|
|
"CFG_RAINBOW_NAVI_IDLE_OUTER_ENABLED": 0x004E,
|
|
"CFG_RAINBOW_NAVI_ENEMY_INNER_ENABLED": 0x004F,
|
|
"CFG_RAINBOW_NAVI_ENEMY_OUTER_ENABLED": 0x0050,
|
|
"CFG_RAINBOW_NAVI_NPC_INNER_ENABLED": 0x0051,
|
|
"CFG_RAINBOW_NAVI_NPC_OUTER_ENABLED": 0x0052,
|
|
"CFG_RAINBOW_NAVI_PROP_INNER_ENABLED": 0x0053,
|
|
"CFG_RAINBOW_NAVI_PROP_OUTER_ENABLED": 0x0054,
|
|
}
|
|
}
|
|
|
|
# 6.2.218
|
|
patch_sets[0x1F073FD9] = {
|
|
"patches": patch_sets[0x1F073FD8]["patches"] + [
|
|
patch_dpad_info,
|
|
],
|
|
"symbols": {
|
|
**patch_sets[0x1F073FD8]["symbols"],
|
|
"CFG_DPAD_DUNGEON_INFO_ENABLE": 0x0055,
|
|
}
|
|
}
|
|
|
|
|
|
def patch_cosmetics(ootworld, rom):
|
|
# Use the world's slot seed for cosmetics
|
|
random.seed(ootworld.multiworld.per_slot_randoms[ootworld.player].random())
|
|
|
|
# try to detect the cosmetic patch data format
|
|
versioned_patch_set = None
|
|
cosmetic_context = rom.read_int32(rom.sym('RANDO_CONTEXT') + 4)
|
|
if cosmetic_context >= 0x80000000 and cosmetic_context <= 0x80F7FFFC:
|
|
cosmetic_context = (cosmetic_context - 0x80400000) + 0x3480000 # convert from RAM to ROM address
|
|
cosmetic_version = rom.read_int32(cosmetic_context)
|
|
versioned_patch_set = patch_sets.get(cosmetic_version)
|
|
else:
|
|
# If cosmetic_context is not a valid pointer, then try to
|
|
# search over all possible legacy header locations.
|
|
for header in legacy_cosmetic_data_headers:
|
|
cosmetic_context = header
|
|
cosmetic_version = rom.read_int32(cosmetic_context)
|
|
if cosmetic_version in patch_sets:
|
|
versioned_patch_set = patch_sets[cosmetic_version]
|
|
break
|
|
|
|
# patch version specific patches
|
|
if versioned_patch_set:
|
|
# offset the cosmetic_context struct for absolute addressing
|
|
cosmetic_context_symbols = {
|
|
sym: address + cosmetic_context
|
|
for sym, address in versioned_patch_set['symbols'].items()
|
|
}
|
|
|
|
# warn if patching a legacy format
|
|
if cosmetic_version != rom.read_int32(rom.sym('COSMETIC_FORMAT_VERSION')):
|
|
logger.error("ROM uses old cosmetic patch format.")
|
|
|
|
# patch cosmetics that use vanilla oot data, and always compatible
|
|
for patch_func in [patch for patch in global_patch_sets if patch not in versioned_patch_set['patches']]:
|
|
patch_func(rom, ootworld, {})
|
|
|
|
for patch_func in versioned_patch_set['patches']:
|
|
patch_func(rom, ootworld, cosmetic_context_symbols)
|
|
else:
|
|
# patch cosmetics that use vanilla oot data, and always compatible
|
|
for patch_func in global_patch_sets:
|
|
patch_func(rom, ootworld, {})
|
|
|
|
# Unknown patch format
|
|
logger.error("Unable to patch some cosmetics. ROM uses unknown cosmetic patch format.")
|