set minimum delta time to 60fps

src/engine/engine.cpp

@@ -19,8 +19,8 @@ bool Engine::next_frame()
     SDL_UpdateWindowSurface(window_handle);
 
     delta_second = static_cast<double>(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - last_frame_time).count()) / 1000000.0;
-    //clamp delta seconds to avoid physic issues during freezes
-    delta_second    = std::min(1 / 20.0, delta_second);
+    //clamp delta seconds to avoid physic issues during freezes. (minimum framerate is 60fps)
+    delta_second    = std::min(1 / 60.0, delta_second);
     last_frame_time = std::chrono::steady_clock::now();
     SDL_FillRect(surface_handle, nullptr, 0x000000);
     return !close;

src/engine/event_manager.hpp

@@ -5,68 +5,72 @@
 // Usage : declare a delegate type using the appropriate macro : DECLARE_DELEGATE_TYPE(EventMyDelegate), then declare a property using this type.
 // Ex :
 //
-// DECLARE_DELEGATE_MULTICAST(MyEvent, int, double);
+// DECLARE_DELEGATE_MULTICAST(MyEvent, int, double); // Declare the type of the event
 //
-// MyEvent on_my_event;
+// MyEvent on_my_event; // Event instance
 //
 // struct Foo {
-//   void foo(int a, double b) {}
+//   void foo(int a, double b) {} // a dummy method we want to be called when event is trigger
 // }
 //
 // int main() {
 //   Foo foo;
 //   on_my_event.add_object(&foo, &Foo::foo);
-//   on_my_event.add_lambda([&](int a, double b) {});
+//   on_my_event.add_lambda([&](int a, double b) {}); // same, but with a lambda method. Multiple objects or lambda can be bound to the same event
 //
-//   on_my_event.execute(1, 4.0);
+//   on_my_event.execute(1, 4.0); // trigger event
 // }
 //
+// Inspired from Unreal Engine's system @EpicGame
+// 
 
-#include <cassert>
 #include <memory>
 #include <vector>
 
-#define DECLARE_DELEGATE_SINGLECAST(name, ...)                    using name = DelegateSingleCast<void, __VA_ARGS__>;
-#define DECLARE_DELEGATE_SINGLECAST_RETURN(name, returnType, ...) typedef DelegateSingleCast<returnType, __VA_ARGS__> name;
 #define DECLARE_DELEGATE_MULTICAST(name, ...)                     using name = DelegateMultiCast<__VA_ARGS__>;
 
+// Wrapper classes for lambda and methods
 template <typename Return_T, typename... Args_T> class DelegateFunctionPtrWrapper
 {
-  public:
-    virtual Return_T execute(Args_T&...)           = 0;
+public:
+    virtual Return_T execute(Args_T&...) = 0;
     virtual bool     operator==(const void*) const = 0;
 };
 
 template <typename... Args_T> class ILambdaClassStorage
 {
-  public:
-    ILambdaClassStorage()                     = default;
-    virtual void execute(Args_T&&... in_args) = 0;
+public:
+    ILambdaClassStorage() = default;
+    virtual void execute(Args_T&&...in_args) = 0;
 };
 
 template <typename Lambda_T, typename... Args_T> class TLambdaClassStorage final : public ILambdaClassStorage<Args_T...>
 {
-  public:
-    TLambdaClassStorage(Lambda_T in_lambda) : lambda_expression(in_lambda)
+public:
+    TLambdaClassStorage(Lambda_T in_lambda)
+        : lambda_expression(in_lambda)
     {
     }
-    void execute(Args_T&&... in_args) override
+
+    void execute(Args_T&&...in_args) override
     {
         lambda_expression(std::forward<Args_T>(in_args)...);
     }
 
-  private:
+private:
     Lambda_T lambda_expression;
 };
 
+// Reference to function and corresponding object instance are stored
 template <typename ObjectClass_T, typename Return_T, typename... Args_T> class DelegateFunctionPtr final : public DelegateFunctionPtrWrapper<Return_T, Args_T...>
 {
-  public:
-    DelegateFunctionPtr(ObjectClass_T* objPtr, Return_T (ObjectClass_T::*funcPtr)(Args_T...)) : object_ptr(objPtr), function_ptr(funcPtr)
+public:
+    DelegateFunctionPtr(ObjectClass_T* objPtr, Return_T (ObjectClass_T::*funcPtr)(Args_T ...))
+        : object_ptr(objPtr), function_ptr(funcPtr)
     {
     }
 
-    Return_T execute(Args_T&... inArgs)
+    Return_T execute(Args_T&...inArgs)
     {
         return (object_ptr->*function_ptr)(inArgs...);
     }
@@ -76,48 +80,21 @@ template <typename ObjectClass_T, typename Return_T, typename... Args_T> class D
         return object_ptr == objPtr;
     }
 
-  private:
-    ObjectClass_T* object_ptr;
-    Return_T (ObjectClass_T::*function_ptr)(Args_T...);
-};
-
-template <typename Return_T, typename... Args_T> class DelegateSingleCast final
-{
-  public:
-    ~DelegateSingleCast()
-    {
-        clear();
-    }
-
-    template <typename ObjectClass_T> void bind(ObjectClass_T* inObjPtr, Return_T (ObjectClass_T::*inFunc)(Args_T...))
-    {
-        function_ptr = std::make_shared<DelegateFunctionPtr<ObjectClass_T, Return_T, Args_T...>>(inObjPtr, inFunc);
-    }
-
-    void clear()
-    {
-        function_ptr = nullptr;
-    }
-
-    Return_T execute(Args_T&... inArgs)
-    {
-        assert(function_ptr);
-        return function_ptr->execute(inArgs...);
-    }
-
-  private:
-    std::shared_ptr<DelegateFunctionPtrWrapper<Return_T, Args_T...>> function_ptr = nullptr;
+private:
+    ObjectClass_T*            object_ptr;
+    Return_T (ObjectClass_T::*function_ptr)(Args_T ...);
 };
 
+// Main delegate class
 template <typename... Args_T> class DelegateMultiCast final
 {
-  public:
+public:
     ~DelegateMultiCast()
     {
         clear();
     }
 
-    template <typename ObjectClass_T> void add_object(ObjectClass_T* inObjPtr, void (ObjectClass_T::*inFunc)(Args_T...))
+    template <typename ObjectClass_T> void add_object(ObjectClass_T* inObjPtr, void (ObjectClass_T::*inFunc)(Args_T ...))
     {
         functions.push_back(std::make_shared<DelegateFunctionPtr<ObjectClass_T, void, Args_T...>>(inObjPtr, inFunc));
     }
@@ -136,25 +113,20 @@ template <typename... Args_T> class DelegateMultiCast final
     void clear_object(void* ObjPtr)
     {
         for (int64_t i = functions.size() - 1; i >= 0; --i)
-        {
             if (*functions[i] == ObjPtr)
                 functions.erase(functions.begin() + i);
-        }
     }
 
-    void execute(Args_T... inArgs)
+    void execute(Args_T ...inArgs)
     {
         for (const auto& fct : functions)
-        {
             fct->execute(inArgs...);
-        }
+
         for (const auto& lambda : lambda_expressions)
-        {
             lambda->execute(std::forward<Args_T>(inArgs)...);
-        }
     }
 
-  private:
+private:
     std::vector<std::shared_ptr<DelegateFunctionPtrWrapper<void, Args_T...>>> functions;
     std::vector<std::shared_ptr<ILambdaClassStorage<Args_T...>>>              lambda_expressions;
-};
\ No newline at end of file
+};

src/engine/format.hpp

@@ -4,8 +4,8 @@
 #include <string>
 #include <vector>
 
-// std format replacement
-// #define format format_2
+// std::format replacement
+// As std::format is still not implemented on every compiler, we quickly implemented our own version (format parsing is done at runtime, so performances are not as good as stl's one)
 
 namespace std
 {

src/game/pacman_gamemode.cpp

@@ -8,6 +8,7 @@
 #include "engine/sprite_sheet.hpp"
 #include "engine/terrain.hpp"
 
+#include <cassert>
 #include <SDL.h>
 #include <SDL_surface.h>