464 lines
16 KiB
C++
464 lines
16 KiB
C++
#include "precompile.h"
|
|
|
|
#include <a8/mutable_xobject.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/Map.h"
|
|
#include "mt/Hero.h"
|
|
#include "mt/PveGemini.h"
|
|
#include "mt/PveGeminiMode.h"
|
|
#include "mt/PveGeminiContent.h"
|
|
|
|
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() >= MAX_TEAM_NUM;
|
|
}
|
|
|
|
void Team::CombineBornPoint()
|
|
{
|
|
Human* target = nullptr;
|
|
for (Human* member : members_) {
|
|
if (!target) {
|
|
target = member;
|
|
} else {
|
|
if (target->born_point) {
|
|
if (member->born_point) {
|
|
room->DecBornPointHumanNum(member->born_point, member);
|
|
}
|
|
member->born_point = target->born_point;
|
|
if (member->born_point) {
|
|
room->IncBornPointHumanNum(member->born_point, member);
|
|
}
|
|
}
|
|
} //end if
|
|
if (!member->born_point) {
|
|
abort();
|
|
} else {
|
|
member->SetPos(member->born_point->RandPoint());
|
|
}
|
|
if (!a8::HasBitFlag(member->status, CS_Disable)) {
|
|
member->FindLocation();
|
|
member->RefreshView();
|
|
room->grid_service->MoveCreature(member);
|
|
} else if (room->GetRoomType() == RT_MidBrid && !member->team_uuid.empty()){
|
|
room->EnableHuman(member);
|
|
}
|
|
}
|
|
}
|
|
|
|
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 < MAX_TEAM_NUM);
|
|
}
|
|
|
|
void Team::AddCombineMemberNum(int member_num)
|
|
{
|
|
combined_team_member_num_ += member_num;
|
|
}
|
|
|
|
bool Team::HasReviveCoin(Human* member)
|
|
{
|
|
for (Human* member : members_) {
|
|
if (member->GetBattleContext()->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;
|
|
}
|
|
|
|
std::shared_ptr<a8::MutableXObject> post_data = a8::MutableXObject::CreateObject();
|
|
GenBattleReportData(player, post_data.get());
|
|
std::string url;
|
|
JsonDataMgr::Instance()->GetApiUrl(url);
|
|
if (url.find('?') != std::string::npos) {
|
|
url += "c=Battle&a=teamReport";
|
|
} else {
|
|
url += "?c=Battle&a=teamReport";
|
|
}
|
|
std::shared_ptr<a8::MutableXObject> params = a8::MutableXObject::CreateObject();
|
|
params->SetVal("account_id", player->account_id);
|
|
params->SetVal("session_id", player->session_id);
|
|
params->SetVal("__POST", post_data->ToJsonStr());
|
|
|
|
long long room_uuid = room->GetRoomUuid();
|
|
int team_id = GetTeamId();
|
|
HttpProxy::Instance()->HttpGet
|
|
(
|
|
[room_uuid, team_id]
|
|
(bool ok, a8::XObject* rsp_obj, f8::HttpContext* ctx)
|
|
{
|
|
Room* room = RoomMgr::Instance()->GetRoomByUuid(room_uuid);
|
|
if (room) {
|
|
Team* team = room->GetTeam(team_id);
|
|
if (team) {
|
|
team->already_report_battle = true;
|
|
team->sending_battlereport = false;
|
|
team->TraverseMembers
|
|
(
|
|
[] (Human* hum)
|
|
{
|
|
hum->SendGameOver();
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
},
|
|
url.c_str(),
|
|
*params.get()
|
|
);
|
|
}
|
|
|
|
void Team::GenBattleReportData(Human* player, a8::MutableXObject* params)
|
|
{
|
|
params->SetVal("version", 2023030201);
|
|
params->SetVal("battle_uuid", a8::XValue(player->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_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("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("is_mvp", 0);
|
|
|
|
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("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);
|
|
{
|
|
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 {
|
|
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);
|
|
|
|
params->SetVal("pvp_team_kills", pvp_team_kills);
|
|
}
|
|
|
|
}
|
|
|
|
void Team::GenBattleUuid()
|
|
{
|
|
long long battle_uuid = 0;
|
|
for (Human* hum : members_) {
|
|
if (hum->battle_uuid) {
|
|
battle_uuid = hum->battle_uuid;
|
|
break;
|
|
}
|
|
}
|
|
if (!battle_uuid) {
|
|
battle_uuid = App::Instance()->NewUuid();
|
|
}
|
|
|
|
for (Human* hum : members_) {
|
|
hum->battle_uuid = battle_uuid;
|
|
hum->GetBattleContext()->battle_uuid = battle_uuid;
|
|
}
|
|
}
|