- Replace hardcoded with in NetDeck.ino (8 occurrences) - Add to nd_layout.h - Update test expectations in unit_tests.h and integration_tests.h from units[6] to units[7] to match the new reinforcement slot indexing This enables supporting more than 7 units in the future.
350 lines
14 KiB
C++
350 lines
14 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(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);
|
|
}
|
|
|
|
// --- 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[6].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[7].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
|
|
}
|
|
|
|
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
|
|
units[3].tx = 12; units[3].ty = 12; // droid at the edge tile
|
|
EXPECT_EQ(acquireTarget(0), 3); // marine locks it in the light
|
|
}
|