mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-06-27 08:53:23 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
1b3b493fbf244faf1cd0dc823638abfc593be8bc
dusklight/src/dusk/ui/rando_config.cpp
T
gymnast86 1b3b493fbf reset rando context if current seed is deleted
2026-06-26 11:53:33 -07:00

1403 lines
60 KiB
C++
Raw Blame History

#include "rando_config.hpp"
#include "bool_button.hpp"
#include "dusk/config.hpp"
#include "dusk/data.hpp"
#include "dusk/logging.h"
#include "dusk/randomizer/game/tools.h"
#include "dusk/randomizer/generator/seedgen/seed.hpp"
#include "dusk/randomizer/generator/utility/string.hpp"
#include "modal.hpp"
#include "number_button.hpp"
#include "pane.hpp"
#include "rando_seed_generation.hpp"
#include "string_button.hpp"
#include "d/d_file_select.h"
#include "SDL3/SDL_clipboard.h"
#include <mutex>
#include <thread>
namespace dusk::ui {
randomizer::seedgen::settings::Setting* FindSetting(const std::string& key) {
if (key.empty()) {
DuskLog.fatal("Key is empty! Unable to find setting.");
}
// TODO: handle multi-world selection
auto& settings = GetRandomizerConfig().GetSettings();
try {
return &settings.GetMap().at(key);
} catch (std::exception e) {
DuskLog.fatal("Failed to get Settings Key: {}", key);
}
}
void SaveRandomizerConfig() {
GetRandomizerConfig().WriteToFile(GetRandomizerSettingsPath(), GetRandomizerPreferencesPath());
}
bool TryCreateRandomSeed() {
auto& config = GetRandomizerConfig();
const std::string& configSeed = config.GetSeed();
if (configSeed.empty()) {
config.SetSeed(randomizer::seedgen::seed::GenerateSeed());
SaveRandomizerConfig();
return true;
}
return false;
}
void rando_config_group_update_right_pane(
Pane& pane,
randomizer::seedgen::settings::Setting* curSetting,
std::function<Component*(const std::string&, Pane&)> onSelected)
{
pane.clear();
auto curSelIdx = curSetting->GetCurrentOptionIndex();
auto settingInfo = curSetting->GetInfo();
Rml::Element* text_elem = pane.add_rml(settingInfo->GetDescriptions().at(curSelIdx));
for (int i = 0; i < settingInfo->GetOptions().size(); ++i) {
pane.add_button(
{
.text = settingInfo->GetOptions()[i],
.isSelected = [curSetting, i] {
return curSetting->GetCurrentOptionIndex() == i;
},
})
.on_pressed([i, text_elem, curSetting, &pane, onSelected] {
auto settingInfo = curSetting->GetInfo();
mDoAud_seStartMenu(kSoundItemChange);
curSetting->SetCurrentOption(i);
text_elem->SetInnerRML(settingInfo->GetDescriptions().at(i));
SaveRandomizerConfig();
rando_config_group_update_right_pane(pane, curSetting, onSelected);
});
}
if (onSelected) {
onSelected(curSetting->GetCurrentOption(), pane);
}
}
void rando_config_group(Pane& leftPane, Pane& rightPane, std::string settingKey,
std::function<Component*(const std::string&, Pane&)> onSelected = nullptr) {
auto randoSettings = randomizer::seedgen::settings::GetAllSettingsInfo();
auto& settingData = randoSettings->at(settingKey);
if (settingData == nullptr) {
return;
}
auto curSetting = FindSetting(settingKey);
leftPane.register_control(
leftPane.add_select_button({
.key = settingKey,
.getValue =
[curSetting] { return Rml::String{curSetting->GetCurrentOption()}; },
}),
rightPane, [curSetting, onSelected](Pane& pane) {
rando_config_group_update_right_pane(pane, curSetting, onSelected);
});
}
SelectButton& rando_config_button(
Pane& leftPane, Pane& rightPane, std::string settingKey) {
auto setting = FindSetting(settingKey);
// Helper function to call when we want to update the right pane
auto updateRightPane = [setting, &rightPane] {
rightPane.clear();
auto info = setting->GetInfo();
// Show all options/descriptions
for (size_t i = 0; i < info->GetOptions().size(); ++i) {
auto text = rightPane.add_rml(fmt::format("<span style=\"color: #C2A42D;\">{}</span>: {}", info->GetOptions()[i], info->GetDescriptions()[i]));
// Change styling for currently selected option
if (i == setting->GetCurrentOptionIndex()) {
text->SetClass("current-option-text", true);
} else {
text->SetClass("not-current-option-text", true);
}
}
};
// Helper function for changing the setting index based on button presses
auto changeOptionIndex = [setting, updateRightPane](int change) {
auto newIndex = setting->GetCurrentOptionIndex() + change;
if (newIndex < 0) {
newIndex = setting->GetInfo()->GetOptions().size() - 1;
} else if (newIndex >= setting->GetInfo()->GetOptions().size()) {
newIndex = 0;
}
setting->SetCurrentOption(newIndex);
updateRightPane();
};
auto& button = leftPane.add_select_button(ControlledSelectButton::Props{
.key = settingKey,
.getValue = [setting] { return setting->GetCurrentOption(); }
})
// Cycle through the options forward when the button is pressed
.on_pressed([changeOptionIndex] {
changeOptionIndex(1);
});
// Update the right pane info when we change between options
auto& comp = leftPane.register_control(button, rightPane, [updateRightPane](Pane&) {
updateRightPane();
});
// Listen for left/right nav commands to cycle between the available options
comp.listen(comp.root(), Rml::EventId::Keydown, [changeOptionIndex](Rml::Event& event) {
auto cmd = map_nav_event(event);
if (cmd == NavCommand::Left) {
changeOptionIndex(-1);
event.StopPropagation();
} else if (cmd == NavCommand::Right) {
changeOptionIndex(1);
event.StopPropagation();
}
});
return button;
}
NumberButton* rando_add_optional_setting(std::string optionValue, std::string optionsKeyPrefix,
Pane& pane) {
std::string fullOptionalKey = fmt::format("{} {}", optionsKeyPrefix, optionValue);
// check if setting exists
auto randoSettings = randomizer::seedgen::settings::GetAllSettingsInfo();
if (!randoSettings->contains(fullOptionalKey)) {
return nullptr;
}
auto curSetting = FindSetting(fullOptionalKey);
const auto& options = curSetting->GetInfo()->GetOptions();
return &pane.add_child<NumberButton>(NumberButton::Props{
.key = fmt::format("{} Count", optionValue),
.getValue = [curSetting] { return curSetting->GetCurrentOptionAsNumber(); },
.setValue = [curSetting](int value) {
curSetting->SetCurrentOption(std::to_string(value));
SaveRandomizerConfig();
},
.min = std::stoi(options.front()),
.max = std::stoi(options.back()),
});
}
const std::vector<std::pair<std::string, std::string>>& GetStartingInventoryLayoutOrder() {
static const std::vector<std::pair<std::string, std::string>> layoutOrder = {
// { display name , logic item name }
{"Shadow Crystal", "Shadow Crystal"},
{"Horse Call", "Horse Call"},
{"Fishing Rod", "Progressive Fishing Rod"},
{"Slingshot", "Slingshot"},
{"Lantern", "Lantern"},
{"Gale Boomerang", "Gale Boomerang"},
{"Iron Boots", "Iron Boots"},
{"Bow", "Progressive Bow"},
{"Hawkeye", "Hawkeye"},
{"Bomb Bags", "Bomb Bag"},
{"Giant Bomb Bags", "Giant Bomb Bag"},
{"Clawshot", "Progressive Clawshot"},
{"Spinner", "Spinner"},
{"Ball and Chain", "Ball and Chain"},
{"Dominion Rod", "Progressive Dominion Rod"},
{"Empty Bottle", "Empty Bottle"},
{"Auru's Memo", "Aurus Memo"},
{"Ashei's Sketch", "Asheis Sketch"},
{"Sky Book", "Progressive Sky Book"},
{"Sword", "Progressive Sword"},
{"Ordon Shield", "Ordon Shield"},
{"Hylian Shield", "Hylian Shield"},
{"Zora Armor", "Zora Armor"},
{"Magic Armor", "Magic Armor"},
{"Wallet", "Progressive Wallet"},
{"Hidden Skills", "Progressive Hidden Skill"},
{"Poe Souls", "Poe Soul"},
{"Fused Shadows", "Progressive Fused Shadow"},
{"Mirror Shards", "Progressive Mirror Shard"},
{"Gate Keys", "Gate Keys"},
{"Gerudo Desert Bulblin Camp Key", "Gerudo Desert Bulblin Camp Key"},
{"Forest Temple Small Keys", "Forest Temple Small Key"},
{"Goron Mines Small Keys", "Goron Mines Small Key"},
{"Lakebed Temple Small Keys", "Lakebed Temple Small Key"},
{"Arbiter's Grounds Small Keys", "Arbiters Grounds Small Key"},
{"Snowpeak Ruins Small Keys", "Snowpeak Ruins Small Key"},
{"Ordon Pumpkin", "Ordon Pumpkin"},
{"Ordon Cheese", "Ordon Cheese"},
{"Temple of Time Small Keys", "Temple of Time Small Key"},
{"City in the Sky Small Keys", "City in the Sky Small Key"},
{"Palace of Twilight Small Keys", "Palace of Twilight Small Key"},
{"Hyrule Castle Small Keys", "Hyrule Castle Small Key"},
{"Forest Temple Big Key", "Forest Temple Big Key"},
{"Goron Mines Key Shards", "Goron Mines Key Shard"},
{"Lakebed Temple Big Key", "Lakebed Temple Big Key"},
{"Arbiter's Grounds Big Key", "Arbiters Grounds Big Key"},
{"Snowpeak Ruins Bedroom Key", "Snowpeak Ruins Bedroom Key"},
{"Temple of Time Big Key", "Temple of Time Big Key"},
{"City in the Sky Big Key", "City in the Sky Big Key"},
{"Palace of Twilight Big Key", "Palace of Twilight Big Key"},
{"Hyrule Castle Big Key", "Hyrule Castle Big Key"},
{"Gerudo Desert Portal", "Gerudo Desert Portal"},
{"Mirror Chamber Portal", "Mirror Chamber Portal"},
{"Snowpeak Portal", "Snowpeak Portal"},
{"Sacred Grove Portal", "Sacred Grove Portal"},
{"Bridge of Eldin Portal", "Bridge of Eldin Portal"},
{"Upper Zora's River Portal", "Upper Zoras River Portal"}
};
return layoutOrder;
}
void rando_starting_inventory_update_right_pane(Pane& rightPane) {
rightPane.clear();
rightPane.add_section("Selected Starting Items");
const auto& inventory = GetRandomizerConfig().GetSettings().GetStartingInventory();
const auto& layoutOrder = GetStartingInventoryLayoutOrder();
for (const auto& [itemText, itemName] : layoutOrder) {
if (!inventory.contains(itemName)) {
continue;
}
int count = inventory.at(itemName);
if (count <= 0) {
continue;
}
// If we have a prettier name for the item, prioritize that
std::string prettyItemName = fmt::format("{} x{}", itemName, count);
if (randomizer::textObjectExists(prettyItemName)) {
rightPane.add_text(fmt::format("• {}", randomizer::getTextStr(prettyItemName)));
}
// Display the count before the itemname for these items
else if (itemName.find("Small Key") != std::string::npos ||
itemName.find("Shard") != std::string::npos ||
itemName.find("Fused Shadow") != std::string::npos ||
itemName.find("Hidden Skill") != std::string::npos ||
itemName == "Poe Soul" ||
itemName == "Bomb Bag")
{
rightPane.add_text(fmt::format("• {} {}", count, itemText));
} else {
rightPane.add_text(fmt::format("• {}", itemText));
}
}
}
void rando_starting_item_toggle(Pane& leftPane, Pane& rightPane, std::string itemText, std::string itemName = "", int max = 1) {
if (itemName.empty()) {
itemName = itemText;
}
// Helper function for increasing a starting item count by 1
auto increaseCount = [itemName, max]() {
auto& inventory = GetRandomizerConfig().GetSettings().GetModifiableStartingInventory();
int newCount = inventory[itemName] + 1;
if (newCount > max) {
inventory.erase(itemName);
} else {
inventory.at(itemName) = newCount;
}
SaveRandomizerConfig();
};
// Helper function for decreasing a starting item count by 1
auto decreaseCount = [itemName, max]() {
auto& inventory = GetRandomizerConfig().GetSettings().GetModifiableStartingInventory();
int newCount = inventory[itemName] - 1;
if (newCount < 0) {
newCount = max;
}
if (newCount == 0) {
inventory.erase(itemName);
} else {
inventory.at(itemName) = newCount;
}
SaveRandomizerConfig();
};
leftPane.add_select_button({
.key = itemText,
.getValue =
[itemName, itemText] {
auto& inventory = GetRandomizerConfig().GetSettings().GetModifiableStartingInventory();
int curCount = inventory.contains(itemName) ? inventory[itemName] : 0;
std::string prettyItemName = fmt::format("{} x{}", itemName, curCount);
if (randomizer::textObjectExists(prettyItemName)) {
return Rml::String{randomizer::getTextStr(prettyItemName)};
}
if (curCount > 0) {
return Rml::String{itemText};
}
return Rml::String{"None"};
},
})
// Allow pressing the button to advance through the item choices
.on_pressed([increaseCount]() {
increaseCount();
mDoAud_seStartMenu(kSoundItemChange);
})
// Also allow pressing left/right to go back/advance through them
.on_nav_command([increaseCount, decreaseCount](Rml::Event&, NavCommand cmd) {
if (cmd == NavCommand::Right) {
increaseCount();
mDoAud_seStartMenu(kSoundItemChange);
return true;
}
if (cmd == NavCommand::Left) {
decreaseCount();
mDoAud_seStartMenu(kSoundItemChange);
return true;
}
return false;
})
// Listen for the change event so that we can update the list on the right pane
.listen(Rml::EventId::Change, [&rightPane](Rml::Event&) {
rando_starting_inventory_update_right_pane(rightPane);
});
}
void rando_starting_item_number_toggle(Pane& leftPane, Pane& rightPane, std::string itemText, std::string itemName = "", int max = 1) {
if (itemName.empty()) {
itemName = itemText;
}
leftPane.add_child<NumberButton>(NumberButton::Props{
.key = itemText,
.getValue =
[itemName] {
auto& inventory = GetRandomizerConfig().GetSettings().GetModifiableStartingInventory();
return inventory.contains(itemName) ? inventory[itemName] : 0;
},
.setValue = [itemName](int value) {
auto& inventory = GetRandomizerConfig().GetSettings().GetModifiableStartingInventory();
if (value == 0) {
inventory.erase(itemName);
} else {
inventory[itemName] = value;
}
SaveRandomizerConfig();
},
.min = 0,
.max = max,
})
.listen(Rml::EventId::Change, [&rightPane](Rml::Event&) {
rando_starting_inventory_update_right_pane(rightPane);
});
}
struct ExcludedTabLocData {
std::string name {};
std::string lowercaseName{};
std::unordered_set<std::string> categories{};
};
auto& RandomizerWindow::get_locations_for_left_pane() {
static std::list<ExcludedTabLocData> locationsForExcludedTab;
// If we haven't loaded the locations to display for the excluded locations tab, load them up
// TODO: Maybe preload this before any graphics stuff happens?
if (locationsForExcludedTab.empty()) {
auto locationDataTree = LOAD_EMBED_YAML(RANDO_DATA_PATH "locations.yaml");
for (const auto& locationNode : locationDataTree) {
ExcludedTabLocData excludedTabLocData{};
auto& name = excludedTabLocData.name;
auto& lowercaseName = excludedTabLocData.lowercaseName;
name = locationNode["Name"].as<std::string>();
lowercaseName = name;
std::transform(lowercaseName.begin(), lowercaseName.end(), lowercaseName.begin(),
[](unsigned char c) { return std::tolower(c); });
for (const auto& category : locationNode["Categories"]) {
excludedTabLocData.categories.insert(category.as<std::string>());
}
if (locationNode["Metadata"].IsMap()) {
for (const auto& data : locationNode["Metadata"]) {
excludedTabLocData.categories.insert(data.first.as<std::string>());
}
}
// Don't include warp portals
if (excludedTabLocData.categories.contains("Warp Portal")) {
continue;
}
// Certain locations we don't include for now
if (randomizer::utility::str::Contains(excludedTabLocData.name,
"Renados Letter", "Telma Invoice", "Wooden Statue", "Ilia Charm",
"Defeat Ganondorf", "Twilit Insect", "Twilit Bloat", "Hint"))
{
continue;
}
locationsForExcludedTab.push_back(excludedTabLocData);
}
locationsForExcludedTab.sort([](const auto& a, const auto& b) {
return a.name < b.name;
});
}
// Create the vector we're going to return
static std::vector<const std::string*> locationNames{};
locationNames.clear();
// Get settings values
auto& randoSettings = GetRandomizerConfig().GetSettings().GetMap();
bool goldenBugs = randoSettings.at("Golden Bugs") == "On";
bool skyCharacters = randoSettings.at("Sky Characters") == "On";
bool npcs = randoSettings.at("Gifts From NPCs") == "On";
bool shops = randoSettings.at("Shop Items") == "On";
bool goldenWolves = randoSettings.at("Hidden Skills") == "On";
bool hiddenRupees = randoSettings.at("Hidden Rupees") == "On";
bool freestandingRupees = randoSettings.at("Freestanding Rupees") == "On";
bool overworldPoes = randoSettings.at("Poe Souls").IsAnyOf("Overworld", "All");
bool dungeonPoes = randoSettings.at("Poe Souls").IsAnyOf("Dungeon", "All");
// Create lowercase filter
std::string lowercaseFilter = m_excludedLocationsFilter;
std::transform(lowercaseFilter.begin(), lowercaseFilter.end(), lowercaseFilter.begin(),
[](unsigned char c) { return std::tolower(c); });
// Add relevant location names
for (const auto& locData : locationsForExcludedTab) {
// Skip categories that aren't shuffled
auto& cats = locData.categories;
if ((!goldenBugs && cats.contains("Golden Bug")) ||
(!skyCharacters && cats.contains("Sky Character")) ||
(!npcs && cats.contains("Npc")) ||
(!shops && cats.contains("Shop")) ||
(!goldenWolves && cats.contains("Golden Wolf")) ||
(!hiddenRupees && cats.contains("Rupee - Hidden")) ||
(!freestandingRupees && cats.contains("Rupee - Freestanding")) ||
(!overworldPoes && cats.contains("Poe") && cats.contains("Overworld")) ||
(!dungeonPoes && cats.contains("Poe") && cats.contains("Dungeon")))
{
continue;
}
// Don't add this location if it doesn't match the current filter
if (locData.lowercaseName.find(lowercaseFilter) == std::string::npos) {
continue;
}
locationNames.push_back(&locData.name);
}
return locationNames;
}
// Forward declaration
void rando_excluded_locations_update_right_pane(Pane& innerRightPane, bool forceUpdate = false);
// Update the specified inner pane with the necessary button layout
void rando_excluded_locations_update_inner_pane(Pane& paneToUpdate, Pane& rightPane,
const std::vector<const std::string*>& locations, bool forceUpdate)
{
constexpr float buttonHeightDp = 48.0f;
Rml::Element* scrollContainer = paneToUpdate.root();
if (!scrollContainer) return;
// Get the density-independent scale factor to convert DP to physical pixels
float scaleFactor = scrollContainer->GetContext()->GetDensityIndependentPixelRatio();
const float buttonHeightPx = buttonHeightDp * scaleFactor;
int totalItems = static_cast<int>(locations.size());
// Clear pane and return early if no locations
if (totalItems == 0) {
paneToUpdate.clear();
return;
}
// Calculate viewport metrics
const float paneHeightPx = scrollContainer->GetParentNode()->GetParentNode()->GetClientHeight();
const float paneHeightDp = paneHeightPx / scaleFactor;
// Determine how many buttons are needed to fill the screen (+ 2 to prevent pop-in)
auto maxVisibleButtons = static_cast<int>(std::ceil(paneHeightDp / buttonHeightDp)) + 2;
if (maxVisibleButtons > totalItems) {
maxVisibleButtons = totalItems;
}
// Track the active scroll position
float scrollTopPx = scrollContainer->GetScrollTop();
// Find the index of the location that should be visible on the first button
auto topButtonIdx = static_cast<int>(std::floor(scrollTopPx / buttonHeightPx)) - 1;
// Clamp the index to ensure we don't calculate past the boundaries of the dataset
if (topButtonIdx < 0) topButtonIdx = 0;
if (topButtonIdx + maxVisibleButtons > totalItems) {
topButtonIdx = totalItems - maxVisibleButtons;
if (topButtonIdx < 0) topButtonIdx = 0;
}
// If the pane is empty, or if we've scrolled enough to need a new button,
// or we're forcing an update, make all the new buttons.
if (forceUpdate || paneToUpdate.children().empty() ||
paneToUpdate.children()[0]->root()->GetInnerRML() != *locations[topButtonIdx])
{
// Get the text of the currently focused element
std::string focusedText{};
for (const auto& button : paneToUpdate.children()) {
if (button->root()->IsPseudoClassSet("focus")) {
focusedText = dynamic_cast<ControlledButton*>(button.get())->get_text();
break;
}
}
// Clear all buttons from the element
paneToUpdate.clear();
// Add the top spacer before all other elements
auto topSpacer = append(paneToUpdate.root(), "div");
// Remake all the buttons with updated text and top/bottom padding
// TODO: Could improve this by only creating/deleting buttons from the top/bottom as necessary
// but I couldn't get that to work well
for (int i = 0; i < maxVisibleButtons; ++i) {
auto& name = *locations[topButtonIdx + i];
auto& button = paneToUpdate.add_button({
.text = name,
.isSelected = [name]{return GetRandomizerConfig().GetSettings().GetExcludedLocations().contains(name);},
})
.on_pressed([&rightPane, name] {
auto& excludedLocations = GetRandomizerConfig().GetSettings().GetModifiableExcludedLocations();
if (excludedLocations.contains(name)) {
excludedLocations.erase(name);
rando_excluded_locations_update_right_pane(rightPane, true);
} else {
excludedLocations.insert(name);
rando_excluded_locations_update_right_pane(rightPane, true);
}
SaveRandomizerConfig();
});
button.root()->SetProperty("padding-left", "8dp");
button.root()->SetProperty("font-size", "15dp");
// Call update now to prevent background opacity flickering
button.update();
// Focus this button if it has the same text as the one which was focused before
if (button.get_text() == focusedText) {
button.root()->SetPseudoClass("focus-visible", true);
button.root()->Focus();
}
}
// Add the bottom spacer after all other elements
auto bottomSpacer = append(paneToUpdate.root(), "div");
// Calculate and apply the top and bottom padding offsets.
// Using padding on the pane itself doesn't work for some
// reason, so instead we lock the height of the top and bottom spacers
int paddingTop = topButtonIdx * buttonHeightDp - 8;
int paddingBottom = (totalItems - topButtonIdx - paneToUpdate.children().size()) * buttonHeightDp + 8;
if (paddingBottom < 0) paddingBottom = 0;
topSpacer->SetProperty("height", std::to_string(paddingTop) + "dp");
bottomSpacer->SetProperty("height", std::to_string(paddingBottom) + "dp");
}
}
void rando_excluded_locations_update_right_pane(Pane& innerRightPane, bool forceUpdate /*= false*/) {
// Data for right pane is the current list of excluded locations
std::vector<const std::string*> excludedLocationsVec{};
for (const auto& location : GetRandomizerConfig().GetSettings().GetExcludedLocations()) {
excludedLocationsVec.push_back(&location);
}
// When the user removes an excluded location from the right pane, we have to track
// which child was focused here to properly restore focus to the previous child
int focusedId{-1};
for (int i = 0; i < innerRightPane.root()->GetNumChildren(); ++i) {
if (innerRightPane.root()->GetChild(i)->IsPseudoClassSet("focus")) {
focusedId = i;
break;
}
}
rando_excluded_locations_update_inner_pane(innerRightPane, innerRightPane, excludedLocationsVec, forceUpdate);
// Refocus the child with the same id (or the previous child if the user had deleted the last one)
// Subtract one more than normal for these calculations to take into account the spacer
if (focusedId >= innerRightPane.root()->GetNumChildren() - 1) {
focusedId = innerRightPane.root()->GetNumChildren() - 2;
}
if (focusedId >= 0) {
auto child = innerRightPane.root()->GetChild(focusedId);
child->SetPseudoClass("focus-visible", true);
child->Focus();
}
}
void RandomizerWindow::rando_excluded_locations_update_left_pane(Pane& innerLeftPane, Pane& rightPane, bool forceUpdate /* = false*/) {
// Data for left pane is all possible locations to exclude
auto& locations = get_locations_for_left_pane();
rando_excluded_locations_update_inner_pane(innerLeftPane, rightPane, locations, forceUpdate);
}
// Focus the closest child in the next Pane. Returns true if a child was found to focus
bool focus_closest_child_on_next_pane(Pane& currentPane, Pane& nextPane) {
auto childToFocusY = currentPane.get_focused_child_y();
return nextPane.focus_closest_child(childToFocusY);
}
void delete_seed_callback(Pane& pane) {
// Get the Y position to focus the child nearest to after we rebuild this pane
auto childToFocusY = pane.get_focused_child_y();
pane.clear();
std::filesystem::path seedDirectory = GetRandomizerSeedsPath();
if (std::filesystem::is_empty(seedDirectory)) {
pane.add_rml(
"No seeds generated.");
return;
}
pane.add_rml(
"Delete any seed not currently being used.");
for (const auto& entry : std::filesystem::directory_iterator(seedDirectory)) {
if (entry.is_directory()) {
std::string hash = entry.path().filename().string();
// If the hash is attached to any files, add the file number(s) afterward
auto& seedHashes = getSettings().randomizer.seedHashes;
auto hashCopy = hash;
for (int i = 0; i < seedHashes.size(); ++i) {
if (seedHashes[i].getValue() == hashCopy) {
hash += " (File " + std::to_string(i + 1) + ")";
}
}
pane.add_button(
{
.text = hash,
.isDisabled = [hash] {
return !playerIsOnTitleScreen() || hash.ends_with(')');
}
})
.on_pressed([entry, &pane, hash] {
// If the currently selected seed is deleted, reset the context
if (randomizer_GetContext().mHash == hash) {
randomizer_GetContext() = RandomizerContext{};
}
std::filesystem::remove_all(entry);
delete_seed_callback(pane);
});
}
}
// Refocus the closest child to the seed we just deleted
pane.focus_closest_child(childToFocusY);
};
RandomizerWindow::RandomizerWindow(dFile_select_c* fileSelect /*= nullptr*/) : mFileSelectMenu(fileSelect) {
// Create rando directories if they don't exist
if (!std::filesystem::exists(GetRandomizerSeedsPath())) {
std::filesystem::create_directories(GetRandomizerSeedsPath());
}
if (!std::filesystem::exists(GetRandomizerPresetsPath())) {
std::filesystem::create_directories(GetRandomizerPresetsPath());
}
// If we're bringing this menu up during file selection
if (mFileSelectMenu) {
// Don't allow going back to the main dusklight menu while this menu
// is active
mTabBar->listen(Rml::EventId::Keydown, [](Rml::Event& event) {
auto cmd = map_nav_event(event);
if (cmd == NavCommand::Menu || cmd == NavCommand::Cancel) {
event.StopPropagation();
}
});
add_tab("Play", [this](Rml::Element* content) {
auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
auto& rightPane = add_child<Pane>(content, Pane::Type::Controlled);
leftPane.register_control(
leftPane.add_select_button({
.key = "Selected Seed",
.getValue =
[] {
return randomizer_GetContext().mHash.empty() ?
"None" :
randomizer_GetContext().mHash;
},
}),
rightPane, [](Pane& pane) {
std::filesystem::path seedDirectory = GetRandomizerSeedsPath();
if (std::filesystem::is_empty(seedDirectory)) {
pane.add_rml(
"No seeds generated! You can generate a seed from the Seed Management Tab.");
return;
}
pane.add_rml(
"Choose which seed you want to play.");
for (const auto& entry : std::filesystem::directory_iterator(seedDirectory)) {
if (entry.is_directory()) {
std::string hash = entry.path().filename().string();
pane.add_button(
{
.text = hash,
.isSelected = [hash] {
return randomizer_GetContext().mHash == hash;
},
})
.on_pressed([hash] {
randomizer_GetContext() = RandomizerContext();
randomizer_GetContext().LoadFromHash(hash);
});
}
}
});
leftPane.add_button({
.text = "Start Randomizer",
.isDisabled = []{return randomizer_GetContext().mHash.empty();},
})
.on_pressed([this]{
if (mFileSelectMenu) {
mFileSelectMenu->mDusk.mBackToFileSelect = false;
}
mDoAud_seStartMenu(Z2SE_SY_CURSOR_OK);
this->hide(true);
});
});
}
add_tab("Seed Management", [this](Rml::Element* content) {
auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
auto& rightPane = add_child<Pane>(content, Pane::Type::Controlled);
leftPane.register_control(leftPane.add_button("Generate Seed").on_pressed(
[] {
if (TryCreateRandomSeed()) {
DuskLog.info("Created new Seed for generator.");
}
GenerateRandomizerSeed();
}),rightPane, [](Pane& pane) {
pane.clear();
pane.add_rml(
"Generate a Randomizer seed using the current configuration options, and the supplied seed string.");
});
leftPane.register_control(leftPane.add_child<StringButton>(StringButton::Props{
.key = "Seed String",
.getValue = [] {
return GetRandomizerConfig().GetSeed();
},
.setValue = [](Rml::String value) {
GetRandomizerConfig().SetSeed(value);
SaveRandomizerConfig();
},
.maxLength = 32,
}),
rightPane, [](Pane& pane) {
pane.clear();
pane.add_rml(
"Current value of the seed used by the randomizer for generation. Leave blank for a random value.");
});
leftPane.register_control(
leftPane.add_button("Delete Seeds"),
rightPane, delete_seed_callback
);
leftPane.add_section("Permalink");
leftPane.register_control(
leftPane.add_button("Copy Permalink")
.on_pressed([] {
CopyPermalinkToClipboard();
}),
rightPane, [](Pane& pane) {
pane.clear();
pane.add_text("Copy your current settings permalink to share with others.");
auto text = pane.add_text(fmt::format("Current Permalink: {}", GetRandomizerConfig().GetPermalink()));
text->SetProperty("word-break", "break-word");
});
leftPane.register_control(
leftPane.add_button("Paste Permalink")
.on_pressed([] {
PastePermalinkFromClipboard();
}),
rightPane, [](Pane& pane) {
pane.clear();
pane.add_text("Paste in a permalink from your clipboard. This will overwrite your current settings.");
});
leftPane.add_section("Presets");
leftPane.register_control(
leftPane.add_button("Save Current Settings as Preset")
.on_pressed([] {
push_document(std::make_unique<TextInputModal>(Modal::Props{
.title = "Preset Name",
.bodyRml = "",
.actions = {
ModalAction{
.label = "Save",
.onPressed = [](Modal& modal) {
auto textModal = dynamic_cast<TextInputModal*>(&modal);
if (!textModal->get_input_text().empty()) {
modal.pop();
SaveNewRandomizerPreset(textModal->get_input_text());
}
},
},
ModalAction{
.label = "Cancel",
.onPressed = [](Modal& modal) {
modal.pop();
},
},
},
.icon = "information"
}));
}),
rightPane, [](Pane& pane) {
pane.clear();
pane.add_text("Save the current settings to your list of presets.");
});
leftPane.register_control(
leftPane.add_button("Load Preset"),
rightPane, [](Pane& pane) {
pane.clear();
pane.add_text("Choose an existing preset to load from.");
for (const auto& file : std::filesystem::directory_iterator{GetRandomizerPresetsPath()}) {
const auto& filepath = file.path();
auto presetName = file.path().stem().generic_string();
pane.add_button(ControlledButton::Props{
.text = presetName,
})
.on_pressed([filepath] {
ApplyExistingRandomizerPreset(filepath);
});
}
});
});
add_tab("Seed Options", [this](Rml::Element* content) {
auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
leftPane.register_control(leftPane.add_button("Reset Settings to Default")
.on_pressed([] {
GetRandomizerConfig().ResetSettingsToDefault();
SaveRandomizerConfig();
}),
rightPane, [](Pane& pane) {
pane.clear();
pane.add_rml(
"Reset all settings to their default values. This will also clear starting items and excluded locations.");
});
leftPane.add_section("Logic Settings");
rando_config_button(leftPane, rightPane, "Logic Rules");
leftPane.add_section("Access Options");
rando_config_group(leftPane, rightPane, "Hyrule Barrier Requirements",
[](const std::string& value, Pane& pane) {
return rando_add_optional_setting(value, "Hyrule Barrier", pane);
});
rando_config_button(leftPane, rightPane, "Palace of Twilight Requirements");
rando_config_button(leftPane, rightPane, "Faron Woods Logic");
rando_config_button(leftPane, rightPane, "Mirror Chamber Access");
leftPane.add_section("Shuffles");
rando_config_button(leftPane, rightPane, "Golden Bugs");
rando_config_button(leftPane, rightPane, "Sky Characters");
rando_config_button(leftPane, rightPane, "Gifts From NPCs");
rando_config_button(leftPane, rightPane, "Shop Items");
rando_config_button(leftPane, rightPane, "Hidden Skills");
rando_config_button(leftPane, rightPane, "Hidden Rupees");
rando_config_button(leftPane, rightPane, "Freestanding Rupees");
rando_config_button(leftPane, rightPane, "Poe Souls");
rando_config_button(leftPane, rightPane, "Ilia Memory Quest");
rando_config_button(leftPane, rightPane, "Item Scarcity");
rando_config_button(leftPane, rightPane, "Trap Item Frequency");
leftPane.add_section("Dungeon Items");
rando_config_button(leftPane, rightPane, "Small Keys");
rando_config_button(leftPane, rightPane, "Big Keys");
rando_config_button(leftPane, rightPane, "Maps and Compasses");
rando_config_group(leftPane, rightPane, "Hyrule Castle Big Key Requirements",
[](const std::string& value, Pane& pane) {
return rando_add_optional_setting(value, "Hyrule Castle Big Key", pane);
});
rando_config_button(leftPane, rightPane, "Dungeon Rewards Can Be Anywhere");
rando_config_button(leftPane, rightPane, "No Small Keys on Bosses");
rando_config_button(leftPane, rightPane, "Unrequired Dungeons Are Barren");
leftPane.add_section("Timesavers");
rando_config_button(leftPane, rightPane, "Skip Prologue");
rando_config_button(leftPane, rightPane, "Faron Twilight Cleared");
rando_config_button(leftPane, rightPane, "Eldin Twilight Cleared");
rando_config_button(leftPane, rightPane, "Lanayru Twilight Cleared");
rando_config_button(leftPane, rightPane, "Skip Midna's Desparate Hour");
rando_config_button(leftPane, rightPane, "Skip Minor Cutscenes");
rando_config_button(leftPane, rightPane, "Skip Major Cutscenes");
rando_config_button(leftPane, rightPane, "Unlock Map Regions");
rando_config_button(leftPane, rightPane, "Open Door of Time");
rando_config_button(leftPane, rightPane, "Active Goron Mines Magnets");
rando_config_button(leftPane, rightPane, "Lower Hyrule Castle Chandelier");
rando_config_button(leftPane, rightPane, "Skip Bridge Donation");
leftPane.add_section("Additional Settings");
// rando_config_group(leftPane, rightPane, "Starting Form");
// rando_config_toggle(leftPane, rightPane, "Bonks Do Damage");
rando_config_button(leftPane, rightPane, "Starting Time of Day");
rando_config_button(leftPane, rightPane, "Logic Transform Anywhere");
rando_config_button(leftPane, rightPane, "Logic Increase Wallet Capacity");
rando_config_button(leftPane, rightPane, "Logic Damage Multiplier");
leftPane.add_section("Dungeon Entrance Settings");
rando_config_button(leftPane, rightPane, "Lakebed Does Not Require Water Bombs");
rando_config_button(leftPane, rightPane, "Arbiters Does Not Require Bulblin Camp");
rando_config_button(leftPane, rightPane, "Snowpeak Does Not Require Reekfish Scent");
rando_config_button(leftPane, rightPane, "Sacred Grove Does Not Require Skull Kid");
rando_config_button(leftPane, rightPane, "City Does Not Require Filled Skybook");
rando_config_button(leftPane, rightPane, "Goron Mines Entrance");
rando_config_button(leftPane, rightPane, "Temple of Time Sword Requirement");
// rando_config_toggle(leftPane, rightPane, "Randomize Starting Spawn");
// rando_config_group(leftPane, rightPane, "Randomize Dungeon Entrances");
// rando_config_toggle(leftPane, rightPane, "Randomize Boss Entrances");
// rando_config_toggle(leftPane, rightPane, "Randomize Grotto Entrances");
// rando_config_toggle(leftPane, rightPane, "Randomize Cave Entrances");
// rando_config_toggle(leftPane, rightPane, "Randomize Interior Entrances");
// rando_config_toggle(leftPane, rightPane, "Randomize Overworld Entrances");
// rando_config_toggle(leftPane, rightPane, "Decouple Double Door Entrances");
// rando_config_toggle(leftPane, rightPane, "Decouple Entrances");
leftPane.add_section("Tricks");
rando_config_button(leftPane, rightPane, "Back Slice as Sword");
rando_config_button(leftPane, rightPane, "Ball and Chain Webs");
});
add_tab("Starting Inventory", [this](Rml::Element* content) {
auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
auto& rightPane = add_child<Pane>(content, Pane::Type::Controlled);
// Hijack the Next Nav Command to let controller users interact with the right pane's scrollbar
leftPane.listen(Rml::EventId::Keydown, [&rightPane](Rml::Event& event) {
const auto cmd = map_nav_event(event);
if (cmd == NavCommand::Next) {
rightPane.root()->Focus();
event.StopPropagation();
}
});
// Map up and down to use the scrollbar on the right pane for controllers
rightPane.listen(Rml::EventId::Keydown, [&rightPane, &leftPane](Rml::Event& event) {
const auto cmd = map_nav_event(event);
if (cmd == NavCommand::Up) {
rightPane.root()->SetScrollTop(rightPane.root()->GetScrollTop() - 40.0f);
event.StopPropagation();
} else if (cmd == NavCommand::Down) {
rightPane.root()->SetScrollTop(rightPane.root()->GetScrollTop() + 40.0f);
} else if (cmd == NavCommand::Previous) {
leftPane.root()->Focus();
event.StopPropagation();
}
});
leftPane.add_button({
.text = "Clear Selected Starting Items",
.isSelected = []{ return false;},
})
.on_pressed([&rightPane]() {
auto& inventory = GetRandomizerConfig().GetSettings().GetModifiableStartingInventory();
inventory.clear();
SaveRandomizerConfig();
rando_starting_inventory_update_right_pane(rightPane);
});
leftPane.add_section("Main Items");
rando_starting_item_toggle(leftPane, rightPane, "Shadow Crystal");
rando_starting_item_toggle(leftPane, rightPane, "Horse Call");
rando_starting_item_toggle(leftPane, rightPane, "Fishing Rod", "Progressive Fishing Rod", 2);
rando_starting_item_toggle(leftPane, rightPane, "Slingshot");
rando_starting_item_toggle(leftPane, rightPane, "Lantern");
rando_starting_item_toggle(leftPane, rightPane, "Gale Boomerang");
rando_starting_item_toggle(leftPane, rightPane, "Iron Boots");
rando_starting_item_toggle(leftPane, rightPane, "Bow", "Progressive Bow", 3);
rando_starting_item_toggle(leftPane, rightPane, "Hawkeye");
rando_starting_item_number_toggle(leftPane, rightPane, "Bomb Bags", "Bomb Bag", 3);
rando_starting_item_toggle(leftPane, rightPane, "Giant Bomb Bags", "Giant Bomb Bag");
rando_starting_item_toggle(leftPane, rightPane, "Clawshot", "Progressive Clawshot", 2);
rando_starting_item_toggle(leftPane, rightPane, "Spinner");
rando_starting_item_toggle(leftPane, rightPane, "Ball and Chain");
rando_starting_item_toggle(leftPane, rightPane, "Dominion Rod", "Progressive Dominion Rod", 2);
rando_starting_item_toggle(leftPane, rightPane, "Empty Bottle");
rando_starting_item_toggle(leftPane, rightPane, "Auru's Memo", "Aurus Memo");
rando_starting_item_toggle(leftPane, rightPane, "Ashei's Sketch", "Asheis Sketch");
rando_starting_item_toggle(leftPane, rightPane, "Sky Book", "Progressive Sky Book", 7);
leftPane.add_section("Gear Screen");
rando_starting_item_toggle(leftPane, rightPane, "Sword", "Progressive Sword", 4);
rando_starting_item_toggle(leftPane, rightPane, "Ordon Shield");
rando_starting_item_toggle(leftPane, rightPane, "Hylian Shield");
rando_starting_item_toggle(leftPane, rightPane, "Zora Armor");
rando_starting_item_toggle(leftPane, rightPane, "Magic Armor");
rando_starting_item_toggle(leftPane, rightPane, "Wallet", "Progressive Wallet", 2);
rando_starting_item_number_toggle(leftPane, rightPane, "Hidden Skills", "Progressive Hidden Skill", 7);
rando_starting_item_number_toggle(leftPane, rightPane, "Poe Souls", "Poe Soul", 60);
rando_starting_item_number_toggle(leftPane, rightPane, "Fused Shadows", "Progressive Fused Shadow", 3);
rando_starting_item_number_toggle(leftPane, rightPane, "Mirror Shards", "Progressive Mirror Shard", 4);
leftPane.add_section("Overworld Keys");
rando_starting_item_toggle(leftPane, rightPane, "Gate Keys");
rando_starting_item_toggle(leftPane, rightPane, "Gerudo Desert Bulblin Camp Key");
leftPane.add_section("Dungeon Items");
rando_starting_item_number_toggle(leftPane, rightPane, "Forest Temple Small Keys", "Forest Temple Small Key", 4);
rando_starting_item_number_toggle(leftPane, rightPane, "Goron Mines Small Keys", "Goron Mines Small Key", 3);
rando_starting_item_number_toggle(leftPane, rightPane, "Lakebed Temple Small Keys", "Lakebed Temple Small Key", 3);
rando_starting_item_number_toggle(leftPane, rightPane, "Arbiter's Grounds Small Keys", "Arbiters Grounds Small Key", 5);
rando_starting_item_number_toggle(leftPane, rightPane, "Snowpeak Ruins Small Keys", "Snowpeak Ruins Small Key", 4);
rando_starting_item_toggle(leftPane, rightPane, "Ordon Pumpkin");
rando_starting_item_toggle(leftPane, rightPane, "Ordon Cheese");
rando_starting_item_number_toggle(leftPane, rightPane, "Temple of Time Small Keys", "Temple of Time Small Key", 4);
rando_starting_item_number_toggle(leftPane, rightPane, "City in the Sky Small Keys", "City in the Sky Small Key", 1);
rando_starting_item_number_toggle(leftPane, rightPane, "Palace of Twilight Small Keys", "Palace of Twilight Small Key", 7);
rando_starting_item_number_toggle(leftPane, rightPane, "Hyrule Castle Small Keys", "Hyrule Castle Small Key", 3);
rando_starting_item_toggle(leftPane, rightPane, "Forest Temple Big Key");
rando_starting_item_number_toggle(leftPane, rightPane, "Goron Mines Key Shards", "Goron Mines Key Shard", 3);
rando_starting_item_toggle(leftPane, rightPane, "Lakebed Temple Big Key");
rando_starting_item_toggle(leftPane, rightPane, "Arbiter's Grounds Big Key", "Arbiters Grounds Big Key");
rando_starting_item_toggle(leftPane, rightPane, "Snowpeak Ruins Bedroom Key");
rando_starting_item_toggle(leftPane, rightPane, "Temple of Time Big Key");
rando_starting_item_toggle(leftPane, rightPane, "City in the Sky Big Key");
rando_starting_item_toggle(leftPane, rightPane, "Palace of Twilight Big Key");
rando_starting_item_toggle(leftPane, rightPane, "Hyrule Castle Big Key");
leftPane.add_section("Warp Portals");
rando_starting_item_toggle(leftPane, rightPane, "Gerudo Desert Portal");
rando_starting_item_toggle(leftPane, rightPane, "Mirror Chamber Portal");
rando_starting_item_toggle(leftPane, rightPane, "Snowpeak Portal");
rando_starting_item_toggle(leftPane, rightPane, "Sacred Grove Portal");
rando_starting_item_toggle(leftPane, rightPane, "Bridge of Eldin Portal");
rando_starting_item_toggle(leftPane, rightPane, "Upper Zora's River Portal", "Upper Zoras River Portal");
});
add_tab("Excluded Locations", [this](Rml::Element* content) {
auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled, false);
auto& rightPane = add_child<Pane>(content, Pane::Type::Controlled, false);
// Setup right pane
rightPane.root()->SetProperty("overflow", "hidden");
rightPane.root()->SetProperty("padding", "0dp");
rightPane.root()->SetProperty("gap", "0dp");
auto excludedLocationsSection = rightPane.add_section("Current Excluded Locations");
excludedLocationsSection->SetProperty("margin-top", "22dp");
excludedLocationsSection->SetProperty("margin-bottom", "0dp");
excludedLocationsSection->SetProperty("text-align", "center");
excludedLocationsSection->SetProperty("font-size", "25dp");
excludedLocationsSection->SetProperty("opacity", "1");
auto clickToRemoveSection = rightPane.add_section("Select a location to remove it");
clickToRemoveSection->SetProperty("margin-bottom", "21dp");
clickToRemoveSection->SetProperty("margin-top", "0dp");
clickToRemoveSection->SetProperty("text-align", "center");
clickToRemoveSection->SetProperty("font-size", "15dp");
auto& innerRightPane = rightPane.add_child<Pane>(Pane::Type::Controlled);
innerRightPane.root()->SetClass("excluded-locations-pane", true);
// Setup left pane
leftPane.root()->SetProperty("overflow", "hidden");
leftPane.root()->SetProperty("padding", "0dp");
auto& clearExcluded = leftPane.add_button(ControlledButton::Props{
.text = "Clear All",
});
clearExcluded.root()->SetProperty("margin", "12dp 24dp");
clearExcluded.root()->SetProperty("margin-bottom", "0dp");
clearExcluded.on_pressed([&innerRightPane] {
GetRandomizerConfig().GetSettings().GetModifiableExcludedLocations().clear();
rando_excluded_locations_update_right_pane(innerRightPane);
});
auto& filter = leftPane.add_child<StringButton>(StringButton::Props{
.key = "Filter",
.getValue = [this] { return m_excludedLocationsFilter; },
.setValue = [this](Rml::String str) { m_excludedLocationsFilter = str; },
});
filter.root()->SetProperty("margin", "6dp 24dp");
filter.root()->SetProperty("height", "40dp");
auto& innerLeftPane = leftPane.add_child<Pane>(Pane::Type::Controlled, false);
innerLeftPane.root()->SetClass("excluded-locations-pane", true);
// Attach listeners for left pane
filter.listen(Rml::EventId::Change, [this, &innerLeftPane, &innerRightPane](Rml::Event& event) {
if (event.GetParameters().find("text") != event.GetParameters().end()) {
const Rml::String text = event.GetParameter("text", Rml::String{});
m_excludedLocationsFilter = text;
this->rando_excluded_locations_update_left_pane(innerLeftPane, innerRightPane, true);
event.StopImmediatePropagation();
}
});
// Check for updating the left pane each time we scroll on it
innerLeftPane.listen(Rml::EventId::Scroll, [&innerLeftPane, &innerRightPane, this](Rml::Event&) {
this->rando_excluded_locations_update_left_pane(innerLeftPane, innerRightPane);
});
// Hijack the right nav command to make switching to the other pan more intuitive
innerLeftPane.listen(Rml::EventId::Keydown, [&innerLeftPane, &innerRightPane](Rml::Event& event) {
auto cmd = map_nav_event(event);
if (cmd == NavCommand::Right) {
if (focus_closest_child_on_next_pane(innerLeftPane, innerRightPane)) {
event.StopPropagation();
}
}
});
// Attach listeners for right pane
innerRightPane.listen(Rml::EventId::Scroll, [&innerRightPane](Rml::Event&) {
rando_excluded_locations_update_right_pane(innerRightPane);
});
// Hijack the right nav command to make switching to the other pan more intuitive
innerRightPane.listen(Rml::EventId::Keydown, [&innerLeftPane, &innerRightPane](Rml::Event& event) {
auto cmd = map_nav_event(event);
if (cmd == NavCommand::Left) {
if (focus_closest_child_on_next_pane(innerRightPane, innerLeftPane)) {
event.StopPropagation();
}
}
});
// Initial update of panes
rando_excluded_locations_update_right_pane(innerRightPane);
this->rando_excluded_locations_update_left_pane(innerLeftPane, innerRightPane);
});
if (randomizer_IsActive()) {
add_tab("In-Game", [this](Rml::Element* content) {
auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
leftPane.add_section("General");
leftPane.register_control(leftPane.add_button("Warp to Start").on_pressed([] {
mDoAud_seStartMenu(kSoundClick);
dComIfGp_setNextStage("F_SP103", 1, 1, -1);
}), rightPane, [](Pane& pane) {
pane.clear();
pane.add_rml("Respawns the player at their appropriate starting location.");
});
leftPane.add_button("Toggle Tracker Window").on_pressed([] {
g_randomizerState.mShowTracker = !g_randomizerState.mShowTracker;
});
});
}
}
FileSelectRandomizerWindow::FileSelectRandomizerWindow(dFile_select_c* fileSelectMenu) :
RandomizerWindow(fileSelectMenu) { }
bool FileSelectRandomizerWindow::consume_close_request() {
hide(true);
return true;
}
void SaveNewRandomizerPreset(const std::string& presetName, bool overwriteExisting /*= false*/) {
auto presetFilepath = GetRandomizerPresetsPath() / (presetName + ".yaml");
// If the preset exists, ask the user if they want to overwrite it. If so, call this function
// again but force overwrite the existing preset
if (std::filesystem::exists(presetFilepath) && !overwriteExisting) {
push_document(std::make_unique<Modal>(Modal::Props{
.title = "Overwrite Existing Preset",
.bodyRml = "A preset with the name " + presetName + " already exists. Do you wish to overwrite it?",
.actions = {
ModalAction{
.label = "Yes",
.onPressed = [presetName](Modal& modal) {
modal.pop();
SaveNewRandomizerPreset(presetName, true);
}
},
ModalAction{
.label = "No",
.onPressed = [](Modal& modal) {
modal.pop();
}
}
}
}));
}
// If there was an error trying to save, let the user know
try {
GetRandomizerConfig().WriteSettingsToFile(presetFilepath);
} catch (std::exception& e) {
push_document(std::make_unique<Modal>(Modal::Props{
.title = "Error Saving Preset",
.bodyRml = fmt::format("Error: {}", e.what()),
.actions = {
ModalAction{
.label = "Okay",
.onPressed = [](Modal& modal) {
modal.pop();
}
}
},
.icon = "error"
}));
return;
}
push_toast(Toast{
.title = "",
.content = fmt::format("Saved preset {}", presetName),
.duration = std::chrono::seconds(3)
});
}
void ApplyExistingRandomizerPreset(const std::filesystem::path& presetFilePath) {
// Don't overwrite the seed with the one from the preset
auto seed = GetRandomizerConfig().GetSeed();
try {
GetRandomizerConfig().LoadFromFile(presetFilePath, GetRandomizerPreferencesPath(), false, true);
GetRandomizerConfig().SetSeed(seed);
} catch (std::exception& e) {
push_document(std::make_unique<Modal>(Modal::Props{
.title = "Error Loading Preset",
.bodyRml = fmt::format("Error: {}", e.what()),
.actions = {
ModalAction{
.label = "Okay",
.onPressed = [](Modal& modal) {
modal.pop();
}
}
},
.icon = "error"
}));
return;
}
push_toast(Toast{
.title = "",
.content = fmt::format("Loaded preset {}", presetFilePath.stem().generic_string()),
.duration = std::chrono::seconds(3)
});
}
void CopyPermalinkToClipboard() {
if (SDL_SetClipboardText(GetRandomizerConfig().GetPermalink().data())) {
push_toast(Toast{
.content = "Permalink Copied",
.duration = std::chrono::seconds(3)
});
} else {
push_document(std::make_unique<Modal>(Modal::Props{
.title = "Permalink Error",
.bodyRml = fmt::format("Could not copy permalink to clipboard. Reason: {}", SDL_GetError()),
.actions = {
ModalAction{
.label = "Okay",
.onPressed = [](Modal& modal) {
modal.pop();
}
}
},
.icon = "error"
}));
}
}
void PastePermalinkFromClipboard() {
if (SDL_HasClipboardText()) {
std::string clipBoardText = SDL_GetClipboardText();
auto result = GetRandomizerConfig().LoadFromPermalink(clipBoardText);
if (result.has_value()) {
auto modal = dynamic_cast<Modal*>(&push_document(std::make_unique<Modal>(Modal::Props{
.title = "Permalink Error",
.bodyRml = result.value(),
.actions = {
ModalAction{
.label = "Okay",
.onPressed = [](Modal& modal) {
modal.pop();
}
}
},
.icon = "error"
})));
modal->root()->SetProperty("white-space", "pre-line");
} else {
push_toast(Toast{.content = "Applied Permalink", .duration = std::chrono::seconds(3)});
SaveRandomizerConfig();
}
}
}
std::filesystem::path GetRandomizerPath() {
return data::configured_data_path() / "randomizer";
}
std::filesystem::path GetRandomizerSettingsPath() {
return GetRandomizerPath() / "settings.yaml";
}
std::filesystem::path GetRandomizerPreferencesPath() {
return GetRandomizerPath() / "preferences.yaml";
}
std::filesystem::path GetRandomizerPresetsPath() {
return GetRandomizerPath() / "presets";
}
std::filesystem::path GetRandomizerSeedsPath() {
return GetRandomizerPath() / "seeds";
}
randomizer::seedgen::config::Config& GetRandomizerConfig() {
static randomizer::seedgen::config::Config s_config{GetRandomizerSettingsPath(),
GetRandomizerPreferencesPath()};
return s_config;
}
}
Reference in New Issue View Git Blame Copy Permalink