Files
Dejvino b38d5d4b56 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)
2026-11-15 18:21:35 +01:00

522 lines
22 KiB
C++

/**
* @file unit_tests.h
* @brief Unit tests: pure sketch logic in isolation (map queries, LOS,
* pathfinding, cover, link state machine, combat rules, flow
* transitions). No rendering, no input pipeline, no wall time —
* determinism comes from freshScenario()'s fixed RNG seed.
*
* Included by test_main.cpp AFTER the sketch, so sketch statics are visible.
*/
#include "sim_helpers.h"
// --- map queries -----------------------------------------------------------
TEST(unit/map_queries)
{
freshScenario();
EXPECT_EQ(tileAt(-1, 0), '#'); // out of bounds = wall
EXPECT_EQ(tileAt(40, 0), '#');
EXPECT_EQ(tileAt(28, 12), '+'); // the blast door tile
EXPECT(!walkable(0, 0)); // '#'
EXPECT(walkable(20, 12)); // corridor floor
EXPECT(walkable(2, 21)); // airlock 'A'
EXPECT(walkable(34, 7)); // objective terminal 'T'
EXPECT(blocksSight(0, 0));
EXPECT(!blocksSight(20, 12));
EXPECT_EQ(nd::DEMO_MAP[7][34], 'T'); // the win tile really is T
}
TEST(unit/door_gates_movement_and_sight)
{
freshScenario();
EXPECT(!walkable(28, 12)); // closed door blocks movement
EXPECT(blocksSight(28, 12)); // ... and sight
doorOpen = true;
EXPECT(walkable(28, 12));
EXPECT(!blocksSight(28, 12));
doorOpen = false;
EXPECT(!walkable(28, 12));
}
// --- line of sight ---------------------------------------------------------
TEST(unit/los_wall_and_door)
{
freshScenario();
EXPECT(losClear(1, 1, 9, 1)); // along open floor
EXPECT(!losClear(1, 1, 11, 1)); // wall at col 10
EXPECT(!losClear(27, 12, 29, 12)); // through CLOSED door
doorOpen = true;
EXPECT(losClear(27, 12, 29, 12)); // through OPEN door
doorOpen = false;
}
// --- pathfinding -----------------------------------------------------------
TEST(unit/bfs_door_gates_the_route)
{
freshScenario();
int path[64];
EXPECT_EQ(bfsPath(2, 21, 34, 7, path, 64), -1); // no route, door closed
doorOpen = true;
int n = bfsPath(2, 21, 34, 7, path, 64);
EXPECT(n > 0);
for (int i = 0; i < n; i++) { // every step walkable
int t = path[i];
EXPECT(walkable(t % nd::TILE_COLS, t / nd::TILE_COLS));
}
EXPECT_EQ(bfsPath(2, 21, 0, 0, path, 64), -1); // wall target unreachable
}
TEST(unit/bfs_respects_capacity)
{
freshScenario();
doorOpen = true;
int path[4]; // tiny buffer
EXPECT_EQ(bfsPath(2, 21, 34, 7, path, 4), -1); // longer than cap -> fail
}
// --- cover -----------------------------------------------------------------
TEST(unit/cover_rule)
{
freshScenario();
spawnUnit(6, U_DROID, 4, 4); // beside the crate at (5,4)
EXPECT(inCover(6));
spawnUnit(6, U_DROID, 20, 10); // open corridor floor
EXPECT(!inCover(6));
}
// --- link state machine ------------------------------------------------------
TEST(unit/link_routing_and_online)
{
freshScenario();
tryLink(N_JUNC); // AIRLK root is online
int l = linkIdx(0); // edge AIRLK-JUNC
EXPECT(l >= 0);
EXPECT(!nodeOnline[N_JUNC]); // offline while building
stepTicks(LINK_TICKS);
EXPECT(nodeOnline[N_JUNC]); // up after 1.5 s of ticks
tryLink(N_DOOR);
stepTicks(LINK_TICKS);
EXPECT(nodeOnline[N_DOOR]);
}
TEST(unit/link_rejects_non_adjacent)
{
freshScenario();
tryLink(N_HIVE); // not adjacent to AIRLK
EXPECT_EQ(strcmp(msgText, "NO UPLINK"), 0);
EXPECT(linkIdx(2) < 0); // JUNC-HIVE not routed
}
TEST(unit/sever_cascades_downstream)
{
freshScenario();
tryLink(N_JUNC); stepTicks(LINK_TICKS);
tryLink(N_DOOR); stepTicks(LINK_TICKS);
tryLink(N_HIVE); stepTicks(ICE_TICKS);
EXPECT(nodeOnline[N_HIVE]);
int door = linkIdx(1); // JUNC-DOOR
severLink(door);
EXPECT(!nodeOnline[N_DOOR]);
EXPECT(nodeOnline[N_JUNC]); // upstream survives
EXPECT(linkIdx(1) < 0);
}
// regression: link slots are not edge indices. Routing out-of-order edges
// (JUNC-CAM1 = edge 3 lands in slot 1) used to make linkOnEdge(JUNC-DOOR)
// see slot 1 active and refuse the door link with "LINKING..." forever.
TEST(unit/link_slots_dont_shadow_edges)
{
freshScenario();
tryLink(N_JUNC); stepTicks(LINK_TICKS); // edge 0 -> slot 0
tryLink(N_CAM1); stepTicks(LINK_TICKS); // edge 3 -> slot 1
tryLink(N_CAM3); stepTicks(LINK_TICKS); // edge 5 -> slot 2
tryLink(N_DOOR); // edge 1 must still route
EXPECT(linkIdx(1) >= 0);
stepTicks(LINK_TICKS);
EXPECT(nodeOnline[N_DOOR]);
EXPECT(!doorOpen);
tryLink(N_DOOR); // online DOOR toggles
EXPECT(doorOpen);
}
// --- trace / feedback / reinforcement ---------------------------------------
TEST(unit/ice_trace_feedback_reinforcement)
{
freshScenario();
tryLink(N_JUNC); stepTicks(LINK_TICKS);
tryLink(N_HIVE); stepTicks(ICE_TICKS);
EXPECT(hiveCracked);
EXPECT(traceActive); // red trace inbound
stepTicks(TRACE_TICKS); // trace reaches AIRLK
EXPECT(!traceActive);
EXPECT(heatT > 0 && heatT <= HEAT_TICKS); // OVERHEAT lockout engaged
EXPECT(linkIdx(0) < 0 && linkIdx(1) < 0 && linkIdx(2) < 0);
EXPECT(!nodeOnline[N_JUNC]); // everything past root drops
EXPECT(nodeOnline[N_AIRLK]);
EXPECT(units[g_reinforceIdx].alive); // reinforcement droid spawned
}
TEST(unit/overheat_gates_daemons_and_sever)
{
freshScenario();
heatT = HEAT_TICKS;
handleKey('1');
EXPECT_EQ(strcmp(msgText, "OVERHEAT"), 0);
handleKey('x');
EXPECT_EQ(strcmp(msgText, "OVERHEAT"), 0);
stepTicks(HEAT_TICKS);
EXPECT_EQ(heatT, 0); // lockout expires
}
// --- combat rules ------------------------------------------------------------
TEST(unit/target_acquisition_needs_range_and_los)
{
freshScenario();
spawnUnit(6, U_MARINE, 5, 7);
spawnUnit(0, U_DROID, 20, 12); // far outside marine range
spawnUnit(1, U_DROID, 8, 7); // same room, clear LOS
EXPECT_EQ(acquireTarget(6), 1);
units[1].tx = 11; units[1].ty = 7; // still in range (6 tiles)
EXPECT_EQ(acquireTarget(6), -1); // but the col-10 wall at
// row 7 blocks sight
}
TEST(unit/win_and_loss_transitions)
{
freshScenario();
for (int i = 2; i < 7; i++) // clear the terminal guards:
if (units[i].alive) unitKill(i); // no target -> marine walks
beaconTX = 34; beaconTY = 7;
units[0].tx = 33; units[0].ty = 7; // adjacent, path in
stepTicks(1); // arrive -> BREACH SUCCESS
EXPECT_EQ(scenario, SC_WIN);
freshScenario();
unitKill(0);
unitKill(1);
stepTicks(1);
EXPECT_EQ(scenario, SC_LOSS);
}
TEST(unit/reset_rearms_everything)
{
freshScenario();
units[0].tx = 34; units[0].ty = 7;
stepTicks(1); // -> SC_WIN mess
resetScenario();
EXPECT_EQ(scenario, SC_LIVE);
EXPECT(paused);
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[g_reinforceIdx].alive); // reinforcement slot cleared
EXPECT(!doorOpen);
EXPECT_EQ(heatT, 0);
EXPECT(linkIdx(0) < 0 && linkIdx(1) < 0 && linkIdx(2) < 0);
EXPECT(nodeOnline[N_AIRLK]); // the old root-online bug
EXPECT(!nodeOnline[N_JUNC] && !nodeOnline[N_DOOR] && !nodeOnline[N_HIVE]);
}
// Enemies outside the hive sphere of influence should not be impacted by frenzy
TEST(unit/frenzy_hive_sphere_influence)
{
// HIVE node is at tile (35, 4), FRENZY_RADIUS = 6 tiles.
// Sphere covers tiles within 6 tiles of (35, 4).
// (12, 2) is ~23 tiles from HIVE — outside the frenzy sphere.
// (20, 12) is ~17 tiles from HIVE — outside the frenzy sphere.
// (32, 10) is ~3.6 tiles from HIVE — inside the frenzy sphere.
// (33, 5) is ~2.2 tiles from HIVE — inside the frenzy sphere.
freshScenario();
// Droid at (12, 2) — outside HIVE frenzy sphere (default droid position)
// Unit 2 is already a droid at (12, 2) from freshScenario()
// Enemy droid at (20, 12) — outside HIVE frenzy sphere (default droid at unit 3)
// Unit 3 is already a droid at (20, 12) from freshScenario()
frenzyT = 300; // activate Frenzy.EXE
// With frenzy active: droid at (12,2) should NOT target droid at (20,12)
// because the enemy is outside the HIVE sphere of influence.
// Without the fix, this would incorrectly target the enemy.
EXPECT_EQ(acquireTarget(2), -1);
// Without frenzy: droid at (12,2) should target droid at (20,12)
// since it's within range and LOS, and not marine.
frenzyT = 0;
// Note: may or may not acquire target depending on LOS, but the key test
// is that with frenzy + outside sphere, target is rejected.
}
// --- fog of war (DESIGN.md §5.D) -------------------------------------------
// tile helpers for fog assertions
static bool fogNowAt(int tx, int ty) { return fogNow[tileIdx(tx, ty)] != 0; }
static bool fogSeenAt(int tx, int ty) { return fogSeen[tileIdx(tx, ty)] != 0; }
TEST(unit/fog_initial_reveal_from_los_and_airlock_node)
{
freshScenario();
// marines in the airlock: their LOS window + the always-online AIRLK
// node uncover the airlock room; the rest of the ship is unknown
EXPECT(fogNowAt(2, 21)); // under marine 0
EXPECT(fogNowAt(3, 21)); // under marine 1
EXPECT(fogNowAt(4, 20)); // AIRLK node tile
EXPECT(fogNowAt(4, 18)); // room interior, marine LOS
EXPECT(fogNowAt(4, 20) == fogSeenAt(4, 20)); // current implies historical
// far side of the ship stays unknown until the squad gets there
EXPECT(!fogSeenAt(35, 7)); // server room near terminal
EXPECT(!fogSeenAt(36, 2)); // HIVE corner
// every currently-visible tile is also historical
for (int i = 0; i < nd::TILE_COLS * nd::TILE_ROWS; i++)
if (fogNow[i]) EXPECT(fogSeen[i]);
}
TEST(unit/fog_walls_block_sight_but_faces_render)
{
freshScenario();
// a closed blast door seen from the corridor: the door tile itself
// renders (ray target), the server room behind it stays unknown
for (int i = 0; i < nd::TILE_COLS * nd::TILE_ROWS; i++) {
fogNow[i] = 0;
fogSeen[i] = 0;
}
revealLos(26, 12, FOG_SIGHT_R); // corridor, 2 tiles west of door
EXPECT(fogNowAt(27, 12)); // floor in front of the door
EXPECT(fogNowAt(28, 12)); // door tile itself (ray target)
EXPECT(fogSeenAt(28, 11)); // wall face beside it renders
EXPECT(!fogSeenAt(29, 12)); // behind the closed door: blocked
// and a plain wall segment blocks mid-ray
EXPECT(fogSeenAt(24, 12));
EXPECT(!fogSeenAt(31, 12)); // server room interior
}
TEST(unit/fog_historical_persists_after_losing_sight)
{
freshScenario();
// teleport marine 0 deep into the corridor and re-derive the fog:
// tiles the airlock used to see stay historical, but stop being current
EXPECT(fogNowAt(2, 14)); // visible from marine 0
units[0].tx = 20; units[0].ty = 12; // corridor droid's old spot
units[1].alive = false; // isolate marine 0's window
updateFog();
EXPECT(fogNowAt(20, 12)); // new position visible
// the airlock room: the online AIRLK node (4,20) keeps ITS connected
// tiles current, but tiles only the marine used to see go historical
EXPECT(fogNowAt(4, 20)); // node-connected: still lit
EXPECT(!fogNowAt(2, 14)); // out of every sight window...
EXPECT(fogSeenAt(2, 14)); // ...but remembered (grayscale)
// fresh LOS from the corridor reveals corridor tiles, not the server room
EXPECT(fogNowAt(18, 12));
EXPECT(!fogSeenAt(34, 7)); // terminal still unknown
}
TEST(unit/fog_online_nodes_uncover_connected_tiles)
{
freshScenario();
// JUNC at (18,6) is unknown until its link goes up
EXPECT(!fogSeenAt(18, 6));
tryLink(N_JUNC); // AIRLK root is online
stepTicks(LINK_TICKS); // link build completes
EXPECT(nodeOnline[N_JUNC]);
EXPECT(fogNowAt(18, 6)); // node tile uncovered
EXPECT(fogNowAt(17, 6)); // connected room surroundings
// HIVE side stays unknown
EXPECT(!fogSeenAt(35, 4));
// severing the link: JUNC tiles drop from current but stay historical
int li = linkIdx(0);
severLink(li);
updateFog();
EXPECT(!nodeOnline[N_JUNC]);
EXPECT(!fogNowAt(18, 6));
EXPECT(fogSeenAt(18, 6)); // historical (grayscale) memory
}
// cameras see farther than plain nodes: FOG_CAM_R=6 vs FOG_NODE_R=3.
// CAM1 sits at (14,2) behind JUNC; its online reveal must reach 6 tiles
// down the open col-14 corridor but no farther.
TEST(unit/fog_camera_sees_farther)
{
freshScenario();
EXPECT(!fogSeenAt(14, 2)); // CAM1 unknown initially
handleKey('p'); // Network view
clickNode(N_JUNC); stepTicks(LINK_TICKS); // get CAM1 a uplink
clickNode(N_CAM1); stepTicks(LINK_TICKS);
EXPECT(nodeOnline[N_CAM1]);
EXPECT(fogNowAt(14, 8)); // 6 tiles out: camera lit
EXPECT(!fogSeenAt(14, 9)); // 7 tiles out: beyond sight
}
TEST(unit/fog_gray565_is_neutral_and_clamped)
{
uint16_t w = gray565(0xFFFF); // white -> white-ish gray
EXPECT_EQ((w >> 11) & 0x1F, w & 0x1F); // red == blue channel
EXPECT_EQ((w >> 5) & 0x3F, 2 * ((w >> 11) & 0x1F)); // green is double-wide
uint16_t g = gray565(nd::C_HIVE); // magenta -> neutral gray
EXPECT_EQ((g >> 11) & 0x1F, g & 0x1F); // red == blue channel
EXPECT(g != nd::C_HIVE); // hue removed
EXPECT_EQ(gray565(0x0000), 0x0000); // black stays black
}
// fog sight must cover the marines' fire range: acquireTarget() uses the
// same losClear ray, so anything a marine can shoot at must be revealed —
// regression for marines shooting into darkness (fog radius < fire range)
TEST(unit/fog_sight_covers_marine_fire_range)
{
freshScenario();
units[0].tx = 20; units[0].ty = 12; // open corridor
units[1].alive = false;
updateFog();
// (12,12) is exactly 8.0 tiles west along open row 12 = STATS marine
// range boundary: dx^2+dy^2 = 64 = rng2/4 — must be revealed
EXPECT(fogNowAt(12, 12));
// (11,12) is 9.0 tiles out — beyond the fire range, stays dark
EXPECT(!fogSeenAt(11, 12));
// and the revealed tiles can actually host a targetable enemy
// Marine at (20,12) acquires a target within range + LOS
EXPECT(acquireTarget(0) >= 0); // marine acquires a target in light
}
// --- emulator shim: GPIO-matrix pin ownership ------------------------------
// Parity tests for the pin model that reproduces hardware-only bugs here:
// a peripheral driver (i2s_set_pin, ...) claims a pin and drives it, so an
// input/ISR on the same GPIO stops seeing the outside world. Regression for
// the sound engine silently claiming GPIO0 (MCLK-capable!) and killing the
// trackball click line on the device while every emulator build looked fine.
TEST(unit/shim_claimed_pin_is_dead_input)
{
test::resetInput();
emu::releasePin(BOARD_BOOT_PIN);
EXPECT_EQ(digitalRead(BOARD_BOOT_PIN), HIGH); // free pulled-up input
emu::claimPin(BOARD_BOOT_PIN, "test MCLK");
EXPECT(digitalRead(BOARD_BOOT_PIN) == LOW); // driven line, idles low
emu::setPin(BOARD_BOOT_PIN, HIGH); // the outside world...
EXPECT(digitalRead(BOARD_BOOT_PIN) == LOW); // ...cannot move it
emu::releasePin(BOARD_BOOT_PIN); // peripheral released
EXPECT_EQ(digitalRead(BOARD_BOOT_PIN), HIGH); // input again
}
TEST(unit/shim_edge_survives_same_dispatch_pulse)
{
// A press+release fully contained between two dispatchIsrs() calls used
// to be invisible to the level-diff sweep (the click was swallowed).
test::resetInput();
emu::releasePin(BOARD_BOOT_PIN);
detachInterrupt(BOARD_BOOT_PIN);
static int fires;
fires = 0;
attachInterrupt(BOARD_BOOT_PIN, [] { fires++; }, FALLING);
emu::setPin(BOARD_BOOT_PIN, LOW);
emu::setPin(BOARD_BOOT_PIN, HIGH); // pulse within one batch
emu::dispatchIsrs();
EXPECT_EQ(fires, 1); // the edge must survive
detachInterrupt(BOARD_BOOT_PIN);
emu::releasePin(BOARD_BOOT_PIN);
}
// --- emulator shim: I2S TX DMA ring model -----------------------------------
// The legacy ESP32 driver buffers i2s_write() data in a TX DMA ring
// (dma_buf_count x dma_buf_len samples = 512 = 64 ms @ 8 kHz here) and hands
// a buffer back to i2s_write() only after the DMA finished playing it, while
// i2s_zero_dma_buffer() memsets the WHOLE ring instantly — erasing everything
// not yet played. The shim models exactly that (plus a bounded log of what
// the DAC actually emitted) so hardware-only sound bugs reproduce headlessly.
TEST(unit/shim_zero_dma_erases_unplayed)
{
// Pin the model to the legacy driver's semantics, both directions:
// written data plays out, but i2s_zero_dma_buffer() wipes anything that
// has not been played yet (it is never heard). This fidelity is the
// premise the sound-engine regression below relies on.
int16_t tone[16];
for (int i = 0; i < 16; i++) tone[i] = (i & 1) ? -12345 : 12345;
int16_t zeros[64] = {0};
size_t bw;
// phase A: no zeroing — the samples reach the DAC in order
test::resetAudio();
i2s_write(0, tone, sizeof(tone), &bw, 0);
for (int i = 0; i < 10; i++) // drain the ring with silence
i2s_write(0, zeros, sizeof(zeros), &bw, 0);
const auto &played = test::playedAudio();
EXPECT(played.size() >= 16);
for (int i = 0; i < 16; i++) EXPECT_EQ(played[i], tone[i]);
// phase B: zero_dma before playback — the samples vanish unheard
test::resetAudio();
i2s_write(0, tone, sizeof(tone), &bw, 0);
i2s_zero_dma_buffer(0);
for (int i = 0; i < 10; i++)
i2s_write(0, zeros, sizeof(zeros), &bw, 0);
for (int16_t v : test::playedAudio()) EXPECT_EQ(v, 0);
}
TEST(unit/sound_short_tone_reaches_dac)
{
// Regression for the sound task calling i2s_zero_dma_buffer() as soon as
// the queue drained: a 10 ms beep (80 samples) fits into the ring's free
// space without ever blocking i2s_write(), so the render finished in
// microseconds and the zeroing erased the tone before the DMA played a
// single sample — silent on hardware. (Every game beep ≤ 80 ms was in
// that dead zone; longer tones survived because i2s_write blocks on a
// full ring and paces rendering to real-time playback.) The fix flushes
// the ring with paced silence writes instead, which reuse each DMA buffer
// only after the DMA finished playing it.
sound.begin(false); // queue only — no task thread
test::resetAudio();
SndEvent e = {SND_TONE, 400, 0, 10, 12000}; // the link-active beep
sound.play(e);
sound.pumpOne(); // render + (queue drained) ring purge
const auto &played = test::playedAudio();
// the DAC must have heard the tone: ~41 full-amplitude samples at
// amp 12000 * vol 5/8 = 7500, plus the ramp shoulders
size_t loud = 0;
for (int16_t v : played)
if (v > 7000 || v < -7000) loud++;
EXPECT(loud >= 40);
// and the purge must leave silence behind — no tail replaying forever
bool tailClean = true;
for (size_t i = 80; i < played.size(); i++)
if (played[i] != 0) { tailClean = false; break; }
EXPECT(tailClean);
emu::releasePin(BOARD_I2S_BCK); // begin() claimed the I2S pins
emu::releasePin(BOARD_I2S_WS);
emu::releasePin(BOARD_I2S_DOUT);
}
TEST(unit/sound_long_tone_plays_out_fully)
{
// And the purge must never truncate a long tone either: the 500 ms
// link-build beep (4000 samples) outlives the 512-sample DMA ring, so
// i2s_write() blocks mid-render and playback stays real-time paced —
// every steady-state sample must still reach the DAC.
sound.begin(false);
test::resetAudio();
SndEvent e = {SND_TONE, 500, 0, 500, 13000}; // playLinkBuild()
sound.play(e);
sound.pumpOne();
const auto &played = test::playedAudio();
EXPECT(played.size() >= 4000); // whole tone, then silence
size_t loud = 0;
for (int16_t v : played)
if (v > 8000 || v < -8000) loud++;
EXPECT(loud >= 3800); // 3872 steady samples
emu::releasePin(BOARD_I2S_BCK);
emu::releasePin(BOARD_I2S_WS);
emu::releasePin(BOARD_I2S_DOUT);
}