DieMitchell/ReSkate
1
0 Fork 0
mirror of https://github.com/Dingo-Shenanigans/ReSkate.git synced 2026-10-24 17:06:17 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
118c489fdb9efef7e834c49f9c19092e992ef028
ReSkate/Extension/World/world_entities.cpp
T
AyeZeeBB 45346b122c Plugins: prop hunt APIs, and plugin commands in the console lookup 
- reskate.entities.blueprints lists the game's object blueprints (meshes only if asked),
  and reskate.entities.bounds gives a blueprint's box, so a mod can pick a prop by list or at random
- Attached objects take upright, turn and ground (a floor found within reach below), the "root"
  joint, and a 6th options argument with solid; spawned props' bodies are found and ghosted
- reskate.skater.hide, reskate.world.pick, and skater.get gives right and switch
- reskate.console.command takes an optional 4th table of subcommands; the console lookup
  suggests plugin commands word by word, and plugin commands lists the subcommands
- objbody: a test command for finding which body setter takes a prop out of collision
2026-10-22 00:30:06 -05:00

680 lines
33 KiB
C++
Raw Blame History

#include "world_entities.h"
#include "world_entities_contract.h"
#include "Engine/Core/Log/logging.h"
#include "Engine/Core/Platform/memory.h"
#include "Engine/Game/Abi/native_data.h"
#include "Engine/Game/Build/addresses.h"
#include "Engine/Game/Build/20260929/ai_skaters.h"
#include "Engine/Game/Build/20260929/engine.h"
#include "Engine/Game/Build/20260929/skater_entities.h"
#include "Extension/Multiplayer/Remote/native_skater.h"
#include <Windows.h>
#include <intrin.h>
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstring>
#include <format>
#include <map>
#include <mutex>
#include <optional>
#include <set>
#include <stdexcept>
#include <vector>
// The native calls are SmokeyDawg58's (from his fork's world objects): a bus under the
// local skater's ClientSkaterSource, a creation descriptor at the transform, CreateEntity from the
// blueprint, InitializePlacement; MoveSpatialEntity to move it, DestroyEntity to take it away.
namespace dingosdk::world_entities {
namespace {
namespace e = addr::skater_entities;
namespace b = addr::ai_skaters;
template<class T> T get(std::uintptr_t p) { T v{}; memory::peek(p, v); return v; }
std::uintptr_t ptr(std::uintptr_t p, std::uintptr_t offset = 0) { return get<std::uintptr_t>(p + offset); }
void require(bool ok, const char* why) { if (!ok) throw std::runtime_error(why); }
template<std::size_t N> void prefix(std::uintptr_t base, std::uintptr_t rva, const std::array<unsigned char, N>& expected) {
std::array<unsigned char, N> actual{};
require(memory::peek_bytes(base + rva, actual.data(), N) && actual == expected, "World object entity ABI differs.");
}
struct Wanted {
std::string asset;
Matrix matrix{};
bool hidden{};
std::optional<Attach> attach;
bool solid{true};
};
struct Live {
std::uintptr_t entity{}, owner{}, context{};
std::string asset;
Matrix matrix{};
std::uint64_t moved{};
// Its physics bodies once found, whether they are ghosted, and when to look for them again.
std::vector<Body> bodies;
bool looked{}, ghosted{};
std::uint64_t made{}, next_look{};
};
struct Asset {
std::uintptr_t asset{};
std::uint16_t domain{};
std::uint64_t retry{};
bool looked{};
};
using Key = std::pair<std::string, std::uint32_t>;
struct State {
detail::WorldObjectLifetime lifetime;
std::mutex mutex;
std::map<Key, Wanted> wanted;
std::map<Key, Live> live;
std::map<std::string, Asset> assets;
std::uintptr_t context{};
bool verified{};
std::string error, waiting;
std::map<Key, std::uint64_t> lost; // client thread: attached objects whose joint is not known, since when
};
State& state() { static auto* s = new State; return *s; }
std::atomic<JointSource> joint_source{};
Physics& physics() { static auto* value = new Physics; return *value; }
std::mutex test_mutex;
std::string test_request; // under test_mutex
std::atomic<bool> physics_set{};
// An object's physics bodies: in its entity and what it points to (two levels, objects with a
// vtable in the game image only), the physics world's address followed by a body the world says is
// valid. All of them must have one owner (a world object's own), and be few.
std::vector<Body> find_bodies(std::uintptr_t base, std::uintptr_t entity, std::uintptr_t world) {
const auto& p = physics();
std::vector<Body> found;
std::vector<std::pair<std::uintptr_t, unsigned>> queue{{entity, 0}};
std::set<std::uintptr_t> seen{entity};
const auto game_object = [&](std::uintptr_t at) {
const auto vtable = ptr(at);
return vtable >= base && vtable < base + 0x10000000;
};
for (std::size_t next = 0; next < queue.size() && queue.size() < 512; ++next) {
const auto [node, depth] = queue[next];
std::array<std::uintptr_t, 0x80> words{};
if (!memory::peek(node, words)) continue;
for (std::size_t i = 0; i < words.size(); ++i) {
const auto value = words[i];
if (value == world && i + 1 < words.size()) {
const Body body{world, words[i + 1]};
if (static_cast<std::uint32_t>(body[1]) < (1u << 24) && p.valid(body) &&
std::find(found.begin(), found.end(), body) == found.end())
found.push_back(body);
continue;
}
if (depth < 2 && value > 0x10000 && value < 0x7ff000000000 && !seen.contains(value) && game_object(value)) {
seen.insert(value);
queue.emplace_back(value, depth + 1);
}
}
}
if (found.empty() || found.size() > 16) return {};
const auto owner = p.owner(found.front());
for (const auto& body : found)
if (p.owner(body) != owner) return {};
return found;
}
// `offset` (in a joint's frame) placed on the joint: each row taken through the joint's axes.
Matrix on_joint(const Matrix& joint, const Matrix& offset) {
Matrix m{};
for (int row = 0; row < 4; ++row) {
for (int k = 0; k < 3; ++k) {
float v = row == 3 ? joint[12 + k] : 0.0f;
for (int j = 0; j < 3; ++j) v += offset[row * 4 + j] * joint[j * 4 + k];
m[row * 4 + k] = v;
}
}
m[15] = 1.0f;
return m;
}
// The joint stood level at its position: up is world up, and forward its own forward axis laid flat
// (its up axis laid flat when the forward axis points up or down). Rows right (fz, 0, -fx), up,
// forward, as the skater's own frame is (heading 0 faces +Z, right +X).
Matrix level(const Matrix& joint) {
float fx = joint[8], fz = joint[10];
if (std::hypot(fx, fz) < 0.2f * std::hypot(joint[8], joint[9], joint[10])) fx = joint[4], fz = joint[6];
const float length = std::hypot(fx, fz);
if (!(length > 1e-6f)) fx = 0, fz = 1;
else fx /= length, fz /= length;
return {fz, 0, -fx, 0, 0, 1, 0, 0, fx, 0, fz, 0, joint[12], joint[13], joint[14], 1};
}
void note(State& s, std::string issue) {
if (s.waiting == issue) return;
s.waiting = std::move(issue);
logging::log(logging::Level::debug, logging::Channel::runtime, "World objects: {}", s.waiting);
}
bool finite(const Matrix& m) {
for (const auto v : m)
if (!std::isfinite(v)) return false;
for (int axis = 0; axis < 3; ++axis) {
const float length = std::sqrt(m[axis * 4] * m[axis * 4] + m[axis * 4 + 1] * m[axis * 4 + 1] + m[axis * 4 + 2] * m[axis * 4 + 2]);
if (length > 200.f) return false;
}
return std::fabs(m[12]) < 100000.f && std::fabs(m[13]) < 100000.f && std::fabs(m[14]) < 100000.f;
}
std::uintptr_t parent_bus(std::uintptr_t base, std::uintptr_t context) {
return detail::object_parent_bus(base, context, [](auto at) { return ptr(at); },
[](auto at) { return get<std::uint32_t>(at); }, [](auto at) { return get<std::uint8_t>(at); },
[](auto at) -> std::string {
std::array<char, 256> text{};
if (!at || !memory::peek_bytes(at, text.data(), text.size()) || std::find(text.begin(), text.end(), '\0') == text.end()) return {};
return text.data();
});
}
bool intact(const Live& l) {
const auto collection = ptr(l.entity, 0x70);
return ptr(l.entity, 0x20) == l.context && ptr(l.entity, 0x40) == l.owner && collection && ptr(collection) == l.entity;
}
Live create(std::uintptr_t base, std::uintptr_t parent, std::uintptr_t asset, const Matrix& matrix) {
using CreateBus = std::uintptr_t (*)(std::uintptr_t, std::uintptr_t, std::uintptr_t, std::uintptr_t, std::uint8_t, std::uintptr_t);
const auto bus = reinterpret_cast<CreateBus>(base + b::create_bus)(ptr(ptr(parent, 8), 0x48), parent, 0, 0, 0, 0);
require(bus != 0, "World object entity bus unavailable.");
reinterpret_cast<int (*)(std::uintptr_t)>(base + b::acquire_bus)(bus);
struct BusScope {
std::uintptr_t base, bus;
~BusScope() { reinterpret_cast<void (*)(std::uintptr_t)>(base + e::release_reference)(bus); }
} bus_scope{base, bus};
alignas(16) std::array<unsigned char, 0x190> descriptor{};
reinterpret_cast<void* (*)(void*, std::uintptr_t, std::uintptr_t, const void*)>(base + e::descriptor_init)(descriptor.data(), 0, bus, matrix.data());
struct Scope {
std::uintptr_t base;
void* data;
~Scope() { reinterpret_cast<void (*)(void*)>(base + e::descriptor_destroy)(static_cast<unsigned char*>(data) + 0x10); }
} scope{base, descriptor.data()};
const std::uint32_t id = 255;
std::memcpy(descriptor.data() + 0x38, &id, 4);
descriptor[0x151] = 0;
std::array<std::uintptr_t, 3> result{};
reinterpret_cast<void* (*)(void*, void*, std::uintptr_t, std::uintptr_t, std::uintptr_t)>(base + e::create_entity)(result.data(), descriptor.data(), asset, 0, 0);
if (result[1]) reinterpret_cast<void (*)(std::uintptr_t)>(base + e::release_reference)(result[1]);
require(result[0] != 0, "A world object blueprint did not create an entity.");
Live live{result[0], ptr(result[0], 0x40), ptr(result[0], 0x20)};
reinterpret_cast<void (*)(std::uintptr_t, const void*, std::uintptr_t, std::uint8_t)>(base + e::initialize_placement)(live.entity, matrix.data(), 0, 1);
return live;
}
void move(std::uintptr_t base, const Live& l, const Matrix& matrix) {
reinterpret_cast<void (*)(std::uintptr_t, const void*, std::uint8_t, std::uint8_t)>(base + e::move_spatial_entity)(l.entity, matrix.data(), 1, 1);
}
void destroy(std::uintptr_t base, const Live& l) {
// No lock held: the shared destroy hook calls entity_destroyed back.
if (ptr(l.entity, 0x20) == l.context && ptr(l.entity, 0x40) == l.owner)
reinterpret_cast<void (*)(std::uintptr_t, std::uintptr_t)>(base + e::destroy_entity)(l.entity, l.owner);
}
void destroy_all(std::uintptr_t base) {
auto& s = state();
std::map<Key, Live> old;
{
std::lock_guard lock(s.mutex);
old.swap(s.live);
}
for (const auto& [key, l] : old) destroy(base, l);
}
// A blueprint by name: in a domain already known (validated each time), else looked for in every
// loaded domain at most once a second. UI and world bundles live in child domains, so the skater's
// parent domains alone cannot find a mod's objects.
std::uintptr_t resolve(std::uintptr_t base, Asset& a, const std::string& name, std::uint64_t now, unsigned& lookups) {
const auto find = game::native_data().find_asset;
if (!find) return 0;
const auto read = [](auto at) { return ptr(at); };
if (a.asset) {
if (detail::object_resident(a.asset, find(a.domain, name.c_str()), base, read)) return a.asset;
a.asset = 0;
}
if (now < a.retry || lookups == 0) return 0;
--lookups;
a.retry = now + 1000;
a.looked = true;
for (std::uint16_t domain = 0; domain < 0xbbf; ++domain) {
if (!ptr(base + addr::engine::domain_owners, std::uintptr_t(domain) * 8)) continue;
const auto asset = find(domain, name.c_str());
if (detail::object_blueprint(asset, base, read)) {
a.asset = asset;
a.domain = domain;
return asset;
}
}
return 0;
}
} // namespace
// ---- the blueprints loaded -------------------------------------------------------------------
// Each asset domain (engine::domain_owners) keeps its named assets in a registry (domain + 0x48),
// with registries of its own at +0x58..+0x60 (and theirs): an EASTL hash map of the name's hash to
// an entry (buckets at +0xf8, their count at +0x100, a node {hash, entry, next}), behind the
// critical section at +0x90 (the game's own lookup, 0x41b5800 -> 0x3db78d0 / 0x3db7f60). An entry
// starts with the tagged asset (bits 1 and 2 are tags; bit 2 set: one more pointer to follow,
// 0x3db9060), then the asset's GUID and the name's hash. An asset's name is at +0x18; it is taken
// only when it hashes to the node's key, as the game hashes names (5381, x33, xor, A-Z folded).
// Read in a running game on 2026-10-21: 57 registries, 2930 world object blueprints.
namespace {
std::uint64_t asset_name_hash(std::string_view name) {
std::uint64_t hash = 0x1505;
for (const unsigned char c : name) hash = (std::uint64_t{c} + (c >= 'A' && c <= 'Z' ? 0x20 : 0)) ^ (hash * 33);
return hash;
}
bool prefixed(std::string_view name, std::string_view prefix) {
if (name.size() < prefix.size()) return false;
for (std::size_t i = 0; i < prefix.size(); ++i) {
const auto a = static_cast<unsigned char>(name[i]), b = static_cast<unsigned char>(prefix[i]);
if ((a >= 'A' && a <= 'Z' ? a + 32 : a) != (b >= 'A' && b <= 'Z' ? b + 32 : b)) return false;
}
return true;
}
std::optional<std::string> asset_name(std::uintptr_t asset, std::uint64_t key) {
const auto at = ptr(asset + 0x18);
if (!at) return std::nullopt;
std::array<char, 257> text{};
if (!memory::peek_bytes(at, text.data(), text.size() - 1)) {
// A short name near the end of readable memory: read it in smaller pieces.
std::size_t length = 0;
for (; length < 256 && memory::peek(at + length, text[length]) && text[length]; ++length) {}
text[length] = 0;
}
const std::string name(text.data(), strnlen(text.data(), 256));
if (name.empty() || name.size() >= 256 || asset_name_hash(name) != key) return std::nullopt;
return name;
}
// The mesh box of a world object blueprint's asset (Engine/Game/Build/20260929/skater_entities.h).
std::optional<Box> asset_bounds(std::uintptr_t base, std::uintptr_t asset) {
const auto data = asset + e::object_data_offset;
if (ptr(data) != base + e::object_data_vtable) return std::nullopt;
const auto mesh = ptr(data + e::object_data_mesh_offset);
if (!mesh || ptr(mesh) != base + e::mesh_asset_vtable) return std::nullopt;
const auto loaded = ptr(mesh + e::mesh_asset_loaded_offset);
if (!loaded || ptr(loaded) != base + e::loaded_mesh_vtable) return std::nullopt;
const auto at = ptr(loaded + e::loaded_mesh_bounds_offset);
std::array<float, 8> v{};
if (!at || !memory::peek(at, v)) return std::nullopt;
Box box{{{v[0], v[1], v[2]}, {v[4], v[5], v[6]}}};
for (int i = 0; i < 3; ++i)
if (!std::isfinite(box[0][i]) || !std::isfinite(box[1][i]) || box[1][i] < box[0][i] || box[1][i] - box[0][i] > 2000) return std::nullopt;
return box;
}
void walk_registry(std::uintptr_t base, std::uintptr_t registry, std::string_view prefix, bool meshes_only, std::set<std::string>& found,
std::set<std::uintptr_t>& walked, unsigned depth = 0) {
if (!registry || depth > 16 || walked.size() >= 4096 || !walked.insert(registry).second) return;
// Its own registries first, outside its lock (the game takes each one's lock on its own).
if (const auto first = ptr(registry + 0x58), last = ptr(registry + 0x60); first && last >= first && last - first <= 8 * 4096)
for (auto at = first; at < last; at += 8)
if (const auto child = ptr(at)) walk_registry(base, child, prefix, meshes_only, found, walked, depth + 1);
const auto buckets = ptr(registry + 0xf8);
const auto count = get<std::uint32_t>(registry + 0x100);
if (!buckets || !count || count > (1u << 22)) return;
auto* section = reinterpret_cast<CRITICAL_SECTION*>(registry + 0x90);
EnterCriticalSection(section);
struct Leave { CRITICAL_SECTION* section; ~Leave() { LeaveCriticalSection(section); } } leave{section};
const auto sentinel = ptr(buckets + std::uintptr_t{count} * 8);
const auto read = [](auto at) { return ptr(at); };
std::size_t steps = 0;
for (std::uint32_t bucket = 0; bucket < count; ++bucket) {
for (auto node = ptr(buckets + std::uintptr_t{bucket} * 8); node && node != sentinel && ++steps < (1u << 22); node = ptr(node + 16)) {
const auto entry = ptr(node + 8);
const auto tagged = entry ? ptr(entry) : 0;
if (!tagged) continue;
auto asset = tagged & ~std::uintptr_t{6};
if (tagged & 4) asset = ptr(asset);
if (!detail::object_blueprint(asset, base, read) || (meshes_only && !asset_bounds(base, asset))) continue;
if (auto name = asset_name(asset, get<std::uint64_t>(node)); name && prefixed(*name, prefix)) found.insert(std::move(*name));
}
}
}
struct Listing {
std::mutex mutex;
std::uint64_t at{};
std::string prefix;
bool meshes_only{};
std::vector<std::string> names;
};
Listing& listing() { static auto* value = new Listing; return *value; }
} // namespace
std::vector<std::string> blueprints(std::uintptr_t base, std::string_view prefix, std::size_t most, bool meshes_only) {
auto& l = listing();
std::lock_guard lock(l.mutex);
const auto now = GetTickCount64();
if (!l.at || now >= l.at + 2000 || l.prefix != prefix || l.meshes_only != meshes_only) {
std::set<std::string> found;
std::set<std::uintptr_t> walked;
try {
for (std::uint16_t domain = 0; domain < 0xbbf && found.size() < 65536; ++domain) {
const auto owner = ptr(base + addr::engine::domain_owners, std::uintptr_t(domain) * 8);
if (const auto registry = owner ? ptr(owner + 0x48) : 0) walk_registry(base, registry, prefix, meshes_only, found, walked);
}
} catch (...) {
}
l.names.assign(found.begin(), found.end());
l.prefix = std::string(prefix);
l.meshes_only = meshes_only;
l.at = now;
}
return {l.names.begin(), l.names.begin() + static_cast<std::ptrdiff_t>(std::min(most, l.names.size()))};
}
std::optional<Box> blueprint_bounds(std::uintptr_t base, std::string_view blueprint) {
const auto find = game::native_data().find_asset;
if (!find || blueprint.empty() || blueprint.size() > 200) return std::nullopt;
const std::string name(blueprint);
const auto read = [](auto at) { return ptr(at); };
for (std::uint16_t domain = 0; domain < 0xbbf; ++domain) {
if (!ptr(base + addr::engine::domain_owners, std::uintptr_t(domain) * 8)) continue;
if (const auto asset = find(domain, name.c_str()); detail::object_blueprint(asset, base, read)) return asset_bounds(base, asset);
}
return std::nullopt;
}
void set_joint_source(JointSource source) noexcept { joint_source.store(source, std::memory_order_release); }
void test_bodies(std::string name) {
std::lock_guard lock(test_mutex);
test_request = std::move(name);
}
void set_physics(const Physics& p) noexcept {
physics() = p;
physics_set.store(true, std::memory_order_release);
}
std::string set(std::string_view owner, std::uint32_t id, std::string asset, const Matrix& matrix, bool hidden, std::optional<Attach> attach,
bool solid) {
if (asset.empty() || asset.size() > 200) return "an object's blueprint is a name of 1 to 200 characters";
if (!finite(matrix)) return "an object's transform must be finite, within 100 km, each axis at most 200 long";
if (attach && attach->joint >= 395) return "a skater's joints are 0 to 394";
if (attach && !(attach->ground >= 0 && attach->ground <= 50)) return "an object finds the ground at most 50 m below its joint";
if ((!solid || (attach && attach->ground > 0)) && !physics_set.load(std::memory_order_acquire))
return "objects that are not solid or stand on the ground are unavailable for this game build";
auto& s = state();
std::lock_guard lock(s.mutex);
const Key key{std::string(owner), id};
if (!s.wanted.contains(key)) {
const auto mine = std::count_if(s.wanted.begin(), s.wanted.end(), [&](const auto& w) { return w.first.first == owner; });
if (static_cast<std::size_t>(mine) >= max_per_owner) return std::format("at most {} objects", max_per_owner);
if (s.wanted.size() >= max_total) return "the world holds as many objects as ReSkate keeps";
}
s.wanted[key] = {std::move(asset), matrix, hidden, attach, solid};
return {};
}
void remove(std::string_view owner, std::uint32_t id) {
auto& s = state();
std::lock_guard lock(s.mutex);
s.wanted.erase({std::string(owner), id});
}
void clear(std::string_view owner) {
auto& s = state();
std::lock_guard lock(s.mutex);
std::erase_if(s.wanted, [&](const auto& w) { return w.first.first == owner; });
}
Status status(std::string_view owner, std::uint32_t id) {
auto& s = state();
std::lock_guard lock(s.mutex);
const Key key{std::string(owner), id};
const auto w = s.wanted.find(key);
if (w == s.wanted.end()) return Status::none;
if (w->second.hidden) return Status::hidden;
if (const auto l = s.live.find(key); l != s.live.end() && l->second.asset == w->second.asset) return Status::ready;
const auto a = s.assets.find(w->second.asset);
if (a == s.assets.end() || !a->second.looked) return Status::waiting;
return a->second.asset ? Status::loading : Status::missing;
}
bool ready(std::string_view owner) {
auto& s = state();
std::lock_guard lock(s.mutex);
for (const auto& [key, w] : s.wanted) {
if (key.first != owner || w.hidden) continue;
const auto l = s.live.find(key);
if (l == s.live.end() || l->second.asset != w.asset) return false;
}
return true;
}
std::size_t count(std::string_view owner) {
auto& s = state();
std::lock_guard lock(s.mutex);
return static_cast<std::size_t>(std::count_if(s.wanted.begin(), s.wanted.end(), [&](const auto& w) { return w.first.first == owner; }));
}
std::vector<std::uintptr_t> live_entities() {
auto& s = state();
std::lock_guard lock(s.mutex);
std::vector<std::uintptr_t> out;
for (const auto& [key, l] : s.live) out.push_back(l.entity);
return out;
}
void entity_destroyed(std::uintptr_t entity) noexcept {
auto& s = state();
std::lock_guard lock(s.mutex);
std::erase_if(s.live, [&](const auto& l) { return l.second.entity == entity; });
}
namespace {
// An object's bodies, looked for while it is new (its physics may come a few frames after it), for
// the floor below it and for being made not solid; then ghosted or made solid as it is wanted.
void bodies_for(std::uintptr_t base, const Key& key, Live& l, const Wanted& w, std::uint64_t now) {
auto& p = physics();
if (!physics_set.load(std::memory_order_acquire) || !p.world) return;
const bool needed = !w.solid || (w.attach && w.attach->ground > 0);
if (!needed && !l.ghosted) return;
if (l.bodies.empty() && !l.looked && now >= l.next_look) {
l.next_look = now + 250;
if (const auto world = p.world()) l.bodies = find_bodies(base, l.entity, world);
// Not kept in the entity where they were looked for: rays into the object's own box, the
// first body they meet, and the rest of that body's owner's.
if (l.bodies.empty() && p.hit && p.owned)
if (const auto box = blueprint_bounds(base, l.asset)) {
const auto& m = l.matrix;
const auto at = [&](float x, float y, float z) {
return std::array<float, 3>{m[12] + m[0] * x + m[4] * y + m[8] * z, m[13] + m[1] * x + m[5] * y + m[9] * z,
m[14] + m[2] * x + m[6] * y + m[10] * z};
};
const auto& lo = (*box)[0];
const auto& hi = (*box)[1];
const float cx = (lo[0] + hi[0]) / 2, cy = (lo[1] + hi[1]) / 2, cz = (lo[2] + hi[2]) / 2;
const std::array<std::pair<std::array<float, 3>, std::array<float, 3>>, 3> rays{{
{at(cx, hi[1] + 0.5f, cz), at(cx, lo[1] + 0.05f, cz)}, // short of the floor it stands on
{at(lo[0] - 0.5f, cy, cz), at(hi[0], cy, cz)},
{at(cx, cy, lo[2] - 0.5f), at(cx, cy, hi[2])},
}};
for (const auto& [from, to] : rays)
if (const auto body = p.hit(from, to)) {
l.bodies = p.owned(*body, 16);
if (!l.bodies.empty()) break;
}
}
if (!l.bodies.empty() || now >= l.made + 5000) {
l.looked = true;
logging::log(logging::Level::info, logging::Channel::runtime, "World objects: {} {} has {} physics bod{}.", key.first, l.asset,
l.bodies.size(), l.bodies.size() == 1 ? "y" : "ies");
}
}
const bool ghost = !w.solid;
if (ghost != l.ghosted && !l.bodies.empty()) {
bool all = true;
for (const auto& body : l.bodies) all = p.ghost(body, ghost) && all;
if (all) l.ghosted = ghost;
}
auto& s = state();
std::lock_guard lock(s.mutex);
if (const auto at = s.live.find(key); at != s.live.end() && at->second.entity == l.entity) {
at->second.bodies = l.bodies;
at->second.looked = l.looked;
at->second.ghosted = l.ghosted;
at->second.next_look = l.next_look;
}
}
} // namespace
void tick(std::uintptr_t base, std::uintptr_t client, bool ready) noexcept {
auto& s = state();
try {
{
std::lock_guard lock(s.mutex);
if (s.lifetime.blocked()) return;
if (s.wanted.empty() && s.live.empty()) return;
}
const auto context = ptr(client, 8);
const auto now = GetTickCount64();
if (s.context && s.context != context) {
// The old client context took its entities with it.
std::lock_guard lock(s.mutex);
s.live.clear();
s.assets.clear();
s.context = 0;
}
if (!ready || !context) return note(s, "waiting for local client world readiness");
const auto tls_array = static_cast<std::uintptr_t>(__readgsqword(0x58));
const auto index = get<std::uint32_t>(base + addr::engine::tls_index);
if (index > 4095) return;
const auto tls = ptr(tls_array, std::uintptr_t(index) * 8);
if (!get<std::uint8_t>(base + addr::engine::entity_creation_ready) || !get<std::uint8_t>(tls + 0xb19) || ptr(tls, 0x550) != context)
return note(s, "waiting for verified native client creation scope");
s.context = context;
if (!s.verified) {
prefix(base, e::descriptor_init, e::descriptor_init_prefix);
prefix(base, e::descriptor_destroy, e::descriptor_destroy_prefix);
prefix(base, e::create_entity, e::create_entity_prefix);
prefix(base, e::initialize_placement, e::initialize_placement_prefix);
prefix(base, e::move_spatial_entity, e::move_spatial_entity_prefix);
prefix(base, b::create_bus, b::create_bus_prefix);
prefix(base, b::acquire_bus, b::acquire_bus_prefix);
// ReSkate's shared entity lifetime hook detours Destroy: it tells us of each one.
std::string detail;
require(multiplayer::install_entity_hooks(base, detail), "Native entity lifetime hooks unavailable.");
s.verified = true;
}
std::map<Key, Wanted> wanted;
std::map<Key, Live> live;
{
std::lock_guard lock(s.mutex);
wanted = s.wanted;
live = s.live;
}
// Attached objects onto their joints as they are now; one whose joint is not known stays put
// (or waits), and after a second is taken away.
const auto source = joint_source.load(std::memory_order_acquire);
std::vector<Key> unplaced;
for (auto& [key, w] : wanted) {
if (!w.attach || w.hidden) continue;
if (const auto at = source ? source(w.attach->player, w.attach->joint) : std::nullopt; at && finite(*at)) {
const Matrix held{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, (*at)[12], (*at)[13], (*at)[14], 1};
const float height = w.matrix[13];
w.matrix = on_joint(!w.attach->turn ? held : w.attach->upright ? level(*at) : *at, w.matrix);
// On the floor within reach below the joint (the object's own bodies are not floor).
if (w.attach->ground > 0 && physics_set.load(std::memory_order_acquire) && physics().floor) {
const auto l = live.find(key);
static const std::vector<Body> none;
if (const auto floor = physics().floor({(*at)[12], (*at)[13], (*at)[14]}, w.attach->ground, l != live.end() ? l->second.bodies : none))
w.matrix[13] = *floor + height;
}
s.lost.erase(key);
} else {
unplaced.push_back(key);
s.lost.try_emplace(key, now);
}
}
std::erase_if(s.lost, [&](const auto& l) { return !wanted.contains(l.first); });
// Gone or hidden, or a different blueprint now: taken away.
std::vector<Key> drop;
for (const auto& [key, l] : live) {
const auto w = wanted.find(key);
const bool gone = w != wanted.end() && s.lost.contains(key) && now - s.lost[key] > 1000;
if (w == wanted.end() || w->second.hidden || w->second.asset != l.asset || gone || !intact(l)) drop.push_back(key);
}
// A blueprint whose bundle streamed out: its objects come back once it resolves again.
unsigned lookups = 4;
std::map<std::string, std::uintptr_t> resolved;
for (const auto& [key, w] : wanted) {
if (w.hidden || resolved.contains(w.asset)) continue;
resolved[w.asset] = resolve(base, s.assets[w.asset], w.asset, now, lookups);
}
for (const auto& [key, l] : live)
if (const auto r = resolved.find(l.asset); r != resolved.end() && !r->second && std::find(drop.begin(), drop.end(), key) == drop.end())
drop.push_back(key);
for (const auto& key : drop) {
const auto l = live.find(key);
destroy(base, l->second);
live.erase(l);
std::lock_guard lock(s.mutex);
s.live.erase(key);
}
std::uintptr_t parent{};
unsigned created{};
for (const auto& [key, w] : wanted) {
if (w.hidden || std::find(unplaced.begin(), unplaced.end(), key) != unplaced.end()) continue;
if (const auto l = live.find(key); l != live.end()) {
bodies_for(base, key, l->second, w, now);
// Move a resident object in place: recreating restarts its effects and makes it jump.
// One on a joint follows it every frame.
if (l->second.matrix != w.matrix && (w.attach || now >= l->second.moved + 16)) {
move(base, l->second, w.matrix);
std::lock_guard lock(s.mutex);
if (const auto at = s.live.find(key); at != s.live.end()) at->second.matrix = w.matrix, at->second.moved = now;
}
continue;
}
const auto asset = resolved[w.asset];
if (!asset) continue;
if (created >= 64) break; // spread a long route over a few frames
if (!parent) parent = parent_bus(base, context);
if (!parent) return note(s, "waiting for the native local skater entity bus");
auto made = create(base, parent, asset, w.matrix);
made.asset = w.asset;
made.matrix = w.matrix;
made.moved = now;
made.made = now;
++created;
std::lock_guard lock(s.mutex);
s.live[key] = std::move(made);
}
if (created) note(s, std::format("{} object(s) created", created));
// Test only: a per-body setter on every live object's bodies.
std::string test;
{
std::lock_guard lock(test_mutex);
test.swap(test_request);
}
if (!test.empty() && physics_set.load(std::memory_order_acquire) && physics().test) {
unsigned ran{}, bodies{};
std::lock_guard lock(s.mutex);
for (const auto& [key, l] : s.live)
for (const auto& body : l.bodies) {
++bodies;
if (physics().test(test, body)) ++ran;
}
logging::log(logging::Level::info, logging::Channel::runtime, "World objects: {} ran on {} of {} bodies.", test, ran, bodies);
}
} catch (const std::exception& error) {
if (s.error != error.what()) {
s.error = error.what();
logging::log(logging::Level::error, logging::Channel::runtime, "World objects: {}", s.error);
}
} catch (...) {
logging::write(logging::Level::error, logging::Channel::runtime, "World object creation failed.");
}
}
void before_level_transition(std::uintptr_t base, unsigned next) noexcept {
auto& s = state();
bool release{};
{
std::lock_guard lock(s.mutex);
release = s.lifetime.before_transition(next);
}
if (!release) return;
// Retired in the live world, before its component data goes.
try {
destroy_all(base);
} catch (...) {
logging::write(logging::Level::error, logging::Channel::runtime, "World object cleanup before a level change failed.");
}
std::lock_guard lock(s.mutex);
s.live.clear();
s.wanted.clear();
s.assets.clear();
s.lost.clear();
s.context = 0;
logging::log(logging::Level::info, logging::Channel::runtime, "World objects retired before native state {}.", next);
}
} // namespace dingosdk::world_entities
Reference in new issue View Git Blame Copy Permalink