1553 lines
60 KiB
C++
1553 lines
60 KiB
C++
#include "precompile.h"
|
|
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <regex.h>
|
|
|
|
#include <regex>
|
|
|
|
#include <a8/stringlist.h>
|
|
#include <a8/csvreader.h>
|
|
#include <a8/mutable_xobject.h>
|
|
|
|
#include "f8/utils.h"
|
|
|
|
#include "metamgr.h"
|
|
#include "app.h"
|
|
#include "jsondatamgr.h"
|
|
#include "mapmgr.h"
|
|
#include "mapinstance.h"
|
|
|
|
#define METAMGR_READ(field_name, def_val) MetaMgr::Instance()->field_name = \
|
|
a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, #def_val));
|
|
|
|
#define METAMGR_READ_STR(field_name, def_val) MetaMgr::Instance()->field_name = \
|
|
a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, def_val)).GetString();
|
|
|
|
template <typename T>
|
|
static bool LoadMetaFile(const std::string& res_path, const std::string& name, std::list<T>& meta_list)
|
|
{
|
|
f8::ReadCsvMetaFile(res_path + name + ".csv", meta_list);
|
|
return true;
|
|
}
|
|
|
|
static void ParseElemets(const std::string& textid,
|
|
const std::string& text,
|
|
std::vector<std::tuple<int, std::string>>& elements)
|
|
{
|
|
auto parsevar_cb =
|
|
[] (const std::string& var_name, std::vector<std::tuple<int, std::string>>& elements)
|
|
{
|
|
if (var_name == "${master.name}") {
|
|
elements.push_back(std::make_tuple(kFieldIdxMasterName, ""));
|
|
} else if (var_name == "${killer.name}") {
|
|
elements.push_back(std::make_tuple(kFieldIdxKillerName, ""));
|
|
} else if (var_name == "${dead.name}") {
|
|
elements.push_back(std::make_tuple(kFieldIdxDeadName, ""));
|
|
} else if (var_name == "${weapon.name}") {
|
|
elements.push_back(std::make_tuple(kFieldIdxWeaponName, ""));
|
|
} else if (var_name == "${weapon.text_icon}") {
|
|
elements.push_back(std::make_tuple(kFieldIdxWeaponTextIcon, ""));
|
|
} else if (var_name.find("${image.id:") == 0) {
|
|
std::vector<std::string> strings;
|
|
a8::Split(var_name, strings, ':');
|
|
std::string id = strings[1].substr(0, strings[1].length() - 1);
|
|
elements.push_back(std::make_tuple(kImageElement, id));
|
|
} else {
|
|
A8_ABORT();
|
|
}
|
|
};
|
|
|
|
std::regex re(R"(\$\{.*?\})", std::regex_constants::ECMAScript);
|
|
|
|
const char* pcurr = text.c_str();
|
|
const char* pend = text.c_str() + text.length();
|
|
while (pcurr < pend) {
|
|
#if 1
|
|
int pos = 0;
|
|
int length = 0;
|
|
bool match_ok = false;
|
|
std::string m_str;
|
|
{
|
|
const char* tmp_curr = pcurr;
|
|
while (*tmp_curr) {
|
|
if (tmp_curr[0] == '$' && tmp_curr[1] == '{') {
|
|
int i = 2;
|
|
while (tmp_curr[i] != '}') {
|
|
if (tmp_curr[i] == '\0') {
|
|
break;
|
|
}
|
|
++i;
|
|
}
|
|
if (tmp_curr[i] == '}') {
|
|
pos = tmp_curr - pcurr;
|
|
length = i + 1;
|
|
m_str = std::string(tmp_curr, length);
|
|
match_ok = true;
|
|
break;
|
|
} else {
|
|
++tmp_curr;
|
|
}
|
|
} else {
|
|
++tmp_curr;
|
|
}
|
|
}
|
|
}
|
|
if (match_ok) {
|
|
if (pos > 0) {
|
|
auto& e = a8::FastAppend(elements);
|
|
e = std::make_tuple(kTextElement, std::string(pcurr, pos));
|
|
}
|
|
parsevar_cb(m_str, elements);
|
|
pcurr += pos + length;
|
|
} else {
|
|
auto& e = a8::FastAppend(elements);
|
|
e = std::make_tuple(kTextElement, std::string(pcurr, pend - pcurr));
|
|
pcurr = pend;
|
|
}
|
|
#else
|
|
std::cmatch m;
|
|
if (std::regex_search(pcurr, m, re)) {
|
|
if (m.position() > 0) {
|
|
auto& e = a8::FastAppend(elements);
|
|
e = std::make_tuple(kTextElement, std::string(pcurr, m.position()));
|
|
}
|
|
|
|
parsevar_cb(m.str(), elements);
|
|
pcurr += m.position() + m.length();
|
|
} else {
|
|
auto& e = a8::FastAppend(elements);
|
|
e = std::make_tuple(kTextElement, std::string(pcurr, pend - pcurr));
|
|
pcurr = pend;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
{
|
|
a8::MutableXObject* obj = a8::MutableXObject::NewObject();
|
|
a8::MutableXObject* arr = a8::MutableXObject::NewArray();
|
|
for (auto& e : elements) {
|
|
a8::MutableXObject* obj_el = a8::MutableXObject::NewObject();
|
|
obj_el->SetVal("type", std::get<0>(e));
|
|
obj_el->SetVal("val", std::get<1>(e));
|
|
arr->Push(*obj_el);
|
|
}
|
|
obj->SetVal("text", text);
|
|
obj->SetVal("elemets", *arr);
|
|
#if 0
|
|
a8::UdpLog::Instance()->Info
|
|
("load textid:%s %s",
|
|
{
|
|
textid,
|
|
obj->ToJsonStr()
|
|
}
|
|
);
|
|
#endif
|
|
delete obj;
|
|
}
|
|
}
|
|
|
|
class MetaDataLoader
|
|
{
|
|
public:
|
|
std::list<metatable::Parameter> parameter_meta_list;
|
|
std::list<MetaData::Parameter> parameter_list;
|
|
std::list<metatable::Map> map_meta_list;
|
|
std::list<MetaData::Map> map_list;
|
|
std::list<metatable::SafeArea> safearea_meta_list;
|
|
std::list<MetaData::SafeArea> safearea_list;
|
|
std::list<metatable::SafeAreaPos> safearea_pos_meta_list;
|
|
std::list<MetaData::SafeAreaPos> safearea_pos_list;
|
|
std::list<metatable::Item> item_meta_list;
|
|
std::list<MetaData::Item> item_list;
|
|
std::list<metatable::Equip> equip_meta_list;
|
|
std::list<MetaData::Equip> equip_list;
|
|
std::list<metatable::Player> player_meta_list;
|
|
std::list<MetaData::Player> player_list;
|
|
std::list<metatable::MapThing> mapthing_meta_list;
|
|
std::list<MetaData::MapThing> mapthing_list;
|
|
std::list<metatable::BuildingJson> building_meta_list;
|
|
std::list<MetaData::Building> building_list;
|
|
std::list<metatable::Drop> drop_meta_list;
|
|
std::list<MetaData::Drop> drop_list;
|
|
std::list<metatable::AirDrop> airdrop_meta_list;
|
|
std::list<MetaData::AirDrop> airdrop_list;
|
|
std::list<metatable::AirRaid> airraid_meta_list;
|
|
std::list<MetaData::AirRaid> airraid_list;
|
|
std::list<metatable::AirLine> airline_meta_list;
|
|
std::list<MetaData::AirLine> airline_list;
|
|
std::list<metatable::Skill> skill_meta_list;
|
|
std::list<MetaData::Skill> skill_list;
|
|
std::list<metatable::SkillNumber> skill_number_meta_list;
|
|
std::list<MetaData::SkillNumber> skill_number_list;
|
|
std::list<metatable::Buff> buff_meta_list;
|
|
std::list<MetaData::Buff> buff_list;
|
|
std::list<metatable::Attr> attr_meta_list;
|
|
std::list<MetaData::Attr> attr_list;
|
|
std::list<metatable::RankReward> rankreward_meta_list;
|
|
std::list<MetaData::RankReward> rankreward_list;
|
|
std::list<metatable::KillReward> killreward_meta_list;
|
|
std::list<MetaData::KillReward> killreward_list;
|
|
std::list<metatable::RankPoint> rankpoint_meta_list;
|
|
std::list<MetaData::RankPoint> rankpoint_list;
|
|
std::list<metatable::KillPoint> killpoint_meta_list;
|
|
std::list<MetaData::KillPoint> killpoint_list;
|
|
std::list<metatable::Robot> robot_meta_list;
|
|
std::vector<MetaData::Robot> robot_list;
|
|
std::list<metatable::AI> ai_meta_list;
|
|
std::list<MetaData::AI> ai_list;
|
|
std::list<metatable::Text> text_meta_list;
|
|
std::list<metatable::TerrainJson> terrain_meta_list;
|
|
std::list<metatable::GunTalentGrow> talent_meta_list;
|
|
std::list<metatable::FormulaPvp> formula_pvp_meta_list;
|
|
std::list<MetaData::FormulaPvp> formula_pvp_list;
|
|
std::list<metatable::HeroQuality> hero_quality_meta_list;
|
|
std::list<metatable::GunQuality> gun_quality_meta_list;
|
|
std::list<metatable::PveGemini> pve_gemini_meta_list;
|
|
std::list<metatable::PveGeminiContent> pve_gemini_content_meta_list;
|
|
std::list<metatable::PveGeminiMode> pve_gemini_mode_meta_list;
|
|
std::list<metatable::NpcStandard> npc_standard_meta_list;
|
|
|
|
std::map<std::string, MetaData::Parameter*> parameter_hash;
|
|
std::map<int, MetaData::Map*> gamemap_hash;
|
|
std::map<int, MetaData::AirDrop*> airdrop_hash;
|
|
std::map<int, MetaData::AirRaid*> airraid_hash;
|
|
std::map<int, MetaData::SafeArea*> safearea_hash;
|
|
std::map<int, MetaData::SafeArea*> safearea_type_hash;
|
|
std::map<int, std::vector<MetaData::SafeAreaPos*>> safearea_pos_hash;
|
|
std::map<int, MetaData::Item*> item_hash;
|
|
std::map<int, MetaData::Item*> item_heroskin_hash;
|
|
std::map<int, MetaData::Equip*> equip_hash;
|
|
std::map<int, MetaData::Equip*> equip_slot_hash;
|
|
std::map<int, MetaData::Player*> player_hash;
|
|
std::map<int, MetaData::MapThing*> mapthing_hash;
|
|
std::map<int, MetaData::Building*> building_hash;
|
|
std::map<int, MetaData::Drop*> drop_hash;
|
|
std::map<std::string, std::list<metatable::MapTplThingJson>> maptpl_meta_hash;
|
|
std::map<std::string, std::list<metatable::MapLayerJson>> layer_meta_hash;
|
|
std::map<std::string, std::list<metatable::MapBlockJson>> block_meta_hash;
|
|
std::map<std::string, std::vector<MetaData::MapTplThing>> maptpl_hash;
|
|
std::map<int, MetaData::Skill*> skill_hash;
|
|
std::map<int, MetaData::SkillNumber*> skill_number_hash;
|
|
std::map<int, MetaData::Buff*> buff_hash;
|
|
std::map<int, MetaData::Attr*> attr_id_hash;
|
|
std::map<std::string, MetaData::Attr*> attr_name_hash;
|
|
std::map<int, MetaData::RankReward*> rankreward_hash;
|
|
std::map<int, MetaData::KillReward*> killreward_hash;
|
|
std::map<int, MetaData::RankPoint*> rankpoint_hash;
|
|
std::map<int, MetaData::KillPoint*> killpoint_hash;
|
|
std::map<int, MetaData::Robot*> robot_hash;
|
|
std::map<int, std::vector<MetaData::AirLine*>> airline_hash;
|
|
std::map<long long, MetaData::AI*> android_ai_hash;
|
|
std::map<int, MetaData::AI*> ai_hash;
|
|
std::map<std::string, std::string> text_hash;
|
|
std::map<int, std::shared_ptr<MetaData::GunTalentGrow>> talent_hash;
|
|
std::map<std::string, std::vector<std::tuple<int, std::string>>> text_element_hash;
|
|
std::map<int, MetaData::HeroQuality> hero_quality_hash;
|
|
std::map<int, MetaData::GunQuality> gun_quality_hash;
|
|
std::map<int, MetaData::PveGemini> pve_gemini_hash;
|
|
std::map<int, std::vector<MetaData::PveGeminiContent>> pve_gemini_content_hash;
|
|
std::map<int, MetaData::PveGeminiMode> pve_gemini_mode_hash;
|
|
std::map<int, MetaData::NpcStandard> npc_standard_hash;
|
|
|
|
int curr_group_id = 1001;
|
|
std::map<long long, int> weapon_group_hash;
|
|
|
|
void Load()
|
|
{
|
|
if (!f8::IsOnlineEnv()) {
|
|
if (f8::IsTestEnv()) {
|
|
res_path = a8::Format("../../../conf_test/game%d/gameserver.test/res%d/",
|
|
{
|
|
GAME_ID,
|
|
App::Instance()->instance_id
|
|
});
|
|
} else {
|
|
res_path = a8::Format("../../../conf_test/game%d/gameserver.dev/res%d/",
|
|
{
|
|
GAME_ID,
|
|
App::Instance()->instance_id
|
|
});
|
|
}
|
|
} else {
|
|
res_path = "../res/";
|
|
}
|
|
|
|
LoadMetaFile(res_path, "parameter@parameter", parameter_meta_list);
|
|
LoadMetaFile(res_path, "map@map", map_meta_list);
|
|
LoadMetaFile(res_path, "safearea@safearea", safearea_meta_list);
|
|
LoadMetaFile(res_path, "safearea_pos@safearea_pos", safearea_pos_meta_list);
|
|
LoadMetaFile(res_path, "item@item", item_meta_list);
|
|
LoadMetaFile(res_path, "buff@buff", buff_meta_list);
|
|
LoadMetaFile(res_path, "equip@equip", equip_meta_list);
|
|
LoadMetaFile(res_path, "hero@hero", player_meta_list);
|
|
LoadMetaFile(res_path, "mapThing@mapThing", mapthing_meta_list);
|
|
LoadMetaFile(res_path, "drop@drop", drop_meta_list);
|
|
LoadMetaFile(res_path, "airdrop@airdrop", airdrop_meta_list);
|
|
LoadMetaFile(res_path, "airraid@airraid", airraid_meta_list);
|
|
LoadMetaFile(res_path, "airline@airline", airline_meta_list);
|
|
f8::ReadJsonMetaFile(res_path + "maps.json", building_meta_list);
|
|
LoadMetaFile(res_path, "skill@skill", skill_meta_list);
|
|
LoadMetaFile(res_path, "skillNumber@skillNumber", skill_number_meta_list);
|
|
LoadMetaFile(res_path, "attr@attr", attr_meta_list);
|
|
LoadMetaFile(res_path, "rankReward@rankReward", rankreward_meta_list);
|
|
LoadMetaFile(res_path, "killReward@killReward", killreward_meta_list);
|
|
LoadMetaFile(res_path, "killPoint@killPoint", killpoint_meta_list);
|
|
LoadMetaFile(res_path, "rankPoint@rankPoint", rankpoint_meta_list);
|
|
LoadMetaFile(res_path, "robot@robot", robot_meta_list);
|
|
LoadMetaFile(res_path, "ai@ai", ai_meta_list);
|
|
LoadMetaFile(res_path, "text@text", text_meta_list);
|
|
LoadMetaFile(res_path, "gunTalentGrow@gunTalentGrow", talent_meta_list);
|
|
LoadMetaFile(res_path, "pvp@formula", formula_pvp_meta_list);
|
|
LoadMetaFile(res_path, "heroQuality@heroQuality", hero_quality_meta_list);
|
|
LoadMetaFile(res_path, "gunQuality@gunQuality", gun_quality_meta_list);
|
|
LoadMetaFile(res_path, "pveGemini@pveGemini", pve_gemini_meta_list);
|
|
LoadMetaFile(res_path, "pveGeminiContent@pveGeminiContent", pve_gemini_content_meta_list);
|
|
LoadMetaFile(res_path, "pveGeminiMode@pveGeminiMode", pve_gemini_mode_meta_list);
|
|
LoadMetaFile(res_path, "npcStandard@npcStandard", npc_standard_meta_list);
|
|
f8::ReadJsonMetaFile(res_path + "terrain.json", terrain_meta_list);
|
|
BindToMetaData();
|
|
#if 1
|
|
{
|
|
MetaMgr::Instance()->gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("gas_inactive_time");
|
|
|
|
MetaMgr::Instance()->newbie_gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("newbie_gas_inactive_time", 5);
|
|
MetaMgr::Instance()->midbrid_gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("midbrid_gas_inactive_time", 15);
|
|
MetaMgr::Instance()->common_gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("common_gas_inactive_time", 15);
|
|
MetaMgr::Instance()->newbie_born_point = MetaMgr::Instance()->GetSysParamAsString("newbie_born_point");
|
|
MetaMgr::Instance()->downed_relive_recover_hp = MetaMgr::Instance()->GetSysParamAsInt("downed_relive_recover_hp");
|
|
{
|
|
std::vector<std::string> strings;
|
|
std::string tmpstr = MetaMgr::Instance()->GetSysParamAsString("newbie_drop");
|
|
a8::Split(tmpstr, strings, ':');
|
|
for (const std::string& str : strings) {
|
|
int drop_id = a8::XValue(str);
|
|
MetaMgr::Instance()->newbie_drop.push_back(drop_id);
|
|
}
|
|
}
|
|
{
|
|
std::vector<std::string> strings;
|
|
std::string tmpstr = MetaMgr::Instance()->GetSysParamAsString("newbie_airdrop");
|
|
a8::Split(tmpstr, strings, ':');
|
|
for (const std::string& str : strings) {
|
|
int drop_id = a8::XValue(str);
|
|
MetaMgr::Instance()->newbie_airdrop.push_back(drop_id);
|
|
}
|
|
}
|
|
MetaMgr::Instance()->newbie_first_robot_distance =
|
|
MetaMgr::Instance()->GetSysParamAsInt("newbie_first_robot_distance", 500);
|
|
{
|
|
std::vector<std::string> strings;
|
|
std::string tmpstr = MetaMgr::Instance()->GetSysParamAsString("newbie_buff_list");
|
|
a8::Split(tmpstr, strings, ':');
|
|
for (const std::string& str : strings) {
|
|
int drop_id = a8::XValue(str);
|
|
MetaMgr::Instance()->newbie_buff_list.push_back(drop_id);
|
|
}
|
|
}
|
|
|
|
MetaMgr::Instance()->K = MetaMgr::Instance()->GetSysParamAsFloat("K");
|
|
MetaMgr::Instance()->kill_param = MetaMgr::Instance()->GetSysParamAsFloat("kill_parameter");
|
|
MetaMgr::Instance()->rank_param = MetaMgr::Instance()->GetSysParamAsFloat("rank_parameter");
|
|
MetaMgr::Instance()->fighting_mode = MetaMgr::Instance()->GetSysParamAsInt("fighting_mode", 1);
|
|
MetaMgr::Instance()->tank_damage1 = MetaMgr::Instance()->GetSysParamAsInt("tank_damage1");
|
|
MetaMgr::Instance()->tank_damage2 = MetaMgr::Instance()->GetSysParamAsInt("tank_damage2");
|
|
MetaMgr::Instance()->tank_damage_interval = MetaMgr::Instance()->GetSysParamAsFloat("tank_damage_interval", 1);
|
|
MetaMgr::Instance()->average_oil = MetaMgr::Instance()->GetSysParamAsInt("average_oil");
|
|
MetaMgr::Instance()->max_oil = MetaMgr::Instance()->GetSysParamAsInt("max_oil");
|
|
MetaMgr::Instance()->max_mount_horse_distance = MetaMgr::Instance()->GetSysParamAsFloat("max_mount_horse_distance", 100);
|
|
MetaMgr::Instance()->newbie_game_times = MetaMgr::Instance()->GetSysParamAsInt("newbie_game_times", 5);
|
|
MetaMgr::Instance()->niube_win_times = MetaMgr::Instance()->GetSysParamAsInt("niube_win_times", 1);
|
|
MetaMgr::Instance()->newbie_fill_interval = MetaMgr::Instance()->GetSysParamAsInt("newbie_fill_interval", 5000);
|
|
MetaMgr::Instance()->other_fill_interval = MetaMgr::Instance()->GetSysParamAsInt("other_fill_interval", 2000);
|
|
MetaMgr::Instance()->map_cell_width = MetaMgr::Instance()->GetSysParamAsInt("map_cell_width", 64 * 8);
|
|
#ifdef DEBUG
|
|
MetaMgr::Instance()->map_cell_width = 512;
|
|
#endif
|
|
MetaMgr::Instance()->bullet_planck_step_length = std::max(15, MetaMgr::Instance()->GetSysParamAsInt("bullet_planck_step_length", 15));
|
|
MetaMgr::Instance()->async_send_mapblock = MetaMgr::Instance()->GetSysParamAsInt("async_send_mapblock", 0);
|
|
#ifdef DEBUG
|
|
MetaMgr::Instance()->async_send_mapblock = 1;
|
|
#endif
|
|
MetaMgr::Instance()->show_team_ui = MetaMgr::Instance()->GetSysParamAsInt("show_team_ui", 0);
|
|
#ifdef DEBUG
|
|
MetaMgr::Instance()->show_team_ui = 1;
|
|
#endif
|
|
MetaMgr::Instance()->match_team_time = MetaMgr::Instance()->GetSysParamAsInt("match_team_time", 0);
|
|
MetaMgr::Instance()->match_robot_time = MetaMgr::Instance()->GetSysParamAsInt("match_robot_time", 0);
|
|
MetaMgr::Instance()->match_choose_time = MetaMgr::Instance()->GetSysParamAsInt("match_choose_time", 0);
|
|
MetaMgr::Instance()->match_lock_time = MetaMgr::Instance()->GetSysParamAsInt("match_lock_time", 0);
|
|
#if 1
|
|
MetaMgr::Instance()->match_lock_time++;
|
|
#endif
|
|
#ifdef DEBUG
|
|
MetaMgr::Instance()->match_team_time = 6;
|
|
MetaMgr::Instance()->match_robot_time = 5;
|
|
MetaMgr::Instance()->match_choose_time = 25;
|
|
MetaMgr::Instance()->match_lock_time = 3;
|
|
#endif
|
|
{
|
|
METAMGR_READ(prebattle_box_id_chiji, 0);
|
|
}
|
|
{
|
|
METAMGR_READ(newbie_first_robot_ammo, 3);
|
|
METAMGR_READ(newbie_first_robot_appeartime, 8);
|
|
METAMGR_READ(newbie_airdrop_appeartime, 6);
|
|
|
|
METAMGR_READ(level0room_shua_robot_min_time, 5);
|
|
METAMGR_READ(level0room_shua_robot_max_time, 7);
|
|
METAMGR_READ(level0room_shua_robot_min_num, 1);
|
|
METAMGR_READ(level0room_shua_robot_max_num, 3);
|
|
METAMGR_READ(level0room_die_robot_min_time, 10);
|
|
METAMGR_READ(level0room_die_robot_max_time, 20);
|
|
METAMGR_READ(level0room_die_robot_min_num, 1);
|
|
METAMGR_READ(level0room_die_robot_max_num, 3);
|
|
METAMGR_READ(level0room_robot_water, 3);
|
|
METAMGR_READ(level0room_robot_protect_time, 60);
|
|
METAMGR_READ(level0room_robot_autodie_time, 10);
|
|
METAMGR_READ(level0room_robot_autodie_distance, 500);
|
|
METAMGR_READ(water_move_coefficient, 0.75);
|
|
METAMGR_READ(teammate_kill_color, 0xFFFF00);
|
|
METAMGR_READ(teammate_bekill_color, 0x00FF00);
|
|
METAMGR_READ(self_kill_color, 0xFFFF00);
|
|
METAMGR_READ(self_bekill_color, 0x00FF00);
|
|
METAMGR_READ(refresh_ai_destory_box_time, 30);
|
|
METAMGR_READ(refresh_ai_destory_box_times, 5);
|
|
METAMGR_READ(refresh_ai_downed_nearby_teammate_num, 1);
|
|
METAMGR_READ(refresh_ai_downed_nearby_range, 580);
|
|
|
|
METAMGR_READ(view_objects_out_distance, 530);
|
|
METAMGR_READ(view_objects_in_distance, 530);
|
|
|
|
METAMGR_READ(incubator_base_length, 501);
|
|
METAMGR_READ(incubator_rand_length, 10);
|
|
METAMGR_READ(incubator_canset_distance, 520);
|
|
|
|
METAMGR_READ(prebattle_can_use_skill, 1);
|
|
METAMGR_READ(watchable, 1);
|
|
METAMGR_READ(prebattle_combine_team, 1);
|
|
|
|
METAMGR_READ(refresh_view_time, 4);
|
|
|
|
METAMGR_READ(kill_exp_monster, 0);
|
|
METAMGR_READ(kill_exp_player, 0);
|
|
{
|
|
METAMGR_READ_STR(level0room_spec_things, "");
|
|
std::vector<std::string> tmpstrings;
|
|
a8::Split(MetaMgr::Instance()->level0room_spec_things, tmpstrings, ':');
|
|
for (auto& str : tmpstrings) {
|
|
if (!str.empty()) {
|
|
MetaMgr::Instance()->level0room_spec_things_set.insert
|
|
(
|
|
a8::XValue(str).GetInt()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
{
|
|
METAMGR_READ_STR(level0room_spec_airdrop, "");
|
|
std::vector<std::string> tmpstrings;
|
|
a8::Split(MetaMgr::Instance()->level0room_spec_airdrop, tmpstrings, ':');
|
|
for (auto& str : tmpstrings) {
|
|
if (!str.empty()) {
|
|
MetaMgr::Instance()->level0room_spec_airdrops.push_back
|
|
(
|
|
a8::XValue(str).GetInt()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
{
|
|
METAMGR_READ_STR(a_room_ai, "");
|
|
std::vector<std::string> tmpstrings;
|
|
a8::Split(MetaMgr::Instance()->a_room_ai, tmpstrings, '|');
|
|
int i = 1;
|
|
for (auto& str : tmpstrings) {
|
|
int weight = a8::XValue(str).GetInt();
|
|
MetaMgr::Instance()->a_room_ai_weights_space += weight;
|
|
MetaMgr::Instance()->a_room_ai_weights.push_back
|
|
(
|
|
std::make_tuple
|
|
(
|
|
i,
|
|
MetaMgr::Instance()->a_room_ai_weights_space
|
|
)
|
|
);
|
|
++i;
|
|
}
|
|
if (MetaMgr::Instance()->a_room_ai_weights.size() != MAX_AI_LEVEL) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->a_room_ai_weights_space <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
{
|
|
METAMGR_READ_STR(b_room_ai, "");
|
|
std::vector<std::string> tmpstrings;
|
|
a8::Split(MetaMgr::Instance()->b_room_ai, tmpstrings, '|');
|
|
int i = 1;
|
|
for (auto& str : tmpstrings) {
|
|
int weight = a8::XValue(str).GetInt();
|
|
MetaMgr::Instance()->b_room_ai_weights_space += weight;
|
|
MetaMgr::Instance()->b_room_ai_weights.push_back
|
|
(
|
|
std::make_tuple
|
|
(
|
|
i,
|
|
MetaMgr::Instance()->b_room_ai_weights_space
|
|
)
|
|
);
|
|
++i;
|
|
}
|
|
if (MetaMgr::Instance()->b_room_ai_weights.size() != MAX_AI_LEVEL) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->b_room_ai_weights_space <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
{
|
|
METAMGR_READ_STR(c_room_ai, "");
|
|
std::vector<std::string> tmpstrings;
|
|
a8::Split(MetaMgr::Instance()->c_room_ai, tmpstrings, '|');
|
|
int i = 1;
|
|
for (auto& str : tmpstrings) {
|
|
int weight = a8::XValue(str).GetInt();
|
|
MetaMgr::Instance()->c_room_ai_weights_space += weight;
|
|
MetaMgr::Instance()->c_room_ai_weights.push_back
|
|
(
|
|
std::make_tuple
|
|
(
|
|
i,
|
|
MetaMgr::Instance()->c_room_ai_weights_space
|
|
)
|
|
);
|
|
++i;
|
|
}
|
|
if (MetaMgr::Instance()->c_room_ai_weights.size() != MAX_AI_LEVEL) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->c_room_ai_weights_space <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
|
|
METAMGR_READ(level1room_shua_robot_min_time, 5);
|
|
METAMGR_READ(level1room_shua_robot_max_time, 7);
|
|
METAMGR_READ(level1room_shua_robot_min_num, 2);
|
|
METAMGR_READ(level1room_shua_robot_max_num, 5);
|
|
METAMGR_READ(level1room_die_robot_min_time, 10);
|
|
METAMGR_READ(level1room_die_robot_max_time, 14);
|
|
METAMGR_READ(level1room_die_robot_min_num, 1);
|
|
METAMGR_READ(level1room_die_robot_max_num, 3);
|
|
METAMGR_READ(level1room_robot_water, 8);
|
|
METAMGR_READ(level1room_robot_autodie_time, 10);
|
|
METAMGR_READ(level1room_robot_autodie_distance, 500);
|
|
METAMGR_READ_STR(level1room_born_point, "");
|
|
|
|
METAMGR_READ(dive_oxygen_total, 200);
|
|
METAMGR_READ(dive_oxygen_consume, 20);
|
|
METAMGR_READ(dive_hp_consume, 20);
|
|
METAMGR_READ(dive_explosion_dmg_switch, 0);
|
|
METAMGR_READ(inwater_oxygen_recover, 20);
|
|
}
|
|
if (MetaMgr::Instance()->K < 0.01f) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
{
|
|
MetaMgr::Instance()->human_meta = MetaMgr::Instance()->GetPlayer(40001);
|
|
if (!MetaMgr::Instance()->human_meta) {
|
|
A8_ABORT();
|
|
}
|
|
MetaMgr::Instance()->android_meta = MetaMgr::Instance()->GetPlayer(40002);
|
|
if (!MetaMgr::Instance()->android_meta) {
|
|
A8_ABORT();
|
|
}
|
|
MetaMgr::Instance()->terminator_meta = MetaMgr::Instance()->GetPlayer(5005);
|
|
}
|
|
#endif
|
|
LoadHeroAndEquipShotData();
|
|
Check();
|
|
}
|
|
|
|
private:
|
|
|
|
void LoadHeroAndEquipShotData()
|
|
{
|
|
a8::XObject xobj;
|
|
xobj.ReadFromFile(res_path + "shot_animation.json");
|
|
{
|
|
auto hero_list_xobj = xobj.At("hero");
|
|
std::vector<std::string> keys;
|
|
hero_list_xobj->GetKeys(keys);
|
|
for (auto& key : keys) {
|
|
auto hero_xobj = hero_list_xobj->At(key);
|
|
int hero_id = a8::XValue(key);
|
|
std::vector<std::string> keys2;
|
|
hero_xobj->GetKeys(keys2);
|
|
|
|
for (auto& key2 : keys2) {
|
|
auto anim_xobj = hero_xobj->At(key2);
|
|
int id = a8::XValue(key2);
|
|
int t = anim_xobj->At("t") ? anim_xobj->At("t")->AsXValue().GetInt() : 0;
|
|
|
|
float r_x = 0;
|
|
float r_y = 0;
|
|
float r_z = 0;
|
|
if (anim_xobj->At("r") && anim_xobj->At("r")->IsObject()) {
|
|
r_x = anim_xobj->At("r")->At("x")->AsXValue().GetDouble();
|
|
r_y = anim_xobj->At("r")->At("y")->AsXValue().GetDouble();
|
|
r_z = anim_xobj->At("r")->At("z")->AsXValue().GetDouble();
|
|
}
|
|
|
|
float l_x = 0;
|
|
float l_y = 0;
|
|
float l_z = 0;
|
|
if (anim_xobj->At("l") && anim_xobj->At("l")->IsObject()) {
|
|
l_x = anim_xobj->At("l")->At("x")->AsXValue().GetDouble();
|
|
l_y = anim_xobj->At("l")->At("y")->AsXValue().GetDouble();
|
|
l_z = anim_xobj->At("l")->At("z")->AsXValue().GetDouble();
|
|
}
|
|
|
|
float p3_x = 0;
|
|
float p3_y = 0;
|
|
float p3_z = 0;
|
|
if (anim_xobj->At("p3") && anim_xobj->At("p3")->IsObject()) {
|
|
p3_x = anim_xobj->At("p3")->At("x")->AsXValue().GetDouble();
|
|
p3_y = anim_xobj->At("p3")->At("y")->AsXValue().GetDouble();
|
|
p3_z = anim_xobj->At("p3")->At("z")->AsXValue().GetDouble();
|
|
}
|
|
|
|
float p4_x = 0;
|
|
float p4_y = 0;
|
|
float p4_z = 0;
|
|
if (anim_xobj->At("p4") && anim_xobj->At("p4")->IsObject()) {
|
|
|
|
p4_x = anim_xobj->At("p4")->At("x")->AsXValue().GetDouble();
|
|
p4_y = anim_xobj->At("p4")->At("y")->AsXValue().GetDouble();
|
|
p4_z = anim_xobj->At("p4")->At("z")->AsXValue().GetDouble();
|
|
}
|
|
|
|
float p5_x = 0;
|
|
float p5_y = 0;
|
|
float p5_z = 0;
|
|
if (anim_xobj->At("p5") && anim_xobj->At("p5")->IsObject()) {
|
|
p5_x = anim_xobj->At("p5")->At("x")->AsXValue().GetDouble();
|
|
p5_y = anim_xobj->At("p5")->At("y")->AsXValue().GetDouble();
|
|
p5_z = anim_xobj->At("p5")->At("z")->AsXValue().GetDouble();
|
|
}
|
|
|
|
{
|
|
MetaData::Player* hero_meta = MetaMgr::Instance()->GetPlayer(hero_id);
|
|
if (hero_meta) {
|
|
MetaData::HeroShotAnimation anim;
|
|
anim.id = id;
|
|
anim.t = t;
|
|
|
|
anim.r_x = r_x;
|
|
anim.r_y = r_y;
|
|
anim.r_z = r_z;
|
|
|
|
anim.l_x = l_x;
|
|
anim.l_y = l_y;
|
|
anim.l_z = l_z;
|
|
|
|
anim.p3_x = p3_x;
|
|
anim.p3_y = p3_y;
|
|
anim.p3_z = p3_z;
|
|
|
|
anim.p4_x = p4_x;
|
|
anim.p4_y = p4_y;
|
|
anim.p4_z = p4_z;
|
|
|
|
anim.p5_x = p5_x;
|
|
anim.p5_y = p5_y;
|
|
anim.p5_z = p5_z;
|
|
|
|
hero_meta->shot_animations[id] = anim;
|
|
}
|
|
}
|
|
#if 0
|
|
a8::UdpLog::Instance()->Info
|
|
("shot animation hero_id:%d anim_id:%d t:%f r_x:%f r_y:%f r_z:%f l_x:%f l_y:%f l_z:%f",
|
|
{
|
|
hero_id,
|
|
id,
|
|
t,
|
|
r_x,
|
|
r_y,
|
|
r_z,
|
|
l_x,
|
|
l_y,
|
|
l_z
|
|
});
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
{
|
|
auto equip_list_xobj = xobj.At("equip");
|
|
std::vector<std::string> keys;
|
|
equip_list_xobj->GetKeys(keys);
|
|
for (auto& key : keys) {
|
|
auto equip_xobj = equip_list_xobj->At(key);
|
|
int equip_id = a8::XValue(key);
|
|
|
|
float x = equip_xobj->At("x")->AsXValue().GetDouble();
|
|
float y = equip_xobj->At("y")->AsXValue().GetDouble();
|
|
float z = equip_xobj->At("z")->AsXValue().GetDouble();
|
|
|
|
float movex = equip_xobj->At("movex") ?
|
|
equip_xobj->At("movex")->AsXValue().GetDouble() : 0;
|
|
float movey = equip_xobj->At("movey") ?
|
|
equip_xobj->At("movey")->AsXValue().GetDouble() : 0;
|
|
float movez = equip_xobj->At("movez") ?
|
|
equip_xobj->At("movez")->AsXValue().GetDouble() : 0;
|
|
|
|
MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(equip_id);
|
|
if (equip_meta) {
|
|
equip_meta->gun_muzzle_position = std::make_shared<std::tuple<float, float, float>>
|
|
(
|
|
x,
|
|
y,
|
|
z
|
|
);
|
|
equip_meta->movex_position = std::make_shared<std::tuple<float, float, float>>
|
|
(
|
|
movex,
|
|
movey,
|
|
movez
|
|
);
|
|
}
|
|
#if 0
|
|
a8::UdpLog::Instance()->Info
|
|
("weapon animation equip_id:%d x:%f y:%f z:%f movex:%f lmovey:%f movez:%f",
|
|
{
|
|
equip_id,
|
|
x,
|
|
y,
|
|
z,
|
|
movex,
|
|
movey,
|
|
movez
|
|
});
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void Check()
|
|
{
|
|
|
|
{
|
|
if (MetaMgr::Instance()->level0room_shua_robot_min_time >
|
|
MetaMgr::Instance()->level0room_shua_robot_max_time) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->level0room_shua_robot_min_num >
|
|
MetaMgr::Instance()->level0room_shua_robot_max_num) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->level0room_die_robot_min_time >
|
|
MetaMgr::Instance()->level0room_die_robot_max_time) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->level0room_die_robot_min_num >
|
|
MetaMgr::Instance()->level0room_die_robot_max_num) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
|
|
{
|
|
if (MetaMgr::Instance()->level1room_shua_robot_min_time >
|
|
MetaMgr::Instance()->level1room_shua_robot_max_time) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->level1room_shua_robot_min_num >
|
|
MetaMgr::Instance()->level1room_shua_robot_max_num) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->level1room_die_robot_min_time >
|
|
MetaMgr::Instance()->level1room_die_robot_max_time) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->level1room_die_robot_min_num >
|
|
MetaMgr::Instance()->level1room_die_robot_max_num) {
|
|
A8_ABORT();
|
|
}
|
|
}
|
|
{
|
|
for (auto& skill : skill_list) {
|
|
skill.Init2();
|
|
}
|
|
for (auto& buff : buff_list) {
|
|
buff.Init2();
|
|
}
|
|
for (auto& equip : equip_list) {
|
|
equip.Init2();
|
|
}
|
|
for (auto& map : map_list) {
|
|
map.Init2();
|
|
}
|
|
}
|
|
if (MetaMgr::Instance()->match_team_time <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->match_robot_time <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->match_robot_time >= MetaMgr::Instance()->match_team_time) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->match_choose_time <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->match_lock_time <= 0) {
|
|
A8_ABORT();
|
|
}
|
|
if (MetaMgr::Instance()->match_lock_time >= MetaMgr::Instance()->match_choose_time) {
|
|
A8_ABORT();
|
|
}
|
|
{
|
|
for (int i = 1; i <= 15; ++i) {
|
|
if (!MetaMgr::Instance()->GetNpcStandard(i)) {
|
|
abort();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void BindToMetaData()
|
|
{
|
|
|
|
for (auto& meta : parameter_meta_list) {
|
|
MetaData::Parameter& item = a8::FastAppend(parameter_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
parameter_hash[item.pb->param_name()] = &item;
|
|
}
|
|
|
|
{
|
|
for (auto& meta : map_meta_list) {
|
|
MetaData::Map& item = a8::FastAppend(map_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
gamemap_hash[item.pb->map_id()] = &item;
|
|
#if 1
|
|
{
|
|
for (auto& tuple : item.template_list) {
|
|
{
|
|
auto itr = maptpl_meta_hash.find(std::get<0>(tuple));
|
|
if (itr == maptpl_meta_hash.end()) {
|
|
maptpl_meta_hash[std::get<0>(tuple)] = std::list<metatable::MapTplThingJson>();
|
|
itr = maptpl_meta_hash.find(std::get<0>(tuple));
|
|
} else {
|
|
itr->second.clear();
|
|
}
|
|
f8::ReadJsonMetaFile(res_path + std::get<0>(tuple) + ".json", itr->second);
|
|
}
|
|
{
|
|
auto itr = layer_meta_hash.find(meta.map_pic());
|
|
if (itr == layer_meta_hash.end()) {
|
|
layer_meta_hash[meta.map_pic()] = std::list<metatable::MapLayerJson>();
|
|
itr = layer_meta_hash.find(meta.map_pic());
|
|
} else {
|
|
itr->second.clear();
|
|
}
|
|
std::string filename = res_path + "map" + meta.map_pic() + ".layers.json";
|
|
if (access(filename.c_str(), F_OK) != -1) {
|
|
f8::ReadJsonMetaFile(filename, itr->second);
|
|
}
|
|
}
|
|
{
|
|
auto itr = block_meta_hash.find(meta.map_pic());
|
|
if (itr == block_meta_hash.end()) {
|
|
block_meta_hash[meta.map_pic()] = std::list<metatable::MapBlockJson>();
|
|
itr = block_meta_hash.find(meta.map_pic());
|
|
} else {
|
|
itr->second.clear();
|
|
}
|
|
std::string filename = res_path + "map" + meta.map_pic() + ".block.json";
|
|
if (access(filename.c_str(), F_OK) != -1) {
|
|
f8::ReadJsonMetaFile(filename, itr->second);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
for (auto& pair : maptpl_meta_hash) {
|
|
std::vector<MetaData::MapTplThing> things;
|
|
for (auto& itr : pair.second) {
|
|
auto& thing = a8::FastAppend(things);
|
|
thing.pb = &itr;
|
|
thing.Init();
|
|
}
|
|
maptpl_hash[pair.first] = things;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : safearea_meta_list) {
|
|
MetaData::SafeArea& item = a8::FastAppend(safearea_list);
|
|
item.pb = &meta;
|
|
if (App::Instance()->HasFlag(7)) {
|
|
meta.set_wait_time(3);
|
|
meta.set_shrink_speed(500);
|
|
}
|
|
safearea_hash[item.pb->id()] = &item;
|
|
if (safearea_type_hash.find(item.pb->type()) == safearea_type_hash.end()) {
|
|
safearea_type_hash[item.pb->type()] = &item;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : safearea_pos_meta_list) {
|
|
MetaData::SafeAreaPos& item = a8::FastAppend(safearea_pos_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
{
|
|
auto itr = safearea_pos_hash.find(meta.id());
|
|
if (itr != safearea_pos_hash.end()) {
|
|
itr->second.push_back(&item);
|
|
} else {
|
|
safearea_pos_hash[meta.id()] = std::vector<MetaData::SafeAreaPos*>({&item});
|
|
}
|
|
}
|
|
}
|
|
|
|
for (auto& meta : buff_meta_list) {
|
|
if (!IsValidBuffEffect(meta.buff_effect())) {
|
|
A8_ABORT();
|
|
}
|
|
MetaData::Buff& item = a8::FastAppend(buff_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
if (buff_hash.find(item.pb->buff_id()) != buff_hash.end()) {
|
|
A8_ABORT();
|
|
}
|
|
buff_hash[item.pb->buff_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : item_meta_list) {
|
|
MetaData::Item& item = a8::FastAppend(item_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
item_hash[item.pb->id()] = &item;
|
|
if (meta.playerid()) {
|
|
item_heroskin_hash[item.pb->playerid()] = &item;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : equip_meta_list) {
|
|
if (meta.inventory_slot().empty()) {
|
|
meta.set__inventory_slot(-1);
|
|
} else {
|
|
meta.set__inventory_slot(a8::XValue(meta.inventory_slot()));
|
|
}
|
|
MetaData::Equip& item = a8::FastAppend(equip_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
equip_hash[item.pb->id()] = &item;
|
|
if (meta._inventory_slot() > -1) {
|
|
equip_slot_hash[meta._inventory_slot()] = &item;
|
|
}
|
|
if (meta.equip_type() == EQUIP_TYPE_WEAPON) {
|
|
auto itr = weapon_group_hash.find(meta.id());
|
|
if (itr != weapon_group_hash.end()) {
|
|
item.group_id = itr->second;
|
|
} else {
|
|
item.group_id = ++curr_group_id;
|
|
weapon_group_hash[meta.id()] = item.group_id;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (auto& meta : player_meta_list) {
|
|
MetaData::Player& item = a8::FastAppend(player_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
player_hash[item.pb->id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : mapthing_meta_list) {
|
|
MetaData::MapThing& item = a8::FastAppend(mapthing_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
mapthing_hash[item.pb->thing_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : drop_meta_list) {
|
|
MetaData::Drop& item = a8::FastAppend(drop_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
drop_hash[item.pb->drop_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : airdrop_meta_list) {
|
|
MetaData::AirDrop& item = a8::FastAppend(airdrop_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
airdrop_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : airraid_meta_list) {
|
|
MetaData::AirRaid& item = a8::FastAppend(airraid_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
airraid_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : airline_meta_list) {
|
|
MetaData::AirLine& item = a8::FastAppend(airline_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
{
|
|
auto itr = airline_hash.find(item.pb->map_id());
|
|
if (itr != airline_hash.end()) {
|
|
itr->second.push_back(&item);
|
|
} else {
|
|
airline_hash[item.pb->map_id()] = std::vector<MetaData::AirLine*>({&item});
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
for (auto& meta : building_meta_list) {
|
|
MetaData::Building& item = a8::FastAppend(building_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
building_hash[item.pb->mapid()] = &item;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : attr_meta_list) {
|
|
MetaData::Attr& item = a8::FastAppend(attr_list);
|
|
item.pb = &meta;
|
|
attr_id_hash[item.pb->attr_id()] = &item;
|
|
attr_name_hash[item.pb->attr_ename()] = &item;
|
|
}
|
|
|
|
for (auto& meta : skill_meta_list) {
|
|
MetaData::Skill& item = a8::FastAppend(skill_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
skill_hash[item.pb->skill_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : skill_number_meta_list) {
|
|
MetaData::SkillNumber& item = a8::FastAppend(skill_number_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
skill_number_hash[item.pb->skill_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : rankreward_meta_list) {
|
|
MetaData::RankReward& item = a8::FastAppend(rankreward_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
rankreward_hash[item.pb->rank()] = &item;
|
|
}
|
|
|
|
for (auto& meta : killreward_meta_list) {
|
|
MetaData::KillReward& item = a8::FastAppend(killreward_list);
|
|
item.pb = &meta;
|
|
killreward_hash[item.pb->kill_num()] = &item;
|
|
}
|
|
|
|
for (auto& meta : killpoint_meta_list) {
|
|
MetaData::KillPoint& item = a8::FastAppend(killpoint_list);
|
|
item.pb = &meta;
|
|
killpoint_hash[item.pb->kill_num()] = &item;
|
|
}
|
|
|
|
for (auto& meta : rankpoint_meta_list) {
|
|
MetaData::RankPoint& item = a8::FastAppend(rankpoint_list);
|
|
item.pb = &meta;
|
|
rankpoint_hash[item.pb->rank()] = &item;
|
|
}
|
|
|
|
for (auto& meta : robot_meta_list) {
|
|
MetaData::Robot& item = a8::FastAppend(robot_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
robot_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : ai_meta_list) {
|
|
MetaData::AI& item = a8::FastAppend(ai_list);
|
|
item.pb = &meta;
|
|
item.Init();
|
|
ai_hash[item.pb->id()] = &item;
|
|
if (item.pb->ai_kind() == kAI_Android) {
|
|
android_ai_hash[a8::MakeInt64(meta.id() - ANDROID_AI_ID_START + 1, meta.ai_mode())] = &item;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : text_meta_list) {
|
|
text_hash[meta.textid()] = meta.text();
|
|
if (meta.textid().find("battle_server_dead_text_") != std::string::npos) {
|
|
std::vector<std::tuple<int, std::string>> elemets;
|
|
ParseElemets(meta.textid(), meta.text(), elemets);
|
|
text_element_hash[meta.textid()] = elemets;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : talent_meta_list) {
|
|
std::shared_ptr<MetaData::GunTalentGrow> item = std::make_shared<MetaData::GunTalentGrow>();
|
|
item->pb = &meta;
|
|
item->Init();
|
|
talent_hash[a8::MakeInt64(meta.talent_id(), meta.talent_lv())] = item;
|
|
}
|
|
|
|
for (auto& meta : formula_pvp_meta_list) {
|
|
MetaData::FormulaPvp item;
|
|
item.pb = &meta;
|
|
formula_pvp_list.push_back(item);
|
|
}
|
|
|
|
for (auto& meta : hero_quality_meta_list) {
|
|
MetaData::HeroQuality item;
|
|
item.pb = &meta;
|
|
hero_quality_hash[meta.quality()] = item;
|
|
}
|
|
|
|
for (auto& meta : gun_quality_meta_list) {
|
|
MetaData::GunQuality item;
|
|
item.pb = &meta;
|
|
gun_quality_hash[meta.quality()] = item;
|
|
}
|
|
|
|
for (auto& meta : pve_gemini_meta_list) {
|
|
MetaData::PveGemini item;
|
|
item.pb = &meta;
|
|
item.Init();
|
|
pve_gemini_hash[meta.gemini_id()] = item;
|
|
}
|
|
|
|
for (auto& meta : pve_gemini_content_meta_list) {
|
|
MetaData::PveGeminiContent item;
|
|
item.pb = &meta;
|
|
if (pve_gemini_content_hash.find(meta.mode_id()) == pve_gemini_content_hash.end()) {
|
|
pve_gemini_content_hash[meta.mode_id()] = std::vector<MetaData::PveGeminiContent>();
|
|
}
|
|
item.Init();
|
|
pve_gemini_content_hash[meta.mode_id()].push_back(item);
|
|
}
|
|
|
|
for (auto& meta : pve_gemini_mode_meta_list) {
|
|
MetaData::PveGeminiMode item;
|
|
item.pb = &meta;
|
|
item.Init();
|
|
pve_gemini_mode_hash[meta.id()] = item;
|
|
}
|
|
|
|
for (auto& meta : npc_standard_meta_list) {
|
|
MetaData::NpcStandard item;
|
|
item.pb = &meta;
|
|
npc_standard_hash[meta.id()] = item;
|
|
}
|
|
|
|
}
|
|
|
|
public:
|
|
std::string res_path;
|
|
};
|
|
|
|
void MetaMgr::Init()
|
|
{
|
|
loader_ = new MetaDataLoader();
|
|
loader_->Load();
|
|
}
|
|
|
|
void MetaMgr::UnInit()
|
|
{
|
|
delete loader_;
|
|
loader_ = nullptr;
|
|
}
|
|
|
|
void MetaMgr::Reload()
|
|
{
|
|
delete loader_;
|
|
loader_ = nullptr;
|
|
|
|
loader_ = new MetaDataLoader();
|
|
loader_->Load();
|
|
}
|
|
|
|
int MetaMgr::GetSysParamAsInt(const std::string& param_name, int def_val)
|
|
{
|
|
auto itr = loader_->parameter_hash.find(param_name);
|
|
return itr != loader_->parameter_hash.end() ? itr->second->int_val: def_val;
|
|
}
|
|
|
|
double MetaMgr::GetSysParamAsFloat(const std::string& param_name, double def_val)
|
|
{
|
|
auto itr = loader_->parameter_hash.find(param_name);
|
|
return itr != loader_->parameter_hash.end() ? itr->second->float_val: def_val;
|
|
}
|
|
|
|
std::string MetaMgr::GetSysParamAsString(const std::string& param_name, const char* def_val)
|
|
{
|
|
auto itr = loader_->parameter_hash.find(param_name);
|
|
return itr != loader_->parameter_hash.end() ? itr->second->str_val: def_val;
|
|
}
|
|
|
|
MetaData::Map* MetaMgr::GetMap(int map_id)
|
|
{
|
|
auto itr = loader_->gamemap_hash.find(map_id);
|
|
return itr != loader_->gamemap_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
std::list<MetaData::Map>* MetaMgr::GetMaps()
|
|
{
|
|
return &loader_->map_list;
|
|
}
|
|
|
|
MetaData::MapThing* MetaMgr::GetMapThing(int mapthing_id)
|
|
{
|
|
auto itr = loader_->mapthing_hash.find(mapthing_id);
|
|
return itr != loader_->mapthing_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Player* MetaMgr::GetPlayer(int id)
|
|
{
|
|
auto itr = loader_->player_hash.find(id);
|
|
return itr != loader_->player_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Equip* MetaMgr::GetEquip(int id)
|
|
{
|
|
auto itr = loader_->equip_hash.find(id);
|
|
return itr != loader_->equip_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Equip* MetaMgr::GetEquipBySlotId(int slot_id)
|
|
{
|
|
auto itr = loader_->equip_slot_hash.find(slot_id);
|
|
return itr != loader_->equip_slot_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Building* MetaMgr::GetBuilding(int building_id)
|
|
{
|
|
auto itr = loader_->building_hash.find(building_id);
|
|
return itr != loader_->building_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Drop* MetaMgr::GetDrop(int drop_id)
|
|
{
|
|
auto itr = loader_->drop_hash.find(drop_id);
|
|
return itr != loader_->drop_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::SafeArea* MetaMgr::GetSafeArea(int area_id)
|
|
{
|
|
auto itr = loader_->safearea_hash.find(area_id);
|
|
return itr != loader_->safearea_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::SafeArea* MetaMgr::GetSafeAreaByType(int area_type)
|
|
{
|
|
auto itr = loader_->safearea_type_hash.find(area_type);
|
|
return itr != loader_->safearea_type_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::SafeAreaPos* MetaMgr::RandSafeAreaPos(int area_id)
|
|
{
|
|
std::vector<MetaData::SafeAreaPos*>* pos_list = GetSafeAreaPosList(area_id);
|
|
return pos_list && !pos_list->empty() ? pos_list->at(rand() % pos_list->size()) : nullptr;
|
|
}
|
|
|
|
std::vector<MetaData::SafeAreaPos*>* MetaMgr::GetSafeAreaPosList(int area_id)
|
|
{
|
|
auto itr = loader_->safearea_pos_hash.find(area_id);
|
|
return itr != loader_->safearea_pos_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
std::vector<MetaData::MapTplThing>* MetaMgr::GetMapTplThing(const std::string& map_name)
|
|
{
|
|
auto itr = loader_->maptpl_hash.find(map_name);
|
|
return itr != loader_->maptpl_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
metatable::TerrainJson* MetaMgr::GetTerrainJson(int map_id)
|
|
{
|
|
for (auto& itr : loader_->terrain_meta_list) {
|
|
if (itr.map_id() == map_id) {
|
|
return &itr;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
std::list<metatable::MapLayerJson>* MetaMgr::GetMapLayer(const std::string& map_name)
|
|
{
|
|
auto itr = loader_->layer_meta_hash.find(map_name);
|
|
return itr != loader_->layer_meta_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
std::list<metatable::MapBlockJson>* MetaMgr::GetMapBlock(const std::string& map_name)
|
|
{
|
|
auto itr = loader_->block_meta_hash.find(map_name);
|
|
return itr != loader_->block_meta_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
std::list<MetaData::AirDrop>& MetaMgr::GetAirDrops()
|
|
{
|
|
return loader_->airdrop_list;
|
|
}
|
|
|
|
MetaData::AirDrop* MetaMgr::GetAirDrop(int airdrop_id)
|
|
{
|
|
auto itr = loader_->airdrop_hash.find(airdrop_id);
|
|
return itr != loader_->airdrop_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
std::list<MetaData::AirRaid>& MetaMgr::GetAirRaids()
|
|
{
|
|
return loader_->airraid_list;
|
|
}
|
|
|
|
MetaData::AirRaid* MetaMgr::GetAirRaid(int airraid_id)
|
|
{
|
|
auto itr = loader_->airraid_hash.find(airraid_id);
|
|
return itr != loader_->airraid_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::AirLine* MetaMgr::RandAirLine(int map_id)
|
|
{
|
|
auto itr = loader_->airline_hash.find(map_id);
|
|
if (itr != loader_->airline_hash.end()) {
|
|
return !itr->second.empty() ? itr->second.at(rand() % itr->second.size()) : nullptr;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
MetaData::SkillNumber* MetaMgr::GetSkillNumber(int skill_id)
|
|
{
|
|
auto itr = loader_->skill_number_hash.find(skill_id);
|
|
return itr != loader_->skill_number_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Skill* MetaMgr::GetSkill(int skill_id)
|
|
{
|
|
auto itr = loader_->skill_hash.find(skill_id);
|
|
return itr != loader_->skill_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Buff* MetaMgr::GetBuff(int buff_id)
|
|
{
|
|
auto itr = loader_->buff_hash.find(buff_id);
|
|
return itr != loader_->buff_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Attr* MetaMgr::GetAttrById(int attr_id)
|
|
{
|
|
auto itr = loader_->attr_id_hash.find(attr_id);
|
|
return itr != loader_->attr_id_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Attr* MetaMgr::GetAttrByName(const std::string& attr_name)
|
|
{
|
|
auto itr = loader_->attr_name_hash.find(attr_name);
|
|
return itr != loader_->attr_name_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::RankReward* MetaMgr::GetRankReward(int rank)
|
|
{
|
|
auto itr = loader_->rankreward_hash.find(rank);
|
|
return itr != loader_->rankreward_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
float MetaMgr::GetRankRewardParam(int rank)
|
|
{
|
|
auto itr = loader_->rankreward_hash.find(rank);
|
|
return itr != loader_->rankreward_hash.end() ? itr->second->pb->parameter() : 0.0f;
|
|
}
|
|
|
|
float MetaMgr::GetKillRewardParam(int kill_num)
|
|
{
|
|
auto itr = loader_->killreward_hash.find(kill_num);
|
|
return itr != loader_->killreward_hash.end() ? itr->second->pb->parameter() : 0.0f;
|
|
}
|
|
|
|
int MetaMgr::GetRankPointParam1(int rank)
|
|
{
|
|
auto itr = loader_->rankpoint_hash.find(rank);
|
|
return itr != loader_->rankpoint_hash.end() ? itr->second->pb->parameter() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetRankPointParam2(int rank)
|
|
{
|
|
auto itr = loader_->rankpoint_hash.find(rank);
|
|
return itr != loader_->rankpoint_hash.end() ? itr->second->pb->parameter2() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetRankPointParam3(int rank)
|
|
{
|
|
auto itr = loader_->rankpoint_hash.find(rank);
|
|
return itr != loader_->rankpoint_hash.end() ? itr->second->pb->parameter3() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetKillPointParam1(int kill_num)
|
|
{
|
|
auto itr = loader_->killpoint_hash.find(kill_num);
|
|
return itr != loader_->killpoint_hash.end() ? itr->second->pb->parameter() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetKillPointParam2(int kill_num)
|
|
{
|
|
auto itr = loader_->killpoint_hash.find(kill_num);
|
|
return itr != loader_->killpoint_hash.end() ? itr->second->pb->parameter2() : 0;
|
|
}
|
|
|
|
MetaData::Robot* MetaMgr::RandRobot(std::set<int>& refreshed_robot_set)
|
|
{
|
|
int try_count = 0;
|
|
while (true) {
|
|
MetaData::Robot& tmp_robot_meta = loader_->robot_list[rand() % loader_->robot_list.size()];
|
|
if (refreshed_robot_set.find(tmp_robot_meta.pb->id()) == refreshed_robot_set.end()) {
|
|
return &tmp_robot_meta;
|
|
}
|
|
++try_count;
|
|
if (try_count > 3000) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
MetaData::AI* MetaMgr::GetAndroidAI(int ai_level, int ai_mode)
|
|
{
|
|
auto itr = loader_->android_ai_hash.find(a8::MakeInt64(ai_level, ai_mode));
|
|
return itr != loader_->android_ai_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::AI* MetaMgr::GetHeroAI(int id)
|
|
{
|
|
auto itr = loader_->ai_hash.find(id);
|
|
return itr != loader_->ai_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
std::string MetaMgr::GetText(const std::string& textid, const std::string& def_text)
|
|
{
|
|
auto itr = loader_->text_hash.find(textid);
|
|
#if 1
|
|
return itr != loader_->text_hash.end() ? itr->second : "";
|
|
#else
|
|
return itr != loader_->text_hash.end() ? itr->second : def_text;
|
|
#endif
|
|
}
|
|
|
|
bool MetaMgr::HasText(const std::string& textid)
|
|
{
|
|
auto itr = loader_->text_hash.find(textid);
|
|
return itr != loader_->text_hash.end();
|
|
}
|
|
|
|
std::vector<std::tuple<int, std::string>>* MetaMgr::GetTextElements(const std::string& textid)
|
|
{
|
|
auto itr = loader_->text_element_hash.find(textid);
|
|
return itr != loader_->text_element_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::GunTalentGrow* MetaMgr::GetTalent(int talent_id, int talent_lv)
|
|
{
|
|
auto itr = loader_->talent_hash.find(a8::MakeInt64(talent_id, talent_lv));
|
|
return itr != loader_->talent_hash.end() ? itr->second.get() : nullptr;
|
|
}
|
|
|
|
MetaData::Item* MetaMgr::GetItem(int id)
|
|
{
|
|
auto itr = loader_->item_hash.find(id);
|
|
return itr != loader_->item_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::Item* MetaMgr::GetHeroSkin(int hero_id)
|
|
{
|
|
auto itr = loader_->item_heroskin_hash.find(hero_id);
|
|
return itr != loader_->item_heroskin_hash.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::HeroQuality* MetaMgr::GetHeroQuality(int quality)
|
|
{
|
|
auto itr = loader_->hero_quality_hash.find(quality);
|
|
return itr != loader_->hero_quality_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::GunQuality* MetaMgr::GetGunQuality(int quality)
|
|
{
|
|
auto itr = loader_->gun_quality_hash.find(quality);
|
|
return itr != loader_->gun_quality_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::FormulaPvp* MetaMgr::GetFormulaPvp(float ranked_topx)
|
|
{
|
|
MetaData::FormulaPvp* last_meta = nullptr;
|
|
for (auto& meta : loader_->formula_pvp_list) {
|
|
if (ranked_topx <= meta.pb->top()) {
|
|
return &meta;
|
|
}
|
|
}
|
|
return last_meta;
|
|
}
|
|
|
|
MetaData::PveGemini* MetaMgr::GetPveGemini(int gemini_id)
|
|
{
|
|
auto itr = loader_->pve_gemini_hash.find(gemini_id);
|
|
return itr != loader_->pve_gemini_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
std::vector<MetaData::PveGeminiContent>* MetaMgr::GetPveGeminiContents(int mode_id)
|
|
{
|
|
auto itr = loader_->pve_gemini_content_hash.find(mode_id);
|
|
return itr != loader_->pve_gemini_content_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::PveGeminiMode* MetaMgr::GetPveGeminiMode(int mode_id)
|
|
{
|
|
auto itr = loader_->pve_gemini_mode_hash.find(mode_id);
|
|
return itr != loader_->pve_gemini_mode_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
void MetaMgr::CheckMapSpawnPoint()
|
|
{
|
|
for (int i = kDestoryMode; i <= kSurvivalMode; ++i) {
|
|
MetaData::PveGeminiMode* mode_meta = GetPveGeminiMode(i);
|
|
if (!mode_meta) {
|
|
abort();
|
|
}
|
|
auto contents = GetPveGeminiContents(i);
|
|
if (!contents) {
|
|
abort();
|
|
}
|
|
MapInstance* map_instance = MapMgr::Instance()->GetMapInstance(mode_meta->pb->map_id());
|
|
if (!map_instance) {
|
|
abort();
|
|
}
|
|
for (auto& content : *contents) {
|
|
a8::Vec2* p = map_instance->GetSpawnPoint(content.pb->spawn_point());
|
|
if (!p) {
|
|
abort();
|
|
}
|
|
content.spawn_point = *p;
|
|
}
|
|
}
|
|
}
|
|
|
|
MetaData::NpcStandard* MetaMgr::GetNpcStandard(int quality)
|
|
{
|
|
auto itr = loader_->npc_standard_hash.find(quality);
|
|
return itr != loader_->npc_standard_hash.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
MetaData::RankRoom* MetaMgr::GetRoomRank(int id )
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
std::string MetaMgr::GetResDir()
|
|
{
|
|
return loader_->res_path;
|
|
}
|