Merge branch 'master' of https://github.com/teamfisk/TacticalZ

include/Engine/Collision/CollisionSystem.h

@@ -24,6 +24,7 @@ public:
 private:
     Octree<EntityAABB>* m_Octree;
     std::vector<EntityAABB> m_OctreeResult;
+    std::unordered_map<EntityWrapper, glm::vec3> m_PrevPositions;
 };
 
 #endif

include/Engine/Network/Client.h

@@ -21,6 +21,7 @@
 #include "Core/ConfigFile.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"
@@ -47,7 +48,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
@@ -101,6 +104,7 @@ public:
     void parseEntityDeletion(Packet& packet);
     void parsePlayerDamage(Packet& packet);
     void parseComponentDeletion(Packet& packet);
+    void parseDoubleJump(Packet& packet);
     void InterpolateFields(Packet & packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
     void parseSnapshot(Packet& packet);
     void identifyPacketLoss();
@@ -126,11 +130,10 @@ 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);
     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/MessageType.h

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

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,6 +17,7 @@
 #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"
 
@@ -81,8 +81,9 @@ private:
     void parseOnInputCommand(Packet& packet);
     void parseClientPing();
     void parsePing();
-    void parseUDPConnect(Packet & packet);
+    bool parseDoubleJump(Packet& packet);
-    void parseTCPConnect(Packet & packet);
+    void parseUDPConnect(Packet& packet);
+    void parseTCPConnect(Packet& packet);
     void parseDisconnect();
     void parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint);
     bool shouldSendToClient(EntityWrapper childEntity);

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;

include/Game/Events/EDoubleJump.h

@@ -8,7 +8,7 @@ namespace Events
 
 struct DoubleJump : public Event
 {
-
+    EntityID entityID;
 };
 
 }

include/Game/Systems/PlayerMovementSystem.h

@@ -34,9 +34,13 @@ private:
     glm::vec3 m_LastPosition = glm::vec3();
     // The logic for making the sound play when player is moving
     void playerStep(double dt);
+    // Spawn a hexagon at origin of an Entity
+    void spawnHexagon(EntityWrapper target);
 
     EventRelay<PlayerMovementSystem, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
+    EventRelay<PlayerMovementSystem, Events::DoubleJump> m_EDoubleJump;
+    bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e);
 
     void updateMovementControllers(double dt);
     void updateVelocity(EntityWrapper player, double dt);

resources/Schema/Components/Physics.xml

@@ -2,7 +2,6 @@
 <Physics xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Physics.xsd">
 	<Velocity X="0" Y="0" Z="0"/>
 	<Gravity>true</Gravity>
-	<PrevOrigin X="-9876.5" Y="-9876.5" Z="-9876.5"/>
 	<IsOnGround>false</IsOnGround>
 	<VerticalStepHeight>0.33</VerticalStepHeight>
 </Physics>

resources/Schema/Components/Physics.xsd

@@ -13,7 +13,6 @@
 					<xs:annotation><xs:documentation>m/s^2</xs:documentation></xs:annotation>
 				</xs:element>
 				<xs:element name="Gravity" type="t:bool" minOccurs="0"/>
-				<xs:element name="PrevOrigin" type="t:Vector" minOccurs="0"/>
 				<xs:element name="IsOnGround" type="t:bool" minOccurs="0"/>
 				<xs:element name="VerticalStepHeight" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>The largest height of a "stair-step" that can be walked over</xs:documentation></xs:annotation>

resources/Schema/Entities/Player.xml

@@ -13,7 +13,6 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
-      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

resources/Schema/Entities/PlayerRed.xml

@@ -13,7 +13,6 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
-      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

src/Engine/Collision/CollisionSystem.cpp

@@ -16,51 +16,51 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
 
-    glm::vec3 size = boxA.Size();
+    auto prevPosIt = m_PrevPositions.find(entity);
-    float diameter = std::min(size.x, size.z);
+    if (prevPosIt != m_PrevPositions.end()) {
-    glm::vec3 prevOrigin = (glm::vec3)cPhysics["PrevOrigin"];
+        glm::vec3 size = boxA.Size();
-    glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
+        float diameter = std::min(size.x, size.z);
-    float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
+        glm::vec3 prevOrigin = prevPosIt->second;
-    //If the entity has moved farther than the size of its box, we need to handle it specially.
+        glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
-    bool traceCollision = rayLength > diameter;
+        float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
-    //hack solution: If prevOrigin is less than -9000 in all dimensions, 
+        //If the entity has moved farther than the size of its box, we need to handle it specially.
-    //then it means it is not set, i.e. this is the first collision check for the entity.
+        if (rayLength > diameter) {
-    if (traceCollision && glm::any(glm::greaterThan((glm::vec3)cPhysics["PrevOrigin"], glm::vec3(-9000.f)))) {
+            Ray ray(prevOrigin, toCurrentPos);
-        Ray ray(prevOrigin, toCurrentPos);
+            m_OctreeResult.clear();
-        m_OctreeResult.clear();
+            m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
-        m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
+            for (auto& boxB : m_OctreeResult) {
-        for (auto& boxB : m_OctreeResult) {
+                if (boxA.Entity == boxB.Entity) {
-            if (boxA.Entity == boxB.Entity) {
-                continue;
-            }
-            bool hit;
-            float dist;
-            if (boxB.Entity.HasComponent("Model")) {
-                RawModel* model;
-                std::string res = (std::string)boxB.Entity["Model"]["Resource"];
-                try {
-                    model = ResourceManager::Load<RawModel, true>(res);
-                } catch (const std::exception&) {
                     continue;
                 }
-                float u, v;
+                bool hit;
-                hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
+                float dist;
-            } else {
+                if (boxB.Entity.HasComponent("Model")) {
-                hit = Collision::RayVsAABB(ray, boxB, dist);
+                    RawModel* model;
-            }
+                    std::string res = (std::string)boxB.Entity["Model"]["Resource"];
-            if (hit && dist < rayLength) {
+                    try {
-                //Set the entity to where it was colliding, minus the maximum box size. 
+                        model = ResourceManager::Load<RawModel, true>(res);
-                //TODO: Perhaps this should be done slightly more properly.
+                    } catch (const std::exception&) {
-                glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
+                        continue;
-                glm::vec3 resolve = newOriginPos - boxA.Origin();
+                    }
-                (glm::vec3&)cTransform["Position"] += resolve;
+                    float u, v;
-                boxA = *Collision::EntityAbsoluteAABB(entity);
+                    hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
-                if (resolve.y > 0) {
+                } else {
-                    everHitTheGround = true;
+                    hit = Collision::RayVsAABB(ray, boxB, dist);
-                    (bool)cPhysics["IsOnGround"] = true;
+                }
-                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                if (hit && dist < rayLength) {
+                    //Set the entity to where it was colliding, minus the maximum box size. 
+                    //TODO: Perhaps this should be done slightly more properly.
+                    glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
+                    glm::vec3 resolve = newOriginPos - boxA.Origin();
+                    (glm::vec3&)cTransform["Position"] += resolve;
+                    boxA = *Collision::EntityAbsoluteAABB(entity);
+                    if (resolve.y > 0) {
+                        everHitTheGround = true;
+                        (bool)cPhysics["IsOnGround"] = true;
+                        ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                    }
+                    break;
                 }
-                break;
             }
         }
     }
@@ -90,6 +90,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
             if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                 (glm::vec3&)cTransform["Position"] += resolutionVector;
+                boxA = *Collision::EntityAbsoluteAABB(entity);
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {
                     everHitTheGround = true;
@@ -99,6 +100,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             //Enter here if boxB has no Model.
             (glm::vec3&)cTransform["Position"] += resolutionVector;
+            boxA = *Collision::EntityAbsoluteAABB(entity);
             if (resolutionVector.y > 0) {
                 everHitTheGround = true;
                 (bool)cPhysics["IsOnGround"] = true;
@@ -112,5 +114,5 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         (bool)cPhysics["IsOnGround"] = false;
     }
 
-    (glm::vec3&)cPhysics["PrevOrigin"] = boxA.Origin();
+    m_PrevPositions[entity] = boxA.Origin();
 }

src/Engine/Network/Client.cpp

@@ -32,6 +32,7 @@ void Client::Connect(std::string address, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Client::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Client::OnPlayerDamage);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Client::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &Client::OnDoubleJump);
     EVENT_SUBSCRIBE_MEMBER(m_ESearchForServers, &Client::OnSearchForServers);
     auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_Address = address;
@@ -140,6 +141,9 @@ void Client::parseMessageType(Packet& packet)
     case MessageType::OnPlayerDamage:
         parsePlayerDamage(packet);
         break;
+    case MessageType::OnDoubleJump:
+        parseDoubleJump(packet);
+        break;
     default:
         break;
     }
@@ -272,6 +276,20 @@ void Client::parseComponentDeletion(Packet & packet)
     }
 }
 
+void Client::parseDoubleJump(Packet & packet)
+{
+    EntityID serverID = packet.ReadPrimitive<EntityID>();
+    if (!serverClientMapsHasEntity(serverID)) {
+        return;
+    }
+    Events::DoubleJump e;
+    e.entityID = m_ServerIDToClientID.at(serverID);
+    // If player is local player do not publish to prevent infinite feedback loop
+    if (e.entityID != m_LocalPlayer.ID) {
+        m_EventBroker->Publish(e);
+    }
+}
+
 void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID)
 {
     for (auto field : componentInfo.FieldsInOrder) {
@@ -348,7 +366,7 @@ void Client::parseSnapshot(Packet& packet)
                 EntityWrapper localEntity(m_World, localEntityID);
                 // Update entity
                 if (m_World->HasComponent(localEntityID, componentType)) {
-
+                    // TODO Fix memory leak here
                     SharedComponentWrapper newComponent = createSharedComponent(packet, localEntityID, componentInfo);
                     bool shouldApply = true;
                     // Apply potential filter function
@@ -392,7 +410,9 @@ void Client::parseSnapshot(Packet& packet)
         // This should be enough beacause we know that the entities arives in pre-order (there will always be a parent)
         if (serverParentID != EntityID_Invalid && serverClientMapsHasEntity(serverParentID)) {
             EntityID localEntityID = m_ServerIDToClientID.at(serverEntityID);
-            m_World->SetParent(localEntityID, m_ServerIDToClientID.at(serverParentID));
+            if (m_World->GetParent(localEntityID) != m_ServerIDToClientID.at(serverParentID)) {
+                m_World->SetParent(localEntityID, m_ServerIDToClientID.at(serverParentID));
+            }
         }
     }
     parseSpawnEvents();
@@ -460,6 +480,11 @@ bool Client::OnPlayerDamage(const Events::PlayerDamage & e)
     if (e.Inflictor != m_LocalPlayer) {
         return false;
     }
+    // Could this happen?
+    //if (!clientServerMapsHasEntity(e.Inflictor.ID) 
+    //    || !clientServerMapsHasEntity(e.Victim.ID)) {
+    //    return;
+    //}
 
     Packet packet(MessageType::OnPlayerDamage, m_SendPacketID);
     packet.WritePrimitive(m_ClientIDToServerID.at(e.Inflictor.ID));
@@ -494,7 +519,7 @@ void Client::parsePlayerDamage(Packet& packet)
     Events::PlayerDamage e;
     PlayerID victimID = packet.ReadPrimitive<EntityID>();
     PlayerID inflictorID = packet.ReadPrimitive<EntityID>();
-    if(!serverClientMapsHasEntity(victimID) || !serverClientMapsHasEntity(inflictorID)){
+    if (!serverClientMapsHasEntity(victimID) || !serverClientMapsHasEntity(inflictorID)) {
         return;
     }
     e.Inflictor = EntityWrapper(m_World, m_ServerIDToClientID.at(victimID));
@@ -506,6 +531,17 @@ void Client::parsePlayerDamage(Packet& packet)
     }
 }
 
+bool Client::OnDoubleJump(Events::DoubleJump & e)
+{
+    if (!clientServerMapsHasEntity(e.entityID) || e.entityID != m_LocalPlayer.ID) {
+        return false;
+    }
+    Packet packet(MessageType::OnDoubleJump);
+    packet.WritePrimitive(m_ClientIDToServerID.at(e.entityID));
+    m_Reliable.Send(packet);
+    return true;
+}
+
 void Client::sendLocalPlayerTransform()
 {
     if (!m_LocalPlayer.Valid()) {

src/Engine/Network/Server.cpp

@@ -29,9 +29,8 @@ Server::~Server()
 
 void Server::Update()
 {
-    PlayerDefinition pd;
-
     m_Reliable.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
+
     for (auto& kv : m_ConnectedPlayers) {
         while (kv.second.TCPSocket->available()) {
             // Packet will get real data in receive
@@ -47,6 +46,7 @@ void Server::Update()
         }
     }
 
+    PlayerDefinition pd;
     while (m_Unreliable.IsSocketAvailable()) {
         // Packet will get real data in receive
         Packet packet(MessageType::Invalid);
@@ -138,6 +138,9 @@ void Server::parseMessageType(Packet& packet)
     case MessageType::PlayerTransform:
         parsePlayerTransform(packet);
         break;
+    case MessageType::OnDoubleJump:
+        parseDoubleJump(packet);
+        break;
     default:
         break;
     }
@@ -504,7 +507,7 @@ bool Server::OnPlayerDamage(const Events::PlayerDamage& e)
     packet.WritePrimitive(e.Damage);
     reliableBroadcast(packet);
 
-    return false;
+    return true;
 }
 
 void Server::parseClientPing()
@@ -533,6 +536,12 @@ void Server::parsePing()
     }
 }
 
+bool Server::parseDoubleJump(Packet & packet)
+{
+    reliableBroadcast(packet);
+    return true;
+}
+
 void Server::parseOnInputCommand(Packet& packet)
 {
     PlayerID player = -1;

src/Engine/Network/TCPServer.cpp

@@ -4,6 +4,8 @@ using namespace boost::asio::ip;
 TCPServer::TCPServer() 
 {
     acceptor = std::unique_ptr<tcp::acceptor>(new tcp::acceptor(m_IOService, tcp::endpoint(tcp::v4(), 27666)));
+    // Make the acceptor non-blocking so we wont get stuck in AcceptNewConnections().
+    acceptor->non_blocking(true);
     m_Port = GetPort();
     m_Address = GetAddress();
 }
@@ -13,14 +15,24 @@ TCPServer::~TCPServer()
 
 void TCPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
 {
+    boost::system::error_code error;
     boost::shared_ptr<tcp::socket> newSocket = boost::shared_ptr<tcp::socket>(new tcp::socket(m_IOService));
-    m_IOService.poll();
+    acceptor->accept(*newSocket, error);
-    acceptor->async_accept(*newSocket,
+    // If no error occured add new tcp connection
-        boost::bind(&TCPServer::handle_accept, this, newSocket, boost::ref(nextPlayerID), boost::ref(connectedPlayers),
+    if (!error) {
-            boost::asio::placeholders::error));
+        // Add tcp socket to connections
+        boost::asio::ip::tcp::no_delay option(true);
+        newSocket->set_option(option);
+        PlayerDefinition pd;
+        pd.StopTime = std::clock();
+        pd.TCPSocket = newSocket;
+        pd.TCPAddress = newSocket.get()->remote_endpoint().address();
+        pd.TCPPort = newSocket.get()->remote_endpoint().port();
+        connectedPlayers[nextPlayerID++] = pd;
+    }
 }
 
-PlayerID GetPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+PlayerID TCPServer::getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
     boost::asio::ip::address address, unsigned short port)
 {
     for (auto& kv : connectedPlayers) {
@@ -32,24 +44,6 @@ PlayerID GetPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& con
     return -1;
 }
 
-void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket,
-    int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers,
-    const boost::system::error_code& error)
-{
-    if (!error && GetPlayerIDFromEndpoint(connectedPlayers, socket->remote_endpoint().address(),
-        socket->remote_endpoint().port()) == -1) {
-        // Add tcp socket to connections
-        boost::asio::ip::tcp::no_delay option(true);
-        socket->set_option(option);
-        PlayerDefinition pd;
-        pd.StopTime = std::clock();
-        pd.TCPSocket = socket;
-        pd.TCPAddress = socket.get()->remote_endpoint().address();
-        pd.TCPPort = socket.get()->remote_endpoint().port();
-        connectedPlayers[nextPlayerID++] = pd;
-    }
-}
-
 void TCPServer::Send(Packet & packet, PlayerDefinition & playerDefinition)
 {
     packet.UpdateSize();

src/Game/Systems/PlayerMovementSystem.cpp

@@ -4,6 +4,7 @@ PlayerMovementSystem::PlayerMovementSystem(SystemParams params)
     : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &PlayerMovementSystem::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &PlayerMovementSystem::OnDoubleJump);
 }
 
 PlayerMovementSystem::~PlayerMovementSystem()
@@ -36,7 +37,6 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
         if (!player.Valid()) {
             continue;
         }
-
         // Aim pitch
         EntityWrapper cameraEntity = player.FirstChildByName("Camera");
         if (cameraEntity.Valid()) {
@@ -122,15 +122,14 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 if (isOnGround) {
                     controller->SetDoubleJumping(false);
                 } else {
+                    // If IsServer and network is off this will not work
                     if (IsClient) {
                         //put a hexagon at the players feet
-                        auto hexagonEffect = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
+                        spawnHexagon(player);
-                        EntityFileParser parser(hexagonEffect);
-                        EntityID hexagonEffectID = parser.MergeEntities(m_World);
-                        EntityWrapper hexagonEW = EntityWrapper(m_World, hexagonEffectID);
-                        hexagonEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
                         controller->SetDoubleJumping(true);
+                        // Publish event for client to listen to
                         Events::DoubleJump e;
+                        e.entityID = player.ID;
                         m_EventBroker->Publish(e);
                     }
                 }
@@ -295,3 +294,26 @@ bool PlayerMovementSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     }
     return true;
 }
+
+bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e)
+{
+    // If entity does not exist, exit
+    if (!EntityWrapper(m_World, e.entityID).Valid()) { 
+        return false;
+    }
+    // If entity IsLocalPlayer, exit
+    if (e.entityID == m_LocalPlayer.ID) { 
+        return false;
+    }
+    spawnHexagon(EntityWrapper(m_World, e.entityID));
+}
+
+void PlayerMovementSystem::spawnHexagon(EntityWrapper target)
+{ 
+    //put a hexagon at the entitys... feet?
+    auto hexagonEffect = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
+    EntityFileParser parser(hexagonEffect);
+    EntityID hexagonEffectID = parser.MergeEntities(m_World);
+    EntityWrapper hexagonEW = EntityWrapper(m_World, hexagonEffectID);
+    hexagonEW["Transform"]["Position"] = (glm::vec3)target["Transform"]["Position"];
+}