Merge remote-tracking branch 'origin/master' into AndersTest

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/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/Game/Game.cpp

@@ -22,7 +22,7 @@ Game::Game(int argc, char* argv[])
     m_Renderer = new Renderer(m_EventBroker);
     m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
     m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
-    m_Renderer->SetResolution(Rectangle(
+    m_Renderer->SetResolution(Rectangle::Rectangle(
         0,
         0,
         m_Config->Get<int>("Video.Width", 1280),
@@ -58,6 +58,11 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<CollisionSystem>();
     m_SystemPipeline->AddSystem<TriggerSystem>();
 
+    // Invoke network
+    if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
+        //boost::thread workerThread(&Game::networkFunction, this);
+        networkFunction();
+    }
     m_LastTime = glfwGetTime();
 
     debugInitialize();
@@ -65,6 +70,10 @@ Game::Game(int argc, char* argv[])
 
 Game::~Game()
 {
+    // Call before to ensure that thread closes correctly.
+    //if (m_IsClientOrServer)
+    //  m_ClientOrServer.Close();
+
     delete m_FrameStack;
     delete m_EventBroker;
 }
@@ -87,10 +96,16 @@ void Game::Tick()
     m_InputProxy->Process();
     m_EventBroker->Swap();
 
+    // Update network
+    if (m_IsClientOrServer) {
+        m_ClientOrServer->Update();
+    }
+
     // Iterate through systems and update world!
     m_SystemPipeline->Update(m_World, dt);
     debugTick(dt);
     m_Renderer->Update(dt);
+    m_EventBroker->Process<Client>();
 
     m_RenderQueueFactory->Update(m_World);
     GLERROR("Game::Tick m_RenderQueueFactory->Update");
@@ -112,6 +127,16 @@ bool Game::debugOnInputCommand(const Events::InputCommand& e)
             ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World);
         }
     }
+    if (e.Command == "SwitchToServer" && e.Value > 0) {
+        m_ClientOrServer = new Server();
+        LOG_INFO("Switching to server");
+        m_ClientOrServer->Start(m_World, m_EventBroker);
+    }
+    if (e.Command == "SwitchToClient" && e.Value > 0) {
+        m_ClientOrServer = new Client(m_Config);
+        m_ClientOrServer->Start(m_World, m_EventBroker);
+        LOG_INFO("Switching to client");
+    }
 
     return false;
 }
@@ -125,3 +150,23 @@ void Game::debugTick(double dt)
 {
     m_EventBroker->Process<Game>();
 }
+
+void Game::networkFunction()
+{
+    bool isServer = m_Config->Get<bool>("Networking.IsServer", false);
+    if (!isServer) {
+        m_IsClientOrServer = true;
+        m_ClientOrServer = new Client(m_Config);
+    }
+    if (isServer) {
+        m_IsClientOrServer = true;
+        m_ClientOrServer = new Server();
+    }
+    m_ClientOrServer->Start(m_World, m_EventBroker);
+    // I don't think we are reaching this part of the code right now.
+    // ~Game() is not called if the game is exited by closing console windows
+    // When server or client is done set it to false.
+    //m_IsClientOrServer = false;
+    // Destroy it
+    //delete m_ClientOrServer;
+}

src/Game/PlayerSystem.cpp

@@ -2,58 +2,25 @@
 
 void PlayerSystem::UpdateComponent(World * world, ComponentWrapper & player, double dt)
 {
-    if (input.Forward) {
-        m_Direction.z = -1;
-    } else if (input.Back) {
-        m_Direction.z = 1;
-    } else {
-        m_Direction.z = 0;
+    player["Velocity"] = glm::vec3(0.f, 0.f, 0.f);
+    if ((bool&)player["Forward"] == true) {
+        ((glm::vec3&)player["Velocity"]).z = m_Speed * float(dt) * -1;
+
     }
-    if (input.Left) {
-        m_Direction.x = -1;
-    } else if (input.Right) {
-        m_Direction.x = 1;
-    } else {
-        m_Direction.x = 0;
+    if ((bool&)player["Left"] == true) {
+        ((glm::vec3&)player["Velocity"]).x = m_Speed * float(dt) * -1;
+    }
+    if ((bool&)player["Back"] == true) {
+        ((glm::vec3&)player["Velocity"]).z = m_Speed * float(dt);
+    }
+    if ((bool&)player["Right"] == true) {
+        ((glm::vec3&)player["Velocity"]).x = m_Speed * float(dt);
     }
 
-    ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
-    (glm::vec3&)player["Velocity"] = m_Speed * float(dt) * m_Direction;
-    (glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
-}
-
-bool PlayerSystem::OnKeyDown(const Events::KeyDown & event)
-{
-    if (event.KeyCode == GLFW_KEY_W) {
-        input.Forward = true;
+    if ((glm::vec3)player["Velocity"] != glm::vec3(0.f)) {
+        ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
+        (glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
     }
-    if (event.KeyCode == GLFW_KEY_A) {
-        input.Left = true;
-    }
-    if (event.KeyCode == GLFW_KEY_S) {
-        input.Back = true;
-    }
-    if (event.KeyCode == GLFW_KEY_D) {
-        input.Right = true;
-    }
-    return true;
-}
-
-bool PlayerSystem::OnKeyUp(const Events::KeyUp & event)
-{
-    if (event.KeyCode == GLFW_KEY_W) {
-        input.Forward = false;
-    }
-    if (event.KeyCode == GLFW_KEY_A) {
-        input.Left = false;
-    }
-    if (event.KeyCode == GLFW_KEY_S) {
-        input.Back = false;
-    }
-    if (event.KeyCode == GLFW_KEY_D) {
-        input.Right = false;
-    }
-    return false;
 }
 
 bool PlayerSystem::OnTouch(const Events::TriggerTouch &event)