Extract map-specific data into a generic MapSource interface

One interface (nd_mapsource.h) now owns everything map-specific: tiles,
rooms/doors/cameras, the network graph (nodes + edges with roles replacing
the hardcoded N_AIRLK/N_DOOR/N_HIVE indices) and the entity spawn list.
The scenario populates its structures once via selectMap() and never checks
which map is active.

- DemoMapSource: self-contained demo grid (moved out of the sketch), demo
  node/edge/spawn tables
- GenMapSource: adapts the random MapGenerator — now with L-corridors for
  guaranteed connectivity, doors that lead somewhere, airlock pad, terminal
  and crates (never on corridor tiles); network graph derived from the room
  chain, marine-first spawn list with droid patrols
- NetDeck.ino: all source branching removed; red trace follows the real
  active-link path (BFS HIVE->ROOT); reinforcement spawns near the blast door
- Tests: MapTest validates 50 generated runs + demo via the interface with
  an airlock flood-fill; new generated-map integration journey; test node
  handles resolve through the source (no hardcoded indices)
This commit is contained in:
Dejvino
2026-11-15 18:21:35 +01:00
parent 7b80854e1d
commit b38d5d4b56
10 changed files with 1296 additions and 172 deletions
+1 -1
View File
@@ -154,7 +154,7 @@ TEST(e2e/network_journey)
EXPECT(pumpUntil(30.0, spikeSeen)); // ... trace ... feedback spike
EXPECT(test::serialHas("[spawn] reinforcement droid"));
stepTicks(1);
EXPECT(units[7].alive);
EXPECT(units[g_reinforceIdx].alive);
EXPECT(heatT > 0); // OVERHEAT lockout engaged
}
+45 -2
View File
@@ -73,7 +73,7 @@ TEST(integration/full_network_journey)
EXPECT(traceActive);
stepTicks(TRACE_TICKS);
EXPECT(heatT > 0); // feedback spike cooldown
EXPECT(units[7].alive); // reinforcement spawned
EXPECT(units[g_reinforceIdx].alive); // reinforcement spawned
EXPECT(!nodeOnline[N_JUNC]); // spike dropped the net
}
@@ -105,7 +105,7 @@ TEST(integration/sever_during_trace_is_safe)
handleKey('x'); // sever before arrival
EXPECT(!traceActive); // trace reset safely
EXPECT_EQ(heatT, 0); // no feedback spike
EXPECT(!units[7].alive); // no reinforcement
EXPECT(!units[g_reinforceIdx].alive); // no reinforcement
}
TEST(integration/daemon_gating_messages)
@@ -120,3 +120,46 @@ TEST(integration/daemon_gating_messages)
EXPECT_EQ(strcmp(msgText, "FRENZY ACTIVE"), 0); // FRENZY effect lands in M4
EXPECT(test::serialHas("[key] frenzy"));
}
TEST(integration/generated_map_source_journey)
{
// Switch to the random generator: the SAME scenario code (spawns, node
// roles, link routing, fog) must drive it with no map-source checks.
// The generator is seedless by design (random_device); assertions are
// therefore structural — layout invariants are fuzz-covered by
// src/netdeck/MapTest.cpp.
selectMap(false);
EXPECT(g_map == &g_genSource);
EXPECT(ROOT_NODE >= 0 && HIVE_NODE >= 0 && DOOR_NODE >= 0);
EXPECT(TERM_TX >= 0 && AIRLOCK_TX >= 0); // terminal + airlock found
EXPECT(g_map->spawnCount() >= 2);
EXPECT(g_map->spawnCount() < nd::MAX_UNITS); // reinforcement slot exists
resetScenario();
EXPECT(units[0].alive && units[1].alive); // marines come from the spawn list
EXPECT(nodeOnline[ROOT_NODE]); // root up after reset
EXPECT(!nodeOnline[HIVE_NODE]);
// route a link from the root to any adjacent offline node (source-agnostic)
// (the previous test may leave either view; make the mode explicit)
viewMode = VM_NETWORK;
int target = -1;
for (int e = 0; e < edgeCount() && target < 0; e++) {
int a = g_map->edge(e).a, b = g_map->edge(e).b;
if (a == ROOT_NODE && !nodeOnline[b]) target = b;
if (b == ROOT_NODE && !nodeOnline[a]) target = a;
}
EXPECT(target >= 0);
clickNode(target);
stepTicks(ICE_TICKS); // covers plain + ICE durations
EXPECT(nodeOnline[target]); // link built on a generated map
stepTicks(60); // combat/fog run a while: no crash
for (int i = 0; i < g_map->spawnCount(); i++)
EXPECT(units[i].alive || true); // slots exist (alive or KIA)
// back to the demo map — the other tests expect it
selectMap(true);
resetScenario();
EXPECT(nodeOnline[ROOT_NODE]);
EXPECT_EQ(nd::DEMO_MAP[7][34], 'T');
}
+20
View File
@@ -32,6 +32,26 @@ inline void clickTile(int tx, int ty)
// find the active link on an edge, or -1
inline int linkIdx(int edge) { return linkOnEdge(edge); }
// ---------------------------------------------------------------------------
// Node handles resolved from the ACTIVE MAP SOURCE. The old tests hardcoded
// demo node indices (N_AIRLK/N_JUNC/...); the map source now owns the node
// tables, so the tests resolve through the same generic interface the sketch
// uses. (The fast suites run the demo map, where these are the classic nodes.)
// ---------------------------------------------------------------------------
inline int nodeByLabel(const char *label)
{
for (int i = 0; i < nodeCount(); i++)
if (strcmp(g_map->node(i).label, label) == 0) return i;
return -1;
}
#define N_AIRLK ROOT_NODE
#define N_DOOR DOOR_NODE
#define N_HIVE HIVE_NODE
#define N_JUNC nodeByLabel("JUNC")
#define N_CAM1 nodeByLabel("CAM1")
#define N_CAM2 nodeByLabel("CAM2")
#define N_CAM3 nodeByLabel("CAM3")
// fresh deterministic scenario state for a test
inline void freshScenario(unsigned seed = 0xC0FFEE)
{
+3 -3
View File
@@ -23,7 +23,7 @@ TEST(unit/map_queries)
EXPECT(walkable(34, 7)); // objective terminal 'T'
EXPECT(blocksSight(0, 0));
EXPECT(!blocksSight(20, 12));
EXPECT_EQ(DEMO_MAP[7][34], 'T'); // the win tile really is T
EXPECT_EQ(nd::DEMO_MAP[7][34], 'T'); // the win tile really is T
}
TEST(unit/door_gates_movement_and_sight)
@@ -158,7 +158,7 @@ TEST(unit/ice_trace_feedback_reinforcement)
EXPECT(linkIdx(0) < 0 && linkIdx(1) < 0 && linkIdx(2) < 0);
EXPECT(!nodeOnline[N_JUNC]); // everything past root drops
EXPECT(nodeOnline[N_AIRLK]);
EXPECT(units[7].alive); // reinforcement droid spawned
EXPECT(units[g_reinforceIdx].alive); // reinforcement droid spawned
}
TEST(unit/overheat_gates_daemons_and_sever)
@@ -215,7 +215,7 @@ TEST(unit/reset_rearms_everything)
EXPECT(units[0].alive && units[1].alive);
EXPECT_EQ(units[0].tx, 2); // back in the airlock
EXPECT_EQ(units[0].hp, STATS[U_MARINE].maxHp);
EXPECT(!units[7].alive); // reinforcement slot cleared
EXPECT(!units[g_reinforceIdx].alive); // reinforcement slot cleared
EXPECT(!doorOpen);
EXPECT_EQ(heatT, 0);
EXPECT(linkIdx(0) < 0 && linkIdx(1) < 0 && linkIdx(2) < 0);
+146
View File
@@ -0,0 +1,146 @@
// Minimal test for the map sources (nd_mapsource.h / nd_mapgen.h)
// Validates the generated map and the generic MapSource interface.
#include "nd_mapgen.h"
#include "nd_demomap.h"
static bool allPass = true;
static void check(const char *name, bool ok) {
printf("%-42s %s\n", name, ok ? "PASS" : "FAIL");
if (!ok) allPass = false;
}
// every node reachable from the root over the edge list?
static bool graphConnected(const nd::MapSource &m) {
int n = m.nodeCount();
int root = m.rootNode();
if (n <= 0 || root < 0) return false;
bool seen[nd::MAX_NODES] = {};
int queue[nd::MAX_NODES], qh = 0, qt = 0;
queue[qt++] = root;
seen[root] = true;
while (qh < qt) {
int cur = queue[qh++];
for (int e = 0; e < m.edgeCount(); e++) {
int a = m.edge(e).a, b = m.edge(e).b;
int nbr = (a == cur) ? b : (b == cur) ? a : -1;
if (nbr < 0 || seen[nbr]) continue;
seen[nbr] = true;
queue[qt++] = nbr;
}
}
for (int i = 0; i < n; i++)
if (!seen[i]) return false;
return true;
}
// walkable flood fill from the airlock ('+' doors treated as open):
// the terminal and every entity spawn must be reachable on foot
static bool tilesConnected(const nd::MapSource &m) {
static bool seen[nd::TILE_COLS * nd::TILE_ROWS];
for (int i = 0; i < nd::TILE_COLS * nd::TILE_ROWS; i++) seen[i] = false;
int ax, ay;
if (!m.findTile('A', ax, ay)) return false;
int queue[nd::TILE_COLS * nd::TILE_ROWS], qh = 0, qt = 0;
queue[qt++] = ay * nd::TILE_COLS + ax;
seen[queue[0]] = true;
while (qh < qt) {
int cur = queue[qh++];
int cx = cur % nd::TILE_COLS, cy = cur / nd::TILE_COLS;
static const int DX[4] = { 1, -1, 0, 0 };
static const int DY[4] = { 0, 0, 1, -1 };
for (int d = 0; d < 4; d++) {
int nx = cx + DX[d], ny = cy + DY[d];
if (nx < 0 || ny < 0 || nx >= nd::TILE_COLS || ny >= nd::TILE_ROWS) continue;
char t = m.tileAt(nx, ny);
bool pass = (t == '.' || t == 'A' || t == 'T' || t == '+');
if (!pass || seen[ny * nd::TILE_COLS + nx]) continue;
seen[ny * nd::TILE_COLS + nx] = true;
queue[qt++] = ny * nd::TILE_COLS + nx;
}
}
int tx, ty;
if (!m.findTile('T', tx, ty) || !seen[ty * nd::TILE_COLS + tx]) return false;
for (int s = 0; s < m.spawnCount(); s++) {
const nd::UnitSpawn &sp = m.spawn(s);
if (!seen[sp.ty * nd::TILE_COLS + sp.tx]) return false;
}
return true;
}
static void testGeneratedSource(int seed) {
nd::MapGenerator gen;
nd::GenMapSource src(gen);
src.generate();
char title[64];
printf("--- generated map (run %d) ---\n", seed);
// structural tiles exist
int tx, ty;
snprintf(title, sizeof(title), "airlock + terminal tiles present");
check(title, src.findTile('A', tx, ty) && src.findTile('T', tx, ty));
// room count (4-6)
snprintf(title, sizeof(title), "room count 4-6 (got %zu)",
src.getRooms().size());
check(title, src.getRooms().size() >= 4 && src.getRooms().size() <= 6);
// marines: spawns 0/1 must be marines (the squad)
check("spawns 0/1 are marines",
src.spawnCount() >= 2 &&
src.spawn(0).kind == 0 && src.spawn(1).kind == 0);
// spawn budget: leaves room for the reinforcement droid
snprintf(title, sizeof(title), "spawn count %d <= MAX_UNITS-1", src.spawnCount());
check(title, src.spawnCount() > 0 && src.spawnCount() < nd::MAX_UNITS);
// roles present
check("root/hive/door nodes present",
src.rootNode() >= 0 && src.hiveNode() >= 0 && src.doorNode() >= 0);
// node node(0) is the online root
check("root node online", src.node(src.rootNode()).online);
// network graph connected
check("network graph connected from root", graphConnected(src));
// physical walkability: terminal + all spawns reachable from the airlock
check("tiles connected (airlock flood)", tilesConnected(src));
// node/edge pools within bounds
snprintf(title, sizeof(title), "nodes %d<=%d, edges %d<=%d",
src.nodeCount(), nd::MAX_NODES, src.edgeCount(), nd::MAX_EDGES);
check(title, src.nodeCount() <= nd::MAX_NODES && src.edgeCount() <= nd::MAX_EDGES);
}
static void testDemoSource() {
printf("--- demo map ---\n");
nd::DemoMapSource demo;
check("demo terminal tile at (34,7)", demo.tileAt(34, 7) == 'T');
check("demo airlock tile at (2,21)", demo.tileAt(2, 21) == 'A');
check("demo blast door at (28,12)", demo.tileAt(28, 12) == '+');
check("demo node count 7", demo.nodeCount() == 7);
check("demo roles root/door/hive",
demo.rootNode() == 0 && demo.doorNode() == 2 && demo.hiveNode() == 3);
check("demo spawns 11, marines first",
demo.spawnCount() == 11 && demo.spawn(0).kind == 0 && demo.spawn(1).kind == 0);
check("demo patrol endpoints set", demo.spawn(2).patA >= 0 && demo.spawn(2).patB >= 0);
check("demo graph connected", graphConnected(demo));
check("demo tiles connected (airlock flood)", tilesConnected(demo));
}
int main() {
for (int i = 0; i < 50; i++) testGeneratedSource(i);
testDemoSource();
printf("\n");
if (allPass) {
printf("ALL TESTS PASSED\n");
return 0;
}
printf("SOME TESTS FAILED\n");
return 1;
}
+195 -165
View File
@@ -45,6 +45,8 @@
#include "utilities.h"
#include "TouchDrvGT911.hpp"
#include "nd_layout.h"
#include "nd_demomap.h"
#include "nd_mapgen.h"
#include "sound_engine.h"
// ---------------------------------------------------------------------------
@@ -92,47 +94,53 @@ static uint32_t simAcc = 0;
static uint32_t lastFrameMs = 0;
// ---------------------------------------------------------------------------
// Floorplan (MVP.md §1): 40x24 tiles, 3 rooms
// '#' wall '.' floor 'o' cover crate '+' blast door 'A' airlock 'T' terminal
// Room 1 airlock (bottom-left), Room 2 main corridor (L-shaped middle),
// Room 3 server room (right). The '+' door is the Room2/Room3 blast door.
// Map source: everything map-specific comes from one MapSource interface
// (nd_mapsource.h). The scenario populates its structures from the source
// exactly once (selectMap) and afterwards never checks which map is active —
// the demo floorplan and the random MapGenerator are interchangeable.
// ---------------------------------------------------------------------------
static const char *const DEMO_MAP[nd::TILE_ROWS] = {
"########################################",
"#.........#.................#..........#",
"#.........#......#..........#..........#",
"#...#.....#......#..........#.....o....#",
"#....o....#......#..........#..........#",
"#...#.....#......#..........#..........#",
"#.........#.................#..........#",
"#.........#.................#.....T....#",
"#...........................#..........#",
"#...........................#..........#",
"#.........#...#.....o.......#..........#",
"#.........#...#.............#..........#",
"#.........#.................+..........#",
"###########.................#..........#",
"#.........#.................#..........#",
"#....#....#...........o.....#....#.....#",
"#.........#.................#..........#",
"#...........................#..........#",
"#...........................#..........#",
"#.........#.....#...........#..........#",
"#.........#.....#...........#.....o....#",
"#.A.......#.................#..........#",
"#.........#.................#..........#",
"########################################",
};
static nd::DemoMapSource g_demoSource;
static nd::MapGenerator g_mapGenerator;
static nd::GenMapSource g_genSource(g_mapGenerator);
static nd::MapSource *g_map = &g_demoSource; // active map source
static bool g_mapSelected = false;
static const int DOOR_TX = 28, DOOR_TY = 12; // the Room2/Room3 blast door
static const int AIRLOCK_TX = 2, AIRLOCK_TY = 21;
// map-anchored specials + node roles + free unit slot — filled by selectMap()
static int AIRLOCK_TX = -1, AIRLOCK_TY = -1; // 'A' airlock pad
static int TERM_TX = -1, TERM_TY = -1; // 'T' objective terminal
static int ROOT_NODE = -1; // always-online uplink node
static int HIVE_NODE = -1; // ICE-protected hive node
static int DOOR_NODE = -1; // blast-door control node
static int g_reinforceIdx = -1; // reinforcement droid unit slot
static bool doorOpen = false;
// squad priority beacon (defaults to the airlock pad of the active map)
static int beaconTX = -1, beaconTY = -1;
// switch map sources: populates every map-specific structure exactly once
static void selectMap(bool demo)
{
if (demo) {
g_map = &g_demoSource;
} else {
g_genSource.generate();
g_map = &g_genSource;
}
g_mapSelected = true;
g_map->findTile('A', AIRLOCK_TX, AIRLOCK_TY);
g_map->findTile('T', TERM_TX, TERM_TY);
ROOT_NODE = g_map->rootNode();
HIVE_NODE = g_map->hiveNode();
DOOR_NODE = g_map->doorNode();
g_reinforceIdx = g_map->spawnCount(); // first free unit slot
beaconTX = AIRLOCK_TX;
beaconTY = AIRLOCK_TY;
}
static char tileAt(int tx, int ty)
{
if (tx < 0 || ty < 0 || tx >= nd::TILE_COLS || ty >= nd::TILE_ROWS) return '#';
return DEMO_MAP[ty][tx];
return g_map->tileAt(tx, ty);
}
// blocks unit movement (closed blast door included)
@@ -153,40 +161,18 @@ static bool blocksSight(int tx, int ty)
static int tileIdx(int tx, int ty) { return ty * nd::TILE_COLS + tx; }
// ---------------------------------------------------------------------------
// Sub-net (MVP.md §2): 7 nodes in the same coordinate space
// Sub-net (MVP.md §2): node/edge tables come from the active map source;
// only the runtime link state lives here.
// ---------------------------------------------------------------------------
enum { N_AIRLK, N_JUNC, N_DOOR, N_HIVE, N_CAM1, N_CAM2, N_CAM3 };
static const int NODE_COUNT = 7;
static const int EDGE_COUNT = 6;
struct NetNode {
const char *label;
int tx, ty;
uint16_t color;
uint8_t sight; // fog reveal radius (tiles) while online
};
// cameras see farther than plain nodes (FOG_NODE_R vs FOG_CAM_R)
static const int FOG_NODE_R = 3;
static const int FOG_CAM_R = 6;
static const NetNode NODES[NODE_COUNT] = {
{ "AIRLK", 4, 20, nd::C_AIRLOCK, FOG_NODE_R },
{ "JUNC", 18, 6, nd::C_NODE, FOG_NODE_R },
{ "DOOR", 28, 12, nd::C_DOOR, FOG_NODE_R },
{ "HIVE", 35, 4, nd::C_HIVE, FOG_NODE_R },
{ "CAM1", 14, 2, nd::C_CAMERA, FOG_CAM_R },
{ "CAM2", 31, 3, nd::C_CAMERA, FOG_CAM_R },
{ "CAM3", 22, 18, nd::C_CAMERA, FOG_CAM_R },
};
static const uint8_t EDGES[EDGE_COUNT][2] = {
{ N_AIRLK, N_JUNC }, { N_JUNC, N_DOOR }, { N_JUNC, N_HIVE },
{ N_JUNC, N_CAM1 }, { N_DOOR, N_CAM2 }, { N_CAM1, N_CAM3 },
};
static const char *EDGE_LABELS[EDGE_COUNT] = {
"AIRLK-JUNC", "JUNC-DOOR", "JUNC-HIVE",
"JUNC-CAM1", "DOOR-CAM2", "CAM1-CAM3",
};
static int nodePx(int i) { return NODES[i].tx * nd::TILE + nd::TILE / 2; }
static int nodePy(int i) { return NODES[i].ty * nd::TILE + nd::TILE / 2; }
static int nodeCount() { return g_map->nodeCount(); }
static int edgeCount() { return g_map->edgeCount(); }
static int nodePx(int i) { return g_map->node(i).tx * nd::TILE + nd::TILE / 2; }
static int nodePy(int i) { return g_map->node(i).ty * nd::TILE + nd::TILE / 2; }
// link build durations (sim ticks @ 50 ms): 1.5 s plain, 3.0 s through ICE
static const int LINK_TICKS = 30;
@@ -198,19 +184,21 @@ static const int HEAT_TICKS = 60;
struct NetLink {
bool active;
uint8_t edge; // which EDGES[] entry this link occupies
uint8_t edge; // which map edge this link occupies
uint8_t a, b; // node ids
int prog; // build progress in ticks (prog == dur -> ACTIVE)
int dur;
};
static NetLink links[EDGE_COUNT];
static NetLink links[nd::MAX_EDGES];
static bool nodeOnline[NODE_COUNT]; // compromised & reachable from AIRLK
static bool nodeOnline[nd::MAX_NODES]; // compromised & reachable from AIRLK
static bool hiveCracked = false;
// red trace pulse HIVE -> JUNC -> AIRLK
// red trace pulse HIVE -> ... -> AIRLK, along the active link path
static bool traceActive = false;
static int traceProg = 0; // 0..TRACE_TICKS
static int tracePath[nd::MAX_NODES]; // node ids from HIVE back to ROOT
static int tracePathLen = 0;
// deck thermal: >0 = OVERHEAT lockout (ticks remaining, shown as %)
static int heatT = 0;
@@ -230,7 +218,7 @@ static bool reinforcePending = false;
// cursor
static int curX = 60, curY = 120;
static int beaconTX = AIRLOCK_TX, beaconTY = AIRLOCK_TY;
// (beacon lives with the map source state: beaconTX/beaconTY above)
// transient UI feedback
static uint32_t viewFlashUntil = 0;
@@ -426,8 +414,8 @@ static void updateFog(); // fwd decl: fog recompute lives below the unit laye
// reachability from AIRLK over ACTIVE links (links form a tree)
static void refreshOnline()
{
bool reach[NODE_COUNT] = {}; // AIRLK root starts reachable
reach[N_AIRLK] = true;
bool reach[nd::MAX_NODES] = {}; // AIRLK root starts reachable
if (ROOT_NODE >= 0) reach[ROOT_NODE] = true;
bool changed = true;
while (changed) {
changed = false;
@@ -439,23 +427,24 @@ static void refreshOnline()
}
}
}
for (int i = 0; i < NODE_COUNT; i++) nodeOnline[i] = reach[i];
if (!nodeOnline[N_HIVE]) hiveCracked = false;
for (int i = 0; i < nodeCount(); i++) nodeOnline[i] = reach[i];
if (HIVE_NODE >= 0 && !nodeOnline[HIVE_NODE]) hiveCracked = false;
}
// is there an edge between two nodes?
static int edgeBetween(int a, int b)
{
for (int i = 0; i < EDGE_COUNT; i++)
if ((EDGES[i][0] == a && EDGES[i][1] == b) ||
(EDGES[i][0] == b && EDGES[i][1] == a)) return i;
for (int i = 0; i < edgeCount(); i++) {
const nd::NetEdgeDef &e = g_map->edge(i);
if ((e.a == a && e.b == b) || (e.a == b && e.b == a)) return i;
}
return -1;
}
// is a link already routed on this edge (building or active)?
static int linkOnEdge(int edge)
{
for (int i = 0; i < EDGE_COUNT; i++)
for (int i = 0; i < edgeCount(); i++)
if (links[i].active && links[i].edge == edge) return i;
return -1;
}
@@ -471,7 +460,7 @@ static void tryLink(int node)
{
if (heatT > 0) { flashMsg("OVERHEAT"); return; }
if (nodeOnline[node]) {
if (node == N_DOOR) {
if (node == DOOR_NODE) {
doorOpen = !doorOpen;
if (doorOpen) playDoorOpen();
else playDoorClose();
@@ -485,8 +474,8 @@ static void tryLink(int node)
}
// route a link from any online node adjacent to this one
int edge = -1, from = -1;
for (int i = 0; i < EDGE_COUNT; i++) {
int a = EDGES[i][0], b = EDGES[i][1];
for (int i = 0; i < edgeCount(); i++) {
int a = g_map->edge(i).a, b = g_map->edge(i).b;
if ((a == node && nodeOnline[b]) || (b == node && nodeOnline[a])) {
edge = i;
from = (a == node) ? b : a;
@@ -496,7 +485,7 @@ static void tryLink(int node)
if (edge < 0) { flashMsg("NO UPLINK"); return; }
if (linkOnEdge(edge) >= 0) { flashMsg("LINKING..."); return; }
bool ice = (node == N_HIVE);
bool ice = (node == HIVE_NODE);
for (auto &l : links) {
if (!l.active) {
l.active = true;
@@ -508,7 +497,7 @@ static void tryLink(int node)
refreshOnline(); // offline until the build completes
playLinkBuild();
playLinkActive();
Serial.printf("[net] routing %s%s (%.1fs)\n", EDGE_LABELS[edge],
Serial.printf("[net] routing %s%s (%.1fs)\n", g_map->edge(edge).label,
ice ? " [ICE]" : "", l.dur * nd::SIM_TICK_MS / 1000.0f);
return;
}
@@ -519,10 +508,11 @@ static void tryLink(int node)
static void severLink(int li)
{
playLinkSevered();
Serial.printf("[net] severed %s\n", EDGE_LABELS[edgeBetween(links[li].a, links[li].b)]);
Serial.printf("[net] severed %s\n",
g_map->edge(edgeBetween(links[li].a, links[li].b)).label);
links[li].active = false;
refreshOnline();
if (!nodeOnline[N_HIVE]) traceActive = false; // trace cut short: reset safely
if (HIVE_NODE >= 0 && !nodeOnline[HIVE_NODE]) traceActive = false; // trace cut short: reset safely
flashMsg("LINK SEVERED");
}
@@ -531,7 +521,7 @@ static int hoverLink()
{
int best = -1;
float bestD = 7.0f;
for (int i = 0; i < EDGE_COUNT; i++) {
for (int i = 0; i < edgeCount(); i++) {
if (!links[i].active) continue;
float x0 = nodePx(links[i].a), y0 = nodePy(links[i].a);
float x1 = nodePx(links[i].b), y1 = nodePy(links[i].b);
@@ -547,8 +537,45 @@ static int hoverLink()
return best;
}
// is the edge fully linked up right now (any complete active link on it)?
static bool edgeUp(int e)
{
for (int i = 0; i < nd::MAX_EDGES; i++)
if (links[i].active && links[i].edge == e && links[i].prog == links[i].dur)
return true;
return false;
}
static void spawnTrace()
{
// walk the active-link path HIVE -> ... -> AIRLK (BFS over the node graph)
tracePathLen = 0;
if (HIVE_NODE >= 0 && ROOT_NODE >= 0 && HIVE_NODE != ROOT_NODE) {
int prev[nd::MAX_NODES];
int queue[nd::MAX_NODES];
for (int i = 0; i < nd::MAX_NODES; i++) prev[i] = -2;
int qh = 0, qt = 0;
queue[qt++] = HIVE_NODE;
prev[HIVE_NODE] = -1;
while (qh < qt && prev[ROOT_NODE] == -2) {
int cur = queue[qh++];
for (int e = 0; e < edgeCount(); e++) {
if (!edgeUp(e)) continue;
int a = g_map->edge(e).a, b = g_map->edge(e).b;
int nbr = (a == cur) ? b : (b == cur) ? a : -1;
if (nbr < 0 || prev[nbr] != -2) continue;
prev[nbr] = cur;
queue[qt++] = nbr;
}
}
if (prev[ROOT_NODE] != -2) {
int rev[nd::MAX_NODES], len = 0;
for (int n = ROOT_NODE; n != -1; n = prev[n]) rev[len++] = n;
for (int i = 0; i < len; i++) tracePath[i] = rev[len - 1 - i];
tracePathLen = len; // HIVE first, ROOT last
}
}
if (tracePathLen < 2) return; // no path: no trace
traceActive = true;
traceProg = 0;
Serial.println("[net] TRACE detected: red pulse inbound!");
@@ -573,11 +600,12 @@ static void stepNetwork()
l.prog++;
if (l.prog == l.dur) {
refreshOnline();
if (l.b == N_HIVE && nodeOnline[N_HIVE]) {
if (l.b == HIVE_NODE && nodeOnline[HIVE_NODE]) {
hiveCracked = true;
spawnTrace();
} else {
Serial.printf("[net] link up: %s\n", EDGE_LABELS[edgeBetween(l.a, l.b)]);
Serial.printf("[net] link up: %s\n",
g_map->edge(edgeBetween(l.a, l.b)).label);
}
}
}
@@ -591,7 +619,7 @@ static void stepNetwork()
}
// ICE crack progress check during link building
for (auto &l : links) {
if (l.b == N_HIVE && l.active && l.prog < l.dur) {
if (l.b == HIVE_NODE && l.active && l.prog < l.dur) {
int crackProg = l.prog;
if (crackProg % 20 == 0) playIceCrack(); // crack every ~1s
}
@@ -640,8 +668,8 @@ struct Unit {
bool patFlip;
};
static Unit units[nd::MAX_UNITS];
// 0,1 marines | 2,8,10 patrol droids | 3,9 stationary droids | 4 heavy
// 5,6,11 turrets | 7 = reinforcement slot (spawns on the feedback spike)
// slots 0..spawnCount-1 come from the map source's spawn list (marines first);
// the slot after the last spawn is the reinforcement droid (feedback spike)
// transient hitscan tracers / impact flashes
struct Tracer {
@@ -774,8 +802,8 @@ static int acquireTarget(int si)
// 1. if blindT > 0 AND shooter is within HIVE frenzy range: return no target
bool inFrenzyRange = (frenzyT > 0);
if (inFrenzyRange) {
int ddx = u.tx - NODES[N_HIVE].tx;
int ddy = u.ty - NODES[N_HIVE].ty;
int ddx = u.tx - g_map->node(HIVE_NODE).tx;
int ddy = u.ty - g_map->node(HIVE_NODE).ty;
long shooterD2 = (long)ddx * ddx + (long)ddy * ddy;
inFrenzyRange = (shooterD2 <= (long)FRENZY_RADIUS * FRENZY_RADIUS);
}
@@ -944,19 +972,30 @@ static void stepUnits()
// reinforcement droid queued by the feedback spike
if (reinforcePending) {
reinforcePending = false;
if (!units[7].alive) {
// spawn inside the server room by the blast door, first free tile
static const int SP[5][2] = { {31,12}, {30,12}, {32,12}, {31,11}, {31,13} };
for (int s = 0; s < 5; s++) {
int sx = SP[s][0], sy = SP[s][1];
if (walkable(sx, sy) && !tileOccupied(sx, sy, 7)) {
spawnUnit(7, U_DROID, sx, sy);
Serial.printf("[spawn] reinforcement droid at %d,%d\n", sx, sy);
if (!units[g_reinforceIdx].alive) {
// spawn on the hive side of the blast door, first free tile
int dtx = g_map->node(DOOR_NODE).tx, dty = g_map->node(DOOR_NODE).ty;
int hx = g_map->node(HIVE_NODE).tx, hy = g_map->node(HIVE_NODE).ty;
int sx = (hx > dtx) - (hx < dtx); // step toward the hive
int sy = (hy > dty) - (hy < dty);
for (int k = 1; k <= 3; k++) {
int cand[3][2] = {
{ dtx + sx * k, dty },
{ dtx, dty + sy * k },
{ dtx + sx * k, dty + sy * k },
};
for (int c = 0; c < 3; c++) {
int cx = cand[c][0], cy = cand[c][1];
if (walkable(cx, cy) && !tileOccupied(cx, cy, g_reinforceIdx)) {
spawnUnit(g_reinforceIdx, U_DROID, cx, cy);
Serial.printf("[spawn] reinforcement droid at %d,%d\n", cx, cy);
k = 4; // done
break;
}
}
}
}
}
for (int i = 0; i < nd::MAX_UNITS; i++) {
Unit &u = units[i];
@@ -986,7 +1025,7 @@ static void stepUnits()
// stationary droids / heavy / turret hold position
// objective + wipe checks
if (u.kind == U_MARINE && u.tx == 34 && u.ty == 7) {
if (u.kind == U_MARINE && u.tx == TERM_TX && u.ty == TERM_TY) {
scenario = SC_WIN;
playBreachSuccess();
Serial.println("[objective] terminal reached — BREACH SUCCESS");
@@ -1024,11 +1063,11 @@ static void updateFog()
if (!units[i].alive || units[i].team != TEAM_MARINE) continue;
revealLos(units[i].tx, units[i].ty, FOG_SIGHT_R);
}
for (int i = 0; i < NODE_COUNT; i++) {
for (int i = 0; i < nodeCount(); i++) {
if (nodeOnline[i]) {
// only cameras have large LOS; other nodes uncover just their own position
int r = (strstr(NODES[i].label, "CAM") != nullptr) ? NODES[i].sight : 1;
revealLos(NODES[i].tx, NODES[i].ty, r);
int r = (g_map->node(i).role == nd::NR_CAMERA) ? g_map->node(i).sight : 1;
revealLos(g_map->node(i).tx, g_map->node(i).ty, r);
}
}
}
@@ -1038,9 +1077,11 @@ static void updateFog()
// ---------------------------------------------------------------------------
static void resetScenario()
{
if (!g_mapSelected) selectMap(true); // lazy first population (test harnesses)
for (auto &l : links) l.active = false;
traceActive = false;
traceProg = 0;
tracePathLen = 0;
hiveCracked = false;
heatT = 0;
doorOpen = false;
@@ -1048,32 +1089,17 @@ static void resetScenario()
for (auto &t : tracers) t.ttl = 0;
refreshOnline(); // AIRLK root comes up online
// squad: 2 marines in the airlock (out of enemy LOS)
spawnUnit(0, U_MARINE, 2, 21);
spawnUnit(1, U_MARINE, 3, 21);
// corridor: 1 patrolling + 1 stationary security droid
spawnUnit(2, U_DROID, 12, 2);
units[2].patA = tileIdx(12, 2);
units[2].patB = tileIdx(26, 18);
units[2].patFlip = false;
spawnUnit(3, U_DROID, 20, 12);
// server room: heavy droid + ceiling turrets guarding the terminal
spawnUnit(4, U_HEAVY, 32, 10);
spawnUnit(5, U_TURRET, 33, 5);
spawnUnit(6, U_TURRET, 35, 5);
units[7].alive = false; // reinforcement slot
// wider garrison: airlock-side patrol, server-room guard, corridor
// patrol and a turret covering the blast door approach
spawnUnit(8, U_DROID, 2, 2);
units[8].patA = tileIdx(2, 2);
units[8].patB = tileIdx(8, 6);
units[8].patFlip = false;
spawnUnit(9, U_DROID, 31, 16);
spawnUnit(10, U_DROID, 14, 18);
units[10].patA = tileIdx(13, 18);
units[10].patB = tileIdx(25, 18);
units[10].patFlip = false;
spawnUnit(11, U_TURRET, 26, 10);
// entities: apply the map source's spawn list exactly once (marines first)
for (int s = 0; s < g_map->spawnCount() && s < nd::MAX_UNITS; s++) {
const nd::UnitSpawn &sp = g_map->spawn(s);
spawnUnit(s, sp.kind, sp.tx, sp.ty);
units[s].patA = sp.patA;
units[s].patB = sp.patB;
units[s].patFlip = false;
}
units[g_reinforceIdx].alive = false; // reinforcement slot
for (int i = g_reinforceIdx + 1; i < nd::MAX_UNITS; i++)
units[i].alive = false; // unused slots stay down
// fog of war starts blank: only what the marines see in the airlock and
// the always-online [AIRLK] node's connected tiles is uncovered
@@ -1160,7 +1186,7 @@ static void registerClick()
} else {
// nearest node
int best = -1, bestD = 1 << 30;
for (int i = 0; i < NODE_COUNT; i++) {
for (int i = 0; i < nodeCount(); i++) {
int dx = curX - nodePx(i);
int dy = curY - nodePy(i);
int d = dx * dx + dy * dy;
@@ -1194,7 +1220,7 @@ static void handleKey(char c)
break;
case '1': case '2':
if (heatT > 0) { flashMsg("OVERHEAT"); break; }
if (!nodeOnline[N_HIVE]) { flashMsg("NO HIVE LINK"); playNoLink(); break; }
if (HIVE_NODE < 0 || !nodeOnline[HIVE_NODE]) { flashMsg("NO HIVE LINK"); playNoLink(); break; }
// FRENZY.EXE (1) or BLIND_OPTICS.SH (2) — land in Milestone 4
if (c == '1') {
// FRENZY: droids attack everyone within sphere of influence
@@ -1374,7 +1400,7 @@ static uint16_t gray565(uint16_t c)
static void renderMap(bool dim)
{
for (int ty = 0; ty < nd::TILE_ROWS; ty++) {
const char *row = DEMO_MAP[ty];
const char *row = g_map->getMap()[ty].c_str();
for (int tx = 0; tx < nd::TILE_COLS; tx++) {
char t = row[tx];
int fi = tileIdx(tx, ty);
@@ -1442,7 +1468,7 @@ static void drawLinkLine(int x0, int y0, int x1, int y1, float frac,
static void renderNetwork(bool full)
{
// links: active solid, building partial, ghost outlines in cameras mode
for (int i = 0; i < EDGE_COUNT; i++) {
for (int i = 0; i < edgeCount(); i++) {
auto &l = links[i];
int x0 = nodePx(l.a), y0 = nodePy(l.a);
int x1 = nodePx(l.b), y1 = nodePy(l.b);
@@ -1475,14 +1501,14 @@ static void renderNetwork(bool full)
}
}
// red trace pulse along HIVE -> JUNC -> AIRLK
if (traceActive) {
float f = (float)traceProg / TRACE_TICKS * 2.0f; // 2 segments
int seg = (f >= 1.0f) ? 1 : 0;
// red trace pulse along the active link path HIVE -> ... -> AIRLK
if (traceActive && tracePathLen >= 2) {
float f = (float)traceProg / TRACE_TICKS * (tracePathLen - 1);
int seg = (int)f;
if (seg > tracePathLen - 2) seg = tracePathLen - 2;
float t = f - seg;
int x0 = nodePx(N_HIVE), y0 = nodePy(N_HIVE);
int x1 = nodePx(N_JUNC), y1 = nodePy(N_JUNC);
if (seg == 1) { x0 = nodePx(N_JUNC); y0 = nodePy(N_JUNC); x1 = nodePx(N_AIRLK); y1 = nodePy(N_AIRLK); }
int x0 = nodePx(tracePath[seg]), y0 = nodePy(tracePath[seg]);
int x1 = nodePx(tracePath[seg + 1]), y1 = nodePy(tracePath[seg + 1]);
int px = x0 + (int)((x1 - x0) * t);
int py = y0 + (int)((y1 - y0) * t);
GFXP->fillCircle(px, py, 3, nd::C_TRACE);
@@ -1490,10 +1516,10 @@ static void renderNetwork(bool full)
}
// frenzy / blind sphere of influence — only drawn when HIVE is online (connected)
// Network mode only; gated by nodeOnline[N_HIVE]
if (full && nodeOnline[N_HIVE]) {
int cx = nodePx(N_HIVE);
int cy = nodePy(N_HIVE);
// Network mode only; gated by nodeOnline[HIVE_NODE]
if (full && HIVE_NODE >= 0 && nodeOnline[HIVE_NODE]) {
int cx = nodePx(HIVE_NODE);
int cy = nodePy(HIVE_NODE);
int r = FRENZY_RADIUS * nd::TILE;
if (frenzyT > 0 || blindT > 0) {
// solid circles when frenzy/blind is active
@@ -1550,17 +1576,19 @@ static void renderNetwork(bool full)
// - nodeOnline[i] == true: filled node with label (established link)
// - node is a connectable target of an online source: ghost circle (known, not yet active)
// these are nodes reachable from online nodes via one edge, but link not built yet
bool isConnectableTarget[NODE_COUNT];
for (int i = 0; i < NODE_COUNT; i++) isConnectableTarget[i] = false;
bool isConnectableTarget[nd::MAX_NODES];
int nCount = nodeCount();
int eCount = edgeCount();
for (int i = 0; i < nCount; i++) isConnectableTarget[i] = false;
if (full) {
// first pass: identify connectable targets from online sources
for (int s = 0; s < NODE_COUNT; s++) {
for (int s = 0; s < nCount; s++) {
// AIRLK is always a source; others if online
bool srcOnline = nodeOnline[s];
if (s == N_AIRLK) srcOnline = true; // AIRLK always source
if (s == ROOT_NODE) srcOnline = true; // AIRLK always source
if (!srcOnline) continue;
for (int e = 0; e < EDGE_COUNT; e++) {
int a = EDGES[e][0], b = EDGES[e][1];
for (int e = 0; e < eCount; e++) {
int a = g_map->edge(e).a, b = g_map->edge(e).b;
if (a != s && b != s) continue;
int neighbor = (a == s) ? b : a;
if (!nodeOnline[neighbor]) { // not already online
@@ -1570,19 +1598,20 @@ static void renderNetwork(bool full)
}
}
for (int i = 0; i < NODE_COUNT; i++) {
for (int i = 0; i < nCount; i++) {
const nd::NetNodeDef &nd_ = g_map->node(i);
int nx = nodePx(i), ny = nodePy(i);
if (full) {
if (nodeOnline[i]) {
// established connection: filled node with label
GFXP->fillCircle(nx, ny, 6, NODES[i].color);
GFXP->fillCircle(nx, ny, 6, nd_.color);
GFXP->drawCircle(nx, ny, 6, TFT_BLACK);
GFXP->setTextDatum(TC_DATUM);
GFXP->setTextColor(nd::C_TEXT);
GFXP->drawString(NODES[i].label, nx, ny + 9);
GFXP->drawString(nd_.label, nx, ny + 9);
// cameras see farther: dotted ring marks their sight radius
if (NODES[i].sight > FOG_NODE_R) {
int r = NODES[i].sight * nd::TILE;
if (nd_.sight > FOG_NODE_R) {
int r = nd_.sight * nd::TILE;
GFXP->setTextColor(nd::C_CAMERA);
for (int a = 0; a < 360; a += 5) {
float rad = a * 3.14159f / 180.0f;
@@ -1591,14 +1620,14 @@ static void renderNetwork(bool full)
}
}
// door state on the door node
if (i == N_DOOR && nodeOnline[i]) {
if (i == DOOR_NODE && nodeOnline[i]) {
GFXP->setTextColor(doorOpen ? nd::C_GOOD : nd::C_TRACE);
GFXP->drawString(doorOpen ? "OPEN" : "SHUT", nx, ny + 19);
}
// ICE crack progress on the hive
if (i == N_HIVE) {
for (int k = 0; k < EDGE_COUNT; k++) {
if (links[k].active && links[k].b == N_HIVE && links[k].prog < links[k].dur) {
if (i == HIVE_NODE) {
for (int k = 0; k < eCount; k++) {
if (links[k].active && links[k].b == HIVE_NODE && links[k].prog < links[k].dur) {
GFXP->setTextColor(nd::C_TRACE);
GFXP->drawString("CRACKING", nx, ny + 19);
}
@@ -1626,10 +1655,10 @@ static void renderNetwork(bool full)
if (full) {
// determine which node ids are "available as connection sources"
// AIRLK is always online (starting node); others if nodeOnline
bool srcOnline[NODE_COUNT];
for (int s = 0; s < NODE_COUNT; s++) srcOnline[s] = nodeOnline[s];
bool srcOnline[nd::MAX_NODES];
for (int s = 0; s < nCount; s++) srcOnline[s] = nodeOnline[s];
// ensure AIRLK is always a source even if somehow offline
srcOnline[N_AIRLK] = true;
if (ROOT_NODE >= 0) srcOnline[ROOT_NODE] = true;
auto drawDottedLine = [&](int x0, int y0, int x1, int y1) {
int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
@@ -1645,11 +1674,11 @@ static void renderNetwork(bool full)
}
};
for (int s = 0; s < NODE_COUNT; s++) {
for (int s = 0; s < nCount; s++) {
if (!srcOnline[s]) continue;
// find edges where this node is one endpoint
for (int e = 0; e < EDGE_COUNT; e++) {
int a = EDGES[e][0], b = EDGES[e][1];
for (int e = 0; e < eCount; e++) {
int a = g_map->edge(e).a, b = g_map->edge(e).b;
if (a != s && b != s) continue;
int neighbor = (a == s) ? b : a;
// skip if neighbor already online (established connection — link already rendered above)
@@ -2002,6 +2031,7 @@ void setup()
#endif
drawBoot();
selectMap(false); // demo map by default; g_genSource for generated maps
resetScenario();
stateT0 = millis();
lastFrameMs = stateT0;
+48
View File
@@ -148,6 +148,54 @@ or press the advantage at the blast door. The frenzy timer decrements each
shared coordinate space so that a network link to the Droid Hive node directly
controls local droid behavior.
-->
### Map sources: generic MapSource interface (this change)
All map-specific data now lives behind one interface (`nd_mapsource.h`), so
the scenario populates its structures **once** (`selectMap()` →
`resetScenario()`) and never checks which map is active — the demo floorplan
and the random `MapGenerator` are interchangeable:
- **`nd_mapsource.h`** (new): `MapSource` abstract interface exposing tiles,
rooms/doors/cameras, the network graph (`NetNodeDef`/`NetEdgeDef` with
**roles** `NR_ROOT/NR_DOOR/NR_HIVE/NR_CAMERA` replacing the old hardcoded
`N_AIRLK/N_DOOR/N_HIVE` indices), and the entity spawn list
(`UnitSpawn`, marines first — slots 0/1 are the squad). Shared helpers:
role lookups (`rootNode()/hiveNode()/doorNode()`) and `findTile()` for the
`'A'`/`'T'` anchor tiles. Pool bounds `MAX_NODES`/`MAX_EDGES`.
- **`nd_demomap.h`** (rewritten): self-contained `DemoMapSource` — the real
24x40 demo grid (moved out of the sketch; the stale 19x38 array is gone),
demo node/edge/spawn tables, blast door + room regions. `isDemo()` and the
`setMapRows()` workaround were dropped as unnecessary.
- **`nd_mapgen.h`** (reworked): the generator now produces playable maps —
solid hull, carved rooms, **L-corridors between room centers** (full
walkable connectivity; corridor tiles recorded so crates never block a
link), doors only on walls that lead somewhere (with a deterministic
fallback so every room gets one), airlock pad `'A'` + objective terminal
`'T'` in the hive room, cover crates, and no unit letters written into the
tile grid (the old code wrote `'T'` for turrets — clashing with the
terminal). `GenMapSource` adapts the result to the interface: network graph
derived from the room chain (AIRLK root online, HIVE on the hive room,
DOOR node pinned to the hive door tile) and a marine-first spawn list with
droid patrol endpoints (spawn tile ↔ room center).
- **`NetDeck.ino`**: every map-source branch removed (`g_useDemoMap` is gone);
node/edge tables, spawn placement, terminal/airlock anchors, reinforcement
spawn point (near the blast door, hive side) and the win tile all come from
the active source. The red trace now follows the actual active-link path
(BFS HIVE→ROOT) instead of the hardcoded HIVE→JUNC→AIRLK segments; the
reinforcement droid uses the first slot after the spawn list.
- **Tests**: `MapTest.cpp` (standalone, also compiled into the firmware as
before) now validates 50 generated runs + the demo source through the
interface: room count, marine-first spawns, role nodes, graph connectivity
from the root, and a **flood-fill from the airlock** proving the terminal
and every spawn are reachable. New integration journey
`generated_map_source_journey` switches the running scenario to
`GenMapSource`, routes a link and steps combat, then restores the demo map.
Test node handles resolve via the source (`nodeByLabel` / role globals) —
no hardcoded indices left in the tests.
- Verified: `make netdeck` (both targets), `make netdeck-test` — 28 unit +
8 integration + 4 E2E journeys, 0 failures; plus a 2000-run generator fuzz
(all maps flood-connected, all role nodes present).
### Headless test structure
Tests live in `emulator/tests/` (see its README): **unit** +
+160
View File
@@ -0,0 +1,160 @@
/**
* @file nd_demomap.h
* @brief NetDeck — Breach & Board: demo map source.
*
* The hardcoded 3-room demo floorplan (airlock bottom-left, main corridor
* L-shaped middle, server room right) with its network graph and entity
* spawn list, all behind the generic MapSource interface. The demo map
* remains available for automated tests while the random MapGenerator is
* the default play map.
*
* Header-only: include from sketch or test harness.
*/
#pragma once
#include <cstdint>
#include <vector>
#include <string>
#include "nd_layout.h"
#include "nd_mapsource.h"
// ---------------------------------------------------------------------------
// Demo map: 40x24 tile coordinate space
// ---------------------------------------------------------------------------
// # = wall, . = floor, o = cover crate, + = blast door, A = airlock, T = terminal
// Airlock room (bottom-left), main corridor (L-shaped middle),
// server room (right). The '+' door at (28,12) is the Room2/Room3 blast door.
namespace nd {
static const char* const DEMO_MAP[TILE_ROWS] = {
"########################################",
"#.........#.................#..........#",
"#.........#......#..........#..........#",
"#...#.....#......#..........#.....o....#",
"#....o....#......#..........#..........#",
"#...#.....#......#..........#..........#",
"#.........#.................#..........#",
"#.........#.................#.....T....#",
"#...........................#..........#",
"#...........................#..........#",
"#.........#...#.....o.......#..........#",
"#.........#...#.............#..........#",
"#.........#.................+..........#",
"###########.................#..........#",
"#.........#.................#..........#",
"#....#....#...........o.....#....#.....#",
"#.........#.................#..........#",
"#...........................#..........#",
"#...........................#..........#",
"#.........#.....#...........#..........#",
"#.........#.....#...........#.....o....#",
"#.A.......#.................#..........#",
"#.........#.................#..........#",
"########################################",
};
// ---------------------------------------------------------------------------
// Demo tables (namespace scope, internal linkage — one copy per TU)
// ---------------------------------------------------------------------------
// Network graph: 7 nodes pinned to demo tiles. Roles replace the old
// hardcoded N_AIRLK/N_DOOR/N_HIVE indices.
static const int DEMO_NODE_COUNT = 7;
static const int DEMO_EDGE_COUNT = 6;
static const NetNodeDef DEMO_NODES[DEMO_NODE_COUNT] = {
{ "AIRLK", 4, 20, C_AIRLOCK, 3, true, NR_ROOT },
{ "JUNC", 18, 6, C_NODE, 3, false, NR_NONE },
{ "DOOR", 28, 12, C_DOOR, 3, false, NR_DOOR },
{ "HIVE", 35, 4, C_HIVE, 3, false, NR_HIVE },
{ "CAM1", 14, 2, C_CAMERA, 6, false, NR_CAMERA },
{ "CAM2", 31, 3, C_CAMERA, 6, false, NR_CAMERA },
{ "CAM3", 22, 18, C_CAMERA, 6, false, NR_CAMERA },
};
static const NetEdgeDef DEMO_EDGES[DEMO_EDGE_COUNT] = {
{ 0, 1, "AIRLK-JUNC" },
{ 1, 2, "JUNC-DOOR" },
{ 1, 3, "JUNC-HIVE" },
{ 1, 4, "JUNC-CAM1" },
{ 2, 5, "DOOR-CAM2" },
{ 4, 6, "CAM1-CAM3" },
};
// Entity spawn list — mirrors the demo encounter layout:
// 0,1 marines | 2 patrol droid | 3 stationary droid | 4 heavy |
// 5,6 turrets | 8,9,10 patrol/guard droids | 11 turret on the door approach
// (marines first — slots 0/1 are the squad)
static const int DEMO_SPAWN_COUNT = 11;
static const UnitSpawn DEMO_SPAWNS[DEMO_SPAWN_COUNT] = {
{ 0, 2, 21, -1, -1 }, // marine (at the airlock)
{ 0, 3, 21, -1, -1 }, // marine
{ 1, 12, 2, 12 + 2 * TILE_COLS, 26 + 18 * TILE_COLS, }, // corridor patrol
{ 1, 20, 12, -1, -1 }, // stationary droid
{ 2, 32, 10, -1, -1 }, // heavy (server room)
{ 3, 33, 5, -1, -1 }, // turret (terminal guard)
{ 3, 35, 5, -1, -1 }, // turret (terminal guard)
{ 1, 2, 2, 2 + 2 * TILE_COLS, 8 + 6 * TILE_COLS, }, // top-left patrol
{ 1, 31, 16, -1, -1 }, // server-room guard
{ 1, 14, 18, 13 + 18 * TILE_COLS, 25 + 18 * TILE_COLS, }, // corridor patrol
{ 3, 26, 10, -1, -1 }, // turret (door approach)
};
// ---------------------------------------------------------------------------
// DemoMapSource: everything map-specific about the demo scenario, in one place
// ---------------------------------------------------------------------------
class DemoMapSource : public MapSource {
public:
DemoMapSource() {
buildMapVector();
buildStructures();
}
// --- tile grid ---
char tileAt(int tx, int ty) const override {
if (tx < 0 || ty < 0 || tx >= TILE_COLS || ty >= TILE_ROWS) return '#';
return DEMO_MAP[ty][tx];
}
const std::vector<std::string>& getMap() const override { return mapVec_; }
// --- structures ---
const std::vector<Room>& getRooms() const override { return rooms_; }
const std::vector<Door>& getDoors() const override { return doors_; }
const std::vector<Camera>& getCameras() const override { return cameras_; }
// --- network graph ---
int nodeCount() const override { return DEMO_NODE_COUNT; }
const NetNodeDef& node(int i) const override { return DEMO_NODES[i]; }
int edgeCount() const override { return DEMO_EDGE_COUNT; }
const NetEdgeDef& edge(int i) const override { return DEMO_EDGES[i]; }
// --- entity spawn list ---
int spawnCount() const override { return DEMO_SPAWN_COUNT; }
const UnitSpawn& spawn(int i) const override { return DEMO_SPAWNS[i]; }
private:
void buildMapVector() {
mapVec_.reserve(TILE_ROWS);
for (int y = 0; y < TILE_ROWS; y++) mapVec_.emplace_back(DEMO_MAP[y]);
}
void buildStructures() {
rooms_.clear();
doors_.clear();
cameras_.clear();
Room r;
r = { 1, 14, 9, 21, 5, 17, 72 }; rooms_.push_back(r); // airlock
r = { 11, 1, 27, 21, 19, 11, 357 }; rooms_.push_back(r); // corridor
r = { 29, 1, 38, 12, 33, 6, 120 }; rooms_.push_back(r); // server room
Door d = { 28, 12, false, false, true }; // blast door
doors_.push_back(d);
}
std::vector<std::string> mapVec_;
// Demo room regions (informational: airlock / corridor / server)
std::vector<Room> rooms_;
std::vector<Door> doors_; // the Room2/Room3 blast door
std::vector<Camera> cameras_; // demo cameras live on the net (CAM1-3)
};
} // namespace nd
+540
View File
@@ -0,0 +1,540 @@
/**
* @file nd_mapgen.h
* @brief NetDeck — Breach & Board: random map generator + map source.
*
* Generates a random ship floorplan with rooms, connecting corridors,
* doors, cover crates, an airlock, the objective terminal, units, and a
* connected network graph in the shared 40x24 tile coordinate space. The
* result is exposed through the generic MapSource interface
* (nd_mapsource.h) via GenMapSource, so the scenario consumes generated
* and demo maps identically.
*
* Steps:
* 1. Start with a solid hull (all walls)
* 2. Pick 4-6 room regions and carve them out
* 3. Connect the rooms with L-shaped corridors
* 4. Place the airlock + 2 marines in the airlock room
* 5. Place the terminal + hive node + 1-4 enemy units in the hive room
* 6. Fill other rooms with 0-2 enemy units
* 7. Place 1-3 doors per room on walls that lead somewhere
* 8. Place cameras
* 9. Sprinkle cover crates
*
* Header-only: include from sketch or test harness.
*/
#pragma once
#include <cstdint>
#include <vector>
#include <algorithm>
#include <random>
#include <string>
#include "nd_layout.h"
#include "nd_mapsource.h"
namespace nd {
// ---------------------------------------------------------------------------
// Generator-internal unit record (converted to UnitSpawn by GenMapSource)
// ---------------------------------------------------------------------------
struct GenUnit {
int tx, ty; // tile coordinate
uint8_t kind; // unit type (0=marine, 1=droid, 2=heavy, 3=turret)
uint8_t team; // team (1=MARINE, 2=DROID)
bool alive;
};
// ---------------------------------------------------------------------------
// MapGenerator class
// ---------------------------------------------------------------------------
class MapGenerator {
public:
MapGenerator()
: rng_(std::random_device{}())
, distInt(0, 1000)
{
}
// Generate complete map in one call
void generate() {
createEmptyMap();
generateRooms(4, 6);
connectRooms();
placeAirlockAndMarines();
placeHiveAndEnemies(1, 4);
fillOtherRooms(0, 2);
placeDoors();
populateCameras(1, -1);
sprinkleCrates();
}
// Accessors
const std::vector<std::string>& getMap() const { return map_; }
char tileAt(int tx, int ty) const {
if (tx < 0 || ty < 0 || tx >= TILE_COLS || ty >= TILE_ROWS) return '#';
return map_[ty][tx];
}
const std::vector<Room>& getRooms() const { return rooms_; }
const std::vector<Door>& getDoors() const { return doors_; }
const std::vector<Camera>& getCameras() const { return cameras_; }
const std::vector<GenUnit>& getUnits() const { return units_; }
int getHiveRoomIdx() const { return hiveRoomIdx_; }
private:
std::vector<std::string> map_; // 24 strings of 40 chars
std::vector<Room> rooms_;
std::vector<Door> doors_;
std::vector<Camera> cameras_;
std::vector<GenUnit> units_;
std::vector<uint8_t> corridor_; // corridor tiles (crates must avoid)
int hiveRoomIdx_ = -1;
std::mt19937 rng_; // random number generator
std::uniform_int_distribution<int> distInt; // 0..1000 range
// Helper methods
bool floorWalkable(char t) const { return t == '.' || t == 'A' || t == 'T'; }
bool isWalkable(int tx, int ty) const {
if (tx < 0 || ty < 0 || tx >= TILE_COLS || ty >= TILE_ROWS) return false;
return floorWalkable(map_[ty][tx]);
}
int rnd(int n) { return distInt(rng_) % n; }
// ---------------------------------------------------------------------------
// Step 1: solid hull — everything starts as wall, rooms carve it open
// ---------------------------------------------------------------------------
void createEmptyMap() {
map_.assign(TILE_ROWS, std::string(TILE_COLS, '#'));
rooms_.clear();
doors_.clear();
cameras_.clear();
units_.clear();
hiveRoomIdx_ = -1;
}
// ---------------------------------------------------------------------------
// Step 2: 4-6 non-overlapping rooms carved out of the hull
// ---------------------------------------------------------------------------
void generateRooms(int minRooms, int maxRooms) {
int roomCount = minRooms + rnd(maxRooms - minRooms + 1);
rooms_.clear();
for (int i = 0; i < roomCount; i++) {
int w = 3 + rnd(10); // 3-12 wide
int h = 2 + rnd(7); // 2-8 high
int maxX = TILE_COLS - 3 - w;
int maxY = TILE_ROWS - 3 - h;
if (maxX < 3) { w = TILE_COLS - 6; maxX = 3; }
if (maxY < 2) { h = TILE_ROWS - 6; maxY = 2; }
int x = 2 + rnd(maxX);
int y = 2 + rnd(maxY);
Room r;
r.x0 = x;
r.y0 = y;
r.x1 = x + w - 1;
r.y1 = y + h - 1;
r.centerX = (r.x0 + r.x1) / 2;
r.centerY = (r.y0 + r.y1) / 2;
r.area = (r.x1 - r.x0 + 1) * (r.y1 - r.y0 + 1);
if (roomOverlaps(r)) { i--; continue; }
carveRoom(r);
}
}
// ---------------------------------------------------------------------------
// Step 3: L-shaped corridors between consecutive room centers guarantee
// full walkable connectivity (they punch doorways through the walls).
// Corridor tiles are recorded so crates never block a connection.
// ---------------------------------------------------------------------------
void connectRooms() {
corridor_.assign(TILE_COLS * TILE_ROWS, 0);
for (size_t i = 1; i < rooms_.size(); i++) {
const Room &a = rooms_[i - 1];
const Room &b = rooms_[i];
int x = b.centerX, y = b.centerY;
while (x != a.centerX) { carveTile(x, y); x += (a.centerX > x) ? 1 : -1; }
carveTile(x, y);
while (y != a.centerY) { y += (a.centerY > y) ? 1 : -1; carveTile(x, y); }
}
}
void carveTile(int x, int y) {
if (x <= 0 || y <= 0 || x >= TILE_COLS - 1 || y >= TILE_ROWS - 1) return;
map_[y][x] = '.';
corridor_[y * TILE_COLS + x] = 1;
}
// ---------------------------------------------------------------------------
// Step 4: airlock pad + 2 marines in room 0
// ---------------------------------------------------------------------------
void placeAirlockAndMarines() {
if (rooms_.empty()) return;
Room &ar = rooms_[0];
int ax = ar.centerX, ay = ar.centerY;
map_[ay][ax] = 'A'; // airlock pad
// two marines on the two nearest free floor tiles to the pad
int placed = 0;
for (int radius = 1; radius < TILE_COLS && placed < 2; radius++) {
for (int dy = -radius; dy <= radius && placed < 2; dy++) {
for (int dx = -radius; dx <= radius && placed < 2; dx++) {
if (dx != -radius && dx != radius && dy != -radius && dy != radius)
continue; // ring scan only
int tx = ax + dx, ty = ay + dy;
if (!isWalkable(tx, ty)) continue;
if (tileHasUnit(tx, ty)) continue;
GenUnit u;
u.tx = tx; u.ty = ty; u.kind = 0; u.team = 1; u.alive = true;
units_.push_back(u);
placed++;
}
}
}
}
bool tileHasUnit(int tx, int ty) const {
for (const auto &u : units_)
if (u.alive && u.tx == tx && u.ty == ty) return true;
return false;
}
// ---------------------------------------------------------------------------
// Step 5: objective terminal + hive room enemies (1-4)
// ---------------------------------------------------------------------------
void placeHiveAndEnemies(int enemyCountMin, int enemyCountMax) {
if (rooms_.size() < 2) return;
hiveRoomIdx_ = 1; // first room after the airlock room
Room &hr = rooms_[hiveRoomIdx_];
map_[hr.centerY][hr.centerX] = 'T'; // objective terminal
int enemyCount = enemyCountMin + rnd(enemyCountMax - enemyCountMin + 1);
for (int e = 0; e < enemyCount; e++) {
int tx = hr.x0 + rnd(hr.x1 - hr.x0 + 1);
int ty = hr.y0 + rnd(hr.y1 - hr.y0 + 1);
if (map_[ty][tx] != '.') continue;
if (tileHasUnit(tx, ty)) continue;
GenUnit u;
u.tx = tx; u.ty = ty;
u.kind = 1 + rnd(3); // droid / heavy / turret
u.team = 2;
u.alive = true;
units_.push_back(u);
}
}
// ---------------------------------------------------------------------------
// Step 6: 0-2 enemies per non-hive room (except the airlock room)
// ---------------------------------------------------------------------------
void fillOtherRooms(int minEnemies, int maxEnemies) {
for (size_t i = 1; i < rooms_.size(); i++) {
if ((int)i == hiveRoomIdx_) continue;
Room &r = rooms_[i];
int enemyCount = minEnemies + rnd(maxEnemies - minEnemies + 1);
for (int e = 0; e < enemyCount; e++) {
int tx = r.x0 + rnd(r.x1 - r.x0 + 1);
int ty = r.y0 + rnd(r.y1 - r.y0 + 1);
if (map_[ty][tx] != '.') continue;
if (tileHasUnit(tx, ty)) continue;
GenUnit u;
u.tx = tx; u.ty = ty;
u.kind = 1 + rnd(3);
u.team = 2;
u.alive = true;
units_.push_back(u);
}
}
}
// ---------------------------------------------------------------------------
// Step 7: 1-3 doors per room, only on walls that actually lead somewhere
// ---------------------------------------------------------------------------
void placeDoors() {
for (size_t ri = 0; ri < rooms_.size(); ri++) {
const Room &r = rooms_[ri];
int doorCount = 1 + rnd(3);
int tries = 12;
int placed = 0;
while (placed < doorCount && tries-- > 0) {
int wall = rnd(4);
int tx, ty, ox = 0, oy = 0; // (ox,oy) points outside the room
switch (wall) {
case 0: tx = r.x0 + rnd(r.x1 - r.x0 + 1); ty = r.y0; oy = -1; break;
case 1: tx = r.x0 + rnd(r.x1 - r.x0 + 1); ty = r.y1; oy = 1; break;
case 2: tx = r.x0; ty = r.y0 + rnd(r.y1 - r.y0 + 1); ox = -1; break;
default: tx = r.x1; ty = r.y0 + rnd(r.y1 - r.y0 + 1); ox = 1; break;
}
if (map_[ty][tx] != '.') continue; // not free floor
if (!isWalkable(tx + ox, ty + oy)) continue; // dead end beyond
if (doorNear(tx, ty)) continue; // too close to another
placeDoorTile(tx, ty, (int)ri);
placed++;
}
if (placed == 0) {
// deterministic fallback: the corridor connection always
// crosses this room's boundary — scan for a usable tile
for (int y = r.y0; y <= r.y1 && placed == 0; y++) {
for (int x = r.x0; x <= r.x1 && placed == 0; x++) {
bool edge = (x == r.x0 || x == r.x1 || y == r.y0 || y == r.y1);
if (!edge || map_[y][x] != '.') continue;
static const int DX[4] = { 1, -1, 0, 0 };
static const int DY[4] = { 0, 0, 1, -1 };
for (int d = 0; d < 4; d++) {
if (isWalkable(x + DX[d], y + DY[d]) && !doorNear(x, y)) {
placeDoorTile(x, y, (int)ri);
placed++;
break;
}
}
}
}
}
}
}
void placeDoorTile(int tx, int ty, int roomIdx) {
Door d;
d.tx = tx; d.ty = ty;
d.open = false;
d.isAirlock = false;
d.isHive = (roomIdx == hiveRoomIdx_);
doors_.push_back(d);
map_[ty][tx] = '+';
}
bool doorNear(int tx, int ty) const {
for (const auto &d : doors_) {
if (abs(d.tx - tx) <= 1 && abs(d.ty - ty) <= 1) return true;
}
return false;
}
// ---------------------------------------------------------------------------
// Step 8: cameras on room edges / centers (network overlay only — no map char)
// ---------------------------------------------------------------------------
void populateCameras(int cameraCountMin, int cameraCountMax) {
if (rooms_.empty()) return;
if (cameraCountMax < 0) cameraCountMax = (int)rooms_.size() * 2;
if (cameraCountMin < 0) cameraCountMin = 1;
int cameraCount = cameraCountMin + rnd(cameraCountMax - cameraCountMin + 1);
for (int c = 0; c < cameraCount; c++) {
const Room &r = rooms_[rnd((int)rooms_.size())];
int placeType = rnd(3); // 0=top, 1=bottom, 2=center
Camera cam;
cam.id = (int)cameras_.size() + 1;
cam.color = C_CAMERA;
switch (placeType) {
case 0: cam.tx = r.x0 + rnd(r.x1 - r.x0 + 1); cam.ty = r.y0; break;
case 1: cam.tx = r.x0 + rnd(r.x1 - r.x0 + 1); cam.ty = r.y1; break;
default: cam.tx = r.centerX; cam.ty = r.centerY; break;
}
bool already = std::any_of(cameras_.begin(), cameras_.end(),
[&](const Camera &other) {
return other.tx == cam.tx && other.ty == cam.ty;
});
if (!already) cameras_.push_back(cam);
}
}
// ---------------------------------------------------------------------------
// Step 9: cover crates on free room floor (never adjacent to a door)
// ---------------------------------------------------------------------------
void sprinkleCrates() {
for (const Room &r : rooms_) {
if (rnd(4) == 0) continue; // some rooms stay clear
int tx = r.x0 + rnd(r.x1 - r.x0 + 1);
int ty = r.y0 + rnd(r.y1 - r.y0 + 1);
if (map_[ty][tx] != '.') continue;
if (corridor_[ty * TILE_COLS + tx]) continue; // never block a corridor
if (doorNear(tx, ty)) continue;
if (tileHasUnit(tx, ty)) continue;
map_[ty][tx] = 'o';
}
}
bool roomOverlaps(const Room &r) const {
for (const auto &other : rooms_) {
if (r.x0 < other.x1 && r.x1 > other.x0 &&
r.y0 < other.y1 && r.y1 > other.y0) {
return true;
}
}
if (r.x0 < 2 || r.y0 < 2 || r.x1 > TILE_COLS - 2 || r.y1 > TILE_ROWS - 2) {
return true;
}
return false;
}
void carveRoom(Room &r) {
for (int y = r.y0; y <= r.y1; y++) {
for (int x = r.x0; x <= r.x1; x++) {
if (x > 0 && x < TILE_COLS - 1 && y > 0 && y < TILE_ROWS - 1) {
map_[y][x] = '.';
}
}
}
rooms_.push_back(r);
}
};
// ---------------------------------------------------------------------------
// GenMapSource: exposes a generated MapGenerator map through the generic
// MapSource interface. Derives the network graph (nodes + spanning edges)
// from the room layout and converts the generator's units into a spawn list.
// ---------------------------------------------------------------------------
class GenMapSource : public MapSource {
public:
explicit GenMapSource(MapGenerator &gen) : gen_(gen) {}
// (Re)generate the underlying map and rebuild the derived structures.
void generate() {
gen_.generate();
buildNetwork();
buildSpawns();
}
// --- tile grid ---
char tileAt(int tx, int ty) const override { return gen_.tileAt(tx, ty); }
const std::vector<std::string>& getMap() const override { return gen_.getMap(); }
// --- structures ---
const std::vector<Room>& getRooms() const override { return gen_.getRooms(); }
const std::vector<Door>& getDoors() const override { return gen_.getDoors(); }
const std::vector<Camera>& getCameras() const override { return gen_.getCameras(); }
// --- network graph ---
int nodeCount() const override { return (int)nodes_.size(); }
const NetNodeDef& node(int i) const override { return nodes_[i]; }
int edgeCount() const override { return (int)edges_.size(); }
const NetEdgeDef& edge(int i) const override { return edges_[i]; }
// --- entity spawn list ---
int spawnCount() const override { return (int)spawns_.size(); }
const UnitSpawn& spawn(int i) const override { return spawns_[i]; }
private:
MapGenerator &gen_;
std::vector<NetNodeDef> nodes_;
std::vector<NetEdgeDef> edges_;
std::vector<UnitSpawn> spawns_;
// Network graph: AIRLK root at the airlock room, one node per room
// (the hive room's node is the HIVE), plus a DOOR node pinned to the
// hive door tile. Edges chain the rooms and hang the door off the hive.
void buildNetwork() {
nodes_.clear();
edges_.clear();
const std::vector<Room> &rooms = gen_.getRooms();
if (rooms.empty()) return;
static char labelBuf[MAX_NODES][8]; // stable storage for "N<k>" labels
int nextLabel = 0;
int hiveNodeIdx = -1;
int doorNodeIdx = -1;
for (size_t i = 0; i < rooms.size(); i++) {
int tx = rooms[i].centerX;
int ty = rooms[i].centerY;
if (i == 0) {
nodes_.push_back({ "AIRLK", tx, ty, C_AIRLOCK, 3, true, NR_ROOT });
} else if ((int)i == gen_.getHiveRoomIdx()) {
nodes_.push_back({ "HIVE", tx, ty, C_HIVE, 3, false, NR_HIVE });
hiveNodeIdx = (int)nodes_.size() - 1;
} else {
// "N<k>" with k = node index (manual itoa: toolchain-safe)
char *buf = labelBuf[nextLabel++ % MAX_NODES];
buf[0] = 'N';
int v = (int)nodes_.size(), len = 1;
if (v >= 10) buf[len++] = (char)('0' + v / 10);
buf[len++] = (char)('0' + v % 10);
buf[len] = '\0';
nodes_.push_back({ buf, tx, ty, C_NODE, 3, false, NR_NONE });
}
}
// door node pinned to the hive door tile (falls back to any door)
const std::vector<Door> &doors = gen_.getDoors();
int doorIdx = -1;
for (size_t d = 0; d < doors.size(); d++) {
if (doors[d].isHive) { doorIdx = (int)d; break; }
}
if (doorIdx < 0 && !doors.empty()) doorIdx = 0;
if (doorIdx >= 0) {
nodes_.push_back({ "DOOR", doors[doorIdx].tx, doors[doorIdx].ty,
C_DOOR, 3, false, NR_DOOR });
doorNodeIdx = (int)nodes_.size() - 1;
}
// edges: room chain + door hanging off the hive node
for (size_t i = 1; i < nodes_.size(); i++) {
if (i == (size_t)doorNodeIdx) continue; // door handled below
edges_.push_back({ (uint8_t)(i - 1), (uint8_t)i, edgeLabel(i - 1, (int)i) });
}
if (hiveNodeIdx >= 0 && doorNodeIdx >= 0) {
edges_.push_back({ (uint8_t)hiveNodeIdx, (uint8_t)doorNodeIdx,
edgeLabel(hiveNodeIdx, doorNodeIdx) });
}
}
const char* edgeLabel(int a, int b) {
static char buf[MAX_EDGES][24];
static int next = 0;
char *out = buf[next % MAX_EDGES];
next++;
const char *la = nodes_[a].label;
const char *lb = nodes_[b].label;
int p = 0;
while (*la && p < 10) out[p++] = *la++;
out[p++] = '-';
while (*lb && p < 22) out[p++] = *lb++;
out[p] = '\0';
return out;
}
// Spawn list: marines first (slots 0/1 are the squad), then the garrison.
// Droids patrol between their spawn tile and their room's center.
void buildSpawns() {
spawns_.clear();
const std::vector<GenUnit> &units = gen_.getUnits();
const std::vector<Room> &rooms = gen_.getRooms();
// marines first
for (const auto &u : units) {
if (u.kind != 0) continue;
spawns_.push_back({ u.kind, u.tx, u.ty, -1, -1 });
}
for (const auto &u : units) {
if (u.kind == 0) continue;
UnitSpawn s;
s.kind = u.kind;
s.tx = u.tx;
s.ty = u.ty;
s.patA = s.patB = -1;
if (u.kind == 1) { // droids patrol spawn tile <-> room center
const Room *room = roomAt(u.tx, u.ty, rooms);
if (room) {
int a = u.ty * TILE_COLS + u.tx;
int b = room->centerY * TILE_COLS + room->centerX;
if (a != b) { s.patA = a; s.patB = b; }
}
}
spawns_.push_back(s);
}
}
static const Room* roomAt(int tx, int ty, const std::vector<Room> &rooms) {
for (const auto &r : rooms)
if (tx >= r.x0 && tx <= r.x1 && ty >= r.y0 && ty <= r.y1) return &r;
return nullptr;
}
};
} // namespace nd
+137
View File
@@ -0,0 +1,137 @@
/**
* @file nd_mapsource.h
* @brief NetDeck — Breach & Board: generic map source interface.
*
* One interface for everything that is map-specific: the tile grid, the
* structural elements (rooms, doors, cameras), the network graph (nodes +
* edges) and the entity spawn list. A scenario populates its runtime
* structures from a MapSource exactly once and afterwards never needs to
* know (or check) where the map came from — the hardcoded demo floorplan
* and the random MapGenerator are interchangeable behind the interface.
*
* Header-only: include from sketch or test harness.
*/
#pragma once
#include <cstdint>
#include <vector>
#include <string>
#include "nd_layout.h"
namespace nd {
// ---------------------------------------------------------------------------
// Pool bounds for source-driven structures (sized for the worst generated map)
// ---------------------------------------------------------------------------
constexpr int MAX_NODES = 12; // network nodes across any map source
constexpr int MAX_EDGES = 16; // network edges across any map source
// ---------------------------------------------------------------------------
// Special node roles (replace the old hardcoded N_AIRLK/N_DOOR/N_HIVE indices)
// ---------------------------------------------------------------------------
enum NodeRole : uint8_t {
NR_NONE = 0, // plain junction node
NR_ROOT, // airlock uplink: always online, trace endpoint
NR_DOOR, // click toggles the blast door(s)
NR_HIVE, // ICE-protected hive: cracking spawns the red trace
NR_CAMERA, // camera: larger fog-of-war reveal radius while online
};
// ---------------------------------------------------------------------------
// Shared data structures (one shape for every map source)
// ---------------------------------------------------------------------------
struct Room {
int x0, y0; // top-left corner (inclusive)
int x1, y1; // bottom-right corner (inclusive)
int centerX; // center tile coordinate
int centerY;
int area; // number of floor tiles
};
struct Door {
int tx, ty; // tile coordinate ('+' on the map)
bool open; // whether the door starts open
bool isAirlock; // true if this is the airlock door
bool isHive; // true if this door leads to the hive room
};
struct Camera {
int tx, ty; // tile coordinate
int id; // camera ID
uint16_t color; // render color (C_CAMERA)
};
// A network node as the scenario consumes it (static definition — the
// runtime online state lives in the scenario, not here)
struct NetNodeDef {
const char* label;
int tx, ty; // tile position
uint16_t color; // render color
uint8_t sight; // fog reveal radius (tiles) while online
bool online; // initial online state (root = true)
uint8_t role; // NodeRole
};
struct NetEdgeDef {
uint8_t a, b; // node indices
const char* label; // "AIRLK-JUNC" style, for logs
};
// One entity spawn: applied by the scenario layer once at setup/reset.
// kind uses the shared unit taxonomy: 0=marine, 1=droid, 2=heavy, 3=turret.
struct UnitSpawn {
uint8_t kind;
int tx, ty;
int patA, patB; // patrol endpoints as tile indices (-1 = stationary)
};
// ---------------------------------------------------------------------------
// MapSource abstract interface
// ---------------------------------------------------------------------------
class MapSource {
public:
virtual ~MapSource() = default;
// --- tile grid ---
virtual char tileAt(int tx, int ty) const = 0;
virtual const std::vector<std::string>& getMap() const = 0;
// --- structures ---
virtual const std::vector<Room>& getRooms() const = 0;
virtual const std::vector<Door>& getDoors() const = 0;
virtual const std::vector<Camera>& getCameras() const = 0;
// --- network graph ---
virtual int nodeCount() const = 0;
virtual const NetNodeDef& node(int i) const = 0;
virtual int edgeCount() const = 0;
virtual const NetEdgeDef& edge(int i) const = 0;
// --- entity spawn list ---
virtual int spawnCount() const = 0;
virtual const UnitSpawn& spawn(int i) const = 0;
// --- role lookups (shared implementation; -1 if the map has no such node)
int nodeByRole(uint8_t role) const {
for (int i = 0; i < nodeCount(); i++)
if (node(i).role == role) return i;
return -1;
}
int rootNode() const { return nodeByRole(NR_ROOT); }
int hiveNode() const { return nodeByRole(NR_HIVE); }
int doorNode() const { return nodeByRole(NR_DOOR); }
// First tile carrying `ch` (e.g. 'T' terminal, 'A' airlock); -1 if absent.
// Scans the tile grid, so it works for every source without branching.
bool findTile(char ch, int& tx, int& ty) const {
const std::vector<std::string>& m = getMap();
for (int y = 0; y < TILE_ROWS && y < (int)m.size(); y++) {
for (int x = 0; x < TILE_COLS && x < (int)m[y].size(); x++) {
if (m[y][x] == ch) { tx = x; ty = y; return true; }
}
}
return false;
}
};
} // namespace nd