mirror of
https://github.com/Jacobwasbeast/LegacyWeaveLoader.git
synced 2026-08-05 17:11:14 +00:00
979 lines
35 KiB
C++
979 lines
35 KiB
C++
#include "WorldIdRemap.h"
|
|
|
|
#include "GameObjectFactory.h"
|
|
#include "IdRegistry.h"
|
|
#include "LogUtil.h"
|
|
#include "ModStrings.h"
|
|
#include "PdbParser.h"
|
|
|
|
#include <Windows.h>
|
|
#include <cstddef>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <mutex>
|
|
#include <new>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
namespace
|
|
{
|
|
constexpr wchar_t kNamespaceTagKey[] = L"weaveloader:id";
|
|
constexpr wchar_t kNamespaceKindTagKey[] = L"weaveloader:kind";
|
|
constexpr char kMissingBlockId[] = "weaveloader:missing_block";
|
|
constexpr char kMissingItemId[] = "weaveloader:missing_item";
|
|
constexpr int kMissingBlockVanillaFallbackId = 7; // bedrock
|
|
constexpr int kMissingBlockDescriptionId = 900000;
|
|
constexpr int kMissingItemDescriptionId = 900001;
|
|
constexpr ptrdiff_t kItemIdOffset = 0x20;
|
|
constexpr ptrdiff_t kItemTagOffset = 0x28;
|
|
constexpr unsigned char kTagStringId = 8;
|
|
constexpr unsigned char kTagCompoundId = 10;
|
|
constexpr int kChunkWidth = 16;
|
|
constexpr int kChunkMaxY = 256;
|
|
|
|
using TagNewTag_fn = void* (__fastcall *)(unsigned char type, const std::wstring& name);
|
|
using LevelChunkGetTile_fn = int (__fastcall *)(void* thisPtr, int x, int y, int z);
|
|
using LevelChunkSetTile_fn = bool (__fastcall *)(void* thisPtr, int x, int y, int z, int tile);
|
|
using LevelChunkGetPos_fn = void* (__fastcall *)(void* thisPtr);
|
|
using LevelChunkGetHighestNonEmptyY_fn = int (__fastcall *)(void* thisPtr);
|
|
using CompressedTileStorageSet_fn = void (__fastcall *)(void* thisPtr, int x, int y, int z, int val);
|
|
|
|
struct CompoundTagLayout
|
|
{
|
|
void* vtable;
|
|
std::wstring name;
|
|
std::unordered_map<std::wstring, void*> tags;
|
|
};
|
|
|
|
struct StringTagLayout
|
|
{
|
|
void* vtable;
|
|
std::wstring name;
|
|
std::wstring data;
|
|
};
|
|
|
|
std::once_flag s_symbolInitOnce;
|
|
TagNewTag_fn s_tagNewTag = nullptr;
|
|
void* s_tileArray = nullptr;
|
|
LevelChunkGetTile_fn s_levelChunkGetTile = nullptr;
|
|
LevelChunkSetTile_fn s_levelChunkSetTile = nullptr;
|
|
LevelChunkGetPos_fn s_levelChunkGetPos = nullptr;
|
|
LevelChunkGetHighestNonEmptyY_fn s_levelChunkGetHighestNonEmptyY = nullptr;
|
|
CompressedTileStorageSet_fn s_compressedTileStorageSet = nullptr;
|
|
|
|
// LevelChunk layout: vtable(8) + byteArray(16) = 24, then lowerBlocks at 24, upperBlocks at 32
|
|
static constexpr size_t kLevelChunkLowerBlocksOffset = 24;
|
|
bool s_missingPlaceholdersReady = false;
|
|
int s_chunkRemapLogCount = 0;
|
|
int s_chunkSaveLogCount = 0;
|
|
int s_chunkIoLogCount = 0;
|
|
std::mutex s_chunkMetaMutex;
|
|
|
|
struct ChunkMeta
|
|
{
|
|
void* storagePtr = nullptr;
|
|
int x = 0;
|
|
int z = 0;
|
|
};
|
|
std::unordered_map<void*, ChunkMeta> s_chunkMetaByPtr;
|
|
std::unordered_map<void*, std::unordered_map<int, std::string>> s_loadedNamespaceByChunk;
|
|
std::unordered_map<std::string, std::unordered_map<int, std::string>> s_chunkNamespaceCache;
|
|
|
|
struct ConsoleSavePathLayout
|
|
{
|
|
std::wstring path;
|
|
explicit ConsoleSavePathLayout(const std::wstring& p) : path(p) {}
|
|
};
|
|
|
|
struct McRegionChunkStorageLayout
|
|
{
|
|
void* vtable;
|
|
std::wstring prefix;
|
|
void* saveFile;
|
|
};
|
|
|
|
struct ChunkPosLayout
|
|
{
|
|
int x;
|
|
int z;
|
|
};
|
|
|
|
struct RuntimeConsoleSaveFile
|
|
{
|
|
virtual ~RuntimeConsoleSaveFile() = default;
|
|
virtual void* createFile(const ConsoleSavePathLayout& fileName) = 0;
|
|
virtual void deleteFile(void* fileEntry) = 0;
|
|
virtual void setFilePointer(void* fileEntry, long distance, long* distanceHigh, unsigned long moveMethod) = 0;
|
|
virtual int writeFile(void* fileEntry, const void* buffer, unsigned long bytesToWrite, unsigned long* bytesWritten) = 0;
|
|
virtual int zeroFile(void* fileEntry, unsigned long bytesToWrite, unsigned long* bytesWritten) = 0;
|
|
virtual int readFile(void* fileEntry, void* buffer, unsigned long bytesToRead, unsigned long* bytesRead) = 0;
|
|
virtual int closeHandle(void* fileEntry) = 0;
|
|
virtual void finalizeWrite() = 0;
|
|
virtual void tick() = 0;
|
|
};
|
|
|
|
struct RuntimeFileEntryLayout
|
|
{
|
|
wchar_t filename[64];
|
|
unsigned int length;
|
|
unsigned int startOffsetOrRegion;
|
|
long long lastModifiedTime;
|
|
unsigned int currentFilePointer;
|
|
};
|
|
static bool IsReadableRange(const void* ptr, size_t bytes);
|
|
|
|
static bool IsValidChunkStorage(const void* storagePtr)
|
|
{
|
|
return storagePtr && IsReadableRange(storagePtr, sizeof(void*) + sizeof(std::wstring) + sizeof(void*));
|
|
}
|
|
|
|
static std::wstring MakeChunkNamespacePathCoordsOnly(int chunkX, int chunkZ)
|
|
{
|
|
std::wstringstream ss;
|
|
ss << L"modloader\\blockns_v3\\c." << chunkX << L"." << chunkZ << L".txt";
|
|
return ss.str();
|
|
}
|
|
|
|
static std::string MakeChunkCacheKey(const McRegionChunkStorageLayout* storage, int chunkX, int chunkZ)
|
|
{
|
|
const std::wstring path = MakeChunkNamespacePathCoordsOnly(chunkX, chunkZ);
|
|
std::string key(path.begin(), path.end());
|
|
return key;
|
|
}
|
|
|
|
static bool SaveReadAllText(void* saveFile, const std::wstring& path, std::string* outText)
|
|
{
|
|
if (!saveFile || !outText || !IsReadableRange(saveFile, sizeof(void*)))
|
|
return false;
|
|
auto* save = reinterpret_cast<RuntimeConsoleSaveFile*>(saveFile);
|
|
|
|
ConsoleSavePathLayout savePath(path);
|
|
void* fileEntry = save->createFile(savePath);
|
|
if (!fileEntry)
|
|
return false;
|
|
save->setFilePointer(fileEntry, 0, nullptr, FILE_BEGIN);
|
|
|
|
if (!IsReadableRange(fileEntry, sizeof(RuntimeFileEntryLayout)))
|
|
{
|
|
save->closeHandle(fileEntry);
|
|
return false;
|
|
}
|
|
const auto* entry = reinterpret_cast<const RuntimeFileEntryLayout*>(fileEntry);
|
|
const unsigned int fileSize = entry->length;
|
|
// Hard cap for corrupted metadata; chunk namespace files should stay tiny.
|
|
if (fileSize > (1024u * 1024u))
|
|
{
|
|
save->closeHandle(fileEntry);
|
|
return false;
|
|
}
|
|
|
|
std::string text;
|
|
if (fileSize > 0)
|
|
{
|
|
text.resize(fileSize);
|
|
unsigned long bytesRead = 0;
|
|
const int ok = save->readFile(fileEntry, text.data(), fileSize, &bytesRead);
|
|
if (!ok)
|
|
{
|
|
save->closeHandle(fileEntry);
|
|
return false;
|
|
}
|
|
text.resize(bytesRead);
|
|
}
|
|
|
|
save->closeHandle(fileEntry);
|
|
*outText = std::move(text);
|
|
return true;
|
|
}
|
|
|
|
static bool SaveWriteAllText(void* saveFile, const std::wstring& path, const std::string& text)
|
|
{
|
|
if (!saveFile || !IsReadableRange(saveFile, sizeof(void*)))
|
|
return false;
|
|
auto* save = reinterpret_cast<RuntimeConsoleSaveFile*>(saveFile);
|
|
|
|
ConsoleSavePathLayout savePath(path);
|
|
void* fileEntry = save->createFile(savePath);
|
|
if (!fileEntry)
|
|
return false;
|
|
save->setFilePointer(fileEntry, 0, nullptr, FILE_BEGIN);
|
|
|
|
unsigned long bytesWritten = 0;
|
|
const int ok = save->writeFile(fileEntry, text.data(), static_cast<unsigned long>(text.size()), &bytesWritten);
|
|
save->closeHandle(fileEntry);
|
|
return ok && bytesWritten == text.size();
|
|
}
|
|
|
|
static bool WriteChunkNamespaceMap(
|
|
void* saveFile,
|
|
const std::wstring& path,
|
|
const std::unordered_map<int, std::string>& map);
|
|
|
|
static bool ReadChunkNamespaceMap(
|
|
void* saveFile,
|
|
const std::wstring& path,
|
|
std::unordered_map<int, std::string>* outMap)
|
|
{
|
|
if (!outMap)
|
|
return false;
|
|
outMap->clear();
|
|
|
|
std::string text;
|
|
if (!SaveReadAllText(saveFile, path, &text))
|
|
return false;
|
|
|
|
std::istringstream input(text);
|
|
std::string line;
|
|
int expectedEntries = -1;
|
|
int parsedEntries = 0;
|
|
while (std::getline(input, line))
|
|
{
|
|
if (line.empty())
|
|
continue;
|
|
|
|
if (expectedEntries < 0 && line.rfind("#count ", 0) == 0)
|
|
{
|
|
std::istringstream hs(line.substr(7));
|
|
int count = -1;
|
|
if (hs >> count && count >= 0)
|
|
expectedEntries = count;
|
|
continue;
|
|
}
|
|
|
|
std::istringstream ss(line);
|
|
int blockIndex = -1;
|
|
std::string namespacedId;
|
|
if (!(ss >> blockIndex >> namespacedId))
|
|
continue;
|
|
if (blockIndex < 0 || namespacedId.empty())
|
|
continue;
|
|
(*outMap)[blockIndex] = namespacedId;
|
|
++parsedEntries;
|
|
if (expectedEntries >= 0 && parsedEntries >= expectedEntries)
|
|
break;
|
|
}
|
|
if (expectedEntries < 0)
|
|
{
|
|
// Require explicit count header for safety; legacy files can contain stale tail bytes.
|
|
outMap->clear();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool IsLikelyNamespacedId(const std::string& s)
|
|
{
|
|
if (s.size() < 3 || s.size() > 200)
|
|
return false;
|
|
if (s.find(':') == std::string::npos)
|
|
return false;
|
|
for (char c : s)
|
|
{
|
|
if (c <= 0x20 || c == '\x7f')
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool ReadChunkNamespaceMapWithFallback(
|
|
const McRegionChunkStorageLayout* storage,
|
|
int chunkX,
|
|
int chunkZ,
|
|
std::unordered_map<int, std::string>* outMap)
|
|
{
|
|
if (!storage || !storage->saveFile || !outMap)
|
|
return false;
|
|
outMap->clear();
|
|
|
|
// Preferred stable path that does not depend on object layout/prefix decoding.
|
|
const std::wstring v3Path = MakeChunkNamespacePathCoordsOnly(chunkX, chunkZ);
|
|
if (ReadChunkNamespaceMap(storage->saveFile, v3Path, outMap) && !outMap->empty())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
static bool WriteChunkNamespaceMap(
|
|
void* saveFile,
|
|
const std::wstring& path,
|
|
const std::unordered_map<int, std::string>& map)
|
|
{
|
|
std::ostringstream out;
|
|
out << "#count " << map.size() << '\n';
|
|
for (const auto& entry : map)
|
|
out << entry.first << ' ' << entry.second << '\n';
|
|
return SaveWriteAllText(saveFile, path, out.str());
|
|
}
|
|
|
|
static int MakeBlockIndex(int x, int y, int z)
|
|
{
|
|
return ((y & 0xFF) << 8) | ((z & 0x0F) << 4) | (x & 0x0F);
|
|
}
|
|
|
|
static void DecodeBlockIndex(int index, int* x, int* y, int* z)
|
|
{
|
|
if (x) *x = index & 0x0F;
|
|
if (z) *z = (index >> 4) & 0x0F;
|
|
if (y) *y = (index >> 8) & 0xFF;
|
|
}
|
|
|
|
static bool TryGetChunkMeta(void* chunkPtr, ChunkMeta* outMeta)
|
|
{
|
|
if (!chunkPtr || !outMeta)
|
|
return false;
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
const auto it = s_chunkMetaByPtr.find(chunkPtr);
|
|
if (it == s_chunkMetaByPtr.end())
|
|
return false;
|
|
*outMeta = it->second;
|
|
return true;
|
|
}
|
|
|
|
static void SetChunkMeta(void* chunkPtr, void* storagePtr, int chunkX, int chunkZ)
|
|
{
|
|
if (!chunkPtr || !storagePtr)
|
|
return;
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
ChunkMeta& meta = s_chunkMetaByPtr[chunkPtr];
|
|
meta.storagePtr = storagePtr;
|
|
meta.x = chunkX;
|
|
meta.z = chunkZ;
|
|
}
|
|
|
|
static void SetLoadedChunkNamespaces(void* chunkPtr, const std::unordered_map<int, std::string>& entries)
|
|
{
|
|
if (!chunkPtr)
|
|
return;
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
s_loadedNamespaceByChunk[chunkPtr] = entries;
|
|
}
|
|
|
|
static bool TryGetLoadedChunkNamespaces(void* chunkPtr, std::unordered_map<int, std::string>* outEntries)
|
|
{
|
|
if (!chunkPtr || !outEntries)
|
|
return false;
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
const auto it = s_loadedNamespaceByChunk.find(chunkPtr);
|
|
if (it == s_loadedNamespaceByChunk.end())
|
|
return false;
|
|
*outEntries = it->second;
|
|
return true;
|
|
}
|
|
|
|
static bool TryResolveChunkCoords(void* levelChunkPtr, int* outX, int* outZ)
|
|
{
|
|
if (!levelChunkPtr || !s_levelChunkGetPos)
|
|
return false;
|
|
void* posPtr = s_levelChunkGetPos(levelChunkPtr);
|
|
if (!posPtr || !IsReadableRange(posPtr, sizeof(ChunkPosLayout)))
|
|
return false;
|
|
const auto* pos = reinterpret_cast<const ChunkPosLayout*>(posPtr);
|
|
if (outX) *outX = pos->x;
|
|
if (outZ) *outZ = pos->z;
|
|
return true;
|
|
}
|
|
|
|
static bool IsValidRuntimeTileId(int tileId)
|
|
{
|
|
if (tileId == 0)
|
|
return true;
|
|
if (tileId < 0 || tileId > 255)
|
|
return false;
|
|
if (!s_tileArray || !IsReadableRange(s_tileArray, sizeof(void*)))
|
|
return true; // can't validate, don't aggressively rewrite
|
|
|
|
// Tile::tiles is a global Tile** pointer variable in this build.
|
|
// Symbol points at the variable, so dereference once to get the actual table.
|
|
auto** tiles = *reinterpret_cast<void***>(s_tileArray);
|
|
if (!tiles || !IsReadableRange(tiles, sizeof(void*) * 256))
|
|
return true; // can't validate safely
|
|
|
|
return tiles[tileId] != nullptr;
|
|
}
|
|
|
|
static bool IsVanillaId(const std::string& namespacedId)
|
|
{
|
|
return namespacedId.rfind("minecraft:", 0) == 0;
|
|
}
|
|
|
|
static int ResolveSafeMissingBlockFallbackId()
|
|
{
|
|
int fallbackId = IdRegistry::Instance().GetMissingFallback(IdRegistry::Type::Block);
|
|
if (IsValidRuntimeTileId(fallbackId))
|
|
return fallbackId;
|
|
const int missingBlockId = IdRegistry::Instance().GetNumericId(IdRegistry::Type::Block, kMissingBlockId);
|
|
if (IsValidRuntimeTileId(missingBlockId))
|
|
return missingBlockId;
|
|
if (IsValidRuntimeTileId(kMissingBlockVanillaFallbackId))
|
|
return kMissingBlockVanillaFallbackId;
|
|
if (IsValidRuntimeTileId(1))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static bool IsTilePointerValid(int tileId)
|
|
{
|
|
if (tileId == 0)
|
|
return true;
|
|
if (tileId < 0 || tileId > 255)
|
|
return false;
|
|
if (!s_tileArray || !IsReadableRange(s_tileArray, sizeof(void*)))
|
|
return true;
|
|
auto** tiles = *reinterpret_cast<void***>(s_tileArray);
|
|
if (!tiles || !IsReadableRange(tiles, sizeof(void*) * 256))
|
|
return true;
|
|
return tiles[tileId] != nullptr;
|
|
}
|
|
|
|
static bool SafeSetChunkTile(void* levelChunkPtr, int x, int y, int z, int tileId)
|
|
{
|
|
if (!s_levelChunkSetTile)
|
|
return false;
|
|
|
|
// If the current block has no valid Tile pointer, setTileAndData will crash when it
|
|
// calls Tile::tiles[old]->onRemoving. Clear it to air first via direct block storage write.
|
|
if (s_levelChunkGetTile && s_compressedTileStorageSet && levelChunkPtr && IsReadableRange(levelChunkPtr, kLevelChunkLowerBlocksOffset + 16))
|
|
{
|
|
#if defined(_MSC_VER)
|
|
__try
|
|
{
|
|
int current = s_levelChunkGetTile(levelChunkPtr, x, y, z);
|
|
if (current != 0 && !IsTilePointerValid(current))
|
|
{
|
|
void* blocksPtr = *reinterpret_cast<void**>(static_cast<char*>(levelChunkPtr) + (y >= 128 ? kLevelChunkLowerBlocksOffset + 8 : kLevelChunkLowerBlocksOffset));
|
|
if (blocksPtr && IsReadableRange(blocksPtr, sizeof(void*)))
|
|
{
|
|
s_compressedTileStorageSet(blocksPtr, x, y % 128, z, 0);
|
|
}
|
|
}
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
// Ignore - we'll try setTile anyway
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if defined(_MSC_VER)
|
|
__try
|
|
{
|
|
s_levelChunkSetTile(levelChunkPtr, x, y, z, tileId);
|
|
return true;
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
return false;
|
|
}
|
|
#else
|
|
s_levelChunkSetTile(levelChunkPtr, x, y, z, tileId);
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
static std::string ResolveNamespacedItemId(int numericId)
|
|
{
|
|
std::string namespacedId = IdRegistry::Instance().GetStringId(IdRegistry::Type::Item, numericId);
|
|
if (!namespacedId.empty())
|
|
return namespacedId;
|
|
|
|
// Block-backed inventory entries are TileItems whose stored item ID matches the block ID.
|
|
return IdRegistry::Instance().GetStringId(IdRegistry::Type::Block, numericId);
|
|
}
|
|
|
|
static int ResolveNumericItemId(const std::string& namespacedId, int oldNumericId, const std::wstring& kind = L"")
|
|
{
|
|
if (namespacedId.empty())
|
|
return -1;
|
|
|
|
const bool wasKnownAsBlock = !IdRegistry::Instance().GetStringId(IdRegistry::Type::Block, oldNumericId).empty();
|
|
const bool wasKnownAsItem = !IdRegistry::Instance().GetStringId(IdRegistry::Type::Item, oldNumericId).empty();
|
|
|
|
if (wasKnownAsBlock && !wasKnownAsItem)
|
|
{
|
|
int blockId = IdRegistry::Instance().GetNumericId(IdRegistry::Type::Block, namespacedId);
|
|
if (blockId >= 0)
|
|
return blockId;
|
|
}
|
|
|
|
int itemId = IdRegistry::Instance().GetNumericId(IdRegistry::Type::Item, namespacedId);
|
|
if (itemId >= 0)
|
|
return itemId;
|
|
|
|
int blockId = IdRegistry::Instance().GetNumericId(IdRegistry::Type::Block, namespacedId);
|
|
if (blockId >= 0)
|
|
return blockId;
|
|
|
|
if (wasKnownAsBlock || kind == L"block")
|
|
return IdRegistry::Instance().GetMissingFallback(IdRegistry::Type::Block);
|
|
|
|
return IdRegistry::Instance().GetMissingFallback(IdRegistry::Type::Item);
|
|
}
|
|
|
|
static bool IsReadableRange(const void* ptr, size_t bytes);
|
|
|
|
static CompoundTagLayout* GetItemTag(void* itemInstancePtr)
|
|
{
|
|
if (!itemInstancePtr || !IsReadableRange(static_cast<const char*>(itemInstancePtr) + kItemTagOffset, sizeof(void*)))
|
|
return nullptr;
|
|
return *reinterpret_cast<CompoundTagLayout**>(static_cast<char*>(itemInstancePtr) + kItemTagOffset);
|
|
}
|
|
|
|
static CompoundTagLayout* EnsureItemTag(void* itemInstancePtr)
|
|
{
|
|
CompoundTagLayout* tag = GetItemTag(itemInstancePtr);
|
|
if (tag || !s_tagNewTag)
|
|
return tag;
|
|
|
|
void* createdTag = s_tagNewTag(kTagCompoundId, L"");
|
|
if (!createdTag)
|
|
return nullptr;
|
|
|
|
*reinterpret_cast<void**>(static_cast<char*>(itemInstancePtr) + kItemTagOffset) = createdTag;
|
|
return reinterpret_cast<CompoundTagLayout*>(createdTag);
|
|
}
|
|
|
|
static bool TryGetCompoundString(CompoundTagLayout* compoundTag, const std::wstring& key, std::wstring* outValue)
|
|
{
|
|
if (!compoundTag || !outValue)
|
|
return false;
|
|
|
|
const auto it = compoundTag->tags.find(key);
|
|
if (it == compoundTag->tags.end() || !it->second)
|
|
return false;
|
|
|
|
const auto* stringTag = reinterpret_cast<const StringTagLayout*>(it->second);
|
|
*outValue = stringTag->data;
|
|
return true;
|
|
}
|
|
|
|
static bool PutCompoundString(CompoundTagLayout* compoundTag, const std::wstring& key, const std::wstring& value)
|
|
{
|
|
if (!compoundTag)
|
|
return false;
|
|
|
|
const auto it = compoundTag->tags.find(key);
|
|
if (it != compoundTag->tags.end() && it->second)
|
|
{
|
|
auto* stringTag = reinterpret_cast<StringTagLayout*>(it->second);
|
|
stringTag->data = value;
|
|
return true;
|
|
}
|
|
|
|
if (!s_tagNewTag)
|
|
return false;
|
|
|
|
void* createdTag = s_tagNewTag(kTagStringId, key);
|
|
if (!createdTag)
|
|
return false;
|
|
|
|
auto* stringTag = reinterpret_cast<StringTagLayout*>(createdTag);
|
|
stringTag->data = value;
|
|
compoundTag->tags[key] = createdTag;
|
|
return true;
|
|
}
|
|
|
|
static bool IsReadableRange(const void* ptr, size_t bytes)
|
|
{
|
|
if (!ptr || bytes == 0)
|
|
return false;
|
|
|
|
MEMORY_BASIC_INFORMATION mbi{};
|
|
if (VirtualQuery(ptr, &mbi, sizeof(mbi)) != sizeof(mbi))
|
|
return false;
|
|
if (mbi.State != MEM_COMMIT || mbi.Protect == PAGE_NOACCESS || (mbi.Protect & PAGE_GUARD))
|
|
return false;
|
|
|
|
const DWORD readMask = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY |
|
|
PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;
|
|
if ((mbi.Protect & readMask) == 0)
|
|
return false;
|
|
|
|
const uintptr_t p = reinterpret_cast<uintptr_t>(ptr);
|
|
const uintptr_t end = reinterpret_cast<uintptr_t>(mbi.BaseAddress) + mbi.RegionSize;
|
|
return p + bytes >= p && p + bytes <= end;
|
|
}
|
|
|
|
static void ResolveSymbolsOnce()
|
|
{
|
|
std::call_once(s_symbolInitOnce, []() {
|
|
if (s_tagNewTag)
|
|
return;
|
|
|
|
const uintptr_t base = reinterpret_cast<uintptr_t>(GetModuleHandleW(nullptr));
|
|
uint32_t newTagRvaByName = PdbParser::FindSymbolRVAByName("Tag::newTag");
|
|
uint32_t newTagRvaByDecorated = PdbParser::FindSymbolRVA(
|
|
"?newTag@Tag@@SAPEAV1@EAEBV?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@@Z");
|
|
uint32_t newTagRva = newTagRvaByName;
|
|
if (newTagRva == 0)
|
|
newTagRva = newTagRvaByDecorated;
|
|
if (newTagRva)
|
|
s_tagNewTag = reinterpret_cast<TagNewTag_fn>(base + newTagRva);
|
|
});
|
|
}
|
|
}
|
|
|
|
namespace WorldIdRemap
|
|
{
|
|
static thread_local int s_remapStage = 0;
|
|
|
|
void SetTagNewTagSymbol(void* fnPtr)
|
|
{
|
|
s_tagNewTag = reinterpret_cast<TagNewTag_fn>(fnPtr);
|
|
}
|
|
|
|
void SetTileArraySymbol(void* tileArrayPtr)
|
|
{
|
|
s_tileArray = tileArrayPtr;
|
|
}
|
|
|
|
void SetLevelChunkTileSymbols(void* getTileFn, void* setTileFn, void* getPosFn, void* getHighestNonEmptyYFn)
|
|
{
|
|
s_levelChunkGetTile = reinterpret_cast<LevelChunkGetTile_fn>(getTileFn);
|
|
s_levelChunkSetTile = reinterpret_cast<LevelChunkSetTile_fn>(setTileFn);
|
|
s_levelChunkGetPos = reinterpret_cast<LevelChunkGetPos_fn>(getPosFn);
|
|
s_levelChunkGetHighestNonEmptyY = reinterpret_cast<LevelChunkGetHighestNonEmptyY_fn>(getHighestNonEmptyYFn);
|
|
}
|
|
|
|
void SetCompressedTileStorageSetSymbol(void* setFn)
|
|
{
|
|
s_compressedTileStorageSet = reinterpret_cast<CompressedTileStorageSet_fn>(setFn);
|
|
}
|
|
|
|
void EnsureMissingPlaceholders()
|
|
{
|
|
if (s_missingPlaceholdersReady)
|
|
return;
|
|
|
|
const int missingBlockId = IdRegistry::Instance().Register(IdRegistry::Type::Block, kMissingBlockId);
|
|
const int missingItemId = IdRegistry::Instance().Register(IdRegistry::Type::Item, kMissingItemId);
|
|
|
|
if (missingBlockId < 0)
|
|
LogUtil::Log("[WeaveLoader] Failed to register missing block placeholder (no free block IDs)");
|
|
if (missingItemId < 0)
|
|
LogUtil::Log("[WeaveLoader] Failed to register missing item placeholder (no free item IDs)");
|
|
|
|
if (missingBlockId >= 0)
|
|
{
|
|
ModStrings::Register(kMissingBlockDescriptionId, L"Missing Block");
|
|
GameObjectFactory::CreateTile(
|
|
missingBlockId,
|
|
1,
|
|
1.0f,
|
|
1.0f,
|
|
1,
|
|
L"weaveloader.api:block/missing_block",
|
|
0.0f,
|
|
15,
|
|
kMissingBlockDescriptionId);
|
|
IdRegistry::Instance().SetMissingFallback(IdRegistry::Type::Block, missingBlockId);
|
|
}
|
|
|
|
if (missingItemId >= 0)
|
|
{
|
|
ModStrings::Register(kMissingItemDescriptionId, L"Missing Item");
|
|
GameObjectFactory::CreateItem(
|
|
missingItemId,
|
|
64,
|
|
0,
|
|
L"weaveloader.api:item/missing_item",
|
|
kMissingItemDescriptionId);
|
|
IdRegistry::Instance().SetMissingFallback(IdRegistry::Type::Item, missingItemId);
|
|
}
|
|
|
|
s_missingPlaceholdersReady = true;
|
|
LogUtil::Log("[WeaveLoader] Missing content placeholders ready: block=%d item=%d",
|
|
IdRegistry::Instance().GetMissingFallback(IdRegistry::Type::Block),
|
|
IdRegistry::Instance().GetMissingFallback(IdRegistry::Type::Item));
|
|
}
|
|
|
|
static int RemapChunkBlockIdsImpl(void* chunkStoragePtr, void* levelChunkPtr, int chunkX, int chunkZ)
|
|
{
|
|
s_remapStage = 1;
|
|
if (!chunkStoragePtr || !levelChunkPtr || !s_levelChunkGetTile || !s_levelChunkSetTile)
|
|
return 0;
|
|
if (!IsValidChunkStorage(chunkStoragePtr))
|
|
return 0;
|
|
|
|
auto* storage = reinterpret_cast<McRegionChunkStorageLayout*>(chunkStoragePtr);
|
|
if (!storage->saveFile)
|
|
return 0;
|
|
|
|
SetChunkMeta(levelChunkPtr, chunkStoragePtr, chunkX, chunkZ);
|
|
|
|
std::unordered_map<int, std::string> entries;
|
|
const std::string cacheKey = MakeChunkCacheKey(storage, chunkX, chunkZ);
|
|
{
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
const auto cacheIt = s_chunkNamespaceCache.find(cacheKey);
|
|
if (cacheIt != s_chunkNamespaceCache.end())
|
|
entries = cacheIt->second;
|
|
}
|
|
if (s_chunkIoLogCount < 32)
|
|
{
|
|
++s_chunkIoLogCount;
|
|
LogUtil::Log("[WeaveLoader] WorldIdRemap blocks: reading chunk namespace map x=%d z=%d", chunkX, chunkZ);
|
|
}
|
|
if (entries.empty())
|
|
{
|
|
s_remapStage = 2;
|
|
if (ReadChunkNamespaceMapWithFallback(storage, chunkX, chunkZ, &entries) && !entries.empty())
|
|
{
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
s_chunkNamespaceCache[cacheKey] = entries;
|
|
}
|
|
}
|
|
if (!entries.empty())
|
|
SetLoadedChunkNamespaces(levelChunkPtr, entries);
|
|
|
|
const int sanitizeFallbackId = ResolveSafeMissingBlockFallbackId();
|
|
int applyMaxY = 127;
|
|
if (s_levelChunkGetHighestNonEmptyY)
|
|
{
|
|
const int highestY = s_levelChunkGetHighestNonEmptyY(levelChunkPtr);
|
|
if (highestY >= 0 && highestY < kChunkMaxY)
|
|
{
|
|
int bound = highestY + 16;
|
|
if (bound >= kChunkMaxY)
|
|
bound = kChunkMaxY - 1;
|
|
applyMaxY = bound;
|
|
}
|
|
else if (highestY >= 0)
|
|
{
|
|
applyMaxY = kChunkMaxY - 1;
|
|
}
|
|
}
|
|
|
|
if (applyMaxY > 127)
|
|
applyMaxY = 127;
|
|
|
|
int changed = 0;
|
|
int skippedInvalid = 0;
|
|
int writeExceptions = 0;
|
|
s_remapStage = 3;
|
|
for (const auto& entry : entries)
|
|
{
|
|
int x = 0;
|
|
int y = 0;
|
|
int z = 0;
|
|
DecodeBlockIndex(entry.first, &x, &y, &z);
|
|
if (y < 0 || y > applyMaxY)
|
|
{
|
|
++skippedInvalid;
|
|
continue;
|
|
}
|
|
if (!IsLikelyNamespacedId(entry.second))
|
|
{
|
|
++skippedInvalid;
|
|
continue;
|
|
}
|
|
int newId = IdRegistry::Instance().GetNumericId(IdRegistry::Type::Block, entry.second);
|
|
if (newId < 0)
|
|
newId = sanitizeFallbackId;
|
|
if (!IsValidRuntimeTileId(newId))
|
|
newId = sanitizeFallbackId;
|
|
if (newId < 0 || newId > 255)
|
|
{
|
|
++skippedInvalid;
|
|
continue;
|
|
}
|
|
if (!SafeSetChunkTile(levelChunkPtr, x, y, z, newId))
|
|
{
|
|
++writeExceptions;
|
|
continue;
|
|
}
|
|
++changed;
|
|
}
|
|
|
|
if (changed > 0 && s_chunkRemapLogCount < 64)
|
|
{
|
|
++s_chunkRemapLogCount;
|
|
LogUtil::Log("[WeaveLoader] WorldIdRemap blocks: remapped %d block ids in chunk", changed);
|
|
}
|
|
if (skippedInvalid > 0 && s_chunkRemapLogCount < 64)
|
|
{
|
|
++s_chunkRemapLogCount;
|
|
LogUtil::Log("[WeaveLoader] WorldIdRemap blocks: skipped %d invalid namespace entries in chunk", skippedInvalid);
|
|
}
|
|
if (writeExceptions > 0 && s_chunkRemapLogCount < 64)
|
|
{
|
|
++s_chunkRemapLogCount;
|
|
LogUtil::Log("[WeaveLoader] WorldIdRemap blocks: skipped %d writes due to setTile exceptions", writeExceptions);
|
|
}
|
|
s_remapStage = 0;
|
|
return changed;
|
|
}
|
|
|
|
int RemapChunkBlockIds(void* chunkStoragePtr, void* levelChunkPtr, int chunkX, int chunkZ)
|
|
{
|
|
#if defined(_MSC_VER)
|
|
__try
|
|
{
|
|
return RemapChunkBlockIdsImpl(chunkStoragePtr, levelChunkPtr, chunkX, chunkZ);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
LogUtil::Log("[WeaveLoader] WorldIdRemap blocks: exception while remapping chunk x=%d z=%d stage=%d (skipped)", chunkX, chunkZ, s_remapStage);
|
|
return 0;
|
|
}
|
|
#else
|
|
return RemapChunkBlockIdsImpl(chunkStoragePtr, levelChunkPtr, chunkX, chunkZ);
|
|
#endif
|
|
}
|
|
|
|
void SaveChunkBlockNamespaces(void* chunkStoragePtr, void* levelChunkPtr)
|
|
{
|
|
if (!chunkStoragePtr || !levelChunkPtr || !s_levelChunkGetTile)
|
|
return;
|
|
if (!IsValidChunkStorage(chunkStoragePtr))
|
|
return;
|
|
|
|
auto* storage = reinterpret_cast<McRegionChunkStorageLayout*>(chunkStoragePtr);
|
|
if (!storage->saveFile)
|
|
return;
|
|
|
|
ChunkMeta meta{};
|
|
if (!TryGetChunkMeta(levelChunkPtr, &meta))
|
|
{
|
|
meta.storagePtr = chunkStoragePtr;
|
|
if (!TryResolveChunkCoords(levelChunkPtr, &meta.x, &meta.z))
|
|
return;
|
|
SetChunkMeta(levelChunkPtr, chunkStoragePtr, meta.x, meta.z);
|
|
}
|
|
|
|
const std::wstring path = MakeChunkNamespacePathCoordsOnly(meta.x, meta.z);
|
|
const std::string cacheKey = MakeChunkCacheKey(storage, meta.x, meta.z);
|
|
std::unordered_map<int, std::string> loadedEntries;
|
|
const bool hadLoadedMap = TryGetLoadedChunkNamespaces(levelChunkPtr, &loadedEntries) && !loadedEntries.empty();
|
|
|
|
std::unordered_map<int, std::string> nextEntries;
|
|
const int missingBlockFallback = IdRegistry::Instance().GetMissingFallback(IdRegistry::Type::Block);
|
|
int maxY = kChunkMaxY - 1;
|
|
if (s_levelChunkGetHighestNonEmptyY)
|
|
{
|
|
const int highestY = s_levelChunkGetHighestNonEmptyY(levelChunkPtr);
|
|
if (highestY < 0 && !hadLoadedMap)
|
|
return;
|
|
if (highestY >= 0 && highestY < kChunkMaxY)
|
|
maxY = highestY;
|
|
}
|
|
|
|
for (int y = 0; y <= maxY; ++y)
|
|
{
|
|
for (int z = 0; z < kChunkWidth; ++z)
|
|
{
|
|
for (int x = 0; x < kChunkWidth; ++x)
|
|
{
|
|
const int blockId = s_levelChunkGetTile(levelChunkPtr, x, y, z);
|
|
const int blockIndex = MakeBlockIndex(x, y, z);
|
|
|
|
if (blockId == missingBlockFallback)
|
|
{
|
|
const auto loadedIt = loadedEntries.find(blockIndex);
|
|
if (loadedIt != loadedEntries.end() && !loadedIt->second.empty() && loadedIt->second != kMissingBlockId)
|
|
{
|
|
nextEntries[blockIndex] = loadedIt->second;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
std::string namespacedId = IdRegistry::Instance().GetStringId(IdRegistry::Type::Block, blockId);
|
|
if (namespacedId.empty())
|
|
continue;
|
|
if (IsVanillaId(namespacedId))
|
|
continue;
|
|
if (namespacedId == kMissingBlockId)
|
|
{
|
|
const auto loadedIt = loadedEntries.find(blockIndex);
|
|
if (loadedIt != loadedEntries.end() && !loadedIt->second.empty() && loadedIt->second != kMissingBlockId)
|
|
{
|
|
nextEntries[blockIndex] = loadedIt->second;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
nextEntries[blockIndex] = std::move(namespacedId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nextEntries.empty() && !hadLoadedMap)
|
|
return;
|
|
if (!WriteChunkNamespaceMap(storage->saveFile, path, nextEntries))
|
|
return;
|
|
{
|
|
std::lock_guard<std::mutex> lock(s_chunkMetaMutex);
|
|
s_chunkNamespaceCache[cacheKey] = nextEntries;
|
|
}
|
|
|
|
if (s_chunkSaveLogCount < 64)
|
|
{
|
|
++s_chunkSaveLogCount;
|
|
LogUtil::Log("[WeaveLoader] WorldIdRemap blocks: saved %zu namespace entries for chunk x=%d z=%d",
|
|
nextEntries.size(), meta.x, meta.z);
|
|
}
|
|
}
|
|
|
|
void TagModdedItemInstance(void* itemInstancePtr, void* compoundTagPtr)
|
|
{
|
|
ResolveSymbolsOnce();
|
|
if (!itemInstancePtr)
|
|
return;
|
|
if (!IsReadableRange(static_cast<const char*>(itemInstancePtr) + kItemIdOffset, sizeof(int)))
|
|
return;
|
|
(void)compoundTagPtr;
|
|
|
|
const int itemId = *reinterpret_cast<const int*>(static_cast<const char*>(itemInstancePtr) + kItemIdOffset);
|
|
const std::string namespacedId = ResolveNamespacedItemId(itemId);
|
|
if (namespacedId.empty() || IsVanillaId(namespacedId))
|
|
return;
|
|
const bool isBlockBacked = !IdRegistry::Instance().GetStringId(IdRegistry::Type::Block, itemId).empty() &&
|
|
IdRegistry::Instance().GetStringId(IdRegistry::Type::Item, itemId).empty();
|
|
|
|
CompoundTagLayout* itemTag = EnsureItemTag(itemInstancePtr);
|
|
if (!itemTag)
|
|
return;
|
|
|
|
// Never let placeholder IDs overwrite a previously saved real namespace.
|
|
if (namespacedId == kMissingItemId || namespacedId == kMissingBlockId)
|
|
{
|
|
std::wstring existingNamespace;
|
|
if (TryGetCompoundString(itemTag, kNamespaceTagKey, &existingNamespace) && !existingNamespace.empty())
|
|
return;
|
|
}
|
|
|
|
const std::wstring namespacedWide(namespacedId.begin(), namespacedId.end());
|
|
if (!PutCompoundString(itemTag, kNamespaceTagKey, namespacedWide))
|
|
return;
|
|
(void)PutCompoundString(itemTag, kNamespaceKindTagKey, isBlockBacked ? L"block" : L"item");
|
|
}
|
|
|
|
void RemapItemInstanceFromTag(void* itemInstancePtr, void* compoundTagPtr)
|
|
{
|
|
ResolveSymbolsOnce();
|
|
if (!itemInstancePtr)
|
|
return;
|
|
(void)compoundTagPtr;
|
|
if (!IsReadableRange(static_cast<const char*>(itemInstancePtr) + kItemIdOffset, sizeof(int)))
|
|
return;
|
|
|
|
const int oldItemId = *reinterpret_cast<const int*>(static_cast<const char*>(itemInstancePtr) + kItemIdOffset);
|
|
CompoundTagLayout* itemTag = GetItemTag(itemInstancePtr);
|
|
if (!itemTag)
|
|
return;
|
|
|
|
std::wstring namespacedWide;
|
|
if (!TryGetCompoundString(itemTag, kNamespaceTagKey, &namespacedWide) || namespacedWide.empty())
|
|
return;
|
|
std::wstring kindWide;
|
|
(void)TryGetCompoundString(itemTag, kNamespaceKindTagKey, &kindWide);
|
|
|
|
const std::string namespacedId(namespacedWide.begin(), namespacedWide.end());
|
|
int numericId = ResolveNumericItemId(namespacedId, oldItemId, kindWide);
|
|
if (numericId >= 0)
|
|
*reinterpret_cast<int*>(static_cast<char*>(itemInstancePtr) + kItemIdOffset) = numericId;
|
|
}
|
|
}
|