Files
Dreierpack-Manager/tests/modern_stadium_ui_tests.cpp
T

295 lines
26 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/demo_stadium.hpp"
#include <array>
#include <chrono>
#include <cmath>
#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() == 5 && 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").at("periphery").size() == 14 && !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", 3}}, {{"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");
}
Json scene_fixture() {
const auto binding=[](const std::string &id) {return Json{{"asset",id},{"width",300},{"scale",1.2},{"anchorX",.4},{"anchorY",.8},{"offsetX",12},{"offsetY",-7}};};
Json config={{"schemaVersion",1},{"activeProfile","modern"},{"simulation",{{"capacity",100000}}},{"assets",Json::object()}};
auto &profile=config["profiles"]["modern"];
profile["referenceSize"]={{"width",1920},{"height",1080}};
profile["background"]=binding("panorama-forest");
profile["backgroundOptions"]=Json::array({{{"variants",Json::array()}}});
const auto add=[&](const std::string &id) {config["assets"][id]={{"width",1500},{"height",1000}};return binding(id);};
for(int i=0;i<5;++i)profile["backgroundOptions"][0]["variants"].push_back(add("traffic-"+std::to_string(i)));
profile["stadium"]={{"transform",{{"x",945.3},{"y",718.1},{"scale",1},{"z",20}}},{"thresholds",{10000,25000,50000,75000,100000}},{"variants",Json::array()}};
for(int i=0;i<6;++i)profile["stadium"]["variants"].push_back(add("stadium-"+std::to_string(i)));
profile["objects"]=Json::array();
for(int i=0;i<14;++i) {
Json variants=Json::array(),overlays=Json::array();const int cap=i==0?0:i==4?3:1;
for(int level=1;level<=cap;++level){variants.push_back(add("site-"+std::to_string(i)+"-"+std::to_string(level)));if(i<=5)overlays.push_back(add("overlay-"+std::to_string(i)+"-"+std::to_string(level)));}
profile["objects"].push_back({{"id",i},{"transform",{{"x",400+i*50},{"y",650},{"scale",1.5},{"z",i<6?15:40}}},
{"hitArea",{{"width",100},{"height",80},{"offsetX",10},{"offsetY",-30}}},
{"state",{{"status","built"},{"completedLevel",cap},{"targetLevel",cap}}},
{"sprites",{{"variants",variants},{"overlays",overlays},{"marker",add("marker")}}}});
}
return config;
}
void periphery() {
for(int precision:{0,2}) {
Fixture fixture(precision);const auto &world=*fixture.world;const int64_t factor=precision?100:1;
Json defaults;defaults=Json::object();require(migrate_demo_stadium(defaults,world),"Initialize periphery fixture");
auto old=defaults;old["stadium"].erase("periphery");const auto before=old;
require(migrate_demo_stadium(old,world)&&old==defaults,"Old four-field checkpoint not extended exactly");
old=before;old["stadium"]["budget"]=3;const auto broken=old;
require(!migrate_demo_stadium(old,world)&&old==broken,"Invalid old ledger repaired during periphery migration");
for(int i=0;i<14;++i) {
const int cap=i==0?4:i==4?3:1;
for(int level=0;level<cap;++level) {
auto state=defaults;state["stadium"]["periphery"][size_t(i)]["level"]=level;
const auto request=Json{{"kind","periphery"},{"index",i},{"level",level+1}};
const auto q=demo_stadium_quote(state,request,world);require(q.at("can_build")==true,"Next periphery level rejected");
const auto keep=state;reject_build(state,{{"kind","periphery"},{"index",i},{"level",level+2}},world);
reject_build(state,{{"kind","periphery"},{"index",i},{"level",level}},world);
build(state,request,world);conserved(state,world,factor);
const auto current=demo_stadium_view(state,world),future=demo_stadium_view(state,world,true);
require(current.at("periphery")[size_t(i)].at("display_level")==level&&future.at("periphery")[size_t(i)].at("display_level")==level+1,"Periphery current/future projection wrong");
auto other=state;other["stadium"]["periphery"]=keep.at("stadium").at("periphery");other["stadium"]["budget"]=keep.at("stadium").at("budget");require(other==keep,"Periphery build affected another ledger or finance");
reject_build(state,request,world);
const auto checkpoint=Json::parse(state.dump());require(valid_demo_stadium(checkpoint,world)&&checkpoint==state,"Periphery checkpoint loses pending weeks/level");
auto corrupt=state;corrupt["stadium"]["periphery"][size_t(i)]["job"]["level"]=level+2;require(!valid_demo_stadium(corrupt,world),"Skipped queued periphery level accepted");
corrupt=state;corrupt["stadium"]["periphery"][size_t(i)]["job"]["weeks"]=1;require(!valid_demo_stadium(corrupt,world),"Invalid periphery weeks accepted");
}
}
auto state=defaults;for(auto &row:state["stadium"]["periphery"])row["level"]=0;
const auto config=scene_fixture(),keep=config;
const auto initial=demo_stadium_scene(config,demo_stadium_view(state,world),false);
require(initial.at("layers").size()==2&&initial.at("traffic_level")==0,"Export full-build preview leaked into empty career");
const auto &area=initial.at("areas")[0];require(area.at("x")==340&&area.at("y")==545&&area.at("width")==150&&area.at("height")==120,"Calibrated hit area did not scale around object transform");
build(state,{{"kind","periphery"},{"index",4},{"level",1}},world);
build(state,{{"kind","periphery"},{"index",6},{"level",1}},world);
build(state,{{"kind","periphery"},{"index",0},{"level",1}},world);
auto current=demo_stadium_scene(config,demo_stadium_view(state,world),false),future=demo_stadium_scene(config,demo_stadium_view(state,world,true),true);
require(current.at("traffic_level")==1&&future.at("traffic_level")==1,"Construction transport target panorama wrong");
bool overlay=false,marker=false;for(const auto &layer:current.at("layers")) {
overlay|=layer.at("owner")==4&&layer.at("role")=="overlay";
marker|=layer.at("owner")==6&&layer.at("role")=="marker";
if(layer.at("owner")==6)require(layer.at("role")=="marker","Snack building appears before completion");
if(layer.at("owner")==4)require(std::abs(layer.at("x").get<double>()-402)<.00001&&std::abs(layer.at("y").get<double>()-351.5)<.00001,"PNG anchor/offset geometry changed");
}
require(overlay&&marker,"Missing parking overlay or independent snack marker");
for(const auto &layer:future.at("layers"))require(layer.at("role")!="overlay"&&layer.at("role")!="marker","Future preview retains construction overlay");
auto overview=demo_stadium_view(state,world);const std::array<int,4> boundaries{10000,25000,50000,75000};
for(size_t i=0;i<boundaries.size();++i)for(int delta:{-1,0}) {overview["physical_capacity"]=boundaries[i]+delta;require(demo_stadium_scene(config,overview,false).at("stadium_index")==i+(delta==0),"Capacity boundary selects wrong stadium");}
overview["physical_capacity"]=100000;
require(demo_stadium_scene(config,overview,false).at("stadium_index")==4,"Capacity alone selected the reserved Super-Stadion image");
require(config==keep,"Scene projection mutated calibrated export");
auto block_state=defaults;build(block_state,block(0,4000),world);require(demo_stadium_view(block_state,world).at("physical_capacity")==36000&&demo_stadium_view(block_state,world,true).at("physical_capacity")==37000,"Closed block shrinks physical stadium artwork");
}
}
void super_stadium() {
for (int precision : {0, 2}) {
Fixture fixture(precision);
const auto &world = *fixture.world;
Json full = Json::object();
require(migrate_demo_stadium(full, world), "Initialize Super-Stadion fixture");
const auto rules = demo_stadium_rules(world), config = scene_fixture();
int maximum = 0;
for (size_t i = 0; i < 8; ++i) {
const int places = rules.at("blocks")[i].at("max_places").get<int>();
full["stadium"]["blocks"][i] = {{"places", places}, {"seats", true}, {"roof", true}, {"job", nullptr}};
maximum += places;
}
require(maximum == 96000 && valid_demo_stadium(full, world), "Full block maxima or stadium fixture invalid");
const auto verify = [&](const Json &state, bool future, bool expected) {
const auto before = state;
const auto view = demo_stadium_view(state, world, future);
const auto scene = demo_stadium_scene(config, view, future);
require(view.at("ok") == true && view.at("super_stadium") == expected,
"Super-Stadion predicate ignores a block capacity/seat/roof boundary");
require(scene.at("stadium_index") == (expected ? 5 : 4),
"Full-upgrade status selected the wrong stadium image");
require(view.at("periphery").size() == 14 && scene.at("areas").size() == 14 && state == before,
"Super-Stadion projection changed periphery or source state");
};
verify(full, false, true);
verify(full, true, true);
for (size_t i = 0; i < 8; ++i) {
auto unroofed = full;
unroofed["stadium"]["blocks"][i]["roof"] = false;
verify(unroofed, false, false);
verify(unroofed, true, false);
auto standing = full;
standing["stadium"]["blocks"][i]["seats"] = false;
verify(standing, false, false);
verify(standing, true, false);
auto smaller = full;
smaller["stadium"]["blocks"][i]["places"] = rules.at("blocks")[i].at("max_places").get<int>() - 1000;
verify(smaller, false, false);
verify(smaller, true, false);
build(unroofed, block(int(i), rules.at("blocks")[i].at("max_places").get<int>(), true, true), world);
verify(unroofed, false, false);
verify(unroofed, true, true);
}
auto queued = full;
for (size_t i = 0; i < 8; ++i) {
auto &base = queued["stadium"]["blocks"][i];
base["places"] = rules.at("blocks")[i].at("max_places").get<int>() - 1000;
base["seats"] = false;
base["roof"] = false;
}
for (size_t i = 0; i < 8; ++i)
build(queued, block(int(i), rules.at("blocks")[i].at("max_places").get<int>(), true, true), world);
conserved(queued, world, precision ? 100 : 1);
verify(queued, false, false);
verify(queued, true, true);
require(demo_stadium_view(queued, world).at("physical_capacity") == 88000 &&
demo_stadium_view(queued, world, true).at("physical_capacity") == 96000,
"Queued maximum was treated as already completed");
}
}
} // namespace
int main() try {
currency(0); currency(2); periphery(); super_stadium();
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; }