diff --git a/server/gameserver/android.ai.cc b/server/gameserver/android.ai.cc
index d55cb9e..e27585e 100644
--- a/server/gameserver/android.ai.cc
+++ b/server/gameserver/android.ai.cc
@@ -103,7 +103,7 @@ void AndroidAI::ChangeToState(AndroidState_e to_state)
 void AndroidAI::DoMove()
 {
     Human* hum = (Human*)owner;
-    if (hum->room->waiting_start) {
+    if (hum->room->IsWaitingStart()) {
         return;
     }
     if (owner->UpdatedTimes() % 2 == 0) {
@@ -132,10 +132,10 @@ void AndroidAI::DoMove()
 void AndroidAI::DoAttack()
 {
     Human* hum = (Human*)owner;
-    if (hum->room->waiting_start) {
+    if (hum->room->IsWaitingStart()) {
         return;
     }
-    if (hum->room->gas_data.gas_mode == GasInactive) {
+    if (hum->room->GetGasData().gas_mode == GasInactive) {
         return;
     }
     if (owner->UpdatedTimes() % 10 == 0) {
diff --git a/server/gameserver/framemaker.cc b/server/gameserver/framemaker.cc
index db5a387..12314d5 100644
--- a/server/gameserver/framemaker.cc
+++ b/server/gameserver/framemaker.cc
@@ -189,9 +189,9 @@ cs::SMUpdate* FrameMaker::MakeUpdateMsg(const Human* hum)
         if (room->frame_event.airdrops_.size() > 0) {
             *msg->mutable_airdrop() = room->frame_event.airdrops_.Get(0);
         }
-        if (room->gas_data.gas_mode == GasMoving) {
-            msg->set_gas_progress(room->gas_data.gas_progress);
-            TypeConvert::ToPb(room->gas_data.pos_old, msg->mutable_gas_pos_old());
+        if (room->GetGasData().gas_mode == GasMoving) {
+            msg->set_gas_progress(room->GetGasData().gas_progress);
+            TypeConvert::ToPb(room->GetGasData().pos_old, msg->mutable_gas_pos_old());
         }
         msg->set_alive_count(room->AliveCount());
     }
diff --git a/server/gameserver/human.cc b/server/gameserver/human.cc
index f8c0bf7..bffc3ed 100644
--- a/server/gameserver/human.cc
+++ b/server/gameserver/human.cc
@@ -277,7 +277,7 @@ void Human::FillMFTeamData(cs::MFTeamData* team_data)
 #if 1
     {
 #else
-    if (room->gas_data.gas_mode == GasJump ||
+    if (room->GetGasData().gas_mode == GasJump ||
         room->GetFrameNo() - last_sync_teamdata_frameno_ > SERVER_FRAME_RATE * 2) {
 #endif
         last_sync_teamdata_frameno_ = room->GetFrameNo();
@@ -477,7 +477,7 @@ bool Human::IsCollisionInMapService()
                         if (!obstacle->IsDead(room) &&
                             obstacle->meta->i->attack_type() == 1 &&
                             obstacle->meta->i->drop() != 0 &&
-                            room->gas_data.gas_mode != GasInactive
+                            room->GetGasData().gas_mode != GasInactive
                             ) {
                             obstacle->Die(room);
                             if (obstacle->IsDead(room)) {
@@ -644,10 +644,10 @@ void Human::UpdatePoisoning()
     }
     bool need_notify = poisoning_time > 1000;
     while (poisoning_time > 1000) {
-        if (room->gas_data.is_last_gas) {
-            DecHP(room->gas_data.new_area_meta->i->hurt(), VP_SafeArea, "毒圈", VW_SafeArea);
+        if (room->GetGasData().is_last_gas) {
+            DecHP(room->GetGasData().new_area_meta->i->hurt(), VP_SafeArea, "毒圈", VW_SafeArea);
         } else {
-            DecHP(room->gas_data.old_area_meta->i->hurt(), VP_SafeArea, "毒圈", VW_SafeArea);
+            DecHP(room->GetGasData().old_area_meta->i->hurt(), VP_SafeArea, "毒圈", VW_SafeArea);
         }
         if (dead) {
             poisoning_time = 0;
@@ -697,8 +697,9 @@ void Human::SyncAroundPlayers(const char* file, int line, const char* func)
 #endif
             assert(hum->part_objects.find(this) != hum->part_objects.end());
             if (hum->part_objects.find(this) == hum->part_objects.end()) {
-                if (a8::XGetTickCount() - room->last_debugout_tick > 1000 * 10) {
-                    room->last_debugout_tick = a8::XGetTickCount();
+                static long long last_debugout_tick = 0;
+                if (a8::XGetTickCount() - last_debugout_tick > 1000 * 10) {
+                    last_debugout_tick = a8::XGetTickCount();
                     a8::UdpLog::Instance()->Warning("SyncAroundPlayers error file:%s line:%d func:%s",
                                                     {
                                                      file,
@@ -795,7 +796,7 @@ void Human::FillSMGameOver(cs::SMGameOver& msg)
                              [&human_list] (Human* hum, a8::XParams& param) -> bool
                              {
                                  if (hum->leave_frameno_ == 0 ||
-                                     hum->leave_frameno_ > hum->room->battle_start_frameno_) {
+                                     hum->leave_frameno_ > hum->room->GetBattleStartFrameNo()) {
                                      human_list.push_back(hum);
                                  }
                                  return true;
@@ -839,7 +840,7 @@ void Human::FillSMGameOver(cs::SMGameOver& msg)
     msg.set_team_id(team_id);
     msg.set_team_rank(stats.rank);
     msg.set_team_allcnt(1);
-    msg.set_game_over(room->game_over);
+    msg.set_game_over(room->IsGameOver());
     msg.set_victory(!dead);
     msg.set_room_uuid(a8::XValue(room->room_uuid));
 
@@ -852,7 +853,7 @@ void Human::BeKill(int killer_id, const std::string& killer_name, int weapon_id)
     #ifdef DEBUG
     room->CheckPartObjects();
     #endif
-    if (!dead && !room->game_over && !real_dead) {
+    if (!dead && !room->IsGameOver() && !real_dead) {
         lethal_weapon = weapon_id;
         Entity* hum = room->GetEntityByUniId(killer_id);
         if (hum && hum->entity_type == ET_Player) {
@@ -1448,35 +1449,35 @@ void Human::FillMFActivePlayerData(cs::MFActivePlayerData* player_data)
 
 void Human::FillMFGasData(cs::MFGasData* gas_data)
 {
-    gas_data->set_mode(room->gas_data.gas_mode);
-    if (room->gas_data.gas_mode == GasInactive) {
+    gas_data->set_mode(room->GetGasData().gas_mode);
+    if (room->GetGasData().gas_mode == GasInactive) {
         long long duration = room->GetGasInactiveTime() * SERVER_FRAME_RATE -
-            (room->GetFrameNo() - room->gas_data.gas_start_frameno);
+            (room->GetFrameNo() - room->GetGasData().gas_start_frameno);
         gas_data->set_duration(std::max(duration * 50, (long long)1000) / 1000);
-    } else if (room->gas_data.gas_mode == GasJump) {
+    } else if (room->GetGasData().gas_mode == GasJump) {
         gas_data->set_duration(0);
-   } else if (room->gas_data.gas_mode == GasMoving) {
-        if (room->gas_data.new_area_meta->i->shrink_speed() > 0.01f) {
-            long long duration = (room->gas_data.old_area_meta->i->rad() - room->gas_data.new_area_meta->i->rad()) /
-                room->gas_data.new_area_meta->i->shrink_speed();
+   } else if (room->GetGasData().gas_mode == GasMoving) {
+        if (room->GetGasData().new_area_meta->i->shrink_speed() > 0.01f) {
+            long long duration = (room->GetGasData().old_area_meta->i->rad() - room->GetGasData().new_area_meta->i->rad()) /
+                room->GetGasData().new_area_meta->i->shrink_speed();
             ++duration;
             gas_data->set_duration(++duration);
         } else {
             gas_data->set_duration(0);
         }
      } else {
-        if (room->gas_data.old_area_meta->i->wait_time() <= 0) {
+        if (room->GetGasData().old_area_meta->i->wait_time() <= 0) {
             gas_data->set_duration(0);
         } else {
-            long long duration = room->gas_data.old_area_meta->i->wait_time() * 20 -
-                (room->GetFrameNo() - room->gas_data.gas_start_frameno);
+            long long duration = room->GetGasData().old_area_meta->i->wait_time() * 20 -
+                (room->GetFrameNo() - room->GetGasData().gas_start_frameno);
             gas_data->set_duration(std::max(duration * 50, (long long)1000) / 1000);
         }
     }
-    TypeConvert::ToPb(room->gas_data.pos_old, gas_data->mutable_pos_old());
-    TypeConvert::ToPb(room->gas_data.pos_new, gas_data->mutable_pos_new());
-    gas_data->set_rad_old(room->gas_data.rad_old);
-    gas_data->set_rad_new(room->gas_data.rad_new);
+    TypeConvert::ToPb(room->GetGasData().pos_old, gas_data->mutable_pos_old());
+    TypeConvert::ToPb(room->GetGasData().pos_new, gas_data->mutable_pos_new());
+    gas_data->set_rad_old(room->GetGasData().rad_old);
+    gas_data->set_rad_new(room->GetGasData().rad_new);
 }
 
 bool Human::CanSee(const Human* hum) const
@@ -1603,8 +1604,8 @@ void Human::SendUpdateMsg()
         }
 
         cs::SMUpdate* msg = room->frame_maker.MakeUpdateMsg(this);
-        if (send_msg_times == 0 || last_sync_gas_frameno < room->gas_data.gas_start_frameno) {
-            last_sync_gas_frameno = room->gas_data.gas_start_frameno;
+        if (send_msg_times == 0 || last_sync_gas_frameno < room->GetGasData().gas_start_frameno) {
+            last_sync_gas_frameno = room->GetGasData().gas_start_frameno;
             FillMFGasData(msg->mutable_gas_data());
         }
         bool refreshed_view = false;
@@ -2520,7 +2521,7 @@ void Human::ProcLootSkin(Loot* entity, MetaData::Equip* item_meta)
 
 void Human::ProcLootCar(Loot* entity, MetaData::Equip* item_meta)
 {
-    if (room->gas_data.gas_mode == GasInactive) {
+    if (room->GetGasData().gas_mode == GasInactive) {
         return;
     }
     if (GetPos().Distance(entity->GetPos()) > MetaMgr::Instance()->max_mount_horse_distance) {
diff --git a/server/gameserver/player.cc b/server/gameserver/player.cc
index 61ef193..34ad0ed 100644
--- a/server/gameserver/player.cc
+++ b/server/gameserver/player.cc
@@ -119,7 +119,7 @@ void Player::UpdateMove()
         CancelAction();
     }
     if (dead ||
-        room->waiting_start) {
+        room->IsWaitingStart()) {
         moving = false;
         moved_frames = 0;
         last_collision_door = nullptr;
@@ -156,7 +156,7 @@ void Player::UpdateShot()
 {
     if (dead ||
         downed ||
-        room->waiting_start) {
+        room->IsWaitingStart()) {
         shot_start = false;
         shot_hold = false;
         series_shot_frames = 0;
@@ -293,8 +293,8 @@ void Player::UpdateUseItemId()
 
 void Player::UpdateSpectate()
 {
-    if (room->gas_data.gas_mode == GasInactive ||
-        room->gas_data.gas_mode == GasJump) {
+    if (room->GetGasData().gas_mode == GasInactive ||
+        room->GetGasData().gas_mode == GasJump) {
         spectate = false;
         return;
     }
diff --git a/server/gameserver/room.cc b/server/gameserver/room.cc
index c869508..cc4e3ca 100644
--- a/server/gameserver/room.cc
+++ b/server/gameserver/room.cc
@@ -90,7 +90,7 @@ void Room::Update(int delta_time)
     run_in_timer_ = true;
 #endif
     xtimer.Update();
-    if (game_over && GetFrameNo() - game_over_frameno > SERVER_FRAME_RATE * 20) {
+    if (IsGameOver() && GetFrameNo() - game_over_frameno_ > SERVER_FRAME_RATE * 20) {
         return;
     }
 
@@ -144,7 +144,7 @@ int Room::AliveCount()
 
 void Room::AddPlayer(Player* hum)
 {
-    assert(gas_data.gas_mode == GasInactive);
+    assert(gas_data_.gas_mode == GasInactive);
     hum->born_point = AllocBornPoint(hum);
     if (!hum->born_point) {
         hum->SetPos(a8::Vec2(DEFAULT_BORN_POINT_X + rand() % 100,
@@ -257,7 +257,7 @@ int Room::AllocUniid()
 
 void Room::ShuaAndroid()
 {
-    if (gas_data.gas_mode != GasInactive) {
+    if (gas_data_.gas_mode != GasInactive) {
         return;
     }
     int robot_min_num = MetaMgr::Instance()->GetSysParamAsInt("refresh_robot_min_num", 5);
@@ -658,7 +658,7 @@ int Room::GetAliveTeamNum()
 
 bool Room::CanJoin(const std::string& accountid, RoomType_e self_room_type)
 {
-    if (gas_data.gas_mode != GasInactive) {
+    if (gas_data_.gas_mode != GasInactive) {
         return false;
     }
     if (GetPlayerByAccountId(accountid)) {
@@ -863,7 +863,7 @@ void Room::TouchEntityList(a8::XParams param,
 
 void Room::UpdateGas()
 {
-    switch (gas_data.gas_mode) {
+    switch (gas_data_.gas_mode) {
     case GasInactive:
         UpdateGasInactive();
         break;
@@ -877,10 +877,10 @@ void Room::UpdateGas()
         UpdateGasMoving();
         break;
     }
-    if (gas_data.gas_mode != GasInactive && gas_data.gas_mode != GasJump) {
-        if (!game_over && alive_count_ <= MAX_TEAM_NUM && GetAliveTeamNum() <= 1) {
-            game_over = true;
-            game_over_frameno = GetFrameNo();
+    if (gas_data_.gas_mode != GasInactive && gas_data_.gas_mode != GasJump) {
+        if (!IsGameOver() && alive_count_ <= MAX_TEAM_NUM && GetAliveTeamNum() <= 1) {
+            game_over_ = true;
+            game_over_frameno_ = GetFrameNo();
             OnGameOver();
         }
         for (auto& pair : human_hash_) {
@@ -888,13 +888,13 @@ void Room::UpdateGas()
                 a8::HasBitFlag(pair.second->status, HS_Disable)) {
                 continue;
             }
-            bool b1 = a8::CircleContainCircle(gas_data.pos_old,
-                                              gas_data.gas_progress,
+            bool b1 = a8::CircleContainCircle(gas_data_.pos_old,
+                                              gas_data_.gas_progress,
                                               pair.second->GetPos(),
                                               pair.second->GetRadius()
                                               );
-            bool b2 = a8::CircleContainCircle(gas_data.pos_new,
-                                              gas_data.rad_new,
+            bool b2 = a8::CircleContainCircle(gas_data_.pos_new,
+                                              gas_data_.rad_new,
                                               pair.second->GetPos(),
                                               pair.second->GetRadius()
                                               );
@@ -910,24 +910,24 @@ void Room::UpdateGas()
 
 void Room::UpdateGasInactive()
 {
-    if (GetFrameNo() - gas_data.gas_start_frameno >= GetGasInactiveTime() * SERVER_FRAME_RATE) {
-        gas_data.gas_mode = GasWaiting;
-        gas_data.old_area_meta = MetaMgr::Instance()->GetSafeArea(30001);
-        gas_data.new_area_meta = MetaMgr::Instance()->GetSafeArea(30002);
-        gas_data.gas_progress = gas_data.old_area_meta->i->rad();
-        gas_data.gas_start_frameno = GetFrameNo();
-        gas_data.pos_old = a8::Vec2(map_meta->i->map_width() / 2.0f,
+    if (GetFrameNo() - gas_data_.gas_start_frameno >= GetGasInactiveTime() * SERVER_FRAME_RATE) {
+        gas_data_.gas_mode = GasWaiting;
+        gas_data_.old_area_meta = MetaMgr::Instance()->GetSafeArea(30001);
+        gas_data_.new_area_meta = MetaMgr::Instance()->GetSafeArea(30002);
+        gas_data_.gas_progress = gas_data_.old_area_meta->i->rad();
+        gas_data_.gas_start_frameno = GetFrameNo();
+        gas_data_.pos_old = a8::Vec2(map_meta->i->map_width() / 2.0f,
                                     map_meta->i->map_height() / 2.0f);
-        gas_data.pos_old_bk = gas_data.pos_old;
+        gas_data_.pos_old_bk = gas_data_.pos_old;
         {
-            bool gen_ok = GenSmallCircle(gas_data.pos_old,
-                                         gas_data.old_area_meta->i->rad(),
-                                         gas_data.new_area_meta->i->rad(),
-                                         gas_data.pos_new);
+            bool gen_ok = GenSmallCircle(gas_data_.pos_old,
+                                         gas_data_.old_area_meta->i->rad(),
+                                         gas_data_.new_area_meta->i->rad(),
+                                         gas_data_.pos_new);
             assert(gen_ok);
         }
-        gas_data.rad_old = gas_data.old_area_meta->i->rad();
-        gas_data.rad_new = gas_data.new_area_meta->i->rad();
+        gas_data_.rad_old = gas_data_.old_area_meta->i->rad();
+        gas_data_.rad_new = gas_data_.new_area_meta->i->rad();
         battle_start_frameno_ = GetFrameNo();
         if (human_hash_.size() < ROOM_MAX_PLAYER_NUM) {
             CreateAndroid(ROOM_MAX_PLAYER_NUM - human_hash_.size());
@@ -945,56 +945,56 @@ void Room::UpdateGasInactive()
 
 void Room::UpdateGasWaiting()
 {
-    if (GetFrameNo() - gas_data.gas_start_frameno >=
-        gas_data.old_area_meta->i->wait_time() * SERVER_FRAME_RATE) {
-        gas_data.gas_mode = GasMoving;
-        gas_data.gas_start_frameno = GetFrameNo();;
+    if (GetFrameNo() - gas_data_.gas_start_frameno >=
+        gas_data_.old_area_meta->i->wait_time() * SERVER_FRAME_RATE) {
+        gas_data_.gas_mode = GasMoving;
+        gas_data_.gas_start_frameno = GetFrameNo();;
     }
 }
 
 void Room::UpdateGasMoving()
 {
-    if (GetFrameNo() - gas_data.gas_start_frameno > 0 && !gas_data.is_last_gas) {
-        float distance = gas_data.old_area_meta->i->shrink_speed() *
-            ((GetFrameNo() - gas_data.gas_start_frameno) * (1.0 / SERVER_FRAME_RATE));
-        gas_data.gas_progress = std::max(gas_data.rad_old - distance, gas_data.rad_new);
-        if (!(gas_data.pos_new == gas_data.pos_old)) {
-            a8::Vec2 p1 = gas_data.pos_new - gas_data.pos_old_bk;
-            gas_data.pre_pos_old = gas_data.pos_old;
+    if (GetFrameNo() - gas_data_.gas_start_frameno > 0 && !gas_data_.is_last_gas) {
+        float distance = gas_data_.old_area_meta->i->shrink_speed() *
+            ((GetFrameNo() - gas_data_.gas_start_frameno) * (1.0 / SERVER_FRAME_RATE));
+        gas_data_.gas_progress = std::max(gas_data_.rad_old - distance, gas_data_.rad_new);
+        if (!(gas_data_.pos_new == gas_data_.pos_old)) {
+            a8::Vec2 p1 = gas_data_.pos_new - gas_data_.pos_old_bk;
+            gas_data_.pre_pos_old = gas_data_.pos_old;
             if (p1.Norm() - distance <= 0.01f) {
-                gas_data.pos_old = gas_data.pos_new;
+                gas_data_.pos_old = gas_data_.pos_new;
             } else {
                 a8::Vec2 dir = p1;
                 dir.Normalize();
-                gas_data.pos_old = gas_data.pos_old_bk + dir * distance;
+                gas_data_.pos_old = gas_data_.pos_old_bk + dir * distance;
             }
-            if (gas_data.rad_old - distance <= gas_data.rad_new) {
-                assert(gas_data.pos_new == gas_data.pos_old);
+            if (gas_data_.rad_old - distance <= gas_data_.rad_new) {
+                assert(gas_data_.pos_new == gas_data_.pos_old);
             }
         }
-        if (std::abs(gas_data.gas_progress - gas_data.rad_new) <= 0.001f) {
-            int pre_area_id = gas_data.new_area_meta->i->id();
-            a8::Vec2 pre_pos = gas_data.pos_new;
+        if (std::abs(gas_data_.gas_progress - gas_data_.rad_new) <= 0.001f) {
+            int pre_area_id = gas_data_.new_area_meta->i->id();
+            a8::Vec2 pre_pos = gas_data_.pos_new;
             if (!MetaMgr::Instance()->GetSafeArea(pre_area_id + 1)) {
-                gas_data.is_last_gas = true;
+                gas_data_.is_last_gas = true;
                 return;
             }
-            gas_data.gas_mode = GasWaiting;
-            gas_data.old_area_meta = MetaMgr::Instance()->GetSafeArea(pre_area_id);
-            gas_data.new_area_meta = MetaMgr::Instance()->GetSafeArea(pre_area_id + 1);
-            gas_data.gas_progress = gas_data.old_area_meta->i->rad();
-            gas_data.gas_start_frameno = GetFrameNo();
-            gas_data.pos_old = pre_pos;
-            gas_data.pos_old_bk = gas_data.pos_old;
+            gas_data_.gas_mode = GasWaiting;
+            gas_data_.old_area_meta = MetaMgr::Instance()->GetSafeArea(pre_area_id);
+            gas_data_.new_area_meta = MetaMgr::Instance()->GetSafeArea(pre_area_id + 1);
+            gas_data_.gas_progress = gas_data_.old_area_meta->i->rad();
+            gas_data_.gas_start_frameno = GetFrameNo();
+            gas_data_.pos_old = pre_pos;
+            gas_data_.pos_old_bk = gas_data_.pos_old;
             {
-                bool gen_ok = GenSmallCircle(gas_data.pos_old,
-                                             gas_data.old_area_meta->i->rad(),
-                                             gas_data.new_area_meta->i->rad(),
-                                             gas_data.pos_new);
+                bool gen_ok = GenSmallCircle(gas_data_.pos_old,
+                                             gas_data_.old_area_meta->i->rad(),
+                                             gas_data_.new_area_meta->i->rad(),
+                                             gas_data_.pos_new);
                 assert(gen_ok);
             }
-            gas_data.rad_old = gas_data.old_area_meta->i->rad();
-            gas_data.rad_new = gas_data.new_area_meta->i->rad();
+            gas_data_.rad_old = gas_data_.old_area_meta->i->rad();
+            gas_data_.rad_new = gas_data_.new_area_meta->i->rad();
         }
     }
 }
@@ -1223,7 +1223,7 @@ void Room::InitAirDrop()
                                          [] (const a8::XParams& param)
                                          {
                                              Room* room = (Room*)param.sender.GetUserData();
-                                             if (!room->game_over) {
+                                             if (!room->IsGameOver()) {
                                                  room->AirDrop(param.param1, param.param2);
                                              }
                                          },
@@ -1237,7 +1237,7 @@ void Room::AirDrop(int appear_time, int box_id)
     if (thing_meta && thing_meta->i->type() == 2) {
         a8::Vec2 dir = a8::Vec2::UP;
         dir.Rotate(a8::RandAngle());
-        a8::Vec2 box_pos = gas_data.pos_new + dir * (500 + rand() % 300);
+        a8::Vec2 box_pos = gas_data_.pos_new + dir * (500 + rand() % 300);
         if (box_pos.x < 1.0f) {
             box_pos.x = 1.0f;
         }
@@ -1284,7 +1284,7 @@ void Room::AirDrop(int appear_time, int box_id)
                                       [] (const a8::XParams& param)
                                       {
                                           Room* room = (Room*)param.sender.GetUserData();
-                                          if (!room->game_over) {
+                                          if (!room->IsGameOver()) {
                                               RoomObstacle* obstacle = room->
                                                   CreateObstacle(param.param1.GetInt(),
                                                                  param.param2.GetDouble(),
@@ -1358,7 +1358,7 @@ void Room::AddObjectLater(RoomEntity* entity)
 void Room::OnGameOver()
 {
     for (auto& pair : human_hash_) {
-        if (game_over && game_over_frameno == GetFrameNo()) {
+        if (IsGameOver() && game_over_frameno_ == GetFrameNo()) {
             pair.second->SendGameOver();
         }
     }
@@ -1733,14 +1733,14 @@ void Room::NotifyGameStart()
                                          room->SecondRandPoint();
                                      },
                                      &xtimer_attacher_.timer_list_);
-    waiting_start = true;
+    waiting_start_ = true;
     xtimer.AddDeadLineTimerAndAttach(SERVER_FRAME_RATE * 2,
                                      a8::XParams()
                                      .SetSender(this),
                                      [] (const a8::XParams& param)
                                      {
                                          Room* room = (Room*)param.sender.GetUserData();
-                                         room->waiting_start = false;
+                                         room->waiting_start_ = false;
                                      },
                                      &xtimer_attacher_.timer_list_);
     if (room_type == RT_NewBrid) {
@@ -2177,7 +2177,7 @@ void Room::ProcDieAndroid(int die_time, int die_num)
                 alive_humans_copy.erase(alive_humans_copy.begin() + i);
                 break;
             }
-            if (killer && ((rand() % 100 < 70) || !gas_data.old_area_meta)) {
+            if (killer && ((rand() % 100 < 70) || !gas_data_.old_area_meta)) {
                 hum->BeKill(killer->entity_uniid,
                             killer->name,
                             killer->curr_weapon->weapon_id);
diff --git a/server/gameserver/room.h b/server/gameserver/room.h
index d7b60b3..ccb9b26 100644
--- a/server/gameserver/room.h
+++ b/server/gameserver/room.h
@@ -10,7 +10,6 @@
 namespace MetaData
 {
     struct Map;
-    struct SafeArea;
     struct Building;
     struct AirLine;
     struct MapTplThing;
@@ -39,26 +38,20 @@ class Room
 public:
     int room_idx = 0;
     long long room_uuid = 0;
-    MetaData::Map* map_meta = nullptr;
+    const MetaData::Map* map_meta = nullptr;
     std::string map_tpl_name;
     FrameEvent frame_event;
     FrameMaker frame_maker;
-    GasData gas_data;
-    bool game_over = false;
-    long long game_over_frameno = 0;
     a8::XTimer xtimer;
+    a8::XTimerAttacher timer_attacher;
     GridService* grid_service = nullptr;
     MapService* map_service = nullptr;
-    long long battle_start_frameno_ = 0;
-    long long last_debugout_tick = 0;
-    bool waiting_start = false;
     RoomType_e room_type = RT_NewBrid;
-    std::vector<MetaData::MapTplThing*>* spawn_points = nullptr;
-    MetaData::MapTplThing* newbie_born_point_meta = nullptr;
-    std::vector<MetaData::MapTplThing*>* loots = nullptr;
-    std::vector<Building*>* buildings = nullptr;
+    const std::vector<MetaData::MapTplThing*>* spawn_points = nullptr;
+    const MetaData::MapTplThing* newbie_born_point_meta = nullptr;
+    const std::vector<MetaData::MapTplThing*>* loots = nullptr;
+    const std::vector<Building*>* buildings = nullptr;
     Human* first_newbie = nullptr;
-    a8::XTimerAttacher timer_attacher;
 
     ~Room();
     void Init();
@@ -68,6 +61,10 @@ public:
     int GetPlayerNum();
     int AliveCount();
     inline int RealAliveCount() { return alive_human_hash_.size(); }
+    long long GetBattleStartFrameNo() { return battle_start_frameno_; }
+    bool IsGameOver() { return game_over_; }
+    const GasData& GetGasData() { return gas_data_; }
+    bool IsWaitingStart() { return waiting_start_; }
     Player* GetPlayerByAccountId(const std::string& accountid);
     Player* GetPlayerByUniId(int uniid);
     Entity* GetEntityByUniId(int uniid);
@@ -165,7 +162,12 @@ private:
     void CheckAliveHuman(Human* hum, std::vector<Human*>& alive_humans);
 
 private:
+    bool waiting_start_ = false;
+    GasData gas_data_;
     long long frameno_ = 0;
+    long long battle_start_frameno_ = 0;
+    bool game_over_ = false;
+    long long game_over_frameno_ = 0;
     int elapsed_time_ = 0;
     int alive_count_ = 0;
     int force_shua_android_times_ = 0;