boki/poe2-bot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactoring

Browse source
This commit is contained in:
Boki 2026-03-02 16:23:23 -05:00
parent fbd0ba445a
commit 18d8721dd5
68 changed files with 2187 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

166
src/Automata.Memory/TerrainReader.cs
View file

@ -1,166 +0,0 @@
using Serilog;
namespace Automata.Memory;
/// <summary>
/// Reads terrain walkability grid from AreaInstance, with caching and loading edge detection.
/// </summary>
public sealed class TerrainReader
{
private readonly MemoryContext _ctx;
private uint _cachedTerrainAreaHash;
private WalkabilityGrid? _cachedTerrain;
private bool _wasLoading;
public TerrainReader(MemoryContext ctx)
{
_ctx = ctx;
}
/// <summary>
/// Invalidates the terrain cache (called when LocalPlayer changes on zone change).
/// </summary>
public void InvalidateCache()
{
_cachedTerrain = null;
_cachedTerrainAreaHash = 0;
}
/// <summary>
/// Reads terrain data from AreaInstance into the snapshot.
/// Handles both inline and pointer-based terrain layouts.
/// </summary>
public void ReadTerrain(GameStateSnapshot snap, nint areaInstance)
{
var mem = _ctx.Memory;
var offsets = _ctx.Offsets;
if (!offsets.TerrainInline)
{
// Pointer-based: AreaInstance → TerrainList → first terrain → dimensions
var terrainListPtr = mem.ReadPointer(areaInstance + offsets.TerrainListOffset);
if (terrainListPtr == 0) return;
var terrainPtr = mem.ReadPointer(terrainListPtr);
if (terrainPtr == 0) return;
var dimsPtr = mem.ReadPointer(terrainPtr + offsets.TerrainDimensionsOffset);
if (dimsPtr == 0) return;
snap.TerrainCols = mem.Read<int>(dimsPtr);
snap.TerrainRows = mem.Read<int>(dimsPtr + 4);
if (snap.TerrainCols > 0 && snap.TerrainCols < 1000 &&
snap.TerrainRows > 0 && snap.TerrainRows < 1000)
{
snap.TerrainWidth = snap.TerrainCols * offsets.SubTilesPerCell;
snap.TerrainHeight = snap.TerrainRows * offsets.SubTilesPerCell;
}
else
{
snap.TerrainCols = 0;
snap.TerrainRows = 0;
}
return;
}
// Inline mode: TerrainStruct is inline at AreaInstance + TerrainListOffset
var terrainBase = areaInstance + offsets.TerrainListOffset;
var cols = (int)mem.Read<long>(terrainBase + offsets.TerrainDimensionsOffset);
var rows = (int)mem.Read<long>(terrainBase + offsets.TerrainDimensionsOffset + 8);
if (cols <= 0 || cols >= 1000 || rows <= 0 || rows >= 1000)
return;
snap.TerrainCols = cols;
snap.TerrainRows = rows;
snap.TerrainWidth = cols * offsets.SubTilesPerCell;
snap.TerrainHeight = rows * offsets.SubTilesPerCell;
// While loading, clear cached terrain and don't read (data is stale/invalid)
if (snap.IsLoading)
{
_cachedTerrain = null;
_cachedTerrainAreaHash = 0;
return;
}
// Loading just finished — clear cache to force a fresh read
if (_wasLoading)
{
_cachedTerrain = null;
_cachedTerrainAreaHash = 0;
}
// Return cached grid if same area
if (_cachedTerrain != null && _cachedTerrainAreaHash == snap.AreaHash)
{
snap.Terrain = _cachedTerrain;
snap.TerrainWalkablePercent = CalcWalkablePercent(_cachedTerrain);
return;
}
// Read GridWalkableData StdVector (begin/end/cap pointers)
var gridVecOffset = offsets.TerrainWalkableGridOffset;
var gridBegin = mem.ReadPointer(terrainBase + gridVecOffset);
var gridEnd = mem.ReadPointer(terrainBase + gridVecOffset + 8);
if (gridBegin == 0 || gridEnd <= gridBegin)
return;
var gridDataSize = (int)(gridEnd - gridBegin);
if (gridDataSize <= 0 || gridDataSize > 16 * 1024 * 1024)
return;
var bytesPerRow = mem.Read<int>(terrainBase + offsets.TerrainBytesPerRowOffset);
if (bytesPerRow <= 0 || bytesPerRow > 0x10000)
return;
var gridWidth = cols * offsets.SubTilesPerCell;
var gridHeight = rows * offsets.SubTilesPerCell;
var rawData = mem.ReadBytes(gridBegin, gridDataSize);
if (rawData is null)
return;
// Unpack 4-bit nibbles: each byte → 2 cells
var data = new byte[gridWidth * gridHeight];
for (var row = 0; row < gridHeight; row++)
{
var rowStart = row * bytesPerRow;
for (var col = 0; col < gridWidth; col++)
{
var byteIndex = rowStart + col / 2;
if (byteIndex >= rawData.Length) break;
data[row * gridWidth + col] = (col % 2 == 0)
? (byte)(rawData[byteIndex] & 0x0F)
: (byte)((rawData[byteIndex] >> 4) & 0x0F);
}
}
var grid = new WalkabilityGrid(gridWidth, gridHeight, data);
snap.Terrain = grid;
snap.TerrainWalkablePercent = CalcWalkablePercent(grid);
_cachedTerrain = grid;
_cachedTerrainAreaHash = snap.AreaHash;
Log.Information("Terrain grid read: {W}x{H} ({Cols}x{Rows} cells), {Pct}% walkable",
gridWidth, gridHeight, cols, rows, snap.TerrainWalkablePercent);
}
/// <summary>
/// Updates the loading edge detection state. Call after ReadTerrain.
/// </summary>
public void UpdateLoadingEdge(bool isLoading)
{
_wasLoading = isLoading;
}
public static int CalcWalkablePercent(WalkabilityGrid grid)
{
var walkable = 0;
for (var i = 0; i < grid.Data.Length; i++)
if (grid.Data[i] != 0) walkable++;
return grid.Data.Length > 0 ? (int)(100L * walkable / grid.Data.Length) : 0;
}
}