Files
Dreierpack-Manager/src/formats/native_state.cpp
T

196 lines
8.2 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/native_state.hpp"
#include <limits>
#include <type_traits>
namespace bmh {
namespace {
using J = cli::Json;
using O = J::Object;
using A = J::Array;
[[noreturn]] void invalid() { throw FormatError("native state: invalid or missing field"); }
const J &field(const J &obj, const char *name) {
if (!obj.object())
invalid();
const auto it = obj.object()->find(name);
if (it == obj.object()->end())
invalid();
return it->second;
}
template <class T> J number(T v) { return J(int64_t(v)); }
template <class T> void number(const J &j, T &v) {
if (!j.integer())
invalid();
const auto n = *j.integer();
if constexpr (std::is_unsigned_v<T>) {
if (n < 0 || uint64_t(n) > uint64_t(std::numeric_limits<T>::max()))
invalid();
} else if (n < std::numeric_limits<T>::min() || n > std::numeric_limits<T>::max())
invalid();
v = T(n);
}
J scalar(bool b) { return b; }
void scalar(const J &j, bool &b) {
if (!j.boolean())
invalid();
b = *j.boolean();
}
template <class T> J scalar(T n) { return number(n); }
template <class T> void scalar(const J &j, T &n) { number(j, n); }
template <class Range> J sequence(const Range &values) {
A out;
for (const auto v : values)
out.push_back(number(v));
return out;
}
template <class T> void sequence(const J &j, std::vector<T> &values) {
if (!j.array() || j.array()->size() > 1000000)
invalid();
values.resize(j.array()->size());
for (size_t i = 0; i < values.size(); ++i)
number((*j.array())[i], values[i]);
}
template <class T, size_t N> void sequence(const J &j, std::array<T, N> &values) {
if (!j.array() || j.array()->size() != N)
invalid();
for (size_t i = 0; i < N; ++i)
number((*j.array())[i], values[i]);
}
std::string hex(const Bytes &data) {
constexpr char d[] = "0123456789abcdef";
std::string out;
out.reserve(data.size() * 2);
for (auto c : data) {
out += d[c >> 4];
out += d[c & 15];
}
return out;
}
Bytes unhex(const J &value) {
if (!value.string() || value.string()->size() % 2 || value.string()->size() > 32 * 1024 * 1024)
invalid();
const auto &s = *value.string();
Bytes b;
b.reserve(s.size() / 2);
const auto digit = [](char c) -> int {
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
invalid();
};
for (size_t i = 0; i < s.size(); i += 2)
b.push_back(uint8_t(digit(s[i]) * 16 + digit(s[i + 1])));
return b;
}
} // namespace
cli::Json encode_native_bytes(const Bytes &bytes) {
return O{{"schema", "classic-bytes@1.0"}, {"hex", hex(bytes)}};
}
Bytes decode_native_bytes(const J &value, size_t expected) {
if (!field(value, "schema").string() || *field(value, "schema").string() != "classic-bytes@1.0")
invalid();
auto b = unhex(field(value, "hex"));
if (b.size() != expected)
invalid();
return b;
}
#define STATE_SCALARS(X) \
X(indoor) \
X(level) X(chance_rain) X(chance_temperature) X(last_shooter) X(last_pick_quality) X(live_scene) \
X(sportschau_selection_available) X(sportschau_club_threshold) X(list_toggle) X(lineups_frozen) \
X(offer_answer) X(transfer_notice_suppressed) X(pools_open) X(autosave_months) X(autosave_month) \
X(display_start_year) X(date) X(season_start) X(development_balance) X(trend_rotation) \
X(season)
#define STATE_BYTES(X) \
X(team_morale) \
X(player_bonus) X(formations) X(manager_records) X(tactics) X(manager_options) X(club_table) \
X(club_heap_bc) X(club_heap_78) X(club_heap_b8) X(master_database_metadata) X(referee_names) \
X(stadium_names) X(tournament_name) X(manager_results) X(manager_ratings) X(position_history) \
X(league_rounds) X(results) X(stocks) X(foreign_strength) X(mailbox) X(club_names) \
X(player_names)
#define STATE_NUMBERS(X) \
X(squad_slots) \
X(team_flags) X(manager_teams) X(live_matches) X(sportschau_homes) X(sportschau_priorities) X(club_ids) \
X(player_cards) X(player_name_offsets)
J encode_native_state(const GameState &g) {
O out{{"schema", "classic-state@1.0"}};
#define PUT_SCALAR(name) out[#name] = scalar(g.name);
STATE_SCALARS(PUT_SCALAR)
#undef PUT_SCALAR
#define PUT_BYTES(name) out[#name] = hex(g.name);
STATE_BYTES(PUT_BYTES)
#undef PUT_BYTES
#define PUT_NUMBERS(name) out[#name] = sequence(g.name);
STATE_NUMBERS(PUT_NUMBERS)
#undef PUT_NUMBERS
A players;
for (const auto &p : g.players)
players.push_back(O{{"name_hex", hex(Bytes(p.name.begin(), p.name.end()))},
{"form", number(p.w35c)},
{"skills", number(p.w368)},
{"identity", number(p.w364)}});
out["players"] = std::move(players);
A blocks;
for (const auto &[at, bytes] : g.memory.blocks())
blocks.push_back(O{{"address", number(at)}, {"hex", hex(bytes)}});
out["memory"] = std::move(blocks);
// Reality scene residues influence later matches and must survive a checkpoint.
out["reality"] = O{{"initialized", g.reality.initialized}, {"deflected", g.reality.deflected},
{"card_kind", number(g.reality.card_kind)}, {"distance", g.reality.distance},
{"actors", sequence(g.reality.cue_actors)}, {"grid", g.reality.grid.checkpoint()}};
return out;
}
GameState decode_native_state(const J &in) {
if (!field(in, "schema").string() || *field(in, "schema").string() != "classic-state@1.0")
invalid();
GameState g;
#define GET_SCALAR(name) scalar(field(in, #name), g.name);
STATE_SCALARS(GET_SCALAR)
#undef GET_SCALAR
#define GET_BYTES(name) g.name = unhex(field(in, #name));
STATE_BYTES(GET_BYTES)
#undef GET_BYTES
#define GET_NUMBERS(name) sequence(field(in, #name), g.name);
STATE_NUMBERS(GET_NUMBERS)
#undef GET_NUMBERS
const auto &players = field(in, "players");
if (!players.array() || players.array()->size() > 4095)
invalid();
for (const auto &row : *players.array()) {
Player p;
auto bytes = unhex(field(row, "name_hex"));
p.name.assign(bytes.begin(), bytes.end());
number(field(row, "form"), p.w35c);
number(field(row, "skills"), p.w368);
number(field(row, "identity"), p.w364);
g.players.push_back(std::move(p));
}
const auto &memory = field(in, "memory");
if (!memory.array() || memory.array()->size() > 8192)
invalid();
std::map<uint32_t, Bytes> blocks;
for (const auto &row : *memory.array()) {
uint32_t at;
number(field(row, "address"), at);
auto b = unhex(field(row, "hex"));
if (uint64_t(at) + b.size() > UINT32_MAX || !blocks.emplace(at, std::move(b)).second)
invalid();
}
g.memory = StaticMemory::from_blocks(std::move(blocks));
const auto &reality = field(in, "reality");
scalar(field(reality, "initialized"), g.reality.initialized);
scalar(field(reality, "deflected"), g.reality.deflected);
number(field(reality, "card_kind"), g.reality.card_kind);
number(field(reality, "distance"), g.reality.distance);
sequence(field(reality, "actors"), g.reality.cue_actors);
g.reality.grid.restore_checkpoint(field(reality, "grid"));
if (g.display_start_year < 1900 || g.display_start_year > 9998 || g.manager_teams.size() > 4 ||
g.level < 0 || g.level > 9 || g.date < g.season_start || g.date > 3000000)
invalid();
return g;
}
#undef STATE_SCALARS
#undef STATE_BYTES
#undef STATE_NUMBERS
} // namespace bmh