402 lines
14 KiB
C++
402 lines
14 KiB
C++
#include "precompile.h"
|
|
|
|
#include "mt/Map.h"
|
|
#include "mt/MapCollider.h"
|
|
#include "mt/SafeArea.h"
|
|
#include "mt/MetaMgr.h"
|
|
|
|
IMPL_TABLE(mt::Map)
|
|
|
|
static void LoadWorldObjects(const std::string& world_object_file,
|
|
std::vector<std::shared_ptr<mt::WorldObject>>& world_objects,
|
|
std::map<int, std::vector<std::shared_ptr<mt::WorldObject>>>& group_world_objects)
|
|
{
|
|
auto parse_func =
|
|
[] (std::shared_ptr<a8::XObject> node, std::shared_ptr<mt::WorldObject> obj)
|
|
{
|
|
obj->object_id = node->At("id")->AsXValue();
|
|
auto bounds = node->At("bounds");
|
|
auto center = bounds->At("center");
|
|
auto size = bounds->At("size");
|
|
obj->pos.x = center->At("x")->AsXValue().GetDouble();
|
|
obj->pos.y = center->At("y")->AsXValue().GetDouble();
|
|
obj->pos.z = center->At("z")->AsXValue().GetDouble();
|
|
|
|
obj->size.x = size->At("x")->AsXValue().GetDouble();
|
|
obj->size.y = size->At("y")->AsXValue().GetDouble();
|
|
obj->size.z = size->At("z")->AsXValue().GetDouble();
|
|
};
|
|
|
|
auto parse_human_func =
|
|
[] (std::shared_ptr<a8::XObject> node, std::shared_ptr<mt::WorldObject> obj)
|
|
{
|
|
auto pos = node->At("pos");
|
|
obj->pos.x = pos->At("x")->AsXValue().GetDouble();
|
|
obj->pos.y = pos->At("y")->AsXValue().GetDouble();
|
|
obj->pos.z = pos->At("z")->AsXValue().GetDouble();
|
|
};
|
|
|
|
a8::XObject root;
|
|
if (!world_object_file.empty() &&
|
|
root.ReadFromFile(mt::MetaMgr::Instance()->GetResDir() + world_object_file)) {
|
|
{
|
|
auto thing = root.At("thing");
|
|
for (int i = 0; i < thing->Size(); ++i) {
|
|
auto obj = std::make_shared<mt::WorldObject>();
|
|
obj->object_type = WorldObjectType_e::kBoxType;
|
|
parse_func(thing->At(i), obj);
|
|
world_objects.push_back(obj);
|
|
}
|
|
}
|
|
{
|
|
auto thing = root.At("loot");
|
|
for (int i = 0; i < thing->Size(); ++i) {
|
|
auto obj = std::make_shared<mt::WorldObject>();
|
|
obj->object_type = WorldObjectType_e::kLootType;
|
|
parse_func(thing->At(i), obj);
|
|
world_objects.push_back(obj);
|
|
}
|
|
}
|
|
{
|
|
auto thing = root.At("car");
|
|
for (int i = 0; i < thing->Size(); ++i) {
|
|
auto obj = std::make_shared<mt::WorldObject>();
|
|
obj->object_type = WorldObjectType_e::kCarType;
|
|
parse_func(thing->At(i), obj);
|
|
world_objects.push_back(obj);
|
|
}
|
|
}
|
|
{
|
|
auto thing = root.At("monster");
|
|
for (int i = 0; i < thing->Size(); ++i) {
|
|
auto obj = std::make_shared<mt::WorldObject>();
|
|
obj->object_type = WorldObjectType_e::kMonsterType;
|
|
parse_func(thing->At(i), obj);
|
|
world_objects.push_back(obj);
|
|
}
|
|
}
|
|
{
|
|
auto thing = root.At("human");
|
|
for (int i = 0; i < thing->Size(); ++i) {
|
|
auto obj = std::make_shared<mt::WorldObject>();
|
|
obj->object_type = WorldObjectType_e::kBornPointType;
|
|
parse_human_func(thing->At(i), obj);
|
|
world_objects.push_back(obj);
|
|
}
|
|
}
|
|
{
|
|
auto group = root.At("group");
|
|
for (int i = 0; i < group->Size(); ++i) {
|
|
auto group_obj = group->At(i);
|
|
std::vector<std::string> keys;
|
|
group_obj->GetKeys(keys);
|
|
for (auto key : keys) {
|
|
int ikey = a8::XValue(key);
|
|
if (group_world_objects.find(ikey) != group_world_objects.end()) {
|
|
abort();
|
|
}
|
|
std::vector<std::shared_ptr<mt::WorldObject>> objects;
|
|
auto items = group_obj->At(key);
|
|
for (int iii = 0; iii < items->Size(); ++iii) {
|
|
auto item_obj = items->At(iii);
|
|
auto obj = std::make_shared<mt::WorldObject>();
|
|
{
|
|
obj->pos.x = item_obj->At("x")->AsXValue().GetDouble();
|
|
obj->pos.y = item_obj->At("y")->AsXValue().GetDouble();
|
|
obj->pos.z = item_obj->At("z")->AsXValue().GetDouble();
|
|
}
|
|
objects.push_back(obj);
|
|
}
|
|
group_world_objects[ikey] = objects;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace mt
|
|
{
|
|
|
|
void Map::Init1()
|
|
{
|
|
scale_ = 0.1f;
|
|
rand_space = 0;
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(template_list(), strings, '|');
|
|
for (auto& str : strings) {
|
|
std::vector<std::string> strings2;
|
|
a8::Split(str, strings2, ':');
|
|
assert(strings2.size() == 2);
|
|
rand_space += a8::XValue(strings2[1]).GetInt();
|
|
template_list_.push_back(std::make_tuple(
|
|
strings2[0],
|
|
rand_space
|
|
));
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(airdrops(), strings, '|');
|
|
for (auto& str : strings) {
|
|
airdrops_.push_back(a8::XValue(str).GetInt());
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(safearea(), strings, '|');
|
|
for (auto& str : strings) {
|
|
safearea_list.push_back(a8::XValue(str).GetInt());
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(airraids(), strings, '|');
|
|
for (auto& str : strings) {
|
|
airraids_.push_back(a8::XValue(str).GetInt());
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(car_num_limit(), strings, '|');
|
|
for (auto& str : strings) {
|
|
std::vector<std::string> strings2;
|
|
a8::Split(str, strings2, ':');
|
|
car_num_limit_[a8::XValue(strings2[0]).GetInt()] = a8::XValue(strings2[1]).GetInt();
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(game_start_buff_list(), strings, ':');
|
|
for (auto& str : strings) {
|
|
buff_list.push_back(a8::XValue(str).GetInt());
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
a8::Split(ground_sampling_pos(), strings, ':');
|
|
if (strings.size() != 3) {
|
|
abort();
|
|
}
|
|
sampling_pos_ = glm::vec3((float)a8::XValue(strings[0]).GetDouble(),
|
|
(float)a8::XValue(strings[1]).GetDouble(),
|
|
(float)a8::XValue(strings[2]).GetDouble());
|
|
}
|
|
if (!IsPveMap()) {
|
|
std::vector<std::string> strings;
|
|
a8::Split(refresh_robot(), strings, '|');
|
|
if (strings.size() != 2) {
|
|
A8_ABORT();
|
|
}
|
|
{
|
|
std::vector<std::string> strings2;
|
|
a8::Split(strings[0], strings2, '-');
|
|
if (strings2.size() != 2) {
|
|
A8_ABORT();
|
|
}
|
|
refresh_robot_min_num = a8::XValue(strings2[0]);
|
|
refresh_robot_max_num = a8::XValue(strings2[1]);
|
|
}
|
|
{
|
|
std::vector<std::string> strings2;
|
|
a8::Split(strings[1], strings2, '-');
|
|
if (strings2.size() != 2) {
|
|
A8_ABORT();
|
|
}
|
|
refresh_robot_min_time = a8::XValue(strings2[0]);
|
|
refresh_robot_max_time = a8::XValue(strings2[1]);
|
|
}
|
|
if (refresh_robot_min_num >= refresh_robot_max_num) {
|
|
A8_ABORT();
|
|
}
|
|
if (refresh_robot_min_time >= refresh_robot_max_time) {
|
|
A8_ABORT();
|
|
}
|
|
if (refresh_robot_min_num <= 0 || refresh_robot_max_num <= 0 ||
|
|
refresh_robot_min_time <= 0 || refresh_robot_max_time <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
first_safearea_center_ = glm::vec3(map_width() / 2.0f,
|
|
0.0f,
|
|
map_height() / 2.0f);
|
|
if (!first_safearea_center().empty()) {
|
|
std::vector<std::string> strings;
|
|
a8::Split(first_safearea_center(), strings, ':');
|
|
if (strings.size() != 2) {
|
|
A8_ABORT();
|
|
}
|
|
first_safearea_center_ = glm::vec3(a8::XValue(strings[0]).GetDouble(),
|
|
0.0f,
|
|
a8::XValue(strings[1]).GetDouble());
|
|
}
|
|
if (is_open() && !IsPveMap() && !is_moba() && player() < 10) {
|
|
A8_ABORT();
|
|
}
|
|
collider_info = MapCollider::GetByName(map_collider());
|
|
LoadWorldObjects(world_object_file(),
|
|
_world_objects,
|
|
_group_world_objects);
|
|
PostProcess();
|
|
}
|
|
|
|
void Map::Init2()
|
|
{
|
|
{
|
|
if (is_open() && !IsPveMap() && !is_moba() && safearea_list.empty()) {
|
|
A8_ABORT();
|
|
}
|
|
for (const int area_type : safearea_list) {
|
|
if (!mt::SafeArea::GetByType(area_type)) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string Map::RandTemplate() const
|
|
{
|
|
if (rand_space <= 0) {
|
|
return "";
|
|
}
|
|
int rnd = rand() % rand_space;
|
|
for (auto& tpl : template_list_) {
|
|
if (rnd <= std::get<1>(tpl)) {
|
|
return std::get<0>(tpl);
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
int Map::GetCarLimit(int car_id) const
|
|
{
|
|
auto itr = car_num_limit_.find(car_id);
|
|
return itr != car_num_limit_.end() ? itr->second : 666;
|
|
}
|
|
|
|
glm::vec3 Map::GetCenter() const
|
|
{
|
|
glm::vec3 center(map_width() / 2, 0.0f, map_height() / 2);
|
|
return center;
|
|
}
|
|
|
|
int Map::RandSafeArea() const
|
|
{
|
|
if (safearea_list.empty()) {
|
|
A8_ABORT();
|
|
}
|
|
return safearea_list[rand() % safearea_list.size()];
|
|
}
|
|
|
|
bool Map::IsPveMap() const
|
|
{
|
|
return map_id() >= 1002 && map_id() <= 1003;
|
|
}
|
|
|
|
bool Map::IsOpen() const
|
|
{
|
|
return is_open();
|
|
}
|
|
|
|
glm::vec3 Map::GroundSamplingPos() const
|
|
{
|
|
return sampling_pos_;
|
|
}
|
|
|
|
void Map::PostProcess()
|
|
{
|
|
if (!is_moba()) {
|
|
return;
|
|
}
|
|
std::vector<std::shared_ptr<WorldObject>> path_objects;
|
|
std::map<int, std::vector<std::shared_ptr<WorldObject>>> group_path_objects;
|
|
std::string file_name = world_object_file();
|
|
a8::ReplaceString(file_name, ".json", ".path.json");
|
|
LoadWorldObjects(file_name,
|
|
path_objects,
|
|
group_path_objects);
|
|
|
|
std::vector<int> del_ids;
|
|
std::vector<std::shared_ptr<WorldObject>> born_points;
|
|
std::vector<std::vector<std::shared_ptr<WorldObject>>> roads_points;
|
|
roads_points.push_back(std::vector<std::shared_ptr<WorldObject>>());
|
|
roads_points.push_back(std::vector<std::shared_ptr<WorldObject>>());
|
|
roads_points.push_back(std::vector<std::shared_ptr<WorldObject>>());
|
|
{
|
|
int idx = 0;
|
|
for (auto& obj : path_objects) {
|
|
if (obj->object_type == WorldObjectType_e::kBoxType) {
|
|
switch (obj->object_id) {
|
|
case 80012:
|
|
{
|
|
born_points.push_back(obj);
|
|
del_ids.push_back(idx);
|
|
}
|
|
break;
|
|
case 66001:
|
|
{
|
|
roads_points.at(0).push_back(obj);
|
|
del_ids.push_back(idx);
|
|
}
|
|
break;
|
|
case 66002:
|
|
{
|
|
roads_points.at(1).push_back(obj);
|
|
del_ids.push_back(idx);
|
|
}
|
|
break;
|
|
case 51216:
|
|
{
|
|
roads_points.at(2).push_back(obj);
|
|
del_ids.push_back(idx);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++idx;
|
|
}
|
|
}
|
|
{
|
|
if (born_points.size() != 2) {
|
|
abort();
|
|
}
|
|
std::sort(born_points.begin(), born_points.end(),
|
|
[] (std::shared_ptr<WorldObject> a, std::shared_ptr<WorldObject> b) {
|
|
return a->pos.x < b->pos.x;
|
|
});
|
|
for (auto obj : born_points) {
|
|
moba_born_points.push_back(std::make_tuple(obj, 0));
|
|
}
|
|
for (size_t i = 0; i < 3; ++i) {
|
|
moba_path_points.push_back(std::vector<std::tuple<std::shared_ptr<WorldObject>, int>>());
|
|
auto& points = moba_path_points.at(i);
|
|
for (auto obj : roads_points.at(i)) {
|
|
points.push_back(std::make_tuple(obj, 100));
|
|
}
|
|
std::sort(points.begin(), points.end(),
|
|
[] (const std::tuple<std::shared_ptr<WorldObject>, int>& a,
|
|
const std::tuple<std::shared_ptr<WorldObject>, int>& b) {
|
|
return std::get<0>(a)->pos.x < std::get<0>(b)->pos.x;
|
|
});
|
|
if (points.size() < 3) {
|
|
abort();
|
|
}
|
|
}
|
|
}
|
|
{
|
|
std::sort(del_ids.begin(), del_ids.end(),
|
|
[] (int a, int b) {
|
|
return a > b;
|
|
});
|
|
for (auto idx : del_ids) {
|
|
path_objects.erase(path_objects.begin() + idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|