Merge pull request SantiSev#177 from SantiSev/dev_add_namespaces

Dev add namespaces
maxogod · Jun 26, 2024 · 55c4daf · 55c4daf
2 parents 75fa7a1 + 49f2c45
commit 55c4daf
Show file tree

Hide file tree

Showing 33 changed files with 158 additions and 143 deletions.
diff --git a/game_engine/game_object.h b/game_engine/game_object.h
diff --git a/game_engine/physics_engine/collision_manager.cpp b/game_engine/physics_engine/collision_manager.cpp
@@ -4,16 +4,20 @@
 
 #include "physics_object/dynamic_body.h"
 
+using engine::CollisionManager;
+
 CollisionManager::CollisionManager(int level_width, int level_height):
         grid_width(level_width),
         grid_height(level_height),
-        grid(level_width, std::vector<std::shared_ptr<CollisionObject>>(level_height, nullptr)) {}
+        grid(level_width,
+             std::vector<std::shared_ptr<engine::CollisionObject>>(level_height, nullptr)) {}
 
-std::shared_ptr<CollisionObject> CollisionManager::get_collision_object_at(int x, int y) const {
+std::shared_ptr<engine::CollisionObject> CollisionManager::get_collision_object_at(int x,
+                                                                                   int y) const {
     return grid[x][y];
 }
 
-void CollisionManager::place_object_in_grid(std::shared_ptr<CollisionObject> obj) {
+void CollisionManager::place_object_in_grid(std::shared_ptr<engine::CollisionObject> obj) {
 
     for (int i = obj->position.x; i < obj->position.x + obj->get_hitbox_width(); ++i) {
         for (int j = obj->position.y; j < obj->position.y + obj->get_hitbox_height(); ++j) {
@@ -28,7 +32,7 @@ bool CollisionManager::is_valid_cell(int x, int y) const {
     return x >= 0 && x < grid_width && y >= 0 && y < grid_height;
 }
 
-void CollisionManager::remove_object_from_grid(std::shared_ptr<CollisionObject> obj,
+void CollisionManager::remove_object_from_grid(std::shared_ptr<engine::CollisionObject> obj,
                                                Vector2D position) {
 
     for (int i = position.x; i < position.x + obj->get_hitbox_width(); ++i) {
@@ -44,7 +48,7 @@ void CollisionManager::remove_object_from_grid(std::shared_ptr<CollisionObject>
 // ----------------- public methods ---------------------
 
 
-bool CollisionManager::can_be_placed(std::shared_ptr<CollisionObject> obj,
+bool CollisionManager::can_be_placed(std::shared_ptr<engine::CollisionObject> obj,
                                      Vector2D new_position) const {
     for (int i = new_position.x; i < new_position.x + obj->get_hitbox_width(); ++i) {
         for (int j = new_position.y; j < new_position.y + obj->get_hitbox_height(); ++j) {
@@ -56,28 +60,28 @@ bool CollisionManager::can_be_placed(std::shared_ptr<CollisionObject> obj,
     return true;
 }
 
-void CollisionManager::add_object(std::shared_ptr<StaticBody> obj) {
+void CollisionManager::add_object(std::shared_ptr<engine::StaticBody> obj) {
 
     static_bodies.emplace_back(obj);
     place_object_in_grid(obj);
 }
 
-void CollisionManager::track_dynamic_body(std::shared_ptr<DynamicBody> obj) {
+void CollisionManager::track_dynamic_body(std::shared_ptr<engine::DynamicBody> obj) {
 
     dynamic_bodies.emplace_back(obj, obj->position);
     place_object_in_grid(obj);
 }
 
-void CollisionManager::remove_object(std::shared_ptr<CollisionObject> obj) {
+void CollisionManager::remove_object(std::shared_ptr<engine::CollisionObject> obj) {
     remove_object_from_grid(obj, obj->position);
 }
 
-void CollisionManager::update_object(std::shared_ptr<CollisionObject> obj) {
+void CollisionManager::update_object(std::shared_ptr<engine::CollisionObject> obj) {
     remove_object_from_grid(obj, obj->position);
     place_object_in_grid(obj);
 }
 
-void CollisionManager::detect_colisions(std::shared_ptr<DynamicBody> obj) {
+void CollisionManager::detect_colisions(std::shared_ptr<engine::DynamicBody> obj) {
 
     int obj_x = obj->position.x;
     int obj_y = obj->position.y;
@@ -91,7 +95,7 @@ void CollisionManager::detect_colisions(std::shared_ptr<DynamicBody> obj) {
 
     for (int i = obj_x; i < obj_x + obj_width; ++i) {
         for (int j = obj_y; j < obj_y + obj_height; ++j) {
-            std::shared_ptr<CollisionObject> other = get_collision_object_at(i, j);
+            std::shared_ptr<engine::CollisionObject> other = get_collision_object_at(i, j);
             if (other != nullptr && other.get() != obj.get()) {
                 // double dispatch to handle collision
                 obj->handle_colision(other.get());  // Handle collision with other object
@@ -102,7 +106,7 @@ void CollisionManager::detect_colisions(std::shared_ptr<DynamicBody> obj) {
 }
 
 void CollisionManager::handle_out_of_bounds(
-        std::shared_ptr<DynamicBody> obj) {  // TODO refactor this :D
+        std::shared_ptr<engine::DynamicBody> obj) {  // TODO refactor this :D
     if (obj->position.x < 0) {
         obj->position.x = 32;
         obj->velocity.x = 0;
@@ -173,7 +177,7 @@ void CollisionManager::remove_inactive_bodies() {
 }
 
 void CollisionManager::iterateDynamicBodies(
-        std::function<void(std::shared_ptr<DynamicBody>&)> func) {
+        std::function<void(std::shared_ptr<engine::DynamicBody>&)> func) {
     for (auto& bodyTuple: dynamic_bodies) {
         auto& body = std::get<0>(bodyTuple);
         func(body);
@@ -222,8 +226,8 @@ void CollisionManager::prepare_map() {
                 // Check left adjacent cell
                 if (is_valid_cell(i - 1, j)) {
                     auto coll_obj = get_collision_object_at(i - 1, j);
-                    StaticBody* adj_obj =
-                            dynamic_cast<StaticBody*>(get_collision_object_at(i - 1, j).get());
+                    engine::StaticBody* adj_obj = dynamic_cast<engine::StaticBody*>(
+                            get_collision_object_at(i - 1, j).get());
 
                     if (adj_obj && adj_obj->position.x + adj_obj->get_hitbox_width() ==
                                            static_body->position.x) {
@@ -235,7 +239,7 @@ void CollisionManager::prepare_map() {
                 // Check right adjacent cell
                 if (is_valid_cell(i + 1, j)) {
                     auto coll_obj = get_collision_object_at(i + 1, j);
-                    StaticBody* adj_obj = dynamic_cast<StaticBody*>(coll_obj.get());
+                    engine::StaticBody* adj_obj = dynamic_cast<engine::StaticBody*>(coll_obj.get());
                     if (adj_obj && adj_obj->position.x == static_body->position.x +
                                                                   static_body->get_hitbox_width()) {
                         static_body->disable_collision(CollisionFace::RIGHT);
@@ -246,7 +250,7 @@ void CollisionManager::prepare_map() {
                 // Check top adjacent cell
                 if (is_valid_cell(i, j - 1)) {
                     auto coll_obj = get_collision_object_at(i, j - 1);
-                    StaticBody* adj_obj = dynamic_cast<StaticBody*>(coll_obj.get());
+                    engine::StaticBody* adj_obj = dynamic_cast<engine::StaticBody*>(coll_obj.get());
                     if (adj_obj && adj_obj->position.y + adj_obj->get_hitbox_height() ==
                                            static_body->position.y) {
                         static_body->disable_collision(CollisionFace::TOP);
@@ -257,7 +261,7 @@ void CollisionManager::prepare_map() {
                 // Check bottom adjacent cell
                 if (is_valid_cell(i, j + 1)) {
                     auto coll_obj = get_collision_object_at(i, j + 1);
-                    StaticBody* adj_obj = dynamic_cast<StaticBody*>(coll_obj.get());
+                    engine::StaticBody* adj_obj = dynamic_cast<engine::StaticBody*>(coll_obj.get());
                     if (adj_obj &&
                         adj_obj->position.y ==
                                 static_body->position.y + static_body->get_hitbox_height()) {

diff --git a/game_engine/physics_engine/collision_manager.h b/game_engine/physics_engine/collision_manager.h
@@ -13,33 +13,35 @@
 
 #include "collision_object.h"
 
+namespace engine {
+
 class CollisionManager {
 private:
     int grid_width;
     int grid_height;
-    std::vector<std::vector<std::shared_ptr<CollisionObject>>>
-            grid;  // grid: [x][y] stores a vector of shared pointers to CollisionObjects
+    std::vector<std::vector<std::shared_ptr<engine::CollisionObject>>>
+            grid;  // grid: [x][y] stores a vector of shared pointers to engine::CollisionObjects
 
-    std::vector<std::tuple<std::shared_ptr<DynamicBody>, Vector2D>> dynamic_bodies;
-    std::vector<std::shared_ptr<StaticBody>> static_bodies;
+    std::vector<std::tuple<std::shared_ptr<engine::DynamicBody>, Vector2D>> dynamic_bodies;
+    std::vector<std::shared_ptr<engine::StaticBody>> static_bodies;
 
-    void handle_out_of_bounds(std::shared_ptr<DynamicBody> obj);
-    void place_object_in_grid(std::shared_ptr<CollisionObject> obj);
-    void remove_object_from_grid(std::shared_ptr<CollisionObject> obj, Vector2D position);
+    void handle_out_of_bounds(std::shared_ptr<engine::DynamicBody> obj);
+    void place_object_in_grid(std::shared_ptr<engine::CollisionObject> obj);
+    void remove_object_from_grid(std::shared_ptr<engine::CollisionObject> obj, Vector2D position);
 
     bool is_valid_cell(int x, int y) const;
-    void detect_colisions(std::shared_ptr<DynamicBody> obj);
+    void detect_colisions(std::shared_ptr<engine::DynamicBody> obj);
     void clear();
 
 public:
     CollisionManager(int levelWidth, int levelHeight);
-    void iterateDynamicBodies(std::function<void(std::shared_ptr<DynamicBody>&)> func);
-    std::shared_ptr<CollisionObject> get_collision_object_at(int x, int y) const;
-    void add_object(std::shared_ptr<StaticBody> obj);
-    void track_dynamic_body(std::shared_ptr<DynamicBody> obj);
-    bool can_be_placed(std::shared_ptr<CollisionObject> obj, Vector2D new_position) const;
-    void remove_object(std::shared_ptr<CollisionObject> obj);
-    void update_object(std::shared_ptr<CollisionObject> obj);
+    void iterateDynamicBodies(std::function<void(std::shared_ptr<engine::DynamicBody>&)> func);
+    std::shared_ptr<engine::CollisionObject> get_collision_object_at(int x, int y) const;
+    void add_object(std::shared_ptr<engine::StaticBody> obj);
+    void track_dynamic_body(std::shared_ptr<engine::DynamicBody> obj);
+    bool can_be_placed(std::shared_ptr<engine::CollisionObject> obj, Vector2D new_position) const;
+    void remove_object(std::shared_ptr<engine::CollisionObject> obj);
+    void update_object(std::shared_ptr<engine::CollisionObject> obj);
     void update();
     void remove_inactive_bodies();
     int get_grid_width() const;
@@ -50,5 +52,6 @@ class CollisionManager {
     ~CollisionManager();
 };
 
+}  // namespace engine
 
 #endif  // COLLISION_MANAGER_H
diff --git a/game_engine/physics_engine/collision_object.cpp b/game_engine/physics_engine/collision_object.cpp
@@ -1,13 +1,14 @@
 
 #include "collision_object.h"
 
-#include <iostream>
+
+using engine::CollisionObject;
 
 CollisionObject::CollisionObject(int hitbox_width, int hitbox_height):
-        GameObject(0, 0), hitbox_width(hitbox_width), hitbox_height(hitbox_height) {}
+        position(0, 0), hitbox_width(hitbox_width), hitbox_height(hitbox_height) {}
 
 CollisionObject::CollisionObject(int x, int y, int hitbox_width, int hitbox_height):
-        GameObject(x, y), hitbox_width(hitbox_width), hitbox_height(hitbox_height) {}
+        position(x, y), hitbox_width(hitbox_width), hitbox_height(hitbox_height) {}
 
 int CollisionObject::get_left_hitbox_side() const { return position.x; }
 

diff --git a/game_engine/physics_engine/collision_object.h b/game_engine/physics_engine/collision_object.h
@@ -3,13 +3,16 @@
 
 #include <string>
 
-#include "../game_object.h"
+#include "../math/vector2D.h"
 
 #include "collision_face.h"
-#include "collision_object.h"
 
+namespace engine {
+
+class CollisionObject {
+public:
+    Vector2D position;
 
-class CollisionObject: public GameObject {
 private:
     int hitbox_width;
     int hitbox_height;
@@ -59,6 +62,7 @@ class CollisionObject: public GameObject {
 
     virtual ~CollisionObject() = default;
 };
+}  // namespace engine
 
 
 #endif  // GAME_ENGINE_COLISION_OBJECT_H_
diff --git a/game_engine/physics_engine/physics_object/dynamic_body.cpp b/game_engine/physics_engine/physics_object/dynamic_body.cpp
@@ -2,13 +2,15 @@
 
 #include <iostream>
 
-DynamicBody::DynamicBody(int width, int height): CollisionObject(width, height) {}
+using engine::DynamicBody;
+
+DynamicBody::DynamicBody(int width, int height): engine::CollisionObject(width, height) {}
 
 DynamicBody::DynamicBody(int x, int y, int width, int height):
-        CollisionObject(x, y, width, height) {}
+        engine::CollisionObject(x, y, width, height) {}
 
 DynamicBody::DynamicBody(int x, int y, int width, int height, Vector2D base_speed):
-        CollisionObject(x, y, width, height), velocity(base_speed) {}
+        engine::CollisionObject(x, y, width, height), velocity(base_speed) {}
 
 void DynamicBody::update_body() {}
 
@@ -20,7 +22,7 @@ void DynamicBody::print_info() {
 }
 
 void DynamicBody::handle_colision(
-        CollisionObject* other) {  // other players cant overlap with other players
+        engine::CollisionObject* other) {  // other players cant overlap with other players
 
     CollisionFace face = is_touching(other);
     switch (face) {

diff --git a/game_engine/physics_engine/physics_object/dynamic_body.h b/game_engine/physics_engine/physics_object/dynamic_body.h
@@ -3,7 +3,10 @@
 
 #include "../collision_object.h"
 
-class DynamicBody: public CollisionObject {
+namespace engine {
+
+
+class DynamicBody: public engine::CollisionObject {
 public:
     Vector2D velocity = Vector2D(0, 0);
 
@@ -17,12 +20,13 @@ class DynamicBody: public CollisionObject {
      */
     virtual void update_body();
 
-    void handle_colision(CollisionObject* other) override;
+    void handle_colision(engine::CollisionObject* other) override;
 
     virtual void print_info();
 
     virtual void handle_out_of_bounds() {}
 };
+}  // namespace engine
 
 
 #endif  // CHARACTER_BODY_H
diff --git a/game_engine/physics_engine/physics_object/static_body.cpp b/game_engine/physics_engine/physics_object/static_body.cpp
@@ -1,14 +1,16 @@
 
 #include "static_body.h"
 
-#include <iostream>
 
-StaticBody::StaticBody(int width, int height): CollisionObject(width, height) {}
+using engine::StaticBody;
 
-StaticBody::StaticBody(int x, int y, int width, int height): CollisionObject(x, y, width, height) {}
+StaticBody::StaticBody(int width, int height): engine::CollisionObject(width, height) {}
 
+StaticBody::StaticBody(int x, int y, int width, int height):
+        engine::CollisionObject(x, y, width, height) {}
 
-void StaticBody::handle_colision(CollisionObject* other) {
+
+void StaticBody::handle_colision(engine::CollisionObject* other) {
 
     CollisionFace face = this->is_touching(other);
 

diff --git a/game_engine/physics_engine/physics_object/static_body.h b/game_engine/physics_engine/physics_object/static_body.h
@@ -4,7 +4,9 @@
 
 #include "../collision_object.h"
 
-class StaticBody: public CollisionObject {
+namespace engine {
+
+class StaticBody: public engine::CollisionObject {
 
 protected:
     bool top_collision = true;
@@ -13,11 +15,13 @@ class StaticBody: public CollisionObject {
     bool bottom_collision = true;
 
 public:
-    void handle_colision(CollisionObject* other) override;
+    void handle_colision(engine::CollisionObject* other) override;
     StaticBody(int width, int height);
     StaticBody(int x, int y, int width, int height);
     void disable_collision(CollisionFace face);
 };
 
+}  // namespace engine
+
 
 #endif  // STATIC_BODY_H
diff --git a/server/game_logic/characters/character.cpp b/server/game_logic/characters/character.cpp
@@ -7,7 +7,7 @@
 
 CharacterBody::CharacterBody(size_t id, const character_t& character, int x, int y, int w, int h,
                              Vector2D velocity, int health, state_t state, int revive_cooldown):
-        DynamicBody(x, y, w, h, Vector2D(velocity)),
+        engine::DynamicBody(x, y, w, h, Vector2D(velocity)),
         id(id),
         character_reference(character),
         state(state),
@@ -118,7 +118,7 @@ void CharacterBody::update_body() {
     position += velocity;
 }
 
-void CharacterBody::handle_colision(CollisionObject* other) {
+void CharacterBody::handle_colision(engine::CollisionObject* other) {
 
     CollisionFace face = is_touching(other);
 

diff --git a/server/game_logic/characters/character.h b/server/game_logic/characters/character.h
@@ -31,7 +31,7 @@
 #define REVIVE_COOLDOWN 1000
 #define INVINCIBILITY_COOLDOWN 600
 
-class CharacterBody: public DynamicBody {
+class CharacterBody: public engine::DynamicBody {
 
 protected:
     // dto info
@@ -55,7 +55,7 @@ class CharacterBody: public DynamicBody {
 
     //------- Overrided Methods --------
 
-    void handle_colision(CollisionObject* other) override;
+    void handle_colision(engine::CollisionObject* other) override;
     void update_body() override;
 
     //------- Getters --------