Merge branch 'master' into OrderedSystemPipeline

# Conflicts:
#	include/Engine/Core/SystemPipeline.h

src/Engine/Collision/Collision.cpp

@@ -252,6 +252,9 @@ bool GetEntityBox(World* world, ComponentWrapper& AABBComponent, AABB& outBox)
     glm::vec3 mini = outBox.MinCorner();
     glm::vec3 maxi = outBox.MaxCorner();
 
+    if (modelRes == nullptr) {
+        return false;
+    }
     glm::mat4 modelMatrix = modelRes->m_Matrix *
         glm::translate(glm::mat4(), (glm::vec3)cTrans["Position"]) *
         glm::scale((glm::vec3)cTrans["Scale"]);

src/Engine/Core/EventBroker.cpp

@@ -2,21 +2,24 @@
 
 BaseEventRelay::~BaseEventRelay()
 {
-	if (m_Broker != nullptr) {
-		m_Broker->Unsubscribe(*this);
-	}
+    if (m_Broker != nullptr) {
+        m_Broker->Unsubscribe(*this);
+    }
 }
 
-void EventBroker::Unsubscribe(BaseEventRelay &relay) // ?
+void EventBroker::Unsubscribe(BaseEventRelay& relay) // ?
 {
-	if (m_IsProcessing) {
-		m_RelaysToUnsubscribe.push_back(&relay);
-	} else {
-		unsubscribeImmediate(relay);
-	}
+    auto identifier = std::make_tuple(relay.m_EventID, relay.m_ContextTypeName, relay.m_EventTypeName);
+
+    relay.m_Broker = nullptr;
+    if (m_IsProcessing) {
+        m_RelaysToUnsubscribe.push_back(identifier);
+    } else {
+        unsubscribeImmediate(identifier);
+    }
 }
 
-void EventBroker::Subscribe(BaseEventRelay &relay)
+void EventBroker::Subscribe(BaseEventRelay& relay)
 {
 	if (m_IsProcessing) {
 		m_RelaysToSubscribe.push_back(&relay);
@@ -38,12 +41,11 @@ int EventBroker::Process(std::string contextTypeName)
 
 	int eventsProcessed = 0;
 	for (auto &pair : *m_EventQueueRead) {
-		std::string &eventTypeName = pair.first;
+		std::string& eventTypeName = pair.first;
 		std::shared_ptr<Event> event = pair.second;
 
 		auto itpair = relays.equal_range(eventTypeName);
-		for (auto it2 = itpair.first; it2 != itpair.second; it2++)
-		{
+		for (auto it2 = itpair.first; it2 != itpair.second; it2++) {
 			std::string name = it2->first;
 			BaseEventRelay* relay = it2->second;
 			relay->Receive(event);
@@ -60,8 +62,8 @@ int EventBroker::Process(std::string contextTypeName)
 	m_RelaysToSubscribe.clear();
 
 	// Process pending unsubscriptions
-	for (auto& r : m_RelaysToUnsubscribe) {
-		unsubscribeImmediate(*r);
+	for (auto& identifier : m_RelaysToUnsubscribe) {
+		unsubscribeImmediate(identifier);
 	}
 	m_RelaysToUnsubscribe.clear();
 
@@ -81,21 +83,26 @@ void EventBroker::Clear()
 void EventBroker::subscribeImmediate(BaseEventRelay& relay)
 {
 	relay.m_Broker = this;
+    relay.m_EventID = m_NextEventID++;
 	m_ContextRelays[relay.m_ContextTypeName].insert(std::make_pair(relay.m_EventTypeName, &relay));
 }
 
-void EventBroker::unsubscribeImmediate(BaseEventRelay& relay)
+void EventBroker::unsubscribeImmediate(std::tuple<EventID, ContextTypeName_t, EventTypeName_t> identifier)
 {
-	auto contextIt = m_ContextRelays.find(relay.m_ContextTypeName);
+    EventID eventID;
+    ContextTypeName_t contextTypeName;
+    EventTypeName_t eventTypeName;
+    std::tie(eventID, contextTypeName, eventTypeName) = identifier;
+
+	auto contextIt = m_ContextRelays.find(contextTypeName);
 	if (contextIt == m_ContextRelays.end()) {
 		return;
 	}
 
 	auto eventRelays = contextIt->second;
-	auto itpair = eventRelays.equal_range(relay.m_EventTypeName);
+	auto itpair = eventRelays.equal_range(eventTypeName);
 	for (auto it = itpair.first; it != itpair.second; ++it) {
-		if (it->second == &relay) {
-			relay.m_Broker = nullptr;
+		if (it->second->m_EventID == eventID) {
 			eventRelays.erase(it);
 			break;
 		}

src/Engine/Network/Client.cpp

@@ -1,11 +1,334 @@
-#include "Network\Client.h"
+#include "Network/Client.h"
 
-Client::Client()
+using namespace boost::asio::ip;
+
+
+Client::Client(ConfigFile* config) : m_Socket(m_IOService)
 {
-
+    // Default is local host
+    std::string address = config->Get<std::string>("Networking.Address", "127.0.0.1");
+    int port = config->Get<int>("Networking.Port", 13);
+    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_NextSnapshot.InputForward = "";
+    m_NextSnapshot.InputRight = "";
 }
 
 Client::~Client()
 {
 
 }
+
+void Client::Start(World* world, EventBroker* eventBroker)
+{
+    m_WasStarted = true;
+    m_EventBroker = eventBroker;
+    m_World = world;
+
+    // Subscribe to events
+    m_EInputCommand = decltype(m_EInputCommand)(std::bind(&Client::OnInputCommand, this, std::placeholders::_1));
+    m_EventBroker->Subscribe(m_EInputCommand);
+
+
+    //while (m_PlayerName.size() > 7) {
+    //    LOG_INFO("Please enter your name (No longer than 7 characters):");
+    //    std::cin >> m_PlayerName;
+    //}
+    m_Socket.connect(m_ReceiverEndpoint);
+    LOG_INFO("I am client. BIP BOP");
+}
+
+void Client::Update()
+{
+    readFromServer();
+}
+
+void Client::Close()
+{
+    if (m_WasStarted) {
+        disconnect();
+        m_ThreadIsRunning = false;
+        m_EventBroker->Unsubscribe(m_EInputCommand);
+    }
+}
+
+void Client::readFromServer()
+{
+    if (m_Socket.available()) {
+        bytesRead = receive(readBuf, INPUTSIZE);
+        if (bytesRead > 0) {
+            Packet packet(readBuf, bytesRead);
+            parseMessageType(packet);
+        }
+    }
+    std::clock_t currentTime = std::clock();
+    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+        if (isConnected()) {
+            sendSnapshotToServer();
+        }
+        previousSnapshotMessage = currentTime;
+    }
+}
+
+void Client::sendSnapshotToServer()
+{
+    // Reset previouse key state in snapshot.
+    m_NextSnapshot.InputForward = "";
+    m_NextSnapshot.InputRight = "";
+
+    auto player = m_World->GetComponent(m_PlayerDefinitions[m_PlayerID].EntityID, "Player");
+
+
+    // See if any movement keys are down
+    // We dont care if it's overwritten by later
+    // if statement. Watcha gonna do, right!
+    if (player["Forward"]) {
+        m_NextSnapshot.InputForward = "+Forward";
+    }
+    if (player["Left"]) {
+        m_NextSnapshot.InputRight = "-Right";
+    }
+    if (player["Back"]) {
+        m_NextSnapshot.InputForward = "-Forward";
+    }
+    if (player["Right"]) {
+        m_NextSnapshot.InputRight = "+Right";
+    }
+
+    if (m_NextSnapshot.InputForward != "") {
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString(m_NextSnapshot.InputForward);
+        send(packet);
+    } else {
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString("0Forward");
+        send(packet);
+    }
+
+    if (m_NextSnapshot.InputRight != "") {
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString(m_NextSnapshot.InputRight);
+        send(packet);
+    } else {
+        Packet packet(MessageType::Event, m_SendPacketID);
+        packet.WriteString("0Right");
+        send(packet);
+    }
+}
+
+void Client::parseMessageType(Packet& packet)
+{
+    int messageType = packet.ReadPrimitive<int>();
+    if (messageType == -1)
+        return;
+    // Read packet ID 
+    m_PreviousPacketID = m_PacketID;    // Set previous packet id
+    m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
+    //IdentifyPacketLoss();
+
+    switch (static_cast<MessageType>(messageType)) {
+    case MessageType::Connect:
+        parseConnect(packet);
+        break;
+    case MessageType::ClientPing:
+        parsePing();
+        break;
+    case MessageType::ServerPing:
+        parseServerPing();
+        break;
+    case MessageType::Message:
+        break;
+    case MessageType::Snapshot:
+        parseSnapshot(packet);
+        break;
+    case MessageType::Disconnect:
+        break;
+    case MessageType::Event:
+        parseEventMessage(packet);
+        break;
+    default:
+        break;
+    }
+}
+
+void Client::parseConnect(Packet& packet)
+{
+    m_PlayerID = packet.ReadPrimitive<int>();
+    LOG_INFO("%i: I am player: %i", m_PacketID, m_PlayerID);
+}
+
+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()
+{
+    Packet packet(MessageType::ServerPing, m_SendPacketID);
+    packet.WriteString("Ping recieved");
+    send(packet);
+}
+
+void Client::parseEventMessage(Packet& packet)
+{
+    int Id = -1;
+    std::string command = packet.ReadString();
+    if (command.find("+Player") != std::string::npos) {
+        Id = packet.ReadPrimitive<int>();
+        // Sett Player name
+        m_PlayerDefinitions[Id].Name = command.erase(0, 7);
+    } else {
+        LOG_INFO("%i: Event message: %s", m_PacketID, command.c_str());
+    }
+}
+
+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 = packet.ReadString();
+
+
+        // Apply the position data read to the player entity
+        // New player connected on the server side 
+        if (m_PlayerDefinitions[i].Name == "" && tempName != "") {
+            m_PlayerDefinitions[i].Name = tempName;
+            m_PlayerDefinitions[i].EntityID = createPlayer();
+        } else if (m_PlayerDefinitions[i].Name != "" && tempName == "") {
+            // Someone disconnected
+            // TODO: Insert code here
+            break;
+        } else if (m_PlayerDefinitions[i].Name == "" && tempName == "") {
+            // Not a connected player
+            break;
+        }
+        if (m_PlayerDefinitions[i].EntityID != -1) {
+
+            // 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, packet.ReadData(dataSize), dataSize);
+        }
+    }
+}
+
+int Client::receive(char* data, size_t length)
+{
+    boost::system::error_code error;
+
+    int bytesReceived = m_Socket.receive_from(boost
+        ::asio::buffer((void*)data, length),
+        m_ReceiverEndpoint,
+        0, error);
+
+    if (error) {
+        //LOG_ERROR("receive: %s", error.message().c_str());
+    }
+
+    return bytesReceived;
+}
+
+void Client::send(Packet& packet)
+{
+    m_Socket.send_to(boost::asio::buffer(
+        packet.Data(),
+        packet.Size()),
+        m_ReceiverEndpoint, 0);
+}
+
+void Client::connect()
+{
+    Packet packet(MessageType::Connect, m_SendPacketID);
+    packet.WriteString(m_PlayerName);
+    m_StartPingTime = std::clock();
+    send(packet);
+}
+
+void Client::disconnect()
+{
+    Packet packet(MessageType::Connect, m_SendPacketID);
+    packet.WriteString("+Disconnect");
+    send(packet);
+}
+
+void Client::ping()
+{
+    Packet packet(MessageType::Connect, m_SendPacketID);
+    packet.WriteString("Ping");
+    m_StartPingTime = std::clock();
+    send(packet);
+}
+
+void Client::moveMessageHead(char*& data, size_t& length, size_t stepSize)
+{
+    data += stepSize;
+    length -= stepSize;
+}
+
+bool Client::OnInputCommand(const Events::InputCommand & e)
+{
+    if (isConnected()) {
+        ComponentWrapper& player = m_World->GetComponent(m_PlayerDefinitions[m_PlayerID].EntityID, "Player");
+        if (e.Command == "Forward") {
+            if (e.Value > 0) {
+                (bool&)player["Forward"] = true;
+                (bool&)player["Back"] = false;
+            } else if (e.Value < 0) {
+                (bool&)player["Back"] = true;
+                (bool&)player["Forward"] = false;
+            } else {
+                (bool&)player["Forward"] = false;
+                (bool&)player["Back"] = false;
+            }
+        }
+        if (e.Command == "Right") {
+            if (e.Value > 0) {
+                (bool&)player["Right"] = true;
+                (bool&)player["Left"] = false;
+            } else if (e.Value < 0) {
+                (bool&)player["Left"] = true;
+                (bool&)player["Right"] = false;
+            } else {
+                (bool&)player["Left"] = false;
+                (bool&)player["Right"] = false;
+            }
+        }
+    }
+    if (e.Command == "ConnectToServer") { // Connect for now
+        connect();
+    }
+    return false;
+}
+
+
+void Client::identifyPacketLoss()
+{
+    // if no packets lost, difference should be equal to 1
+    int difference = m_PacketID - m_PreviousPacketID;
+    if (difference != 1) {
+        LOG_INFO("%i Packet(s) were lost...", difference);
+    }
+}
+
+bool Client::isConnected()
+{
+    if (m_PlayerID != -1) {
+        if (m_PlayerDefinitions[m_PlayerID].EntityID != -1) {
+            return true;
+        }
+    }
+    return false;
+}
+
+EntityID Client::createPlayer()
+{
+    EntityID entityID = m_World->CreateEntity();
+    ComponentWrapper transform = m_World->AttachComponent(entityID, "Transform");
+    ComponentWrapper model = m_World->AttachComponent(entityID, "Model");
+    model["Resource"] = "Models/Core/UnitSphere.obj";
+    ComponentWrapper player = m_World->AttachComponent(entityID, "Player");
+    return entityID;
+}

src/Engine/Network/Packet.cpp

@@ -0,0 +1,72 @@
+#include "Network/Packet.h"
+
+Packet::Packet(MessageType type, unsigned int& packetID)
+{
+    m_Data = new char[m_MaxPacketSize];
+    // Create message header
+    // Add message type
+    int messageType = static_cast<int>(type);
+    Packet::WritePrimitive<int>(messageType);
+    packetID = packetID % 1000; // Packet id modulos
+    Packet::WritePrimitive<int>(packetID);
+    packetID++;
+}
+
+// Create message
+Packet::Packet(char* data, const int sizeOfPacket)
+{
+    // Resize message
+    m_MaxPacketSize = sizeOfPacket;
+    // Copy data newly allocated memory
+    m_Data = new char[sizeOfPacket];
+    memcpy(m_Data, data, sizeOfPacket);
+    m_Offset = sizeOfPacket;
+}
+
+Packet::~Packet()
+{
+    delete[] m_Data;
+}
+
+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::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 Packet::WriteData(char * data, int sizeOfData)
+{
+    if (m_Offset + sizeOfData > m_MaxPacketSize) {
+        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 Packet::ReadString()
+{
+    std::string returnValue(m_Data + m_ReturnDataOffset);
+    if (m_Offset < m_ReturnDataOffset + returnValue.size()) {
+        LOG_WARNING("packet ReadString(): Oh no! You are trying to remove things outside my memory kingdom");
+        return "PopFrontString Failed";
+    }
+    // +1 for null terminator.
+    m_ReturnDataOffset += returnValue.size() + 1;
+    return returnValue;
+}
+
+char * Packet::ReadData(int SizeOfData)
+{
+    if (m_Offset < m_ReturnDataOffset + SizeOfData) {
+        LOG_WARNING("packet ReadData(): Oh no! You are trying to remove things outside my memory kingdom");
+        return nullptr;
+    }
+    unsigned int oldReturnDataOffset = m_ReturnDataOffset;
+    m_ReturnDataOffset += SizeOfData;
+    return (m_Data + oldReturnDataOffset);
+}

src/Engine/Network/Server.cpp

@@ -1,11 +1,355 @@
-#include "Network\Server.h"
+#include "Network/Server.h"
 
-Server::Server()
-{
-
-}
+Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 13))
+{ }
 
 Server::~Server()
-{
+{ }
 
+
+void Server::Start(World* world, EventBroker* eventBroker)
+{
+    m_World = world;
+    m_EventBroker = eventBroker;
+    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+        m_StopTimes[i] = std::clock();
+    }
+    LOG_INFO("I am Server. BIP BOP\n");
+}
+
+void Server::Update()
+{
+    readFromClients();
+}
+
+void Server::Close()
+{
+    m_ThreadIsRunning = false;
+}
+
+void Server::readFromClients()
+{
+    // m_ThreadIsRunning might be unnecessary but the 
+    // program crashed if it executed m_Socket.available()
+    // when closing the program. 
+
+    if (m_Socket.available()) {
+        try {
+            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());
+        }
+
+    }
+    std::clock_t currentTime = std::clock();
+    // Send snapshot
+    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+        sendSnapshot();
+        previousSnapshotMessage = currentTime;
+    }
+
+    // Send pings each 
+    if (intervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+        sendPing();
+        previousePingMessage = currentTime;
+    }
+
+    // Time out logic
+    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
+        checkForTimeOuts();
+        timOutTimer = currentTime;
+    }
+}
+
+void Server::parseMessageType(Packet& packet)
+{
+    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 = packet.ReadPrimitive<int>(); //Read new packet id
+    //IdentifyPacketLoss();
+    switch (static_cast<MessageType>(messageType)) {
+    case MessageType::Connect:
+        parseConnect(packet);
+        break;
+    case MessageType::ClientPing:
+        //parseClientPing();
+        break;
+    case MessageType::ServerPing:
+        parseServerPing();
+        break;
+    case MessageType::Message:
+        break;
+    case MessageType::Snapshot:
+        parseSnapshot(packet);
+        break;
+    case MessageType::Disconnect:
+        parseDisconnect();
+        break;
+    case MessageType::Event:
+        parseEvent(packet);
+        break;
+    default:
+        break;
+    }
+}
+
+int Server::receive(char * data, size_t length)
+{
+    length = m_Socket.receive_from(
+        boost::asio::buffer((void*)data
+            , length)
+        , m_ReceiverEndpoint, 0);
+    return length;
+}
+
+void Server::send(Packet& packet, int playerID)
+{
+    m_Socket.send_to(
+        boost::asio::buffer(packet.Data(), packet.Size()),
+        m_PlayerDefinitions[playerID].Endpoint,
+        0);
+}
+
+void Server::send(Packet & packet)
+{
+    m_Socket.send_to(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        m_ReceiverEndpoint,
+        0);
+}
+
+void Server::moveMessageHead(char *& data, size_t & length, size_t stepSize)
+{
+    data += stepSize;
+    length -= stepSize;
+}
+
+void Server::broadcast(std::string 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(packet, i);
+        }
+    }
+}
+
+void Server::broadcast(Packet& packet)
+{
+    for (int i = 0; i < MAXCONNECTIONS; ++i) {
+        if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
+            send(packet, i);
+        }
+    }
+}
+
+void Server::sendSnapshot()
+{
+    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.
+        packet.WriteString(m_PlayerDefinitions[i].Name);
+
+        if (m_PlayerDefinitions[i].EntityID == -1) {
+            continue;
+        }
+        // Pack transfrom component into data packet
+        auto transform = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform");
+        packet.WriteData(transform.Data, transform.Info.Meta.Stride);
+    }
+    broadcast(packet);
+}
+
+void Server::sendPing()
+{
+    // Prints connected players ping
+    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
+            int ping = 1000 * (m_StopTimes[i] - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
+            LOG_INFO("%i: Player %i's ping: %i", m_PacketID, i, ping);
+        }
+    }
+
+    // Create ping message
+    Packet packet(MessageType::ServerPing, m_SendPacketID);
+    packet.WriteString("Ping from server");
+    // Time message
+    m_StartPingTime = std::clock();
+    // Send message
+    broadcast(packet);
+}
+
+void Server::checkForTimeOuts()
+{
+    int timeOutTimeMs = 5000;
+    int startPing = 1000 * m_StartPingTime
+        / static_cast<double>(CLOCKS_PER_SEC);
+
+    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
+            int stopPing = 1000 * m_StopTimes[i]
+                / static_cast<double>(CLOCKS_PER_SEC);
+            if (startPing > stopPing + timeOutTimeMs) {
+                LOG_INFO("Player %i timed out!", i);
+                disconnect(i);
+            }
+        }
+    }
+}
+
+void Server::disconnect(int i)
+{
+    broadcast("A player disconnected");
+    LOG_INFO("Player %i disconnected/timed out", i);
+
+    // Remove enteties and stuff
+    m_PlayerDefinitions[i].Endpoint = boost::asio::ip::udp::endpoint();
+    m_PlayerDefinitions[i].EntityID = -1;
+    m_PlayerDefinitions[i].Name = "";
+}
+
+void Server::parseEvent(Packet& packet)
+{
+    size_t i;
+    for (i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
+            break;
+        }
+    }
+    // If no player matches the address return.
+    if (i >= 8)
+        return;
+
+    unsigned int entityId = m_PlayerDefinitions[i].EntityID;
+    std::string eventString = packet.ReadString();
+    if ("+Forward" == eventString) {
+        m_World->GetComponent(entityId, "Player")["Forward"] = true;
+        m_World->GetComponent(entityId, "Player")["Back"] = false;
+    } else if ("-Forward" == eventString) {
+        m_World->GetComponent(entityId, "Player")["Forward"] = false;
+        m_World->GetComponent(entityId, "Player")["Back"] = true;
+    } else if ("0Forward" == eventString) {
+        m_World->GetComponent(entityId, "Player")["Forward"] = false;
+        m_World->GetComponent(entityId, "Player")["Back"] = false;
+    }
+    if ("+Right" == eventString) {
+        m_World->GetComponent(entityId, "Player")["Left"] = false;
+        m_World->GetComponent(entityId, "Player")["Right"] = true;
+    } else if ("-Right" == eventString) {
+        m_World->GetComponent(entityId, "Player")["Right"] = false;
+        m_World->GetComponent(entityId, "Player")["Left"] = true;
+    } else if ("0Right" == eventString) {
+        m_World->GetComponent(entityId, "Player")["Right"] = false;
+        m_World->GetComponent(entityId, "Player")["Left"] = false;
+    }
+}
+
+void Server::parseConnect(Packet& packet)
+{
+    LOG_INFO("Parsing connections");
+    // Check if player is already connected
+    for (int i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
+            return;
+        }
+    }
+
+    for (int i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() == boost::asio::ip::address()) {
+            // Create new player
+            m_PlayerDefinitions[i].EntityID = createPlayer();
+            m_PlayerDefinitions[i].Endpoint = m_ReceiverEndpoint;
+            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());
+
+            Packet packet(MessageType::Connect, m_SendPacketID);
+            packet.WritePrimitive<int>(i); // Player ID
+
+            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);
+            break;
+        }
+    }
+}
+
+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);
+            break;
+        }
+    }
+}
+
+void Server::parseClientPing()
+{
+    LOG_INFO("%i: Parsing ping", m_PacketID);
+    // Return ping
+    Packet packet(MessageType::ClientPing, m_SendPacketID);
+    packet.WriteString("Ping received");
+    send(packet); // This dosen't work for multiple users
+}
+
+void Server::parseServerPing()
+{
+    for (int i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
+            m_StopTimes[i] = std::clock();
+            break;
+        }
+    }
+}
+
+// NOT USED
+void Server::parseSnapshot(Packet& packet)
+{
+    // Does no logic. Returns snapshot if client request one
+    // The snapshot is not a real snapshot tho...
+    for (int i = 0; i < MAXCONNECTIONS; i++) {
+        if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
+            m_Socket.send_to(
+                boost::asio::buffer("I'm sending a snapshot to you guys!"),
+                m_PlayerDefinitions[i].Endpoint,
+                0);
+        }
+    }
+}
+
+void Server::identifyPacketLoss()
+{
+    // if no packets lost, difference should be equal to 1
+    int difference = m_PacketID - m_PreviousPacketID;
+    if (difference != 1) {
+        LOG_INFO("%i Packet(s) were lost...", difference);
+    }
+}
+
+EntityID Server::createPlayer()
+{
+    EntityID entityID = m_World->CreateEntity();
+    ComponentWrapper transform = m_World->AttachComponent(entityID, "Transform");
+    transform["Position"] = glm::vec3(-1.5f, 0.f, 0.f);
+    ComponentWrapper model = m_World->AttachComponent(entityID, "Model");
+    model["Resource"] = "Models/Core/UnitSphere.obj";
+    model["Color"] = glm::vec4(rand()%255 / 255.f, rand()%255 / 255.f, rand() %255 / 255.f, 1.f);
+    ComponentWrapper player = m_World->AttachComponent(entityID, "Player");
+    return entityID;
 }

src/Engine/Rendering/Renderer.cpp

@@ -1,5 +1,4 @@
 #include "Rendering/Renderer.h"
-#include "Rendering/DebugCameraInputController.h"
 
 void Renderer::Initialize()
 {
@@ -10,6 +9,7 @@ void Renderer::Initialize()
 	if (m_Camera == nullptr) {
 		m_Camera = m_DefaultCamera;
 	}
+    m_DebugCameraInputController = std::make_shared<DebugCameraInputController<Renderer>>(m_EventBroker, -1);
     TEMPCreateLights();
     InitializeRenderPasses();
 
@@ -89,8 +89,6 @@ void Renderer::InitializeShaders()
 
 void Renderer::InputUpdate(double dt)
 {
-    static DebugCameraInputController<Renderer> firstPersonInputController(m_EventBroker, -1);
-
 	glm::vec3 m_Position = m_Camera->Position();
 	if (glfwGetKey(m_Window, GLFW_KEY_O) == GLFW_PRESS)
 	{
@@ -120,9 +118,9 @@ void Renderer::InputUpdate(double dt)
 		m_CameraMoveSpeed = 0.5f;
 	}
 
-    firstPersonInputController.Update(dt);
-    m_Camera->SetOrientation(firstPersonInputController.Orientation());
-	m_Camera->SetPosition(firstPersonInputController.Position());
+    m_DebugCameraInputController->Update(dt);
+    m_Camera->SetOrientation(m_DebugCameraInputController->Orientation());
+	m_Camera->SetPosition(m_DebugCameraInputController->Position());
 }
 
 void Renderer::Update(double dt)