game2006/server/gameserver/custom_battle.cc

#include "precompile.h"

#include "custom_battle.h"
#include "custom_team.h"
#include "custom_member.h"
#include "netdata.h"

#include "mt/Map.h"

void CustomBattle::Init()
{
    ob_team_ = std::make_shared<CustomTeam>();
    ob_team_->team_uuid_ = "";
    ob_team_->is_view_ = true;
}

void CustomBattle::UnInit()
{

}

void CustomBattle::ParseResult(a8::XObject& obj)
{
    if (!obj.HasKey("errcode")) {
        parse_ok_ = false;
        return;
    }
    room_id_ = obj.Get("room_id").GetString();
    room_uuid_ = obj.Get("room_uuid").GetString();
    zone_id_ = obj.Get("zone_id");
    node_id_ = obj.Get("node_id");
    map_id_ = obj.Get("map_id");
    start_time_ = obj.Get("start_time");
    sign_ = obj.Get("sign").GetString();
    const mt::Map* map_meta = mt::Map::GetById(map_id_);
    if (!map_meta || !map_meta->IsOpen()) {
        parse_ok_ = false;
        return;
    }
    {
        is_moba_ = map_meta->is_moba() ? true : false;
    }
    {
        auto team_list = obj.At("team_list");
        if (!team_list || !team_list->IsArray()) {
            parse_ok_ = false;
            return;
        }
        for (int i = 0;i < team_list->Size(); ++i) {
            auto team_obj = team_list->At(i);
            if (!team_obj || !team_obj->IsObject()) {
                parse_ok_ = false;
                return;
            }
            std::string team_uuid = team_obj->Get("team_uuid").GetString();
            int is_view = team_obj->Get("is_view").GetInt();
            auto member_list = team_obj->At("members");
            if (!member_list ||
                !member_list->IsArray()) {
                parse_ok_ = false;
                return;
            }
            auto team = GetTeamByTeamUuid(team_uuid);
            if (!team) {
                team = std::make_shared<CustomTeam>();
                team->team_uuid_ = team_uuid;
                team->is_view_ = false;
                uuid_hash_[team->team_uuid_] = team;
            }
            for (int ii = 0; ii < member_list->Size(); ++ii) {
                auto member_obj = member_list->At(ii);
                if (!member_obj || !member_obj->IsObject()) {
                    parse_ok_ = false;
                    return;
                }
                auto member = std::make_shared<CustomMember>();
                member->team_ = team.get();
                member->account_id_ = member_obj->Get("account_id").GetString();
#ifdef MYDEBUG1
                if (IsMoba()) {
                    member->account_id_ = member->account_id_ + "$$$$";
                }
#endif
                member->session_id_ = member_obj->Get("session_id").GetString();
                member->name_ = member_obj->Get("name").GetString();
                member->sex_ = member_obj->Get("sex");
                member->battle_context_ = std::make_shared<BattleDataContext>();
                member->battle_context_->ParseResult(*member_obj);
                if (!member->battle_context_->parse_ok) {
                    parse_ok_ = false;
                    return;
                }
                member_id_hash_[member->account_id_] = member;
                team->member_hash_[member->account_id_] = member;
                account_hash_[member->account_id_] = team;
#ifdef MYDEBUG1
                if (IsMoba()) {
                    auto member = std::make_shared<CustomMember>();
                    member->team_ = ob_team_.get();
                    member->account_id_ = member_obj->Get("account_id").GetString();
                    member->session_id_ = member_obj->Get("session_id").GetString();
                    member->name_ = member_obj->Get("name").GetString();
                    member->sex_ = member_obj->Get("sex");
                    member->battle_context_ = std::make_shared<BattleDataContext>();
                    member->battle_context_->ParseResult(*member_obj);
                    if (!member->battle_context_->parse_ok) {
                        parse_ok_ = false;
                        return;
                    }
                    account_hash_[member->account_id_] = ob_team_;
                    ob_id_hash_[member->account_id_] = member;
                }
#endif
            }
        }
    }
    {
        auto ob_list = obj.At("ob_list");
        if (ob_list && ob_list->IsArray()) {
            for (int i = 0; i < ob_list->Size(); ++i) {
                auto member_obj = ob_list->At(i);
                if (!member_obj || !member_obj->IsObject()) {
                    parse_ok_ = false;
                    return;
                }
                auto member = std::make_shared<CustomMember>();
                member->team_ = ob_team_.get();
                member->account_id_ = member_obj->Get("account_id").GetString();
                member->session_id_ = member_obj->Get("session_id").GetString();
                member->name_ = member_obj->Get("name").GetString();
                member->sex_ = member_obj->Get("sex");
                member->battle_context_ = std::make_shared<BattleDataContext>();
                member->battle_context_->ParseResult(*member_obj);
                if (!member->battle_context_->parse_ok) {
                    parse_ok_ = false;
                    return;
                }
                account_hash_[member->account_id_] = ob_team_;
                ob_id_hash_[member->account_id_] = member;
            }
        }
    }

    raw_data_ = std::make_shared<a8::XObject>();
    obj.DeepCopy(*raw_data_);
    parse_ok_ = true;
}

std::shared_ptr<CustomMember> CustomBattle::GetMemberByAccountId(const std::string& account_id)
{
    auto itr = member_id_hash_.find(account_id);
    return itr != member_id_hash_.end() ? itr->second : nullptr;
}

std::shared_ptr<CustomTeam> CustomBattle::GetTeamByAccountId(const std::string& account_id)
{
    auto itr = account_hash_.find(account_id);
    return itr != account_hash_.end() ? itr->second : nullptr;
}

std::shared_ptr<CustomTeam> CustomBattle::GetTeamByTeamUuid(const std::string& team_uuid)
{
    auto itr = uuid_hash_.find(team_uuid);
    return itr != uuid_hash_.end() ? itr->second : nullptr;
}

bool CustomBattle::AllIsJoined()
{
    bool ok = true;
    for (auto& pair : member_id_hash_) {
        if (!pair.second->IsJoined()) {
            ok = false;
            break;
        }
    }
    return ok;
}

int CustomBattle::GetMemberNum()
{
    return member_id_hash_.size();
}

int CustomBattle::GetTeamNum()
{
    return uuid_hash_.size();
}

void CustomBattle::TraverseMemberList(std::function<bool (CustomMember*)> func)
{
    for (auto& pair : member_id_hash_) {
        if (!func(pair.second.get())) {
            break;
        }
    }
}

void CustomBattle::TraverseTeamList(std::function<bool (std::shared_ptr<CustomTeam>)> cb)
{
    for (auto& pair : uuid_hash_) {
        if (!cb(pair.second)) {
            break;
        }
    }
}

std::shared_ptr<CustomMember> CustomBattle::GetObByAccountId(const std::string& account_id)
{
    auto itr = ob_id_hash_.find(account_id);
    return itr != ob_id_hash_.end() ? itr->second : nullptr;
}

void CustomBattle::TraverseObList(std::function<bool (std::shared_ptr<CustomMember>)> cb)
{
    for (auto& pair : ob_id_hash_) {
        if (!cb(pair.second)) {
            break;
        }
    }
}

RoomMode_e CustomBattle::GetRoomMode()
{
    if (IsMoba()) {
        return kMobaMode;
    } else {
        return kPvpMode;
    }
}