khallaandClaude Opus 5.5
32f953fc01
The game drew 2x2 px red dots per visited-sector neighbour (0x6c8580), in 64-tile steps and unrelated to the explored mask. Replaced by lines traced from the explored cells (2x2 tiles), simplified to 0.75 px, rebuilt while the map is open when the masks change. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
377 lines
14 KiB
C++
377 lines
14 KiB
C++
// The explored-area border on the large map (M) as a continuous line along
|
|
// the fog's edge.
|
|
//
|
|
// Request (2026-10-26): "the red outline on the mega map is choppy and feels
|
|
// weird"; replace it, following the explored area (option A).
|
|
//
|
|
// Measured (disassembly): cUI_Megamap::DrawVisitedBorder (0x6c8580, called by
|
|
// the map's render) draws one 2x2 px red dot (0xffff0000) per bit of a 100x100
|
|
// byte grid (world +0xb73c), at a fixed offset of 10 / 20 px from the sector's
|
|
// origin towards each neighbour. The grid marks unvisited sectors next to
|
|
// visited ones (sector flag 0x20000, set when the hero's sector becomes the
|
|
// centre of the active 3x3, 0x626603; rebuilt on load by 0x633230 and per
|
|
// sector change by 0x6332d0). So the line was dots in 64-tile steps, and it
|
|
// followed the sectors stood in, not the explored mask the fog shows (since
|
|
// the 10x map reveal, far inside the cleared area).
|
|
//
|
|
// The mod replaces the draw: the edges between explored and unexplored cells
|
|
// (2x2 tiles, game/engine/explored.h) of the map's 100x100 sectors are chained
|
|
// into polylines, simplified to within a pixel and drawn as 2 px lines in the
|
|
// game's red. The lines are rebuilt while the map is open whenever the masks
|
|
// changed (checked every 250 ms). Cells of a missing sector count as neither,
|
|
// so no line runs along the edge of the world.
|
|
|
|
#include <windows.h>
|
|
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include "game/engine/explored.h"
|
|
#include "game/ui/draw.h"
|
|
#include "game/ui/megamap.h"
|
|
#include "mods/widescreen.h"
|
|
#include "re/hook.h"
|
|
#include "re/log.h"
|
|
|
|
namespace mods::mapborder {
|
|
namespace {
|
|
|
|
// The map's sector grid (World_RebuildVisitedBorder 0x633230: 100x100).
|
|
constexpr int kMapSectors = 100;
|
|
constexpr int kMapCells = kMapSectors * game::kSectorCells;
|
|
constexpr uint32_t kColour = 0xffff0000; // the game's border colour (0x6c870e)
|
|
constexpr float kLineWidth = 2.0f; // the game's dots: 2x2 px
|
|
constexpr double kTolerance = 0.75; // map pixels a simplified line may deviate
|
|
constexpr DWORD kCheckIntervalMs = 250;
|
|
constexpr int kScreenHeight = 768;
|
|
|
|
enum class Cell : uint8_t { None, Unexplored, Explored };
|
|
|
|
struct Grid {
|
|
const uint8_t* masks[kMapSectors][kMapSectors];
|
|
|
|
void Load() {
|
|
for (int y = 0; y < kMapSectors; ++y) {
|
|
for (int x = 0; x < kMapSectors; ++x) {
|
|
masks[y][x] = game::SectorExploredMask(x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
Cell At(int x, int y) const {
|
|
if (x < 0 || y < 0 || x >= kMapCells || y >= kMapCells) {
|
|
return Cell::None;
|
|
}
|
|
const uint8_t* mask = masks[y / game::kSectorCells][x / game::kSectorCells];
|
|
if (!mask) {
|
|
return Cell::None;
|
|
}
|
|
return game::MaskCellExplored(mask, x % game::kSectorCells, y % game::kSectorCells) ? Cell::Explored
|
|
: Cell::Unexplored;
|
|
}
|
|
|
|
// FNV-1a over the masks and which sectors exist.
|
|
uint64_t Hash() const {
|
|
uint64_t hash = 0xcbf29ce484222325ull;
|
|
const auto add = [&](uint8_t byte) { hash = (hash ^ byte) * 0x100000001b3ull; };
|
|
for (const auto& row : masks) {
|
|
for (const uint8_t* mask : row) {
|
|
add(mask != nullptr);
|
|
for (size_t i = 0; mask && i < 128; ++i) {
|
|
add(mask[i]);
|
|
}
|
|
}
|
|
}
|
|
return hash;
|
|
}
|
|
};
|
|
|
|
struct Point {
|
|
double x, y;
|
|
};
|
|
|
|
// Cell corner -> map pixel: WorldToMapPixel is linear, so three points give
|
|
// it for the whole grid.
|
|
struct Projection {
|
|
Point origin, stepX, stepY;
|
|
|
|
static Point Corner(uint8_t* megamap, int cellX, int cellY) {
|
|
const float unitsPerCell = game::kExploredCellTiles * game::kWorldUnitsPerTile;
|
|
const game::Vec3 pixel = game::WorldToMapPixel(megamap, {cellX * unitsPerCell, cellY * unitsPerCell, 0});
|
|
return {pixel.x, pixel.y};
|
|
}
|
|
|
|
explicit Projection(uint8_t* megamap) {
|
|
origin = Corner(megamap, 0, 0);
|
|
const Point right = Corner(megamap, kMapCells, 0);
|
|
const Point down = Corner(megamap, 0, kMapCells);
|
|
stepX = {(right.x - origin.x) / kMapCells, (right.y - origin.y) / kMapCells};
|
|
stepY = {(down.x - origin.x) / kMapCells, (down.y - origin.y) / kMapCells};
|
|
}
|
|
|
|
Point operator()(int cellX, int cellY) const {
|
|
return {origin.x + cellX * stepX.x + cellY * stepY.x, origin.y + cellX * stepX.y + cellY * stepY.y};
|
|
}
|
|
};
|
|
|
|
// Corners on the cell grid, (kMapCells + 1)^2 of them.
|
|
uint32_t Key(int x, int y) {
|
|
return static_cast<uint32_t>(y) * (kMapCells + 1) + static_cast<uint32_t>(x);
|
|
}
|
|
|
|
struct Edge {
|
|
int x0, y0, x1, y1;
|
|
};
|
|
|
|
// Every side between an explored and an unexplored cell, clockwise around
|
|
// the explored cell (screen orientation, y down), so the edges of a border
|
|
// chain head to tail.
|
|
std::vector<Edge> BorderEdges(const Grid& grid) {
|
|
std::vector<Edge> edges;
|
|
for (int sy = 0; sy < kMapSectors; ++sy) {
|
|
for (int sx = 0; sx < kMapSectors; ++sx) {
|
|
const uint8_t* mask = grid.masks[sy][sx];
|
|
bool any = false;
|
|
for (int i = 0; mask && i < 128 && !any; ++i) {
|
|
any = mask[i] != 0;
|
|
}
|
|
if (!any) {
|
|
continue;
|
|
}
|
|
for (int ly = 0; ly < game::kSectorCells; ++ly) {
|
|
for (int lx = 0; lx < game::kSectorCells; ++lx) {
|
|
if (!game::MaskCellExplored(mask, lx, ly)) {
|
|
continue;
|
|
}
|
|
const int x = sx * game::kSectorCells + lx;
|
|
const int y = sy * game::kSectorCells + ly;
|
|
if (grid.At(x, y - 1) == Cell::Unexplored) {
|
|
edges.push_back({x, y, x + 1, y});
|
|
}
|
|
if (grid.At(x + 1, y) == Cell::Unexplored) {
|
|
edges.push_back({x + 1, y, x + 1, y + 1});
|
|
}
|
|
if (grid.At(x, y + 1) == Cell::Unexplored) {
|
|
edges.push_back({x + 1, y + 1, x, y + 1});
|
|
}
|
|
if (grid.At(x - 1, y) == Cell::Unexplored) {
|
|
edges.push_back({x, y + 1, x, y});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return edges;
|
|
}
|
|
|
|
using Chain = std::vector<std::pair<int, int>>;
|
|
|
|
// Edges chained into polylines: open ones (from a corner no edge ends at,
|
|
// at a missing sector) first, then the closed loops. Where two cells touch
|
|
// only at a corner, the chain turns right, staying around its own cell.
|
|
std::vector<Chain> ChainEdges(const std::vector<Edge>& edges) {
|
|
std::unordered_map<uint32_t, std::vector<size_t>> starting;
|
|
std::unordered_map<uint32_t, int> ending;
|
|
starting.reserve(edges.size());
|
|
ending.reserve(edges.size());
|
|
for (size_t i = 0; i < edges.size(); ++i) {
|
|
starting[Key(edges[i].x0, edges[i].y0)].push_back(i);
|
|
++ending[Key(edges[i].x1, edges[i].y1)];
|
|
}
|
|
std::vector<bool> used(edges.size(), false);
|
|
std::vector<Chain> chains;
|
|
const auto follow = [&](size_t first) {
|
|
Chain chain = {{edges[first].x0, edges[first].y0}};
|
|
size_t current = first;
|
|
for (;;) {
|
|
used[current] = true;
|
|
const Edge& e = edges[current];
|
|
chain.emplace_back(e.x1, e.y1);
|
|
const int dx = e.x1 - e.x0;
|
|
const int dy = e.y1 - e.y0;
|
|
size_t next = SIZE_MAX;
|
|
int bestTurn = 3;
|
|
for (size_t candidate : starting[Key(e.x1, e.y1)]) {
|
|
if (used[candidate]) {
|
|
continue;
|
|
}
|
|
const int cx = edges[candidate].x1 - edges[candidate].x0;
|
|
const int cy = edges[candidate].y1 - edges[candidate].y0;
|
|
// 0 right (-dy, dx), 1 straight, 2 left.
|
|
const int turn = (cx == -dy && cy == dx) ? 0 : (cx == dx && cy == dy) ? 1 : 2;
|
|
if (turn < bestTurn) {
|
|
bestTurn = turn;
|
|
next = candidate;
|
|
}
|
|
}
|
|
if (next == SIZE_MAX) {
|
|
break;
|
|
}
|
|
current = next;
|
|
}
|
|
chains.push_back(std::move(chain));
|
|
};
|
|
for (size_t i = 0; i < edges.size(); ++i) {
|
|
if (!used[i] && ending.find(Key(edges[i].x0, edges[i].y0)) == ending.end()) {
|
|
follow(i);
|
|
}
|
|
}
|
|
for (size_t i = 0; i < edges.size(); ++i) {
|
|
if (!used[i]) {
|
|
follow(i);
|
|
}
|
|
}
|
|
return chains;
|
|
}
|
|
|
|
double DistanceToSegment(const Point& p, const Point& a, const Point& b) {
|
|
const double dx = b.x - a.x;
|
|
const double dy = b.y - a.y;
|
|
const double length2 = dx * dx + dy * dy;
|
|
double t = length2 > 0 ? ((p.x - a.x) * dx + (p.y - a.y) * dy) / length2 : 0;
|
|
t = t < 0 ? 0 : t > 1 ? 1 : t;
|
|
return std::hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
|
|
}
|
|
|
|
// Douglas-Peucker: keeps first and last, and every point needed to stay
|
|
// within kTolerance of the original.
|
|
void Simplify(const std::vector<Point>& points, size_t first, size_t last, std::vector<Point>& out) {
|
|
double farthest = 0;
|
|
size_t index = first;
|
|
for (size_t i = first + 1; i < last; ++i) {
|
|
const double d = DistanceToSegment(points[i], points[first], points[last]);
|
|
if (d > farthest) {
|
|
farthest = d;
|
|
index = i;
|
|
}
|
|
}
|
|
if (farthest > kTolerance) {
|
|
Simplify(points, first, index, out);
|
|
Simplify(points, index, last, out);
|
|
} else {
|
|
out.push_back(points[last]);
|
|
}
|
|
}
|
|
|
|
std::vector<Point> SimplifiedLine(const Chain& chain, const Projection& project) {
|
|
std::vector<Point> points;
|
|
points.reserve(chain.size());
|
|
for (const auto& [x, y] : chain) {
|
|
points.push_back(project(x, y));
|
|
}
|
|
std::vector<Point> out = {points.front()};
|
|
if (points.size() < 2) {
|
|
return out;
|
|
}
|
|
// A closed loop is split at its point farthest from the start, so both
|
|
// halves have distinct ends.
|
|
size_t split = points.size() - 1;
|
|
if (chain.front() == chain.back()) {
|
|
double farthest = -1;
|
|
for (size_t i = 1; i + 1 < points.size(); ++i) {
|
|
const double d = std::hypot(points[i].x - points[0].x, points[i].y - points[0].y);
|
|
if (d > farthest) {
|
|
farthest = d;
|
|
split = i;
|
|
}
|
|
}
|
|
}
|
|
Simplify(points, 0, split, out);
|
|
if (split < points.size() - 1) {
|
|
Simplify(points, split, points.size() - 1, out);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Map-pixel line segments of the current border.
|
|
struct Segment {
|
|
float x0, y0, x1, y1;
|
|
};
|
|
std::vector<Segment> g_segments;
|
|
uint64_t g_hash = 0;
|
|
DWORD g_lastCheck = 0;
|
|
bool g_built = false;
|
|
|
|
void Rebuild(uint8_t* megamap) {
|
|
static Grid grid;
|
|
grid.Load();
|
|
const uint64_t hash = grid.Hash();
|
|
if (g_built && hash == g_hash) {
|
|
return;
|
|
}
|
|
const DWORD start = GetTickCount();
|
|
const Projection project(megamap);
|
|
const std::vector<Edge> edges = BorderEdges(grid);
|
|
const std::vector<Chain> chains = ChainEdges(edges);
|
|
g_segments.clear();
|
|
for (const Chain& chain : chains) {
|
|
const std::vector<Point> line = SimplifiedLine(chain, project);
|
|
for (size_t i = 1; i < line.size(); ++i) {
|
|
g_segments.push_back({static_cast<float>(line[i - 1].x), static_cast<float>(line[i - 1].y),
|
|
static_cast<float>(line[i].x), static_cast<float>(line[i].y)});
|
|
}
|
|
}
|
|
if (!g_built) {
|
|
re::Log("map border: %zu edges, %zu lines, %zu segments, %lu ms", edges.size(), chains.size(),
|
|
g_segments.size(), GetTickCount() - start);
|
|
}
|
|
g_hash = hash;
|
|
g_built = true;
|
|
}
|
|
|
|
void Draw(uint8_t* megamap, void* device) {
|
|
const DWORD now = GetTickCount();
|
|
if (!g_built || now - g_lastCheck >= kCheckIntervalMs) {
|
|
g_lastCheck = now;
|
|
Rebuild(megamap);
|
|
}
|
|
const float scrollX = static_cast<float>(game::MegamapScrollX(megamap));
|
|
const float scrollY = static_cast<float>(game::MegamapScrollY(megamap));
|
|
const float width = static_cast<float>(mods::widescreen::RenderWidth());
|
|
const float half = kLineWidth / 2;
|
|
static std::vector<game::ScreenVertex> vertices;
|
|
vertices.clear();
|
|
for (const Segment& s : g_segments) {
|
|
const float x0 = s.x0 - scrollX, y0 = s.y0 - scrollY;
|
|
const float x1 = s.x1 - scrollX, y1 = s.y1 - scrollY;
|
|
if ((x0 < -half && x1 < -half) || (x0 > width + half && x1 > width + half) ||
|
|
(y0 < -half && y1 < -half) || (y0 > kScreenHeight + half && y1 > kScreenHeight + half)) {
|
|
continue;
|
|
}
|
|
const float length = std::hypot(x1 - x0, y1 - y0);
|
|
if (length <= 0) {
|
|
continue;
|
|
}
|
|
// Along and across the segment, half the width each; the ends reach
|
|
// half the width further, closing the joints.
|
|
const float ax = (x1 - x0) / length * half, ay = (y1 - y0) / length * half;
|
|
const float nx = -ay, ny = ax;
|
|
const game::ScreenVertex a = {x0 - ax + nx, y0 - ay + ny, 0, 1, kColour, 0, 0, 0};
|
|
const game::ScreenVertex b = {x0 - ax - nx, y0 - ay - ny, 0, 1, kColour, 0, 0, 0};
|
|
const game::ScreenVertex c = {x1 + ax + nx, y1 + ay + ny, 0, 1, kColour, 0, 0, 0};
|
|
const game::ScreenVertex d = {x1 + ax - nx, y1 + ay - ny, 0, 1, kColour, 0, 0, 0};
|
|
vertices.insert(vertices.end(), {a, b, c, c, b, d});
|
|
}
|
|
if (!vertices.empty()) {
|
|
game::FillTriangles(device, vertices.data(), vertices.size());
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace mods::mapborder
|
|
|
|
namespace game {
|
|
|
|
// cUI_Megamap::DrawVisitedBorder (0x6c8580, thiscall (device), ret 4).
|
|
void __fastcall UiMegamap_DrawVisitedBorder(uint8_t* self, void* edx, void* device);
|
|
RE_HOOK(0x006c8580, UiMegamap_DrawVisitedBorder);
|
|
void __fastcall UiMegamap_DrawVisitedBorder(uint8_t* self, void*, void* device) {
|
|
if (self && device) {
|
|
mods::mapborder::Draw(self, device);
|
|
}
|
|
}
|
|
|
|
} // namespace game
|