#include "precompile.h"

#include <a8/mutable_xobject.h>

#include <f8/btmgr.h>

#include "team.h"

#include "human.h"
#include "room.h"
#include "app.h"
#include "bornpoint.h"
#include "netdata.h"
#include "stats.h"
#include "jsondatamgr.h"
#include "httpproxy.h"
#include "roommgr.h"

#include "mt/Param.h"
#include "mt/Map.h"
#include "mt/MapMode.h"
#include "mt/Hero.h"
#include "mt/PveGemini.h"
#include "mt/PveGeminiMode.h"
#include "mt/PveGeminiContent.h"

Team::Team()
{
    battle_uuid_ = f8::App::Instance()->NewGlobalUuid();
}

Team::~Team()
{
}

void Team::TraverseMembers(std::function<bool (Human*)> func)
{
    for (Human* member : members_) {
        if (!func(member)) {
            break;
        }
    }
}

void Team::GetOveredHumans(std::set<Human*>& overed_humans)
{
    for (Human* member : members_) {
        if (member->real_dead) {
            overed_humans.insert(member);
        }
    }
}

Human* Team::GetOneAliveMember(Human* exclude_hum)
{
    for (Human* member : members_) {
        if (member != exclude_hum && !member->dead) {
            return member;
        }
    }
    return nullptr;
}

Human* Team::RandomOneAliveMember(Human* exclude_hum)
{
    std::vector<Human*> humans;
    for (Human* member : members_) {
        if (member != exclude_hum && !member->dead) {
            humans.push_back(member);
        }
    }
    if (!humans.empty()) {
        std::random_shuffle(humans.begin(), humans.end());
        return humans.at(0);
    }
    return nullptr;
}

bool Team::HasAliveMember()
{
    for (Human* member : members_) {
        if (!member->real_dead) {
            return true;
        }
    }
    return false;
}

void Team::AddMember(Human* member)
{
    if (!first_member_) {
        first_member_ = member;
        init_team_member_num_ = member->init_team_member_num;
        combined_team_member_num_ = member->init_team_member_num;
    }
    member->team_id = team_id_;
    member->SetTeam(this);
    members_.insert(member);
    if (member->GetFollowTimes() <= 0 && member != first_member_ && !member->follow_target.Get()) {
        member->DoFollow(first_member_->GetUniId());
    }
    if (!target_pos.empty()) {
        member->NotifyTeamMarkTargetPos();
    }
}

bool Team::IsFull()
{
    return GetMemberNum() >= room->GetMaxTeamNum();
}

int Team::GetAliveNum()
{
    int num = 0;
    for (Human* member : members_) {
        if (!member->real_dead) {
            ++num;
        }
    }
    return num;
}

void Team::CombineTeam(Team* b_team)
{
    b_team->TraverseMembers
        (
         [this] (Human* member) -> bool
         {
             AddMember(member);
             return true;
         });
}

Human* Team::GetMemberByUniId(int member_id)
{
    for (Human* member : members_) {
        if (member->GetUniId() == member_id) {
            return member;
        }
    }
    return nullptr;
}

bool Team::CanCombine(Human* member)
{
    return !IsFull() && (combined_team_member_num_ + member->init_team_member_num < room->GetMaxTeamNum());
}

void Team::AddCombineMemberNum(int member_num)
{
    combined_team_member_num_ += member_num;
}

bool Team::HasReviveCoin(Human* member)
{
    for (Human* member : members_) {
        if (member->GetNetData()->GetReviveCoin() > 0) {
            return true;
        }
    }
    return false;
}

bool Team::IsFreeTeam()
{
    if (members_.size() == 1) {
        for (Human* member : members_) {
            if (member->IsAndroid()) {
                return true;
            }
        }
    }
    return false;
}

bool Team::HasPlayer()
{
    for (Human* member : members_) {
        if (member->IsPlayer()) {
            return true;
        }
    }
    return false;
}

void Team::SendTeamBattleReport(Human* sender)
{
    Human* player = nullptr;
    for (Human* hum : members_) {
        if (hum->IsPlayer()) {
            player = hum;
            break;
        }
    }
    if (!player) {
        return;
    }
    if (AllIsRunAway()) {
        return;
    }
    if (room->GetBattleStartFrameNo() <= 0) {
        return;
    }
    if (IsViewTeam()) {
        return;
    }
    std::shared_ptr<a8::MutableXObject> post_data = a8::MutableXObject::CreateObject();
    GenBattleReportData(post_data.get());
#ifdef MYDEBUG
    a8::XPrintf("SendTeamBattleReport:%s\n", {post_data->ToJsonStr()});
#endif
    std::string url;
    JsonDataMgr::Instance()->GetApiUrl(url);
    std::shared_ptr<a8::MutableXObject> params = a8::MutableXObject::CreateObject();
    params->SetVal("c", "Battle");
    params->SetVal("a", "teamReport");
    params->SetVal("account_id", player->account_id);
    params->SetVal("session_id", player->session_id);
    //params->SetVal("__POST", post_data->ToJsonStr());

    std::string room_uuid = room->GetRoomUuid();
    int team_id = GetTeamId();
    if (room->GetCustomBattle()) {
        already_report_battle_ = true;
        sending_battlereport_ = false;
        TraverseMembers
            (
             [] (Human* hum)
             {
                 hum->SendGameOver();
                 return true;
             });
        return;
    }
    HttpProxy::Instance()->HttpPost
        (
         [room_uuid, team_id]
         (bool ok, a8::XObject* rsp_obj, f8::HttpContext* ctx)
         {
             auto room = RoomMgr::Instance()->GetRoomByUuid(room_uuid);
             if (room) {
                 Team* team = room->GetTeam(team_id);
                 if (team) {
                     if (ok) {
                         team->already_report_battle_ = true;
                         team->sending_battlereport_ = false;
                         team->TraverseMembers
                             (
                              [] (Human* hum)
                              {
                                  hum->SendGameOver();
                                  return true;
                              });
                     } else {
                         team->already_report_battle_ = false;
                         team->sending_battlereport_ = false;
                         team->TraverseMembers
                             (
                              [] (Human* hum)
                              {
                                  hum->SendGameOver();
                                  return true;
                              });
                     }
                 }
             }
         },
         url,
         params,
         post_data->ToJsonStr()
         );
}

void Team::GenBattleReportData(a8::MutableXObject* params)
{
    params->SetVal("version", 2023030201);
    params->SetVal("is_newbie_battle", a8::XValue(room->IsNewBieBattle()));
    params->SetVal("battle_uuid", a8::XValue(battle_uuid_));
    params->SetVal("room_uuid", a8::XValue(room->GetRoomUuid()));
    params->SetVal("room_mode", room->GetReportRoomMode());
    params->SetVal("team_id", GetTeamId());
    params->SetVal("team_mode", 1);
    params->SetVal("map_mode_id", room->GetMapModeMeta()->id());
    params->SetVal("map_mode", room->GetReportMapMode());
    params->SetVal("map_id", room->GetMapMeta()->map_id());
    if (room->IsPveRoom()) {
        params->SetVal("victory", room->pve_data.pve_kill_boss == 1 ? 1 : 0);
    } else {
        params->SetVal("victory", team_rank == 1 ? 1 : 0);
    }

    if (room->IsPveRoom()) {
        params->SetVal("pve_settelement_type", 1);
        params->SetVal("pve_instance_id", room->pve_instance->gemini_id());
        params->SetVal("pve_wave", room->pve_data.GetPassedWave());
        params->SetVal("pve_max_wave", room->pve_data.max_wave);
    } else {
        params->SetVal("pvp_settelement_type", 1);
        params->SetVal("pvp_settelement_color", settlement_color);
        params->SetVal("pvp_team_rank", team_rank);
        params->SetVal("pvp_total_human_num", room->GetHumanNum());
        params->SetVal("pvp_alive_human_num", room->AliveCount());
        params->SetVal("pvp_total_team_num", room->GetTeamNum());
        params->SetVal("pvp_match_mode", room->GetPvpMatchMode());
        params->SetVal("pvp_team_kills", 0); //
    }

    {
        auto teams_pb = a8::MutableXObject::CreateArray();
        room->TraverseTeams
            (
             [teams_pb] (Team* team)
             {
                 auto members_pb = a8::MutableXObject::CreateArray();
                 team->TraverseMembers
                     (
                      [members_pb] (Human* hum)
                      {
                          auto member_pb = a8::MutableXObject::CreateObject();
                          member_pb->SetVal("account_id", hum->account_id);
                          members_pb->Push(*member_pb);
                          return true;
                      });
                 auto team_pb = a8::MutableXObject::CreateObject();
                 team_pb->SetVal("team_id", team->GetTeamId());
                 team_pb->SetVal("members", *members_pb);
                 teams_pb->Push(*team_pb);
                 return true;
             });
        params->SetVal("team_list", *teams_pb);
    }

    {
        int pvp_team_kills = 0;

        auto members_pb = a8::MutableXObject::CreateArray();
        std::vector<Human*> sorted_members;
        TraverseMembers
            (
             [&sorted_members] (Human* hum) mutable
             {
                 sorted_members.push_back(hum);
                 return true;
             }
             );
        if (room->IsPveRoom()) {
            std::sort(sorted_members.begin(), sorted_members.end(),
                      [] (Human* a, Human* b) -> bool
                      {
                          if (a->stats->pve_rank_score > b->stats->pve_rank_score) {
                              return true;
                          }
                          if (a->stats->pve_rank_score < b->stats->pve_rank_score) {
                              return false;
                          }
                          return a->GetUniId() < b->GetUniId();
                      });
        }
        int i = 0;
        for (Human* hum : sorted_members) {
            ++i;
            pvp_team_kills += hum->stats->kills;

            auto member_pb = a8::MutableXObject::CreateObject();
            member_pb->SetVal("account_id", hum->account_id);
            member_pb->SetVal("match_room_uuid", hum->match_room_uuid);
            member_pb->SetVal("name", hum->name);
            member_pb->SetVal("head", a8::XValue(hum->avatar_url));
            member_pb->SetVal("head_frame", hum->head_frame);
            member_pb->SetVal("sex", hum->sex);
            member_pb->SetVal("dead", hum->dead);
            member_pb->SetVal("dead_times", hum->stats->dead_times);
            member_pb->SetVal("is_mvp", 0);
            if (hum->GetNetData()->GetSkinId() != 0) {
                member_pb->SetVal("skin_id", hum->GetNetData()->GetSkinId());
            } else {
                member_pb->SetVal("skin_id", 0);
            }
            member_pb->SetVal("move_distance", hum->stats->move_distance);
            member_pb->SetVal("full_level_idx", hum->stats->full_level_idx);
            member_pb->SetVal("hero_level", hum->GetHeroLevel());
            member_pb->SetVal("is_run_away", hum->stats->is_run_away);

            member_pb->SetVal("hero_id", hum->meta->id());
            member_pb->SetVal("hero_uniid", hum->hero_uniid);
            //member_pb->SetVal("hero_quality", hum->hero_uniid);
            member_pb->SetVal("game_time", hum->stats->game_time);
            member_pb->SetVal("game_duration", hum->stats->game_duration);
            member_pb->SetVal("alive_time", hum->stats->alive_time);
            member_pb->SetVal("ranked", hum->stats->rank);
            member_pb->SetVal("kills", hum->stats->kills);
            member_pb->SetVal("damage_out", hum->stats->damage_amount_out);
            member_pb->SetVal("weapon_uuid1", hum->spec_weapons.size() > 0 ? hum->spec_weapons[0].weapon_uniid : 0);
            member_pb->SetVal("weapon_uuid2", hum->spec_weapons.size() > 1 ? hum->spec_weapons[1].weapon_uniid : 0);
            member_pb->SetVal("rescue_teammate_times", hum->stats->rescue_member);
            member_pb->SetVal("diving_times", hum->stats->diving_times);
            member_pb->SetVal("damage_in", hum->stats->damage_amount_in);
            member_pb->SetVal("recover_hp", hum->stats->heal_amount);
            member_pb->SetVal("open_airdrop_times", hum->stats->open_airdrop_times);
            member_pb->SetVal("use_medicine_times", hum->stats->use_medicine_times);
            member_pb->SetVal("destory_car_times", hum->stats->destory_car_times);
            member_pb->SetVal("use_camouflage_times", hum->stats->use_camouflage_times);
            member_pb->SetVal("use_skill_times", hum->stats->use_skill_times);
            member_pb->SetVal("ride_car_move_distance", hum->stats->ride_car_move_distance);
            member_pb->SetVal("ride_car_kills", hum->stats->ride_car_kills);
            member_pb->SetVal("max_hero_skill_lv", hum->stats->max_hero_skill_lv);
            member_pb->SetVal("abandon_battle", hum->stats->abandon_battle);
            member_pb->SetVal("assist", hum->stats->assist);
            member_pb->SetVal("box_num", hum->box_num);
            {
                std::string weapons_type;
                std::string weapons_slot;
                for (auto& pair : hum->stats->weapon_stats) {
                    auto& weapon = pair.second;
                    if (weapon.kills || weapon.damage_out || weapon.obtain_count) {
                        weapons_type += a8::Format("%d:%d:%d:%d|",
                                                   {
                                                    weapon.weapon_id,
                                                    weapon.kills,
                                                    weapon.damage_out,
                                                    weapon.obtain_count
                                                   });
                    }
                    if (weapon.use_times) {
                        weapons_slot += a8::Format("%d:%d|",
                                                   {
                                                    weapon.weapon_id,
                                                    weapon.use_times
                                                   });
                    }
                }
                member_pb->SetVal("weapons_type", weapons_type);
                member_pb->SetVal("weapons_slot", weapons_slot);
            }
            {
                std::string heros;
                for (auto& pair : hum->stats->hero_stats) {
                    auto& hero = pair.second;
                    if (hero.skill_lv || hero.weapon_lv) {
                        heros += a8::Format("%d:%d:%d|",
                                            {
                                             hero.hero_id,
                                             hero.skill_lv,
                                             hero.weapon_lv,
                                            });
                    }
                }
                member_pb->SetVal("heros", heros);
            }
            if (room->IsPveRoom()) {
                member_pb->SetVal("pve_order", i);
                member_pb->SetVal("pve_score", hum->stats->pve_rank_score);
                member_pb->SetVal("pve_star", room->pve_mode_meta->CalcStar(hum->stats->pve_rank_score));
                member_pb->SetVal("pve_damage", hum->stats->damage_amount_out);
                member_pb->SetVal("pve_revive", hum->stats->revive);
                member_pb->SetVal("pve_survia_time", hum->stats->alive_time);
                member_pb->SetVal("pve_wave", hum->stats->pve_wave);
                member_pb->SetVal("pve_max_wave", room->pve_data.max_wave);
                member_pb->SetVal("pve_boss_killed", hum->stats->pve_kill_boss);
                member_pb->SetVal("pve_rank_score", hum->stats->pve_rank_score);
            } else if (room->IsMobaModeRoom()) {
                member_pb->SetVal("pvp_kill", hum->stats->kills);
                member_pb->SetVal("pvp_damage", hum->stats->damage_amount_out);
                member_pb->SetVal("pvp_assist", hum->stats->assist);
                member_pb->SetVal("pvp_survia_time", hum->stats->alive_time);
                member_pb->SetVal("pvp_recover", hum->stats->heal_amount);
                member_pb->SetVal("pvp_rescue", hum->stats->rescue_member);
                member_pb->SetVal("pvp_personal_rank", hum->stats->rank);
            } else {
                member_pb->SetVal("pvp_kill", hum->stats->kills);
                member_pb->SetVal("pvp_damage", hum->stats->damage_amount_out);
                member_pb->SetVal("pvp_assist", hum->stats->assist);
                member_pb->SetVal("pvp_survia_time", hum->stats->alive_time);
                member_pb->SetVal("pvp_recover", hum->stats->heal_amount);
                member_pb->SetVal("pvp_rescue", hum->stats->rescue_member);
                member_pb->SetVal("pvp_personal_rank", hum->stats->rank);
            }
            members_pb->Push(*member_pb);
        };
        params->SetVal("members", *members_pb);
        if (room->IsMobaModeRoom()) {
            params->SetVal("moba_my_team_kills", GetKillCount());
            if (room->GetMobaTeamA() == this) {
                params->SetVal("moba_enemy_team_kills", room->GetMobaTeamB()->GetKillCount());
            } else {
                params->SetVal("moba_enemy_team_kills", room->GetMobaTeamA()->GetKillCount());
            }
        }
        params->SetVal("pvp_team_kills", pvp_team_kills);
    }

}

void Team::RunAway(Human* hum)
{

}

bool Team::AllIsRunAway()
{
    for (Human* hum : members_) {
        if (!hum->stats->is_run_away) {
            return false;
        }
    }
    return true;
}

int Team::GetKillCount()
{
    return kill_count_;
}

void Team::IncKillCount()
{
    if (room->IsMobaModeRoom()) {
        if (room->GetVictoryTeam()) {
            return;
        }
    }
    #if 0
    if (room->IsMobaModeRoom() && kill_count_ + 1 >= mt::Param::s().moba_kill_times) {
        room->SetVictoryTeam(this);
        room->xtimer.SetTimeoutWpEx
            (NEXT_FRAME_TIMER,
             [this] (int event, const a8::Args* args)
             {
                 if (a8::TIMER_EXEC_EVENT == event) {
                     if (!room->IsGameOver()) {
                         room->game_over_ = true;
                         room->game_over_frameno_ = room->GetFrameNo();
                         room->OnGameOver();
                     }
                 }
             },
             &room->xtimer_attacher_);
    }
    #endif
    ++kill_count_;
    last_kill_frameno_ = room->GetFrameNo();
    if (room->IsMobaModeRoom() && room->GetMobaOvertimeRaceFrameNo() > 0) {
        room->MobaOver();
        TraverseMembers
            (
             [] (Human* hum) -> bool
             {
                 hum->SendUIUpdate();
                 return true;
             });
    }
}

int Team::GetAlivePlayerNum()
{
    int num = 0;
    for (Human* member : members_) {
        if (member->IsPlayer() && !member->dead) {
            ++num;
        }
    }
    return num;
}

int Team::GetPlayerNum()
{
    int num = 0;
    for (Human* member : members_) {
        if (member->IsPlayer()) {
            ++num;
        }
    }
    return num;
}

void Team::RemoveMember(Human* member)
{
    members_.erase(member);
    first_member_ = nullptr;
    for (auto hum : members_) {
        first_member_ = hum;
    }
}

bool Team::MemberHasOb()
{
    if (IsViewTeam()) {
        return false;
    }
    bool has = false;
    TraverseMembers
        (
         [&has] (Human* ele_hum) -> bool
         {
             ele_hum->TraverseObservers
                 (
                  [&has] (Human* ele_hum, bool& stop)
                  {
                      if (ele_hum->IsOb()) {
                          has = true;
                          stop = true;
                      }
                  });
             if (has) {
                 return false;
             }
             return true;
         });
    return has;
}

bool Team::AllIsDead()
{
    for (Human* hum : members_) {
        if (!hum->dead) {
            return false;
        }
    }
    return true;
}

void Team::TrySendTeamBattleReport(Human* sender)
{
    if (!sending_battlereport_ && !already_report_battle_) {
        if (room->IsMobaModeRoom()) {
        } else {
            sending_battlereport_ = true;
            SendTeamBattleReport(sender);
        }
    }
}

void Team::GenRoomReportData(a8::MutableXObject* params)
{
    params->SetVal("battle_uuid", battle_uuid_);
    params->SetVal("team_id", GetTeamId());
    params->SetVal("map_mode_id", room->GetMapModeMeta()->id());
    params->SetVal("map_mode", room->GetReportMapMode());

    if (room->IsPveRoom()) {
        params->SetVal("victory", room->pve_data.pve_kill_boss == 1 ? 1 : 0);
    } else {
        params->SetVal("victory", team_rank == 1 ? 1 : 0);
    }

    if (room->IsPveRoom()) {
        params->SetVal("pve_settelement_type", 1);
        params->SetVal("pve_instance_id", room->pve_instance->gemini_id());
        params->SetVal("pve_wave", room->pve_data.GetPassedWave());
        params->SetVal("pve_max_wave", room->pve_data.max_wave);
    } else {
        params->SetVal("pvp_settelement_type", 1);
        params->SetVal("pvp_settelement_color", settlement_color);
        params->SetVal("pvp_team_rank", team_rank);
        params->SetVal("pvp_total_human_num", room->GetHumanNum());
        params->SetVal("pvp_alive_human_num", room->AliveCount());
        params->SetVal("pvp_total_team_num", room->GetTeamNum());
        params->SetVal("pvp_match_mode", room->GetPvpMatchMode());
        params->SetVal("pvp_team_kills", 0); //
    }

    #if 0
    {
        auto teams_pb = a8::MutableXObject::CreateArray();
        room->TraverseTeams
            (
             [teams_pb] (Team* team)
             {
                 auto members_pb = a8::MutableXObject::CreateArray();
                 team->TraverseMembers
                     (
                      [members_pb] (Human* hum)
                      {
                          auto member_pb = a8::MutableXObject::CreateObject();
                          member_pb->SetVal("account_id", hum->account_id);
                          members_pb->Push(*member_pb);
                          return true;
                      });
                 auto team_pb = a8::MutableXObject::CreateObject();
                 team_pb->SetVal("team_id", team->GetTeamId());
                 team_pb->SetVal("members", *members_pb);
                 teams_pb->Push(*team_pb);
                 return true;
             });
        params->SetVal("team_list", *teams_pb);
    }
    #endif

    {
        int pvp_team_kills = 0;

        auto members_pb = a8::MutableXObject::CreateArray();
        std::vector<Human*> sorted_members;
        TraverseMembers
            (
             [&sorted_members] (Human* hum) mutable
             {
                 sorted_members.push_back(hum);
                 return true;
             }
             );
        if (room->IsPveRoom()) {
            std::sort(sorted_members.begin(), sorted_members.end(),
                      [] (Human* a, Human* b) -> bool
                      {
                          if (a->stats->pve_rank_score > b->stats->pve_rank_score) {
                              return true;
                          }
                          if (a->stats->pve_rank_score < b->stats->pve_rank_score) {
                              return false;
                          }
                          return a->GetUniId() < b->GetUniId();
                      });
        }
        int i = 0;
        for (Human* hum : sorted_members) {
            ++i;
            pvp_team_kills += hum->stats->kills;

            auto member_pb = a8::MutableXObject::CreateObject();
            member_pb->SetVal("account_id", hum->account_id);
            member_pb->SetVal("match_room_uuid", hum->match_room_uuid);
            member_pb->SetVal("name", hum->name);
            member_pb->SetVal("head", a8::XValue(hum->avatar_url));
            member_pb->SetVal("head_frame", hum->head_frame);
            member_pb->SetVal("sex", hum->sex);
            member_pb->SetVal("dead", hum->dead);
            member_pb->SetVal("dead_times", hum->stats->dead_times);
            member_pb->SetVal("is_mvp", 0);
            if (hum->GetNetData()->GetSkinId() != 0) {
                member_pb->SetVal("skin_id", hum->GetNetData()->GetSkinId());
            } else {
                member_pb->SetVal("skin_id", 0);
            }
            member_pb->SetVal("move_distance", hum->stats->move_distance);
            member_pb->SetVal("full_level_idx", hum->stats->full_level_idx);
            member_pb->SetVal("hero_level", hum->GetHeroLevel());
            member_pb->SetVal("is_run_away", hum->stats->is_run_away);

            member_pb->SetVal("hero_id", hum->meta->id());
            member_pb->SetVal("hero_uniid", hum->hero_uniid);
            //member_pb->SetVal("hero_quality", hum->hero_uniid);
            member_pb->SetVal("game_time", hum->stats->game_time);
            member_pb->SetVal("game_duration", hum->stats->game_duration);
            member_pb->SetVal("alive_time", hum->stats->alive_time);
            member_pb->SetVal("ranked", hum->stats->rank);
            member_pb->SetVal("kills", hum->stats->kills);
            member_pb->SetVal("damage_out", hum->stats->damage_amount_out);
            member_pb->SetVal("weapon_uuid1", hum->spec_weapons.size() > 0 ? hum->spec_weapons[0].weapon_uniid : 0);
            member_pb->SetVal("weapon_uuid2", hum->spec_weapons.size() > 1 ? hum->spec_weapons[1].weapon_uniid : 0);
            member_pb->SetVal("rescue_teammate_times", hum->stats->rescue_member);
            member_pb->SetVal("diving_times", hum->stats->diving_times);
            member_pb->SetVal("damage_in", hum->stats->damage_amount_in);
            member_pb->SetVal("recover_hp", hum->stats->heal_amount);
            member_pb->SetVal("open_airdrop_times", hum->stats->open_airdrop_times);
            member_pb->SetVal("use_medicine_times", hum->stats->use_medicine_times);
            member_pb->SetVal("destory_car_times", hum->stats->destory_car_times);
            member_pb->SetVal("use_camouflage_times", hum->stats->use_camouflage_times);
            member_pb->SetVal("use_skill_times", hum->stats->use_skill_times);
            member_pb->SetVal("ride_car_move_distance", hum->stats->ride_car_move_distance);
            member_pb->SetVal("ride_car_kills", hum->stats->ride_car_kills);
            member_pb->SetVal("max_hero_skill_lv", hum->stats->max_hero_skill_lv);
            member_pb->SetVal("abandon_battle", hum->stats->abandon_battle);
            member_pb->SetVal("assist", hum->stats->assist);
            member_pb->SetVal("box_num", hum->box_num);
            {
                std::string weapons_type;
                std::string weapons_slot;
                for (auto& pair : hum->stats->weapon_stats) {
                    auto& weapon = pair.second;
                    if (weapon.kills || weapon.damage_out || weapon.obtain_count) {
                        weapons_type += a8::Format("%d:%d:%d:%d|",
                                                   {
                                                    weapon.weapon_id,
                                                    weapon.kills,
                                                    weapon.damage_out,
                                                    weapon.obtain_count
                                                   });
                    }
                    if (weapon.use_times) {
                        weapons_slot += a8::Format("%d:%d|",
                                                   {
                                                    weapon.weapon_id,
                                                    weapon.use_times
                                                   });
                    }
                }
                member_pb->SetVal("weapons_type", weapons_type);
                member_pb->SetVal("weapons_slot", weapons_slot);
            }
            {
                std::string heros;
                for (auto& pair : hum->stats->hero_stats) {
                    auto& hero = pair.second;
                    if (hero.skill_lv || hero.weapon_lv) {
                        heros += a8::Format("%d:%d:%d|",
                                            {
                                             hero.hero_id,
                                             hero.skill_lv,
                                             hero.weapon_lv,
                                            });
                    }
                }
                member_pb->SetVal("heros", heros);
            }
            if (room->IsPveRoom()) {
                member_pb->SetVal("pve_order", i);
                member_pb->SetVal("pve_score", hum->stats->pve_rank_score);
                member_pb->SetVal("pve_star", room->pve_mode_meta->CalcStar(hum->stats->pve_rank_score));
                member_pb->SetVal("pve_damage", hum->stats->damage_amount_out);
                member_pb->SetVal("pve_revive", hum->stats->revive);
                member_pb->SetVal("pve_survia_time", hum->stats->alive_time);
                member_pb->SetVal("pve_wave", hum->stats->pve_wave);
                member_pb->SetVal("pve_max_wave", room->pve_data.max_wave);
                member_pb->SetVal("pve_boss_killed", hum->stats->pve_kill_boss);
                member_pb->SetVal("pve_rank_score", hum->stats->pve_rank_score);
            } else if (room->IsMobaModeRoom()) {
                member_pb->SetVal("pvp_kill", hum->stats->kills);
                member_pb->SetVal("pvp_damage", hum->stats->damage_amount_out);
                member_pb->SetVal("pvp_assist", hum->stats->assist);
                member_pb->SetVal("pvp_survia_time", hum->stats->alive_time);
                member_pb->SetVal("pvp_recover", hum->stats->heal_amount);
                member_pb->SetVal("pvp_rescue", hum->stats->rescue_member);
                member_pb->SetVal("pvp_personal_rank", hum->stats->rank);
            } else {
                member_pb->SetVal("pvp_kill", hum->stats->kills);
                member_pb->SetVal("pvp_damage", hum->stats->damage_amount_out);
                member_pb->SetVal("pvp_assist", hum->stats->assist);
                member_pb->SetVal("pvp_survia_time", hum->stats->alive_time);
                member_pb->SetVal("pvp_recover", hum->stats->heal_amount);
                member_pb->SetVal("pvp_rescue", hum->stats->rescue_member);
                member_pb->SetVal("pvp_personal_rank", hum->stats->rank);
            }
            members_pb->Push(*member_pb);
        };
        params->SetVal("members", *members_pb);
        if (room->IsMobaModeRoom()) {
            params->SetVal("moba_my_team_kills", GetKillCount());
            if (room->GetMobaTeamA() == this) {
                params->SetVal("moba_enemy_team_kills", room->GetMobaTeamB()->GetKillCount());
            } else {
                params->SetVal("moba_enemy_team_kills", room->GetMobaTeamA()->GetKillCount());
            }
        }
        params->SetVal("pvp_team_kills", pvp_team_kills);
    }
}

#ifdef MYDEBUG
void Team::SetKillCount(int count)
{
    kill_count_ = count;
}
#endif