Files
Dreierpack-Manager/src/game/memory.hpp
T

90 lines
3.6 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// The static data of the original (its data object, LE addresses GermanDataSegmentBegin-layout field) as far
// as the savegame stores it.
//
// Many parts of the original work on small global tables that point at each other, e.g.
// the cup table at CupTable whose entries hold pointers to team lists and result arrays in
// other globals. Porting every one of them into a typed field would lose that structure,
// so they are kept here as raw memory addressed like in the original. The pointers stored
// in such tables are guest linear addresses: data address + kGuestDataBase.
//
// Blocks that GameState also decodes into typed fields (squads, players, results, ...)
// must be read and written through those fields; their copies here are not kept current.
#include <cstdint>
#include <cstdio>
#include <map>
#include <stdexcept>
#include <string>
#include <vector>
#include "formats/savestate.hpp"
namespace bmh {
// Offset between the LE addresses of the data object and the guest linear addresses the
// original stores in pointers (DOS/4GW loads the data object at relocated data-segment base).
constexpr uint32_t kGuestDataBase = 0x1a2000;
class StaticMemory {
public:
StaticMemory() = default;
// All non-heap blocks of a savegame.
explicit StaticMemory(const SaveState& save) {
for (const SaveBlock& b : save.blocks())
if (!b.heap && b.size != 0 && !blocks_.count(b.address))
blocks_[b.address].assign(save.stream().begin() + b.offset, save.stream().begin() + b.offset + b.size);
}
// A global the savegame does not store (e.g. a work list the original rebuilds before
// use): created zeroed unless it is there already.
void add_block(uint32_t address, size_t size) {
if (!has(address)) blocks_[address].assign(size, 0);
}
bool has(uint32_t address) const {
auto it = blocks_.upper_bound(address);
if (it == blocks_.begin()) return false;
--it;
return address - it->first < it->second.size();
}
uint8_t& at(uint32_t address) {
auto it = blocks_.upper_bound(address);
if (it != blocks_.begin()) {
--it;
if (address - it->first < it->second.size()) return it->second[address - it->first];
}
throw std::out_of_range("static memory: address " + hex(address) + " is not in the savegame");
}
uint8_t u8(uint32_t a) const { return const_cast<StaticMemory*>(this)->at(a); }
uint16_t u16(uint32_t a) const { return uint16_t(u8(a) | u8(a + 1) << 8); }
uint32_t u32(uint32_t a) const { return uint32_t(u16(a) | uint32_t(u16(a + 2)) << 16); }
void set8(uint32_t a, uint8_t v) { at(a) = v; }
void set16(uint32_t a, uint16_t v) { at(a) = uint8_t(v), at(a + 1) = uint8_t(v >> 8); }
void set32(uint32_t a, uint32_t v) { set16(a, uint16_t(v)), set16(a + 2, uint16_t(v >> 16)); }
// A pointer stored in the original's memory, as an LE data address (0 stays 0).
uint32_t pointer(uint32_t a) const {
uint32_t p = u32(a);
return p == 0 ? 0 : p - kGuestDataBase;
}
void set_pointer(uint32_t a, uint32_t address) { set32(a, address == 0 ? 0 : address + kGuestDataBase); }
const std::map<uint32_t, Bytes> &blocks() const { return blocks_; }
static StaticMemory from_blocks(std::map<uint32_t, Bytes> blocks) {
StaticMemory memory;
memory.blocks_ = std::move(blocks);
return memory;
}
private:
static std::string hex(uint32_t v) {
char b[16];
std::snprintf(b, sizeof b, "0x%x", v);
return b;
}
std::map<uint32_t, std::vector<uint8_t>> blocks_;
};
} // namespace bmh