DieMitchell/ReSkate
1
0 Fork 0
mirror of https://github.com/Dingo-Shenanigans/ReSkate.git synced 2026-10-18 01:37:05 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
5d37d0bc50de42b5162a85eb10e27849ba13f64f
ReSkate/Runtime/client_tick.cpp
T
AyeZeeBB 5d37d0bc50 Drone: follow mode flies the drone behind the skater 
An autopilot flies the real flight model behind the skater while they skate: it
works the sticks a pilot would (angle mode with height hold), reacts a moment late,
eases toward the lie of the ground instead of every ollie, closes gaps no faster than
it can slow down gently, and climbs a little over what blocks the shot. Its camera
sits on a tilt gimbal so leaning to speed up or brake keeps the skater in frame.

Started from FOLLOW ME on the DRONE page or the dronefollow command; it hides the
game's interface like Start flying does. Tests cover straight, turns, hard stops,
ollies and catching up.
2026-10-16 16:43:56 -05:00

1474 lines
89 KiB
C++
Raw Blame History

#include "runtime_internal.h"
#include "Extension/Customization/developer_hoodie.h"
#include "Extension/Customization/developer_board.h"
#include "Extension/Assets/live_mods.h"
#include "Extension/Assets/map_download.h"
#include "Extension/Assets/map_icons.h"
#include "Extension/Music/spotify_station.h"
#include "Extension/Multiplayer/Hud/game_ui_state.h"
#include "Extension/Music/music_inject.h"
#include "Extension/World/texture_handle_limit.h"
#include "Extension/Assets/native_render_resource_pool.h"
#include "Engine/Core/Log/logging.h"
#include "Engine/Core/Profiling/profiler.h"
#include "Extension/Console/memory_ledger.h"
#include "Extension/Settings/job_spin.h"
#include "Extension/Settings/replay_drafts.h"
#include "Engine/Game/World/client_state.h"
#include "Extension/HallOfMeat/hall_of_meat.h"
#include "Extension/RoadRash/road_rash.h"
#include "Extension/BoardBreak/board_break.h"
#include "Extension/Skater/grind_exit_control.h"
#include "Extension/Skater/camera_observer.h"
#include "Extension/UI/NativeMenu/native_menu.h"
#include "Extension/Multiplayer/Hud/native_party.h"
#include "Extension/Multiplayer/Session/session.h"
#include "Extension/Multiplayer/Remote/native_prop.h"
#include "Extension/Multiplayer/Remote/drone_sound.h"
#include "Extension/Boot/discord_presence.h"
#include "Engine/Game/World/world_names.h"
#include "Extension/Multiplayer/Hud/custom_nametags.h"
#include "Extension/Multiplayer/developer_identity.h"
#include "Extension/Multiplayer/Hud/follow_camera.h"
#include "Engine/Game/UI/game_view.h"
#include "Extension/Multiplayer/Steam/steam_friend_join.h"
#include "Extension/Objects/network_object_runtime.h"
#include "Extension/Profile/local_profile_runtime.h"
#include "Extension/Progression/fixed_stop_entitlement_provider.h"
#include "Extension/Progression/mission_progression_override.h"
#include "Extension/Progression/neighborhood_unlock_override.h"
#include "Extension/Settings/gameplay_settings_override.h"
#include "Extension/Settings/named_settings.h"
#include "Extension/Skater/ai_skaters.h"
#include "Extension/Skater/client_source_spawn.h"
#include "Extension/Skater/skater_slot_override.h"
#include "Extension/Skater/drone_flight.h"
#include "Extension/Skater/drone_outfit.h"
#include "Extension/Throwdowns/native_throwdowns.h"
#include "Extension/Trainer/trainer.h"
#include "Extension/World/level_loading.h"
#include "Extension/World/loading_screen.h"
#include <Windows.h>
#include <dxgi.h>
#include <Psapi.h>
#include <algorithm>
#include <array>
#include <cctype>
#include <chrono>
#include <iomanip>
#include <optional>
#include <sstream>
#include <format>
#include <thread>
namespace dingosdk::runtime::detail {
namespace {
using HostedSelector = bool (*)(const char*);
const char* state_name(DWORD state) { return dingosdk::client_state_name(state); }
// What update_model learned about this tick's client, reused by the rest of the
// tick instead of reading the same native chains again.
struct TickState {
bool valid{};
DWORD state{}, game_type{};
std::optional<bool> context; // native_context
std::optional<const char*> camera_issue; // camera_probe_unavailable_reason, nullptr when ready
};
void refresh_interactive_model(std::uintptr_t client, DWORD state, DWORD game_type) {
auto& r = runtime();
auto world = dingosdk::local_profile_world_layers();
bool ready{};
{
std::lock_guard lock(r.mutex);
ready = !r.observer_failed && !r.requests.loading() && r.model.can_queue_load &&
state == r.previous_state && (state == 13 || state == 21) && world.ready;
}
const auto map = ready && native_context(r.base, client, game_type) ? world.map : dingosdk::WorldMap::none;
// Commands already run on the verified client thread. Apply their settings
// and publish the result now, without waiting for the 500 ms catalog scan.
dingosdk::update_local_world_controls(map);
dingosdk::update_local_graphics_controls();
auto controls = dingosdk::local_profile_world_controls();
auto graphics = dingosdk::local_profile_graphics_controls();
auto parks = dingosdk::local_profile_parks();
auto progression = dingosdk::local_profile_progression();
auto player_card = dingosdk::local_profile_player_card();
auto object_persistence = dingosdk::local_profile_object_persistence();
auto editor = dingosdk::local_park_editor();
auto bindings = dingosdk::local_profile_controller_bindings();
const auto missions = dingosdk::local_profile_missions();
std::vector<dingosdk::overlay::MissionRow> rows;
for (const auto& row : missions.rows) rows.push_back({row.id, row.group, row.completed});
std::lock_guard lock(r.mutex);
r.model.world = std::move(world);
r.model.world_controls = std::move(controls);
r.model.graphics = std::move(graphics);
r.model.parks = std::move(parks);
r.model.progression = std::move(progression);
r.model.player_card = std::move(player_card);
r.model.object_persistence = std::move(object_persistence);
r.model.editor = std::move(editor);
r.model.bindings = std::move(bindings);
r.model.missions_available = missions.available;
r.model.mission_feedback = missions.feedback;
r.model.missions = std::move(rows);
++r.model_revision;
}
// Engine settings that cost simulation time for nothing here, set once through the named
// setter (retried until the settings registry answers):
// - telemetry and the performance tracker only feed EA's backend, absent offline;
// - EA's error reporting (EadpErrorsData) only builds reports for EA's servers, which
// ea_service_block keeps unreachable. Set here because the same values given on the game's
// command line do not take;
// - the in-game advertising (billboards served by EA's ad service, with a render pass that
// measures how long each was on screen) has nothing to show offline and still costs frame
// time: its three switches, the renderer's, the service's and the game's own;
// - the world-transform update, which grows with every remote player's entities, is split
// over more jobs than Game.cfg's 2.
void apply_performance_settings() {
static bool applied = false;
static ULONGLONG next_attempt = 0;
if (applied) return;
const auto now = GetTickCount64();
if (now < next_attempt) return;
next_attempt = now + 500;
try {
const auto jobs = std::to_string(std::clamp(std::thread::hardware_concurrency() / 2, 2u, 8u));
const std::array<std::pair<const char*, std::string>, 13> settings{{
{"DingoTelemetry.Enable", "0"},
{"DingoTelemetry.EnablePlayerTickEvents", "0"},
{"DingoTelemetry.EnablePerformanceEvents", "0"},
{"DingoTelemetry.EnableCPUBenchmark", "0"},
{"EadpErrorsData.DisableAllEventsReporting", "1"},
{"EadpErrorsData.EnableReportCrashes", "0"},
{"EadpErrorsData.AutoSendEventFromPersistence", "0"},
{"PerformanceTracker.Enabled", "0"},
{"PerformanceTracker.JuiceLogPerformance", "0"},
{"AdTech.AdTechEnable", "0"},
{"AdTechService.AdTechEnable", "0"},
{"DingoAdTech.EnableAdTech", "0"},
{"EcsWorldTransform.ParallelWorldTransformUpdateJobCount", jobs},
}};
bool pending = false;
std::string results;
for (const auto& [name, value] : settings) {
const auto result = dingosdk::change_named_setting(name, value, false);
pending = pending || result.starts_with("error: ");
results += (results.empty() ? "" : " | ") + result;
}
if (!pending) {
applied = true;
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::runtime,
"Performance settings: {}", results);
}
} catch (...) {}
}
// The game's own connection is a loopback to the world it hosts in the same process (ReSkate's
// multiplayer runs beside it), so its in-game timeouts (Game.cfg 15 s, Branch.cfg 5 s) can only
// fire when the game itself stalls that long; a long replay export does (the encoder sets the
// pace of every frame), and the game then dropped the player to the splash screen with
// SecureReason_TimedOut while the export went on. -1 turns them off, as the game's own
// development config does. Kept apart from the settings above so an unknown name here cannot
// hold those back; tried for a minute.
void apply_local_connection_timeouts() {
static int attempts = 0;
static ULONGLONG next_attempt = 0;
if (attempts >= 120) return;
const auto now = GetTickCount64();
if (now < next_attempt) return;
next_attempt = now + 500;
try {
bool pending = false;
std::string results;
for (const auto* name : {"Client.IngameTimeout", "Server.IngameTimeout"}) {
const auto result = dingosdk::change_named_setting(name, "-1", false);
pending = pending || result.starts_with("error: ");
results += (results.empty() ? "" : " | ") + result;
}
if (!pending || ++attempts == 120) {
attempts = 120;
dingosdk::logging::log(pending ? dingosdk::logging::Level::warning : dingosdk::logging::Level::info,
dingosdk::logging::Channel::runtime, "Local connection timeouts: {}", results);
}
} catch (...) {}
}
// The mesh streaming pool holds every render mesh the world has loaded, in video memory.
// GraphicsPC.lua fixes it at 532960 KB (520 MB) on every PC quality level, sized for San Van's
// streamed cells; a big custom map's meshes do not fit, so its level either never finishes
// loading or waits out the transition's 180 s world-quality timeout
// (MeshStreamingLoadStateProvider never reports high) and spawns the skater invisible. The pools
// are re-created from this setting at every level start (FUN_14507a2d0), so raising it before a
// load is enough; the quality script sets it again whenever graphics settings are applied, so it
// is kept here. The engine turns it into bytes in 32 bits (PoolSize << 10, plus
// PoolHeadroomSize), so the combined allocation must remain below 4 GiB.
// How far it is raised depends on the card: 1.0.0 set 3.5 GiB on every card, the likely cause
// of older cards resetting the device while loading (DXGI_ERROR_DEVICE_RESET in
// gameRendBeginFrame on an RX 580, 2026-10-03). A quarter of the card's dedicated memory, from
// the game's own 520 MB up to 3.5 GiB (from 16 GB cards up); cards of 6 GB or less keep the
// game's value. Cards of up to 12 GB stop at 2 GiB: a quarter was 3 GiB of a 12 GB card, and
// with a big map and texture mods on top the game ran out of video memory (E_OUTOFMEMORY from
// CreateCommittedResource on an RTX 4070 SUPER, 2026-10-04).
namespace mesh_pool {
constexpr std::uint32_t stock_kb = 532960, most_kb = 3584u * 1024u, most_to_12gb_kb = 2048u * 1024u;
static_assert((std::uint64_t{most_kb} + 24576u) * 1024u <= 0xffffffffull);
struct Card { std::uint64_t memory{}; std::string name; };
// The hardware adapter with the most dedicated memory: the one the game renders on (a laptop's
// integrated GPU has little or none). The game's own dxgi.dll, so nothing new is loaded.
Card largest_card() {
Card card;
const auto module = GetModuleHandleW(L"dxgi.dll");
using Create = HRESULT(WINAPI*)(REFIID, void**);
const auto create = module ? reinterpret_cast<Create>(GetProcAddress(module, "CreateDXGIFactory1")) : nullptr;
IDXGIFactory1* factory{};
if (!create || FAILED(create(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&factory))) || !factory) return card;
IDXGIAdapter1* adapter{};
for (UINT i = 0; factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; ++i) {
DXGI_ADAPTER_DESC1 desc{};
if (SUCCEEDED(adapter->GetDesc1(&desc)) && !(desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) &&
desc.DedicatedVideoMemory > card.memory) {
card.memory = desc.DedicatedVideoMemory;
card.name.clear();
for (const auto* c = desc.Description; *c; ++c) card.name.push_back(*c < 128 ? static_cast<char>(*c) : '?');
}
adapter->Release();
}
factory->Release();
return card;
}
// RESKATE_MESH_POOL_MB: the pool's size for this session in MB, whatever the card (520 to 3584);
// for finding what size a map that fails needs.
std::uint32_t override_kb() {
wchar_t value[16]{};
const auto length = GetEnvironmentVariableW(L"RESKATE_MESH_POOL_MB", value, 16);
if (!length || length >= 16) return 0;
const auto megabytes = std::wcstoul(value, nullptr, 10);
return megabytes ? static_cast<std::uint32_t>(std::clamp<std::uint64_t>(std::uint64_t{megabytes} * 1024, stock_kb, most_kb)) : 0;
}
// KiB for the pool on this card, or 0 to keep the game's own value.
std::uint32_t size_kb(std::uint64_t memory) {
if (const auto chosen = override_kb()) return chosen;
// Cards report a little under or over their nominal size.
constexpr std::uint64_t six_gib = 6ull << 30, twelve_gib = 12ull << 30, slack = 256ull << 20;
if (memory <= six_gib + slack) return 0;
const auto most = memory <= twelve_gib + slack ? most_to_12gb_kb : most_kb;
return static_cast<std::uint32_t>(std::clamp<std::uint64_t>(memory / 4 / 1024, stock_kb, most));
}
}
void apply_mesh_streaming_pool() {
static const auto card = mesh_pool::largest_card();
static const auto pool_kb = mesh_pool::size_kb(card.memory);
static bool reported = false;
if (!reported) {
reported = true;
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::runtime,
"Mesh streaming pool: {} for {} ({:.1f} GB of video memory).",
pool_kb ? std::format("{} MB", pool_kb / 1024) : std::string("the game's own 520 MB"),
card.name.empty() ? std::string("an unknown card") : card.name, static_cast<double>(card.memory) / (1ull << 30));
}
if (!pool_kb) return;
static ULONGLONG next_check = 0;
static std::string last_result;
const auto now = GetTickCount64();
if (now < next_check) return;
next_check = now + 2000;
try {
const auto result = dingosdk::change_named_setting("MeshStreaming.PoolSize", std::to_string(pool_kb), false);
if (result.starts_with("error: ")) { next_check = now + 500; return; }
if (result != last_result && !result.ends_with("(unchanged)"))
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::runtime,
"Mesh streaming pool raised for big custom maps (applies from the next level load): {}", result);
last_result = result;
} catch (...) {}
}
void apply_throwdown_modes() {
// The throwdowner flow picks between the mode-select page and straight Jam
// placement by reading these by name (GetBoolSetting). Retail receives them
// from live config; S.K.A.T.E. ships off in the native constructor. Go
// through the named setter so registered setting listeners are notified.
static bool applied = false;
static ULONGLONG next_attempt = 0;
static std::string last_result;
if (applied) return;
const auto now = GetTickCount64();
if (now < next_attempt) return;
next_attempt = now + 500;
try {
bool pending = false;
std::string results;
// EnableAdvancedParameters adds the host's Customize button and the
// parameter panel (players, timer, privacy, scored actions) to the
// throwdown details page; it also ships off.
for (const auto* name : {"DingoThrowdowns.EnableSpotBattle", "DingoThrowdowns.EnableSKATE",
"DingoThrowdowns.EnableAdvancedParameters"}) {
const auto result = dingosdk::change_named_setting(name, "1", false);
pending = pending || result.starts_with("error: ");
results += (results.empty() ? "" : " | ") + result;
}
{
// Local play has nobody to wait for: with the single-player queue
// enabled (native_throwdowns.cpp) the 120 s join countdown would only
// delay the host. Revisit when throwdowns are relayed to other players.
const auto result = dingosdk::change_named_setting("DingoThrowdowns.QueueStartTimer", "1", false);
pending = pending || result.starts_with("error: ");
results += " | " + result;
}
if (results != last_result) {
last_result = results;
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::progression,
"Throwdown modes: {}", results);
}
applied = !pending;
} catch (...) {}
}
void update_model(std::uintptr_t client, TickState& frame) {
auto& r = runtime();
std::uintptr_t vtable{};
DWORD state{}, game_type{};
// Every client tick: peeked, not read (three ReadProcessMemory calls a tick, profiled 2026-10-02).
if (!memory::peek(client, vtable) || vtable != r.base + engine::client_vtable || client > highest - 0x2a0 ||
!memory::peek(client + 0xc4, state) || state > 26 || !memory::peek(client + 0xc0, game_type) || game_type > 3) return;
DWORD no_thread{};
r.engine_thread.compare_exchange_strong(no_thread, GetCurrentThreadId());
if (r.engine_thread.load() != GetCurrentThreadId()) return;
frame.valid = true;
frame.state = state;
frame.game_type = game_type;
// Some two dozen native reads: one result serves the whole tick.
const auto native_context_ready = [&] {
if (!frame.context) frame.context = native_context(r.base, client, game_type);
return *frame.context;
};
// Engine settings are only shown by the menu and console; refresh them
// quickly (and hand them over) only while one of them is reading.
const auto settings_now = GetTickCount64();
const bool settings_wanted = settings_now < r.named_settings_wanted_until.load(std::memory_order_relaxed);
dingosdk::refresh_named_settings(settings_wanted);
apply_throwdown_modes();
apply_performance_settings();
apply_local_connection_timeouts();
dingosdk::job_spin::apply_default();
apply_mesh_streaming_pool();
dingosdk::multiplayer::apply_throwdown_strings(r.base);
const bool named_context_ready = (state == 13 || state == 21) && native_context_ready();
{
std::lock_guard lock(r.mutex);
r.named_context_ready = named_context_ready;
}
if (settings_wanted && settings_now >= r.next_named_settings_publish) {
r.next_named_settings_publish = settings_now + 250;
publish_named_settings(r);
}
// RESKATE_STARTUP_COMMANDS="load skate1map;noclip 1" (development, and the launcher's
// -map <name>, which is a "load" at the front of it): console commands
// queued in order once the world is up and can accept them, so a build can be exercised
// without anyone driving the overlay. A load waits for its destination to be listed.
{
static std::optional<std::vector<std::string>> startup_commands;
if (!startup_commands) {
startup_commands.emplace();
std::wstring value(4096, L'\0');
const auto length = GetEnvironmentVariableW(L"RESKATE_STARTUP_COMMANDS", value.data(), 4096);
if (length && length < 4096) {
std::string narrow;
for (const auto character : value.substr(0, length))
narrow.push_back(character < 128 ? static_cast<char>(character) : '?');
for (std::size_t start = 0; start <= narrow.size();) {
auto end = narrow.find(';', start);
if (end == std::string::npos) end = narrow.size();
auto piece = narrow.substr(start, end - start);
const auto first = piece.find_first_not_of(" \t");
const auto last = piece.find_last_not_of(" \t");
if (first != std::string::npos) startup_commands->push_back(piece.substr(first, last - first + 1));
start = end + 1;
}
}
}
if (!startup_commands->empty() && named_context_ready) {
std::lock_guard lock(r.mutex);
const auto& text = startup_commands->front();
const auto lower = [](std::string value) {
for (auto& character : value) character = static_cast<char>(std::tolower(static_cast<unsigned char>(character)));
return value;
};
// "wait <seconds>" pauses the list, e.g. to let a multiplayer join finish.
static std::optional<std::chrono::steady_clock::time_point> wait_until;
const bool wait = lower(text).starts_with("wait ");
if (wait) {
const auto now = std::chrono::steady_clock::now();
if (!wait_until) wait_until = now + std::chrono::milliseconds(static_cast<int>(1000 * std::atof(text.c_str() + 5)));
if (now >= *wait_until) {
wait_until.reset();
startup_commands->erase(startup_commands->begin());
}
}
bool ready = !wait && r.model.can_queue_load && !r.requests.loading();
if (ready && lower(text).starts_with("load ")) {
const auto wanted = lower(text.substr(5, text.find(' ', 5) == std::string::npos ? std::string::npos : text.find(' ', 5) - 5));
ready = std::ranges::any_of(r.model.levels, [&](const dingosdk::overlay::Level& level) {
return level.can_load && (lower(level.asset).find(wanted) != std::string::npos ||
lower(level.display_name) == wanted);
});
}
if (ready && r.requests.enqueue(ConsoleRequest{text}, request_context(r), GetCurrentThreadId())) {
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::level,
"Startup command queued: {}", text);
startup_commands->erase(startup_commands->begin());
}
}
}
std::optional<ConsoleRequest> console_command;
{
std::lock_guard lock(r.mutex);
console_command = r.requests.take<ConsoleRequest>(GetCurrentThreadId());
}
if (console_command) {
ScheduledWorkScope work{r, true};
const auto started = std::chrono::steady_clock::now();
execute_console_command(console_command->text);
const auto executed = std::chrono::steady_clock::now();
refresh_interactive_model(client, state, game_type);
const auto published = std::chrono::steady_clock::now();
const auto milliseconds = [](auto duration) { return std::chrono::duration<double, std::milli>(duration).count(); };
record("{\"event\":\"menu_command_timing\",\"queue_ms\":" +
std::to_string(milliseconds(started - console_command->queued_at)) + ",\"execute_ms\":" +
std::to_string(milliseconds(executed - started)) + ",\"publish_ms\":" +
std::to_string(milliseconds(published - executed)) + "}");
}
const auto now = GetTickCount64();
bool has_request{};
{ std::lock_guard lock(r.mutex); has_request = r.requests.pending_load(); }
// Camera phase validation is necessary before camera/motion operations,
// not on every idle frame. Validate afresh after any action in this tick
// that can have changed the native camera's identity (frame.camera_issue is
// cleared then); until one runs, the first check serves the whole tick.
const auto camera_phase_issue = [&]() -> const char* {
if (!frame.camera_issue) {
std::uintptr_t context{};
frame.camera_issue = read(client + 8, context) ? dingosdk::camera_probe_unavailable_reason(context) :
"Waiting for the local camera context.";
}
return *frame.camera_issue;
};
const auto camera_phase_ready = [&] { return camera_phase_issue() == nullptr; };
std::optional<dingosdk::overlay::DebugRequest> debug_request;
bool debug_busy{}, controller_busy{};
std::uint32_t freecam_controller_combo{}, freecam_combo{}, tp_to_freecam_combo{}, noclip_combo{}, forward_velocity_combo{}, up_velocity_combo{}, offboard_up_velocity_combo{};
// Yes and No in a dedicated server's vote: read only while one is running.
std::uint32_t vote_yes_combo{}, vote_no_combo{};
// The switches on buttons (action_binds): each runs its console command.
std::array<std::uint32_t, dingosdk::action_binds.size()> action_combos{};
const bool vote_open = dingosdk::multiplayer::server_vote_open();
// The map download's card (map_download.h) is answered with the same two binds, and by a
// controller, whose buttons are kept from the game while it asks.
const bool map_prompt = dingosdk::map_download::asking();
// The vote for the next map comes up the same way (overlay.h: map_vote_asking), when no map is being asked about.
const bool map_vote = !map_prompt && dingosdk::overlay::map_vote_asking();
// And a message to say OK to (overlay.h: message_asking), over either.
const bool message_up = dingosdk::overlay::message_asking();
// The hold on the game's input outlasts the card's question until everything pressed is let
// go (or a moment has passed): the button that answered must not also be a press in the
// game, or in the pause menu behind the card.
static bool prompt_held{};
static ULONGLONG prompt_release_by{};
if (map_prompt || map_vote || message_up) {
prompt_held = true;
prompt_release_by = 0;
} else if (prompt_held) {
if (!prompt_release_by) prompt_release_by = GetTickCount64() + 1500;
dingosdk::ControllerInput held;
DingoSDKOverlayReadControllerInput(&held, true);
const bool pressed = (held.available && held.buttons) || DingoSDKOverlayReadPromptKeys() ||
std::ranges::any_of(held.keys, [](std::uint64_t word) { return word != 0; });
if (!pressed || GetTickCount64() >= prompt_release_by) prompt_held = false;
}
DingoSDKOverlaySetPromptInputCapture(map_prompt || map_vote || message_up || prompt_held);
const unsigned poll_answers = dingosdk::multiplayer::server_poll_answers();
bool freecam_controller = dingosdk::local_freecam_controller();
{
std::lock_guard lock(r.mutex);
debug_busy = r.requests.loading();
controller_busy = !r.requests.idle();
freecam_controller_combo = r.model.bindings.available ? r.model.bindings.freecam_controller_combo : 0;
freecam_combo = r.model.bindings.available ? r.model.bindings.freecam_combo : 0;
tp_to_freecam_combo = r.model.bindings.available ? r.model.bindings.tp_to_freecam_combo : 0;
noclip_combo = r.model.bindings.available ? r.model.bindings.noclip_combo : 0;
forward_velocity_combo = r.model.bindings.available ? r.model.bindings.forward_velocity_combo : 0;
up_velocity_combo = r.model.bindings.available ? r.model.bindings.up_velocity_combo : 0;
offboard_up_velocity_combo = r.model.bindings.available ? r.model.bindings.offboard_up_velocity_combo : 0;
if (r.model.bindings.available) action_combos = r.model.bindings.action_combos;
if ((vote_open || map_prompt) && r.model.bindings.available) {
vote_yes_combo = r.model.bindings.vote_yes_combo;
vote_no_combo = r.model.bindings.vote_no_combo;
}
if (r.model.bindings.available)
dingosdk::map_download::set_binds(r.model.bindings.vote_yes_combo, r.model.bindings.vote_no_combo);
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
}
// Capture belongs to the freecam state itself. Keep it active across brief
// request/loading phases instead of opening a path back to player input.
DingoSDKOverlaySetFreecamInputCapture(dingosdk::client_free_camera_active() && (freecam_controller || dingosdk::drone::controller_capture()));
dingosdk::ControllerInput controller;
if (freecam_controller_combo || freecam_combo || tp_to_freecam_combo || noclip_combo || forward_velocity_combo || up_velocity_combo || offboard_up_velocity_combo ||
vote_yes_combo || vote_no_combo || poll_answers || map_prompt || map_vote || message_up ||
std::ranges::any_of(action_combos, [](auto combo) { return combo != 0; }))
// (The card that asks has the pointer, as a menu does: it is still read for.)
DingoSDKOverlayReadControllerInput(&controller, map_prompt || map_vote || message_up);
for (std::size_t i = 0; i < action_combos.size(); ++i)
if (r.action_bind_latches[i].update(action_combos[i], controller, r.observer_failed)) {
std::array<char, 256> result{};
const std::string command(dingosdk::action_binds[i].command);
if (queue_console_command(nullptr, command.c_str(), result.data(), result.size()))
record(("{\"event\":\"controller_binding_triggered\",\"action\":\"" + std::string(dingosdk::action_binds[i].key) + "\"}").c_str());
}
// (The input reads as nothing while the menu, the console or the chat box is open, so typing
// a bound key answers no vote.)
if (r.vote_yes_bind_latch.update(vote_yes_combo, controller, !vote_open && !map_prompt)) {
if (map_prompt) dingosdk::map_download::answer(true);
else if (dingosdk::multiplayer::queue_command("vote", "yes", ""))
record("{\"event\":\"controller_binding_triggered\",\"action\":\"vote_yes\"}");
}
if (r.vote_no_bind_latch.update(vote_no_combo, controller, !vote_open && !map_prompt)) {
if (map_prompt) dingosdk::map_download::answer(false);
else if (dingosdk::multiplayer::queue_command("vote", "no", ""))
record("{\"event\":\"controller_binding_triggered\",\"action\":\"vote_no\"}");
}
{
// A controller on the card: D-pad left and right pick, A takes the pick, B is no. Only a
// button pressed since the card came up counts, so the one that was held does not answer.
static bool prompt_before{};
static std::uint32_t buttons_before{};
// The keyboard's arrows, Enter and Esc do the same, above the pad's bits.
const bool prompt = map_prompt || map_vote || message_up;
const std::uint32_t buttons = !prompt ? 0
: (controller.available ? controller.buttons : 0) | (DingoSDKOverlayReadPromptKeys() << 20);
// The message is over the others and is answered first: A or B, Enter or Esc, is its OK.
static bool message_before{};
if (message_up && message_before) {
if ((buttons & ~buttons_before) & (0x1000 | 0x2000 | 1u << 22 | 1u << 23)) dingosdk::overlay::message_dismiss();
} else if (map_prompt && prompt_before) {
const auto pressed = buttons & ~buttons_before;
if (pressed & (0x0004 | 1u << 20)) dingosdk::map_download::pick(true);
if (pressed & (0x0008 | 1u << 21)) dingosdk::map_download::pick(false);
if (pressed & (0x1000 | 1u << 22)) dingosdk::map_download::answer(dingosdk::map_download::picked());
else if (pressed & (0x2000 | 1u << 23)) dingosdk::map_download::answer(false);
}
// The vote's popup: left and right move the pick, A votes for it, B closes it.
static bool vote_before{};
if (!message_up && map_vote && vote_before) {
const auto pressed = buttons & ~buttons_before;
if (pressed & (0x0004 | 1u << 20)) dingosdk::overlay::map_vote_move(-1);
if (pressed & (0x0008 | 1u << 21)) dingosdk::overlay::map_vote_move(1);
if (pressed & (0x1000 | 1u << 22)) dingosdk::overlay::map_vote_take();
else if (pressed & (0x2000 | 1u << 23)) dingosdk::overlay::map_vote_dismiss();
}
vote_before = map_vote;
message_before = message_up;
prompt_before = map_prompt;
buttons_before = buttons;
}
// While it downloads, the No bind stops it.
if (!map_prompt && !vote_open && dingosdk::map_download::view().stage == dingosdk::map_download::Stage::downloading) {
std::uint32_t stop_combo{};
{
std::lock_guard lock(r.mutex);
if (r.model.bindings.available) stop_combo = r.model.bindings.vote_no_combo;
}
if (stop_combo) {
dingosdk::ControllerInput input;
DingoSDKOverlayReadControllerInput(&input);
static dingosdk::ControllerComboLatch stop_latch;
if (stop_latch.update(stop_combo, input, false)) dingosdk::map_download::answer(false);
}
}
// A poll's answers are on the number keys, 1 for the first: only while one is running, so
// the keys are the game's own the rest of the time.
for (unsigned answer = 0; answer < r.poll_answer_latches.size(); ++answer) {
const std::uint32_t key = answer < poll_answers ? dingosdk::keyboard_binding_tag | ('1' + answer) : 0U;
const char number[2]{static_cast<char>('1' + answer), 0};
if (r.poll_answer_latches[answer].update(key, controller, !poll_answers) && dingosdk::multiplayer::queue_command("vote", number, ""))
record("{\"event\":\"controller_binding_triggered\",\"action\":\"poll_answer\"}");
}
if (r.freecam_controller_bind_latch.update(freecam_controller_combo, controller, r.observer_failed || controller_busy || !r.debug_model.free_camera)) {
if (dingosdk::set_local_freecam_controller(!freecam_controller))
freecam_controller = !freecam_controller;
DingoSDKOverlaySetFreecamInputCapture(dingosdk::client_free_camera_active() && (freecam_controller || dingosdk::drone::controller_capture()));
record("{\"event\":\"controller_binding_triggered\",\"action\":\"freecam_controller\"}");
}
if (r.tp_to_freecam_bind_latch.update(tp_to_freecam_combo, controller, r.observer_failed || controller_busy || !r.debug_model.free_camera || !r.debug_model.camera_position_valid || debug_request.has_value())) {
if (dingosdk::teleport_local_skater(r.debug_model.camera_position)) {
std::lock_guard lock(r.mutex);
const dingosdk::overlay::DebugRequest request{dingosdk::overlay::DebugAction::set_free_camera, false};
if (r.requests.enqueue(request, request_context(r), GetCurrentThreadId()))
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
}
record("{\"event\":\"controller_binding_triggered\",\"action\":\"tp_to_freecam\"}");
}
const bool freecam_bind_blocked = r.observer_failed || controller_busy || debug_request.has_value() ||
(state != 13 && state != 21) || !r.debug_model.camera_available ||
(freecam_combo && !camera_phase_ready());
if (r.freecam_bind_latch.update(freecam_combo, controller, freecam_bind_blocked)) {
{
std::lock_guard lock(r.mutex);
const dingosdk::overlay::DebugRequest request{dingosdk::overlay::DebugAction::set_free_camera, !r.debug_model.free_camera};
if (r.requests.enqueue(request, request_context(r), GetCurrentThreadId()))
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
}
record("{\"event\":\"controller_binding_triggered\",\"action\":\"freecam\"}");
}
const bool bind_blocked = r.observer_failed || controller_busy || debug_request.has_value() ||
(state != 13 && state != 21) || !r.debug_model.noclip_available ||
(noclip_combo && !camera_phase_ready());
const bool noclip_triggered = r.noclip_bind_latch.update(noclip_combo, controller, bind_blocked);
if (noclip_triggered) {
{
std::lock_guard lock(r.mutex);
const dingosdk::overlay::DebugRequest request{dingosdk::overlay::DebugAction::set_noclip, !r.debug_model.noclip};
if (r.requests.enqueue(request, request_context(r), GetCurrentThreadId()))
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
}
record("{\"event\":\"controller_binding_triggered\",\"action\":\"noclip\"}");
}
const bool forward_velocity_blocked = r.observer_failed || controller_busy || debug_request.has_value() ||
(r.debug_model.offboard_up_velocity_available && forward_velocity_combo == offboard_up_velocity_combo) ||
(r.debug_model.free_camera && freecam_controller) ||
(state != 13 && state != 21) || !r.debug_model.forward_velocity_available ||
(forward_velocity_combo && forward_velocity_combo == noclip_combo);
if (r.forward_velocity_bind_latch.update(forward_velocity_combo, controller, forward_velocity_blocked)) {
{
std::lock_guard lock(r.mutex);
const dingosdk::overlay::DebugRequest request{dingosdk::overlay::DebugAction::add_forward_velocity};
if (r.requests.enqueue(request, request_context(r), GetCurrentThreadId()))
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
}
record("{\"event\":\"controller_binding_triggered\",\"action\":\"forward_velocity\"}");
}
const bool up_velocity_blocked = r.observer_failed || controller_busy || debug_request.has_value() ||
(r.debug_model.offboard_up_velocity_available && up_velocity_combo == offboard_up_velocity_combo) ||
(r.debug_model.free_camera && freecam_controller) ||
(state != 13 && state != 21) || !r.debug_model.up_velocity_available ||
(up_velocity_combo && (up_velocity_combo == noclip_combo || up_velocity_combo == forward_velocity_combo));
if (r.up_velocity_bind_latch.update(up_velocity_combo, controller, up_velocity_blocked)) {
std::lock_guard lock(r.mutex);
const dingosdk::overlay::DebugRequest request{dingosdk::overlay::DebugAction::add_up_velocity};
if (r.requests.enqueue(request, request_context(r), GetCurrentThreadId())) {
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
record("{\"event\":\"controller_binding_triggered\",\"action\":\"up_velocity\"}");
}
}
const bool offboard_up_velocity_blocked = r.observer_failed || controller_busy || debug_request.has_value() ||
(r.debug_model.free_camera && freecam_controller) ||
(state != 13 && state != 21) || !r.debug_model.offboard_up_velocity_available ||
(offboard_up_velocity_combo && offboard_up_velocity_combo == noclip_combo);
if (r.offboard_up_velocity_bind_latch.update(offboard_up_velocity_combo, controller, offboard_up_velocity_blocked)) {
std::lock_guard lock(r.mutex);
const dingosdk::overlay::DebugRequest request{dingosdk::overlay::DebugAction::add_offboard_up_velocity};
if (r.requests.enqueue(request, request_context(r), GetCurrentThreadId())) {
debug_request = r.requests.take<dingosdk::overlay::DebugRequest>(GetCurrentThreadId());
record("{\"event\":\"controller_binding_triggered\",\"action\":\"offboard_up_velocity\"}");
}
}
if (debug_request || r.debug_model.free_camera || r.debug_model.first_person || r.debug_model.drone_follow || r.debug_model.noclip ||
now >= r.next_debug) {
ScheduledWorkScope work{r, debug_request.has_value()};
r.next_debug = now + 100;
const bool debug_ready = !r.observer_failed && !debug_busy && (state == 13 || state == 21) && native_context_ready();
dingosdk::overlay::FlightInput flight_input;
DingoSDKOverlayReadFlightInput(&flight_input, (r.debug_model.free_camera || r.debug_model.noclip) && debug_ready,
r.debug_model.noclip || (r.debug_model.free_camera && freecam_controller));
const auto phase_issue = camera_phase_issue();
auto debug = dingosdk::on_client_debug_tick(r.base, client, debug_ready,
phase_issue == nullptr,
debug_request ? &*debug_request : nullptr, &flight_input);
// Input ownership must follow the live camera even with every overlay closed.
DingoSDKOverlaySetFreecamInputCapture(dingosdk::client_free_camera_active() && (freecam_controller || dingosdk::drone::controller_capture()));
// A debug action, or a mode the tick ended by itself (host policy, lost
// camera), can have replaced the native camera: validate it again.
if (debug_request || debug.free_camera != r.debug_model.free_camera ||
debug.first_person != r.debug_model.first_person || debug.noclip != r.debug_model.noclip ||
debug.park_editor != r.debug_model.park_editor)
frame.camera_issue.reset();
if (debug_ready && phase_issue && !debug.camera_available) {
debug.camera_unavailable = phase_issue;
debug.noclip_unavailable = phase_issue;
}
// Ignore brief loading/ownership transitions. Report a persistent reason
// once, then report recovery; the menu always shows the current reason.
const std::string issue = debug_ready && debug.skater_position_valid && !debug.noclip_available
? debug.noclip_unavailable : std::string{};
if (issue != r.flight_unavailable_issue) {
r.flight_unavailable_issue = issue;
r.flight_unavailable_since = now;
}
if (!issue.empty() && now - r.flight_unavailable_since >= 2000 && issue != r.flight_unavailable_logged) {
dingosdk::logging::log(dingosdk::logging::Level::warning, dingosdk::logging::Channel::skater,
"{} unavailable: {}", debug.camera_available ? "Noclip" : "Freecam and Noclip", issue);
r.flight_unavailable_logged = issue;
} else if (debug.noclip_available && !r.flight_unavailable_logged.empty()) {
dingosdk::logging::write(dingosdk::logging::Level::info, dingosdk::logging::Channel::skater,
"Freecam and Noclip are available again.");
r.flight_unavailable_logged.clear();
}
if (debug.noclip_velocity_updates && !r.debug_model.noclip_velocity_updates)
record("{\"event\":\"noclip_velocity_applied\",\"count\":" + std::to_string(debug.noclip_velocity_updates) + "}");
if (debug.noclip_motion_updates && !r.debug_model.noclip_motion_updates)
record("{\"event\":\"noclip_offboard_motion_applied\",\"count\":" + std::to_string(debug.noclip_motion_updates) + "}");
if (debug.forward_velocity_updates != r.debug_model.forward_velocity_updates)
record("{\"event\":\"forward_velocity_applied\",\"count\":" + std::to_string(debug.forward_velocity_updates) + "}");
if (debug.up_velocity_updates != r.debug_model.up_velocity_updates)
record("{\"event\":\"up_velocity_applied\",\"count\":" + std::to_string(debug.up_velocity_updates) + "}");
if (debug.offboard_up_velocity_updates != r.debug_model.offboard_up_velocity_updates)
record("{\"event\":\"offboard_up_velocity_applied\",\"count\":" + std::to_string(debug.offboard_up_velocity_updates) + "}");
if (r.debug_model.noclip && !debug.noclip && !debug_request) {
std::ostringstream stopped;
stopped << "{\"event\":\"noclip_stopped\",\"reason\":" << std::quoted(debug.status) << '}';
record(stopped.str());
}
if (debug_request) record("{\"event\":\"interactive_debug_result\",\"action\":" +
std::to_string(static_cast<int>(debug_request->action)) + ",\"free_camera\":" +
(debug.free_camera ? "true" : "false") + ",\"noclip\":" + (debug.noclip ? "true" : "false") + ",\"game_ui_hidden\":" +
(debug.game_ui_hidden ? "true" : "false") + ",\"no_bail\":" + (debug.no_bail ? "true" : "false") +
",\"no_bail_active\":" + (debug.no_bail_active ? "true" : "false") + ",\"speed\":" + std::to_string(debug.camera_speed) +
",\"velocity_updates\":" + std::to_string(debug.noclip_velocity_updates) + ",\"motion_updates\":" + std::to_string(debug.noclip_motion_updates) + "}");
if (debug_request) {
std::ostringstream message;
message << "Noclip " << (debug.noclip ? "on" : "off") << " | free camera " << (debug.free_camera ? "on" : "off")
<< " | No Bail " << (debug.no_bail_active ? "active" : debug.no_bail ? "waiting" : "off")
<< (debug.no_bail_active && !debug.no_bail ? " (noclip)" : "")
<< " | speed " << debug.camera_speed << " | game UI "
<< (debug.game_ui_hidden ? "hidden" : "visible");
if (!debug.status.empty()) message << " | " << debug.status;
activity_line(dingosdk::ConsoleSource::runtime, message.str());
}
std::lock_guard lock(r.mutex);
r.debug_model = std::move(debug);
++r.debug_revision;
}
std::optional<dingosdk::overlay::OfflineFeatureRequest> offline_request;
{
std::lock_guard lock(r.mutex);
offline_request = r.requests.take<dingosdk::overlay::OfflineFeatureRequest>(GetCurrentThreadId());
}
if (offline_request || now >= r.next_offline) {
ScheduledWorkScope work{r, offline_request.has_value()};
DINGO_PROFILE_ZONE("tick/update_model/features (500 ms)");
r.next_offline = now + 500;
auto offline = dingosdk::update_gameplay_settings_override(
offline_request ? &*offline_request : nullptr);
if (offline_request) {
using dingosdk::overlay::OfflineFeatureGroup;
if (offline_request->group == OfflineFeatureGroup::board_wear)
dingosdk::profile_runtime::set_local_preference("BoardWear", offline_request->enabled);
else if (offline_request->group == OfflineFeatureGroup::restore_all)
dingosdk::profile_runtime::set_local_preference("BoardWear", false);
dingosdk::logging::printf(dingosdk::logging::Level::info, dingosdk::logging::Channel::runtime,
"Offline feature %d -> %d applied: %s (board wear available %d, effective %d).",
static_cast<int>(offline_request->group), offline_request->enabled, offline.model.status.c_str(),
offline.model.board_wear.available, offline.model.board_wear.effective);
}
auto slot_action = dingosdk::SkaterSlotOverrideAction::tick;
if (offline_request &&
offline_request->group == dingosdk::overlay::OfflineFeatureGroup::restore_all)
slot_action = dingosdk::SkaterSlotOverrideAction::restore;
const auto profile_access = dingosdk::local_profile_access();
{
DINGO_PROFILE_ZONE("tick/update_model/features (500 ms)/local profile");
dingosdk::update_local_customization();
}
// Saved access owns these prerequisites. This runs on the recorded
// game-update thread and reacquires/validates each native settings object.
const auto enable_saved_feature = [&](const char* name, bool requested, const char* reapplied_log = nullptr) {
if (!requested) return;
const auto variable = std::find_if(offline.model.variables.begin(), offline.model.variables.end(),
[&](const auto& field) { return field.name == name; });
if (variable != offline.model.variables.end() && variable->available && !variable->value) {
offline = dingosdk::update_gameplay_engine_variable({name, dingosdk::EngineVariableAction::set, true});
if (reapplied_log)
dingosdk::logging::printf(dingosdk::logging::Level::info, dingosdk::logging::Channel::runtime,
"%s", reapplied_log);
}
};
enable_saved_feature("FastTravelPointsEnabled", profile_access.bus_stops);
enable_saved_feature("EnableNeighborhoodRank", profile_access.neighborhoods || profile_access.neighborhood_ranks);
enable_saved_feature("EnableCASArtistSandbox", profile_access.cosmetics);
enable_saved_feature("EnableMyStuffMenu", profile_access.cosmetics);
enable_saved_feature("BoardWearEnabled",
dingosdk::profile_runtime::local_preference("BoardWear").value_or(false),
"Re-applied saved board wear preference (BoardWearEnabled).");
if (profile_access.preset_slots) slot_action = dingosdk::SkaterSlotOverrideAction::enable;
const auto slots = dingosdk::update_skater_slot_override(slot_action, dingosdk::local_customization_selected_preset(),
dingosdk::local_customization_outfits_loadable());
if (slots.manager_available && slots.ui_ready)
dingosdk::observe_local_customization_selection(slots.selected_slot);
const bool missions_requested = offline.model.activities.available &&
offline.model.activities.effective &&
offline.model.activities.override_active;
if (missions_requested)
dingosdk::arm_main_mission_override(r.base, true);
else
dingosdk::restore_main_mission_override();
const auto missions = dingosdk::main_mission_override_observation();
const bool fixed_stop_requested = r.fixed_stop_entitlement_route_ready &&
(profile_access.bus_stops || (offline.model.fast_travel.available &&
offline.model.fast_travel.effective &&
offline.model.fast_travel.override_active));
dingosdk::set_fixed_stop_entitlement_provider_enabled(fixed_stop_requested);
const bool neighborhood_requested = profile_access.neighborhoods || (offline.model.progression.available &&
offline.model.progression.effective &&
offline.model.progression.override_active);
(void)dingosdk::set_neighborhood_unlock_override_enabled(neighborhood_requested);
const auto fixed_stops = dingosdk::fixed_stop_entitlement_provider_observation();
const auto neighborhoods = dingosdk::neighborhood_unlock_override_observation();
merge_skater_slot_observation(offline.model, slots);
merge_main_mission_observation(offline.model, missions);
merge_progression_provider_observations(offline.model, fixed_stops, neighborhoods,
r.fixed_stop_entitlement_route_ready);
if (offline.json != r.last_gameplay_settings_override_observation) {
record(offline.json);
r.last_gameplay_settings_override_observation = offline.json;
}
if (slots.json != r.last_skater_slot_override_observation) {
record(slots.json);
r.last_skater_slot_override_observation = slots.json;
}
if (missions.json != r.last_main_mission_override_observation) {
record(missions.json);
r.last_main_mission_override_observation = missions.json;
}
if (fixed_stops.json != r.last_fixed_stop_entitlement_provider_observation) {
record(fixed_stops.json);
r.last_fixed_stop_entitlement_provider_observation = fixed_stops.json;
}
if (neighborhoods.json != r.last_neighborhood_unlock_override_observation) {
record(neighborhoods.json);
r.last_neighborhood_unlock_override_observation = neighborhoods.json;
}
std::lock_guard lock(r.mutex);
r.offline_model = std::move(offline.model);
++r.offline_revision;
// Skater slots, teleports and customization ran: check the camera again.
frame.camera_issue.reset();
}
if (r.debug_model.park_editor && !r.observer_failed && !debug_busy && (state == 13 || state == 21) &&
native_context_ready()) {
{
DINGO_PROFILE_ZONE("tick/update_model/park editor");
dingosdk::tick_local_park_editor();
}
frame.camera_issue.reset();
auto editor = dingosdk::local_park_editor();
std::lock_guard lock(r.mutex);
r.model.editor = std::move(editor);
++r.model_revision;
} else {
// Other players' objects still to be created: queue the next as soon as the
// last one is in, not at the 500 ms customization pace.
DINGO_PROFILE_ZONE("tick/update_model/network objects");
dingosdk::tick_network_objects();
}
if (r.observer_failed) return; // Keep the bounded restore/telemetry path available after catalog failure.
dingosdk::hall_of_meat::on_client_tick();
dingosdk::road_rash::on_client_tick(client);
dingosdk::drone::outfit::on_client_tick();
dingosdk::board_break::on_client_tick(client);
dingosdk::grind_exit_control::on_client_tick(client);
if (!has_request && now < r.next_model && state == r.previous_state) return;
r.next_model = now + 500;
DINGO_PROFILE_ZONE("tick/update_model/world model (500 ms)");
auto description = dingosdk::read_world_description(GetCurrentProcess(), client + 0x198);
r.multiplayer_map = description.level.empty() ? std::string{} : description.level + "|" + description.lm_level;
const auto& current_level = description.lm_level.empty() ? description.level : description.lm_level;
dingosdk::live_mods::set_current_level(current_level);
dingosdk::hall_of_meat::set_level(current_level);
dingosdk::replay_drafts::on_client_tick(r.base, state);
// A live mod apply hands over the destinations its mods declare. A map
// being played that is no longer among them (its mod disabled or deleted)
// cannot stay loaded: the player goes to San Van.
bool left_map{}, manifests_applied{};
if (auto manifests = dingosdk::live_mods::take_level_manifests()) {
manifests_applied = true;
auto next = read_custom_levels(*manifests);
const auto listed = [&](const dingosdk::CustomLevelManifest& set) {
return std::ranges::any_of(set.levels, [&](const auto& level) { return equals(level.asset, description.lm_level); });
};
left_map = !description.lm_level.empty() && listed(r.custom_levels) && !listed(next);
r.custom_levels = std::move(next);
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::level,
"Custom-level destinations after the live mod apply: {}.", r.custom_levels.levels.size());
}
// Handed out with the manifests: once the merge is in, load the level being
// played again ("Apply and reload level"), or San Van when that map is gone.
const bool reload = dingosdk::live_mods::take_reload();
if (left_map || reload) {
constexpr std::string_view san_van = "levels/game/BAM_LevelRoot/BAM_LevelRoot";
const std::string target = left_map ? std::string(san_van) : current_level;
std::lock_guard lock(r.mutex);
if (target.empty() || !r.requests.enqueue(ConsoleRequest{"load " + target}, request_context(r), GetCurrentThreadId()))
dingosdk::logging::log(dingosdk::logging::Level::warning, dingosdk::logging::Channel::level,
"Mods applied, but the level could not be {}; load a level to use them.", left_map ? "left" : "reloaded");
else if (left_map)
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::level,
"{} was removed by the mod apply; loading San Van.", description.lm_level);
else
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Channel::level,
"Reloading {} to use the applied mods.", target);
}
// The native level registry changes only with a mod apply or a level load,
// and the server's sublevels settle during loads: read both again then, and
// whenever this client is not in play; otherwise every 10 s and 2 s.
bool requests_loading{};
{ std::lock_guard lock(r.mutex); requests_loading = r.requests.loading(); }
const bool world_changed = manifests_applied || requests_loading || (state != 13 && state != 21) ||
state != r.previous_state || description.level != r.last_level || description.lm_level != r.catalog_level;
r.catalog_level = description.lm_level;
if (!r.native_catalog || !r.native_catalog->available || world_changed || now >= r.next_catalog_read) {
r.native_catalog = dingosdk::read_world_catalog(GetCurrentProcess(), r.base);
r.next_catalog_read = now + 10000;
}
const bool sublevels_read = !r.sublevel_catalog || !r.sublevel_catalog->available || world_changed ||
now >= r.next_sublevel_read;
if (sublevels_read) {
r.sublevel_catalog = dingosdk::read_server_sublevels(GetCurrentProcess(), r.base);
r.next_sublevel_read = now + 2000;
}
auto catalog = *r.native_catalog;
const auto native_level_count = catalog.levels.size();
catalog = dingosdk::merge_custom_levels(std::move(catalog), r.custom_levels);
const auto& sublevels = *r.sublevel_catalog;
const auto client_content = read_client_content(r.base, client, description.lm_level);
const bool context_ready = native_context_ready();
const bool manifest_custom_active = (state == 13 || state == 21) &&
context_ready && description.available &&
std::any_of(catalog.levels.begin(), catalog.levels.end(), [&](const auto& level) {
return level.manifest_only && equals(level.asset, description.lm_level);
});
// Schema 1 Studio maps are authored exclusively from BAM's bounded
// service/environment closure. This hint permits that reduced controller
// graph to identify its family without weakening native-map detection.
dingosdk::set_local_world_layer_map_hint(
manifest_custom_active ? dingosdk::WorldMap::bam : dingosdk::WorldMap::none);
dingosdk::ConsoleActivity activity;
activity.state = state;
activity.native_loading_logging = r.native_loading_logging;
activity.state_name = state_name(state);
activity.level = description.level;
activity.sublevel = description.lm_level;
for (const auto& level : sublevels.levels)
activity.sublevel_active |= sublevels.available && sublevels.active && level.state == 5 &&
equals(level.asset, description.lm_level);
activity.client_sublevel_present = client_content.sublevels_available &&
client_content.requested_sublevel_present;
activity.players_available = client_content.players_available;
activity.players = client_content.local_player_count;
activity.controllables = client_content.controllable_reference_count;
{
std::lock_guard lock(r.mutex);
if (r.debug_model.skater_position_valid) {
activity.skater = r.debug_model.skater_identity;
activity.position = r.debug_model.skater_position;
}
}
r.console_activity.update(activity, &activity_line);
const auto content_json = "{\"event\":\"client_content\",\"sublevels_available\":" +
std::string(client_content.sublevels_available ? "true" : "false") +
",\"sublevel_count\":" + std::to_string(client_content.sublevel_count) +
",\"requested_sublevel_present\":" + (client_content.requested_sublevel_present ? "true" : "false") +
",\"player_manager_present\":" + (client_content.player_manager_present ? "true" : "false") +
",\"players_available\":" + (client_content.players_available ? "true" : "false") +
",\"local_player_count\":" + std::to_string(client_content.local_player_count) +
",\"controllable_reference_count\":" + std::to_string(client_content.controllable_reference_count) + "}";
if (content_json != r.last_client_content) { record(content_json); r.last_client_content = content_json; }
if (sublevels_read) {
const auto sublevel_json = dingosdk::sublevel_catalog_json(sublevels);
if (sublevel_json != r.last_sublevels) {
dingosdk::logging::log(dingosdk::logging::Level::info, dingosdk::logging::Context::server,
dingosdk::logging::Channel::level, "Server sublevel catalog: {} entries; available={}, root active={}.",
sublevels.levels.size(), sublevels.available, sublevels.active);
dingosdk::logging::event(dingosdk::logging::Context::server, dingosdk::logging::Channel::level,
"{\"event\":\"server_sublevels\",\"catalog\":" + sublevel_json + "}");
r.last_sublevels = sublevel_json;
}
}
if (state != r.previous_state || description.level != r.last_level) {
record("{\"event\":\"engine_state\",\"state\":" + std::to_string(state) +
",\"description\":" + dingosdk::world_description_json(description) + "}");
r.previous_state = state;
r.last_level = description.level;
}
if (!r.catalog_logged && catalog.available && native_level_count && !catalog.levels.empty()) {
record("{\"event\":\"level_catalog\",\"catalog\":" + dingosdk::world_catalog_json(catalog) + "}");
r.catalog_logged = true;
const auto manifest_count = static_cast<std::size_t>(std::count_if(
catalog.levels.begin(), catalog.levels.end(), [](const auto& level) { return level.manifest_only; }));
activity_line(dingosdk::ConsoleSource::level,
"Discovered " + std::to_string(catalog.levels.size()) + " levels (" +
std::to_string(native_level_count) + " native, " + std::to_string(manifest_count) +
" manifest). Ready for manual selection.");
}
dingosdk::overlay::Model model;
const auto missions_model = dingosdk::local_profile_missions();
model.progression = dingosdk::local_profile_progression();
model.player_card = dingosdk::local_profile_player_card();
model.hall_of_meat = {dingosdk::hall_of_meat::available(), dingosdk::hall_of_meat::enabled()};
model.road_rash = {dingosdk::road_rash::available(), dingosdk::road_rash::enabled(), dingosdk::road_rash::blood()};
const auto breakable_deck = dingosdk::board_break::deck();
model.board_break = {dingosdk::board_break::available(), dingosdk::board_break::enabled(), !breakable_deck.empty(),
dingosdk::board_break::deck_label(breakable_deck)};
{
const auto feel = dingosdk::board_break::settings();
auto& bb = model.board_break;
bb.always = feel.always;
bb.rails = feel.rails;
bb.wear = feel.wear;
bb.crack_sounds = feel.crack_sounds;
bb.body_sounds = feel.body_sounds;
bb.sensitivity = feel.sensitivity;
bb.joined = feel.joined;
bb.wear_rate = feel.wear_rate;
bb.worn = dingosdk::board_break::wear();
bb.condition = std::string(dingosdk::board_break::condition_name(bb.worn));
}
model.grind_exit = {dingosdk::grind_exit_control::available(), dingosdk::grind_exit_control::enabled(),
dingosdk::grind_exit_control::toe_heel(), dingosdk::grind_exit_control::stance(),
dingosdk::grind_exit_control::strength()};
model.bindings = dingosdk::local_profile_controller_bindings();
model.parks = dingosdk::local_profile_parks();
model.world = dingosdk::local_profile_world_layers();
model.missions_available = missions_model.available;
model.mission_feedback = missions_model.feedback;
for (const auto& row : missions_model.rows) model.missions.push_back({row.id, row.group, row.completed});
model.state = state_name(state);
model.detail = description.level.empty() ? "Waiting for a level description" : description.level;
if (!description.lm_level.empty()) {
bool active = false;
for (const auto& level : sublevels.levels)
active = active || (sublevels.available && sublevels.active && level.state == 5 && equals(level.asset, description.lm_level));
model.detail += "\nSublevel: " + description.lm_level + (active ? " (active on local server)" : " (not yet confirmed active)");
model.detail += "\nClient sublevel: " + std::string(!client_content.sublevels_available ? "unavailable" :
(client_content.requested_sublevel_present ? "present" : "not present"));
}
model.detail += client_content.players_available ? "\nLocal players: " + std::to_string(client_content.local_player_count) +
" | Controllable references: " + std::to_string(client_content.controllable_reference_count) : "\nLocal players: unavailable";
for (const auto& level : catalog.levels) {
dingosdk::overlay::Level choice;
choice.asset = level.asset;
choice.display_name = level.display_name;
choice.manifest_start_point = level.manifest_start_point;
choice.native_registered = !level.manifest_only;
choice.custom = level.custom;
for (const auto& point : level.start_points) choice.start_points.push_back(point.name);
choice.can_load = catalog.available && context_ready;
choice.load_block_reason = "Waiting for this process's native local world context.";
model.levels.push_back(std::move(choice));
}
const bool local = (state == 13 || state == 21) && context_ready && catalog.available && !catalog.levels.empty();
model.can_queue_load = local;
model.load_block_reason = local ? "" : "Waiting for an active local level and initialized level manager.";
if (!catalog.available) model.load_block_reason = catalog.issue;
const auto readiness = "{\"event\":\"load_readiness\",\"can_load\":" + std::string(local ? "true" : "false") +
",\"state\":" + std::to_string(state) +
",\"context_ready\":" + (context_ready ? "true" : "false") +
",\"game_type\":" + std::to_string(game_type) +
",\"catalog_available\":" + (catalog.available ? "true" : "false") +
",\"level_count\":" + std::to_string(catalog.levels.size()) + "}";
if (readiness != r.last_readiness) {
record(readiness);
r.last_readiness = readiness;
}
bool load_busy{};
{ std::lock_guard lock(r.mutex); load_busy = r.requests.loading(); }
dingosdk::update_local_world_controls(!r.observer_failed && !load_busy && local && context_ready &&
(state == 13 || state == 21) && model.world.ready ? model.world.map : dingosdk::WorldMap::none);
model.world_controls = dingosdk::local_profile_world_controls();
dingosdk::update_local_graphics_controls();
model.graphics = dingosdk::local_profile_graphics_controls();
model.object_persistence = dingosdk::local_profile_object_persistence();
// The park list is a disk walk of the Mods folder: only while the menu or the editor shows it.
dingosdk::set_park_mod_list_visible(r.debug_model.park_editor ||
GetTickCount64() < r.named_settings_wanted_until.load(std::memory_order_relaxed));
model.editor = dingosdk::local_park_editor();
// Spectating only needs one controllable local player; it works on every
// map, including custom mod levels.
r.spectate_ready = local && !load_busy && client_content.players_available &&
client_content.local_player_count == 1 && client_content.controllable_reference_count == 1;
r.spectate_client = client;
std::optional<Request> request;
{
std::lock_guard lock(r.mutex);
if (r.requests.inflight()) {
r.transition_seen = r.transition_seen || state != r.requested_from;
const bool manifest_sublevel = !r.last_lm_level.empty() &&
std::any_of(catalog.levels.begin(), catalog.levels.end(), [&](const auto& level) {
return level.manifest_only && equals(level.asset, r.last_lm_level);
});
bool sublevel_active = r.last_lm_level.empty();
for (const auto& level : sublevels.levels)
sublevel_active = sublevel_active || (sublevels.available && sublevels.active && level.state == 5 &&
equals(level.asset, r.last_lm_level));
const bool client_sublevel_present = r.last_lm_level.empty() ||
(client_content.sublevels_available && client_content.requested_sublevel_present);
// Native destinations are corroborated by both stock sublevel
// registries. A Studio manifest destination may not be published by
// one or both supplemental registries, so the engine's settled state
// plus its exact active WorldDescription is authoritative.
const bool manifest_description_active = manifest_sublevel && description.available &&
equals(description.level, r.last_request) &&
equals(description.lm_level, r.last_lm_level);
const bool content_confirmed = manifest_sublevel ? manifest_description_active :
(sublevel_active && client_sublevel_present);
const bool settled = r.transition_seen && (state == 13 || state == 21) && content_confirmed;
const bool timed_out = now - r.request_started >= 90000 && (state == 13 || state == 21) && local;
const bool cancelled = state == 2 || state == 24 || state == 25;
if (settled || timed_out || cancelled) {
const bool destination_matched = settled && equals(description.level, r.last_request) &&
(r.last_lm_level.empty() || equals(description.lm_level, r.last_lm_level));
const bool start_points_matched =
(r.last_start.empty() || equals(description.start_point, r.last_start)) &&
(r.last_lm_start.empty() || equals(description.lm_start_point, r.last_lm_start));
// A start point is a placement request, not part of a detached
// custom level's loaded identity. Preserve the comparison in
// diagnostics, but do not report a loaded custom world as failed
// if the engine normalizes or substitutes its default spawn.
const bool matched = destination_matched &&
(manifest_sublevel || start_points_matched);
r.load_result = matched ? (manifest_sublevel ?
"Requested custom destination is active; player control is not yet verified." :
"Requested root loaded and sublevel content is present; player control is not yet verified.") :
"The requested level/start point did not finish loading as expected.";
record("{\"event\":\"native_level_result\",\"matched\":" + std::string(matched ? "true" : "false") +
",\"timed_out\":" + (timed_out ? "true" : "false") +
",\"manifest_sublevel\":" + (manifest_sublevel ? "true" : "false") +
",\"manifest_description_active\":" + (manifest_description_active ? "true" : "false") +
",\"start_points_matched\":" + (start_points_matched ? "true" : "false") +
",\"server_sublevel_active\":" + (sublevel_active ? "true" : "false") +
",\"client_sublevel_present\":" + (client_sublevel_present ? "true" : "false") +
",\"description\":" + dingosdk::world_description_json(description) + "}");
activity_line(dingosdk::ConsoleSource::level,
matched ? "Level content loaded: " + r.last_request +
(r.last_lm_level.empty() ? "" : " + " + r.last_lm_level)
: (timed_out ? "Level load timed out: " : "Level load did not complete: ") + r.last_request,
matched ? dingosdk::ConsoleSeverity::success : dingosdk::ConsoleSeverity::warning);
r.requests.finish_load();
dingosdk::loading_screen::cancel();
}
}
if (!r.load_result.empty()) model.detail += "\n" + r.load_result;
if (r.requests.inflight()) {
model.can_queue_load = false;
model.load_block_reason = "Waiting for the requested level to finish loading.";
}
request = r.requests.take_load();
r.menu_splash_ready = local && description.available &&
equals(description.level, "levels/Game/DingoLevel_Splash/DingoLevel_Splash");
if (!r.menu_splash_ready || (!r.requests.loading() && !request)) r.menu_load_queued = false;
r.model = std::move(model);
++r.model_revision;
}
// Start San Van as soon as the splash world's local loader is ready. Use
// the normal request scheduler, preserving user/join requests and all
// transition cleanup. This is a once-per-process startup action.
if (!r.startup_load_queued) {
if (request || (local && description.available && !r.menu_splash_ready))
r.startup_load_queued = true;
else if (queue_menu_bam()) r.startup_load_queued = true;
}
if (!request) return;
const dingosdk::LevelInfo* selected_level = nullptr;
for (const auto& level : catalog.levels)
if (!level.manifest_only && equals(level.asset, request->asset)) selected_level = &level;
if (!local || !registered_request(catalog, *request) || !selected_level) {
activity_line(dingosdk::ConsoleSource::level,
"Load rejected: local context or selected level changed.", dingosdk::ConsoleSeverity::warning);
record("{\"event\":\"native_level_rejected\",\"reason\":\"context_or_selection_changed\"}");
std::lock_guard lock(r.mutex);
r.requests.finish_load();
r.model.load_block_reason = "Load rejected: the local context or registered selection changed.";
++r.model_revision;
return;
}
// Validated afresh for the restore, which may itself change the camera.
frame.camera_issue.reset();
const bool restored = dingosdk::restore_client_debug(r.base, client, camera_phase_ready());
DingoSDKOverlaySetFreecamInputCapture(false);
frame.camera_issue.reset();
if (!restored) {
std::lock_guard lock(r.mutex);
r.requests.finish_load();
r.load_result = "Load cancelled: restore the current debug camera/settings first, then retry.";
activity_line(dingosdk::ConsoleSource::level, r.load_result, dingosdk::ConsoleSeverity::warning);
return;
}
if (!dingosdk::multiplayer::prepare_native_menu_level_load(r.base)) {
std::lock_guard lock(r.mutex);
r.requests.finish_load();
r.load_result = "Load cancelled: menu cleanup could not finish. Close the pause menu and retry.";
activity_line(dingosdk::ConsoleSource::level, r.load_result, dingosdk::ConsoleSeverity::warning);
return;
}
{
std::lock_guard lock(r.mutex);
r.requests.submitted_load();
r.transition_seen = false;
r.requested_from = state;
r.request_started = now;
r.last_request = request->asset;
r.last_start = request->start;
r.last_lm_level = request->lm_level;
r.last_lm_start = request->lm_start;
r.load_result.clear();
r.model.can_queue_load = false;
r.model.load_block_reason = "Level request submitted; waiting for engine loading.";
++r.model_revision;
}
dingosdk::WorldDescription selected;
selected.available = true; selected.level = request->asset; selected.start_point = request->start;
selected.lm_level = request->lm_level; selected.lm_start_point = request->lm_start;
selected.flags[0] = selected_level->level_flag68;
const bool hosted = reinterpret_cast<HostedSelector>(r.base + rt::hosted_level_selector)(request->asset.c_str());
activity_line(dingosdk::ConsoleSource::level, "Loading " + request->asset +
(request->lm_level.empty() ? "" : " + " + request->lm_level) +
" (" + (hosted ? "local hosted server" : "single player") + ").");
record("{\"event\":\"native_level_request\",\"predicted_route\":\"" + std::string(hosted ? "HostedLocal" : "SinglePlayer") +
"\",\"selection\":" + dingosdk::world_description_json(selected) + "}");
dingosdk::multiplayer::host_map_change(request->asset + "|" + request->lm_level);
submit_local(r.base, client, *request, selected_level->level_flag68);
}
}
void tick(std::uintptr_t client, std::uintptr_t update) {
const auto incoming_error = GetLastError();
// The profiler's client update timing: the native update, and ReSkate's own work around it.
const auto tick_start = dingosdk::profiler::now_ns();
auto& r = runtime();
dingosdk::poll_level_loading(client);
dingosdk::camera_tick_enter(client);
struct CameraTickScope {
~CameraTickScope() {
const auto error = GetLastError();
dingosdk::camera_tick_leave();
SetLastError(error);
}
} camera_tick_scope;
SetLastError(incoming_error);
const auto native_start = dingosdk::profiler::now_ns();
r.original_tick(client, update);
const auto native_time = dingosdk::profiler::now_ns() - native_start;
struct RecordUpdate {
std::uint64_t start, native;
~RecordUpdate() { dingosdk::profiler::record_client_update(dingosdk::profiler::now_ns() - start - native); }
} record_update{tick_start, native_time};
struct PreserveTickError {
DWORD value{GetLastError()};
~PreserveTickError() { SetLastError(value); }
} preserve_tick_error;
dingosdk::camera_tick_native_return();
dingosdk::poll_level_loading(client);
try {
TickState tick_state;
{
DINGO_PROFILE_ZONE("tick/update_model");
update_model(client, tick_state);
}
if (r.engine_thread.load() != GetCurrentThreadId()) return;
DWORD state{},game_type{};
bool loading{};
{ std::lock_guard lock(r.mutex); loading=r.requests.loading(); }
// update_model's context check, when it made one for this same state and mode.
const auto context_ready = [&] {
return tick_state.valid && tick_state.context && tick_state.state == state && tick_state.game_type == game_type
? *tick_state.context : native_context(r.base, client, game_type);
};
const bool multiplayer_ready=!r.observer_failed && !loading &&
memory::peek(client+0xc4,state) && (state==13 || state==21) && memory::peek(client+0xc0,game_type) &&
context_ready();
{
DINGO_PROFILE_ZONE("tick/multiplayer");
dingosdk::multiplayer::tick(r.base,client,multiplayer_ready,r.multiplayer_map,load_multiplayer_map);
if (multiplayer_ready) {
dingosdk::multiplayer::tick_prop_test(r.base, client);
// Other players' drones as models in the world (DRONE page, LOBBY tab: show other players' drones).
dingosdk::multiplayer::tick_drone_models(r.base, client,
dingosdk::drone::knobs().value[dingosdk::drone::kShowBeacons].load(std::memory_order_relaxed) >= 0.5f);
}
// And heard where they fly (every frame, so their sounds stop on leaving a level).
dingosdk::multiplayer::tick_drone_sounds(r.base, client, multiplayer_ready,
dingosdk::drone::knobs().value[dingosdk::drone::kShowBeacons].load(std::memory_order_relaxed) >= 0.5f);
if (auto notice = dingosdk::multiplayer::take_leave_notice(); !notice.empty())
dingosdk::overlay::notify(dingosdk::overlay::NoticeLevel::warning, "Map not installed", std::move(notice));
// Kicked, banned or otherwise put out by the host or server: said in the middle of
// the screen, to be answered (message_card.cpp).
if (auto removed = dingosdk::multiplayer::take_removed_notice(); !removed.empty()) {
const char* title = removed.find("banned") != std::string::npos ? "YOU WERE BANNED"
: removed.find("kicked") != std::string::npos ? "YOU WERE KICKED" : "YOU WERE REMOVED";
dingosdk::overlay::show_message(title, std::move(removed));
}
// Or, when the host said which Thunderstore package its map is from, the offer to
// fetch it (map_download.h), which then applies it and joins the session again.
if (const auto need = dingosdk::multiplayer::take_map_need()) dingosdk::map_download::offer(*need);
dingosdk::map_download::tick();
dingosdk::map_icons::tick();
dingosdk::texture_handle_limit::tick();
dingosdk::report_native_render_resources();
// (Whether a menu of the game's is up, the music screen among them: a playlist changed then
// is the player's own choice, and one changed in play is a speaker's music being grabbed.)
{
const bool menu = dingosdk::multiplayer::sample_game_ui_state(r.base).in_menu;
static bool was{};
if (menu != was) {
was = menu;
try {
dingosdk::logging::log(dingosdk::logging::Level::debug, dingosdk::logging::Channel::music, "Trace: a menu of the game's is {}.", menu ? "up" : "no longer up");
} catch (...) {}
}
dingosdk::spotify_station::set_music_screen(menu);
}
dingosdk::spotify_station::tick();
dingosdk::music_inject::tick();
}
dingosdk::multiplayer::refresh_identity_lists();
// How much memory the game holds, beside what a session adds to it: said when it has
// moved by a quarter of a gigabyte or the players or skaters have changed much, at most
// every ten seconds. For telling what a full server's memory goes on (the map, every
// player, or only the skaters that are built).
if (static std::uint64_t next_memory{}; GetTickCount64() >= next_memory) {
next_memory = GetTickCount64() + 10000;
PROCESS_MEMORY_COUNTERS_EX counters{};
counters.cb = sizeof(counters);
if (GetProcessMemoryInfo(GetCurrentProcess(), reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&counters), sizeof(counters))) {
const auto mp = dingosdk::multiplayer::model();
const bool session = mp.active && !mp.echo && (mp.hosting || mp.connected);
const int players = session ? static_cast<int>(mp.roster.size()) : 0;
const int skaters = session ? static_cast<int>(std::ranges::count_if(mp.roster, [](const auto& player) { return player.visible; })) : 0;
static std::uint64_t said_private{};
static int said_players = -1, said_skaters = -1;
const auto moved = counters.PrivateUsage > said_private ? counters.PrivateUsage - said_private : said_private - counters.PrivateUsage;
// (And every two minutes whatever it has done: a slow leak moves it by less than
// that quarter for a long while.)
static std::uint64_t said_at{};
if (moved >= (256ull << 20) || std::abs(players - said_players) >= 5 || std::abs(skaters - said_skaters) >= 5 ||
GetTickCount64() - said_at >= 120000) {
said_at = GetTickCount64();
said_private = counters.PrivateUsage; said_players = players; said_skaters = skaters;
const auto gigabytes = [](std::uint64_t bytes) { return static_cast<double>(bytes) / (1024.0 * 1024.0 * 1024.0); };
// Handles grow with a leak of them (a leak looked for in the music player,
// 2026-10-13); counting them is cheap.
//
// The heaps' sizes and the threads were counted here as well, and that held the
// game's frame up: HeapSummary walks a whole heap with its lock held, which took
// the client thread from half a second to two seconds each time (a player's
// profile, 2026-10-15), every two minutes and at each change above. They are not
// counted any more. The GPU's share and the memory ledger (a DXGI factory, a lock)
// are written from a thread of their own, so the line costs the frame nothing.
DWORD handles{};
GetProcessHandleCount(GetCurrentProcess(), &handles);
auto line = std::format(
"Memory: {:.2f} GB committed, {:.2f} GB in RAM; {} player(s) in the session, {} built as skaters "
"(player distance {:.0f} m); map {}. {} handle(s).",
gigabytes(counters.PrivateUsage), gigabytes(counters.WorkingSetSize), players, skaters, mp.player_distance,
session && !mp.map.empty() ? mp.map : r.multiplayer_map, handles);
try {
std::thread([line = std::move(line)]() mutable {
try {
// The GPU's share (its system memory is not in the committed figure),
// and while the memory ledger is on, who holds the most (memory_ledger.h).
if (const auto gpu = dingosdk::memory_ledger::gpu_line(); !gpu.empty()) line += " " + gpu + ".";
if (const auto owners = dingosdk::memory_ledger::owners_line(); !owners.empty()) line += " " + owners + ".";
dingosdk::logging::write(dingosdk::logging::Level::info, dingosdk::logging::Channel::runtime, line);
} catch (...) {}
}).detach();
} catch (...) {}
}
}
}
// The player's Discord status (discord_presence.h): where they skate and with whom,
// looked at every couple of seconds.
if (static std::uint64_t next_presence{}; dingosdk::discord_presence::available() && GetTickCount64() >= next_presence) {
next_presence = GetTickCount64() + 2000;
const auto mp = dingosdk::multiplayer::model();
const bool session = mp.active && !mp.echo && (mp.hosting || mp.connected);
// A destination is "root|level": the level names the map. Maps ReSkate adds are "reskate <name>".
const std::string_view destination = session && !mp.map.empty() ? std::string_view(mp.map) : std::string_view(r.multiplayer_map);
auto map = dingosdk::world_level_name(destination.substr(destination.find_last_of('|') + 1));
if (map.size() > 8 && (map.starts_with("reskate ") || map.starts_with("ReSkate "))) map.erase(0, 8);
dingosdk::discord_presence::Presence presence;
presence.details = map.empty() ? std::string("Skating") : "On " + map;
if (!session) {
presence.state = "Solo skating";
} else {
// A session behind a password keeps its name to itself.
presence.state = mp.password_required ? std::string(mp.dedicated ? "Private server" : "Private lobby")
: mp.lobby_name.empty() ? std::string(mp.dedicated ? "On a server" : "In a lobby")
: (mp.dedicated ? "Server: " : "Lobby: ") + mp.lobby_name;
presence.party_size = mp.players;
presence.party_most = std::max(mp.capacity, mp.players);
presence.party = std::to_string(mp.host_id);
// Anyone may walk in: no password, and a server or a lobby that is publicly listed
// (one shared by code stays with those who were given the code).
if (!mp.password_required && (mp.dedicated || (mp.public_host && mp.lobby_listed) || mp.public_lobby))
presence.join = mp.join_code;
}
dingosdk::discord_presence::update(std::move(presence));
}
// A session the player chose to join from Discord, once the game can join one.
if (static std::string discord_join; dingosdk::discord_presence::available()) {
if (auto asked = dingosdk::discord_presence::take_join(); !asked.empty()) discord_join = std::move(asked);
if (!discord_join.empty() && multiplayer_ready && dingosdk::multiplayer::queue_command("join", discord_join, ""))
discord_join.clear();
}
dingosdk::tick_local_developer_hoodie(r.base, client, multiplayer_ready);
dingosdk::tick_local_developer_board(r.base, client, multiplayer_ready);
// The session spawns and places skaters and can teleport: check the camera again.
tick_state.camera_issue.reset();
// The spectate camera follows a moving skater, so it runs every client tick, after the
// session placed the remote skaters for this frame (and also out of play, to give up).
std::uintptr_t camera_context{};
const bool camera_phase = tick_state.camera_issue ? *tick_state.camera_issue == nullptr :
memory::peek(client + 8, camera_context) && !dingosdk::camera_probe_unavailable_reason(camera_context);
{
DINGO_PROFILE_ZONE("tick/native party");
dingosdk::multiplayer::tick_native_party_actions(r.base, client,
r.spectate_ready && r.spectate_client == client && (state == 13 || state == 21), camera_phase);
}
if (state == 13 || state == 21) {
DINGO_PROFILE_ZONE("tick/camera view");
// The camera ReSkate's nametags start from, and the spectate camera's lesson in how
// the game frames the local skater.
if (dingosdk::publish_local_camera_view(r.base, client))
if (const auto view = dingosdk::latest_game_view())
dingosdk::multiplayer::observe_gameplay_camera(r.base, *view);
}
// Same verified client scope in which remote skater actors are created.
{
DINGO_PROFILE_ZONE("tick/AI skaters");
dingosdk::ai_skaters::tick(r.base,client,multiplayer_ready);
}
{
DINGO_PROFILE_ZONE("tick/trainer");
// A custom map is a sublevel of the root level: that is the map the player means.
dingosdk::trainer::tick(r.base, client, multiplayer_ready, r.catalog_level.empty() ? r.last_level : r.catalog_level);
}
{
DINGO_PROFILE_ZONE("tick/Steam friend join");
dingosdk::multiplayer::tick_steam_friend_join();
}
// Model creation requires cleanup on every native unload, including
// transitions that bypass the ReSkate request scheduler.
if (r.native_loading_logging) {
DINGO_PROFILE_ZONE("tick/native menu");
dingosdk::multiplayer::tick_native_menu(r.base, loading);
}
}
catch (const std::exception&) {
if (!r.observer_failed.exchange(true)) activity_line(dingosdk::ConsoleSource::runtime,
"Debug controller stopped after an observation error. See the runtime log.", dingosdk::ConsoleSeverity::error);
std::lock_guard lock(r.mutex);
r.model.can_queue_load = false;
r.model.load_block_reason = "Debug controller stopped after a local observation error.";
++r.model_revision;
r.requests.fault();
}
}
}
Reference in new issue View Git Blame Copy Permalink