1

server/gameserver/creature.cc

@@ -4,6 +4,15 @@
 #include "metamgr.h"
 #include "room.h"
 #include "skill.h"
+#include "human.h"
+
+Creature::~Creature()
+{
+    for (auto& pair : skill_hash_) {
+        delete pair.second;
+    }
+    skill_hash_.clear();
+}
 
 bool Creature::HasBuffEffect(int buff_effect_id)
 {
@@ -79,6 +88,7 @@ void Creature::AddBuff(Creature* caster,
              &buff->xtimer_attacher.timer_list_
                                                );
     }
+    ProcBuffEffect(caster, buff);
     AddBuffPostProc(caster, buff);
     #ifdef DEBUG
     SendDebugMsg(a8::Format("添加buff_id:%d buff_effect:%d",
@@ -301,7 +311,130 @@ void Creature::AddPassiveSkillBuff(MetaData::Skill* skill_meta)
 
 void Creature::SelectSkillTargets(const a8::Vec2& target_pos, std::set<Entity*>& target_list)
 {
-
+    switch (CurrentSkill()->meta->i->skill_target()) {
+    case kST_All:
+        {
+            TouchAllLayerHumanList
+                (
+                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
+                 {
+                    if (hum->GetPos().Distance(target_pos) < CurrentSkill()->meta->i->skill_distance()) {
+                        target_list.insert(hum);
+                    }
+                 });
+        }
+        break;
+    case kST_Self:
+        {
+            target_list.insert(this);
+        }
+        break;
+    case kST_FriendlyIncludeSelf:
+        {
+            target_list.insert(this);
+            TouchAllLayerHumanList
+                (
+                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
+                 {
+#if 0
+                    if ((hum == this || hum->team_id == team_id) &&
+                        hum->GetPos().Distance(target_pos) < CurrentSkill()->meta->i->skill_distance()) {
+                        target_list.insert(hum);
+                    }
+#endif
+                 });
+        }
+        break;
+    case kST_FriendlyExcludeSelf:
+        {
+            TouchAllLayerHumanList
+                (
+                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
+                 {
+                     #if 0
+                    if ((hum != this && hum->team_id == team_id) &&
+                        hum->GetPos().Distance(target_pos) < CurrentSkill()->i->skill_distance()) {
+                        target_list.insert(hum);
+                    }
+                    #endif
+                 });
+        }
+        break;
+    case kST_EnemySingle:
+        {
+            Entity* entity = room->GetEntityByUniId(skill_target_id_);
+            if (entity && entity->IsEntityType(ET_Player)) {
+                Human* hum = (Human*)entity;
+                #if 0
+                if (IsEnemy(hum)) {
+                    target_list.insert(hum);
+                }
+                #endif
+            }
+        }
+        break;
+    case kST_EnemyGroup:
+        {
+            TouchAllLayerHumanList
+                (
+                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
+                 {
+                     #if 0
+                    if ((hum->team_id != team_id) &&
+                        hum->GetPos().Distance(target_pos) < CurrentSkill()->i->skill_distance()) {
+                        target_list.insert(hum);
+                    }
+                    #endif
+                 });
+        }
+        break;
+    case kST_EnemyAndObject:
+        {
+            TouchAllLayerHumanList
+                (
+                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
+                 {
+                     #if 0
+                    if ((hum->team_id != team_id) &&
+                        hum->GetPos().Distance(target_pos) < CurrentSkill()->i->skill_distance()) {
+                        target_list.insert(hum);
+                    }
+                    #endif
+                 });
+        }
+        break;
+    case kST_EnemyAndSelf:
+        {
+            TouchAllLayerHumanList
+                (
+                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
+                 {
+                     #if 0
+                     if ((hum == this || this->IsEnemy(hum)) &&
+                         hum->GetPos().Distance(target_pos) < CurrentSkill()->i->skill_distance()) {
+                         target_list.insert(hum);
+                     }
+                     #endif
+                 });
+        }
+        break;
+    case kST_SingleEnemyAndSelf:
+        {
+            Entity* entity = room->GetEntityByUniId(skill_target_id_);
+            if (entity && entity->IsEntityType(ET_Player)) {
+                Human* hum = (Human*)entity;
+                #if 0
+                if (IsEnemy(hum)) {
+                    target_list.insert(hum);
+                }
+                #endif
+            }
+            target_list.insert(this);
+        }
+        break;
+    default:
+        break;
+    }
 }
 
 void Creature::TriggerBuff(std::set<Entity*>& target_list, BuffTriggerType_e trigger_type)
@@ -462,3 +595,211 @@ Skill* Creature::CurrentSkill()
 {
     return nullptr;
 }
+
+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
+                    ) {
+                    #if 0
+                    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();
+                    }
+                    #endif
+                }
+            }
+        }
+        break;
+    case kBET_TurnOver:
+        {
+            Skill* skill = CurrentSkill();
+            if (skill) {
+                MetaData::SkillPhase* phase = GetCurrSkillPhase();
+                if (phase && phase->time_offset >= skill->GetLeftTime()) {
+                    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)->skill_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->skill_meta_ && caster) {
+                             hum->AddBuff(caster, buff_meta, 1, skill);
+                         }
+                     },
+                     &buff->xtimer_attacher.timer_list_);
+            }
+        }
+        break;
+    default:
+        {
+        }
+        break;
+    }
+}
+
+void Creature::Initialize()
+{
+    MoveableEntity::Initialize();
+    skill_xtimer_attacher_.xtimer = &room->xtimer;
+}
+
+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_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;
+    }
+}

server/gameserver/creature.h

@@ -17,10 +17,15 @@ class Creature : public MoveableEntity
 {
  public:
 
+    bool aiming = false;
+    ActionType_e action_type = AT_None;
     a8::Vec2 attack_dir;
     HumanAbility ability;
+    a8::Vec2 target_pos;
     std::function<bool ()> on_move_collision;
 
+    virtual ~Creature() override;
+    virtual void Initialize() override;
     bool HasBuffEffect(int buff_effect_id);
     Buff* GetBuffByEffectId(int effect_id);
     Buff* GetBuffById(int buff_id);
@@ -39,6 +44,8 @@ class Creature : public MoveableEntity
     void FillBuffList(::google::protobuf::RepeatedPtrField<::cs::MFBuff>* pb_buff_list);
     void TriggerBuff(std::set<Entity*>& target_list, BuffTriggerType_e trigger_type);
     Skill* GetSkill(int skill_id);
+    void AddSkill(int skill_id);
+    void ClearSkill();
 
     void AddPassiveSkill(MetaData::Skill* skill_meta);
     void RemovePassiveSkill(MetaData::Skill* skill_meta);
@@ -54,15 +61,8 @@ class Creature : public MoveableEntity
     Skill* CurrentSkill();
     MetaData::SkillPhase* GetCurrSkillPhase();
 
-protected:
-    a8::Vec2 skill_dir;
-    float skill_param1 = 0;
-    bool playing_skill = false;
-    int skill_target_id_ = 0;
-    a8::Vec2 skill_target_pos_;
-
-    a8::XTimerAttacher skill_xtimer_attacher_;
-    MetaData::Skill* skill_meta_ = nullptr;
+    virtual void CancelAction() {};
+    virtual void ResetAction() {};
 
 private:
 
@@ -72,8 +72,10 @@ private:
     virtual void TriggerOneObjectBuff(Entity* target, BuffTriggerType_e trigger_type);
     virtual void DoSkillPreProc(int skill_id, int target_id, const a8::Vec2& target_pos);
     virtual void DoSkillPostProc(bool used, int skill_id, int target_id, const a8::Vec2& target_pos);
+    virtual void _UpdateMove(int speed) {};
     void UpdateSkill();
     void ProcSkillPhase(MetaData::SkillPhase* phase);
+    void ProcBuffEffect(Creature* caster, Buff* buff);
 
 private:
     std::array<float, kHAT_End> buff_attr_abs_ = {};
@@ -81,7 +83,14 @@ private:
     std::array<Buff*, kBET_End> buff_effect_ = {};
     std::list<Buff> buff_list_;
 
+    a8::Vec2 skill_dir;
+    float skill_param1 = 0;
+    bool playing_skill = false;
+    MetaData::Skill* skill_meta_ = nullptr;
     size_t curr_skill_phase = 0;
+    int skill_target_id_ = 0;
+    a8::Vec2 skill_target_pos_;
     std::map<int, Skill*> skill_hash_;
+    a8::XTimerAttacher skill_xtimer_attacher_;
     std::map<MetaData::Skill*, xtimer_list*> passive_skill_metas_;
 };

server/gameserver/entity.h

@@ -26,6 +26,7 @@ class Entity
     virtual bool IsDead(Room* room) { return false;};
     virtual long long GetDeadFrameNo(Room* room) { return 0;};
     virtual void OnPreCollision(Room* room) {};
+    virtual void RecalcSelfCollider() {};
     int GetEntityUniId() const { return entity_uniid_; }
     EntityType_e GetEntityType() const { return entity_type_; }
     EntitySubType_e GetEntitySubType() const { return entity_subtype_; }

server/gameserver/hero.cc

@@ -23,7 +23,7 @@ Hero::~Hero()
 
 void Hero::Initialize()
 {
-    MoveableEntity::Initialize();
+    Creature::Initialize();
     RecalcSelfCollider();
     ai = new HeroAI;
     ai->owner = this;

server/gameserver/hero.h

@@ -20,7 +20,6 @@ public:
     bool dead = false;
     bool shot_hold = false;
     int team_id = 0;
-    a8::Vec2 attack_dir;
 
     Hero();
     virtual ~Hero() override;
@@ -37,7 +36,7 @@ protected:
     void UpdateMove(int speed);
     void InternalUpdateMove(float speed);
     bool IsCollisionInMapService();
-    void RecalcSelfCollider();
+    virtual void RecalcSelfCollider() override;
 
 private:
     bool later_removed_ = false;

server/gameserver/human.cc

@@ -137,8 +137,7 @@ Human::~Human()
 
 void Human::Initialize()
 {
-    MoveableEntity::Initialize();
-    skill_xtimer_attacher_.xtimer = &room->xtimer;
+    Creature::Initialize();
     RecalcSelfCollider();
     volume_ = meta->volume;
     observers_.insert(this);
@@ -2003,12 +2002,13 @@ void Human::_UpdateSpecMove()
     if (move_end) {
         Buff* buff = GetBuffByEffectId(kBET_JumpTo);
         if (buff) {
-            if (buff->skill_meta == skill_meta_ &&
-                !skill_meta_->phases.empty()) {
+            if (CurrentSkill() &&
+                                buff->skill_meta == CurrentSkill()->meta &&
+                                !CurrentSkill()->meta->phases.empty()) {
                 std::set<Entity*> target_list;
-                metatable::Skill* mutable_skill_meta = (metatable::Skill*)skill_meta_->i;
-                float old_skill_distance = skill_meta_->i->skill_distance();
-                mutable_skill_meta->set_skill_distance(skill_meta_->phases[0].param1.GetDouble());
+                metatable::Skill* mutable_skill_meta = (metatable::Skill*)CurrentSkill()->meta->i;
+                float old_skill_distance = CurrentSkill()->meta->i->skill_distance();
+                mutable_skill_meta->set_skill_distance(CurrentSkill()->meta->phases[0].param1.GetDouble());
                 SelectSkillTargets(GetPos(), target_list);
                 mutable_skill_meta->set_skill_distance(old_skill_distance);
 
@@ -2102,6 +2102,7 @@ void Human::WinExp(Human* sender, int exp)
     exp_ += exp;
     MetaData::Player* old_meta = meta;
     int start_meta_id = race_ == kHumanRace ? HUMAN_RACE_META_START_ID : ZOMBIE_RACE_META_START_ID;
+    ClearSkill();
     do {
         MetaData::Player* tmp_meta = MetaMgr::Instance()->GetPlayer(start_meta_id + level_);
         if (!tmp_meta) {
@@ -2109,7 +2110,7 @@ void Human::WinExp(Human* sender, int exp)
         }
         if (exp_ >= tmp_meta->i->exp()) {
             meta = tmp_meta;
-            skill_meta_ = MetaMgr::Instance()->GetSkill(meta->i->active_skill());
+            AddSkill(meta->i->active_skill());
             ResetSkill();
             ++level_;
         } else {
@@ -2905,28 +2906,28 @@ void Human::TriggerOneObjectBuff(Entity* target, BuffTriggerType_e trigger_type)
     if (hum->dead) {
         return;
     }
-    auto itr = skill_meta_->trigger_type_buffs.find(trigger_type);
-    if (itr != skill_meta_->trigger_type_buffs.end()) {
+    auto itr = CurrentSkill()->meta->trigger_type_buffs.find(trigger_type);
+    if (itr != CurrentSkill()->meta->trigger_type_buffs.end()) {
         for (MetaData::Buff* buff_meta : itr->second) {
             switch (buff_meta->i->buff_target()) {
             case kBuffTargetSelf: //自己
                 {
                     if (hum == this) {
-                        hum->AddBuff(this, buff_meta, 1, skill_meta_);
+                        hum->AddBuff(this, buff_meta, 1, CurrentSkill()->meta);
                     }
                 }
                 break;
             case kBuffTargetFriendly: //友军
                 {
                     if (hum->team_id == team_id) {
-                        hum->AddBuff(this, buff_meta, 1, skill_meta_);
+                        hum->AddBuff(this, buff_meta, 1, CurrentSkill()->meta);
                     }
                 }
                 break;
             case kBuffTargetEnemy: //敌军
                 {
                     if (hum->team_id != team_id) {
-                        hum->AddBuff(this, buff_meta, 1, skill_meta_);
+                        hum->AddBuff(this, buff_meta, 1, CurrentSkill()->meta);
                     }
                 }
                 break;
@@ -2940,171 +2941,6 @@ void Human::TriggerOneObjectBuff(Entity* target, BuffTriggerType_e trigger_type)
 void Human::AddBuffPostProc(Creature* caster, Buff* buff)
 {
     room->frame_event.AddBuff(this, 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->GetLeftTime()) {
-                    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 (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();
-            }
-        }
-        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 (caster->GetEntityType() == ET_Player) {
-                DecHP(buff->meta->param1,
-                      caster->GetEntityUniId(),
-                      ((Human*)caster)->name,
-                      0);
-            }
-        }
-        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)->skill_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->skill_meta_ && caster) {
-                             hum->AddBuff(caster, buff_meta, 1, skill);
-                         }
-                     },
-                     &buff->xtimer_attacher.timer_list_);
-            }
-        }
-        break;
-    default:
-        {
-        }
-        break;
-    }
 }
 
 int Human::GetItemNum(int item_id)
@@ -3284,120 +3120,6 @@ void Human::Revive()
     }
 }
 
-void Human::SelectSkillTargets(const a8::Vec2& target_pos, std::set<Entity*>& target_list)
-{
-    switch (skill_meta_->i->skill_target()) {
-    case kST_All:
-        {
-            TouchAllLayerHumanList
-                (
-                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
-                 {
-                    if (hum->GetPos().Distance(target_pos) < skill_meta_->i->skill_distance()) {
-                        target_list.insert(hum);
-                    }
-                 });
-        }
-        break;
-    case kST_Self:
-        {
-            target_list.insert(this);
-        }
-        break;
-    case kST_FriendlyIncludeSelf:
-        {
-            target_list.insert(this);
-            TouchAllLayerHumanList
-                (
-                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
-                 {
-                    if ((hum == this || hum->team_id == team_id) &&
-                        hum->GetPos().Distance(target_pos) < skill_meta_->i->skill_distance()) {
-                        target_list.insert(hum);
-                    }
-                 });
-        }
-        break;
-    case kST_FriendlyExcludeSelf:
-        {
-            TouchAllLayerHumanList
-                (
-                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
-                 {
-                    if ((hum != this && hum->team_id == team_id) &&
-                        hum->GetPos().Distance(target_pos) < skill_meta_->i->skill_distance()) {
-                        target_list.insert(hum);
-                    }
-                 });
-        }
-        break;
-    case kST_EnemySingle:
-        {
-            Entity* entity = room->GetEntityByUniId(skill_target_id_);
-            if (entity && entity->IsEntityType(ET_Player)) {
-                Human* hum = (Human*)entity;
-                if (IsEnemy(hum)) {
-                    target_list.insert(hum);
-                }
-            }
-        }
-        break;
-    case kST_EnemyGroup:
-        {
-            TouchAllLayerHumanList
-                (
-                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
-                 {
-                    if ((hum->team_id != team_id) &&
-                        hum->GetPos().Distance(target_pos) < skill_meta_->i->skill_distance()) {
-                        target_list.insert(hum);
-                    }
-                 });
-        }
-        break;
-    case kST_EnemyAndObject:
-        {
-            TouchAllLayerHumanList
-                (
-                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
-                 {
-                    if ((hum->team_id != team_id) &&
-                        hum->GetPos().Distance(target_pos) < skill_meta_->i->skill_distance()) {
-                        target_list.insert(hum);
-                    }
-                 });
-        }
-        break;
-    case kST_EnemyAndSelf:
-        {
-            TouchAllLayerHumanList
-                (
-                 [this, &target_pos, &target_list] (Human* hum, bool& stop)
-                 {
-                     if ((hum == this || this->IsEnemy(hum)) &&
-                         hum->GetPos().Distance(target_pos) < skill_meta_->i->skill_distance()) {
-                         target_list.insert(hum);
-                     }
-                 });
-        }
-        break;
-    case kST_SingleEnemyAndSelf:
-        {
-            Entity* entity = room->GetEntityByUniId(skill_target_id_);
-            if (entity && entity->IsEntityType(ET_Player)) {
-                Human* hum = (Human*)entity;
-                if (IsEnemy(hum)) {
-                    target_list.insert(hum);
-                }
-            }
-            target_list.insert(this);
-        }
-        break;
-    default:
-        break;
-    }
-}
-
 void Human::AutoChgWeapon()
 {
     if (weapons[GUN_SLOT1].weapon_id != 0) {
@@ -3699,7 +3421,8 @@ void Human::OnMetaChange()
     }
     room->frame_event.AddHpChg(this);
     RecalcBaseAttr();
-    skill_meta_ = MetaMgr::Instance()->GetSkill(meta->i->active_skill());
+    ClearSkill();
+    AddSkill(meta->i->active_skill());
     ResetSkill();
     MetaData::Skill* passive_skill_meta = MetaMgr::Instance()->GetSkill(meta->i->passive_skill());
     ClearPassiveSkill();

server/gameserver/human.h

@@ -69,7 +69,6 @@ class Human : public Creature
     bool disconnected = false;
     int anim_type = 0;
     int anim_seq = 0;
-    ActionType_e action_type = AT_None;
     long long action_frameno = 0;
     int action_duration = 0;
     int action_item_id = 0;
@@ -96,7 +95,6 @@ class Human : public Creature
     bool real_dead = false;
     xtimer_list* revive_timer = nullptr;
     int dead_times = 0;
-    bool aiming = false;
     bool dead = false;
     long long dead_frameno = 0;
     long long real_dead_frameno = 0;
@@ -140,7 +138,6 @@ class Human : public Creature
     xtimer_list* ad_timer_ = nullptr;
     Human* last_human_target = nullptr;
 
-    a8::Vec2 target_pos;
     int game_times = 0;
     int win_times = 0;
     int kill_times = 0;
@@ -165,7 +162,7 @@ class Human : public Creature
     void FillMFTeamData(cs::MFTeamData* team_data, bool is_game_over);
     void Shot(a8::Vec2& target_dir, bool& shot_ok);
     void CarShot(a8::Vec2& target_dir);
-    void RecalcSelfCollider();
+    virtual void RecalcSelfCollider() override;
     bool IsCollisionInMapService();
     void FindPathInMapService();
     float GetRadius();
@@ -177,8 +174,8 @@ class Human : public Creature
                      int action_duration,
                      int item_id,
                      int target_id);
-    void CancelAction();
-    void ResetAction();
+    virtual void CancelAction() override;
+    virtual void ResetAction() override;
     void BeKill(int killer_id, const std::string& killer_name, int weapon_id);
     void DecHP(float dec_hp, int killer_id, const std::string& killer_name, int weapon_id);
     void AddToNewObjects(Entity* entity);
@@ -261,7 +258,7 @@ class Human : public Creature
     ObjectSyncFlags* GetObjectSyncFlags(int obj_uniid);
     bool HasSpecMove();
     void _UpdateSpecMove();
-    void _UpdateMove(int speed);
+    virtual void _UpdateMove(int speed) override;
     RaceType_e GetRace() { return race_; }
     void ChangeToRace(RaceType_e race, int level);
     void ChangeToRaceAndNotify(RaceType_e race, int level);
@@ -279,7 +276,6 @@ protected:
     void ProcLootCar(Loot* entity, MetaData::Equip* item_meta);
     void ProcCamoutflage(Loot* entity, MetaData::Equip* item_meta);
     void ProcSpoils(Loot* entity, MetaData::Equip* item_meta);
-    virtual void SelectSkillTargets(const a8::Vec2& target_pos, std::set<Entity*>& target_list) override;
     void AutoChgWeapon();
     void CancelRevive();
 

server/gameserver/player.cc

@@ -36,7 +36,7 @@ void Player::Initialize()
 {
     Human::Initialize();
     max_energy_shield = energy_shield;
-    skill_meta_ = MetaMgr::Instance()->GetSkill(41001);
+    AddSkill(TURN_OVER_SKILL_ID);
     RecalcBaseAttr();
 }