1

server/gameserver/constant.h

@@ -475,7 +475,8 @@ enum PolyExtDataFlag_e
 A8_DECLARE_ENUM(TimerUserEvent_e,
                 kCheckShotHoldStateTimerEvent = 100,
                 kShenBaoAddTimeTimerEvent,
-                kAddDjsHaloRangeTimerEvent
+                kActiveDjsSkillTimerEvent,
+                kDeactiveDjsSkillTimerEvent
                 );
 
 const char* const PROJ_NAME_FMT = "game%d_gameserver";

server/gameserver/human.cc

@@ -3340,8 +3340,6 @@ int Human::GetTeamMode()
     return GetTeam()->GetMemberNum() <= 1 ? 0 : 1;
 }
 
-
-
 void Human::CalcAssists(Human* target)
 {
     if (GetTeam() && GetTeam()->GetMemberNum() > 1) {

server/gameserver/skill.cc

@@ -628,46 +628,124 @@ void Skill::Proc30501TZ()
 
 void Skill::Proc30601DJS()
 {
-    a8::XTimerWp timer = owner->room->xtimer.SetIntervalWpEx
+    a8::XTimerWp passive_skill_timer;
+    {
+        const mt::Skill* active_skill_meta = nullptr;
+        std::set<Human*> in_range_humans;
+        auto on_enter =
+            [] (Human* num)
+            {
+
+            };
+        auto on_stay =
+            [] (Human* hum)
+            {
+
+            };
+        auto on_leave =
+            [] (Human* hum)
+            {
+
+            };
+        passive_skill_timer = owner->room->xtimer.SetIntervalWpEx
             (
              SERVER_FRAME_RATE,
-         [this] (int event, const a8::Args* args)
+             [this, in_range_humans, active_skill_meta, on_enter, on_stay, on_leave]
+             (int event, const a8::Args* args) mutable
              {
                  if (a8::TIMER_EXEC_EVENT == event) {
                      if (!owner->dead) {
+                         float range = meta->_number_meta->_float_range2;
+                         float resume_hp = meta->_number_meta->resume();
+                         int size = 0;
+                         std::array<Human*, MAX_TEAM_NUM> hit_humans;
                          owner->GetTeam()->TraverseMembers
                              (
-                          [this] (Human* hum)
+                              [this, range, hit_humans, &size] (Human* hum) mutable
                               {
                                   if (owner != hum &&
                                       Collision::CheckCC(owner, owner->GetRadius(),
-                                                     hum, meta->_number_meta->_float_range2)) {
+                                                         hum, range)) {
-                                  if (hum->GetHP() < hum->GetMaxHP()) {
+                                      if (size < MAX_TEAM_NUM) {
-                                      hum->AddHp(hum->GetMaxHP() * meta->_number_meta->resume());
+                                          hit_humans[size++] = hum;
                                       }
                                   }
                                   return true;
                               });
+                         std::vector<Human*> leave_humans;
+                         for (Human* hum : in_range_humans) {
+                             bool found = false;
+                             for (int i = 0; i < size; ++i){
+                                 if (hit_humans[i] == hum) {
+                                     found = true;
+                                     break;
                                  }
                              }
+                             if (!found) {
+                                 on_leave(hum);
+                                 leave_humans.push_back(hum);
+                             }
+                         }
+                         for (Human* hum : leave_humans) {
+                             in_range_humans.erase(hum);
+                         }
+                         for (int i = 0; i < size; ++i){
+                             if (in_range_humans.find(hit_humans[i]) == in_range_humans.end()) {
+                                 on_enter(hit_humans[i]);
+                                 in_range_humans.insert(hit_humans[i]);
+                             } else {
+                                 on_stay(hit_humans[i]);
+                             }
+                         }
+                     }
+                 } else if (kActiveDjsSkillTimerEvent == event) {
+                     active_skill_meta = args->Get<const mt::Skill*>(0);
+                     //owner->GetAbility()->AddSpeedRuduce(active_skill_meta->_number_meta->speed());
+                 } else if (kDeactiveDjsSkillTimerEvent == event) {
+                     //owner->GetAbility()->DecSpeedRuduce(active_skill_meta->_number_meta->speed());
+                     active_skill_meta = nullptr;
+                 }
              },
              &xtimer_attacher);
+    }
 
+    {
+        a8::XTimerWp active_skill_timer;
         owner->GetTrigger()->AddListener
             (
              kUseSkillEvent,
-         [this, timer] (const a8::Args& args) mutable
+             [this, passive_skill_timer, active_skill_timer] (const a8::Args& args) mutable
              {
-             if (!timer.expired()) {
+                 if (passive_skill_timer.expired()) {
+                     return;
+                 }
                  Skill* skill = args.Get<Skill*>(0);
                  if (skill->meta->GetMagicId() == MAGIC_20601_DJS) {
-                     a8::Args args({});
+                     if (!active_skill_timer.expired()) {
-                     owner->room->xtimer.FireEvent(timer, kAddDjsHaloRangeTimerEvent, &args);
+                         return;
                      }
+                     a8::Args event_args({skill->meta});
+                     owner->room->xtimer.FireEvent(passive_skill_timer,
+                                                   kActiveDjsSkillTimerEvent,
+                                                   &event_args);
+                     active_skill_timer = owner->room->xtimer.SetTimeoutWpEx
+                         (
+                          skill->meta->_number_meta->_float_time / FRAME_RATE_MS,
+                          [this, passive_skill_timer] (int event, const a8::Args* args) mutable
+                          {
+                              if (a8::TIMER_DELETE_EVENT == event) {
+                                  a8::Args event_args({});
+                                  owner->room->xtimer.FireEvent(passive_skill_timer,
+                                                                kDeactiveDjsSkillTimerEvent,
+                                                                &event_args);
+                              }
+                          },
+                          &xtimer_attacher);
                  }
              }
              );
     }
+}
 
 void Skill::Proc30701BAO()
 {