youhua room player android bullet Update

server/gameserver/android.ai.cc

@@ -102,7 +102,7 @@ void AndroidAI::DoMove()
     if (hum->room->waiting_start) {
         return;
     }
-    if (owner->updated_times % 2 == 0) {
+    if (owner->UpdatedTimes() % 2 == 0) {
         Human* hum = (Human*)owner;
         int speed = std::max(1, (int)hum->GetSpeed());
         for (int i = 0; i < speed; ++i) {
@@ -129,7 +129,7 @@ void AndroidAI::DoAttack()
     if (hum->room->gas_data.gas_mode == GasInactive) {
         return;
     }
-    if (owner->updated_times % 10 == 0) {
+    if (owner->UpdatedTimes() % 10 == 0) {
         Human* enemy = owner->room->FindEnemy((Human*)owner);
         if (enemy) {
             Human* sender = (Human*)owner;

server/gameserver/android.cc

@@ -35,6 +35,20 @@ void Android::Initialize()
 }
 
 void Android::Update(int delta_time)
+{
+    if (UpdatedTimes() <= 0) {
+        if (room->frame_no % 2 != 0) {
+            return;
+        }
+    }
+    InternalUpdate(delta_time);
+    if (room->frame_no % 2 == 0) {
+        SendUpdateMsg();
+    }
+    ++updated_times_;
+}
+
+void Android::InternalUpdate(int delta_time)
 {
     if (a8::HasBitFlag(status, HS_Disable)) {
         return;

server/gameserver/android.h

@@ -20,4 +20,6 @@ class Android : public Human
     virtual void Update(int delta_time) override;
     void GiveEquip();
 
+private:
+    void InternalUpdate(int delta_time);
 };

server/gameserver/app.cc

@@ -56,7 +56,7 @@ static void SavePerfLog()
 {
     a8::UdpLog::Instance()->Info
         ("mainloop_rundelay:%d room_num:%d player_num:%d online_num:%d alive_count:%d "
-         "sys_request_delay:%d user_request_delay:%d http_pending_num:%d",
+         "sys_request_delay:%d user_request_delay:%d http_pending_num:%d active_count:%d",
          {
           App::Instance()->perf.max_run_delay_time,
           RoomMgr::Instance()->RoomNum(),
@@ -65,7 +65,8 @@ static void SavePerfLog()
           App::Instance()->perf.alive_count,
           f8::HttpClientPool::Instance()->max_sys_request_delay,
           f8::HttpClientPool::Instance()->max_user_request_delay,
-          f8::HttpClientPool::Instance()->GetPendingNum()
+          f8::HttpClientPool::Instance()->GetPendingNum(),
+          App::Instance()->perf.active_count
          });
     App::Instance()->perf.max_run_delay_time = 0;
     App::Instance()->perf.max_dispatchmsg_time = 0;

server/gameserver/bullet.cc

@@ -28,6 +28,7 @@ void Bullet::Initialize()
 void Bullet::Update(int delta_time)
 {
     MapServiceUpdate();
+    ++updated_times_;
 }
 
 void Bullet::RecalcSelfCollider()

server/gameserver/bullet.h

@@ -39,7 +39,7 @@ class Bullet : public MoveableEntity
     void OnHit(std::set<Entity*>& objects);
     void ProcBomb();
     bool IsBomb();
-    void MapServiceUpdate();
+    inline void MapServiceUpdate();
 
 private:
     CircleCollider* self_collider_ = nullptr;

server/gameserver/metamgr.cc

@@ -8,6 +8,9 @@
 #include "metamgr.h"
 #include "app.h"
 
+#define METAMGR_READ(field_name, def_val) MetaMgr::Instance()->field_name = \
+        a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, #def_val));
+
 class MetaDataLoader
 {
 public:
@@ -180,6 +183,25 @@ public:
             MetaMgr::Instance()->newbie_fill_interval = MetaMgr::Instance()->GetSysParamAsInt("newbie_fill_interval", 5000);
             MetaMgr::Instance()->other_fill_interval = MetaMgr::Instance()->GetSysParamAsInt("other_fill_interval", 2000);
             MetaMgr::Instance()->map_cell_width = MetaMgr::Instance()->GetSysParamAsInt("map_cell_width", 64 * 8);
+            {
+                METAMGR_READ(level0room_shua_robot_min_time, 5);
+                METAMGR_READ(level0room_shua_robot_max_time, 7);
+                METAMGR_READ(level0room_shua_robot_min_num, 1);
+                METAMGR_READ(level0room_shua_robot_max_num, 3);
+                METAMGR_READ(level0room_die_robot_min_time, 10);
+                METAMGR_READ(level0room_die_robot_max_time, 20);
+                METAMGR_READ(level0room_die_robot_min_num, 2);
+                METAMGR_READ(level0room_die_robot_max_num, 5);
+
+                METAMGR_READ(level1room_shua_robot_min_time, 5);
+                METAMGR_READ(level1room_shua_robot_max_time, 7);
+                METAMGR_READ(level1room_shua_robot_min_num, 2);
+                METAMGR_READ(level1room_shua_robot_max_num, 5);
+                METAMGR_READ(level1room_die_robot_min_time, 10);
+                METAMGR_READ(level1room_die_robot_max_time, 20);
+                METAMGR_READ(level1room_die_robot_min_num, 1);
+                METAMGR_READ(level1room_die_robot_max_num, 5);
+            }
             if (MetaMgr::Instance()->K < 0.01f) {
                 abort();
             }
@@ -195,10 +217,54 @@ public:
             }
         }
         #endif
+        Check();
     }
 
 private:
 
+    void Check()
+    {
+
+        {
+            if (MetaMgr::Instance()->level0room_shua_robot_min_time >
+                MetaMgr::Instance()->level0room_shua_robot_max_time) {
+                abort();
+            }
+            if (MetaMgr::Instance()->level0room_shua_robot_min_num >
+                MetaMgr::Instance()->level0room_shua_robot_max_num) {
+                abort();
+            }
+            if (MetaMgr::Instance()->level0room_die_robot_min_time >
+                MetaMgr::Instance()->level0room_die_robot_max_time) {
+                abort();
+            }
+            if (MetaMgr::Instance()->level0room_die_robot_min_num >
+                MetaMgr::Instance()->level0room_die_robot_max_num) {
+                abort();
+            }
+        }
+
+        {
+            if (MetaMgr::Instance()->level1room_shua_robot_min_time >
+                MetaMgr::Instance()->level1room_shua_robot_max_time) {
+                abort();
+            }
+            if (MetaMgr::Instance()->level1room_shua_robot_min_num >
+                MetaMgr::Instance()->level1room_shua_robot_max_num) {
+                abort();
+            }
+            if (MetaMgr::Instance()->level1room_die_robot_min_time >
+                MetaMgr::Instance()->level1room_die_robot_max_time) {
+                abort();
+            }
+            if (MetaMgr::Instance()->level1room_die_robot_min_num >
+                MetaMgr::Instance()->level1room_die_robot_max_num) {
+                abort();
+            }
+        }
+
+    }
+
     void BindToMetaData()
     {
 

server/gameserver/metamgr.h

@@ -73,6 +73,24 @@ class MetaMgr : public a8::Singleton<MetaMgr>
     int newbie_first_robot_distance = 0;
     std::vector<int> newbie_buff_list;
 
+    int level0room_shua_robot_min_time = 0;
+    int level0room_shua_robot_max_time = 0;
+    int level0room_shua_robot_min_num = 0;
+    int level0room_shua_robot_max_num = 0;
+    int level0room_die_robot_min_time = 0;
+    int level0room_die_robot_max_time = 0;
+    int level0room_die_robot_min_num = 0;
+    int level0room_die_robot_max_num = 0;
+
+    int level1room_shua_robot_min_time = 0;
+    int level1room_shua_robot_max_time = 0;
+    int level1room_shua_robot_min_num = 0;
+    int level1room_shua_robot_max_num = 0;
+    int level1room_die_robot_min_time = 0;
+    int level1room_die_robot_max_time = 0;
+    int level1room_die_robot_min_num = 0;
+    int level1room_die_robot_max_num = 0;
+
     int other_fill_interval = 0;
     float android_attack_range = 0;
     float android_pursuit_range = 0;

server/gameserver/moveableentity.h

@@ -5,6 +5,9 @@
 class MoveableEntity : public RoomEntity
 {
  public:
-    int updated_times = 0;
     virtual void Update(int delta_time) {};
+    int UpdatedTimes() { return updated_times_;}
+
+protected:
+    int updated_times_ = 0;
 };

server/gameserver/player.cc

@@ -38,16 +38,24 @@ void Player::Initialize()
 }
 
 void Player::Update(int delta_time)
+{
+    if (UpdatedTimes() <= 0) {
+        if (room->frame_no % 2 != 0) {
+            return;
+        }
+    }
+    InternalUpdate(delta_time);
+    if (room->frame_no % 2 == 0) {
+        SendUpdateMsg();
+    }
+    ++updated_times_;
+}
+
+void Player::InternalUpdate(int delta_time)
 {
     if (poisoning) {
         poisoning_time += delta_time;
     }
-    #if 0
-    if (a8::HasBitFlag(status, HS_Fly)) {
-        SetPos(room->plane.curr_pos);
-        room->grid_service.MoveHuman(this);
-    }
-    #endif
     if (moving) {
         UpdateMove();
     }

server/gameserver/player.h

@@ -102,4 +102,5 @@ class Player : public Human
 private:
     void InternalAdCancel();
     void InternalAdOk();
+    void InternalUpdate(int delta_time);
 };

server/gameserver/room.cc

@@ -89,27 +89,16 @@ void Room::Update(int delta_time)
         return;
     }
 
+    real_alive_count_ = 0;
     elapsed_time_ += delta_time;
     while (elapsed_time_ >= 50) {
         if (frame_no % 2 == 0) {
             UpdateGas();
         }
         for (auto& pair : moveable_hash_) {
-            if (pair.second->entity_type == ET_Player &&
-                pair.second->updated_times <= 0) {
-                if (frame_no % 2 == 0) {
             pair.second->Update(50);
-                    pair.second->updated_times++;
-                }
-            } else {
-                pair.second->Update(50);
-                pair.second->updated_times++;
-            }
         }
         if (frame_no % 2 == 0) {
-            for (auto& pair : human_hash_) {
-                pair.second->SendUpdateMsg();
-            }
             frame_event.Clear();
         }
         ++frame_no;
@@ -145,6 +134,16 @@ int Room::AliveCount()
     return alive_count_;
 }
 
+int Room::RealAliveCount()
+{
+    return real_alive_count_;
+}
+
+int Room::ActiveCount()
+{
+    return active_count_;
+}
+
 void Room::AddPlayer(Player* hum)
 {
     assert(gas_data.gas_mode == GasInactive);
@@ -1675,6 +1674,10 @@ void Room::NotifyGameStart()
                                          room->waiting_start = false;
                                      },
                                      &xtimer_attacher_.timer_list_);
+    if (room_type == RT_MidBrid) {
+        ShuaAndroidTimerFunc();
+        DieAndroidTimerFunc();
+    }
 }
 
 void Room::InitObstacleDatas()
@@ -1753,4 +1756,132 @@ void Room::ShuaNewBieAndroid(Human* target)
             break;
         }
     }
+    ShuaAndroidTimerFunc();
+    DieAndroidTimerFunc();
+}
+
+void Room::ShuaAndroidTimerFunc()
+{
+    if (room_type == RT_NewBrid || room_type == RT_MidBrid) {
+        int shua_time = a8::RandEx(
+                                   MetaMgr::Instance()->level0room_shua_robot_min_time,
+                                   MetaMgr::Instance()->level0room_shua_robot_max_time
+                                   );
+        int shua_num = a8::RandEx(
+                                  MetaMgr::Instance()->level0room_shua_robot_min_num,
+                                  MetaMgr::Instance()->level0room_shua_robot_max_num
+                                  );
+        if (room_type == RT_MidBrid) {
+            shua_time = a8::RandEx(
+                                   MetaMgr::Instance()->level1room_shua_robot_min_time,
+                                   MetaMgr::Instance()->level1room_shua_robot_max_time
+                                   );
+            shua_num = a8::RandEx(
+                                  MetaMgr::Instance()->level1room_shua_robot_min_num,
+                                  MetaMgr::Instance()->level1room_shua_robot_max_num
+                                  );
+        }
+        if (shua_time <= 0) {
+            return;
+        }
+        if (shua_num <= 0) {
+            return;
+        }
+        shua_android_timer = xtimer.AddDeadLineTimerAndAttach
+            (SERVER_FRAME_RATE * shua_time,
+             a8::XParams()
+             .SetSender(this),
+             [] (const a8::XParams& param)
+             {
+                 Room* room = (Room*)param.sender.GetUserData();
+                 room->ShuaAndroidTimerFunc();
+             },
+             &xtimer_attacher_.timer_list_,
+             [] (const a8::XParams& param)
+             {
+                 Room* room = (Room*)param.sender.GetUserData();
+                 room->shua_android_timer = nullptr;
+             }
+             );
+        ProcShuaAndroid(shua_time, shua_num);
+    }
+}
+
+void Room::DieAndroidTimerFunc()
+{
+    if (room_type == RT_NewBrid || room_type == RT_MidBrid) {
+        int die_time = a8::RandEx(
+                                   MetaMgr::Instance()->level0room_die_robot_min_time,
+                                   MetaMgr::Instance()->level0room_die_robot_max_time
+                                   );
+        int die_num = a8::RandEx(
+                                  MetaMgr::Instance()->level0room_die_robot_min_num,
+                                  MetaMgr::Instance()->level0room_die_robot_max_num
+                                  );
+        if (room_type == RT_MidBrid) {
+            die_time = a8::RandEx(
+                                   MetaMgr::Instance()->level1room_die_robot_min_time,
+                                   MetaMgr::Instance()->level1room_die_robot_max_time
+                                   );
+            die_num = a8::RandEx(
+                                  MetaMgr::Instance()->level1room_die_robot_min_num,
+                                  MetaMgr::Instance()->level1room_die_robot_max_num
+                                  );
+        }
+        if (die_time <= 0) {
+            return;
+        }
+        if (die_num <= 0) {
+            return;
+        }
+        die_android_timer = xtimer.AddDeadLineTimerAndAttach
+            (SERVER_FRAME_RATE * die_time,
+             a8::XParams()
+             .SetSender(this),
+             [] (const a8::XParams& param)
+             {
+                 Room* room = (Room*)param.sender.GetUserData();
+                 room->DieAndroidTimerFunc();
+             },
+             &xtimer_attacher_.timer_list_,
+             [] (const a8::XParams& param)
+             {
+                 Room* room = (Room*)param.sender.GetUserData();
+                 room->die_android_timer = nullptr;
+             }
+             );
+        ProcDieAndroid(die_time, die_num);
+    }
+}
+
+void Room::ProcShuaAndroid(int shua_time, int shua_num)
+{
+    for (auto& pair : human_hash_) {
+        if (pair.second->entity_subtype == EST_Android &&
+            a8::HasBitFlag(pair.second->status, HS_Disable)) {
+            Android* hum = (Android*)pair.second;
+        }
+    }
+}
+
+void Room::ProcDieAndroid(int die_time, int die_num)
+{
+    for (auto& pair : human_hash_) {
+        if (pair.second->entity_subtype == EST_Android &&
+            a8::HasBitFlag(pair.second->status, HS_Disable)) {
+            Android* hum = (Android*)pair.second;
+        }
+    }
+}
+
+void Room::IncActiveCount()
+{
+    ++active_count_;
+    ++App::Instance()->perf.active_count;
+}
+
+void Room::DecActiveCount()
+{
+    --active_count_;
+    --App::Instance()->perf.active_count;
 }

server/gameserver/room.h

@@ -64,6 +64,8 @@ public:
     MetaData::MapTplThing* newbie_born_point_meta = nullptr;
     std::vector<MetaData::MapTplThing*>* loots = nullptr;
     std::vector<Building*>* buildings = nullptr;
+    xtimer_list* shua_android_timer = nullptr;
+    xtimer_list* die_android_timer = nullptr;
 
     ~Room();
     void Init();
@@ -71,6 +73,8 @@ public:
     void Update(int delta_time);
     int GetPlayerNum();
     int AliveCount();
+    inline int RealAliveCount();
+    int ActiveCount();
     Player* GetPlayerByAccountId(const std::string& accountid);
     Player* GetPlayerByUniId(int uniid);
     Entity* GetEntityByUniId(int uniid);
@@ -155,10 +159,18 @@ private:
     void InitObstacleDatas();
     void EnableHuman(Human* hum);
     void DisableHuman(Human* hum);
+    void ShuaAndroidTimerFunc();
+    void DieAndroidTimerFunc();
+    void ProcShuaAndroid(int shua_time, int shua_num);
+    void ProcDieAndroid(int die_time, int die_num);
+    void IncActiveCount();
+    void DecActiveCount();
 
 private:
     int elapsed_time_ = 0;
     int alive_count_ = 0;
+    int real_alive_count_ = 0;
+    int active_count_ = 0;
     int force_shua_android_times_ = 0;
     MetaData::AirLine* airline_ = nullptr;
     a8::XTimerAttacher xtimer_attacher_;

server/gameserver/types.h

@@ -11,6 +11,8 @@ struct PerfMonitor
     long long grid_chg_times = 0;
     long long test_times = 0;
     long long alive_count = 0;
+    long long real_alive_count = 0;
+    long long active_count = 0;
     std::array<long long, 30> params = {};
     std::array<int, 30> entity_num = {};
 };