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

# Conflicts:
#	src/Engine/Rendering/Renderer.cpp

include/Engine/Network/Client.h

@@ -24,6 +24,19 @@
 #include "Network/EInterpolate.h"
 #include "Network/SnapshotFilter.h"
 #include "Core/EPlayerSpawned.h"
+#include "Network/ESearchForServers.h"
+
+struct ServerInfo
+{
+    ServerInfo(std::string a, int b, std::string c, int d)
+    {
+        Address = a; Port = b; Name = c; PlayersConnected = d;
+    }
+    std::string Address = "";
+    int Port = 0;
+    std::string Name = "";
+    int PlayersConnected = 0;
+};
 
 class Client : public Network
 {
@@ -82,18 +95,22 @@ public:
     void parseTCPConnect(Packet& packet);
     void parsePlayerConnected(Packet& packet);
     void parsePing();
+    void parseServerlist(Packet& packet);
     void parseKick();
     void parsePlayersSpawned(Packet& packet);
     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 parseSnapshot(Packet& packet);
+    void UpdateLocalCapturePointHUD(EntityWrapper capturePointHUD);
     void identifyPacketLoss();
     void hasServerTimedOut();
     EntityID createPlayer();
     void sendInputCommands();
     void sendLocalPlayerTransform();
     void becomePlayer();
+    void displayServerlist();
     // Mapping Logic
     // Returns if local EntityID exist in map
     bool clientServerMapsHasEntity(EntityID clientEntityID);
@@ -109,10 +126,16 @@ public:
     bool OnPlayerDamage(const Events::PlayerDamage& e);
     EventRelay<Client, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(const Events::PlayerSpawned& e);
-    void parsePlayerDamage(Packet& packet);
+    EventRelay< Client, Events::SearchForServers> m_ESearchForServers;
+    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;
+    double m_SearchingTime = 2000; // Config I guess
 };
 
 #endif

include/Engine/Network/ESearchForServers.h

@@ -0,0 +1,12 @@
+#ifndef Events_SearchForServers_h__
+#define Events_SearchForServers_h__
+
+#include "Core/Event.h"
+
+namespace Events
+{
+
+struct SearchForServers : public Event { };
+
+}
+#endif

include/Engine/Network/HybridClient.h

@@ -1,13 +0,0 @@
-#ifndef HybridClient_h__
-#define HybridClient_h__
-
-class HybridClient
-{
-public:
-    HybridClient();
-    ~HybridClient();
-private:
-
-};
-
-#endif

include/Engine/Network/HybridServer.h

@@ -1,12 +0,0 @@
-#ifndef HybridServer_h__
-#define HybridServer_h__
-
-class HybridServer
-{
-public:
-    HybridServer();
-    ~HybridServer();
-private:
-};
-
-#endif

include/Engine/Network/MessageType.h

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

include/Engine/Network/NetworkClient.h

@@ -9,13 +9,16 @@ typedef unsigned int PacketID;
 class NetworkClient
 {
 public:
+    NetworkClient();
+    virtual ~NetworkClient();
     virtual void Connect(std::string playerName, std::string address, int port) = 0;
     virtual void Disconnect() = 0;
     virtual void Receive(Packet& packet) = 0;
     virtual void Send(Packet & packet) = 0;
     virtual bool IsSocketAvailable() = 0;
 protected:
-    char m_ReadBuffer[BUFFERSIZE] = { 0 };
+    char* m_ReadBuffer;
+    unsigned int m_BufferSize = BUFFERSIZE;
 };
 
 #endif

include/Engine/Network/NetworkServer.h

@@ -10,12 +10,15 @@ typedef unsigned int PacketID;
 class NetworkServer
 {
 public:
+    NetworkServer();
+    virtual ~NetworkServer();
     virtual void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers) = 0;
     virtual void Receive(Packet & packet, PlayerDefinition & playerDefinition) = 0;
     virtual void Send(Packet & packet, PlayerDefinition & playerDefinition) = 0;
     virtual void Send(Packet & packet) = 0;
 protected:
-    char m_ReadBuffer[BUFFERSIZE] = { 0 };
+    char* m_ReadBuffer;
+    unsigned int m_BufferSize = BUFFERSIZE;
 };
 
 #endif

include/Engine/Network/Server.h

@@ -8,6 +8,7 @@
 
 #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"
@@ -32,6 +33,7 @@ private:
     // Network channels
     TCPServer m_Reliable;
     UDPServer m_Unreliable;
+    UDPServer m_ServerlistRequest;
     // dont forget to set these in the childrens receive logic
     boost::asio::ip::address m_Address;
     int m_Port = 27666;
@@ -54,7 +56,7 @@ private:
     std::vector<Events::InputCommand> m_InputCommandsToBroadcast;
     //Timers
     std::clock_t m_StartPingTime;
-    
+
     // Packet loss logic
     PacketID m_PacketID = 0;
     PacketID m_PreviousPacketID = 0;
@@ -64,6 +66,7 @@ private:
     void reliableBroadcast(Packet& packet);
     void unreliableBroadcast(Packet& packet);
     void sendSnapshot();
+    void addPlayersToPacket(Packet& packet, EntityID entityID);
     void addChildrenToPacket(Packet& packet, EntityID entityID);
     void addInputCommandsToPacket(Packet& packet);
     void sendPing();
@@ -77,10 +80,11 @@ private:
     void parsePlayerTransform(Packet& packet);
     void parseOnInputCommand(Packet& packet);
     void parseClientPing();
-    void parsePing();    
+    void parsePing();
     void parseUDPConnect(Packet & packet);
     void parseTCPConnect(Packet & packet);
     void parseDisconnect();
+    void parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint);
     bool shouldSendToClient(EntityWrapper childEntity);
 
     // Debug event

include/Engine/Network/TCPClient.h

@@ -20,7 +20,7 @@ private:
     boost::asio::ip::tcp::endpoint m_Endpoint;
     boost::asio::io_service m_IOService;
     std::unique_ptr<boost::asio::ip::tcp::socket> m_Socket;
-    size_t readBuffer(char* data);
+    size_t readBuffer();
     PacketID m_SendPacketID = 0;
     bool m_IsConnected = false;
 };

include/Engine/Network/TCPServer.h

@@ -16,6 +16,9 @@ public:
     void Send(Packet & packet, PlayerDefinition & playerDefinition);
     void Send(Packet & packet);
     void Disconnect();
+    int Port() { return m_Port; }
+    std::string Address() { return m_Address; }
+
 private:
     // TCP logic
     boost::asio::io_service m_IOService;
@@ -25,7 +28,11 @@ private:
     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(char* data, PlayerDefinition& playerDefinition);
+    int readBuffer(PlayerDefinition& playerDefinition);
+    int GetPort();
+    std::string GetAddress();
+    int m_Port = 0;
+    std::string m_Address = "";
 };
 
 #endif

include/Engine/Network/UDPClient.h

@@ -14,13 +14,14 @@ public:
     void Disconnect();
     void Receive(Packet& packet);
     void Send(Packet & packet);
+    void Broadcast(Packet& packet, int port);
     bool IsSocketAvailable();
 private:
     // Assio UDP logic
     boost::asio::io_service m_IOService;
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
     boost::shared_ptr<boost::asio::ip::udp::socket> m_Socket;
-    int readBuffer(char* data);
+    int readBuffer();
     PacketID m_SendPacketID = 0;
 };
 

include/Engine/Network/UDPServer.h

@@ -8,18 +8,21 @@ class UDPServer : public NetworkServer
 {
 public:
     UDPServer();
+    UDPServer(int port);
     ~UDPServer();
     void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
     void Receive(Packet & packet, PlayerDefinition & playerDefinition);
     void Send(Packet & packet, PlayerDefinition & playerDefinition);
-    void Send(Packet & packet);
+    void Send(Packet & packet); 
+    void Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint);
+    void Broadcast(Packet & packet, int port);
     bool IsSocketAvailable();
 private:
     // UDP logic
     boost::asio::io_service m_IOService;
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
     std::unique_ptr<boost::asio::ip::udp::socket> m_Socket;
-    int readBuffer(char* data);
+    int readBuffer();
 };
 
 #endif

include/Engine/Rendering/CubeMapPass.h

@@ -0,0 +1,27 @@
+#ifndef CubeMapPass_h__
+#define CubeMapPass_h__
+
+#include "IRenderer.h"
+#include "ShaderProgram.h"
+
+class CubeMapPass
+{
+public:
+    CubeMapPass(IRenderer* renderer);
+    ~CubeMapPass() { }
+
+    void LoadTextures(std::string input);
+    void FillCubeMap(glm::vec3 originPosition);
+    void GenerateCubeMapTexture();
+
+    //GLuint CubeMapTexture() const { return m_CubeMapTexture; }
+    GLuint m_CubeMapTexture = -1;
+
+private:
+    IRenderer* m_Renderer;
+    std::string m_PreviusCubeMapTexture;
+
+    std::vector<Texture*> m_CubeMapTextures;
+};
+
+#endif 

include/Engine/Rendering/DrawFinalPass.h

@@ -4,6 +4,7 @@
 #include "IRenderer.h"
 #include "DrawFinalPassState.h"
 #include "LightCullingPass.h"
+#include "CubeMapPass.h"
 #include "FrameBuffer.h"
 #include "ShaderProgram.h"
 #include "Util/UnorderedMapVec2.h"
@@ -13,7 +14,7 @@
 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass);
     ~DrawFinalPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
@@ -62,12 +63,14 @@ private:
     GLuint m_SceneTextureLowRes;
     GLuint m_DepthBuffer;
     GLuint m_DepthBufferLowRes;
+    GLuint m_CubeMapTexture;
 
     //maqke this component based i guess?
     GLuint m_ShieldPixelRate = 16;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
+    const CubeMapPass* m_CubeMapPass;
 
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;

include/Engine/Rendering/Renderer.h

@@ -17,6 +17,7 @@
 #include "DrawBloomPass.h"
 #include "DrawColorCorrectionPass.h"
 #include "SSAOPass.h"
+#include "CubeMapPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
@@ -58,6 +59,7 @@ private:
     Model* m_UnitSphere;
 
     int m_DebugTextureToDraw = 0;
+    int m_CubeMapTexture = 0;
     bool m_ResizeWindow = false;
 	float m_SSAO_Radius = 1.0f;
 	float m_SSAO_Bias = 0.05f;
@@ -74,6 +76,7 @@ private:
     DrawBloomPass* m_DrawBloomPass;
     DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 	SSAOPass* m_SSAOPass;
+    CubeMapPass* m_CubeMapPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();

include/Engine/Rendering/SSAOPass.h

@@ -14,11 +14,14 @@ class SSAOPass
 {
 public:
 	SSAOPass(IRenderer* rendere);
-	~SSAOPass() { };
+	~SSAOPass() { 
+		delete m_DrawBloomPass;
+	};
 
 	void Draw(GLuint depthBuffer, Camera* camera);
 	void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns);
 	void ClearBuffer();
+	void OnWindowResize();
 
 	//Return the SSAO of the texture sent to Draw
 	GLuint SSAOTexture() const { return m_DrawBloomPass->GaussianTexture(); }
@@ -31,7 +34,6 @@ private:
 
 	void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
 
-	void ComputeAO(GLuint depthBuffer, Camera* camera);
 	//void blurHorizontal(GLuint depthBuffer);
 	//void blurVertical(GLuint depthBuffer);
 

include/Engine/Rendering/Texture.h

@@ -18,6 +18,7 @@ public:
 	void Bind(GLenum textureUnit = GL_TEXTURE0);
 
 	GLuint m_Texture = 0;
+    unsigned char* Data = nullptr;
     
 };
 

include/Game/Systems/DamageIndicatorSystem.h

@@ -14,11 +14,13 @@
 #include <glm/gtx/vector_angle.hpp>
 
 #include "Rendering/Util/CommonFunctions.h"
+//#define INDICATOR_TEST
 
-class DamageIndicatorSystem : public System
+class DamageIndicatorSystem : public ImpureSystem
 {
 public:
     DamageIndicatorSystem(SystemParams params);
+    virtual void Update(double dt) override;
 
 private:
     EventRelay<DamageIndicatorSystem, Events::PlayerDamage> m_EPlayerDamage;
@@ -28,6 +30,20 @@ private:
     bool OnSetCamera(const Events::SetCamera& e);
 
     EntityID m_CurrentCamera = -1;
+    struct DamageIndicatorStruct {
+        EntityWrapper spriteEntity;
+        glm::vec3 enemyPosition;
+        DamageIndicatorStruct(EntityWrapper sprite, glm::vec3 pos)
+            : spriteEntity(sprite)
+            , enemyPosition(pos) {}
+    };
+    std::vector<DamageIndicatorStruct> updateDamageIndicatorVector;
+    float CalculateAngle(EntityWrapper player, glm::vec3 enemyPos);
 
+    //for tests
+#ifdef INDICATOR_TEST
+    glm::vec3 DamageIndicatorTest(EntityWrapper player);
+    int m_TestVar = 0;
+#endif
 };
 #endif

include/Game/Systems/PlayerMovementSystem.h

@@ -39,5 +39,5 @@ private:
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
 
     void updateMovementControllers(double dt);
-    void updateVelocity(double dt);
+    void updateVelocity(EntityWrapper player, double dt);
 };

resources/Schema/Entities/Player.xml

@@ -304,8 +304,7 @@
                   </Children>
                 </Entity>
               </Children>
-            </Entity>
+            </Entity>            <Entity name="KillFeed">
-            <Entity name="KillFeed">
               <Components>
                 <c:KillFeed/>
                 <c:Transform>

resources/Shaders/ForwardPlus.frag.glsl

@@ -12,6 +12,7 @@ uniform vec4 FillColor;
 uniform vec4 AmbientColor;
 uniform float FillPercentage;
 uniform float GlowIntensity = 10;
+uniform vec3 CameraPosition;
 
 uniform vec2 DiffuseUVRepeat;
 uniform vec2 NormalUVRepeat;
@@ -22,6 +23,7 @@ layout (binding = 1) uniform sampler2D DiffuseTexture;
 layout (binding = 2) uniform sampler2D NormalMapTexture;
 layout (binding = 3) uniform sampler2D SpecularMapTexture;
 layout (binding = 4) uniform sampler2D GlowMapTexture;
+layout (binding = 5) uniform samplerCube CubeMap;
 
 #define TILE_SIZE 16
 
@@ -76,7 +78,7 @@ struct LightResult {
 };
 
 float CalcAttenuation(float radius, float dist, float falloff) {
-	return 1.0 - smoothstep(radius * 0.3, radius, dist);
+	return 1.0 - smoothstep(radius * falloff, radius, dist);
 }
 
 vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
@@ -132,7 +134,11 @@ void main()
 	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture);
 	normal = normalize(normal);
 	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
-	vec4 viewVec = normalize(-position); 
+	vec4 viewVec = normalize(-position);
+	vec3 I = normalize(vec3(M * vec4(Input.Position, 1.0)) - CameraPosition);
+	vec3 R = reflect(-I, Input.Normal);
+	//R = vec3(P * vec4(R, 1.0));
+	vec4 reflectionColor = texture(CubeMap, R);
 
 	vec2 tilePos;
 	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
@@ -163,6 +169,8 @@ void main()
 
 	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
 	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
+	color_result = color_result * clamp(1/specularTexel, 0, 1)*2 + reflectionColor * clamp(specularTexel, 0, 1)/2;
 	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
 	
 
@@ -172,9 +180,10 @@ void main()
 		color_result += FillColor;
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	//sceneColor = vec4(reflectionColor.xyz, 1);
 	color_result += glowTexel*GlowIntensity;
 
-	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), clamp(color_result.a, 0, 1));
 
 	//Tiled Debug Code
 	/*

resources/Shaders/ForwardPlus.vert.glsl

@@ -23,12 +23,12 @@ out VertexData{
 void main()
 {
 	gl_Position = P*V*M * vec4(Position, 1.0);
-	
+	mat4 TIM = transpose(inverse(M));
 	Output.Position = Position;
 	Output.TextureCoordinate = TextureCoords;
-	Output.Normal = vec3(M * vec4(Normal, 0.0));
+	Output.Normal = vec3(TIM * vec4(Normal, 0.0));
-	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
+	Output.Tangent = vec3(TIM * vec4(Tangent, 0.0));
- 	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
+ 	Output.BiTangent = vec3(TIM * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);
 	Output.ExplosionPercentageElapsed = 0.0;
 }

src/Engine/Network/Client.cpp

@@ -1,7 +1,7 @@
 #include "Network/Client.h"
 using namespace boost::asio::ip;
 
-Client::Client(World* world, EventBroker* eventBroker) 
+Client::Client(World* world, EventBroker* eventBroker)
     : Network(world, eventBroker)
 {
     // Asumes root node is EntityID_Invalid
@@ -13,6 +13,8 @@ Client::Client(World* world, EventBroker* eventBroker)
     m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
     m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
     LOG_INFO("Client initialized");
+
+    m_ServerlistRequest.Connect(m_PlayerName, "192.168.1.255", 32554);
 }
 
 Client::Client(World* world, EventBroker* eventBroker, std::unique_ptr<SnapshotFilter> snapshotFilter)
@@ -30,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_ESearchForServers, &Client::OnSearchForServers);
     auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_Address = address;
     if (address.empty()) {
@@ -66,6 +69,21 @@ void Client::Update()
 
     }
 
+    while (m_ServerlistRequest.IsSocketAvailable()) {
+        Packet packet(MessageType::Invalid);
+        m_ServerlistRequest.Receive(packet);
+        if (packet.GetMessageType() == MessageType::ServerlistRequest) {
+            parseServerlist(packet);
+        }
+    }
+
+    if (m_SearchingForServers) {
+        if (m_SearchingTime < (1000* (std::clock() - m_StartSearchTime) / (double)CLOCKS_PER_SEC)) {
+            m_SearchingForServers = false;
+            displayServerlist();
+        }
+    }
+
     if (m_IsConnected) {
         // Don't send 1 input in 1 packet, bunch em up.
         if (m_SendInputIntervalMs < (1000 * (std::clock() - m_TimeSinceSentInputs) / (double)CLOCKS_PER_SEC)) {
@@ -173,6 +191,22 @@ void Client::parsePing()
     m_Reliable.Send(packet);
 }
 
+
+void Client::parseServerlist(Packet& packet)
+{
+    // Pop size, message type, and ID
+    packet.ReadPrimitive<int>();
+    packet.ReadPrimitive<int>();
+    packet.ReadPrimitive<int>();
+    std::string address = packet.ReadString();
+    int port = packet.ReadPrimitive<int>();
+    std::string serverName = packet.ReadString();
+    int playersConnected = packet.ReadPrimitive<int>();
+    //TODO: This should not happen when a client is connected to a server
+
+    m_Serverlist.push_back({ address, port, serverName, playersConnected });
+}
+
 void Client::parseKick()
 {
     LOG_WARNING("You have been kicked from the server.");
@@ -190,12 +224,12 @@ void Client::parseSpawnEvents()
         }
         e.Player = EntityWrapper(m_World, m_ServerIDToClientID.at(m_PlayerSpawnEvents.at(i).Player.ID));
         //e.Spawner = EntityWrapper(m_World, m_ServerIDToClientID.at(m_PlayerSpawnEvents.at(i).Spawner.ID));
-        e.PlayerID = -1; 
+        e.PlayerID = -1;
         e.PlayerName = m_PlayerSpawnEvents.at(i).PlayerName;
         m_EventBroker->Publish(e);
     }
     m_PlayerSpawnEvents = tempSpawn;
-   // m_PlayerSpawnEvents.clear();
+    // m_PlayerSpawnEvents.clear();
 }
 
 void Client::parsePlayersSpawned(Packet& packet)
@@ -312,16 +346,18 @@ void Client::parseSnapshot(Packet& packet)
             if (serverClientMapsHasEntity(serverEntityID)) {
                 EntityID localEntityID = m_ServerIDToClientID.at(serverEntityID);
                 EntityWrapper localEntity(m_World, localEntityID);
-                
                 // Update entity
                 if (m_World->HasComponent(localEntityID, componentType)) {
+                    if (localEntity.Name() == "CapturePointHUD") {
+                        UpdateLocalCapturePointHUD(localEntity);
+                    }
                     SharedComponentWrapper newComponent = createSharedComponent(packet, localEntityID, componentInfo);
                     bool shouldApply = true;
                     // Apply potential filter function
                     if (m_SnapshotFilter != nullptr) {
                         shouldApply = m_SnapshotFilter->FilterComponent(localEntity, newComponent);
                     }
-                    if (shouldApply) {
+                    if (shouldApply) {                        
                         ComponentWrapper currentComponent = m_World->GetComponent(localEntityID, componentType);
                         memcpy(currentComponent.Data, newComponent.Data, componentInfo.Stride);
                     }
@@ -359,6 +395,18 @@ void Client::parseSnapshot(Packet& packet)
     parseSpawnEvents();
 }
 
+
+void Client::UpdateLocalCapturePointHUD(EntityWrapper capturePointHUD)
+{
+    //auto children = m_World->GetChildren(capturePointHUD.ID);
+    //for (auto it = children.first; it != children.second; it++) {
+    //    it->first
+    //}
+    //
+    //EntityWrapper& localHUD = m_LocalPlayer.FirstChildByName("HUD").FirstChildByName("CapturePointHUD");
+    //m_World->GetComponentPools()
+}
+
 void Client::disconnect()
 {
     m_IsConnected = false;
@@ -371,6 +419,12 @@ void Client::disconnect()
 
 bool Client::OnInputCommand(const Events::InputCommand & e)
 {
+    // TEMP
+    if (e.Command == "SearchForServers" && e.Value > 0) {
+        Events::SearchForServers e;
+        m_EventBroker->Publish(e);
+    }
+
     if (e.PlayerID != -1) {
         return false;
     }
@@ -433,6 +487,17 @@ bool Client::OnPlayerSpawned(const Events::PlayerSpawned& e)
     return true;
 }
 
+bool Client::OnSearchForServers(const Events::SearchForServers& e)
+{
+    m_SearchingForServers = true;
+    m_StartSearchTime = std::clock();
+    m_Serverlist.clear();
+    LOG_INFO("Searching for LAN servers...\n");
+    Packet packet(MessageType::ServerlistRequest);
+    m_ServerlistRequest.Broadcast(packet, 13); // TODO: Config
+    return true;
+}
+
 void Client::parsePlayerDamage(Packet& packet)
 {
     Events::PlayerDamage e;
@@ -467,7 +532,7 @@ void Client::sendLocalPlayerTransform()
     packet.WritePrimitive(orientation.x);
     packet.WritePrimitive(orientation.y);
     packet.WritePrimitive(orientation.z);
- 
+
     bool hasAssaultWeapon = m_LocalPlayer.HasComponent("AssaultWeapon");
     packet.WritePrimitive(hasAssaultWeapon);
     if (hasAssaultWeapon) {
@@ -475,7 +540,7 @@ void Client::sendLocalPlayerTransform()
         packet.WritePrimitive((int)cAssaultWeapon["MagazineAmmo"]);
         packet.WritePrimitive((int)cAssaultWeapon["Ammo"]);
     }
-    
+
     m_Unreliable.Send(packet);
 }
 
@@ -528,6 +593,16 @@ void Client::becomePlayer()
     m_Reliable.Send(packet);
 }
 
+
+void Client::displayServerlist()
+{
+    LOG_INFO("This is a serverlist:\n");
+    for (int i = 0; i < m_Serverlist.size(); i++) {
+        ServerInfo si = m_Serverlist[i];
+        LOG_INFO("%s:%i\t%s\t%i\n", si.Address.c_str(), si.Port, si.Name.c_str(), si.PlayersConnected);
+    }
+}
+
 bool Client::clientServerMapsHasEntity(EntityID clientEntityID)
 {
     if (m_ClientIDToServerID.find(clientEntityID) != m_ClientIDToServerID.end()) {

src/Engine/Network/HybridClient.cpp

@@ -1,10 +0,0 @@
-#include "Network/HybridClient.h"
-
-
-HybridClient::HybridClient()
-{
-}
-
-HybridClient::~HybridClient()
-{
-}

src/Engine/Network/HybridServer.cpp

@@ -1,9 +0,0 @@
-#include "Network/HybridServer.h"
-
-HybridServer::HybridServer()
-{ 
-}
-
-HybridServer::~HybridServer()
-{
-}

src/Engine/Network/NetworkClient.cpp

@@ -0,0 +1,11 @@
+#include "Network/NetworkClient.h"
+
+NetworkClient::NetworkClient()
+{ 
+    m_ReadBuffer = new char[m_BufferSize];
+}
+
+NetworkClient::~NetworkClient()
+{ 
+    delete[] m_ReadBuffer;
+}

src/Engine/Network/NetworkServer.cpp

@@ -0,0 +1,11 @@
+#include "Network/NetworkServer.h"
+
+NetworkServer::NetworkServer()
+{
+    m_ReadBuffer = new char[m_BufferSize];
+}
+
+NetworkServer::~NetworkServer()
+{ 
+    delete[] m_ReadBuffer;
+}

src/Engine/Network/Server.cpp

@@ -1,7 +1,8 @@
 #include "Network/Server.h"
 
-Server::Server(World* world, EventBroker* eventBroker, int port) 
+Server::Server(World* world, EventBroker* eventBroker, int port)
     : Network(world, eventBroker)
+    , m_ServerlistRequest(13)
 {
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
     snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
@@ -13,7 +14,7 @@ Server::Server(World* world, EventBroker* eventBroker, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EComponentDeleted, &Server::OnComponentDeleted);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Server::OnPlayerDamage);
 
-    // Bind
+    // BindWW
     if (port == 0) {
         port = config->Get<float>("Networking.Port", 27666);
     }
@@ -58,8 +59,24 @@ void Server::Update()
             parseMessageType(packet);
         }
     }
+
+    while (m_ServerlistRequest.IsSocketAvailable()) {
+        Packet packet(MessageType::Invalid);
+        PlayerDefinition localArea;
+        localArea.Endpoint = boost::asio::ip::udp::endpoint();
+        m_ServerlistRequest.Receive(packet, localArea);
+        if(packet.GetMessageType() == MessageType::ServerlistRequest) {
+            packet.ReadPrimitive<int>(); // Pop size
+            packet.ReadPrimitive<int>(); // Pop MsgType
+            packet.ReadPrimitive<int>(); // Pop packet ID
+            int port = packet.ReadPrimitive<int>();
+            std::string address = localArea.Endpoint.address().to_string();
+            parseServerlistRequest(boost::asio::ip::udp::endpoint(boost::asio::ip::address().from_string(address), port));
+        }
+    }
+
     // Check if players have disconnected
-    for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
+     for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
         disconnect(m_PlayersToDisconnect.at(i));
     }
     m_PlayersToDisconnect.clear();
@@ -75,6 +92,7 @@ void Server::Update()
         sendPing();
         previousePingMessage = currentTime;
     }
+
     // Time out logic
     if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
         checkForTimeOuts();
@@ -118,7 +136,7 @@ void Server::parseMessageType(Packet& packet)
         parseOnPlayerDamage(packet);
         break;
     case MessageType::PlayerTransform:
-        parsePlayerTransform(packet);
+       parsePlayerTransform(packet);
         break;
     default:
         break;
@@ -146,7 +164,7 @@ void Server::sendSnapshot()
 {
     Packet packet(MessageType::Snapshot);
     addInputCommandsToPacket(packet);
-    addChildrenToPacket(packet, EntityID_Invalid);
+    addPlayersToPacket(packet, EntityID_Invalid);
     unreliableBroadcast(packet);
 }
 
@@ -163,7 +181,7 @@ void Server::addInputCommandsToPacket(Packet& packet)
     m_InputCommandsToBroadcast.clear();
 }
 
-void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
+void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 {
     auto itPair = m_World->GetChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
@@ -171,6 +189,7 @@ void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
     for (auto it = itPair.first; it != itPair.second; it++) {
         EntityID childEntityID = it->second;
         // HACK: Only sync players for now, since the map turned out to be TOO LARGE to send in one snapshot and Simon's computer shits itself
+        // HACK: Also checked CapturePointHUD for now. (this would get out of sync);
         EntityWrapper childEntity(m_World, childEntityID);
         if (!shouldSendToClient(childEntity)) {
             continue;
@@ -212,6 +231,49 @@ void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
     }
 }
 
+void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
+{
+    auto itPair = m_World->GetChildren(entityID);
+    std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
+    // Loop through every child
+    for (auto it = itPair.first; it != itPair.second; it++) {
+        EntityID childEntityID = it->second;
+        // Write EntityID and parentsID and Entity name
+        packet.WritePrimitive(childEntityID);
+        packet.WritePrimitive(entityID);
+        packet.WriteString(m_World->GetName(childEntityID));
+        // Write components to child
+        int numberOfComponents = 0;
+        for (auto& i : worldComponentPools) {
+            if (i.second->KnowsEntity(childEntityID)) {
+                numberOfComponents++;
+            }
+        }
+        // Write how many components should be read
+        packet.WritePrimitive(numberOfComponents);
+        for (auto& i : worldComponentPools) {
+            // If the entity exist in the pool
+            if (i.second->KnowsEntity(childEntityID)) {
+                ComponentWrapper componentWrapper = i.second->GetByEntity(childEntityID);
+                // ComponentType
+                packet.WriteString(componentWrapper.Info.Name);
+                // Loop through fields
+                for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
+                    ComponentInfo::Field_t fieldInfo = componentWrapper.Info.Fields.at(componentField);
+                    if (fieldInfo.Type == "string") {
+                        std::string& value = componentWrapper[componentField];
+                        packet.WriteString(value);
+                    } else {
+                        packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
+                    }
+                }
+            }
+        }
+        // Go to to your children
+        addChildrenToPacket(packet, childEntityID);
+    }
+}
+
 void Server::sendPing()
 {
     // Prints connected players ping
@@ -230,6 +292,8 @@ void Server::sendPing()
     reliableBroadcast(packet);
 }
 
+
+
 void Server::checkForTimeOuts()
 {
     double startPing = 1000 * m_StartPingTime
@@ -304,6 +368,11 @@ void Server::parseTCPConnect(Packet & packet)
     connnectPacket.WritePrimitive(playerID);
     m_Reliable.Send(connnectPacket);
 
+    Packet firstSnapshot(MessageType::Snapshot);
+    addInputCommandsToPacket(firstSnapshot);
+    addChildrenToPacket(firstSnapshot, EntityID_Invalid);
+    m_Reliable.Send(firstSnapshot);
+
     // Send notification that a player has connected
     //Packet notificationPacket(MessageType::PlayerConnected);
     //broadcast(notificationPacket);
@@ -322,6 +391,17 @@ void Server::parseDisconnect()
     }
 }
 
+
+void Server::parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint)
+{
+    Packet packet(MessageType::ServerlistRequest);
+    packet.WriteString(m_Reliable.Address());
+    packet.WritePrimitive<int>(m_Reliable.Port());
+    packet.WriteString("SERVERNAME");
+    packet.WritePrimitive<int>(m_ConnectedPlayers.size());
+    m_ServerlistRequest.Send(packet);
+}
+
 void Server::disconnect(PlayerID playerID)
 {
     //broadcast("A player disconnected");
@@ -346,6 +426,7 @@ void Server::parseOnPlayerDamage(Packet & packet)
     e.Victim = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
     e.Damage = packet.ReadPrimitive<double>();
     m_EventBroker->Publish(e);
+
     //LOG_DEBUG("Server::parseOnPlayerDamage: Command is %s. Value is %f. PlayerID is %i.", e.DamageAmount, e.PlayerDamagedID, e.TypeOfDamage.c_str());
 }
 
@@ -375,7 +456,7 @@ bool Server::OnInputCommand(const Events::InputCommand & e)
         isReadingData = !isReadingData;
         m_SaveDataTimer = std::clock();
     }
-    if (e.Command == "KickPlayer" && e.Value > 0) {
+    else if (e.Command == "KickPlayer" && e.Value > 0) {
         kick(0);
     }
 
@@ -446,7 +527,9 @@ void Server::parsePing()
 {
     for (auto& kv : m_ConnectedPlayers) {
         if (kv.second.TCPAddress == m_Address &&
-            kv.second.TCPPort == m_Port) {
+            kv.second.TCPPort == m_Port
+            || (kv.second.Endpoint.address() == m_Address
+                && kv.second.Endpoint.port() == m_Port)) {
             kv.second.StopTime = std::clock();
             break;
         }
@@ -512,7 +595,8 @@ void Server::parsePlayerTransform(Packet& packet)
 
 bool Server::shouldSendToClient(EntityWrapper childEntity)
 {
-    return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid();
+    return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid()
+        || childEntity.HasComponent("CapturePoint") || childEntity.FirstParentWithComponent("CapturePoint").Valid();
 }
 
 PlayerID Server::GetPlayerIDFromEndpoint()

src/Engine/Network/TCPClient.cpp

@@ -56,32 +56,42 @@ void TCPClient::Disconnect()
 
 void TCPClient::Receive(Packet& packet)
 {
-    size_t bytesRead = readBuffer(m_ReadBuffer);
+    size_t bytesRead = readBuffer();
     if (bytesRead > 0) {
         packet.ReconstructFromData(m_ReadBuffer, bytesRead);
     }
 }
 
-size_t TCPClient::readBuffer(char* data)
+size_t TCPClient::readBuffer()
 { 
     if (!m_Socket) {
         return 0;
     }
     boost::system::error_code error;
     // Read size of packet
-    size_t bytesReceived = m_Socket->read_some(boost
+    m_Socket->receive(boost
-        ::asio::buffer((void*)data, sizeof(int)),
+        ::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
-        error);
+        boost::asio::ip::tcp::socket::message_peek, error);
-    int sizeOfPacket = 0;
+    unsigned int sizeOfPacket = 0;
-    memcpy(&sizeOfPacket, data, sizeof(int));
+    memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
 
+    // if the buffer is to small increase the size of it
+    // TODO if message is huge 1 time the buffer will not decrease.
+    if (sizeOfPacket > m_BufferSize) {
+        delete[] m_ReadBuffer;
+        m_ReadBuffer = new char[sizeOfPacket];
+        m_BufferSize = sizeOfPacket;
+    }
     // Read the rest of the message
-    bytesReceived += m_Socket->read_some(boost
+    size_t bytesReceived = m_Socket->read_some(boost
-        ::asio::buffer((void*)(data + bytesReceived), sizeOfPacket - bytesReceived),
+        ::asio::buffer((void*)(m_ReadBuffer), sizeOfPacket),
         error);
     if (error) {
         //LOG_ERROR("receive: %s", error.message().c_str());
     }
+    if (sizeOfPacket > 1000000)
+        LOG_WARNING("The packets received are bigger than 1MB");
+
     return bytesReceived;
 }
 

src/Engine/Network/TCPServer.cpp

@@ -1,14 +1,15 @@
 #include "Network/TCPServer.h"
 using namespace boost::asio::ip;
 
-TCPServer::TCPServer()
+TCPServer::TCPServer() 
 {
     acceptor = std::unique_ptr<tcp::acceptor>(new tcp::acceptor(m_IOService, tcp::endpoint(tcp::v4(), 27666)));
+    m_Port = GetPort();
+    m_Address = GetAddress();
 }
 
 TCPServer::~TCPServer()
-{
+{ }
-}
 
 void TCPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
 {
@@ -31,7 +32,7 @@ PlayerID GetPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& con
     return -1;
 }
 
-void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket, 
+void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket,
     int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers,
     const boost::system::error_code& error)
 {
@@ -51,8 +52,8 @@ void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket,
 
 void TCPServer::Send(Packet & packet, PlayerDefinition & playerDefinition)
 {
+    packet.UpdateSize();
     try {
-        packet.UpdateSize();
         int bytesSent = playerDefinition.TCPSocket->send(
             boost::asio::buffer(packet.Data(), packet.Size()),
             0);
@@ -73,38 +74,60 @@ void TCPServer::Send(Packet & packet)
 }
 
 void TCPServer::Disconnect()
-{ 
+{
+}
 
+int TCPServer::GetPort()
+{
+    return acceptor->local_endpoint().port();
+}
+
+std::string TCPServer::GetAddress()
+{
+    boost::asio::ip::tcp::resolver resolver(m_IOService);
+    boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), boost::asio::ip::host_name(), "");
+    boost::asio::ip::tcp::resolver::iterator it = resolver.resolve(query);
+    boost::asio::ip::tcp::endpoint endpoint = *it;
+    return endpoint.address().to_string().c_str();
 }
 
 void TCPServer::Receive(Packet & packet, PlayerDefinition & playerDefinition)
 {
-    int bytesRead = readBuffer(m_ReadBuffer, playerDefinition);
+    int bytesRead = readBuffer(playerDefinition);
     if (bytesRead > 0) {
         packet.ReconstructFromData(m_ReadBuffer, bytesRead);
     }
     lastReceivedSocket = playerDefinition.TCPSocket;
 }
 
-int TCPServer::readBuffer(char* data, PlayerDefinition & playerDefinition)
+int TCPServer::readBuffer(PlayerDefinition & playerDefinition)
 {
     if (!playerDefinition.TCPSocket) {
         return 0;
     }
     boost::system::error_code error;
     // Read size of packet
-    size_t bytesReceived = playerDefinition.TCPSocket->read_some(boost
+    playerDefinition.TCPSocket->receive(boost
-        ::asio::buffer((void*)data, sizeof(int)),
+        ::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
-        error);
+        boost::asio::ip::tcp::socket::message_peek, error);
-    int sizeOfPacket = 0;
+    unsigned int sizeOfPacket = 0;
-    memcpy(&sizeOfPacket, data, sizeof(int));
+    memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
 
+    // if the buffer is to small increase the size of it
+    if (sizeOfPacket > m_BufferSize) {
+        delete[] m_ReadBuffer;
+        m_ReadBuffer = new char[sizeOfPacket];
+        m_BufferSize = sizeOfPacket;
+    }
     // Read the rest of the message
-    bytesReceived += playerDefinition.TCPSocket->read_some(boost
+    size_t bytesReceived = playerDefinition.TCPSocket->read_some(boost
-        ::asio::buffer((void*)(data + bytesReceived), sizeOfPacket - bytesReceived),
+        ::asio::buffer((void*)(m_ReadBuffer), sizeOfPacket),
         error);
     if (error) {
         //LOG_ERROR("receive: %s", error.message().c_str());
     }
+    if (sizeOfPacket > 1000000)
+        LOG_WARNING("The packets received are bigger than 1MB");
+
     return bytesReceived;
 }

src/Engine/Network/UDPClient.cpp

@@ -15,9 +15,9 @@ void UDPClient::Connect(std::string playerName, std::string address, int port)
     if (m_Socket) {
         return;
     }
-    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
+    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address().from_string(address), port);
     m_Socket = boost::shared_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService));
-    m_Socket->connect(m_ReceiverEndpoint);
+    m_Socket->open(boost::asio::ip::udp::v4());
 }
 
 void UDPClient::Disconnect()
@@ -27,34 +27,66 @@ void UDPClient::Disconnect()
 
 void UDPClient::Receive(Packet& packet)
 {
-    int bytesRead = readBuffer(m_ReadBuffer);
+    int bytesRead = readBuffer();
     if (bytesRead > 0) { 
         packet.ReconstructFromData(m_ReadBuffer, bytesRead);
     }
 }
 
-int UDPClient::readBuffer(char* data)
+int UDPClient::readBuffer()
 {
     if (!m_Socket) {
         return 0;
     }
     boost::system::error_code error;
-    int bytesReceived = m_Socket->receive_from(boost
+    // Read size of packet
-        ::asio::buffer((void*)data, BUFFERSIZE),
+     m_Socket->receive(boost
-        m_ReceiverEndpoint,
+        ::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
-        0, error);
+         boost::asio::ip::udp::socket::message_peek, error);
+    int sizeOfPacket = 0;
+    memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
+
+    // if the buffer is to small increase the size of it
+    if (sizeOfPacket > m_BufferSize) {
+        delete[] m_ReadBuffer;
+        m_ReadBuffer = new char[sizeOfPacket];
+        m_BufferSize = sizeOfPacket;
+    }
+
+    size_t availableData = m_Socket->available();
+    // Read the rest of the message
+    size_t bytesReceived = m_Socket->receive_from(boost
+        ::asio::buffer((void*)(m_ReadBuffer),
+            sizeOfPacket),
+        m_ReceiverEndpoint, 0, error);
     if (error) {
         //LOG_ERROR("receive: %s", error.message().c_str());
     }
+    if (sizeOfPacket > 1000000)
+        LOG_WARNING("The packets received are bigger than 1MB");
+
     return bytesReceived;
 }
 
 void UDPClient::Send(Packet& packet)
 {
+    packet.UpdateSize();
     m_Socket->send_to(boost::asio::buffer(
         packet.Data(),
         packet.Size()),
         m_ReceiverEndpoint, 0);
+} 
+
+void UDPClient::Broadcast(Packet& packet, int port)
+{
+    packet.UpdateSize();
+    m_Socket->set_option(boost::asio::socket_base::broadcast(true));
+    m_Socket->send_to(boost::asio::buffer(
+        packet.Data(),
+        packet.Size()),
+        udp::endpoint(boost::asio::ip::address_v4().broadcast(), port)
+        , 0);
+    m_Socket->set_option(boost::asio::socket_base::broadcast(false));
 }
 
 bool UDPClient::IsSocketAvailable()

src/Engine/Network/UDPServer.cpp

@@ -5,11 +5,17 @@ UDPServer::UDPServer()
     m_Socket = std::unique_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666)));
 }
 
+UDPServer::UDPServer(int port)
+{
+    m_Socket = std::unique_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), port)));
+}
+
 UDPServer::~UDPServer()
 { }
 
 void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
 {
+    packet.UpdateSize();
     try {
         int bytesSent = m_Socket->send_to(
             boost::asio::buffer(packet.Data(), packet.Size()),
@@ -23,6 +29,7 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
 // Send back to endpoint of received packet
 void UDPServer::Send(Packet & packet)
 {
+    packet.UpdateSize();
     m_Socket->send_to(
         boost::asio::buffer(
             packet.Data(),
@@ -31,9 +38,35 @@ void UDPServer::Send(Packet & packet)
         0);
 }
 
+// Broadcasting respond specific logic
+void UDPServer::Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint)
+{
+    packet.UpdateSize();
+    m_Socket->send_to(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        endpoint,
+        0);
+}
+
+// Broadcasting
+void UDPServer::Broadcast(Packet & packet, int port)
+{
+    packet.UpdateSize();
+    m_Socket->set_option(boost::asio::socket_base::broadcast(true));
+    m_Socket->send_to(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        boost::asio::ip::udp::endpoint(boost::asio::ip::address_v4().broadcast(),port),
+        0);
+    m_Socket->set_option(boost::asio::socket_base::broadcast(false));
+}
+
 void UDPServer::Receive(Packet & packet, PlayerDefinition & playerDefinition)
 {
-    int bytesRead = readBuffer(m_ReadBuffer);
+    int bytesRead = readBuffer();
     if (bytesRead > 0) {
         packet.ReconstructFromData(m_ReadBuffer, bytesRead);
     }
@@ -45,17 +78,39 @@ bool UDPServer::IsSocketAvailable()
     return m_Socket->available();
 }
 
-int UDPServer::readBuffer(char* data)
+int UDPServer::readBuffer()
 {
-    boost::system::error_code error = boost::asio::error::host_not_found;
+    if (!m_Socket) {
-    unsigned int length = m_Socket->receive_from(
+        return 0;
-        boost::asio::buffer((void*)data
-            , BUFFERSIZE)
-        , m_ReceiverEndpoint, 0, error);
-    if (error) {
-        LOG_WARNING(error.message().c_str());
     }
-    return length;
+    int addasdasd = m_Socket->available();
+    boost::system::error_code error;
+    // Read size of packet
+     m_Socket->receive_from(boost
+        ::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
+        m_ReceiverEndpoint, boost::asio::ip::udp::socket::message_peek, error);
+    unsigned int sizeOfPacket = 0;
+    memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
+
+    // if the buffer is to small increase the size of it
+    if (sizeOfPacket > m_BufferSize) {
+        delete[] m_ReadBuffer;
+        m_ReadBuffer = new char[sizeOfPacket];
+        m_BufferSize = sizeOfPacket;
+    }
+
+    // Read the rest of the message
+    size_t bytesReceived = m_Socket->receive_from(boost
+        ::asio::buffer((void*)(m_ReadBuffer),
+            sizeOfPacket),
+        m_ReceiverEndpoint, 0, error);
+        if (error) {
+            //LOG_ERROR("receive: %s", error.message().c_str());
+        }
+        if (sizeOfPacket > 1000000)
+            LOG_WARNING("The packets received are bigger than 1MB");
+
+        return bytesReceived;
 }
 
 void UDPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)

src/Engine/Rendering/CubeMapPass.cpp

@@ -0,0 +1,40 @@
+#include "Rendering/CubeMapPass.h"
+
+CubeMapPass::CubeMapPass(IRenderer* renderer)
+    :m_Renderer(renderer)
+{
+    LoadTextures("Nevada");
+}
+
+void CubeMapPass::LoadTextures(std::string input)
+{
+    if (m_PreviusCubeMapTexture != input) {
+        m_CubeMapTextures.clear();
+        for (int i = 0; i < 6; i++) {
+            std::string str;
+            str = "Textures/Test/CubeMap/" + input + "/CubeMapTest0" + std::to_string(i) + ".png";
+            Texture* img = ResourceManager::Load<Texture>(str);
+            m_CubeMapTextures.push_back(img);
+        }
+        GenerateCubeMapTexture();
+    }
+}
+
+void CubeMapPass::GenerateCubeMapTexture()
+{
+    if (m_CubeMapTexture == -1) {
+        glGenTextures(1, &m_CubeMapTexture);
+    }
+    glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapTexture);
+
+    for (int i = 0; i < 6; i++) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA32F, m_CubeMapTextures[0]->Width, m_CubeMapTextures[0]->Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_CubeMapTextures[i]->Data);
+    }
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+    GLERROR("Generate Cubemap");
+}
+

src/Engine/Rendering/DrawBloomPass.cpp

@@ -52,6 +52,7 @@ void DrawBloomPass::InitializeBuffers()
 
 void DrawBloomPass::ClearBuffer()
 {
+    GLERROR("PRE");
     m_GaussianFrameBuffer_horiz.Bind();
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -60,6 +61,7 @@ void DrawBloomPass::ClearBuffer()
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_GaussianFrameBuffer_vert.Unbind();
+    GLERROR("END");
 }
 
 void DrawBloomPass::Draw(GLuint texture)

src/Engine/Rendering/DrawFinalPass.cpp

@@ -1,10 +1,11 @@
 #include "Rendering/DrawFinalPass.h"
 
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass)
+    : m_Renderer(renderer)
+    , m_LightCullingPass(lightCullingPass)
+    , m_CubeMapPass(cubeMapPass)
 {
     //TODO: Make sure that uniforms are not sent into shader if not needed.
-    m_Renderer = renderer;
-    m_LightCullingPass = lightCullingPass;
     m_ShieldPixelRate = 8;
     InitializeTextures();
     InitializeShaderPrograms();
@@ -192,8 +193,10 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
     state->StencilMask(0x00);
     DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
     GLERROR("OpaqueObjects");
+    state->BlendFunc(GL_ONE, GL_ONE);
     DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
     GLERROR("TransparentObjects");
+    state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     DrawSprites(scene.Jobs.SpriteJob, scene);
     GLERROR("SpriteJobs");
 
@@ -259,20 +262,35 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
 
 void DrawFinalPass::ClearBuffer()
 {
+    GLERROR("PRE");
     m_FinalPassFrameBufferLowRes.Bind();
+    GLERROR("Bind LowRes");
+
     glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    GLERROR("ViewPort,Scissor LowRes");
+
     glClearColor(0.f, 0.f, 0.f, 0.f);
+    GLERROR("1");
+
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    GLERROR("2");
+
     glDisable(GL_SCISSOR_TEST);
+    GLERROR("3");
+
     m_FinalPassFrameBufferLowRes.Unbind();
 
+    GLERROR("prebind HighRes");
     m_FinalPassFrameBuffer.Bind();
+    GLERROR("Bind HighRes");
     glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    GLERROR("ViewPort,Scissor LowRes");
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_FinalPassFrameBuffer.Unbind();
+    GLERROR("END");
 }
 
 
@@ -356,12 +374,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
             case RawModel::MaterialType::SingleTextures:
             {
                 if (explosionEffectJob->Model->IsSkinned()) {
+
                     m_ExplosionEffectSkinnedProgram->Bind();
                     GLERROR("Bind ExplosionEffectSkinned program");
                     //bind uniforms
                     BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
                     //bind textures
                     BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
+                    glActiveTexture(GL_TEXTURE5);
+                    glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
                     std::vector<glm::mat4> frameBones;
                     if (explosionEffectJob->AnimationOffset.animation != nullptr) {
                         frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
@@ -376,6 +399,10 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
                     //bind textures
                     BindExplosionTextures(explosionHandle, explosionEffectJob);
+                    glActiveTexture(GL_TEXTURE5);
+                    glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
                 }
                 break;
             }
@@ -434,6 +461,10 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
                             //bind textures
                             BindModelTextures(forwardSkinnedHandle, modelJob);
+                            glActiveTexture(GL_TEXTURE5);
+                            glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                            glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
                             std::vector<glm::mat4> frameBones;
                             if (modelJob->AnimationOffset.animation != nullptr) {
                                 frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
@@ -449,6 +480,9 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelUniforms(forwardHandle, modelJob, scene);
                             //bind textures
                             BindModelTextures(forwardHandle, modelJob);
+                            glActiveTexture(GL_TEXTURE5);
+                            glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+                            glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
                         }
                         break;
                     }
@@ -807,6 +841,8 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 
 void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job)
 {
+
+
 	switch (job->Type) {
 	case RawModel::MaterialType::SingleTextures:
 	case RawModel::MaterialType::Basic:

src/Engine/Rendering/PickingPass.cpp

@@ -21,23 +21,13 @@ void PickingPass::InitializeTextures()
 {
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
         glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
+
+	GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
+		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
 }
 
 void PickingPass::InitializeFrameBuffers()
 {
-   /* glGenRenderbuffers(1, &m_DepthBuffer);
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);*/
-
-	glGenTextures(1, &m_DepthBuffer);
-
-	glBindTexture(GL_TEXTURE_2D, m_DepthBuffer);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width), (int)(m_Renderer->GetViewportSize().Height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));
     m_PickingBuffer.Generate();
@@ -64,6 +54,7 @@ void PickingPass::InitializeShaderPrograms()
 
 void PickingPass::Draw(RenderScene& scene)
 {
+    GLERROR("PRE");
     PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
 
     //TODO: Render: Add code for more jobs than modeljobs.
@@ -367,6 +358,7 @@ void PickingPass::Draw(RenderScene& scene)
 
 void PickingPass::ClearPicking()
 {
+    GLERROR("PRE");
     m_PickingColorsToEntity.clear();
     m_EntityColors.clear();
     m_ColorCounter[0] = 0;
@@ -376,14 +368,13 @@ void PickingPass::ClearPicking()
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_PickingBuffer.Unbind();
+    GLERROR("END");
 }
 
 
 void PickingPass::OnWindowResize()
 {
     InitializeTextures();
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     m_PickingBuffer.Generate();
 }
 

src/Engine/Rendering/PickingPassState.cpp

@@ -3,9 +3,9 @@
 
 PickingPassState::PickingPassState(GLuint frameBuffer)
 {
-    GLERROR("---2");
+    GLERROR("PRE");
     BindFramebuffer(frameBuffer);
-    GLERROR("---3");
+    GLERROR("Bind Framebuffer");
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
     Disable(GL_BLEND);
@@ -13,6 +13,7 @@ PickingPassState::PickingPassState(GLuint frameBuffer)
     glm::vec4 clearColor = glm::vec4(0.f);
     //ClearColor(clearColor);
     //Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    GLERROR("END");
 }
 
 PickingPassState::~PickingPassState()

src/Engine/Rendering/Renderer.cpp

@@ -30,6 +30,7 @@ void Renderer::glfwFrameBufferCallback(GLFWwindow* window, int width, int height
     currentRenderer->m_LightCullingPass->OnWindowResize();
     currentRenderer->m_PickingPass->OnWindowResize();
     currentRenderer->m_DrawBloomPass->OnWindowResize();
+	currentRenderer->m_SSAOPass->OnWindowResize();
 }
 
 void Renderer::InitializeWindow()
@@ -88,9 +89,6 @@ void Renderer::InitializeShaders()
     //m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ExplosionEffect.frag.glsl")));
     //m_ExplosionEffectProgram->Compile();
     //m_ExplosionEffectProgram->Link();
-
-
-
 }
 
 void Renderer::InputUpdate(double dt)
@@ -108,7 +106,14 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
+    GLERROR("PRE");
     ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
+    ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
+    if(m_CubeMapTexture == 0) {
+        m_CubeMapPass->LoadTextures("Nevada");
+    } else if (m_CubeMapTexture == 1) {
+        m_CubeMapPass->LoadTextures("Sky");
+    }
 
 	ImGui::SliderFloat("SSAO sample radius", &m_SSAO_Radius, 0.01f, 5.0f);
 	ImGui::SliderFloat("SSAO bias", &m_SSAO_Bias, 0.0f, 0.1f);
@@ -117,6 +122,7 @@ void Renderer::Draw(RenderFrame& frame)
 	ImGui::SliderInt("SSAO Number of Samples", &m_SSAO_NumOfSamples, 2, 100);
 	ImGui::SliderInt("SSAO Number of Turns", &m_SSAO_NumOfTurns, 0, 50);
 	m_SSAOPass->Setting(m_SSAO_Radius, m_SSAO_Bias, m_SSAO_Contrast, m_SSAO_IntensityScale, m_SSAO_NumOfSamples, m_SSAO_NumOfTurns);
+    GLERROR("SSAO Settings");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -126,7 +132,9 @@ void Renderer::Draw(RenderFrame& frame)
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
     m_DrawBloomPass->ClearBuffer();
+	m_SSAOPass->ClearBuffer();
     PerformanceTimer::StopTimer("Renderer-ClearBuffers");
+    GLERROR("ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
 		PerformanceTimer::StartTimer("Renderer-Depth");
 		m_PickingPass->Draw(*scene);
@@ -239,9 +247,10 @@ void Renderer::InitializeRenderPasses()
 {
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
-    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
+    m_CubeMapPass = new CubeMapPass(this);
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass);
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
-	m_SSAOPass = new SSAOPass(this);
+    m_SSAOPass = new SSAOPass(this);
 }

src/Engine/Rendering/SSAOPass.cpp

@@ -6,6 +6,7 @@ SSAOPass::SSAOPass(IRenderer* renderer)
 
 	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
+	InitializeTexture();
 	InitializeBuffer();
 	InitializeShaderProgram();
 	Setting(0.1f, 0.012f, 1.0f, 1.0f, 13, 7);
@@ -28,16 +29,16 @@ void SSAOPass::InitializeShaderProgram()
 	m_SSAOViewSpaceZProgram->Link();
 }
 
+void SSAOPass::InitializeTexture() {
+	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
+	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
+}
 
 void SSAOPass::InitializeBuffer()
 {
-	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
-
 	m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
 	m_SSAOFramBuffer.Generate();
 
-	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
-
 	m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
 	m_SSAOViewSpaceZFramBuffer.Generate();
 }
@@ -45,12 +46,12 @@ void SSAOPass::InitializeBuffer()
 void SSAOPass::ClearBuffer()
 {
 	m_SSAOFramBuffer.Bind();
-	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClearColor(1.f, 1.f, 1.f, 1.f);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	m_SSAOFramBuffer.Unbind();
 
 	m_SSAOViewSpaceZFramBuffer.Bind();
-	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClearColor(1.f, 1.f, 1.f, 1.f);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	m_SSAOViewSpaceZFramBuffer.Unbind();
 }
@@ -136,6 +137,9 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 	m_DrawBloomPass->Draw(m_SSAOTexture);
 }
 
-void ComputeAO(GLuint depthBuffer, Camera* camera) {
+void SSAOPass::OnWindowResize() {
-
+	m_DrawBloomPass->OnWindowResize();
+	InitializeTexture();
+	m_SSAOFramBuffer.Generate();
+	m_SSAOViewSpaceZFramBuffer.Generate();
 }

src/Engine/Rendering/Texture.cpp

@@ -18,6 +18,7 @@ Texture::Texture(std::string path)
 
     this->Width = img->Width;
     this->Height = img->Height;
+    this->Data = img->Data;
 
     GLint format;
     switch (img->Format) {
@@ -28,6 +29,7 @@ Texture::Texture(std::string path)
         format = GL_RGBA;
         break;
     }
+    
 
     // Construct the OpenGL texture
     glGenTextures(1, &m_Texture);

src/Game/Systems/CapturePointSystem.cpp

@@ -1,32 +1,34 @@
 #include "Systems/CapturePointSystem.h"
 #include <algorithm>
 
-CapturePointSystem::CapturePointSystem(SystemParams params) 
+CapturePointSystem::CapturePointSystem(SystemParams params)
     : System(params)
     , PureSystem("CapturePoint")
 {
     //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
-    if (IsClient) {
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
-        EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
-        EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
+    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
-        EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
+
-    }
 }
 
 //here all capturepoints will update their component
 //NOTE: needs to run each frame, since we're possibly modifying the captureTimer for the capturePoints by dt
 void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, ComponentWrapper& cCapturePoint, double dt)
 {
-    if (!IsClient) {
-        return;
-    }
-
     if (m_WinnerWasFound) {
         return;
     }
     const int capturePointNumber = cCapturePoint["CapturePointNumber"];
     const bool hasTeamComponent = capturePointEntity.HasComponent("Team");
 
+    if (m_NumberOfCapturePoints != 0) {
+        if (!m_CapturePointNumberToEntityMap[0].HasComponent("CapturePoint")) {
+            //if map has changed, the capturepoints has changed, now have to redo them
+            m_NumberOfCapturePoints = 0;
+            m_CapturePointNumberToEntityMap.clear();
+        }
+    }
     //if point doesnt have a teamComponent yet, add one. since:
     //what if capture point has no team -> we cant get/use the team enum from it...
     if (!hasTeamComponent) {
@@ -71,8 +73,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     std::map<std::string, int> nextPossibleCapturePoint;
     nextPossibleCapturePoint["Red"] = -1;
     nextPossibleCapturePoint["Blue"] = -1;
-    for (int i = 0; i < m_NumberOfCapturePoints; i++)
+    for (int i = 0; i < m_NumberOfCapturePoints; i++) {
-    {
         if (!m_CapturePointNumberToEntityMap[i].HasComponent("Team")) {
             continue;
         }
@@ -84,8 +85,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
             nextPossibleCapturePoint["Blue"] = i + 1;
         }
     }
-    for (int i = m_NumberOfCapturePoints - 1; i >= 0; i--)
+    for (int i = m_NumberOfCapturePoints - 1; i >= 0; i--) {
-    {
         if (!m_CapturePointNumberToEntityMap[i].HasComponent("Team")) {
             continue;
         }
@@ -100,8 +100,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 
     //reset timers and reset the bool that triggers this
     if (m_ResetTimers) {
-        for (int i = 0; i < m_NumberOfCapturePoints; i++)
+        for (int i = 0; i < m_NumberOfCapturePoints; i++) {
-        {
             ComponentWrapper& capturePoint = m_CapturePointNumberToEntityMap[i]["CapturePoint"];
             if ((int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Red"] &&
                 (int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Blue"]) {
@@ -116,8 +115,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     }
 
     //check how many players are standing inside and are healthy
-    for (size_t i = m_ETriggerTouchVector.size(); i > 0; i--)
+    for (size_t i = m_ETriggerTouchVector.size(); i > 0; i--) {
-    {
         auto triggerTouched = m_ETriggerTouchVector[i - 1];
         if (std::get<1>(triggerTouched) == capturePointEntity) {
             //some player has touched this - lets figure out: what team, health
@@ -176,8 +174,8 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
             cCapturePoint["CaptureTimer"] = (double)cCapturePoint["CaptureTimer"] + timerDeltaChange;
         }
         //if capturePoint is owned by the team, and the other team has been trying to take it, then increase/decrease the timer towards 0.0
-        if ((ownedBy == currentTeam && currentTeam == redTeam && (double)cCapturePoint["CaptureTimer"] < 0.0) ||
+        if ((ownedBy == currentTeam && currentTeam == redTeam && (double)cCapturePoint["CaptureTimer"] < captureTimeToTakeOver) ||
-            (ownedBy == currentTeam && currentTeam == blueTeam && (double)cCapturePoint["CaptureTimer"] > 0.0)) {
+            (ownedBy == currentTeam && currentTeam == blueTeam && (double)cCapturePoint["CaptureTimer"] > -captureTimeToTakeOver)) {
             cCapturePoint["CaptureTimer"] = (double)cCapturePoint["CaptureTimer"] + timerDeltaChange;
         }
         //check if captureTimer > captureTimeToTakeOver and if so change owner and publish the eCaptured event
@@ -195,17 +193,14 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 
     //check for possible winCondition = check if the homebase is owned by the other team
     bool checkForWinner = false;
-    if (capturePointNumber == m_RedTeamHomeCapturePoint && ownedBy != redTeam)
+    if (capturePointNumber == m_RedTeamHomeCapturePoint && ownedBy != redTeam) {
-    {
         checkForWinner = true;
     }
-    if (capturePointNumber == m_BlueTeamHomeCapturePoint && ownedBy != blueTeam)
+    if (capturePointNumber == m_BlueTeamHomeCapturePoint && ownedBy != blueTeam) {
-    {
         checkForWinner = true;
     }
 
-    if (checkForWinner && !m_WinnerWasFound)
+    if (checkForWinner && !m_WinnerWasFound) {
-    {
         //publish Win event
         Events::Win e;
         e.TeamThatWon = ownedBy;
@@ -224,8 +219,7 @@ bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e)
 
 bool CapturePointSystem::OnTriggerLeave(const Events::TriggerLeave& e)
 {
-    for (size_t i = 0; i < m_ETriggerTouchVector.size(); i++)
+    for (size_t i = 0; i < m_ETriggerTouchVector.size(); i++) {
-    {
         auto triggerTouched = m_ETriggerTouchVector[i];
         if (std::get<0>(triggerTouched) == e.Entity && std::get<1>(triggerTouched) == e.Trigger) {
             m_ETriggerTouchVector.erase(m_ETriggerTouchVector.begin() + i);

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -12,51 +12,41 @@ DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
     auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
 }
 
+void DamageIndicatorSystem::Update(double dt) {
+    if (!IsServer) {
+        for (auto& iter = updateDamageIndicatorVector.begin(); iter != updateDamageIndicatorVector.end(); iter++) {
+            if (!iter->spriteEntity.Valid()) {
+                updateDamageIndicatorVector.erase(iter);
+                break;
+            }
+            auto angleBetweenVectors = CalculateAngle(LocalPlayer, iter->enemyPosition);
+            //simply set the rotation z-wise to the angleBetweenVectors
+            iter->spriteEntity["Transform"]["Orientation"] = glm::vec3(0, 0, angleBetweenVectors);
+        }
+    }
+}
+
 bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
 {
     if (m_CurrentCamera == EntityID_Invalid) {
         return false;
     }
 
-    //if (e.Victim != LocalPlayer) {
-    //    return false;
-    //}
     if (e.Victim.Valid() && e.Victim != LocalPlayer && !e.Victim.IsChildOf(LocalPlayer)) {
         return false;
     }
 
     if (!e.Inflictor.Valid() || !e.Victim.Valid()) {
-        return false; 
+        return false;
     }
 
-    //grab players direction
+    glm::vec3 inflictorPos = e.Inflictor["Transform"]["Position"];
-    auto playerOrientation = glm::quat((glm::vec3)e.Victim["Transform"]["Orientation"]);
+    //if testing
+#ifdef INDICATOR_TEST
+        inflictorPos = DamageIndicatorTest(e.Victim);
+#endif
 
-    //get the position vectors, but ignore the y-height
+    float angleBetweenVectors = CalculateAngle(e.Victim, inflictorPos);
-    auto enemyPosition = (glm::vec3)e.Inflictor["Transform"]["Position"];
-    auto playerPosition = (glm::vec3)e.Victim["Transform"]["Position"];
-    enemyPosition.y = 0.0f;
-    playerPosition.y = 0.0f;
-
-    //calculate the enemy to player vector
-    auto enemyPlayerVector = glm::normalize(playerPosition - enemyPosition);
-
-    //get angle from players current rotation, this angle is how much you rotate around the y-axis
-    auto playerAngle = glm::angle(playerOrientation);
-    auto playerRotationVector = glm::normalize(glm::rotateY(glm::vec3(0, 0, 1), playerAngle));
-
-    //dot product of players direction-vector and enemys-to-playervector will give the cos of the angle between the vectors
-    auto playerRotationDot = glm::dot(playerRotationVector, enemyPlayerVector);
-    //to get the angle between the vectors just do cos-inverse
-    auto angleBetweenVectors = glm::acos(playerRotationDot);
-
-    //rotate the direction-vector 90 degrees to get the players side-vector
-    auto playerSideVector = glm::normalize(glm::rotateY(glm::vec3(0, 0, 1), playerAngle + 1.57f));
-    //dot of sidevector positive = enemy is on the right side, dot sidevector negative = left side
-    auto playerSideVectorDot = glm::dot(playerSideVector, enemyPlayerVector);
-    if (playerSideVectorDot < 0) {
-        angleBetweenVectors = -angleBetweenVectors;
-    }
 
     //load & set the "2d" sprite
     auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
@@ -67,6 +57,10 @@ bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
     //simply set the rotation z-wise to the angleBetweenVectors
     spriteWrapper["Transform"]["Orientation"] = glm::vec3(0, 0, angleBetweenVectors);
 
+    if (!IsServer) {
+        updateDamageIndicatorVector.emplace_back(spriteWrapper, inflictorPos);
+    }
+
     return true;
 }
 
@@ -74,3 +68,82 @@ bool DamageIndicatorSystem::OnSetCamera(const Events::SetCamera& e) {
     m_CurrentCamera = e.CameraEntity.ID;
     return true;
 }
+
+float DamageIndicatorSystem::CalculateAngle(EntityWrapper player, glm::vec3 enemyPos) {
+    //grab players direction
+    auto playerOrientation = glm::quat((glm::vec3)player["Transform"]["Orientation"]);
+
+    //get the position vectors, but ignore the y-height
+    auto enemyPosition = enemyPos;
+    auto playerPosition = (glm::vec3)player["Transform"]["Position"];
+    enemyPosition.y = 0.0f;
+    playerPosition.y = 0.0f;
+
+    //calculate the enemy to player vector
+    auto enemyPlayerVector = glm::normalize(playerPosition - enemyPosition);
+
+    //get the rotationvector relative to the z-axis
+    auto rotationVectorVec3 = glm::vec3(glm::toMat4(Transform::AbsoluteOrientation(player))*glm::vec4(0, 0, 1, 0));
+    //rotate the direction-vector 90 degrees to get the players side-vector
+    auto playerSideVector = glm::vec3(glm::rotateY(rotationVectorVec3, 1.57f));
+
+    //dot product of players direction-vector and enemys-to-playervector will give the cos of the angle between the vectors
+    auto playerRotationDot = glm::dot(rotationVectorVec3, enemyPlayerVector);
+    //to get the angle between the vectors just do cos-inverse
+    auto angleBetweenVectors = glm::acos(playerRotationDot);
+
+    //dot of sidevector positive = enemy is on the right side, dot sidevector negative = left side
+    auto playerSideVectorDot = glm::dot(playerSideVector, enemyPlayerVector);
+    if (playerSideVectorDot < 0) {
+        angleBetweenVectors = -angleBetweenVectors;
+    }
+
+    return angleBetweenVectors;
+}
+#ifdef INDICATOR_TEST
+glm::vec3 DamageIndicatorSystem::DamageIndicatorTest(EntityWrapper player) {
+    auto currentPos = (glm::vec3)player["Transform"]["Position"];
+
+    auto testVar = 1;
+    auto testVar2 = 1;
+    if (m_TestVar % 4 == 0) {
+        testVar = -1;
+        testVar2 = 1;
+    }
+    if (m_TestVar % 4 == 1) {
+        testVar = 1;
+        testVar2 = 1;
+    }
+    if (m_TestVar % 4 == 2) {
+        testVar *= -1;
+        testVar2 = -1;
+    }
+    if (m_TestVar % 4 == 3) {
+        testVar = 1;
+        testVar2 = -1;
+    }
+    m_TestVar++;
+
+     auto inflictorPos = glm::vec3(currentPos.x + testVar*6.0f, currentPos.y, currentPos.z + testVar2*6.0f);
+
+    //load the explosioneffect XML
+    auto deathEffect = ResourceManager::Load<EntityFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
+    EntityFileParser parser(deathEffect);
+    EntityID deathEffectID = parser.MergeEntities(m_World);
+    EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
+
+    //components that we need from player
+    auto playerModel = player.FirstChildByName("PlayerModel");
+    auto playerEntityModel = playerModel["Model"];
+    auto playerEntityAnimation = playerModel["Animation"];
+
+    //copy the data from player to explosioneffectmodel
+    playerEntityModel.Copy(deathEffectEW["Model"]);
+    playerEntityAnimation.Copy(deathEffectEW["Animation"]);
+
+    //copy the models position,orientation
+    deathEffectEW["Transform"]["Position"] = inflictorPos;
+    deathEffectEW["Transform"]["Orientation"] = (glm::vec3)player["Transform"]["Orientation"];
+    return inflictorPos;
+}
+#endif

src/Game/Systems/PlayerDeathSystem.cpp

@@ -33,9 +33,8 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
 
     //components that we need from player
-    auto playerCamera = player.FirstChildByName("Camera");
     auto playerModel = player.FirstChildByName("PlayerModel");
-    if (!playerCamera.Valid() || !playerModel.Valid()) {
+    if (!playerModel.Valid()) {
         return;
     }
     if (!playerModel.HasComponent("Model") || !playerModel.HasComponent("Animation")) {
@@ -44,7 +43,7 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     auto playerEntityModel = playerModel["Model"];
     auto playerEntityAnimation = playerModel["Animation"];
 
-    //copy the data from player to explisioneffectmodel
+    //copy the data from player to explosioneffectmodel
     playerEntityModel.Copy(deathEffectEW["Model"]);
     playerEntityAnimation.Copy(deathEffectEW["Animation"]);
     //freeze the animation

src/Game/Systems/PlayerMovementSystem.cpp

@@ -16,7 +16,15 @@ PlayerMovementSystem::~PlayerMovementSystem()
 void PlayerMovementSystem::Update(double dt)
 {
     updateMovementControllers(dt);
-    updateVelocity(dt);
+    if (IsServer) {
+        for (auto& kv : m_PlayerInputControllers) {
+            updateVelocity(kv.first, dt);
+        }
+    } else {
+        if (LocalPlayer.Valid()) {
+            updateVelocity(LocalPlayer, dt);
+        }
+    }
 }
 
 void PlayerMovementSystem::updateMovementControllers(double dt)
@@ -221,15 +229,11 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
 }
 
 
-void PlayerMovementSystem::updateVelocity(double dt)
+void PlayerMovementSystem::updateVelocity(EntityWrapper player, double dt)
 {
     // Only apply velocity to local player
-    if (!LocalPlayer.Valid()) {
+    ComponentWrapper& cTransform = player["Transform"];
-        return;
+    ComponentWrapper& cPhysics = player["Physics"];
-    }
-
-    ComponentWrapper& cTransform = LocalPlayer["Transform"];
-    ComponentWrapper& cPhysics = LocalPlayer["Physics"];
     glm::vec3& velocity = cPhysics["Velocity"];
     bool isOnGround = (bool)cPhysics["IsOnGround"];
 

src/Game/Systems/SoundSystem.cpp

@@ -14,6 +14,7 @@ SoundSystem::SoundSystem(SystemParams params)
         EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &SoundSystem::OnPlayerDamage);
         EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &SoundSystem::OnCaptured);
         EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &SoundSystem::OnTriggerTouch);
+        EVENT_SUBSCRIBE_MEMBER(m_EPlayerDeath, &SoundSystem::OnPlayerDeath);
     }
 }
 
@@ -90,6 +91,9 @@ bool SoundSystem::drumTimer(double dt)
 
 bool SoundSystem::OnCaptured(const Events::Captured & e)
 {
+    if (!LocalPlayer.Valid()) {
+        return false;
+    }
     int homeTeam = (int)m_World->GetComponent(e.CapturePointID, "Team")["Team"];
     int team = (int)m_World->GetComponent(LocalPlayer.ID, "Team")["Team"];
     Events::PlaySoundOnEntity ev;
@@ -108,7 +112,12 @@ bool SoundSystem::OnCaptured(const Events::Captured & e)
 // Testing purposes atm...
 bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
 {
-    // Should check for only local players here...
+    if (!IsClient) { // Only play for clients
+        return false;
+    }
+    if (LocalPlayer.ID = e.Victim.ID) { // You're local player was the one who took dmg
+        return false;
+    }
     std::uniform_int_distribution<int> dist(1, 12);
     int rand = dist(generator);
     std::vector<std::string> paths;
@@ -128,8 +137,16 @@ bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
 
 bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
 {
-    Events::PlaySoundOnEntity ev;
+    if (e.Player.ID != LocalPlayer.ID) {
-    ev.EmitterID = LocalPlayer.ID;
+        return false;
+    }
+    if (!IsClient) {
+        return false;
+    }
+    // The local player is dead. The local player might be invalid?
+    // Play the sound from the listener.
+    // TODO: We might want to hear other players die.
+    Events::PlayBackgroundMusic ev;
     ev.FilePath = "Audio/die/die2.wav";
     m_EventBroker->Publish(ev);
     return false;

src/Tests/HealthSystemTest.h

@@ -6,7 +6,6 @@
 #include "Core/EventBroker.h"
 #include "Rendering/Renderer.h"
 #include "Core/InputManager.h"
-#include "GUI/Frame.h"
 #include "Core/World.h"
 #include "Input/InputProxy.h"
 #include "Input/KeyboardInputHandler.h"