diff --git a/server/gameserver/android.ai.cc b/server/gameserver/android.ai.cc
index a54c5eb..4ccba14 100644
--- a/server/gameserver/android.ai.cc
+++ b/server/gameserver/android.ai.cc
@@ -20,17 +20,17 @@ AndroidAI::~AndroidAI()
 void AndroidAI::Update(int delta_time)
 {
     Human* hum = (Human*)owner;
-    state_elapsed_time += delta_time;
+    state_elapsed_time_ += delta_time;
     if (hum->dead) {
         return;
     }
     if (hum->playing_skill) {
         hum->UpdateSkill();
     }
-    switch (state) {
+    switch (state_) {
     case AS_thinking:
         {
-            if (state_elapsed_time > 1500 + rand() % 3000) {
+            if (state_elapsed_time_ > 1500 + rand() % 3000) {
                 int rnd = rand();
                 if (rnd % 100 < 30) {
                     ChangeToState(AS_moving);
@@ -42,7 +42,7 @@ void AndroidAI::Update(int delta_time)
         break;
     case AS_moving:
         {
-            if (state_elapsed_time < 1000 + rand() % 2000) {
+            if (state_elapsed_time_ < 1000 + rand() % 2000) {
                 DoMove();
             } else {
                 int rnd = rand();
@@ -56,7 +56,7 @@ void AndroidAI::Update(int delta_time)
         break;
     case AS_attack:
         {
-            if (state_elapsed_time < 1000) {
+            if (state_elapsed_time_ < 1000) {
                 DoAttack();
             } else {
                 int rnd = rand();
@@ -71,11 +71,38 @@ void AndroidAI::Update(int delta_time)
     }
 }
 
+void AndroidAI::LockEnemy(Human* enemy)
+{
+    locked_enemy_ = enemy;
+    if (state_ != AS_attack) {
+        ChangeToState(AS_attack);
+    }
+}
+
+void AndroidAI::LockEnemy(int target_id)
+{
+    Human* enemy = HumMaster()->room->GetHumanByUniId(target_id);
+    if (enemy) {
+        LockEnemy(enemy);
+        locked_frameno_ = HumMaster()->room->frameno;
+    }
+}
+
+void AndroidAI::UnLockEnemy()
+{
+    locked_enemy_ = nullptr;
+}
+
+Human* AndroidAI::HumMaster()
+{
+    return (Human*)owner;
+}
+
 void AndroidAI::ChangeToState(AndroidState_e to_state)
 {
-    state = to_state;
-    state_elapsed_time = 0;
-    switch (state) {
+    state_ = to_state;
+    state_elapsed_time_ = 0;
+    switch (state_) {
     case AS_moving:
         {
             Human* hum = (Human*)owner;
diff --git a/server/gameserver/android.ai.h b/server/gameserver/android.ai.h
index 9bb9710..56e4096 100644
--- a/server/gameserver/android.ai.h
+++ b/server/gameserver/android.ai.h
@@ -6,22 +6,25 @@ enum AndroidState_e
 {
    AS_thinking,
    AS_moving,
-   AS_attack
+   AS_attack,
 };
 
 class Human;
 class AndroidAI : public AIComponent
 {
  public:
-    AndroidState_e state = AS_thinking;
-    int state_elapsed_time = 0;
-    Human* last_hiter = nullptr;
-
     virtual ~AndroidAI() override;
     virtual void Update(int delta_time) override;
 
-private:
+    void LockEnemy(Human* enemy);
+    void LockEnemy(int target_id);
+    void UnLockEnemy();
 
+private:
+    AndroidState_e state_ = AS_thinking;
+    int state_elapsed_time_ = 0;
+
+    Human* HumMaster();
     void ChangeToState(AndroidState_e to_state);
 
     void DoMove();
@@ -29,4 +32,7 @@ private:
 
     void Shot(Human* enemy);
     void UseSkill(Human* enemy);
+
+    Human* locked_enemy_ = nullptr;
+    long long locked_frameno_ = 0;
 };
diff --git a/server/gameserver/buff.cc b/server/gameserver/buff.cc
index 17f3dc6..ecedf4b 100644
--- a/server/gameserver/buff.cc
+++ b/server/gameserver/buff.cc
@@ -8,7 +8,7 @@
 
 int Buff::GetLeftTime()
 {
-    int passed_ms = (owner->room->frame_no - add_frameno) * kFRAME_RATE_MS;
+    int passed_ms = (owner->room->frameno - add_frameno) * kFRAME_RATE_MS;
     return std::max(GetLastingTime() - passed_ms, 0);
 }
 
diff --git a/server/gameserver/bullet.cc b/server/gameserver/bullet.cc
index 08973a9..6ad31f5 100644
--- a/server/gameserver/bullet.cc
+++ b/server/gameserver/bullet.cc
@@ -126,7 +126,7 @@ void Bullet::OnHit(std::set<Entity*>& objects)
 
                     obstacle->health = std::max(0.0f, obstacle->health - finaly_dmg);
                     obstacle->dead = obstacle->health <= 0.01f;
-                    obstacle->dead_frameno = room->frame_no;
+                    obstacle->dead_frameno = room->frameno;
                     if (obstacle->dead) {
                         if (obstacle->meta->i->damage_dia() > 0.01f &&
                             obstacle->meta->i->damage() > 0.01f) {
diff --git a/server/gameserver/framemaker.cc b/server/gameserver/framemaker.cc
index 738a1ce..5603115 100644
--- a/server/gameserver/framemaker.cc
+++ b/server/gameserver/framemaker.cc
@@ -85,7 +85,7 @@ cs::SMUpdate* FrameMaker::MakeUpdateMsg(const Human* hum)
         {
             if (room->BattleStarted()) {
                 int game_left_time = MetaMgr::Instance()->game_duration * 1000 -
-                    (room->frame_no - room->battle_start_frameno_) * kFRAME_RATE_MS;
+                    (room->frameno - room->battle_start_frameno_) * kFRAME_RATE_MS;
                 game_left_time = std::max(0, game_left_time);
                 msg->set_game_left_time(game_left_time);
             } else {
diff --git a/server/gameserver/gamelog.cc b/server/gameserver/gamelog.cc
index 76e9f37..26bb525 100644
--- a/server/gameserver/gamelog.cc
+++ b/server/gameserver/gamelog.cc
@@ -71,7 +71,7 @@ void GameLog::GameEnd(Player* hum)
     prop->SetVal("map_name", hum->room->map_meta->i->map_name());
     prop->SetVal("map_tpl_name", hum->room->map_tpl_name);
     if (!hum->dead) {
-        prop->SetVal("alive_time", hum->room->frame_no * 1000.0f / kSERVER_FRAME_RATE);
+        prop->SetVal("alive_time", hum->room->frameno * 1000.0f / kSERVER_FRAME_RATE);
     } else {
         prop->SetVal("alive_time", hum->dead_frameno * 1000.0f / kSERVER_FRAME_RATE);
     }
diff --git a/server/gameserver/human.cc b/server/gameserver/human.cc
index 0ca1011..a6b69ed 100644
--- a/server/gameserver/human.cc
+++ b/server/gameserver/human.cc
@@ -203,7 +203,7 @@ void Human::Shot()
     if (curr_weapon->ammo <= 0) {
         AutoLoadingBullet();
     }
-    last_shot_frameno_ = room->frame_no;
+    last_shot_frameno_ = room->frameno;
     need_sync_active_player = true;
 }
 
@@ -381,7 +381,7 @@ void Human::UpdateSkill()
     if (skill_meta_) {
         if (curr_skill_phase < skill_meta_->phases.size()) {
             MetaData::SkillPhase* phase = &skill_meta_->phases[curr_skill_phase];
-            if (phase->time_offset >= (int)((room->frame_no - last_use_skill_frameno_) * kFRAME_RATE_MS)) {
+            if (phase->time_offset >= (int)((room->frameno - last_use_skill_frameno_) * kFRAME_RATE_MS)) {
                 ProcSkillPhase(phase);
                 ++curr_skill_phase;
             }
@@ -424,7 +424,7 @@ void Human::StartAction(ActionType_e action_type,
         return;
     }
     this->action_type = action_type;
-    this->action_frameno = room->frame_no;
+    this->action_frameno = room->frameno;
     this->action_duration = action_duration;
     this->action_item_id = item_id;
     this->action_target_id = target_id;
@@ -462,7 +462,7 @@ void Human::BeKill(int killer_id, const std::string& killer_name, int weapon_id)
         stats.killer_name = killer_name;
         stats.weapon_id = weapon_id;
         dead = true;
-        dead_frameno = room->frame_no;
+        dead_frameno = room->frameno;
         room->xtimer.AddDeadLineTimerAndAttach(MetaMgr::Instance()->revive_time * kSERVER_FRAME_RATE,
                                                a8::XParams()
                                                .SetSender(this),
@@ -500,6 +500,7 @@ void Human::DecHP(float dec_hp, int killer_id, const std::string& killer_name, i
     last_attacker_id = killer_id;
     last_attacker_name = killer_name;
     last_attacker_weapon_id = weapon_id;
+    last_attacked_frameno = room->frameno;
     SyncAroundPlayers();
 }
 
@@ -571,7 +572,7 @@ void Human::DoSkill()
         skill_target_pos = a8::Vec2();
         skill_param1 = 0.0f;
         playing_skill = true;
-        last_use_skill_frameno_ = room->frame_no;
+        last_use_skill_frameno_ = room->frameno;
         Entity* entity = room->GetEntityByUniId(skill_target_id);
         if (entity && entity->entity_type == kET_Player) {
             Human* hum = (Human*)entity;
@@ -723,7 +724,7 @@ void Human::FillMFActivePlayerData(cs::MFActivePlayerData* player_data)
         if (action_type != kAT_None) {
             int duration = std::max(0,
                                     action_duration -
-                                    (int)((room->frame_no - action_frameno) * 1.0f / kSERVER_FRAME_RATE) * 1000
+                                    (int)((room->frameno - action_frameno) * 1.0f / kSERVER_FRAME_RATE) * 1000
                                     );
             player_data->set_action_item_id(action_item_id);
             player_data->set_action_duration(duration);
@@ -755,7 +756,7 @@ void Human::FillMFGasData(cs::MFGasData* gas_data)
     gas_data->set_mode(room->gas_data.gas_mode);
     if (room->gas_data.gas_mode == kGasInactive) {
         long long duration = MetaMgr::Instance()->gas_inactive_time * kSERVER_FRAME_RATE -
-            (room->frame_no - room->gas_data.gas_start_frameno);
+            (room->frameno - room->gas_data.gas_start_frameno);
         gas_data->set_duration(std::max(duration * 50, (long long)1000) / 1000);
      } else {
         #if 0
@@ -763,7 +764,7 @@ void Human::FillMFGasData(cs::MFGasData* gas_data)
             gas_data->set_duration(0);
         } else {
             long long duration = room->gas_data.old_area_meta->i->wait_time() * 20 -
-                (room->frame_no - room->gas_data.gas_start_frameno);
+                (room->frameno - room->gas_data.gas_start_frameno);
             gas_data->set_duration(std::max(duration * 50, (long long)1000) / 1000);
         }
         #endif
@@ -967,7 +968,7 @@ void Human::UpdateAction()
 {
     int duration = std::max(0,
                             action_duration -
-                            (int)((room->frame_no - action_frameno) * 1.0f / kSERVER_FRAME_RATE) * 1000
+                            (int)((room->frameno - action_frameno) * 1.0f / kSERVER_FRAME_RATE) * 1000
                             );
     if (duration <= 0) {
         switch (action_type) {
@@ -1076,7 +1077,7 @@ int Human::GetSkillLeftTime()
         if (last_use_skill_frameno_ == 0) {
             return 0;
         } else {
-            int passed_time = (room->frame_no - last_use_skill_frameno_) * kFRAME_RATE_MS;
+            int passed_time = (room->frameno - last_use_skill_frameno_) * kFRAME_RATE_MS;
             int skill_left_time = std::max(0, skill_meta_->i->skill_cd() * 1000 - passed_time);
             return skill_left_time;
         }
@@ -1149,7 +1150,7 @@ void Human::AddBuff(MetaData::Buff* buff_meta)
     buff->owner = this;
     buff->meta = buff_meta;
     //buff->skill_meta
-    buff->add_frameno = room->frame_no;
+    buff->add_frameno = room->frameno;
     buff->xtimer_attacher.xtimer = &room->xtimer;
     buff_effect_[buff->meta->i->buff_effect()] = buff;
     room->frame_event.AddBuff(this, buff);
@@ -1497,7 +1498,7 @@ void Human::_UpdateMove(int speed)
 void Human::_UpdateAssaultMove()
 {
     Buff* buff = GetBuffByEffectId(kBET_Assault);
-    if (!buff || (room->frame_no - buff->add_frameno) * kFRAME_RATE_MS < buff->meta->param1) {
+    if (!buff || (room->frameno - buff->add_frameno) * kFRAME_RATE_MS < buff->meta->param1) {
         return;
     }
     bool move_end = false;
diff --git a/server/gameserver/human.h b/server/gameserver/human.h
index 56bab8b..d8b4b61 100644
--- a/server/gameserver/human.h
+++ b/server/gameserver/human.h
@@ -43,6 +43,7 @@ class Human : public Entity
     int last_attacker_id = 0;
     std::string last_attacker_name;
     int last_attacker_weapon_id = 0;
+    long long last_attacked_frameno = 0;
 
     a8::Vec2 move_dir;
     a8::Vec2 attack_dir;
diff --git a/server/gameserver/obstacle.cc b/server/gameserver/obstacle.cc
index e8d1447..7014998 100644
--- a/server/gameserver/obstacle.cc
+++ b/server/gameserver/obstacle.cc
@@ -113,7 +113,7 @@ void Obstacle::FillMFObjectFull(cs::MFObjectFull* full_data)
     p->set_obstacle_id(meta->i->thing_id());
     p->set_health(health);
     p->set_dead(dead);
-    p->set_dead_at_thisframe(dead ? dead_frameno <= room->frame_no : false);
+    p->set_dead_at_thisframe(dead ? dead_frameno <= room->frameno : false);
     if (master) {
         p->set_master_id(master->entity_uniid);
     }
@@ -227,7 +227,7 @@ void Obstacle::Explosion()
 
                         obstacle->health = std::max(0.0f, obstacle->health - finaly_dmg);
                         obstacle->dead = obstacle->health <= 0.01f;
-                        obstacle->dead_frameno = room->frame_no;
+                        obstacle->dead_frameno = room->frameno;
                         if (obstacle->dead) {
                             room->ScatterDrop(obstacle->pos, obstacle->meta->i->drop());
                         }
diff --git a/server/gameserver/player.cc b/server/gameserver/player.cc
index e3f3bc7..8a8ab67 100644
--- a/server/gameserver/player.cc
+++ b/server/gameserver/player.cc
@@ -60,7 +60,7 @@ void Player::Update(int delta_time)
             UpdateMove();
         }
     }
-    if (room->frame_no % 2 == 0) {
+    if (room->frameno % 2 == 0) {
         if (shot_start || shot_hold) {
             UpdateShot();
         }
@@ -142,7 +142,7 @@ void Player::UpdateShot()
         ++series_shot_frames;
         if (last_shot_frameno_ == 0 ||
             (
-             (room->frame_no - last_shot_frameno_) * (1000 / kSERVER_FRAME_RATE)) >=
+             (room->frameno - last_shot_frameno_) * (1000 / kSERVER_FRAME_RATE)) >=
             curr_weapon->meta->i->fire_rate()
             ) {
             Shot();
@@ -564,7 +564,7 @@ void Player::_CMLeave(f8::MsgHdr& hdr, const cs::CMLeave& msg)
             BeKill(entity_uniid, name, kVW_Spectate);
         }
         leave_ = true;
-        leave_frameno_ = room->frame_no;
+        leave_frameno_ = room->frameno;
     }
     cs::SMLeave respmsg;
     SendNotifyMsg(respmsg);
diff --git a/server/gameserver/room.cc b/server/gameserver/room.cc
index 80d57cc..ba79d18 100644
--- a/server/gameserver/room.cc
+++ b/server/gameserver/room.cc
@@ -26,7 +26,7 @@
 static long long RoomXGetTickCount(void* context)
 {
     Room* room = (Room*)context;
-    return room->frame_no;
+    return room->frameno;
 }
 
 Room::~Room()
@@ -90,19 +90,19 @@ void Room::UnInit()
 void Room::Update(int delta_time)
 {
     xtimer.Update();
-    if (game_over && frame_no - game_over_frameno > kSERVER_FRAME_RATE * 20) {
+    if (game_over && frameno - game_over_frameno > kSERVER_FRAME_RATE * 20) {
         return;
     }
 
     elapsed_time_ += delta_time;
     while (elapsed_time_ >= 50) {
-        if (frame_no % 2 == 0) {
+        if (frameno % 2 == 0) {
             UpdateGas();
         }
         for (auto& pair : moveable_hash_) {
             if (pair.second->entity_type == kET_Player &&
                 pair.second->updated_times <= 0) {
-                if (frame_no % 2 == 0) {
+                if (frameno % 2 == 0) {
                     pair.second->Update(50);
                     pair.second->updated_times++;
                 }
@@ -111,13 +111,13 @@ void Room::Update(int delta_time)
                 pair.second->updated_times++;
             }
         }
-        if (frame_no % 2 == 0) {
+        if (frameno % 2 == 0) {
             for (auto& pair : human_hash_) {
                 pair.second->SendUpdateMsg();
             }
             frame_event.Clear();
         }
-        ++frame_no;
+        ++frameno;
         elapsed_time_ -= 50;
     }
 }
@@ -179,7 +179,7 @@ void Room::AddPlayer(Player* hum)
         hum->move_dir = hum->attack_dir;
     }
     hum->room = this;
-    hum->join_frameno = frame_no;
+    hum->join_frameno = frameno;
     hum->Initialize();
     born_point_human_hash_[hum->born_point] = hum;
     uniid_hash_[hum->entity_uniid] = hum;
@@ -814,17 +814,17 @@ void Room::UpdateGas()
     switch (gas_data.gas_mode) {
     case kGasInactive:
         {
-            if (frame_no - gas_data.gas_start_frameno >=
+            if (frameno - gas_data.gas_start_frameno >=
                 MetaMgr::Instance()->gas_inactive_time * kSERVER_FRAME_RATE) {
                 gas_data.gas_mode = kGasStarted;
-                gas_data.gas_start_frameno = frame_no;
+                gas_data.gas_start_frameno = frameno;
                 if (human_hash_.size() < kROOM_MAX_PLAYER_NUM) {
                     CreateAndroid(kROOM_MAX_PLAYER_NUM - human_hash_.size());
                     NotifyUiUpdate();
                 }
                 NotifyWxVoip();
                 RoomMgr::Instance()->ActiveRoom(room_uuid);
-                battle_start_frameno_ = frame_no;
+                battle_start_frameno_ = frameno;
                 battle_report_timer_ = xtimer.AddDeadLineTimerAndAttach(kSERVER_FRAME_RATE * MetaMgr::Instance()->game_duration,
                                                                         a8::XParams()
                                                                         .SetSender(this),
@@ -1061,7 +1061,7 @@ void Room::BattleReport()
         }
     }
     game_over = true;
-    game_over_frameno = frame_no;
+    game_over_frameno = frameno;
     RoomMgr::Instance()->AddOverRoom(room_uuid);
 }
 
diff --git a/server/gameserver/room.h b/server/gameserver/room.h
index e94614f..7a3068d 100644
--- a/server/gameserver/room.h
+++ b/server/gameserver/room.h
@@ -35,7 +35,7 @@ public:
     int map_height = 0;
     FrameEvent frame_event;
     FrameMaker frame_maker;
-    long long frame_no = 0;
+    long long frameno = 0;
     GasData gas_data;
     bool game_over = false;
     long long game_over_frameno = 0;