diff --git a/include/Engine/Network/Client.h b/include/Engine/Network/Client.h
index 26f4489d..51d66fc8 100644
--- a/include/Engine/Network/Client.h
+++ b/include/Engine/Network/Client.h
@@ -27,7 +27,7 @@ public:
     void Close();
 private:
 	void ReadFromServer();
-	void SendToServer();
+	void SendSnapshotToServer();
 
 	int Receive(char* data, size_t length);
 	void Send(Package& message);
@@ -66,6 +66,7 @@ private:
     // Use to check if we should send disconnect message
     // if game is turned of by closing window.
     bool m_WasStarted = false;
+    IsWASDKeyDown m_IsWASDKeyDown;
 
 	// Events
 	EventBroker* m_EventBroker;
diff --git a/include/Engine/Network/NetworkDefinitions.h b/include/Engine/Network/NetworkDefinitions.h
index 8b2ebadf..88eab7cf 100644
--- a/include/Engine/Network/NetworkDefinitions.h
+++ b/include/Engine/Network/NetworkDefinitions.h
@@ -10,9 +10,12 @@
 #define MAXCONNECTIONS 8
 #define INPUTSIZE 128
 #define PACKETMODULUS 1000 // How many packets to send before the number resets
+#define PLAYERSPEED 0.2f;
 
 typedef boost::shared_ptr<boost::asio::ip::udp::socket> socket_ptr;
 typedef boost::shared_ptr<std::string> string_ptr;
 typedef boost::shared_ptr<std::queue<string_ptr>> messageQueue_ptr;
 
+
+
 #endif
\ No newline at end of file
diff --git a/include/Engine/Network/SnapshotDefinitions.h b/include/Engine/Network/SnapshotDefinitions.h
index 7f9e4ce5..2b4ba948 100644
--- a/include/Engine/Network/SnapshotDefinitions.h
+++ b/include/Engine/Network/SnapshotDefinitions.h
@@ -4,9 +4,17 @@
 struct SnapshotDefinitions
 {
 	// "+Forward" is 8 characters * sizeof(char) = 8
-	char* inputForward = new char[8];
+	char* InputForward = new char[8];
 	// "+Right" is 6 characters * sizeof(char) = 6
-	char* inputRight = new char[6];
+	char* InputRight = new char[6];
+};
+
+struct IsWASDKeyDown
+{
+    bool W = false;
+    bool A = false;
+    bool S = false;
+    bool D = false;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/Engine/Network/Client.cpp b/src/Engine/Network/Client.cpp
index 73b8b823..f9d20377 100644
--- a/src/Engine/Network/Client.cpp
+++ b/src/Engine/Network/Client.cpp
@@ -5,10 +5,10 @@ using namespace boost::asio::ip;
 
 Client::Client() : m_Socket(m_IOService)
 {
-	// Set up network stream
-	m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string("192.168.1.2"), 13);
-	m_NextSnapshot.inputForward = "";
-	m_NextSnapshot.inputRight = "";
+    // Set up network stream
+    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string("192.168.1.2"), 13);
+	m_NextSnapshot.InputForward = "";
+	m_NextSnapshot.InputRight = "";
 }
 
 Client::~Client()
@@ -21,22 +21,22 @@ void Client::Start(World* world, EventBroker* eventBroker)
 {
     m_WasStarted = true;
     m_EventBroker = eventBroker;
-	m_World = world;
-	
-	// Subscribe to events
-	m_EKeyDown = decltype(m_EKeyDown)(std::bind(&Client::OnKeyDown, this, std::placeholders::_1));
+    m_World = world;
+
+    // Subscribe to events
+    m_EKeyDown = decltype(m_EKeyDown)(std::bind(&Client::OnKeyDown, this, std::placeholders::_1));
     m_EventBroker->Subscribe(m_EKeyDown);
-	m_EKeyUp = decltype(m_EKeyUp)(std::bind(&Client::OnKeyUp, this, std::placeholders::_1));
-	m_EventBroker->Subscribe(m_EKeyUp);
-	
-	std::cout << "Please enter you name: ";
-	std::cin >> m_PlayerName;
-	while (m_PlayerName.size() > 7) {
-		std::cout << "Please enter you name(No longer than 7 characters): ";
-		std::cin >> m_PlayerName;
-	}
-	m_Socket.connect(m_ReceiverEndpoint);
-	std::cout << "I am client. BIP BOP\n";
+    m_EKeyUp = decltype(m_EKeyUp)(std::bind(&Client::OnKeyUp, this, std::placeholders::_1));
+    m_EventBroker->Subscribe(m_EKeyUp);
+
+    std::cout << "Please enter you name: ";
+    std::cin >> m_PlayerName;
+    while (m_PlayerName.size() > 7) {
+        std::cout << "Please enter you name(No longer than 7 characters): ";
+        std::cin >> m_PlayerName;
+    }
+    m_Socket.connect(m_ReceiverEndpoint);
+    std::cout << "I am client. BIP BOP\n";
     ReadFromServer();
 }
 
@@ -52,45 +52,67 @@ void Client::Close()
 
 void Client::ReadFromServer()
 {
-	int bytesRead = -1;
-	char readBuf[1024] = { 0 };
+    int bytesRead = -1;
+    char readBuf[1024] = { 0 };
 
-	int snapshotInterval = 33;
-	std::clock_t previousSnapshotMessage = std::clock();
+    int snapshotInterval = 33;
+    std::clock_t previousSnapshotMessage = std::clock();
 
-	while (m_ThreadIsRunning) {
-		if (m_Socket.available()) {
-			bytesRead = Receive(readBuf, INPUTSIZE);
-			ParseMessageType(readBuf, bytesRead);
-		}
-		std::clock_t currentTime = std::clock();
-		if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
-			SendToServer();
-			previousSnapshotMessage = currentTime;
-		}
-		
-	}
+    while (m_ThreadIsRunning) {
+        if (m_Socket.available()) {
+            bytesRead = Receive(readBuf, INPUTSIZE);
+            ParseMessageType(readBuf, bytesRead);
+        }
+        std::clock_t currentTime = std::clock();
+        if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+            SendSnapshotToServer();
+            previousSnapshotMessage = currentTime;
+        }
+
+    }
 }
 
-void Client::SendToServer()
+void Client::SendSnapshotToServer()
 {
-	if (m_NextSnapshot.inputForward != "" && m_NextSnapshot.inputForward[0] != '\0') {
+    // Reset previouse key state in snapshot.
 		Package message(MessageType::Event);
-		message.AddString(m_NextSnapshot.inputForward);
+		message.AddString(m_NextSnapshot.InputForward);
 		Send(message);
-	}
-	if (m_NextSnapshot.inputRight != "" && m_NextSnapshot.inputRight[0] != '\0') {
+    m_NextSnapshot.InputRight = "";
+    m_NextSnapshot.InputRight = "";
+    // See if any movement keys are down
+    // We dont care if it's overwritten by later
+    // if statement. Watcha gonna do, right!
+    if (m_IsWASDKeyDown.W) {
+        m_NextSnapshot.InputRight = "+Forward";
+    }
+    if (m_IsWASDKeyDown.A) {
+        m_NextSnapshot.InputRight = "-Right";
+    }
+    if (m_IsWASDKeyDown.S) {
+        m_NextSnapshot.InputRight = "-Forward";
+    }
+    if (m_IsWASDKeyDown.D) {
+        m_NextSnapshot.InputRight = "+Right";
+    }
+
+    if (m_NextSnapshot.InputForward != "") {
+	Package message(MessageType::Event);
+	message.AddString(m_NextSnapshot.InputForward);
+	Send(message);
+    }
+    if (m_NextSnapshot.InputRight != "") {
 		Package message(MessageType::Event);
-		message.AddString(m_NextSnapshot.inputRight);
+		message.AddString(m_NextSnapshot.InputRight);
 		Send(message);
-	}
+    }
 }
 
 void Client::ParseMessageType(char* data, size_t length)
 {
-	int messageType = -1;
-	memcpy(&messageType, data, sizeof(int)); // Read what type off message was sent from server
-	MoveMessageHead(data, length, sizeof(int)); // Move the message head to know where to read from
+    int messageType = -1;
+    memcpy(&messageType, data, sizeof(int)); // Read what type off message was sent from server
+    MoveMessageHead(data, length, sizeof(int)); // Move the message head to know where to read from
 
 	// Read packet ID 
 	m_PreviousPacketID = m_PacketID;
@@ -98,29 +120,29 @@ void Client::ParseMessageType(char* data, size_t length)
 	MoveMessageHead(data, length, sizeof(int)); 
 	IdentifyPacketLoss();
 
-	switch (static_cast<MessageType>(messageType)) {
-	case MessageType::Connect:
-		ParseConnect(data, length);
-		break;
-	case MessageType::ClientPing:
-		ParsePing();
-		break;
-	case MessageType::ServerPing:
-		ParseServerPing();
-		break;
-	case MessageType::Message:
-		break;
-	case MessageType::Snapshot:
-		ParseSnapshot(data, length);
-		break;
-	case MessageType::Disconnect:
-		break;
-	case MessageType::Event:
-		ParseEventMessage(data, length);
-		break;
-	default:
-		break;
-	}
+    switch (static_cast<MessageType>(messageType)) {
+    case MessageType::Connect:
+        ParseConnect(data, length);
+        break;
+    case MessageType::ClientPing:
+        ParsePing();
+        break;
+    case MessageType::ServerPing:
+        ParseServerPing();
+        break;
+    case MessageType::Message:
+        break;
+    case MessageType::Snapshot:
+        ParseSnapshot(data, length);
+        break;
+    case MessageType::Disconnect:
+        break;
+    case MessageType::Event:
+        ParseEventMessage(data, length);
+        break;
+    default:
+        break;
+    }
 }
 
 void Client::ParseConnect(char* data, size_t len)
@@ -132,7 +154,7 @@ void Client::ParseConnect(char* data, size_t len)
 
 void Client::ParsePing()
 {
-	m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
+    m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
 	std::cout << m_PacketID << ": response time with ctime(ms): " << m_DurationOfPingTime << std::endl;
 }
 
@@ -141,71 +163,74 @@ void Client::ParseServerPing()
 	Package message(MessageType::ServerPing);
 	message.AddString("Ping recieved");
 	Send(message);
+    //std::cout << "Parsing ping." << std::endl;
 }
 
 void Client::ParseEventMessage(char* data, size_t length)
 {
-	int Id = -1;
-	std::string command = std::string(data);
-	if (command.find("+Player") != std::string::npos) {
-		MoveMessageHead(data, length, command.size() + 1);
-		memcpy(&Id, data, sizeof(int));
-		MoveMessageHead(data, length, sizeof(int));
-		// Sett Player name
-		m_PlayerDefinitions[Id].Name = command.erase(0, 7);
-	}
-	else {
+    int Id = -1;
+    std::string command = std::string(data);
+    if (command.find("+Player") != std::string::npos) {
+        MoveMessageHead(data, length, command.size() + 1);
+        memcpy(&Id, data, sizeof(int));
+        MoveMessageHead(data, length, sizeof(int));
+        // Sett Player name
+        m_PlayerDefinitions[Id].Name = command.erase(0, 7);
+    } else {
 		std::cout << m_PacketID << ": Event message: " << std::string(data) << std::endl;
-	}
+    }
 
-	MoveMessageHead(data, length, std::string(data).size() + 1);
+    MoveMessageHead(data, length, std::string(data).size() + 1);
 }
 
 void Client::ParseSnapshot(char* data, size_t length)
 {
 	std::cout << m_PacketID << ": Parsing incoming snapshot." << std::endl;
-	std::string tempName;
-	for (size_t i = 0; i < MAXCONNECTIONS; i++) {
-		// We're checking for empty name for now. This might not be the best way,
-		// but it is to avoid sending redundant data.
+    std::string tempName;
+    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+        // We're checking for empty name for now. This might not be the best way,
+        // but it is to avoid sending redundant data.
 
-		// Read position data
-		glm::vec3 playerPos;
-		memcpy(&playerPos.x, data, sizeof(float));
-		MoveMessageHead(data, length, sizeof(float));
-		memcpy(&playerPos.y, data, sizeof(float));
-		MoveMessageHead(data, length, sizeof(float));
-		memcpy(&playerPos.z, data, sizeof(float));
-		MoveMessageHead(data, length, sizeof(float));
-		
-		tempName = std::string(data);
-		// +1 for null terminator
-		MoveMessageHead(data, length, tempName.size() + 1);
-		// Apply the position data read to the player entity
-		// New player connected on the server side 
-		if (m_PlayerDefinitions[i].Name == "" && tempName != "") { 
-			CreateNewPlayer(i);
-		}
-		else if (m_PlayerDefinitions[i].Name != "" && tempName == "") {
-			// Someone disconnected
-			// TODO: Insert code here
-		}
-		else if (m_PlayerDefinitions[i].Name == "" && tempName == "") {
-			// Not a connected player
-			break;
-		}
-		m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform")["Position"] = playerPos;
-		m_PlayerDefinitions[i].Name = tempName;
-	}
+        // Read position data
+        glm::vec3 playerPos;
+        memcpy(&playerPos.x, data, sizeof(float));
+        MoveMessageHead(data, length, sizeof(float));
+        memcpy(&playerPos.y, data, sizeof(float));
+        MoveMessageHead(data, length, sizeof(float));
+        memcpy(&playerPos.z, data, sizeof(float));
+        MoveMessageHead(data, length, sizeof(float));
+
+        tempName = std::string(data);
+        // +1 for null terminator
+        MoveMessageHead(data, length, tempName.size() + 1);
+        // Apply the position data read to the player entity
+        // New player connected on the server side 
+        if (m_PlayerDefinitions[i].Name == "" && tempName != "") {
+            CreateNewPlayer(i);
+        } else if (m_PlayerDefinitions[i].Name != "" && tempName == "") {
+            // Someone disconnected
+            // TODO: Insert code here
+        } else if (m_PlayerDefinitions[i].Name == "" && tempName == "") {
+            // Not a connected player
+            break;
+        }
+        m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform")["Position"] = playerPos;
+        m_PlayerDefinitions[i].Name = tempName;
+    }
 }
 
 int Client::Receive(char* data, size_t length)
 {
-	int bytesReceived = m_Socket.receive_from(boost
-		::asio::buffer((void*)data, length),
-		m_ReceiverEndpoint,
-		0);
-	return bytesReceived;
+    boost::system::error_code error;
+
+    int bytesReceived = m_Socket.receive_from(boost
+        ::asio::buffer((void*)data, length),
+        m_ReceiverEndpoint,
+        0, error);
+   
+    std::cout << "ReadFromServer crashed: " << error.message();
+    
+    return bytesReceived;
 }
 
 void Client::Send(Package& package)
@@ -232,7 +257,7 @@ void Client::Disconnect()
 }
 
 void Client::Ping()
-{ 
+{
 	Package message(MessageType::Connect);
 	message.AddString("Ping"); 
 	m_StartPingTime = std::clock();
@@ -241,59 +266,73 @@ void Client::Ping()
 
 void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize)
 {
-	data += stepSize;
-	length -= stepSize;
+    data += stepSize;
+    length -= stepSize;
 }
 
 bool Client::OnKeyDown(const Events::KeyDown& event)
 {
-	char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled
-	if (event.KeyCode == GLFW_KEY_W) {
-		m_NextSnapshot.inputForward = "+Forward";
-	}
-	if (event.KeyCode == GLFW_KEY_A) {
-		m_NextSnapshot.inputRight = "-Right";
-	}
-	if (event.KeyCode == GLFW_KEY_S) {
-		m_NextSnapshot.inputForward = "-Forward";
-	}
-	if (event.KeyCode == GLFW_KEY_D) {
-		m_NextSnapshot.inputRight = "+Right";
-	}
+    char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled
+    if (event.KeyCode == GLFW_KEY_W) {
+        m_IsWASDKeyDown.W = true;
+        //m_NextSnapshot.inputForward = "+Forward";
+    }
+    if (event.KeyCode == GLFW_KEY_A) {
+        m_IsWASDKeyDown.A = true;
+        //m_NextSnapshot.inputRight = "-Right";
+    }
+    if (event.KeyCode == GLFW_KEY_S) {
+        m_IsWASDKeyDown.S = true;
+        //m_NextSnapshot.inputForward = "-Forward";
+    }
+    if (event.KeyCode == GLFW_KEY_D) {
+        m_IsWASDKeyDown.D = true;
+        //m_NextSnapshot.inputRight = "+Right";
+    }
 
-	if (event.KeyCode == GLFW_KEY_V) {
-		Disconnect();
-	}
-	if (event.KeyCode == GLFW_KEY_C) {
-		Connect();
-	}
+    if (event.KeyCode == GLFW_KEY_V) {
+        Disconnect();
+    }
+    if (event.KeyCode == GLFW_KEY_C) {
+        Connect();
+    }
     if (event.KeyCode == GLFW_KEY_P) {
         Ping();
     }
-	memset(dataPackage, 0, INPUTSIZE);
-	delete[] dataPackage;
-	return true;
+    memset(dataPackage, 0, INPUTSIZE);
+    delete[] dataPackage;
+    return true;
 }
 
 bool Client::OnKeyUp(const Events::KeyUp & e)
 {
-	if (e.KeyCode == GLFW_KEY_W || e.KeyCode == GLFW_KEY_S) {
-		m_NextSnapshot.inputForward = "";
-		return true;
-	}
-	if (e.KeyCode == GLFW_KEY_A || e.KeyCode == GLFW_KEY_D) {
-		m_NextSnapshot.inputRight = "";
-		return true;
-	}
-	return false;
+    if (e.KeyCode == GLFW_KEY_W) {
+        m_IsWASDKeyDown.W = false;
+        //m_NextSnapshot.inputForward = "";
+        return true;
+    }
+    if (e.KeyCode == GLFW_KEY_A){
+        m_IsWASDKeyDown.A = false;
+        return true;
+    }
+    if (e.KeyCode == GLFW_KEY_S){
+        m_IsWASDKeyDown.S = false;
+        return true;
+    }
+    if (e.KeyCode == GLFW_KEY_D) {
+        m_IsWASDKeyDown.D = false;
+        //m_NextSnapshot.inputRight = "";
+        return true;
+    }
+    return false;
 }
 
 void Client::CreateNewPlayer(int i)
 {
-	m_PlayerDefinitions[i].EntityID = m_World->CreateEntity();
-	ComponentWrapper transform = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Transform");
-	ComponentWrapper model = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Model");
-	model["Resource"] = "Models/Core/UnitSphere.obj";
+    m_PlayerDefinitions[i].EntityID = m_World->CreateEntity();
+    ComponentWrapper transform = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Transform");
+    ComponentWrapper model = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Model");
+    model["Resource"] = "Models/Core/UnitSphere.obj";
 }
 
 void Client::IdentifyPacketLoss()
diff --git a/src/Game/Game.cpp b/src/Game/Game.cpp
index 67070933..ed7723b1 100644
--- a/src/Game/Game.cpp
+++ b/src/Game/Game.cpp
@@ -124,11 +124,11 @@ void Game::NetworkFunction()
 	std::cout << "Start client or server? (c/s)" << std::endl;
 	std::cin >> inputMessage;
 	if (inputMessage == "c" || inputMessage == "C") {
-		Client m_Client;
+        Client m_Client;
 		m_Client.Start(m_World, m_EventBroker);
 	}
     if (inputMessage == "s" || inputMessage == "S") {
-		Server m_Server;
+        Server m_Server;
         m_Server.Start(m_World);
     }
 }
\ No newline at end of file