Fog of war: LOS-derived current/historical visibility bitmaps + rendering
Replace the fading visibility[] stub with two bitmaps over the tile grid: fogNow (visible this tick) and fogSeen (persistent historical memory), re-derived each sim tick via revealLos() Bresenham raycasts from: - each living marine's 8-tile sight window (= marine fire range, so the squad never shoots into darkness), and - each online network node uncovering its connected tiles (3-tile window). Rendering (renderMap): never-seen -> flat dark gray, historical -> luma grayscale via gray565(), current -> full palette. Hostiles on non-visible tiles are hidden in renderUnits. Ad-hoc revealTile() stamps (marine step, door/HIVE links, hand-placed airlock tiles) removed; fog refreshes on door toggle and scenario reset. Tests: 5 new unit tests (initial reveal, wall blocking with face render, historical persistence, node uncover/sever, gray565 channels) plus a regression pinning fog sight >= marine fire range.
This commit is contained in:
+125
-11
@@ -333,6 +333,8 @@ static void playTraceProgress()
|
||||
sound.play(e);
|
||||
}
|
||||
|
||||
static void updateFog(); // fwd decl: fog recompute lives below the unit layer
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Sub-net logic
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -388,6 +390,7 @@ static void tryLink(int node)
|
||||
doorOpen = !doorOpen;
|
||||
if (doorOpen) playDoorOpen();
|
||||
else playDoorClose();
|
||||
updateFog(); // the door tile changes the squad's sightlines
|
||||
Serial.printf("[net] DOOR_CTRL: blast door %s\n", doorOpen ? "OPEN" : "CLOSED");
|
||||
flashMsg(doorOpen ? "DOOR OPEN" : "DOOR CLOSED");
|
||||
return;
|
||||
@@ -613,6 +616,51 @@ static bool losClear(int x0, int y0, int x1, int y1)
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fog of War (DESIGN.md §5.D): two bitmaps over the tile grid
|
||||
// fogSeen[i] — historical: the tile has been seen at least once
|
||||
// fogNow[i] — current: visible to the squad by LOS, or uncovered by an
|
||||
// online network node
|
||||
// Rendering: neither -> dark gray unknown, seen only -> grayscale memory,
|
||||
// visible now -> full palette color.
|
||||
// ---------------------------------------------------------------------------
|
||||
static uint8_t fogNow[nd::TILE_COLS * nd::TILE_ROWS];
|
||||
static uint8_t fogSeen[nd::TILE_COLS * nd::TILE_ROWS];
|
||||
|
||||
// squad sight radius (tiles) — LOS rays from each marine reveal this window.
|
||||
// MUST be >= the marines' fire range (STATS[U_MARINE].rng2 = 16*16 half-tiles²
|
||||
// = 8.0 tiles): acquireTarget() uses the same losClear ray, so any tile a
|
||||
// marine can shoot from must be revealed, or the squad fires into darkness.
|
||||
// (Enemies may still outrange this — the ceiling turret fires from 10.5.)
|
||||
static const int FOG_SIGHT_R = 8;
|
||||
// online network nodes uncover their connected tiles within this radius
|
||||
static const int FOG_NODE_R = 3;
|
||||
|
||||
// unknown-space color (RGB565): flat dark gray, no floorplan detail
|
||||
constexpr uint16_t C_FOG_UNKNOWN = 0x2108;
|
||||
|
||||
// reveal every tile visible from (cx,cy) within radius r: circular window,
|
||||
// one Bresenham ray per tile. Walls and closed blast doors block the ray
|
||||
// mid-flight, but a blocking tile that IS the ray target still renders
|
||||
// (losClear ignores its endpoints), so room outlines are remembered.
|
||||
static void revealLos(int cx, int cy, int r)
|
||||
{
|
||||
int r2 = r * r;
|
||||
for (int dy = -r; dy <= r; dy++) {
|
||||
int dyy = dy * dy;
|
||||
for (int dx = -r; dx <= r; dx++) {
|
||||
if (dx * dx + dyy > r2) continue;
|
||||
int tx = cx + dx, ty = cy + dy;
|
||||
if (tx < 0 || ty < 0 || tx >= nd::TILE_COLS || ty >= nd::TILE_ROWS)
|
||||
continue;
|
||||
if ((dx || dy) && !losClear(cx, cy, tx, ty)) continue;
|
||||
int i = tileIdx(tx, ty);
|
||||
fogNow[i] = 1;
|
||||
fogSeen[i] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// adjacent to a cover crate? (MVP: halves incoming hit chance)
|
||||
// (unit index, not a reference — see the planPath() note)
|
||||
static bool inCover(int ui)
|
||||
@@ -790,6 +838,8 @@ static void unitMove(int i)
|
||||
u.hasPath = false; // door shut / another unit in the way
|
||||
return;
|
||||
}
|
||||
// fog of war: tile visibility re-derives from the marine's new position
|
||||
// in updateFog() at the end of the tick
|
||||
u.tx = nx;
|
||||
u.ty = ny;
|
||||
u.mvCd = STATS[u.kind].speed;
|
||||
@@ -866,6 +916,32 @@ static void stepUnits()
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fog of War recompute (DESIGN.md §5.D)
|
||||
// ---------------------------------------------------------------------------
|
||||
// Current visibility drains into the historical bitmap (seen-once stays
|
||||
// remembered), then re-derives from the world state:
|
||||
// - each living marine casts LOS rays over its sight window
|
||||
// - each ONLINE network node uncovers its connected tiles (the room around
|
||||
// the node — cyberspace access lights up physical space)
|
||||
// Runs once per sim tick, after units/network stepped, plus after door
|
||||
// toggles and scenario resets so the fog never goes stale.
|
||||
static void updateFog()
|
||||
{
|
||||
const int N = nd::TILE_COLS * nd::TILE_ROWS;
|
||||
for (int i = 0; i < N; i++)
|
||||
if (fogNow[i]) fogSeen[i] = 1;
|
||||
for (int i = 0; i < N; i++) fogNow[i] = 0;
|
||||
|
||||
for (int i = 0; i < 7; i++) {
|
||||
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 < 4; i++)
|
||||
if (nodeOnline[i])
|
||||
revealLos(NODES[i].tx, NODES[i].ty, FOG_NODE_R);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Scenario reset (MVP: R replays the 60-second scenario instantly)
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -895,6 +971,14 @@ static void resetScenario()
|
||||
spawnUnit(5, U_TURRET, 33, 5);
|
||||
units[6].alive = false; // reinforcement slot
|
||||
|
||||
// fog of war starts blank: only what the marines see in the airlock and
|
||||
// the always-online [AIRLK] node's connected tiles is uncovered
|
||||
for (int i = 0; i < nd::TILE_COLS * nd::TILE_ROWS; i++) {
|
||||
fogNow[i] = 0;
|
||||
fogSeen[i] = 0;
|
||||
}
|
||||
updateFog();
|
||||
|
||||
scenario = SC_LIVE;
|
||||
paused = true;
|
||||
}
|
||||
@@ -1128,6 +1212,7 @@ static void stepSim()
|
||||
if (blindT > 0) blindT--;
|
||||
stepNetwork();
|
||||
stepUnits();
|
||||
updateFog(); // fog re-derives after this tick's movement + links
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -1154,31 +1239,57 @@ static uint16_t dim565(uint16_t c)
|
||||
return (uint16_t)((r << 11) | (g << 5) | b);
|
||||
}
|
||||
|
||||
// grayscale conversion for the historical fog layer: luma-weighted RGB565
|
||||
// components re-packed as a neutral gray (r = b = luma, g = 2*luma)
|
||||
static uint16_t gray565(uint16_t c)
|
||||
{
|
||||
uint32_t r = (c >> 11) & 0x1F;
|
||||
uint32_t g = (c >> 5) & 0x3F;
|
||||
uint32_t b = c & 0x1F;
|
||||
uint32_t lum = (r * 30 + (g * 59) / 2 + b * 11) / 100; // 0..31
|
||||
return (uint16_t)((lum << 11) | ((lum * 2) << 5) | lum);
|
||||
}
|
||||
|
||||
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++) {
|
||||
char t = row[tx];
|
||||
int fi = tileIdx(tx, ty);
|
||||
bool now = fogNow[fi]; // in squad LOS / node reveal right now
|
||||
bool seen = fogSeen[fi]; // historical: seen at least once
|
||||
|
||||
// --- Fog of War layers (DESIGN.md §5.D) ---
|
||||
// never seen -> flat dark gray (unknown space)
|
||||
// seen, not now -> grayscale memory of the tile
|
||||
// visible now -> full palette color
|
||||
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;
|
||||
if (!seen) c = C_FOG_UNKNOWN;
|
||||
else if (!now) c = gray565(c);
|
||||
|
||||
// the blast door: open frame when open (fog layers still apply)
|
||||
if (t == '+' && doorOpen && seen)
|
||||
c = now ? dim565(nd::C_FLOOR) : gray565(nd::C_FLOOR);
|
||||
GFXP->fillRect(tx * nd::TILE, ty * nd::TILE, nd::TILE, nd::TILE, c);
|
||||
if (t == '+' && doorOpen) {
|
||||
uint16_t dc = dim ? dim565(nd::C_DOOR) : nd::C_DOOR;
|
||||
if (t == '+' && doorOpen && seen) {
|
||||
uint16_t dc = now ? (dim ? dim565(nd::C_DOOR) : nd::C_DOOR)
|
||||
: gray565(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') {
|
||||
if (t == 'A' && seen) {
|
||||
GFXP->drawRect(tx * nd::TILE, ty * nd::TILE, nd::TILE, nd::TILE,
|
||||
dim ? dim565(nd::C_FLOOR) : nd::C_FLOOR);
|
||||
now ? (dim ? dim565(nd::C_FLOOR) : nd::C_FLOOR)
|
||||
: gray565(nd::C_FLOOR));
|
||||
}
|
||||
if (t == 'T') { // objective terminal: dark rack + cyan screen
|
||||
uint16_t dc = dim ? dim565(nd::C_HUDBG) : nd::C_HUDBG;
|
||||
if (t == 'T' && seen) { // objective terminal: dark rack + cyan screen
|
||||
uint16_t dc = now ? (dim ? dim565(nd::C_HUDBG) : nd::C_HUDBG)
|
||||
: gray565(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);
|
||||
uint16_t tc = now ? (dim ? dim565(nd::C_PACKET) : nd::C_PACKET)
|
||||
: gray565(nd::C_PACKET);
|
||||
GFXP->fillRect(tx * nd::TILE + 1, ty * nd::TILE + 1, 6, 3, tc);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1442,6 +1553,9 @@ static void renderUnits(bool full)
|
||||
for (int i = 0; i < 7; i++) {
|
||||
const Unit &u = units[i];
|
||||
if (!u.alive) continue;
|
||||
// fog of war: hostiles on tiles the squad can't currently see are
|
||||
// hidden (marines are the sight source, so they always render)
|
||||
if (u.team == TEAM_DROID && !fogNow[tileIdx(u.tx, u.ty)]) continue;
|
||||
int px = unitPx(i), py = unitPy(i);
|
||||
uint16_t body, line;
|
||||
if (u.kind == U_MARINE) {
|
||||
|
||||
Reference in New Issue
Block a user