Merge pull request #56 from G-Epitech/rtp-52-create-in-game-scene

TekMath · web-flow · commit fc8fc2b16fa4 · 2024-10-14T04:18:50.000+02:00
RTP-52 - Create in game scene
diff --git a/client/main.cpp b/client/main.cpp
@@ -10,12 +10,14 @@
 using namespace rtype::client;
 
 #if (defined(_WIN32) && !defined(DEBUG))
-  #define MAIN WinMain
+  #include <windows.h>
+  #define MAIN \
+    WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 #else
-  #define MAIN main
+  #define MAIN main()
 #endif
 
-int MAIN() {
+int MAIN {
   try {
     App app;
 
diff --git a/client/src/scenes/lobby.cpp b/client/src/scenes/lobby.cpp
@@ -104,7 +104,7 @@ void SceneLobby::JoinLobby() {
     status_ = LobbyStatus::kFailed;
     return;
   }
-  usleep(1200000);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1200));
   status_ = LobbyStatus::kRegistered;
   mainMessage_ = "Joining the lobby";
   secondaryMessage_ = "Please wait...";
@@ -117,7 +117,7 @@ void SceneLobby::JoinLobby() {
   }
   mainMessage_ = "Success";
   secondaryMessage_ = "You are now in the lobby. The game will start soon";
-  usleep(1200000);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1200));
   status_ = LobbyStatus::kIn;
 }
 
diff --git a/client/src/systems/background.cpp b/client/src/systems/background.cpp
@@ -64,7 +64,7 @@ void BackgroundSystem::SpawnStar(const std::shared_ptr<Registry>& r) {
 
   r->AddComponent<Position>(entity, {Vector3f{randomX, randomY, 0}});
   r->AddComponent<Tags>(entity, Tags({"background"}));
-  r->AddComponent<Drawable>(entity, {Rectangle{
+  r->AddComponent<Drawable>(entity, {components::Rectangle{
                                         .color = sf::Color::White,
                                         .size = {randomSize, randomSize},
                                     }});
diff --git a/client/src/systems/game/sync.cpp b/client/src/systems/game/sync.cpp
@@ -42,8 +42,10 @@ void GameSyncSystem::CreatePlayer(const std::shared_ptr<Registry>& registry, con
                           core::components::VerticalAlign::kTop}});
   registry->AddComponent<components::Drawable>(
       player, {
-                  .drawable = components::Texture{.name = "player", .scale = 3, .rect = base},
+                  .drawable = components::Texture{.name = "player", .scale = 5, .rect = base},
               });
+
+  std::cout << "Player created" << std::endl;
   players_.insert_or_assign(id, player);
 }
 
@@ -113,7 +115,7 @@ void GameSyncSystem::CreateEnemy(const std::shared_ptr<Registry>& registry, cons
 
 void GameSyncSystem::UpdateEnemy(const std::shared_ptr<Registry>& registry, const std::size_t& id,
                                  const zygarde::core::types::Vector3f& pos) {
-  auto enemy = players_.at(id);
+  auto enemy = enemies_.at(id);
   auto positions = registry->GetComponents<zygarde::core::components::Position>();
   auto entity_id = static_cast<std::size_t>(enemy);
 
diff --git a/libs/abra/src/client/udp/client_udp.cpp b/libs/abra/src/client/udp/client_udp.cpp
@@ -64,7 +64,6 @@ void ClientUDP::Close() {
 
   this->logger_.Info("Closing session");
 
-  this->socket_.shutdown(ip::udp::socket::shutdown_both);
   try {
     this->socket_.shutdown(ip::udp::socket::shutdown_both);
   } catch (const std::exception &e) {
diff --git a/libs/abra/src/server/udp/server_udp.cpp b/libs/abra/src/server/udp/server_udp.cpp
@@ -87,8 +87,8 @@ void ServerUDP::ResolveBuffer(std::vector<char> *buffer, std::size_t len) {
 
 void ServerUDP::StoreMessage(std::shared_ptr<tools::dynamic_bitset> bitset) {
   ClientUDPMessage message = {this->remoteEndpoint_,
-                              tools::PacketUtils::ExportMessageIdFromBitset(bitset),
-                              tools::PacketUtils::ExportMessageTypeFromBitset(bitset), bitset};
+                              tools::PacketUtils::ExportMessageTypeFromBitset(bitset),
+                              tools::PacketUtils::ExportMessageIdFromBitset(bitset), bitset};
 
   this->mutex_.lock();
   queue_.push(message);
diff --git a/libs/abra/src/server/udp/server_udp.tpp b/libs/abra/src/server/udp/server_udp.tpp
@@ -15,9 +15,6 @@ abra::server::ServerUDP::Send(const std::unique_ptr<abra::tools::Packet<T>> &pac
   const auto vector = bitset->GetVector();
   auto status = abra::tools::SendMessageStatus::kSuccess;
 
-  // debug endpoint
-  std::cout << endpoint.address().to_string() << ":" << endpoint.port() << std::endl;
-
   try {
     std::size_t len = this->socket_.send_to(boost::asio::buffer(vector, vector.size()), endpoint);
 
diff --git a/libs/abra/src/tools/packet/packet_builder.cpp b/libs/abra/src/tools/packet/packet_builder.cpp
@@ -98,6 +98,8 @@ void tools::PacketBuilder::SetHeaderFromBitset(const std::shared_ptr<dynamic_bit
 
   this->header_.payloadLength = payloadLength;
   this->header_.payloadType = payloadType;
+  this->header_.offsetFlag = offsetFlag;
+  this->header_.turnFlag = turnFlag;
 }
 
 void tools::PacketBuilder::SetMessageFromBitset(const std::shared_ptr<dynamic_bitset> &bitset,
diff --git a/libs/abra/tests/tools/bitset_test.cpp b/libs/abra/tests/tools/bitset_test.cpp
@@ -64,3 +64,44 @@ TEST(BitsetTest, ConvertBitsetToPacket) {
   EXPECT_EQ(convertedPayload.b, payload.b);
   EXPECT_EQ(convertedPayload.c, payload.c);
 }
+
+TEST(BitsetTest, SuspiciousPacket) {
+  tools::PacketBuilder packetBuilder;
+  struct payloadStruct {
+    std::size_t id;
+    struct {
+      float x;
+      float y;
+    } position;
+    std::size_t health;
+  };
+
+  packetBuilder.SetPayloadType(tools::PayloadType::kCustom);
+  packetBuilder.SetMessageType(5);
+
+  std::vector<struct payloadStruct> payload = {
+      {1, {1.0f, 2.0f}, 100},
+  };
+
+  auto packet = packetBuilder.Build<payloadStruct>(payload);
+  EXPECT_EQ(packet[0]->GetHeader().offsetFlag, 1);
+
+  auto bitset = packet[0]->GetBitset();
+
+  auto header = tools::PacketUtils::ExportHeaderFromBitset(bitset);
+  EXPECT_EQ(header.offsetFlag, 1);
+
+  auto convertedPacket = packetBuilder.Build<payloadStruct>(bitset);
+
+  EXPECT_EQ(convertedPacket->GetHeader().payloadType, static_cast<unsigned>(tools::PayloadType::kCustom));
+  EXPECT_EQ(convertedPacket->GetHeader().payloadLength, sizeof(payloadStruct));
+  EXPECT_EQ(convertedPacket->GetHeader().offsetFlag, 1);
+  EXPECT_EQ(convertedPacket->GetHeader().turnFlag, 0);
+
+  EXPECT_EQ(convertedPacket->GetMessage().messageType, 5);
+
+  auto convertedPayload = convertedPacket->GetPayload();
+  EXPECT_EQ(convertedPayload.id, payload[0].id);
+  EXPECT_EQ(convertedPayload.position.x, payload[0].position.x);
+  EXPECT_EQ(convertedPayload.health, payload[0].health);
+}
diff --git a/libs/game/src/api/server/server.cpp b/libs/game/src/api/server/server.cpp
@@ -150,7 +150,7 @@ std::uint64_t Server::FindUserByEndpoint(std::uint64_t lobbyId,
   }
 
   for (auto &client : this->lobbies_[lobbyId].clients) {
-    if (client.endpoint == endpoint) {
+    if (client.endpoint.port() == endpoint.port()) {
       return client.id;
     }
   }
diff --git a/libs/zygarde/src/physics/2d/systems/collision/collision_system.cpp b/libs/zygarde/src/physics/2d/systems/collision/collision_system.cpp
@@ -17,6 +17,9 @@ void CollisionSystem::Run(std::shared_ptr<Registry> r,
                           tools::sparse_array<core::components::Position>::ptr positions,
                           tools::sparse_array<components::BoxCollider2D>::ptr colliders) {
   for (size_t i = 0; i < positions->size(); i++) {
+    if (!r->HasEntityAtIndex(i)) {
+      continue;
+    }
     if (!IndexHasRequiredComponents(i, rigidbodies, positions, colliders)) {
       continue;
     }
diff --git a/libs/zygarde/src/registry.cpp b/libs/zygarde/src/registry.cpp
@@ -38,20 +38,26 @@ Entity Registry::SpawnEntity() {
     newId = currentMaxEntityId_++;
   }
   Entity e(newId);
-  entities_.push_back(e);
+  entities_.emplace_back(e);
   return e;
 }
 
 Entity Registry::EntityFromIndex(const std::size_t idx) const {
-  if (idx >= entities_.size()) {
-    return Entity(-1);
+  if (entities_.empty()) {
+    throw Exception("Entity not found");
   }
-  return entities_.at(idx);
+  if (entities_.size() < idx) {
+    throw Exception("Entity not found");
+  }
+  if (!entities_.at(idx).has_value()) {
+    throw Exception("Entity not found");
+  }
+  return entities_.at(idx).value();
 }
 
 void Registry::KillEntity(Entity const &e) {
   freeIds_.push(static_cast<std::size_t>(e));
-  entities_.erase(entities_.begin(), std::remove(entities_.begin(), entities_.end(), e));
+  entities_.at(IndexFromEntity(e)) = std::nullopt;
   for (auto &remove_function : removeFunctions_) {
     remove_function.second(*this, e);
   }
@@ -77,7 +83,7 @@ void Registry::CleanupDestroyedEntities() {
   }
 }
 bool Registry::HasEntityAtIndex(std::size_t idx) const {
-  return idx < entities_.size();
+  return idx < entities_.size() && entities_.at(idx).has_value();
 }
 
 Registry::Exception::Exception(std::string message) : message_(std::move(message)) {}
diff --git a/libs/zygarde/src/registry.hpp b/libs/zygarde/src/registry.hpp
@@ -180,7 +180,7 @@ class EXPORT_ZYGARDE_API Registry : public std::enable_shared_from_this<Registry
   size_t currentMaxEntityId_ = 0;
 
   /// @brief Entities stored
-  std::vector<Entity> entities_;
+  std::vector<std::optional<Entity>> entities_;
 
   /// @brief Free ids available for entities
   std::stack<std::size_t> freeIds_;
diff --git a/libs/zygarde/src/registry.tpp b/libs/zygarde/src/registry.tpp
@@ -59,7 +59,7 @@ Component *Registry::GetComponent(const Entity &e) {
 
   const auto entityIndex = IndexFromEntity(e);
 
-  if (components.get()->size() > entityIndex) {
+  if (components.get()->size() >= entityIndex) {
     auto &optionalComponent = (*components)[entityIndex];
     if (optionalComponent) {
       return &(*optionalComponent);
diff --git a/libs/zygarde/src/scripting/components/script/script.cpp b/libs/zygarde/src/scripting/components/script/script.cpp
@@ -13,10 +13,10 @@ using namespace zygarde::scripting::components;
 
 Script::Script(std::optional<types::Collision2DFunction> on_collision_enter,
                std::optional<types::FixedUpdateFunction> fixed_update,
-               scripting::types::ValuesMap values)
+               const scripting::types::ValuesMap& values)
     : onCollisionEnter(std::move(on_collision_enter)),
       fixedUpdate(std::move(fixed_update)),
-      values_(std::move(values)) {}
+      values_(std::make_shared<types::ValuesMap>(values)) {}
 
 Script::Script(std::optional<scripting::types::Collision2DFunction> on_collision_enter,
                std::optional<scripting::types::FixedUpdateFunction> fixed_update)
diff --git a/libs/zygarde/src/scripting/components/script/script.hpp b/libs/zygarde/src/scripting/components/script/script.hpp
@@ -21,28 +21,18 @@ class EXPORT_ZYGARDE_API Script final {
   ~Script() = default;
 
   Script(std::optional<types::Collision2DFunction> on_collision_enter,
-         std::optional<types::FixedUpdateFunction> fixed_update, types::ValuesMap values);
+         std::optional<types::FixedUpdateFunction> fixed_update, const types::ValuesMap& values);
 
   Script(std::optional<types::Collision2DFunction> on_collision_enter,
          std::optional<types::FixedUpdateFunction> fixed_update);
 
- public:
-  /**
-   * @brief Set a value in the script
-   * @param key Key of the value
-   * @param value Value to set
-   */
-  inline void SetValue(const std::string &key, const std::any &value) noexcept {
-    values_[key] = value;
-  }
-
  public:
   std::optional<types::Collision2DFunction> onCollisionEnter;
   std::optional<types::FixedUpdateFunction> fixedUpdate;
 
   friend class zygarde::scripting::systems::ScriptExecutionSystem;
 
  private:
-  types::ValuesMap values_;
+  std::shared_ptr<types::ValuesMap> values_;
 };
 }  // namespace zygarde::scripting::components
diff --git a/libs/zygarde/src/scripting/systems/execution/script_execution_system.cpp b/libs/zygarde/src/scripting/systems/execution/script_execution_system.cpp
@@ -29,7 +29,8 @@ void ScriptExecutionSystem::Run(Registry::Ptr r,
 
 void ScriptExecutionSystem::ProcessScript(Registry::Const_Ptr registry,
                                           scripting::components::Script* script) {
-  types::ScriptingContext context = CreateContext(registry, script);
+  std::shared_ptr<types::ScriptingContext> context =
+      std::make_shared<types::ScriptingContext>(CreateContext(registry, script));
 
   HandleFixedUpdate(registry, script, context);
   HandleCollisionCallback(registry, script, context);
@@ -42,7 +43,7 @@ scripting::types::ScriptingContext ScriptExecutionSystem::CreateContext(
 
 void ScriptExecutionSystem::HandleCollisionCallback(
     Registry::Const_Ptr registry, scripting::components::Script* script,
-    scripting::types::ScriptingContext& context) const {
+    types::ScriptingContext::ConstPtr context) const {
   if (!script->onCollisionEnter.has_value()) {
     return;
   }
@@ -57,9 +58,9 @@ void ScriptExecutionSystem::HandleCollisionCallback(
   }
 }
 
-void ScriptExecutionSystem::HandleFixedUpdate(Registry::Const_Ptr registry,
-                                              scripting::components::Script* script,
-                                              scripting::types::ScriptingContext& context) {
+void ScriptExecutionSystem::HandleFixedUpdate(
+    Registry::Const_Ptr registry, scripting::components::Script* script,
+    scripting::types::ScriptingContext::ConstPtr context) {
   if (script->fixedUpdate.has_value()) {
     script->fixedUpdate.value()(context);
   }
diff --git a/libs/zygarde/src/scripting/systems/execution/script_execution_system.hpp b/libs/zygarde/src/scripting/systems/execution/script_execution_system.hpp
@@ -28,10 +28,10 @@ class EXPORT_ZYGARDE_API ScriptExecutionSystem final
   void ProcessScript(Registry::Const_Ptr registry, scripting::components::Script *script);
 
   static void HandleFixedUpdate(Registry::Const_Ptr registry, scripting::components::Script *script,
-                                types::ScriptingContext &context);
+                                types::ScriptingContext::ConstPtr context);
 
   void HandleCollisionCallback(Registry::Const_Ptr registry, scripting::components::Script *script,
-                               types::ScriptingContext &context) const;
+                               types::ScriptingContext::ConstPtr context) const;
 
   types::ScriptingContext CreateContext(Registry::Const_Ptr registry,
                                         scripting::components::Script *script);
diff --git a/libs/zygarde/src/scripting/types/callbacks.hpp b/libs/zygarde/src/scripting/types/callbacks.hpp
@@ -27,8 +27,8 @@
 
 namespace zygarde::scripting::types {
 /// @brief Fixed Update callback function
-using FixedUpdateFunction = std::function<void(const ScriptingContext &)>;
+using FixedUpdateFunction = std::function<void(ScriptingContext::ConstPtr)>;
 /// @brief Colliding callback function
 using Collision2DFunction =
-    std::function<void(const ScriptingContext &, physics::types::Collision2D::ptr)>;
+    std::function<void(ScriptingContext::ConstPtr, physics::types::Collision2D::ptr)>;
 }  // namespace zygarde::scripting::types
diff --git a/libs/zygarde/src/scripting/types/context.hpp b/libs/zygarde/src/scripting/types/context.hpp
@@ -14,8 +14,11 @@ namespace zygarde::scripting::types {
 using ValuesMap = std::map<std::string, std::any>;
 
 struct ScriptingContext {
+  using Ptr = std::shared_ptr<ScriptingContext>;
+  using ConstPtr = const std::shared_ptr<ScriptingContext> &;
+
   const Registry::Ptr &registry;
-  ValuesMap &values;
+  std::shared_ptr<ValuesMap> values;
   const utils::Timer::Nanoseconds &deltaTime;
   zygarde::Entity me;
 };
diff --git a/server/src/app/lobby/game_service/enemy_manager/enemy_manager.cpp b/server/src/app/lobby/game_service/enemy_manager/enemy_manager.cpp
@@ -13,16 +13,14 @@
 void rtype::server::game::EnemyManager::Update(const utils::Timer::Nanoseconds &deltaTime,
                                                zygarde::Registry::Const_Ptr registry) {
   accumulatedTime_ += deltaTime;
-  if (accumulatedTime_ < std::chrono::milliseconds(500)) {
+  if (accumulatedTime_ < std::chrono::milliseconds(4000)) {
     return;
   }
   accumulatedTime_ = std::chrono::milliseconds(0);
   std::random_device rd;
   std::mt19937 gen(rd());
-  std::uniform_real_distribution<float> dist(100.0f, 800.0f);
+  std::uniform_real_distribution<float> dist(80.0f, 1000.0f);
 
-  zygarde::core::types::Vector3f position(0, 5000, 0);
+  zygarde::core::types::Vector3f position(1300, dist(gen), 0);
   EnemyFactory::CreateEnemy(registry, position, sdk::game::types::EnemyType::kPata);
-  std::cout << "spawn at-----------------------------------------" << position.x << " "
-            << position.y << std::endl;
 }
diff --git a/server/src/app/lobby/game_service/factories/enemy_factory.cpp b/server/src/app/lobby/game_service/factories/enemy_factory.cpp
diff --git a/server/src/app/lobby/game_service/factories/enemy_factory.hpp b/server/src/app/lobby/game_service/factories/enemy_factory.hpp
diff --git a/server/src/app/lobby/game_service/factories/player_factory.cpp b/server/src/app/lobby/game_service/factories/player_factory.cpp
diff --git a/server/src/app/lobby/game_service/factories/player_factory.hpp b/server/src/app/lobby/game_service/factories/player_factory.hpp
diff --git a/server/src/app/lobby/game_service/factories/projectile_factory.cpp b/server/src/app/lobby/game_service/factories/projectile_factory.cpp
diff --git a/server/src/app/lobby/game_service/factories/projectile_factory.hpp b/server/src/app/lobby/game_service/factories/projectile_factory.hpp
diff --git a/server/src/app/lobby/game_service/game_service.cpp b/server/src/app/lobby/game_service/game_service.cpp

Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ void SceneLobby::JoinLobby() {`
`104`	`104`	`status_ = LobbyStatus::kFailed;`
`105`	`105`	`return;`
`106`	`106`	`}`
`107`		`- usleep(1200000);`
	`107`	`+ std::this_thread::sleep_for(std::chrono::milliseconds(1200));`
`108`	`108`	`status_ = LobbyStatus::kRegistered;`
`109`	`109`	`mainMessage_ = "Joining the lobby";`
`110`	`110`	`secondaryMessage_ = "Please wait...";`
`@@ -117,7 +117,7 @@ void SceneLobby::JoinLobby() {`
`117`	`117`	`}`
`118`	`118`	`mainMessage_ = "Success";`
`119`	`119`	`secondaryMessage_ = "You are now in the lobby. The game will start soon";`
`120`		`- usleep(1200000);`
	`120`	`+ std::this_thread::sleep_for(std::chrono::milliseconds(1200));`
`121`	`121`	`status_ = LobbyStatus::kIn;`
`122`	`122`	`}`
`123`	`123`
Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,8 @@ void tools::PacketBuilder::SetHeaderFromBitset(const std::shared_ptr<dynamic_bit`
`98`	`98`
`99`	`99`	`this->header_.payloadLength = payloadLength;`
`100`	`100`	`this->header_.payloadType = payloadType;`
	`101`	`+ this->header_.offsetFlag = offsetFlag;`
	`102`	`+ this->header_.turnFlag = turnFlag;`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`void tools::PacketBuilder::SetMessageFromBitset(const std::shared_ptr<dynamic_bitset> &bitset,`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ std::uint64_t Server::FindUserByEndpoint(std::uint64_t lobbyId,`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`for (auto &client : this->lobbies_[lobbyId].clients) {`
`153`		`- if (client.endpoint == endpoint) {`
	`153`	`+ if (client.endpoint.port() == endpoint.port()) {`
`154`	`154`	`return client.id;`
`155`	`155`	`}`
`156`	`156`	`}`