diff --git a/server/gameserver/android.ai.cc b/server/gameserver/android.ai.cc
index 2e60951..7734ccf 100644
--- a/server/gameserver/android.ai.cc
+++ b/server/gameserver/android.ai.cc
@@ -118,8 +118,10 @@ void AndroidAI::DoAttack()
         Human* enemy = owner->room->FindEnemy((Human*)owner);
         if (enemy) {
             Human* sender = (Human*)owner;
-            Vector2D shot_dir = enemy->pos;
+            Vector2D shot_dir = enemy->pos - sender->pos;
             shot_dir.Normalize();
+            shot_dir.Rotate((rand() % 10) / 180.0f);
+            sender->attack_dir = shot_dir;
             sender->Shot(shot_dir);
         }
     }
diff --git a/server/gameserver/android.cc b/server/gameserver/android.cc
index 7d4b239..44cc46a 100644
--- a/server/gameserver/android.cc
+++ b/server/gameserver/android.cc
@@ -32,5 +32,8 @@ void Android::Update(int delta_time)
         pos = room->plane.curr_pos;
         room->grid_service.MoveHuman(this);
     }
+    if (action_type != AT_None) {
+        UpdateAction();
+    }
     ai->Update(delta_time);
 }
diff --git a/server/gameserver/bullet.cc b/server/gameserver/bullet.cc
index 3d80af3..1bc2337 100644
--- a/server/gameserver/bullet.cc
+++ b/server/gameserver/bullet.cc
@@ -38,7 +38,7 @@ void Bullet::Update(int delta_time)
         for (auto& grid : grid_list) {
             for (Human* hum: grid->human_list) {
 #if 1
-                if (hum != player) {
+                if (hum != player && !hum->dead) {
 #else
                 if (hum != player &&
                     (hum->team_id == 0 || player->team_id != hum->team_id)) {
diff --git a/server/gameserver/constant.h b/server/gameserver/constant.h
index cca524d..670f5d6 100755
--- a/server/gameserver/constant.h
+++ b/server/gameserver/constant.h
@@ -148,3 +148,5 @@ const int MAP_WIDTH = 8192;
 const int MAP_CELL_WIDTH = 64 * 8;
 
 const int DOOR_THING_ID = 61701;
+
+const int FIGHTING_MODE_BULLET_NUM = 10000 * 10000;
diff --git a/server/gameserver/human.cc b/server/gameserver/human.cc
index 8f376b1..9de4948 100644
--- a/server/gameserver/human.cc
+++ b/server/gameserver/human.cc
@@ -36,6 +36,14 @@ Human::Human():Entity()
     weapons[0] = default_weapon;
     curr_weapon = &weapons[0];
     inventory_[IS_1XSCOPE] = 1;
+
+    if (MetaMgr::Instance()->fighting_mode) {
+        inventory_[IS_9MM] = FIGHTING_MODE_BULLET_NUM;
+        inventory_[IS_556MM] = FIGHTING_MODE_BULLET_NUM;
+        inventory_[IS_762MM] = FIGHTING_MODE_BULLET_NUM;
+        inventory_[IS_12GAUGE] = FIGHTING_MODE_BULLET_NUM;
+        inventory_[IS_RPG] = FIGHTING_MODE_BULLET_NUM;
+    }
 }
 
 Human::~Human()
@@ -185,6 +193,12 @@ void Human::Shot(Vector2D& target_dir)
         Vector2D bullet_born_offset = Vector2D(std::get<0>(tuple), std::get<1>(tuple));
         bullet_born_offset.Rotate(attack_dir.CalcAngle(Vector2D::UP));
         Vector2D bullet_born_pos = pos + bullet_born_offset;
+        Vector2D bullet_dir = attack_dir;
+        float bullet_angle = std::get<2>(tuple);
+        if (curr_weapon->meta->i->bullet_angle() >= 1.0f) {
+            bullet_angle += (rand() % (int)curr_weapon->meta->i->bullet_angle()) * (rand() % 2 == 0 ? 1 : -1);
+        }
+        bullet_dir.Rotate(bullet_angle / 180.0f);
         room->frame_event.AddBullet(this, bullet_born_pos, attack_dir, fly_distance);
         room->CreateBullet(this, curr_weapon->meta, bullet_born_pos, attack_dir, fly_distance);
     }
@@ -704,6 +718,17 @@ bool Human::HasNoDownedTeammate()
 void Human::Land()
 {
     a8::UnSetBitFlag(status, HS_Jump);
+    if (entity_subtype == EST_Android) {
+        MetaData::Equip* weapon_meta = MetaMgr::Instance()->GetEquip(a8::RandEx(12103, 12122));
+        if (weapon_meta) {
+            weapons[GUN_SLOT1].weapon_idx = GUN_SLOT1;
+            weapons[GUN_SLOT1].weapon_id = weapon_meta->i->id();
+            weapons[GUN_SLOT1].weapon_lv = 1;
+            weapons[GUN_SLOT1].ammo = 0;
+            weapons[GUN_SLOT1].meta = weapon_meta;
+            curr_weapon = &weapons[GUN_SLOT1];
+        }
+    }
     FindLocation();
     SyncAroundPlayers();
 }
@@ -1465,6 +1490,140 @@ void Human::SendRollMsg(const std::string& roll_msg)
                                            );
 }
 
+void Human::UpdateAction()
+{
+    int duration = std::max(0,
+                            action_duration -
+                            (int)((room->frame_no - action_frameno) * 1.0f / SERVER_FRAME_RATE) * 1000
+                            );
+    if (duration <= 0) {
+        switch (action_type) {
+        case AT_Reload:
+            {
+                if (curr_weapon->weapon_idx == action_target_id &&
+                    curr_weapon->weapon_id == action_item_id &&
+                    curr_weapon->weapon_idx != 0) {
+                    MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(curr_weapon->meta->i->use_bullet());
+                    if (bullet_meta) {
+                        int ammo = curr_weapon->ammo;
+                        if (ammo < curr_weapon->meta->i->clip_volume()) {
+                            if (bullet_meta->i->_inventory_slot() >= 0 &&
+                                bullet_meta->i->_inventory_slot() < IS_END) {
+                                if (GetInventory(bullet_meta->i->_inventory_slot()) > 0) {
+                                    int add_num = 0;
+                                    if (GetInventory(bullet_meta->i->_inventory_slot()) <=
+                                        curr_weapon->meta->i->clip_volume() - ammo) {
+                                        add_num = GetInventory(bullet_meta->i->_inventory_slot());
+                                        DecInventory(bullet_meta->i->_inventory_slot(), add_num);
+                                    } else {
+                                        add_num = curr_weapon->meta->i->clip_volume() - ammo;
+                                        DecInventory(bullet_meta->i->_inventory_slot(), add_num);
+                                    }
+                                    curr_weapon->ammo += add_num;
+                                    need_sync_active_player = true;;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+        case AT_UseItem:
+            {
+                switch (action_item_id) {
+                case IS_HEALTHKIT:
+                    {
+                        MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(action_item_id);
+                        if (item_meta){
+                            if (GetInventory(item_meta->i->_inventory_slot()) > 0) {
+                                float old_health = health;
+                                health += item_meta->i->heal();
+                                health = std::min(health, GetMaxHP());
+                                stats.heal_amount += health - old_health;
+                                DecInventory(item_meta->i->_inventory_slot(), 1);
+                                need_sync_active_player = true;
+                                SyncAroundPlayers();
+                            }
+                        }
+                    }
+                    break;
+                case IS_PAIN_KILLER:
+                    {
+                        MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(action_item_id);
+                        if (item_meta){
+                            if (GetInventory(item_meta->i->_inventory_slot()) > 0) {
+                                if (pain_killer_timer) {
+                                    int passed_time = (room->frame_no - pain_killer_frameno) * FRAME_RATE_MS;
+                                    int left_time = std::max(0, pain_killer_lastingtime * 1000 - passed_time);
+                                    int anodyne_max_time = MetaMgr::Instance()->GetSysParamAsInt("anodyne_max_time");
+                                    left_time = std::min(left_time, anodyne_max_time * 1000);
+                                    pain_killer_lastingtime += std::min(item_meta->i->time() * 1000, anodyne_max_time * 1000 - left_time) / 1000;
+                                    need_sync_active_player = true;
+                                } else {
+                                    pain_killer_frameno = room->frame_no;
+                                    pain_killer_lastingtime = item_meta->i->time();
+                                    pain_killer_timer = room->xtimer.AddRepeatTimerAndAttach(
+                                                                                             SERVER_FRAME_RATE,
+                                                                                             a8::XParams()
+                                                                                             .SetSender(this)
+                                                                                             .SetParam1(item_meta->i->heal()),
+                                                                                             [] (const a8::XParams& param)
+                                                                                             {
+                                                                                                 Human* hum = (Human*)param.sender.GetUserData();
+                                                                                                 float old_health = hum->health;
+                                                                                                 hum->health += param.param1.GetDouble();
+                                                                                                 hum->health = std::min(hum->health, hum->GetMaxHP());
+                                                                                                 hum->stats.heal_amount += hum->health - old_health;
+                                                                                                 hum->SyncAroundPlayers();
+                                                                                                 if (hum->room->frame_no - hum->pain_killer_frameno > hum->pain_killer_lastingtime * SERVER_FRAME_RATE) {
+                                                                                                     hum->room->xtimer.DeleteTimer(hum->pain_killer_timer);
+                                                                                                     hum->pain_killer_timer = nullptr;
+                                                                                                 }
+                                                                                             },
+                                                                                             &xtimer_attacher.timer_list_
+                                                                                             );
+                                }
+                                DecInventory(item_meta->i->_inventory_slot(), 1);
+                                need_sync_active_player = true;
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    {
+                    }
+                    break;
+                }
+            }
+            break;
+        case AT_Relive:
+            {
+                Entity* entity = room->GetEntityByUniId(action_target_id);
+                if (entity->entity_type != ET_Player) {
+                    return;
+                }
+                Human* hum = (Human*)entity;
+                if (hum->action_type == AT_Rescue) {
+                    hum->CancelAction();
+                    return;
+                }
+                if (!hum->dead && hum->downed) {
+                    hum->health = MetaMgr::Instance()->GetSysParamAsInt("downed_relive_recover_hp");
+                    hum->downed = false;
+                    if (hum->downed_timer) {
+                        room->xtimer.DeleteTimer(hum->downed_timer);
+                        hum->downed_timer = nullptr;
+                    }
+                    ++hum->stats.rescue_member;
+                }
+                hum->SyncAroundPlayers();
+            }
+            break;
+        }
+        ResetAction();
+    }
+}
+
 void Human::ClearFrameData()
 {
     if (!new_objects.empty()) {
diff --git a/server/gameserver/human.h b/server/gameserver/human.h
index 3a86507..f76bb8b 100644
--- a/server/gameserver/human.h
+++ b/server/gameserver/human.h
@@ -171,6 +171,7 @@ class Human : public Entity
     void FollowTarget(Human* target);
     void SendDebugMsg(const std::string& debug_msg);
     void SendRollMsg(const std::string& roll_msg);
+    void UpdateAction();
 
 private:
     void ClearFrameData();
diff --git a/server/gameserver/metamgr.cc b/server/gameserver/metamgr.cc
index c1445cf..c41b639 100755
--- a/server/gameserver/metamgr.cc
+++ b/server/gameserver/metamgr.cc
@@ -96,6 +96,7 @@ public:
             MetaMgr::Instance()->K = MetaMgr::Instance()->GetSysParamAsFloat("K");
             MetaMgr::Instance()->kill_param = MetaMgr::Instance()->GetSysParamAsFloat("kill_parameter");
             MetaMgr::Instance()->rank_param = MetaMgr::Instance()->GetSysParamAsFloat("rank_parameter");
+            MetaMgr::Instance()->fighting_mode = MetaMgr::Instance()->GetSysParamAsInt("fighting_mode", 1);
             if (MetaMgr::Instance()->K < 0.01f) {
                 abort();
             }
diff --git a/server/gameserver/metamgr.h b/server/gameserver/metamgr.h
index ac0cc37..0f2b3d7 100755
--- a/server/gameserver/metamgr.h
+++ b/server/gameserver/metamgr.h
@@ -39,6 +39,7 @@ class MetaMgr : public a8::Singleton<MetaMgr>
     float K = 100.0f;
     float kill_param = 0.0f;
     float rank_param = 0.0f;
+    int fighting_mode = 0;
 
  private:
     MetaDataLoader* loader_ = nullptr;
diff --git a/server/gameserver/obstacle.cc b/server/gameserver/obstacle.cc
index d1fe53f..d3cdf2c 100644
--- a/server/gameserver/obstacle.cc
+++ b/server/gameserver/obstacle.cc
@@ -94,6 +94,7 @@ void Obstacle::FillMFObjectFull(cs::MFObjectFull* full_data)
     p->set_is_door(is_door);
     if (is_door) {
         p->set_door_id(door_id);
+        p->set_door_open_times(door_open_times);
         p->set_door_old_state((int)door_state);
         p->set_door_new_state((int)door_state);
         p->set_door_house_uniid(door_house_uniid);
diff --git a/server/gameserver/obstacle.h b/server/gameserver/obstacle.h
index befc090..13f4a7b 100644
--- a/server/gameserver/obstacle.h
+++ b/server/gameserver/obstacle.h
@@ -30,6 +30,7 @@ class Obstacle : public Entity
 
     bool is_door = false;
     int door_id = 0;
+    int door_open_times = 0;
     DoorState_e door_state = DoorStateClose;
     Building* building = nullptr;
     int door_house_uniid = 0;
diff --git a/server/gameserver/player.cc b/server/gameserver/player.cc
index 4f69bc2..65be105 100644
--- a/server/gameserver/player.cc
+++ b/server/gameserver/player.cc
@@ -175,153 +175,22 @@ void Player::UpdateSelectWeapon()
         return;
     }
     if (selected_weapon_idx >= 0 && selected_weapon_idx < weapons.size()) {
+        Weapon* old_weapon = curr_weapon;
         Weapon* weapon = &weapons[selected_weapon_idx];
         if (weapon->weapon_id != 0) {
             curr_weapon = weapon;
             ResetAction();
             need_sync_active_player = true;
             SyncAroundPlayers();
-            AutoLoadingBullet();
+            if (old_weapon != weapon) {
+                AutoLoadingBullet();
+            }
         }
     }
     select_weapon = false;
     selected_weapon_idx = 0;
 }
 
-void Player::UpdateAction()
-{
-    int duration = std::max(0,
-                            action_duration -
-                            (int)((room->frame_no - action_frameno) * 1.0f / SERVER_FRAME_RATE) * 1000
-                            );
-    if (duration <= 0) {
-        switch (action_type) {
-        case AT_Reload:
-            {
-                if (curr_weapon->weapon_idx == action_target_id &&
-                    curr_weapon->weapon_id == action_item_id &&
-                    curr_weapon->weapon_idx != 0) {
-                    MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(curr_weapon->meta->i->use_bullet());
-                    if (bullet_meta) {
-                        int ammo = curr_weapon->ammo;
-                        if (ammo < curr_weapon->meta->i->clip_volume()) {
-                            if (bullet_meta->i->_inventory_slot() >= 0 &&
-                                bullet_meta->i->_inventory_slot() < IS_END) {
-                                if (GetInventory(bullet_meta->i->_inventory_slot()) > 0) {
-                                    int add_num = 0;
-                                    if (GetInventory(bullet_meta->i->_inventory_slot()) <=
-                                        curr_weapon->meta->i->clip_volume() - ammo) {
-                                        add_num = GetInventory(bullet_meta->i->_inventory_slot());
-                                        DecInventory(bullet_meta->i->_inventory_slot(), add_num);
-                                    } else {
-                                        add_num = curr_weapon->meta->i->clip_volume() - ammo;
-                                        DecInventory(bullet_meta->i->_inventory_slot(), add_num);
-                                    }
-                                    curr_weapon->ammo += add_num;
-                                    need_sync_active_player = true;;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-        case AT_UseItem:
-            {
-                switch (action_item_id) {
-                case IS_HEALTHKIT:
-                    {
-                        MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(action_item_id);
-                        if (item_meta){
-                            if (GetInventory(item_meta->i->_inventory_slot()) > 0) {
-                                float old_health = health;
-                                health += item_meta->i->heal();
-                                health = std::min(health, GetMaxHP());
-                                stats.heal_amount += health - old_health;
-                                DecInventory(item_meta->i->_inventory_slot(), 1);
-                                need_sync_active_player = true;
-                                SyncAroundPlayers();
-                            }
-                        }
-                    }
-                    break;
-                case IS_PAIN_KILLER:
-                    {
-                        MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(action_item_id);
-                        if (item_meta){
-                            if (GetInventory(item_meta->i->_inventory_slot()) > 0) {
-                                if (pain_killer_timer) {
-                                    int passed_time = (room->frame_no - pain_killer_frameno) * FRAME_RATE_MS;
-                                    int left_time = std::max(0, pain_killer_lastingtime * 1000 - passed_time);
-                                    int anodyne_max_time = MetaMgr::Instance()->GetSysParamAsInt("anodyne_max_time");
-                                    left_time = std::min(left_time, anodyne_max_time * 1000);
-                                    pain_killer_lastingtime += std::min(item_meta->i->time() * 1000, anodyne_max_time * 1000 - left_time) / 1000;
-                                    need_sync_active_player = true;
-                                } else {
-                                    pain_killer_frameno = room->frame_no;
-                                    pain_killer_lastingtime = item_meta->i->time();
-                                    pain_killer_timer = room->xtimer.AddRepeatTimerAndAttach(
-                                                                                             SERVER_FRAME_RATE,
-                                                                                             a8::XParams()
-                                                                                             .SetSender(this)
-                                                                                             .SetParam1(item_meta->i->heal()),
-                                                                                             [] (const a8::XParams& param)
-                                                                                             {
-                                                                                                 Human* hum = (Human*)param.sender.GetUserData();
-                                                                                                 float old_health = hum->health;
-                                                                                                 hum->health += param.param1.GetDouble();
-                                                                                                 hum->health = std::min(hum->health, hum->GetMaxHP());
-                                                                                                 hum->stats.heal_amount += hum->health - old_health;
-                                                                                                 hum->SyncAroundPlayers();
-                                                                                                 if (hum->room->frame_no - hum->pain_killer_frameno > hum->pain_killer_lastingtime * SERVER_FRAME_RATE) {
-                                                                                                     hum->room->xtimer.DeleteTimer(hum->pain_killer_timer);
-                                                                                                     hum->pain_killer_timer = nullptr;
-                                                                                                 }
-                                                                                             },
-                                                                                             &xtimer_attacher.timer_list_
-                                                                                             );
-                                }
-                                DecInventory(item_meta->i->_inventory_slot(), 1);
-                                need_sync_active_player = true;
-                            }
-                        }
-                    }
-                    break;
-                default:
-                    {
-                    }
-                    break;
-                }
-            }
-            break;
-        case AT_Relive:
-            {
-                Entity* entity = room->GetEntityByUniId(action_target_id);
-                if (entity->entity_type != ET_Player) {
-                    return;
-                }
-                Human* hum = (Human*)entity;
-                if (hum->action_type == AT_Rescue) {
-                    hum->CancelAction();
-                    return;
-                }
-                if (!hum->dead && hum->downed) {
-                    hum->health = MetaMgr::Instance()->GetSysParamAsInt("downed_relive_recover_hp");
-                    hum->downed = false;
-                    if (hum->downed_timer) {
-                        room->xtimer.DeleteTimer(hum->downed_timer);
-                        hum->downed_timer = nullptr;
-                    }
-                    ++hum->stats.rescue_member;
-                }
-                hum->SyncAroundPlayers();
-            }
-            break;
-        }
-        ResetAction();
-    }
-}
-
 void Player::UpdateReload()
 {
     AutoLoadingBullet(true);
@@ -586,6 +455,7 @@ void Player::ObstacleInteraction(Obstacle* entity)
             entity->pos = Vector2D(entity->building->pos.x + entity->door_state0->x() - entity->building->meta->i->tilewidth() / 2.0,
                                    entity->building->pos.y + entity->door_state0->y() - entity->building->meta->i->tileheight() / 2.0);
         }
+        ++entity->door_open_times;
         entity->RecalcSelfCollider();
         room->TouchHumanList(a8::XParams(),
                              [entity] (Human* hum, a8::XParams& param) -> bool
@@ -791,7 +661,7 @@ void Player::HumanInteraction(Human* hum)
     }
     hum->StartAction(
                      AT_Rescue,
-                     MetaMgr::Instance()->GetSysParamAsInt("rescue_time") * 1000,
+                     MetaMgr::Instance()->GetSysParamAsInt("downed_relive_time") * 1000,
                      room->frame_no,
                      entity_uniid
                      );
diff --git a/server/gameserver/player.h b/server/gameserver/player.h
index 96f16a3..6b82065 100644
--- a/server/gameserver/player.h
+++ b/server/gameserver/player.h
@@ -71,7 +71,6 @@ class Player : public Human
     void UpdateSelectWeapon();
     void UpdateDropWeapon();
     void UpdateUseScope();
-    void UpdateAction();
     void UpdateReload();
     void UpdateCancelAction();
     void UpdateUseItemIdx();
diff --git a/server/gameserver/room.cc b/server/gameserver/room.cc
index e3faf36..b0f4ee0 100644
--- a/server/gameserver/room.cc
+++ b/server/gameserver/room.cc
@@ -26,7 +26,7 @@ const int ROOM_MAX_PLAYER_NUM = 50;
 #if 0
 const int ANDROID_NUM = 0;
 #else
-const int ANDROID_NUM = 10;
+const int ANDROID_NUM = 49;
 #endif
 
 static long long RoomXGetTickCount(void* context)
@@ -123,11 +123,6 @@ void Room::Update(int delta_time)
     }
 }
 
-bool Room::IsFull()
-{
-    return accountid_hash_.size() >= ROOM_MAX_PLAYER_NUM;
-}
-
 int Room::GetPlayerNum()
 {
     return accountid_hash_.size();
@@ -158,6 +153,7 @@ int Room::AliveCount()
 
 void Room::AddPlayer(Player* hum)
 {
+    assert(gas_data.gas_mode == GasInactive);
     {
         hum->pos.x = 3000 + rand() % 100;
         hum->pos.y = 3000 + rand() % 200;
@@ -179,6 +175,9 @@ void Room::AddPlayer(Player* hum)
     hum->FindLocation();
     hum->RefreshView();
     MatchTeam(hum);
+    while (human_hash_.size() > ROOM_MAX_PLAYER_NUM) {
+        RandRemoveAndroid();
+    }
 }
 
 unsigned short Room::AllocUniid()
@@ -202,8 +201,8 @@ void Room::ShuaAndroid()
         hum->meta = hum_meta;
         hum->entity_uniid = AllocUniid();
         {
-            hum->pos.x = 3000 + rand() % 400;
-            hum->pos.y = 3000 + rand() % 500;
+            hum->pos.x = 3000 + rand() % 1400;
+            hum->pos.y = 3000 + rand() % 1500;
             hum->attack_dir = hum->pos;
             hum->attack_dir.Normalize();
             hum->attack_dir.Rotate(a8::RandAngle());
@@ -230,11 +229,22 @@ Human* Room::FindEnemy(Human* hum)
 {
     std::vector<Human*> enemys;
     enemys.reserve(50);
-    for (auto& pair : accountid_hash_) {
-        if (pair.second->team_id == 0 ||
-            pair.second->team_id != hum->team_id
-            ) {
-            enemys.push_back(pair.second);
+    EntitySubType_e sub_type = EST_Player;
+    if ((rand() % 10) < 2) {
+        sub_type = EST_Android;
+    }
+    for (auto& cell : hum->grid_list) {
+        for (Human* target : cell->human_list) {
+            if (target->entity_subtype == sub_type &&
+                !target->dead) {
+                if (hum->pos.Distance(target->pos) < 300.0f) {
+                    if (target->team_id == 0 ||
+                        target->team_id != hum->team_id
+                        ) {
+                        enemys.push_back(target);
+                    }
+                }
+            }
         }
     }
     std::sort(enemys.begin(), enemys.end(),
@@ -474,6 +484,10 @@ void Room::CreateLoot(int equip_id, Vector2D pos, int count)
 {
     MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(equip_id);
     if (equip_meta) {
+        if (equip_meta->i->equip_type() == 2 &&
+            MetaMgr::Instance()->fighting_mode) {
+            return;
+        }
         Loot* entity = new Loot();
         entity->room = this;
         entity->meta = equip_meta;
@@ -526,6 +540,12 @@ void Room::RemoveObjectLater(Entity* entity)
                                    entity->room->grid_service.DelEntity(entity);
                                }
                                break;
+                           case ET_Player:
+                               {
+                                   entity->room->moveable_hash_.erase(entity->entity_uniid);
+                                   entity->room->human_hash_.erase(entity->entity_uniid);
+                               }
+                               break;
                            default:
                                {
                                    abort();
@@ -638,6 +658,14 @@ int Room::GetAliveTeamNum()
     return num;
 }
 
+bool Room::CanJoin(const std::string& accountid)
+{
+    if (gas_data.gas_mode != GasInactive) {
+        return false;
+    }
+    return accountid_hash_.size() < ROOM_MAX_PLAYER_NUM;
+}
+
 std::set<Human*>* Room::GetAliveTeam()
 {
     for (auto& pair : team_hash_) {
@@ -1117,3 +1145,30 @@ void Room::OnGameOver()
         }
     }
 }
+
+void Room::RandRemoveAndroid()
+{
+    Human* hum = nullptr;
+    for (auto& pair : human_hash_) {
+        if (pair.second->entity_subtype == EST_Android) {
+            hum = pair.second;
+            break;
+        }
+    }
+    if (hum) {
+        if (hum->team_id != 0) {
+            team_hash_.erase(hum->team_id);
+        }
+        for (auto& cell : hum->grid_list) {
+            for (Human* target : cell->human_list) {
+                target->AddOutObjects(hum);
+            }
+            cell->human_list.erase(hum);
+        }
+        moveable_hash_.erase(hum->entity_uniid);
+        uniid_hash_.erase(hum->entity_uniid);
+        human_hash_.erase(hum->entity_uniid);
+        removed_robot_hash_[hum->entity_uniid] = hum;
+        --alive_count_;
+    }
+}
diff --git a/server/gameserver/room.h b/server/gameserver/room.h
index 4775a5b..d3dbcb9 100644
--- a/server/gameserver/room.h
+++ b/server/gameserver/room.h
@@ -50,7 +50,6 @@ public:
     void Init();
     void UnInit();
     void Update(int delta_time);
-    bool IsFull();
     int GetPlayerNum();
     int AliveCount();
     Player* GetPlayerByAccountId(const std::string& accountid);
@@ -88,6 +87,7 @@ public:
     bool BattleStarted();
     int GetAliveTeamNum();
     std::set<Human*>* GetAliveTeam();
+    bool CanJoin(const std::string& accountid);
 
 private:
     unsigned short AllocUniid();
@@ -109,6 +109,7 @@ private:
                                      std::function<void (Obstacle*)> on_precreate);
     void AddObjectLater(Entity* entity);
     void OnGameOver();
+    void RandRemoveAndroid();
 
 private:
     timer_list* stats_timer_ = nullptr;
@@ -127,4 +128,6 @@ private:
     std::map<unsigned short, Entity*> uniid_hash_;
     std::map<unsigned short, Entity*> later_add_hash_;
     std::map<unsigned short, Human*> human_hash_;
+
+    std::map<unsigned short, Human*> removed_robot_hash_;
 };
diff --git a/server/gameserver/roommgr.cc b/server/gameserver/roommgr.cc
index ba8c6d5..3daaa7d 100644
--- a/server/gameserver/roommgr.cc
+++ b/server/gameserver/roommgr.cc
@@ -106,7 +106,7 @@ int RoomMgr::RoomNum()
 Room* RoomMgr::GetJoinableRoom(const std::string& account_id)
 {
     for (auto& pair : inactive_room_hash_) {
-        if (!pair.second->IsFull() && !pair.second->GetPlayerByAccountId(account_id)) {
+        if (pair.second->CanJoin(account_id)) {
             return pair.second;
         }
     }
diff --git a/server/gameserver/vector2d.cc b/server/gameserver/vector2d.cc
index 127cc34..f2b26af 100644
--- a/server/gameserver/vector2d.cc
+++ b/server/gameserver/vector2d.cc
@@ -135,6 +135,12 @@ Vector2D Vector2D::FromAngle(float angle)
     return vec2;
 }
 
+float Vector2D::Distance(const Vector2D& b)
+{
+    Vector2D v = b - *this;
+    return v.Norm();
+}
+
 Vector2D Vector2D::Perp()
 {
     return Vector2D(y, -x);
diff --git a/server/gameserver/vector2d.h b/server/gameserver/vector2d.h
index cdf4f19..5ee1b74 100644
--- a/server/gameserver/vector2d.h
+++ b/server/gameserver/vector2d.h
@@ -19,6 +19,7 @@ struct Vector2D
     void Rotate(float angle);
     float CalcAngle(const Vector2D& b);
     static Vector2D FromAngle(float angle);
+    float Distance(const Vector2D& b);
 
     bool operator == (const Vector2D& b) const;
     Vector2D operator + (const Vector2D& b) const;
diff --git a/server/tools/protobuild/cs_proto.proto b/server/tools/protobuild/cs_proto.proto
index 81b6160..b3d9702 100755
--- a/server/tools/protobuild/cs_proto.proto
+++ b/server/tools/protobuild/cs_proto.proto
@@ -191,6 +191,7 @@ message MFObstacleFull
     optional int32 door_house_id = 26; //门所属房间id
     optional float door_width = 27; //门宽度
     optional float door_height = 28; //门高度
+    optional int32 door_open_times = 29; //门开启次数,每次开/关 ++times 0:客户端自动开
 
 }