Major networking refactoring to allow for snapshot filtering outside of netcode

include/Game/ExplosionEffectSystem.h

@@ -1,24 +0,0 @@
-#include "Common.h"
-#include "Core/System.h"
-
-class ExplosionEffectSystem : public PureSystem
-{
-public:
-    ExplosionEffectSystem(SystemParams params)
-        : System(params)
-        , PureSystem("ExplosionEffect")
-    { }
-
-    virtual void  UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
-    {
-
-        if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
-            (double)component["TimeSinceDeath"] = 0.f;
-        }
-        (double&)component["TimeSinceDeath"] += dt;
-
-        //if ((bool)Component["Gravity"] == true) {
-        //    (bool)Component["ExponentialAccelaration"] = false;
-        //}
-    }
-};

include/Game/Game.h

@@ -1,6 +1,8 @@
 #ifndef Game_h__
 #define Game_h__
 
+#include <boost/program_options.hpp>
+
 #include "Core/ResourceManager.h"
 #include "Core/ConfigFile.h"
 #include "Core/EventBroker.h"
@@ -14,7 +16,7 @@
 #include "Core/EKeyDown.h"
 #include "Core/EntityFilePreprocessor.h"
 #include "Core/SystemPipeline.h"
-#include "ExplosionEffectSystem.h"
+#include "Systems/ExplosionEffectSystem.h"
 #include "Editor/EditorSystem.h"
 #include "Core/EntityFile.h"
 #include "Rendering/RenderSystem.h"
@@ -42,7 +44,9 @@ public:
 	void Tick();
 
 private:
-	double m_LastTime;
+    std::string m_NetworkAddress;
+    int m_NetworkPort;
+
 	ConfigFile* m_Config = nullptr;
 	EventBroker* m_EventBroker;
 	IRenderer* m_Renderer;
@@ -55,13 +59,15 @@ private:
     Octree<EntityAABB>* m_OctreeFrustrumCulling;
     SystemPipeline* m_SystemPipeline;
     RenderFrame* m_RenderFrame;
-    Network* m_Network = nullptr;
+    Client* m_NetworkClient = nullptr;
+    Server* m_NetworkServer = nullptr;
+    SoundSystem* m_SoundSystem;
+	double m_LastTime;
 
     bool m_IsClient = false;
     bool m_IsServer = false;
 
-    // Sound
-    SoundSystem* m_SoundSystem;
+    int parseArgs(int argc, char* argv[]);
 };
 
 #endif

include/Game/Network/MultiplayerSnapshotFilter.h

@@ -0,0 +1,25 @@
+#ifndef MultiplayerSnapshotFilter_h__
+#define MultiplayerSnapshotFilter_h__
+
+#include "Core/EventBroker.h"
+#include "Core/EPlayerSpawned.h"
+#include "Network/SnapshotFilter.h"
+#include "Network/EInterpolate.h"
+
+class MultiplayerSnapshotFilter : public SnapshotFilter
+{
+public:
+    MultiplayerSnapshotFilter(EventBroker* eventBroker);
+
+    virtual bool FilterComponent(EntityWrapper entity, SharedComponentWrapper& component) override;
+
+private:
+    EventBroker* m_EventBroker;
+
+    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
+
+    EventRelay<MultiplayerSnapshotFilter, Events::PlayerSpawned> m_EPlayerSpawned;
+    bool OnPlayerSpawned(Events::PlayerSpawned ePlayerSpawned);
+};
+
+#endif

include/Game/Systems/ExplosionEffectSystem.h

@@ -0,0 +1,18 @@
+#ifndef ExplosionEffectSystem_h__
+#define ExplosionEffectSystem_h__
+
+#include "Common.h"
+#include "Core/System.h"
+
+class ExplosionEffectSystem : public PureSystem
+{
+public:
+    ExplosionEffectSystem(SystemParams params)
+        : System(params)
+        , PureSystem("ExplosionEffect")
+    { }
+
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+};
+
+#endif

include/Game/Systems/InterpolationSystem.h

@@ -18,6 +18,13 @@
 
 class InterpolationSystem : public PureSystem
 {
+public:
+    InterpolationSystem(SystemParams params);
+    ~InterpolationSystem() { }
+
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
+
+private:
     struct Transform 
     {
         glm::vec3 Position;
@@ -25,27 +32,22 @@ class InterpolationSystem : public PureSystem
         glm::quat Orientation;
         float interpolationTime;
     };
-public:
-    InterpolationSystem(SystemParams params);
-    ~InterpolationSystem() { }
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
-private:
+
     std::unordered_map<EntityID, Transform> m_NextTransform;
     std::unordered_map<EntityID, Transform> m_LastReceivedTransform;
     EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
 
-    //glm::vec3 vectorInterpolation(glm::vec3 prev, glm::vec3 next, double currentTime);
     template <typename T>
     T vectorInterpolation(T prev, T next, double currentTime)
     {
         T difference = next - prev;
-        T vector = (difference / m_SnapshotInterval) * static_cast<float>(currentTime);
+        T vector = difference * (static_cast<float>(currentTime) / m_SnapshotInterval);
         return vector;
     }
     float m_SnapshotInterval;
 
     EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
-    bool InterpolationSystem::OnInterpolate(const Events::Interpolate& e);
+    bool InterpolationSystem::OnInterpolate(Events::Interpolate& e);
     EventRelay<InterpolationSystem, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };