game2001/server/gameserver/metamgr.cc

#include "precompile.h"

#include <a8/stringlist.h>
#include <a8/csvreader.h>

#include "framework/cpp/utils.h"

#include "metamgr.h"
#include "app.h"

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::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::AirLine> airline_meta_list;
    std::vector<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::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::KillPoint> killpoint_meta_list;
    std::list<MetaData::KillPoint> killpoint_list;
    std::list<metatable::Robot> robot_meta_list;
    std::vector<MetaData::Robot> robot_list;

    std::map<std::string, MetaData::Parameter*> parameter_hash;
    std::map<int, MetaData::Map*> gamemap_hash;
    std::map<int, MetaData::SafeArea*> safearea_hash;
    std::map<int, MetaData::Item*> item_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::vector<MetaData::MapTplThing>> maptpl_hash;
    std::map<int, MetaData::Dress*> dress_hash;
    std::map<int, MetaData::Skill*> skill_hash;
    std::map<int, MetaData::RankReward*> rankreward_hash;
    std::map<int, MetaData::KillReward*> killreward_hash;
    std::map<int, MetaData::KillPoint*> killpoint_hash;
    std::map<int, MetaData::EquipUpgrade*> equipupgrade_hash;
    std::map<int, MetaData::Robot*> robot_hash;

    void Load()
    {
        if (!f8::IsOnlineEnv()) {
            if (App::Instance()->HasFlag(2)) {
                res_path = a8::Format("/root/pub/%d/%d/conf_test/game%d/gameserver/res/",
                                     {
                                      GAME_ID,
                                      App::Instance()->instance_id,
                                      GAME_ID
                                     });
            } else {
                res_path = a8::Format("/var/data/conf_test/game%d/gameserver/res/", {GAME_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 + "item@item.csv", item_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 + "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 + "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 + "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 + "equipUpgrade@equipUpgrade.csv", equipupgrade_meta_list);
        f8::ReadCsvMetaFile(res_path + "robot@robot.csv", robot_meta_list);
        BindToMetaData();
        #if 1
        {
            MetaMgr::Instance()->gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("gas_inactive_time");
            MetaMgr::Instance()->jump_time = MetaMgr::Instance()->GetSysParamAsFloat("jump_time");
            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);
            if (MetaMgr::Instance()->K < 0.01f) {
                abort();
            }
        }
        #endif
    }

private:

    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);
                }
                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;
                }
            }
            #endif
        }

        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;
        }

        for (auto& meta : item_meta_list) {
            MetaData::Item& item = a8::FastAppend(item_list);
            item.i = &meta;
            item_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;
            }
        }

        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;
            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;
        }

        for (auto& meta : airline_meta_list) {
            MetaData::AirLine& item = a8::FastAppend(airline_list);
            item.i = &meta;
            item.Init();
        }

        {
            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;
        }

        for (auto& meta : skill_meta_list) {
            MetaData::Skill& item = a8::FastAppend(skill_list);
            item.i = &meta;
            item.Init();
            skill_hash[item.i->id()] = &item;
        }

       for (auto& meta : rankreward_meta_list) {
            MetaData::RankReward& item = a8::FastAppend(rankreward_list);
            item.i = &meta;
            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 : equipupgrade_meta_list) {
           MetaData::EquipUpgrade& item = a8::FastAppend(equipupgrade_list);
           item.i = &meta;
           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;
       }

    }

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;
}

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;
}

std::vector<MetaData::MapTplThing>* MetaMgr::GetMapTplThing(std::string& map_name)
{
    auto itr = loader_->maptpl_hash.find(map_name);
    return itr != loader_->maptpl_hash.end() ? &itr->second : nullptr;
}

std::list<MetaData::AirDrop>& MetaMgr::GetAirDrops()
{
    return loader_->airdrop_list;
}

MetaData::AirLine* MetaMgr::RandAirLine()
{
    if (loader_->airline_list.empty()) {
        abort();
    }
    return &loader_->airline_list[rand() % loader_->airline_list.size()];
}

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::Dress* MetaMgr::GetDress(int dress_id)
{
    auto itr = loader_->dress_hash.find(dress_id);
    return itr != loader_->dress_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->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::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;
}

std::vector<MetaData::Robot>* MetaMgr::GetRobotList()
{
    return &loader_->robot_list;
}

MetaData::Robot* MetaMgr::GetRobot(int robot_id)
{
    auto itr = loader_->robot_hash.find(robot_id);
    return itr != loader_->robot_hash.end() ? itr->second : nullptr;
}