Skip to content

Play your Steam library's Windows games on a jailbroken PS5.

C++

Group Game settings rows by topic

Leonardo Lobatof2d5bd30edab
diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
index 1772ef2..f8f0235 100644
--- a/COMPATIBILITY.md
+++ b/COMPATIBILITY.md
@@ -51,7 +51,7 @@ uses: Direct3D 8–11 goes through DXVK to Vulkan, and Direct3D 12 through vkd3d
| [Cuphead](https://store.steampowered.com/app/268910) | ✅ Works | 0.11 | Unity · D3D11 · DXVK · 64-bit | Default settings. Title, a new save, the storybook intro and Elder Kettle's house with the controller. |
| [Cyberpunk 2077](https://store.steampowered.com/app/1091500) | ✅ Works | 0.11 | REDengine 4 · D3D12 · vkd3d-proton · 64-bit | Game settings › Program = `bin/x64/Cyberpunk2077.exe` (the default launcher cannot start the game), Graphics = DXVK, Direct3D 12 = **vkd3d-proton**. The first start opens at 1024×768: set 1920×1080 in the game's Video settings. Intro, menus, character creation, the Nomad opening and walking in the garage with the controller; about 3 GB of video memory, no crash in a 13-minute session. Frame rate not measured yet. ([#67](https://github.com/leolobato/playden-ps5/issues/67)) |
| [DAEMON X MACHINA](https://store.steampowered.com/app/1167450) | ✅ Works | 0.10 | — | Plays with the DualSense. The game's Select/Back is on the Share button, and pressing Share or PS makes the game stop responding: rebind Select/Back (for example to the touchpad) or play with a USB mouse and keyboard. ([#55](https://github.com/leolobato/playden-ps5/issues/55), firmware 12.40) |
-| [Darkwood](https://store.steampowered.com/app/274520) | ✅ Works | 0.12 | Unity · D3D11 · DXVK · 64-bit | Plays at 4K with Game settings › 120 Hz output. For 120 Hz, turn off the PS5's Screen and Video › Video Output › VRR › Apply to Unsupported Games, or the game stays at 60 Hz. The game opens the map and journal with Create, which also opens the PS5's capture menu: the tester mapped the touchpad to M and L3 to J, and the left stick to the mouse at full speed for the map ([recipe](https://github.com/leolobato/playden-ps5/issues/93#issuecomment-6346281720)). DualSense, PS5 Pro. ([#93](https://github.com/leolobato/playden-ps5/issues/93), firmware 13.60) |
+| [Darkwood](https://store.steampowered.com/app/274520) | ✅ Works | 0.12 | Unity · D3D11 · DXVK · 64-bit | Plays at 4K with Game settings › Refresh rate = 120 Hz. For 120 Hz, turn off the PS5's Screen and Video › Video Output › VRR › Apply to Unsupported Games, or the game stays at 60 Hz. The game opens the map and journal with Create, which also opens the PS5's capture menu: the tester mapped the touchpad to M and L3 to J, and the left stick to the mouse at full speed for the map ([recipe](https://github.com/leolobato/playden-ps5/issues/93#issuecomment-6346281720)). DualSense, PS5 Pro. ([#93](https://github.com/leolobato/playden-ps5/issues/93), firmware 13.60) |
| [Dead Cells](https://store.steampowered.com/app/588650) | ✅ Works | 0.11 | Heaps · D3D11 · DXVK · 64-bit | Playden picks Graphics = DXVK for HashLink games; with Automatic it stopped with "Failed to initialize DirectX driver". Menus, the intro and the first room with the controller. |
| [Death’s Door](https://store.steampowered.com/app/894020) | ✅ Works | 0.12 | Unity · D3D11 · DXVK · 64-bit | Default settings. Controller menus, a new save, the bus intro and moving/attacking in the opening headquarters area verified. Tested from USB storage; later combat and sustained performance not tested. |
| [Deep Rock Galactic](https://store.steampowered.com/app/548430) | ✅ Works | 0.11 | Unreal 4 · D3D12 · vkd3d-proton · 64-bit | Program = *Deep Rock Galactic (DirectX 12)*, Direct3D 12 = **vkd3d-proton** (Playden then passes `-dx12`). Title screen, the intro and the tutorial mission (moving, shooting) with the controller. Online play not tested. |
@@ -143,7 +143,7 @@ uses: Direct3D 8–11 goes through DXVK to Vulkan, and Direct3D 12 through vkd3d
| [Urban Jungle](https://store.steampowered.com/app/2744010) | ✅ Works | 0.12 | — | DualSense with the Mouse preset. The first hour. ([#123](https://github.com/leolobato/playden-ps5/issues/123), firmware 13.60) |
| [Vampire Survivors](https://store.steampowered.com/app/1794680) | ✅ Works | 0.10 | Unity · D3D11 · 64-bit | Plays with the DualSense; Cloud saves restore. A mouse pointer was seen once in the top-left corner. |
| [Victory Heat Rally](https://store.steampowered.com/app/1594060) | ✅ Works | 0.12 | GameMaker · D3D11 · DXVK · 64-bit | Default settings. Controller menus, loading the existing save and driving in an Ancient Arena circuit race (accelerating and steering) verified. Tested from the M.2 SSD; a full race and multiplayer not tested. |
-| [VVVVVV](https://store.steampowered.com/app/70300) | ✅ Works | 0.12 | SDL2 · D3D9 · DXVK · 32-bit | Requires Game settings > More settings > Graphics = DXVK. Automatic exits before menu: SDL cannot create a renderer; WineD3D cannot create a GL context. With DXVK, v2.4.4 language/menu, new-game intro, controller movement, gravity flip, room transition to Conundrum and death/respawn verified; clean rendering. Launched prepared title directly after Playden reported native launch capability unavailable. Later levels untested. |
+| [VVVVVV](https://store.steampowered.com/app/70300) | ✅ Works | 0.12 | SDL2 · D3D9 · DXVK · 32-bit | Requires Game settings › Compatibility › Graphics = DXVK. Automatic exits before menu: SDL cannot create a renderer; WineD3D cannot create a GL context. With DXVK, v2.4.4 language/menu, new-game intro, controller movement, gravity flip, room transition to Conundrum and death/respawn verified; clean rendering. Launched prepared title directly after Playden reported native launch capability unavailable. Later levels untested. |
| [What Remains of Edith Finch](https://store.steampowered.com/app/501300) | ✅ Works | 0.12 | Unreal 4 · D3D11 · DXVK · 64-bit | Default settings, direct `FinchGame/Binaries/Win64/FinchGame.exe` selected by Playden. Opening ferry scene, looking around and opening the journal with the controller, then walking on the path toward the house verified. Tested from USB storage; later stories not tested. |
| [Wobbly Life](https://store.steampowered.com/app/1211020) | ✅ Works | 0.10 | — | Single-player with DualSense or USB mouse and keyboard; multiplayer does not work. Loading takes about a minute. ([#25](https://github.com/leolobato/playden-ps5/issues/25), firmware 9.40) |
| [Antichamber](https://store.steampowered.com/app/219890) | 🟡 Partial | 0.10 | Unreal 3 · D3D9 · 32-bit | Reaches the first room; the controller is ignored. With Controller preset = **Mouse** the stick turns the view; walking needs a USB keyboard (WASD) or Button mapping. |
diff --git a/README.md b/README.md
index 1807c38..d8c5260 100644
--- a/README.md
+++ b/README.md
@@ -322,7 +322,7 @@ build/homebrew-host/playden-homebrew --simulation --scenario signed-out
happening, use Settings › Account › **Sign in again**: it keeps your library, favorites and settings.
- Godot games (Slay the Spire 2) need `--rendering-driver opengl3` in Game settings › Extra arguments. Playden picks
Godot's Vulkan renderer, which did not work on this kit.
-- The "120 Hz output" game setting needs a newer runtime kit; it is not available with this kit.
+- The 120 Hz choice of the "Refresh rate" game setting needs a newer runtime kit; it is not available with this kit.
- When you close a game from the PS5 menu, it can stay suspended. Pressing Play again resumes it instead of starting
it again.
- Downloads can be slow (about 1 MB/s) on some networks, far from a fast Steam server. Turn on Settings › Storage ›
diff --git a/src/homebrew/simulation.cpp b/src/homebrew/simulation.cpp
index 2becd8e..3b14a62 100644
--- a/src/homebrew/simulation.cpp
+++ b/src/homebrew/simulation.cpp
@@ -475,7 +475,9 @@ std::string action_label(const std::string& key) {
{"value-edit", "Edit…"}, {"value-reset", "Reset to recipe"}, {"override-add", "Add an override…"},
{"unlock-setting", "Change anyway"}, {"export-recipe", "Export as recipe"}, {"program-scan", "Looking for programs…"},
{"preset-picker", "Preset"}, {"game-settings", "Game settings"}, {"game-maintenance", "Maintenance"}, {"runtime-check-again", "Check again"}, {"reset-settings", "Reset all to preset"}, {"clear-shader-cache", "Clear shader cache"},
- {"section-more", "More settings"}, {"section-advanced", "Advanced"},
+ {"section-compatibility", "Compatibility"}, {"section-advanced", "Advanced"}, {"heading-game", "Game"},
+ {"heading-display", "Display"}, {"heading-controls", "Controls"}, {"heading-sound", "Sound"},
+ {"heading-graphics", "Graphics"}, {"heading-windows", "Windows"},
{"sort-name", "Name"}, {"sort-recent-played", "Recently played"}, {"sort-recent-added", "Recently added"},
{"sort-playtime", "Playtime"}, {"sort-install-size", "Install size"}, {"filter-installed", "Installed"},
{"filter-genre-adventure", "Adventure"}, {"filter-controller-full", "Full controller support"},
@@ -3702,6 +3704,7 @@ void Simulation::rebuild_view() {
}
const GameId settings_game = state_.navigation.selected_game_id;
const bool settings_modal = modal.id == "game-settings" || modal.id == "preset-picker" || modal.id == "button-mapping" ||
+ modal.id == "controller-tuning" ||
modal.id == "game-maintenance" || !modal.setting_id.empty();
rt::EffectiveSettings settings_values;
const bool settings_ready = settings_modal && EffectiveSettingsFor(settings_game, &settings_values);
@@ -3897,6 +3900,17 @@ void Simulation::rebuild_view() {
: saved ? std::to_string(saved) : std::string("None");
item.subtitle = from_file ? "From the game's steam_appid.txt" : "Only for games that need Steam. Most run without it.";
item.modified = saved != 0;
+ } else if (settings_ready && action_key == "controller-tuning") {
+ item.kind = RowKind::Choice;
+ item.title = "Controller tuning";
+ item.subtitle = "Pointer stick, dead zones, rumble and invert.";
+ int changed = 0;
+ for (const auto& definition : rt::SettingsCatalogue())
+ if (definition.group == rt::SettingGroup::kControllerTuning &&
+ settings_values.values.at(definition.id).source == rt::ValueSource::kUser)
+ ++changed;
+ item.value = changed == 0 ? "Default" : std::to_string(changed) + " changed";
+ item.modified = changed > 0;
} else if (settings_ready && action_key == "button-mapping") {
item.kind = RowKind::Choice;
item.title = "Button mapping";
@@ -3910,14 +3924,23 @@ void Simulation::rebuild_view() {
}
item.value = bound == 0 ? "None" : std::to_string(bound) + (bound == 1 ? " button" : " buttons");
item.modified = changed;
- } else if (settings_ready && (action_key == "section-more" || action_key == "section-advanced")) {
+ } else if (settings_ready && (action_key == "section-compatibility" || action_key == "section-advanced")) {
item.kind = RowKind::Heading;
- const auto tier = action_key == "section-more" ? rt::SettingTier::kCompatibility : rt::SettingTier::kAdvanced;
+ const bool advanced = action_key == "section-advanced";
int count = 0;
- for (const auto& definition : rt::SettingsCatalogue())
- if (definition.tier == tier && rt::SettingShown(definition, kit_)) ++count;
- if (tier == rt::SettingTier::kCompatibility) ++count; // Button mapping
+ for (const auto& definition : rt::SettingsCatalogue()) {
+ const bool inside = advanced ? definition.group == rt::SettingGroup::kAdvanced
+ : definition.group == rt::SettingGroup::kCompatibility ||
+ definition.group == rt::SettingGroup::kGraphics ||
+ definition.group == rt::SettingGroup::kWindows;
+ if (inside && game_settings_row_shown(definition, settings_game)) ++count;
+ }
item.value = expanded_settings_sections_.count(action_key) ? "Hide" : "Show " + std::to_string(count);
+ } else if (settings_ready && action_key.rfind("heading-", 0) == 0) {
+ // Names the rows below it; not focusable (move_game_settings skips it).
+ item.kind = RowKind::Separator;
+ item.action.clear();
+ item.enabled = false;
} else if (settings_ready && !modal.setting_id.empty() && action_key.rfind("choice-", 0) == 0 && action_key != "choice-custom") {
item.kind = RowKind::Choice;
const auto index = static_cast<std::size_t>(std::stoul(action_key.substr(7)));
@@ -4372,6 +4395,7 @@ void Simulation::rebuild_view() {
if (modal.id == "game-settings") view_.legends = {"Cross Change", "Triangle Reset", "L1/R1 Jump", "Circle Close"};
else if (modal.id == "preset-picker") view_.legends = {"Cross Use this preset", "L1/R1 Jump", "Circle Back"};
else if (modal.id == "button-mapping") view_.legends = {"Cross Change", "L1/R1 Jump", "Circle Back"};
+ else if (modal.id == "controller-tuning") view_.legends = {"Cross Change", "Triangle Reset", "L1/R1 Jump", "Circle Back"};
else if (modal.id == "game-maintenance") view_.legends = {"Cross Select", "L1/R1 Jump", "Circle Cancel"};
else if (modal.id == "import-games") view_.legends = {"Cross Select", "Circle Close"};
else if (modal.id == "import-programs" || modal.id == "import-choice") view_.legends = {"Cross Select", "Circle Back"};
@@ -5748,7 +5772,17 @@ void Simulation::move(int delta_x, int delta_y) {
if (modal.id == "installed-games") { move_installed_manager(delta_x, delta_y); return; }
if (modal.id == "import-games") { move_import_sheet(delta_y != 0 ? delta_y : delta_x); return; }
const int delta = delta_y != 0 ? delta_y : delta_x;
- modal.focused_action = std::clamp(modal.focused_action + delta, 0, static_cast<int>(modal.action_keys.size()) - 1);
+ const int last = static_cast<int>(modal.action_keys.size()) - 1;
+ modal.focused_action = std::clamp(modal.focused_action + delta, 0, last);
+ // Game settings' topic headings only label the rows below them: focus goes on past them.
+ if (modal.id == "game-settings" && delta != 0) {
+ const auto heading = [&modal](int index) { return modal.action_keys[static_cast<std::size_t>(index)].rfind("heading-", 0) == 0; };
+ const int step = delta > 0 ? 1 : -1;
+ while (heading(modal.focused_action) && modal.focused_action + step >= 0 && modal.focused_action + step <= last)
+ modal.focused_action += step;
+ while (heading(modal.focused_action) && modal.focused_action - step >= 0 && modal.focused_action - step <= last)
+ modal.focused_action -= step;
+ }
state_.navigation.focus_key = modal.action_keys[static_cast<std::size_t>(modal.focused_action)];
return;
}
@@ -7234,6 +7268,7 @@ void Simulation::activate() {
if (id == "launch_option") forget_program_choices(&record.overrides);
if (id == "dll_overrides") record.overrides.erase("library_overrides");
++record.revision;
+ if (id == "refresh") follow_refresh_rate(state_.navigation.selected_game_id);
close_modal(); refresh_game_settings(); save_profile();
} else if (action_name.rfind("program-", 0) == 0 && action_name != "program-scan" && !state_.navigation.modals.empty()) {
// A program from the game folder; its architecture comes with it.
@@ -7261,6 +7296,12 @@ void Simulation::activate() {
for (const auto& button : rt::ProsperoButtons()) actions.push_back("setting-button." + button);
actions.push_back("cancel");
open_modal({"button-mapping", "Button mapping", "button-mapping", std::move(actions), 0, false});
+ } else if (action_name == "controller-tuning") {
+ std::vector<std::string> actions;
+ for (const auto& definition : rt::SettingsCatalogue())
+ if (definition.group == rt::SettingGroup::kControllerTuning) actions.push_back("setting-" + definition.id);
+ actions.push_back("cancel");
+ open_modal({"controller-tuning", "Controller tuning", "controller-tuning", std::move(actions), 0, false});
} else if (action_name.rfind("choice-", 0) == 0 && !state_.navigation.modals.empty() && state_.navigation.modals.back().setting_id.rfind("button.", 0) == 0) {
const auto id = state_.navigation.modals.back().setting_id;
const auto index = static_cast<std::size_t>(std::stoul(action_name.substr(7)));
@@ -7283,7 +7324,7 @@ void Simulation::activate() {
set_game_setting(id, launch ? recipe.launch_entries[index].id : definition->choices[index].value);
}
close_modal(); refresh_game_settings(); save_profile();
- } else if (action_name == "section-more" || action_name == "section-advanced") {
+ } else if (action_name == "section-compatibility" || action_name == "section-advanced") {
if (!expanded_settings_sections_.erase(action_name)) expanded_settings_sections_.insert(action_name);
refresh_game_settings();
} else if (action_name == "reset-settings") {
@@ -7725,7 +7766,8 @@ bool Simulation::action(const std::string& logical_action) {
else if ((logical_action == "l1" || logical_action == "r1") && !state_.navigation.modals.empty() &&
(state_.navigation.modals.back().id == "game-settings" || state_.navigation.modals.back().id == "preset-picker" ||
state_.navigation.modals.back().id == "game-maintenance" ||
- state_.navigation.modals.back().id == "button-mapping" || !state_.navigation.modals.back().setting_id.empty()))
+ state_.navigation.modals.back().id == "button-mapping" || state_.navigation.modals.back().id == "controller-tuning" ||
+ !state_.navigation.modals.back().setting_id.empty()))
move(0, logical_action == "l1" ? -5 : 5); // L1/R1 jump five rows, as on macOS
else if (logical_action == "l1") change_route(-1);
else if (logical_action == "r1") change_route(1);
@@ -7757,7 +7799,8 @@ bool Simulation::action(const std::string& logical_action) {
}
}
else if (logical_action == "triangle" && !state_.editor.active && !state_.navigation.modals.empty() &&
- (state_.navigation.modals.back().id == "game-settings" || !state_.navigation.modals.back().setting_id.empty())) {
+ (state_.navigation.modals.back().id == "game-settings" || state_.navigation.modals.back().id == "controller-tuning" ||
+ !state_.navigation.modals.back().setting_id.empty())) {
// Triangle returns the focused setting (or the open picker's setting) to the preset value.
const auto& modal = state_.navigation.modals.back();
const auto id = !modal.setting_id.empty() ? modal.setting_id
@@ -7779,6 +7822,7 @@ bool Simulation::action(const std::string& logical_action) {
if (!id.empty() && !closed_needed && present() && can_change_game_settings()) {
for (const auto& key : keys) record->second.overrides.erase(key);
++record->second.revision;
+ if (id == "refresh") follow_refresh_rate(state_.navigation.selected_game_id);
if (!modal.setting_id.empty()) close_modal();
refresh_game_settings(); save_profile();
}
@@ -8260,29 +8304,53 @@ bool Simulation::EffectiveSettingsFor(GameId id, rt::EffectiveSettings* settings
}
std::vector<std::string> Simulation::game_settings_actions() const {
- const auto shown = [this](const rt::SettingDefinition& definition) { return rt::SettingShown(definition, kit_); };
+ using G = rt::SettingGroup;
const auto game = state_.navigation.selected_game_id;
std::vector<std::string> actions = {"preset-picker"};
- for (const auto& definition : rt::SettingsCatalogue())
- if (definition.tier == rt::SettingTier::kBasic && shown(definition)) actions.push_back("setting-" + definition.id);
- // Another store's game may use Steamworks: the Steam app ID its emulator is given.
- if (game.store == Store::kLocal) actions.push_back("steam-app-id");
- for (const auto& [section, tier] : {std::pair<const char*, rt::SettingTier>{"section-more", rt::SettingTier::kCompatibility},
- std::pair<const char*, rt::SettingTier>{"section-advanced", rt::SettingTier::kAdvanced}}) {
- actions.push_back(section);
- if (!expanded_settings_sections_.count(section)) continue;
- if (tier == rt::SettingTier::kCompatibility) actions.push_back("button-mapping");
+ const auto rows = [&](G group) {
for (const auto& definition : rt::SettingsCatalogue())
- if (definition.tier == tier && shown(definition) && (definition.id != "start_check" || known_problem(game)))
- actions.push_back("setting-" + definition.id);
- if (tier == rt::SettingTier::kAdvanced) actions.push_back("effective-command");
- if (tier == rt::SettingTier::kAdvanced) actions.push_back("export-recipe");
+ if (definition.group == group && game_settings_row_shown(definition, game)) actions.push_back("setting-" + definition.id);
+ };
+ // Rows by topic under headings that only label them; Compatibility and Advanced start collapsed.
+ actions.push_back("heading-game");
+ rows(G::kGame);
+ // Another store's game may use Steamworks: the Steam app ID its emulator is given.
+ if (game.store == Store::kLocal) {
+ const auto program = std::find(actions.begin(), actions.end(), "setting-launch_option");
+ actions.insert(program == actions.end() ? actions.end() : program + 1, "steam-app-id");
+ }
+ actions.push_back("heading-display");
+ rows(G::kDisplay);
+ actions.push_back("heading-controls");
+ rows(G::kControls);
+ actions.push_back("button-mapping");
+ actions.push_back("controller-tuning");
+ actions.push_back("heading-sound");
+ rows(G::kSound);
+ actions.push_back("section-compatibility");
+ if (expanded_settings_sections_.count("section-compatibility")) {
+ rows(G::kCompatibility);
+ actions.push_back("heading-graphics");
+ rows(G::kGraphics);
+ actions.push_back("heading-windows");
+ rows(G::kWindows);
+ }
+ actions.push_back("section-advanced");
+ if (expanded_settings_sections_.count("section-advanced")) {
+ rows(G::kAdvanced);
+ actions.push_back("effective-command");
+ actions.push_back("export-recipe");
}
actions.push_back("reset-settings");
actions.push_back("cancel");
return actions;
}
+// Whether the sheet lists a setting's row: Known problems only for a game that has one.
+bool Simulation::game_settings_row_shown(const rt::SettingDefinition& definition, GameId game) const {
+ return rt::SettingShown(definition, kit_) && (definition.id != "start_check" || known_problem(game));
+}
+
// Whether Game settings shows "Known problems": Playden refused the game for a reason a run
// could get past, the chosen program has one, or the player already chose to try anyway.
bool Simulation::known_problem(GameId id) const {
@@ -8662,6 +8730,34 @@ void Simulation::set_game_setting(const std::string& id, const std::string& valu
if (inherited) record.overrides.erase(id);
else record.overrides[id] = value;
++record.revision;
+ if (id == "refresh") follow_refresh_rate(game);
+}
+
+// Frame limit follows Refresh rate: a cap of 120 or 40 the player chose that the new rate can't pace goes back to Off,
+// and the toast says so, instead of a saved choice that no longer applies. Runs after every change to Refresh rate.
+void Simulation::follow_refresh_rate(GameId game) {
+ const auto found = state_.game_settings.find(game);
+ if (found == state_.game_settings.end()) return;
+ auto& record = found->second;
+ const auto limit = record.overrides.find("frame_limit");
+ if (limit == record.overrides.end() || (limit->second != "120" && limit->second != "40")) return;
+ rt::EffectiveSettings after;
+ rt::SettingsError error;
+ if (!rt::BuildEffectiveSettings(RecipeFor(game), preset_for(game), record.overrides, kit_for(game), &after, &error)) return;
+ if (rt::SettingChoiceUnavailable(after, "frame_limit", limit->second).empty()) return;
+ const auto cap = limit->second;
+ // Off is saved unless the game would have it anyway: a recipe or preset cap that only falls back to Off at 60 Hz
+ // would come back at 120 Hz.
+ auto overrides = record.overrides;
+ overrides.erase("frame_limit");
+ rt::EffectiveSettings base;
+ const bool inherited_off = rt::BuildEffectiveSettings(RecipeFor(game), preset_for(game), overrides, kit_for(game), &base, &error) &&
+ rt::ChosenValue(base.values.at("frame_limit")) == "off" && base.values.at("frame_limit").reason.empty();
+ if (inherited_off) record.overrides.erase("frame_limit");
+ else record.overrides["frame_limit"] = "off";
+ ++record.revision;
+ push_notice({"frame-limit-off", "Frame limit set to Off", "", false, kLiveNoticeSeconds, false,
+ "A cap of " + cap + " needs Refresh rate 120 Hz.", false});
}
// Player words for a preparation journal step; never the step's identifier.
diff --git a/src/homebrew/simulation.hpp b/src/homebrew/simulation.hpp
index 6279411..44cde9d 100644
--- a/src/homebrew/simulation.hpp
+++ b/src/homebrew/simulation.hpp
@@ -860,6 +860,8 @@ public:
[[nodiscard]] bool EffectiveSettingsFor(GameId id, playden::runtime::EffectiveSettings* settings) const;
// Whether Game settings lists "Known problems" (Try anyway) for a game.
[[nodiscard]] bool known_problem(GameId id) const;
+ void follow_refresh_rate(GameId game);
+ [[nodiscard]] bool game_settings_row_shown(const playden::runtime::SettingDefinition& definition, GameId game) const;
// The overrides a preset change or a reset keeps: the program choices (simulation.cpp).
[[nodiscard]] std::map<std::string, std::string> kept_start_choices(GameId id) const;
// Opens the picker, editor or "Change anyway" for one Game settings row.
diff --git a/src/homebrew/view.cpp b/src/homebrew/view.cpp
index 94c060d..d281f04 100644
--- a/src/homebrew/view.cpp
+++ b/src/homebrew/view.cpp
@@ -3432,7 +3432,7 @@ class Render::Impl
static std::string sheet_eyebrow(const std::string &surface)
{
static const std::map<std::string, std::string> names = {
- {"choice-picker", "Game settings"}, {"preset-picker", "Game settings"}, {"button-mapping", "Game settings"},
+ {"choice-picker", "Game settings"}, {"preset-picker", "Game settings"}, {"button-mapping", "Game settings"}, {"controller-tuning", "Game settings"},
{"game-settings", "Playden"}, {"game-maintenance", "Playden"}, {"kept-data", "Settings"}, {"installed-games", "Settings"},
{"import-games", "Library"}, {"import-programs", "Import games"}, {"steam-programs", "Setup"}, {"import-choice", "Import games"},
{"import-storage", "Import games"},
@@ -3478,7 +3478,8 @@ class Render::Impl
const bool wide = view.surface.find("settings") != std::string::npos ||
view.surface.find("profile") != std::string::npos ||
view.surface == "choice-picker" || view.surface == "preset-picker" ||
- view.surface == "button-mapping" || view.surface == "game-maintenance" ||
+ view.surface == "button-mapping" || view.surface == "controller-tuning" ||
+ view.surface == "game-maintenance" ||
view.surface == "controller" || view.surface == "logs" ||
view.surface == "storage" || view.surface == "install" || view.surface == "kept-data" ||
view.surface == "installed-games" || view.surface == "import-games" ||
@@ -3951,6 +3952,7 @@ class Render::Impl
{
const bool settings_sheet = view.surface == "game-settings" || view.surface == "choice-picker" ||
view.surface == "preset-picker" || view.surface == "button-mapping" ||
+ view.surface == "controller-tuning" ||
view.surface == "game-maintenance";
// The Import sheets: each folder's path (or why it can't be added) under its name.
const bool import_sheet = view.surface == "import-games" || view.surface == "import-programs" ||
diff --git a/src/runtime/game_settings.cpp b/src/runtime/game_settings.cpp
index 00bb5fe..a36c5c0 100644
--- a/src/runtime/game_settings.cpp
+++ b/src/runtime/game_settings.cpp
@@ -37,14 +37,14 @@ using platform::ManagedDirectory;
bool RetiredSetting(std::string_view id) { return id == "opengl_thread"; }
SettingDefinition Choice(std::string id, std::string label, std::string effect, std::string also_called,
- SettingTier tier, std::vector<SettingChoice> choices, std::string playden_default,
+ SettingGroup group, std::vector<SettingChoice> choices, std::string playden_default,
int phase = 1, ApplyMode apply = ApplyMode::kNextLaunch) {
SettingDefinition definition;
definition.id = std::move(id);
definition.label = std::move(label);
definition.effect = std::move(effect);
definition.also_called = std::move(also_called);
- definition.tier = tier;
+ definition.group = group;
definition.phase = phase;
definition.apply = apply;
definition.choices = std::move(choices);
@@ -53,74 +53,87 @@ SettingDefinition Choice(std::string id, std::string label, std::string effect,
}
SettingDefinition Text(std::string id, std::string label, std::string effect, std::string also_called,
- SettingTier tier) {
- auto definition = Choice(std::move(id), std::move(label), std::move(effect), std::move(also_called), tier, {}, "");
+ SettingGroup group) {
+ auto definition = Choice(std::move(id), std::move(label), std::move(effect), std::move(also_called), group, {}, "");
definition.kind = SettingKind::kText;
return definition;
}
std::vector<SettingDefinition> BuildCatalogue() {
- using T = SettingTier;
+ using G = SettingGroup;
std::vector<SettingDefinition> list;
- // Settings (T1).
+ // Game.
// A new program or folder applies like other settings: applying them switches the prepared
// title's program (RuntimeHost::RepublishSettings). The picker also lists the game folder's
// programs, which set "program".
list.push_back(Choice("launch_option", "Program", "Which program starts when you press Play.",
- "Steam launch option · [application] executable", T::kBasic, {}, "", 1));
+ "Steam launch option · [application] executable", G::kGame, {}, "", 1));
{
// Not a row of its own: the Program picker sets it to a program from the game folder.
auto program = Text("program", "Program file", "A program from the game folder instead of a launch option.",
- "[application] executable", T::kBasic);
+ "[application] executable", G::kGame);
list.push_back(std::move(program));
}
+ list.push_back(Text("extra_arguments", "Extra arguments", "Added after the arguments the game needs.",
+ "[application] arguments", G::kGame));
+ // Display.
list.push_back(Choice("resolution", "Resolution", "Size of the game's screen. Higher is sharper and slower.",
- "[display] desktop", T::kBasic,
+ "[display] desktop", G::kDisplay,
{{"1280x720", "1280×720", "Smoother frame rate in heavy scenes. Softer on a 4K TV."},
{"1920x1080", "1920×1080", "Full HD."},
{"2560x1440", "2560×1440", "Sharper image. May drop below 60 fps."},
{"3840x2160", "3840×2160", "The TV's own size. For light games; heavy ones run slowly."}},
"1920x1080"));
- list.push_back(Choice("controller", "Controller", "How the game sees your DualSense.", "[input] mode", T::kBasic,
- {{"xinput", "Xbox controller", "For games with controller support."},
- {"keyboard", "Keyboard and mouse mapping", "Buttons send keys and mouse clicks."}},
- "xinput"));
- list.push_back(Choice("controller_preset", "Controller preset", "Ready-made button layout for this kind of game.",
- "[input] preset", T::kBasic,
- {{"none", "None", "Only the buttons set here."},
- {"gamepad", "Gamepad", "Xbox controller layout; no stick moves the pointer."},
- {"mouse", "Mouse", "Left stick moves the pointer; Cross clicks, Circle right-clicks, Options Enter."},
- {"arrows", "Arrow keys", "D-pad sends the arrows; Cross Z, Circle X, Triangle C, Options Enter."}},
- "none"));
- list.push_back(Choice("volume", "Volume", "How loud this game plays, without changing the console's volume.",
- "[audio] volume", T::kBasic,
- {{"100", "100%", ""}, {"75", "75%", ""}, {"50", "50%", ""}, {"25", "25%", ""},
- {"0", "Muted", ""}},
- "100", 4));
- list.push_back(Choice("performance_overlay", "Performance overlay", "Frame rate in the corner of the screen.",
- "DXVK HUD · [display] show_fps", T::kBasic,
- {{"off", "Off", ""}, {"on", "On", "Shows frames per second."}}, "off"));
- list.push_back(Choice("overlay_detail", "Overlay detail", "What the performance overlay shows.", "dxvk.hud",
- T::kBasic,
- {{"fps", "Frame rate", ""},
- {"frametimes", "Frame rate and frame times", "Adds a graph of how long each frame took."},
- {"full", "Everything", "Also memory, GPU load and the DXVK version."}},
- "fps", 2));
- list.push_back(Text("extra_arguments", "Extra arguments", "Added after the arguments the game needs.",
- "[application] arguments", T::kBasic));
+ list.push_back(Choice("refresh", "Refresh rate",
+ "How often the TV shows a new frame. Some older games run too fast at 120 Hz: if so, set it "
+ "back to 60 Hz.",
+ "[display] refresh", G::kDisplay,
+ {{"60", "60 Hz", "The TV refreshes 60 times a second."},
+ {"120", "120 Hz", "Needs a TV with 120 Hz and the PS5's 120 Hz output on."}},
+ "60"));
// With a display-120hz runtime the display paces the cap ([display] frame_rate); otherwise DXVK does.
list.push_back(Choice("frame_limit", "Frame limit", "Caps the frame rate for steadier motion and less heat.",
- "[display] frame_rate · dxgi.maxFrameRate · d3d9.maxFrameRate", T::kBasic,
+ "[display] frame_rate · dxgi.maxFrameRate · d3d9.maxFrameRate", G::kDisplay,
{{"off", "Off", "No cap."}, {"120", "120", ""}, {"60", "60", ""}, {"40", "40", ""},
{"30", "30", ""}},
"off", 2));
list.push_back(Choice("vsync", "VSync", "Waits for the TV before showing a frame. Stops tearing, adds some delay.",
- "dxgi.syncInterval · d3d9.presentInterval", T::kBasic,
+ "dxgi.syncInterval · d3d9.presentInterval", G::kDisplay,
{{"game", "Game default", "The game's own setting."},
{"on", "On", ""},
{"off", "Off", ""}},
"game", 2));
- // More settings (T2).
+ list.push_back(Choice("performance_overlay", "Performance overlay", "Frame rate in the corner of the screen.",
+ "DXVK HUD · [display] show_fps", G::kDisplay,
+ {{"off", "Off", ""}, {"on", "On", "Shows frames per second."}}, "off"));
+ list.push_back(Choice("overlay_detail", "Overlay detail", "What the performance overlay shows.", "dxvk.hud",
+ G::kDisplay,
+ {{"fps", "Frame rate", ""},
+ {"frametimes", "Frame rate and frame times", "Adds a graph of how long each frame took."},
+ {"full", "Everything", "Also memory, GPU load and the DXVK version."}},
+ "fps", 2));
+ list.push_back(Choice("scaling", "Scaling", "How the game's screen fills the TV.", "[display] scaling",
+ G::kDisplay,
+ {{"fit", "Fit", "Keeps the shape; black bars if needed."},
+ {"integer", "Integer", "Whole-number steps; sharp pixels."},
+ {"stretch", "Stretch", "Fills the screen."}},
+ "fit"));
+ list.push_back(Choice("window_view", "Window view", "Show only game windows, or the whole Windows desktop.",
+ "[display] view", G::kDisplay,
+ {{"window", "Game windows", ""}, {"desktop", "Entire desktop", ""}}, "window"));
+ // Controls.
+ list.push_back(Choice("controller", "Controller", "How the game sees your DualSense.", "[input] mode", G::kControls,
+ {{"xinput", "Xbox controller", "For games with controller support."},
+ {"keyboard", "Keyboard and mouse mapping", "Buttons send keys and mouse clicks."}},
+ "xinput"));
+ list.push_back(Choice("controller_preset", "Controller preset", "Ready-made button layout for this kind of game.",
+ "[input] preset", G::kControls,
+ {{"none", "None", "Only the buttons set here."},
+ {"gamepad", "Gamepad", "Xbox controller layout; no stick moves the pointer."},
+ {"mouse", "Mouse", "Left stick moves the pointer; Cross clicks, Circle right-clicks, Options Enter."},
+ {"arrows", "Arrow keys", "D-pad sends the arrows; Cross Z, Circle X, Triangle C, Options Enter."}},
+ "none"));
+ // Controls › Button mapping.
static const std::map<std::string, std::string> button_names = {
{"cross", "Cross"}, {"circle", "Circle"}, {"square", "Square"}, {"triangle", "Triangle"},
{"l1", "L1"}, {"r1", "R1"}, {"l2", "L2"}, {"r2", "R2"},
@@ -129,67 +142,66 @@ std::vector<SettingDefinition> BuildCatalogue() {
{"touchpad", "Touchpad"}};
for (const auto& button : ProsperoButtons()) {
auto definition = Text("button." + button, button_names.at(button), "Key or mouse button this button sends.",
- "[input] " + button, T::kCompatibility);
+ "[input] " + button, G::kButtonMapping);
list.push_back(std::move(definition));
}
+ // Controls › Controller tuning.
list.push_back(Choice("pointer_stick", "Pointer stick", "Move the mouse pointer with a stick, for menus.",
- "[input] mouse", T::kCompatibility,
+ "[input] mouse", G::kControllerTuning,
{{"none", "None", ""}, {"left_stick", "Left stick", ""}, {"right_stick", "Right stick", ""}},
"none"));
list.push_back(Choice("pointer_speed", "Pointer speed", "How fast the pointer moves, in pixels per second.",
- "[input] mouse_speed", T::kCompatibility,
+ "[input] mouse_speed", G::kControllerTuning,
{{"600", "600", ""}, {"900", "900", ""}, {"1200", "1200", ""}, {"1800", "1800", ""},
{"2400", "2400", ""}},
"1200"));
list.push_back(Choice("stick_deadzone", "Stick dead zone",
"How far a stick moves before the game sees it. Raise it if the camera drifts.",
- "[input] stick_deadzone", T::kCompatibility,
+ "[input] stick_deadzone", G::kControllerTuning,
{{"0", "Off", "The game's own dead zone only."}, {"5", "5%", ""}, {"10", "10%", ""},
{"15", "15%", ""}, {"20", "20%", ""}, {"30", "30%", "For a badly drifting stick."}},
"0", 4));
list.push_back(Choice("rumble", "Rumble", "How strongly the controller vibrates.", "[input] rumble",
- T::kCompatibility,
+ G::kControllerTuning,
{{"100", "Full", ""}, {"75", "75%", ""}, {"50", "50%", ""}, {"25", "25%", ""},
{"0", "Off", ""}},
"100", 4));
list.push_back(Choice("invert_stick", "Invert stick", "Flip a stick's up and down for this game.",
- "[input] invert", T::kCompatibility,
+ "[input] invert", G::kControllerTuning,
{{"none", "None", ""}, {"left_y", "Left stick up/down", ""}, {"right_y", "Right stick up/down", ""}},
"none", 4));
list.push_back(Choice("trigger_deadzone", "Trigger dead zone",
"How far L2 and R2 travel before the game sees them. Raise it for worn triggers.",
- "[input] trigger_deadzone", T::kCompatibility,
+ "[input] trigger_deadzone", G::kControllerTuning,
{{"0", "Off", ""}, {"5", "5%", ""}, {"10", "10%", ""}, {"20", "20%", ""}, {"30", "30%", ""}},
"0", 4));
list.push_back(Choice("wheel_stick", "Mouse wheel stick", "Scroll the mouse wheel by pushing a stick up or down.",
- "[input] wheel", T::kCompatibility,
+ "[input] wheel", G::kControllerTuning,
{{"none", "None", ""}, {"left_stick", "Left stick", ""}, {"right_stick", "Right stick", ""}},
"none", 4));
- list.push_back(Choice("scaling", "Scaling", "How the game's screen fills the TV.", "[display] scaling",
- T::kCompatibility,
- {{"fit", "Fit", "Keeps the shape; black bars if needed."},
- {"integer", "Integer", "Whole-number steps; sharp pixels."},
- {"stretch", "Stretch", "Fills the screen."}},
- "fit"));
- list.push_back(Choice("window_view", "Window view", "Show only game windows, or the whole Windows desktop.",
- "[display] view", T::kCompatibility,
- {{"window", "Game windows", ""}, {"desktop", "Entire desktop", ""}}, "window"));
- list.push_back(Choice("refresh", "120 Hz output",
- "Sends up to 120 frames per second to a 120 Hz TV. Some older games run too fast at 120 Hz: "
- "if so, set it back to 60 Hz.",
- "[display] refresh", T::kCompatibility,
- {{"60", "60 Hz", "The TV refreshes 60 times a second."},
- {"120", "120 Hz", "Needs a TV with 120 Hz and the PS5's 120 Hz output on."}},
- "60"));
+ // Sound.
+ list.push_back(Choice("volume", "Volume", "How loud this game plays, without changing the console's volume.",
+ "[audio] volume", G::kSound,
+ {{"100", "100%", ""}, {"75", "75%", ""}, {"50", "50%", ""}, {"25", "25%", ""},
+ {"0", "Muted", ""}},
+ "100", 4));
+ // Compatibility.
+ // Shown only for a game whose program Playden refuses for a reason a run could get past.
+ list.push_back(Choice("start_check", "Known problems", "What Playden does with a problem it found in the game's program.",
+ ".NET · shared section", G::kCompatibility,
+ {{"stop", "Don't start", "Playden stops before a program it expects to fail."},
+ {"try", "Try anyway", "Prepares the game anyway. It may not start."}},
+ "stop", 1));
+ // Compatibility › Graphics.
// "OpenGL worker thread" ([display] opengl_thread) was the PS5 OpenGL SDK's; Zink has none, so the row is gone.
// Saved values for it are dropped when the record loads (RecordFromValue).
list.push_back(Choice("graphics", "Graphics", "How Direct3D is drawn on the PS5 GPU.", "[application] graphics",
- T::kCompatibility,
+ G::kGraphics,
{{"auto", "Automatic", ""}, {"gdi", "GDI", "2D only."}, {"dxvk", "DXVK", "Direct3D 9-11 on Vulkan."},
{"opengl", "OpenGL", ""}},
"auto"));
list.push_back(Choice("d3d12", "Direct3D 12", "What draws a Direct3D 12 game.", "d3d12.dll · d3d12core.dll",
- T::kCompatibility,
+ G::kGraphics,
{{"wine", "Wine", "Wine's own Direct3D 12."},
{"vkd3d-proton", "vkd3d-proton", "Direct3D 12 on Vulkan, as in Proton. Experimental."}},
"wine"));
@@ -197,91 +209,88 @@ std::vector<SettingDefinition> BuildCatalogue() {
// (Stray). Wave32 ran the same as wave64 in every game tested, so it is the default. A saved "auto" (the earlier
// Automatic choice) is dropped when the record loads (RecordFromValue).
list.push_back(Choice("pixel_shader_waves", "Pixel shaders",
- "How the GPU runs pixel shaders. Wave64 freezes the console in some games.",
- "RADV_PERFTEST=pswave32", T::kCompatibility,
- {{"wave32", "Wave32", "Stops GPU freezes in some games, such as Stray."},
- {"wave64", "Wave64", "May freeze the console in some games, such as Stray."}},
+ "How many pixels the GPU shades at once. Change it only if a game freezes or draws wrong.",
+ "RADV_PERFTEST=pswave32", G::kGraphics,
+ {{"wave32", "Wave32", "32 at a time. Works in every game tested so far."},
+ {"wave64", "Wave64",
+ "64 at a time, the older default. Freezes the console in some games: try it only if a game "
+ "draws wrong in Wave32."}},
"wave32"));
- list.push_back(Choice("steam_features", "Steam features", "How the game reaches Steam without the Steam client.",
- "steam_api.dll · steam_api64.dll", T::kCompatibility,
- {{"emulate", "Offline emulation", "Playden's Steam emulator answers the game."},
- {"game", "Game's own files", "The game's Steam library, unchanged."}},
- "game", 1, ApplyMode::kGameClosed));
list.push_back(Choice("frame_latency", "Frame latency", "How many frames can wait in the queue.",
- "dxgi.maxFrameLatency · d3d9.maxFrameLatency", T::kCompatibility,
+ "dxgi.maxFrameLatency · d3d9.maxFrameLatency", G::kGraphics,
{{"game", "Game default", ""}, {"1", "1", "Lowest delay."}, {"2", "2", ""}, {"3", "3", ""}},
"game", 2));
list.push_back(Choice("reported_gpu", "Reported graphics card", "Which GPU maker the game is told it runs on.",
- "dxgi.customVendorId", T::kCompatibility,
+ "dxgi.customVendorId", G::kGraphics,
{{"game", "DXVK default", ""}, {"amd", "AMD", ""}, {"nvidia", "NVIDIA", ""}, {"intel", "Intel", ""}},
"game", 2));
list.push_back(Choice("reported_vram", "Reported video memory", "How much VRAM the game is told it has. Does not add memory.",
- "dxgi.maxDeviceMemory · d3d9.maxAvailableMemory", T::kCompatibility,
+ "dxgi.maxDeviceMemory · d3d9.maxAvailableMemory", G::kGraphics,
{{"game", "DXVK default", ""}, {"2048", "2 GB", ""}, {"4096", "4 GB", ""}}, "game", 2));
+ // Compatibility › Windows.
+ list.push_back(Choice("steam_features", "Steam features", "How the game reaches Steam without the Steam client.",
+ "steam_api.dll · steam_api64.dll", G::kWindows,
+ {{"emulate", "Offline emulation", "Playden's Steam emulator answers the game."},
+ {"game", "Game's own files", "The game's Steam library, unchanged."}},
+ "game", 1, ApplyMode::kGameClosed));
list.push_back(Choice("windows_version", "Windows version", "Which Windows the game is told it runs on.",
- "winver · registry", T::kCompatibility,
+ "winver · registry", G::kWindows,
{{"win10", "Windows 10", ""}, {"win81", "Windows 8.1", ""}, {"win7", "Windows 7", ""},
{"winxp", "Windows XP", ""}},
"win10", 3, ApplyMode::kGameClosed));
list.push_back(Choice("text_scale", "Text scale", "Size of Windows text and dialogs. Shared by every game in the same bottle.",
- "LogPixels · DPI", T::kCompatibility,
+ "LogPixels · DPI", G::kWindows,
{{"96", "100%", ""}, {"120", "125%", ""}, {"144", "150%", ""}}, "96", 3, ApplyMode::kGameClosed));
list.push_back(Choice("locale", "Language and region", "Which Windows language and region the game sees.",
- "LocaleName · registry", T::kCompatibility,
+ "LocaleName · registry", G::kWindows,
{{"en-US", "English (United States)", ""}, {"en-GB", "English (United Kingdom)", ""},
{"de-DE", "German", ""}, {"fr-FR", "French", ""}, {"es-ES", "Spanish", ""},
{"pt-BR", "Portuguese (Brazil)", ""}, {"ja-JP", "Japanese", ""}},
"en-US", 3, ApplyMode::kGameClosed));
list.push_back(Choice("cpu_topology", "CPU cores", "How many processor cores the game is told about.",
- "WINE_CPU_TOPOLOGY", T::kCompatibility,
+ "WINE_CPU_TOPOLOGY", G::kWindows,
{{"kit", "Runtime default", ""}, {"4", "4 cores", "For games that fail with many cores."},
{"8", "8 cores", ""}},
"kit", 3, ApplyMode::kGameClosed));
- // Shown only for a game whose program Playden refuses for a reason a run could get past.
- list.push_back(Choice("start_check", "Known problems", "What Playden does with a problem it found in the game's program.",
- ".NET · shared section", T::kCompatibility,
- {{"stop", "Don't start", "Playden stops before a program it expects to fail."},
- {"try", "Try anyway", "Prepares the game anyway. It may not start."}},
- "stop", 1));
list.push_back(Choice("logging", "Logging", "How much detail goes into the game's log file.", "WINEDEBUG",
- T::kCompatibility,
+ G::kWindows,
{{"normal", "Normal", "Errors and loaded modules."},
{"verbose", "Verbose", "Also warnings and exceptions, for one session; then Normal again."},
{"input", "Input", "Also keyboard, mouse and controller calls, for one session; then Normal again."}},
"normal"));
- // Advanced (T3).
+ // Advanced.
{
auto environment = Text("environment", "Environment variables",
"Extra variables for the game, separated by ';', like WINE_CPU_TOPOLOGY=4:0,1,2,3.",
- "[environment]", T::kAdvanced);
+ "[environment]", G::kAdvanced);
environment.phase = 2;
list.push_back(std::move(environment));
}
{
auto folder = Text("program_folder", "Program folder",
"Folder the program starts in, inside the game folder; . is the game folder itself. Empty: the program's own folder.",
- "[application] working_directory", T::kAdvanced);
+ "[application] working_directory", G::kAdvanced);
list.push_back(std::move(folder));
}
list.push_back(Text("program_arguments", "Program arguments", "The program's own arguments, as Steam lists them.",
- "launch option arguments", T::kAdvanced));
+ "launch option arguments", G::kAdvanced));
list.push_back(Text("arguments", "Required arguments",
"Arguments the game needs, from its recipe. {resolution} adds the Resolution size.",
- "[application] arguments", T::kAdvanced));
+ "[application] arguments", G::kAdvanced));
list.push_back(Choice("architecture", "Program type", "Follows the program: 32-bit or 64-bit Windows.",
- "[application] architecture", T::kAdvanced,
+ "[application] architecture", G::kAdvanced,
{{"pe32", "32-bit", ""}, {"pe64", "64-bit", ""}}, "pe32"));
list.push_back(Text("dll_overrides", "Library overrides",
"Windows libraries the game loads from its own copy, from the recipe, DXVK and you.",
- "WINEDLLOVERRIDES · [application] dll_overrides", T::kAdvanced));
+ "WINEDLLOVERRIDES · [application] dll_overrides", G::kAdvanced));
// Earlier builds kept only the player's additions here. Still read, never shown: the full
// list above starts from them, and changing it replaces them.
list.push_back(Text("library_overrides", "Added library overrides", "Library overrides added after the recipe's.",
- "[application] dll_overrides", T::kAdvanced));
+ "[application] dll_overrides", G::kAdvanced));
{
auto registry = Text("registry_dll_overrides", "Library load order in the registry",
"Library overrides kept in the game's Windows registry, like name=n,b.",
- "HKCU\\Software\\Wine\\DllOverrides", T::kAdvanced);
+ "HKCU\\Software\\Wine\\DllOverrides", G::kAdvanced);
registry.phase = 3;
registry.apply = ApplyMode::kGameClosed;
list.push_back(std::move(registry));
@@ -584,9 +593,9 @@ std::string SettingChoiceUnavailable(const EffectiveSettings& settings, std::str
const bool at_120 = refresh != settings.values.end() &&
(refresh->second.available || refresh->second.waits_for_update) &&
ChosenValue(refresh->second) == "120";
- if (high && !at_120) return "Only with 120 Hz output.";
+ if (high && !at_120) return "Only with Refresh rate 120 Hz.";
// 30 at 120 Hz takes four vblanks per frame, which the display cannot pace; DXVK's and vkd3d-proton's limiters can.
- if (value == "30" && at_120 && settings.graphics != "dxvk") return "At 120 Hz output, only with DXVK.";
+ if (value == "30" && at_120 && settings.graphics != "dxvk") return "At 120 Hz, only with DXVK.";
return {};
}
diff --git a/src/runtime/game_settings.h b/src/runtime/game_settings.h
index 8c2a6d8..0e41f42 100644
--- a/src/runtime/game_settings.h
+++ b/src/runtime/game_settings.h
@@ -27,7 +27,20 @@ namespace playden::runtime {
// A recipe only supplies starting values: the program, its folder and arguments, the
// arguments the game needs and the library overrides each have a row the player can change.
-enum class SettingTier { kBasic, kCompatibility, kAdvanced };
+// Where the Game settings sheet lists a setting, in sheet order. Button mapping and Controller tuning are submenus of
+// Controls; Compatibility (with its Graphics and Windows parts) and Advanced start collapsed.
+enum class SettingGroup {
+ kGame,
+ kDisplay,
+ kControls,
+ kButtonMapping,
+ kControllerTuning,
+ kSound,
+ kCompatibility,
+ kGraphics,
+ kWindows,
+ kAdvanced,
+};
enum class ApplyMode { kNextLaunch, kGameClosed, kPreparesBottle };
enum class SettingKind { kChoice, kText };
enum class ValueSource { kPlayden, kRecipe, kPreset, kUser };
@@ -69,7 +82,7 @@ struct SettingDefinition {
std::string label;
std::string effect; // one-line description under the name
std::string also_called; // technical names: profile keys, DXVK options
- SettingTier tier = SettingTier::kBasic;
+ SettingGroup group = SettingGroup::kGame;
int phase = 1; // roadmap phase that ships it
ApplyMode apply = ApplyMode::kNextLaunch;
SettingKind kind = SettingKind::kChoice;
diff --git a/tests/game_settings_test.cpp b/tests/game_settings_test.cpp
index 9f66e5f..8938bb8 100644
--- a/tests/game_settings_test.cpp
+++ b/tests/game_settings_test.cpp
@@ -69,6 +69,31 @@ int main(int argc, char** argv) {
if (preset.id == "mouse-driven") mouse = &preset;
CHECK(mouse);
+ // The sheet lists rows in catalogue order, grouped by topic: each group in one run, in SettingGroup order.
+ {
+ std::vector<std::string> ids;
+ for (const auto& definition : SettingsCatalogue())
+ if (definition.group != SettingGroup::kButtonMapping) ids.push_back(definition.id);
+ const std::vector<std::string> expected = {
+ "launch_option", "program", "extra_arguments",
+ "resolution", "refresh", "frame_limit", "vsync", "performance_overlay", "overlay_detail", "scaling",
+ "window_view",
+ "controller", "controller_preset",
+ "pointer_stick", "pointer_speed", "stick_deadzone", "rumble", "invert_stick", "trigger_deadzone", "wheel_stick",
+ "volume",
+ "start_check",
+ "graphics", "d3d12", "pixel_shader_waves", "frame_latency", "reported_gpu", "reported_vram",
+ "steam_features", "windows_version", "text_scale", "locale", "cpu_topology", "logging",
+ "environment", "program_folder", "program_arguments", "arguments", "architecture", "dll_overrides",
+ "library_overrides", "registry_dll_overrides"};
+ CHECK(ids == expected);
+ for (std::size_t index = 1; index < SettingsCatalogue().size(); ++index)
+ CHECK(SettingsCatalogue()[index - 1].group <= SettingsCatalogue()[index].group);
+ CHECK(FindSetting("refresh")->group == SettingGroup::kDisplay &&
+ FindSetting("button.cross")->group == SettingGroup::kButtonMapping &&
+ FindSetting("rumble")->group == SettingGroup::kControllerTuning);
+ }
+
// Every catalogue choice default is one of its own choices.
for (const auto& definition : SettingsCatalogue()) {
if (definition.kind != SettingKind::kChoice || definition.choices.empty()) continue;
@@ -311,8 +336,8 @@ int main(int argc, char** argv) {
CHECK(profile.text.find(std::string("\nframe_rate = ") + rate + "\n") != std::string::npos);
// At 60 Hz they fall back to Off, and the row says why.
CHECK(BuildEffectiveSettings(hl2, nullptr, {{"frame_limit", rate}}, display, &shown, &error));
- CHECK(Value(shown, "frame_limit") == "off" && shown.values.at("frame_limit").reason == "Only with 120 Hz output.");
- CHECK(SettingChoiceUnavailable(shown, "frame_limit", rate) == "Only with 120 Hz output.");
+ CHECK(Value(shown, "frame_limit") == "off" && shown.values.at("frame_limit").reason == "Only with Refresh rate 120 Hz.");
+ CHECK(SettingChoiceUnavailable(shown, "frame_limit", rate) == "Only with Refresh rate 120 Hz.");
CHECK(RenderProsperoProfile(hl2, shown, target, &profile, &reason));
CHECK(profile.text.find("\nrefresh = 60\n") != std::string::npos && profile.text.find("frame_rate") == std::string::npos);
}
@@ -336,7 +361,7 @@ int main(int argc, char** argv) {
CHECK(!frame_rate_env); // not a vkd3d-proton game
// OpenGL has no software limiter: 30 at 120 Hz falls back to Off.
CHECK(BuildEffectiveSettings(opengl, nullptr, {{"refresh", "120"}, {"frame_limit", "30"}}, display, &shown, &error));
- CHECK(Value(shown, "frame_limit") == "off" && shown.values.at("frame_limit").reason == "At 120 Hz output, only with DXVK.");
+ CHECK(Value(shown, "frame_limit") == "off" && shown.values.at("frame_limit").reason == "At 120 Hz, only with DXVK.");
CHECK(BuildEffectiveSettings(opengl, nullptr, {{"refresh", "120"}, {"frame_limit", "40"}}, display, &shown, &error));
CHECK(RenderProsperoProfile(opengl, shown, target, &profile, &reason));
CHECK(profile.text.find("\nrefresh = 120\nframe_rate = 40\n") != std::string::npos);
@@ -410,9 +435,9 @@ int main(int argc, char** argv) {
CHECK(RenderDxvkConfig(shown).find("\ndxgi.maxFrameRate = 60\nd3d9.maxFrameRate = 60\n") != std::string::npos);
// 120 and 40 need 120 Hz output, chosen or not; with it they wait for Update and nothing caps the game until then.
CHECK(BuildEffectiveSettings(hl2, nullptr, {{"frame_limit", "40"}}, stale, &shown, &error));
- CHECK(Value(shown, "frame_limit") == "off" && shown.values.at("frame_limit").reason == "Only with 120 Hz output.");
+ CHECK(Value(shown, "frame_limit") == "off" && shown.values.at("frame_limit").reason == "Only with Refresh rate 120 Hz.");
CHECK(shown.values.at("frame_limit").after_update.empty());
- CHECK(SettingChoiceUnavailable(shown, "frame_limit", "120") == "Only with 120 Hz output.");
+ CHECK(SettingChoiceUnavailable(shown, "frame_limit", "120") == "Only with Refresh rate 120 Hz.");
CHECK(RenderDxvkConfig(shown).find("maxFrameRate") == std::string::npos);
for (const char* limit : {"120", "40"}) {
CHECK(BuildEffectiveSettings(hl2, nullptr, {{"refresh", "120"}, {"frame_limit", limit}}, stale, &shown, &error));
@@ -443,14 +468,14 @@ int main(int argc, char** argv) {
const auto& row = shown.values.at("frame_limit");
CHECK(!row.available && row.waits_for_update && row.reason == kAppliesAfterKitUpdate && row.after_update == "60");
CHECK(SettingChoiceWaitsForUpdate(shown, "frame_limit", "60"));
- CHECK(SettingChoiceUnavailable(shown, "frame_limit", "30") == "At 120 Hz output, only with DXVK.");
+ CHECK(SettingChoiceUnavailable(shown, "frame_limit", "30") == "At 120 Hz, only with DXVK.");
}
CHECK(RenderProsperoProfile(opengl, shown, target, &profile, &reason));
CHECK(profile.text.find("frame_rate") == std::string::npos && profile.text.find("\nrefresh = 60\n") != std::string::npos);
// A saved choice the kit's runtime would not take either is dropped with its reason.
CHECK(BuildEffectiveSettings(opengl, nullptr, {{"refresh", "120"}, {"frame_limit", "30"}}, stale, &shown, &error));
CHECK(shown.values.at("frame_limit").after_update.empty() &&
- shown.values.at("frame_limit").reason == "At 120 Hz output, only with DXVK.");
+ shown.values.at("frame_limit").reason == "At 120 Hz, only with DXVK.");
CHECK(BuildEffectiveSettings(d3d12, nullptr, {{"refresh", "120"}, {"frame_limit", "30"}}, stale, &shown, &error));
for (const auto& value : RenderBottleEnvironment(shown))
CHECK(value.name != "VKD3D_FRAME_RATE" || value.data.empty());
@@ -582,7 +607,7 @@ int main(int argc, char** argv) {
return found;
};
CHECK(FindSetting("pixel_shader_waves") && FindSetting("pixel_shader_waves")->playden_default == "wave32" &&
- FindSetting("pixel_shader_waves")->tier == SettingTier::kCompatibility);
+ FindSetting("pixel_shader_waves")->group == SettingGroup::kGraphics);
CHECK(!ValidateSettingValue(hl2, "pixel_shader_waves", "wave16", &reason));
CHECK(!ValidateSettingValue(hl2, "pixel_shader_waves", "auto", &reason));
// Every game runs wave32 by default; the profile ends in its [environment] section.
diff --git a/tests/homebrew_installed_locations_test.cpp b/tests/homebrew_installed_locations_test.cpp
index 5b9a424..806fa5b 100644
--- a/tests/homebrew_installed_locations_test.cpp
+++ b/tests/homebrew_installed_locations_test.cpp
@@ -915,7 +915,7 @@ void ImportedGamePlaysInPlace() {
open_details(model, game);
CHECK(model.action("focus:details-more") && model.action("cross"));
CHECK(model.action("focus:game-settings") && model.action("cross"));
- CHECK(model.action("focus:section-more") && model.action("cross"));
+ CHECK(model.action("focus:section-compatibility") && model.action("cross"));
// Sky's recipe leaves Graphics automatic; 120 Hz output is for DXVK and OpenGL.
tick_until([&] { const auto* row = row_of(model, "setting-graphics"); return row && row->enabled; });
CHECK(model.action("focus:setting-graphics") && model.action("cross"));
diff --git a/tests/homebrew_live_model_test.cpp b/tests/homebrew_live_model_test.cpp
index 18a4c6b..5af4a62 100644
--- a/tests/homebrew_live_model_test.cpp
+++ b/tests/homebrew_live_model_test.cpp
@@ -246,7 +246,6 @@ void live_120hz_waits_for_the_title_update(const std::filesystem::path& base) {
check(model.action("details:220"), "open the display game's details");
activate(model, "details-more");
activate(model, "game-settings");
- activate(model, "section-more");
const std::string after_update = playden::runtime::kAppliesAfterKitUpdate;
const auto says_after_update = [&](const char* key) {
const auto* row = find_row(model, key);
@@ -256,7 +255,7 @@ void live_120hz_waits_for_the_title_update(const std::filesystem::path& base) {
"120 Hz output can be chosen before the title's update and says when it applies");
activate(model, "setting-frame_limit");
const auto* limit_120 = find_row(model, "choice-1");
- check(limit_120 && limit_120->title == "120" && !limit_120->enabled && limit_120->subtitle == "Only with 120 Hz output.",
+ check(limit_120 && limit_120->title == "120" && !limit_120->enabled && limit_120->subtitle == "Only with Refresh rate 120 Hz.",
"Frame limit 120 needs 120 Hz output first");
check(find_row(model, "choice-2") && find_row(model, "choice-2")->enabled, "Frame limit 60 stays available");
check(model.action("circle"), "close the Frame limit picker");
@@ -299,6 +298,37 @@ void live_120hz_waits_for_the_title_update(const std::filesystem::path& base) {
check(find_row(model, "choice-1")->enabled && find_row(model, "choice-1")->subtitle.empty(), "Frame limit 120 applies now");
check(model.action("circle"), "close the Frame limit picker on the updated title");
+ // Frame limit follows Refresh rate: back at 60 Hz, a cap of 120 goes to Off and the toast says so; 60 stays.
+ activate(model, "setting-refresh");
+ activate(model, "choice-0");
+ const auto& after_60 = model.state().game_settings.at(SteamId(220)).overrides;
+ check(!after_60.count("refresh") && !after_60.count("frame_limit") &&
+ find_row(model, "setting-frame_limit")->value == "Off",
+ "Refresh rate 60 Hz sets a cap of 120 back to Off");
+ const auto toast = std::find_if(model.state().notices.begin(), model.state().notices.end(),
+ [](const playden::homebrew::Notice& notice) { return notice.id == "frame-limit-off"; });
+ check(toast != model.state().notices.end() && toast->message == "Frame limit set to Off" &&
+ toast->detail == "A cap of 120 needs Refresh rate 120 Hz.",
+ "the toast says why the cap went to Off");
+ activate(model, "setting-refresh");
+ activate(model, "choice-1");
+ activate(model, "setting-frame_limit");
+ activate(model, "choice-2");
+ activate(model, "setting-refresh");
+ activate(model, "choice-0");
+ check(model.state().game_settings.at(SteamId(220)).overrides.count("frame_limit") &&
+ model.state().game_settings.at(SteamId(220)).overrides.at("frame_limit") == "60",
+ "a cap of 60 stays at 60 Hz");
+ // Triangle on Refresh rate takes 120 Hz back, and a cap of 40 with it.
+ activate(model, "setting-refresh");
+ activate(model, "choice-1");
+ activate(model, "setting-frame_limit");
+ activate(model, "choice-3");
+ check(model.action("focus:setting-refresh") && model.action("triangle"), "reset Refresh rate with Triangle");
+ check(!model.state().game_settings.at(SteamId(220)).overrides.count("refresh") &&
+ !model.state().game_settings.at(SteamId(220)).overrides.count("frame_limit"),
+ "resetting Refresh rate sets a cap of 40 back to Off");
+
// Reset takes the waiting choices back.
runtime.status = "Kit update available";
runtime.ready = false;
@@ -310,6 +340,43 @@ void live_120hz_waits_for_the_title_update(const std::filesystem::path& base) {
"after Reset the rows show the preset's values");
}
+// A preset's cap of 120 falls back to Off at 60 Hz without being Off: a player's 40 set back by Refresh rate 60 Hz is
+// saved as Off, so 120 Hz later does not bring the preset's cap back.
+void live_refresh_rate_keeps_off_over_a_preset_cap(const std::filesystem::path& base) {
+ std::filesystem::create_directories(base);
+ auto model = make_live(base);
+ model.SetGameSettingsFile(base / "capped-settings.json");
+ model.SetSettingsData({{"playden-default", "Playden default", "Most games", "", {{"refresh", "120"}, {"frame_limit", "120"}}}}, {});
+ model.SetKitCapabilities(playden::runtime::KitCapabilitiesFromManifest({"dxvk", "display-120hz"}, true));
+ model.UpdateAccount({AuthState::SignedIn, "account", "Owner", {}, {}, false});
+ playden::GameSummary game;
+ game.id = SteamId(220);
+ game.title = "Half-Life 2";
+ check(model.UpdateLibrary({{game}, false, {}, false, true, 100}), "capped game library delivered");
+ model.UpdateInstalls({}, {{SteamId(220), 1024, "internal", true}});
+ playden::homebrew::LiveRuntimeGame runtime;
+ runtime.game_id = SteamId(220);
+ runtime.status = "Ready";
+ runtime.prepared = runtime.has_title = runtime.ready = runtime.runtime_current = true;
+ runtime.launch_entry_id = "game";
+ runtime.activity = playden::homebrew::TitleActivity::Stopped;
+ model.UpdateRuntime(playden::homebrew::RuntimeState::Ready, {runtime});
+ check(model.action("details:220"), "open the capped game's details");
+ activate(model, "details-more");
+ activate(model, "game-settings");
+ check(find_row(model, "setting-frame_limit")->value == "120", "the preset caps the game at 120");
+ activate(model, "setting-frame_limit");
+ activate(model, "choice-3");
+ activate(model, "setting-refresh");
+ activate(model, "choice-0");
+ const auto& overrides = model.state().game_settings.at(SteamId(220)).overrides;
+ check(overrides.count("frame_limit") && overrides.at("frame_limit") == "off",
+ "a cap set back over the preset's 120 is saved as Off");
+ activate(model, "setting-refresh");
+ activate(model, "choice-1");
+ check(find_row(model, "setting-frame_limit")->value == "Off", "120 Hz again keeps Off, not the preset's 120");
+}
+
// Maintenance › Update runtime runs the update Play does first for a title on an older kit's runtime, without
// starting the game: only while the title waits for it and the game is closed.
void live_update_runtime_from_maintenance(const std::filesystem::path& base) {
@@ -460,7 +527,7 @@ void live_settings_follow_the_prepared_title(const std::filesystem::path& base)
activate(model, "game-settings");
check(model.TakeActivityRequests() == std::vector<playden::homebrew::GameId>{SteamId(220)}, "the sheet asks whether the game runs");
- activate(model, "section-more");
+ activate(model, "section-compatibility");
const auto* version = find_row(model, "setting-windows_version");
check(version && !version->enabled && version->subtitle == "Checking whether Half-Life 2 is running…",
"game-closed rows wait for the console's answer");
@@ -1147,6 +1214,7 @@ int main() {
settings_survive_account_restore_and_cache_action_is_honest(base);
live_settings_follow_the_prepared_title(base);
live_120hz_waits_for_the_title_update(base / "display");
+ live_refresh_rate_keeps_off_over_a_preset_cap(base / "capped");
live_update_runtime_from_maintenance(base / "update-runtime");
live_program_change_applies_like_other_settings(base);
live_imported_game_steam_app_id(base);
diff --git a/tests/homebrew_simulation_test.cpp b/tests/homebrew_simulation_test.cpp
index 75bd0a2..db5f522 100644
--- a/tests/homebrew_simulation_test.cpp
+++ b/tests/homebrew_simulation_test.cpp
@@ -372,10 +372,36 @@ void t08b_settings_sheet_rules(const std::filesystem::path& fixtures, const std:
simulation.action("details:900001");
activate(simulation, "details-more");
activate(simulation, "game-settings");
- // More settings expands inline; graphics is locked by the recipe and scaling is
+ // Rows by topic: the frame-rate rows sit together in Display, and focus steps over the headings.
+ const auto& keys = simulation.state().navigation.modals.back().action_keys;
+ const std::vector<std::string> top(keys.begin(), keys.begin() + std::min<std::size_t>(keys.size(), 22));
+ check(top == std::vector<std::string>{"preset-picker", "heading-game", "setting-launch_option", "setting-extra_arguments",
+ "heading-display", "setting-resolution", "setting-refresh", "setting-frame_limit",
+ "setting-vsync", "setting-performance_overlay", "setting-overlay_detail",
+ "setting-scaling", "setting-window_view", "heading-controls", "setting-controller",
+ "setting-controller_preset", "button-mapping", "controller-tuning", "heading-sound",
+ "setting-volume", "section-compatibility", "section-advanced"},
+ "T08b the sheet groups rows by topic");
+ check(find_row(simulation, "heading-display") && find_row(simulation, "heading-display")->title == "Display" &&
+ !find_row(simulation, "heading-display")->enabled,
+ "T08b topic headings only label rows");
+ check(find_row(simulation, "setting-refresh") && find_row(simulation, "setting-refresh")->title == "Refresh rate",
+ "T08b Refresh rate is listed without a 120 Hz kit");
+ simulation.action("focus:setting-resolution");
+ simulation.action("down");
+ check(simulation.state().navigation.focus_key == "setting-refresh", "T08b Refresh rate follows Resolution");
+ simulation.action("down");
+ check(simulation.state().navigation.focus_key == "setting-frame_limit", "T08b Frame limit follows Refresh rate");
+ simulation.action("focus:setting-window_view");
+ simulation.action("down");
+ check(simulation.state().navigation.focus_key == "setting-controller", "T08b Down steps over a heading");
+ simulation.action("focus:setting-launch_option");
+ simulation.action("up");
+ check(simulation.state().navigation.focus_key == "preset-picker", "T08b Up steps over a heading");
+ // Compatibility expands inline; graphics is locked by the recipe and scaling is
// disabled on DXVK with its reason.
- check(!find_row(simulation, "setting-graphics"), "T08b More settings starts collapsed");
- activate(simulation, "section-more");
+ check(!find_row(simulation, "setting-graphics"), "T08b Compatibility starts collapsed");
+ activate(simulation, "section-compatibility");
const auto* graphics = find_row(simulation, "setting-graphics");
check(graphics && graphics->enabled && graphics->badge == "Required by this game", "T08b graphics is locked by the recipe");
const auto* scaling = find_row(simulation, "setting-scaling");
@@ -403,9 +429,19 @@ void t08b_settings_sheet_rules(const std::filesystem::path& fixtures, const std:
check(rt::RenderProsperoProfile(simulation.RecipeFor(SteamId(900001)), settings, {"playden-steam-900001", "/data/playden/games/900001"},
&generated, &reason), "T08b sheet settings render a valid prospero profile");
// Reset all returns to the preset.
+ // Controller tuning is a submenu of Controls; its row counts the changed rows in it.
+ check(find_row(simulation, "controller-tuning") && find_row(simulation, "controller-tuning")->value == "Default" &&
+ !find_row(simulation, "setting-pointer_speed"),
+ "T08b controller tuning rows live in their submenu");
+ activate(simulation, "controller-tuning");
+ check(simulation.state().navigation.modals.back().id == "controller-tuning", "T08b controller tuning opens");
activate(simulation, "setting-pointer_speed");
activate(simulation, "choice-4");
check(!simulation.state().game_settings.at(SteamId(900001)).overrides.empty(), "T08b override recorded");
+ check(simulation.state().navigation.modals.back().id == "controller-tuning", "T08b a choice returns to controller tuning");
+ simulation.action("circle");
+ check(find_row(simulation, "controller-tuning") && find_row(simulation, "controller-tuning")->value == "1 changed",
+ "T08b controller tuning counts its changes");
activate(simulation, "reset-settings");
check(simulation.state().game_settings.at(SteamId(900001)).overrides.empty(), "T08b reset all clears overrides");
simulation.action("circle");
@@ -423,7 +459,6 @@ void t08b_settings_sheet_rules(const std::filesystem::path& fixtures, const std:
check(find_row(simulation, "setting-frame_limit") && find_row(simulation, "setting-frame_limit")->enabled,
"T08b frame limit appears once the kit supports it");
// Button mapping: inherit shows the recipe binding; a common key and a typed key save.
- activate(simulation, "section-more");
activate(simulation, "button-mapping");
check(find_row(simulation, "setting-button.options")->value == "Escape", "T08b recipe binding shows");
activate(simulation, "setting-button.touchpad");
@@ -864,7 +899,7 @@ void t52_recipe_values_in_game_settings(const std::filesystem::path& fixtures, c
activate(simulation, "setting-launch_option");
activate(simulation, "program-1");
check(overrides().at("start_check") == "try", "T52 a soft-refused program tries anyway");
- activate(simulation, "section-more");
+ activate(simulation, "section-compatibility");
const auto* problems = find_row(simulation, "setting-start_check");
check(problems && problems->value == "Try anyway" && problems->subtitle.find(".NET") != std::string::npos,
"T52 Known problems shows the refusal");