Used config for a lot of things

include/Engine/Network/Client.h

@@ -57,12 +57,12 @@ private:
     std::unordered_map<EntityID, EntityID> m_ClientIDToServerID;
 
     // Network logic
-    PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
+    PlayerDefinition m_PlayerDefinitions[8];
     SnapshotDefinitions m_NextSnapshot;
     double m_DurationOfPingTime;
     std::clock_t m_StartPingTime;
     std::clock_t m_TimeSinceSentInputs;
-    unsigned int m_SendInputIntervalMs = 33;
+    unsigned int m_SendInputIntervalMs;
     std::vector<Events::InputCommand> m_InputCommandBuffer;
 
     // Private member functions

include/Engine/Network/Network.h

@@ -7,12 +7,12 @@
 #include "Core/EventBroker.h"
 #include "Network/Packet.h"
 #include "Network/NetworkData.h"
+#include "Core/ResourceManager.h"
+#include "Core/ConfigFile.h"
 #include <fstream>
 #include <iostream>
 
-#define MAXCONNECTIONS 8
 #define INPUTSIZE 4097
-#define TIMEOUTMS 15000
 
 class Network
 {
@@ -26,8 +26,11 @@ protected:
     NetworkData m_NetworkData;
     unsigned int m_SaveDataIntervalMs = 1000;
     std::clock_t m_SaveDataTimer;
+    unsigned int m_MaxConnections;
+    unsigned int m_TimeoutMs;
     void saveToFile();
     void updateNetworkData();
+    void initialize();
 };
 
 #endif

include/Engine/Network/Server.h

@@ -30,7 +30,7 @@ private:
     boost::asio::ip::udp::socket m_Socket;
 
     // Sending messages to client logic
-    PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
+    PlayerDefinition m_PlayerDefinitions[8]; // 
     std::vector<PlayerDefinition> m_ConnectedUsers;
     char readBuffer[INPUTSIZE] = { 0 };
     int bytesRead = 0;
@@ -39,8 +39,8 @@ private:
     std::clock_t previousSnapshotMessage = std::clock();
     std::clock_t timOutTimer = std::clock();
     // How often we send messages (milliseconds)
-    int intervalMs = 1000;
+    int pingIntervalMs;
-    int snapshotInterval = 50;
+    int snapshotInterval;
     int checkTimeOutInterval = 100;
 
     //Timers

include/Game/Systems/InterpolationSystem.h

@@ -10,11 +10,11 @@
 #include "Common.h"
 #include "Core/System.h"
 #include "Core/EventBroker.h"
+#include "Core/ResourceManager.h"
+#include "Core/ConfigFile.h"
 
 #include "Network/EInterpolate.h"
 
-#define SNAPSHOTINTERVAL 0.05f
-
 class InterpolationSystem : public PureSystem
 {
     struct Transform 
@@ -29,6 +29,8 @@ public:
         : System(world, eventBroker)
         , PureSystem("Transform")
     {
+        ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+        m_SnapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05);
         EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
     }
     ~InterpolationSystem() { }
@@ -42,9 +44,10 @@ private:
     T vectorInterpolation(T prev, T next, double currentTime)
     {
         T difference = next - prev;
-        T vector = (difference / SNAPSHOTINTERVAL) * static_cast<float>(currentTime);
+        T vector = (difference / m_SnapshotInterval) * static_cast<float>(currentTime);
         return vector;
     }
+    float m_SnapshotInterval;
 
     EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
     bool InterpolationSystem::OnInterpolate(const Events::Interpolate& e);

resources/DefaultConfig.ini

@@ -19,6 +19,11 @@ IsServer=false
 Name=Bob
 Address=127.0.0.1
 Port=13
+MaxConnections=8
+SnapshotInterval=0.05
+SendInputIntervalMs=33
+PingIntervalMs= 1000
+TimeoutMs=15000
 
 [Multithreading]
 ResourceLoading=true

src/Engine/Network/Client.cpp

@@ -5,6 +5,8 @@ using namespace boost::asio::ip;
 
 Client::Client(ConfigFile* config) : m_Socket(m_IOService)
 {
+    Network::initialize();
+
     // Asumes root node is EntityID 0
     insertIntoServerClientMaps(0, 0);
     // Init timer
@@ -15,6 +17,8 @@ Client::Client(ConfigFile* config) : m_Socket(m_IOService)
     m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
     // Set up network stream
     m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
+    m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
+
 }
 
 Client::~Client()
@@ -316,7 +320,7 @@ bool Client::hasServerTimedOut()
 {
     // Time in ms
     float timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
-    if (timeSincePing > TIMEOUTMS) {
+    if (timeSincePing > m_TimeoutMs) {
         // Clear everything and go to menu.
         LOG_INFO("Server has timed out, returning to menu, Beep Boop.");
         m_IsConnected = false;

src/Engine/Network/Network.cpp

@@ -58,4 +58,11 @@ void Network::updateNetworkData()
         m_NetworkData.DataSentThisInterval = 0;
         m_NetworkData.DataReceivedThisInterval = 0;
     }
-}
+}
+
+void Network::initialize()
+{ 
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_MaxConnections = config->Get<int>("Networking.MaxConnections", 8);
+    m_TimeoutMs = config->Get<int>("Networking.TimeoutMs", 20000);
+}

src/Engine/Network/Server.cpp

@@ -1,7 +1,13 @@
 #include "Network/Server.h"
 
 Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 13))
-{ }
+{
+    Network::initialize();
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05);
+    pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
+
+}
 
 Server::~Server()
 {
@@ -14,7 +20,7 @@ void Server::Start(World* world, EventBroker* eventBroker)
     m_EventBroker = eventBroker;
     // Subscribe to events
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Server::OnInputCommand);
-    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+    for (size_t i = 0; i < m_MaxConnections; i++) {
         m_PlayerDefinitions[i].StopTime = std::clock();
     }
     LOG_INFO("I am Server. BIP BOP\n");
@@ -49,7 +55,7 @@ void Server::readFromClients()
     }
 
     // Send pings each 
-    if (intervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
         sendPing();
         previousePingMessage = currentTime;
     }
@@ -210,7 +216,7 @@ void Server::checkForTimeOuts()
         if (m_ConnectedUsers[i].Endpoint.address() != boost::asio::ip::address()) {
             int stopPing = 1000 * m_ConnectedUsers[i].StopTime /
                 static_cast<double>(CLOCKS_PER_SEC);
-            if (startPing > stopPing + TIMEOUTMS) {
+            if (startPing > stopPing + m_TimeoutMs) {
                 LOG_INFO("User %i timed out!", i);
                 disconnect(i);
             }
@@ -239,7 +245,7 @@ void Server::parseOnInputCommand(Packet& packet)
 {
     int playerID = -1;
     // Check which player it was who sent the message
-    for (int i = 0; i < MAXCONNECTIONS; i++) {
+    for (int i = 0; i < m_MaxConnections; i++) {
         // if the player is connected set playerID to the correct PlayerID
         if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()
             && m_PlayerDefinitions[i].Endpoint.port() == m_ReceiverEndpoint.port()) {
@@ -364,7 +370,7 @@ void Server::createPlayer()
         LOG_WARNING("Not a recognized user!");
         return;
     }
-    for (int playerIndex = 0; playerIndex < MAXCONNECTIONS; playerIndex++) {
+    for (int playerIndex = 0; playerIndex < m_MaxConnections; playerIndex++) {
         if (m_PlayerDefinitions[playerIndex].Endpoint.address() == boost::asio::ip::address()) {
             m_PlayerDefinitions[playerIndex] = m_ConnectedUsers[userIndex];
             EntityID entityID = m_World->CreateEntity();
@@ -384,7 +390,7 @@ void Server::createPlayer()
 
 int Server::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
 {
-    for (int i = 0; i < MAXCONNECTIONS; i++) {
+    for (int i = 0; i < m_MaxConnections; i++) {
         if (m_PlayerDefinitions[i].Endpoint.address() == endpoint.address() &&
             m_PlayerDefinitions[i].Endpoint.port() == endpoint.port()) {
             return i;

src/Game/Systems/InterpolationSystem.cpp

@@ -1,35 +1,15 @@
 #include "Systems/InterpolationSystem.h"
 
-//void InterpolationSystem::UpdateComponent(World * world, ComponentWrapper & transform, double dt)
-//{
-//    if (m_InterpolationPoints[transform.EntityID].size() > 0) {
-//        Transform& sTransform = m_InterpolationPoints[transform.EntityID].front();
-//        sTransform.interpolationTime += dt;
-//        if (sTransform.interpolationTime > 0.05) {
-//            double time = std::fmod(sTransform.interpolationTime, 0.05f);
-//            m_InterpolationPoints[transform.EntityID].pop();
-//            if (m_InterpolationPoints[transform.EntityID].size() <= 0) {
-//                return;
-//            }
-//            sTransform = m_InterpolationPoints[transform.EntityID].front();
-//            sTransform.interpolationTime = time;
-//        }
-//        glm::vec3 nextPosition = sTransform.Position;
-//        glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
-//        transform["Position"] = vectorInterpolation(currentPosition, nextPosition, sTransform.interpolationTime);
-//    }
-//}
-
 void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt)
 {
     if (m_NextTransform.find(transform.EntityID) != m_NextTransform.end()) { // Exists in map
         m_NextTransform[transform.EntityID].interpolationTime += dt;
         Transform sTransform = m_NextTransform[transform.EntityID];
         double time = sTransform.interpolationTime;
-        if (time > SNAPSHOTINTERVAL) {
+        if (time > m_SnapshotInterval) {
             if (m_LastReceivedTransform.find(transform.EntityID) != m_LastReceivedTransform.end()) {
                 m_NextTransform[transform.EntityID] = m_LastReceivedTransform[transform.EntityID];
-                m_NextTransform[transform.EntityID].interpolationTime = time - SNAPSHOTINTERVAL;
+                m_NextTransform[transform.EntityID].interpolationTime = time - m_SnapshotInterval;
                 sTransform = m_NextTransform[transform.EntityID];
                 m_LastReceivedTransform.erase(transform.EntityID);
             } else {
@@ -44,7 +24,7 @@ void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
             // Orientation
             glm::quat nextOrientation = sTransform.Orientation;
             glm::quat currentOrientation = glm::quat(static_cast<glm::vec3>(transform["Orientation"]));
-            (glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / SNAPSHOTINTERVAL));
+            (glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / m_SnapshotInterval));
             // Scale
             glm::vec3 nextScale = sTransform.Scale;
             glm::vec3 currentScale = static_cast<glm::vec3>(transform["Scale"]);
@@ -72,15 +52,5 @@ bool InterpolationSystem::OnInterpolate(const Events::Interpolate & e)
     } else { // Did not
         m_NextTransform[e.Entity] = transform;
     }
-    // Check if queue already exists
-    //if (m_InterpolationPoints.find(e.Entity) != m_InterpolationPoints.end()) { // Did exist, push to queue
-    //    m_InterpolationPoints[e.Entity].push(transform);
-    //} 
-
-    //else { // Did not exist, create queue
-    //    std::queue<Transform> transformQueue;
-    //    transformQueue.push(transform);
-    //    m_InterpolationPoints[e.Entity] = transformQueue;
-    //}
     return false;
 }