server/game2006
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
game2006/server/gameserver/human.cc
aozhiwei d0519e8a4d 1
2023-02-15 18:04:41 +08:00

3365 lines
106 KiB
C++
Raw Blame History

#include "precompile.h"
#include <math.h>
#include <float.h>
#include <a8/mutable_xobject.h>
#include <a8/collision.h>
#include <f8/utils.h>
#include <f8/udplog.h>
#include "human.h"
#include "room.h"
#include "bullet.h"
#include "loot.h"
#include "app.h"
#include "roommgr.h"
#include "android.h"
#include "gamelog.h"
#include "typeconvert.h"
#include "obstacle.h"
#include "roomobstacle.h"
#include "player.h"
#include "buff.h"
#include "car.h"
#include "roomobstacle.h"
#include "jsondatamgr.h"
#include "skill.h"
#include "incubator.h"
#include "team.h"
#include "explosion.h"
#include "killmgr.h"
#include "tracemgr.h"
#include "httpproxy.h"
#include "skillhelper.h"
#include "shot.h"
#include "battledatacontext.h"
#include "mapinstance.h"
#include "movement.h"
#include "pbutils.h"
#include "trigger.h"
#include "ability.h"
#include "mt/Param.h"
#include "mt/Hero.h"
#include "mt/Equip.h"
#include "mt/Buff.h"
#include "mt/Skill.h"
#include "mt/SkillNumber.h"
#include "mt/GunTalentGrow.h"
#include "mt/SafeArea.h"
#include "mt/MapThing.h"
#include "mt/Text.h"
#include "mt/Map.h"
#include "mt/PveGemini.h"
#include "mt/PveGeminiMode.h"
#include "mt/RankReward.h"
#include "mt/RankPoint.h"
#include "mt/KillReward.h"
#include "mt/KillPoint.h"
#include "mt/Drop.h"
#include "pbutils.h"
static double TopXFunc (Human* sender,
std::function<int (Human*, Human*)> cmpFunc,
bool need_group,
std::function<bool (Human*)> validFunc)
{
std::vector<std::vector<Human*>> rank_list;
double topx = 0.0f;
#if 0
sender->room->TraverseHumanList
(a8::XParams(),
[cmpFunc, &rank_list, need_group] (Human* hum, a8::XParams& param) -> bool
{
bool found = false;
if (need_group) {
for (auto& list : rank_list) {
if (cmpFunc(list[0], hum) == 0) {
list.push_back(hum);
found = true;
}
}
}
if (!found) {
rank_list.push_back(std::vector<Human*>({hum}));
}
return true;
});
std::sort
(rank_list.begin(), rank_list.end(),
[cmpFunc] (const std::vector<Human*>& a, const std::vector<Human*>& b )
{
a8::XPrintf("id1:%d dead:%d id2:%d dead:%d cmpRet:%d\n",
{
a[0]->GetUniId(),
a[0]->dead ? 1 :0,
b[0]->GetUniId(),
b[0]->dead ? 1 :0,
cmpFunc(a[0], b[0])
});
return cmpFunc(a[0], b[0]) > 0;
});
int rank = rank_list.size();
for (int i = 0; i < rank_list.size(); ++i){
bool found = false;
for (Human* hum : rank_list[i]) {
if (hum == sender){
rank = i + 1;
found = true;
break;
}
}
if (found) {
break;
}
}
#if 1
double topx = (double)rank / 40.0f;
if (!validFunc(sender)) {
topx = 40.0f / 40.0f;
}
#else
double topx = (double)rank / rank_list.size();
#endif
#endif
return topx;
};
void PlayerStats::Statement(Human* sender)
{
sender->stats.ranked_topx = (double)sender->stats.rank / sender->room->GetHumanNum();
sender->stats.kills_topx = TopXFunc
(
sender,
[] (Human* a, Human* b) -> int
{
if (a->stats.kills == b->stats.kills) {
return 0;
} else if (a->stats.kills > b->stats.kills) {
return 1;
} else {
return -1;
}
},
true,
[] (Human* hum)
{
return hum->stats.kills > 0;
}
);
sender->stats.hero_topx = TopXFunc
(
sender,
[] (Human* a, Human* b) -> int
{
long long a_value = 0;
long long b_value = 0;
if (a->GetBattleContext()) {
int hero_lv = 0;
int quality = 0;
a->GetBattleContext()->GetHeroLvQuality(hero_lv, quality);
a_value = hero_lv + quality;
}
if (b->GetBattleContext()) {
int hero_lv = 0;
int quality = 0;
b->GetBattleContext()->GetHeroLvQuality(hero_lv, quality);
b_value = hero_lv + quality;
}
if (a_value == b_value) {
return 0;
} else if (a_value > b_value) {
return 1;
} else {
return -1;
}
},
true,
[] (Human* hum)
{
if (hum->GetBattleContext()) {
int hero_lv = 0;
int quality = 0;
hum->GetBattleContext()->GetHeroLvQuality(hero_lv, quality);
return hero_lv + quality > 0;
}
return false;
}
);
sender->stats.weapon_topx = TopXFunc
(
sender,
[] (Human* a, Human* b) -> int
{
long long a_value = 0;
long long b_value = 0;
if (a->GetBattleContext()) {
int weapon_lv = 0;
int quality = 0;
a->GetBattleContext()->GetWeaponLvQuality(weapon_lv, quality);
a_value = weapon_lv + quality;
}
if (b->GetBattleContext()) {
int weapon_lv = 0;
int quality = 0;
b->GetBattleContext()->GetWeaponLvQuality(weapon_lv, quality);
b_value = weapon_lv + quality;
}
if (a_value == b_value) {
return 0;
} else if (a_value > b_value) {
return 1;
} else {
return -1;
}
},
true,
[] (Human* hum)
{
if (hum->GetBattleContext()) {
int weapon_lv = 0;
int quality = 0;
hum->GetBattleContext()->GetWeaponLvQuality(weapon_lv, quality);
return weapon_lv + quality > 0;
}
return false;
}
);
sender->stats.survival_topx = TopXFunc
(
sender,
[] (Human* a, Human* b) -> int
{
if (a->dead && b->dead) {
if (a->dead_frameno == b->dead_frameno) {
return 0;
} else if (a->dead_frameno > b->dead_frameno) {
return 1;
} else {
return -1;
}
} else {
if (!a->dead && !b->dead) {
return 0;
} else {
if (!a->dead) {
return 1;
} else {
return -1;
}
}
}
},
true,
[] (Human* hum)
{
return true;
}
);
if (sender->GetBattleContext()) {
sender->GetBattleContext()->CalcBattleStat(this);
}
statemented = 1;
}
WeaponStats& PlayerStats::MustBeWeapon(int weapon_id)
{
auto itr = weapon_stats.find(weapon_id);
if (itr == weapon_stats.end()){
WeaponStats weapon;
weapon_stats[weapon_id] = weapon;
itr = weapon_stats.find(weapon_id);
}
return itr->second;
}
void PlayerStats::IncWeaponKills(int weapon_id, int val)
{
MustBeWeapon(weapon_id).kills += val;
}
void PlayerStats::IncWeaponDamageOut(int weapon_id, int val)
{
MustBeWeapon(weapon_id).damage_out += val;
}
void PlayerStats::IncWeaponObtainCount(int weapon_id, int val)
{
MustBeWeapon(weapon_id).obtain_count += val;
}
void PlayerStats::IncWeaponUseTimes(int weapon_id, int val)
{
MustBeWeapon(weapon_id).use_times += val;
}
HeroStats& PlayerStats::MustBeHero(int hero_id)
{
auto itr = hero_stats.find(hero_id);
if (itr == hero_stats.end()){
HeroStats hero;
hero_stats[hero_id] = hero;
itr = hero_stats.find(hero_id);
}
return itr->second;
}
void PlayerStats::SetHeroSkillLv(int hero_id, int skill_lv)
{
MustBeHero(hero_id).skill_lv = std::max(MustBeHero(hero_id).skill_lv, skill_lv);
}
void PlayerStats::SetHeroWeaponLv(int hero_id, int weapon_lv)
{
MustBeHero(hero_id).weapon_lv = std::max(MustBeHero(hero_id).weapon_lv, weapon_lv);
}
void PlayerStats::ParseReward(Human* hum, a8::XObject& xobj)
{
if (!xobj.IsObject()) {
AdjustRewardData();
return;
}
auto reward_xobj = xobj.At("reward");
if (!reward_xobj || !reward_xobj->IsObject()) {
AdjustRewardData();
return;
}
over_reward.total_ceg = reward_xobj->At("total_ceg")->AsXValue().GetString();
{
auto hero_xobj = reward_xobj->At("hero");
if (hero_xobj && hero_xobj->IsObject()) {
over_reward.hero.curr_gold = hero_xobj->At("curr_ceg") ?
hero_xobj->At("curr_ceg")->AsXValue().GetString() : "0";
over_reward.hero.obtain_gold = hero_xobj->At("obtain_ceg")->AsXValue().GetString();
over_reward.hero.gold_limit = hero_xobj->At("ceg_uplimit")->AsXValue().GetString();
if (hum->GetBattleContext()->hero_dto &&
hum->GetBattleContext()->hero_dto->IsObject()) {
over_reward.hero.id = hum->GetBattleContext()->hero_dto->At("hero_id")->AsXValue();
}
}
}
{
auto weapon_xobj = reward_xobj->At("weapon1");
if (weapon_xobj && weapon_xobj->IsObject()) {
over_reward.weapon1.curr_gold = weapon_xobj->At("curr_ceg") ?
weapon_xobj->At("curr_ceg")->AsXValue().GetString() : "";
over_reward.weapon1.obtain_gold = weapon_xobj->At("obtain_ceg")->AsXValue().GetString();
over_reward.weapon1.gold_limit = weapon_xobj->At("ceg_uplimit")->AsXValue().GetString();
if (hum->GetBattleContext()->weapon_dto1 &&
hum->GetBattleContext()->weapon_dto1->IsObject()) {
over_reward.weapon1.id = hum->GetBattleContext()->weapon_dto1->At("gun_id")->AsXValue();
}
}
}
{
auto weapon_xobj = reward_xobj->At("weapon2");
if (weapon_xobj && weapon_xobj->IsObject()) {
over_reward.weapon2.curr_gold = weapon_xobj->At("curr_ceg") ?
weapon_xobj->At("curr_ceg")->AsXValue().GetString() : "0";
over_reward.weapon2.obtain_gold = weapon_xobj->At("obtain_ceg")->AsXValue().GetString();
over_reward.weapon2.gold_limit = weapon_xobj->At("ceg_uplimit")->AsXValue().GetString();
if (hum->GetBattleContext()->weapon_dto2 &&
hum->GetBattleContext()->weapon_dto2->IsObject()) {
over_reward.weapon2.id = hum->GetBattleContext()->weapon_dto2->At("gun_id")->AsXValue();
}
}
}
{
auto items_xobj = reward_xobj->At("items");
if (items_xobj && items_xobj->IsArray()) {
for (int i = 0; i < items_xobj->Size(); ++i) {
auto item_xobj = items_xobj->At(i);
if (item_xobj && item_xobj->IsObject()) {
over_reward.items.push_back
(std::make_tuple
(
item_xobj->At("item_id")->AsXValue(),
item_xobj->At("item_num")->AsXValue()
)
);
}
}
}
}
{
auto score_info_xobj = xobj.At("score_info");
if (score_info_xobj && score_info_xobj->IsObject()) {
old_rank = score_info_xobj->At("old_rank")->AsXValue();
new_rank = score_info_xobj->At("new_rank")->AsXValue();
old_score = score_info_xobj->At("old_score")->AsXValue();
new_score = score_info_xobj->At("new_score")->AsXValue();
}
}
AdjustRewardData();
}
void PlayerStats::AdjustRewardData()
{
auto EmptyStrToZero =
[] (std::string& str) {
if (str.empty()) {
str = "0";
}
};
EmptyStrToZero(over_reward.total_ceg);
{
EmptyStrToZero(over_reward.hero.curr_gold);
EmptyStrToZero(over_reward.hero.obtain_gold);
EmptyStrToZero(over_reward.hero.gold_limit);
}
{
EmptyStrToZero(over_reward.weapon1.curr_gold);
EmptyStrToZero(over_reward.weapon1.obtain_gold);
EmptyStrToZero(over_reward.weapon1.gold_limit);
}
{
EmptyStrToZero(over_reward.weapon2.curr_gold);
EmptyStrToZero(over_reward.weapon2.obtain_gold);
EmptyStrToZero(over_reward.weapon2.gold_limit);
}
}
Human::Human():Creature()
{
default_weapon.weapon_idx = 0;
default_weapon.weapon_id = 30101;
default_weapon.ammo = 1;
default_weapon.meta = mt::Equip::GetById(default_weapon.weapon_id);
default_weapon.Recalc();
for (int i = 0; i < kSkinNum; ++i) {
Skin& skin = a8::FastAppend(skins);
skin.skin_id = 0;
skin.skin_lv = 1;
}
weapons[0] = default_weapon;
if (mt::Param::s().fighting_mode) {
AddInventory(IS_9MM, FIGHTING_MODE_BULLET_NUM);
AddInventory(IS_556MM, FIGHTING_MODE_BULLET_NUM);
AddInventory(IS_762MM, FIGHTING_MODE_BULLET_NUM);
AddInventory(IS_12GAUGE, FIGHTING_MODE_BULLET_NUM);
AddInventory(IS_RPG, FIGHTING_MODE_BULLET_NUM);
AddInventory(IS_ICE, FIGHTING_MODE_BULLET_NUM);
}
}
Human::~Human()
{
int i = 0;
}
void Human::Initialize()
{
Creature::Initialize();
volume_ = meta->_volume;
observers_.insert(this);
SetCurrWeapon(&weapons[0]);
SetOxygen(mt::Param::s().dive_oxygen_total);
}
float Human::GetSpeed()
{
{
Buff* buff = GetBuffByEffectId(kBET_JumpTo);
if (buff) {
return buff->meta->_buff_param2;
}
}
{
Buff* buff = GetBuffByEffectId(kBET_HoldShield);
if (buff) {
return buff->meta->_buff_param1;
}
}
{
Buff* buff = GetBuffByEffectId(kBET_Jump);
if (buff) {
return meta->jump_speed();
}
}
{
Buff* buff = GetBuffByEffectId(kBET_BePull);
if (buff) {
return buff->meta->_buff_param2;
}
}
{
Buff* buff = GetBuffByEffectId(kBET_Sprint);
if (buff) {
return buff->meta->_buff_param2;
}
}
float speed = 1.0;
if (downed) {
speed = meta->move_speed3();
} else {
if (shot_hold) {
if (GetCurrWeapon()->weapon_idx == GUN_SLOT1 ||
GetCurrWeapon()->weapon_idx == GUN_SLOT2) {
if (action_type != AT_Reload) {
speed = meta->shot_speed() * (1 + GetAbility()->GetAttrRate(kHAT_ShotSpeed));
if (HasBuffEffect(kBET_InWater)) {
speed *= mt::Param::s().water_move_coefficient;
}
return speed;
}
}
} else if (aiming) {
speed = std::max(1, meta->aiming_speed());
if (HasBuffEffect(kBET_InWater)) {
speed *= mt::Param::s().water_move_coefficient;
}
return speed;
} else if (action_type == AT_Reload) {
speed = std::max(1, meta->reload_speed());
if (HasBuffEffect(kBET_InWater)) {
speed *= mt::Param::s().water_move_coefficient;
}
return speed;
} else if (action_type == AT_UseItem) {
speed = std::max(1, meta->useitem_speed());
if (HasBuffEffect(kBET_InWater)) {
speed *= mt::Param::s().water_move_coefficient;
}
return speed;
}
speed = meta->move_speed();
}
float old_speed = speed;
#if 1
speed = (speed * SERVER_FRAME_RATE *
(1 + GetAbility()->GetSpeedAddition() - GetAbility()->GetSpeedRuduce())) / SERVER_FRAME_RATE;
#else
speed = (speed + GetAbility()->GetAttrAbs(kHAT_Speed)) *
(1 + GetAbility()->GetAttrRate(kHAT_Speed));
#endif
if (HasBuffEffect(kBET_InWater)) {
speed *= mt::Param::s().water_move_coefficient;
}
return std::max(speed, 1.0f);
}
float Human::GetSpeed4()
{
return meta->move_speed4();
}
bool Human::IsDead(Room * room)
{
return dead;
}
long long Human::GetDeadFrameNo(Room* room)
{
return dead_frameno;
}
long long Human::GetRealDeadFrameNo(Room* room)
{
return real_dead_frameno;
}
void Human::CarShot(const glm::vec3& target_dir)
{
if (!second_weapon.meta) {
return;
}
if (second_weapon.weapon_idx != 0 &&
second_weapon.ammo <= 0) {
AutoLoadingBullet();
return;
}
if (action_type == AT_Reload) {
CancelAction();
}
if (action_type == AT_Reload ||
action_type == AT_Rescue ||
action_type == AT_UseItem ||
action_type == AT_Relive) {
CancelAction();
}
InternalShot(this,
second_weapon.meta,
second_weapon.bullet_meta,
nullptr,
5,
0,
0);
--second_weapon.ammo;
last_shot_frameno_ = room->GetFrameNo();
}
void Human::BeKill(int killer_id, const std::string& killer_name, int weapon_id,
int real_killer_id, const std::string& real_killer_name)
{
if (!dead && !room->IsGameOver() && !real_dead && !a8::HasBitFlag(status, CS_PreDieSuspended)) {
GetTrigger()->PreDie(killer_id, weapon_id);
#ifdef DEBUG
{
if (!f8::IsTestEnv()) {
a8::XPrintf("BeKill killer_id:%d killer_name:%s over_delay_time:%d\n",
{
killer_id,
killer_name,
over_delay_time
});
}
}
#endif
if (over_delay_time > 0) {
std::shared_ptr<KillInfo> info = std::make_shared<KillInfo>();
info->killer_id = killer_id;
info->killer_name = killer_name;
info->weapon_id = weapon_id;
info->real_killer_id = real_killer_id;
info->real_killer_name = real_killer_name;
a8::SetBitFlag(status, CS_PreDieSuspended);
room->xtimer.SetTimeoutEx
(over_delay_time / FRAME_RATE_MS,
[this, info] (int event, const a8::Args* args)
{
if (a8::TIMER_EXEC_EVENT == event) {
over_delay_time = 0;
a8::UnSetBitFlag(status, CS_PreDieSuspended);
InternalBeKill
(
info->killer_id,
info->killer_name,
info->weapon_id,
info->real_killer_id,
info->real_killer_name
);
}
},
&xtimer_attacher);
} else {
InternalBeKill(killer_id, killer_name, weapon_id, real_killer_id, real_killer_name);
}
}
}
void Human::DecHP(float dec_hp, int killer_id, const std::string& killer_name, int weapon_id,
int real_killer_id, const std::string& real_killer_name)
{
if (!room->BattleStarted()) {
return;
}
#ifdef DEBUG
#if 0
if (IsPlayer()) {
return;
}
#endif
#endif
{
Buff* buff = GetBuffByEffectId(kBET_Shield);
if (buff) {
dec_hp = std::max((float)1.0, dec_hp - buff->meta->_buff_param2);
}
}
if (HasBuffEffect(kBET_Invincible)) {
return;
}
{
Human* hum = room->GetHumanByUniId(real_killer_id);
if (hum) {
attacker_hash_[real_killer_id] = room->GetFrameNo();
}
}
struct DownedInfo
{
int killer_id = 0;
std::string killer_name;
int weapon_id = 0;
int real_killer_id = 0;
std::string real_killer_name;
};
last_receive_dmg_frameno = room->GetFrameNo();
float old_hp = GetHP();
if (energy_shield > 0.001f) {
energy_shield = std::max(0.0f, energy_shield - dec_hp);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
} else {
float old_health = GetHP();
float new_health = std::max(0.0f, GetHP() - dec_hp);
AdjustDecHp(old_health, new_health);
SetHP(std::max(0.0f, new_health));
if (old_health - GetHP() > 0.001f) {
stats.damage_amount_in += old_health - GetHP();
GetTrigger()->ReceiveDmg();
}
if (GetHP() <= 0.0001f && !dead) {
if (downed) {
if (!downed_timer.expired()) {
room->xtimer.Delete(downed_timer);
}
downed = false;
BeKill(killer_id, killer_name, weapon_id, real_killer_id, real_killer_name);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
} else {
if (HasNoDownedTeammate() && !room->IsPveRoom()) {
SetHP(mt::Param::GetIntParam("downed_recover_hp"));
downed = true;
if (HasBuffEffect(kBET_Camouflage)) {
RemoveBuffByEffectId(kBET_Camouflage);
}
CancelAction();
DoGetDown();
std::shared_ptr<DownedInfo> info = std::make_shared<DownedInfo>();
info->killer_id = killer_id;
info->killer_name = killer_name;
info->weapon_id = weapon_id;
info->real_killer_id = real_killer_id;
info->real_killer_name = real_killer_name;
downed_timer = room->xtimer.SetIntervalWpEx
(
SERVER_FRAME_RATE,
[this, info] (int event, const a8::Args* args) mutable
{
if (a8::TIMER_EXEC_EVENT == event) {
if (!downed) {
FreeDownedTimer();
return;
}
if (dead) {
FreeDownedTimer();
return;
}
if (!HasLiveTeammate()) {
FreeDownedTimer();
BeKill(info->killer_id, info->killer_name, info->weapon_id,
info->real_killer_id, info->real_killer_name);
return;
}
int dec_hp = mt::Param::GetIntParam("downed_dec_hp");
DecHP(dec_hp, info->killer_id, info->killer_name, info->weapon_id,
info->real_killer_id, info->real_killer_name);
}
},
&xtimer_attacher);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
TryAddBuff(this, kDownBuffId);
} else {
BeKill(killer_id, killer_name, weapon_id, real_killer_id, real_killer_name);
}
}
}
room->frame_event.AddHpChg(GetWeakPtrRef());
}
GetTrigger()->HpChg();
}
void Human::AddToNewObjects(Entity* entity)
{
framedata_.new_objects[entity->GetUniId()] = entity->GetEntityWeakPtrRef();
}
void Human::AddToImageObjects(Creature* c)
{
framedata_.image_objects[c->GetUniId()] = c->GetWeakPtrRef();
}
void Human::AddToPartObjects(Entity* entity)
{
#ifdef DEBUG1
{
if (!follow_target_) {
for (Human* ob : observers_) {
if (ob->IsPlayer()) {
TraceMgr::Instance()->Trace
(a8::Format("add part_object %d->%d frameno:%d %d",
{
GetUniId(),
ob->GetUniId(),
room->GetFrameNo(),
entity->GetUniId()
}));
}
}
}
}
#endif
PartObject part_obj;
part_obj.entity_uniid = entity->GetUniId();
part_obj.entity_type = entity->GetEntityType();
part_obj.entity_subtype = entity->GetEntitySubType();
part_obj.add_frameno = room->GetFrameNo();
part_obj.object = entity->GetEntityWeakPtrRef();
framedata_.part_objects[entity->GetUniId()] = part_obj;
entity->OnAddToTargetPartObject(this);
}
void Human::RemovePartObjects(Entity* entity)
{
#ifdef DEBUG1
if (!follow_target_) {
for (Human* observer : observers_) {
if (observer->IsPlayer()) {
observer->SendDebugMsg(a8::Format("view_debug %d->%d frameno:%d remove_part_obj:%d",
{
GetUniId(),
observer->GetUniId(),
room->GetFrameNo(),
entity->GetUniId()
}));
}
}
}
#endif
framedata_.part_objects.erase(entity->GetUniId());
entity->OnRemoveFromTargetPartObject(this);
}
void Human::ClearPartObjects()
{
framedata_.part_objects.clear();
}
int Human::GetPartObjectsCount()
{
return framedata_.part_objects.size();
}
bool Human::InNewObjects(Entity* target)
{
return framedata_.new_objects.find(target->GetUniId()) != framedata_.new_objects.end();
}
bool Human::InPartObjects(Entity* target)
{
return framedata_.part_objects.find(target->GetUniId()) != framedata_.part_objects.end();
}
void Human::RemoveObjects(Entity* entity)
{
framedata_.del_objects.insert(entity->GetUniId());
framedata_.new_objects.erase(entity->GetUniId());
}
void Human::AddOutObjects(Entity* entity)
{
framedata_.out_objects.insert(entity->GetUniId());
}
void Human::RemoveOutObjects(Entity* entity)
{
framedata_.out_objects.erase(entity->GetUniId());
}
bool Human::HasLiveTeammate()
{
bool has = false;
if (GetTeam()) {
GetTeam()->TraverseMembers
(
[this, &has] (Human* member)
{
if (member != this && !member->dead) {
has = true;
return false;
}
return true;
});
}
return has;
}
bool Human::HasNoDownedTeammate()
{
bool has = false;
if (GetTeam()) {
GetTeam()->TraverseMembers
(
[this, &has] (Human* member)
{
if (member != this && !member->dead && !member->downed) {
has = true;
return false;
}
return true;
});
}
return has;
}
int Human::GetNearbyTeammateNum(float range)
{
int num = 0;
if (GetTeam()) {
GetTeam()->TraverseMembers
(
[this, &num, range] (Human* member)
{
if (member != this && !member->dead && !member->downed) {
if (member->GetPos().Distance2D2(GetPos()) <= range) {
++num;
}
}
return true;
});
}
return num;
}
void Human::DoJump()
{
if (HasBuffEffect(kBET_Fly)) {
a8::UnSetBitFlag(status, CS_DisableAttack);
RemoveBuffByEffectId(kBET_Fly);
MustBeAddBuff(this, kThroughWall_BUFFID);
MustBeAddBuff(this, JUMP_BUFFID);
jump_frameno_ = room->GetFrameNo();
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
}
void Human::DoGetOn(int obj_uniid)
{
if (room->GetGasData().GetGasMode() == GasInactive) {
return;
}
Entity* entity = room->GetEntityByUniId(obj_uniid);
if (!entity) {
return;
}
if (GetPos().Distance2D2(entity->GetPos()) > mt::Param::s().max_mount_horse_distance) {
return;
}
if (downed) {
return;
}
if (HasBuffEffect(kBET_Become)) {
return;
}
switch (entity->GetEntityType()) {
case ET_Loot:
{
DoGetOnWithLoot((Loot*)entity);
}
break;
case ET_Car:
{
DoGetOnWithCar((Car*)entity);
}
break;
default:
break;
}
}
void Human::RefreshView()
{
#if 1
room->grid_service->TraverseCreatures
(
room->GetRoomIdx(),
GetGridList(),
[this] (Creature* c, bool& stop)
{
c->AddToNewObjects(this);
c->AddToPartObjects(this);
AddToNewObjects(c);
AddToPartObjects(c);
});
#else
TraverseAllLayerHumanList
(
[this] (Human* hum, bool& stop)
{
hum->AddToNewObjects(this);
hum->AddToPartObjects(this);
AddToNewObjects(hum);
AddToPartObjects(hum);
});
#endif
TraverseAllLayerEntityList
(
[this] (Entity* entity, bool& stop)
{
switch (entity->GetEntityType()) {
case ET_Building:
case ET_Obstacle:
case ET_Loot:
case ET_MapBlock:
{
AddToNewObjects(entity);
}
break;
default:
{
}
break;
}
});
}
void Human::OnGridListChange(std::set<GridCell*>& old_grids,
std::set<GridCell*>& inc_grids,
std::set<GridCell*>& dec_grids
)
{
ProcIncGridList(old_grids, inc_grids, dec_grids);
ProcDecGridList(old_grids, inc_grids, dec_grids);
if (IsPlayer() && on_grid_chg) {
on_grid_chg(this);
}
}
void Human::SyncAroundPlayers(const char* file, int line, const char* func)
{
#if 0
if (a8::HasBitFlag(status, CS_Disable)) {
return;
}
#endif
#ifdef DEBUG
#if 0
room->CheckPartObjects();
f8::UdpLog::Instance()->Debug("room_idx:%d syncaround begin %s %d %s",
{
room->GetRoomIdx(),
file,
line,
func
});
#endif
#endif
TraverseAllLayerHumanList
(
[this, file, line, func] (Human* hum, bool& stop)
{
hum->AddToNewObjects(this);
#ifdef DEBUG
#if 0
{
std::string objs_str;
for (auto& obj : hum->part_objects) {
objs_str += a8::Format("%d ", {(long long)obj});
}
f8::UdpLog::Instance()->Debug("hum1 %d %s", {(long long)hum, objs_str});
}
{
std::string objs_str;
for (auto& obj : part_objects) {
objs_str += a8::Format("%d ", {(long long)obj});
}
f8::UdpLog::Instance()->Debug("hum2 %d %s", {(long long)this, objs_str});
}
room->CheckPartObjects(hum, this);
hum->InPartObjects(this);
#endif
#endif
assert(hum->InPartObjects(this));
if (!hum->InPartObjects(this)) {
static long long last_debugout_tick = 0;
if (a8::XGetTickCount() - last_debugout_tick > 1000 * 10) {
last_debugout_tick = a8::XGetTickCount();
f8::UdpLog::Instance()->Warning
("SyncAroundPlayers error room_idx:%d, file:%s line:%d func:%s",
{
room->GetRoomIdx(),
file,
line,
func
});
}
}
});
#ifdef DEBUG
#if 0
room->CheckPartObjects();
f8::UdpLog::Instance()->Debug("syncaround end %s %d %s",
{
file,
line,
func
});
#endif
#endif
}
void Human::RecalcVolume()
{
const mt::Equip* backpack_meta = mt::Equip::GetById(backpack);
for (size_t i = 0; i < IS_END; ++i) {
volume_[i] = meta->_volume[i];
volume_[i] += buff_inventory_[i].num;
if (backpack_meta) {
volume_[i] += backpack_meta->_volume[i];
}
}
}
void Human::RecalcBaseAttr()
{
#if 0
xxxxxxxx
const mt::Equip* chest_meta = mt::Equip::GetById(chest);
float def = meta->def();
if (chest_meta) {
def += chest_meta->def();
}
const mt::Equip* helmet_meta = mt::Equip::GetById(helmet);
if (helmet_meta) {
def += helmet_meta->def();
}
SetDef(def);
#endif
}
int Human::GetVolume(int slot_id)
{
if (!IsValidSlotId(slot_id)) {
A8_ABORT();
}
return volume_[slot_id];
}
void Human::RecoverHp(int inc_hp)
{
if (!dead) {
float hp = GetHP();
hp += inc_hp;
SetHP(hp);
SetHP(std::min(GetHP(), GetMaxHP()));
}
}
void Human::AddObserver(Human* observer)
{
observers_.insert(observer);
}
void Human::RemoveObserver(Human* observer)
{
observers_.erase(observer);
}
bool Human::HasObserver()
{
return observers_.size() > 1;
}
void Human::FollowTarget(Human* target)
{
if (target == this) {
return;
}
int pre_uniid = 0;
if (follow_target_) {
pre_uniid = follow_target_->GetUniId();
follow_target_->RemoveObserver(this);
}
target->AddObserver(this);
follow_target_ = target;
follow_synced_active_player = false;
#ifdef DEBUG
SendDebugMsg(a8::Format("观战 watch %d->%d->%d frameno:%d",
{
room->GetFrameNo(),
pre_uniid,
follow_target_->GetUniId(),
GetUniId()
}));
#endif
}
void Human::UpdateAction()
{
int passed_time = (room->GetFrameNo() - action_frameno) * FRAME_RATE_MS;
int left_time = std::max(0, action_duration - passed_time);
if (left_time <= 0) {
switch (action_type) {
case AT_Reload:
{
ProcReloadAction();
}
break;
case AT_UseItem:
{
ProcUseItemAction();
}
break;
case AT_Relive:
{
ProcReliveAction();
}
break;
case AT_Rescue:
{
RemoveBuffByEffectId(kBET_InRescue);
}
break;
default:
{
}
break;
}
ResetAction();
}
}
void Human::UpdateMove()
{
Creature::UpdateMove();
}
void Human::GenBattleReportData(a8::MutableXObject* params)
{
params->SetVal("room_mode", room->GetRoomMode());
int rank = 0;
{
std::vector<Human*> human_list;
room->TraverseHumanList(
[&human_list] (Human* hum) -> bool
{
human_list.push_back(hum);
return true;
});
std::sort(human_list.begin(), human_list.end(),
[] (Human* a, Human* b )
{
if (a->real_dead && b->real_dead) {
if (a->dead_frameno == b->dead_frameno) {
return a->GetUniId() < b->GetUniId();
} else {
return a->dead_frameno == 0 ||
(b->dead_frameno != 0 && a->dead_frameno > b->dead_frameno);
}
} else {
if (a->real_dead) {
return false;
}
if (b->real_dead) {
return true;
}
return a->GetUniId() < b->GetUniId();
}
});
rank = human_list.size();
for (size_t i = 0; i < human_list.size(); ++i) {
if (human_list[i] == this) {
rank = i + 1;
break;
}
}
if (room->GetAliveTeamNum() == 1) {
if (room->GetAliveTeam() == GetTeam()) {
rank = 1;
}
}
stats.rank = rank;
if (room->IsPveRoom()) {
if (stats.pve_kill_boss) {
stats.victory = true;
stats.settlement_color = 1;
}
} else {
stats.victory = stats.rank == 1;
if (GetTeam()->GetAliveNum() <= 0) {
GetTeam()->team_rank = room->GetAliveTeamNum();
stats.pvp_settlement_type = GetTeam()->GetMemberNum() > 1 ? 1 : 0;
stats.settlement_color = 1;
} else {
if (room->GetAliveTeamNum() == 1) {
if (room->GetAliveTeam() == GetTeam()) {
GetTeam()->team_rank = 1;
stats.pvp_settlement_type = GetTeam()->GetMemberNum() > 1 ? 1 : 0;
stats.settlement_color = 1;
}
}
}
if (rank < 10) {
stats.settlement_color = 1;
}
if (stats.victory) {
GetTeam()->team_rank = 0;
}
}
}
if (!stats.statemented) {
stats.Statement(this);
}
params->SetVal("account_id", account_id);
params->SetVal("session_id", session_id);
params->SetVal("team_id", team_id);
params->SetVal("pve_instance_id", room->IsPveRoom() ? room->pve_instance->gemini_id() : 0);
params->SetVal("pve_instance_mode", room->IsPveRoom() ? room->pve_mode_meta->id() : 0);
params->SetVal("battle_uuid", battle_uuid);
params->SetVal("match_mode", room->IsPveRoom() ? 2 : 0);
params->SetVal("is_valid_battle", is_valid_battle);
params->SetVal("payload", payload);
params->SetVal("map_id", room->GetMapMeta()->map_id());
params->SetVal("map_name", room->GetMapMeta()->map_name());
params->SetVal("team_mode", GetTeam() && GetTeam()->GetMemberNum() > 1 ? 1 : 0);
params->SetVal("map_tpl_name", room->GetMapTplName());
params->SetVal("room_uuid", room->GetRoomUuid());
params->SetVal("room_mode", room->GetRoomMode());
params->SetVal("hero_id", meta->id());
params->SetVal("hero_uniid", hero_uniid);
params->SetVal("game_time", time(nullptr)); //?
int alive_time = room->GetFrameNo() * FRAME_RATE_MS;
if (!dead) {
params->SetVal("alive_time", alive_time);
} else {
alive_time = (dead_frameno - room->GetBattleStartFrameNo()) * FRAME_RATE_MS;
if (room->GetBattleStartFrameNo() <= 0) {
alive_time = 0;
}
params->SetVal("alive_time", alive_time);
}
params->SetVal("weapon_uuid1", spec_weapons.size() > 0 ? spec_weapons[0].weapon_uniid : 0);
params->SetVal("weapon_uuid2", spec_weapons.size() > 1 ? spec_weapons[1].weapon_uniid : 0);
params->SetVal("ranked", rank);
params->SetVal("kills", stats.kills);
params->SetVal("damage_out", stats.damage_amount_out);
params->SetVal("rescue_teammate_times", stats.rescue_member);
params->SetVal("diving_times", stats.diving_times);
params->SetVal("damage_in", stats.damage_amount_in);
params->SetVal("recover_hp", stats.heal_amount);
params->SetVal("open_airdrop_times", stats.open_airdrop_times);
params->SetVal("use_medicine_times", stats.use_medicine_times);
params->SetVal("destory_car_times", stats.destory_car_times);
params->SetVal("use_camouflage_times", stats.use_camouflage_times);
params->SetVal("use_skill_times", stats.use_skill_times);
params->SetVal("ride_car_move_distance", stats.ride_car_move_distance);
params->SetVal("ride_car_kills", stats.ride_car_kills);
params->SetVal("max_hero_skill_lv", stats.max_hero_skill_lv);
{
params->SetVal("pve_rank_score", stats.pve_rank_score);
params->SetVal("pve_kill_boss", stats.pve_kill_boss);
}
{
std::string weapons_type;
std::string weapons_slot;
for (auto& pair : 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
});
}
}
params->SetVal("weapons_type", weapons_type);
params->SetVal("weapons_slot", weapons_slot);
}
{
std::string heros;
for (auto& pair : 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,
});
}
}
params->SetVal("heros", heros);
}
{
float rank_param = mt::RankReward::GetRankRewardParam(rank);
float kill_param = mt::KillReward::GetKillRewardParam(stats.kills);
int coin_num = (rank_param * mt::Param::s().rank_param) +
(kill_param * mt::Param::s().kill_param);
stats.gold = coin_num;
params->SetVal("coin_num", coin_num);
}
{
std::string items_str;
for (auto& pair : battlein_items) {
items_str += a8::Format("%d:%d|",
{pair.first,
pair.second
});
}
params->SetVal("items", items_str);
}
{
stats.pass_score = mt::KillPoint::GetKillPointParam1(stats.kills);
stats.pass_score += mt::RankPoint::GetRankPointParam1(rank);
stats.rank_score = mt::KillPoint::GetKillPointParam2(stats.kills);
stats.rank_score += mt::RankPoint::GetRankPointParam2(rank);
}
params->SetVal("score", 0);
params->SetVal("pass_score", has_pass ? stats.pass_score * 2 : stats.pass_score);
params->SetVal("rank_score", stats.rank_score);
{
params->SetVal("ranked_topx", stats.ranked_topx);
params->SetVal("kills_topx", stats.kills_topx);
params->SetVal("hero_topx", stats.hero_topx);
params->SetVal("weapon_topx", stats.weapon_topx);
params->SetVal("survival_topx", stats.survival_topx);
params->SetVal("hero_stats_uniid", stats.pb_hero_stats.hero_uniid);
params->SetVal("hero_stats_name", stats.pb_hero_stats.hero_name);
params->SetVal("hero_stats_hero_id", stats.pb_hero_stats.hero_id);
params->SetVal("hero_stats_reward_ceg", stats.pb_hero_stats.reward_ceg);
params->SetVal("hero_stats_today_get_ceg", stats.pb_hero_stats.today_get_ceg);
params->SetVal("hero_stats_ceg_uplimit", stats.pb_hero_stats.ceg_uplimit);
for (int i = 0; i < stats.pb_weapons_stats.size(); ++i) {
auto& p = stats.pb_weapons_stats.at(i);
std::string i_str = a8::XValue(i).GetString();
params->SetVal("weapon_stats_uniid" + i_str, p.weapon_uniid);
params->SetVal("weapon_stats_name" + i_str, p.weapon_name);
params->SetVal("weapon_stats_weapon_id" + i_str, p.weapon_id);
params->SetVal("weapon_stats_reward_ceg" + i_str, p.reward_ceg);
params->SetVal("weapon_stats_today_get_ceg" + i_str, p.today_get_ceg);
params->SetVal("weapon_stats_ceg_uplimit" + i_str, p.ceg_uplimit);
}
}
{
std::shared_ptr<a8::MutableXObject> post_data = a8::MutableXObject::CreateObject();
std::shared_ptr<a8::MutableXObject> team_list = a8::MutableXObject::CreateArray();
room->TraverseTeams
(
[team_list] (Team* team)
{
std::shared_ptr<a8::MutableXObject> team_data = a8::MutableXObject::CreateObject();
std::shared_ptr<a8::MutableXObject> members_list = a8::MutableXObject::CreateArray();
team->TraverseMembers
(
[members_list] (Human* hum)
{
std::shared_ptr<a8::MutableXObject> member = a8::MutableXObject::CreateObject();
member->SetVal("account_id", hum->account_id);
members_list->Push(*member.get());
return true;
});
team_data->SetVal("team_id", team->GetTeamId());
team_data->SetVal("members", *members_list.get());
team_list->Push(*team_data.get());
return true;
});
post_data->SetVal("team_list", *team_list.get());
params->SetVal("__POST", post_data->ToJsonStr());
}
}
void Human::DeadDrop()
{
#ifdef DEBUG
a8::XPrintf("DeadDrop\n", {});
//room->DropItem(GetPos(), 30908, 1, 1);
//return;
#endif
auto SkinCanDrop =
[this] (Skin* skin) -> bool
{
#ifdef DEBUG
return false;
#else
return skin->skin_id != 0;
#endif
};
if (a8::HasBitFlag(status, CS_DeadNoDrop)) {
return;
}
if (!(HasBuffEffect(kBET_Become) && GetBuffByEffectId(kBET_Become)->FreezeOperate())) {
for (auto& weapon : weapons) {
if (weapon.weapon_id != 0 &&
weapon.weapon_id != default_weapon.weapon_id
) {
Position drop_pos = GetPos();
room->DropItem(drop_pos, weapon.weapon_id, 1, 1);
if (weapon.ammo > 0 && weapon.bullet_meta && weapon.ammo < 200) {
if (IsPlayer() &&
weapon.bullet_meta &&
IsValidSlotId(weapon.bullet_meta->_inventory_slot())) {
AddInventory(weapon.bullet_meta->_inventory_slot(), weapon.ammo);
}
}
if (IsAndroid() && weapon.bullet_meta) {
int drop_num = weapon.bullet_meta->group_num();
room->DropItem(GetPos(), weapon.bullet_meta->id(), drop_num, 1);
}
weapon.Clear();
}
}
{
weapons[0] = default_weapon;
SetCurrWeapon(&weapons[0]);
}
}
{
Skin* old_skin = GetSkinByIdx(kSkinSlot_HAT);
if (old_skin && old_skin->skin_id != 0 && SkinCanDrop(old_skin)) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(old_skin->skin_id, drop_pos, 1, 1);
*old_skin = Skin();
}
}
{
Skin* old_skin = GetSkinByIdx(kSkinSlot_CLOTH);
if (old_skin && old_skin->skin_id != 0 && SkinCanDrop(old_skin)) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(old_skin->skin_id, drop_pos, 1, 1);
*old_skin = Skin();
}
}
{
//头盔
if (helmet != 0) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(helmet, drop_pos, 1, 1);
helmet = 0;
}
//衣服
if (chest != 0) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(chest, drop_pos, 1, 1);
chest = 0;
}
//背包
if (backpack != 0) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(backpack, drop_pos, 1, 1);
backpack = 0;
}
}
for (size_t slot = 0; slot < GetInventoryData().size(); ++slot) {
if (GetInventory(slot) > 0 && !mt::Param::s().fighting_mode) {
const mt::Equip* equip_meta = mt::Equip::GetByIdBySlotId(slot);
if (equip_meta) {
int drop_num = equip_meta->group_num();
if (equip_meta->equip_type() == EQUIP_TYPE_BULLET) {
switch (equip_meta->_inventory_slot()) {
case IS_FRAG:
case IS_SMOKE:
case IS_POSION_GAS_BOMB:
case IS_MOLOTOR_COCKTAIL:
case IS_TRAP:
case IS_MINE:
case IS_C4:
case IS_SHIELD_WALL:
case IS_SINGAL_GUN:
case IS_OIL_BUCKET:
{
if (drop_num > 0) {
Position drop_pos = GetPos();
if (IsPlayer()) {
room->DropItem(drop_pos, equip_meta->id(), GetInventory(slot), 1);
} else {
room->DropItem(drop_pos, equip_meta->id(), drop_num, 1);
}
DecInventory(slot, GetInventory(slot));
}
}
break;
default:
{
if (drop_num > 0) {
Position drop_pos = GetPos();
if (IsPlayer()) {
room->DropItem(drop_pos, equip_meta->id(), GetInventory(slot), 1);
} else {
#if 1
if (GetCurrWeapon()) {
}
#else
room->DropItem(drop_pos, equip_meta->id(), drop_num, 1);
#endif
}
DecInventory(slot, GetInventory(slot));
}
}
break;
}
} else {
Position drop_pos = GetPos();
room->DropItem(drop_pos, equip_meta->id(), GetInventory(slot), 1);
}
}
}
}
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
}
void Human::SendBattleReport()
{
std::shared_ptr<a8::MutableXObject> params = a8::MutableXObject::CreateObject();
GenBattleReportData(params.get());
std::string url;
JsonDataMgr::Instance()->GetApiUrl(url);
if (url.find('?') != std::string::npos) {
url += "c=Battle&a=battleReport";
} else {
url += "?c=Battle&a=battleReport";
}
std::string data;
params->ToUrlEncodeStr(data);
if (stats.is_run_away) {
sending_battlereport_ = false;
already_report_battle_ = true;
SendGameOver();
} else {
long long room_uuid = room->GetRoomUuid();
std::string sender_id = account_id;
HttpProxy::Instance()->HttpGet
(
[room_uuid, sender_id, data]
(bool ok, a8::XObject* rsp_obj, f8::HttpContext* ctx)
{
if (!ok) {
f8::UdpLog::Instance()->Error("battleReport http error params: %s response: %s",
{
data,
""
});
}
Room* room = RoomMgr::Instance()->GetRoomByUuid(room_uuid);
if (!room) {
return;
}
Player* hum = room->GetPlayerByAccountId(sender_id);
if (!hum) {
return;
}
if (ok) {
hum->sending_battlereport_ = false;
hum->already_report_battle_ = true;
hum->stats.ParseReward(hum, *rsp_obj);
hum->SendGameOver();
hum->SendBattleSettlement();
} else {
hum->sending_battlereport_ = false;
}
},
url.c_str(),
*params.get()
);
}
}
void Human::ProcLootSkin(AddItemDTO& dto)
{
switch (dto.item_meta->equip_subtype()) {
case 11:
{
//装饰
Skin* old_skin = GetSkinByIdx(kSkinSlot_HAT);
if (old_skin) {
if (old_skin->skin_id != 0) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(old_skin->skin_id, drop_pos, 1, 1);
}
*old_skin = Skin();
old_skin->skin_id = dto.item_meta->id();
old_skin->skin_lv = 1;
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
}
break;
case 12:
{
//衣服
Skin* old_skin = GetSkinByIdx(kSkinSlot_CLOTH);
if (old_skin) {
if (old_skin->skin_id != 0) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(dir * (40.0f + rand() % 50));
room->CreateLoot(old_skin->skin_id, drop_pos, 1, 1);
}
*old_skin = Skin();
old_skin->skin_id = dto.item_meta->id();
old_skin->skin_lv = 1;
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
}
break;
}
dto.handled = true;
}
void Human::ProcLootCar(AddItemDTO& dto)
{
DoGetOn(dto.uniid);
dto.handled = true;
}
void Human::ProcNormalItem(AddItemDTO& dto)
{
AddItem(dto.item_meta->id(), 1);
dto.handled = true;
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
}
void Human::ProcSpoils(AddItemDTO& dto)
{
dto.handled = true;
}
void Human::OnDie()
{
{
if (HasBuffEffect(kBET_Camouflage)) {
RemoveBuffByEffectId(kBET_Camouflage);
}
DoGetDown();
}
real_dead_frameno = room->GetFrameNo();
room->OnHumanDie(this);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
if (GetTeam()) {
GetTeam()->TraverseMembers
(
[this] (Human* member) -> bool
{
if (this != member &&
member->action_type == AT_Relive &&
member->action_target_id == GetUniId()) {
member->CancelAction();
}
return true;
});
}
if (real_dead) {
std::set<Human*> over_humans;
if (!leave_) {
if (!HasNoDownedTeammate()) {
if (GetTeam()) {
GetTeam()->GetOveredHumans(over_humans);
} else {
over_humans.insert(this);
}
} else {
over_humans.insert(this);
}
}
if (room->GetAliveTeamNum() == 1) {
Team* alive_team = room->GetAliveTeam();
if (alive_team) {
alive_team->GetOveredHumans(over_humans);
}
}
for (Human* hum : over_humans) {
hum->SendGameOver();
}
}
if (observers_.size() > 1) {
std::vector<Human*> exclude_self_observers;
for (auto& observer : observers_) {
if (observer != this) {
exclude_self_observers.push_back(observer);
}
}
for (auto& observer : exclude_self_observers) {
observers_.erase(observer);
observer->OnWatcherDie(this);
}
}
DeadDrop();
}
void Human::FreeDownedTimer()
{
RemoveBuffById(kDownBuffId);
if (!downed_timer.expired()) {
room->xtimer.Delete(downed_timer);
}
}
void Human::FreeReviveTimer()
{
if (!revive_timer.expired()) {
room->xtimer.Delete(revive_timer);
}
}
void Human::SetSkin(int idx, int skin_id)
{
if (idx < kSkinNum) {
Skin& skin = skins[idx];
skin.skin_id = skin_id;
skin.skin_lv = 1;
}
}
Skin* Human::GetSkinByIdx(int idx)
{
int i = 0;
for (auto& skin : skins) {
if (i == idx) {
return &skin;
}
++i;
}
return nullptr;
}
void Human::AddBuffPostProc(Creature* caster, Buff* buff)
{
}
int Human::GetItemNum(int item_id)
{
auto itr = items_.find(item_id);
return itr != items_.end() ? itr->second : 0;
}
void Human::DecItem(int item_id, int item_num)
{
auto itr = items_.find(item_id);
if (itr != items_.end()) {
itr->second -= item_num;
room->frame_event.AddItemChg(GetWeakPtrRef(), item_id, std::max(0, itr->second));
if (itr->second <= 0) {
if (battling_items_.find(item_id) == battling_items_.end()) {
//items_.erase(itr); //为啥?????
}
items_.erase(itr);
}
}
}
void Human::DropItems(Obstacle* obstacle)
{
bool is_treasure_box = false;
int drop_id = obstacle->meta->RandDrop();
if (drop_id == 0) {
return;
}
if (drop_id == 0) {
drop_id = obstacle->meta->RandDrop();
}
room->ScatterDrop(obstacle->GetPos(), drop_id);
if (is_treasure_box) {
++box_drop_times_;
} else {
++normal_drop_times_;
}
}
void Human::Revive()
{
{
int wait_revive_time = mt::Param::GetIntParam("revive_time", 25) +
kReviveTimeAdd;
revive_timer = room->xtimer.SetTimeoutWpEx
(SERVER_FRAME_RATE * wait_revive_time,
[this] (int event, const a8::Args* args)
{
if (a8::TIMER_EXEC_EVENT == event) {
dead = true;
real_dead = true;
downed = false;
OnDie();
}
},
&xtimer_attacher);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
}
void Human::CancelRevive()
{
if (dead && !revive_timer.expired() && !real_dead) {
dead = true;
real_dead = true;
downed = false;
FreeDownedTimer();
OnDie();
FreeReviveTimer();
}
}
void Human::AdjustDecHp(float old_health, float& new_health)
{
Buff* buff = GetBuffByEffectId(kBET_NewProtect);
if (buff) {
if (new_health < GetMaxHP() * buff->meta->_buff_param1) {
new_health = std::max(GetMaxHP() * buff->meta->_buff_param1, (float)0);
}
}
}
void Human::OnEnable()
{
a8::UnSetBitFlag(status, CS_Disable);
enable_frameno = room->GetFrameNo();
room->grid_service->MoveCreature(this);
FindLocation();
RefreshView();
}
void Human::OnDisable()
{
a8::SetBitFlag(status, CS_Disable);
RemoveFromScene();
framedata_.ClearFrameData(this);
ClearPartObjects();
}
void Human::GetViewObjects(std::set<Entity*>& view_objects)
{
TraverseCreatures
(
[&view_objects] (Creature* c, bool& stop)
{
view_objects.insert(c);
});
TraverseAllLayerEntityList
(
[&view_objects] (Entity* entity, bool& stop)
{
switch (entity->GetEntityType()) {
case ET_Building:
case ET_Obstacle:
case ET_Loot:
case ET_MapBlock:
{
view_objects.insert(entity);
}
break;
default:
{
}
break;
}
});
}
void Human::ProcIncGridList(std::set<GridCell*>& old_grids,
std::set<GridCell*>& inc_grids,
std::set<GridCell*>& dec_grids)
{
room->grid_service->TraverseCreatures
(
room->GetRoomIdx(),
inc_grids,
[this, &old_grids] (Creature* c, bool& stop)
{
if (!room->grid_service->CreatureInGridList(c, old_grids)) {
c->AddToNewObjects(this);
c->AddToPartObjects(this);
c->RemoveOutObjects(this);
AddToNewObjects(c);
AddToPartObjects(c);
RemoveOutObjects(c);
}
});
room->grid_service->TraverseAllLayerEntityList
(
room->GetRoomIdx(),
inc_grids,
[this] (Entity* entity, bool& stop)
{
switch (entity->GetEntityType()) {
case ET_Building:
case ET_Obstacle:
case ET_Loot:
case ET_MapBlock:
{
AddToNewObjects(entity);
RemoveOutObjects(entity);
}
break;
default:
{
}
break;
}
});
}
void Human::ProcDecGridList(std::set<GridCell*>& old_grids,
std::set<GridCell*>& inc_grids,
std::set<GridCell*>& dec_grids)
{
room->grid_service->TraverseCreatures
(
room->GetRoomIdx(),
dec_grids,
[this] (Creature* c, bool& stop)
{
if (!room->grid_service->CreatureInGridList(c, GetGridList())) {
AddOutObjects(c);
c->AddOutObjects(this);
#ifdef DEBUG
#if 0
f8::UdpLog::Instance()->Debug("addoutobjects %d %d",
{
(long long)c,
c->GetUniId()
});
#endif
#endif
}
});
room->grid_service->TraverseAllLayerEntityList
(
room->GetRoomIdx(),
dec_grids,
[this] (Entity* entity, bool& stop)
{
if (!room->grid_service->EntityInGridList(room, entity, GetGridList())) {
switch (entity->GetEntityType()) {
case ET_Building:
case ET_Obstacle:
case ET_Loot:
case ET_MapBlock:
{
AddOutObjects(entity);
}
break;
default:
{
}
break;
}
}
});
}
void Human::RemoveFromScene()
{
room->grid_service->DeatchHuman(this);
room->TraverseHumanList
(
[this] (Human* hum)
{
hum->RemovePartObjects(this);
return true;
});
}
void Human::ProcReloadAction()
{
Weapon* p_weapon = GetCurrWeapon();
if (second_weapon.meta) {
p_weapon = &second_weapon;
}
if (p_weapon->weapon_idx == action_target_id &&
p_weapon->weapon_id == action_item_id &&
p_weapon->weapon_idx != 0) {
const mt::Equip* bullet_meta = mt::Equip::GetById(p_weapon->meta->use_bullet());
if (bullet_meta) {
int ammo = p_weapon->ammo;
if (ammo < p_weapon->GetClipVolume(this)) {
if (bullet_meta->_inventory_slot() >= 0 &&
bullet_meta->_inventory_slot() < IS_END) {
if (GetInventory(bullet_meta->_inventory_slot()) > 0) {
int add_num = 0;
if (GetInventory(bullet_meta->_inventory_slot()) <=
p_weapon->GetClipVolume(this) - ammo) {
add_num = GetInventory(bullet_meta->_inventory_slot());
if (p_weapon->meta->reloadtype() == 1) {
add_num = 1;
}
DecInventory(bullet_meta->_inventory_slot(), add_num);
} else {
add_num = p_weapon->GetClipVolume(this) - ammo;
if (p_weapon->meta->reloadtype() == 1) {
add_num = 1;
}
DecInventory(bullet_meta->_inventory_slot(), add_num);
}
p_weapon->ammo += add_num;
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
if (p_weapon->meta->reloadtype() == 1) {
int weapon_idx = p_weapon->weapon_idx;
int weapon_id = p_weapon->weapon_id;
room->xtimer.SetTimeoutEx
(1,
[this, weapon_idx, weapon_id]
(int event, const a8::Args* args)
{
NextReload(weapon_id, weapon_idx);
},
&xtimer_attacher);
}
}
}
}
}
}
}
void Human::ProcUseItemAction()
{
const mt::Equip* item_meta = mt::Equip::GetByIdBySlotId(action_item_id);
if (!item_meta) {
return;
}
if (GetInventory(item_meta->_inventory_slot()) <= 0) {
return;
}
switch (action_item_id) {
case IS_HEALTHKIT:
{
+stats.use_medicine_times;
AddHp(item_meta->heal() * (1 + GetAbility()->GetAttrRate(kHAT_DrugEfficacy)));
DecInventory(item_meta->_inventory_slot(), 1);
GetTrigger()->UseItemAction(action_item_id);
}
break;
case IS_PAIN_KILLER:
{
+stats.use_medicine_times;
if (!pain_killer_timer.expired()) {
int passed_time = (room->GetFrameNo() - pain_killer_frameno) * FRAME_RATE_MS;
int left_time = std::max(0, pain_killer_lastingtime * 1000 - passed_time);
int anodyne_max_time = mt::Param::GetIntParam("anodyne_max_time");
left_time = std::min(left_time, anodyne_max_time * 1000);
pain_killer_lastingtime += std::min(item_meta->time() * 1000,
anodyne_max_time * 1000 - left_time) / 1000;
} else {
pain_killer_frameno = room->GetFrameNo();
pain_killer_lastingtime = item_meta->time();
if (pain_killer_lastingtime > 0) {
auto heal = item_meta->heal();
pain_killer_timer = room->xtimer.SetIntervalWpEx
(
SERVER_FRAME_RATE,
[this, heal] (int event, const a8::Args* args)
{
if (a8::TIMER_EXEC_EVENT == event) {
AddHp(heal);
if (room->GetFrameNo() - pain_killer_frameno >
pain_killer_lastingtime * SERVER_FRAME_RATE) {
room->xtimer.Delete(pain_killer_timer);
}
}
},
&xtimer_attacher);
}
AddHp(item_meta->heal());
}
DecInventory(item_meta->_inventory_slot(), 1);
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
GetTrigger()->UseItemAction(action_item_id);
}
break;
case IS_SHEN_BAO:
{
+stats.use_medicine_times;
if (!shen_bao_timer.expired()) {
a8::Args args({item_meta->time()});
room->xtimer.FireEvent(shen_bao_timer, kShenBaoAddTimeTimerEvent, &args);
} else {
int exec_time = 0;
int total_time = item_meta->time();
int heal = item_meta->heal();
shen_bao_timer = room->xtimer.SetIntervalWpEx
(
SERVER_FRAME_RATE,
[this, exec_time, total_time, heal] (int event, const a8::Args* args) mutable
{
if (a8::TIMER_EXEC_EVENT == event) {
exec_time += 1;
if (exec_time >= total_time || dead) {
room->xtimer.DeleteCurrentTimer();
} else {
AddHp(heal);
}
} else if (kShenBaoAddTimeTimerEvent == event) {
total_time += args->Get<int>(0);
}
},
&xtimer_attacher);
AddHp(heal);
}
DecInventory(item_meta->_inventory_slot(), 1);
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
GetTrigger()->UseItemAction(action_item_id);
}
break;
default:
{
}
break;
}
}
void Human::ProcReliveAction()
{
RemoveBuffByEffectId(kBET_Rescuer);
Entity* entity = room->GetEntityByUniId(action_target_id);
if (!entity->IsEntityType(ET_Player)) {
return;
}
Human* hum = (Human*)entity;
if (hum->action_type == AT_Rescue) {
hum->CancelAction();
}
if (!dead && downed) {
SetHP(mt::Param::GetFloatParam("downed_relive_recover_hp") * GetMaxHP());
downed = false;
if (!downed_timer.expired()) {
room->xtimer.Delete(downed_timer);
}
++hum->stats.rescue_member;
if (hum->guild_id != 0 && hum->guild_id == guild_id) {
++hum->stats.rescue_guild_member;
}
if (GetBuffById(kDownBuffId)) {
RemoveBuffById(kDownBuffId);
}
}
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
void Human::OnBuffRemove(Buff& buff)
{
Creature::OnBuffRemove(buff);
}
void Human::NextReload(int prev_weapon_id, int prev_weapon_idx)
{
if (action_type != AT_None) {
return;
}
Weapon* p_weapon = GetCurrWeapon();
if (second_weapon.meta) {
p_weapon = &second_weapon;
}
if (p_weapon &&
p_weapon->weapon_id == prev_weapon_id &&
p_weapon->weapon_idx == prev_weapon_idx) {
AutoLoadingBullet(true);
}
}
void Human::DoGetDown()
{
if (GetCar()) {
GetCar()->GetDown(this);
}
}
void Human::DoGetOnWithLoot(Loot* entity)
{
const mt::Equip* item_meta = mt::Equip::GetById(entity->item_id);
if (!item_meta) {
return;
}
if (GetCar()) {
GetCar()->GetDown(this);
}
Car* car = room->CreateCar(
this,
entity->GetUniId(),
item_meta,
entity->GetPos(),
team_id
);
car->GetOn(this);
#ifdef DEBUG
a8::XPrintf("DoGetOnWithLoot uniid:%d car_uniid:%d\n", {car->GetUniId(), car->car_uniid});
#endif
}
void Human::DoGetOnWithCar(Car* car)
{
car->GetOn(this);
}
void Human::DoSkillPreProc(int skill_id, int target_ids)
{
if (action_type == AT_Reload ||
action_type == AT_UseItem
) {
CancelAction();
}
}
void Human::DoSkillPostProc(bool used, int skill_id, int target_id)
{
if (used) {
++stats.skill_times;
Skill* skill = GetSkill(skill_id);
if (skill) {
skill->DecTimes();
room->frame_event.AddSkillCdChg(AllocWeakPtr(), skill_id, skill->GetLeftTime());
room->frame_event.AddSkillCurrTimesChg(AllocWeakPtr(), skill_id, skill->GetCurrTimes());
}
OnAttack();
}
}
float Human::GetRadius()
{
return meta->radius();
}
float Human::GetHitRadius()
{
return meta->hit_radius();
}
void Human::UpdateViewObjects()
{
if (view_objects_.size() >= 2) {
std::vector<Human*> deleted_humans;
for (Human* hum : view_objects_) {
if (hum->dead ||
hum->GetPos().ManhattanDistance2D(GetPos()) > mt::Param::s().view_objects_out_distance) {
deleted_humans.push_back(hum);
}
}
for (Human* hum : deleted_humans) {
view_objects_.erase(hum);
}
}
if (view_objects_.size() < 2) {
TraverseAllLayerHumanList
(
[this] (Human* hum, bool& stop)
{
if (hum->IsAndroid() && !hum->dead && view_objects_.find(hum) == view_objects_.end()) {
if (hum->GetPos().ManhattanDistance2D(GetPos()) <
mt::Param::s().view_objects_in_distance) {
view_objects_.insert(hum);
}
if (view_objects_.size() >= 2) {
stop = true;
return;
}
}
});
}
if (view_objects_.size() < 2) {
room->GetIncubator()->AllocAndroid(this, 1 + rand() % 2);
if (!refresh_view_timer_.expired()) {
room->xtimer.ModifyTime
(refresh_view_timer_,
SERVER_FRAME_RATE * (mt::Param::s().refresh_view_time + (rand() % 3))
);
}
}
}
void Human::GMAddItem(int item_id, int item_num)
{
const mt::Equip* item_meta = mt::Equip::GetById(item_id);
if (!item_meta) {
return;
}
AddItemDTO dto;
dto.uniid = 0;
dto.item_id = item_id;
dto.count = item_num;
dto.item_level = 1;
dto.handled = false;
dto.item_meta = item_meta;
ProcAddItemDto(dto);
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
void Human::OnBulletHit(IBullet* bullet)
{
if (IsInvincible()) {
return;
}
if (HasBuffEffect(kBET_Jump) ||
HasBuffEffect(kBET_Fly)) {
return;
}
{
Buff* buff = GetBuffByEffectId(kBET_Camouflage);
if (buff && buff->meta->_int_buff_param2 == 1) {
return;
}
}
#ifdef DEBUG
#if 0
if (IsPlayer()) {
return;
}
#endif
#endif
if (bullet->GetSender().Get()) {
bullet->GetSender().Get()->GetTrigger()->BulletHit(bullet, this);
}
RemoveBuffByEffectId(kBET_PeaceMode);
RemoveBuffByEffectId(kBET_Hide);
GetTrigger()->Attacked(bullet->GetSender().Get());
if (!dead && (bullet->IsBomb() || bullet->GetSender().Get()->team_id != team_id)) {
float finaly_dmg = 0;
if (bullet->GetSkillMeta() && SkillHelper::ProcBulletDmg(bullet, this, finaly_dmg)) {
} else {
finaly_dmg = bullet->GetSender().Get()->GetBattleContext()->CalcDmg(this, bullet);
}
if (bullet->GetSender().Get()->IsHuman()) {
bullet->GetSender().Get()->AsHuman()->stats.damage_amount_out += finaly_dmg;
}
if (bullet->GetBulletMeta()->_buff_meta) {
MustBeAddBuff(bullet->GetSender().Get(), bullet->GetBulletMeta()->buffid());
}
if (bullet->GetSender().Get()->GetBattleContext()->IsCrit()) {
room->frame_event.AddPropChg
(
GetWeakPtrRef(),
kPropCritDmg,
0,
bullet->GetSender().Get()->GetBattleContext()->GetCritDmg()
);
}
if (bullet->GetSender().Get() && bullet->GetSender().Get()->IsCar() && bullet->GetPassenger().Get()) {
if (!bullet->IsPreBattleBullet()) {
DecHP(finaly_dmg,
bullet->GetPassenger().Get()->GetUniId(),
bullet->GetPassenger().Get()->GetName(),
bullet->GetGunMeta()->id(),
bullet->GetPassenger().Get()->GetUniId(),
bullet->GetPassenger().Get()->GetName()
);
}
} else {
if (!bullet->IsPreBattleBullet()) {
if (bullet->GetSender().Get() && bullet->GetSender().Get()->IsHuman()) {
bullet->GetSender().Get()->AsHuman()->stats.IncWeaponDamageOut
(bullet->GetGunMeta()->id(), finaly_dmg);
}
DecHP(finaly_dmg,
bullet->GetSender().Get()->GetUniId(),
bullet->GetSender().Get()->GetName(),
bullet->GetGunMeta()->id(),
bullet->GetSender().Get()->GetUniId(),
bullet->GetSender().Get()->GetName()
);
}
}
}
}
void Human::OnExplosionHit(Explosion* e)
{
if (IsInvincible()) {
return;
}
if (dead) {
return;
}
if (e->IsPreBattleExplosion()) {
return;
}
if (HasBuffEffect(kBET_Jump) ||
HasBuffEffect(kBET_Fly)) {
return;
}
if (HasBuffEffect(kBET_Dive) && !mt::Param::s().dive_explosion_dmg_switch) {
return;
}
int real_killer_id = 0;
std::string real_killer_name;
if (e->GetSender().Get()) {
real_killer_id = e->GetSender().Get()->GetUniId();
real_killer_name = e->GetSender().Get()->GetName();
}
RemoveBuffByEffectId(kBET_PeaceMode);
float finaly_dmg = GetBattleContext()->CalcDmg(e);
#if 1
{
#else
if (e->GetSender().Get()) {
#endif
DecHP(finaly_dmg,
VP_Explosion,
"",
e->GetExplosionEffect(),
real_killer_id,
real_killer_name);
}
}
void Human::SendRollMsgEx(KillInfo& info,
const char* fmt,
std::initializer_list<a8::XValue> args
)
{
}
void Human::ProcUseItem(int item_id)
{
if (downed) {
return;
}
const mt::Equip* item_meta = mt::Equip::GetById(item_id);
if (item_meta && GetItemNum(item_id) > 0) {
if (item_meta->use_scene() == 1 && !HasBuffEffect(kBET_InWater)) {
SendSysPiaoMsg(TEXT("only_inwater_use", "only in water use"),
a8::MkRgb(255, 0, 0),
3
);
return;
}
if (GetCar() && item_meta->equip_type() == EQUIP_TYPE_CAMOUFLAGE) {
return;
}
std::shared_ptr<Ability> old_context_ability = context_ability;
glm::vec3 old_context_dir = context_dir;
Position old_context_pos = context_pos;
context_dir = GetAttackDir();
context_pos = GetPos();
if (item_meta->buffid() != 0) {
TryAddBuff(this, item_meta->buffid());
}
DecItem(item_id, 1);
context_dir = old_context_dir;
context_pos = old_context_pos;
context_ability = old_context_ability;
}
}
Weapon* Human::TakeonWeapon(const mt::Equip* equip_meta)
{
if (equip_meta->equip_type() != EQUIP_TYPE_WEAPON) {
return nullptr;
}
if (equip_meta->equip_subtype() == 1) {
return nullptr;
}
Weapon* weapon = nullptr;
for (int idx = GUN_SLOT1; idx <= GUN_SLOT2; ++idx) {
if (weapons[idx].weapon_id == 0) {
weapon = &weapons[idx];
weapon->weapon_idx = idx;
break;
}
}
return weapon;
}
void Human::StartRefreshViewTimer()
{
if (!refresh_view_timer_.expired()) {
return;
}
refresh_view_timer_ = room->xtimer.SetIntervalWpEx
(
SERVER_FRAME_RATE * mt::Param::s().refresh_view_time,
[this] (int event, const a8::Args* args)
{
if (a8::TIMER_EXEC_EVENT == event) {
UpdateViewObjects();
}
},
&xtimer_attacher);
}
void Human::ProcLootBag(AddItemDTO& dto)
{
const mt::Equip* old_item_meta = mt::Equip::GetById(backpack);
if (old_item_meta) {
if (old_item_meta->equip_lv() >= dto.item_meta->equip_lv()) {
return;
}
room->DropItem(GetPos(), old_item_meta->id(), 1, 1);
}
backpack = dto.item_meta->id();
RecalcVolume();
dto.handled = true;
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
void Human::ProcLootProtection(AddItemDTO& dto)
{
if (dto.item_meta->equip_subtype() == 1) {
//盔甲
const mt::Equip* old_item_meta = mt::Equip::GetById(chest);
if (old_item_meta) {
if (old_item_meta->equip_lv() >= dto.item_meta->equip_lv()) {
return;
}
room->DropItem(GetPos(), old_item_meta->id(), 1, 1);
}
chest = dto.item_meta->id();
RecalcBaseAttr();
} else if (dto.item_meta->equip_subtype() == 2) {
//头盔
const mt::Equip* old_item_meta = mt::Equip::GetById(helmet);
if (old_item_meta) {
if (old_item_meta->equip_lv() >= dto.item_meta->equip_lv()) {
return;
}
room->DropItem(GetPos(), old_item_meta->id(), 1, 1);
}
helmet = dto.item_meta->id();
RecalcBaseAttr();
}
dto.handled = true;
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
void Human::ProcLootSpecItem(AddItemDTO& dto)
{
if (dto.item_meta->_inventory_slot() >= 0 &&
dto.item_meta->_inventory_slot() < IS_END) {
if (GetInventory(dto.item_meta->_inventory_slot()) >=
GetVolume(dto.item_meta->_inventory_slot())
) {
return;
}
int add_num = GetVolume(dto.item_meta->_inventory_slot()) -
GetInventory(dto.item_meta->_inventory_slot());
add_num = std::min(dto.count, add_num);
AddInventory(dto.item_meta->_inventory_slot(), add_num);
switch (dto.item_meta->_inventory_slot()) {
case IS_FRAG:
case IS_SMOKE:
{
Weapon* weapon = &weapons[SPEC1_SLOT_BEGIN +
(dto.item_meta->_inventory_slot() - SPEC1_IS_BEGIN)
];
weapon->weapon_id = dto.item_id;
weapon->ammo += dto.count;
weapon->meta = dto.item_meta;
weapon->Recalc();
#if 0
DecInventory(dto.item_meta->_inventory_slot(), add_num);
#endif
}
break;
case IS_1XSCOPE:
case IS_2XSCOPE:
case IS_4XSCOPE:
case IS_8XSCOPE:
case IS_15XSCOPE:
{
if (dto.item_meta->_inventory_slot() - IS_1XSCOPE > curr_scope_idx) {
curr_scope_idx = dto.item_meta->_inventory_slot() - IS_1XSCOPE;
}
}
break;
case IS_POSION_GAS_BOMB:
case IS_MOLOTOR_COCKTAIL:
case IS_TRAP:
case IS_MINE:
{
Weapon* weapon = &weapons[SPEC2_SLOT_BEGIN +
(dto.item_meta->_inventory_slot() - SPEC2_IS_BEGIN)
];
weapon->weapon_id = dto.item_id;
weapon->ammo += dto.count;
weapon->meta = dto.item_meta;
weapon->Recalc();
#if 0
DecInventory(dto.item_meta->_inventory_slot(), add_num);
#endif
}
break;
case IS_C4:
case IS_SHIELD_WALL:
case IS_SINGAL_GUN:
case IS_OIL_BUCKET:
{
Weapon* weapon = &weapons[SPEC3_SLOT_BEGIN +
(dto.item_meta->_inventory_slot() - SPEC3_IS_BEGIN)
];
weapon->weapon_id = dto.item_id;
weapon->ammo += dto.count;
weapon->meta = dto.item_meta;
weapon->Recalc();
#if 0
DecInventory(dto.item_meta->_inventory_slot(), add_num);
#endif
}
break;
default:
{
int i = 0;
#if 0
A8_ABORT();
#endif
}
break;
}
if (add_num < dto.count) {
//刷新数量
Entity* entity = room->GetEntityByUniId(dto.uniid);
if (entity && entity->IsEntityType(ET_Loot)) {
((Loot*)entity)->count -= add_num;
((Loot*)entity)->BroadcastFullState(room);
}
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
if (action_type == AT_None) {
AutoLoadingBullet();
}
return;
}
}
if (action_type == AT_None) {
AutoLoadingBullet();
}
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
dto.handled = true;
}
void Human::ProcGiftPackage(AddItemDTO& dto)
{
if (dto.item_meta->equip_type() == EQUIP_TYPE_GIFT_PACKAGE) {
const mt::Drop* drop_meta = mt::Drop::GetById(dto.item_meta->drop_id());
if (drop_meta) {
std::vector<std::tuple<int, int, int>> drop_items;
drop_meta->RandItems(drop_items);
for (auto& item : drop_items) {
int item_id = std::get<0>(item);
int item_num = std::get<1>(item);
auto itr = battlein_items.find(item_id);
if (itr != battlein_items.end()) {
itr->second += item_num;
} else {
battlein_items[item_id] = item_num;
}
}
}
}
dto.handled = true;
}
void Human::ProcLootWeapon(AddItemDTO& dto)
{
//装备
if (dto.item_meta->equip_subtype() == 1) {
//近战
if (default_weapon.weapon_id != weapons[0].weapon_id) {
return;
} else {
weapons[0].weapon_idx = 0;
weapons[0].weapon_id = dto.item_id;
weapons[0].ammo = 0;
weapons[0].meta = dto.item_meta;
weapons[0].Recalc();
}
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
} else {
if (FreezeOperate()) {
return;
}
bool switch_gun = false;
Weapon* weapon = TakeonWeapon(dto.item_meta);
if (weapon && GetCurrWeapon() != weapon) {
if (GetCurrWeapon()->weapon_idx == 0) {
switch_gun = true;
}
}
if (!weapon) {
return;
}
weapon->weapon_id = dto.item_id;
weapon->ammo = 0;
weapon->meta = dto.item_meta;
weapon->Recalc();
if (HasBuffEffect(kBET_Car)) {
} else {
AutoLoadingBullet();
}
if (switch_gun) {
SetCurrWeapon(weapon);
}
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
dto.handled = true;
}
void Human::LootInteraction(Loot* entity)
{
#ifdef DEBUG
a8::XPrintf("LootInteraction start %d:%d\n", {entity->GetUniId(), entity->item_id});
#endif
if (entity->pickuped ||
entity->count <= 0) {
#ifdef DEBUG
a8::XPrintf("LootInteraction error1 %d:%d\n", {entity->GetUniId(), entity->item_id});
#endif
return;
}
AddItemDTO dto;
dto.uniid = entity->GetUniId();
dto.item_id = entity->item_id;
dto.count = entity->count;
dto.item_level = entity->item_level;
dto.handled = false;
dto.item_meta = mt::Equip::GetById(entity->item_id);
ProcAddItemDto(dto);
if (dto.handled) {
entity->pickuped = true;
room->RemoveObjectLater(entity);
}
}
void Human::ProcAddItemDto(AddItemDTO& dto)
{
if (!dto.item_meta) {
#ifdef DEBUG
a8::XPrintf("LootInteraction error20 %d:%d\n", {dto.uniid, dto.item_id});
#endif
return;
}
switch (dto.item_meta->equip_type()) {
case EQUIP_TYPE_WEAPON:
{
ProcLootWeapon(dto);
}
break;
case EQUIP_TYPE_PROTECTION:
{
ProcLootProtection(dto);
}
break;
case EQUIP_TYPE_BAG:
{
ProcLootBag(dto);
}
break;
case EQUIP_TYPE_OLDSKIN:
{
A8_ABORT();
}
break;
case EQUIP_TYPE_SKIN:
{
ProcLootSkin(dto);
}
break;
case EQUIP_TYPE_CAR:
{
ProcLootCar(dto);
}
break;
case EQUIP_TYPE_SPOILS:
{
ProcSpoils(dto);
}
break;
case EQUIP_TYPE_CAMOUFLAGE:
case EQUIP_TYPE_SINGAL_EMITTER:
{
ProcNormalItem(dto);
}
break;
case EQUIP_TYPE_GIFT_PACKAGE:
{
ProcGiftPackage(dto);
}
break;
default:
{
ProcLootSpecItem(dto);
}
break;
}
}
void Human::DropWeapon(int weapon_idx, int num)
{
num = std::max(1, num);
switch (weapon_idx) {
case 101:
case 102:
case 103:
{
int slot_id = -1;
if (weapon_idx == 101) {
slot_id = IS_HEALTHKIT;
} else if (weapon_idx == 102) {
slot_id = IS_PAIN_KILLER;
} else if (weapon_idx == 103) {
slot_id = IS_SHEN_BAO;
}
if (slot_id >= 0 && GetInventory(slot_id) > 0) {
const mt::Equip* item_meta = mt::Equip::GetByIdBySlotId(slot_id);
if (item_meta) {
num = std::max(1, GetInventory(slot_id));
DecInventory(slot_id, num);
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
glm::vec3 drop_dir = GlmHelper::UP;
GlmHelper::RotateY(drop_dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.AddGlmVec3(drop_dir * (25.0f + rand() % 50));
room->DropItem(drop_pos, item_meta->id(), num, 1);
}
}
return;
}
default:
{
}
break;
}
if (weapon_idx < 0 ||
weapon_idx >= weapons.size()) {
return;
}
bool drop_ok = false;
Weapon* weapon = &weapons[weapon_idx];
int weapon_id = weapon->weapon_id;
int weapon_ammo = weapon->ammo;
const mt::Equip* weapon_meta = weapon->meta;
if (weapon->weapon_id != 0) {
switch (weapon->weapon_idx) {
case GUN_SLOT0:
{
if (weapon->weapon_id != default_weapon.weapon_id) {
drop_ok = true;
*weapon = default_weapon;
}
}
break;
case GUN_SLOT1:
{
drop_ok = true;
*weapon = Weapon();
weapon->weapon_idx = weapon_idx;
if (GetCurrWeapon() == weapon) {
if (weapons[GUN_SLOT2].weapon_id != 0) {
SetCurrWeapon(&weapons[GUN_SLOT2]);
} else {
SetCurrWeapon(&weapons[0]);
}
}
}
break;
case GUN_SLOT2:
{
drop_ok = true;
*weapon = Weapon();
weapon->weapon_idx = weapon_idx;
if (GetCurrWeapon() == weapon) {
if (weapons[GUN_SLOT1].weapon_id != 0) {
SetCurrWeapon(&weapons[GUN_SLOT1]);
} else {
SetCurrWeapon(&weapons[0]);
}
}
}
break;
case FRAG_SLOT:
{
weapon_ammo = std::min(weapon->ammo, num);
if (weapon_ammo > 0) {
drop_ok = true;
weapon->ammo = std::max(0, weapon->ammo - weapon_ammo);
int slot_id = weapon->meta->_inventory_slot();
DecInventory(slot_id, weapon_ammo);
if (weapon->ammo <= 0) {
*weapon = Weapon();
weapon->weapon_idx = weapon_idx;
if (GetCurrWeapon() == weapon) {
if (weapons[GUN_SLOT1].weapon_id != 0) {
SetCurrWeapon(&weapons[GUN_SLOT1]);
} else if (weapons[GUN_SLOT2].weapon_id != 0) {
SetCurrWeapon(&weapons[GUN_SLOT2]);
} else {
SetCurrWeapon(&weapons[0]);
}
}
}
}
}
break;
case SMOKE_SLOT:
{
weapon_ammo = std::min(weapon->ammo, num);
if (weapon_ammo > 0) {
drop_ok = true;
weapon->ammo = std::max(0, weapon->ammo - weapon_ammo);
int slot_id = weapon->meta->_inventory_slot();
DecInventory(slot_id, weapon_ammo);
if (weapon->ammo <= 0) {
*weapon = Weapon();
weapon->weapon_idx = weapon_idx;
if (GetCurrWeapon() == weapon) {
if (weapons[GUN_SLOT1].weapon_id != 0) {
SetCurrWeapon(&weapons[GUN_SLOT1]);
} else if (weapons[GUN_SLOT2].weapon_id != 0) {
SetCurrWeapon(&weapons[GUN_SLOT2]);
} else {
SetCurrWeapon(&weapons[0]);
}
}
}
}
}
break;
default:
{
weapon_ammo = std::min(weapon->ammo, num);
if (weapon_ammo > 0) {
drop_ok = true;
weapon->ammo = std::max(0, weapon->ammo - weapon_ammo);
int slot_id = weapon->meta->_inventory_slot();
DecInventory(slot_id, weapon_ammo);
if (weapon->ammo <= 0) {
*weapon = Weapon();
weapon->weapon_idx = weapon_idx;
if (GetCurrWeapon() == weapon) {
Weapon* next_weapon = ChooseNextSpecWeapon(weapon_idx);
if (!next_weapon) {
next_weapon = AutoChgWeapon();
}
if (next_weapon) {
SetCurrWeapon(next_weapon);
}
}
}
}
}
break;
}
if (drop_ok) {
bool create_loot = true;
if (weapon_ammo > 0) {
const mt::Equip* bullet_meta = mt::Equip::GetById(weapon_meta->use_bullet());
if (bullet_meta && bullet_meta->_inventory_slot() > 0) {
#if 1
int drop_num = weapon_ammo;
#else
int volume = GetVolume(bullet_meta->_inventory_slot());
int inventory = GetInventory(bullet_meta->_inventory_slot());
int add_inventory = std::min(weapon_ammo, volume - std::min(volume, inventory));
if (add_inventory > 0 &&
!(weapon_idx == FRAG_SLOT || weapon_idx == SMOKE_SLOT)) {
AddInventory(bullet_meta->_inventory_slot(), add_inventory);
}
int drop_num = weapon_ammo - add_inventory;
#endif
if (drop_num > 0) {
glm::vec3 drop_dir = GlmHelper::UP;
GlmHelper::RotateY(drop_dir, a8::RandAngle());
Position drop_pos = GetPos();
drop_pos.FromGlmVec3(GetPos().ToGlmVec3() + drop_dir * (25.0f + rand() % 50));
#if 1
{
room->DropItem(drop_pos, bullet_meta->id(), drop_num, 1);
create_loot = false;
}
#else
if (bullet_meta->_inventory_slot() == IS_FRAG ||
bullet_meta->_inventory_slot() == IS_SMOKE) {
//只有手雷和烟雾弹会掉落
room->DropItem(drop_pos, bullet_meta->id(), drop_num, 1);
create_loot = false;
}
#endif
}
}
}
if (create_loot ||
weapon_idx == GUN_SLOT0 ||
weapon_idx == GUN_SLOT1 ||
weapon_idx == GUN_SLOT2) {
glm::vec3 dir = GlmHelper::UP;
GlmHelper::RotateY(dir, a8::RandAngle());
Position pos = GetPos();
pos.FromGlmVec3(GetPos().ToGlmVec3() + dir * (40.0f + rand() % 50));
room->CreateLoot(weapon_id, pos, 1, 1);
}
MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
SyncAroundPlayers(__FILE__, __LINE__, __func__);
}
}
}
void Human::DoFollow(int target_id)
{
if (target_id == 0){
if (follow_target.Get()) {
follow_target.Detach();
room->frame_event.AddPropChg(GetWeakPtrRef(), kPropFollowTarget, 0, 0, true);
if (!follow_target_timer_.expired()) {
room->xtimer.Delete(follow_target_timer_);
}
}
} else {
if (GetTeam()) {
Human* member = GetTeam()->GetMemberByUniId(target_id);
if (member && member->CanFollow(this)) {
#ifdef DEBUG
a8::XPrintf("DoFollow %d->%d\n", {GetUniId(), member->GetUniId()});
#endif
if (follow_target.Get()) {
follow_target.Detach();
if (!follow_target_timer_.expired()) {
room->xtimer.Delete(follow_target_timer_);
}
}
follow_target_last_chg_move_dir_times_ = -1;
follow_target.Attach(member);
room->frame_event.AddPropChg(GetWeakPtrRef(), kPropFollowTarget, 0, target_id, true);
follow_target_timer_ = room->xtimer.SetIntervalWpEx
(
400 / FRAME_RATE_MS,
[this] (int event, const a8::Args* args)
{
if (a8::TIMER_EXEC_EVENT == event) {
if (!follow_target.Get()) {
if (IsPlayer()) {
AsPlayer()->moving = false;
AsPlayer()->moved_frames = 0;
}
room->xtimer.DeleteCurrentTimer();
return;
}
if (room->GetGasData().GetGasMode() != GasInactive &&
!(follow_target.Get()->HasBuffEffect(kBET_Fly) ||
follow_target.Get()->HasBuffEffect(kBET_Jump))
){
if (IsPlayer()) {
AsPlayer()->moving = false;
AsPlayer()->moved_frames = 0;
}
follow_target.Detach();
room->xtimer.DeleteCurrentTimer();
return;
}
if (follow_target.Get()->HasBuffEffect(kBET_Jump)) {
if (HasBuffEffect(kBET_Jump)) {
FollowToTarget();
} else {
DoJump();
}
}
}
},
&xtimer_attacher);
}
}
}
IncFollowTimes();
}
void Human::DoDive()
{
if (!HasBuffEffect(kBET_InWater)) {
return;
}
if (HasBuffEffect(kBET_Dive)) {
return;
}
if (HasBuffEffect(kBET_Driver) ||
HasBuffEffect(kBET_Passenger)) {
return;
}
if (HasBuffEffect(kBET_Become)) {
return;
}
if (HasBuffEffect(kBET_Camouflage) ) {
RemoveBuffByEffectId(kBET_Camouflage);
}
MustBeAddBuff(this, kDiveBuffId);
}
void Human::OnWatcherDie(Human* watcher)
{
if (follow_target_ == watcher) {
if (socket_handle != 0 && IsPlayer()) {
((Player*)this)->AsyncRequestWatchWar(true);
}
} else {
#ifdef DEBUG
A8_ABORT();
#endif
}
}
void Human::TraverseObservers(std::function<void (Human*, bool&)> func)
{
bool stop;
for (auto& observer : observers_) {
func(observer, stop);
if (stop) {
break;
}
}
}
void Human::AddOxygen(int val)
{
oxygen_ += val;
oxygen_ = std::min(mt::Param::s().dive_oxygen_total, oxygen_);
}
void Human::DecOxygen(int val)
{
oxygen_ -= val;
oxygen_ = std::max(0, oxygen_);
}
void Human::WinPveScore(int score)
{
stats.pve_rank_score += score;
}
void Human::InternalBeKill(int killer_id, const std::string& killer_name, int weapon_id,
int real_killer_id, const std::string& real_killer_name)
{
#ifdef DEBUG
if (IsPlayer()) {
a8::XPrintf("BeKill %d\n", {GetUniId()});
}
#endif
if (!dead && !room->IsGameOver() && !real_dead) {
KillInfo info;
{
info.killer_id = killer_id;
info.killer_name = killer_name;
info.weapon_id = weapon_id;
info.real_killer_id = real_killer_id;
info.real_killer_name = real_killer_name;
}
{
++stats.dead_times;
stats.killer_id = real_killer_id;
stats.killer_name = real_killer_name;
stats.weapon_id = weapon_id;
}
{
Entity* killer = room->GetEntityByUniId(real_killer_id);
if (killer && killer->IsCreature(room)) {
((Creature*)killer)->GetTrigger()->Kill(this, weapon_id);
}
}
if (room->IsPveRoom()) {
dead = true;
real_dead = false;
downed = false;
SetHP(0.0f);
if (real_killer_id != GetUniId() && GetTeam() && GetTeam()->HasReviveCoin(this)) {
real_dead = true;
dead_frameno = room->GetFrameNo();
GetTrigger()->Die(killer_id, weapon_id);
if (real_dead) {
real_dead = false;
OnDie();
KillMgr::Instance()->OnHumanDead(this, &info);
room->frame_event.AddDead(GetWeakPtrRef(), 1000 * mt::Param::s().revive_time);
dead_timer = room->xtimer.SetTimeoutWpEx
(mt::Param::s().revive_time * SERVER_FRAME_RATE,
[this] (int event, const a8::Args* args)
{
if (a8::TIMER_EXEC_EVENT == event) {
real_dead = true;
SendGameOver();
}
},
&xtimer_attacher);
} else {
OnDie();
KillMgr::Instance()->OnHumanDead(this, &info);
room->frame_event.AddDead(GetWeakPtrRef(), 0);
}
} else {
real_dead = true;
dead_frameno = room->GetFrameNo();
GetTrigger()->Die(killer_id, weapon_id);
OnDie();
KillMgr::Instance()->OnHumanDead(this, &info);
room->frame_event.AddDead(GetWeakPtrRef(), 0);
}
} else {
dead = true;
real_dead = true;
downed = false;
SetHP(0.0f);
dead_frameno = room->GetFrameNo();
GetTrigger()->Die(killer_id, weapon_id);
OnDie();
KillMgr::Instance()->OnHumanDead(this, &info);
room->frame_event.AddDead(GetWeakPtrRef(), 0);
}
}
}
int Human::GetTeamMode()
{
return GetTeam()->GetMemberNum() <= 1 ? 0 : 1;
}
void Human::CalcAssists(Human* target)
{
if (GetTeam() && GetTeam()->GetMemberNum() > 1) {
GetTeam()->TraverseMembers
(
[target, this] (Human* hum)
{
if (hum->GetUniId() == this->GetUniId()) {
return true;
}
int assist_time = mt::Param::GetIntParam("assist_time", 5);
auto itr = target->attacker_hash_.find(hum->GetUniId());
if (itr != target->attacker_hash_.end()) {
if (hum->room->GetFrameNo() - itr->second <
SERVER_FRAME_RATE * assist_time) {
++hum->stats.assist;
}
}
return true;
});
}
}
Reference in New Issue View Git Blame Copy Permalink