alex/sots-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
sots-engine/src/shim/hooks/tech_effects.cpp

335 lines
15 KiB
C++
Raw Blame History

#include "shim/hooks/tech_effects.h"
#include <algorithm>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <stdexcept>
#include <string>
#include <vector>
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#include "game/effects/tech_effects.h"
#include "shim/hooks/tech_effect_fields.h"
#include "game/effects/tech_id.h"
#include "game/sim/species.h"
#include "game/sim/tuning.h"
#include "generated/sots_addresses.h"
namespace shim::hooks {
using trace::Tv;
namespace tv = trace::tv;
namespace fx = sots::effects;
namespace tfx = shim::hooks::techfx;
namespace {
namespace A = sots::addr;
// The two game entry points `ours` leans on. Both are verified, read-only reads of the
// tech tree: the same delegation B3 makes to TechTree::Cost.
using IsTechFn = bool(SHIM_THISCALL*)(void* master, void* def, int techId);
using HasResearchedFn = bool(SHIM_THISCALL*)(void* tree, int techId);
// Reselects and (re)allocates the node-bore parameter block. Used only in replace mode,
// where `ours` has to leave the game in a consistent state and cannot allocate itself.
using UpdateBoreFn = void(SHIM_THISCALL*)(void* self);
struct Env {
std::uintptr_t exe_base = 0;
void (*log_line)(const char*) = nullptr;
IsTechFn is_tech = nullptr;
HasResearchedFn has_researched = nullptr;
UpdateBoreFn update_bore = nullptr;
const int* gate_tpgate = nullptr;
const int* gate_gatamp = nullptr;
};
Env g_env;
void logf(const char* fmt, ...) {
if (!g_env.log_line) return;
char line[512];
va_list ap;
va_start(ap, fmt);
std::vsnprintf(line, sizeof line, fmt, ap);
va_end(ap);
g_env.log_line(line);
}
// ---- safe pointer chasing (the guard M2/B3 use) ---------------------------------------
bool readable(const void* p, std::size_t n) {
if (!p) return false;
if (n == 0) return true;
#if defined(_WIN32)
const char* c = static_cast<const char*>(p);
const char* const end = c + n;
while (c < end) {
MEMORY_BASIC_INFORMATION mbi;
if (!VirtualQuery(c, &mbi, sizeof mbi)) return false;
if (mbi.State != MEM_COMMIT) return false;
if (mbi.Protect & (PAGE_NOACCESS | PAGE_GUARD)) return false;
const DWORD ok = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ |
PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;
if (!(mbi.Protect & ok)) return false;
c = static_cast<const char*>(mbi.BaseAddress) + mbi.RegionSize;
}
return true;
#else
return true;
#endif
}
// The x87 control word in force for the call. The modifier arithmetic is `fld dword;
// fadd qword; fstp dword`, so the precision-control field decides whether the middle step
// rounds to 53 or to 24 significand bits -- the same open question B3 records.
std::uint32_t fpu_control_word() {
#if defined(__i386__) || defined(__x86_64__)
unsigned short cw = 0;
__asm__ __volatile__("fnstcw %0" : "=m"(cw));
return cw;
#else
return 0;
#endif
}
// ---- per-call state ---------------------------------------------------------------------
//
// OnTechResearched CAN nest: the Zuul Cruiser-Construction branch grants boarding pods via
// SetResearched, which calls the callback again. `ours` never does that (it only reports
// the grant), so the statics below are only ever written by the outer invocation of the
// *hook*; a nested original call runs inside the original, not inside the hook. The depth
// counter makes that assumption checkable rather than assumed.
struct CallState {
bool compare = false;
int region_of[tfx::kRegionCount] = {};
tfx::Views views; // the scratch copies, once rebind() has resolved them
};
CallState g_call;
void reset_call() {
g_call = CallState{};
for (int i = 0; i < tfx::kRegionCount; ++i) g_call.region_of[i] = -1;
}
// The few reads `ours` makes straight off the live object -- fields the callback never
// writes, so "live" and "before" are the same value.
std::int32_t i32_at(const void* p, std::size_t off) {
std::int32_t v = 0;
std::memcpy(&v, static_cast<const char*>(p) + off, sizeof v);
return v;
}
void* ptr_at(const void* p, std::size_t off) {
void* v = nullptr;
std::memcpy(&v, static_cast<const char*>(p) + off, sizeof v);
return v;
}
std::uint8_t u8_at(const void* p, std::size_t off) {
return static_cast<const std::uint8_t*>(p)[off];
}
// ---- tech identity ----------------------------------------------------------------------
void* master_tree_of(void* self) {
void* tree = ptr_at(self, A::ServerPlayer_off_TechTree);
if (!readable(tree, A::TechTree_off_Master + 4)) return nullptr;
return ptr_at(tree, A::TechTree_off_Master);
}
// The TechId of a definition.
//
// TechDef's first word is NOT the TechId: MasterTechTree::IsTech maps `id - 10000` into the
// master table and compares TechDef pointers, while TechTree::HasResearched uses that same
// map to reach a TechDef and *then* uses the def's first word as an index into the node
// vector. So the first word is a node index in a different, larger key space, and the only
// way to get the TechId is the identity test the callback itself uses. 196 calls into a
// three-compare function, once per completion.
int resolve_tech_id(void* self, void* def) {
if (!readable(def, 4)) return -1;
void* master = master_tree_of(self);
if (!master || !g_env.is_tech) return -1;
for (int i = 0; i < fx::kTechIdCount; ++i) {
const int id = fx::kTechIdBase + i;
if (g_env.is_tech(master, def, id)) return id;
}
return -1; // a tech that is not in the 196-name table has no code effect
}
// ---- our state <-> the player object ----------------------------------------------------
// The gate-traffic config words, read from the executable's own storage.
sots::sim::TuningTable gate_tuning() {
sots::sim::TuningTable t;
if (g_env.gate_tpgate) t.PERGATETRAFFIC_DRV_TpGate = *g_env.gate_tpgate;
if (g_env.gate_gatamp) t.PERGATETRAFFIC_DRV_GatAmp = *g_env.gate_gatamp;
return t;
}
} // namespace
// ---- descriptor ---------------------------------------------------------------------------
void ServerPlayerOnTechResearchedHook::describe_args(std::vector<Tv>& out, void* self, void* def,
bool silent) {
out.push_back(tv::ptr(self).named("player"));
const bool ok = readable(self, tfx::PlayerSpan());
out.push_back(tv::i32(ok ? i32_at(self, A::ServerPlayer_off_PlyrIdx) : -1).named("player_index"));
out.push_back(tv::i32(ok ? i32_at(self, A::ServerPlayer_off_Species) : -1).named("species"));
out.push_back(tv::ptr(def).named("def"));
const int id = ok ? resolve_tech_id(self, def) : -1;
out.push_back(tv::i32(id).named("tech_id"));
// The def's own first word, so a trace shows the two key spaces side by side (it is the
// node-vector index, not the TechId -- see resolve_tech_id).
out.push_back(tv::i32(readable(def, 4) ? i32_at(def, A::TechDef_off_TechId) : -1).named("def_node_index"));
const char* name = fx::IsValidTechId(id) ? fx::TechIdName(static_cast<fx::TechId>(id)) : nullptr;
out.push_back(tv::str(name).named("tech_name"));
out.push_back(tv::boolean(silent).named("silent"));
out.push_back(tv::boolean(ok && ptr_at(self, A::ServerPlayer_off_ResearchTarget) == def)
.named("is_current_target"));
out.push_back(tv::i32(ok ? i32_at(self, A::ServerPlayer_off_OwnedSystems + 4) -
i32_at(self, A::ServerPlayer_off_OwnedSystems)
: 0)
.named("owned_systems_bytes"));
out.push_back(tv::boolean(ok && u8_at(self, A::ServerPlayer_off_RebAI) != 0).named("rebel_ai"));
out.push_back(tv::boolean(ok && u8_at(self, A::ServerPlayer_off_AIBn) != 0).named("ai_benefit_in"));
out.push_back(tv::i32(g_env.gate_tpgate ? *g_env.gate_tpgate : -1).named("gate_traffic_tpgate"));
out.push_back(tv::i32(g_env.gate_gatamp ? *g_env.gate_gatamp : -1).named("gate_traffic_gatamp"));
out.push_back(tv::u32(fpu_control_word()).named("fpu_cw"));
}
void ServerPlayerOnTechResearchedHook::regions(std::vector<trace::Region>& out, void* self,
void* def, bool silent) {
(void)def;
(void)silent;
reset_call();
if (!readable(self, tfx::PlayerSpan())) throw std::runtime_error("ServerPlayer not readable");
const tfx::Views live = tfx::Views::OverPlayer(self);
for (int i = 0; i < tfx::kRegionCount; ++i) {
const tfx::RegionDef& d = tfx::kRegions[i];
const void* base = live.base[i];
// The node-bore block is declared only when it already exists: a region has to be
// snapshottable *before* the call, and the original allocates it on first use.
if (!readable(base, d.size)) continue;
trace::Region r;
r.name = d.name;
r.ptr = base;
r.size = d.size;
r.describe = d.describe;
g_call.region_of[i] = static_cast<int>(out.size());
out.push_back(r);
}
}
ServerPlayerOnTechResearchedHook::Args ServerPlayerOnTechResearchedHook::rebind(trace::Scratch& s,
void* self, void* def,
bool silent) {
for (int i = 0; i < tfx::kRegionCount; ++i) {
g_call.views.base[i] = g_call.region_of[i] >= 0
? s.ptr(static_cast<std::size_t>(g_call.region_of[i]))
: nullptr;
}
g_call.compare = true;
// `self` is passed through unchanged: `ours` only reads never-written fields off it
// (species, the tech tree) and takes everything else from the scratch copies above.
return Args(self, def, silent);
}
void ServerPlayerOnTechResearchedHook::ours(void* self, void* def, bool silent) {
(void)silent; // only the events depend on it, and events are not reproduced
const bool compare = g_call.compare;
g_call.compare = false; // a replace-mode call must never inherit a stale mapping
if (!readable(self, tfx::PlayerSpan())) throw std::runtime_error("ServerPlayer not readable");
const tfx::Views v = compare ? g_call.views : tfx::Views::OverPlayer(self);
if (!compare) reset_call();
const int raw_id = resolve_tech_id(self, def);
// The pending plague-cure roll: the two words are cleared either way, but the roll
// itself draws from the strategic generator, so `ours` records it instead of running it.
const bool would_roll = tfx::ClearResearchTargetIfMatched(v, def);
int species_index = i32_at(self, A::ServerPlayer_off_Species);
if (species_index < 0 || species_index >= sots::sim::kSpeciesCount) species_index = 0;
fx::PlayerEconomyState s =
tfx::ReadPlayerState(v, static_cast<sots::sim::Species>(species_index));
// The researched set, from the player's own tree. In compare mode the tree is the live
// one, i.e. the state the original's tail saw: the completing node is already marked.
void* tree = ptr_at(self, A::ServerPlayer_off_TechTree);
if (!tree || !g_env.has_researched) throw std::runtime_error("tech tree not available");
for (int i = 0; i < fx::kTechIdCount; ++i) {
if (g_env.has_researched(tree, fx::kTechIdBase + i)) s.researched.set(static_cast<std::size_t>(i));
}
fx::ApplyContext ctx;
sots::sim::TuningTable tuning = gate_tuning();
ctx.tuning = &tuning;
fx::TechApplyOutcome outcome;
if (fx::IsValidTechId(raw_id)) {
// The completion callback, not the guarded wrapper: by the time it runs the node is
// already state 4, so an already-researched guard would make it a no-op.
outcome = fx::ApplyTechCompletion(s, static_cast<fx::TechId>(raw_id), ctx);
} else {
// Roughly half the data files are not in the 196-name key space and so have no
// branch of their own -- but the callback still runs its whole tail for them.
outcome = fx::RunCompletionTail(s);
}
// The node-track techs are keyed by name in the species table rather than by id; the
// callback resolves them with its own helper, which returns the species or -1.
for (int sp = 0; sp < sots::sim::kSpeciesCount; ++sp) {
const char* track = fx::NodeTrackTechName(static_cast<sots::sim::Species>(sp));
if (track == nullptr) continue;
const fx::TechId tid = fx::TechIdFromName(track);
if (fx::IsValidTechId(tid) && static_cast<int>(tid) == raw_id) s.nodeTrackMask |= 1u << sp;
}
tfx::WritePlayerState(v, s);
// The two design-option masks are a fresh OR over the researched set on every
// completion, which is why they are computed here rather than in the effects table.
const fx::DesignOptionMasks dm = fx::ComputeDesignOptionMasks(
[&](fx::TechId id) { return g_env.has_researched(tree, static_cast<int>(id)); });
tfx::WriteDesignOptionMasks(v, dm.a, dm.b);
// Replace mode only: the node-bore block has to be allocated or freed to keep the game
// consistent, and `ours` has no allocator the game's runtime could free. Delegating to
// the game's own updater is the same read-only-helper delegation B3 makes for Cost.
if (!compare && g_env.update_bore) g_env.update_bore(self);
// describe_args runs before the original (and so before `ours`), so the outcome cannot
// ride on the record. Completions are rare, so one audit line each is affordable and is
// where the un-compared consequences -- the system-side writes, the Zuul grant, the
// roll -- are visible at all.
logf("techfx: ours mode=%s id=%d granted=%d plague=0x%02x systems_ai=%d civcaps=%d "
"temperance=0x%02x bore_changed=%d bore_present=%d roll=%d",
compare ? "compare" : "replace", raw_id, static_cast<int>(outcome.grantedTech),
outcome.plagueCuredMask, outcome.flagSystemsAI ? 1 : 0,
outcome.reevaluateCivilianCaps ? 1 : 0, outcome.temperanceSpeciesMask,
outcome.nodeBoreParamsChanged ? 1 : 0, v.base[tfx::R_NODEBORE] ? 1 : 0,
would_roll ? 1 : 0);
}
void init_tech_effects(std::uintptr_t exe_base, void (*log_line)(const char* line)) {
g_env.exe_base = exe_base;
g_env.log_line = log_line;
g_env.is_tech = reinterpret_cast<IsTechFn>(exe_base + A::MasterTechTree_IsTech);
g_env.has_researched = reinterpret_cast<HasResearchedFn>(exe_base + A::TechTree_HasResearched);
g_env.update_bore = reinterpret_cast<UpdateBoreFn>(exe_base + A::ServerPlayer_UpdateNodeBoreParams);
g_env.gate_tpgate = reinterpret_cast<const int*>(exe_base + A::g_PERGATETRAFFIC_DRV_TpGate);
g_env.gate_gatamp = reinterpret_cast<const int*>(exe_base + A::g_PERGATETRAFFIC_DRV_GatAmp);
logf("techfx: OnTechResearched hook ready (regions=%d, gate=%d/%d, fpu_cw=0x%04x)", tfx::kRegionCount,
g_env.gate_tpgate ? *g_env.gate_tpgate : -1, g_env.gate_gatamp ? *g_env.gate_gatamp : -1,
fpu_control_word());
}
} // namespace shim::hooks
Reference in a new issue View git blame Copy permalink