1221 lines
47 KiB
C++
1221 lines
47 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 "framework/cpp/utils.h"
|
|
|
|
#include "metamgr.h"
|
|
#include "app.h"
|
|
#include "jsondatamgr.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();
|
|
|
|
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);
|
|
a8::UdpLog::Instance()->Info
|
|
("load textid:%s %s",
|
|
{
|
|
textid,
|
|
obj->ToJsonStr()
|
|
}
|
|
);
|
|
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::Dress> dress_meta_list;
|
|
std::list<MetaData::Dress> dress_list;
|
|
std::list<metatable::Skill> skill_meta_list;
|
|
std::list<MetaData::Skill> skill_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::EquipUpgrade> equipupgrade_meta_list;
|
|
std::list<MetaData::EquipUpgrade> equipupgrade_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::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::Dress*> dress_hash;
|
|
std::vector<MetaData::Dress*> dress_vec;
|
|
std::map<int, MetaData::Skill*> skill_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::EquipUpgrade*> equipupgrade_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<std::string, std::vector<std::tuple<int, std::string>>> text_element_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/";
|
|
}
|
|
|
|
f8::ReadCsvMetaFile(res_path + "parameter@parameter.csv", parameter_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "map@map.csv", map_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "safearea@safearea.csv", safearea_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "safearea_pos@safearea_pos.csv", safearea_pos_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "item@item.csv", item_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "buff@buff.csv", buff_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "equip@equip.csv", equip_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "player@player.csv", player_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "mapThing@mapThing.csv", mapthing_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "drop@drop.csv", drop_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "airdrop@airdrop.csv", airdrop_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "airraid@airraid.csv", airraid_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "airline@airline.csv", airline_meta_list);
|
|
f8::ReadJsonMetaFile(res_path + "maps.json", building_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "dress@dress.csv", dress_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "skill@skill.csv", skill_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "attr@attr.csv", attr_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "rankReward@rankReward.csv", rankreward_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "killReward@killReward.csv", killreward_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "killPoint@killPoint.csv", killpoint_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "rankPoint@rankPoint.csv", rankpoint_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "equipUpgrade@equipUpgrade.csv", equipupgrade_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "robot@robot.csv", robot_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "ai@ai.csv", ai_meta_list);
|
|
f8::ReadCsvMetaFile(res_path + "text@text.csv", text_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");
|
|
{
|
|
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_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
|
|
Check();
|
|
}
|
|
|
|
private:
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
void BindToMetaData()
|
|
{
|
|
|
|
for (auto& meta : parameter_meta_list) {
|
|
MetaData::Parameter& item = a8::FastAppend(parameter_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
parameter_hash[item.i->param_name()] = &item;
|
|
}
|
|
|
|
{
|
|
for (auto& meta : map_meta_list) {
|
|
MetaData::Map& item = a8::FastAppend(map_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
gamemap_hash[item.i->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.i = &itr;
|
|
thing.Init();
|
|
}
|
|
maptpl_hash[pair.first] = things;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : safearea_meta_list) {
|
|
MetaData::SafeArea& item = a8::FastAppend(safearea_list);
|
|
item.i = &meta;
|
|
if (App::Instance()->HasFlag(7)) {
|
|
meta.set_wait_time(3);
|
|
meta.set_shrink_speed(500);
|
|
}
|
|
safearea_hash[item.i->id()] = &item;
|
|
if (safearea_type_hash.find(item.i->type()) == safearea_type_hash.end()) {
|
|
safearea_type_hash[item.i->type()] = &item;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : safearea_pos_meta_list) {
|
|
MetaData::SafeAreaPos& item = a8::FastAppend(safearea_pos_list);
|
|
item.i = &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.i = &meta;
|
|
item.Init();
|
|
if (buff_hash.find(item.i->buff_id()) != buff_hash.end()) {
|
|
A8_ABORT();
|
|
}
|
|
buff_hash[item.i->buff_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : item_meta_list) {
|
|
MetaData::Item& item = a8::FastAppend(item_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
item_hash[item.i->id()] = &item;
|
|
if (meta.playerid()) {
|
|
item_heroskin_hash[item.i->id()] = &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.i = &meta;
|
|
item.Init();
|
|
equip_hash[item.i->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.i = &meta;
|
|
item.Init();
|
|
player_hash[item.i->id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : mapthing_meta_list) {
|
|
MetaData::MapThing& item = a8::FastAppend(mapthing_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
mapthing_hash[item.i->thing_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : drop_meta_list) {
|
|
MetaData::Drop& item = a8::FastAppend(drop_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
drop_hash[item.i->drop_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : airdrop_meta_list) {
|
|
MetaData::AirDrop& item = a8::FastAppend(airdrop_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
airdrop_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : airraid_meta_list) {
|
|
MetaData::AirRaid& item = a8::FastAppend(airraid_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
airraid_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : airline_meta_list) {
|
|
MetaData::AirLine& item = a8::FastAppend(airline_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
{
|
|
auto itr = airline_hash.find(item.i->map_id());
|
|
if (itr != airline_hash.end()) {
|
|
itr->second.push_back(&item);
|
|
} else {
|
|
airline_hash[item.i->map_id()] = std::vector<MetaData::AirLine*>({&item});
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
for (auto& meta : building_meta_list) {
|
|
MetaData::Building& item = a8::FastAppend(building_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
building_hash[item.i->mapid()] = &item;
|
|
}
|
|
}
|
|
|
|
for (auto& meta : dress_meta_list) {
|
|
MetaData::Dress& item = a8::FastAppend(dress_list);
|
|
item.i = &meta;
|
|
dress_hash[item.i->id()] = &item;
|
|
dress_vec.push_back(&item);
|
|
}
|
|
|
|
for (auto& meta : attr_meta_list) {
|
|
MetaData::Attr& item = a8::FastAppend(attr_list);
|
|
item.i = &meta;
|
|
attr_id_hash[item.i->attr_id()] = &item;
|
|
attr_name_hash[item.i->attr_ename()] = &item;
|
|
}
|
|
|
|
for (auto& meta : skill_meta_list) {
|
|
MetaData::Skill& item = a8::FastAppend(skill_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
skill_hash[item.i->skill_id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : rankreward_meta_list) {
|
|
MetaData::RankReward& item = a8::FastAppend(rankreward_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
rankreward_hash[item.i->rank()] = &item;
|
|
}
|
|
|
|
for (auto& meta : killreward_meta_list) {
|
|
MetaData::KillReward& item = a8::FastAppend(killreward_list);
|
|
item.i = &meta;
|
|
killreward_hash[item.i->kill_num()] = &item;
|
|
}
|
|
|
|
for (auto& meta : killpoint_meta_list) {
|
|
MetaData::KillPoint& item = a8::FastAppend(killpoint_list);
|
|
item.i = &meta;
|
|
killpoint_hash[item.i->kill_num()] = &item;
|
|
}
|
|
|
|
for (auto& meta : rankpoint_meta_list) {
|
|
MetaData::RankPoint& item = a8::FastAppend(rankpoint_list);
|
|
item.i = &meta;
|
|
rankpoint_hash[item.i->rank()] = &item;
|
|
}
|
|
|
|
for (auto& meta : equipupgrade_meta_list) {
|
|
MetaData::EquipUpgrade& item = a8::FastAppend(equipupgrade_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
equipupgrade_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : robot_meta_list) {
|
|
MetaData::Robot& item = a8::FastAppend(robot_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
robot_hash[meta.id()] = &item;
|
|
}
|
|
|
|
for (auto& meta : ai_meta_list) {
|
|
MetaData::AI& item = a8::FastAppend(ai_list);
|
|
item.i = &meta;
|
|
item.Init();
|
|
ai_hash[item.i->id()] = &item;
|
|
if (item.i->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;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
|
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::EquipUpgrade* MetaMgr::GetEquipUpgrade(int equip_id)
|
|
{
|
|
auto itr = loader_->equipupgrade_hash.find(equip_id);
|
|
return itr != loader_->equipupgrade_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::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::Dress* MetaMgr::GetDress(int dress_id)
|
|
{
|
|
auto itr = loader_->dress_hash.find(dress_id);
|
|
return itr != loader_->dress_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;
|
|
}
|
|
|
|
MetaData::Dress* MetaMgr::RandDress()
|
|
{
|
|
if (loader_->dress_vec.empty()) {
|
|
return nullptr;
|
|
}
|
|
return loader_->dress_vec[rand() % loader_->dress_vec.size()];
|
|
}
|
|
|
|
float MetaMgr::GetRankRewardParam(int rank)
|
|
{
|
|
auto itr = loader_->rankreward_hash.find(rank);
|
|
return itr != loader_->rankreward_hash.end() ? itr->second->i->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->i->parameter() : 0.0f;
|
|
}
|
|
|
|
int MetaMgr::GetRankPointParam1(int rank)
|
|
{
|
|
auto itr = loader_->rankpoint_hash.find(rank);
|
|
return itr != loader_->rankpoint_hash.end() ? itr->second->i->parameter() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetRankPointParam2(int rank)
|
|
{
|
|
auto itr = loader_->rankpoint_hash.find(rank);
|
|
return itr != loader_->rankpoint_hash.end() ? itr->second->i->parameter2() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetRankPointParam3(int rank)
|
|
{
|
|
auto itr = loader_->rankpoint_hash.find(rank);
|
|
return itr != loader_->rankpoint_hash.end() ? itr->second->i->parameter3() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetKillPointParam1(int kill_num)
|
|
{
|
|
auto itr = loader_->killpoint_hash.find(kill_num);
|
|
return itr != loader_->killpoint_hash.end() ? itr->second->i->parameter() : 0;
|
|
}
|
|
|
|
int MetaMgr::GetKillPointParam2(int kill_num)
|
|
{
|
|
auto itr = loader_->killpoint_hash.find(kill_num);
|
|
return itr != loader_->killpoint_hash.end() ? itr->second->i->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.i->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);
|
|
return itr != loader_->text_hash.end() ? itr->second : def_text;
|
|
}
|
|
|
|
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::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;
|
|
}
|