From 6d2f593bc50f29e1525471e773e7a862a64889dd Mon Sep 17 00:00:00 2001 From: Dejvino Date: Sat, 14 Nov 2026 11:23:37 +0100 Subject: [PATCH] NetDeck M2: sub-net graph, link routing, ICE crack, red trace + feedback spike MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements MVP.md §1-§3 (network half of the vertical slice) on the shared coordinate space: - 3-room floorplan (airlock/corridor/server room) with blast door + terminal - 4 nodes: AIRLK root - JUNC - DOOR_CTRL (on the door tile) / HIVE (3s ICE) - animated link builds (dotted->solid, 1.5s plain / 3.0s ICE), reachability tree from AIRLK; links offline until the build completes - DOOR_CTRL toggles the blast door; X severs the hovered link (ICE progress resets, trace cut short resets safely) - cracking HIVE spawns a 4s red trace to AIRLK; arrival = feedback spike: links drop + 3s OVERHEAT lockout (TEMP bar) - FRENZY/BLIND daemon slots gated on HIVE link (effects land in M4) - R instant reset via resetScenario() (also fixes root-online init bug) - boot straight into the paused encounter - emulator: --tap "x,y@frame" and repeatable --type "text@frame" for headless scenario testing Verified headlessly: full trace->feedback run, safe sever, all gating messages, reset; visual dumps inspected. Spec: src/netdeck/MVP.md. --- emulator/src/main.cpp | 90 ++++- examples/NetDeck/NetDeck.ino | 701 ++++++++++++++++++++++++----------- src/netdeck/MVP.md | 75 ++++ src/netdeck/STATUS.md | 34 +- 4 files changed, 670 insertions(+), 230 deletions(-) create mode 100644 src/netdeck/MVP.md diff --git a/emulator/src/main.cpp b/emulator/src/main.cpp index ce1baa6..e81719f 100644 --- a/emulator/src/main.cpp +++ b/emulator/src/main.cpp @@ -73,9 +73,16 @@ int main(int argc, char **argv) { long maxFrames = -1; const char *dumpPath = nullptr; - const char *typeStr = nullptr; int typeFromFrame = 30; int dumpEvery = 0; + // scheduled screen taps: --tap "x,y[@frame]" (repeatable) + struct Tap { int x, y, at, hold; bool fired; }; + static Tap taps[32]; + int nTaps = 0; + // scheduled typing: --type "text[@frame]" (repeatable, chars ~40 ms apart) + struct TypeEvt { const char *s; int at; }; + static TypeEvt typeEvts[16]; + int nType = 0; #ifdef EMU_APP_MISSILECOMMAND bool autoplay = false; #endif @@ -83,8 +90,28 @@ int main(int argc, char **argv) if (!strcmp(argv[i], "--frames") && i + 1 < argc) maxFrames = atol(argv[++i]); else if (!strcmp(argv[i], "--dump") && i + 1 < argc) dumpPath = argv[++i]; else if (!strcmp(argv[i], "--dump-interval") && i + 1 < argc) dumpEvery = atoi(argv[++i]); - else if (!strcmp(argv[i], "--type") && i + 1 < argc) typeStr = argv[++i]; + else if (!strcmp(argv[i], "--type") && i + 1 < argc && nType < 16) { + // "text[@frame]": queue another typing event (chars ~40 ms apart) + const char *s = argv[++i]; + int at = typeFromFrame; // legacy default via --type-at + const char *atp = strchr(s, '@'); + char *copy = strdup(s); + if (atp) { + at = atoi(atp + 1); + copy[atp - s] = '\0'; + } + typeEvts[nType++] = { copy, at }; + } else if (!strcmp(argv[i], "--type-at") && i + 1 < argc) typeFromFrame = atoi(argv[++i]); + else if (!strcmp(argv[i], "--tap") && i + 1 < argc && nTaps < 32) { + Tap &t = taps[nTaps++]; + t.x = t.y = t.at = 0; t.hold = 0; t.fired = false; + const char *s = argv[++i]; + sscanf(s, "%d,%d@%d", &t.x, &t.y, &t.at); + if (t.at <= 0) t.at = 30; // "@frame" part optional + t.hold = t.at + 120; // hold long enough that a frame-paced + // pollTick (~34 ms apart) sees it + } else if (!strcmp(argv[i], "--autoplay")) { emuAutoplay = true; } #ifdef EMU_APP_MISSILECOMMAND else if (!strcmp(argv[i], "--wave") && i + 1 < argc) emuStartWaveRequest = atoi(argv[++i]); @@ -231,28 +258,35 @@ int main(int argc, char **argv) } } - // --type: queue the string on the keyboard device like a human typing - // (one char per --type-at start, ~40 ms apart in millis time, so the - // sketch processes each key before the next arrives). + // --type: queue the strings on the keyboard device like a human typing + // (chars ~40 ms apart in millis time, so the sketch processes each key + // before the next arrives; each event starts at its "@frame"). // '\n' emulates Enter: press the trackball pin for one iteration. static const char *typeNext = nullptr; static int typePressPin = -1; static unsigned long lastTypeMs = 0; - if (typeStr && frame >= (uint32_t)typeFromFrame) { - if (typePressPin >= 0) { - emu::pinLevels[typePressPin] = 1; // release the Enter press - typePressPin = -1; - } - if (!typeNext) typeNext = typeStr; - const char *typeEnd = typeStr + strlen(typeStr); - if (typeNext < typeEnd && millis() - lastTypeMs >= 40) { - lastTypeMs = millis(); - if (*typeNext == '\n' || *typeNext == '\r') { - typeNext++; // consume the Enter char - emu::pinLevels[BOARD_BOOT_PIN] = 0; - typePressPin = BOARD_BOOT_PIN; - } else { - emu::keyboard.push_back((uint8_t)*typeNext++); + static int curType = 0; + if (curType < nType) { + const TypeEvt &te = typeEvts[curType]; + if (frame >= (uint32_t)te.at) { + if (typePressPin >= 0) { + emu::pinLevels[typePressPin] = 1; // release the Enter press + typePressPin = -1; + } + const char *typeEnd = te.s + strlen(te.s); + if (!typeNext) { typeNext = te.s; lastTypeMs = 0; } + if (typeNext >= typeEnd) { + curType++; // event finished + typeNext = nullptr; + } else if (millis() - lastTypeMs >= 40) { + lastTypeMs = millis(); + if (*typeNext == '\n' || *typeNext == '\r') { + typeNext++; // consume the Enter char + emu::pinLevels[BOARD_BOOT_PIN] = 0; + typePressPin = BOARD_BOOT_PIN; + } else { + emu::keyboard.push_back((uint8_t)*typeNext++); + } } } } @@ -272,6 +306,22 @@ int main(int argc, char **argv) } #endif + // --tap: scheduled screen taps (left-button touch at x,y from frame N, + // held ~40 iterations so the sketch's frame-paced poll sees it) + for (int i = 0; i < nTaps; i++) { + Tap &t = taps[i]; + if (!t.fired && frame >= (uint32_t)t.at) { + emu::touchX = t.x; + emu::touchY = t.y; + emu::touchDown = true; + t.fired = true; + std::printf("[emu] tap %d,%d at frame %u\n", t.x, t.y, frame); + } else if (t.fired && frame >= (uint32_t)t.hold) { + emu::touchDown = false; + t.hold = -1; // released; don't re-release + } + } + // fire any emulated interrupts triggered by the pin changes above emu::dispatchIsrs(); diff --git a/examples/NetDeck/NetDeck.ino b/examples/NetDeck/NetDeck.ino index e03b934..e0a1f23 100644 --- a/examples/NetDeck/NetDeck.ino +++ b/examples/NetDeck/NetDeck.ino @@ -1,32 +1,35 @@ /** * @file NetDeck.ino - * @brief NetDeck — Breach & Board: Milestone 1 hardware sandbox. + * @brief NetDeck — Breach & Board: Milestone 2 — network graph & traces. * - * Milestone 1 (DESIGN.md §7): the same M0 sandbox sketch prepared for the - * T-Deck hardware. Rendering goes into a full-frame RAM sprite and is pushed - * to the ST7789 as one continuous SPI stream (anti-flicker, see present()); - * the emulator draws straight into the SDL shim framebuffer instead. + * Milestone 2 (DESIGN.md §7) implementing the sub-net half of the MVP + * vertical slice (MVP.md §2/§3) over the shared coordinate space: * - * - shared tactical view (320x192) + HUD bar, ONE coordinate space: - * bulkhead doors and their network door nodes occupy the same spot - * - two view modes over that space (`P` to switch, `Tab` as legacy alias): - * C) Cameras — full top-down ship view, network overlaid as outlines - * N) Network — ship dimmed underneath, full network graph on top - * - fixed-timestep engine loop (20 Hz sim decoupled from ~30 fps render) - * - trackball cursor with edge-ISR counting + momentum - * - keyboard device @ I2C 0x55: Space = tactical freeze, P = view switch - * - demo floorplan tile map + demo sub-net graph with packet flow + * - 3-room floorplan (airlock / main corridor / server room) with one + * interactive blast door and the objective terminal + * - 4 hardcoded nodes in the same coordinate space: + * [AIRLK] root (always online) - [JUNC] - [DOOR] / [HIVE] (3 s ICE) + * the [DOOR] node sits exactly on its blast-door tile + * - click an adjacent node to route a link: animated dotted line that + * turns solid over 1.5 s (3.0 s when ICE-locked); X severs the hovered + * link (everything beyond it drops, ICE progress resets) + * - [DOOR] node (once online) toggles the blast door open/closed + * - cracking [HIVE] spawns a red trace pulse: 4 s back to [AIRLK]; + * arrival = feedback spike (links drop + 3 s OVERHEAT lockout) + * - HUD: [1:FRENZY] [2:BLIND] slots (effects land in M4), TEMP bar, + * RESET (R); boot goes straight into the paused encounter * * Run on the desktop: make APP=NetDeck run (from emulator/) * Headless smoke test: make smoke APP=NetDeck * * Controls (emulator / device): - * Trackball move cursor (snaps to tiles in Cameras, nodes in Network) + * Trackball move cursor (tiles in Cameras, nodes/links in Network) * Enter / click trackball press / screen tap = primary action - * Space toggle tactical freeze (time-stop + CRT scanlines) + * Space toggle tactical freeze (starts PAUSED) * P (or Tab) switch view: Cameras <-> Network - * 1-4 arm slotted exploit daemon (groundwork, flashes slot) - * X / R / Q / E sever link / retreat / cycle (groundwork, logged) + * X sever the hovered network link + * R reset the scenario + * 1 / 2 FRENZY / BLIND daemons (need an online [HIVE] link; M4) */ #include @@ -38,19 +41,12 @@ #include "../../src/netdeck/nd_layout.h" // --------------------------------------------------------------------------- -// Hardware +// Hardware + full-frame rendering (M1 anti-flicker pattern) // --------------------------------------------------------------------------- TFT_eSPI tft; TouchDrvGT911 touch; static bool touchAvail = false; -// --------------------------------------------------------------------------- -// Full-frame rendering — draw into a RAM buffer, push to the panel once per -// frame (the MiataDrive anti-flicker pattern: thousands of small draw calls -// racing the panel's scan-out cause tearing; one continuous SPI stream writes -// each pixel exactly once). Emulator: the SDL shim framebuffer IS the second -// buffer, so we draw straight into it. -// --------------------------------------------------------------------------- #ifndef EMULATOR static TFT_eSprite fb(&tft); // full-frame 320x240x16 buffer (PSRAM) static TFT_eSprite *const GFXP = &fb; @@ -59,7 +55,6 @@ static TFT_eSPI *const GFXP = &tft; #endif #ifndef EMULATOR -// Push the finished frame to the ST7789 as one continuous SPI stream. static void present() { if (!fb.created()) return; @@ -80,96 +75,320 @@ enum ViewMode { VM_CAMERAS, VM_NETWORK }; static ViewMode viewMode = VM_CAMERAS; static uint32_t stateT0 = 0; -static bool paused = false; -static uint32_t simTick = 0; // 20 Hz deterministic ticks -static uint32_t simAcc = 0; // fixed-timestep accumulator +static bool paused = true; // MVP: boot straight into the paused encounter +static uint32_t simTick = 0; +static uint32_t simAcc = 0; static uint32_t lastFrameMs = 0; // --------------------------------------------------------------------------- -// Demo deck floorplan (40x24 tile grid; DESIGN.md §3 shared tactical view) -// '#' wall '.' floor 'o' cover crate '+' bulkhead door 'A' airlock -// Rooms: left hull (w/ Security), top-mid lab, bottom-mid hold (Power), -// right server vault (Droid Hive). Bulkhead doors are network door nodes. +// 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. // --------------------------------------------------------------------------- static const char *const DEMO_MAP[nd::TILE_ROWS] = { "########################################", - "#...........#.............#............#", - "#..o........#.............#...o........#", - "#...........#....o........#............#", - "#..........+.............#............#", - "#...........#.........o...#............#", - "#.......o...#.............#.........o..#", - "#...........#.............#............#", - "#...........######+#######............#", - "#...........#.............#............#", - "#.o.........#.............#............#", - "#...........#.............+............#", - "#...........#..o..........#............#", - "#...........#.............#............#", - "#........o..#.............#.o..........#", - "#...........#.............#............#", - "#...........#........o....#............#", - "#...........#.............#............#", - "#..........+.............#......o....#", - "#...o......#.............#............#", - "#...........#...........o#............#", - "#.A.........#.............#....o......#", - "#...........#.............#............#", + "#.........#.................#..........#", + "#.........#.................#..........#", + "#.........#.................#..........#", + "#....o....#.................#..........#", + "#.........#.................#..........#", + "#.........#.................#..........#", + "#.........#.................#.....T....#", + "#...........................#..........#", + "#...........................#..........#", + "#.........#...o.............#..........#", + "#.........#.................#..........#", + "#.........#.................+..........#", + "###########.................#..........#", + "#.........#.................#..........#", + "#.........#...........o.....#..........#", + "#.........#.................#..........#", + "#...........................#..........#", + "#...........................#..........#", + "#.........#.................#..........#", + "#.........#.................#..........#", + "#.A.......#.................#..........#", + "#.........#.................#..........#", "########################################", }; -static const int AIRLOCK_TX = 2, AIRLOCK_TY = 21; // breach entry tile +static const int DOOR_TX = 28, DOOR_TY = 12; // the Room2/Room3 blast door +static const int AIRLOCK_TX = 2, AIRLOCK_TY = 21; + +static bool doorOpen = false; + +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]; +} + +// blocks unit movement (closed blast door included) — used from M3 on +[[maybe_unused]] static bool walkable(int tx, int ty) +{ + char t = tileAt(tx, ty); + if (t == '+' && !doorOpen) return false; + return t == '.' || t == 'A' || t == 'T' || t == '+'; +} + +// blocks line-of-sight raycasts — used from M3 on +[[maybe_unused]] static bool blocksSight(int tx, int ty) +{ + char t = tileAt(tx, ty); + return t == '#' || (t == '+' && !doorOpen); +} + +[[maybe_unused]] static int tileIdx(int tx, int ty) { return ty * nd::TILE_COLS + tx; } // --------------------------------------------------------------------------- -// Demo sub-net graph — same coordinate space as the floorplan -// (tile coords; door nodes sit exactly on their bulkhead door tiles) +// Sub-net (MVP.md §2): 4 nodes in the same coordinate space // --------------------------------------------------------------------------- +enum { N_AIRLK, N_JUNC, N_DOOR, N_HIVE }; struct NetNode { const char *label; - int tx, ty; // tile coords (px center = tile*8+4) + int tx, ty; uint16_t color; - uint8_t type; // 0 junction, 1 ICE, 2 hive, 3 door controller }; -enum { NN_AIRLK, NN_SEC, NN_D1, NN_D2, NN_D3, NN_D4, NN_PWR, NN_HIVE }; -static const NetNode NODES[8] = { - { "AIRLK", 2, 21, nd::C_AIRLOCK, 0 }, - { "SEC", 6, 6, nd::C_ICE, 1 }, - { "DOOR1", 12, 4, nd::C_DOOR, 3 }, - { "DOOR2", 12, 18, nd::C_DOOR, 3 }, - { "DOOR3", 19, 8, nd::C_DOOR, 3 }, - { "DOOR4", 26, 11, nd::C_DOOR, 3 }, - { "PWR", 19, 14, nd::C_NODE, 0 }, - { "HIVE", 33, 5, nd::C_HIVE, 2 }, +static const NetNode NODES[4] = { + { "AIRLK", 4, 20, nd::C_AIRLOCK }, + { "JUNC", 18, 6, nd::C_NODE }, + { "DOOR", 28, 12, nd::C_DOOR }, + { "HIVE", 35, 4, nd::C_HIVE }, }; -static const uint8_t LINKS[7][2] = { - { NN_AIRLK, NN_D2 }, { NN_D2, NN_PWR }, { NN_PWR, NN_D4 }, - { NN_D4, NN_HIVE }, { NN_PWR, NN_D3 }, { NN_D3, NN_D1 }, { NN_D1, NN_SEC }, +static const uint8_t EDGES[3][2] = { + { N_AIRLK, N_JUNC }, { N_JUNC, N_DOOR }, { N_JUNC, N_HIVE }, }; -// packet flow path AIRLK -> DOOR2 -> PWR -> DOOR4 -> HIVE -static const uint8_t PACKET_PATH[5] = { NN_AIRLK, NN_D2, NN_PWR, NN_D4, NN_HIVE }; +static const char *EDGE_LABELS[3] = { "AIRLK-JUNC", "JUNC-DOOR", "JUNC-HIVE" }; 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; } -// --------------------------------------------------------------------------- -// Cursor (shared space; snaps to tiles in Cameras, nodes targeted in Network) -// --------------------------------------------------------------------------- -static int curX = 60, curY = 120; +// link build durations (sim ticks @ 50 ms): 1.5 s plain, 3.0 s through ICE +static const int LINK_TICKS = 30; +static const int ICE_TICKS = 60; +// red trace: 4 s from HIVE back to AIRLK +static const int TRACE_TICKS = 80; +// overheat lockout after a feedback spike +static const int HEAT_TICKS = 60; -// Squad priority beacon (tile coords), starts at the airlock +struct NetLink { + bool active; + uint8_t a, b; // node ids + int prog; // build progress in ticks (prog == dur -> ACTIVE) + int dur; +}; +static NetLink links[3]; + +static bool nodeOnline[4]; // compromised & reachable from AIRLK +static bool hiveCracked = false; + +// red trace pulse HIVE -> JUNC -> AIRLK +static bool traceActive = false; +static int traceProg = 0; // 0..TRACE_TICKS + +// deck thermal: >0 = OVERHEAT lockout (ticks remaining, shown as %) +static int heatT = 0; + +// cursor +static int curX = 60, curY = 120; static int beaconTX = AIRLOCK_TX, beaconTY = AIRLOCK_TY; // transient UI feedback -static uint32_t viewFlashUntil = 0; // frame flash after view switch -static uint32_t slotFlash = 0xFF; // daemon slot flash id + expiry pair -static uint32_t slotFlashUntil = 0; -static int nodeFlash = -1; // clicked net node highlight -static uint32_t nodeFlashUntil = 0; +static uint32_t viewFlashUntil = 0; +static char msgText[24] = ""; +static uint32_t msgUntil = 0; + +static void flashMsg(const char *t) +{ + snprintf(msgText, sizeof(msgText), "%s", t); + msgUntil = millis() + 1200; + Serial.printf("[msg] %s\n", t); +} // --------------------------------------------------------------------------- -// Trackball input — edge-counting ISRs + momentum model -// Quadrant pins + center click, per UnitTest's mouse mapping: -// G02 -> right, G01 -> up, G04 -> left, G03 -> down, BOOT -> click +// Sub-net logic +// --------------------------------------------------------------------------- + +// reachability from AIRLK over ACTIVE links (links form a tree) +static void refreshOnline() +{ + bool reach[4] = { true, false, false, false }; + bool changed = true; + while (changed) { + changed = false; + for (auto &l : links) { + if (!l.active || l.prog != l.dur) continue; + if (reach[l.a] != reach[l.b]) { + reach[l.a] = reach[l.b] = true; + changed = true; + } + } + } + for (int i = 0; i < 4; i++) nodeOnline[i] = reach[i]; + if (!nodeOnline[N_HIVE]) hiveCracked = false; +} + +// is there an edge between two nodes? +static int edgeBetween(int a, int b) +{ + for (int i = 0; i < 3; i++) + if ((EDGES[i][0] == a && EDGES[i][1] == b) || + (EDGES[i][0] == b && EDGES[i][1] == 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 < 3; i++) + if (links[i].active && edge == i) return i; + return -1; +} + +static void dropLinks() +{ + for (auto &l : links) l.active = false; + traceActive = false; + refreshOnline(); +} + +static void tryLink(int node) +{ + if (heatT > 0) { flashMsg("OVERHEAT"); return; } + if (nodeOnline[node]) { + if (node == N_DOOR) { + doorOpen = !doorOpen; + Serial.printf("[net] DOOR_CTRL: blast door %s\n", doorOpen ? "OPEN" : "CLOSED"); + flashMsg(doorOpen ? "DOOR OPEN" : "DOOR CLOSED"); + return; + } + flashMsg("ONLINE"); + return; + } + // route a link from any online node adjacent to this one + int edge = -1, from = -1; + for (int i = 0; i < 3; i++) { + int a = EDGES[i][0], b = EDGES[i][1]; + if ((a == node && nodeOnline[b]) || (b == node && nodeOnline[a])) { + edge = i; + from = (a == node) ? b : a; + break; + } + } + if (edge < 0) { flashMsg("NO UPLINK"); return; } + if (linkOnEdge(edge) >= 0) { flashMsg("LINKING..."); return; } + + bool ice = (node == N_HIVE); + for (auto &l : links) { + if (!l.active) { + l.active = true; + l.a = from; + l.b = node; + l.prog = 0; + l.dur = ice ? ICE_TICKS : LINK_TICKS; + refreshOnline(); // offline until the build completes + Serial.printf("[net] routing %s%s (%.1fs)\n", EDGE_LABELS[edge], + ice ? " [ICE]" : "", l.dur * nd::SIM_TICK_MS / 1000.0f); + return; + } + } +} + +// sever the link (and everything that loses its path to AIRLK) +static void severLink(int li) +{ + Serial.printf("[net] severed %s\n", EDGE_LABELS[edgeBetween(links[li].a, links[li].b)]); + links[li].active = false; + refreshOnline(); + if (!nodeOnline[N_HIVE]) traceActive = false; // trace cut short: reset safely + flashMsg("LINK SEVERED"); +} + +// distance cursor->link segment; returns the hovered link or -1 +static int hoverLink() +{ + int best = -1; + float bestD = 7.0f; + for (int i = 0; i < 3; 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); + float dx = x1 - x0, dy = y1 - y0; + float len2 = dx * dx + dy * dy; + float t = ((curX - x0) * dx + (curY - y0) * dy) / len2; + if (t < 0) t = 0; + if (t > 1) t = 1; + float px = x0 + t * dx, py = y0 + t * dy; + float d = hypotf(curX - px, curY - py); + if (d < bestD) { bestD = d; best = i; } + } + return best; +} + +static void spawnTrace() +{ + traceActive = true; + traceProg = 0; + Serial.println("[net] TRACE detected: red pulse inbound!"); +} + +static void feedbackSpike() +{ + traceActive = false; + dropLinks(); + heatT = HEAT_TICKS; + Serial.println("[net] FEEDBACK SPIKE: links dropped, OVERHEAT 3s, reinforcement inbound"); + flashMsg("FEEDBACK!"); + // reinforcement droid spawns in M3 +} + +static void stepNetwork() +{ + // link builds + for (auto &l : links) { + if (!l.active || l.prog == l.dur) continue; + l.prog++; + if (l.prog == l.dur) { + refreshOnline(); + if (l.b == N_HIVE && nodeOnline[N_HIVE]) { + hiveCracked = true; + spawnTrace(); + } else { + Serial.printf("[net] link up: %s\n", EDGE_LABELS[edgeBetween(l.a, l.b)]); + } + } + } + // red trace + if (traceActive) { + traceProg++; + if (traceProg >= TRACE_TICKS) feedbackSpike(); + } + // thermal cooldown + if (heatT > 0) { + heatT--; + if (heatT == 0) Serial.println("[net] deck cooled: systems online"); + } +} + +// --------------------------------------------------------------------------- +// Scenario reset (MVP: R replays the 60-second scenario instantly) +// --------------------------------------------------------------------------- +static void resetScenario() +{ + for (auto &l : links) l.active = false; + traceActive = false; + traceProg = 0; + hiveCracked = false; + heatT = 0; + doorOpen = false; + refreshOnline(); // AIRLK root comes up online + paused = true; + // entities (marines/droids) arrive in M3 +} + +// --------------------------------------------------------------------------- +// Trackball input — edge-counting ISRs + momentum (unchanged from M1) // --------------------------------------------------------------------------- static volatile uint32_t tbEdges[4]; static volatile uint32_t tbClicks; @@ -180,18 +399,18 @@ static void IRAM_ATTR tbIsrLeft() { tbEdges[2]++; } static void IRAM_ATTR tbIsrDown() { tbEdges[3]++; } static void IRAM_ATTR tbIsrClick() { tbClicks++; } -static const int TB_FP = 8; // velocity fixed point +static const int TB_FP = 8; #ifdef EMULATOR -static const int TB_IMPULSE = 6; // emulated: rich edge rate -static const int TB_FRICTION = 12; // velocity kept per frame (of 16) +static const int TB_IMPULSE = 6; +static const int TB_FRICTION = 12; #else -static const int TB_IMPULSE = 24; // device: fewer edges to move +static const int TB_IMPULSE = 24; static const int TB_FRICTION = 15; #endif -static const int TB_VMAX = 24 << TB_FP; // hard-flick cap +static const int TB_VMAX = 24 << TB_FP; -static int32_t tbVelX, tbVelY; // momentum, 1/8 px per frame -static int32_t tbRemX, tbRemY; // sub-pixel accumulators +static int32_t tbVelX, tbVelY; +static int32_t tbRemX, tbRemY; static void attachTrackball() { @@ -223,25 +442,14 @@ static void clampCursor() } // --------------------------------------------------------------------------- -// View mode -// --------------------------------------------------------------------------- -static void toggleView() -{ - viewMode = (viewMode == VM_CAMERAS) ? VM_NETWORK : VM_CAMERAS; - viewFlashUntil = millis() + 350; - Serial.printf("[key] view -> %s\n", - viewMode == VM_CAMERAS ? "CAMERAS" : "NETWORK"); -} - -// --------------------------------------------------------------------------- -// Primary action (groundwork: M3 beacon placement, M2 node routing) +// Primary action // --------------------------------------------------------------------------- static void registerClick() { if (viewMode == VM_CAMERAS) { int tx = curX / nd::TILE, ty = curY / nd::TILE; - char t = DEMO_MAP[ty][tx]; - if (t != '#') { // beacons can't sit inside walls + char t = tileAt(tx, ty); + if (t != '#') { beaconTX = tx; beaconTY = ty; Serial.printf("[click] beacon -> tile %d,%d\n", tx, ty); @@ -249,17 +457,16 @@ static void registerClick() Serial.println("[click] wall tile: beacon ignored"); } } else { - // nearest demo node flash (routing groundwork for Milestone 2) + // nearest node int best = -1, bestD = 1 << 30; - for (int i = 0; i < 8; i++) { + for (int i = 0; i < 4; i++) { int dx = curX - nodePx(i); int dy = curY - nodePy(i); int d = dx * dx + dy * dy; if (d < bestD) { bestD = d; best = i; } } - nodeFlash = best; - nodeFlashUntil = millis() + 400; - Serial.printf("[click] node %s targeted\n", NODES[best].label); + if (bestD > 24 * 24) { flashMsg("NO NODE"); return; } + tryLink(best); } } @@ -273,24 +480,33 @@ static void handleKey(char c) paused = !paused; Serial.printf("[key] tactical freeze %s\n", paused ? "ON" : "OFF"); break; - case 'p': case '\t': // '\t' kept as legacy alias for the pane era - toggleView(); + case 'p': case '\t': + viewMode = (viewMode == VM_CAMERAS) ? VM_NETWORK : VM_CAMERAS; + viewFlashUntil = millis() + 350; + Serial.printf("[key] view -> %s\n", + viewMode == VM_CAMERAS ? "CAMERAS" : "NETWORK"); break; - case '1': case '2': case '3': case '4': - slotFlash = c - '1'; - slotFlashUntil = millis() + 400; - Serial.printf("[key] arm daemon slot %d (M4 groundwork)\n", c - '1'); + case '1': case '2': + if (heatT > 0) { flashMsg("OVERHEAT"); break; } + if (!nodeOnline[N_HIVE]) { flashMsg("NO HIVE LINK"); break; } + // FRENZY / BLIND payloads land in Milestone 4 + Serial.printf("[key] daemon %c armed (effect lands in M4)\n", c); + flashMsg("M4 PENDING"); break; - case 'x': - Serial.println("[key] kill-switch sever (M2 groundwork)"); + case 'x': { + if (heatT > 0) { flashMsg("OVERHEAT"); break; } + int li = hoverLink(); + if (li >= 0) severLink(li); + else flashMsg("NO LINK HERE"); break; + } case 'r': - Serial.println("[key] tactical retreat (M3 groundwork)"); - beaconTX = AIRLOCK_TX; - beaconTY = AIRLOCK_TY; + Serial.println("[key] RESET"); + resetScenario(); + Serial.println("[reset] scenario re-armed (paused)"); break; case 'q': case 'e': - Serial.printf("[key] cycle %s (M2 groundwork)\n", c == 'q' ? "back" : "fwd"); + Serial.printf("[key] cycle %s (groundwork)\n", c == 'q' ? "back" : "fwd"); break; default: break; @@ -302,7 +518,7 @@ static void pollKeyboard() static char lastKey = 0; Wire.requestFrom((uint8_t)0x55, (uint8_t)1); if (Wire.available() == 0) { - lastKey = 0; // idle: arm the next press (same key can repeat) + lastKey = 0; return; } char k = (char)Wire.read(); @@ -323,7 +539,8 @@ static void pollTouch() if (!down) { wasDown = false; return; } if (wasDown) return; // only act on new taps int16_t x[1], y[1]; - if (touch.getPoint(x, y, 1) > 0) { + int gp = touch.getPoint(x, y, 1); + if (gp > 0) { wasDown = true; curX = x[0]; curY = y[0]; @@ -333,8 +550,7 @@ static void pollTouch() } // --------------------------------------------------------------------------- -// Trackball -> cursor (momentum, capped; cursor stays live during the freeze -// because planning happens while paused) +// Trackball -> cursor // --------------------------------------------------------------------------- static void applyTrackball() { @@ -368,18 +584,18 @@ static void applyTrackball() } // --------------------------------------------------------------------------- -// Simulation — deterministic 20 Hz ticks (grows into M2/M3 systems) +// Simulation — deterministic 20 Hz ticks // --------------------------------------------------------------------------- static void stepSim() { simTick++; + stepNetwork(); } // --------------------------------------------------------------------------- // Rendering // --------------------------------------------------------------------------- -// palette color of a map tile static uint16_t tileColor(char t) { switch (t) { @@ -387,11 +603,11 @@ static uint16_t tileColor(char t) case 'o': return nd::C_COVER; case '+': return nd::C_DOOR; case 'A': return nd::C_AIRLOCK; + case 'T': return nd::C_NODE; default: return nd::C_FLOOR; } } -// ~35% brightness ghost of an RGB565 color (Network mode dims the ship view) static uint16_t dim565(uint16_t c) { uint32_t r = (((c >> 11) & 0x1F) * 22) >> 6; @@ -405,62 +621,137 @@ static void renderMap(bool dim) for (int ty = 0; ty < nd::TILE_ROWS; ty++) { const char *row = DEMO_MAP[ty]; for (int tx = 0; tx < nd::TILE_COLS; tx++) { - uint16_t c = tileColor(row[tx]); + char t = row[tx]; + uint16_t c = tileColor(t); if (dim) c = dim565(c); + // the blast door: amber block when closed, open frame when open + if (t == '+' && doorOpen) c = dim ? dim565(nd::C_FLOOR) : nd::C_FLOOR; GFXP->fillRect(tx * nd::TILE, ty * nd::TILE, nd::TILE, nd::TILE, c); - if (row[tx] == 'A') { // airlock outline pops on the floor + if (t == '+' && doorOpen) { + uint16_t dc = dim ? dim565(nd::C_DOOR) : nd::C_DOOR; + GFXP->fillRect(tx * nd::TILE, ty * nd::TILE, 2, nd::TILE, dc); + GFXP->fillRect(tx * nd::TILE + 6, ty * nd::TILE, 2, nd::TILE, dc); + } + if (t == 'A') { GFXP->drawRect(tx * nd::TILE, ty * nd::TILE, nd::TILE, nd::TILE, - dim ? dim565(nd::C_FLOOR) : nd::C_FLOOR); + dim ? dim565(nd::C_FLOOR) : nd::C_FLOOR); + } + if (t == 'T') { // objective terminal: dark rack + cyan screen + uint16_t dc = dim ? dim565(nd::C_HUDBG) : nd::C_HUDBG; + GFXP->fillRect(tx * nd::TILE, ty * nd::TILE, nd::TILE, nd::TILE, dc); + GFXP->fillRect(tx * nd::TILE + 1, ty * nd::TILE + 1, 6, 3, + dim ? dim565(nd::C_PACKET) : nd::C_PACKET); } } } } +// partial line: solid fraction, dotted remainder (link build animation) +static void drawLinkLine(int x0, int y0, int x1, int y1, float frac, + uint16_t solid, uint16_t dotted, bool dottedFirst) +{ + int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1; + int dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1; + int err = dx + dy; + int steps = dx - dy; // bresenham step count approx + int solidSteps = (int)(steps * frac); + int i = 0; + for (;;) { + bool solidPix = dottedFirst ? (i >= steps - solidSteps) + : (i < solidSteps); + if (solidPix) GFXP->drawPixel(x0, y0, solid); + else if ((i & 1) == 0) GFXP->drawPixel(x0, y0, dotted); + if (x0 == x1 && y0 == y1) break; + int e2 = 2 * err; + if (e2 >= dy) { err += dy; x0 += sx; } + if (e2 <= dx) { err += dx; y0 += sy; } + i++; + } +} + static void renderNetwork(bool full) { - // links: solid trace (Network) vs dotted ghost outline (Cameras) - for (auto &l : LINKS) { - int x0 = nodePx(l[0]), y0 = nodePy(l[0]); - int x1 = nodePx(l[1]), y1 = nodePy(l[1]); - if (full) { - GFXP->drawLine(x0, y0, x1, y1, nd::C_LINK); - } else { - // dotted line: every other pixel of a Bresenham walk - int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1; - int dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1; - int err = dx + dy, step = 0; - for (;;) { - if ((step++ & 1) == 0) GFXP->drawPixel(x0, y0, nd::C_GHOST); - if (x0 == x1 && y0 == y1) break; - int e2 = 2 * err; - if (e2 >= dy) { err += dy; x0 += sx; } - if (e2 <= dx) { err += dx; y0 += sy; } + // links: active solid, building partial, ghost outlines in cameras mode + for (int i = 0; i < 3; i++) { + auto &l = links[i]; + int x0 = nodePx(l.a), y0 = nodePy(l.a); + int x1 = nodePx(l.b), y1 = nodePy(l.b); + bool hovered = (hoverLink() == i && full); + uint16_t solidC = hovered ? nd::C_CURSOR : nd::C_LINK; + if (l.active && full) { + if (l.prog < l.dur) { + drawLinkLine(x0, y0, x1, y1, (float)l.prog / l.dur, + solidC, nd::C_PACKET, false); + } else { + GFXP->drawLine(x0, y0, x1, y1, solidC); + } + } else if (l.active && !full) { + if (l.prog < l.dur) { + drawLinkLine(x0, y0, x1, y1, (float)l.prog / l.dur, + nd::C_GHOST, nd::C_GHOST, false); + } else { + for (int k = 0; k <= 1; k++) {} // dotted ghost: + int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1; + int dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1; + int err = dx + dy, step = 0; + for (;;) { + if ((step++ & 1) == 0) GFXP->drawPixel(x0, y0, nd::C_GHOST); + if (x0 == x1 && y0 == y1) break; + int e2 = 2 * err; + if (e2 >= dy) { err += dy; x0 += sx; } + if (e2 <= dx) { err += dx; y0 += sy; } + } } } } - // data packets flowing along the packet path (freeze with the sim) - int segs = 4, per = 36; - int tt = (int)(simTick % (uint32_t)(segs * per)); - int seg = tt / per, f = tt % per; - int a = PACKET_PATH[seg], b = PACKET_PATH[seg + 1]; - int px = nodePx(a) + (nodePx(b) - nodePx(a)) * f / per; - int py = nodePy(a) + (nodePy(b) - nodePy(a)) * f / per; - GFXP->fillCircle(px, py, full ? 2 : 1, nd::C_PACKET); - if (full) GFXP->drawPixel(px, py, TFT_WHITE); + // 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; + 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 px = x0 + (int)((x1 - x0) * t); + int py = y0 + (int)((y1 - y0) * t); + GFXP->fillCircle(px, py, 3, nd::C_TRACE); + GFXP->drawCircle(px, py, 5, nd::C_TRACE); + } - // nodes: filled icons + labels (Network) vs hollow outlines (Cameras) - for (int i = 0; i < 8; i++) { + // nodes + for (int i = 0; i < 4; i++) { int nx = nodePx(i), ny = nodePy(i); - bool flashing = (nodeFlash == i && (int32_t)(millis() - nodeFlashUntil) < 0); + int hoverDx = curX - nx, hoverDy = curY - ny; + bool hovered = viewMode == VM_NETWORK && hoverDx * hoverDx + hoverDy * hoverDy < 24 * 24; if (full) { - GFXP->fillCircle(nx, ny, 6, flashing ? nd::C_CURSOR : NODES[i].color); - GFXP->drawCircle(nx, ny, 6, TFT_BLACK); + if (nodeOnline[i]) { + GFXP->fillCircle(nx, ny, 6, NODES[i].color); + GFXP->drawCircle(nx, ny, 6, TFT_BLACK); + } else { + GFXP->drawCircle(nx, ny, 6, hovered ? nd::C_CURSOR : nd::C_GHOST); + } GFXP->setTextDatum(TC_DATUM); - GFXP->setTextColor(nd::C_TEXTDIM); + GFXP->setTextColor(nodeOnline[i] ? nd::C_TEXT : nd::C_TEXTDIM); GFXP->drawString(NODES[i].label, nx, ny + 9); + // door state on the door node + if (i == N_DOOR && 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 < 3; k++) { + if (links[k].active && links[k].b == N_HIVE && links[k].prog < links[k].dur) { + GFXP->setTextColor(nd::C_TRACE); + GFXP->drawString("CRACKING", nx, ny + 19); + } + } + } } else { - GFXP->drawCircle(nx, ny, 6, flashing ? nd::C_CURSOR : nd::C_GHOST); + GFXP->drawCircle(nx, ny, 6, + nodeOnline[i] ? nd::C_GHOST + : (hovered ? nd::C_CURSOR : nd::C_GHOST)); } } @@ -473,7 +764,6 @@ static void renderNetwork(bool full) static void renderBeacon() { - // squad priority beacon (cyan diamond at the beacon tile center) int bx = beaconTX * nd::TILE + nd::TILE / 2; int by = beaconTY * nd::TILE + nd::TILE / 2; uint16_t c = (viewMode == VM_NETWORK) ? dim565(nd::C_BEACON) : nd::C_BEACON; @@ -493,27 +783,24 @@ static void renderHud() GFXP->fillRect(nd::HUD_X, nd::HUD_Y, nd::HUD_W, nd::HUD_H, nd::C_HUDBG); GFXP->drawFastHLine(nd::HUD_X, nd::HUD_Y, nd::HUD_W, nd::C_BORDER); - // 4 exploit daemon slots: keycap, name, cooldown bar - static const char *const NAMES[4] = { "FRENZY", "BLIND", "OVRCLK", "PATCH" }; - static const int COOL[4] = { 30, 55, 80, 45 }; - for (int i = 0; i < 4; i++) { + // 2 exploit daemon slots (MVP: FRENZY + BLIND) + static const char *const NAMES[2] = { "FRENZY", "BLIND" }; + for (int i = 0; i < 2; i++) { int x = 6 + i * 58, y = nd::HUD_Y + 6; - bool flashing = (slotFlash == (uint32_t)i && (int32_t)(millis() - slotFlashUntil) < 0); - uint16_t tc = flashing ? nd::C_CURSOR : nd::C_TEXT; - GFXP->setTextColor(tc); GFXP->setTextDatum(TL_DATUM); + GFXP->setTextColor(nd::C_TEXT); GFXP->drawString(String("[") + char('1' + i) + "]", x, y); GFXP->setTextColor(nd::C_TEXTDIM); GFXP->drawString(NAMES[i], x + 18, y); - meterBar(x, y + 14, 48, 6, COOL[i], nd::C_GOOD); + meterBar(x, y + 14, 48, 6, 100, nodeOnline[N_HIVE] ? nd::C_GOOD : nd::C_BORDER); } - // RAM + thermal load - GFXP->setTextColor(nd::C_TEXT); - GFXP->drawString("RAM 4/6", 246, nd::HUD_Y + 6); - meterBar(246, nd::HUD_Y + 16, 56, 7, 42, nd::C_WARN); - GFXP->setTextColor(nd::C_TEXTDIM); - GFXP->drawString("TEMP", 246, nd::HUD_Y + 25); + // TEMP bar (overheat lockout) + int heatPct = heatT * 100 / HEAT_TICKS; + GFXP->setTextColor(heatT > 0 ? nd::C_HOT : nd::C_TEXT); + GFXP->drawString(heatT > 0 ? "OVERHEAT" : "TEMP", 130, nd::HUD_Y + 6); + meterBar(130, nd::HUD_Y + 16, 56, 7, heatT > 0 ? heatPct : 15, + heatT > 0 ? nd::C_HOT : nd::C_WARN); // pause hint / state GFXP->setTextDatum(TR_DATUM); @@ -521,35 +808,40 @@ static void renderHud() GFXP->drawString("SPACE", nd::HUD_X + nd::HUD_W - 6, nd::HUD_Y + 6); GFXP->setTextColor(paused ? nd::C_FREEZE : nd::C_TEXTDIM); GFXP->drawString(paused ? "RESUME" : "PAUSE", nd::HUD_X + nd::HUD_W - 6, nd::HUD_Y + 16); + GFXP->setTextColor(nd::C_TEXTDIM); + GFXP->drawString("R: RESET", nd::HUD_X + nd::HUD_W - 6, nd::HUD_Y + 32); GFXP->setTextDatum(TL_DATUM); // view mode indicator - GFXP->setTextColor(nd::C_FREEZE); GFXP->setTextDatum(TR_DATUM); + GFXP->setTextColor(nd::C_FREEZE); GFXP->drawString(viewMode == VM_CAMERAS ? "VIEW: CAMERAS [P]" : "VIEW: NETWORK [P]", - nd::HUD_X + nd::HUD_W - 6, nd::HUD_Y + 32); + nd::HUD_X + 190, nd::HUD_Y + 32); GFXP->setTextDatum(TL_DATUM); - // squad health pips + // squad readout (live marine HP in M3; placeholder now) GFXP->setTextColor(nd::C_TEXTDIM); GFXP->drawString("SQUAD", 6, nd::HUD_Y + 30); - static const int HP[3] = { 4, 5, 2 }; // of 5 (M3 groundwork) - for (int i = 0; i < 3; i++) { + for (int i = 0; i < 2; i++) { int x = 48 + i * 58; for (int s = 0; s < 5; s++) { - uint16_t c = s < HP[i] ? nd::C_GOOD : nd::C_BORDER; - GFXP->fillRect(x + s * 8, nd::HUD_Y + 34, 6, 8, c); + GFXP->fillRect(x + s * 8, nd::HUD_Y + 34, 6, 8, nd::C_GOOD); } GFXP->setTextColor(nd::C_TEXTDIM); GFXP->drawString(String("M") + String(i + 1), x - 10, nd::HUD_Y + 30); } + + // transient message + if ((int32_t)(millis() - msgUntil) < 0) { + GFXP->setTextColor(nd::C_CURSOR); + GFXP->drawString(msgText, 200, nd::HUD_Y + 6); + } } static void renderCursor() { uint16_t c = (viewMode == VM_NETWORK) ? nd::C_PACKET : nd::C_CURSOR; if (viewMode == VM_CAMERAS) { - // tile snap highlight + crosshair int tx = curX / nd::TILE, ty = curY / nd::TILE; GFXP->drawRect(tx * nd::TILE, ty * nd::TILE, nd::TILE, nd::TILE, c); GFXP->drawCircle(curX, curY, 3, c); @@ -560,7 +852,6 @@ static void renderCursor() } } -// CRT freeze tint: scanlines over the view + status text (DESIGN.md §4) static void renderFreezeTint() { for (int y = 0; y < nd::VIEW_H; y += 3) { @@ -581,7 +872,6 @@ static void render() renderBeacon(); renderHud(); - // HUD separator (flashes when the view mode switches) uint16_t bc = (int32_t)(millis() - viewFlashUntil) < 0 ? nd::C_CURSOR : nd::C_BORDER; GFXP->drawFastHLine(nd::HUD_X, nd::HUD_Y - 1, nd::HUD_W, bc); if ((int32_t)(millis() - viewFlashUntil) < 0) { @@ -592,9 +882,6 @@ static void render() if (paused) renderFreezeTint(); } -// --------------------------------------------------------------------------- -// Boot screen -// --------------------------------------------------------------------------- static void drawBoot() { GFXP->fillScreen(TFT_BLACK); @@ -606,9 +893,9 @@ static void drawBoot() GFXP->drawString("BREACH & BOARD", 160, 108); GFXP->setTextFont(2); GFXP->setTextColor(nd::C_TEXTDIM); - GFXP->drawString("M1 // SANDBOX", 160, 136); + GFXP->drawString("M2 // VERTICAL SLICE", 160, 136); GFXP->drawString("p: cameras/network space: freeze", 160, 158); - GFXP->drawString("ball: cursor enter: select", 160, 174); + GFXP->drawString("ball: cursor enter: select x: sever", 160, 174); GFXP->setTextDatum(TL_DATUM); GFXP->setTextFont(1); } @@ -619,12 +906,11 @@ static void drawBoot() static void hardwareInit() { Serial.begin(115200); - Serial.println("NetDeck M1 — hardware sandbox"); + Serial.println("NetDeck M2 — vertical slice (network & traces)"); - pinMode(BOARD_POWERON, OUTPUT); // power rail first (battery boot) + pinMode(BOARD_POWERON, OUTPUT); digitalWrite(BOARD_POWERON, HIGH); - // CS lines high during init pinMode(BOARD_SDCARD_CS, OUTPUT); pinMode(RADIO_CS_PIN, OUTPUT); pinMode(BOARD_TFT_CS, OUTPUT); @@ -661,13 +947,13 @@ void setup() hardwareInit(); #ifndef EMULATOR - // second buffer for flicker-free full-frame pushes fb.setColorDepth(16); if (!fb.createSprite(tft.width(), tft.height())) Serial.println("NetDeck: framebuffer alloc failed (blank screen)"); #endif drawBoot(); + resetScenario(); stateT0 = millis(); lastFrameMs = stateT0; } @@ -680,31 +966,28 @@ void loop() if (now - stateT0 >= nd::BOOT_MS) { gameState = ST_RUN; stateT0 = now; - // swallow stale keyboard bytes + trackball edges from floating pins for (int i = 0; i < 8; i++) { if (Wire.requestFrom((uint8_t)0x55, (uint8_t)16) == 0) break; } resetTrackball(); - Serial.println("[boot] entering sandbox (view: cameras)"); + Serial.println("[boot] encounter loaded (paused, cameras view)"); } delay(1); return; } - // frame pacing ~30 fps static uint32_t nextFrame = 0; if ((int32_t)(now - nextFrame) < 0) { delay(1); return; } nextFrame = now + nd::FRAME_MS; uint32_t dt = now - lastFrameMs; lastFrameMs = now; - if (dt > 200) dt = 200; // clamp hiccups (debug stalls, USB pauses) + if (dt > 200) dt = 200; applyTrackball(); pollTouch(); pollKeyboard(); - // fixed-timestep simulation (DESIGN.md §6) if (!paused) { simAcc += dt; while (simAcc >= nd::SIM_TICK_MS) { diff --git a/src/netdeck/MVP.md b/src/netdeck/MVP.md new file mode 100644 index 0000000..fd4d900 --- /dev/null +++ b/src/netdeck/MVP.md @@ -0,0 +1,75 @@ +To validate the core premise of **NetDeck: Breach & Board**—specifically whether *pausing time to manipulate a network graph while watching an autonomous squad survive a room breach* feels tense, readable, and fun on a 320x240 screen—you only need **one single room-breach encounter**. + +Strip out sector maps, upgrades, multiple classes, oxygen systems, and procedural generation. Build a single, self-contained **Vertical Slice Sandbox** with these exact features: + +--- + +### 1. Physical Deck Pane (184x192) — The Combat Arena + +* **One Hardcoded 3-Room Floorplan:** +* *Room 1 (Airlock):* Where your squad spawns safely out of enemy line-of-sight. +* *Room 2 (Main Corridor):* Contains 2 low-cover crates and 2 patrolling/stationary security droids. +* *Room 3 (Server Room):* Guarded by 1 heavy droid + 1 automated ceiling turret, housing the objective terminal. + + +* **2 Identical Marines (No Classes Yet):** +* Represented by simple colored `8x8` or `12x12` sprites with a tiny overhead health bar. +* **Pathfinding:** Simple BFS/A* toward a single player-placed **Priority Beacon** (trackball click on any walkable floor tile). +* **Combat AI:** If an enemy is within range and line-of-sight (simple Bresenham tile raycast), stop and fire periodic hitscan/tracer lines. Standing adjacent to a cover crate cuts incoming hit chance by 50%. + + +* **2 Enemy Types:** +* *Security Droid:* Basic HP, shoots at marines. +* *Ceiling Turret:* Stationary, high rate of fire, shreds marines in seconds unless hacked or bypassed. + + +* **1 Interactive Blast Door:** Separates Room 2 and Room 3. Can be toggled open/closed via the network pane to trap droids or buy time. + +### 2. Sub-Net Pane (136x192) — The Hacking Graph + +* **4 Hardcoded Nodes:** +1. `[AIRLOCK]` (Your starting root node). +2. `[JUNCTION]` (Unprotected bridge node). +3. `[DOOR_CTRL]` (Connected to Junction — toggles the blast door between Rooms 2 and 3). +4. `[HIVE_CORE]` (Connected to Junction — protected by a 3-second ICE lock; controls the droids and turret). + + +* **Link Routing & Severing:** +* Clicking an adjacent node from an already-compromised node starts building a link (animated dotted line turning solid over 1.5s, or 3.0s if ICE-locked). +* Pressing **`X`** while hovering over a link immediately severs it. + + +* **Only 2 Exploit Daemons (Keys `1` and `2`):** +* You only need two contrasting verbs to test the tactical loop: +1. **`1: FRENZY` (Offensive Chaos):** Requires an active link to `[HIVE_CORE]`. For 5 seconds, droids and the turret target the closest entity (including each other). +2. **`2: BLIND` (Tactical Utility):** Requires an active link to `[HIVE_CORE]`. For 6 seconds, droids/turret cannot fire, giving your squad time to cross open floor into cover. + + + + +* **1 Enemy Counter-Measure (The Red Trace):** +* As soon as your link to `[HIVE_CORE]` finishes cracking, a red pulse spawns at `[HIVE_CORE]` and travels back toward `[AIRLOCK]` over **4 seconds**. +* If it hits `[AIRLOCK]`, your link drops, your deck locks out for 3 seconds ("OVERHEAT"), and a reinforcement droid spawns. Severing the link with `X` before it arrives resets the trace safely. + + + +### 3. Minimal HUD & Flow Control (320x48) + +* **`Space` (Tactical Pause):** Freezes the 20 Hz simulation tick instantly and draws a subtle `"PAUSED"` border/tint so you can calmly queue a link or move the squad beacon. +* **`Tab` (Pane Snap):** Warps the cursor between the center of the Left Pane and Right Pane so you never waste time scrolling the trackball across the whole screen. +* **HUD Readouts:** Just `[1:FRENZY] [2:BLIND]`, a `TEMP` bar (or cooldown timer), and a `RESET (R)` hotkey so you can replay the 60-second scenario instantly after winning or wiping. + +--- + +### What to Intentionally Cut from the MVP + +To keep this buildable in a few evenings, ruthlessly exclude: + +* **RAM / Bandwidth math:** Use simple per-daemon cooldown timers instead of a resource pool. +* **Procedural map/graph generation:** Hand-tune the single 3-room layout until the timing between squad movement, ICE cracking, and the 4-second red trace feels razor-sharp. +* **Sound effects / SD card loading:** Compile your `8x8` sprites and map arrays directly into `const` headers in Flash. +* **Menus, title screens, and progression:** Boot straight into the paused encounter; on win/loss, show a 1-line banner (`BREACH SUCCESS` / `SQUAD KIA`) and let `R` reset the state struct. + +### The Litmus Test for This MVP + +Once this slice is running on the T-Deck, play it 5 times in a row. If you find yourself naturally hitting `Space` when the turret opens fire, slamming the blast door shut via `[DOOR_CTRL]`, cracking `[HIVE_CORE]` while your squad hugs cover, triggering `1: FRENZY` to watch the turret wipe out the droids, and hitting `X` right before the red trace reaches your airlock—you know the core game loop works and deserves a full sector generator around it. diff --git a/src/netdeck/STATUS.md b/src/netdeck/STATUS.md index 4b009e5..706922b 100644 --- a/src/netdeck/STATUS.md +++ b/src/netdeck/STATUS.md @@ -8,7 +8,7 @@ milestone lands. | --- | --- | --- | | **M0 — Emulator** | SDL2 emulator support + M1 surface tested locally | **done** | | **M1 — Hardware Sandbox** | Full-frame sprite rendering to ST7789, shared tactical view + HUD, cursor, `Space` freeze, `P` view switch | **compiled + emulator-verified; on-device check pending** | -| M2 — Network Graph & Traces | Node graph in Network view (door nodes on bulkhead tiles), link routing, ICE crack, red trace + `X` sever | planned | +| M2 — Network Graph & Traces | 4-node sub-net in shared space (AIRLK→JUNC→DOOR/HIVE), animated link routing (1.5 s / 3.0 s ICE), door control, red trace → feedback spike + OVERHEAT, `X` sever, `R` reset | **done (emulator-verified)** | | M3 — Squad vs. Droids | Ship floorplan in Cameras view, 3 marines → beacon, 4 droids, gunfire | planned | | M4 — Cyber-Physical Bridge | Hive link + `1` FRENZY.EXE turns droids on each other (shared coordinate space) | planned | @@ -56,3 +56,35 @@ milestone lands. 4. `Space` freezes (CRT scanlines, sim/packets halt); cursor stays live. 5. Trackball: smooth momentum cursor, tile snap in Cameras, node targeting in Network; Enter = beacon drop / node select; screen tap works too. + +## M2 (done — emulator-verified) + +Implements the sub-net half of the MVP vertical slice (`MVP.md` §1–§3, +validation spec added in this commit) on the shared 320x192 coordinate space: + +- **3-room floorplan** (airlock / main corridor / server room) with the + Room2/Room3 blast door (`+`) and the objective terminal `T`. +- **4-node sub-net** pinned to map tiles: AIRLK root (always online) — + JUNC — DOOR_CTRL (on the blast door tile) / HIVE (3 s ICE). Click an + adjacent offline node to route a link: animated dotted line turning + solid over 1.5 s (3.0 s through ICE); offline until the build completes. +- **DOOR_CTRL** (once online) toggles the blast door open/closed — open + doors also un-block LOS/movement for the combat milestone. +- **`X` severs the hovered link** (distance cursor→segment): everything + beyond it drops, ICE progress resets; severing during a trace resets + the trace safely. +- **Red trace**: cracking HIVE spawns a 4 s red pulse back to AIRLK; + arrival = feedback spike → all links drop + 3 s OVERHEAT lockout + (`TEMP` bar). FRENZY/BLIND daemons are gated until a HIVE link is up + (effects land in M4). +- **`R` resets** the scenario instantly to the paused, re-armed state + (`resetScenario()`), which also fixes the AIRLK-root-online bug. +- Boot goes straight into the paused encounter; HUD shows daemon slots, + TEMP bar, and `R: RESET`. +- Emulator host (`emulator/src/main.cpp`): headless testing support — + repeatable `--tap "x,y@frame"` screen-tap injection and repeatable + `--type "text@frame"` scheduled keyboard input. +- Verified headlessly: full route→door→ICE→trace→feedback→cooldown run, + safe-sever run (trace reset, no spike), all gating messages + (NO HIVE LINK / NO UPLINK / OVERHEAT / LINK SEVERED / NO NODE), + and `r` reset; visual frame dumps inspected.