Correct selection orientation, game-entry lifecycle, mounted NPCs, labels and skill panels. Add the native GPU scene path, resident geometry, bounded texture and Python caches, and collision broad phase. Pin the independently maintained Metin2 SDK through a submodule and document reproducible setup. Include rendering regressions and macOS packaging improvements. Validation: client Debug build and 12 targeted client tests passed; SDK build and all 14 SDK tests passed.
1564 lines
78 KiB
C++
1564 lines
78 KiB
C++
#include "src/eter_render/Gr2ModelRenderer.h"
|
|
#include "src/eter_render/TerrainHeightmap.h"
|
|
#include "src/eter_render/MapObjectManager.h"
|
|
#include "src/eter_render/WaterManager.h"
|
|
#include "src/eter_render/OrbitCamera.h"
|
|
#include "src/eter_render/MinimapManager.h"
|
|
#include "src/eter_render/ActorInstance.h"
|
|
#include "src/eter_render/RaceData.h"
|
|
#include "src/eter_render/FloatingTextManager.h"
|
|
#include "src/eter_render/TargetManager.h"
|
|
#include "src/eter_render/TextTailManager.h"
|
|
#include "src/eter_sound/SoundManager.h"
|
|
#include "src/eter_effect/EffectManager.h"
|
|
#include "src/eter_effect/FlyingManager.h"
|
|
#include "src/eter_net/NetworkActorManager.h"
|
|
#include <SDL3/SDL.h>
|
|
#include <cassert>
|
|
#include <iostream>
|
|
#include <filesystem>
|
|
#include <map>
|
|
#include <fstream>
|
|
#include <chrono>
|
|
#include "test_rundir.h"
|
|
|
|
using ava2_test::kSkip;
|
|
using ava2_test::PackMaker;
|
|
|
|
int main(int argc, char** argv) {
|
|
if (!ava2_test::EnterTestRunDir()) return kSkip;
|
|
|
|
std::string model_path = "ymir work/pc/warrior/warrior_assasin1.gr2";
|
|
if (argc > 1) {
|
|
model_path = argv[1];
|
|
}
|
|
|
|
if (!std::filesystem::exists(model_path)) {
|
|
if (std::filesystem::exists("build/dev/" + model_path)) {
|
|
model_path = "build/dev/" + model_path;
|
|
} else if (std::filesystem::exists("../" + model_path)) {
|
|
model_path = "../" + model_path;
|
|
} else {
|
|
std::cerr << "SKIP: model file not found: " << model_path << std::endl;
|
|
return kSkip;
|
|
}
|
|
}
|
|
|
|
// The scene below loads cwd-relative client assets (merged `ymir work`, bgm, sound),
|
|
// like the Windows client root. Without them the asserts would only report the
|
|
// environment, so skip instead; when they are present every check runs.
|
|
for (const char* required : {"ymir work/zone/b/obj/b_general_obj_01_2.gr2",
|
|
"bgm/login_window.mp3",
|
|
"sound/ui/click.wav"}) {
|
|
if (!std::filesystem::exists(required)) {
|
|
std::cerr << "SKIP: client asset missing from working directory: " << required << std::endl;
|
|
return kSkip;
|
|
}
|
|
}
|
|
|
|
std::cout << "Loading 3D GR2 Model: " << model_path << std::endl;
|
|
auto model = ava2::Gr2ModelInstance::Load(model_path);
|
|
if (!model) {
|
|
std::cerr << "Failed to load GR2 model instance!" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
const auto& info = model->GetInfo();
|
|
std::cout << "Model Info: " << info.models.size() << " models, "
|
|
<< info.meshes.size() << " meshes, "
|
|
<< info.skeletons.size() << " skeletons." << std::endl;
|
|
|
|
if (!info.skeletons.empty()) {
|
|
std::cout << "Skeleton bones (" << info.skeletons[0].bones.size() << "): ";
|
|
for (const auto& b : info.skeletons[0].bones) {
|
|
if (b.name.find("Hand") != std::string::npos || b.name.find("equip") != std::string::npos || b.name.find("Head") != std::string::npos) {
|
|
std::cout << "[" << b.name << "] ";
|
|
}
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
// Warrior toes point along native -Y, converted by GR2 to engine +Z.
|
|
// At yaw=0, both the mesh forward axis and locomotion must remain +Z.
|
|
float foot[16]{},toe[16]{};
|
|
assert(model->GetBoneWorldTransform("Bip01 L Foot",foot));
|
|
assert(model->GetBoneWorldTransform("Bip01 L Toe0",toe));
|
|
const float forwardX=toe[12]-foot[12], forwardZ=-(toe[13]-foot[13]);
|
|
assert(forwardZ>0);
|
|
ava2::ActorInstance facing;
|
|
facing.SetModel(model_path); facing.SetPosition(0,0,0); facing.SetSpeed(100);
|
|
facing.MoveInDirection(0,0.1f);
|
|
auto facingDraws=facing.BuildDrawCommands();
|
|
assert(!facingDraws.empty());
|
|
const auto& w=facingDraws[0].world;
|
|
const float worldForwardZ=forwardX*w[2]+(toe[13]-foot[13])*w[6]+(toe[14]-foot[14])*w[10];
|
|
assert(worldForwardZ*facing.GetZ()>0 && "rendered face must point toward movement");
|
|
facing.SetYaw(180.0f);
|
|
auto showcaseDraws=facing.BuildDrawCommands();
|
|
const auto& sw=showcaseDraws[0].world;
|
|
const float showcaseForwardZ=forwardX*sw[2]+(toe[13]-foot[13])*sw[6]+(toe[14]-foot[14])*sw[10];
|
|
assert(showcaseForwardZ*worldForwardZ<0 && facing.GetYaw()==180);
|
|
assert(!info.meshes.empty() && "GR2 model must contain at least one mesh");
|
|
std::size_t total_verts = 0;
|
|
std::size_t total_indices = 0;
|
|
for (const auto& mesh : info.meshes) {
|
|
total_verts += mesh.vertices.size();
|
|
total_indices += mesh.indices.size();
|
|
}
|
|
std::cout << "Total vertices: " << total_verts << ", Total indices: " << total_indices << std::endl;
|
|
assert(total_verts > 100 && "Warrior mesh must have substantial vertex count");
|
|
assert(total_indices > 300 && "Warrior mesh must have triangle indices");
|
|
|
|
// Build 3D draw commands with bind pose skinning
|
|
auto draws = model->BuildDrawCommands();
|
|
std::cout << "Generated " << draws.size() << " 3D draw commands." << std::endl;
|
|
for (size_t i = 0; i < draws.size(); ++i) {
|
|
std::cout << "Draw " << i << " texture0: '" << draws[i].texture0 << "'" << std::endl;
|
|
}
|
|
assert(!draws.empty() && "Must produce at least one 3D draw command");
|
|
|
|
// Setup 3D Scene Renderer
|
|
const int width = 1024;
|
|
const int height = 768;
|
|
ava2::Gr2SceneRenderer renderer(width, height);
|
|
|
|
// Setup Camera to look at the warrior model
|
|
// Warrior height is typically ~170-180 units in Metin2 space
|
|
renderer.SetCameraLookAt(
|
|
0.0f, 130.0f, -320.0f, // Eye
|
|
0.0f, 100.0f, 0.0f, // Target (chest height)
|
|
0.0f, 1.0f, 0.0f // Up
|
|
);
|
|
renderer.SetPerspective(45.0f, static_cast<float>(width) / static_cast<float>(height), 1.0f, 2000.0f);
|
|
|
|
SDL_Surface* surface = SDL_CreateSurface(width, height, SDL_PIXELFORMAT_ARGB8888);
|
|
assert(surface != nullptr && "Failed to create SDL surface for 3D rendering");
|
|
|
|
// Clear background to dark blue
|
|
uint32_t bg_color = 0xFF101826;
|
|
SDL_FillSurfaceRect(surface, nullptr, bg_color);
|
|
renderer.Clear(bg_color, 1.0f);
|
|
|
|
// Execute 3D rendering
|
|
renderer.RenderScene(surface, draws);
|
|
|
|
// Verify rasterized content
|
|
uint32_t* pixels = static_cast<uint32_t*>(surface->pixels);
|
|
int rendered_mesh_pixels = 0;
|
|
const auto& depth = renderer.GetDepthBuffer();
|
|
for (int i = 0; i < width * height; ++i) {
|
|
if (depth[i] < 0.999f) {
|
|
rendered_mesh_pixels++;
|
|
}
|
|
}
|
|
|
|
std::cout << "Rasterized 3D Warrior model pixels: " << rendered_mesh_pixels
|
|
<< " out of " << (width * height) << std::endl;
|
|
|
|
// Save screenshot of base pose
|
|
const char* screenshot_path = "/tmp/test_3d_warrior.bmp";
|
|
if (SDL_SaveBMP(surface, screenshot_path)) {
|
|
std::cout << "Successfully saved 3D warrior render to: " << screenshot_path << std::endl;
|
|
}
|
|
|
|
// Test World Rotation (Yaw 35 degrees)
|
|
float world_rot[16];
|
|
ava2::MakeTransformMatrix(35.0f, 0.0f, 0.0f, 0.0f, 1.0f, world_rot);
|
|
auto rotated_draws = model->BuildDrawCommands(-1.0f, world_rot);
|
|
renderer.Clear(bg_color, 1.0f);
|
|
SDL_FillSurfaceRect(surface, nullptr, bg_color);
|
|
renderer.RenderScene(surface, rotated_draws);
|
|
|
|
int rotated_mesh_pixels = 0;
|
|
const auto& depth_rot = renderer.GetDepthBuffer();
|
|
for (int i = 0; i < width * height; ++i) {
|
|
if (depth_rot[i] < 0.999f) rotated_mesh_pixels++;
|
|
}
|
|
std::cout << "Rasterized Rotated 3D Warrior model pixels: " << rotated_mesh_pixels << std::endl;
|
|
assert(rotated_mesh_pixels > 5000 && "Rotated mesh must produce valid silhouette");
|
|
|
|
const char* rot_screenshot = "/tmp/test_3d_warrior_rotated.bmp";
|
|
if (SDL_SaveBMP(surface, rot_screenshot)) {
|
|
std::cout << "Successfully saved rotated 3D warrior render to: " << rot_screenshot << std::endl;
|
|
}
|
|
|
|
// ── Test Bone Query (equip_right_hand and Bip01 Head) ──────────────────
|
|
float hand_matrix[16] = {};
|
|
bool has_hand = model->GetBoneWorldTransform("equip_right_hand", hand_matrix);
|
|
if (!has_hand) {
|
|
has_hand = model->GetBoneWorldTransform("Bip01 R Hand", hand_matrix);
|
|
}
|
|
std::cout << "GetBoneWorldTransform(right_hand): " << (has_hand ? "SUCCESS" : "FAILED") << std::endl;
|
|
assert(has_hand && "Must find hand bone on warrior skeleton");
|
|
std::cout << "Hand position: (" << hand_matrix[12] << ", " << hand_matrix[13] << ", " << hand_matrix[14] << ")" << std::endl;
|
|
|
|
// Bone effects / mount saddles must use the same native Z-up conversion as meshes.
|
|
{
|
|
ava2::ActorInstance actor;
|
|
assert(actor.SetModel(model_path));actor.SetScale(2);actor.SetPosition(11,22,33);actor.SetYaw(90);
|
|
std::string bone="equip_right_hand";
|
|
float native[16];
|
|
if (!model->GetBoneWorldTransform(bone,native,0)) { bone="Bip01 R Hand";assert(model->GetBoneWorldTransform(bone,native,0)); }
|
|
float x,y,z;assert(actor.GetBonePosition(bone,x,y,z));
|
|
assert(std::abs(x-(11-2*native[13]))<.01f);
|
|
assert(std::abs(y-(22+2*native[14]))<.01f);
|
|
assert(std::abs(z-(33-2*native[12]))<.01f);
|
|
}
|
|
|
|
// ── Test Weapon Attachment ─────────────────────────────────────────────
|
|
std::string weapon_path = "ymir work/item/weapon/set_11_sword.gr2";
|
|
if (!std::filesystem::exists(weapon_path) && std::filesystem::exists("../" + weapon_path)) {
|
|
weapon_path = "../" + weapon_path;
|
|
}
|
|
auto weapon = ava2::Gr2ModelInstance::Load(weapon_path);
|
|
if (weapon) {
|
|
std::cout << "Loaded weapon model: " << weapon_path << std::endl;
|
|
model->AttachModel("equip_right_hand", std::move(weapon));
|
|
auto equipped_draws = model->BuildDrawCommands();
|
|
const auto& wd = equipped_draws.back();
|
|
std::cout << "Weapon draw world translation: (" << wd.world[12] << ", " << wd.world[13] << ", " << wd.world[14] << ")" << std::endl;
|
|
float wx = wd.positions[0]*wd.world[0] + wd.positions[1]*wd.world[4] + wd.positions[2]*wd.world[8] + wd.world[12];
|
|
float wy = wd.positions[0]*wd.world[1] + wd.positions[1]*wd.world[5] + wd.positions[2]*wd.world[9] + wd.world[13];
|
|
float wz = wd.positions[0]*wd.world[2] + wd.positions[1]*wd.world[6] + wd.positions[2]*wd.world[10] + wd.world[14];
|
|
std::cout << "Weapon vertex 0 world pos: (" << wx << ", " << wy << ", " << wz << ")" << std::endl;
|
|
|
|
renderer.Clear(bg_color, 1.0f);
|
|
SDL_FillSurfaceRect(surface, nullptr, bg_color);
|
|
renderer.RenderScene(surface, equipped_draws);
|
|
|
|
int equipped_pixels = 0;
|
|
const auto& eq_depth = renderer.GetDepthBuffer();
|
|
for (int i = 0; i < width * height; ++i) {
|
|
if (eq_depth[i] < 0.999f) equipped_pixels++;
|
|
}
|
|
std::cout << "Equipped warrior (with weapon) pixels: " << equipped_pixels << std::endl;
|
|
assert(equipped_pixels > rendered_mesh_pixels && "Weapon attachment must add visible pixels");
|
|
|
|
const char* wep_screenshot = "/tmp/test_3d_warrior_weapon.bmp";
|
|
if (SDL_SaveBMP(surface, wep_screenshot)) {
|
|
std::cout << "Successfully saved weapon attachment render to: " << wep_screenshot << std::endl;
|
|
}
|
|
}
|
|
|
|
// ── Test Hair Part Attachment ──────────────────────────────────────────
|
|
std::string hair_path = "ymir work/pc/plechito/summer2020_costume/hair/warrior_m.gr2";
|
|
if (!std::filesystem::exists(hair_path) && std::filesystem::exists("../" + hair_path)) {
|
|
hair_path = "../" + hair_path;
|
|
}
|
|
auto hair = ava2::Gr2ModelInstance::Load(hair_path);
|
|
if (hair) {
|
|
std::cout << "Loaded hair part model: " << hair_path << std::endl;
|
|
model->AttachPart(std::move(hair));
|
|
auto full_draws = model->BuildDrawCommands();
|
|
std::cout << "Fully equipped draws count: " << full_draws.size() << std::endl;
|
|
|
|
renderer.Clear(bg_color, 1.0f);
|
|
SDL_FillSurfaceRect(surface, nullptr, bg_color);
|
|
renderer.RenderScene(surface, full_draws);
|
|
|
|
const char* full_screenshot = "/tmp/test_3d_warrior_fully_equipped.bmp";
|
|
if (SDL_SaveBMP(surface, full_screenshot)) {
|
|
std::cout << "Successfully saved fully equipped warrior render to: " << full_screenshot << std::endl;
|
|
}
|
|
}
|
|
|
|
// ── Test External Animation Loading & Pose Sampling ───────────────────
|
|
std::string anim_model_path = "ymir work/npc_mount/halloween_2018_cerberos/halloween_2018_cerberos.gr2";
|
|
std::string anim_file_path = "ymir work/npc_mount/halloween_2018_cerberos/wait.gr2";
|
|
if (!std::filesystem::exists(anim_model_path) && std::filesystem::exists("../" + anim_model_path)) {
|
|
anim_model_path = "../" + anim_model_path;
|
|
anim_file_path = "../" + anim_file_path;
|
|
}
|
|
auto anim_model = ava2::Gr2ModelInstance::Load(anim_model_path);
|
|
if (anim_model) {
|
|
bool anim_loaded = anim_model->LoadExternalAnimation(anim_file_path);
|
|
std::cout << "Loaded external animation: " << (anim_loaded ? "SUCCESS" : "FAILED") << std::endl;
|
|
assert(anim_loaded && "External animation file must load successfully");
|
|
|
|
float duration = anim_model->GetAnimationDuration();
|
|
std::cout << "Cerberos animation duration: " << duration << "s" << std::endl;
|
|
assert(duration > 0.1f && "Animation duration must be positive");
|
|
|
|
// Sample pose at t = 0.5s
|
|
auto anim_draws = anim_model->BuildDrawCommands(0.5f);
|
|
assert(!anim_draws.empty() && "Animated model must generate draw commands");
|
|
float cminX=1e9, cmaxX=-1e9, cminY=1e9, cmaxY=-1e9, cminZ=1e9, cmaxZ=-1e9;
|
|
for (const auto& d : anim_draws) {
|
|
for (size_t i = 0; i < d.positions.size(); i += 3) {
|
|
cminX = std::min(cminX, d.positions[i]); cmaxX = std::max(cmaxX, d.positions[i]);
|
|
cminY = std::min(cminY, d.positions[i+1]); cmaxY = std::max(cmaxY, d.positions[i+1]);
|
|
cminZ = std::min(cminZ, d.positions[i+2]); cmaxZ = std::max(cmaxZ, d.positions[i+2]);
|
|
}
|
|
}
|
|
std::cout << "Cerberos bounds: X[" << cminX << ".." << cmaxX << "] Y[" << cminY << ".." << cmaxY << "] Z[" << cminZ << ".." << cmaxZ << "]" << std::endl;
|
|
|
|
renderer.SetCameraLookAt(0.0f, 100.0f, -350.0f, 0.0f, 80.0f, 0.0f, 0.0f, 1.0f, 0.0f);
|
|
renderer.Clear(bg_color, 1.0f);
|
|
SDL_FillSurfaceRect(surface, nullptr, bg_color);
|
|
renderer.RenderScene(surface, anim_draws);
|
|
|
|
int anim_pixels = 0;
|
|
const auto& anim_depth = renderer.GetDepthBuffer();
|
|
for (int i = 0; i < width * height; ++i) {
|
|
if (anim_depth[i] < 0.999f) anim_pixels++;
|
|
}
|
|
std::cout << "Rasterized Animated Cerberos pixels: " << anim_pixels << std::endl;
|
|
assert(anim_pixels > 5000 && "Animated model rendering must produce valid silhouette");
|
|
|
|
const char* anim_screenshot = "/tmp/test_3d_cerberos_anim.bmp";
|
|
if (SDL_SaveBMP(surface, anim_screenshot)) {
|
|
std::cout << "Successfully saved animated cerberos render to: " << anim_screenshot << std::endl;
|
|
}
|
|
}
|
|
|
|
// ── Test Terrain Heightmap & Outdoor Scene Rendering ────────────────────
|
|
std::cout << "\n── Testing Terrain Heightmap & Outdoor Scene Rendering ──" << std::endl;
|
|
ava2::TerrainHeightmap terrain;
|
|
std::string raw_path = PackMaker() + "/Maps/metin2_map_a1/001003/height.raw";
|
|
if (std::filesystem::exists(raw_path)) {
|
|
bool raw_ok = terrain.LoadRaw(raw_path, 0.5f, 50.0f);
|
|
std::cout << "Loaded Metin2 height.raw: " << (raw_ok ? "SUCCESS" : "FAILED") << std::endl;
|
|
assert(raw_ok && "Metin2 height.raw must load successfully");
|
|
|
|
std::string tile_path = PackMaker() + "/Maps/metin2_map_a1/001003/tile.raw";
|
|
if (std::filesystem::exists(tile_path)) {
|
|
bool tile_ok = terrain.LoadTileRaw(tile_path);
|
|
std::cout << "Loaded Metin2 tile.raw: " << (tile_ok ? "SUCCESS" : "FAILED") << std::endl;
|
|
assert(tile_ok && "Metin2 tile.raw must load successfully");
|
|
assert(terrain.HasTileMap());
|
|
}
|
|
} else {
|
|
terrain.GenerateProcedural(64, 64, 40.0f, 60.0f);
|
|
std::cout << "Generated procedural outdoor rolling hill terrain" << std::endl;
|
|
}
|
|
|
|
assert(terrain.GetWidth() >= 16 && terrain.GetHeight() >= 16);
|
|
float h_center = terrain.GetHeightAtWorld(0.0f, 0.0f);
|
|
std::cout << "Terrain height at center (0,0): " << h_center
|
|
<< ", min: " << terrain.GetMinHeight() << ", max: " << terrain.GetMaxHeight() << std::endl;
|
|
|
|
float normal[3];
|
|
terrain.GetNormalAtWorld(0.0f, 0.0f, normal);
|
|
std::cout << "Terrain normal at center: (" << normal[0] << ", " << normal[1] << ", " << normal[2] << ")" << std::endl;
|
|
assert(normal[1] > 0.1f && "Terrain normal Y component must point upwards");
|
|
|
|
// Build terrain 3D draw command (with tile-aware shading)
|
|
auto terrain_draw = terrain.BuildDrawCommand(nullptr, 2);
|
|
std::cout << "Terrain mesh vertices: " << (terrain_draw.positions.size() / 3)
|
|
<< ", indices: " << terrain_draw.indices.size() << std::endl;
|
|
assert(!terrain_draw.positions.empty() && !terrain_draw.indices.empty());
|
|
|
|
// ── Test MapObjectManager: Outdoor Buildings & Props ───────────────────
|
|
std::cout << "\n── Testing MapObjectManager (Buildings & Props) ──" << std::endl;
|
|
ava2::MapObjectManager obj_mgr;
|
|
std::string bldg_path = "ymir work/zone/b/obj/b_general_obj_01_2.gr2";
|
|
if (!std::filesystem::exists(bldg_path) && std::filesystem::exists("../" + bldg_path)) {
|
|
bldg_path = "../" + bldg_path;
|
|
}
|
|
|
|
bool added_bldg = obj_mgr.AddObject(bldg_path, 80.0f, h_center, -60.0f, 30.0f, 0.0f, 0.0f, 1.0f);
|
|
std::cout << "Added outdoor building instance: " << (added_bldg ? "SUCCESS" : "FAILED") << std::endl;
|
|
assert(added_bldg && "Building model must instantiate successfully");
|
|
{
|
|
const auto fixture = std::filesystem::temp_directory_path() / "ava2-native-area-test.txt";
|
|
{ std::ofstream f(fixture); f << "AreaDataFile\nStart Object000\n10 -20 30\n1\n0#0#90\n5\nEnd Object\n"; }
|
|
ava2::MapObjectManager native;
|
|
native.RegisterProperty(1, bldg_path);
|
|
assert(native.LoadAreaData(fixture.string(), 1, nullptr, true));
|
|
assert(native.GetObjectCount() == 1);
|
|
const auto& object = native.GetObjects().front();
|
|
assert(object.x == 10 && object.y == 35 && object.z == 20);
|
|
assert(object.yaw == 90 && object.pitch == 0 && object.roll == 0);
|
|
std::filesystem::remove(fixture);
|
|
}
|
|
|
|
// Test AreaData & Property scanning
|
|
std::string prop_dir = PackMaker() + "/property/property";
|
|
if (std::filesystem::exists(prop_dir)) {
|
|
obj_mgr.RegisterProperty(234517142, bldg_path);
|
|
assert(obj_mgr.GetPropertyCount() >= 1);
|
|
std::string areadata_path = PackMaker() + "/Maps/metin2_map_a1/001003/areadata.txt";
|
|
if (std::filesystem::exists(areadata_path)) {
|
|
obj_mgr.LoadAreaData(areadata_path, 0.05f);
|
|
std::cout << "Loaded objects from areadata.txt: " << obj_mgr.GetObjectCount() << std::endl;
|
|
}
|
|
}
|
|
|
|
auto obj_draws = obj_mgr.BuildDrawCommands();
|
|
std::cout << "Generated " << obj_draws.size() << " draw commands for map objects." << std::endl;
|
|
assert(!obj_draws.empty() && "Map objects must produce 3D draw commands");
|
|
auto objRepeat = obj_mgr.BuildDrawCommands();
|
|
assert(obj_draws.front().geometry && obj_draws.front().positions.empty());
|
|
assert(objRepeat.front().geometry == obj_draws.front().geometry);
|
|
ava2::MapObjectManager instanceObjects;
|
|
instanceObjects.AddObject(bldg_path,80.f,h_center,-60.f,30.f,0.f,0.f,1.f);
|
|
instanceObjects.AddObject(bldg_path,180.f,h_center,-60.f,60.f,0.f,0.f,1.f);
|
|
auto repeatedObjects=instanceObjects.BuildDrawCommands();
|
|
assert(!repeatedObjects.empty() && repeatedObjects.size()%2==0);
|
|
const auto groupSize=repeatedObjects.size()/2;
|
|
assert(repeatedObjects[0].geometry==repeatedObjects[groupSize].geometry);
|
|
assert(repeatedObjects[0].world[12]!=repeatedObjects[groupSize].world[12]);
|
|
assert(!obj_draws.front().Mesh().positions.empty());
|
|
// Spatial broad phase must match the original object-order traversal, including normals.
|
|
ava2::MapObjectManager collisionGrid;
|
|
for(int x=-5;x<=5;++x)for(int z=-5;z<=5;++z)
|
|
collisionGrid.AddObject(bldg_path,x*3000.f,h_center,z*3000.f,float((x+z)*13),0,0,1);
|
|
collisionGrid.AddObject(bldg_path,0,h_center,0,45,0,0,80); // oversized fallback candidate
|
|
auto linear=[&](float x,float z,float r,float& nx,float& nz,bool normal){
|
|
for(const auto& obj:collisionGrid.GetObjects()) {
|
|
if(!obj.has_collision)continue;
|
|
const float maxR=std::max(obj.obb.halfExtents[0],obj.obb.halfExtents[2])*1.5f+r;
|
|
float dx=x-obj.obb.centerX,dz=z-obj.obb.centerZ;
|
|
if(dx*dx+dz*dz>maxR*maxR)continue;
|
|
float penetration;
|
|
if(normal ? obj.obb.GetPenetrationAndNormal(x,z,r,nx,nz,penetration) : obj.obb.IntersectsCircle2D(x,z,r))return true;
|
|
}
|
|
return false;
|
|
};
|
|
for(int i=0;i<500;++i) {
|
|
float x=float((i*7919)%40000-20000),z=float((i*3571)%40000-20000),r=i%7==0 ? 5000.f : float(i%90+1);
|
|
float a=0,b=0,c=0,d=0;
|
|
assert(collisionGrid.CheckCollision(x,z,r)==linear(x,z,r,a,b,false));
|
|
bool expected=linear(x,z,r,a,b,true),actual=collisionGrid.CheckCollisionNormal(x,z,r,c,d);
|
|
assert(expected==actual);if(expected){assert(std::abs(a-c)<.001f && std::abs(b-d)<.001f);}
|
|
}
|
|
collisionGrid.CheckCollision(0,0,30);
|
|
assert(collisionGrid.GetLastCollisionCandidateCount()<collisionGrid.GetObjectCount()/4);
|
|
collisionGrid.ClearObjects();assert(!collisionGrid.CheckCollision(0,0,30));
|
|
collisionGrid.AddObject(bldg_path,0,h_center,0,0,0,0,1);
|
|
float nx=0,nz=0;assert(collisionGrid.CheckCollision(0,0,30)==linear(0,0,30,nx,nz,false));
|
|
|
|
|
|
// Place character standing on terrain at (0, h_center, 0)
|
|
std::vector<ava2::Render3DDraw> outdoor_scene_draws;
|
|
outdoor_scene_draws.push_back(std::move(terrain_draw));
|
|
|
|
for (auto& od : obj_draws) {
|
|
outdoor_scene_draws.push_back(std::move(od));
|
|
}
|
|
|
|
if (model) {
|
|
float char_world[16];
|
|
ava2::MakeTransformMatrix(0.0f, 0.0f, h_center, 0.0f, 0.8f, char_world);
|
|
auto char_draws = model->BuildDrawCommands(-1.0f, char_world);
|
|
for (auto& cd : char_draws) {
|
|
outdoor_scene_draws.push_back(std::move(cd));
|
|
}
|
|
}
|
|
|
|
// Setup 3D camera for outdoor perspective (third-person view looking at terrain + character)
|
|
renderer.SetCameraLookAt(
|
|
0.0f, h_center + 160.0f, -400.0f, // Eye position
|
|
0.0f, h_center + 60.0f, 0.0f, // Target position
|
|
0.0f, 1.0f, 0.0f // Up
|
|
);
|
|
renderer.SetPerspective(50.0f, static_cast<float>(width) / static_cast<float>(height), 1.0f, 4000.0f);
|
|
|
|
uint32_t sky_color = 0xFF355272; // Outdoor atmospheric sky blue
|
|
SDL_FillSurfaceRect(surface, nullptr, sky_color);
|
|
renderer.Clear(sky_color, 1.0f);
|
|
|
|
renderer.RenderScene(surface, outdoor_scene_draws);
|
|
|
|
int outdoor_pixels = 0;
|
|
const auto& outdoor_depth = renderer.GetDepthBuffer();
|
|
for (int i = 0; i < width * height; ++i) {
|
|
if (outdoor_depth[i] < 0.999f) outdoor_pixels++;
|
|
}
|
|
std::cout << "Rasterized outdoor terrain + character scene pixels: " << outdoor_pixels
|
|
<< " (" << (float(outdoor_pixels) / float(width * height) * 100.0f) << "%)" << std::endl;
|
|
assert(outdoor_pixels > 50000 && "Outdoor terrain must cover substantial viewport pixels");
|
|
|
|
const char* outdoor_screenshot = "/tmp/test_3d_terrain_scene.bmp";
|
|
if (SDL_SaveBMP(surface, outdoor_screenshot)) {
|
|
std::cout << "Successfully saved outdoor terrain + character render to: " << outdoor_screenshot << std::endl;
|
|
}
|
|
|
|
// ── Test WaterManager & Fog Rendering ──────────────────────────────────
|
|
std::cout << "\n── Testing WaterManager & Depth Fog System ──" << std::endl;
|
|
ava2::WaterManager water_mgr;
|
|
std::string water_file = PackMaker() + "/Maps/metin2_map_a1/001003/water.wtr";
|
|
if (std::filesystem::exists(water_file)) {
|
|
bool water_loaded = water_mgr.LoadWater(water_file, 40.0f, 0.5f, 40.0f, -2560.0f, -2560.0f);
|
|
assert(water_loaded && "Failed to load water.wtr");
|
|
assert(water_mgr.HasWater() && "WaterManager must report water exists");
|
|
std::cout << "Loaded water.wtr successfully! Water face count: " << water_mgr.GetWaterFaceCount() << std::endl;
|
|
assert(water_mgr.GetWaterFaceCount() > 0 && "Water face count must be non-zero");
|
|
} else {
|
|
water_mgr.GenerateProceduralWater(25.0f, -2000.0f, 2000.0f, -2000.0f, 2000.0f, 60.0f);
|
|
std::cout << "Generated procedural water plane with faces: " << water_mgr.GetWaterFaceCount() << std::endl;
|
|
}
|
|
|
|
auto water_draw = water_mgr.BuildDrawCommand(0.5f);
|
|
assert(!water_draw.indices.empty() && "Water draw command must produce indices");
|
|
assert(!water_draw.positions.empty() && "Water draw command must produce positions");
|
|
outdoor_scene_draws.push_back(std::move(water_draw));
|
|
|
|
// Test Fog configuration
|
|
renderer.SetFog(true, 0xFF355272, 0.00035f, 200.0f, 3200.0f, true);
|
|
assert(renderer.IsFogEnabled() && "Renderer fog must be enabled");
|
|
assert(renderer.GetFogColor() == 0xFF355272 && "Renderer fog color mismatch");
|
|
|
|
SDL_FillSurfaceRect(surface, nullptr, sky_color);
|
|
renderer.Clear(sky_color, 1.0f);
|
|
renderer.RenderScene(surface, outdoor_scene_draws);
|
|
|
|
int water_fog_pixels = 0;
|
|
const auto& fog_depth = renderer.GetDepthBuffer();
|
|
for (int i = 0; i < width * height; ++i) {
|
|
if (fog_depth[i] < 0.999f) water_fog_pixels++;
|
|
}
|
|
std::cout << "Rasterized outdoor terrain + water + fog pixels: " << water_fog_pixels
|
|
<< " (" << (float(water_fog_pixels) / float(width * height) * 100.0f) << "%)" << std::endl;
|
|
assert(water_fog_pixels > 50000 && "Outdoor scene with water must cover substantial pixels");
|
|
|
|
const char* water_screenshot = "/tmp/test_3d_water_fog_scene.bmp";
|
|
if (SDL_SaveBMP(surface, water_screenshot)) {
|
|
std::cout << "Successfully saved water + fog scene render to: " << water_screenshot << std::endl;
|
|
}
|
|
|
|
// ── Test Monster & NPC GR2 Models ───────────────────────────────────────
|
|
std::cout << "\n── Testing Monster & NPC Models Loading ──" << std::endl;
|
|
const char* mob_npc_models[] = {
|
|
"ymir work/npc_mount/christmas_2017_sleddog/christmas_2017_sleddog.gr2",
|
|
"ymir work/monster/metinstone_02/metinstone_10.gr2",
|
|
"ymir work/npc/12zi_statue_rabbit_npc/12zi_statue_rabbit_npc.gr2"
|
|
};
|
|
int mob_loaded = 0;
|
|
for (const char* mob_p : mob_npc_models) {
|
|
std::string p = mob_p;
|
|
if (!std::filesystem::exists(p) && std::filesystem::exists("../" + p)) {
|
|
p = "../" + p;
|
|
}
|
|
auto mob_inst = ava2::Gr2ModelInstance::Load(p);
|
|
if (mob_inst) {
|
|
mob_loaded++;
|
|
auto d = mob_inst->BuildDrawCommands();
|
|
assert(!d.empty() && "Monster/NPC model must produce draw commands");
|
|
}
|
|
}
|
|
std::cout << "Successfully loaded and verified " << mob_loaded << "/3 monster/NPC models." << std::endl;
|
|
assert(mob_loaded == 3 && "All 3 monster/NPC models must load successfully");
|
|
|
|
// ── Test 8 Character Class / Form Models ────────────────────────────────
|
|
std::cout << "\n── Testing 8 Character Class Models Loading ──" << std::endl;
|
|
const char* race_models[] = {
|
|
"ymir work/pc/warrior/warrior_assasin1.gr2",
|
|
"ymir work/pc/assassin/assassin_halloween1_lod_01.gr2",
|
|
"ymir work/pc/sura/sura_soccer1_germany_lod_02.gr2",
|
|
"ymir work/pc/shaman/shaman_fencing1_germany_lod_02.gr2",
|
|
"ymir work/pc/plechito/summer2020_costume/warrior_w.gr2",
|
|
"ymir work/pc/plechito/summer2020_costume/assassin_m.gr2",
|
|
"ymir work/pc/plechito/summer2020_costume/sura_w.gr2",
|
|
"ymir work/pc/plechito/summer2020_costume/shaman_m.gr2"
|
|
};
|
|
|
|
int loaded_count = 0;
|
|
for (int r = 0; r < 8; ++r) {
|
|
std::string p = race_models[r];
|
|
if (!std::filesystem::exists(p) && std::filesystem::exists("../" + p)) {
|
|
p = "../" + p;
|
|
}
|
|
auto race_inst = ava2::Gr2ModelInstance::Load(p);
|
|
if (race_inst) {
|
|
loaded_count++;
|
|
auto d = race_inst->BuildDrawCommands();
|
|
assert(!d.empty() && "Race model must produce draw commands");
|
|
}
|
|
}
|
|
std::cout << "Successfully loaded and verified " << loaded_count << "/8 character class models." << std::endl;
|
|
assert(loaded_count == 8 && "All 8 character class models must load successfully");
|
|
|
|
// ── Test OrbitCamera (Third-Person Orbit Camera System) ─────────────────
|
|
std::cout << "\n── Testing OrbitCamera (Third-Person Camera System) ──" << std::endl;
|
|
ava2::OrbitCamera cam;
|
|
cam.SetTarget(50.0f, 20.0f, 100.0f);
|
|
cam.SetTargetHeight(85.0f);
|
|
assert(cam.GetTargetHeight() == 85.0f);
|
|
|
|
cam.SetDistance(500.0f);
|
|
assert(cam.GetDistance() == 500.0f);
|
|
cam.SetPitch(30.0f);
|
|
assert(cam.GetPitch() == 30.0f);
|
|
cam.SetYaw(45.0f);
|
|
assert(cam.GetYaw() == 45.0f);
|
|
|
|
// Test pitch clamping
|
|
cam.SetPitch(100.0f);
|
|
assert(cam.GetPitch() <= 85.0f);
|
|
cam.SetPitch(-20.0f);
|
|
assert(cam.GetPitch() >= 5.0f);
|
|
cam.SetPitch(30.0f);
|
|
|
|
// Test yaw wrapping
|
|
cam.SetYaw(400.0f);
|
|
assert(std::abs(cam.GetYaw() - 40.0f) < 0.01f);
|
|
cam.SetYaw(-30.0f);
|
|
assert(std::abs(cam.GetYaw() - 330.0f) < 0.01f);
|
|
cam.SetYaw(0.0f);
|
|
|
|
// Test distance clamping & Zoom
|
|
cam.SetDistance(3000.0f);
|
|
assert(cam.GetDistance() <= 2500.0f);
|
|
cam.SetDistance(50.0f);
|
|
assert(cam.GetDistance() >= 120.0f);
|
|
|
|
cam.SetDistance(400.0f);
|
|
cam.Zoom(2.0f, 50.0f); // Zoom in: 400 - 100 = 300
|
|
assert(cam.GetDistance() == 300.0f);
|
|
cam.Zoom(-1.0f, 50.0f); // Zoom out: 300 + 50 = 350
|
|
assert(cam.GetDistance() == 350.0f);
|
|
|
|
// Test mouse dragging
|
|
cam.BeginDrag(100, 100);
|
|
assert(cam.IsDragging());
|
|
cam.Drag(120, 80, 0.5f); // dx = +20 -> yaw += 10; dy = -20 -> pitch += 10
|
|
assert(cam.GetYaw() > 0.0f);
|
|
cam.EndDrag();
|
|
assert(!cam.IsDragging());
|
|
|
|
// Test eye position calculation and renderer application
|
|
float eyeX = 0.0f, eyeY = 0.0f, eyeZ = 0.0f;
|
|
cam.GetEye(eyeX, eyeY, eyeZ);
|
|
float tgtX = 0.0f, tgtY = 0.0f, tgtZ = 0.0f;
|
|
cam.GetLookTarget(tgtX, tgtY, tgtZ);
|
|
assert(tgtX == 50.0f && tgtY == 105.0f && tgtZ == 100.0f);
|
|
cam.ApplyToRenderer(renderer);
|
|
std::cout << "OrbitCamera tested and verified successfully!" << std::endl;
|
|
|
|
// ── Test MinimapManager (Radar Minimap System) ──────────────────────────
|
|
std::cout << "\n── Testing MinimapManager (Radar Minimap System) ──" << std::endl;
|
|
ava2::MinimapManager minimap;
|
|
std::string minimap_test_path = PackMaker() + "/Maps/metin2_map_a1/001003/minimap.dds";
|
|
if (std::filesystem::exists(minimap_test_path)) {
|
|
bool m_ok = minimap.LoadMinimap(minimap_test_path);
|
|
std::cout << "Loaded Metin2 minimap.dds: " << (m_ok ? "SUCCESS" : "FAILED")
|
|
<< " (" << minimap.GetTextureWidth() << "x" << minimap.GetTextureHeight() << ")" << std::endl;
|
|
assert(m_ok);
|
|
assert(minimap.HasTexture());
|
|
assert(minimap.GetTextureWidth() == 256 && minimap.GetTextureHeight() == 256);
|
|
} else {
|
|
minimap.GenerateProceduralMinimap(256, 256);
|
|
assert(minimap.HasTexture());
|
|
}
|
|
|
|
minimap.SetWorldBounds(-2600.0f, 2600.0f, -2600.0f, 2600.0f);
|
|
minimap.ClearBlips();
|
|
minimap.AddBlip(120.0f, -80.0f, ava2::MinimapBlipType::Monster);
|
|
minimap.AddBlip(-160.0f, 90.0f, ava2::MinimapBlipType::Monster);
|
|
minimap.AddBlip(60.0f, 140.0f, ava2::MinimapBlipType::NPC);
|
|
assert(minimap.GetBlipCount() == 3);
|
|
|
|
// Test radar rasterization onto surface
|
|
minimap.RenderRadar(surface, width - 180, 20, 160, 0.0f, 0.0f, 0.0f);
|
|
|
|
// Check that golden border pixel exists
|
|
uint32_t* radar_px = static_cast<uint32_t*>(surface->pixels);
|
|
int gold_pixels = 0;
|
|
for (int y = 20; y < 180; ++y) {
|
|
for (int x = width - 180; x < width - 20; ++x) {
|
|
uint32_t col = radar_px[y * (surface->pitch / 4) + x];
|
|
if (col == 0xFFC29B4A) gold_pixels++;
|
|
}
|
|
}
|
|
std::cout << "Radar golden frame pixels rendered: " << gold_pixels << std::endl;
|
|
assert(gold_pixels > 50 && "Minimap radar golden frame must be rasterized");
|
|
|
|
const char* radar_screenshot = "/tmp/test_3d_minimap_radar.bmp";
|
|
if (SDL_SaveBMP(surface, radar_screenshot)) {
|
|
std::cout << "Successfully saved minimap radar render to: " << radar_screenshot << std::endl;
|
|
}
|
|
|
|
// Parsed model resources are shared, while instance attachments and pose clocks are independent.
|
|
auto sharedA = ava2::Gr2ModelInstance::Load(model_path);
|
|
auto sharedB = ava2::Gr2ModelInstance::Load(model_path);
|
|
assert(sharedA && sharedB && &sharedA->GetFile() == &sharedB->GetFile());
|
|
const std::string cachedAnimation = "ymir work/pc/warrior/horse/wait.gr2";
|
|
assert(sharedA->LoadExternalAnimation(cachedAnimation));
|
|
assert(sharedB->LoadExternalAnimation(cachedAnimation));
|
|
assert(sharedA->GetImpl()->GetAnimationResource() == sharedB->GetImpl()->GetAnimationResource());
|
|
float cachedLeg[16], repeatLeg[16];
|
|
assert(sharedA->GetBoneWorldTransform("Bip01 L Calf", cachedLeg, .25f));
|
|
const auto countBefore = sharedA->GetImpl()->GetPoseEvaluationCount();
|
|
assert(sharedA->GetBoneWorldTransform("Bip01 L Calf", repeatLeg, .25f));
|
|
sharedA->BuildDrawCommands(.25f);
|
|
assert(sharedA->GetImpl()->GetPoseEvaluationCount() == countBefore);
|
|
std::vector<gr2::Mat4> referenceWorld, referenceSkin;
|
|
const auto* animationFile = sharedA->GetImpl()->GetAnimationResource();
|
|
const gr2::Mat4 identity{1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1};
|
|
gr2::sample_pose(sharedA->GetInfo().skeletons[0], animationFile->file_info().animations[0], .25f,
|
|
referenceWorld, referenceSkin, &identity);
|
|
const auto& bones = sharedA->GetInfo().skeletons[0].bones;
|
|
for (size_t b=0;b<bones.size();++b) if (bones[b].name=="Bip01 L Calf")
|
|
for (int k=0;k<16;++k) assert(std::abs(cachedLeg[k]-referenceWorld[b][k])<.001f);
|
|
assert(sharedA->GetBoneWorldTransform("Bip01 L Calf", repeatLeg, .5f));
|
|
assert(sharedA->GetImpl()->GetPoseEvaluationCount() == countBefore+1);
|
|
assert(sharedA->LoadExternalAnimation("ymir work/pc/warrior/general/wait.gr2"));
|
|
assert(sharedA->GetBoneWorldTransform("Bip01 L Calf", repeatLeg, .5f));
|
|
assert(sharedA->GetImpl()->GetPoseEvaluationCount() == countBefore+2);
|
|
assert(sharedB->GetImpl()->GetPoseEvaluationCount() == 0);
|
|
// Replacing a resource at the same path must invalidate the parsed-file cache.
|
|
const auto reloadPath = std::filesystem::temp_directory_path()/"ava2_model_cache_reload.gr2";
|
|
std::filesystem::copy_file(model_path,reloadPath,std::filesystem::copy_options::overwrite_existing);
|
|
auto reloadA = ava2::Gr2ModelInstance::Load(reloadPath.string());
|
|
auto reloadB = ava2::Gr2ModelInstance::Load(reloadPath.string());
|
|
assert(reloadA && reloadB && &reloadA->GetFile()==&reloadB->GetFile());
|
|
std::filesystem::last_write_time(reloadPath,std::filesystem::last_write_time(reloadPath)+std::chrono::seconds(1));
|
|
auto reloadC = ava2::Gr2ModelInstance::Load(reloadPath.string());
|
|
assert(reloadC && &reloadA->GetFile()!=&reloadC->GetFile());
|
|
std::filesystem::remove(reloadPath);
|
|
|
|
// GPU streams retain raw vertices and weights; independently apply the palette
|
|
// and compare every vertex/normal against the established CPU skinning path.
|
|
auto checkGpuSkin=[](ava2::Gr2ModelInstance& instance,float time) {
|
|
auto cpu=instance.GetImpl()->BuildDrawCommands(time,nullptr,false);
|
|
auto gpu=instance.GetImpl()->BuildDrawCommands(time,nullptr,true);
|
|
assert(cpu.size()==gpu.size());
|
|
auto again=instance.GetImpl()->BuildDrawCommands(time+.1f,nullptr,true);
|
|
assert(again.size()==gpu.size());
|
|
for(size_t d=0;d<cpu.size();++d) {
|
|
const auto& g=gpu[d];assert(g.geometry && again[d].geometry==g.geometry);
|
|
const auto& mesh=*g.geometry;
|
|
assert(cpu[d].positions.size()==mesh.positions.size());
|
|
assert(cpu[d].indices==mesh.indices);
|
|
for(size_t v=0;v<mesh.positions.size()/3;++v) {
|
|
float p[3]{},n[3]{},total=0;
|
|
if(g.gpu_skinning)for(int b=0;b<4;++b) {
|
|
const auto bone=mesh.bone_indices[v*4+b];const float w=mesh.bone_weights[v*4+b];
|
|
if(w<=0 || size_t(bone)*16+15>=g.bone_matrices.size())continue;
|
|
const auto* m=g.bone_matrices.data()+bone*16;
|
|
for(int k=0;k<3;++k){p[k]+=(mesh.positions[v*3]*m[k]+mesh.positions[v*3+1]*m[k+4]+mesh.positions[v*3+2]*m[k+8]+m[k+12])*w;
|
|
n[k]+=(mesh.normals[v*3]*m[k]+mesh.normals[v*3+1]*m[k+4]+mesh.normals[v*3+2]*m[k+8])*w;}
|
|
total+=w;
|
|
}
|
|
for(int k=0;k<3;++k){if(total<=.0001f){p[k]=mesh.positions[v*3+k];n[k]=mesh.normals[v*3+k];}
|
|
assert(std::abs(p[k]-cpu[d].positions[v*3+k])<.001f);
|
|
assert(std::abs(n[k]-cpu[d].normals[v*3+k])<.001f);}
|
|
}
|
|
}
|
|
};
|
|
checkGpuSkin(*sharedA,.25f);
|
|
auto gpuPart=ava2::Gr2ModelInstance::Load(hair_path);
|
|
if(gpuPart)sharedA->AttachPart(std::move(gpuPart));
|
|
auto gpuWeapon=ava2::Gr2ModelInstance::Load(weapon_path);
|
|
if(gpuWeapon)sharedA->AttachModel("equip_right_hand",std::move(gpuWeapon));
|
|
checkGpuSkin(*sharedA,.5f);
|
|
|
|
// Mounted NPCs must animate in the registered horse mode, including after an armor rebuild.
|
|
ava2::RaceManager::Instance().LoadPlayerRaces();
|
|
ava2::ActorInstance rider;
|
|
assert(rider.SetRace(0));
|
|
assert(rider.SetModel(model_path));
|
|
assert(rider.PlayMotion(ava2::MotionType::Wait, true));
|
|
float standingLeg[16], ridingLeg[16];
|
|
assert(rider.GetModel()->GetBoneWorldTransform("Bip01 L Calf", standingLeg, 0.0f));
|
|
rider.SetMotionMode(9);
|
|
assert(rider.PlayMotion(ava2::MotionType::Wait, true));
|
|
assert(rider.GetModel()->GetBoneWorldTransform("Bip01 L Calf", ridingLeg, 0.0f));
|
|
float poseDifference = 0;
|
|
for (int i = 0; i < 16; ++i) poseDifference += std::abs(standingLeg[i] - ridingLeg[i]);
|
|
assert(poseDifference > 1.0f && "Riding must bend the legs rather than reuse standing pose");
|
|
assert(rider.SetRace(0));
|
|
assert(rider.SetModel(model_path));
|
|
assert(rider.PlayMotion(ava2::MotionType::Wait, true));
|
|
float rebuiltLeg[16];
|
|
assert(rider.GetModel()->GetBoneWorldTransform("Bip01 L Calf", rebuiltLeg, 0.0f));
|
|
for (int i = 0; i < 16; ++i) assert(std::abs(rebuiltLeg[i] - ridingLeg[i]) < 0.001f);
|
|
rider.SetMotionMode(1);
|
|
assert(rider.PlayMotion(ava2::MotionType::Wait, true));
|
|
assert(rider.GetModel()->GetBoneWorldTransform("Bip01 L Calf", rebuiltLeg, 0.0f));
|
|
for (int i = 0; i < 16; ++i) assert(std::abs(rebuiltLeg[i] - standingLeg[i]) < 0.001f);
|
|
|
|
// ── Test ActorInstance (Motion State Machine & Combat System) ─────────
|
|
std::cout << "\n── Testing ActorInstance (Motion State Machine & Combat) ──" << std::endl;
|
|
ava2::ActorInstance actor;
|
|
bool actor_loaded = actor.SetModel(model_path);
|
|
assert(actor_loaded && "ActorInstance must load base model");
|
|
bool wep_loaded = actor.SetWeapon(weapon_path);
|
|
assert(wep_loaded && "ActorInstance must attach weapon");
|
|
|
|
actor.RegisterMotion(ava2::MotionType::Wait, "ymir work/pc/warrior/skill/geomgyeong.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::Run, "ymir work/pc/warrior/skill/geompung.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::Walk, "ymir work/pc/warrior/skill/geompung.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::Attack, "ymir work/pc/warrior/skill/samyeon.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::ComboAttack1, "ymir work/pc/warrior/skill/samyeon.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::ComboAttack2, "ymir work/pc/warrior/skill/palbang.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::ComboAttack3, "ymir work/pc/warrior/skill/finish.gr2");
|
|
actor.RegisterMotion(ava2::MotionType::Damage, "ymir work/pc/warrior/skill/geomgyeong.gr2");
|
|
|
|
bool played_wait = actor.PlayMotion(ava2::MotionType::Wait, true);
|
|
assert(played_wait && "Must play Wait motion");
|
|
assert(actor.GetCurrentMotion() == ava2::MotionType::Wait);
|
|
assert(actor.GetMotionDuration() > 0.1f);
|
|
|
|
actor.Update(0.1f, &terrain);
|
|
assert(actor.GetAnimTime() > 0.05f);
|
|
|
|
actor.SetPosition(0,0,0);
|
|
ava2::Gr2SceneRenderer cullCamera;
|
|
cullCamera.SetCameraLookAt(0,200,-1000,0,100,0,0,1,0);
|
|
cullCamera.SetPerspective(45,1.0f,1,10000);
|
|
assert(actor.IsVisible(cullCamera.GetViewMatrix(),cullCamera.GetProjMatrix()));
|
|
actor.SetPosition(100000,0,0);
|
|
assert(!actor.IsVisible(cullCamera.GetViewMatrix(),cullCamera.GetProjMatrix()));
|
|
const auto poseBeforeCull = actor.GetModel()->GetImpl()->GetPoseEvaluationCount();
|
|
assert(!actor.IsVisible(cullCamera.GetViewMatrix(),cullCamera.GetProjMatrix()));
|
|
assert(actor.GetModel()->GetImpl()->GetPoseEvaluationCount()==poseBeforeCull);
|
|
assert(actor.IsVisible(nullptr,nullptr));
|
|
|
|
// Test movement driving
|
|
actor.SetPosition(0.0f, 0.0f, 0.0f);
|
|
actor.MoveInDirection(90.0f, 0.2f, &terrain); // Move East
|
|
assert(actor.GetX() > 10.0f && "Actor must move in X direction");
|
|
assert(actor.GetCurrentMotion() == ava2::MotionType::Run);
|
|
|
|
actor.StopMoving();
|
|
assert(actor.GetCurrentMotion() == ava2::MotionType::Wait);
|
|
|
|
// Test combat combo attack
|
|
bool attacked = actor.Attack();
|
|
assert(attacked && "Must initiate attack combo");
|
|
assert(actor.IsAttacking());
|
|
assert(actor.GetCurrentMotion() == ava2::MotionType::ComboAttack1);
|
|
|
|
// Test attack range detection
|
|
ava2::ActorInstance target_dummy;
|
|
target_dummy.SetPosition(actor.GetX() + 50.0f, actor.GetY(), actor.GetZ());
|
|
actor.SetYaw(90.0f); // Facing target
|
|
assert(actor.IsTargetInAttackRange(target_dummy, 100.0f, 60.0f));
|
|
|
|
target_dummy.SetPosition(actor.GetX() - 50.0f, actor.GetY(), actor.GetZ()); // Behind
|
|
assert(!actor.IsTargetInAttackRange(target_dummy, 100.0f, 60.0f));
|
|
|
|
// Test target taking damage & knockback
|
|
target_dummy.SetMaxHP(500);
|
|
target_dummy.TakeDamage(150, -10.0f, 0.0f);
|
|
assert(target_dummy.GetHP() == 350);
|
|
target_dummy.Update(0.1f, &terrain);
|
|
|
|
// Test BuildDrawCommands
|
|
auto actor_draws = actor.BuildDrawCommands();
|
|
assert(!actor_draws.empty() && "ActorInstance must produce draw commands with animated weapon");
|
|
std::cout << "ActorInstance motion state machine and combat verified successfully!" << std::endl;
|
|
|
|
// ── Test FloatingTextManager (Combat Floating Numbers & Projection) ───
|
|
std::cout << "\n── Testing FloatingTextManager (Combat Text & Projection) ──" << std::endl;
|
|
ava2::FloatingTextManager ftm;
|
|
ftm.AddDamage(420, 0.0f, 100.0f, 0.0f, false, true);
|
|
ftm.AddDamage(840, 0.0f, 100.0f, 0.0f, true, true);
|
|
assert(ftm.GetCount() == 2);
|
|
|
|
ftm.Update(0.2f);
|
|
assert(ftm.GetCount() == 2);
|
|
|
|
float sx = 0.0f, sy = 0.0f;
|
|
bool projected = renderer.ProjectToScreen(0.0f, 100.0f, 0.0f, sx, sy);
|
|
assert(projected && "Gr2SceneRenderer::ProjectToScreen must project visible point");
|
|
assert(sx > 0.0f && sx < static_cast<float>(width));
|
|
assert(sy > 0.0f && sy < static_cast<float>(height));
|
|
std::cout << "3D to Screen projection test: (" << sx << ", " << sy << ")" << std::endl;
|
|
|
|
ftm.Update(2.0f); // Fast forward past lifetime
|
|
assert(ftm.GetCount() == 0 && "Floating texts must expire after lifetime");
|
|
std::cout << "FloatingTextManager verified successfully!" << std::endl;
|
|
|
|
// ── Test TextTailManager (40250 CPythonTextTail Overhead & Item Labels) ─
|
|
std::cout << "\n── Testing TextTailManager (Overhead Names, Titles, Levels, Items & Picking) ──" << std::endl;
|
|
auto& ttm = ava2::TextTailManager::Instance();
|
|
ttm.Clear();
|
|
assert(ttm.GetCharacterCount() == 0);
|
|
assert(ttm.GetItemCount() == 0);
|
|
|
|
// 1. Character TextTail registration
|
|
uint32_t charVid = 1001;
|
|
ttm.RegisterCharacterTextTail(12, charVid, 0xFFFFFFFF, 175.0f);
|
|
ttm.SetCharacterName(charVid, "WarriorKing");
|
|
ttm.AttachTitle(charVid, "Noble", 0xFFFFD700);
|
|
ttm.AttachLevel(charVid, "[Lv. 99]", 0xFF98FF33);
|
|
ttm.SetGuildName(charVid, "Olympus");
|
|
ttm.SetCharacterPosition(charVid, 0.0f, 0.0f, 0.0f);
|
|
assert(ttm.HasCharacter(charVid));
|
|
|
|
// 2. Chat bubble
|
|
ttm.RegisterChatTail(charVid, "Welcome to Metin2!");
|
|
assert(ttm.IsChatTextTail(charVid));
|
|
|
|
// 3. Item TextTail registration
|
|
uint32_t itemVid = 2001;
|
|
ttm.RegisterItemTextTail(itemVid, "Full Moon Sword +9", 50.0f, 0.0f, 50.0f, 180, "WarriorKing", true, 0xFFFFFFFF);
|
|
assert(ttm.HasItem(itemVid));
|
|
|
|
uint32_t itemVid2 = 2002;
|
|
ttm.RegisterItemTextTail(itemVid2, "Red Potion (L)", 50.0f, 0.0f, 50.0f, 0, "", false, 0xFFFF4040);
|
|
assert(ttm.HasItem(itemVid2));
|
|
|
|
// 4. Update projections & show texttails
|
|
ttm.ShowAllTextTail();
|
|
assert(ttm.GetShowingCharacterCount() == 1);
|
|
assert(ttm.GetShowingItemCount() == 2);
|
|
|
|
ttm.UpdateAllTextTail(0.0f, 0.0f, 0.0f, &renderer);
|
|
ttm.UpdateShowingTextTail(&renderer);
|
|
|
|
float ttx = 0.0f, tty = 0.0f, ttz = 0.0f;
|
|
bool hasPos = ttm.GetTextTailPosition(charVid, ttx, tty, ttz);
|
|
assert(hasPos && "Character texttail must have valid screen position");
|
|
std::cout << "Projected Character TextTail screen pos: (" << ttx << ", " << tty << ")" << std::endl;
|
|
|
|
// 5. Arrange texttails (overlap resolution)
|
|
auto item1 = ttm.GetItemTail(itemVid);
|
|
auto item2 = ttm.GetItemTail(itemVid2);
|
|
float origY2 = item2->y;
|
|
ttm.ArrangeTextTail();
|
|
// Since item1 and item2 were at same world pos, item2's y must be shifted down to prevent overlap!
|
|
assert(item2->y > origY2 && "Overlapping items must be arranged apart");
|
|
std::cout << "ArrangeTextTail resolved overlap: item1.y=" << item1->y << ", item2.y=" << item2->y << std::endl;
|
|
|
|
// 6. Mouse Picking
|
|
// Mouse clicked on item1's screen position
|
|
int pickVid = ttm.Pick(static_cast<int>(item1->x), static_cast<int>(item1->y));
|
|
assert(pickVid == static_cast<int>(itemVid) && "Mouse picking must hit item1");
|
|
assert(item1->isSelected && "Picked item must be marked as selected");
|
|
std::cout << "Mouse picking successfully picked item VID: " << pickVid << std::endl;
|
|
|
|
// 7. Chat timer update
|
|
ttm.Update(5.0f); // Fast forward past chat duration
|
|
assert(!ttm.IsChatTextTail(charVid) && "Chat bubble must expire after duration");
|
|
|
|
// 8. Hide and Clear
|
|
ttm.HideAllTextTail();
|
|
assert(ttm.GetShowingCharacterCount() == 0);
|
|
assert(ttm.GetShowingItemCount() == 0);
|
|
ttm.Clear();
|
|
assert(ttm.GetCharacterCount() == 0);
|
|
std::cout << "TextTailManager verified successfully!" << std::endl;
|
|
|
|
// ── Test ScreenToWorldRay & Terrain Picking (40250 GrpScreen & MapOutdoor) ─
|
|
std::cout << "\n── Testing ScreenToWorldRay & PickTerrain ──" << std::endl;
|
|
cam.SetTarget(0.0f, h_center, 0.0f);
|
|
cam.SetDistance(450.0f);
|
|
cam.SetPitch(25.0f);
|
|
cam.SetYaw(0.0f);
|
|
cam.ApplyToRenderer(renderer);
|
|
renderer.SetPerspective(50.0f, static_cast<float>(width) / static_cast<float>(height), 1.0f, 4000.0f);
|
|
|
|
float rayOrig[3] = {0}, rayDir[3] = {0};
|
|
bool rayOk = renderer.ScreenToWorldRay(width * 0.5f, height * 0.5f, rayOrig, rayDir);
|
|
assert(rayOk && "ScreenToWorldRay must succeed for screen center");
|
|
float rLen = std::sqrt(rayDir[0]*rayDir[0] + rayDir[1]*rayDir[1] + rayDir[2]*rayDir[2]);
|
|
assert(std::abs(rLen - 1.0f) < 1e-4f && "Ray direction must be normalized");
|
|
std::cout << "Unprojected ray: Orig(" << rayOrig[0] << ", " << rayOrig[1] << ", " << rayOrig[2]
|
|
<< ") Dir(" << rayDir[0] << ", " << rayDir[1] << ", " << rayDir[2] << ")" << std::endl;
|
|
|
|
float pickX = 0, pickY = 0, pickZ = 0;
|
|
bool pickOk = renderer.PickTerrain(width * 0.5f, height * 0.5f, terrain, pickX, pickY, pickZ);
|
|
std::cout << "PickTerrain at center: " << (pickOk ? "HIT" : "MISS")
|
|
<< " (" << pickX << ", " << pickY << ", " << pickZ << ")" << std::endl;
|
|
assert(pickOk && "Screen center ray must hit terrain in outdoor scene");
|
|
float groundH = terrain.GetHeightAtWorld(pickX, pickZ);
|
|
assert(std::abs(pickY - groundH) < 0.1f && "PickTerrain Y coordinate must match terrain heightmap");
|
|
|
|
// ── Test Click-to-Move & Destination Pathing ───────────────────────────
|
|
std::cout << "\n── Testing Click-to-Move & Destination Pathing ──" << std::endl;
|
|
actor.SetPosition(0.0f, h_center, 0.0f);
|
|
actor.PlayMotion(ava2::MotionType::Wait, true);
|
|
actor.SetMoveTarget(80.0f, 60.0f);
|
|
assert(actor.HasMoveTarget());
|
|
float tx = 0, tz = 0;
|
|
actor.GetMoveTarget(tx, tz);
|
|
assert(tx == 80.0f && tz == 60.0f);
|
|
|
|
actor.Update(0.1f, &terrain);
|
|
assert(actor.GetCurrentMotion() == ava2::MotionType::Run);
|
|
assert(actor.GetX() > 0.0f && actor.GetZ() > 0.0f && "Actor must move towards destination");
|
|
|
|
// Advance until destination reached
|
|
actor.Update(1.0f, &terrain);
|
|
assert(!actor.HasMoveTarget() && "Actor must clear move target upon arriving at destination");
|
|
assert(actor.GetCurrentMotion() == ava2::MotionType::Wait);
|
|
|
|
// ── Test Screen Space Capsule HitTestScreen ────────────────────────────
|
|
std::cout << "\n── Testing HitTestScreen ──" << std::endl;
|
|
actor.SetPosition(0.0f, h_center, 0.0f);
|
|
float ax = 0, ay = 0;
|
|
bool aProj = renderer.ProjectToScreen(0.0f, h_center, 0.0f, ax, ay);
|
|
assert(aProj);
|
|
assert(actor.HitTestScreen(ax, ay, renderer, 40.0f) && "Click at projected base must hit actor");
|
|
assert(!actor.HitTestScreen(ax + 200.0f, ay + 200.0f, renderer, 40.0f) && "Click far away must miss actor");
|
|
|
|
// ── Test TargetManager (Selection Ring Decal, TargetBoard, EFFECT_PICK)
|
|
std::cout << "\n── Testing TargetManager (Selection Ring & TargetBoard) ──" << std::endl;
|
|
ava2::TargetManager tm;
|
|
actor.SetVID(1001);
|
|
actor.SetName("WarriorHero");
|
|
actor.SetMaxHP(1200);
|
|
|
|
tm.SelectTarget(&actor);
|
|
assert(tm.HasTarget());
|
|
assert(tm.GetTarget() == &actor);
|
|
assert(tm.GetTargetVID() == 1001);
|
|
|
|
tm.AddGroundPickEffect(pickX, pickY, pickZ);
|
|
assert(tm.HasGroundPickEffect());
|
|
|
|
tm.Update(0.1f);
|
|
assert(tm.HasGroundPickEffect());
|
|
|
|
// Software renderer verification of TargetManager drawing routines
|
|
SDL_Renderer* sw_rnd = SDL_CreateSoftwareRenderer(surface);
|
|
assert(sw_rnd && "SDL_CreateSoftwareRenderer must succeed");
|
|
tm.Render(sw_rnd, renderer);
|
|
|
|
// Render floating text as well
|
|
ftm.AddDamage(350, 0.0f, h_center + 60.0f, 0.0f, true, true);
|
|
ftm.Render(sw_rnd, renderer);
|
|
|
|
// Render TextTailManager overhead nameplates & dropped items
|
|
ttm.RegisterCharacterTextTail(1, 1001, 0xFFFFFFFF, 175.0f);
|
|
ttm.SetCharacterName(1001, "WarriorHero");
|
|
ttm.AttachTitle(1001, "Noble", 0xFFFFD700);
|
|
ttm.AttachLevel(1001, "[Lv. 99]", 0xFF98FF33);
|
|
ttm.SetGuildName(1001, "Olympus");
|
|
ttm.SetCharacterPosition(1001, 0.0f, h_center, 0.0f);
|
|
ttm.RegisterChatTail(1001, "Metin2 TextTail System Online!");
|
|
|
|
ttm.RegisterItemTextTail(5001, "Full Moon Sword +9", 60.0f, h_center, 40.0f, 180, "WarriorHero", true);
|
|
ttm.RegisterItemTextTail(5002, "Red Potion (L)", 60.0f, h_center, 40.0f, 0, "", false, 0xFFFF3333);
|
|
ttm.ShowAllTextTail();
|
|
ttm.UpdateAllTextTail(0.0f, h_center, 0.0f, &renderer);
|
|
ttm.UpdateShowingTextTail(&renderer);
|
|
ttm.ArrangeTextTail();
|
|
ttm.SelectItemName(5001);
|
|
|
|
ttm.Render(sw_rnd, &renderer);
|
|
|
|
SDL_RenderPresent(sw_rnd);
|
|
|
|
const char* texttail_screenshot = "/tmp/test_3d_texttail_scene.bmp";
|
|
SDL_SaveBMP(surface, texttail_screenshot);
|
|
std::cout << "Successfully saved texttail + 3D scene render to: " << texttail_screenshot << std::endl;
|
|
|
|
SDL_DestroyRenderer(sw_rnd);
|
|
|
|
tm.ClearTarget();
|
|
assert(!tm.HasTarget() && "ClearTarget must clear selected actor");
|
|
std::cout << "TargetManager & Click-to-Move verified successfully!" << std::endl;
|
|
|
|
// ── Test PRTerrainLib: Quadtree, Frustum Culling, Attr Blocking & Multi-Texture Patch Shading ──
|
|
std::cout << "\n── Testing PRTerrainLib Quadtree, Frustum Culling & Attr Collision ──" << std::endl;
|
|
ava2::TerrainHeightmap pr_terrain;
|
|
|
|
std::string test_raw = "map/metin2_map_a1/001003/height.raw";
|
|
if (!std::filesystem::exists(test_raw)) {
|
|
test_raw = PackMaker() + "/Maps/metin2_map_a1/001003/height.raw";
|
|
}
|
|
std::string test_tile = "map/metin2_map_a1/001003/tile.raw";
|
|
if (!std::filesystem::exists(test_tile)) {
|
|
test_tile = PackMaker() + "/Maps/metin2_map_a1/001003/tile.raw";
|
|
}
|
|
std::string test_attr = "map/metin2_map_a1/001003/attr.atr";
|
|
if (!std::filesystem::exists(test_attr)) {
|
|
test_attr = PackMaker() + "/Maps/metin2_map_a1/001003/attr.atr";
|
|
}
|
|
std::string test_tset = "textureset/metin2_map1.txt";
|
|
if (!std::filesystem::exists(test_tset)) {
|
|
test_tset = PackMaker() + "/textureset/textureset/metin2_map1.txt";
|
|
}
|
|
|
|
if (std::filesystem::exists(test_raw)) {
|
|
bool raw_res = pr_terrain.LoadRaw(test_raw, 0.5f, 200.0f);
|
|
assert(raw_res && "PRTerrain LoadRaw must succeed");
|
|
std::cout << "Loaded official height.raw: " << pr_terrain.GetWidth() << "x" << pr_terrain.GetHeight() << std::endl;
|
|
}
|
|
if (std::filesystem::exists(test_tile)) {
|
|
bool tile_res = pr_terrain.LoadTileRaw(test_tile);
|
|
assert(tile_res && "PRTerrain LoadTileRaw must succeed");
|
|
std::cout << "Loaded official tile.raw: " << pr_terrain.GetTileWidth() << "x" << pr_terrain.GetTileHeight() << std::endl;
|
|
}
|
|
if (std::filesystem::exists(test_attr)) {
|
|
bool attr_res = pr_terrain.LoadAttr(test_attr);
|
|
assert(attr_res && "PRTerrain LoadAttr must succeed");
|
|
std::cout << "Loaded official attr.atr: " << pr_terrain.GetAttrWidth() << "x" << pr_terrain.GetAttrHeight() << std::endl;
|
|
assert(pr_terrain.GetAttrWidth() == 256 && pr_terrain.GetAttrHeight() == 256);
|
|
}
|
|
if (std::filesystem::exists(test_tset)) {
|
|
bool tset_res = pr_terrain.LoadTextureSet(test_tset);
|
|
assert(tset_res && "PRTerrain LoadTextureSet must succeed");
|
|
std::cout << "Loaded textureset: " << test_tset << std::endl;
|
|
}
|
|
|
|
// 1. Verify 8x8 Patch Quadtree
|
|
assert(pr_terrain.GetPatchCount() == 64 && "Terrain must have 64 (8x8) patches");
|
|
std::cout << "Verified 8x8 patches (count = " << pr_terrain.GetPatchCount() << ")" << std::endl;
|
|
|
|
// 2. Verify Frustum Culling with OrbitCamera
|
|
float pr_h_center = pr_terrain.GetHeightAtWorld(0.0f, 0.0f);
|
|
ava2::OrbitCamera qt_cam;
|
|
qt_cam.SetDistance(450.0f);
|
|
qt_cam.SetPitch(22.0f);
|
|
qt_cam.SetYaw(20.0f);
|
|
qt_cam.SetTargetHeight(95.0f);
|
|
qt_cam.SetTarget(0.0f, pr_h_center, 0.0f);
|
|
qt_cam.ApplyToRenderer(renderer);
|
|
renderer.SetPerspective(50.0f, static_cast<float>(width) / static_cast<float>(height), 1.0f, 8000.0f);
|
|
|
|
auto culled_draws = pr_terrain.BuildCulledDraws(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 8000.0f);
|
|
auto repeatedTerrain = pr_terrain.BuildCulledDraws(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 8000.0f);
|
|
assert(!culled_draws.empty() && culled_draws.size()==repeatedTerrain.size());
|
|
assert(culled_draws.front().geometry==repeatedTerrain.front().geometry);
|
|
assert(!culled_draws.front().Mesh().positions.empty());
|
|
const auto oldTerrainGeometry = culled_draws.front().geometry;
|
|
pr_terrain.SetWorldOrigin(pr_terrain.GetWorldMinX(),pr_terrain.GetWorldMinZ());
|
|
repeatedTerrain = pr_terrain.BuildCulledDraws(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 8000.0f);
|
|
assert(!repeatedTerrain.empty() && repeatedTerrain.front().geometry!=oldTerrainGeometry);
|
|
std::cout << "Quadtree Frustum Culling visible patch draws: " << culled_draws.size() << " / 64" << std::endl;
|
|
assert(!culled_draws.empty() && culled_draws.size() <= 64 && "Culled draws must be non-empty and <= 64");
|
|
|
|
// 3. Test Collision & Wall Sliding in ActorInstance
|
|
std::cout << "Testing ActorInstance collision and wall sliding against ATTR_BLOCK..." << std::endl;
|
|
ava2::ActorInstance col_actor;
|
|
col_actor.SetSpeed(300.0f);
|
|
col_actor.SetPosition(0.0f, pr_terrain.GetHeightAtWorld(0.0f, 0.0f), 0.0f);
|
|
|
|
float startX = col_actor.GetX();
|
|
float startZ = col_actor.GetZ();
|
|
col_actor.MoveInDirection(0.0f, 0.1f, &pr_terrain);
|
|
std::cout << "Actor moved from (" << startX << ", " << startZ << ") to (" << col_actor.GetX() << ", " << col_actor.GetZ() << ")" << std::endl;
|
|
|
|
// Test Attribute Query & Collision Blocking
|
|
int block_gx = -1, block_gy = -1;
|
|
for (int y = 5; y < pr_terrain.GetAttrHeight() - 5; ++y) {
|
|
for (int x = 5; x < pr_terrain.GetAttrWidth() - 5; ++x) {
|
|
if ((pr_terrain.GetAttrAtGrid(x, y) & ava2::TerrainAttr::ATTR_BLOCK) &&
|
|
!(pr_terrain.GetAttrAtGrid(x, y - 1) & ava2::TerrainAttr::ATTR_BLOCK)) {
|
|
block_gx = x;
|
|
block_gy = y;
|
|
break;
|
|
}
|
|
}
|
|
if (block_gx >= 0) break;
|
|
}
|
|
|
|
if (block_gx >= 0) {
|
|
std::cout << "Found ATTR_BLOCK boundary at grid (" << block_gx << ", " << block_gy << ")" << std::endl;
|
|
float b_world_x = pr_terrain.GetWorldMinX() + (static_cast<float>(block_gx) / (pr_terrain.GetAttrWidth() - 1)) * (pr_terrain.GetWorldMaxX() - pr_terrain.GetWorldMinX());
|
|
float b_world_z = pr_terrain.GetWorldMinZ() + (static_cast<float>(block_gy) / (pr_terrain.GetAttrHeight() - 1)) * (pr_terrain.GetWorldMaxZ() - pr_terrain.GetWorldMinZ());
|
|
float walk_z = pr_terrain.GetWorldMinZ() + (static_cast<float>(block_gy - 1) / (pr_terrain.GetAttrHeight() - 1)) * (pr_terrain.GetWorldMaxZ() - pr_terrain.GetWorldMinZ());
|
|
assert(pr_terrain.IsAttrOn(b_world_x, b_world_z, ava2::TerrainAttr::ATTR_BLOCK));
|
|
assert(!pr_terrain.IsAttrOn(b_world_x, walk_z, ava2::TerrainAttr::ATTR_BLOCK));
|
|
|
|
// Place actor at walkable tile, attempting to walk directly north (+Z) into blocked tile
|
|
col_actor.SetPosition(b_world_x, pr_terrain.GetHeightAtWorld(b_world_x, walk_z), walk_z);
|
|
col_actor.MoveInDirection(0.0f, 0.5f, &pr_terrain); // Try to step into blocked cell
|
|
// Actor must NOT enter the blocked cell
|
|
assert(!pr_terrain.IsAttrOn(col_actor.GetX(), col_actor.GetZ(), ava2::TerrainAttr::ATTR_BLOCK) && "Actor must not penetrate blocked cell");
|
|
std::cout << "Actor collision blocking verified: Actor prevented from penetrating ATTR_BLOCK tile at (" << col_actor.GetX() << ", " << col_actor.GetZ() << ")" << std::endl;
|
|
}
|
|
|
|
// 4. Render Quadtree Multi-texture Terrain Scene
|
|
SDL_FillSurfaceRect(surface, nullptr, 0xFF7098B8);
|
|
renderer.Clear(0xFF7098B8, 1.0f);
|
|
renderer.SetFog(true, 0xFFB4C8E0, 0.00010f, 1500.0f, 7500.0f, false);
|
|
|
|
std::vector<ava2::Render3DDraw> quadtree_scene_draws;
|
|
for (auto&& d : culled_draws) {
|
|
quadtree_scene_draws.push_back(std::move(d));
|
|
}
|
|
|
|
ava2::MapObjectManager pr_bldgs;
|
|
std::string gate_path = "ymir work/zone/b/building/b1-034-stonedoor.gr2";
|
|
if (std::filesystem::exists(gate_path)) {
|
|
float gh = pr_terrain.GetHeightAtWorld(0.0f, 800.0f);
|
|
pr_bldgs.AddObject(gate_path, 0.0f, gh, 800.0f, 0.0f, 0.0f, 0.0f, 0.55f);
|
|
}
|
|
for (auto& bd : pr_bldgs.BuildDrawCommands()) {
|
|
quadtree_scene_draws.push_back(std::move(bd));
|
|
}
|
|
|
|
if (model) {
|
|
float char_world[16];
|
|
ava2::MakeTransformMatrix(20.0f + 180.0f, 0.0f, pr_h_center, 0.0f, 0.8f, char_world);
|
|
auto char_draws = model->BuildDrawCommands(-1.0f, char_world);
|
|
for (auto& cd : char_draws) {
|
|
quadtree_scene_draws.push_back(std::move(cd));
|
|
}
|
|
}
|
|
renderer.RenderScene(surface, quadtree_scene_draws);
|
|
|
|
// 5. Overlay 2D HUD / TextTails / Radar on top of quadtree scene
|
|
SDL_Renderer* qt_sw_rnd = SDL_CreateSoftwareRenderer(surface);
|
|
if (qt_sw_rnd) {
|
|
ttm.SetCharacterPosition(1001, 0.0f, pr_h_center, 0.0f);
|
|
ttm.UpdateAllTextTail(0.0f, pr_h_center, 0.0f, &renderer);
|
|
ttm.UpdateShowingTextTail(&renderer);
|
|
ttm.ArrangeTextTail();
|
|
ttm.Render(qt_sw_rnd, &renderer);
|
|
tm.Render(qt_sw_rnd, renderer, &pr_terrain);
|
|
SDL_RenderPresent(qt_sw_rnd);
|
|
SDL_DestroyRenderer(qt_sw_rnd);
|
|
}
|
|
|
|
const char* quadtree_screenshot = "/tmp/test_3d_terrain_quadtree.bmp";
|
|
SDL_SaveBMP(surface, quadtree_screenshot);
|
|
std::cout << "Successfully saved terrain quadtree render to: " << quadtree_screenshot << std::endl;
|
|
|
|
SDL_DestroySurface(surface);
|
|
|
|
// 6. Test Metin2 / MilesLib SoundManager Engine
|
|
std::cout << "Testing SoundManager Audio Engine (2D/3D SFX, BGM streaming, .mss parsing)..." << std::endl;
|
|
auto& snd = ava2::SoundManager::Instance();
|
|
bool snd_init = snd.Initialize();
|
|
assert(snd_init && "SoundManager::Initialize must succeed");
|
|
|
|
snd.SetSoundVolumeGrade(5);
|
|
assert(snd.GetSoundVolume() >= 0.99f);
|
|
snd.SetMusicVolumeGrade(4);
|
|
assert(snd.GetMusicVolume() > 0.0f);
|
|
snd.SetPosition(0.0f, pr_h_center, 0.0f);
|
|
|
|
// Test 2D sound effect playback (UI click)
|
|
snd.PlaySound2D("sound/ui/click.wav");
|
|
|
|
// Test 3D sound effect playback (Warrior Skill / Swing)
|
|
snd.PlaySound3D(50.0f, pr_h_center, 50.0f, "sound/common/swing/w_1h_c_1.wav");
|
|
|
|
// Test BGM music streaming via dr_mp3 decoder
|
|
snd.FadeInMusic("BGM/login_window.mp3", 0.05f);
|
|
snd.Update(0.1f);
|
|
assert(!snd.GetCurrentMusic().empty());
|
|
|
|
// Test Character Sound Script (.mss) parsing
|
|
std::vector<ava2::CharacterSoundEvent> mss_events;
|
|
bool mss_loaded = snd.LoadCharacterSoundScript("sound/pc/warrior/skill/samyeon.mss", mss_events);
|
|
if (!mss_loaded) {
|
|
mss_loaded = snd.LoadCharacterSoundScript(PackMaker() + "/Sound/sound/pc/warrior/skill/samyeon.mss", mss_events);
|
|
}
|
|
assert(mss_loaded && "Samyeon .mss script must be loaded");
|
|
assert(mss_events.size() == 2 && "Samyeon .mss must have exactly 2 sound events");
|
|
std::cout << "Verified Samyeon .mss events: [" << mss_events[0].time << "s -> " << mss_events[0].soundFile
|
|
<< "], [" << mss_events[1].time << "s -> " << mss_events[1].soundFile << "]" << std::endl;
|
|
|
|
snd.Update(0.5f);
|
|
std::cout << "SoundManager verified with " << snd.GetCachedSoundCount() << " cached audio assets." << std::endl;
|
|
|
|
// 7. Test Metin2 EffectLib & GameLib Particles & Flying Engine
|
|
std::cout << "Testing EffectLib & FlyingManager Particle and Missile Engine..." << std::endl;
|
|
auto& effMgr = ava2::EffectManager::Instance();
|
|
auto& flyMgr = ava2::FlyingManager::Instance();
|
|
|
|
// Test .mse loading: Palbang ground spin
|
|
uint32_t palbang_id = 0;
|
|
bool palbang_loaded = effMgr.RegisterEffect("ymir work/pc/warrior/effect/palbang_2_spin.mse", &palbang_id);
|
|
assert(palbang_loaded && "Palbang .mse must load successfully");
|
|
assert(palbang_id != 0 && "Palbang effect ID must be non-zero");
|
|
|
|
// Test .mse loading: Samyeon triple slash
|
|
uint32_t samyeon_id = 0;
|
|
bool samyeon_loaded = effMgr.RegisterEffect("ymir work/pc/warrior/effect/samyeon_d.mse", &samyeon_id);
|
|
assert(samyeon_loaded && "Samyeon .mse must load successfully");
|
|
|
|
// Test .mse loading: Aura of the sword (continuous weapon aura)
|
|
uint32_t geom_id = 0;
|
|
bool geom_loaded = effMgr.RegisterEffect("ymir work/pc/warrior/effect/geom_sword_loop.mse", &geom_id);
|
|
assert(geom_loaded && "Geom sword loop .mse must load successfully");
|
|
|
|
// Test creating instances
|
|
uint32_t palbang_inst = effMgr.CreateEffect(palbang_id, 0.0f, 100.0f, 0.0f);
|
|
assert(palbang_inst != 0 && "Effect instance creation must succeed");
|
|
assert(effMgr.IsAliveEffect(palbang_inst) && "Created effect must be alive");
|
|
|
|
// Test updating instance past StartTime (0.208s)
|
|
effMgr.Update(0.3f);
|
|
assert(effMgr.IsAliveEffect(palbang_inst));
|
|
|
|
// Test draw command generation for billboard particle quads
|
|
float dummyView[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
|
|
float dummyProj[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
|
|
float dummyCam[3] = {0.0f, 100.0f, -200.0f};
|
|
std::vector<ava2::Render3DDraw> effectDraws;
|
|
effMgr.BuildDrawCommands(dummyView, dummyProj, dummyCam, effectDraws);
|
|
assert(!effectDraws.empty() && "EffectManager must produce 3D draw commands for active particles");
|
|
assert(effectDraws[0].blend_mode == 1 && "Palbang spin effect must use Additive blend mode");
|
|
assert(effectDraws[0].lighting == false && "Particles must not have lighting enabled");
|
|
|
|
// Test FlyTrace weapon/projectile ribbon
|
|
ava2::FlyTrace trace;
|
|
trace.Create(0xFFFFAA00, 0.3f, 15.0f, false);
|
|
trace.UpdateNewPosition(0.0f, 100.0f, 0.0f, 0.0f);
|
|
trace.UpdateNewPosition(10.0f, 105.0f, 5.0f, 0.05f);
|
|
trace.UpdateNewPosition(25.0f, 110.0f, 15.0f, 0.10f);
|
|
assert(!trace.IsEmpty() && "FlyTrace must contain positions");
|
|
std::vector<ava2::Render3DDraw> traceDraws;
|
|
trace.BuildDrawCommands(dummyView, dummyProj, 0.12f, traceDraws);
|
|
assert(!traceDraws.empty() && "FlyTrace must generate ribbon quad draw commands");
|
|
assert(traceDraws[0].blend_mode == 1 && "FlyTrace must use Additive blend mode");
|
|
|
|
// Test .msf projectile loading and simulation
|
|
uint32_t geompung_msf_id = 0;
|
|
bool msf_loaded = flyMgr.RegisterFlyingData("ymir work/pc/warrior/effect/geompung.msf", &geompung_msf_id);
|
|
assert(msf_loaded && "Geompung .msf must load successfully");
|
|
|
|
float flyStart[3] = {0.0f, 100.0f, 0.0f};
|
|
float flyTarget[3] = {200.0f, 100.0f, 0.0f};
|
|
bool hitTriggered = false;
|
|
uint32_t flyInst = flyMgr.CreateFlyingInstance(geompung_msf_id, flyStart, flyTarget, [&](const float* hitPos) {
|
|
hitTriggered = true;
|
|
});
|
|
assert(flyInst != 0 && "FlyingInstance creation must succeed");
|
|
|
|
// Simulate flying until hit
|
|
for (int step = 0; step < 20 && !hitTriggered; ++step) {
|
|
flyMgr.Update(0.02f, step * 0.02f);
|
|
}
|
|
assert(hitTriggered && "Flying missile must hit target and trigger explosion callback");
|
|
std::cout << "EffectLib, Particle Billboard, FlyTrace and FlyingManager pipeline passed successfully!" << std::endl;
|
|
|
|
// 8. Test NetworkActorManager (CNetworkActorManager 1:1 Replica)
|
|
std::cout << "Testing NetworkActorManager (CNetworkActorManager 1:1 Replica)..." << std::endl;
|
|
auto& netActorMgr = ava2::NetworkActorManager::Instance();
|
|
netActorMgr.Clear();
|
|
netActorMgr.SetMainActorVID(1001);
|
|
|
|
// Append warrior player actor
|
|
ava2::SNetworkActorData mainActorData;
|
|
mainActorData.m_dwVID = 1001;
|
|
mainActorData.m_stName = "WarriorHero";
|
|
mainActorData.m_bType = 6; // PC
|
|
mainActorData.m_dwRace = 0; // Warrior
|
|
mainActorData.m_dwLevel = 99;
|
|
mainActorData.m_dwGuildID = 1;
|
|
mainActorData.m_stGuildName = "Antigravity";
|
|
mainActorData.m_sAlignment = 12500; // Chivalric
|
|
mainActorData.m_dwWeapon = 299;
|
|
mainActorData.m_dwHair = 1;
|
|
mainActorData.m_lCurX = 0;
|
|
mainActorData.m_lCurY = 0;
|
|
mainActorData.m_lCurZ = static_cast<int32_t>(pr_h_center);
|
|
mainActorData.m_fRot = 45.0f;
|
|
netActorMgr.AppendActor(mainActorData);
|
|
|
|
assert(netActorMgr.GetActorData(1001) != nullptr && "Main actor must exist in NetworkActorManager");
|
|
assert(netActorMgr.GetActorInstance(1001) != nullptr && "Main actor must have valid ActorInstance");
|
|
|
|
// Append surrounding mob (Plechi slime / frog)
|
|
ava2::SNetworkActorData mobData;
|
|
mobData.m_dwVID = 2001;
|
|
mobData.m_stName = "WildDog";
|
|
mobData.m_bType = 0; // Mob
|
|
mobData.m_dwRace = 102; // Plechi frog
|
|
mobData.m_dwLevel = 5;
|
|
mobData.m_lCurX = 150;
|
|
mobData.m_lCurY = 150;
|
|
mobData.m_lCurZ = static_cast<int32_t>(pr_h_center);
|
|
netActorMgr.AppendActor(mobData);
|
|
|
|
assert(netActorMgr.GetActorDict().size() == 2 && "Actor dict must contain 2 actors");
|
|
|
|
// Test MoveActor interpolation
|
|
ava2::SNetworkMoveActorData mv;
|
|
mv.m_dwVID = 2001;
|
|
mv.m_dwFunc = 1; // Move
|
|
mv.m_lPosX = 100;
|
|
mv.m_lPosY = 100;
|
|
mv.m_fRot = 180.0f;
|
|
netActorMgr.MoveActor(mv);
|
|
assert(netActorMgr.GetActorData(2001)->m_isMoving && "Mob must enter moving state");
|
|
|
|
// Update 0.1s
|
|
netActorMgr.Update(0.1f, &pr_terrain);
|
|
assert(netActorMgr.GetActorData(2001)->m_lCurX < 150 && "Mob must advance towards target");
|
|
|
|
// Test SyncActor
|
|
netActorMgr.SyncActor(2001, 80, 80);
|
|
assert(netActorMgr.GetActorData(2001)->m_lCurX == 80 && "SyncActor must set exact coordinate");
|
|
assert(!netActorMgr.GetActorData(2001)->m_isMoving && "SyncActor must finish moving");
|
|
|
|
// Test UpdateActor
|
|
ava2::SNetworkUpdateActorData upd;
|
|
upd.m_dwVID = 1001;
|
|
upd.m_dwWeapon = 299;
|
|
upd.m_sAlignment = -12500; // Cruel
|
|
netActorMgr.UpdateActor(upd);
|
|
assert(netActorMgr.GetActorData(1001)->m_sAlignment == -12500 && "Actor alignment must be updated");
|
|
|
|
std::cout << "NetworkActorManager verified with 2 active network actors." << std::endl;
|
|
|
|
// 9. Render Skill Particle Effects Showcase Scene
|
|
std::cout << "Rendering Skill Particle & Missile Effects Showcase Scene..." << std::endl;
|
|
SDL_Surface* eff_surf = SDL_CreateSurface(1024, 768, SDL_PIXELFORMAT_ARGB8888);
|
|
if (eff_surf) {
|
|
SDL_FillSurfaceRect(eff_surf, nullptr, 0xFFB4C8E0);
|
|
renderer.SetViewport(0, 0, 1024, 768);
|
|
renderer.Clear(0xFFB4C8E0, 1.0f);
|
|
renderer.SetFog(true, 0xFFB4C8E0, 0.00010f, 1800.0f, 7500.0f, false);
|
|
renderer.SetCameraLookAt(70.0f, pr_h_center + 140.0f, -240.0f, 30.0f, pr_h_center + 45.0f, 30.0f, 0.0f, 1.0f, 0.0f);
|
|
renderer.SetPerspective(48.0f, 1024.0f / 768.0f, 1.0f, 5000.0f);
|
|
|
|
std::vector<ava2::Render3DDraw> scene_draws;
|
|
|
|
// Terrain
|
|
auto terr_draws = pr_terrain.BuildCulledDraws(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 6000.0f);
|
|
for (auto& td : terr_draws) scene_draws.push_back(std::move(td));
|
|
|
|
// Buildings
|
|
for (auto& bd : pr_bldgs.BuildDrawCommands()) scene_draws.push_back(std::move(bd));
|
|
|
|
// Warrior character with weapon
|
|
if (model) {
|
|
float char_world[16];
|
|
ava2::MakeTransformMatrix(45.0f + 180.0f, 0.0f, pr_h_center, 0.0f, 0.8f, char_world);
|
|
auto char_draws = model->BuildDrawCommands(-1.0f, char_world);
|
|
for (auto& cd : char_draws) scene_draws.push_back(std::move(cd));
|
|
}
|
|
|
|
// Active particles: Palbang ground spin, Aura flame, and Hit Sparks
|
|
effMgr.DeleteAllInstances();
|
|
uint32_t eff_spin = effMgr.CreateEffect("ymir work/pc/warrior/effect/palbang_2_spin.mse", 0.0f, pr_h_center + 5.0f, 0.0f);
|
|
uint32_t eff_aura = effMgr.CreateEffect("ymir work/pc/warrior/effect/geom_sword_loop.mse", 15.0f, pr_h_center + 60.0f, 10.0f);
|
|
uint32_t eff_spark = effMgr.CreateEffect("ymir work/pc/warrior/effect/gihyeol_spark.mse", 90.0f, pr_h_center + 45.0f, 50.0f);
|
|
effMgr.Update(0.35f);
|
|
|
|
float effCamPos[3] = {70.0f, pr_h_center + 140.0f, -240.0f};
|
|
effMgr.BuildDrawCommands(renderer.GetViewMatrix(), renderer.GetProjMatrix(), effCamPos, scene_draws);
|
|
|
|
// Sword blade ribbon trace
|
|
ava2::FlyTrace blade_trace;
|
|
blade_trace.Create(0xFFFFAA00, 0.4f, 18.0f, false);
|
|
blade_trace.UpdateNewPosition(-20.0f, pr_h_center + 50.0f, -10.0f, 0.0f);
|
|
blade_trace.UpdateNewPosition(0.0f, pr_h_center + 65.0f, 10.0f, 0.05f);
|
|
blade_trace.UpdateNewPosition(25.0f, pr_h_center + 60.0f, 25.0f, 0.10f);
|
|
blade_trace.UpdateNewPosition(50.0f, pr_h_center + 55.0f, 35.0f, 0.15f);
|
|
blade_trace.BuildDrawCommands(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 0.18f, scene_draws);
|
|
|
|
// Flying projectile ribbon trace
|
|
ava2::FlyTrace proj_trace;
|
|
proj_trace.Create(0xFF44CCFF, 0.5f, 12.0f, false);
|
|
proj_trace.UpdateNewPosition(15.0f, pr_h_center + 60.0f, 10.0f, 0.0f);
|
|
proj_trace.UpdateNewPosition(40.0f, pr_h_center + 55.0f, 25.0f, 0.06f);
|
|
proj_trace.UpdateNewPosition(65.0f, pr_h_center + 50.0f, 38.0f, 0.12f);
|
|
proj_trace.UpdateNewPosition(85.0f, pr_h_center + 46.0f, 48.0f, 0.18f);
|
|
proj_trace.BuildDrawCommands(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 0.20f, scene_draws);
|
|
|
|
renderer.RenderScene(eff_surf, scene_draws);
|
|
|
|
// Overlay TextTail and floating text
|
|
SDL_Renderer* eff_rnd = SDL_CreateSoftwareRenderer(eff_surf);
|
|
if (eff_rnd) {
|
|
ttm.SetCharacterPosition(1001, 0.0f, pr_h_center, 0.0f);
|
|
ttm.UpdateAllTextTail(0.0f, pr_h_center, 0.0f, &renderer);
|
|
ttm.UpdateShowingTextTail(&renderer);
|
|
ttm.ArrangeTextTail();
|
|
ttm.Render(eff_rnd, &renderer);
|
|
SDL_RenderPresent(eff_rnd);
|
|
SDL_DestroyRenderer(eff_rnd);
|
|
}
|
|
|
|
const char* eff_screenshot = "/tmp/test_3d_skill_effects.bmp";
|
|
SDL_SaveBMP(eff_surf, eff_screenshot);
|
|
std::cout << "Successfully saved skill effects render to: " << eff_screenshot << std::endl;
|
|
SDL_DestroySurface(eff_surf);
|
|
}
|
|
|
|
// 10. Render Stage 5: PhaseGame Network Actor Synchronization Showcase Scene
|
|
std::cout << "Rendering Stage 5 PhaseGame Network Actors & Synchronized World Scene..." << std::endl;
|
|
SDL_Surface* net_surf = SDL_CreateSurface(1024, 768, SDL_PIXELFORMAT_ARGB8888);
|
|
if (net_surf) {
|
|
SDL_FillSurfaceRect(net_surf, nullptr, 0xFFB4C8E0);
|
|
renderer.SetViewport(0, 0, 1024, 768);
|
|
renderer.Clear(0xFFB4C8E0, 1.0f);
|
|
renderer.SetFog(true, 0xFFB4C8E0, 0.00010f, 1800.0f, 7500.0f, false);
|
|
renderer.SetCameraLookAt(50.0f, pr_h_center + 130.0f, -230.0f, 10.0f, pr_h_center + 45.0f, 25.0f, 0.0f, 1.0f, 0.0f);
|
|
renderer.SetPerspective(48.0f, 1024.0f / 768.0f, 1.0f, 5000.0f);
|
|
|
|
std::vector<ava2::Render3DDraw> scene_draws;
|
|
|
|
// Terrain
|
|
auto terr_draws = pr_terrain.BuildCulledDraws(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 6000.0f);
|
|
for (auto& td : terr_draws) scene_draws.push_back(std::move(td));
|
|
|
|
// Buildings
|
|
for (auto& bd : pr_bldgs.BuildDrawCommands()) scene_draws.push_back(std::move(bd));
|
|
|
|
// Add 3rd Network Actor: Sura Mage (VID 1002)
|
|
ava2::SNetworkActorData suraData;
|
|
suraData.m_dwVID = 1002;
|
|
suraData.m_stName = "SuraMage";
|
|
suraData.m_bType = 6; // PC
|
|
suraData.m_dwRace = 2; // Sura
|
|
suraData.m_dwLevel = 75;
|
|
suraData.m_dwGuildID = 2;
|
|
suraData.m_stGuildName = "ShinsooEmpire";
|
|
suraData.m_sAlignment = 8000; // Noble
|
|
suraData.m_lCurX = -75;
|
|
suraData.m_lCurY = 35;
|
|
suraData.m_lCurZ = static_cast<int32_t>(pr_h_center);
|
|
suraData.m_fRot = 120.0f;
|
|
netActorMgr.AppendActor(suraData);
|
|
|
|
// Network ActorManager 3D draws for all actors (Main Warrior, WildDog, SuraMage)
|
|
auto net_draws = netActorMgr.BuildDrawCommands(0.2f);
|
|
for (auto& nd : net_draws) scene_draws.push_back(std::move(nd));
|
|
|
|
// Warrior character fallback if model was directly loaded
|
|
if (model) {
|
|
float char_world[16];
|
|
ava2::MakeTransformMatrix(45.0f + 180.0f, 0.0f, pr_h_center, 0.0f, 0.8f, char_world);
|
|
auto char_draws = model->BuildDrawCommands(-1.0f, char_world);
|
|
for (auto& cd : char_draws) scene_draws.push_back(std::move(cd));
|
|
}
|
|
|
|
// Sword blade slash ribbon from Warrior attack
|
|
ava2::FlyTrace blade_trace;
|
|
blade_trace.Create(0xFFFFAA00, 0.4f, 18.0f, false);
|
|
blade_trace.UpdateNewPosition(-10.0f, pr_h_center + 45.0f, -5.0f, 0.0f);
|
|
blade_trace.UpdateNewPosition(15.0f, pr_h_center + 60.0f, 15.0f, 0.06f);
|
|
blade_trace.UpdateNewPosition(45.0f, pr_h_center + 55.0f, 35.0f, 0.12f);
|
|
blade_trace.BuildDrawCommands(renderer.GetViewMatrix(), renderer.GetProjMatrix(), 0.15f, scene_draws);
|
|
|
|
// Hit spark particle effect at mob location
|
|
uint32_t net_spark = effMgr.CreateEffect("ymir work/pc/warrior/effect/gihyeol_spark.mse", 80.0f, pr_h_center + 40.0f, 80.0f);
|
|
(void)net_spark;
|
|
effMgr.Update(0.2f);
|
|
float netCamPos[3] = {50.0f, pr_h_center + 130.0f, -230.0f};
|
|
effMgr.BuildDrawCommands(renderer.GetViewMatrix(), renderer.GetProjMatrix(), netCamPos, scene_draws);
|
|
|
|
renderer.RenderScene(net_surf, scene_draws);
|
|
|
|
// 2D Overlay: TextTail & Floating Damage Numbers
|
|
SDL_Renderer* net_rnd = SDL_CreateSoftwareRenderer(net_surf);
|
|
if (net_rnd) {
|
|
ttm.RegisterChatTail(1001, "[PhaseGame] Protocol 1:1 Synced!");
|
|
ttm.RegisterItemTextTail(7777, "Full Moon Sword +9", 35.0f, pr_h_center, -45.0f, 180, "Antigravity", true);
|
|
ttm.RegisterItemTextTail(7778, "Blessing Scroll", 55.0f, pr_h_center, -30.0f, 0, "", false, 0xFFFFCC33);
|
|
|
|
ttm.ShowAllTextTail();
|
|
ttm.SetCharacterPosition(1001, 0.0f, pr_h_center, 0.0f);
|
|
ttm.SetCharacterPosition(1002, -75.0f, pr_h_center, 35.0f);
|
|
ttm.SetCharacterPosition(2001, 80.0f, pr_h_center, 80.0f);
|
|
ttm.UpdateAllTextTail(0.0f, pr_h_center, 0.0f, &renderer);
|
|
ttm.UpdateShowingTextTail(&renderer);
|
|
ttm.ArrangeTextTail();
|
|
ttm.SelectItemName(7777);
|
|
ttm.Render(net_rnd, &renderer);
|
|
|
|
// Floating combat damage numbers
|
|
ftm.Clear();
|
|
ftm.AddDamage(2450, 80.0f, pr_h_center + 70.0f, 80.0f, true, true); // Critical hit on mob
|
|
ftm.AddDamage(320, -75.0f, pr_h_center + 85.0f, 35.0f, false, false); // Normal damage on sura
|
|
ftm.Render(net_rnd, renderer);
|
|
|
|
SDL_RenderPresent(net_rnd);
|
|
SDL_DestroyRenderer(net_rnd);
|
|
}
|
|
|
|
const char* net_screenshot = "/tmp/test_3d_network_phasegame.bmp";
|
|
SDL_SaveBMP(net_surf, net_screenshot);
|
|
std::cout << "Successfully saved PhaseGame network scene render to: " << net_screenshot << std::endl;
|
|
SDL_DestroySurface(net_surf);
|
|
}
|
|
|
|
std::cout << "AVA2 3D GR2 Model, Water, Fog, PRTerrain Quadtree, Attr Blocking, Combat, Picking, Targeting, Audio & Effects Pipeline passed successfully!" << std::endl;
|
|
return 0;
|
|
}
|
|
|