DieMitchell/ReSkate
1
0 Fork 0
mirror of https://github.com/Dingo-Shenanigans/ReSkate.git synced 2026-10-25 20:14:43 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
e88debeaf7697a020a0f623fa278244928923400
ReSkate/Extension/Trainer/trainer_page.cpp
T

995 lines
60 KiB
C++
Raw Blame History

#include "trainer_page.h"
#include "trainer.h"
#include "Extension/UI/Overlay/skate_menu_internal.h"
#include "Extension/UI/skate_theme.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <format>
#include <string>
#include <vector>
// The TRAINER page and the skating HUD. Presentation thread: reads the trainer's snapshots
// and queues `trainer ...` console commands; it never touches the game.
namespace dingosdk::overlay::menu {
namespace {
struct Page {
int tab{}; // opens on TUNE: the dials and switches
std::array<char, 96> search{};
int mode{1}; // the Tune tab: 0 Realistic, 1 Fun (two short lists), 2 Everything
int group{1}; // Everything: 1: every group, 2..: one of the view's groups
bool only_changed{}, graph_points{}, show_unused{};
std::size_t hidden_unused{}; // rows the filters would show but for "no use found"
// The rows the filters leave, rebuilt when the snapshot or a filter changes.
std::vector<std::size_t> shown;
std::uint64_t shown_revision{};
std::string shown_key;
// The value under the pointer while it is dragged: the snapshot lags a frame or two.
std::string active;
double active_value{};
std::array<char, 49> preset_name{};
std::array<float, 3> teleport{};
double speed_edit{-1}, speed_until{};
float hippy_edit{1}, nocomply_edit{1}, boneless_edit{1}, offboard_edit{1}, flip_edit{1};
float revert_edit{};
bool revert_editing{};
// The Trick lines tab: rows of the value table per group, for one snapshot.
std::array<std::vector<std::size_t>, 5> trick_rows;
std::uint64_t trick_revision{~0ull};
bool hippy_editing{}, nocomply_editing{}, boneless_editing{}, offboard_editing{}, flip_editing{};
std::uint64_t open_serial{}; // the last `trainer open` acted on
std::uint64_t share_serial{}; // the last `preset export` put on the clipboard
bool share_seen{};
bool show_page{};
};
void trick_heights(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::View &view, const std::string &words);
void feel_buttons(SkateMenu &menu, const CallbacksV3 &callbacks, const trainer::View &view);
void trickline_section(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::View &view);
Page &page() {
static auto *value = new Page;
return *value;
}
std::string lower(std::string_view text) {
std::string result(text);
std::ranges::transform(result, result.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
return result;
}
bool contains_words(const std::string &haystack, const std::string &words) {
std::size_t start = 0;
while (start < words.size()) {
auto end = words.find(' ', start);
if (end == std::string::npos) end = words.size();
if (end > start && haystack.find(words.substr(start, end - start)) == std::string::npos) return false;
start = end + 1;
}
return true;
}
std::string number(double value) { return std::format("{:.6g}", value); }
void trainer_command(SkateMenu &menu, const CallbacksV3 &callbacks, const std::string &text) {
send_console(menu, callbacks, "trainer " + text);
}
void filter_rows(Page &p, const trainer::View &view) {
const auto words = lower(p.search.data());
const auto key = std::format("{}|{}|{}|{}|{}|{}", words, p.group, p.only_changed, p.graph_points, p.show_unused, p.mode);
if (p.shown_revision == view.revision && p.shown_key == key) return;
p.shown_revision = view.revision;
p.shown_key = key;
p.shown.clear();
p.hidden_unused = 0;
const std::string *group = p.mode == 2 && p.group > 1 && static_cast<std::size_t>(p.group) <= view.groups.size() + 1
? &view.groups[static_cast<std::size_t>(p.group) - 2] : nullptr;
const bool essentials = p.mode < 2 && words.empty(); // searching looks through every value, whatever the list
const std::uint8_t list = p.mode == 0 ? trainer::mode_realistic : trainer::mode_fun;
for (std::size_t i = 0; i < view.rows.size(); ++i) {
const auto &row = view.rows[i];
if (essentials) {
// Only what the game was found or seen to read: a short list has no room for maybes.
if (!row.friendly.empty() && (row.modes & list) && (row.used || (row.modes & trainer::mode_trial))) p.shown.push_back(i);
continue;
}
if (row.detail && !p.graph_points && !row.touched) continue;
if (p.only_changed && !row.touched && !row.frozen) continue;
// Searching looks through every group.
if (words.empty() ? (group && row.group != *group) : !contains_words(lower(row.id + " " + row.label + " " + row.friendly), words))
continue;
// A value nothing in the game reads would be a slider that does nothing.
if (!row.used && !p.show_unused && !row.touched && !row.frozen) {
++p.hidden_unused;
continue;
}
p.shown.push_back(i);
}
if (essentials) std::ranges::sort(p.shown, {}, [&](std::size_t i) { return view.rows[i].rank; });
}
void value_row(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::View &view, const trainer::Row &row,
bool with_group, bool friendly) {
ImGui::PushID(row.id.c_str());
bool frozen = row.frozen;
if (ImGui::Checkbox("##freeze", &frozen)) trainer_command(menu, callbacks, std::format("freeze {} {}", row.id, frozen ? 1 : 0));
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Lock: presets and Reset values leave this value alone.\nReset everything (top of the page) clears locks too.\nYou do not need it for a change to apply.");
ImGui::SameLine();
const float column = ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x * 0.52f;
const auto label = friendly && !row.friendly.empty() ? row.friendly : with_group ? row.group + " / " + row.label : row.label;
const bool tinted = row.touched || !row.used;
if (tinted) ImGui::PushStyleColor(ImGuiCol_Text, row.used ? skate_theme::blue : IM_COL32(150, 150, 150, 255));
ImGui::AlignTextToFramePadding();
ImGui::TextUnformatted(row.used ? label.c_str() : (label + " (no use found)").c_str());
if (tinted) ImGui::PopStyleColor();
if (ImGui::IsItemHovered())
ImGui::SetTooltip("%s%s%s\nStock: %s%s", row.help.c_str(), row.help.empty() ? "" : "\n", row.id.c_str(), number(row.stock).c_str(),
row.used ? "" : "\nThe game was not found (or seen) reading this value, so changing it may do nothing.");
ImGui::SameLine(column);
const float reset = ImGui::CalcTextSize("Reset").x + ImGui::GetStyle().FramePadding.x * 2;
ImGui::BeginDisabled(!view.editable || !callbacks.queue_console_command);
double value = p.active == row.id ? p.active_value : row.value;
bool edited = false;
if (row.kind == trainer::Kind::flag) {
bool on = value != 0;
if (ImGui::Checkbox("##value", &on)) {
value = on ? 1 : 0;
edited = true;
}
} else {
ImGui::SetNextItemWidth(std::max(px(90), ImGui::GetContentRegionAvail().x - reset - ImGui::GetStyle().ItemSpacing.x));
const bool scale = row.kind == trainer::Kind::curve || row.kind == trainer::Kind::graph;
const bool whole = row.kind == trainer::Kind::integer;
const double low = scale ? -1.0e9 : -1.0e12, high = scale ? 1.0e9 : 1.0e12; // none of the trainer's own
const auto speed = whole ? 0.1f : scale ? 0.01f
: static_cast<float>(std::max({std::abs(row.stock), std::abs(value), 0.01}) * 0.004);
edited = ImGui::DragScalar("##value", ImGuiDataType_Double, &value, speed, &low, &high, whole ? "%.0f" : scale ? "x %.2f" : "%.4g",
ImGuiSliderFlags_AlwaysClamp);
if (ImGui::IsItemActive()) {
p.active = row.id;
p.active_value = value;
} else if (p.active == row.id) {
p.active.clear();
}
}
if (edited) trainer_command(menu, callbacks, std::format("set {} {}", row.id, number(value)));
if (row.touched && row.kind != trainer::Kind::flag) {
ImGui::SameLine();
if (ImGui::Button("Reset", ImVec2(reset, 0))) trainer_command(menu, callbacks, "reset " + row.id);
}
ImGui::EndDisabled();
ImGui::PopID();
}
// A built-in preset as a switch: blue while every value it sets holds what it sets.
void preset_switch(SkateMenu &menu, const CallbacksV3 &callbacks, const trainer::PresetRow &preset) {
if (preset.active) ImGui::PushStyleColor(ImGuiCol_Button, skate_theme::blue);
const bool pressed = ImGui::Button(preset.name.c_str());
if (preset.active) ImGui::PopStyleColor();
if (pressed) trainer_command(menu, callbacks, std::string(preset.active ? "preset remove " : "preset apply ") + preset.name);
if (ImGui::IsItemHovered() && !preset.note.empty()) ImGui::SetTooltip("%s", preset.note.c_str());
}
// A built-in preset as a dial: one multiplier that moves everything the preset moves.
void dial_row(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::PresetRow &preset) {
ImGui::PushID(preset.name.c_str());
const float column = ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x * 0.40f;
const bool moved = std::abs(preset.factor - 1.0) > 1e-4;
if (moved) ImGui::PushStyleColor(ImGuiCol_Text, skate_theme::blue);
ImGui::AlignTextToFramePadding();
ImGui::TextUnformatted(preset.title.c_str());
if (moved) ImGui::PopStyleColor();
if (ImGui::IsItemHovered())
ImGui::SetTooltip("%s\n1 is the game's own; \"%s\" is x %s.", preset.note.c_str(), preset.name.c_str(), number(preset.amount).c_str());
ImGui::SameLine(column);
const float button = ImGui::CalcTextSize("Fast Parkour Flips").x + ImGui::GetStyle().FramePadding.x * 2;
const float reset = ImGui::CalcTextSize("Reset").x + ImGui::GetStyle().FramePadding.x * 2;
const auto id = "dial:" + preset.name;
double value = p.active == id ? p.active_value : preset.factor;
// A preset that turns its value down gets a dial with more room below 1.
const double low = preset.amount < 1 ? 0.05 : 0.2, high = preset.amount < 1 ? 3.0 : 10.0;
const float box = px(64);
ImGui::SetNextItemWidth(std::max(px(70), ImGui::GetContentRegionAvail().x - box - button - reset - ImGui::GetStyle().ItemSpacing.x * 3));
if (ImGui::SliderScalar("##dial", ImGuiDataType_Double, &value, &low, &high, "x %.2f", ImGuiSliderFlags_Logarithmic) && value > 0)
trainer_command(menu, callbacks, std::format("dial {} {}", number(value), preset.name));
if (ImGui::IsItemActive()) {
p.active = id;
p.active_value = value;
} else if (p.active == id) {
p.active.clear();
}
ImGui::SameLine();
// Any number at all: the slider only covers the sensible range.
double typed = preset.factor;
ImGui::SetNextItemWidth(box);
if (ImGui::InputDouble("##typed", &typed, 0, 0, "%.6g", ImGuiInputTextFlags_EnterReturnsTrue) && typed > 0)
trainer_command(menu, callbacks, std::format("dial {} {}", number(typed), preset.name));
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Type any multiplier and press Enter: the slider's ends are not a limit.");
ImGui::SameLine();
if (preset.active) ImGui::PushStyleColor(ImGuiCol_Button, skate_theme::blue);
const bool pressed = ImGui::Button(preset.name.c_str(), ImVec2(button, 0));
if (preset.active) ImGui::PopStyleColor();
if (pressed) trainer_command(menu, callbacks, std::string(preset.active ? "preset remove " : "preset apply ") + preset.name);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", preset.note.c_str());
if (moved) {
ImGui::SameLine();
if (ImGui::Button("Reset", ImVec2(reset, 0))) trainer_command(menu, callbacks, "dial 1 " + preset.name);
}
ImGui::PopID();
}
// One screen for everything that changes how the game plays: the presets as dials and
// switches, the trick multipliers, the player's own presets and the values themselves. All of
// them show the same values, so none can disagree with another.
void tune_tab(SkateMenu &menu, const Model &model, const CallbacksV3 &callbacks, Page &p, const trainer::View &view) {
if (!view.ready) {
begin_card(menu, "tune-wait", "PHYSICS TUNING");
note(view.status.c_str());
note("The values appear once a level is loaded.");
end_card();
return;
}
if (!view.editable) warn(view.blocked.c_str());
// Two short lists, the trick line section and the whole table (modes 0, 1, 3 and 2).
{
static constexpr std::pair<const char *, int> modes[]{{"REALISTIC", 0}, {"FUN", 1}, {"TRICK LINES", 3}, {"EVERYTHING", 2}};
const float width = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x * 3) / 4;
bool first = true;
for (const auto &[label, mode] : modes) {
if (!first) ImGui::SameLine();
first = false;
const bool on = p.mode == mode;
if (on) ImGui::PushStyleColor(ImGuiCol_Button, skate_theme::blue);
if (ImGui::Button(label, ImVec2(width, 0))) p.mode = mode;
if (on) ImGui::PopStyleColor();
}
}
const std::uint8_t list = p.mode == 0 ? trainer::mode_realistic : p.mode == 1 ? trainer::mode_fun : std::uint8_t{0xff};
const bool can_edit = view.editable && callbacks.queue_console_command != nullptr;
// One search for the whole tab: dials, switches, trick sliders and every value.
ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
ImGui::InputTextWithHint("##search", "Search: dials, tricks and every value...", p.search.data(), p.search.size());
const auto words = lower(p.search.data());
const bool searching = !words.empty();
const auto listed = [&](const trainer::PresetRow &preset) {
return searching ? contains_words(lower(preset.title + " " + preset.name + " " + preset.note), words) : p.mode == 2 || (preset.modes & list) != 0;
};
if (!searching) {
begin_card(menu, "feel", "PLAY LIKE", "The game's own tuning, or Skate 3's on one of its difficulties");
ImGui::BeginDisabled(!can_edit);
feel_buttons(menu, callbacks, view);
ImGui::EndDisabled();
end_card();
}
if (p.mode == 3 && !searching) {
trickline_section(menu, callbacks, p, view);
return;
}
begin_card(menu, "dials", p.mode == 0 ? "FEEL: TONE IT DOWN" : p.mode == 1 ? "FEEL: TURN IT UP" : "FEEL",
"1 is the game's own. A dial moves every value its preset moves.");
ImGui::BeginDisabled(!can_edit);
for (const auto &preset : view.presets)
if (preset.builtin && preset.dial && listed(preset)) dial_row(menu, callbacks, p, preset);
// The presets that are plain switches, and the ones that set several dials at once.
bool first = true;
for (const auto &preset : view.presets) {
if (!preset.builtin || preset.dial || preset.name == "Stock" || preset.name.starts_with("Skate 3") || !listed(preset)) continue;
if (!first && ImGui::GetItemRectMax().x + ImGui::CalcTextSize(preset.name.c_str()).x + ImGui::GetStyle().FramePadding.x * 4 <
ImGui::GetWindowPos().x + ImGui::GetContentRegionMax().x)
ImGui::SameLine();
first = false;
preset_switch(menu, callbacks, preset);
}
ImGui::EndDisabled();
if (p.mode != 0) {
// The game's own bail protection, the same switch as Skater > Movement.
const auto &debug = model.debug;
bool no_bail = debug.no_bail;
if (toggle_row(menu, "Never bail", "No wipeouts at all. Recover from a bail before switching it on.", no_bail,
(debug.no_bail_available || debug.no_bail) && callbacks.queue_debug != nullptr))
debug_request(menu, callbacks, {DebugAction::set_no_bail, no_bail});
}
ImGui::BeginDisabled(!can_edit || !view.touched);
if (ImGui::Button("Reset values")) trainer_command(menu, callbacks, "reset all");
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Every tuning value back to the game's own. Locked values stay.");
ImGui::EndDisabled();
ImGui::SameLine();
ImGui::AlignTextToFramePadding();
ImGui::TextDisabled("%zu values changed", view.touched);
end_card();
ImGui::BeginDisabled(!can_edit);
trick_heights(menu, callbacks, p, view, words);
ImGui::EndDisabled();
if (p.mode == 2 && !searching) {
begin_card(menu, "preset-save", "YOUR PRESETS", "Save what is changed right now");
ImGui::BeginDisabled(!can_edit);
const float button = ImGui::CalcTextSize("Turn off").x + ImGui::GetStyle().FramePadding.x * 2;
for (const auto &preset : view.presets) {
if (preset.builtin) continue;
ImGui::PushID(preset.name.c_str());
if (preset.active) {
ImGui::PushStyleColor(ImGuiCol_Button, skate_theme::blue);
if (ImGui::Button("Turn off", ImVec2(button, 0))) trainer_command(menu, callbacks, "preset remove " + preset.name);
ImGui::PopStyleColor();
} else if (ImGui::Button("Turn on", ImVec2(button, 0))) {
trainer_command(menu, callbacks, "preset apply " + preset.name);
}
ImGui::SameLine();
ImGui::AlignTextToFramePadding();
ImGui::TextUnformatted(preset.name.c_str());
ImGui::SameLine();
ImGui::TextDisabled("%s", preset.note.c_str());
ImGui::SameLine(ImGui::GetContentRegionAvail().x + ImGui::GetCursorPosX() - px(170));
if (ImGui::SmallButton("This map")) trainer_command(menu, callbacks, "profile set " + preset.name);
ImGui::SameLine();
if (ImGui::SmallButton("Share")) trainer_command(menu, callbacks, "preset export " + preset.name);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Copies this preset to the clipboard as one line of text. Paste it in a chat;\nanyone with the trainer can import it.");
ImGui::SameLine();
if (ImGui::SmallButton("Delete")) trainer_command(menu, callbacks, "preset delete " + preset.name);
ImGui::PopID();
}
ImGui::EndDisabled();
field(menu, "Name");
const float save = ImGui::CalcTextSize("Save").x + ImGui::GetStyle().FramePadding.x * 2;
ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - save - ImGui::GetStyle().ItemSpacing.x);
ImGui::InputText("##preset-name", p.preset_name.data(), p.preset_name.size());
ImGui::SameLine();
ImGui::BeginDisabled(!p.preset_name[0] || !view.touched);
if (ImGui::Button("Save", ImVec2(save, 0))) trainer_command(menu, callbacks, std::string("preset save ") + p.preset_name.data());
ImGui::EndDisabled();
// Sharing: a preset travels as one line of text on the clipboard.
ImGui::BeginDisabled(view.stock);
if (ImGui::Button("Share what is changed now")) trainer_command(menu, callbacks, "preset export current");
ImGui::EndDisabled();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) ImGui::SetTooltip("Copies your current setup to the clipboard as one line of text.");
ImGui::SameLine();
if (ImGui::Button("Import from clipboard")) {
const char *text = ImGui::GetClipboardText();
if (text && trainer::stage_import(text)) trainer_command(menu, callbacks, "preset import");
else feedback(menu, "The clipboard holds no text.");
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Copy a preset line someone shared (it starts with RST1:), then press this.\nIt is added to your presets; nothing changes until you turn it on.");
if (!view.map.empty()) {
info(menu, "This map applies", view.profile_preset.empty() ? "nothing" : view.profile_preset);
if (!view.profile_preset.empty() && ImGui::Button("Stop applying it on this map")) trainer_command(menu, callbacks, "profile clear");
note("\"This map\" beside one of your presets applies it every time this map loads.");
}
end_card();
}
// The values themselves: the short list's, or all of them.
ImGui::Spacing();
ImGui::SeparatorText(p.mode == 2 ? "EVERY VALUE" : "FINE TUNING");
if (p.mode == 2) {
// The list includes the game's tuning classes, which the trainer has to find in memory
// before an edit to one does anything: with the list open, it looks now.
trainer::note_class_list_shown();
ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x * 0.42f);
if (p.group < 1) p.group = 1;
const char *current = p.group > 1 && static_cast<std::size_t>(p.group) <= view.groups.size() + 1
? view.groups[static_cast<std::size_t>(p.group) - 2].c_str() : "Every group";
if (ImGui::BeginCombo("##group", current)) {
if (ImGui::Selectable("Every group", p.group == 1)) p.group = 1;
for (std::size_t i = 0; i < view.groups.size(); ++i)
if (ImGui::Selectable(view.groups[i].c_str(), p.group == static_cast<int>(i) + 2)) p.group = static_cast<int>(i) + 2;
ImGui::EndCombo();
}
ImGui::Checkbox("Only what I changed", &p.only_changed);
ImGui::SameLine();
ImGui::Checkbox("Graph points", &p.graph_points);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Show every point of the tuning graphs, not just one multiplier per graph.");
ImGui::SameLine();
ImGui::Checkbox("Values with no use found", &p.show_unused);
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Also list the tuning values that the game was never found or seen reading.\nChanging those will probably do nothing.");
} else if (searching) {
trainer::note_class_list_shown();
} else {
note("The same values the dials move, one at a time. The box on the left locks a value against presets, dials and Reset values.");
}
filter_rows(p, view);
if (p.mode != 2 && searching) ImGui::TextDisabled("%zu values match", p.shown.size());
if (p.mode == 2) {
ImGui::SameLine();
if (p.hidden_unused) ImGui::TextDisabled("%zu shown, %zu changed, %zu hidden", p.shown.size(), view.touched, p.hidden_unused);
else ImGui::TextDisabled("%zu shown, %zu changed", p.shown.size(), view.touched);
}
const bool with_group = searching || (p.mode == 2 && (p.group <= 1 || p.only_changed));
const bool friendly = p.mode < 2;
ImGuiListClipper clipper;
clipper.Begin(static_cast<int>(p.shown.size()));
while (clipper.Step())
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; ++i)
value_row(menu, callbacks, p, view, view.rows[p.shown[static_cast<std::size_t>(i)]], with_group, friendly);
if (p.shown.empty()) note("Nothing matches.");
}
void trick_heights(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::View &view, const std::string &words) {
static constexpr const char *labels[]{"Flip trick speed", "No comply height", "Boneless height", "Hippy jump height", "Off-board jump height",
"Revert speed boost"};
const auto wanted = [&](const char *label) { return words.empty() || contains_words(lower(std::string(label) + " tricks"), words); };
if (std::ranges::none_of(labels, wanted)) return;
begin_card(menu, "trick-heights", "TRICKS", "1.0 is the game's own");
// `limited`: the game itself stops at the slider's end, so a typed number is held to it too.
const auto slider = [&](const char *label, const char *option, float value, float &edit, bool &editing, float high = 50.0f, bool limited = false) {
if (!wanted(label)) return false;
field(menu, label);
ImGui::PushID(option);
float shown = editing ? edit : value;
const float box = px(64);
ImGui::SetNextItemWidth(std::max(px(70), ImGui::GetContentRegionAvail().x - box - ImGui::GetStyle().ItemSpacing.x));
if (ImGui::SliderFloat("##height", &shown, 0.1f, high, "x %.2f", (limited ? ImGuiSliderFlags_AlwaysClamp : 0) | ImGuiSliderFlags_Logarithmic)) {
edit = shown;
editing = true;
}
if (ImGui::IsItemDeactivatedAfterEdit()) trainer_command(menu, callbacks, std::format("option {} {:.2f}", option, edit));
if (!ImGui::IsItemActive() && editing && std::abs(value - edit) < 0.005f * std::max(1.0f, std::abs(edit))) editing = false;
ImGui::SameLine();
float typed = value;
ImGui::SetNextItemWidth(box);
if (ImGui::InputFloat("##typed", &typed, 0, 0, "%.6g", ImGuiInputTextFlags_EnterReturnsTrue) && typed > 0) {
editing = false;
trainer_command(menu, callbacks, std::format("option {} {}", option, typed));
}
if (ImGui::IsItemHovered())
ImGui::SetTooltip(limited ? "Type a multiplier and press Enter." : "Type any multiplier and press Enter: the slider's end is not a limit.");
ImGui::PopID();
return true;
};
if (slider("Flip trick speed", "flip_speed", view.flip_speed, p.flip_edit, p.flip_editing, 3.0f) && ImGui::IsItemHovered()) ImGui::SetTooltip("Slows board flips (and gives them that much longer to come round). Above 1 the game's own limit on how fast a board turns takes over.");
slider("No comply height", "nocomply_height", view.nocomply_height, p.nocomply_edit, p.nocomply_editing);
slider("Boneless height", "boneless_height", view.boneless_height, p.boneless_edit, p.boneless_editing);
slider("Hippy jump height", "hippy_height", view.hippy_height, p.hippy_edit, p.hippy_editing);
slider("Off-board jump height", "offboard_height", view.offboard_height, p.offboard_edit, p.offboard_editing);
if (wanted("Revert speed boost")) {
// Not a multiplier: 0 is the game's own (no boost).
field(menu, "Revert speed boost");
ImGui::PushID("revert_boost");
float shown = p.revert_editing ? p.revert_edit : view.revert_boost;
const float box = px(64);
ImGui::SetNextItemWidth(std::max(px(70), ImGui::GetContentRegionAvail().x - box - ImGui::GetStyle().ItemSpacing.x));
if (ImGui::SliderFloat("##strength", &shown, 0.0f, 5.0f, shown <= 0.0f ? "off" : "x %.2f")) {
p.revert_edit = shown;
p.revert_editing = true;
}
if (ImGui::IsItemDeactivatedAfterEdit()) trainer_command(menu, callbacks, std::format("option revert_boost {:.2f}", p.revert_edit));
if (!ImGui::IsItemActive() && p.revert_editing && std::abs(view.revert_boost - p.revert_edit) < 0.006f) p.revert_editing = false;
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Land a spin the game has to auto revert (the board well out of line) and get speed back, as earlier builds did.\n"
"x 1 gives about +1.5 to +2.6 m/s a landing; chain reverts to build speed. 0 is off, the game's own.\n"
"From AutoRevertBoost by Sivaes, jaq and OVM.");
ImGui::SameLine();
float typed = view.revert_boost;
ImGui::SetNextItemWidth(box);
if (ImGui::InputFloat("##typed", &typed, 0, 0, "%.6g", ImGuiInputTextFlags_EnterReturnsTrue) && typed >= 0) {
p.revert_editing = false;
trainer_command(menu, callbacks, std::format("option revert_boost {}", typed));
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Type any strength and press Enter: the slider's end is not a limit.");
ImGui::PopID();
}
if (ImGui::Button("Reset tricks")) {
p.revert_editing = false;
p.hippy_editing = p.nocomply_editing = p.boneless_editing = p.offboard_editing = p.flip_editing = false;
trainer_command(menu, callbacks, "reset tricks");
}
note("Not tuning values: the game sets these in its trick scripts and flip curves. Type in the box to go past a slider's end.");
end_card();
}
void practice_tab(SkateMenu &menu, const Model &model, const CallbacksV3 &callbacks, Page &p, const trainer::View &view) {
const auto telemetry = trainer::telemetry();
begin_card(menu, "speed", "GAME SPEED", "Slow motion for learning a line");
{
const NamedSettingModel *setting = nullptr;
for (const auto &row : model.engine_settings)
if (row.name == "SimulationTime.TimeScale") {
setting = &row;
break;
}
if (!setting || !setting->available) {
note(setting && !setting->reason.empty() ? setting->reason.c_str() : "Game speed is unavailable right now.");
// The engine resolves a setting the first time it is asked for: ask.
if (setting && callbacks.queue_console_command && ImGui::GetTime() >= p.speed_until) {
p.speed_until = ImGui::GetTime() + 2.0;
p.speed_edit = -1;
std::array<char, 256> ignored{};
callbacks.queue_console_command(callbacks.user, "reset SimulationTime.TimeScale", ignored.data(), ignored.size());
}
} else {
double current = 1;
try {
const auto first = setting->value.find_first_of("-.0123456789");
if (first != std::string::npos) current = std::stod(setting->value.substr(first));
} catch (...) {}
if (p.speed_edit >= 0 && ImGui::GetTime() < p.speed_until) current = p.speed_edit;
const auto set = [&](double speed) {
p.speed_edit = speed;
p.speed_until = ImGui::GetTime() + 1.0;
send_console(menu, callbacks, speed == 1.0 ? "reset SimulationTime.TimeScale" : "SimulationTime.TimeScale " + number(speed));
};
field(menu, "Speed");
auto value = static_cast<float>(current);
if (ImGui::SliderFloat("##game-speed", &value, 0.05f, 2.0f, current == 0.0 ? "paused" : "%.2fx", ImGuiSliderFlags_AlwaysClamp))
set(value);
if (ImGui::Button(current == 0.0 ? "Resume" : "Pause")) set(current == 0.0 ? 1.0 : 0.0);
for (const auto quick : {0.1, 0.25, 0.5, 0.75, 1.0}) {
ImGui::SameLine();
if (ImGui::Button(std::format("{}x", number(quick)).c_str())) set(quick);
}
note("The jump read-out measures real time, so it reads low while the game is slowed.");
}
}
end_card();
begin_card(menu, "markers", "MARKERS", "Saved for each map");
int slot = view.slot;
if (choice(menu, "marker-slot", slot, {"1", "2", "3", "4", "5"})) trainer_command(menu, callbacks, std::format("slot {}", slot + 1));
const auto &marker = view.markers[static_cast<std::size_t>(std::clamp(view.slot, 0, static_cast<int>(trainer::marker_slots) - 1))];
info(menu, "Selected", marker.set ? std::format("{:.1f}, {:.1f}, {:.1f}", marker.position[0], marker.position[1], marker.position[2]) : "empty");
ImGui::BeginDisabled(view.map.empty());
ImGui::BeginDisabled(!telemetry.skater);
if (ImGui::Button("Save here")) trainer_command(menu, callbacks, "marker save");
ImGui::EndDisabled();
ImGui::SameLine();
ImGui::BeginDisabled(!marker.set);
if (ImGui::Button("Go")) trainer_command(menu, callbacks, "marker go");
ImGui::SameLine();
if (ImGui::Button("Clear")) trainer_command(menu, callbacks, "marker clear");
ImGui::EndDisabled();
ImGui::EndDisabled();
bool auto_return = view.auto_return;
if (toggle_row(menu, "Return after a bail", "Go back to the selected marker when the skater wipes out.", auto_return))
trainer_command(menu, callbacks, std::format("option auto_return {}", auto_return ? 1 : 0));
field(menu, "Return delay");
float delay = view.return_delay;
ImGui::SliderFloat("##return-delay", &delay, 0.0f, 10.0f, "%.1f s", ImGuiSliderFlags_AlwaysClamp);
if (ImGui::IsItemDeactivatedAfterEdit()) trainer_command(menu, callbacks, std::format("option return_delay {:.1f}", delay));
bool pad = view.pad_shortcuts;
if (toggle_row(menu, "Controller shortcuts", "Hold LB + RB, then D-pad: up saves, down goes, left / right pick the slot.", pad))
trainer_command(menu, callbacks, std::format("option pad {}", pad ? 1 : 0));
bool pad_menu = view.pad_menu;
if (toggle_row(menu, "Open this menu from the controller",
"LB + RB + click the right stick opens and closes the menu. Inside: D-pad or left stick moves, A presses, B goes back, LB / RB change a slider in big steps.", pad_menu))
trainer_command(menu, callbacks, std::format("option pad_menu {}", pad_menu ? 1 : 0));
end_card();
begin_card(menu, "teleport", "TELEPORT");
if (telemetry.skater)
info(menu, "You are at", std::format("{:.2f}, {:.2f}, {:.2f}", telemetry.position[0], telemetry.position[1], telemetry.position[2]));
field(menu, "X, Y, Z");
ImGui::InputFloat3("##teleport", p.teleport.data(), "%.2f");
ImGui::BeginDisabled(!telemetry.skater);
if (ImGui::Button("Here")) p.teleport = telemetry.position;
ImGui::SameLine();
if (ImGui::Button("Go##teleport"))
trainer_command(menu, callbacks, std::format("tp {:.3f} {:.3f} {:.3f}", p.teleport[0], p.teleport[1], p.teleport[2]));
ImGui::SameLine();
if (ImGui::Button("Copy position"))
ImGui::SetClipboardText(std::format("{:.3f}, {:.3f}, {:.3f}", telemetry.position[0], telemetry.position[1], telemetry.position[2]).c_str());
ImGui::SameLine();
if (ImGui::Button("Copy for Blender"))
ImGui::SetClipboardText(std::format("{:.3f}, {:.3f}, {:.3f}", telemetry.position[0], -telemetry.position[2], telemetry.position[1]).c_str());
ImGui::EndDisabled();
end_card();
}
void jump_lines(SkateMenu &menu, const trainer::Jump &jump) {
info(menu, "Takeoff", std::format("{:.1f} km/h at {:.1f} degrees", jump.takeoff_speed * 3.6f, jump.takeoff_angle));
info(menu, "Air time", std::format("{:.2f} s", jump.air_time));
info(menu, "Height", std::format("{:.2f} m", jump.height));
info(menu, "Distance", std::format("{:.2f} m, {:.2f} m drop", jump.distance, jump.drop));
info(menu, "Landing", std::format("{:.1f} km/h at {:.1f}, {:.1f}, {:.1f}", jump.landing_speed * 3.6f, jump.landing[0], jump.landing[1],
jump.landing[2]));
info(menu, "Rotation", std::format("spin {:.0f} degrees (peak {:.0f} per second), flip {:.0f} degrees", jump.spin, jump.spin_rate, jump.flip));
}
// Which game the skating plays like: the game's own, or Skate 3 on one of its three difficulties.
// One is always lit; a Skate 3 one goes out again as soon as one of its values is changed by hand.
void feel_buttons(SkateMenu &menu, const CallbacksV3 &callbacks, const trainer::View &view) {
struct Choice {
const char *label, *preset, *command, *tip;
};
static constexpr Choice choices[]{
{"skate.", "", "feel stock", "The game's own tuning."},
{"Skate 3 Easy", "Skate 3 Easy", "feel easy", "Skate 3 on Easy: full-height pops every time, strong pushes, generous grind lock-on, easy spins."},
{"Skate 3", "Skate 3", "feel normal", "Skate 3 on Normal: its pop, grind pops, pushing, pumping, steering, manuals, spins, flips and bails."},
{"Skate 3 Hardcore", "Skate 3 Hardcore", "feel hardcore", "Skate 3 on Hardcore: lower pops, weaker pushes, tight grind lock-on, slow auto spins."},
};
const auto active = [&](const char *preset) {
return std::ranges::any_of(view.presets, [&](const trainer::PresetRow &row) { return row.builtin && row.active && row.name == preset; });
};
const bool any = active("Skate 3 Easy") || active("Skate 3") || active("Skate 3 Hardcore");
const float width = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x * 3) / 4;
for (std::size_t i = 0; i < std::size(choices); ++i) {
if (i) ImGui::SameLine();
const bool on = i == 0 ? !any : active(choices[i].preset);
if (on) ImGui::PushStyleColor(ImGuiCol_Button, skate_theme::blue);
if (ImGui::Button(choices[i].label, ImVec2(width, 0))) trainer_command(menu, callbacks, choices[i].command);
if (on) ImGui::PopStyleColor();
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", choices[i].tip);
}
}
// Everything that makes a trick line, in one place: the same values and sliders as the Tune tab,
// gathered, with one button for Skate 3's and one for the game's own.
void trickline_section(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::View &view) {
const bool can_edit = view.editable && callbacks.queue_console_command != nullptr;
ImGui::BeginDisabled(!can_edit);
begin_card(menu, "trickline", "TRICK LINE EXTRAS", "What Skate 3's trick lines had beyond its tuning");
bool extras = view.revert_boost > 0;
if (toggle_row(menu, "Skate 3's trick line extras",
"Speed back out of reverts (the revert boost below, at x 1) and heavier revert and powerslide friction (x 3 and x 1.5: a first guess, tune them below).", extras))
trainer_command(menu, callbacks, extras ? "trickline extras on" : "trickline extras off");
note("Pick the game to play like above, then tune the trick line part of it here. Blue = changed; Reset puts one value back. Type in a box to go past a slider's end.");
end_card();
// Rows of the value table by id, looked up once per snapshot.
static constexpr const char *groups[][2]{
{"REVERTS AND POWERSLIDES", "onboard_powerslide.frictionscalar_revert onboard_powerslide.frictionscalar_autorevert "
"onboard_powerslide.powerslide_forwardforcescalar_revert onboard_powerslide.powerslide_forwardforcescalar_autorevert "
"onboard_powerslide.frictionscalar_slide onboard_powerslide.powerslide_forwardforcescalar_slide"},
{"PUMPING", "physicsmode.pumpeffectfactor physicsmode.pumpmaxacceleration physicsmode.pumpmaxdeceleration physicsmode.unintentionalpumpscalar "
"physicspumping.pumpangle physicspumping.pumpminfactor physicspumping.pumpoutoftransitionscalar"},
{"POPS", "physicsmode.jumpmaxheight physicsmode.jumpminheight physicsmode.jumpminheightmanual physicsmode.grindjumpcommonmax physicsmode.grindjumpcommonmin "
"physicsmode.grindjumpboardslidemax physicsmode.grindjumpboardslidemin physicsmode.grindjumptipslidemax physicsmode.grindjumptipslidemin "
"physicsonboardjumptuning.jumpadjustvelocityboostlimitground physicsonboardjumptuning.jumpadjustvelocityboostlimitgrind"},
{"SPINS AND FLIPS", "physicsairstates.maxspinspeed physicsmode.maxautobodyspinspeed physicsmode.easybodyspins physicsreckoning.flipscalar "
"physicsreckoning.flipmaxspeed heldflip.straightflipcatchtime heldflip.shuvmincatchtime heldflip.varialmincatchtime "
"heldflip.bigflipmincatchtime"},
{"MANUALS AND GRINDS", "physicsmanual.manualscalar_p physicsmanual.manualscalar_i physicsmanual.manualscalar_d physicsmanual.maxtiltangle "
"physicsmode.grindlockdist physicsgrind.commonfrictionscalar physicsfriction.noinputtime physicssteering.generalscalar "
"physicssteering.damping"},
};
if (p.trick_revision != view.revision) {
p.trick_revision = view.revision;
for (std::size_t g = 0; g < std::size(groups); ++g) {
p.trick_rows[g].clear();
const std::string keys = groups[g][1];
for (std::size_t start = 0; start < keys.size();) {
auto end = keys.find(' ', start);
if (end == std::string::npos) end = keys.size();
const auto key = keys.substr(start, end - start);
for (std::size_t i = 0; i < view.rows.size() && !key.empty(); ++i)
if (lower(view.rows[i].id) == key) {
p.trick_rows[g].push_back(i);
break;
}
start = end + 1;
}
}
}
const auto rows = [&](std::size_t g) {
for (const auto i : p.trick_rows[g])
if (i < view.rows.size()) value_row(menu, callbacks, p, view, view.rows[i], false, true);
};
begin_card(menu, "trick-revert", groups[0][0], "Speed back out of a revert, and what a revert costs");
{
// The revert speed boost: its strength, then what counts and what it is worth.
const auto number_row = [&](const char *label, const char *command, float value, float low, float high, const char *format, const char *tip) {
ImGui::PushID(command);
field(menu, label);
const auto key = std::string("revert:") + command;
float shown = p.active == key ? static_cast<float>(p.active_value) : value;
ImGui::SetNextItemWidth(std::max(px(70), ImGui::GetContentRegionAvail().x - px(64) - ImGui::GetStyle().ItemSpacing.x));
if (ImGui::SliderFloat("##value", &shown, low, high, format)) trainer_command(menu, callbacks, std::format("{} {:.3f}", command, shown));
if (ImGui::IsItemActive()) {
p.active = key;
p.active_value = shown;
} else if (p.active == key) {
p.active.clear();
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", tip);
ImGui::SameLine();
float typed = value;
ImGui::SetNextItemWidth(px(64));
if (ImGui::InputFloat("##typed", &typed, 0, 0, "%.6g", ImGuiInputTextFlags_EnterReturnsTrue)) trainer_command(menu, callbacks, std::format("{} {}", command, typed));
ImGui::PopID();
};
const auto &r = view.revert;
number_row("Revert speed boost", "option revert_boost", view.revert_boost, 0.0f, 5.0f, view.revert_boost <= 0 ? "off" : "x %.2f",
"Speed back on a landing the game has to swing round. 0 is off, the game's own. From AutoRevertBoost by Sivaes, jaq and OVM.");
ImGui::Spacing();
if (ImGui::TreeNodeEx("What counts as a revert, and what it is worth", ImGuiTreeNodeFlags_SpanAvailWidth)) {
number_row("Spin needed", "revert spin", r.min_spin, 0.0f, 180.0f, "%.0f deg", "How far you must have turned in the air. Lower it and smaller turns count as reverts.");
number_row("Board off the travel", "revert slip", r.min_slip, 0.0f, 90.0f, "%.0f deg",
"The board must land at least this far out of line with where you are going (0 = lined up, 90 = sideways).");
number_row("or off your body", "revert twist", r.min_twist, 0.0f, 90.0f, "%.0f deg", "A board bend: the board twisted this far off your body at touchdown also counts.");
number_row("Boost: a small bend", "revert bend", r.bend_boost, 0.0f, 10.0f, "+%.1f m/s", "Speed added when the board turned 40 degrees past the body over the flight (times the boost strength).");
number_row("Boost: a full bend", "revert full", r.full_boost, 0.0f, 10.0f, "+%.1f m/s", "The same at 360 degrees; in between it rises in a straight line up to 140 degrees.");
number_row("Boost: an auto revert", "revert auto", r.auto_boost, 0.0f, 10.0f, "+%.1f m/s", "Speed added when the board turned more than 140 degrees past the body.");
number_row("No boost above", "revert max_speed", r.max_speed, 5.0f, 100.0f, "%.0f m/s", "Reverts stop adding speed here (1 m/s = 3.6 km/h).");
number_row("Time between boosts", "revert cooldown", r.cooldown, 0.0f, 3.0f, "%.2f s", "How soon the next revert can boost again.");
number_row("Shortest flight", "revert min_air", r.min_air, 0.0f, 2.0f, "%.2f s", "A hop shorter than this never boosts.");
if (ImGui::Button("Reset revert rules")) trainer_command(menu, callbacks, "revert reset");
ImGui::TreePop();
}
ImGui::Spacing();
}
rows(0);
end_card();
trick_heights(menu, callbacks, p, view, std::string{});
for (std::size_t g = 1; g < std::size(groups); ++g) {
if (p.trick_rows[g].empty()) continue;
begin_card(menu, groups[g][0], groups[g][0]);
rows(g);
end_card();
}
ImGui::EndDisabled();
}
// The player's own follow camera, in place of the game's: one framing on the board, one on foot.
void camera_tab(SkateMenu &menu, const CallbacksV3 &callbacks, Page &p, const trainer::View &view) {
begin_card(menu, "rigs", "THE GAME'S CAMERAS", "Move the game's own cameras: they keep their smoothing and stay out of walls");
if (ImGui::Button("SunJay's Low Cam")) trainer_command(menu, callbacks, "camera rig sunjay");
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Both on-board cameras low and close, the numbers of SunJay's Low Cam mod.");
ImGui::SameLine();
if (ImGui::Button("Low, a little higher")) trainer_command(menu, callbacks, "camera rig low+");
if (ImGui::IsItemHovered()) ImGui::SetTooltip("The low camera lower and closer, but with more of the skater in view.");
ImGui::SameLine();
if (ImGui::Button("The game's own")) trainer_command(menu, callbacks, "camera rig stock");
static constexpr const char *rig_ids[]{"low", "high", "foot"};
static constexpr const char *rig_titles[]{"Low camera (on board)", "High camera (on board)", "On foot"};
for (std::size_t i = 0; i < trainer::camera_rigs; ++i) {
ImGui::SeparatorText(rig_titles[i]);
const auto &rig = view.rigs[i];
const auto slider = [&](const char *label, const char *field, float value, float low, float high, const char *format, const char *tip) {
ImGui::PushID(static_cast<int>(i));
ImGui::PushID(field);
menu::field(menu, label);
const auto key = std::string("rig:") + rig_ids[i] + field;
float shown = p.active == key ? static_cast<float>(p.active_value) : value;
ImGui::SetNextItemWidth(std::max(px(70), ImGui::GetContentRegionAvail().x - px(64) - ImGui::GetStyle().ItemSpacing.x));
if (ImGui::SliderFloat("##value", &shown, low, high, format)) trainer_command(menu, callbacks, std::format("camera rig {} {} {:.3f}", rig_ids[i], field, shown));
ImGui::SameLine();
float typed = value;
ImGui::SetNextItemWidth(px(64));
if (ImGui::InputFloat("##typed", &typed, 0, 0, "%.6g", ImGuiInputTextFlags_EnterReturnsTrue))
trainer_command(menu, callbacks, std::format("camera {} {} {} {}", "rig", rig_ids[i], field, typed));
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Type any number and press Enter: the slider's ends are not a limit.");
if (ImGui::IsItemActive()) {
p.active = key;
p.active_value = shown;
} else if (p.active == key) {
p.active.clear();
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", tip);
ImGui::PopID();
ImGui::PopID();
};
slider("Distance", "distance", rig.distance, 0.3f, 3.0f, "x %.2f", "How far behind you the camera sits. 1 is the game's own.");
slider("Height", "height", rig.height, -1.0f, 2.0f, "%+.2f m", "Moves the camera and the point it looks at up or down together.");
slider("Camera only", "raise", rig.raise, -1.0f, 2.0f, "%+.2f m", "Moves the camera alone, so it looks more down at you (or up from below).");
if (i == 2) slider("Shoulder", "side", rig.side, 0.0f, 2.0f, "%.2f", "Over the shoulder: 1 is the game's own (centred), above 1 moves right, below 1 moves left, by that many metres.");
else slider("Side", "side", rig.side, -2.0f, 2.0f, "x %.2f", "The camera's sideways offset. 1 is the game's own, 0 is dead centre, negative is the other shoulder.");
}
note(("Found: " + view.rigs_found + ". A change shows at once, or the next time that camera starts.").c_str());
end_card();
begin_card(menu, "camera", "A CAMERA OF YOUR OWN (EXPERIMENTAL)", "Replaces the game's camera altogether");
bool on = view.camera_on;
if (toggle_row(menu, "Use my camera", "Replaces the game's camera with the one set below. It stays behind the way you travel and does not avoid walls.", on))
trainer_command(menu, callbacks, std::format("camera {}", on ? "on" : "off"));
static constexpr const char *presets[]{"Low", "Low plus", "Skate 3", "High", "Shoulder", "Shoulder left"};
static constexpr const char *notes[]{
"Close to the ground behind the board, looking slightly up: the Skate 1 feel.", "The low camera raised a little, so more of the skater shows.",
"Close chase camera with a wide lens.", "Further back and above, for lines and big gaps.",
"On foot: over the right shoulder.", "On foot: over the left shoulder."};
for (std::size_t i = 0; i < std::size(presets); ++i) {
if (i) ImGui::SameLine();
if (ImGui::Button(presets[i])) trainer_command(menu, callbacks, std::string("camera preset ") + presets[i]);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", notes[i]);
}
if (view.camera_game.empty()) note("Skate a few seconds with the game's own camera and its framing is measured here.");
else {
info(menu, "The game frames you from", view.camera_game);
if (ImGui::Button("Start from the game's framing")) trainer_command(menu, callbacks, "camera game");
}
end_card();
const auto set_card = [&](const char *id, const char *title, const char *which, const trainer::CameraSet &set) {
begin_card(menu, id, title);
const auto slider = [&](const char *label, const char *field, float value, float low, float high, const char *format, const char *tip) {
ImGui::PushID(field);
ImGui::PushID(which);
menu::field(menu, label);
const auto key = std::string("camera:") + which + field;
float shown = p.active == key ? static_cast<float>(p.active_value) : value;
ImGui::SetNextItemWidth(std::max(px(70), ImGui::GetContentRegionAvail().x - px(64) - ImGui::GetStyle().ItemSpacing.x));
if (ImGui::SliderFloat("##value", &shown, low, high, format)) trainer_command(menu, callbacks, std::format("camera set {} {} {:.3f}", which, field, shown));
ImGui::SameLine();
float typed = value;
ImGui::SetNextItemWidth(px(64));
if (ImGui::InputFloat("##typed", &typed, 0, 0, "%.6g", ImGuiInputTextFlags_EnterReturnsTrue))
trainer_command(menu, callbacks, std::format("camera {} {} {} {}", "set", which, field, typed));
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Type any number and press Enter: the slider's ends are not a limit.");
if (ImGui::IsItemActive()) {
p.active = key;
p.active_value = shown;
} else if (p.active == key) {
p.active.clear();
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", tip);
ImGui::PopID();
ImGui::PopID();
};
slider("Distance", "distance", set.distance, 0.5f, 10.0f, "%.2f m", "How far behind the skater the camera sits.");
slider("Height", "height", set.height, -0.5f, 5.0f, "%.2f m", "How far above the skater's feet. Low numbers give the classic low camera.");
slider("Tilt", "pitch", set.pitch, -60.0f, 30.0f, "%.0f deg", "Negative looks down at the skater, positive looks up.");
slider("Shoulder", "side", set.side, -1.5f, 1.5f, "%.2f m", "Sideways offset: positive is over the right shoulder.");
slider("Field of view", "fov", set.fov, 0.0f, 120.0f, set.fov < 20.0f ? "the game's" : "%.0f deg", "How wide the lens is. All the way left keeps the game's own.");
slider("Follow lag", "lag", set.lag, 0.0f, 0.5f, "%.2f s", "How far the camera trails behind your movement. 0 is rigid.");
end_card();
};
set_card("camera-board", "ON THE BOARD", "board", view.camera_board);
set_card("camera-foot", "ON FOOT", "foot", view.camera_foot);
}
void map_tab(SkateMenu &menu, const CallbacksV3 &callbacks, const trainer::View &view) {
const auto telemetry = trainer::telemetry();
begin_card(menu, "hud", "HUD");
bool hud = view.hud, jump = view.hud_jump, logging = view.logging;
if (toggle_row(menu, "Speed and air HUD", "Speed, air time and height in the corner while you skate.", hud))
trainer_command(menu, callbacks, std::format("option hud {}", hud ? 1 : 0));
if (toggle_row(menu, "Jump read-out", "After each landing: takeoff speed and angle, height, distance, landing speed.", jump))
trainer_command(menu, callbacks, std::format("option hud_jump {}", jump ? 1 : 0));
if (toggle_row(menu, "Record telemetry", "Write position and speed every frame to a CSV in %LOCALAPPDATA%\\ReSkate\\trainer\\telemetry.",
logging))
trainer_command(menu, callbacks, std::format("option log {}", logging ? 1 : 0));
end_card();
begin_card(menu, "now", "RIGHT NOW");
if (!telemetry.skater) {
note("No skater yet.");
} else {
info(menu, "Speed", std::format("{:.1f} km/h ({:.2f} m/s), top {:.1f} km/h", telemetry.speed * 3.6f, telemetry.speed, telemetry.top_speed * 3.6f));
info(menu, "Position", std::format("{:.2f}, {:.2f}, {:.2f}", telemetry.position[0], telemetry.position[1], telemetry.position[2]));
info(menu, "Heading", std::format("{:.0f} degrees", telemetry.heading));
}
end_card();
if (telemetry.last.serial) {
begin_card(menu, "last-jump", "LAST JUMP", std::format("Jump {}", telemetry.last.serial).c_str());
jump_lines(menu, telemetry.last);
end_card();
}
if (telemetry.best.serial && telemetry.best.serial != telemetry.last.serial) {
begin_card(menu, "best-jump", "LONGEST JUMP ON THIS MAP");
jump_lines(menu, telemetry.best);
end_card();
}
begin_card(menu, "map", "THIS MAP", view.map.empty() ? "No level loaded" : view.map.c_str());
if (!view.map_note.empty()) note(view.map_note.c_str());
if (!view.map_preset.empty()) {
info(menu, "Author's preset", view.map_preset);
ImGui::BeginDisabled(!view.editable);
if (ImGui::Button("Apply the author's preset")) trainer_command(menu, callbacks, "preset apply map");
ImGui::EndDisabled();
}
for (std::size_t i = 0; i < view.spots.size(); ++i) {
ImGui::PushID(static_cast<int>(i));
if (ImGui::Button("Go")) trainer_command(menu, callbacks, std::format("spot {}", i + 1));
ImGui::SameLine();
ImGui::AlignTextToFramePadding();
ImGui::TextUnformatted(view.spots[i].name.c_str());
ImGui::PopID();
}
if (view.map_note.empty() && view.map_preset.empty() && view.spots.empty())
note("Map makers can ship a trainer.json in their mod folder with spots and a recommended preset.");
end_card();
}
} // namespace
bool trainer_take_open() {
const auto view = trainer::view();
auto &p = page();
if (view->open_serial == p.open_serial) return false;
p.open_serial = view->open_serial;
// `trainer open` still takes "presets": they live on the Tune tab now.
p.tab = view->open_tab == 7 ? 2 : view->open_tab == 3 ? 3 : view->open_tab == 2 ? 1 : 0; // by name, see `trainer open`
if (view->open_tab == 8) p.mode = 3; // the trick line section of the Tune tab
if (view->open_tab >= 4 && view->open_tab < 7) p.mode = std::clamp(view->open_tab - 4, 0, 2);
p.show_page = true;
return true;
}
bool trainer_page_wanted() {
auto &p = page();
const bool wanted = p.show_page;
p.show_page = false;
return wanted;
}
void trainer_page(SkateMenu &menu, const Model &model, const CallbacksV3 &callbacks) {
auto &p = page();
const auto view = trainer::view();
ImGui::BeginDisabled(!callbacks.queue_console_command);
if (ImGui::Button("RESET EVERYTHING")) {
p.hippy_editing = p.nocomply_editing = p.boneless_editing = p.offboard_editing = p.flip_editing = p.revert_editing = false;
trainer_command(menu, callbacks, "reset everything");
}
ImGui::EndDisabled();
ImGui::SameLine();
ImGui::AlignTextToFramePadding();
if (view->ready && view->stock) ImGui::TextColored(ImVec4(0.45f, 0.85f, 0.45f, 1.0f), "STOCK: the game is exactly as it shipped. Nothing of the trainer's is on.");
else if (view->ready) ImGui::TextColored(ImVec4(1.0f, 0.75f, 0.3f, 1.0f), "MODIFIED: this button puts back every value, lock, preset and trick slider.");
else ImGui::TextDisabled("The game as it shipped: every value, lock, preset and trick slider.");
// `preset export` leaves its line here; the clipboard belongs to this thread.
if (!p.share_seen) {
p.share_seen = true;
p.share_serial = view->share_serial;
} else if (p.share_serial != view->share_serial) {
p.share_serial = view->share_serial;
ImGui::SetClipboardText(view->share_text.c_str());
}
category_tabs(menu, p.tab, {"TUNE", "PRACTICE", "CAMERA", "MAP & HUD"}, "trainer-tabs");
ImGui::PushID(p.tab);
ImGui::BeginChild("trainer-tab", ImVec2(0, page_body_height(menu)));
switch (p.tab) {
case 0: tune_tab(menu, model, callbacks, p, *view); break;
case 1: practice_tab(menu, model, callbacks, p, *view); break;
case 2: camera_tab(menu, callbacks, p, *view); break;
default: map_tab(menu, callbacks, *view); break;
}
ImGui::EndChild();
ImGui::PopID();
}
} // namespace dingosdk::overlay::menu
namespace dingosdk::overlay {
bool trainer_open_requested() { return menu::trainer_take_open(); }
bool trainer_pad_menu_pressed(bool menu_visible) {
static ControllerComboLatch latch;
ControllerInput input;
DingoSDKOverlayReadControllerInput(&input, true);
constexpr std::uint32_t combo = 0x100 | 0x200 | 0x80; // LB + RB + R3
if (!latch.update(combo, input, !trainer::view()->pad_menu)) return false;
if (!menu_visible) menu::page().show_page = true;
return true;
}
bool trainer_hud_pending() {
const auto view = trainer::view();
return (view->hud || view->hud_jump) && trainer::telemetry().skater;
}
void draw_trainer_hud() {
const auto view = trainer::view();
if (!view->hud && !view->hud_jump) return;
const auto telemetry = trainer::telemetry();
if (!telemetry.skater) return;
static std::uint64_t shown_jump{};
static double jump_until{};
if (telemetry.last.serial != shown_jump) {
shown_jump = telemetry.last.serial;
jump_until = shown_jump ? ImGui::GetTime() + 7.0 : 0.0;
}
std::vector<std::string> lines;
if (view->hud) {
lines.push_back(std::format("{:.0f} km/h", telemetry.speed * 3.6f));
if (telemetry.airborne) lines.push_back(std::format("air {:.2f} s {:.2f} m", telemetry.air_time, telemetry.height));
}
if (view->hud_jump && telemetry.last.serial && ImGui::GetTime() < jump_until) {
const auto &jump = telemetry.last;
lines.push_back(std::format("jump {}: {:.1f} km/h at {:.0f} deg", jump.serial, jump.takeoff_speed * 3.6f, jump.takeoff_angle));
lines.push_back(std::format("{:.2f} s {:.2f} m high {:.2f} m far", jump.air_time, jump.height, jump.distance));
lines.push_back(std::format("landed at {:.1f} km/h, {:.2f} m lower", jump.landing_speed * 3.6f, jump.drop));
if (jump.spin >= 45.0f || jump.flip >= 90.0f) lines.push_back(std::format("spin {:.0f} deg flip {:.0f} deg", jump.spin, jump.flip));
}
if (lines.empty()) return;
auto *draw = ImGui::GetForegroundDrawList();
const auto &display = ImGui::GetIO().DisplaySize;
const float scale = std::clamp(display.y / 1080.0f, 0.75f, 2.5f);
auto *font = ImGui::GetFont();
const float big = 34.0f * scale, small = 18.0f * scale, pad = 10.0f * scale;
float width = 0, height = pad * 2;
for (std::size_t i = 0; i < lines.size(); ++i) {
const float size = i == 0 && view->hud ? big : small;
width = std::max(width, font->CalcTextSizeA(size, FLT_MAX, 0, lines[i].c_str()).x);
height += size + 4.0f * scale;
}
const ImVec2 origin(display.x - width - pad * 2 - 24.0f * scale, 24.0f * scale);
draw->AddRectFilled(origin, ImVec2(origin.x + width + pad * 2, origin.y + height), IM_COL32(12, 14, 18, 170), 6.0f * scale);
float y = origin.y + pad;
for (std::size_t i = 0; i < lines.size(); ++i) {
const float size = i == 0 && view->hud ? big : small;
draw->AddText(font, size, ImVec2(origin.x + pad, y), IM_COL32(245, 245, 240, 255), lines[i].c_str());
y += size + 4.0f * scale;
}
}
} // namespace dingosdk::overlay
Reference in new issue View Git Blame Copy Permalink