1

server/gameserver/android_new.ai.cc

@@ -61,48 +61,11 @@ void AndroidNewAI::Update(int delta_time)
         }
     }
     #endif
-    switch (GetAiLevel()) {
-    case 1:
-        {
-            UpdateAiLevel1();
-        }
-        break;
-    case 2:
-        {
-            UpdateAiLevel2();
-        }
-        break;
-    case 3:
-        {
-            UpdateAiLevel3();
-        }
-        break;
-    case 4:
-        {
-            UpdateAiLevel4();
-        }
-        break;
-    case 5:
-        {
-            UpdateAiLevel5();
-        }
-        break;
-    case 6:
-        {
-            UpdateAiLevel6();
-        }
-        break;
-    case 7:
-        {
-            UpdateAiLevel7();
-        }
-        break;
-    default:
-        {
+    if (hum->room->GetGasData().gas_mode == GasInactive) {
         DefaultAi();
+        return;
     }
-        break;
-    }
+    UpdateNewAI();
 }
 
 void AndroidNewAI::DefaultAi()
@@ -227,46 +190,6 @@ void AndroidNewAI::DoAttackOldAI()
     }
 }
 
-void AndroidNewAI::UpdateAiLevel1()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel2()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel3()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel4()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel5()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel6()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel7()
-{
-    DefaultAi();
-}
-
-void AndroidNewAI::UpdateAiLevel8()
-{
-    DefaultAi();
-}
-
 void AndroidNewAI::UpdateNewBieNpc()
 {
     Human* hum = (Human*)owner;
@@ -460,3 +383,148 @@ void AndroidNewAI::UpdateNewBieRoomLogic()
         }
     }
 }
+
+void AndroidNewAI::UpdateNewAI()
+{
+    Human* hum = (Human*)owner;
+    ++node_.exec_frame_num;
+    hum->shot_hold = false;
+    switch (node_.main_state) {
+    case ASE_Idle:
+        {
+            UpdateIdle();
+        }
+        break;
+    case ASE_Thinking:
+        {
+            UpdateThinking();
+        }
+        break;
+    case ASE_Attack:
+        {
+            UpdateAttack();
+        }
+        break;
+    case ASE_RandomWalk:
+        {
+            UpdateRandomWalk();
+        }
+        break;
+    }
+    if (moving_) {
+        DoMoveNewAI();
+    }
+}
+
+void AndroidNewAI::UpdateIdle()
+{
+    Human* hum = (Human*)owner;
+    if (hum->room->GetFrameNo() > node_.frameno + node_.param1) {
+        ChangeToStateNewAI(ASE_Thinking);
+    }
+}
+
+void AndroidNewAI::UpdateThinking()
+{
+    Human* hum = (Human*)owner;
+    if (hum->room->GetGasData().gas_mode == GasInactive ||
+        hum->room->IsWaitingStart()) {
+        if (hum->room->IsWaitingStart()) {
+            ChangeToStateNewAI(ASE_Idle);
+        } else {
+            ChangeToStateNewAI(ASE_RandomWalk);
+        }
+    } else {
+        std::array<Human*, kAndroidAi_RMax> targets = {};
+        ScanTarget(targets);
+        Human* target = GetTarget(targets, target_range);
+        if (target) {
+            node.target = target;
+            ChangeToStateNewAI(ASE_Attack);
+        } else {
+            if ((rand() % 7) < 4) {
+                ChangeToStateNewAI(ASE_Idle);
+            } else {
+                ChangeToStateNewAI(ASE_RandomWalk);
+            }
+        }
+    }
+}
+
+void AndroidNewAI::UpdateAttack()
+{
+
+}
+
+void AndroidNewAI::UpdateRandomWalk()
+{
+
+}
+
+void AndroidNewAI::DoMoveNewAI()
+{
+    Human* hum = (Human*)owner;
+    if (hum->UpdatedTimes() % 2 == 0) {
+        if (std::abs(hum->move_dir.x) > FLT_EPSILON ||
+            std::abs(hum->move_dir.y) > FLT_EPSILON) {
+            int speed = std::max(1, (int)hum->GetSpeed());
+            for (int i = 0; i < speed; ++i) {
+                a8::Vec2 old_pos = hum->GetPos();
+                hum->SetPos(hum->GetPos() + hum->move_dir);
+                if (hum->IsCollisionInMapService()) {
+                    hum->SetPos(old_pos);
+                    if (i == 0) {
+                        hum->FindPathInMapService();
+                    }
+                    break;
+                }
+                hum->room->grid_service->MoveHuman(hum);
+            }
+        }
+    }
+}
+
+void AndroidNewAI::ChangeToStateNewAI(AndroidStateEx_e to_state)
+{
+    Human* hum = (Human*)owner;
+    switch (to_state) {
+    case ASE_Idle:
+        {
+            node_.param1 = 0;
+            moving_ = false;
+            if (hum->room->GetGasData().gas_mode == GasInactive ||
+                hum->room->IsWaitingStart()) {
+                node_.param1 = rand() % (3 * SERVER_FRAME_RATE);
+            } else {
+                node_.param1 = rand() % (2 * SERVER_FRAME_RATE);
+            }
+        }
+        break;
+    case ASE_Thinking:
+        {
+            node_.param1 = 0;
+            moving_ = false;
+        }
+        break;
+    case ASE_Attack:
+        {
+            node_.param1 = 0;
+            moving_ = false;
+            node_.shot_times = 0;
+        }
+        break;
+    case ASE_RandomWalk:
+        {
+            moving_ = true;
+            node_.param1 = SERVER_FRAME_RATE * 2 + rand() % (SERVER_FRAME_RATE * 3);
+            hum->move_dir = a8::Vec2(1.0f, 0);
+            hum->move_dir.Rotate(a8::RandAngle());
+            hum->move_dir.Normalize();
+            hum->attack_dir = hum->move_dir;
+        }
+        break;
+    }
+    node_.main_state = to_state;
+    node_.frameno = hum->room->GetFrameNo();
+    node_.exec_frame_num = 0;
+}

server/gameserver/android_new.ai.h

@@ -3,6 +3,27 @@
 #include "aicomponent.h"
 #include "android.ai.h"
 
+enum AndroidStateEx_e
+{
+   ASE_Idle = 0,
+   ASE_Thinking = 1,
+   ASE_Attack = 2,
+   ASE_RandomWalk = 3
+};
+
+class AINode
+{
+public:
+    AndroidStateEx_e main_state = ASE_Idle;
+    long long frameno = 0;
+    long long exec_frame_num = 0;
+
+    long long param1 = 0;
+    Human* target = nullptr;
+    a8::Vec2 shot_dir;
+    int shot_times = 0;
+};
+
 struct OldAiData
 {
     AndroidState_e state = AS_thinking;
@@ -30,20 +51,23 @@ private:
     void UpdateLastNpc();
     void UpdateNewBieRoomLogic();
 
-    void UpdateAiLevel1();
-    void UpdateAiLevel2();
-    void UpdateAiLevel3();
-    void UpdateAiLevel4();
-    void UpdateAiLevel5();
-    void UpdateAiLevel6();
-    void UpdateAiLevel7();
-    void UpdateAiLevel8();
+    void UpdateNewAI();
+    void UpdateIdle();
+    void UpdateThinking();
+    void UpdateAttack();
+    void UpdateRandomWalk();
+    void DoMoveNewAI();
+    void ChangeToStateNewAI(AndroidStateEx_e to_state);
 
 private:
     OldAiData old_ai_data_;
+
     double param1_ = 0;
     double param2_ = 0;
     double param3_ = 0;
     double param4_ = 0;
 
+    AINode node_;
+    bool moving_ = false;
+
 };