regenerate address header with b2 offsets
This commit is contained in:
alex
parent
5b6f812e31
commit
ee43e96404
1 changed files with 231 additions and 5 deletions
|
|
@ -1,5 +1,5 @@
|
|||
// GENERATED — do not edit. Facts about Sword of the Stars.exe (GOG 1.8.1).
|
||||
// Source: sots-re ghidra/addresses.json @ 8a6c0e8, generated 2026-09-08 by tools/gen_addresses.py
|
||||
// Source: sots-re ghidra/addresses.json @ 5b6f812, generated 2026-09-08 by tools/gen_addresses.py
|
||||
// Runtime address = (uintptr_t)GetModuleHandle(NULL) + RVA (the exe is ASLR-relocated).
|
||||
#pragma once
|
||||
#include <cstdint>
|
||||
|
|
@ -295,10 +295,6 @@ constexpr uint32_t ServerSystem_CalcSuitMod = 0x003484d0;
|
|||
constexpr uint32_t ServerSystem_AccrueSystemBonus = 0x0034d4f0;
|
||||
// thiscall int (ServerSystem* this, float frac) [verified]
|
||||
constexpr uint32_t ServerSystem_SystemBonusPopTarget = 0x0034b5a0;
|
||||
// cdecl void (Vector3* posOut, bool* arrivedOut, float nodespeed, float dt, void* lines, Vector3* from, Vector3* to) [unverified]
|
||||
constexpr uint32_t NodeLine_Step = 0x00305510;
|
||||
// cdecl void (vector* segsOut, vector* systems, Vector3* from, Vector3* to) [unverified]
|
||||
constexpr uint32_t NodeLine_BuildStutterSegments = 0x00305280;
|
||||
// data struct { const char* name; int x; }[196] /* TechId = 10000+i */ [verified]
|
||||
constexpr uint32_t g_TechIdNames = 0x005ff9e4;
|
||||
// data const char*[116] [verified]
|
||||
|
|
@ -429,5 +425,235 @@ constexpr uint32_t ServerPlayer_SpeciesOfTranslationTech = 0x0040e410;
|
|||
constexpr uint32_t AITechRow = 0x00290f70;
|
||||
// data int -- number of rows in g_AITechValueTable (6) [verified]
|
||||
constexpr uint32_t g_AITechValueCount = 0x006ea2ec;
|
||||
// offset void* -- the StrategyServer subobject pointer; StrategyServer = *(void**)(player+8) - 4. Its +0x16c is the Mars::RNG* the strategic sim draws from, and its +8 the event manager [verified]
|
||||
constexpr uint32_t ServerPlayer_off_ServerLink = 0x00000008;
|
||||
// offset Mars::RNG* -- the strategic generator (same object TechTree::ProcessResearch is handed) [verified]
|
||||
constexpr uint32_t StrategyServer_off_RNG = 0x0000016c;
|
||||
// fastcall void (ServerPlayer* this) -- odds = ResearchEventOdds(this, this->ResT); draws EXACTLY ONE NextFloat from StrategyServer's generator, unconditionally, then fires 0x00889d60 when odds > roll. Called from OnTechResearched when the completing def is the current research target and the pending-roll byte at +0x3b4 is set. This is the extra RNG draw B3 observed on a completion [verified]
|
||||
constexpr uint32_t ServerPlayer_RollResearchEvent = 0x0048df20;
|
||||
// thiscall float (ServerPlayer* this, TechDef* def) -- 0 when def is null; a plague-family path via 0x00535480, else the AI-rebellion path via AITechRow (odds column) gated on !NPC. Read-only, makes no draw [verified]
|
||||
constexpr uint32_t ServerPlayer_ResearchEventOdds = 0x00420380;
|
||||
// thiscall void (ServerSystem* this) /* NO stack arguments -- plain RET, nothing reads [ebp+8]; Ghidra's decompile shows a spurious second parameter. Body order: unowned Infra decay -> ApplyInfraBonus -> ApplyPopBonus -> independent pop drift -> IsStable/ntdev -> AccrueSystemBonus -> ProcessPlague -> ProcessBuildQueue -> imperial growth -> civilian growth -> AdjustResources(-out[2]) -> TRes=0 -> RefuelInOrbit(1) -> Bats2 tick -> rcex tick -> haltv[0..2]=false -> ProcessSlaves -> ProcessRebellion -> addiction sweep. Consumes no RNG itself; ProcessPlague / civilian growth / ProcessSlaves are draw-free to depth 1, and ProcessRebellion is the only consumer */ [verified]
|
||||
constexpr uint32_t ServerSystem_ProcessTurn = 0x003598e0;
|
||||
// thiscall bool (StrategyServer* this, StarFleet* fleet, float dt) /* RET 8; dt is a 4-byte float pushed with fstp DWORD [esp]; returns AL, true only when the fleet ends exactly on a waypoint destination at the deepest recursion level. range = MinRange(fleet, +0.05f) -- ADDED, not subtracted; out of range with MinRange(0)==0 zeroes the RANGE, not the step; move = min(min(range, step), distance) with no floor at 0; recursion iff fraction < (double)0.9999f with dt' = float32((1-fraction)*dt) */ [verified]
|
||||
constexpr uint32_t StrategyServer_MoveFleet = 0x003d9ee0;
|
||||
// thiscall void (StrategyServer* this) /* no stack args, plain RET. Pursuit schedule, not a departing/in-transit split: classify every fleet whose current waypoint targets a fleet by owner relation (0 = pursuer, else follower); pass1 prey dt 0.5, pass2 pursuers dt 0.5 (an arrival retires the pair), pass3 remaining prey dt 0.5, pass4 everything unscheduled dt 1.0 (an uncaught pursuer gets 0.5), pass5 followers dt 1.0. Then FPdpos, gate traffic, OnFleetArrived, and clears flag 0x100 on every fleet. Makes no RNG draw of its own */ [verified]
|
||||
constexpr uint32_t StrategyServer_ProcessFleetMovement = 0x003da9a0;
|
||||
// thiscall float (StarFleet* this, float bias) /* RET 4; min over ships of ship->Range seeded with FLT_MAX (an empty fleet is unconstrained), then + bias, narrowed to float32. No ship is skipped -- range-exempt tankers still clamp the fleet */ [verified]
|
||||
constexpr uint32_t StarFleet_MinRange = 0x002ff6a0;
|
||||
// thiscall bool (StarFleet* this, uint32 mask) /* (flags & mask) == mask, flags at fleet+0x10c */ [verified]
|
||||
constexpr uint32_t StarFleet_HasAllFlags = 0x002fe1d0;
|
||||
// thiscall void (StarFleet* this, uint32 mask, bool on) /* the only two writers of fleet+0x10c in the image */ [verified]
|
||||
constexpr uint32_t StarFleet_SetFlag = 0x002fe1a0;
|
||||
// thiscall void* (StarFleet* this) /* no args; NULL when the waypoint vector is empty or the front waypoint's target id does not resolve in the entity hash at fleet->galaxy(+0x10)+0x80 */ [verified]
|
||||
constexpr uint32_t StarFleet_ResolveWaypoint = 0x00301390;
|
||||
// cdecl bool (int waypointType) /* 7-entry jump table: true only for 4 and 5; false default */ [verified]
|
||||
constexpr uint32_t IsGateTransitWaypoint = 0x0016e6e0;
|
||||
// cdecl bool (int waypointType) /* 7-entry jump table: true only for 3. NOTE the node-LINE case of the movement switch is type 2, which this does NOT accept */ [verified]
|
||||
constexpr uint32_t IsNodeWaypoint = 0x0016e720;
|
||||
// thiscall void (StrategyServer* this, StarFleet* fleet, void* dest) /* waypoint type 5. v = float32(NextFloat() * player->CstE); arrives iff !(v > player->CstT) (equality arrives); on a miss the fleet is placed at dest + randomUnitVector * v -- scattered AROUND the destination by v, not advanced a fraction along the vector -- which costs a second raw draw. 1 draw on success, 2 on a miss */ [verified]
|
||||
constexpr uint32_t ProbabilisticJump = 0x003b6700;
|
||||
// cdecl void (Vector3* posOut, bool* arrivedOut, float nodespeed, float dt, vector<StarSystem*>* systems, const Vector3* from, const Vector3* to) /* builds the stutter segments, reverses them and pops from the back (so ascending by start); plain nodespeed between spheres, a constant per-segment speed inside one; arrived = (time < dt) || |along - length| < FLT_EPSILON, and on arrival the destination is copied verbatim */ [verified]
|
||||
constexpr uint32_t NodeLine_Step = 0x00305510;
|
||||
// cdecl void (vector<StutterSegment>* out, vector<StarSystem*>* systems, const Vector3* from, const Vector3* to) /* chord parameters scaled to world distance and clamped to [0, length]; a chord with |start-end| <= 0.01f is dropped; std::sort ascending by start; then ONE forward pass over adjacent pairs sets BOTH boundaries of an overlap to end_i + 0.5*(end_i - start_{i+1}) -- the mirror of the midpoint, pushed forward past both chords. Nothing is dropped or clipped back, so a swallowed chord comes out inverted */ [verified]
|
||||
constexpr uint32_t NodeLine_BuildStutterSegments = 0x00305280;
|
||||
// cdecl bool (float* tNear, float* tFar, const Sphere4* s, const Vector3* from, const Vector3* to) /* wraps the quadratic solver 0x008a62c0; rejects a sphere the segment does not reach and reports an open end as -FLT_MAX / +FLT_MAX */ [verified]
|
||||
constexpr uint32_t SegmentSphereIntersect = 0x004a64f0;
|
||||
// cdecl float (const Vector3* p, const Vector3* a, const Vector3* b) /* projection parameter clamped to [0,1]. NOTE 0x008c8eb0 is a varargs formatter, not this */ [verified]
|
||||
constexpr uint32_t DistPointToSegment = 0x004e8eb0;
|
||||
// thiscall int (ServerSystem* this, ServerPlayer* p, int flag) /* RET 8 -- (player, flag), NOT (species, groupType). Species is derived from p->Species and the group type is hard-coded to 0, which makes the cross-species and INDSYS branches dead in this specialisation. Returns the int64 result clamped to [0, INT32_MAX], low dword only */ [verified]
|
||||
constexpr uint32_t ServerSystem_MaxPop = 0x0034ab20;
|
||||
// thiscall int64 (ServerSystem* this, int groupType, int species, ServerPlayer* p, float* suitOverride) /* RET 0x10 */ [verified]
|
||||
constexpr uint32_t ServerSystem_MaxPopGeneric = 0x0034a4a0;
|
||||
// thiscall bool (ServerSystem* this) /* false without an owner, with Infra < 1.0, or with Suit != IdealSuit */ [verified]
|
||||
constexpr uint32_t ServerSystem_IsStable = 0x0034ad90;
|
||||
// thiscall void (ServerSystem* this) /* returns early unless ibon > 0 and Infra < 1; resets ntdev to 0 when the system is not the owner's home system; applied = min(ibon, float32(1 - Infra)); Infra becomes EXACTLY 1.0f when applied == the remainder, else float32(Infra + applied); ibon -= applied */ [verified]
|
||||
constexpr uint32_t ServerSystem_ApplyInfraBonus = 0x00346780;
|
||||
// thiscall void (ServerSystem* this) /* nothing unless pbon > 0; an unowned system drops the whole pool; returns when Pop >= MaxPop; resets ntdev for a non-home system; Pop += min(cap - Pop, pbon); pbon -= same. Pop and pbon are int32 */ [verified]
|
||||
constexpr uint32_t ServerSystem_ApplyPopBonus = 0x0034b510;
|
||||
// thiscall void (ServerSystem* this, float delta) /* no-op once Infra >= 1; clamps to 1 and re-normalises the system's own output rates when it lands there */ [verified]
|
||||
constexpr uint32_t ServerSystem_ApplyInfraDelta = 0x00348270;
|
||||
// thiscall void (ServerSystem* this, float delta) /* clamps at the ideal from whichever side it approached, so suitability never overshoots; re-normalises the rates when it lands exactly on the ideal */ [verified]
|
||||
constexpr uint32_t ServerSystem_ApplySuitDelta = 0x003481c0;
|
||||
// thiscall void (ServerSystem* this, int out[12], float rates[7]) /* RET 8. `out` is 12 dwords of MIXED type: 0 total (truncated), 1 strip-mined resources, 2 resources consumed, 3 money, 7 gross construction, 8 points to the queue, 9 points SPENT on repairs, 10 float32 infra delta, 11 float32 suitability delta. `rates` is copied to the stack first, so the caller's struct is untouched. NOT side-effect free: it repairs damaged ships in orbit via 0x00751590(points, estimateOnly=0) */ [verified]
|
||||
constexpr uint32_t ServerSystem_ComputeOutputFromRates = 0x00351bb0;
|
||||
// cdecl void (float rates[7], ServerSystem* sys, float* pinned) /* `pinned` defaults to &rates[0] (trade) and every call site passes NULL or that. Suppress terraform at the ideal (exact ==) and infra when float32(ibon+Infra) >= 1; zero any channel <= (double)1e-4f; clamp ONLY the pinned channel to [0,1]; sum the other three in float32; an exactly-zero sum seeds them with 1e-4f (honouring the suppressions); each becomes (r/sum)*(1-pinned) */ [verified]
|
||||
constexpr uint32_t ServerSystem_NormaliseOutputRates = 0x00347390;
|
||||
// thiscall void (ServerSystem* this, int* resourcesConsumedOut) /* computes the turn's output vector, writes out[2] (resources consumed) through the pointer, applies out[11] via ApplySuitDelta and out[10] via ApplyInfraDelta, and feeds out[8] to BuildQueue::ProcessTurn. Increments TnsOH while SRoh > 0 && out[1] > 0 */ [verified]
|
||||
constexpr uint32_t ServerSystem_ProcessBuildQueue = 0x00352500;
|
||||
// thiscall int (BuildQueue* this, ServerSystem* sys, int points) /* RET 8; `points` is BY VALUE and the leftover is the RETURN value. An order needing more than what is left absorbs everything and stops the pass; a design that costs money asks this->vft[9](sys, (int64)cost) and a refusal SKIPS that order and continues rather than stopping. Removal is a separate sweep afterwards that unlinks every order with conleft <= 0 */ [verified]
|
||||
constexpr uint32_t BuildQueue_ProcessTurn = 0x00490d50;
|
||||
// thiscall void (ServerSystem* this, int delta, int mode) /* RET 8; ProcessTurn passes -out[2] with mode 0 when the owner has AMine, else mode 3. Mode 3 takes it all from Res; mode 0 splits it proportionally over Res / ARes2 / MRes */ [verified]
|
||||
constexpr uint32_t ServerSystem_AdjustResources = 0x00345f30;
|
||||
// thiscall int64 (ServerSystem* this, int groupType, int species) /* RET 8; 0 without an owner or when haltv[groupType] is set */ [verified]
|
||||
constexpr uint32_t ServerSystem_PopGrowthDelta = 0x00348100;
|
||||
// thiscall float (ServerPlayer* p, int groupType, int species, float suit, float factor) /* the growth curve. base = 1 - clamp01(min(|ideal - clamp(suit,0,20)|, SuitTol) / SuitTol) -- there is NO pop/capacity term anywhere; g = clamp01(pow(base, clamp(POPULATION_GROWTH_EXP, 0.01f, 1000))) then x MOD x PopMod x factor x groupdef[+4], each gated on a strict > 0 and each stored back to a float32 */ [verified]
|
||||
constexpr uint32_t PopGrowthFraction = 0x00136fb0;
|
||||
// thiscall float (ServerSystem* this, int species) /* RET 4; 1.0 when unowned. mod = (bit0 ? 0.8f : 1) - 0.2*bit1 - 0.2*bit2, no clamp; rate = ((|Ideal-Suit| x BYHAZARD + DEATH_RATE) + SRs x BYOUTPUT) x mod, every step narrowed to float32 */ [verified]
|
||||
constexpr uint32_t ServerSystem_SlaveDeathRate = 0x0034b110;
|
||||
// thiscall void (ServerSystem* this) /* the worst plague's rate is ADDED to the death rate; SLAVES_MIN/MAX_DEATHS are each disabled by ANY negative value; deaths are clamped into [0, adjusted slave count]. Consumes no RNG */ [verified]
|
||||
constexpr uint32_t ServerSystem_ProcessSlaves = 0x003537b0;
|
||||
// thiscall void (ServerSystem* this) /* consumes no RNG, at depth 1 */ [verified]
|
||||
constexpr uint32_t ServerSystem_ProcessPlague = 0x00356a90;
|
||||
// thiscall void (ServerSystem* this) /* the ONLY RNG consumer in a colony turn, and its draw count is data-dependent: one RandChance per iteration of a 64-bit rebel counter (0x0074fbe0), a short-circuiting per-species roll loop (0x00753c60), one outcome roll (0x00756350) and one 0.2f continuation roll */ [verified]
|
||||
constexpr uint32_t ServerSystem_ProcessRebellion = 0x003583b0;
|
||||
// thiscall void (ServerSystem* this) /* consumes no RNG, at depth 1 */ [verified]
|
||||
constexpr uint32_t ServerSystem_GrowCivilianPops = 0x00354220;
|
||||
// stdcall bool (RNG* this /*ecx, the object*/, float p) /* p <= 0 -> false and p >= 1 -> true, both WITHOUT a draw; otherwise exactly one NextFloat and `r < p` */ [verified]
|
||||
constexpr uint32_t RNG_Chance = 0x004e6dd0;
|
||||
// thiscall void (ServerPlayer* this, MoraleEvent* ev, ServerSystem* sys) /* the actual apply. 0x00752a10 is only the MoraleEvent constructor; the per-species delta is carried in ev->deltas[species] (int[7] at ev+0x18), not as an argument */ [verified]
|
||||
constexpr uint32_t ServerPlayer_AddMoraleEvent = 0x00439d60;
|
||||
// thiscall MoraleEvent* (MoraleEvent* this) /* 0x50 bytes: {vptr, ints (+0x10 = event id), vptr2 @+0x14, int deltas[7] @+0x18, std::string name @+0x34} */ [verified]
|
||||
constexpr uint32_t MoraleEvent_ctor = 0x00352a10;
|
||||
// offset StrategyServer* owner (the RAW base; the RNG accessor uses owner-4) [verified]
|
||||
constexpr uint32_t ServerSystem_off_Owner = 0x00000010;
|
||||
// offset int Idx [verified]
|
||||
constexpr uint32_t ServerSystem_off_Idx = 0x0000005c;
|
||||
// offset int Size (1..10); the capacity base is Size * 100000000 as an exact int64 product [verified]
|
||||
constexpr uint32_t ServerSystem_off_Size = 0x00000060;
|
||||
// offset float Suit [verified]
|
||||
constexpr uint32_t ServerSystem_off_Suit = 0x00000064;
|
||||
// offset int Res [verified]
|
||||
constexpr uint32_t ServerSystem_off_Res = 0x00000068;
|
||||
// offset int ARes2 [verified]
|
||||
constexpr uint32_t ServerSystem_off_ARes2 = 0x0000006c;
|
||||
// offset int MRes [verified]
|
||||
constexpr uint32_t ServerSystem_off_MRes = 0x00000070;
|
||||
// offset int TRes -- zeroed every turn by ProcessTurn [verified]
|
||||
constexpr uint32_t ServerSystem_off_TRes = 0x00000074;
|
||||
// offset bool haltv[3] -- growth halt per group; cleared every turn by ProcessTurn [verified]
|
||||
constexpr uint32_t ServerSystem_off_haltv = 0x00000078;
|
||||
// offset float OutMod [verified]
|
||||
constexpr uint32_t ServerSystem_off_OutMod = 0x0000007c;
|
||||
// offset int TAcq (turn acquired) [verified]
|
||||
constexpr uint32_t ServerSystem_off_TAcq = 0x00000080;
|
||||
// offset StarSystem::OutputRates (0x1c): float SRt, SRsc, SRtf, SRi, SRoh, SRs; int SRnr [verified]
|
||||
constexpr uint32_t ServerSystem_off_Rates = 0x00000088;
|
||||
// offset float SRoh -- the over-harvest slider (Rates + 0x10) [verified]
|
||||
constexpr uint32_t ServerSystem_off_SRoh = 0x00000098;
|
||||
// offset BuildQueue* [verified]
|
||||
constexpr uint32_t ServerSystem_off_BuildQueue = 0x000000a4;
|
||||
// offset std::string Name (0x1c, MSVC SSO; capacity word at +0xbc) [verified]
|
||||
constexpr uint32_t ServerSystem_off_Name = 0x000000a8;
|
||||
// offset bool Abdn [verified]
|
||||
constexpr uint32_t ServerSystem_off_Abdn = 0x000000c4;
|
||||
// offset int64 Bats2 -- player i's 4-bit battle-recent counter at bits [4i, 4i+4), i < 15 [verified]
|
||||
constexpr uint32_t ServerSystem_off_Bats2 = 0x000000f0;
|
||||
// offset int64 rcex -- the same shape for the explored/recon-recent counter [verified]
|
||||
constexpr uint32_t ServerSystem_off_Rcex = 0x000000f8;
|
||||
// offset ServerPlayer* PID (null = unowned) [verified]
|
||||
constexpr uint32_t ServerSystem_off_PID = 0x00000100;
|
||||
// offset Morale cm (0x20: vptr + int[7]) [verified]
|
||||
constexpr uint32_t ServerSystem_off_Morale = 0x0000011c;
|
||||
// offset std::vector<StarFleet*> [verified]
|
||||
constexpr uint32_t ServerSystem_off_Fleets = 0x0000016c;
|
||||
// offset int Pop (imperial) [verified]
|
||||
constexpr uint32_t ServerSystem_off_Pop = 0x0000018c;
|
||||
// offset float Infra [verified]
|
||||
constexpr uint32_t ServerSystem_off_Infra = 0x00000190;
|
||||
// offset int pbon -- the pending population bonus (int32, not a float) [verified]
|
||||
constexpr uint32_t ServerSystem_off_pbon = 0x00000194;
|
||||
// offset float ibon -- the pending infrastructure bonus [verified]
|
||||
constexpr uint32_t ServerSystem_off_ibon = 0x00000198;
|
||||
// offset Population Pop2 (civilians): {vptr, vector<PopulationGroup> @+4}, 24-byte entries {?, int type @+4, int species @+8, int64 count @+0x10} [verified]
|
||||
constexpr uint32_t ServerSystem_off_Pop2 = 0x000001a0;
|
||||
// offset Population pbon2 -- the civilian analogue of pbon [verified]
|
||||
constexpr uint32_t ServerSystem_off_pbon2 = 0x000001b4;
|
||||
// offset IndependenceInfo* indi (int indsp at +4) [verified]
|
||||
constexpr uint32_t ServerSystem_off_Indi = 0x000001c8;
|
||||
// offset int rbfl -- rebelling-species bitmask [verified]
|
||||
constexpr uint32_t ServerSystem_off_rbfl = 0x000001dc;
|
||||
// offset int adt[7] -- per-species addiction start turn; 0 means never addicted [verified]
|
||||
constexpr uint32_t ServerSystem_off_adt = 0x000001e4;
|
||||
// offset uint32 -- bit i is cleared when player i's Bats2 counter reaches 0 [verified]
|
||||
constexpr uint32_t ServerSystem_off_BatsMask = 0x000002a0;
|
||||
// offset uint32 -- the same for rcex [verified]
|
||||
constexpr uint32_t ServerSystem_off_RcexMask = 0x000002a4;
|
||||
// offset int TnsOH (turns over-harvesting) [verified]
|
||||
constexpr uint32_t ServerSystem_off_TnsOH = 0x000002b8;
|
||||
// offset int ntdev -- turns developing; ++ when IsStable, reset to 0 otherwise AND by either bonus-apply helper on a non-home system. This is the second SYSTEMBONUS_MINTURNS gate, not rbtn [verified]
|
||||
constexpr uint32_t ServerSystem_off_ntdev = 0x000002c4;
|
||||
// offset int rbtn [verified]
|
||||
constexpr uint32_t ServerSystem_off_rbtn = 0x000002cc;
|
||||
// offset int ModCount (the turn counter), relative to the RAW server base a ServerSystem's +0x10 points at [verified]
|
||||
constexpr uint32_t StrategyServer_off_ModCount = 0x00000008;
|
||||
// offset std::vector<ServerPlayer*> (begin @+0x50, end @+0x54); numPlayers = (end-begin)>>2 [verified]
|
||||
constexpr uint32_t StrategyServer_off_Players = 0x00000050;
|
||||
// offset std::vector<StarFleet*> (begin @+0x64, end @+0x68) -- one flat global list, not per player [verified]
|
||||
constexpr uint32_t StrategyServer_off_Fleets = 0x00000064;
|
||||
// offset 16-bucket hash of entity id -> object, hashed by (key & 0xF); 0x008b9240 is the lookup [verified]
|
||||
constexpr uint32_t StrategyServer_off_EntityHash = 0x00000084;
|
||||
// offset Mars::RNG* relative to the RAW base (== the -4-adjusted base's +0x16c) [verified]
|
||||
constexpr uint32_t StrategyServer_off_RNGPtr = 0x00000168;
|
||||
// offset std::set<pair<FleetId,LocationId>> cleared at the head of ProcessFleetMovement [verified]
|
||||
constexpr uint32_t StrategyServer_off_ArrivedSet = 0x00000204;
|
||||
// offset std::set<pair<FleetId,LocationId>> that MoveFleet fills for fleets still in motion; OnFleetArrived takes the set difference [verified]
|
||||
constexpr uint32_t StrategyServer_off_InMotionSet = 0x00000214;
|
||||
// offset int id (also the entity-hash key) [verified]
|
||||
constexpr uint32_t StarFleet_off_Id = 0x00000004;
|
||||
// offset the object whose +0x80 holds the entity hash the waypoint target is resolved in [verified]
|
||||
constexpr uint32_t StarFleet_off_Galaxy = 0x00000010;
|
||||
// offset Vector3 Pos [verified]
|
||||
constexpr uint32_t StarFleet_off_Pos = 0x00000018;
|
||||
// offset Vector3 PrvPos -- set to the ENTRY position when the fleet moved [verified]
|
||||
constexpr uint32_t StarFleet_off_PrvPos = 0x0000004c;
|
||||
// offset ServerPlayer* owner [verified]
|
||||
constexpr uint32_t StarFleet_off_PID = 0x00000058;
|
||||
// offset Location*; kind at Location+0x14 (0 system, 1 fleet, 2 point) [verified]
|
||||
constexpr uint32_t StarFleet_off_Location = 0x000000a0;
|
||||
// offset std::vector<StarShip*> (begin @+0xa4, end @+0xa8) [verified]
|
||||
constexpr uint32_t StarFleet_off_Ships = 0x000000a4;
|
||||
// offset int16 -- SIGNED, summed into the owner's gate traffic [verified]
|
||||
constexpr uint32_t StarFleet_off_GateTraffic = 0x000000c0;
|
||||
// offset std::vector<Waypoint> _Myfirst (proxy @+0xc4, last @+0xcc, end @+0xd0) [verified]
|
||||
constexpr uint32_t StarFleet_off_Waypoints = 0x000000c8;
|
||||
// offset float FPsp2 -- the fleet's strategic speed [verified]
|
||||
constexpr uint32_t StarFleet_off_Speed = 0x000000d8;
|
||||
// offset Vector3 -- set after every pass to the current waypoint target's position. The notes called this FPogn2; by the FlightPlan layout it is FPdpos [verified]
|
||||
constexpr uint32_t StarFleet_off_DestPos = 0x000000ec;
|
||||
// offset uint32; bit 0x100 = held this turn (cleared for every fleet at the end of ProcessFleetMovement), bit 0x2 cleared in the destination pass, bit 0x1 set by MoveFleet when the fleet moved [verified]
|
||||
constexpr uint32_t StarFleet_off_Flags = 0x0000010c;
|
||||
// offset sizeof(Waypoint) -- pinned by the divide-by-28 reciprocal multiply in the iterator arithmetic [verified]
|
||||
constexpr uint32_t Waypoint_stride = 0x0000001c;
|
||||
// offset int -- the destination entity id [verified]
|
||||
constexpr uint32_t Waypoint_off_Target = 0x00000004;
|
||||
// offset int -- 2 node line, 3 node route, 4 gate teleport, 5 probabilistic jump, otherwise a straight run [verified]
|
||||
constexpr uint32_t Waypoint_off_Type = 0x00000008;
|
||||
// offset uint64 flag pair; bit 0x1000 exempts the ship from movement fuel and marks it a tanker [verified]
|
||||
constexpr uint32_t StarShip_off_Flags = 0x00000018;
|
||||
// offset float Range -- remaining strategic range [verified]
|
||||
constexpr uint32_t StarShip_off_Range = 0x00000020;
|
||||
// offset float -- the cap the refuel helper clamps Range to [verified]
|
||||
constexpr uint32_t StarShip_off_MaxRange = 0x00000078;
|
||||
// offset ServerSystem* -- the bonus-apply helpers skip the ntdev reset for this system [verified]
|
||||
constexpr uint32_t ServerPlayer_off_HomeSystem = 0x0000002c;
|
||||
// offset int GTraf -- assigned (not accumulated) once per turn [verified]
|
||||
constexpr uint32_t ServerPlayer_off_GateTraffic = 0x0000014c;
|
||||
// offset float CstE -- the probabilistic jump's efficiency [verified]
|
||||
constexpr uint32_t ServerPlayer_off_CstE = 0x00000154;
|
||||
// offset float CstT -- the probabilistic jump's threshold [verified]
|
||||
constexpr uint32_t ServerPlayer_off_CstT = 0x00000158;
|
||||
// data int** -- the GlobalConst pointer slot; the storage word is *slot [verified]
|
||||
constexpr uint32_t g_ptr_SYSTEMBONUS_MINTURNS = 0x006eca10;
|
||||
// data float** -- pointer slot [verified]
|
||||
constexpr uint32_t g_ptr_SYSTEMBONUS_POPBONUS = 0x006eca18;
|
||||
// data float** -- pointer slot [verified]
|
||||
constexpr uint32_t g_ptr_SYSTEMBONUS_INFRABONUS = 0x006eca20;
|
||||
// data float** -- pointer slot [verified]
|
||||
constexpr uint32_t g_ptr_SYSTEMBONUS_POPBONUS_INC = 0x006eca38;
|
||||
// data float** -- pointer slot [verified]
|
||||
constexpr uint32_t g_ptr_SYSTEMBONUS_INFRABONUS_INC = 0x006eca40;
|
||||
// data int** -- pointer slot (image default 10) [verified]
|
||||
constexpr uint32_t g_ptr_ADDICTION_PHASE2_START = 0x006eca58;
|
||||
// data int** -- pointer slot (image default 15) [verified]
|
||||
constexpr uint32_t g_ptr_ADDICTION_PHASE3_START = 0x006eca60;
|
||||
// data float -- 0.05f, a hard-coded literal in .data, NOT a GlobalConst; both ServerSystem::ProcessTurn calls to the independent pop-drift helper pass it [verified]
|
||||
constexpr uint32_t g_IndependentPopDriftRate = 0x006eca80;
|
||||
// data float** -- pointer slot; storage 0x00b212cc (shipped value 2) [verified]
|
||||
constexpr uint32_t g_ptr_STUTTER_SYSTEM_INFLUENCE_RADIUS = 0x006ebc44;
|
||||
// data float** -- pointer slot; storage 0x00b212d0 (shipped value 0.33) [verified]
|
||||
constexpr uint32_t g_ptr_STUTTER_MIN_SPEED = 0x006ebc48;
|
||||
// data float** -- pointer slot; storage 0x00b212d4 (shipped value 0.33). NOTE min == max in the shipped data, so the stutter ramp collapses to a constant 0.33x inside any influence sphere [verified]
|
||||
constexpr uint32_t g_ptr_STUTTER_MAX_SPEED = 0x006ebc4c;
|
||||
|
||||
} // namespace sots::addr
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue