Malte Langkabel
9c275e283c
Implements REQ-MAT-OUTPUT-GROUP. A recipe had two shapes -- outputs produced together, or outputs of which exactly one happened -- and every rule over them was written twice, selected by `building == ReprocessingPlant`: sizing a buffer, deciding whether a cycle fits, resolving what a cycle makes, costing an item. RecipeDef now holds output groups, each a weight and a list of items, and a cycle yields exactly one group. One group is the ordinary recipe, so the old two cases are the same shape with one and with several, and all four rules collapse to one expression apiece with no building-type test left. rollReprocessingOutput becomes rollOutputGroup, where a single group returns without drawing or testing eligibility. That early-out is load-bearing twice over. Drawing there would consume entropy for every ordinary recipe and shift every later random outcome; and eligibility must not apply either, since implicit unlocking is demand-derived, so an ordinary recipe's output can be producible while nothing yet calls for it -- testing it would stop the building producing rather than gate a drop. Past the early-out a group is eligible only when all of its items are unlocked, being produced whole. Threat follows the recipe's shape rather than the building, and the per-unit value now divides by the group's amount as well as its odds. That moves no number today: every item resolved through this path has amount 1, which is why the threat expectations are untouched. Config keeps `outputs = [...]` as the single-group form, so only the two reprocessing recipes change shape. The recipe summary gains "/" between groups and keeps "+" within one, which also fixes the plant reading as though a cycle produced all of its items at once. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ne3mejABZoLWKLh8fgpM3x
244 lines
13 KiB
C++
244 lines
13 KiB
C++
#pragma once
|
|
|
|
#include <deque>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <optional>
|
|
#include <random>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <QPoint>
|
|
#include <QPointF>
|
|
#include <QVector2D>
|
|
|
|
#include "BeltSystem.h"
|
|
#include "Building.h"
|
|
#include "FactoryState.h"
|
|
#include "BuildingBuffers.h"
|
|
#include "DeconstructionSystem.h"
|
|
#include "PlacementRules.h"
|
|
#include "ProductionRules.h"
|
|
#include "BuildingType.h"
|
|
#include "BuildingId.h"
|
|
#include "GameConfig.h"
|
|
#include "Rotation.h"
|
|
#include "ModulesConfig.h"
|
|
#include "ShipLayout.h"
|
|
#include "ShipsConfig.h"
|
|
#include "Tick.h"
|
|
|
|
class Hasher;
|
|
|
|
// Manages building placement, construction queuing, and the per-tick
|
|
// production loop (belt→building pull, production, building→belt push).
|
|
// All types including Belt and Splitter are stored as Building instances;
|
|
// BeltSystem owns the per-tile simulation data (item slots, flow).
|
|
class BuildingSystem
|
|
{
|
|
public:
|
|
BuildingSystem(const GameConfig& config,
|
|
BeltSystem& belts,
|
|
std::function<BuildingId()> allocateBuildingId,
|
|
std::function<void(int)> addBuildingBlocks,
|
|
std::function<void(const std::string&, QVector2D,
|
|
const std::optional<ShipLayoutConfig>&)> spawnShip,
|
|
std::function<bool(const std::string&)> isItemUnlocked,
|
|
std::mt19937& rng);
|
|
|
|
// -- Placement / deconstruct ------------------------------------------------
|
|
// Returns the new entity id, or nullopt if the placement falls outside the
|
|
// world bounds (vertical extent and asteroid left edge). Belt and Splitter
|
|
// register with BeltSystem directly; other types enter the construction
|
|
// queue. Terrain type (A vs S) is NOT checked here so that tests can stage
|
|
// arbitrary layouts; the player-facing entry point
|
|
// (Simulation::tryPlaceBuilding) enforces the full rule via isPlacementValid.
|
|
std::optional<BuildingId> place(FactoryState& state, BuildingType type, QPoint anchor, Rotation rotation,
|
|
Tick currentTick);
|
|
|
|
// Returns true if the placement satisfies REQ-BLD-PLACE-VALID terrain and
|
|
// world-bounds rules: every ship-dock (S) cell sits in space (x >= 0), every
|
|
// other body (A) cell sits on the asteroid (x < 0 and x >= the left edge),
|
|
// and every cell has 0 <= y < world.height_tiles. There is no right-side
|
|
// bound — space extends rightward. Tile occupancy is NOT checked here.
|
|
|
|
// Sets the current buildable asteroid width in tiles. Grows the left
|
|
// placement bound as the player unlocks asteroid expansions (REQ-EXP-UNLOCK).
|
|
// Defaults to world.regions.asteroid_width_tiles at construction.
|
|
void setAsteroidWidth_tiles(FactoryState& state, int widthTiles) const
|
|
{ state.asteroidWidth_tiles = widthTiles; }
|
|
|
|
// Mark a building or construction site for demolition (REQ-BLD-DECONSTRUCT).
|
|
// A construction site is removed instantly and the full cost is returned.
|
|
// A fully-built building is instead appended to the deconstruction queue
|
|
// (REQ-BLD-DECON-QUEUE) and stops operating at once; its (partial) refund is
|
|
// credited later, on completion in tickDeconstruction, so this returns 0 for
|
|
// it. Returns 0 for unknown ids and for a building already queued.
|
|
int deconstruct(FactoryState& state, BuildingId id, Tick currentTick);
|
|
|
|
// Take a building back out of the deconstruction queue before it is removed
|
|
// (REQ-BLD-DECON-QUEUE). Clears its queued flag and resumes operation
|
|
// (re-registering belt/tunnel/splitter tiles); discards deconstruction
|
|
// progress and credits no refund. No-op if the id is not queued.
|
|
void cancelDeconstruction(FactoryState& state, BuildingId id);
|
|
|
|
// True if the building is currently in the deconstruction queue.
|
|
|
|
// Set the recipe (or schematic id for shipyard) on a building or queued
|
|
// construction site. Clears both buffers on an operational building.
|
|
void setRecipe(FactoryState& state, BuildingId id, const std::string& recipeId);
|
|
|
|
// Set the module layout for a shipyard. Cancels in-progress production
|
|
// (materials discarded) and reinitializes input buffers (REQ-BLD-SHIPYARD).
|
|
void setShipLayout(FactoryState& state, BuildingId id, const ShipLayoutConfig& layout);
|
|
|
|
// Splitter filter configuration for a queued/under-construction Splitter
|
|
// site (REQ-BLD-SITE-CONFIG). Operational splitters are configured through
|
|
// BeltSystem by tile; these mirror that for sites, which are not yet
|
|
// registered with BeltSystem. getSiteSplitterInfo returns the site's two
|
|
// output directions (derived from its surface mask) and stored filters, or
|
|
// nullopt if the id is not a Splitter site. The stored filters are applied
|
|
// to BeltSystem when the splitter finishes building (tickConstruction).
|
|
void setSiteSplitterFilters(FactoryState& state, BuildingId id,
|
|
const std::vector<ItemType>& filterA,
|
|
const std::vector<ItemType>& filterB);
|
|
|
|
// -- Tick hooks (called from Simulation::tick in the documented order) ---
|
|
// Advances the deconstruction queue (REQ-BLD-DECON-QUEUE): one building at a
|
|
// time, in parallel with tickConstruction. Removes the front building and
|
|
// credits its refund when its timer elapses.
|
|
void tickBeltPull(FactoryState& state);
|
|
void tickProduction(FactoryState& state, Tick currentTick);
|
|
void tickShipyardProduction(FactoryState& state, Tick currentTick);
|
|
// Advances each building's virtual output belts, hands finished items off onto
|
|
// the adjacent real belt, and feeds new buffered items into them
|
|
// (REQ-MAT-OUTPUT-EMERGE).
|
|
void tickOutputBelts(FactoryState& state);
|
|
|
|
// -- Queries -------------------------------------------------------------
|
|
|
|
|
|
// REQ-UI-DEBUG-OVERLAY "Max Factory Production": count of completed
|
|
// (operational) Miner/Smelter/Assembler/ReprocessingPlant/Shipyard buildings.
|
|
|
|
// REQ-UI-DEBUG-OVERLAY "Current Factory Production": subset of the above
|
|
// that currently has an active production cycle.
|
|
|
|
// Production state for the UI status light (REQ-UI-STATUS-LIGHT). Returns
|
|
// nullopt for building types that show no light (belts, splitters, tunnels,
|
|
// HQ, defence stations). The Salvage Bay is a two-state special case:
|
|
// Producing while its output buffer holds scrap, Starved when empty.
|
|
|
|
// Visits every item currently emerging from a building output port on its
|
|
// virtual output belt (REQ-MAT-OUTPUT-EMERGE), passing the item type and its
|
|
// world-space centre (in tile units). Least-progressed first (drawn bottom) so
|
|
// callers can paint in visit order (REQ-GW-TILE-SIZE ordering).
|
|
void forEachEmergingItem(const FactoryState& state,
|
|
const std::function<void(const ItemType&, QPointF)>& visit) const;
|
|
|
|
// Visits every item currently travelling inward on a building input port's
|
|
// virtual input belt (REQ-MAT-INPUT-INTAKE), passing the item type and its
|
|
// world-space centre (in tile units). Least-progressed first (drawn bottom).
|
|
void forEachIncomingItem(const FactoryState& state,
|
|
const std::function<void(const ItemType&, QPointF)>& visit) const;
|
|
|
|
// Rotate an existing building or construction site to newRotation in place.
|
|
// For belt-type operational buildings, re-registers with BeltSystem (items
|
|
// currently on the tile are discarded by BeltSystem::removeTile).
|
|
void rotateInPlace(FactoryState& state, BuildingId id, Rotation newRotation);
|
|
|
|
|
|
// Input-capable adjacent tiles for a building or construction site
|
|
// (REQ-BLD-BELT-DRAG, REQ-MAT-INPUT-PORTS): each returned Port.tile is the
|
|
// outside adjacent tile and Port.direction is the belt facing that points into
|
|
// the target. Output-port edges are excluded. Empty for an unknown id.
|
|
|
|
// Register / unregister tile occupancy for ECS station entities.
|
|
void registerTileOccupancy(FactoryState& state, const std::vector<QPoint>& cells, BuildingId ownerPlaceholder);
|
|
void unregisterTileOccupancy(FactoryState& state, const std::vector<QPoint>& cells);
|
|
|
|
// Place one "scrap" item into a SalvageBay's output buffer.
|
|
// Returns false if bay not found, wrong type, or output buffer is full.
|
|
|
|
// Bypass the construction queue and create a fully-operational Building
|
|
// immediately. Used for pre-placed structures (HQ, defence stations).
|
|
// surfaceMask comes from the relevant config struct.
|
|
BuildingId placeImmediate(FactoryState& state, BuildingType type,
|
|
const std::vector<std::string>& surfaceMask,
|
|
QPoint anchor, Rotation rotation);
|
|
|
|
// Remove an operational building by id without refund (used for deaths).
|
|
// Returns true if found and removed.
|
|
bool removeBuilding(FactoryState& state, BuildingId id);
|
|
|
|
// Mutable iteration over all operational buildings.
|
|
void forEachBuilding(FactoryState& state, std::function<void(Building&)> fn);
|
|
|
|
// -- Determinism ---------------------------------------------------------
|
|
// Folds all building, construction-site, and tile-occupancy state into the
|
|
// hasher in deterministic order (see docs/replay_design.md).
|
|
void appendChecksum(const FactoryState& state, Hasher& hasher) const;
|
|
|
|
private:
|
|
// Starts the front deconstruction-queue entry's timer if not yet started
|
|
// (mirrors how tickConstruction starts a queued construction site).
|
|
|
|
// Registers a belt/splitter/tunnel building's tile with the belt subsystem
|
|
// (on construction completion, or when un-queuing a deconstruction). No-op for
|
|
// non-belt-subsystem types. Splitter filters are (re)applied after placement.
|
|
|
|
// Selects a recipe for an auto-recipe building that has none, from a material being
|
|
// offered to it at one of its input ports (REQ-BLD-AUTO-RECIPE). No-op for every
|
|
// other building, for one that already holds a recipe, and for a material none of
|
|
// its recipes consumes. Called from both intake paths -- the belt pull and the
|
|
// direct coupling -- since either can be where the first material arrives.
|
|
void selectAutoRecipeIfUnset(Building& building,
|
|
const ItemType& offered);
|
|
// True if the consumer would accept `type` at the given input port right now:
|
|
// it is a required input (or a building block for the HQ), the reservation-aware
|
|
// buffer has room, and the input belt entry is free (REQ-MAT-INPUT-INTAKE).
|
|
bool canAcceptInput(const Building& consumer,
|
|
std::size_t inputPortIndex,
|
|
const ItemType& type) const;
|
|
// Places an accepted item onto the consumer's input belt at progress 0.0,
|
|
// reserving a per-material buffer slot (REQ-MAT-INPUT-INTAKE).
|
|
void depositToInputBelt(Building& consumer,
|
|
std::size_t inputPortIndex,
|
|
const Item& item);
|
|
// Attempts to hand an emerging output item straight into a directly adjacent
|
|
// building whose input edge meets the producer's output port (REQ-MAT-DIRECT-COUPLE).
|
|
// Returns true if the item was accepted onto the consumer's input belt.
|
|
bool tryDirectCoupleDeposit(FactoryState& state, BuildingId producerId,
|
|
const Port& outputPort,
|
|
const Item& item);
|
|
|
|
// Candidate recipes an idle building would try this tick: an auto-recipe
|
|
// building (Smelter, Reprocessing Plant) offers every recipe of its type with
|
|
// inputs; other buildings offer only their selected recipe. Shared by
|
|
// tickProduction and the status classifier (REQ-MAT-CYCLE, REQ-UI-STATUS-LIGHT).
|
|
// True if every input of `recipe` is present in `b`'s input buffers in the
|
|
// required per-cycle amount (REQ-MAT-CYCLE input check).
|
|
// Combined base + module materials a shipyard needs per ship (REQ-BLD-SHIPYARD).
|
|
// True if the building currently has all inputs/materials to start a cycle
|
|
// (ignoring output-buffer space); drives the Starved/Blocked distinction of
|
|
// the status light (REQ-UI-STATUS-LIGHT).
|
|
|
|
// What one cycle of this recipe produces: the items of its one output group
|
|
// (REQ-MAT-OUTPUT-GROUP). Where the recipe has several, one is picked by weight from
|
|
// those currently eligible (REQ-LOCK-OUTPUT-POOL) and the result is empty if none is;
|
|
// where it has one, that group is returned with no draw and no eligibility test.
|
|
std::vector<Item> rollOutputGroup(const RecipeDef& recipe);
|
|
|
|
const GameConfig& m_config;
|
|
|
|
|
|
BeltSystem& m_belts;
|
|
std::function<BuildingId()> m_allocateBuildingId;
|
|
std::function<void(int)> m_addBuildingBlocks;
|
|
std::function<void(const std::string&, QVector2D,
|
|
const std::optional<ShipLayoutConfig>&)> m_spawnShip;
|
|
std::function<bool(const std::string&)> m_isItemUnlocked;
|
|
std::mt19937& m_rng;
|
|
};
|