split GameMode into enum class

src/ChatCommands.cc

@@ -521,7 +521,8 @@ static void server_command_playrec(shared_ptr<ServerState> s, shared_ptr<Lobby>
     shared_ptr<Episode3::BattleRecord> record(new Episode3::BattleRecord(data));
     shared_ptr<Episode3::BattleRecordPlayer> battle_player(
         new Episode3::BattleRecordPlayer(record, s->game_server->get_base()));
-    create_game_generic(s, c, args.c_str(), u"", Episode::EP3, 0, flags, nullptr, battle_player);
+    create_game_generic(s, c, args.c_str(), u"", Episode::EP3, GameMode::NORMAL,
+        0, flags, nullptr, battle_player);
   }
 }
 

src/Lobby.cc

@@ -21,6 +21,7 @@ Lobby::Lobby(uint32_t id)
     version(GameVersion::GC),
     section_id(0),
     episode(Episode::NONE),
+    mode(GameMode::NORMAL),
     difficulty(0),
     random_seed(random_object<uint32_t>()),
     random(new mt19937(this->random_seed)),

src/Lobby.hh

@@ -37,10 +37,7 @@ struct Lobby : public std::enable_shared_from_this<Lobby> {
     ITEM_TRACKING_ENABLED           = 0x00001000,
     IS_SPECTATOR_TEAM               = 0x00002000, // episode must be EP3 also
     SPECTATORS_FORBIDDEN            = 0x00004000,
-    BATTLE_MODE                     = 0x00008000,
+    START_BATTLE_PLAYER_IMMEDIATELY = 0x00008000,
-    CHALLENGE_MODE                  = 0x00010000,
-    SOLO_MODE                       = 0x00020000,
-    START_BATTLE_PLAYER_IMMEDIATELY = 0x00040000,
 
     // Flags used only for lobbies
     PUBLIC                          = 0x01000000,
@@ -71,6 +68,7 @@ struct Lobby : public std::enable_shared_from_this<Lobby> {
   GameVersion version;
   uint8_t section_id;
   Episode episode;
+  GameMode mode;
   uint8_t difficulty; // 0-3
   std::u16string password;
   std::u16string name;

src/ReceiveCommands.cc

@@ -1082,7 +1082,8 @@ static bool start_ep3_battle_table_game_if_ready(
   uint32_t flags = Lobby::Flag::NON_V1_ONLY;
   u16string name = tourn ? decode_sjis(tourn->get_name()) : u"<BattleTable>";
   auto game = create_game_generic(
-      s, game_clients.begin()->second, name, u"", Episode::EP3, 0, flags);
+      s, game_clients.begin()->second, name, u"", Episode::EP3,
+      GameMode::NORMAL, 0, flags);
   if (!game) {
     return false;
   }
@@ -1537,18 +1538,10 @@ static void on_09(shared_ptr<ServerState> s, shared_ptr<Client> c,
         }
 
         string secid_str = name_for_section_id(game->section_id);
-        const char* mode_abbrev = "Nml";
-        if (game->flags & Lobby::Flag::BATTLE_MODE) {
-          mode_abbrev = "Btl";
-        } else if (game->flags & Lobby::Flag::CHALLENGE_MODE) {
-          mode_abbrev = "Chl";
-        } else if (game->flags & Lobby::Flag::SOLO_MODE) {
-          mode_abbrev = "Solo";
-        }
         info += string_printf("%s %c %s %s\n",
             abbreviation_for_episode(game->episode),
             abbreviation_for_difficulty(game->difficulty),
-            mode_abbrev,
+            abbreviation_for_mode(game->mode),
             secid_str.c_str());
 
         bool cheats_enabled = game->flags & Lobby::Flag::CHEATS_ENABLED;
@@ -1914,7 +1907,7 @@ static void on_10(shared_ptr<ServerState> s, shared_ptr<Client> c,
         send_lobby_message_box(c, u"$C6You cannot join this\ngame because\nanother player is\ncurrently loading.\nTry again soon.");
         break;
       }
-      if (game->flags & Lobby::Flag::SOLO_MODE) {
+      if (game->mode == GameMode::SOLO) {
         send_lobby_message_box(c, u"$C6You cannot join this\n game because it is\na Solo Mode game.");
         break;
       }
@@ -2321,14 +2314,21 @@ static void on_A2(shared_ptr<ServerState> s, shared_ptr<Client> c,
     if ((c->version() == GameVersion::BB) && flag) {
       menu = &quest_government_menu;
     } else {
-      if (l->flags & Lobby::Flag::BATTLE_MODE) {
+      switch (l->mode) {
-        menu = &quest_battle_menu;
+        case GameMode::NORMAL:
-      } else if (l->flags & Lobby::Flag::CHALLENGE_MODE) {
+          menu = &quest_categories_menu;
-        menu = &quest_challenge_menu;
+          break;
-      } else if (l->flags & Lobby::Flag::SOLO_MODE) {
+        case GameMode::BATTLE:
-        menu = &quest_solo_menu;
+          menu = &quest_battle_menu;
-      } else {
+          break;
-        menu = &quest_categories_menu;
+        case GameMode::CHALLENGE:
+          menu = &quest_challenge_menu;
+          break;
+        case GameMode::SOLO:
+          menu = &quest_solo_menu;
+          break;
+        default:
+          throw logic_error("invalid game mode");
       }
     }
 
@@ -3105,6 +3105,7 @@ shared_ptr<Lobby> create_game_generic(
     const std::u16string& name,
     const std::u16string& password,
     Episode episode,
+    GameMode mode,
     uint8_t difficulty,
     uint32_t flags,
     shared_ptr<Lobby> watched_lobby,
@@ -3165,9 +3166,8 @@ shared_ptr<Lobby> create_game_generic(
   // is not notified when this happens. We'll have to implement this anyway for
   // BB, but for now we ignore it.
   bool item_tracking_enabled =
-      (c->version() == GameVersion::BB) |
+      (c->version() == GameVersion::BB) ||
-      (s->item_tracking_enabled &&
+      (s->item_tracking_enabled && (mode == GameMode::NORMAL || mode == GameMode::SOLO));
-        !(flags & (Lobby::Flag::BATTLE_MODE | Lobby::Flag::CHALLENGE_MODE)));
 
   shared_ptr<Lobby> game = s->create_lobby();
   game->name = name;
@@ -3179,6 +3179,7 @@ shared_ptr<Lobby> create_game_generic(
   game->section_id = c->options.override_section_id >= 0
       ? c->options.override_section_id : c->game_data.player()->disp.section_id;
   game->episode = episode;
+  game->mode = mode;
   game->difficulty = difficulty;
   if (c->options.override_random_seed >= 0) {
     game->random_seed = c->options.override_random_seed;
@@ -3200,7 +3201,7 @@ shared_ptr<Lobby> create_game_generic(
     watched_lobby->watcher_lobbies.emplace(game);
   }
 
-  bool is_solo = (game->flags & Lobby::Flag::SOLO_MODE);
+  bool is_solo = (game->mode == GameMode::SOLO);
 
   // Generate the map variations
   if (game->is_ep3()) {
@@ -3271,14 +3272,14 @@ static void on_C1_PC(shared_ptr<ServerState> s, shared_ptr<Client> c,
   const auto& cmd = check_size_t<C_CreateGame_PC_C1>(data);
 
   uint32_t flags = Lobby::Flag::NON_V1_ONLY;
+  GameMode mode = GameMode::NORMAL;
   if (cmd.battle_mode) {
-    flags |= Lobby::Flag::BATTLE_MODE;
+    mode = GameMode::BATTLE;
-  }
+  } else if (cmd.challenge_mode) {
-  if (cmd.challenge_mode) {
+    mode = GameMode::CHALLENGE;
-    flags |= Lobby::Flag::CHALLENGE_MODE;
   }
   auto game = create_game_generic(
-      s, c, cmd.name, cmd.password, Episode::EP1, cmd.difficulty, flags);
+      s, c, cmd.name, cmd.password, Episode::EP1, mode, cmd.difficulty, flags);
   if (game) {
     s->change_client_lobby(c, game);
     c->flags |= Client::Flag::LOADING;
@@ -3313,14 +3314,15 @@ static void on_0C_C1_E7_EC(shared_ptr<ServerState> s, shared_ptr<Client> c,
   u16string name = decode_sjis(cmd.name);
   u16string password = decode_sjis(cmd.password);
 
+  GameMode mode = GameMode::NORMAL;
   if (cmd.battle_mode) {
-    flags |= Lobby::Flag::BATTLE_MODE;
+    mode = GameMode::BATTLE;
   }
   if (cmd.challenge_mode) {
     if (client_is_ep3) {
       flags |= Lobby::Flag::SPECTATORS_FORBIDDEN;
     } else {
-      flags |= Lobby::Flag::CHALLENGE_MODE;
+      mode = GameMode::CHALLENGE;
     }
   }
 
@@ -3338,7 +3340,8 @@ static void on_0C_C1_E7_EC(shared_ptr<ServerState> s, shared_ptr<Client> c,
   }
 
   auto game = create_game_generic(
-      s, c, name.c_str(), password.c_str(), episode, cmd.difficulty, flags, watched_lobby);
+      s, c, name.c_str(), password.c_str(), episode, mode, cmd.difficulty,
+      flags, watched_lobby);
   if (game) {
     s->change_client_lobby(c, game);
     c->flags |= Client::Flag::LOADING;
@@ -3350,14 +3353,15 @@ static void on_C1_BB(shared_ptr<ServerState> s, shared_ptr<Client> c,
   const auto& cmd = check_size_t<C_CreateGame_BB_C1>(data);
 
   uint32_t flags = Lobby::Flag::NON_V1_ONLY;
+  GameMode mode = GameMode::NORMAL;
   if (cmd.battle_mode) {
-    flags |= Lobby::Flag::BATTLE_MODE;
+    mode = GameMode::BATTLE;
   }
   if (cmd.challenge_mode) {
-    flags |= Lobby::Flag::CHALLENGE_MODE;
+    mode = GameMode::CHALLENGE;
   }
   if (cmd.solo_mode) {
-    flags |= Lobby::Flag::SOLO_MODE;
+    mode = GameMode::SOLO;
   }
 
   Episode episode;
@@ -3376,7 +3380,7 @@ static void on_C1_BB(shared_ptr<ServerState> s, shared_ptr<Client> c,
   }
 
   auto game = create_game_generic(
-      s, c, cmd.name, cmd.password, episode, cmd.difficulty, flags);
+      s, c, cmd.name, cmd.password, episode, mode, cmd.difficulty, flags);
   if (game) {
     s->change_client_lobby(c, game);
     c->flags |= Client::Flag::LOADING;

src/ReceiveCommands.hh

@@ -12,6 +12,7 @@ std::shared_ptr<Lobby> create_game_generic(
     const std::u16string& name,
     const std::u16string& password,
     Episode episode,
+    GameMode mode,
     uint8_t difficulty,
     uint32_t flags,
     std::shared_ptr<Lobby> watched_lobby = nullptr,

src/SendCommands.cc

@@ -1175,14 +1175,20 @@ void send_game_menu_t(
       e.flags = (l->password.empty() ? 0 : 2) | ((l->flags & Lobby::Flag::BATTLE_IN_PROGRESS) ? 4 : 0);
     } else {
       e.flags = ((episode_num << 6) | (l->password.empty() ? 0 : 2));
-      if (l->flags & Lobby::Flag::BATTLE_MODE) {
+      switch (l->mode) {
-        e.flags |= 0x10;
+        case GameMode::NORMAL:
-      }
+          break;
-      if (l->flags & Lobby::Flag::CHALLENGE_MODE) {
+        case GameMode::BATTLE:
-        e.flags |= 0x20;
+          e.flags |= 0x10;
-      }
+          break;
-      if (l->flags & Lobby::Flag::SOLO_MODE) {
+        case GameMode::CHALLENGE:
-        e.flags |= 0x34;
+          e.flags |= 0x20;
+          break;
+        case GameMode::SOLO:
+          e.flags |= 0x34;
+          break;
+        default:
+          throw logic_error("invalid game mode");
       }
     }
     e.name = l->name;
@@ -1461,10 +1467,10 @@ void send_join_game_t(shared_ptr<Client> c, shared_ptr<Lobby> l) {
   cmd->leader_id = l->leader_id;
   cmd->disable_udp = 0x01; // Unused on PC/XB/BB
   cmd->difficulty = l->difficulty;
-  cmd->battle_mode = (l->flags & Lobby::Flag::BATTLE_MODE) ? 1 : 0;
+  cmd->battle_mode = (l->mode == GameMode::BATTLE) ? 1 : 0;
   cmd->event = l->event;
   cmd->section_id = l->section_id;
-  cmd->challenge_mode = (l->flags & Lobby::Flag::CHALLENGE_MODE) ? 1 : 0;
+  cmd->challenge_mode = (l->mode == GameMode::CHALLENGE) ? 1 : 0;
   cmd->rare_seed = l->random_seed;
   switch (l->episode) {
     case Episode::EP1:
@@ -1483,7 +1489,7 @@ void send_join_game_t(shared_ptr<Client> c, shared_ptr<Lobby> l) {
       throw logic_error("invalid episode number in game");
   }
   cmd->unused2 = 0x01;
-  cmd->solo_mode = (l->flags & Lobby::Flag::SOLO_MODE) ? 1 : 0;
+  cmd->solo_mode = (l->mode == GameMode::SOLO) ? 1 : 0;
   cmd->unused3 = 0x00;
 
   send_command(c, 0x64, player_count, data);

src/StaticGameData.cc

@@ -60,6 +60,38 @@ const char* abbreviation_for_episode(Episode ep) {
 
 
 
+const char* name_for_mode(GameMode mode) {
+  switch (mode) {
+    case GameMode::NORMAL:
+      return "Normal";
+    case GameMode::BATTLE:
+      return "Battle";
+    case GameMode::CHALLENGE:
+      return "Challenge";
+    case GameMode::SOLO:
+      return "Solo";
+    default:
+      return "Unknown mode";
+  }
+}
+
+const char* abbreviation_for_mode(GameMode mode) {
+  switch (mode) {
+    case GameMode::NORMAL:
+      return "Nml";
+    case GameMode::BATTLE:
+      return "Btl";
+    case GameMode::CHALLENGE:
+      return "Chl";
+    case GameMode::SOLO:
+      return "Solo";
+    default:
+      return "UnkMd";
+  }
+}
+
+
+
 const vector<string> section_id_to_name({
   "Viridia", "Greennill", "Skyly", "Bluefull", "Purplenum", "Pinkal", "Redria",
   "Oran", "Yellowboze", "Whitill"});

src/StaticGameData.hh

@@ -22,6 +22,16 @@ bool episode_has_arpg_semantics(Episode ep);
 const char* name_for_episode(Episode ep);
 const char* abbreviation_for_episode(Episode ep);
 
+enum class GameMode {
+  NORMAL = 0,
+  BATTLE = 1,
+  CHALLENGE = 2,
+  SOLO = 3,
+};
+
+const char* name_for_mode(GameMode mode);
+const char* abbreviation_for_mode(GameMode mode);
+
 
 
 size_t stack_size_for_item(uint8_t data0, uint8_t data1);