BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fixed client movement.

Browse Source
This commit is contained in:
Jocke
2015-12-10 14:14:36 +01:00
parent 663aca2641
commit f377d9ba70
4 changed files with 234 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Network/Client.h
+2 -1
View File
@@ -27,7 +27,7 @@ public:
void Close(); void Close();
private: private:
void ReadFromServer(); void ReadFromServer();
void SendToServer(); void SendSnapshotToServer();
int Receive(char* data, size_t length); int Receive(char* data, size_t length);
int CreateMessage(MessageType type, std::string message, char* data); int CreateMessage(MessageType type, std::string message, char* data);
@@ -60,6 +60,7 @@ private:
// Use to check if we should send disconnect message // Use to check if we should send disconnect message
// if game is turned of by closing window. // if game is turned of by closing window.
bool m_WasStarted = false; bool m_WasStarted = false;
IsWASDKeyDown m_IsWASDKeyDown;
// Events // Events
EventBroker* m_EventBroker; EventBroker* m_EventBroker;
include/Engine/Network/NetworkDefinitions.h
+3
View File
@@ -7,9 +7,12 @@
#define BOARDSIZE 16 #define BOARDSIZE 16
#define MAXCONNECTIONS 8 #define MAXCONNECTIONS 8
#define INPUTSIZE 128 #define INPUTSIZE 128
#define PLAYERSPEED 0.2f;
typedef boost::shared_ptr<boost::asio::ip::udp::socket> socket_ptr; typedef boost::shared_ptr<boost::asio::ip::udp::socket> socket_ptr;
typedef boost::shared_ptr<std::string> string_ptr; typedef boost::shared_ptr<std::string> string_ptr;
typedef boost::shared_ptr<std::queue<string_ptr>> messageQueue_ptr; typedef boost::shared_ptr<std::queue<string_ptr>> messageQueue_ptr;
#endif #endif
include/Engine/Network/SnapshotDefinitions.h
+10 -2
View File
@@ -4,9 +4,17 @@
struct SnapshotDefinitions struct SnapshotDefinitions
{ {
// "+Forward" is 8 characters * sizeof(char) = 8 // "+Forward" is 8 characters * sizeof(char) = 8
char* inputForward = new char[8]; char* InputForward = new char[8];
// "+Right" is 6 characters * sizeof(char) = 6 // "+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 #endif
src/Engine/Network/Client.cpp
+214 -188
View File
@@ -5,8 +5,8 @@ using namespace boost::asio::ip;
Client::Client() : m_Socket(m_IOService) Client::Client() : m_Socket(m_IOService)
{ {
// Set up network stream // Set up network stream
m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string("192.168.1.6"), 13); m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string("192.168.1.6"), 13);
} }
Client::~Client() Client::~Client()
@@ -19,22 +19,22 @@ void Client::Start(World* world, EventBroker* eventBroker)
{ {
m_WasStarted = true; m_WasStarted = true;
m_EventBroker = eventBroker; m_EventBroker = eventBroker;
m_World = world; m_World = world;
// Subscribe to events // Subscribe to events
m_EKeyDown = decltype(m_EKeyDown)(std::bind(&Client::OnKeyDown, this, std::placeholders::_1)); m_EKeyDown = decltype(m_EKeyDown)(std::bind(&Client::OnKeyDown, this, std::placeholders::_1));
m_EventBroker->Subscribe(m_EKeyDown); m_EventBroker->Subscribe(m_EKeyDown);
m_EKeyUp = decltype(m_EKeyUp)(std::bind(&Client::OnKeyUp, this, std::placeholders::_1)); m_EKeyUp = decltype(m_EKeyUp)(std::bind(&Client::OnKeyUp, this, std::placeholders::_1));
m_EventBroker->Subscribe(m_EKeyUp); m_EventBroker->Subscribe(m_EKeyUp);
std::cout << "Please enter you name: "; std::cout << "Please enter you name: ";
std::cin >> m_PlayerName; std::cin >> m_PlayerName;
while (m_PlayerName.size() > 7) { while (m_PlayerName.size() > 7) {
std::cout << "Please enter you name(No longer than 7 characters): "; std::cout << "Please enter you name(No longer than 7 characters): ";
std::cin >> m_PlayerName; std::cin >> m_PlayerName;
} }
m_Socket.connect(m_ReceiverEndpoint); m_Socket.connect(m_ReceiverEndpoint);
std::cout << "I am client. BIP BOP\n"; std::cout << "I am client. BIP BOP\n";
ReadFromServer(); ReadFromServer();
} }
@@ -50,193 +50,205 @@ void Client::Close()
void Client::ReadFromServer() void Client::ReadFromServer()
{ {
int bytesRead = -1; int bytesRead = -1;
char readBuf[1024] = { 0 }; char readBuf[1024] = { 0 };
int snapshotInterval = 33; int snapshotInterval = 33;
std::clock_t previousSnapshotMessage = std::clock(); std::clock_t previousSnapshotMessage = std::clock();
while (m_ThreadIsRunning) { while (m_ThreadIsRunning) {
if (m_Socket.available()) { if (m_Socket.available()) {
bytesRead = Receive(readBuf, INPUTSIZE); bytesRead = Receive(readBuf, INPUTSIZE);
ParseMessageType(readBuf, bytesRead); ParseMessageType(readBuf, bytesRead);
} }
std::clock_t currentTime = std::clock(); std::clock_t currentTime = std::clock();
if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) { if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
SendToServer(); SendSnapshotToServer();
previousSnapshotMessage = currentTime; previousSnapshotMessage = currentTime;
} }
} }
} }
void Client::SendToServer() void Client::SendSnapshotToServer()
{ {
if (m_NextSnapshot.inputForward != "") { // Reset previouse key state in snapshot.
char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled m_NextSnapshot.InputRight = "";
int len = CreateMessage(MessageType::Event, m_NextSnapshot.inputForward, dataPackage); m_NextSnapshot.InputRight = "";
m_Socket.send_to(boost::asio::buffer( // See if any movement keys are down
dataPackage, // We dont care if it's overwritten by later
len), // if statement. Watcha gonna do, right!
m_ReceiverEndpoint, 0); 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 != "") {
char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled
int len = CreateMessage(MessageType::Event, m_NextSnapshot.InputForward, dataPackage);
m_Socket.send_to(boost::asio::buffer(
dataPackage,
len),
m_ReceiverEndpoint, 0);
delete[] dataPackage; delete[] dataPackage;
} }
if (m_NextSnapshot.inputRight != "") { if (m_NextSnapshot.InputRight != "") {
char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled
int len = CreateMessage(MessageType::Event, m_NextSnapshot.inputRight, dataPackage); int len = CreateMessage(MessageType::Event, m_NextSnapshot.InputRight, dataPackage);
m_Socket.send_to(boost::asio::buffer( m_Socket.send_to(boost::asio::buffer(
dataPackage, dataPackage,
len), len),
m_ReceiverEndpoint, 0); m_ReceiverEndpoint, 0);
delete[] dataPackage; delete[] dataPackage;
} }
} }
void Client::ParseMessageType(char* data, size_t length) void Client::ParseMessageType(char* data, size_t length)
{ {
int messageType = -1; int messageType = -1;
memcpy(&messageType, data, sizeof(int)); // Read what type off message was sent from server 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 MoveMessageHead(data, length, sizeof(int)); // Move the message head to know where to read from
switch (static_cast<MessageType>(messageType)) { switch (static_cast<MessageType>(messageType)) {
case MessageType::Connect: case MessageType::Connect:
ParseConnect(data, length); ParseConnect(data, length);
break; break;
case MessageType::ClientPing: case MessageType::ClientPing:
ParsePing(); ParsePing();
break; break;
case MessageType::ServerPing: case MessageType::ServerPing:
ParseServerPing(); ParseServerPing();
break; break;
case MessageType::Message: case MessageType::Message:
break; break;
case MessageType::Snapshot: case MessageType::Snapshot:
ParseSnapshot(data, length); ParseSnapshot(data, length);
break; break;
case MessageType::Disconnect: case MessageType::Disconnect:
break; break;
case MessageType::Event: case MessageType::Event:
ParseEventMessage(data, length); ParseEventMessage(data, length);
break; break;
default: default:
break; break;
} }
} }
void Client::ParseConnect(char* data, size_t len) void Client::ParseConnect(char* data, size_t len)
{ {
memcpy(&m_PlayerID, data, sizeof(int)); memcpy(&m_PlayerID, data, sizeof(int));
std::cout << "I am player: " << m_PlayerID << std::endl; std::cout << "I am player: " << m_PlayerID << std::endl;
} }
void Client::ParsePing() 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 << "response time with ctime(ms): " << m_DurationOfPingTime << std::endl; std::cout << "response time with ctime(ms): " << m_DurationOfPingTime << std::endl;
} }
void Client::ParseServerPing() void Client::ParseServerPing()
{ {
char* testMessage = new char[128]; char* testMessage = new char[128];
int testOffset = CreateMessage(MessageType::ServerPing, "Ping recieved", testMessage); int testOffset = CreateMessage(MessageType::ServerPing, "Ping recieved", testMessage);
//std::cout << "Parsing ping." << std::endl; //std::cout << "Parsing ping." << std::endl;
m_Socket.send_to(boost::asio::buffer( m_Socket.send_to(boost::asio::buffer(
testMessage, testMessage,
testOffset), testOffset),
m_ReceiverEndpoint, 0); m_ReceiverEndpoint, 0);
delete[] testMessage; delete[] testMessage;
} }
void Client::ParseEventMessage(char* data, size_t length) void Client::ParseEventMessage(char* data, size_t length)
{ {
int Id = -1; int Id = -1;
std::string command = std::string(data); std::string command = std::string(data);
if (command.find("+Player") != std::string::npos) { if (command.find("+Player") != std::string::npos) {
MoveMessageHead(data, length, command.size() + 1); MoveMessageHead(data, length, command.size() + 1);
memcpy(&Id, data, sizeof(int)); memcpy(&Id, data, sizeof(int));
MoveMessageHead(data, length, sizeof(int)); MoveMessageHead(data, length, sizeof(int));
// Sett Player name // Sett Player name
m_PlayerDefinitions[Id].Name = command.erase(0, 7); m_PlayerDefinitions[Id].Name = command.erase(0, 7);
} } else {
else { std::cout << "Event message: " << std::string(data) << std::endl;
std::cout << "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) void Client::ParseSnapshot(char* data, size_t length)
{ {
std::string tempName; std::string tempName;
for (size_t i = 0; i < MAXCONNECTIONS; i++) { for (size_t i = 0; i < MAXCONNECTIONS; i++) {
// We're checking for empty name for now. This might not be the best way, // We're checking for empty name for now. This might not be the best way,
// but it is to avoid sending redundant data. // but it is to avoid sending redundant data.
// Read position data // Read position data
glm::vec3 playerPos; glm::vec3 playerPos;
memcpy(&playerPos.x, data, sizeof(float)); memcpy(&playerPos.x, data, sizeof(float));
MoveMessageHead(data, length, sizeof(float)); MoveMessageHead(data, length, sizeof(float));
memcpy(&playerPos.y, data, sizeof(float)); memcpy(&playerPos.y, data, sizeof(float));
MoveMessageHead(data, length, sizeof(float)); MoveMessageHead(data, length, sizeof(float));
memcpy(&playerPos.z, data, sizeof(float)); memcpy(&playerPos.z, data, sizeof(float));
MoveMessageHead(data, length, sizeof(float)); MoveMessageHead(data, length, sizeof(float));
tempName = std::string(data); tempName = std::string(data);
// +1 for null terminator // +1 for null terminator
MoveMessageHead(data, length, tempName.size() + 1); MoveMessageHead(data, length, tempName.size() + 1);
// Apply the position data read to the player entity // Apply the position data read to the player entity
// New player connected on the server side // New player connected on the server side
if (m_PlayerDefinitions[i].Name == "" && tempName != "") { if (m_PlayerDefinitions[i].Name == "" && tempName != "") {
CreateNewPlayer(i); CreateNewPlayer(i);
} } else if (m_PlayerDefinitions[i].Name != "" && tempName == "") {
else if (m_PlayerDefinitions[i].Name != "" && tempName == "") { // Someone disconnected
// Someone disconnected // TODO: Insert code here
// TODO: Insert code here } else if (m_PlayerDefinitions[i].Name == "" && tempName == "") {
} // Not a connected player
else if (m_PlayerDefinitions[i].Name == "" && tempName == "") { break;
// Not a connected player }
break; m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform")["Position"] = playerPos;
} m_PlayerDefinitions[i].Name = tempName;
m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform")["Position"] = playerPos; }
m_PlayerDefinitions[i].Name = tempName;
}
} }
int Client::Receive(char* data, size_t length) int Client::Receive(char* data, size_t length)
{ {
boost::system::error_code error;
try { int bytesReceived = m_Socket.receive_from(boost
int bytesReceived = m_Socket.receive_from(boost ::asio::buffer((void*)data, length),
::asio::buffer((void*)data, length), m_ReceiverEndpoint,
m_ReceiverEndpoint, 0, error);
0);
return bytesReceived; std::cout << "ReadFromServer crashed: " << error.message();
} catch (const std::exception& err) {
// To not spam "socket closed messages" return bytesReceived;
//if (std::string(err.what()).find("forcefully closed") != std::string::npos) {
std::cout << "Read from client crashed: " << err.what();
//}
}
return 0;
} }
int Client::CreateMessage(MessageType type, std::string message, char* data) int Client::CreateMessage(MessageType type, std::string message, char* data)
{ {
int lengthOfMessage = 0; int lengthOfMessage = 0;
int messageType = static_cast<int>(type); int messageType = static_cast<int>(type);
lengthOfMessage = message.size(); lengthOfMessage = message.size();
int offset = 0; int offset = 0;
// Message type // Message type
memcpy(data + offset, &messageType, sizeof(int)); memcpy(data + offset, &messageType, sizeof(int));
offset += sizeof(int); offset += sizeof(int);
// Message, add one extra byte for null terminator // Message, add one extra byte for null terminator
memcpy(data + offset, message.data(), (lengthOfMessage + 1) * sizeof(char)); memcpy(data + offset, message.data(), (lengthOfMessage + 1) * sizeof(char));
offset += (lengthOfMessage + 1) * sizeof(char); offset += (lengthOfMessage + 1) * sizeof(char);
return offset; return offset;
} }
void Client::Connect() void Client::Connect()
@@ -279,57 +291,71 @@ void Client::Ping()
void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize) void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize)
{ {
data += stepSize; data += stepSize;
length -= stepSize; length -= stepSize;
} }
bool Client::OnKeyDown(const Events::KeyDown& event) bool Client::OnKeyDown(const Events::KeyDown& event)
{ {
char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled char* dataPackage = new char[INPUTSIZE]; // The package that will be sent to the server, when filled
if (event.KeyCode == GLFW_KEY_W) { if (event.KeyCode == GLFW_KEY_W) {
m_NextSnapshot.inputForward = "+Forward"; m_IsWASDKeyDown.W = true;
} //m_NextSnapshot.inputForward = "+Forward";
if (event.KeyCode == GLFW_KEY_A) { }
m_NextSnapshot.inputRight = "-Right"; if (event.KeyCode == GLFW_KEY_A) {
} m_IsWASDKeyDown.A = true;
if (event.KeyCode == GLFW_KEY_S) { //m_NextSnapshot.inputRight = "-Right";
m_NextSnapshot.inputForward = "-Forward"; }
} if (event.KeyCode == GLFW_KEY_S) {
if (event.KeyCode == GLFW_KEY_D) { m_IsWASDKeyDown.S = true;
m_NextSnapshot.inputRight = "+Right"; //m_NextSnapshot.inputForward = "-Forward";
} }
if (event.KeyCode == GLFW_KEY_D) {
m_IsWASDKeyDown.D = true;
//m_NextSnapshot.inputRight = "+Right";
}
if (event.KeyCode == GLFW_KEY_V) { if (event.KeyCode == GLFW_KEY_V) {
Disconnect(); Disconnect();
} }
if (event.KeyCode == GLFW_KEY_C) { if (event.KeyCode == GLFW_KEY_C) {
Connect(); Connect();
} }
if (event.KeyCode == GLFW_KEY_P) { if (event.KeyCode == GLFW_KEY_P) {
Ping(); Ping();
} }
memset(dataPackage, 0, INPUTSIZE); memset(dataPackage, 0, INPUTSIZE);
delete[] dataPackage; delete[] dataPackage;
return true; return true;
} }
bool Client::OnKeyUp(const Events::KeyUp & e) bool Client::OnKeyUp(const Events::KeyUp & e)
{ {
if (e.KeyCode == GLFW_KEY_W || e.KeyCode == GLFW_KEY_S) { if (e.KeyCode == GLFW_KEY_W) {
m_NextSnapshot.inputForward = ""; m_IsWASDKeyDown.W = false;
return true; //m_NextSnapshot.inputForward = "";
} return true;
if (e.KeyCode == GLFW_KEY_A || e.KeyCode == GLFW_KEY_D) { }
m_NextSnapshot.inputRight = ""; if (e.KeyCode == GLFW_KEY_A){
return true; m_IsWASDKeyDown.A = false;
} return true;
return false; }
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) void Client::CreateNewPlayer(int i)
{ {
m_PlayerDefinitions[i].EntityID = m_World->CreateEntity(); m_PlayerDefinitions[i].EntityID = m_World->CreateEntity();
ComponentWrapper transform = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Transform"); ComponentWrapper transform = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Transform");
ComponentWrapper model = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Model"); ComponentWrapper model = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Model");
model["Resource"] = "Models/Core/UnitSphere.obj"; model["Resource"] = "Models/Core/UnitSphere.obj";
} }