Merge remote-tracking branch 'origin/master' into FriendlyHost/Join

# Conflicts:
#	include/Engine/Network/Client.h

include/Engine/Network/Client.h

@@ -19,12 +19,16 @@
 #include "Core/World.h"
 #include "Core/EventBroker.h"
 #include "Core/ConfigFile.h"
+#include "Core/EPlayerDeath.h"
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
+#include "../Game/Events/EDoubleJump.h"
 #include "Network/EInterpolate.h"
 #include "Network/SnapshotFilter.h"
 #include "Core/EPlayerSpawned.h"
+#include "Core/EAmmoPickup.h"
 #include "Network/ESearchForServers.h"
+#include "../Game/Events/EDashAbility.h"
 #include "Network/EDisplayServerlist.h"
 
 class Client : public Network
@@ -36,7 +40,9 @@ public:
 
     void Connect(std::string address, int port);
     void Update() override;
-
+private:
+    //UDPClient m_Unreliable;
+    TCPClient m_Reliable;
     std::vector<Events::PlayerSpawned> m_PlayerSpawnEvents;
     void parseSpawnEvents();
     // Save for children
@@ -90,9 +96,11 @@ public:
     void parseEntityDeletion(Packet& packet);
     void parsePlayerDamage(Packet& packet);
     void parseComponentDeletion(Packet& packet);
-    void InterpolateFields(Packet & packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
+    void parseDoubleJump(Packet& packet);
+    void parseDashEffect(Packet& packet);
+    void parseAmmoPickup(Packet& packet);
+    void InterpolateFields(Packet& packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
     void parseSnapshot(Packet& packet);
-    void UpdateLocalCapturePointHUD(EntityWrapper capturePointHUD);
     void identifyPacketLoss();
     void hasServerTimedOut();
     EntityID createPlayer();
@@ -116,11 +124,13 @@ public:
     EventRelay<Client, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(const Events::PlayerSpawned& e);
     EventRelay< Client, Events::SearchForServers> m_ESearchForServers;
+    EventRelay<Client, Events::DoubleJump> m_EDoubleJump;
+    bool OnDoubleJump(Events::DoubleJump & e);
+    EventRelay<Client, Events::DashAbility> m_EDashAbility;
+    bool OnDashAbility(const Events::DashAbility& e);
+
     bool OnSearchForServers(const Events::SearchForServers& e);
-private:
-    UDPClient m_Unreliable;
     UDPClient m_ServerlistRequest;
-    TCPClient m_Reliable;
     std::vector<ServerInfo> m_Serverlist;
     bool m_SearchingForServers = false;
     std::clock_t m_StartSearchTime;

include/Engine/Network/EKillDeath.h

@@ -0,0 +1,19 @@
+#ifndef Events_KillDeath_h__
+#define Events_KillDeath_h__
+
+#include "Core/EventBroker.h"
+
+typedef unsigned int PlayerID;
+
+namespace Events
+{
+
+struct KillDeath : public Event 
+{
+    PlayerID Casualty = -1;
+    PlayerID Killer = -1;
+};
+
+}
+
+#endif

include/Engine/Network/EPlayerConnected.h

@@ -0,0 +1,17 @@
+#ifndef Events_PlayerConnected
+#define Events_PlayerConnected
+
+#include "Core/EventBroker.h"
+
+namespace Events
+{
+
+struct PlayerConnected : public Event
+{
+    std::string PlayerName = "";
+    int PlayerID = -1;
+};
+
+}
+#endif // !Events_PlayerConnected
+

include/Engine/Network/MessageType.h

@@ -19,7 +19,10 @@ enum class MessageType
     EntityDeleted,
     ComponentDeleted,
     PlayerTransform,
+    OnDoubleJump,
+    OnDashEffect,
     ServerlistRequest,
+    AmmoPickup,
     Invalid
 };
 

include/Engine/Network/Packet.h

@@ -24,7 +24,9 @@ public:
     {
         // Check if we are trying to add more than the package can fit.
         if (m_MaxPacketSize < m_Offset + sizeof(T)) {
-            LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for! New size is %i bytes\n", m_MaxPacketSize*2);
+            if (m_MaxPacketSize >= 32000) {
+                LOG_WARNING("Package::WritePrimitive(): New size is huge %i bytes\n", m_MaxPacketSize*2);
+            }
             resizeData();
         }
         memcpy(m_Data + m_Offset, &val, sizeof(T));

include/Engine/Network/Server.h

@@ -8,7 +8,6 @@
 
 #include "Network/TCPServer.h"
 #include "Network/UDPServer.h"
-#include "Network/UDPClient.h" //LOL
 #include "Network/MessageType.h"
 #include "Network/PlayerDefinition.h"
 #include "Core/World.h"
@@ -18,8 +17,13 @@
 #include "Core/EPlayerDamage.h"
 #include "Network/EPlayerDisconnected.h"
 #include "Core/EPlayerSpawned.h"
+#include "../Game/Events/EDoubleJump.h"
 #include "Core/EEntityDeleted.h"
 #include "Core/EComponentDeleted.h"
+#include "Core/EAmmoPickup.h"
+#include "Core/EPlayerDeath.h"
+#include "Network/EPlayerConnected.h"
+#include "Network/EKillDeath.h"
 
 class Server : public Network
 {
@@ -32,7 +36,7 @@ public:
 private:
     // Network channels
     TCPServer m_Reliable;
-    UDPServer m_Unreliable;
+    //UDPServer m_Unreliable;
     UDPServer m_ServerlistRequest;
     // dont forget to set these in the childrens receive logic
     boost::asio::ip::address m_Address;
@@ -76,18 +80,21 @@ private:
     void parseOnPlayerDamage(Packet& packet);
     void identifyPacketLoss();
     void kick(PlayerID player);
-    PlayerID GetPlayerIDFromEndpoint();
+    PlayerID getPlayerIDFromEndpoint();
+    PlayerID getPlayerIDFromEntityID(EntityID entityID);
     void parsePlayerTransform(Packet& packet);
     void parseOnInputCommand(Packet& packet);
     void parseClientPing();
     void parsePing();
-    void parseUDPConnect(Packet & packet);
-    void parseTCPConnect(Packet & packet);
+    bool parseDoubleJump(Packet& packet);
+    void parseDashEffect(Packet& packet);
+    void parseUDPConnect(Packet& packet);
+    void parseTCPConnect(Packet& packet);
     void parseDisconnect();
     void parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint);
     bool shouldSendToClient(EntityWrapper childEntity);
 
-    // Debug event
+    // Events
     EventRelay<Server, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
     EventRelay<Server, Events::PlayerSpawned> m_EPlayerSpawned;
@@ -98,6 +105,10 @@ private:
     bool OnComponentDeleted(const Events::ComponentDeleted& e);
     EventRelay<Server, Events::PlayerDamage> m_EPlayerDamage;
     bool OnPlayerDamage(const Events::PlayerDamage& e);
+    EventRelay<Server, Events::AmmoPickup> m_EAmmoPickup;
+    bool OnAmmoPickup(const Events::AmmoPickup& e);
+    EventRelay<Server, Events::PlayerDeath> m_EPlayerDeath;
+    bool OnPlayerDeath(const Events::PlayerDeath& e);
 };
 
 #endif

include/Engine/Network/TCPServer.h

@@ -25,10 +25,9 @@ private:
     std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor;
     boost::shared_ptr<boost::asio::ip::tcp::socket> lastReceivedSocket;
 
-    void handle_accept(boost::shared_ptr<boost::asio::ip::tcp::socket> socket,
-        int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers,
-        const boost::system::error_code& error);
     int readBuffer(PlayerDefinition& playerDefinition);
+    PlayerID getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+        boost::asio::ip::address address, unsigned short port);
     int GetPort();
     std::string GetAddress();
     int m_Port = 0;