1714 lines
69 KiB
C++
1714 lines
69 KiB
C++
#include "catch.hpp"
|
||
|
||
#include <map>
|
||
#include <random>
|
||
#include <set>
|
||
#include <string>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
#include <QPoint>
|
||
|
||
#include "BeltSystem.h"
|
||
#include "Building.h"
|
||
#include "BuildingSystem.h"
|
||
#include "BuildingType.h"
|
||
#include "ConfigLoader.h"
|
||
#include "Item.h"
|
||
#include "ItemType.h"
|
||
#include "Port.h"
|
||
#include "Rotation.h"
|
||
#include "Tick.h"
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Fixture helpers
|
||
// ---------------------------------------------------------------------------
|
||
|
||
static GameConfig loadConfig()
|
||
{
|
||
return ConfigLoader::loadFromDirectory(CONFIG_DIR);
|
||
}
|
||
|
||
static Item makeItem(const std::string& id)
|
||
{
|
||
Item item;
|
||
item.type.id = id;
|
||
return item;
|
||
}
|
||
|
||
static Port eastPort(QPoint tile)
|
||
{
|
||
Port p;
|
||
p.tile = tile;
|
||
p.direction = Rotation::East;
|
||
return p;
|
||
}
|
||
|
||
static Port westPort(QPoint tile)
|
||
{
|
||
Port p;
|
||
p.tile = tile;
|
||
p.direction = Rotation::West;
|
||
return p;
|
||
}
|
||
|
||
// Run N full sim ticks: construction, belt-pull, production, belt-push, belt tick.
|
||
static void runTicks(BuildingSystem& bs, BeltSystem& belts, int n, Tick& tick)
|
||
{
|
||
for (int i = 0; i < n; ++i)
|
||
{
|
||
bs.tickConstruction(tick);
|
||
bs.tickDeconstruction(tick);
|
||
bs.tickBeltPull();
|
||
bs.tickProduction(tick);
|
||
bs.tickOutputBelts();
|
||
belts.tick();
|
||
++tick;
|
||
}
|
||
}
|
||
|
||
// All items currently on a building's output side: buffered plus still-emerging on
|
||
// the virtual output belts (REQ-MAT-OUTPUT-EMERGE). A produced item leaves the
|
||
// output buffer the moment it starts emerging, so tests count both.
|
||
static std::vector<Item> outputSideItems(const Building& b)
|
||
{
|
||
std::vector<Item> items = b.outputBuffer.items;
|
||
for (const std::vector<BeltItemSlot>& lane : b.emergingItems)
|
||
{
|
||
for (const BeltItemSlot& slot : lane)
|
||
{
|
||
items.push_back(slot.item);
|
||
}
|
||
}
|
||
return items;
|
||
}
|
||
|
||
// Owns a BuildingSystem and its dependencies for placement-bounds tests.
|
||
struct PlacementFixture
|
||
{
|
||
GameConfig cfg = loadConfig();
|
||
BeltSystem belts{cfg.world.beltSpeed_tps};
|
||
int stock = 0;
|
||
std::mt19937 rng{0};
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs;
|
||
|
||
PlacementFixture()
|
||
: bs(cfg, belts,
|
||
[this]() { return nextBuildingId++; },
|
||
[this](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng)
|
||
{
|
||
}
|
||
};
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Placement
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: place miner occupies expected body tiles", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
REQUIRE(id != kInvalidBuildingId);
|
||
|
||
// Miner mask ["AA","A>"] with East rotation → body at (0,0),(1,0),(0,1).
|
||
REQUIRE(bs.isTileOccupied(QPoint(0, 0)));
|
||
REQUIRE(bs.isTileOccupied(QPoint(1, 0)));
|
||
REQUIRE(bs.isTileOccupied(QPoint(0, 1)));
|
||
// (1,1) is the output-port tile, NOT a body cell.
|
||
REQUIRE_FALSE(bs.isTileOccupied(QPoint(1, 1)));
|
||
}
|
||
|
||
// -- World-bounds rejection (REQ-BLD-PLACE-VALID) ---------------------------
|
||
|
||
TEST_CASE("BuildingSystem: place rejects a building above the world (y < 0)", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
|
||
// Miner mask ["AA","A>"] East → body at (0,0),(1,0),(0,1); at y=-1 the top
|
||
// row sits above the world.
|
||
const std::optional<BuildingId> id = f.bs.place(BuildingType::Miner, QPoint(0, -1), Rotation::East, 0);
|
||
REQUIRE_FALSE(id.has_value());
|
||
REQUIRE(f.bs.getAllSites().empty());
|
||
REQUIRE_FALSE(f.bs.isTileOccupied(QPoint(0, 0)));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: place rejects a building below the world (y >= height)", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
const int heightTiles = f.cfg.world.heightTiles;
|
||
|
||
// Anchored on the last in-bounds row, the miner's lower body row reaches
|
||
// y == heightTiles, which is outside the world.
|
||
const std::optional<BuildingId> id = f.bs.place(BuildingType::Miner,
|
||
QPoint(0, heightTiles - 1), Rotation::East, 0);
|
||
REQUIRE_FALSE(id.has_value());
|
||
REQUIRE(f.bs.getAllSites().empty());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: place rejects a building left of the asteroid edge", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
const int leftEdgeX = -f.cfg.world.regions.asteroidWidth_tiles;
|
||
|
||
const std::optional<BuildingId> id = f.bs.place(BuildingType::Miner,
|
||
QPoint(leftEdgeX - 1, 0), Rotation::East, 0);
|
||
REQUIRE_FALSE(id.has_value());
|
||
REQUIRE(f.bs.getAllSites().empty());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: place accepts a building flush against the world's left edge",
|
||
"[building]")
|
||
{
|
||
PlacementFixture f;
|
||
const int leftEdgeX = -f.cfg.world.regions.asteroidWidth_tiles;
|
||
|
||
// Miner body min relative x is 0, so its leftmost cell sits exactly on the edge.
|
||
const BuildingId id = f.bs.place(BuildingType::Miner,
|
||
QPoint(leftEdgeX, 0), Rotation::East, 0).value();
|
||
REQUIRE(id != kInvalidBuildingId);
|
||
REQUIRE(f.bs.isTileOccupied(QPoint(leftEdgeX, 0)));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: place imposes no right-side bound (space extends rightward)",
|
||
"[building]")
|
||
{
|
||
PlacementFixture f;
|
||
|
||
const BuildingId id = f.bs.place(BuildingType::Miner,
|
||
QPoint(1000, 0), Rotation::East, 0).value();
|
||
REQUIRE(id != kInvalidBuildingId);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: isPlacementValid enforces terrain and world bounds", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
const int leftEdgeX = -f.cfg.world.regions.asteroidWidth_tiles;
|
||
|
||
// Miner is all-asteroid (A): valid only fully on the asteroid (x < 0).
|
||
REQUIRE(f.bs.isPlacementValid(BuildingType::Miner, QPoint(-3, 0), Rotation::East));
|
||
REQUIRE_FALSE(f.bs.isPlacementValid(BuildingType::Miner, QPoint(0, 0), Rotation::East)); // A cells in space
|
||
REQUIRE_FALSE(f.bs.isPlacementValid(BuildingType::Miner, QPoint(0, -1), Rotation::East)); // above world
|
||
REQUIRE(f.bs.isPlacementValid(BuildingType::Miner, QPoint(leftEdgeX, 0), Rotation::East));
|
||
REQUIRE_FALSE(f.bs.isPlacementValid(BuildingType::Miner,
|
||
QPoint(leftEdgeX - 1, 0), Rotation::East)); // past left edge
|
||
|
||
// Shipyard mask ["AAAS>","AAAS "] straddles the boundary: A cells on the
|
||
// asteroid, the S (dock) cell in space. At anchor (-3,0) the A cells land at
|
||
// x=-3..-1 and the dock at x=0.
|
||
REQUIRE(f.bs.isPlacementValid(BuildingType::Shipyard, QPoint(-3, 0), Rotation::East));
|
||
REQUIRE_FALSE(f.bs.isPlacementValid(BuildingType::Shipyard, QPoint(0, 0), Rotation::East)); // A cells in space
|
||
REQUIRE_FALSE(f.bs.isPlacementValid(BuildingType::Shipyard, QPoint(-4, 0), Rotation::East)); // dock on asteroid
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: placing a belt registers it with BeltSystem after construction",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
bs.place(BuildingType::Belt, QPoint(5, 5), Rotation::East, 0);
|
||
|
||
// Belt is queued — not yet in BeltSystem.
|
||
REQUIRE_FALSE(belts.tryPutItem(QPoint(5, 5), makeItem("iron_ore"), Rotation::East));
|
||
|
||
// Complete construction (1 s).
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(1.0)) + 1, tick);
|
||
|
||
REQUIRE(belts.tryPutItem(QPoint(5, 5), makeItem("iron_ore"), Rotation::East));
|
||
REQUIRE(bs.getAllBuildings().size() == 1);
|
||
REQUIRE(bs.getAllBuildings()[0].type == BuildingType::Belt);
|
||
REQUIRE(bs.getAllBuildings()[0].anchor == QPoint(5, 5));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: placed building enters construction queue", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
REQUIRE(bs.getAllSites().size() == 1);
|
||
REQUIRE(bs.getAllBuildings().empty());
|
||
REQUIRE(bs.findSite(id) != nullptr);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: deconstructing a construction site removes it instantly with full refund",
|
||
"[building]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId id =
|
||
f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
// Still queued for construction (not yet built): instant removal, full cost
|
||
// refunded immediately, never entering the deconstruction queue (REQ-BLD-DECONSTRUCT).
|
||
const int refund = f.bs.deconstruct(id, 0);
|
||
|
||
REQUIRE(refund == 15); // Miner cost = 15
|
||
REQUIRE_FALSE(f.bs.isTileOccupied(QPoint(0, 0)));
|
||
REQUIRE(f.bs.getAllSites().empty());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Construction queue
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: first queued building starts construction immediately",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0);
|
||
REQUIRE(bs.getAllSites().front().completesAt > 0);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: second queued building waits (completesAt == 0)", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0);
|
||
bs.place(BuildingType::Miner, QPoint(5, 5), Rotation::East, 0);
|
||
|
||
REQUIRE(bs.getAllSites().size() == 2);
|
||
REQUIRE(bs.getAllSites()[0].completesAt > 0);
|
||
REQUIRE(bs.getAllSites()[1].completesAt == 0);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: construction completes after configured duration", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
// Miner construction_time_seconds = 10. completesAt = secondsToTicks(10) = 300.
|
||
// We need to process tick 300 itself, so run 301 ticks (ticks 0..300).
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(10.0)) + 1, tick);
|
||
|
||
REQUIRE(bs.getAllSites().empty());
|
||
REQUIRE(bs.findBuilding(id) != nullptr);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Deconstruction queue (REQ-BLD-DECON-QUEUE)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// Runs ticks until the building with the given id is operational, or fails.
|
||
static void runUntilBuilt(PlacementFixture& f, BuildingId id, Tick& tick)
|
||
{
|
||
for (int i = 0; i < 100000 && f.bs.findBuilding(id) == nullptr; ++i)
|
||
{
|
||
runTicks(f.bs, f.belts, 1, tick);
|
||
}
|
||
REQUIRE(f.bs.findBuilding(id) != nullptr);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: deconstructing a built building queues it; refund credited on completion",
|
||
"[building][decon]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId id =
|
||
f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runUntilBuilt(f, id, tick);
|
||
|
||
// Deconstructing a built building returns nothing immediately and queues it,
|
||
// stopping it operating while its tiles stay occupied (REQ-BLD-DECON-QUEUE).
|
||
const int refund = f.bs.deconstruct(id, tick);
|
||
REQUIRE(refund == 0);
|
||
REQUIRE(f.bs.isQueuedForDeconstruction(id));
|
||
REQUIRE(f.bs.isTileOccupied(QPoint(0, 0)));
|
||
REQUIRE(f.stock == 0);
|
||
|
||
// After the deconstruction time (0.1s = 3 ticks) it is removed and the partial
|
||
// refund (15 * 75 / 100 = 11) is credited exactly once.
|
||
runTicks(f.bs, f.belts, static_cast<int>(secondsToTicks(0.1)) + 1, tick);
|
||
REQUIRE(f.bs.findBuilding(id) == nullptr);
|
||
REQUIRE_FALSE(f.bs.isTileOccupied(QPoint(0, 0)));
|
||
REQUIRE(f.stock == 15 * f.cfg.world.refundPercentage / 100);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: deconstruction queue removes one building at a time", "[building][decon]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId a = f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
const BuildingId b = f.bs.place(BuildingType::Miner, QPoint(5, 5), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runUntilBuilt(f, a, tick);
|
||
runUntilBuilt(f, b, tick);
|
||
|
||
// Queue both in one tick; 'a' is at the front of the deconstruction queue.
|
||
f.bs.deconstruct(a, tick);
|
||
f.bs.deconstruct(b, tick);
|
||
REQUIRE(f.bs.isQueuedForDeconstruction(a));
|
||
REQUIRE(f.bs.isQueuedForDeconstruction(b));
|
||
|
||
// After one deconstruction interval only the front building is gone; the
|
||
// second is still queued and its refund not yet credited.
|
||
runTicks(f.bs, f.belts, static_cast<int>(secondsToTicks(0.1)) + 1, tick);
|
||
REQUIRE(f.bs.findBuilding(a) == nullptr);
|
||
REQUIRE(f.bs.findBuilding(b) != nullptr);
|
||
REQUIRE(f.bs.isQueuedForDeconstruction(b));
|
||
REQUIRE(f.stock == 15 * f.cfg.world.refundPercentage / 100);
|
||
|
||
// The second drains next.
|
||
runTicks(f.bs, f.belts, static_cast<int>(secondsToTicks(0.1)) + 2, tick);
|
||
REQUIRE(f.bs.findBuilding(b) == nullptr);
|
||
REQUIRE(f.stock == 2 * (15 * f.cfg.world.refundPercentage / 100));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: cancelling deconstruction resumes the building with no refund",
|
||
"[building][decon]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId id =
|
||
f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runUntilBuilt(f, id, tick);
|
||
|
||
f.bs.deconstruct(id, tick);
|
||
REQUIRE(f.bs.isQueuedForDeconstruction(id));
|
||
|
||
// Un-queue before it drains: it operates again, no refund, tiles still occupied.
|
||
f.bs.cancelDeconstruction(id);
|
||
REQUIRE_FALSE(f.bs.isQueuedForDeconstruction(id));
|
||
REQUIRE(f.bs.findBuilding(id) != nullptr);
|
||
REQUIRE(f.bs.isTileOccupied(QPoint(0, 0)));
|
||
REQUIRE(f.stock == 0);
|
||
|
||
// It is never removed even after more than a deconstruction interval passes.
|
||
runTicks(f.bs, f.belts, static_cast<int>(secondsToTicks(0.1)) + 5, tick);
|
||
REQUIRE(f.bs.findBuilding(id) != nullptr);
|
||
REQUIRE(f.stock == 0);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: queued belt stops transporting; cancel restores it", "[building][decon]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId id =
|
||
f.bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runUntilBuilt(f, id, tick);
|
||
REQUIRE(f.belts.tryPutItem(QPoint(0, 0), makeItem("iron_ore"), Rotation::East));
|
||
|
||
// Queuing a belt unregisters its tile from the belt subsystem, so it no longer
|
||
// accepts or transports items, though the tile stays occupied (REQ-BLD-DECON-QUEUE).
|
||
f.bs.deconstruct(id, tick);
|
||
REQUIRE_FALSE(f.belts.tryPutItem(QPoint(0, 0), makeItem("iron_ore"), Rotation::East));
|
||
REQUIRE(f.bs.isTileOccupied(QPoint(0, 0)));
|
||
|
||
// Un-queuing re-registers the belt tile so it transports again.
|
||
f.bs.cancelDeconstruction(id);
|
||
REQUIRE(f.belts.tryPutItem(QPoint(0, 0), makeItem("iron_ore"), Rotation::East));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: splitter filters survive a queue/un-queue round-trip", "[building][decon]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId id =
|
||
f.bs.place(BuildingType::Splitter, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runUntilBuilt(f, id, tick);
|
||
|
||
f.belts.setSplitterFilters(QPoint(0, 0), {ItemType{"iron_ore"}}, {});
|
||
|
||
// Queue: the belt subsystem tile (and its filters) are unregistered, but the
|
||
// filters are captured so an un-queue can restore them.
|
||
f.bs.deconstruct(id, tick);
|
||
REQUIRE_FALSE(f.belts.getSplitterInfo(QPoint(0, 0)).has_value());
|
||
|
||
f.bs.cancelDeconstruction(id);
|
||
const std::optional<BeltSystem::SplitterInfo> info = f.belts.getSplitterInfo(QPoint(0, 0));
|
||
REQUIRE(info.has_value());
|
||
REQUIRE(info->filterA.size() == 1);
|
||
REQUIRE(info->filterA[0].id == "iron_ore");
|
||
REQUIRE(info->filterB.empty());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: second building starts after first completes", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0);
|
||
const BuildingId id2 = bs.place(BuildingType::Miner, QPoint(5, 5), Rotation::East, 0).value();
|
||
|
||
// Process through tick 300 to complete first miner's construction.
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(10.0)) + 1, tick);
|
||
|
||
REQUIRE(bs.getAllSites().size() == 1);
|
||
REQUIRE(bs.getAllSites().front().id == id2);
|
||
REQUIRE(bs.getAllSites().front().completesAt > 0);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Miner production cycle
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: miner produces iron_ore after recipe duration", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(id, "mine_iron_ore");
|
||
|
||
Tick tick = 0;
|
||
// Construction completes on tick 300; production cycle starts tick 300,
|
||
// completes on tick 330. Process through tick 330: 331 ticks total.
|
||
runTicks(bs, belts,
|
||
static_cast<int>(secondsToTicks(10.0)) + static_cast<int>(secondsToTicks(1.0)) + 1,
|
||
tick);
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
// No belt at the output port, so the produced item emerges and stays on the
|
||
// building's virtual output belt (REQ-MAT-OUTPUT-EMERGE).
|
||
const std::vector<Item> out = outputSideItems(*b);
|
||
REQUIRE(out.size() == 1);
|
||
REQUIRE(out.front().type.id == "iron_ore");
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: miner output buffer stalls when full", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(id, "mine_iron_ore");
|
||
|
||
Tick tick = 0;
|
||
// Construction (10s) then cycle 1 starts at tick 300 (completesAt=330).
|
||
// Cycle 1 completes at tick 330: deposit item, continue (no same-tick restart).
|
||
// Cycle 2 starts at tick 331 (completesAt=361).
|
||
// Cycle 2 completes at tick 361: deposit item → buffer=2, cycle 3 stalls.
|
||
// Need to process through tick 361: 362 ticks total.
|
||
runTicks(bs, belts,
|
||
static_cast<int>(secondsToTicks(10.0))
|
||
+ 2 * static_cast<int>(secondsToTicks(1.0)) + 2,
|
||
tick);
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
// Both produced items are held on the output side (buffer + emerging lane),
|
||
// which is what the capacity rule counts (REQ-MAT-OUTPUT-EMERGE).
|
||
REQUIRE(b->getOutputItemCount() == 2);
|
||
REQUIRE_FALSE(b->production.has_value());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// REQ-UI-DEBUG-OVERLAY production counts
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: productionBuildingCount excludes construction sites", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId minerId = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
const BuildingId smelterId = bs.place(BuildingType::Smelter, QPoint(10, 0), Rotation::East, 0).value();
|
||
(void)smelterId;
|
||
|
||
Tick tick = 0;
|
||
// Both still under construction.
|
||
REQUIRE(bs.getProductionBuildingCount() == 0);
|
||
|
||
// The queue builds one at a time: miner (10s) completes at tick 300, then
|
||
// the smelter (15s) starts and completes at tick 300 + 450 = 750.
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(10.0)) + 1, tick);
|
||
REQUIRE(bs.getProductionBuildingCount() == 1);
|
||
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)), tick);
|
||
REQUIRE(bs.getProductionBuildingCount() == 2);
|
||
|
||
// Neither is producing yet: the miner has no recipe selected, and the
|
||
// smelter (auto-recipe, REQ-BLD-SMELTER) has no input feeding it.
|
||
REQUIRE(bs.getActiveProductionBuildingCount() == 0);
|
||
|
||
bs.setRecipe(minerId, "mine_iron_ore");
|
||
runTicks(bs, belts, 1, tick);
|
||
REQUIRE(bs.getActiveProductionBuildingCount() == 1);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: activeProductionBuildingCount tracks production cycle state",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(id, "mine_iron_ore");
|
||
|
||
Tick tick = 0;
|
||
// Not yet operational while under construction.
|
||
REQUIRE(bs.getActiveProductionBuildingCount() == 0);
|
||
|
||
// Construction completes at tick 300; cycle 1 starts the same tick (completesAt=330).
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(10.0)) + 1, tick);
|
||
REQUIRE(bs.getActiveProductionBuildingCount() == 1);
|
||
|
||
// Run cycles 1 and 2 to completion (1s each); cycle 3 stalls once the
|
||
// output buffer (capacity 2) is full (REQ-MAT-OUTPUT-BUFFER).
|
||
runTicks(bs, belts, 2 * static_cast<int>(secondsToTicks(1.0)) + 1, tick);
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
REQUIRE(b->getOutputItemCount() == 2);
|
||
REQUIRE_FALSE(b->production.has_value());
|
||
REQUIRE(bs.getActiveProductionBuildingCount() == 0);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Belt pull → input buffer
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: smelter input buffer fills from adjacent west-flowing belt",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
// Fast belt so items are immediately available for peek/take.
|
||
BeltSystem belts(static_cast<double>(kTickRateHz));
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
// Smelter mask ["AA ","AA>"] → body (0,0),(1,0),(0,1),(1,1).
|
||
// Output port (2,1) East. Input port example: (2,0) West.
|
||
const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0).value();
|
||
// Smelters have no recipe selection (REQ-BLD-SMELTER); they auto-accept any
|
||
// ore/scrap that is an input to a smelter recipe.
|
||
|
||
// Complete construction (15s → tick 450+1 = 451 ticks).
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)) + 1, tick);
|
||
|
||
// Place west-flowing belt at (2,0): belt flows West, delivers to smelter.
|
||
belts.placeBelt(QPoint(2, 0), Rotation::West);
|
||
belts.tryPutItem(QPoint(2, 0), makeItem("iron_ore"));
|
||
belts.tick();
|
||
|
||
bs.tickBeltPull();
|
||
|
||
const Building* b = bs.findBuilding(sid);
|
||
REQUIRE(b != nullptr);
|
||
// The item was accepted; it may still be travelling inward on the input belt,
|
||
// so count buffered + in-transit (REQ-MAT-INPUT-INTAKE).
|
||
REQUIRE(b->pendingInputCount(ItemType{"iron_ore"}) >= 1);
|
||
}
|
||
|
||
// An accepted input item travels inward on its input belt before it becomes usable
|
||
// stock: it is reserved (counts against the cap) on entry and only enters the
|
||
// buffer on reaching the tile centre (REQ-MAT-INPUT-INTAKE).
|
||
TEST_CASE("BuildingSystem: accepted input travels inward before entering the buffer",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz)); // fast belt: 1 tile/tick
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0).value();
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)) + 1, tick);
|
||
|
||
belts.placeBelt(QPoint(2, 0), Rotation::West);
|
||
belts.tryPutItem(QPoint(2, 0), makeItem("iron_ore"));
|
||
belts.tick();
|
||
bs.tickBeltPull(); // accepts the item onto the input belt at progress 0.0
|
||
|
||
const Building* b = bs.findBuilding(sid);
|
||
REQUIRE(b != nullptr);
|
||
// Reserved but not yet consumable: nothing in the buffer, but it counts against
|
||
// the cap via pendingInputCount.
|
||
const std::map<ItemType, int>::const_iterator it0 =
|
||
b->inputBuffer.counts.find(ItemType{"iron_ore"});
|
||
REQUIRE((it0 == b->inputBuffer.counts.end() || it0->second == 0));
|
||
REQUIRE(b->pendingInputCount(ItemType{"iron_ore"}) == 1);
|
||
|
||
// One more pull tick advances the input belt to the centre; the item arrives.
|
||
bs.tickBeltPull();
|
||
REQUIRE(b->inputBuffer.counts.at(ItemType{"iron_ore"}) == 1);
|
||
REQUIRE(b->pendingInputCount(ItemType{"iron_ore"}) == 1);
|
||
}
|
||
|
||
// The acceptance test counts in-transit items, so buffered + reserved never exceeds
|
||
// the per-material cap; excess items stay on the belt (REQ-MAT-INPUT-INTAKE).
|
||
TEST_CASE("BuildingSystem: input reservation caps buffered plus in-transit at the cap",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz)); // fast belt
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::ReprocessingPlant,
|
||
QPoint(0, 0), Rotation::East, 0).value();
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(25.0)) + 1, tick);
|
||
|
||
// Feed scrap via an input belt without ever running production (only pull), so
|
||
// the buffer fills and stays full. Try to over-fill it well past the cap.
|
||
belts.placeBelt(QPoint(-1, 0), Rotation::East);
|
||
for (int i = 0; i < 20; ++i)
|
||
{
|
||
belts.tryPutItem(QPoint(-1, 0), makeItem("scrap"), Rotation::East);
|
||
belts.tick();
|
||
bs.tickBeltPull();
|
||
}
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
const int cap = b->inputBuffer.caps.at(ItemType{"scrap"});
|
||
REQUIRE(cap > 0);
|
||
// buffered + in-transit is capped; the plant never over-pulls.
|
||
REQUIRE(b->pendingInputCount(ItemType{"scrap"}) == cap);
|
||
// Excess scrap is left stuck on the feeding belt rather than silently dropped.
|
||
REQUIRE(belts.peekItem(eastPort(QPoint(-1, 0))).has_value());
|
||
}
|
||
|
||
// A smelter auto-selects the matching recipe for whatever it is fed, with no
|
||
// player recipe selection (REQ-BLD-SMELTER).
|
||
TEST_CASE("BuildingSystem: smelter auto-smelts ore without a recipe selection",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz));
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)) + 1, tick);
|
||
|
||
// Feed 2 iron_ore (the test-config iron_ingot recipe needs 2) via a
|
||
// west-flowing belt at input port (2,0).
|
||
belts.placeBelt(QPoint(2, 0), Rotation::West);
|
||
for (int i = 0; i < 2; ++i)
|
||
{
|
||
belts.tryPutItem(QPoint(2, 0), makeItem("iron_ore"));
|
||
belts.tick();
|
||
bs.tickBeltPull();
|
||
}
|
||
|
||
// iron_ingot recipe cycle is 2s; run to completion.
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(2.0)) + 2, tick);
|
||
|
||
const Building* b = bs.findBuilding(sid);
|
||
REQUIRE(b != nullptr);
|
||
bool hasIronIngot = false;
|
||
for (const Item& item : outputSideItems(*b))
|
||
{
|
||
if (item.type.id == "iron_ingot") { hasIronIngot = true; }
|
||
}
|
||
REQUIRE(hasIronIngot);
|
||
}
|
||
|
||
// With mixed inputs, the smelter runs whichever recipe is currently satisfiable
|
||
// and leaves an incomplete batch of another input waiting (see the union-of-
|
||
// inputs caps in initAutoBuffers).
|
||
TEST_CASE("BuildingSystem: smelter runs a satisfiable recipe while an incomplete batch waits",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz));
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)) + 1, tick);
|
||
|
||
// Feed 1 iron_ore (iron_ingot needs 2 — incomplete) then 2 copper_ore
|
||
// (copper_ingot needs 2 — satisfiable) via the west-flowing input belt.
|
||
belts.placeBelt(QPoint(2, 0), Rotation::West);
|
||
const char* fed[] = { "iron_ore", "copper_ore", "copper_ore" };
|
||
for (const char* id : fed)
|
||
{
|
||
belts.tryPutItem(QPoint(2, 0), makeItem(id));
|
||
belts.tick();
|
||
bs.tickBeltPull();
|
||
}
|
||
|
||
// copper_ingot cycle is 2.5s; run to completion.
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(2.5)) + 2, tick);
|
||
|
||
const Building* b = bs.findBuilding(sid);
|
||
REQUIRE(b != nullptr);
|
||
|
||
// Copper was smelted; the lone iron_ore still waits for a second unit.
|
||
bool hasCopperIngot = false;
|
||
for (const Item& item : outputSideItems(*b))
|
||
{
|
||
if (item.type.id == "copper_ingot") { hasCopperIngot = true; }
|
||
}
|
||
REQUIRE(hasCopperIngot);
|
||
|
||
const std::map<ItemType, int>::const_iterator ironIt =
|
||
b->inputBuffer.counts.find(ItemType{"iron_ore"});
|
||
REQUIRE(ironIt != b->inputBuffer.counts.end());
|
||
REQUIRE(ironIt->second == 1);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Belt push → belt tile
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: miner output buffer drains onto adjacent belt", "[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz));
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(id, "mine_iron_ore");
|
||
|
||
// Belt at the miner's output port tile (1,1) flowing East.
|
||
belts.placeBelt(QPoint(1, 1), Rotation::East);
|
||
|
||
Tick tick = 0;
|
||
// Construction (10s) + 1 production cycle (1s) + 1 extra tick.
|
||
runTicks(bs, belts,
|
||
static_cast<int>(secondsToTicks(10.0)) + static_cast<int>(secondsToTicks(1.0)) + 1,
|
||
tick);
|
||
|
||
// Item should have been pushed onto the belt this tick or a subsequent one.
|
||
// Run one more tick to ensure tickBeltPush fires after the deposit tick.
|
||
runTicks(bs, belts, 1, tick);
|
||
|
||
const std::optional<Item> item = belts.tryTakeItem(eastPort(QPoint(1, 1)));
|
||
REQUIRE(item.has_value());
|
||
REQUIRE(item->type.id == "iron_ore");
|
||
}
|
||
|
||
// Two directly adjacent buildings whose ports meet transfer items with no belt in
|
||
// between: a miner's iron_ore output feeds straight into a smelter, which smelts it
|
||
// (REQ-MAT-DIRECT-COUPLE).
|
||
TEST_CASE("BuildingSystem: output port couples directly into an adjacent input port",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
// Miner at (0,0): body (0,0),(1,0),(0,1); output port tile (1,1) flowing East.
|
||
const BuildingId minerId = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(minerId, "mine_iron_ore");
|
||
// Smelter anchored at (1,1): body (1,1),(2,1),(1,2),(2,2). Its body cell (1,1) is
|
||
// the miner's output-port tile, and its west input edge there faces East, so the
|
||
// two ports meet — no belt placed anywhere.
|
||
const BuildingId smelterId = bs.place(BuildingType::Smelter, QPoint(1, 1), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
// Smelter build (15s) + margin for coupling and a smelt cycle.
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(30.0)), tick);
|
||
|
||
const Building* smelter = bs.findBuilding(smelterId);
|
||
REQUIRE(smelter != nullptr);
|
||
// iron_ore reached the smelter over the direct coupling and was smelted.
|
||
bool hasIronIngot = false;
|
||
for (const Item& produced : outputSideItems(*smelter))
|
||
{
|
||
if (produced.type.id == "iron_ingot") { hasIronIngot = true; }
|
||
}
|
||
REQUIRE(hasIronIngot);
|
||
}
|
||
|
||
// A producer coupled to a building that cannot accept its item delivers nothing; the
|
||
// item stays stuck at the producer's output port (REQ-MAT-DIRECT-COUPLE acceptance).
|
||
TEST_CASE("BuildingSystem: direct coupling to a non-consumer leaves the item stuck",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
// Producing miner at (0,0), output port (1,1) East.
|
||
const BuildingId minerId = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(minerId, "mine_iron_ore");
|
||
// A second, idle miner anchored at (1,1) occupies the output-port tile but takes
|
||
// no inputs, so it cannot accept the iron_ore.
|
||
const BuildingId sinkId = bs.place(BuildingType::Miner, QPoint(1, 1), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
// Both miners build sequentially (10s each), then the producer runs and jams.
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(25.0)), tick);
|
||
|
||
const Building* miner = bs.findBuilding(minerId);
|
||
const Building* sink = bs.findBuilding(sinkId);
|
||
REQUIRE(miner != nullptr);
|
||
REQUIRE(sink != nullptr);
|
||
// Nothing was delivered, and the producer's output side has backed up to its cap.
|
||
REQUIRE(sink->pendingInputCount(ItemType{"iron_ore"}) == 0);
|
||
REQUIRE(miner->getOutputItemCount() == miner->outputBuffer.capacity);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// setRecipe clears buffers
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: setRecipe clears output buffer and active production",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz));
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
bs.setRecipe(id, "mine_iron_ore");
|
||
|
||
Tick tick = 0;
|
||
// Run until first item is in output buffer.
|
||
runTicks(bs, belts,
|
||
static_cast<int>(secondsToTicks(10.0)) + static_cast<int>(secondsToTicks(1.0)) + 1,
|
||
tick);
|
||
|
||
{
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
REQUIRE(b->getOutputItemCount() > 0);
|
||
}
|
||
|
||
bs.setRecipe(id, "mine_copper_ore");
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
// Clearing the output buffer on a recipe change also discards emerging items
|
||
// (REQ-MAT-OUTPUT-EMERGE).
|
||
REQUIRE(b->getOutputItemCount() == 0);
|
||
REQUIRE_FALSE(b->production.has_value());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Reprocessing plant — output buffer capacity (REQ-MAT-OUTPUT-BUFFER-REPROCESSING)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: reprocessing plant output buffer capacity equals max output per roll",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::ReprocessingPlant,
|
||
QPoint(0, 0), Rotation::East, 0).value();
|
||
// Reprocessing plants have no recipe selection (REQ-BLD-REPROCESSING); the
|
||
// single reprocessing recipe is applied automatically on completion.
|
||
|
||
// Complete construction (25s).
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(25.0)) + 1, tick);
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
// reprocessing_cycle outputs: 2 iron_ingot (60%), 1 circuit_board (30%),
|
||
// 1 advanced_alloy (10%). Max per roll = 2. Capacity = 2 (1× max).
|
||
REQUIRE(b->outputBuffer.capacity == 2);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: reprocessing plant produces one cycle output then stalls",
|
||
"[building]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(static_cast<double>(kTickRateHz));
|
||
int stock = 0;
|
||
// Seed chosen so first roll produces 2-item output (iron_ingot), filling buffer.
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::ReprocessingPlant,
|
||
QPoint(0, 0), Rotation::East, 0).value();
|
||
// Reprocessing plants have no recipe selection (REQ-BLD-REPROCESSING); the
|
||
// single reprocessing recipe is applied automatically on completion.
|
||
|
||
// Complete construction (25s).
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(25.0)) + 1, tick);
|
||
|
||
// Feed 5 scrap into the building via a belt at an input port.
|
||
// Reprocessing plant body (East rotation) = 3×3 at (0,0).
|
||
// Valid input port: tile (-1,0) flowing East.
|
||
belts.placeBelt(QPoint(-1, 0), Rotation::East);
|
||
for (int i = 0; i < 5; ++i)
|
||
{
|
||
belts.tryPutItem(QPoint(-1, 0), makeItem("scrap"), Rotation::East);
|
||
belts.tick();
|
||
bs.tickBeltPull();
|
||
}
|
||
|
||
// Verify all five scrap were accepted; some may still be travelling inward on
|
||
// the input belt (REQ-MAT-INPUT-INTAKE), so count buffered + in-transit.
|
||
{
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
REQUIRE(b->pendingInputCount(ItemType{"scrap"}) == 5);
|
||
}
|
||
|
||
// Run production cycle (3s = 90 ticks + 1 for the completion tick).
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(3.0)) + 1, tick);
|
||
|
||
const Building* b = bs.findBuilding(id);
|
||
REQUIRE(b != nullptr);
|
||
// Cycle should have completed and output deposited.
|
||
REQUIRE_FALSE(b->outputBuffer.items.empty());
|
||
// No new production: inputs were consumed and not replenished.
|
||
REQUIRE_FALSE(b->production.has_value());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// findRotateInPlaceTarget
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget returns nullopt when tile is empty",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
REQUIRE_FALSE(
|
||
bs.findRotateInPlaceTarget(BuildingType::Belt, QPoint(0, 0), Rotation::East).has_value());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget returns the site id for a queued belt (same type, different rotation)",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
const std::optional<BuildingId> result =
|
||
bs.findRotateInPlaceTarget(BuildingType::Belt, QPoint(0, 0), Rotation::North);
|
||
REQUIRE(result.has_value());
|
||
REQUIRE(*result == id);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget returns the building id for a completed operational belt",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(1.0)) + 1, tick);
|
||
REQUIRE(bs.getAllSites().empty());
|
||
|
||
const std::optional<BuildingId> result =
|
||
bs.findRotateInPlaceTarget(BuildingType::Belt, QPoint(0, 0), Rotation::South);
|
||
REQUIRE(result.has_value());
|
||
REQUIRE(*result == id);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget returns nullopt when building type differs",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0);
|
||
|
||
// Querying with Splitter at the same tile — type mismatch → nullopt.
|
||
REQUIRE_FALSE(
|
||
bs.findRotateInPlaceTarget(BuildingType::Splitter, QPoint(0, 0), Rotation::East).has_value());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget never rotates a tunnel in place",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
// Even with a coincident same-type tunnel under the ghost, rotate-in-place is
|
||
// never offered for tunnels (REQ-BLD-ROTATE-IN-PLACE exception).
|
||
bs.place(BuildingType::TunnelEntry, QPoint(-1, 0), Rotation::East, 0);
|
||
bs.place(BuildingType::TunnelExit, QPoint(-2, 0), Rotation::East, 0);
|
||
|
||
REQUIRE_FALSE(
|
||
bs.findRotateInPlaceTarget(BuildingType::TunnelEntry, QPoint(-1, 0), Rotation::North).has_value());
|
||
REQUIRE_FALSE(
|
||
bs.findRotateInPlaceTarget(BuildingType::TunnelExit, QPoint(-2, 0), Rotation::North).has_value());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget returns nullopt when footprints only partially overlap",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
// Smelter at (0,0) occupies body tiles (0,0),(1,0),(0,1),(1,1).
|
||
bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0);
|
||
|
||
// Ghost anchored at (1,0) would cover (1,0),(2,0),(1,1),(2,1):
|
||
// only (1,0) and (1,1) are occupied — not a full coincidence.
|
||
REQUIRE_FALSE(
|
||
bs.findRotateInPlaceTarget(BuildingType::Smelter, QPoint(1, 0), Rotation::East).has_value());
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: findRotateInPlaceTarget works for a symmetric multi-tile building with rotated ghost",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
// Smelter is a fully filled 2×2 footprint — rotating the ghost produces the
|
||
// same four body tiles, so findRotateInPlaceTarget must still return the id.
|
||
const BuildingId id = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
const std::optional<BuildingId> result =
|
||
bs.findRotateInPlaceTarget(BuildingType::Smelter, QPoint(0, 0), Rotation::North);
|
||
REQUIRE(result.has_value());
|
||
REQUIRE(*result == id);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// rotateInPlace
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: rotateInPlace updates the rotation field of a construction site",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
REQUIRE(bs.findSite(id)->rotation == Rotation::East);
|
||
|
||
bs.rotateInPlace(id, Rotation::North);
|
||
|
||
REQUIRE(bs.findSite(id)->rotation == Rotation::North);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: rotateInPlace preserves the construction progress of a queued site",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
const Tick completesAt = bs.findSite(id)->completesAt;
|
||
REQUIRE(completesAt > 0);
|
||
|
||
bs.rotateInPlace(id, Rotation::South);
|
||
|
||
REQUIRE(bs.findSite(id)->completesAt == completesAt);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: rotateInPlace updates rotation and output port direction on an operational building",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(1.0)) + 1, tick);
|
||
REQUIRE(bs.findBuilding(id) != nullptr);
|
||
|
||
const Building& before = *bs.findBuilding(id);
|
||
REQUIRE(before.outputPorts[0].direction == Rotation::East);
|
||
|
||
bs.rotateInPlace(id, Rotation::North);
|
||
|
||
const Building& after = *bs.findBuilding(id);
|
||
REQUIRE(after.rotation == Rotation::North);
|
||
REQUIRE(after.outputPorts[0].direction == Rotation::North);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: rotateInPlace re-registers a belt tile with BeltSystem so it still accepts items",
|
||
"[building][rotate-in-place]")
|
||
{
|
||
const GameConfig cfg = loadConfig();
|
||
BeltSystem belts(cfg.world.beltSpeed_tps);
|
||
int stock = 0;
|
||
std::mt19937 rng(0);
|
||
BuildingId nextBuildingId = 1;
|
||
BuildingSystem bs(cfg, belts,
|
||
[&nextBuildingId]() { return nextBuildingId++; },
|
||
[&stock](int n) { stock += n; },
|
||
[](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
|
||
[](const std::string&) -> bool { return true; },
|
||
rng);
|
||
|
||
const BuildingId id = bs.place(BuildingType::Belt, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
Tick tick = 0;
|
||
runTicks(bs, belts, static_cast<int>(secondsToTicks(1.0)) + 1, tick);
|
||
|
||
bs.rotateInPlace(id, Rotation::North);
|
||
|
||
// Belt tile must still be registered after rotation — items can be placed on it.
|
||
REQUIRE(belts.tryPutItem(QPoint(0, 0), makeItem("iron_ore")));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: rotateInPlace preserves the output filters of a splitter "
|
||
"(REQ-BLD-SPLITTER)", "[building][rotate-in-place]")
|
||
{
|
||
PlacementFixture f;
|
||
|
||
const QPoint tile(5, 5);
|
||
const BuildingId id = f.bs.place(BuildingType::Splitter, tile, Rotation::East, 0).value();
|
||
|
||
// Run until construction completes, so the splitter is registered with BeltSystem.
|
||
Tick tick = 0;
|
||
while (f.bs.getAllBuildings().empty() && tick < 100000)
|
||
{
|
||
runTicks(f.bs, f.belts, 1, tick);
|
||
}
|
||
REQUIRE(f.bs.getAllBuildings().size() == 1);
|
||
|
||
const std::vector<ItemType> filterA{ ItemType{"iron_ore"} };
|
||
const std::vector<ItemType> filterB{ ItemType{"copper_ore"} };
|
||
f.belts.setSplitterFilters(tile, filterA, filterB);
|
||
|
||
f.bs.rotateInPlace(id, Rotation::North);
|
||
|
||
// The tile is re-registered with BeltSystem carrying the filters it had before
|
||
// the rotation — rotating must not reset a configured splitter to "accept all".
|
||
const std::optional<BeltSystem::SplitterInfo> info = f.belts.getSplitterInfo(tile);
|
||
REQUIRE(info.has_value());
|
||
REQUIRE(info->filterA == filterA);
|
||
REQUIRE(info->filterB == filterB);
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: splitter filters configured on a construction site carry over "
|
||
"to the built splitter (REQ-BLD-SITE-CONFIG)", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
|
||
const QPoint tile(5, 5);
|
||
const BuildingId id = f.bs.place(BuildingType::Splitter, tile, Rotation::East, 0).value();
|
||
REQUIRE(id != kInvalidBuildingId);
|
||
REQUIRE(f.bs.findSite(id) != nullptr);
|
||
|
||
// Configure an output filter on the still-queued splitter site.
|
||
const std::vector<ItemType> filterA{ ItemType{"iron_ore"} };
|
||
const std::vector<ItemType> filterB{};
|
||
f.bs.setSiteSplitterFilters(id, filterA, filterB);
|
||
|
||
// The site reports its two output directions and the stored filters before
|
||
// it is built; it is not yet registered with BeltSystem.
|
||
const std::optional<BeltSystem::SplitterInfo> siteInfo = f.bs.getSiteSplitterInfo(id);
|
||
REQUIRE(siteInfo.has_value());
|
||
REQUIRE(siteInfo->filterA == filterA);
|
||
REQUIRE(siteInfo->filterB.empty());
|
||
REQUIRE_FALSE(f.belts.getSplitterInfo(tile).has_value());
|
||
|
||
// Run until construction completes.
|
||
Tick tick = 0;
|
||
while (f.bs.getAllBuildings().empty() && tick < 100000)
|
||
{
|
||
runTicks(f.bs, f.belts, 1, tick);
|
||
}
|
||
REQUIRE(f.bs.getAllBuildings().size() == 1);
|
||
REQUIRE(f.bs.getAllBuildings()[0].type == BuildingType::Splitter);
|
||
|
||
// The built splitter is registered with BeltSystem carrying the filters.
|
||
const std::optional<BeltSystem::SplitterInfo> builtInfo = f.belts.getSplitterInfo(tile);
|
||
REQUIRE(builtInfo.has_value());
|
||
REQUIRE(builtInfo->filterA == filterA);
|
||
REQUIRE(builtInfo->filterB.empty());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Production status classifier (REQ-UI-STATUS-LIGHT)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
TEST_CASE("BuildingSystem: getProductionStatus classifies production state", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
|
||
// Pick representative config ids so the test survives content edits.
|
||
std::string minerRecipeId;
|
||
for (const RecipeDef& r : f.cfg.recipes.recipes)
|
||
{
|
||
if (r.building == BuildingType::Miner) { minerRecipeId = r.id; break; }
|
||
}
|
||
REQUIRE_FALSE(minerRecipeId.empty());
|
||
|
||
const RecipeDef* assemblerRecipe = nullptr;
|
||
for (const RecipeDef& r : f.cfg.recipes.recipes)
|
||
{
|
||
if (r.building == BuildingType::Assembler && !r.inputs.empty())
|
||
{
|
||
assemblerRecipe = &r;
|
||
break;
|
||
}
|
||
}
|
||
REQUIRE(assemblerRecipe != nullptr);
|
||
|
||
std::string shipId;
|
||
for (const ShipDef& s : f.cfg.ships.ships)
|
||
{
|
||
if (!s.schematic.materials.empty()) { shipId = s.id; break; }
|
||
}
|
||
REQUIRE_FALSE(shipId.empty());
|
||
|
||
const auto statusOf = [&f](const Building& b) { return f.bs.getProductionStatus(b); };
|
||
|
||
SECTION("non-production buildings show no status light")
|
||
{
|
||
Building belt; belt.type = BuildingType::Belt;
|
||
Building hq; hq.type = BuildingType::Hq;
|
||
REQUIRE_FALSE(statusOf(belt).has_value());
|
||
REQUIRE_FALSE(statusOf(hq).has_value());
|
||
}
|
||
|
||
SECTION("Miner: unconfigured, producing, output-blocked")
|
||
{
|
||
Building miner; miner.type = BuildingType::Miner;
|
||
REQUIRE(statusOf(miner) == ProductionStatus::Unconfigured); // no recipe -> grey
|
||
|
||
miner.recipeId = minerRecipeId;
|
||
miner.production = Production{};
|
||
REQUIRE(statusOf(miner) == ProductionStatus::Producing); // active cycle -> green
|
||
|
||
// A miner has no inputs, so its only idle reason is a full output buffer.
|
||
miner.production = std::nullopt;
|
||
miner.outputBuffer.capacity = 2;
|
||
miner.outputBuffer.items = { makeItem("iron_ore"), makeItem("iron_ore") };
|
||
REQUIRE(statusOf(miner) == ProductionStatus::Blocked); // -> yellow
|
||
}
|
||
|
||
SECTION("Assembler: starved vs blocked, input-missing takes precedence")
|
||
{
|
||
Building assembler; assembler.type = BuildingType::Assembler;
|
||
assembler.recipeId = assemblerRecipe->id;
|
||
|
||
// Idle with inputs missing -> red.
|
||
REQUIRE(statusOf(assembler) == ProductionStatus::Starved);
|
||
|
||
// Inputs present but idle -> the only remaining reason is a full output
|
||
// buffer -> yellow.
|
||
for (const RecipeIngredient& ing : assemblerRecipe->inputs)
|
||
{
|
||
assembler.inputBuffer.counts[ItemType{ing.item}] = ing.amount;
|
||
}
|
||
REQUIRE(statusOf(assembler) == ProductionStatus::Blocked);
|
||
|
||
// Inputs missing AND output full -> red wins over yellow.
|
||
assembler.inputBuffer.counts.clear();
|
||
assembler.outputBuffer.capacity = 2;
|
||
assembler.outputBuffer.items = { makeItem("x"), makeItem("x") };
|
||
REQUIRE(statusOf(assembler) == ProductionStatus::Starved);
|
||
}
|
||
|
||
SECTION("Smelter (auto-recipe) is never grey")
|
||
{
|
||
Building smelter; smelter.type = BuildingType::Smelter;
|
||
// No player-selectable recipe and empty inputs -> red, not grey.
|
||
REQUIRE(statusOf(smelter) == ProductionStatus::Starved);
|
||
}
|
||
|
||
SECTION("Shipyard: unconfigured, then starved without materials, then producing")
|
||
{
|
||
Building yard; yard.type = BuildingType::Shipyard;
|
||
REQUIRE(statusOf(yard) == ProductionStatus::Unconfigured); // no schematic -> grey
|
||
|
||
yard.recipeId = shipId;
|
||
REQUIRE(statusOf(yard) == ProductionStatus::Starved); // no materials -> red
|
||
|
||
yard.production = Production{};
|
||
REQUIRE(statusOf(yard) == ProductionStatus::Producing); // active cycle -> green
|
||
}
|
||
|
||
SECTION("Salvage Bay: red when empty, green when holding scrap")
|
||
{
|
||
Building bay; bay.type = BuildingType::SalvageBay;
|
||
bay.outputBuffer.capacity = 20;
|
||
REQUIRE(statusOf(bay) == ProductionStatus::Starved); // empty -> red
|
||
|
||
bay.outputBuffer.items = { makeItem("scrap") };
|
||
REQUIRE(statusOf(bay) == ProductionStatus::Producing); // holding scrap -> green
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// getInputPorts (REQ-BLD-BELT-DRAG snapping, REQ-MAT-INPUT-PORTS)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
namespace
|
||
{
|
||
QPoint directionDelta(Rotation direction)
|
||
{
|
||
switch (direction)
|
||
{
|
||
case Rotation::North: return QPoint(0, -1);
|
||
case Rotation::East: return QPoint(1, 0);
|
||
case Rotation::South: return QPoint(0, 1);
|
||
case Rotation::West: return QPoint(-1, 0);
|
||
}
|
||
return QPoint(0, 0);
|
||
}
|
||
|
||
bool hasInputPort(const std::vector<Port>& ports, QPoint tile, Rotation direction)
|
||
{
|
||
for (const Port& port : ports)
|
||
{
|
||
if (port.tile == tile && port.direction == direction) { return true; }
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// Advances the sim until the given site becomes an operational building, or a
|
||
// safety cap is reached.
|
||
void buildToCompletion(BuildingSystem& bs, BeltSystem& belts, BuildingId id,
|
||
Tick& tick)
|
||
{
|
||
for (int i = 0; i < 20000 && bs.findBuilding(id) == nullptr; ++i)
|
||
{
|
||
runTicks(bs, belts, 1, tick);
|
||
}
|
||
}
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: getInputPorts on a miner site lists every input edge", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
// Miner mask ["AA","A>"] East → body (0,0),(1,0),(0,1); output tile (1,1) East.
|
||
const BuildingId id = f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
const std::vector<Port> ports = f.bs.getInputPorts(id);
|
||
|
||
// Every perimeter edge except the output-port edge at (1,1), each pointing in.
|
||
REQUIRE(ports.size() == 6);
|
||
REQUIRE(hasInputPort(ports, QPoint(-1, 0), Rotation::East));
|
||
REQUIRE(hasInputPort(ports, QPoint(0, -1), Rotation::South));
|
||
REQUIRE(hasInputPort(ports, QPoint(2, 0), Rotation::West));
|
||
REQUIRE(hasInputPort(ports, QPoint(1, -1), Rotation::South));
|
||
REQUIRE(hasInputPort(ports, QPoint(-1, 1), Rotation::East));
|
||
REQUIRE(hasInputPort(ports, QPoint(0, 2), Rotation::North));
|
||
|
||
// The output-port tile is never an input port.
|
||
REQUIRE_FALSE(hasInputPort(ports, QPoint(1, 1), Rotation::North));
|
||
REQUIRE_FALSE(hasInputPort(ports, QPoint(1, 1), Rotation::West));
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: getInputPorts matches between a site and the built building",
|
||
"[building]")
|
||
{
|
||
PlacementFixture f;
|
||
Tick tick = 0;
|
||
const BuildingId id = f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::East, 0).value();
|
||
|
||
const std::vector<Port> sitePorts = f.bs.getInputPorts(id);
|
||
buildToCompletion(f.bs, f.belts, id, tick);
|
||
REQUIRE(f.bs.findBuilding(id) != nullptr);
|
||
const std::vector<Port> builtPorts = f.bs.getInputPorts(id);
|
||
|
||
// The operational path (stored inputPorts) agrees with the site path (mask-derived).
|
||
REQUIRE(builtPorts.size() == sitePorts.size());
|
||
for (const Port& port : sitePorts)
|
||
{
|
||
REQUIRE(hasInputPort(builtPorts, port.tile, port.direction));
|
||
}
|
||
}
|
||
|
||
TEST_CASE("BuildingSystem: getInputPorts invariants hold for a rotated site", "[building]")
|
||
{
|
||
PlacementFixture f;
|
||
const BuildingId id = f.bs.place(BuildingType::Miner, QPoint(0, 0), Rotation::South, 0).value();
|
||
const ConstructionSite* site = f.bs.findSite(id);
|
||
REQUIRE(site != nullptr);
|
||
|
||
std::set<std::pair<int, int>> bodySet;
|
||
for (const QPoint& cell : site->bodyCells) { bodySet.insert({cell.x(), cell.y()}); }
|
||
|
||
const std::vector<Port> ports = f.bs.getInputPorts(id);
|
||
REQUIRE_FALSE(ports.empty());
|
||
for (const Port& port : ports)
|
||
{
|
||
// Each port tile is outside the footprint...
|
||
REQUIRE(bodySet.count({port.tile.x(), port.tile.y()}) == 0);
|
||
// ...and its direction points into an adjacent body cell.
|
||
const QPoint into = port.tile + directionDelta(port.direction);
|
||
REQUIRE(bodySet.count({into.x(), into.y()}) == 1);
|
||
}
|
||
}
|