Port stadium blocks and facilities without periphery construction (by Codex)

This commit is contained in:
Codex committed 2026-10-25 15:51:35 +01:00
1 parent 0f36b507d4
commit 349c416f3a
21 files changed
+1185 -12

No files matched your search

+158
View File
@@ -0,0 +1,158 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/demo_stadium.hpp"
#include <array>
#include <chrono>
#include <fstream>
#include <iostream>
#include <stdexcept>
using namespace bmh::modern_ui;
namespace {
void require(bool ok, const char *reason) { if (!ok) throw std::runtime_error(reason); }
const std::string first = "club:stadium-test-a", second = "club:stadium-test-b";
struct Fixture {
fs::path root; std::shared_ptr<const Catalog> world;
Fixture(int precision = 0, bool clubs = true) {
root = fs::temp_directory_path() / ("openbmh-stadium-ui-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
fs::create_directories(root / "world");
const auto write = [&](const std::string &path, const Json &value) { std::ofstream file(root / path); file << value.dump(); require(bool(file), "Cannot write synthetic stadium fixture"); };
write("manifest.json", {{"format", "openbmh-world"}, {"kind", "world"}, {"format_version", "1.1"}, {"id", "world:stadium-test"}, {"start_date", "2026-07-01"}, {"currency", {{"code", "EUR"}, {"minor_units", precision}}}, {"requires", {"runtime:modern-v1"}}});
write("world/nations.json", {{"items", {{{"id", "nation:de"}, {"name", "Synthetic country"}}}}});
write("world/competitions.json", {{"items", {{{"id", "competition:stadium-test"}, {"type", "league"}, {"nation", "nation:de"}, {"name", "Synthetic competition"}}}}});
Json teams = Json::array(), stadiums = Json::array();
if (clubs) {
for (const auto &id : {first, second}) {
teams.push_back({{"id", id}, {"name", "Synthetic " + id}, {"competition", "competition:stadium-test"}, {"nation", "nation:de"}, {"stadium", "stadium:" + id}});
stadiums.push_back({{"id", "stadium:" + id}, {"owner", id}, {"name", "Synthetic ground " + id}, {"capacity", 98765}, {"initialization", {{"policy", "test-must-not-run"}}}});
}
}
write("world/clubs.json", {{"items", teams}}); write("world/stadiums.json", {{"items", stadiums}});
write("world/players.json", {{"items", Json::array()}}); world = Catalog::open(root);
}
~Fixture() { std::error_code error; fs::remove_all(root, error); }
};
Json block(int index, int places, bool seats = false, bool roof = false) { return {{"kind", "block"}, {"index", index}, {"places", places}, {"seats", seats}, {"roof", roof}}; }
Json facility(int index, int level) { return {{"kind", "facility"}, {"index", index}, {"level", level}}; }
Json without_stadium(Json state) { state.erase("stadium"); return state; }
void build(Json &state, const Json &request, const Catalog &world) {
const auto result = edit_demo_stadium(state, {{"kind", "build"}, {"request", request}}, world);
if (!result.empty()) throw std::runtime_error("Unexpected construction rejection: " + result + " " + request.dump());
require(valid_demo_stadium(state, world), "Accepted construction invalidated stadium");
}
void reject(Json &state, const Json &action, const Catalog &world) {
const auto before = state;
require(!edit_demo_stadium(state, action, world).empty() && state == before, "Rejected construction accepted or mutated state");
}
void reject_build(Json &state, const Json &request, const Catalog &world) { reject(state, {{"kind", "build"}, {"request", request}}, world); }
void conserved(const Json &state, const Catalog &world, int64_t factor) {
const auto view = demo_stadium_view(state, world);
require(view.at("budget").get<int64_t>() + view.at("pending_cost").get<int64_t>() == 50000000 * factor, "Local budget plus pending orders not conserved");
}
void currency(int precision) {
Fixture fixture(precision); const auto &world = *fixture.world; const int64_t factor = precision ? 100 : 1;
Json state = {{"managers", {{{"club", second}, {"name", "Synthetic manager"}}}}, {"cash", 12450000 * factor}, {"deposit", 600000 * factor}, {"debt", 0}, {"ticket", 13}, {"date", "2026-07-01"}, {"contracts", {{"untouched", {1,2,3}}}}};
const auto unrelated = state, world_clubs = world.rows("clubs"), world_stadiums = world.rows("stadiums"), manifest = world.manifest();
require(!valid_demo_stadium(state, world) && migrate_demo_stadium(state, world) && valid_demo_stadium(state, world) && without_stadium(state) == unrelated, "Missing-state migration altered unrelated fields or failed");
const auto defaults = state;
require(state.at("stadium").size() == 4 && state.at("stadium").at("club") == second && state.at("stadium").at("budget") == 50000000 * factor, "Canonical fields, manager binding or raw budget wrong");
require(!state.at("stadium").contains("periphery") && !state.at("stadium").contains("ticket"), "Excluded construction/navigation leaked into canonical model");
const auto overview = demo_stadium_view(state, world);
require(overview.at("capacity") == 36000 && overview.at("planned_capacity") == 36000 && overview.at("available_capacity") == 36000 && overview.at("name") == "Synthetic ground " + second && overview.at("stadium") == "stadium:" + second, "Overview lost identity or incorrectly derived capacity from OBW initialization");
const std::array<int, 8> base{3000,6000,3000,5000,3000,6000,3000,7000}, caps{8000,18000,8000,14000,8000,18000,8000,14000}, rates{300000,375000,300000,350000,300000,375000,300000,350000}, weeks{30,37,30,25,30,37,30,25};
const auto rules = demo_stadium_rules(world);
for (int i = 0; i < 8; ++i) {
require(rules.at("blocks")[size_t(i)].at("max_places") == caps[size_t(i)] && rules.at("blocks")[size_t(i)].at("rate") == rates[size_t(i)] * factor, "Pinned block caps/rates changed");
auto next = defaults; const auto request = block(i, base[size_t(i)] + 1000); const auto q = demo_stadium_quote(next, request, world);
require(q.at("ok") == true && q.at("can_build") == true && q.at("cost") == rates[size_t(i)] * factor && q.at("placesCost") == q.at("cost") && q.at("seatsCost") == 0 && q.at("roofCost") == 0 && q.at("weeks") == weeks[size_t(i)] && next == defaults, "Block quote changed state, units or weeks");
build(next, request, world); conserved(next, world, factor);
const auto current = demo_stadium_view(next, world), future = demo_stadium_view(next, world, true);
require(next.at("stadium").at("blocks")[size_t(i)].at("places") == base[size_t(i)] && current.at("capacity") == 36000 - base[size_t(i)] && future.at("capacity") == 37000 && current.at("blocks")[size_t(i)].at("display_places") == 0 && future.at("blocks")[size_t(i)].at("display_places") == base[size_t(i)] + 1000, "Pending block completed early or current/future capacity wrong");
require(demo_stadium_quote(next, request, world).at("error") == "stadium_pending", "Pending target not locked"); reject_build(next, request, world);
const auto noop = demo_stadium_quote(defaults, block(i, base[size_t(i)]), world);
require(noop.at("ok") == true && noop.at("can_build") == false && noop.at("cost") == 0 && noop.at("error") == "stadium_no_change", "No-op not quoted as disabled");
auto unmodified = defaults; reject_build(unmodified, block(i, base[size_t(i)]), world); reject_build(unmodified, block(i, base[size_t(i)] - 1000), world); reject_build(unmodified, block(i, caps[size_t(i)] + 1000), world); reject_build(unmodified, block(i, base[size_t(i)] + 1), world);
for (int seats = 0; seats < 2; ++seats) for (int roof = 0; roof < 2; ++roof) {
const auto f = demo_stadium_quote(defaults, block(i, base[size_t(i)] + 1000, bool(seats), bool(roof)), world);
const int64_t total = rates[size_t(i)] + int64_t(base[size_t(i)] / 1000 + 1) * rates[size_t(i)] * (seats * 45 + roof * 30) / 100;
require(f.at("cost") == total * factor, "New features not charged for all target places");
}
}
auto features = defaults;
require(demo_stadium_quote(features, block(0, 3000, true, true), world).at("cost") == 675000 * factor, "Feature-only upgrade disallowed or priced incorrectly");
build(features, block(0, 3000, true, true), world);
require(demo_stadium_view(features, world).at("capacity") == 33000 && demo_stadium_view(features, world, true).at("capacity") == 36000, "Feature-only pending block not closed in current view");
auto imported = defaults; imported["stadium"]["blocks"][0]["seats"] = true;
require(valid_demo_stadium(imported, world) && demo_stadium_quote(imported, block(0, 4000, true, true), world).at("cost") == 795000 * factor, "Existing seats should charge added places only");
imported["stadium"]["blocks"][0]["roof"] = true;
require(demo_stadium_quote(imported, block(0, 4000, true, true), world).at("cost") == 525000 * factor, "Existing seats/roof charged entire block again");
reject_build(imported, block(0, 4000, false, true), world); reject_build(imported, block(0, 4000, true, false), world);
const std::array<int, 8> levels{1,2,1,1,2,2,2,1}, f_rates{250000,350000,850000,1200000,180000,200000,300000,400000}, f_weeks{12,15,16,18,8,5,10,14};
for (int i = 0; i < 8; ++i) {
const int cap = i == 2 || i == 3 ? 2 : 4;
require(rules.at("facilities")[size_t(i)].at("max_level") == cap && rules.at("facilities")[size_t(i)].at("rate") == f_rates[size_t(i)] * factor && rules.at("facilities")[size_t(i)].at("levels").size() == size_t(cap + 1), "Facility caps, rates or level labels wrong");
for (int level = levels[size_t(i)] + 1; level <= cap; ++level) {
auto next = defaults; const auto q = demo_stadium_quote(next, facility(i, level), world);
require(q.at("cost") == (level - levels[size_t(i)]) * f_rates[size_t(i)] * factor && q.at("weeks") == f_weeks[size_t(i)] && q.at("can_build") == true, "Facility target skip or fixed weeks wrong");
build(next, facility(i, level), world); conserved(next, world, factor);
require(demo_stadium_view(next, world).at("facilities")[size_t(i)].at("display_level") == levels[size_t(i)] && demo_stadium_view(next, world, true).at("facilities")[size_t(i)].at("display_level") == level, "Facility job applied before completion");
reject_build(next, facility(i, level), world);
}
auto next = defaults; reject_build(next, facility(i, levels[size_t(i)]), world); reject_build(next, facility(i, 0), world); reject_build(next, facility(i, cap + 1), world);
for (int existing = 1; existing <= cap; ++existing) {
auto saved = defaults; saved["stadium"]["facilities"][size_t(i)]["level"] = existing;
require(valid_demo_stadium(saved, world), "Legal imported facility level rejected");
for (int target = existing; target <= cap; ++target) {
const auto q = demo_stadium_quote(saved, facility(i, target), world);
require(q.at("ok") == true && q.at("can_build") == (target > existing) && q.at("cost") == (target - existing) * f_rates[size_t(i)] * factor, "Facility quote failed a legal current/target level combination");
}
}
}
auto spent = defaults; const auto old_quote = demo_stadium_quote(spent, facility(6, 4), world);
for (int i = 0; i < 8; ++i) build(spent, block(i, caps[size_t(i)], true, true), world);
require(spent.at("stadium").at("budget") == 4725000 * factor && demo_stadium_view(spent, world).at("capacity") == 0 && demo_stadium_view(spent, world, true).at("capacity") == 96000, "All-eight max construction pricing/capacity changed");
for (int i = 0; i < 6; ++i) build(spent, facility(i, i == 2 || i == 3 ? 2 : 4), world);
require(spent.at("stadium").at("budget") == 465000 * factor && old_quote.at("can_build") == true && demo_stadium_quote(spent, facility(6, 4), world).at("error") == "stadium_budget_exceeded", "Stale quote not revalidated against remaining local budget");
reject_build(spent, facility(6, 4), world); conserved(spent, world, factor);
for (const auto &action : std::vector<Json>{nullptr, Json::array(), Json::object(), {{"kind", "complete"}}, {{"kind", "ticket"}, {"value", 0}}, {{"kind", "periphery"}, {"index", 0}}, {{"kind", "build"}, {"request", facility(7, 2)}, {"cost", 1}}}) reject(spent, action, world);
for (const auto &request : std::vector<Json>{nullptr, {{"kind", "periphery"}, {"index", 0}, {"level", 1}}, {{"kind", "block"}, {"index", -1}, {"places", 4000}, {"seats", false}, {"roof", false}}, {{"kind", "block"}, {"index", true}, {"places", 4000}, {"seats", false}, {"roof", false}}, {{"kind", "block"}, {"index", uint64_t(-1)}, {"places", 4000}, {"seats", false}, {"roof", false}}, {{"kind", "block"}, {"index", 0}, {"places", uint64_t(-1)}, {"seats", false}, {"roof", false}}, {{"kind", "block"}, {"index", 0}, {"places", 4000.0}, {"seats", false}, {"roof", false}}, {{"kind", "facility"}, {"index", 0}, {"level", 2}, {"weeks", 1}}}) { auto next = defaults; reject_build(next, request, world); }
std::vector<Json> corrupt;
auto bad = defaults; bad["stadium"]["budget"] = 1; corrupt.push_back(bad);
bad = defaults; bad["stadium"]["periphery"] = Json::array(); corrupt.push_back(bad);
bad = defaults; bad["stadium"].erase("club"); corrupt.push_back(bad);
bad = defaults; bad["stadium"]["club"] = first; corrupt.push_back(bad);
bad = defaults; bad["stadium"]["blocks"][0]["places"] = 3333; corrupt.push_back(bad);
bad = defaults; bad["stadium"]["facilities"][2]["level"] = 3; corrupt.push_back(bad);
bad = features; bad["stadium"]["blocks"][0]["job"]["cost"] = 675001 * factor; bad["stadium"]["budget"] = (50000000 - 675001) * factor; corrupt.push_back(bad);
bad = features; bad["stadium"]["blocks"][0]["job"]["weeks"] = 29; corrupt.push_back(bad);
bad = features; bad["stadium"]["blocks"][0]["job"]["places"] = 2000; corrupt.push_back(bad);
bad = spent; bad["stadium"]["facilities"][0]["job"]["level"] = 1; corrupt.push_back(bad);
bad = defaults; bad["stadium"]["blocks"].push_back(bad["stadium"]["blocks"][0]); corrupt.push_back(bad);
bad = defaults; bad["stadium"]["blocks"][0]["seats"] = 1; corrupt.push_back(bad);
bad = defaults; bad["stadium"]["blocks"][0]["roof"] = "false"; corrupt.push_back(bad);
bad = defaults; bad["stadium"]["facilities"].erase(bad["stadium"]["facilities"].begin()); corrupt.push_back(bad);
bad = defaults; bad["stadium"]["budget"] = uint64_t(-1); corrupt.push_back(bad);
bad = defaults; bad["stadium"] = nullptr; corrupt.push_back(bad);
for (auto &value : corrupt) {
const auto saved = value;
require(!valid_demo_stadium(value, world) && !migrate_demo_stadium(value, world) && value == saved && demo_stadium_quote(value, block(0, 4000), world).at("ok") == false, "Invalid existing state silently repaired or queried");
reject_build(value, block(0, 4000), world);
}
const auto keep = spent;
require(migrate_demo_stadium(spent, world) && spent == keep && valid_demo_stadium(Json::parse(spent.dump()), world) && without_stadium(spent) == unrelated, "Current migration/checkpoint roundtrip changed jobs or unrelated model");
auto copied = demo_stadium_view(spent, world, true); copied["blocks"][0]["places"] = 0;
require(demo_stadium_view(spent, world, true).at("blocks")[0].at("places") == 3000 && spent == keep, "Projection aliases saved state");
auto later = spent; later["date"] = "2036-07-01";
require(valid_demo_stadium(later, world) && demo_stadium_view(later, world).at("pending_cost") == demo_stadium_view(spent, world).at("pending_cost") && later.at("stadium") == spent.at("stadium"), "Presentation date implicitly completed pending jobs");
require(world.rows("clubs") == world_clubs && world.rows("stadiums") == world_stadiums && world.manifest() == manifest, "Provider mutated original world records");
require(demo_stadium(world, first).at("club") == first && !valid_demo_stadium(defaults, world, first), "Explicit manager binding ignored");
}
} // namespace
int main() try {
currency(0); currency(2);
Fixture empty(0, false); Json state = {{"cash", 77}, {"ticket", 13}};
require(migrate_demo_stadium(state, *empty.world) && valid_demo_stadium(state, *empty.world) && state.at("stadium").at("club") == "" && demo_stadium_view(state, *empty.world).at("stadium").is_null() && demo_stadium_view(state, *empty.world).at("name") == "Stadion", "Zero-club fixture invented identity or crashed");
const auto saved = state; require(!migrate_demo_stadium(state, *empty.world, "club:missing") && state == saved, "Invalid explicit club accepted");
Fixture precision(1); Json unsupported = {{"untouched", true}}; const auto original = unsupported;
require(!migrate_demo_stadium(unsupported, *precision.world) && unsupported == original, "Unsupported currency precision initialized guessed prices");
std::cout << "Modern UI stadium checks passed\n"; return 0;
} catch (const std::exception &error) { std::cerr << error.what() << '\n'; return 1; }