Added logic for mapping between ServerEntityIDs and LocalEntityIDs removed old code that wasn't used.

Added 1 map to Client and renamed m_ServerToClientMap to m_ServerIDToClientID.

// Good to know
To keep this structure please use insertIntoServerClientMaps() when adding items to them.
m_ServerIDToClientID and m_ClientIDToServerID maps between server EntityIDs and local EntityIDs.
To see if a local EntityID exist in m_ClientIDToServerID use clientServerMapsHasEntity(EntityID clientEntityID);
To see if server EntityID exist in m_ServerIDToClientID use serverClientMapsHasEntity(EntityID serverEntityID);

include/Engine/Network/Client.h

@@ -34,8 +34,6 @@ private:
     // Sending message to server logic
     int bytesRead = -1;
     char readBuf[INPUTSIZE] = { 0 };
-    int snapshotInterval = 33;
-    std::clock_t previousSnapshotMessage = std::clock();
 
     // Packet loss logic
     unsigned int m_PacketID = 0;
@@ -46,40 +44,43 @@ private:
     World* m_World;
     std::string m_PlayerName;
     int m_PlayerID = -1;
-
+    EntityID m_ServerEntityID = std::numeric_limits<EntityID>::max();
     // Server Client Lookup map
     // Assumes that root node for client and server is EntityID 0.
-    std::unordered_map<EntityID, EntityID> m_ServerToClientMap;
+
+    // Don't Add items to these two maps with insert, use insertIntoServerClientMaps(EntityID, EntityID)!!!!
+    std::unordered_map<EntityID, EntityID> m_ServerIDToClientID;
+    std::unordered_map<EntityID, EntityID> m_ClientIDToServerID;
 
     // Network logic
     PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
     SnapshotDefinitions m_NextSnapshot;
     double m_DurationOfPingTime;
     std::clock_t m_StartPingTime;
-    // Use to check if we should send disconnect message
-    // if game is turned of by closing window.
-    bool m_WasStarted = false;
 
     // Private member functions
     void readFromServer();
-    void sendInputEvents();
     int  receive(char* data, size_t length);
     void send(Packet& packet);
     void connect();
     void disconnect();
     void ping();
-    void moveMessageHead(char*& data, size_t& length, size_t stepSize);
     void parseMessageType(Packet& packet);
-    void parseEventMessage(Packet& packet);
     void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
     void parseConnect(Packet& packet);
+    void parsePlayerConnected(Packet& packet);
     void parsePing();
     void parseServerPing();
     void parseSnapshot(Packet& packet);
     void identifyPacketLoss();
     bool isConnected();
     EntityID createPlayer();
-    bool hasMappedEntity(EntityID entityID);
+    // Mapping Logic
+    // Returns if local EntityID exist in map
+    bool clientServerMapsHasEntity(EntityID clientEntityID);
+    // Returns if server EntityID exist in map
+    bool serverClientMapsHasEntity(EntityID serverEntityID);
+    void insertIntoServerClientMaps(EntityID serverEntityID, EntityID clientEntityID);
 
     // Events
     EventBroker* m_EventBroker;

include/Engine/Network/MessageType.h

@@ -11,9 +11,9 @@ enum class MessageType
 	ServerPing,
 	Message,
 	Snapshot,
-	Event,
     OnInputCommand,
-    OnPlayerDamage
+    OnPlayerDamage,
+    PlayerConnected
 };
 
 #endif

include/Engine/Network/Server.h

@@ -48,8 +48,6 @@ private:
     // Game logic
     World* m_World;
     EventBroker* m_EventBroker;
-    // vec.size() = ammount of players to create, stores playerID's
-    std::vector<unsigned int> m_PlayersToCreate;
     
     // Packet loss logic
     unsigned int m_PacketID;
@@ -61,8 +59,6 @@ private:
     void readFromClients();
     void send(Packet& packet, int playerID);
     void send(Packet& packet);
-    void moveMessageHead(char*& data, size_t& length, size_t stepSize);
-    void broadcast(std::string message);
     void broadcast(Packet& packet);
     void sendSnapshot();
     void sendPing();

src/Engine/Network/Client.cpp

@@ -6,15 +6,13 @@ using namespace boost::asio::ip;
 Client::Client(ConfigFile* config) : m_Socket(m_IOService)
 {
     // Asumes root node is EntityID 0
-    m_ServerToClientMap.insert(std::make_pair(0, 0));
+    insertIntoServerClientMaps(0, 0);
     // 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()
@@ -22,7 +20,6 @@ Client::~Client()
 
 void Client::Start(World* world, EventBroker* eventBroker)
 {
-    m_WasStarted = true;
     m_EventBroker = eventBroker;
     m_World = world;
 
@@ -47,58 +44,6 @@ void Client::readFromServer()
             parseMessageType(packet);
         }
     }
-    std::clock_t currentTime = std::clock();
-    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
-        if (isConnected()) {
-            //sendSnapshotToServer();
-        }
-        previousSnapshotMessage = currentTime;
-    }
-}
-
-void Client::sendInputEvents()
-{
-    // Reset previous 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)
@@ -130,9 +75,8 @@ void Client::parseMessageType(Packet& packet)
         break;
     case MessageType::Disconnect:
         break;
-    case MessageType::Event:
+    case MessageType::PlayerConnected:
-        parseEventMessage(packet);
+        parsePlayerConnected(packet);
-        break;
     default:
         break;
     }
@@ -140,10 +84,19 @@ void Client::parseMessageType(Packet& packet)
 
 void Client::parseConnect(Packet& packet)
 {
+    // Set your own player id
     m_PlayerID = packet.ReadPrimitive<int>();
+    m_ServerEntityID = packet.ReadPrimitive<EntityID>();
+    // Map ServerEntityID and your PlayerID
     LOG_INFO("%i: I am player: %i", m_PacketID, m_PlayerID);
 }
 
+void Client::parsePlayerConnected(Packet & packet)
+{ 
+    // Map ServerEntityID and other player's PlayerID
+    LOG_INFO("A Player connected");
+}
+
 void Client::parsePing()
 {
     m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
@@ -157,19 +110,6 @@ void Client::parseServerPing()
     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::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType)
 {
     for (auto field : componentInfo.FieldsInOrder) {
@@ -194,9 +134,9 @@ void Client::parseSnapshot(Packet& packet)
         EntityID receivedParentEntityID = packet.ReadPrimitive<EntityID>();
         ComponentInfo componentInfo = m_World->GetComponents(componentType)->ComponentInfo();
         // Check if the received EntityID is mapped to one of our local EntityIDs
-        if (hasMappedEntity(receivedEntityID)) {
+        if (clientServerMapsHasEntity(receivedEntityID)) {
             // Get the local EntityID
-            EntityID entityID = m_ServerToClientMap.at(receivedEntityID);
+            EntityID entityID = m_ServerIDToClientID.at(receivedEntityID);
             // Check if the component exists
             if (m_World->HasComponent(entityID, componentType)) {
                 // If the entity and the component exists update it
@@ -213,7 +153,7 @@ void Client::parseSnapshot(Packet& packet)
             // Create Entity
             // If entity dosen't exist
             EntityID newEntityID = m_World->CreateEntity();
-            m_ServerToClientMap.insert(std::make_pair(receivedEntityID, newEntityID));
+            insertIntoServerClientMaps(receivedEntityID, newEntityID);
             // Check if EntityIDs are out of sync
             if (newEntityID != receivedEntityID) {
                 LOG_INFO("Client::parseSnapshot(Packet& packet): Newly created EntityID is not the \
@@ -228,15 +168,15 @@ void Client::parseSnapshot(Packet& packet)
         // Parent Logic
         // Don't need to check if receivedEntityID is mapped. (It should have been set) 
         if (receivedParentEntityID != std::numeric_limits<EntityID>::max()) {
-            if (hasMappedEntity(receivedParentEntityID)) {
+            if (clientServerMapsHasEntity(receivedParentEntityID)) {
-                m_World->SetParent(m_ServerToClientMap.at(receivedEntityID), m_ServerToClientMap.at(receivedParentEntityID));
+                m_World->SetParent(m_ServerIDToClientID.at(receivedEntityID), m_ServerIDToClientID.at(receivedParentEntityID));
                 // If Parent dosen't exist create one and map receivedParentEntityID to it.
             } else {
                 // Create the new parent and add it to map
                 EntityID newParentEntityID = m_World->CreateEntity();
-                m_ServerToClientMap.insert(std::make_pair(receivedParentEntityID, newParentEntityID));
+                insertIntoServerClientMaps(receivedParentEntityID, newParentEntityID);
                 // Set the newly created Entity as parent.
-                m_World->SetParent(m_ServerToClientMap.at(receivedEntityID), newParentEntityID);
+                m_World->SetParent(m_ServerIDToClientID.at(receivedEntityID), newParentEntityID);
             }
         }
     }
@@ -252,7 +192,7 @@ 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;
 }
@@ -288,12 +228,6 @@ void Client::ping()
     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 (e.Command == "ConnectToServer") { // Connect for now
@@ -351,7 +285,19 @@ EntityID Client::createPlayer()
     return entityID;
 }
 
-bool Client::hasMappedEntity(EntityID entityID)
+bool Client::clientServerMapsHasEntity(EntityID clientEntityID)
 {
-    return m_ServerToClientMap.find(entityID) != m_ServerToClientMap.end();
+    return m_ClientIDToServerID.find(clientEntityID) != m_ClientIDToServerID.end();
+}
+
+bool Client::serverClientMapsHasEntity(EntityID serverEntityID)
+{
+    return m_ServerIDToClientID.find(serverEntityID) != m_ServerIDToClientID.end();
+}
+
+void Client::insertIntoServerClientMaps(EntityID serverEntityID, EntityID clientEntityID)
+{ 
+    m_ServerIDToClientID.insert(std::make_pair(serverEntityID, clientEntityID));
+    m_ClientIDToServerID.insert(std::make_pair(clientEntityID, serverEntityID));
+
 }

src/Engine/Network/Server.cpp

@@ -50,7 +50,7 @@ void Server::readFromClients()
 
     // Time out logic
     if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
-        //checkForTimeOuts();
+        checkForTimeOuts();
         timOutTimer = currentTime;
     }
 }
@@ -80,8 +80,6 @@ void Server::parseMessageType(Packet& packet)
     case MessageType::Disconnect:
         parseDisconnect();
         break;
-    case MessageType::Event:
-        break;
     case MessageType::OnInputCommand:
         parseOnInputCommand(packet);
         break;
@@ -120,23 +118,6 @@ void Server::send(Packet & packet)
         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) {
@@ -214,7 +195,7 @@ void Server::checkForTimeOuts()
 
 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
@@ -234,7 +215,7 @@ void Server::parseOnInputCommand(Packet& packet)
 }
 
 void Server::parseOnPlayerDamage(Packet & packet)
-{ 
+{
     Events::PlayerDamage e;
     e.DamageAmount = packet.ReadPrimitive<double>();
     e.PlayerDamagedID = packet.ReadPrimitive<EntityID>();
@@ -264,15 +245,16 @@ void Server::parseConnect(Packet& packet)
 
             LOG_INFO("Player \"%s\" connected on IP: %s", m_PlayerDefinitions[i].Name.c_str(), m_PlayerDefinitions[i].Endpoint.address().to_string().c_str());
 
+            // Send a message to the player that connected
             Packet packet(MessageType::Connect, m_SendPacketID);
             packet.WritePrimitive<int>(i); // Player ID
-
+            packet.WritePrimitive<EntityID>(m_PlayerDefinitions[i].EntityID); // Entity ID
             send(packet, i);
 
             // Send notification that a player has connected
-            std::string str = m_PacketID + "Player " + m_PlayerDefinitions[i].Name + " connected on: "
+            Packet notificationPacket(MessageType::PlayerConnected, m_PacketID);
-                + m_PlayerDefinitions[i].Endpoint.address().to_string();
+            broadcast(notificationPacket);
-            broadcast(str);
+
             break;
         }
     }