937 lines
28 KiB
C++
937 lines
28 KiB
C++
#include "precompile.h"
|
|
|
|
#include <float.h>
|
|
|
|
#include "creature.h"
|
|
#include "metamgr.h"
|
|
#include "room.h"
|
|
#include "skill.h"
|
|
#include "human.h"
|
|
|
|
void InternalShot(Creature* c,
|
|
MetaData::Equip* weapon_meta,
|
|
MetaData::EquipUpgrade* weapon_upgrade_meta,
|
|
MetaData::Equip* bullet_meta,
|
|
int weapon_lv,
|
|
int skill_id,
|
|
float fly_distance,
|
|
bool is_tank_skin)
|
|
{
|
|
for (auto& tuple : weapon_meta->bullet_born_offset) {
|
|
a8::Vec2 bullet_born_offset = a8::Vec2(std::get<0>(tuple), std::get<1>(tuple));
|
|
bullet_born_offset.Rotate(c->attack_dir.CalcAngle(a8::Vec2::UP));
|
|
a8::Vec2 bullet_born_pos = c->GetPos() + bullet_born_offset;
|
|
if (c->room->OverBorder(bullet_born_pos, 0)) {
|
|
return;
|
|
}
|
|
}
|
|
c->room->frame_event.AddShot(c);
|
|
for (auto& tuple : weapon_meta->bullet_born_offset) {
|
|
a8::Vec2 bullet_born_offset = a8::Vec2(std::get<0>(tuple), std::get<1>(tuple));
|
|
bullet_born_offset.Rotate(c->attack_dir.CalcAngle(a8::Vec2::UP));
|
|
a8::Vec2 bullet_born_pos = c->GetPos() + bullet_born_offset;
|
|
a8::Vec2 bullet_dir = c->attack_dir;
|
|
float bullet_angle = std::get<2>(tuple);
|
|
if (weapon_meta->i->bullet_angle() >= 0.10f) {
|
|
int angle = (int)weapon_meta->i->bullet_angle() * 1000;
|
|
if (angle > 0) {
|
|
bullet_angle += (rand() % angle) / 1000.0f * (rand() % 2 == 0 ? 1 : -1);
|
|
}
|
|
}
|
|
bullet_dir.Rotate(bullet_angle / 180.0f);
|
|
#if 0
|
|
if (hum->GetCar()) {
|
|
bullet_born_pos.x += MetaMgr::Instance()->horse_shoot_x;
|
|
bullet_born_pos.y += MetaMgr::Instance()->horse_shoot_y;
|
|
}
|
|
#endif
|
|
c->room->frame_event.AddBullet(c,
|
|
weapon_meta,
|
|
weapon_lv,
|
|
bullet_born_pos,
|
|
bullet_dir,
|
|
fly_distance);
|
|
if (c->room->BattleStarted() ||
|
|
(c->room->GetGasData().gas_mode == GasJump &&
|
|
!c->HasBuffEffect(kBET_Jump))) {
|
|
c->room->CreateBullet(c,
|
|
weapon_meta,
|
|
weapon_upgrade_meta,
|
|
bullet_meta,
|
|
bullet_born_pos,
|
|
bullet_dir,
|
|
fly_distance,
|
|
is_tank_skin);
|
|
}
|
|
}
|
|
}
|
|
|
|
Creature::Creature():MoveableEntity()
|
|
{
|
|
weak_ptr_chunk_.Set(this);
|
|
}
|
|
|
|
Creature::~Creature()
|
|
{
|
|
for (auto& pair : skill_hash_) {
|
|
delete pair.second;
|
|
}
|
|
skill_hash_.clear();
|
|
ClearPassiveSkill();
|
|
}
|
|
|
|
bool Creature::HasBuffEffect(int buff_effect_id)
|
|
{
|
|
return GetBuffByEffectId(buff_effect_id) != nullptr;
|
|
}
|
|
|
|
Buff* Creature::GetBuffByEffectId(int effect_id)
|
|
{
|
|
return IsValidBuffEffect(effect_id) ? buff_effect_[effect_id] : nullptr;
|
|
}
|
|
|
|
Buff* Creature::GetBuffById(int buff_id)
|
|
{
|
|
for (Buff& buff : buff_list_) {
|
|
if (buff.meta->i->buff_id() == buff_id) {
|
|
return &buff;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void Creature::AddBuff(Creature* caster,
|
|
MetaData::Buff* buff_meta,
|
|
int skill_lv,
|
|
MetaData::Skill* buff_skill_meta)
|
|
{
|
|
if (GetBuffById(buff_meta->i->buff_id())) {
|
|
return;
|
|
}
|
|
if (IsImmuneBuffEffect(buff_meta->i->buff_effect())) {
|
|
return;
|
|
}
|
|
if (!buff_meta->EffectCanStack()) {
|
|
Buff* buff = GetBuffByEffectId(buff_meta->i->buff_effect());
|
|
if (buff) {
|
|
RemoveBuffById(buff->meta->i->buff_id());
|
|
}
|
|
}
|
|
if (buff_meta->i->buff_effect() == kBET_OnceChgAttr) {
|
|
if ((int)buff_meta->param1== kHAT_Hp) {
|
|
if ((int)buff_meta->param2 == 1) {
|
|
//绝对值
|
|
ability.hp += buff_meta->param3;
|
|
ability.hp = std::min(ability.max_hp, ability.hp);
|
|
} else if ((int)buff_meta->param2 == 2) {
|
|
//百分比
|
|
ability.hp *= 1 + buff_meta->param3;
|
|
ability.hp = std::min(ability.max_hp, ability.hp);
|
|
}
|
|
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
|
}
|
|
}
|
|
Buff* buff = &a8::FastAppend(buff_list_);
|
|
buff->skill_lv = skill_lv;
|
|
buff->owner = this;
|
|
buff->meta = buff_meta;
|
|
buff->skill_meta = buff_skill_meta;
|
|
buff->add_frameno = room->GetFrameNo();
|
|
buff->xtimer_attacher.xtimer = &room->xtimer;
|
|
buff_effect_[buff->meta->i->buff_effect()] = buff;
|
|
{
|
|
room->xtimer.AddDeadLineTimerAndAttach
|
|
(
|
|
buff_meta->i->duration_time() * SERVER_FRAME_RATE,
|
|
a8::XParams()
|
|
.SetSender(this)
|
|
.SetParam1(buff_meta->i->buff_id()),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
Creature* c = (Creature*)param.sender.GetUserData();
|
|
c->RemoveBuffById(param.param1);
|
|
},
|
|
&buff->xtimer_attacher.timer_list_
|
|
);
|
|
}
|
|
ProcBuffEffect(caster, buff);
|
|
AddBuffPostProc(caster, buff);
|
|
#ifdef DEBUG
|
|
SendDebugMsg(a8::Format("添加buff_id:%d buff_effect:%d",
|
|
{
|
|
buff_meta->i->buff_id(),
|
|
buff_meta->i->buff_effect()
|
|
}));
|
|
#endif
|
|
}
|
|
|
|
bool Creature::IsImmuneBuffEffect(int buff_effect)
|
|
{
|
|
for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
|
|
if (itr->meta->IsImmuneBuffEffect(buff_effect)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Creature::MustBeAddBuff(Creature* caster, int buff_id)
|
|
{
|
|
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(buff_id);
|
|
if (!buff_meta) {
|
|
abort();
|
|
}
|
|
AddBuff(caster, buff_meta, 1);
|
|
}
|
|
|
|
void Creature::RemoveBuffById(int buff_id)
|
|
{
|
|
for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
|
|
const Buff& buff = *itr;
|
|
if (buff.meta->i->buff_id() == buff_id) {
|
|
if (buff_effect_[buff.meta->i->buff_effect()] == &(*itr)) {
|
|
buff_effect_[buff.meta->i->buff_effect()] = nullptr;
|
|
}
|
|
OnBuffRemove(buff);
|
|
buff_list_.erase(itr);
|
|
break;
|
|
}
|
|
}
|
|
RecalcBuffAttr();
|
|
#ifdef DEBUG
|
|
SendDebugMsg(a8::Format("移除buff_id:%d",
|
|
{
|
|
buff_id
|
|
}));
|
|
#endif
|
|
}
|
|
|
|
void Creature::SendDebugMsg(const std::string& debug_msg)
|
|
{
|
|
|
|
}
|
|
|
|
void Creature::AddBuffPostProc(Creature* caster, Buff* buff)
|
|
{
|
|
|
|
}
|
|
|
|
void Creature::RecalcBuffAttr()
|
|
{
|
|
buff_attr_abs_ = {};
|
|
buff_attr_rate_ = {};
|
|
for (auto& buff : buff_list_) {
|
|
if (buff.meta->i->buff_effect() == kBET_ChgAttr ||
|
|
buff.meta->i->buff_effect() == kBET_Car) {
|
|
int attr_type = (int)buff.meta->param1;
|
|
int calc_type = (int)buff.meta->param2;
|
|
if (IsValidHumanAttr(attr_type)) {
|
|
if (calc_type == 1) {
|
|
buff_attr_abs_[attr_type] += buff.meta->param3;
|
|
} else if (calc_type == 2) {
|
|
buff_attr_rate_[attr_type] += buff.meta->param3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Creature::OnBuffRemove(const Buff& buff)
|
|
{
|
|
|
|
}
|
|
|
|
void Creature::RemoveBuffByEffectId(int buff_effect_id)
|
|
{
|
|
Buff* buff = GetBuffByEffectId(buff_effect_id);
|
|
if (buff) {
|
|
RemoveBuffById(buff->meta->i->buff_id());
|
|
}
|
|
}
|
|
|
|
void Creature::ClearBuffList()
|
|
{
|
|
for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
|
|
if (buff_effect_[itr->meta->i->buff_effect()] == &(*itr)) {
|
|
buff_effect_[itr->meta->i->buff_effect()] = nullptr;
|
|
}
|
|
OnBuffRemove(*itr);
|
|
}
|
|
buff_list_.clear();
|
|
buff_effect_ = {};
|
|
buff_attr_abs_ = {};
|
|
buff_attr_rate_ = {};
|
|
RecalcBuffAttr();
|
|
}
|
|
|
|
float Creature::GetBuffAttrAbs(int attr_type)
|
|
{
|
|
if (IsValidHumanAttr(attr_type)) {
|
|
return buff_attr_abs_[attr_type];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
float Creature::GetBuffAttrRate(int attr_type)
|
|
{
|
|
if (IsValidHumanAttr(attr_type)) {
|
|
return buff_attr_rate_[attr_type];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Creature::FillBuffList(::google::protobuf::RepeatedPtrField<::cs::MFBuff>* pb_buff_list)
|
|
{
|
|
for (auto& itr : buff_list_) {
|
|
auto buff = pb_buff_list->Add();
|
|
itr.FillMFBuff(buff);
|
|
}
|
|
}
|
|
|
|
void Creature::FillSkillList(::google::protobuf::RepeatedPtrField< cs::MFSkill >*
|
|
pb_skill_list)
|
|
{
|
|
for (auto& pair : skill_hash_) {
|
|
auto skill = pb_skill_list->Add();
|
|
pair.second->FillMFSkill(skill);
|
|
}
|
|
}
|
|
|
|
void Creature::AddPassiveSkill(int skill_id)
|
|
{
|
|
MetaData::Skill* skill_meta = MetaMgr::Instance()->GetSkill(skill_id);
|
|
if (skill_meta && !GetPassiveSkill(skill_meta->i->skill_id())) {
|
|
Skill* skill = new Skill;
|
|
skill->owner = this;
|
|
skill->meta = skill_meta;
|
|
skill->xtimer_attacher.xtimer = &room->xtimer;
|
|
room->xtimer.AddRepeatTimerAndAttach
|
|
(
|
|
SERVER_FRAME_RATE * skill_meta->i->skill_cd(),
|
|
a8::XParams()
|
|
.SetSender(this)
|
|
.SetParam1(skill_id),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
Creature* c = (Creature*)param.sender.GetUserData();
|
|
Skill* skill = c->GetPassiveSkill(param.param1);
|
|
if (skill) {
|
|
skill->ClearPassiveSkillBuff();
|
|
skill->AddPassiveSkillBuff();
|
|
}
|
|
},
|
|
&skill->xtimer_attacher.timer_list_);
|
|
passive_skill_hash_[skill_meta->i->skill_id()] = skill;
|
|
skill->AddPassiveSkillBuff();
|
|
if (skill_meta->i->skill_cd() > 10000) {
|
|
//永久被动被动技能
|
|
skill->AddPassiveSkillBuff();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Creature::RemovePassiveSkill(int skill_id)
|
|
{
|
|
auto itr = passive_skill_hash_.find(skill_id);
|
|
if (itr != passive_skill_hash_.end()) {
|
|
itr->second->ClearPassiveSkillBuff();
|
|
delete itr->second;
|
|
passive_skill_hash_.erase(itr);
|
|
}
|
|
}
|
|
|
|
void Creature::ClearPassiveSkill()
|
|
{
|
|
std::vector<int> del_skills;
|
|
del_skills.reserve(passive_skill_hash_.size());
|
|
for (auto& pair : passive_skill_hash_) {
|
|
del_skills.push_back(pair.first);
|
|
}
|
|
for (int skill_id : del_skills) {
|
|
RemovePassiveSkill(skill_id);
|
|
}
|
|
}
|
|
|
|
Skill* Creature::GetPassiveSkill(int skill_id)
|
|
{
|
|
auto itr = passive_skill_hash_.find(skill_id);
|
|
return itr != passive_skill_hash_.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
void Creature::TriggerBuff(Skill* skill, std::set<Creature*>& target_list, BuffTriggerType_e trigger_type)
|
|
{
|
|
for (Creature* entity : target_list) {
|
|
TriggerOneObjectBuff(skill, entity, trigger_type);
|
|
}
|
|
}
|
|
|
|
void Creature::TriggerOneObjectBuff(Skill* skill, Creature* target, BuffTriggerType_e trigger_type)
|
|
{
|
|
if (target->dead) {
|
|
return;
|
|
}
|
|
auto itr = skill->meta->trigger_type_buffs.find(trigger_type);
|
|
if (itr != skill->meta->trigger_type_buffs.end()) {
|
|
for (MetaData::Buff* buff_meta : itr->second) {
|
|
switch (buff_meta->i->buff_target()) {
|
|
case kBuffTargetSelf: //自己
|
|
{
|
|
if (target == this) {
|
|
target->AddBuff(this, buff_meta, 1, skill->meta);
|
|
}
|
|
}
|
|
break;
|
|
case kBuffTargetFriendly: //友军
|
|
{
|
|
if (target->team_id == team_id) {
|
|
target->AddBuff(this, buff_meta, 1, skill->meta);
|
|
}
|
|
}
|
|
break;
|
|
case kBuffTargetEnemy: //敌军
|
|
{
|
|
if (target->team_id != team_id) {
|
|
target->AddBuff(this, buff_meta, 1, skill->meta);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Skill* Creature::GetSkill(int skill_id)
|
|
{
|
|
auto itr = skill_hash_.find(skill_id);
|
|
return itr != skill_hash_.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
bool Creature::CanUseSkill(int skill_id)
|
|
{
|
|
Skill* skill = GetSkill(skill_id);
|
|
if (!skill) {
|
|
return false;
|
|
}
|
|
return skill->GetLeftTime() <= 0;
|
|
}
|
|
|
|
void Creature::DoSkill(int skill_id, int target_id, const a8::Vec2& skill_dir, const a8::Vec2& target_pos)
|
|
{
|
|
DoSkillPreProc(skill_id, target_id, target_pos);
|
|
Skill* skill = GetSkill(skill_id);
|
|
if (skill && CanUseSkill(skill_id)) {
|
|
ResetSkill();
|
|
skill_target_id_ = target_id;
|
|
skill_target_pos_ = target_pos;
|
|
skill_dir_ = skill_dir;
|
|
curr_skill_ = skill;
|
|
playing_skill = true;
|
|
CurrentSkill()->last_use_frameno = room->GetFrameNo();
|
|
if (CurrentSkill()->meta->i->skill_target() == kST_Self
|
|
) {
|
|
skill_target_id_ = GetEntityUniId();
|
|
}
|
|
if (CurrentSkill()->meta->i->skill_target() == kST_SpecDir) {
|
|
UpdateSkill();
|
|
} else {
|
|
Entity* entity = room->GetEntityByUniId(skill_target_id_);
|
|
if (entity && entity->IsEntityType(ET_Player)) {
|
|
Creature* c = (Creature*)entity;
|
|
std::set<Creature*> target_list;
|
|
skill_target_pos_ = c->GetPos();
|
|
SelectSkillTargets(CurrentSkill(), c->GetPos(), target_list);
|
|
TriggerBuff(CurrentSkill(), target_list, kBTT_UseSkill);
|
|
if (!CurrentSkill()->meta->phases.empty() &&
|
|
CurrentSkill()->meta->phases[0].time_offset <= 0) {
|
|
UpdateSkill();
|
|
}
|
|
} else {
|
|
playing_skill = false;
|
|
}
|
|
}
|
|
if (HasBuffEffect(kBET_Camouflage)) {
|
|
RemoveBuffByEffectId(kBET_Camouflage);
|
|
}
|
|
DoSkillPostProc(true, skill_id, target_id, target_pos);
|
|
} else {
|
|
DoSkillPostProc(false, skill_id, target_id, target_pos);
|
|
}
|
|
}
|
|
|
|
void Creature::DoSkillPreProc(int skill_id, int target_id, const a8::Vec2& target_pos)
|
|
{
|
|
}
|
|
|
|
void Creature::DoSkillPostProc(bool used, int skill_id, int target_id, const a8::Vec2& target_pos)
|
|
{
|
|
}
|
|
|
|
void Creature::ResetSkill()
|
|
{
|
|
curr_skill_ = nullptr;
|
|
curr_skill_phase = 0;
|
|
skill_dir_ = a8::Vec2();
|
|
skill_target_pos_ = a8::Vec2();
|
|
skill_param1 = 0.0f;
|
|
playing_skill = false;
|
|
}
|
|
|
|
void Creature::UpdateSkill()
|
|
{
|
|
if (CurrentSkill()) {
|
|
if (curr_skill_phase < CurrentSkill()->meta->phases.size()) {
|
|
MetaData::SkillPhase* phase = &CurrentSkill()->meta->phases[curr_skill_phase];
|
|
if (phase->time_offset >= CurrentSkill()->GetPassedTime()) {
|
|
ProcSkillPhase(phase);
|
|
++curr_skill_phase;
|
|
}
|
|
} else {
|
|
playing_skill = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Creature::ProcSkillPhase(MetaData::SkillPhase* phase)
|
|
{
|
|
switch (phase->func_id) {
|
|
case kSkill_TurnOver:
|
|
{
|
|
}
|
|
break;
|
|
case kSkill_JumpTo:
|
|
{
|
|
|
|
}
|
|
break;
|
|
case kSkill_Shot:
|
|
{
|
|
MetaData::Equip* weapon_meta = MetaMgr::Instance()->GetEquip(phase->param1.GetInt());
|
|
if (weapon_meta) {
|
|
MetaData::EquipUpgrade* weapon_upgrade_meta =
|
|
MetaMgr::Instance()->GetEquipUpgrade(weapon_meta->i->id());
|
|
MetaData::Equip* bullet_meta =
|
|
MetaMgr::Instance()->GetEquip(weapon_meta->i->use_bullet());
|
|
if (CurrentSkill()->meta->i->skill_target() == kST_SpecDir) {
|
|
if (std::abs(skill_dir_.x) > FLT_EPSILON ||
|
|
std::abs(skill_dir_.y) > FLT_EPSILON) {
|
|
float target_distance = 5;
|
|
if (bullet_meta && target_distance > 0.00001f) {
|
|
a8::Vec2 old_attack_dir = attack_dir;
|
|
attack_dir = skill_dir_;
|
|
attack_dir.Normalize();
|
|
InternalShot
|
|
(
|
|
this,
|
|
weapon_meta,
|
|
weapon_upgrade_meta,
|
|
bullet_meta,
|
|
1,
|
|
CurrentSkill() ? CurrentSkill()->meta->i->skill_id() : 0,
|
|
target_distance,
|
|
false);
|
|
attack_dir = old_attack_dir;
|
|
}
|
|
}
|
|
} else {
|
|
Entity* entity = room->GetEntityByUniId(skill_target_id_);
|
|
if (entity) {
|
|
float target_distance = entity->GetPos().Distance(GetPos());
|
|
if (bullet_meta && target_distance > 0.00001f) {
|
|
a8::Vec2 old_attack_dir = attack_dir;
|
|
attack_dir = entity->GetPos() - GetPos();
|
|
attack_dir.Normalize();
|
|
InternalShot
|
|
(
|
|
this,
|
|
weapon_meta,
|
|
weapon_upgrade_meta,
|
|
bullet_meta,
|
|
1,
|
|
CurrentSkill() ? CurrentSkill()->meta->i->skill_id() : 0,
|
|
target_distance,
|
|
false);
|
|
attack_dir = old_attack_dir;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case kSkill_Pull:
|
|
{
|
|
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
MetaData::SkillPhase* Creature::GetCurrSkillPhase()
|
|
{
|
|
return curr_skill_phase < CurrentSkill()->meta->phases.size() ?
|
|
&CurrentSkill()->meta->phases[curr_skill_phase] : nullptr;
|
|
}
|
|
|
|
Skill* Creature::CurrentSkill()
|
|
{
|
|
return curr_skill_;
|
|
}
|
|
|
|
void Creature::ProcBuffEffect(Creature* caster, Buff* buff)
|
|
{
|
|
switch (buff->meta->i->buff_effect()) {
|
|
case kBET_ChgAttr:
|
|
case kBET_Car:
|
|
{
|
|
RecalcBuffAttr();
|
|
if (buff->meta->i->buff_effect() == kBET_Car) {
|
|
RecalcSelfCollider();
|
|
MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(buff->meta->param4);
|
|
if (equip_meta &&
|
|
equip_meta->i->equip_type() == EQUIP_TYPE_CAR &&
|
|
equip_meta->i->equip_subtype() == 1
|
|
) {
|
|
MetaData::Equip* car_weapon_meta = MetaMgr::Instance()->GetEquip(equip_meta->int_param1);
|
|
if (car_weapon_meta) {
|
|
car_weapon.weapon_idx = 100;
|
|
car_weapon.weapon_id = car_weapon_meta->i->id();
|
|
car_weapon.weapon_lv = 1;
|
|
car_weapon.meta = car_weapon_meta;
|
|
car_weapon.Recalc();
|
|
car_weapon.ammo = car_weapon.GetClipVolume();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case kBET_TurnOver:
|
|
{
|
|
Skill* skill = CurrentSkill();
|
|
if (skill) {
|
|
MetaData::SkillPhase* phase = GetCurrSkillPhase();
|
|
if (phase && phase->time_offset >= skill->GetPassedTime()) {
|
|
if (HasBuffEffect(kBET_Car)) {
|
|
_UpdateMove(phase->param1.GetDouble() * 1.5);
|
|
} else {
|
|
_UpdateMove(phase->param1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case kBET_Camouflage:
|
|
{
|
|
if (aiming) {
|
|
aiming = false;
|
|
}
|
|
if (action_type != AT_None) {
|
|
CancelAction();
|
|
}
|
|
}
|
|
break;
|
|
case kBET_BePull:
|
|
{
|
|
if (caster == this) {
|
|
abort();
|
|
}
|
|
float target_distance = caster->GetPos().Distance(GetPos());
|
|
if (target_distance <= 0.000001f) {
|
|
SetPos(caster->GetPos());
|
|
target_pos = caster->GetPos();
|
|
} else {
|
|
if (target_distance <= buff->meta->param3) {
|
|
SetPos(caster->GetPos());
|
|
target_pos = caster->GetPos();
|
|
} else {
|
|
move_dir = caster->GetPos() - GetPos();
|
|
move_dir.Normalize();
|
|
target_pos = GetPos() + move_dir * (target_distance - buff->meta->param3);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case kBET_JumpTo:
|
|
{
|
|
Entity* entity = room->GetEntityByUniId(skill_target_id_);
|
|
if (entity) {
|
|
float target_distance = entity->GetPos().Distance(GetPos());
|
|
if (target_distance <= 0.000001f) {
|
|
SetPos(entity->GetPos());
|
|
skill_target_pos_ = entity->GetPos();
|
|
} else {
|
|
if (target_distance <= buff->meta->param3) {
|
|
SetPos(entity->GetPos());
|
|
skill_target_pos_ = entity->GetPos();
|
|
} else {
|
|
move_dir = entity->GetPos() - GetPos();
|
|
move_dir.Normalize();
|
|
skill_dir_ = move_dir;
|
|
skill_target_pos_ = GetPos() + move_dir * (target_distance - buff->meta->param3);
|
|
}
|
|
}
|
|
}
|
|
target_pos = skill_target_pos_;
|
|
}
|
|
break;
|
|
case kBET_Pull:
|
|
{
|
|
int i = 0;
|
|
}
|
|
break;
|
|
case kBET_Terminator:
|
|
{
|
|
#if 0
|
|
if (GetRace() == kHumanRace &&
|
|
MetaMgr::Instance()->terminator_meta &&
|
|
meta != MetaMgr::Instance()->terminator_meta) {
|
|
WinExp(this, MetaMgr::Instance()->terminator_meta->i->exp() + 1);
|
|
room->NotifySysPiao(TEXT("battle_server_terminator_appear", "终结者出现"), a8::MkRgb(255, 0, 0), 3);
|
|
OnChgToTerminator();
|
|
}
|
|
#endif
|
|
}
|
|
break;
|
|
case kBET_PlayShotAni:
|
|
{
|
|
|
|
}
|
|
break;
|
|
case kBET_Vertigo:
|
|
{
|
|
int i = 0;
|
|
}
|
|
break;
|
|
case kBET_DecHp:
|
|
{
|
|
#if 0
|
|
float def = hum->ability.def * (1 + hum->GetBuffAttrRate(kHAT_Def)) +
|
|
hum->GetBuffAttrAbs(kHAT_Def);
|
|
#endif
|
|
#if 0
|
|
if (caster->GetEntityType() == ET_Player) {
|
|
DecHP(buff->meta->param1,
|
|
caster->GetEntityUniId(),
|
|
((Human*)caster)->name,
|
|
0);
|
|
}
|
|
#endif
|
|
}
|
|
break;
|
|
case kBET_DelayAddBuff:
|
|
{
|
|
if (caster->GetEntityType() == ET_Player) {
|
|
room->xtimer.AddDeadLineTimerAndAttach
|
|
(
|
|
SERVER_FRAME_RATE * buff->meta->param1,
|
|
a8::XParams()
|
|
.SetSender(this)
|
|
.SetParam1(caster)
|
|
.SetParam2(buff->meta->param2)
|
|
.SetParam3(((Human*)caster)->CurrentSkill()->meta),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
Human* hum = (Human*)param.sender.GetUserData();
|
|
Human* caster = (Human*)param.param1.GetUserData();
|
|
int buff_id = param.param2;
|
|
MetaData::Skill* skill = (MetaData::Skill*)param.param3.GetUserData();
|
|
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(buff_id);
|
|
if (buff_meta && skill == caster->CurrentSkill()->meta && caster) {
|
|
hum->AddBuff(caster, buff_meta, 1, skill);
|
|
}
|
|
},
|
|
&buff->xtimer_attacher.timer_list_);
|
|
}
|
|
}
|
|
break;
|
|
case kBET_Shield:
|
|
{
|
|
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Creature::Initialize()
|
|
{
|
|
MoveableEntity::Initialize();
|
|
}
|
|
|
|
void Creature::AddSkill(int skill_id)
|
|
{
|
|
MetaData::Skill* skill_meta = MetaMgr::Instance()->GetSkill(skill_id);
|
|
if (skill_meta && !GetSkill(skill_id)) {
|
|
Skill* skill = new Skill;
|
|
skill->owner = this;
|
|
skill->meta = skill_meta;
|
|
skill->xtimer_attacher.xtimer = &room->xtimer;
|
|
skill_hash_[skill_id] = skill;
|
|
}
|
|
}
|
|
|
|
void Creature::ClearSkill()
|
|
{
|
|
Skill* reserve_skill = nullptr;
|
|
for (auto& pair : skill_hash_) {
|
|
if (pair.second->meta->i->skill_id() == TURN_OVER_SKILL_ID) {
|
|
reserve_skill = pair.second;
|
|
} else {
|
|
delete pair.second;
|
|
}
|
|
}
|
|
skill_hash_.clear();
|
|
if (reserve_skill) {
|
|
skill_hash_[reserve_skill->meta->i->skill_id()] = reserve_skill;
|
|
}
|
|
}
|
|
|
|
bool Creature::CanSee(const Creature* c) const
|
|
{
|
|
return room->grid_service->InView(GetGridId(), c->GetGridId());
|
|
}
|
|
|
|
float Creature::GetAttrAbs(int attr_id)
|
|
{
|
|
float attr_abs_val = GetBuffAttrAbs(attr_id);
|
|
if (attr_id == kHAT_Atk || attr_id == kHAT_Def) {
|
|
Buff* buff = GetBuffByEffectId(kBET_Car);
|
|
if (buff) {
|
|
MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(buff->meta->param4);
|
|
if (equip_meta) {
|
|
switch (attr_id) {
|
|
case kHAT_Atk:
|
|
{
|
|
attr_abs_val += equip_meta->i->atk();
|
|
}
|
|
break;
|
|
case kHAT_Def:
|
|
{
|
|
attr_abs_val += equip_meta->i->def();
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return attr_abs_val;
|
|
}
|
|
|
|
float Creature::GetAttrRate(int attr_id)
|
|
{
|
|
float attr_rate_val = GetBuffAttrRate(attr_id);
|
|
return attr_rate_val;
|
|
}
|
|
|
|
bool Creature::IsPlayer() const
|
|
{
|
|
return IsHuman() && IsEntitySubType(EST_Player);
|
|
}
|
|
|
|
bool Creature::IsAndroid() const
|
|
{
|
|
return IsHuman() && IsEntitySubType(EST_Android);
|
|
}
|
|
|
|
bool Creature::IsHuman() const
|
|
{
|
|
return IsEntityType(ET_Player);
|
|
}
|
|
|
|
void Creature::StartAction(ActionType_e action_type,
|
|
int action_duration,
|
|
int item_id,
|
|
int target_id)
|
|
{
|
|
if (this->action_type == action_type &&
|
|
this->action_item_id == item_id &&
|
|
this->action_target_id == target_id) {
|
|
return;
|
|
}
|
|
action_duration = std::max(0, action_duration);
|
|
this->action_type = action_type;
|
|
this->action_frameno = room->GetFrameNo();
|
|
this->action_duration = action_duration;
|
|
this->action_item_id = item_id;
|
|
this->action_target_id = target_id;
|
|
need_sync_active_player = true;
|
|
if (HasBuffEffect(kBET_Camouflage)) {
|
|
RemoveBuffByEffectId(kBET_Camouflage);
|
|
}
|
|
}
|
|
|
|
void Creature::CancelAction()
|
|
{
|
|
if (action_type == AT_Relive) {
|
|
Entity* entity = room->GetEntityByUniId(action_target_id);
|
|
if (!entity->IsEntityType(ET_Player)) {
|
|
Human* hum = (Human*)entity;
|
|
if (hum->action_type == AT_Rescue) {
|
|
hum->CancelAction();
|
|
}
|
|
}
|
|
}
|
|
ResetAction();
|
|
}
|
|
|
|
void Creature::ResetAction()
|
|
{
|
|
action_type = AT_None;
|
|
action_duration = 0;
|
|
action_frameno = 0;
|
|
action_item_id = 0;
|
|
action_target_id = 0;
|
|
need_sync_active_player = true;
|
|
}
|
|
|
|
bool Creature::IsProperTarget(Creature* target)
|
|
{
|
|
if (target->dead) {
|
|
return false;
|
|
}
|
|
if (a8::HasBitFlag(target->status, HS_Disable)) {
|
|
return false;
|
|
}
|
|
if (team_id == target->team_id) {
|
|
return false;
|
|
}
|
|
if (room->GetRoomMode() == kZombieMode && GetRace() == target->GetRace()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Creature::IsEnemy(Creature* target)
|
|
{
|
|
if (room->GetRoomMode() == kZombieMode) {
|
|
return target->GetRace() != GetRace();
|
|
} else {
|
|
return team_id != target->team_id;
|
|
}
|
|
}
|
|
|
|
void Creature::TouchProperTargets(std::function<void (Creature*, bool&)> func)
|
|
{
|
|
auto callback =
|
|
[this, func] (Creature* c, bool& stop)
|
|
{
|
|
if (IsProperTarget(c)) {
|
|
func(c, stop);
|
|
}
|
|
};
|
|
room->grid_service->TouchCreatures(room->GetRoomIdx(),
|
|
GetGridList(),
|
|
callback);
|
|
}
|