chore: formatted src/

src/Core/Animation/Animation.cpp

@@ -72,7 +72,10 @@ namespace obe::animation
         std::vector<std::string> group_keys;
         group_keys.reserve(m_groups.size());
         std::transform(m_groups.cbegin(), m_groups.cend(), group_keys.begin(),
-            [](const auto& pair) { return pair.first; });
+            [](const auto& pair)
+            {
+                return pair.first;
+            });
         return group_keys;
     }
 

src/Core/Audio/Sound.cpp

@@ -118,7 +118,8 @@ namespace obe::audio
         }
         else
         {
-            m_handle = m_sound.m_manager.play(*m_sound.m_source, m_sound.m_source->mVolume, 0, true);
+            m_handle
+                = m_sound.m_manager.play(*m_sound.m_source, m_sound.m_source->mVolume, 0, true);
             this->apply_changes();
             m_sound.m_manager.setPause(m_handle, false);
         }

src/Core/Collision/ColliderComponent.cpp

@@ -137,7 +137,8 @@ namespace obe::collision
         }
 
         std::visit(
-            [&collider_dump](auto&& collider) {
+            [&collider_dump](auto&& collider)
+            {
                 const auto& position = collider.get_position();
                 const std::string& tag = collider.get_tag();
                 collider_dump.insert("x", position.x);
@@ -183,7 +184,8 @@ namespace obe::collision
             throw exceptions::InvalidColliderComponentType(m_id, collider_type_str);
         }
         std::visit(
-            [this, x, y, tag](auto&& collider) {
+            [this, x, y, tag](auto&& collider)
+            {
                 collider.set_position(transform::UnitVector(x, y, m_unit));
                 collider.set_tag(tag);
             },
@@ -219,14 +221,21 @@ namespace obe::collision
     Collider* ColliderComponent::get_inner_collider()
     {
         Collider* collider = std::visit(
-            [](auto& collider_variant) -> Collider* { return &collider_variant; }, m_collider);
+            [](auto& collider_variant) -> Collider*
+            {
+                return &collider_variant;
+            },
+            m_collider);
         return collider;
     }
 
     const Collider* ColliderComponent::get_inner_collider() const
     {
         const Collider* collider = std::visit(
-            [](auto& collider_variant) -> const Collider* { return &collider_variant; },
+            [](auto& collider_variant) -> const Collider*
+            {
+                return &collider_variant;
+            },
             m_collider);
         return collider;
     }

src/Core/Collision/CollisionSpace.cpp

@@ -32,7 +32,6 @@ namespace obe::collision
         const bool is_valid
             = (!check_both_directions || can_collide_with(collider2, collider1, false));
 
-
         // if true, check if we need to check for tags on collider2 -> collider1
         return is_valid;
     }
@@ -41,11 +40,8 @@ namespace obe::collision
 
     CollisionSpace::CollisionSpace()
         : m_quadtree(
-            transform::AABB(
-                transform::UnitVector(-COLLISION_SPACE_SIZE, -COLLISION_SPACE_SIZE),
-                transform::UnitVector(2 * COLLISION_SPACE_SIZE, 2 * COLLISION_SPACE_SIZE)
-            )
-        )
+            transform::AABB(transform::UnitVector(-COLLISION_SPACE_SIZE, -COLLISION_SPACE_SIZE),
+                transform::UnitVector(2 * COLLISION_SPACE_SIZE, 2 * COLLISION_SPACE_SIZE)))
     {
     }
 
@@ -102,10 +98,11 @@ namespace obe::collision
         return false;
     }
 
-    transform::UnitVector CollisionSpace::get_offset_before_collision(const Collider& collider,
-        const transform::UnitVector& offset) const
+    transform::UnitVector CollisionSpace::get_offset_before_collision(
+        const Collider& collider, const transform::UnitVector& offset) const
     {
-        const std::vector<ReachableCollider> reachable_colliders = this->get_reachable_colliders(collider, offset);
+        const std::vector<ReachableCollider> reachable_colliders
+            = this->get_reachable_colliders(collider, offset);
         return this->get_offset_before_collision(collider, reachable_colliders, offset);
     }
 
@@ -166,8 +163,8 @@ namespace obe::collision
         return reachable_colliders;
     }
 
-    void CollisionSpace::add_tag_to_blacklist(const std::string& source_tag,
-        const std::string& rejected_tag)
+    void CollisionSpace::add_tag_to_blacklist(
+        const std::string& source_tag, const std::string& rejected_tag)
     {
         if (!m_tags_blacklists.contains(source_tag))
         {
@@ -176,8 +173,8 @@ namespace obe::collision
         m_tags_blacklists.at(source_tag).insert(rejected_tag);
     }
 
-    void CollisionSpace::remove_tag_to_blacklist(const std::string& source_tag,
-        const std::string& rejected_tag)
+    void CollisionSpace::remove_tag_to_blacklist(
+        const std::string& source_tag, const std::string& rejected_tag)
     {
         if (m_tags_blacklists.contains(source_tag))
         {

src/Core/Collision/ComplexPolygonCollider.cpp

@@ -166,7 +166,7 @@ namespace obe::collision
         transform::UnitVector min_dep;
         const auto calc_min_distance_dep = [this](const std::vector<transform::UnitVector>& sol1,
                                                const std::vector<transform::UnitVector>& sol2,
-                  const transform::UnitVector& t_offset)
+                                               const transform::UnitVector& t_offset)
             -> std::tuple<double, transform::UnitVector, bool>
         {
             double min_distance = -1;
@@ -256,10 +256,15 @@ namespace obe::collision
     {
         // TODO: handle rotation
         auto [min_x, max_x] = std::minmax_element(m_points.begin(), m_points.end(),
-                [](auto& point1, auto& point2) { return point1.x < point2.x; });
-        auto [min_y, max_y]
-            = std::minmax_element(m_points.begin(), m_points.end(),
-                [](auto& point1, auto& point2) { return point1.y < point2.y; });
+            [](auto& point1, auto& point2)
+            {
+                return point1.x < point2.x;
+            });
+        auto [min_y, max_y] = std::minmax_element(m_points.begin(), m_points.end(),
+            [](auto& point1, auto& point2)
+            {
+                return point1.y < point2.y;
+            });
         const double width = max_x->x - min_x->x;
         const double height = max_y->y - min_y->y;
         return transform::AABB(

src/Core/Collision/PolygonCollider.cpp

@@ -55,10 +55,16 @@ namespace obe::collision
         const auto verts_span = std::span { m_shape.verts };
         auto [min_x, max_x]
             = std::minmax_element(verts_span.begin(), verts_span.begin() + m_shape.count,
-                [](auto& point1, auto& point2) { return point1.x < point2.x; });
+                [](auto& point1, auto& point2)
+                {
+                    return point1.x < point2.x;
+                });
         auto [min_y, max_y]
             = std::minmax_element(verts_span.begin(), verts_span.begin() + m_shape.count,
-                [](auto& point1, auto& point2) { return point1.y < point2.y; });
+                [](auto& point1, auto& point2)
+                {
+                    return point1.y < point2.y;
+                });
         const double width = max_x->x - min_x->x;
         const double height = max_y->y - min_y->y;
         return transform::AABB(

src/Core/Collision/Quadtree.cpp

@@ -147,8 +147,8 @@ namespace obe::collision
             auto i = get_quadrant(box, value->get_bounding_box());
             if (i != -1)
             {
-                if (remove_internal(node->children[static_cast<std::size_t>(i)].get(), compute_box(box, i),
-                        value))
+                if (remove_internal(node->children[static_cast<std::size_t>(i)].get(),
+                        compute_box(box, i), value))
                     return try_merge(node);
             }
             // Otherwise, we remove the value from the current node
@@ -162,7 +162,10 @@ namespace obe::collision
     {
         // Find the value in node->values
         auto it = std::find_if(std::begin(node->values), std::end(node->values),
-            [this, &value](const auto& rhs) { return value == rhs; });
+            [this, &value](const auto& rhs)
+            {
+                return value == rhs;
+            });
         assert(it != std::end(node->values)
             && "Trying to remove a value that is not present in the node");
         // Swap with the last element and pop back

src/Core/Collision/TrajectoryNode.cpp

@@ -57,7 +57,8 @@ namespace obe::collision
 
     void TrajectoryNode::update(const double dt) const
     {
-        auto get_offset = [&dt](const Trajectory& trajectory) {
+        auto get_offset = [&dt](const Trajectory& trajectory)
+        {
             const double speed = trajectory.get_speed() + trajectory.get_acceleration() * dt;
             const double rad_angle = (utils::math::pi / 180.0) * -trajectory.get_angle();
             const double x_offset = std::cos(rad_angle) * (speed * dt);

src/Core/Debug/Render.cpp

@@ -29,7 +29,10 @@ namespace obe::debug::render
 
             std::transform(polygon_points.begin(), polygon_points.end(),
                 std::back_inserter(pixel_points),
-                [](const auto& point) { return point.to(transform::Units::ScenePixels); });
+                [](const auto& point)
+                {
+                    return point.to(transform::Units::ScenePixels);
+                });
 
             for (const transform::UnitVector& point : pixel_points)
             {
@@ -110,16 +113,17 @@ namespace obe::debug::render
         target.draw(shape);
     }
 
-    void draw_collider(const graphics::RenderTarget target, const collision::ColliderComponent& collider,
-        const ColliderRenderOptions& render_options)
+    void draw_collider(const graphics::RenderTarget target,
+        const collision::ColliderComponent& collider, const ColliderRenderOptions& render_options)
     {
         switch (collider.get_collider_type())
         {
         case collision::ColliderType::Collider:
             break;
         case collision::ColliderType::Circle:
             draw_circle_collider(target,
-                *static_cast<const collision::CircleCollider*>(collider.get_inner_collider()), render_options);
+                *static_cast<const collision::CircleCollider*>(collider.get_inner_collider()),
+                render_options);
             break;
         case collision::ColliderType::Rectangle:
             draw_rectangle_collider(target,
@@ -136,7 +140,7 @@ namespace obe::debug::render
                 *static_cast<const collision::PolygonCollider*>(collider.get_inner_collider()),
                 render_options);
             break;
-        default: ;
+        default:;
         }
     }
 }

src/Core/Event/EventManager.cpp

@@ -23,9 +23,11 @@ namespace obe::event
                 }
             }
         }
-        m_schedulers.erase(
-            std::remove_if(m_schedulers.begin(), m_schedulers.end(),
-                [](auto& scheduler) { return scheduler->m_state == CallbackSchedulerState::Done; }),
+        m_schedulers.erase(std::remove_if(m_schedulers.begin(), m_schedulers.end(),
+                               [](auto& scheduler)
+                               {
+                                   return scheduler->m_state == CallbackSchedulerState::Done;
+                               }),
             m_schedulers.end());
     }
 

src/Core/Graphics/Canvas.cpp

@@ -185,7 +185,10 @@ namespace obe::graphics::canvas
     void Canvas::sort_elements()
     {
         std::sort(m_elements.begin(), m_elements.end(),
-            [](const auto& elem1, const auto& elem2) { return elem1->layer > elem2->layer; });
+            [](const auto& elem1, const auto& elem2)
+            {
+                return elem1->layer > elem2->layer;
+            });
     }
 
     Canvas::Canvas(unsigned int width, unsigned int height)
@@ -230,7 +233,11 @@ namespace obe::graphics::canvas
 
     void Canvas::remove(const std::string& id)
     {
-        std::erase_if(m_elements, [&id](auto& elem) { return elem->get_id() == id; });
+        std::erase_if(m_elements,
+            [&id](auto& elem)
+            {
+                return elem->get_id() == id;
+            });
     }
 
     Texture Canvas::get_texture() const

src/Core/Graphics/Color.cpp

@@ -322,7 +322,11 @@ namespace obe::graphics
 
     bool Color::from_name(std::string name, bool strict)
     {
-        std::for_each(name.begin(), name.end(), [](char& c) { c = std::tolower(c); });
+        std::for_each(name.begin(), name.end(),
+            [](char& c)
+            {
+                c = std::tolower(c);
+            });
         if (const auto& color = ColorNames.find(name); color != ColorNames.end())
         {
             this->r = color->second.r;
@@ -512,7 +516,10 @@ namespace obe::graphics
     std::optional<std::string> Color::to_name() const
     {
         auto it = std::find_if(ColorNames.begin(), ColorNames.end(),
-            [this](const std::pair<std::string, Color>& color) { return color.second == *this; });
+            [this](const std::pair<std::string, Color>& color)
+            {
+                return color.second == *this;
+            });
         if (it != ColorNames.end())
         {
             return it->first;