Merge remote-tracking branch 'origin/Networking' into Networking

# Conflicts:
#	include/Engine/Network/Packet.h
#	src/Engine/Network/Packet.cpp

src/Engine/Input/InputProxy.cpp

@@ -62,7 +62,7 @@ void InputProxy::Process()
             e.Command = command;
             e.Value = currentValue;
             m_EventBroker->Publish(e);
-            //LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
+            LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
             m_LastCommandValues[command] = currentValue;
         }
     }
@@ -78,7 +78,7 @@ void InputProxy::Process()
         }
         //e.Value = std::max(-1.f, std::min(e.Value, 1.f));
         m_EventBroker->Publish(e);
-        //LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
+        LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
     }
     m_CommandQueue.clear();
 }

src/Engine/Network/Client.cpp

@@ -35,7 +35,7 @@ void Client::Start(World* world, EventBroker* eventBroker)
     }
     m_Socket.connect(m_ReceiverEndpoint);
     LOG_INFO("I am client. BIP BOP");
-    ReadFromServer();
+    readFromServer();
 }
 
 void Client::Update()
@@ -55,13 +55,13 @@ void Client::Update()
 void Client::Close()
 {
     if (m_WasStarted) {
-        Disconnect();
+        disconnect();
         m_ThreadIsRunning = false;
         m_EventBroker->Unsubscribe(m_EInputCommand);
     }
 }
 
-void Client::ReadFromServer()
+void Client::readFromServer()
 {
     int bytesRead = -1;
     char readBuf[1024] = { 0 };
@@ -71,23 +71,23 @@ void Client::ReadFromServer()
 
     while (m_ThreadIsRunning) {
         if (m_Socket.available()) {
-            bytesRead = Receive(readBuf, INPUTSIZE);
+            bytesRead = receive(readBuf, INPUTSIZE);
             if (bytesRead > 0) {
-                Package package(readBuf, bytesRead);
-                ParseMessageType(package);
+                Packet packet(readBuf, bytesRead);
+                parseMessageType(packet);
             }
         }
         std::clock_t currentTime = std::clock();
         if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
-            if (IsConnected()) {
-                SendSnapshotToServer();
+            if (isConnected()) {
+                sendSnapshotToServer();
             }
             previousSnapshotMessage = currentTime;
         }
     }
 }
 
-void Client::SendSnapshotToServer()
+void Client::sendSnapshotToServer()
 {
     // Reset previouse key state in snapshot.
     m_NextSnapshot.InputForward = "";
@@ -113,86 +113,86 @@ void Client::SendSnapshotToServer()
     }
 
     if (m_NextSnapshot.InputForward != "") {
-        Package package(MessageType::Event, m_SendPacketID);
-        package.AddString(m_NextSnapshot.InputForward);
-        Send(package);
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString(m_NextSnapshot.InputForward);
+        send(packet);
     } else {
-        Package package(MessageType::Event, m_SendPacketID);
-        package.AddString("0Forward");
-        Send(package);
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString("0Forward");
+        send(packet);
     }
 
     if (m_NextSnapshot.InputRight != "") {
-        Package package(MessageType::Event, m_SendPacketID);
-        package.AddString(m_NextSnapshot.InputRight);
-        Send(package);
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString(m_NextSnapshot.InputRight);
+        send(packet);
     } else {
-        Package package(MessageType::Event, m_SendPacketID);
-        package.AddString("0Right");
-        Send(package);
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString("0Right");
+        send(packet);
     }
 }
 
-void Client::ParseMessageType(Package& package)
+void Client::parseMessageType(Packet& packet)
 {
-    int messageType = package.PopFrontPrimitive<int>();
+    int messageType = packet.ReadPrimitive<int>();
     if (messageType == -1)
         return;
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
-    m_PacketID = package.PopFrontPrimitive<int>(); //Read new packet id
+    m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
     //IdentifyPacketLoss();
 
     switch (static_cast<MessageType>(messageType)) {
     case MessageType::Connect:
-        ParseConnect(package);
+        parseConnect(packet);
         break;
     case MessageType::ClientPing:
-        ParsePing();
+        parsePing();
         break;
     case MessageType::ServerPing:
-        ParseServerPing();
+        parseServerPing();
         break;
     case MessageType::Message:
         break;
     case MessageType::Snapshot:
-        ParseSnapshot(package);
+        parseSnapshot(packet);
         break;
     case MessageType::Disconnect:
         break;
     case MessageType::Event:
-        ParseEventMessage(package);
+        parseEventMessage(packet);
         break;
     default:
         break;
     }
 }
 
-void Client::ParseConnect(Package& package)
+void Client::parseConnect(Packet& packet)
 {
-    m_PlayerID = package.PopFrontPrimitive<int>();
+    m_PlayerID = packet.ReadPrimitive<int>();
     LOG_INFO("%i: I am player: %i", m_PacketID, m_PlayerID);
 }
 
-void Client::ParsePing()
+void Client::parsePing()
 {
     m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
     LOG_INFO("%i: response time with ctime(ms): %f", m_PacketID, m_DurationOfPingTime);
 }
 
-void Client::ParseServerPing()
+void Client::parseServerPing()
 {
-    Package message(MessageType::ServerPing, m_SendPacketID);
-    message.AddString("Ping recieved");
-    Send(message);
+    Packet message(MessageType::ServerPing, m_SendPacketID);
+    message.WriteString("Ping recieved");
+    send(message);
 }
 
-void Client::ParseEventMessage(Package& package)
+void Client::parseEventMessage(Packet& packet)
 {
     int Id = -1;
-    std::string command = package.PopFrontString();
+    std::string command = packet.ReadString();
     if (command.find("+Player") != std::string::npos) {
-        Id = package.PopFrontPrimitive<int>();
+        Id = packet.ReadPrimitive<int>();
         // Sett Player name
         m_PlayerDefinitions[Id].Name = command.erase(0, 7);
     } else {
@@ -200,13 +200,13 @@ void Client::ParseEventMessage(Package& package)
     }
 }
 
-void Client::ParseSnapshot(Package& package)
+void Client::parseSnapshot(Packet& packet)
 {
     std::string tempName;
     for (size_t i = 0; i < MAXCONNECTIONS; i++) {
         // We're checking for empty name for now. This might not be the best way,
         // but it is to avoid sending redundant data.
-        tempName = package.PopFrontString();
+        tempName = packet.ReadString();
 
 
         // Apply the position data read to the player entity
@@ -226,12 +226,12 @@ void Client::ParseSnapshot(Package& package)
 
             // Move player to server position
             int dataSize = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Info.Meta.Stride;
-            memcpy(m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Data, package.PopData(dataSize), dataSize);
+            memcpy(m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Data, packet.ReadData(dataSize), dataSize);
         }
     }
 }
 
-int Client::Receive(char* data, size_t length)
+int Client::receive(char* data, size_t length)
 {
     boost::system::error_code error;
 
@@ -241,44 +241,44 @@ int Client::Receive(char* data, size_t length)
         0, error);
 
     if (error) {
-        //LOG_ERROR("Receive: %s", error.message().c_str());
+        //LOG_ERROR("receive: %s", error.message().c_str());
     }
 
     return bytesReceived;
 }
 
-void Client::Send(Package& package)
+void Client::send(Packet& packet)
 {
     m_Socket.send_to(boost::asio::buffer(
-        package.Data(),
-        package.Size()),
+        packet.Data(),
+        packet.Size()),
         m_ReceiverEndpoint, 0);
 }
 
-void Client::Connect()
+void Client::connect()
 {
-    Package message(MessageType::Connect, m_SendPacketID);
-    message.AddString(m_PlayerName);
+    Packet message(MessageType::Connect, m_SendPacketID);
+    message.WriteString(m_PlayerName);
     m_StartPingTime = std::clock();
-    Send(message);
+    send(message);
 }
 
-void Client::Disconnect()
+void Client::disconnect()
 {
-    Package message(MessageType::Connect, m_SendPacketID);
-    message.AddString("+Disconnect");
-    Send(message);
+    Packet message(MessageType::Connect, m_SendPacketID);
+    message.WriteString("+Disconnect");
+    send(message);
 }
 
-void Client::Ping()
+void Client::ping()
 {
-    Package message(MessageType::Connect, m_SendPacketID);
-    message.AddString("Ping");
+    Packet message(MessageType::Connect, m_SendPacketID);
+    message.WriteString("Ping");
     m_StartPingTime = std::clock();
-    Send(message);
+    send(message);
 }
 
-void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize)
+void Client::moveMessageHead(char*& data, size_t& length, size_t stepSize)
 {
     data += stepSize;
     length -= stepSize;
@@ -286,7 +286,7 @@ void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize)
 
 bool Client::OnInputCommand(const Events::InputCommand & e)
 {
-    if (IsConnected()) {
+    if (isConnected()) {
         ComponentWrapper& player = m_World->GetComponent(m_PlayerDefinitions[m_PlayerID].EntityID, "Player");
         if (e.Command == "Forward") {
             if (e.Value > 0) {
@@ -314,12 +314,12 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
         }
     }
     if (e.Command == "ConnectToServer") { // Connect for now
-        Connect();
+        connect();
     }
     return false;
 }
 
-void Client::CreateNewPlayer(int i)
+void Client::createNewPlayer(int i)
 {
     m_PlayerDefinitions[i].EntityID = m_World->CreateEntity();
     ComponentWrapper transform = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Transform");
@@ -327,7 +327,7 @@ void Client::CreateNewPlayer(int i)
     model["Resource"] = "Models/Core/UnitSphere.obj";
 }
 
-void Client::IdentifyPacketLoss()
+void Client::identifyPacketLoss()
 {
     // if no packets lost, difference should be equal to 1
     int difference = m_PacketID - m_PreviousPacketID;
@@ -336,7 +336,7 @@ void Client::IdentifyPacketLoss()
     }
 }
 
-bool Client::IsConnected()
+bool Client::isConnected()
 {
     if (m_PlayerID != -1) {
         if (m_PlayerDefinitions[m_PlayerID].EntityID != -1) {

src/Engine/Network/Packet.cpp

@@ -1,60 +1,57 @@
-#include "Network/Package.h"
+#include "Network/Packet.h"
 
-Package::Package(MessageType type, unsigned int& packageID)
+Packet::Packet(MessageType type, unsigned int& packetID)
 {
     m_Data = new char[128];
     // Create message header
     // Add message type
     int messageType = static_cast<int>(type);
-    Package::AddPrimitive<int>(messageType);
-    packageID = packageID % 1000; // Packet id modulos
-    Package::AddPrimitive<int>(packageID);
-    packageID++;
+    Packet::WritePrimitive<int>(messageType);
+    packetID = packetID % 1000; // Packet id modulos
+    Packet::WritePrimitive<int>(packetID);
+    packetID++;
 }
 
 
-Package::Package(char* data, const int sizeOfPackage)
+Packet::Packet(char* data, const int sizeOfPacket)
 {
     // Create message
 
     // Resize message
     m_MaxPacketSize = sizeOfPackage;
-    m_Data = new char[sizeOfPackage];
     // Copy data newly allocated memory
-    memcpy(m_Data, data, sizeOfPackage);
-    m_Offset = sizeOfPackage;
 }
 
-Package::~Package()
+Packet::~Packet()
 {
     delete[] m_Data;
 }
 
-void Package::AddString(std::string str)
+void Packet::WriteString(std::string str)
 {
     // Message, add one extra byte for null terminator
     int sizeOfString = str.size() + 1;
     if (m_Offset + sizeOfString > m_MaxPacketSize) {
-        LOG_WARNING("Package::AddString(): Data size in packet exceeded maximum package size.\n");
+        LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size.\n");
     }
     memcpy(m_Data + m_Offset, str.data(), sizeOfString * sizeof(char));
     m_Offset += sizeOfString * sizeof(char);
 }
 
-void Package::AddData(char * data, int sizeOfData)
+void Packet::WriteData(char * data, int sizeOfData)
 { 
     if (m_Offset + sizeOfData > m_MaxPacketSize) {
-        LOG_WARNING("Package::AddData(): Data size in packet exceeded maximum package size.\n");
+        LOG_WARNING("Packet::WriteData(): Data size in packet exceeded maximum packet size.\n");
     }
     memcpy(m_Data + m_Offset, data, sizeOfData);
     m_Offset += sizeOfData;
 }
 
-std::string Package::PopFrontString()
+std::string Packet::ReadString()
 {
     std::string returnValue(m_Data + m_ReturnDataOffset);
     if (m_Offset < m_ReturnDataOffset + returnValue.size()){
-        LOG_WARNING("packet PopFrontString(): Oh no! You are trying to remove things outside my memory kingdom");
+        LOG_WARNING("packet ReadString(): Oh no! You are trying to remove things outside my memory kingdom");
         return "PopFrontString Failed";
     }   
     // +1 for null terminator.
@@ -62,10 +59,10 @@ std::string Package::PopFrontString()
     return returnValue;
 }
 
-char * Package::PopData(int SizeOfData)
+char * Packet::ReadData(int SizeOfData)
 {
     if (m_Offset < m_ReturnDataOffset + SizeOfData) {
-        LOG_WARNING("packet PopData(): Oh no! You are trying to remove things outside my memory kingdom");
+        LOG_WARNING("packet ReadData(): Oh no! You are trying to remove things outside my memory kingdom");
         return nullptr;
     }
     unsigned int oldReturnDataOffset = m_ReturnDataOffset;

src/Engine/Network/Server.cpp

@@ -16,7 +16,7 @@ void Server::Start(World* world, EventBroker* eventBroker)
     }
     LOG_INFO("I am Server. BIP BOP\n");
 
-    ReadFromClients();
+    readFromClients();
 }
 
 void Server::Update()
@@ -40,7 +40,7 @@ void Server::Close()
     m_ThreadIsRunning = false;
 }
 
-void Server::ReadFromClients()
+void Server::readFromClients()
 {
     char readBuffer[1024] = { 0 };
     int bytesRead = 0;
@@ -60,9 +60,9 @@ void Server::ReadFromClients()
 
         if (m_ThreadIsRunning && m_Socket.available()) {
             try {
-                bytesRead = Receive(readBuffer, INPUTSIZE);
-                Package package(readBuffer, bytesRead);
-                ParseMessageType(package);
+                bytesRead = receive(readBuffer, INPUTSIZE);
+                Packet packet(readBuffer, bytesRead);
+                parseMessageType(packet);
             } catch (const std::exception& err) {
                 //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
             }
@@ -71,59 +71,59 @@ void Server::ReadFromClients()
         std::clock_t currentTime = std::clock();
         // Send snapshot
         if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
-            SendSnapshot();
+            sendSnapshot();
             previousSnapshotMessage = currentTime;
         }
 
         // Send pings each 
         if (intervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
-            SendPing();
+            sendPing();
             previousePingMessage = currentTime;
         }
 
         // Time out logic
         if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
-            CheckForTimeOuts();
+            checkForTimeOuts();
             timOutTimer = currentTime;
         }
     }
 }
 
-void Server::ParseMessageType(Package& package)
+void Server::parseMessageType(Packet& packet)
 {
-    int messageType = package.PopFrontPrimitive<int>(); // Read what type off message was sent from server
+    int messageType = packet.ReadPrimitive<int>(); // Read what type off message was sent from server
 
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
-    m_PacketID = package.PopFrontPrimitive<int>(); //Read new packet id
+    m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
     //IdentifyPacketLoss();
     switch (static_cast<MessageType>(messageType)) {
     case MessageType::Connect:
-        ParseConnect(package);
+        parseConnect(packet);
         break;
     case MessageType::ClientPing:
-        //ParseClientPing();
+        //parseClientPing();
         break;
     case MessageType::ServerPing:
-        ParseServerPing();
+        parseServerPing();
         break;
     case MessageType::Message:
         break;
     case MessageType::Snapshot:
-        ParseSnapshot(package);
+        parseSnapshot(packet);
         break;
     case MessageType::Disconnect:
-        ParseDisconnect();
+        parseDisconnect();
         break;
     case MessageType::Event:
-        ParseEvent(package);
+        parseEvent(packet);
         break;
     default:
         break;
     }
 }
 
-int Server::Receive(char * data, size_t length)
+int Server::receive(char * data, size_t length)
 {
     length = m_Socket.receive_from(
         boost::asio::buffer((void*)data
@@ -132,69 +132,69 @@ int Server::Receive(char * data, size_t length)
     return length;
 }
 
-void Server::Send(Package& message, int playerID)
+void Server::send(Packet& packet, int playerID)
 {
     m_Socket.send_to(
-        boost::asio::buffer(message.Data(), message.Size()),
+        boost::asio::buffer(packet.Data(), packet.Size()),
         m_PlayerDefinitions[playerID].Endpoint,
         0);
 }
 
-void Server::Send(Package & package)
+void Server::send(Packet & packet)
 {
     m_Socket.send_to(
         boost::asio::buffer(
-            package.Data(),
-            package.Size()),
+            packet.Data(),
+            packet.Size()),
         m_ReceiverEndpoint,
         0);
 }
 
-void Server::MoveMessageHead(char *& data, size_t & length, size_t stepSize)
+void Server::moveMessageHead(char *& data, size_t & length, size_t stepSize)
 {
     data += stepSize;
     length -= stepSize;
 }
 
-void Server::Broadcast(std::string message)
+void Server::broadcast(std::string message)
 {
-    Package package(MessageType::Event, m_SendPacketID);
-    package.AddString(message);
+    Packet packet(MessageType::Event, m_SendPacketID);
+    packet.WriteString(message);
     for (int i = 0; i < MAXCONNECTIONS; i++) {
         if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
-            Send(package, i);
+            send(packet, i);
         }
     }
 }
 
-void Server::Broadcast(Package& package)
+void Server::broadcast(Packet& packet)
 {
     for (int i = 0; i < MAXCONNECTIONS; ++i) {
         if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
-            Send(package, i);
+            send(packet, i);
         }
     }
 }
 
-void Server::SendSnapshot()
+void Server::sendSnapshot()
 {
-    Package package(MessageType::Snapshot, m_SendPacketID);
+    Packet packet(MessageType::Snapshot, m_SendPacketID);
     for (size_t i = 0; i < MAXCONNECTIONS; i++) {
 
         // Send an empty name if there is no player connected on this position.
-        package.AddString(m_PlayerDefinitions[i].Name);
+        packet.WriteString(m_PlayerDefinitions[i].Name);
 
         if (m_PlayerDefinitions[i].EntityID == -1) {
             continue;
         }
-        // Pack transfrom component into data package
+        // Pack transfrom component into data packet
         auto transform = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform");
-        package.AddData(transform.Data, transform.Info.Meta.Stride);
+        packet.WriteData(transform.Data, transform.Info.Meta.Stride);
     }
-    Broadcast(package);
+    broadcast(packet);
 }
 
-void Server::SendPing()
+void Server::sendPing()
 {
     // Prints connected players ping
     for (size_t i = 0; i < MAXCONNECTIONS; i++) {
@@ -205,15 +205,15 @@ void Server::SendPing()
     }
 
     // Create ping message
-    Package package(MessageType::ServerPing, m_SendPacketID);
-    package.AddString("Ping from server");
+    Packet packet(MessageType::ServerPing, m_SendPacketID);
+    packet.WriteString("Ping from server");
     // Time message
     m_StartPingTime = std::clock();
     // Send message
-    Broadcast(package);
+    broadcast(packet);
 }
 
-void Server::CheckForTimeOuts()
+void Server::checkForTimeOuts()
 {
     int timeOutTimeMs = 5000;
     int startPing = 1000 * m_StartPingTime
@@ -225,15 +225,15 @@ void Server::CheckForTimeOuts()
                 / static_cast<double>(CLOCKS_PER_SEC);
             if (startPing > stopPing + timeOutTimeMs) {
                 LOG_INFO("Player %i timed out!", i);
-                Disconnect(i);
+                disconnect(i);
             }
         }
     }
 }
 
-void Server::Disconnect(int i)
+void Server::disconnect(int i)
 {
-    Broadcast("A player disconnected");
+    broadcast("A player disconnected");
     LOG_INFO("Player %i disconnected/timed out", i);
 
     // Remove enteties and stuff
@@ -242,7 +242,7 @@ void Server::Disconnect(int i)
     m_PlayerDefinitions[i].Name = "";
 }
 
-void Server::ParseEvent(Package& package)
+void Server::parseEvent(Packet& packet)
 {
     size_t i;
     for (i = 0; i < MAXCONNECTIONS; i++) {
@@ -255,7 +255,7 @@ void Server::ParseEvent(Package& package)
         return;
 
     unsigned int entityId = m_PlayerDefinitions[i].EntityID;
-    std::string eventString = package.PopFrontString();
+    std::string eventString = packet.ReadString();
     if ("+Forward" == eventString) {
         m_World->GetComponent(entityId, "Player")["Forward"] = true;
         m_World->GetComponent(entityId, "Player")["Back"] = false;
@@ -278,7 +278,7 @@ void Server::ParseEvent(Package& package)
     }
 }
 
-void Server::ParseConnect(Package& package)
+void Server::parseConnect(Packet& packet)
 {
     LOG_INFO("Parsing connections");
     // Check if player is already connected
@@ -294,48 +294,48 @@ void Server::ParseConnect(Package& package)
             m_PlayersToCreate.push_back(i);
 
             m_PlayerDefinitions[i].Endpoint = m_ReceiverEndpoint;
-            m_PlayerDefinitions[i].Name = package.PopFrontString();
+            m_PlayerDefinitions[i].Name = packet.ReadString();
 
             m_StopTimes[i] = std::clock();
 
             LOG_INFO("Player \"%s\" connected on IP: %s", m_PlayerDefinitions[i].Name, m_PlayerDefinitions[i].Endpoint.address().to_string());
 
-            Package package(MessageType::Connect, m_SendPacketID);
-            package.AddPrimitive<int>(i); // Player ID
+            Packet packet(MessageType::Connect, m_SendPacketID);
+            packet.WritePrimitive<int>(i); // Player ID
 
-            Send(package, i);
+            send(packet, i);
 
             // Send notification that a player has connected
             std::string str = m_PacketID + "Player " + m_PlayerDefinitions[i].Name + " connected on: "
                 + m_PlayerDefinitions[i].Endpoint.address().to_string();
-            Broadcast(str);
+            broadcast(str);
             break;
         }
     }
 }
 
-void Server::ParseDisconnect()
+void Server::parseDisconnect()
 {
     LOG_INFO("%i: Parsing disconnect", m_PacketID);
 
     for (int i = 0; i < MAXCONNECTIONS; i++) {
         if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
-            Disconnect(i);
+            disconnect(i);
             break;
         }
     }
 }
 
-void Server::ParseClientPing()
+void Server::parseClientPing()
 {
     LOG_INFO("%i: Parsing ping", m_PacketID);
     // Return ping
-    Package package(MessageType::ClientPing, m_SendPacketID);
-    package.AddString("Ping received");
-    Send(package); // This dosen't work for multiple users
+    Packet packet(MessageType::ClientPing, m_SendPacketID);
+    packet.WriteString("Ping received");
+    send(packet); // This dosen't work for multiple users
 }
 
-void Server::ParseServerPing()
+void Server::parseServerPing()
 {
     for (int i = 0; i < MAXCONNECTIONS; i++) {
         if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
@@ -346,7 +346,7 @@ void Server::ParseServerPing()
 }
 
 // NOT USED
-void Server::ParseSnapshot(Package& package)
+void Server::parseSnapshot(Packet& packet)
 {
     // Does no logic. Returns snapshot if client request one
     // The snapshot is not a real snapshot tho...
@@ -360,7 +360,7 @@ void Server::ParseSnapshot(Package& package)
     }
 }
 
-void Server::IdentifyPacketLoss()
+void Server::identifyPacketLoss()
 {
     // if no packets lost, difference should be equal to 1
     int difference = m_PacketID - m_PreviousPacketID;