- 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>
1354 lines
65 KiB
C++
1354 lines
65 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/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 "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;
|
|
}
|
|
|
|
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& m : info.meshes) {
|
|
total_verts += m.vertices.size();
|
|
total_indices += m.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;
|
|
|
|
// ── 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");
|
|
|
|
// 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");
|
|
|
|
// 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() <= 1800.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;
|
|
}
|
|
|
|
// ── 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);
|
|
|
|
// 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);
|
|
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;
|
|
}
|
|
|