// SPDX-License-Identifier: GPL-3.0-only #include "formats/native_state.hpp" #include #include 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 J number(T v) { return J(int64_t(v)); } template void number(const J &j, T &v) { if (!j.integer()) invalid(); const auto n = *j.integer(); if constexpr (std::is_unsigned_v) { if (n < 0 || uint64_t(n) > uint64_t(std::numeric_limits::max())) invalid(); } else if (n < std::numeric_limits::min() || n > std::numeric_limits::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 J scalar(T n) { return number(n); } template void scalar(const J &j, T &n) { number(j, n); } template J sequence(const Range &values) { A out; for (const auto v : values) out.push_back(number(v)); return out; } template void sequence(const J &j, std::vector &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 void sequence(const J &j, std::array &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 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