city3d_smoke.cpp
bash/model-3D/city3d_smoke.cpp · 340 line(s) · c
// SleelaTerminal(TM) -- SLeeLa's terminal product, built on GNU Bash
// (GPL, (C) Free Software Foundation). SLeeLa-authored addition; the
// vendored GNU Bash sources keep their own GPL headers and copyright.
// Phraign(TM) City 3D -- smoke test. Asserts model, config, generation,
// serialization round-trip, and rendering onto a Phraign frame.
#include "city_model.hpp"
#include "city_renderer.hpp"
#include "cityscape_model.hpp"
#include "pixel_terminal.hpp"
#include <cassert>
#include <iostream>
#include <string>
int main() {
using namespace sleela::city;
// --- Theme parsing ------------------------------------------------------
Theme t = Theme::White;
assert(parseTheme("green", t) && t == Theme::Green);
assert(parseTheme("WHITE", t) && t == Theme::White);
assert(parseTheme("Blue", t) && t == Theme::Blue);
assert(!parseTheme("purple", t));
assert(std::string(themeName(Theme::Green)) == "green");
// --- Config parsing -----------------------------------------------------
const std::string cfgText =
"# comment\n"
"grid_cols = 64\n"
"grid_rows = 64\n"
"user = tester\n"
"seed = 0\n"
"theme = blue\n"
"tilt_x = 0.4\n"
"frame_width = 320\n"
"frame_height = 240\n"
"save_target = github\n"
"save_location = mearvk/SLeeLa\n"
"bogus_key = ignored\n";
std::string err;
Config cfg = Config::fromText(cfgText, &err);
assert(cfg.grid_cols == 64 && cfg.grid_rows == 64);
assert(cfg.theme == Theme::Blue);
assert(cfg.viewpoint.tilt_x == 0.4);
assert(cfg.frame_width == 320 && cfg.frame_height == 240);
assert(cfg.save_target == "github" && cfg.save_location == "mearvk/SLeeLa");
assert(err.empty());
// --- Year / quality / weight config keys --------------------------------
const std::string p =
"year = 2807\n"
"year_baseline = 2000\n"
"year_span = 1000\n"
"avg_floors = 20\n"
"floor_height = 1.5\n"
"windows_per_floor = 8\n"
"road_spacing = 8\n"
"bridge_count = 5\n"
"w_year = 1.0\n"
"w_road_proximity = 0.8\n"
"proximity_falloff = 6\n"
"iq = 150\n"
"iq_baseline = 100\n"
"iq_span = 100\n"
"w_iq = 0.7\n"
"legislature = unicameral\n"
"draw_bridges = false\n"
"draw_windows = off\n";
Config pc = Config::fromText(p, &err);
assert(pc.params.year == 2807);
assert(pc.params.avg_floors == 20.0);
assert(pc.params.floor_height == 1.5);
assert(pc.params.windows_per_floor == 8.0);
assert(pc.params.road_spacing == 8 && pc.params.bridge_count == 5);
assert(pc.params.iq == 150 && pc.params.iq_baseline == 100);
assert(pc.params.w_iq == 0.7);
assert(pc.params.legislature == Legislature::Unicameral);
assert(pc.draw_bridges == false && pc.draw_windows == false);
assert(err.empty());
// modernity = (2807-2000)/1000 = 0.807.
assert(pc.params.modernity() > 0.80 && pc.params.modernity() < 0.81);
// designQuality = (150-100)/100 = 0.5.
assert(pc.params.designQuality() > 0.49 && pc.params.designQuality() < 0.51);
// --- IQ -> designQuality mapping (clamped) ------------------------------
CityParams iqp;
iqp.iq = 100; assert(iqp.designQuality() == 0.0);
iqp.iq = 200; assert(iqp.designQuality() == 1.0);
iqp.iq = 300; assert(iqp.designQuality() == 1.0); // clamps above 1
iqp.iq = 50; assert(iqp.designQuality() == 0.0); // clamps below 0
// --- Legislature parse / name round-trip + distinct profiles ------------
Legislature lg = Legislature::Federal;
assert(parseLegislature("unicameral", lg) && lg == Legislature::Unicameral);
assert(parseLegislature("BICAMERAL", lg) && lg == Legislature::Bicameral);
assert(parseLegislature("Municipal", lg) && lg == Legislature::Municipal);
assert(!parseLegislature("monarchy", lg));
assert(std::string(legislatureName(Legislature::Direct)) == "direct");
// Unicameral is more linear than federal; direct is less regular than municipal.
assert(LegislatureProfile::forLegislature(Legislature::Unicameral).linearity >
LegislatureProfile::forLegislature(Legislature::Federal).linearity);
assert(LegislatureProfile::forLegislature(Legislature::Municipal).regularity >
LegislatureProfile::forLegislature(Legislature::Direct).regularity);
// --- Year drives modernity/finality: newer > older ----------------------
CityParams oldP; oldP.year = 2050;
CityParams newP; newP.year = 2807;
City oldC(48, 48), newC(48, 48);
oldC.generate(999, oldP);
newC.generate(999, newP);
assert(newC.params().modernity() > oldC.params().modernity());
assert(newC.cityFinality() > oldC.cityFinality());
assert(oldC.cityFinality() >= 0.0 && newC.cityFinality() <= 1.0);
// --- IQ drives finality: higher IQ -> higher finality -------------------
CityParams loIq; loIq.year = 2807; loIq.iq = 100;
CityParams hiIq; hiIq.year = 2807; hiIq.iq = 200;
City loC(48, 48), hiC(48, 48);
loC.generate(4242, loIq);
hiC.generate(4242, hiIq);
assert(hiC.cityFinality() > loC.cityFinality());
// --- Per-user seed is stable and non-zero -------------------------------
const std::uint64_t s1 = seedForUser("tester");
const std::uint64_t s2 = seedForUser("tester");
const std::uint64_t s3 = seedForUser("other");
assert(s1 == s2 && s1 != 0 && s1 != s3);
// --- Block count is ~4000 (4096) ---------------------------------------
City city(cfg.grid_cols, cfg.grid_rows);
assert(city.blockCount() == 4096);
// --- Generation is deterministic for a seed + params -------------------
CityParams gp; gp.year = 2807; gp.iq = 165; gp.legislature = Legislature::Bicameral;
gp.radix = 4; gp.diameter = 22.0; gp.randomness = 0.4;
City a(64, 64), b(64, 64);
a.generate(12345, gp);
b.generate(12345, gp);
bool identical = true;
for (std::uint32_t y = 0; y < 64 && identical; ++y)
for (std::uint32_t x = 0; x < 64; ++x) {
const Block& pa = a.at(x, y);
const Block& pb = b.at(x, y);
if (pa.height != pb.height || pa.floors != pb.floors ||
pa.windows != pb.windows || pa.cell != pb.cell ||
pa.finality != pb.finality) { identical = false; break; }
}
assert(identical);
// Some buildings exist (not an empty city), with floors + windows.
std::size_t nonzero = 0, withFloors = 0, withWindows = 0;
for (std::uint32_t y = 0; y < 64; ++y)
for (std::uint32_t x = 0; x < 64; ++x) {
const Block& blk = a.at(x, y);
if (blk.isBuilding() && blk.height > 0) ++nonzero;
if (blk.floors > 0) ++withFloors;
if (blk.windows > 0) ++withWindows;
}
assert(nonzero > 1000);
assert(withFloors > 1000 && withWindows > 1000);
// --- Roads, bridges, and computed proximity ----------------------------
std::size_t roads = 0, bridges = 0;
for (std::uint32_t y = 0; y < 64; ++y)
for (std::uint32_t x = 0; x < 64; ++x) {
const Cell cell = a.at(x, y).cell;
if (cell == Cell::Road) ++roads;
if (cell == Cell::Bridge) ++bridges;
}
assert(roads > 0); // road corridors exist
assert(bridges > 0); // bridge spans placed
// A road/bridge cell has proximity 0; buildings have finite distances.
for (std::uint32_t y = 0; y < 64; ++y)
for (std::uint32_t x = 0; x < 64; ++x) {
const Block& blk = a.at(x, y);
assert(blk.road_distance >= 0.0f);
if (blk.cell == Cell::Road || blk.cell == Cell::Bridge)
assert(blk.road_distance == 0.0f);
}
// City finality is a sane average.
assert(a.cityFinality() > 0.0 && a.cityFinality() <= 1.0);
// --- Serialize / deserialize round-trip (v4, all attributes) -----------
const std::string text = a.serialize("tester", 12345);
assert(text.find("PHRAIGN-CITY 4") == 0);
assert(text.find("year 2807") != std::string::npos);
assert(text.find("iq 165") != std::string::npos);
assert(text.find("legislature bicameral") != std::string::npos);
assert(text.find("radix 4") != std::string::npos);
City c;
std::string ru;
std::uint64_t rs = 0;
assert(City::deserialize(text, c, &ru, &rs));
assert(ru == "tester" && rs == 12345);
assert(c.cols() == 64 && c.rows() == 64);
assert(c.params().year == 2807 && c.params().iq == 165);
assert(c.params().legislature == Legislature::Bicameral);
assert(c.params().radix == 4 && c.params().diameter == 22.0);
assert(c.params().randomness == 0.4);
bool round = true;
for (std::uint32_t y = 0; y < 64 && round; ++y)
for (std::uint32_t x = 0; x < 64; ++x) {
const Block& pa = a.at(x, y);
const Block& pc = c.at(x, y);
if (pa.height != pc.height || pa.floors != pc.floors ||
pa.windows != pc.windows || pa.cell != pc.cell) {
round = false; break;
}
}
assert(round);
// --- Back-compat: read a legacy v2 (no iq/legislature) model -----------
const std::string v2 =
"PHRAIGN-CITY 2\n"
"user v2user\n"
"seed 21\n"
"year 2400\n"
"finality 0.5\n"
"grid 2 2\n"
"cell 0 0 0\n"
"row 0 8 9\n"
"floors 0 4 5\n"
"windows 0 20 24\n"
"fin 0 500 520\n"
"cell 1 0 0\n"
"row 1 7 6\n"
"floors 1 3 2\n"
"windows 1 12 10\n"
"fin 1 480 470\n"
"END\n";
City v2c;
std::string v2u;
assert(City::deserialize(v2, v2c, &v2u));
assert(v2u == "v2user" && v2c.cols() == 2 && v2c.rows() == 2);
assert(v2c.params().year == 2400);
assert(v2c.at(0, 0).height == 8 && v2c.at(1, 0).floors == 5);
// --- Back-compat: read a legacy v1 (height-only) model -----------------
const std::string v1 =
"PHRAIGN-CITY 1\n"
"user legacy\n"
"seed 7\n"
"grid 2 2\n"
"row 0 3 4\n"
"row 1 5 6\n"
"END\n";
City lc;
std::string lu;
std::uint64_t ls = 0;
assert(City::deserialize(v1, lc, &lu, &ls));
assert(lu == "legacy" && ls == 7 && lc.cols() == 2 && lc.rows() == 2);
assert(lc.at(0, 0).height == 3 && lc.at(1, 1).height == 6);
// Reject clearly invalid input.
City junk;
assert(!City::deserialize("not a city\n", junk));
// --- Render onto a Phraign frame ---------------------------------------
// Use a compact viewpoint that fits the 64x64 city into a 320x240 frame.
RenderOptions ro = cfg.renderOptions();
ro.frame_width = 320;
ro.frame_height = 240;
ro.viewpoint.scale_x = 3.0;
ro.viewpoint.block_pitch = 3.0;
ro.viewpoint.scale_height = 0.4;
ro.viewpoint.origin_x = 50.0;
ro.viewpoint.origin_y = 150.0;
sleela::terminal::PixelTerminal term(
sleela::terminal::Size{ro.frame_width, ro.frame_height});
Renderer renderer(ro);
const std::size_t drawn = renderer.render(a, term);
assert(drawn > 0);
assert(term.pixelSize().width == 320 && term.pixelSize().height == 240);
assert(term.frame().size() == 320u * 240u);
// Background theme color should appear somewhere (frame was filled first).
const Palette pal = Palette::forTheme(Theme::Blue);
(void)pal;
// --- General cityscape model: graph from centricity --------------------
CityParams mp; mp.year = 2807; mp.iq = 165; mp.legislature = Legislature::Federal;
CityscapeModel g1, g2;
g1.build(777, /*radix=*/3, /*diameter=*/24.0, /*randomness=*/0.35, mp, 64u, 64u);
g2.build(777, 3, 24.0, 0.35, mp, 64u, 64u);
// Reproducible for the same (seed, radix, diameter, randomness, params).
assert(g1.nodes().size() == g2.nodes().size());
assert(g1.edgeCount() == g2.edgeCount());
assert(g1.cylinders().size() == g2.cylinders().size());
// A center of centricity plus branches: more than one node, one cylinder
// pair per node, and a connected tree (edges == nodes - 1).
assert(g1.nodes().size() > 1);
assert(g1.cylinders().size() == g1.nodes().size());
assert(g1.edgeCount() == g1.nodes().size() - 1);
// The root node is the center of centricity.
assert(g1.nodes().front().isCenter());
// Every node celebrated and noted at least one neighbor (except a lone
// center, which has children here).
for (const Node& n : g1.nodes()) {
assert(n.celebrated);
assert(!n.neighbors.empty());
}
// Radix changes the branching: a larger radix yields more nodes.
CityscapeModel gWide;
gWide.build(777, 5, 24.0, 0.35, mp, 64u, 64u);
assert(gWide.nodes().size() > g1.nodes().size());
// Randomness varies the graph: a different randomness gives a different
// node count or layout (very likely; assert node count differs or matches
// but with jitter -- here we just require it still builds sanely).
CityscapeModel gRand;
gRand.build(777, 3, 24.0, 0.9, mp, 64u, 64u);
assert(gRand.nodes().size() > 1);
// Diameter bounds the reach: no node exceeds the diameter from center.
for (const Node& n : g1.nodes())
assert(n.distance_from_center <= g1.diameter() + 1e-6);
// Mating cylinder pairs grace spheres of known moral symmetry (positive).
for (const CylinderPair& cp : g1.cylinders()) {
assert(cp.sphere_radius > 0.0);
assert(cp.sphere_symmetry >= 0.0 && cp.sphere_symmetry <= 1.0);
assert(cp.sphere_center.z > 0.0); // sphere rides above the pair in Z
}
assert(g1.moralSymmetry() > 0.5 && g1.moralSymmetry() <= 1.0);
assert(std::string(CityscapeModel::orientation()).find("positive") == 0);
// Rendering the city + graph writes strictly more than the city alone.
sleela::terminal::PixelTerminal gterm(sleela::terminal::Size{320, 240});
RenderOptions gro = ro;
gro.draw_cylinders = true;
Renderer grenderer(gro);
const std::size_t gdrawn = grenderer.render(a, g1, gterm);
assert(gdrawn > 0);
std::cout << "phraign city3d smoke: OK ("
<< city.blockCount() << " blocks, " << drawn
<< " px; graph nodes=" << g1.nodes().size()
<< " edges=" << g1.edgeCount()
<< " moralSymmetry=" << g1.moralSymmetry() << ")\n";
return 0;
}