Files
AVA2/tests/mark_manager_test.cpp
shenleiandClaude Opus 5.5 9077aa389a AVA2 client Windows parity passes (gr2 BitKnit2/64-bit, GamePhase handlers, python modules)
- gr2: BitKnit2 decompression, 64-bit LE files, compressed curves
- net: remaining GamePhase handlers, generated GC packet table
- python: event/chat/chr/minimap/guild/quest/messenger/shop-search and
  other native modules ported against the AVA2 Windows client
- render: D3D8 fixed-function lighting in Gr2ModelRenderer, terrain
  without baked shade; cape/NPC equipment attachment
- tests + audits updated; docs/PORT-PLAN.md and WINDOWS-PARITY.md

Batch 4 (render pipeline: background.*, app.RenderGame/UpdateGame,
camera bindings, main.cpp fake-content removal) is still in progress.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-08 10:43:01 +09:00

174 lines
5.7 KiB
C++

#include "src/eter_image/MarkManager.h"
#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <filesystem>
#include "test_rundir.h"
using namespace ava2;
void TestGuildMarkPrimitives() {
std::cout << "[Test 1] GuildMark 16x12 Pixel Primitives..." << std::endl;
GuildMark mark;
assert(mark.IsEmpty() && "New mark must be empty");
assert(GuildMark::WIDTH == 16 && GuildMark::HEIGHT == 12);
assert(GuildMark::SIZE == 192);
mark.SetPixel(0, 0, 0xFFFF0000); // Red
mark.SetPixel(15, 11, 0xFF00FF00); // Green
assert(!mark.IsEmpty() && "Mark with non-zero alpha pixels must not be empty");
assert(mark.GetPixel(0, 0) == 0xFFFF0000);
assert(mark.GetPixel(15, 11) == 0xFF00FF00);
assert(mark.GetPixel(5, 5) == 0x00000000);
mark.Clear();
assert(mark.IsEmpty() && "Cleared mark must be empty");
std::cout << " -> GuildMark primitives passed!" << std::endl;
}
void TestGuildMarkBlockCRC() {
std::cout << "[Test 2] GuildMarkBlock 64x48 CRC Calculation..." << std::endl;
GuildMarkBlock block;
assert(GuildMarkBlock::WIDTH == 64 && GuildMarkBlock::HEIGHT == 48);
assert(GuildMarkBlock::SIZE == 3072);
block.ComputeCRC();
uint32_t zeroCRC = block.crc;
block.pixels[100] = 0xFF123456;
block.ComputeCRC();
assert(block.crc != zeroCRC && "CRC must change when block pixels change");
std::cout << " -> GuildMarkBlock CRC verification passed!" << std::endl;
}
void TestGuildMarkImageAtlas() {
std::cout << "[Test 3] GuildMarkImage 512x512 Atlas Serialization..." << std::endl;
GuildMarkImage atlas;
// Load authentic 10_0.tga
bool loaded = atlas.LoadTGA("mark/10_0.tga");
if (!loaded) loaded = atlas.LoadTGA("build/dev/mark/10_0.tga");
if (!loaded) loaded = atlas.LoadTGA(ava2_test::PackMaker() + "/../mark/10_0.tga");
assert(loaded && "Failed to load authentic 10_0.tga mark atlas");
// Check non-zero pixel in atlas
const uint32_t* p = atlas.GetPixels();
bool hasPixels = false;
for (int i = 0; i < GuildMarkImage::WIDTH * GuildMarkImage::HEIGHT; ++i) {
if ((p[i] & 0xFF000000) != 0) {
hasPixels = true;
break;
}
}
assert(hasPixels && "Atlas must contain non-empty guild marks");
// Test UV calculations
float u0, v0, u1, v1;
atlas.GetMarkUV(0, u0, v0, u1, v1);
assert(std::abs(u0 - 0.0f) < 1e-4f);
assert(std::abs(v0 - 0.0f) < 1e-4f);
assert(std::abs(u1 - (16.0f / 512.0f)) < 1e-4f);
assert(std::abs(v1 - (12.0f / 512.0f)) < 1e-4f);
atlas.GetMarkUV(32, u0, v0, u1, v1); // Second row, first column
assert(std::abs(u0 - 0.0f) < 1e-4f);
assert(std::abs(v0 - (12.0f / 512.0f)) < 1e-4f);
assert(std::abs(u1 - (16.0f / 512.0f)) < 1e-4f);
assert(std::abs(v1 - (24.0f / 512.0f)) < 1e-4f);
// Test mark extraction
GuildMark slot0Mark;
bool ok = atlas.GetMark(0, slot0Mark);
assert(ok && "Failed to get mark from slot 0");
// Put a distinct synthetic mark in slot 100
GuildMark customMark;
for (int y = 0; y < 12; ++y) {
for (int x = 0; x < 16; ++x) {
customMark.SetPixel(x, y, 0xFF00AAFF);
}
}
assert(atlas.PutMark(100, customMark));
GuildMark retrieved;
assert(atlas.GetMark(100, retrieved));
assert(retrieved.GetPixel(5, 5) == 0xFF00AAFF);
// Save TGA and re-read
std::string testPath = "/tmp/test_mark_atlas.tga";
assert(atlas.SaveTGA(testPath));
GuildMarkImage reloaded;
assert(reloaded.LoadTGA(testPath));
GuildMark reloadedMark;
assert(reloaded.GetMark(100, reloadedMark));
assert(reloadedMark.GetPixel(5, 5) == 0xFF00AAFF);
std::cout << " -> GuildMarkImage atlas serialization & UV passed!" << std::endl;
}
void TestGuildMarkManager() {
std::cout << "[Test 4] GuildMarkManager Singleton & Guild Mapping..." << std::endl;
auto& mgr = GuildMarkManager::Instance();
mgr.Clear();
mgr.SetMarkPathPrefix("10");
// Register Guild 1001 with markID 0
assert(mgr.AddMarkIDByGuildID(1001, 0));
assert(mgr.HasMark(1001));
assert(mgr.GetMarkID(1001) == 0);
// Register Guild 2002 with markID 45
assert(mgr.AddMarkIDByGuildID(2002, 45));
assert(mgr.HasMark(2002));
assert(mgr.GetMarkID(2002) == 45);
// Non-existent guild
assert(!mgr.HasMark(9999));
assert(mgr.GetMarkID(9999) == INVALID_MARK_ID);
// Test UV lookup for Guild 1001
float u0, v0, u1, v1;
uint32_t imgIdx;
bool uvOk = mgr.GetMarkUV(1001, u0, v0, u1, v1, imgIdx);
assert(uvOk && "GetMarkUV for guild 1001 must succeed");
assert(imgIdx == 0);
assert(u0 >= 0.0f && u1 <= 1.0f);
// Test Mark image filename
std::string filename;
assert(mgr.GetMarkImageFilename(0, filename));
assert(filename == "mark/10_0.tga");
// Test dynamic Mark registration
GuildMark goldenEmblem;
for (int y = 0; y < 12; ++y) {
for (int x = 0; x < 16; ++x) {
goldenEmblem.SetPixel(x, y, 0xFFFFD700);
}
}
assert(mgr.SaveMark(3003, goldenEmblem));
assert(mgr.HasMark(3003));
uint32_t allocID = mgr.GetMarkID(3003);
assert(allocID != INVALID_MARK_ID);
GuildMark readBack;
assert(mgr.GetGuildMark(3003, readBack));
assert(readBack.GetPixel(8, 6) == 0xFFFFD700);
std::cout << " -> GuildMarkManager mapping, UV, and allocation passed!" << std::endl;
}
int main() {
if (!ava2_test::EnterTestRunDir()) return ava2_test::kSkip;
std::cout << "=== Running Guild Mark & MarkManager Engine Tests ===" << std::endl;
TestGuildMarkPrimitives();
TestGuildMarkBlockCRC();
TestGuildMarkImageAtlas();
TestGuildMarkManager();
std::cout << "=== ALL Guild Mark Tests PASSED (100%) ===" << std::endl;
return 0;
}