mirror of
https://github.com/Dingo-Shenanigans/ReSkate.git
synced 2026-10-23 16:25:58 +02:00
AyeZeeBB
f37abef426
- With events.tricks a plugin hears the local skater's tricks: trick_started (where), trick_landed (points, multiplier, where it started and landed, how long it took) and line_broken (a slam or a wipeout); reskate.score.current() is the score HUD's line, multiplier and whether a trick is going on. Without the permission the events cannot be registered. - The score HUD is read into the trick watch (Extension/Skater/score_hud.h, trick_watch.h) on the client tick only while a running plugin has events.tricks; a new level starts a new line. plugins::start takes the image base for it. - reskate-test has a tricks module (skipped until a trick lands) and ptest trick, which waits 30 s for one and prints what its events said; reskate-hostile has trick-loop. Not yet checked against real tricks in game.
256 lines
10 KiB
C++
256 lines
10 KiB
C++
#include "plugin_runtime.h"
|
|
#include "plugin_discovery.h"
|
|
#include "plugin_host.h"
|
|
#include "Engine/Core/Log/logging.h"
|
|
#include "Engine/Game/Multiplayer/session_tools.h"
|
|
#include "Extension/Console/commands.h"
|
|
#include "Extension/Profile/local_profile_runtime.h"
|
|
#include "Extension/Skater/score_hud.h"
|
|
#include "Extension/Skater/trick_watch.h"
|
|
#include "Extension/Trainer/trainer.h"
|
|
#include <Windows.h>
|
|
#include <ShlObj.h>
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <format>
|
|
#include <mutex>
|
|
#include <numbers>
|
|
#include <thread>
|
|
|
|
namespace dingosdk::plugins {
|
|
namespace {
|
|
class GameEnvironment final : public Environment {
|
|
public:
|
|
explicit GameEnvironment(std::filesystem::path storage) : storage_(std::move(storage)) {}
|
|
void log(LogLevel level, std::string_view text) override {
|
|
logging::write(level == LogLevel::error ? logging::Level::error : level == LogLevel::warn ? logging::Level::warning : logging::Level::info,
|
|
logging::Channel::plugins, text);
|
|
}
|
|
// As the console's own lines are written (console_line): an "error: " line is shown as one.
|
|
void console(std::string_view text) override {
|
|
const bool error = text.starts_with("error: ");
|
|
logging::write(error ? logging::Level::error : logging::Level::info, logging::Channel::command, error ? text.substr(7) : text);
|
|
}
|
|
double now_ms() override {
|
|
return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now().time_since_epoch()).count();
|
|
}
|
|
std::filesystem::path storage_root() override { return storage_; }
|
|
bool builtin_command(std::string_view word) override {
|
|
const auto& commands = console::game_commands();
|
|
return commands.find(word) || !commands.under(word).empty();
|
|
}
|
|
// The trainer's telemetry of the local skater, published each tick. Its heading is 0 to 360
|
|
// degrees the same way round; plugins get -pi to pi.
|
|
std::optional<SkaterState> skater() override {
|
|
const auto t = trainer::telemetry();
|
|
if (!t.skater) return std::nullopt;
|
|
const float heading = std::remainder(t.heading * std::numbers::pi_v<float> / 180, 2 * std::numbers::pi_v<float>);
|
|
return SkaterState{t.position, heading, t.speed, t.vertical, t.airborne, t.air_time};
|
|
}
|
|
// As the console's tp: refused in a session whose host has turned teleporting (and noclip) off.
|
|
Teleport teleport(const Vec3& position, float heading) override {
|
|
if (!session_noclip_allowed()) return Teleport::forbidden;
|
|
return teleport_local_skater_heading(position, heading) ? Teleport::sent : Teleport::unavailable;
|
|
}
|
|
std::optional<Vec3> raycast(const Vec3& from, const Vec3& to) override { return local_surface_hit(from, to); }
|
|
std::optional<ScoreState> score() override { return score_now; }
|
|
std::optional<ScoreState> score_now; // read each tick while a plugin wants tricks
|
|
|
|
private:
|
|
std::filesystem::path storage_;
|
|
};
|
|
|
|
std::filesystem::path data_root;
|
|
// Left to the process's end on purpose: unloading plugins from a static destructor would run
|
|
// their scripts while the game shuts down.
|
|
GameEnvironment* environment{};
|
|
Host* host{};
|
|
std::mutex found_mutex;
|
|
std::vector<Candidate> found; // under found_mutex
|
|
std::uint64_t found_generation{}; // under found_mutex
|
|
std::uint64_t applied_generation{};
|
|
std::chrono::steady_clock::time_point last_tick{};
|
|
std::uintptr_t base{};
|
|
// The local skater's tricks (Extension/Skater/trick_watch.h), and where and when the one going on began.
|
|
tricks::TrickWatch trick_watch;
|
|
Vec3 started_at{};
|
|
std::chrono::steady_clock::time_point started_time{};
|
|
std::string watched_level;
|
|
|
|
// The score HUD into the trick watch, and what it saw to the plugins. Client thread.
|
|
void read_tricks() {
|
|
const auto hud = tricks::read_score_hud(base);
|
|
if (!hud) {
|
|
environment->score_now.reset();
|
|
return;
|
|
}
|
|
const auto skater = trainer::telemetry();
|
|
tricks::TrickSignals signals;
|
|
signals.action = hud->action;
|
|
signals.line_score = hud->line_score;
|
|
signals.multiplier = hud->multiplier;
|
|
signals.slam = hud->slam;
|
|
// A wipeout is physics states 300-399 (as Domination reads it).
|
|
signals.wipeout = skater.skater && skater.physics_state >= 300 && skater.physics_state < 400;
|
|
const auto event = trick_watch.update(signals);
|
|
environment->score_now = ScoreState{hud->line_score, hud->multiplier, trick_watch.in_trick()};
|
|
const auto now = std::chrono::steady_clock::now();
|
|
TrickNews news;
|
|
switch (event.kind) {
|
|
case tricks::TrickEvent::Kind::none: return;
|
|
case tricks::TrickEvent::Kind::started:
|
|
started_at = skater.position;
|
|
started_time = now;
|
|
news.kind = TrickNews::Kind::started;
|
|
news.started_at = started_at;
|
|
break;
|
|
case tricks::TrickEvent::Kind::landed:
|
|
news.kind = TrickNews::Kind::landed;
|
|
news.points = event.points;
|
|
news.multiplier = event.multiplier;
|
|
news.started_at = started_at;
|
|
news.landed_at = skater.position;
|
|
news.ms = std::chrono::duration<double, std::milli>(now - started_time).count();
|
|
break;
|
|
case tricks::TrickEvent::Kind::broken:
|
|
news.kind = TrickNews::Kind::broken;
|
|
news.reason = signals.slam ? "slam" : "wipeout";
|
|
break;
|
|
}
|
|
host->trick(news);
|
|
}
|
|
|
|
void watch() {
|
|
FileChecks checks;
|
|
for (;;) {
|
|
try {
|
|
auto plugins = discover(data_root, checks);
|
|
std::lock_guard lock(found_mutex);
|
|
if (plugins != found || !found_generation) {
|
|
found = std::move(plugins);
|
|
++found_generation;
|
|
}
|
|
} catch (const std::exception& error) {
|
|
logging::log(logging::Level::warning, logging::Channel::plugins, "Looking for plugins failed: {}", error.what());
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::seconds(2));
|
|
}
|
|
}
|
|
|
|
std::filesystem::path local_storage() {
|
|
PWSTR raw{};
|
|
std::filesystem::path result;
|
|
if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &raw)) && raw)
|
|
result = std::filesystem::path(raw) / L"ReSkate" / L"Plugins";
|
|
CoTaskMemFree(raw);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
bool start(std::uintptr_t image_base) noexcept {
|
|
try {
|
|
if (host) return true;
|
|
base = image_base;
|
|
std::array<wchar_t, 32768> path{};
|
|
const auto length = GetModuleFileNameW(nullptr, path.data(), static_cast<DWORD>(path.size()));
|
|
if (!length || length >= path.size()) return false;
|
|
data_root = std::filesystem::path(std::wstring(path.data(), length)).parent_path();
|
|
auto storage = local_storage();
|
|
if (storage.empty()) storage = data_root / L"ReSkate.Plugins";
|
|
environment = new GameEnvironment(std::move(storage));
|
|
host = new Host(*environment, Side::client);
|
|
std::thread(watch).detach();
|
|
logging::write(logging::Level::info, logging::Channel::plugins, "Plugins: looking in Mods for reskate-plugin.json every 2 s.");
|
|
return true;
|
|
} catch (const std::exception& error) {
|
|
logging::log(logging::Level::error, logging::Channel::plugins, "Plugins could not start: {}", error.what());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void on_client_tick() noexcept {
|
|
if (!host) return;
|
|
try {
|
|
{
|
|
std::vector<Candidate> latest;
|
|
bool changed = false;
|
|
{
|
|
std::lock_guard lock(found_mutex);
|
|
if (found_generation != applied_generation) {
|
|
latest = found;
|
|
applied_generation = found_generation;
|
|
changed = true;
|
|
}
|
|
}
|
|
if (changed) host->apply(latest);
|
|
}
|
|
const auto now = std::chrono::steady_clock::now();
|
|
const double dt = last_tick == std::chrono::steady_clock::time_point{} ? 0
|
|
: std::chrono::duration<double, std::milli>(now - last_tick).count();
|
|
last_tick = now;
|
|
if (host->wants_tricks()) read_tricks();
|
|
else environment->score_now.reset();
|
|
host->tick(dt);
|
|
} catch (const std::exception& error) {
|
|
logging::log(logging::Level::error, logging::Channel::plugins, "Plugin tick failed: {}", error.what());
|
|
}
|
|
}
|
|
|
|
void set_level(std::string_view level) noexcept {
|
|
if (!host) return;
|
|
try {
|
|
// A new level starts a new line: a trick going on before it scores nothing.
|
|
if (level != watched_level) {
|
|
watched_level = std::string(level);
|
|
trick_watch = tricks::TrickWatch{};
|
|
}
|
|
host->set_level(std::string(level));
|
|
}
|
|
catch (const std::exception& error) {
|
|
logging::log(logging::Level::error, logging::Channel::plugins, "Plugin level change failed: {}", error.what());
|
|
}
|
|
}
|
|
|
|
bool run_console(const std::string& text) noexcept {
|
|
if (!host) return false;
|
|
try { return host->run_console(text); }
|
|
catch (const std::exception& error) {
|
|
logging::log(logging::Level::error, logging::Channel::plugins, "Plugin command failed: {}", error.what());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
std::string describe() {
|
|
if (!host) return "error: Plugins did not start.";
|
|
const auto plugins = host->status();
|
|
if (plugins.empty()) return "No plugins. A plugin is a mod in Mods with a reskate-plugin.json.";
|
|
std::string text;
|
|
for (const auto& plugin : plugins) {
|
|
if (!text.empty()) text += '\n';
|
|
text += std::format("{}: {}", plugin.id, plugin.state);
|
|
if (plugin.state == "running")
|
|
text += std::format(", {:.1f} MB, {:.3f} ms a tick, {} command{}", plugin.memory / 1048576.0, plugin.tick_ms,
|
|
plugin.commands.size(), plugin.commands.size() == 1 ? "" : "s");
|
|
else if (!plugin.reason.empty()) text += " (" + plugin.reason + ")";
|
|
}
|
|
return text;
|
|
}
|
|
|
|
std::string list_commands() {
|
|
if (!host) return "error: Plugins did not start.";
|
|
std::string text;
|
|
for (const auto& plugin : host->status())
|
|
for (const auto& [name, help] : plugin.commands) {
|
|
if (!text.empty()) text += '\n';
|
|
text += std::format("{} - {} ({})", name, help, plugin.id);
|
|
}
|
|
return text.empty() ? "No plugin has a console command." : text;
|
|
}
|
|
|
|
std::string reload(std::string_view id) { return host ? host->reload(id) : "error: Plugins did not start."; }
|
|
std::string switch_off(std::string_view id) { return host ? host->switch_off(id) : "error: Plugins did not start."; }
|
|
std::string switch_on(std::string_view id) { return host ? host->switch_on(id) : "error: Plugins did not start."; }
|
|
}
|