flake parts

src/include/utils/Events/BasicEvents.h

@@ -0,0 +1,88 @@
+#ifndef BASICEVENTS_H
+#define BASICEVENTS_H
+
+#include "Event.h"
+
+namespace Archimedes {
+
+    class Module;
+
+    class AnonymousEvent : public Event {
+
+        public:
+
+            AnonymousEvent() {}
+            
+            AnonymousEvent(std::any data) : Event(data) {}
+
+            ~AnonymousEvent() {}
+
+            operator std::string() const override { return "AnonymousEvent"; }
+
+    };
+
+    class LoadModuleEvent : public Event {
+
+        public:
+
+            LoadModuleEvent() {}
+            
+            LoadModuleEvent(std::string n) : module(n) {}
+
+            ~LoadModuleEvent() {}
+
+            operator std::string() const override { return "LoadModuleEvent"; }
+
+            std::string module;
+
+    };
+
+    class DoLoadModuleEvent : public Event {
+
+        public:
+
+            DoLoadModuleEvent() {}
+            
+            DoLoadModuleEvent(std::variant<std::string, Module*> n) : module(n) {}
+
+            ~DoLoadModuleEvent() {}
+
+            operator std::string() const override { return "DoLoadModuleEvent"; }
+
+            std::variant<std::string, Module*> module;
+
+    };
+ 
+    class UnloadModuleEvent : public Event {
+
+        public:
+            
+            UnloadModuleEvent() {}
+            
+            UnloadModuleEvent(std::string n) : module(n) {}
+
+            ~UnloadModuleEvent() {}
+
+            operator std::string() const override { return "UnloadModuleEvent"; }
+
+            std::string module;
+    };
+    
+    class DoUnloadModuleEvent : public Event {
+
+        public:
+
+            DoUnloadModuleEvent() {}
+            
+            DoUnloadModuleEvent(std::string n) : module(n) {}
+
+            ~DoUnloadModuleEvent() {}
+
+            operator std::string() const override { return "DoUnloadModuleEvent"; }
+
+            std::string module;
+
+    };   
+}
+
+#endif

src/include/utils/Events/Event.h

@@ -0,0 +1,25 @@
+#ifndef EVENT_H
+#define EVENT_H
+
+#include "pch.hpp"
+
+namespace Archimedes {
+
+    class Event {
+
+        public:
+
+            Event() {}
+            Event(std::any data) : userData(data) {}
+
+            virtual ~Event() {}
+
+            virtual operator std::string() const = 0;
+
+            std::any userData;
+    };
+}
+
+#include "BasicEvents.h"
+
+#endif

src/include/utils/Events/NetworkEvents.h

@@ -0,0 +1,59 @@
+#ifndef NETWORKEVENTS_H
+#define NETWORKEVENTS_H
+
+#include "Event.h"
+
+#include <steam/steamnetworkingsockets.h>
+#include <steam/isteamnetworkingutils.h>
+
+namespace Archimedes {
+
+    class DataRecievedEvent : public Event {
+
+        public:
+
+            DataRecievedEvent() : Event(nullptr), msg(nullptr) {}
+
+            DataRecievedEvent(ISteamNetworkingMessage* m) : Event(nullptr), msg(m) {}
+
+            ~DataRecievedEvent() {
+                if(msg)
+                    msg->Release();
+            }
+
+            operator std::string() const override { return "DataRecievedEvent"; }
+
+            ISteamNetworkingMessage* msg;
+
+    };
+
+    class DataSentEvent : public Event {
+
+        public:
+
+            DataSentEvent() : Event(nullptr), msg(nullptr) {}
+
+            DataSentEvent(const void* m, uint32 l) : Event(nullptr), msg(m), length(l) {}
+
+            operator std::string() const override { return "DataSentEvent"; }
+
+            const void* msg;
+            uint32 length;
+    };
+
+    class ConnectionStatusChangedEvent : public Event {
+
+        public:
+
+            ConnectionStatusChangedEvent() : Event(nullptr), info(nullptr) {}
+
+            ConnectionStatusChangedEvent(SteamNetConnectionStatusChangedCallback_t* i) : Event(nullptr), info(i) {}
+
+            operator std::string() const override { return "ConnectionStatusChangedEvent"; }
+
+            SteamNetConnectionStatusChangedCallback_t* info;
+    };
+
+}
+
+#endif