Merge pull request #74 from teamfisk/Warnings-Jocke

Fixed warnings associated with Network

include/Engine/Network/Client.h

@@ -36,7 +36,7 @@ private:
     boost::asio::ip::udp::socket m_Socket;
 
     // Sending message to server logic
-    int bytesRead = -1;
+    size_t bytesRead = 0;
     char readBuf[INPUTSIZE] = { 0 };
 
     // Packet loss logic
@@ -69,7 +69,7 @@ private:
 
     // Private member functions
     void readFromServer();
-    int  receive(char* data);
+    size_t  receive(char* data);
     void send(Packet& packet);
     void connect();
     void disconnect();

include/Engine/Network/Network.h

@@ -29,7 +29,7 @@ protected:
     unsigned int m_SaveDataIntervalMs = 1000;
     std::clock_t m_SaveDataTimer;
     unsigned int m_MaxConnections;
-    unsigned int m_TimeoutMs;
+    double m_TimeoutMs;
     void saveToFile();
     void updateNetworkData();
     void initialize();

include/Engine/Network/NetworkData.h

@@ -3,16 +3,16 @@
 #include <vector>
 
 struct NetworkData {
-    unsigned int TotalTime = 0;
+    double TotalTime = 0;
-    unsigned int TotalDataReceived = 0;
+    size_t TotalDataReceived = 0;
-    unsigned int TotalDataSent = 0;
+    size_t TotalDataSent = 0;
-    unsigned int AmountOfMessagesReceived = 0;
+    size_t AmountOfMessagesReceived = 0;
     unsigned int AmountOfMessagesSent = 0;
     // Interval based
-    unsigned int DataReceivedThisInterval = 0;
+    size_t DataReceivedThisInterval = 0;
-    unsigned int DataSentThisInterval = 0;
+    size_t DataSentThisInterval = 0;
     // pair: first=reveived, second=send 
-    std::vector<std::pair<unsigned int, unsigned int>> BandwidthBytes;
+    std::vector<std::pair<size_t, size_t>> BandwidthBytes;
 };
 
-#endif
+#endif

include/Engine/Network/Packet.h

@@ -13,7 +13,7 @@ public:
     // arg2: PacketID for identifying packet loss.
     Packet(MessageType type, unsigned int& packetID);
     // Used to create packet from already existing data buffer.
-    Packet(char* data, const int sizeOfPacket);
+    Packet(char* data, const size_t sizeOfPacket);
     Packet(MessageType type);
     ~Packet();
     void Init(MessageType type, unsigned int& packetID);
@@ -51,18 +51,18 @@ public:
     std::string ReadString();
     char* ReadData(int SizeOfData);
     void ChangePacketID(unsigned int& packetID);
-    int Size() { return m_Offset; };
+    size_t Size() { return m_Offset; };
     char* Data() { return m_Data; };
-    unsigned int DataReadSize() { return m_ReturnDataOffset; }
+    size_t DataReadSize() { return m_ReturnDataOffset; }
-    unsigned int MaxSize() { return m_MaxPacketSize; }
+    size_t MaxSize() { return m_MaxPacketSize; }
-    unsigned int HeaderSize() { return m_HeaderSize; }
+    size_t HeaderSize() { return m_HeaderSize; }
 
 private:
     char* m_Data;
-    unsigned int m_ReturnDataOffset = 0;
+    size_t m_ReturnDataOffset = 0;
-    int m_Offset = 0;
+    size_t m_Offset = 0;
-    unsigned int m_MaxPacketSize = 512;
+    size_t m_MaxPacketSize = 512;
-    unsigned int m_HeaderSize = 0;
+    size_t m_HeaderSize = 0;
     void resizeData();
 };
 

include/Engine/Network/Server.h

@@ -36,14 +36,14 @@ private:
     std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
     // HACK: Fix INPUTSIZE
     char readBuffer[INPUTSIZE] = { 0 };
-    int bytesRead = 0;
+    size_t bytesRead = 0;
     // time for previouse message
     std::clock_t previousePingMessage = std::clock();
     std::clock_t previousSnapshotMessage = std::clock();
     std::clock_t timOutTimer = std::clock();
     // How often we send messages (milliseconds)
-    int pingIntervalMs;
+    float pingIntervalMs;
-    int snapshotInterval;
+    float snapshotInterval;
     int checkTimeOutInterval = 100;
     int m_NextPlayerID = 0;
 
@@ -59,7 +59,7 @@ private:
     PacketID m_PreviousPacketID = 0;
 
     // Private member functions
-    int  receive(char* data);
+    size_t receive(char* data);
     void readFromClients();
     void send(PlayerID player, Packet& packet);
     void send(Packet& packet);

include/Game/Systems/InterpolationSystem.h

@@ -23,7 +23,7 @@ class InterpolationSystem : public PureSystem
         glm::vec3 Position;
         glm::vec3 Scale;
         glm::quat Orientation;
-        double interpolationTime;
+        float interpolationTime;
     };
 public:
     InterpolationSystem(World* world, EventBroker* eventBroker);

src/Engine/Network/Client.cpp

@@ -258,11 +258,11 @@ void Client::parseSnapshot(Packet& packet)
     }
 }
 
-int Client::receive(char* data)
+size_t Client::receive(char* data)
 {
     boost::system::error_code error;
 
-    int bytesReceived = m_Socket.receive_from(boost
+    size_t bytesReceived = m_Socket.receive_from(boost
         ::asio::buffer((void*)data, INPUTSIZE),
         m_ReceiverEndpoint,
         0, error);
@@ -390,7 +390,7 @@ void Client::identifyPacketLoss()
 bool Client::hasServerTimedOut()
 {
     // Time in ms
-    float timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
+    double timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
     if (timeSincePing > m_TimeoutMs) {
         // Clear everything and go to menu.
         LOG_INFO("Server has timed out, returning to menu, Beep Boop.");

src/Engine/Network/Network.cpp

@@ -26,10 +26,10 @@ void Network::saveToFile()
     outfile << "Total messages received," + std::to_string(m_NetworkData.AmountOfMessagesReceived) + "\n";
     outfile << "Total messages sent," + std::to_string(m_NetworkData.AmountOfMessagesSent) + "\n";
 
-    float messagesReceivedPerSec = (float)m_NetworkData.AmountOfMessagesReceived / (m_NetworkData.TotalTime / 1000);
+    double messagesReceivedPerSec = m_NetworkData.AmountOfMessagesReceived / (m_NetworkData.TotalTime / 1000);
-    float messagesSentPerSec = (float)m_NetworkData.AmountOfMessagesSent / (m_NetworkData.TotalTime / 1000);
+    double messagesSentPerSec = m_NetworkData.AmountOfMessagesSent / (m_NetworkData.TotalTime / 1000);
-    float dataReceivedPerSec = (float)m_NetworkData.TotalDataReceived / (m_NetworkData.TotalTime / 1000);
+    double dataReceivedPerSec = m_NetworkData.TotalDataReceived / (m_NetworkData.TotalTime / 1000);
-    float dataSentPerSec = (float)m_NetworkData.TotalDataSent / (m_NetworkData.TotalTime / 1000);
+    double dataSentPerSec = m_NetworkData.TotalDataSent / (m_NetworkData.TotalTime / 1000);
     outfile << "Avarage messages received / s: " + std::to_string(messagesReceivedPerSec) + "\n";
     outfile << "Avarage messages sents / s: " + std::to_string(messagesSentPerSec) + "\n";
     outfile << "Avarage data received B/s: " + std::to_string(dataReceivedPerSec) + "\n";
@@ -52,7 +52,7 @@ void Network::updateNetworkData()
     if (m_SaveDataIntervalMs < (1000 * (currentTime - m_SaveDataTimer) / (double)CLOCKS_PER_SEC)) {
         // Set values
         m_NetworkData.TotalTime += (1000 * (currentTime - m_SaveDataTimer) / (double)CLOCKS_PER_SEC);
-        m_NetworkData.BandwidthBytes.push_back(std::pair<unsigned int, unsigned int>(m_NetworkData.DataReceivedThisInterval, m_NetworkData.DataSentThisInterval));
+        m_NetworkData.BandwidthBytes.push_back(std::pair<size_t, size_t>(m_NetworkData.DataReceivedThisInterval, m_NetworkData.DataSentThisInterval));
         // Reset interval stuff
         m_SaveDataTimer = std::clock();
         m_NetworkData.DataSentThisInterval = 0;

src/Engine/Network/Packet.cpp

@@ -7,7 +7,7 @@ Packet::Packet(MessageType type, unsigned int& packetID)
 }
 
 // Create message
-Packet::Packet(char* data, const int sizeOfPacket)
+Packet::Packet(char* data, const size_t sizeOfPacket)
 {
     // Resize message
     m_MaxPacketSize = sizeOfPacket;
@@ -45,7 +45,7 @@ void Packet::Init(MessageType type, unsigned int & packetID)
 void Packet::WriteString(const std::string& str)
 {
     // Message, add one extra byte for null terminator
-    int sizeOfString = str.size() + 1;
+    size_t sizeOfString = str.size() + 1;
     if (m_Offset + sizeOfString > m_MaxPacketSize) {
         //LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size. New size is %i bytes\n", m_MaxPacketSize*2);
         resizeData();
@@ -82,7 +82,7 @@ char * Packet::ReadData(int SizeOfData)
         //LOG_WARNING("packet ReadData(): Oh no! You are trying to remove things outside my memory kingdom");
         return nullptr;
     }
-    unsigned int oldReturnDataOffset = m_ReturnDataOffset;
+    size_t oldReturnDataOffset = m_ReturnDataOffset;
     m_ReturnDataOffset += SizeOfData;
     return (m_Data + oldReturnDataOffset);
 }

src/Engine/Network/Server.cpp

@@ -4,7 +4,7 @@ Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::a
 {
     Network::initialize();
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
-    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05);
+    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
     pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
 
 }
@@ -43,7 +43,7 @@ void Server::readFromClients()
             bytesRead = receive(readBuffer);
             Packet packet(readBuffer, bytesRead);
             parseMessageType(packet);
-        } catch (const std::exception& err) {
+        } catch (const std::exception&) {
             //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
         }
     }
@@ -103,9 +103,9 @@ void Server::parseMessageType(Packet& packet)
     }
 }
 
-int Server::receive(char * data)
+size_t Server::receive(char * data)
 {
-    unsigned int length = m_Socket.receive_from(
+    size_t length = m_Socket.receive_from(
         boost::asio::buffer((void*)data
             , INPUTSIZE)
         , m_ReceiverEndpoint, 0);
@@ -121,7 +121,7 @@ int Server::receive(char * data)
 void Server::send(PlayerID player, Packet& packet)
 {
     try {
-        int bytesSent = m_Socket.send_to(
+        size_t bytesSent = m_Socket.send_to(
             boost::asio::buffer(packet.Data(), packet.Size()),
             m_ConnectedPlayers[player].Endpoint,
             0);
@@ -131,7 +131,7 @@ void Server::send(PlayerID player, Packet& packet)
             m_NetworkData.DataSentThisInterval += packet.Size();
             m_NetworkData.AmountOfMessagesSent++;
         }
-    } catch (const boost::system::system_error& e) {
+    } catch (const boost::system::system_error&) {
         // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
         m_ConnectedPlayers[player].Endpoint = boost::asio::ip::udp::endpoint();
     }
@@ -231,12 +231,12 @@ void Server::sendPing()
 
 void Server::checkForTimeOuts()
 {
-    int startPing = 1000 * m_StartPingTime
+    double startPing = 1000 * m_StartPingTime
         / static_cast<double>(CLOCKS_PER_SEC);
 
     for (int i = 0; i < m_ConnectedPlayers.size(); i++) {
         if (m_ConnectedPlayers[i].Endpoint.address() != boost::asio::ip::address()) {
-            int stopPing = 1000 * m_ConnectedPlayers[i].StopTime /
+            double stopPing = 1000 * m_ConnectedPlayers[i].StopTime /
                 static_cast<double>(CLOCKS_PER_SEC);
             if (startPing > stopPing + m_TimeoutMs) {
                 LOG_INFO("User %i timed out!", i);

src/Game/Systems/InterpolationSystem.cpp

@@ -5,7 +5,7 @@ InterpolationSystem::InterpolationSystem(World* world, EventBroker* eventBroker)
     , PureSystem("Transform")
 {
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
-    m_SnapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05);
+    m_SnapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05f);
     EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &InterpolationSystem::OnPlayerSpawned);
 }
@@ -18,9 +18,9 @@ void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
     }
 
     if (m_NextTransform.find(transform.EntityID) != m_NextTransform.end()) { // Exists in map
-        m_NextTransform[transform.EntityID].interpolationTime += dt;
+        m_NextTransform[transform.EntityID].interpolationTime += static_cast<float>(dt);
         Transform sTransform = m_NextTransform[transform.EntityID];
-        double time = sTransform.interpolationTime;
+        float time = sTransform.interpolationTime;
         if (time > m_SnapshotInterval) {
             if (m_LastReceivedTransform.find(transform.EntityID) != m_LastReceivedTransform.end()) {
                 m_NextTransform[transform.EntityID] = m_LastReceivedTransform[transform.EntityID];