Merge pull request #92 from G-Epitech/rtp-110-update-room-selection

RTP-110 - Update room selection

Author: TekMath

client/src/builder/services.cpp

@@ -14,6 +14,6 @@ using namespace rtype::client::builder;
 using namespace rtype::client::services;
 
 void Services::RegisterServices(mew::game::GameBuilder *builder) {
-  builder->WithService<ServerConnectionService>("127.0.0.1", 4848);
+  builder->WithService<ServerConnectionService>("rtype.thismath.com", 4848);
   builder->WithService<RoomsService>();
 }

client/src/scenes/game.cpp

@@ -83,6 +83,10 @@ void SceneGame::OnCreate() {
   InitFade();
 }
 
+void SceneGame::OnActivate() {
+  ResetFade();
+}
+
 void SceneGame::Update(DeltaTime delta_time) {
   deltaTime_ = delta_time;
   registry_->RunSystems();
@@ -155,3 +159,26 @@ void SceneGame::InitFade() {
 
   registry_->AddComponent<Tags>(rectangle, Tags({"end_fade"}));
 }
+
+void SceneGame::ResetFade() {
+  auto drawables = registry_->GetComponents<Drawable>();
+  auto tags = registry_->GetComponents<Tags>();
+  std::size_t fade_id = 0;
+  std::size_t i = 0;
+
+  for (auto &tag : *tags) {
+    if (!tag) {
+      i += 1;
+      continue;
+    } else if ((*tag) & "end_fade") {
+      fade_id = i;
+    }
+    i += 1;
+  }
+  auto &fade = (*drawables)[fade_id];
+  if (!fade) {
+    return;
+  }
+  auto &rectangle = std::get<drawable::Rectangle>((*fade).drawable);
+  rectangle.fillColor.a = 0;
+}

client/src/scenes/game.hpp

@@ -30,6 +30,8 @@ class SceneGame final : public SceneBase {
 
   void Update(DeltaTime delta_time) override;
 
+  void OnActivate() override;
+
  protected:
   void OnCreate() override;
 
@@ -60,6 +62,11 @@ class SceneGame final : public SceneBase {
    */
   void InitFade();
 
+  /**
+   * @brief Reset fade
+   */
+  void ResetFade();
+
   /// @brief Server connection service
   services::ServerConnectionService::Ptr serverConnectionService_;
 

client/src/scenes/lobby.cpp

@@ -8,6 +8,7 @@
 #include "lobby.hpp"
 
 #include "./game.hpp"
+#include "libs/game/src/api/client/client.hpp"
 #include "libs/mew/src/sets/drawable/drawable.hpp"
 
 using namespace rtype::client::scenes;
@@ -18,6 +19,7 @@ using namespace porygon;
 using namespace mew::sets::drawable;
 using namespace mew::scenes;
 using namespace mew::managers;
+using namespace rtype::sdk::game::api;
 
 SceneLobby::SceneLobby(DependenciesHandler::Ptr services) : SceneBase(std::move(services)) {
   serverConnectionService_ = services_->GetOrThrow<ServerConnectionService>();
@@ -36,10 +38,7 @@ void SceneLobby::OnCreate() {
 }
 
 void SceneLobby::OnActivate() {
-  if (status_ == LobbyStatus::kIn) {
-    return managers_.scenes->GoToScene<SceneGame>();
-  }
-  JoinLobbyAsync();
+  WaitAsync();
 }
 
 void SceneLobby::Update(std::chrono::nanoseconds delta_time) {
@@ -48,10 +47,6 @@ void SceneLobby::Update(std::chrono::nanoseconds delta_time) {
   if (status_ == LobbyStatus::kIn) {
     managers_.scenes->GoToScene<SceneGame>();
   }
-
-  if (status_ == LobbyStatus::kWaitingPlayers) {
-    WaitGameStart();
-  }
 }
 
 void SceneLobby::CreateStatusText() {
@@ -83,46 +78,29 @@ void SceneLobby::CreateGEpitechLogo() {
       {Texture{.name = "g-epitech-logo", .scale = 0.35, .rect = rect}, WindowManager::View::HUD});
 }
 
-void SceneLobby::JoinLobbyAsync() {
+void SceneLobby::WaitAsync() {
   if (joiningThread_)
     return;
-  joiningThread_ = std::thread(&SceneLobby::JoinLobby, this);
+  joiningThread_ = std::thread(&SceneLobby::Wait, this);
 }
 
-void SceneLobby::JoinLobby() {
-  if (status_ == LobbyStatus::kJoining) {
-    return;
-  }
-  mainMessage_ = "Creating the room";
-  secondaryMessage_ = "Please wait...";
-  auto res = serverConnectionService_->client()->CreateRoom({
-      .name = "MyPtitRoom",
-      .nbPlayers = 2,
-      .difficulty = 0,
-  });
-  if (!res) {
-    mainMessage_ = "Creating failed";
-    secondaryMessage_ = "Unable to create the lobby";
-    status_ = LobbyStatus::kFailed;
-    return;
-  }
-  std::this_thread::sleep_for(std::chrono::milliseconds(1200));
-  status_ = LobbyStatus::kRegistered;
-  mainMessage_ = "Joining the room";
-  secondaryMessage_ = "Please wait...";
-  res = serverConnectionService_->client()->JoinRoom({
-      .nodeId = 0,
-      .roomId = 0,
-  });
-  if (!res) {
-    mainMessage_ = "Joining failed";
-    secondaryMessage_ = "Unable to join the lobby";
-    status_ = LobbyStatus::kFailed;
-    return;
+void SceneLobby::Wait() {
+  mainMessage_ = "Starting...";
+  secondaryMessage_ = "You are now in the lobby. Waiting for other players";
+  status_ = LobbyStatus::kWaiting;
+
+  while (status_ == LobbyStatus::kWaiting) {
+    auto queue = serverConnectionService_->client()->ExtractQueue();
+
+    while (!queue.empty()) {
+      auto message = queue.front();
+      if (message.messageType == kMsgTypeMTCGameStarted) {
+        status_ = LobbyStatus::kIn;
+        break;
+      }
+      queue.pop();
+    }
   }
-  mainMessage_ = "Waiting for players";
-  secondaryMessage_ = "Please wait until all players are ready";
-  status_ = LobbyStatus::kWaitingPlayers;
 }
 
 void SceneLobby::UpdateStatusText() {
@@ -157,17 +135,12 @@ void SceneLobby::UpdateStatusText() {
     return;
   }
 }
-
-void SceneLobby::WaitGameStart() {
-  auto queue = serverConnectionService_->client()->ExtractQueue();
-
-  while (!queue.empty()) {
-    auto &message = queue.front();
-    if (message.messageType == api::MasterToClientMsgType::kMsgTypeMTCGameStarted) {
-      mainMessage_ = "Starting...";
-      secondaryMessage_ = "The game is starting, please wait";
-      status_ = LobbyStatus::kIn;
+void SceneLobby::OnDeactivate() {
+    if (joiningThread_ && joiningThread_->joinable()) {
+        joiningThread_->join();
     }
-    queue.pop();
-  }
+    joiningThread_.reset();
+    status_ = LobbyStatus::kNone;
+    mainMessage_ = "";
+    secondaryMessage_ = "";
 }

client/src/scenes/lobby.hpp

@@ -32,18 +32,16 @@ class SceneLobby final : public SceneBase {
 
   void OnActivate() override;
 
+  void OnDeactivate() override;
+
  private:
   /**
    * @brief Create the title
    */
   enum class LobbyStatus {
-    kNone,                    ///< No status
-    kFailed,                  ///< Failed to join the lobby
-    kRegistrationInProgress,  ///< Registration in progress
-    kRegistered,              ///< Registered in on the server
-    kJoining,                 ///< Joining the lobby
-    kWaitingPlayers,          ///< Waiting for players
-    kIn,                      ///< In the lobby
+    kNone,     ///< No status
+    kWaiting,  ///< Waiting for the lobby
+    kIn,       ///< In the lobby
   };
 
   /**
@@ -59,23 +57,18 @@ class SceneLobby final : public SceneBase {
   /**
    * @brief Join the lobby
    */
-  void JoinLobby();
+  void Wait();
 
   /**
    * @brief Join the lobby asynchronously
    */
-  void JoinLobbyAsync();
+  void WaitAsync();
 
   /**
    * @brief Update the status text
    */
   void UpdateStatusText();
 
-  /**
-   * @brief Wait for the game to start
-   */
-  void WaitGameStart();
-
   /// @brief The current lobby status
   LobbyStatus status_ = LobbyStatus::kNone;
 

client/src/scenes/start/create_room.cpp

@@ -106,7 +106,7 @@ void SceneCreateRoom::CreateCreateButton() const {
                                return;
                              }
                              api::payload::CreateRoom payload{};
-                             payload.difficulty = difficulty_ - 1;
+                             payload.difficulty = difficulty_ - 2;
                              payload.nbPlayers = nbPlayers_ - 1;
                              char usernameChar[20] = {0};
                              strncpy(usernameChar, text.text.c_str(), sizeof(usernameChar) - 1);

client/src/scenes/start/entities/text_entity.cpp

@@ -28,11 +28,24 @@ void TextEntity::OnSpawn(const TextEntity::Properties &props) {
   auto drawable = Text{.text = props.text,
                        .fontName = props.fontName,
                        .characterSize = props.characterSize,
+                       .style = props.style,
                        .color = props.color};
 
-  registry_->AddComponent<Drawable>(*this, {drawable, WindowManager::HUD});
+  registry_->AddComponent<Drawable>(
+      *this, {.drawable = drawable, .view = WindowManager::HUD, .visible = props.visible});
   registry_->AddComponent<Position>(*this, {
                                                props.position,
                                                props.alignment,
                                            });
+  auto tags = Tags({});
+  for (const auto &tag : props.tags) {
+    tags.AddTag(tag);
+  }
+  registry_->AddComponent<Tags>(*this, tags);
+}
+
+void TextEntity::RegisterDependencies(const Registry::Ptr &registry) {
+  registry->RegisterComponent<Drawable>();
+  registry->RegisterComponent<Position>();
+  registry->RegisterComponent<Tags>();
 }

client/src/scenes/start/entities/text_entity.hpp

@@ -33,8 +33,20 @@ class TextEntity : public Entity {
     sf::Color color;
     /// @brief Layer of the text
     zygarde::core::components::Alignment alignment;
+    /// @brief Style of the text*
+    sf::Text::Style style = sf::Text::Style::Regular;
+    /// @brief Tags list
+    std::vector<std::string> tags;
+    /// @brief View of the text
+    bool visible = true;
   };
 
+  /**
+   * @brief Register the dependencies
+   * @param registry Registry to register the dependencies
+   */
+  static void RegisterDependencies(const zygarde::Registry::Ptr &registry);
+
   explicit TextEntity(const Entity &other);
 
  protected: