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

Added logic for mapping between ServerEntityIDs and LocalEntityIDs removed old code that wasn't used.

Browse Source 
Added 1 map to Client and renamed m_ServerToClientMap to m_ServerIDToClientID.

// Good to know
To keep this structure please use insertIntoServerClientMaps() when adding items to them.
m_ServerIDToClientID and m_ClientIDToServerID maps between server EntityIDs and local EntityIDs.
To see if a local EntityID exist in m_ClientIDToServerID use clientServerMapsHasEntity(EntityID clientEntityID);
To see if server EntityID exist in m_ServerIDToClientID use serverClientMapsHasEntity(EntityID serverEntityID);
This commit is contained in:
Jocke
2016-01-14 17:11:54 +01:00
parent db18a45368
commit 696f44a673
5 changed files with 56 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Network/Client.h
+12 -11
View File
@@ -34,8 +34,6 @@ private:
// Sending message to server logic
int bytesRead = -1;
char readBuf[INPUTSIZE] = { 0 };
int snapshotInterval = 33;
std::clock_t previousSnapshotMessage = std::clock();
// Packet loss logic
unsigned int m_PacketID = 0;
@@ -46,40 +44,43 @@ private:
World* m_World;
std::string m_PlayerName;
int m_PlayerID = -1;
EntityID m_ServerEntityID = std::numeric_limits<EntityID>::max();
// Server Client Lookup map
// Assumes that root node for client and server is EntityID 0.
std::unordered_map<EntityID, EntityID> m_ServerToClientMap;
// Don't Add items to these two maps with insert, use insertIntoServerClientMaps(EntityID, EntityID)!!!!
std::unordered_map<EntityID, EntityID> m_ServerIDToClientID;
std::unordered_map<EntityID, EntityID> m_ClientIDToServerID;
// Network logic
PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
SnapshotDefinitions m_NextSnapshot;
double m_DurationOfPingTime;
std::clock_t m_StartPingTime;
// Use to check if we should send disconnect message
// if game is turned of by closing window.
bool m_WasStarted = false;
// Private member functions
void readFromServer();
void sendInputEvents();
int receive(char* data, size_t length);
void send(Packet& packet);
void connect();
void disconnect();
void ping();
void moveMessageHead(char*& data, size_t& length, size_t stepSize);
void parseMessageType(Packet& packet);
void parseEventMessage(Packet& packet);
void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
void parseConnect(Packet& packet);
void parsePlayerConnected(Packet& packet);
void parsePing();
void parseServerPing();
void parseSnapshot(Packet& packet);
void identifyPacketLoss();
bool isConnected();
EntityID createPlayer();
bool hasMappedEntity(EntityID entityID);
// Mapping Logic
// Returns if local EntityID exist in map
bool clientServerMapsHasEntity(EntityID clientEntityID);
// Returns if server EntityID exist in map
bool serverClientMapsHasEntity(EntityID serverEntityID);
void insertIntoServerClientMaps(EntityID serverEntityID, EntityID clientEntityID);
// Events
EventBroker* m_EventBroker;
include/Engine/Network/MessageType.h
+2 -2
View File
@@ -11,9 +11,9 @@ enum class MessageType
ServerPing,
Message,
Snapshot,
Event,
OnInputCommand,
OnPlayerDamage
OnPlayerDamage,
PlayerConnected
};
#endif
include/Engine/Network/Server.h
-4
View File
@@ -48,8 +48,6 @@ private:
// Game logic
World* m_World;
EventBroker* m_EventBroker;
// vec.size() = ammount of players to create, stores playerID's
std::vector<unsigned int> m_PlayersToCreate;
// Packet loss logic
unsigned int m_PacketID;
@@ -61,8 +59,6 @@ private:
void readFromClients();
void send(Packet& packet, int playerID);
void send(Packet& packet);
void moveMessageHead(char*& data, size_t& length, size_t stepSize);
void broadcast(std::string message);
void broadcast(Packet& packet);
void sendSnapshot();
void sendPing();
src/Engine/Network/Client.cpp
+34 -88
View File
@@ -6,15 +6,13 @@ using namespace boost::asio::ip;
Client::Client(ConfigFile* config) : m_Socket(m_IOService)
{
// Asumes root node is EntityID 0
m_ServerToClientMap.insert(std::make_pair(0, 0));
insertIntoServerClientMaps(0, 0);
// Default is local host
std::string address = config->Get<std::string>("Networking.Address", "127.0.0.1");
int port = config->Get<int>("Networking.Port", 13);
m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
// Set up network stream
m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
m_NextSnapshot.InputForward = "";
m_NextSnapshot.InputRight = "";
}
Client::~Client()
@@ -22,7 +20,6 @@ Client::~Client()
void Client::Start(World* world, EventBroker* eventBroker)
{
m_WasStarted = true;
m_EventBroker = eventBroker;
m_World = world;
@@ -47,58 +44,6 @@ void Client::readFromServer()
parseMessageType(packet);
}
}
std::clock_t currentTime = std::clock();
if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
if (isConnected()) {
//sendSnapshotToServer();
}
previousSnapshotMessage = currentTime;
}
}
void Client::sendInputEvents()
{
// Reset previous key state in snapshot.
m_NextSnapshot.InputForward = "";
m_NextSnapshot.InputRight = "";
auto player = m_World->GetComponent(m_PlayerDefinitions[m_PlayerID].EntityID, "Player");
// See if any movement keys are down
// We dont care if it's overwritten by later
// if statement. Watcha gonna do, right!
if (player["Forward"]) {
m_NextSnapshot.InputForward = "+Forward";
}
if (player["Left"]) {
m_NextSnapshot.InputRight = "-Right";
}
if (player["Back"]) {
m_NextSnapshot.InputForward = "-Forward";
}
if (player["Right"]) {
m_NextSnapshot.InputRight = "+Right";
}
if (m_NextSnapshot.InputForward != "") {
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString(m_NextSnapshot.InputForward);
send(packet);
} else {
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString("0Forward");
send(packet);
}
if (m_NextSnapshot.InputRight != "") {
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString(m_NextSnapshot.InputRight);
send(packet);
} else {
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString("0Right");
send(packet);
}
}
void Client::parseMessageType(Packet& packet)
@@ -130,9 +75,8 @@ void Client::parseMessageType(Packet& packet)
break;
case MessageType::Disconnect:
break;
case MessageType::Event:
parseEventMessage(packet);
break;
case MessageType::PlayerConnected:
parsePlayerConnected(packet);
default:
break;
}
@@ -140,10 +84,19 @@ void Client::parseMessageType(Packet& packet)
void Client::parseConnect(Packet& packet)
{
// Set your own player id
m_PlayerID = packet.ReadPrimitive<int>();
m_ServerEntityID = packet.ReadPrimitive<EntityID>();
// Map ServerEntityID and your PlayerID
LOG_INFO("%i: I am player: %i", m_PacketID, m_PlayerID);
}
void Client::parsePlayerConnected(Packet & packet)
{
// Map ServerEntityID and other player's PlayerID
LOG_INFO("A Player connected");
}
void Client::parsePing()
{
m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
@@ -157,19 +110,6 @@ void Client::parseServerPing()
send(packet);
}
void Client::parseEventMessage(Packet& packet)
{
int Id = -1;
std::string command = packet.ReadString();
if (command.find("+Player") != std::string::npos) {
Id = packet.ReadPrimitive<int>();
// Sett Player name
m_PlayerDefinitions[Id].Name = command.erase(0, 7);
} else {
LOG_INFO("%i: Event message: %s", m_PacketID, command.c_str());
}
}
void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType)
{
for (auto field : componentInfo.FieldsInOrder) {
@@ -194,9 +134,9 @@ void Client::parseSnapshot(Packet& packet)
EntityID receivedParentEntityID = packet.ReadPrimitive<EntityID>();
ComponentInfo componentInfo = m_World->GetComponents(componentType)->ComponentInfo();
// Check if the received EntityID is mapped to one of our local EntityIDs
if (hasMappedEntity(receivedEntityID)) {
if (clientServerMapsHasEntity(receivedEntityID)) {
// Get the local EntityID
EntityID entityID = m_ServerToClientMap.at(receivedEntityID);
EntityID entityID = m_ServerIDToClientID.at(receivedEntityID);
// Check if the component exists
if (m_World->HasComponent(entityID, componentType)) {
// If the entity and the component exists update it
@@ -213,7 +153,7 @@ void Client::parseSnapshot(Packet& packet)
// Create Entity
// If entity dosen't exist
EntityID newEntityID = m_World->CreateEntity();
m_ServerToClientMap.insert(std::make_pair(receivedEntityID, newEntityID));
insertIntoServerClientMaps(receivedEntityID, newEntityID);
// Check if EntityIDs are out of sync
if (newEntityID != receivedEntityID) {
LOG_INFO("Client::parseSnapshot(Packet& packet): Newly created EntityID is not the \
@@ -228,15 +168,15 @@ void Client::parseSnapshot(Packet& packet)
// Parent Logic
// Don't need to check if receivedEntityID is mapped. (It should have been set)
if (receivedParentEntityID != std::numeric_limits<EntityID>::max()) {
if (hasMappedEntity(receivedParentEntityID)) {
m_World->SetParent(m_ServerToClientMap.at(receivedEntityID), m_ServerToClientMap.at(receivedParentEntityID));
if (clientServerMapsHasEntity(receivedParentEntityID)) {
m_World->SetParent(m_ServerIDToClientID.at(receivedEntityID), m_ServerIDToClientID.at(receivedParentEntityID));
// If Parent dosen't exist create one and map receivedParentEntityID to it.
} else {
// Create the new parent and add it to map
EntityID newParentEntityID = m_World->CreateEntity();
m_ServerToClientMap.insert(std::make_pair(receivedParentEntityID, newParentEntityID));
insertIntoServerClientMaps(receivedParentEntityID, newParentEntityID);
// Set the newly created Entity as parent.
m_World->SetParent(m_ServerToClientMap.at(receivedEntityID), newParentEntityID);
m_World->SetParent(m_ServerIDToClientID.at(receivedEntityID), newParentEntityID);
}
}
}
@@ -252,7 +192,7 @@ int Client::receive(char* data, size_t length)
0, error);
if (error) {
LOG_ERROR("receive: %s", error.message().c_str());
//LOG_ERROR("receive: %s", error.message().c_str());
}
return bytesReceived;
}
@@ -288,12 +228,6 @@ void Client::ping()
send(packet);
}
void Client::moveMessageHead(char*& data, size_t& length, size_t stepSize)
{
data += stepSize;
length -= stepSize;
}
bool Client::OnInputCommand(const Events::InputCommand & e)
{
if (e.Command == "ConnectToServer") { // Connect for now
@@ -351,7 +285,19 @@ EntityID Client::createPlayer()
return entityID;
}
bool Client::hasMappedEntity(EntityID entityID)
bool Client::clientServerMapsHasEntity(EntityID clientEntityID)
{
return m_ServerToClientMap.find(entityID) != m_ServerToClientMap.end();
return m_ClientIDToServerID.find(clientEntityID) != m_ClientIDToServerID.end();
}
bool Client::serverClientMapsHasEntity(EntityID serverEntityID)
{
return m_ServerIDToClientID.find(serverEntityID) != m_ServerIDToClientID.end();
}
void Client::insertIntoServerClientMaps(EntityID serverEntityID, EntityID clientEntityID)
{
m_ServerIDToClientID.insert(std::make_pair(serverEntityID, clientEntityID));
m_ClientIDToServerID.insert(std::make_pair(clientEntityID, serverEntityID));
}
src/Engine/Network/Server.cpp
+8 -26
View File
@@ -50,7 +50,7 @@ void Server::readFromClients()
// Time out logic
if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
//checkForTimeOuts();
checkForTimeOuts();
timOutTimer = currentTime;
}
}
@@ -80,8 +80,6 @@ void Server::parseMessageType(Packet& packet)
case MessageType::Disconnect:
parseDisconnect();
break;
case MessageType::Event:
break;
case MessageType::OnInputCommand:
parseOnInputCommand(packet);
break;
@@ -120,23 +118,6 @@ void Server::send(Packet & packet)
0);
}
void Server::moveMessageHead(char *& data, size_t & length, size_t stepSize)
{
data += stepSize;
length -= stepSize;
}
void Server::broadcast(std::string message)
{
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString(message);
for (int i = 0; i < MAXCONNECTIONS; i++) {
if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
send(packet, i);
}
}
}
void Server::broadcast(Packet& packet)
{
for (int i = 0; i < MAXCONNECTIONS; ++i) {
@@ -214,7 +195,7 @@ void Server::checkForTimeOuts()
void Server::disconnect(int i)
{
broadcast("A player disconnected");
//broadcast("A player disconnected");
LOG_INFO("Player %i disconnected/timed out", i);
// Remove enteties and stuff
@@ -234,7 +215,7 @@ void Server::parseOnInputCommand(Packet& packet)
}
void Server::parseOnPlayerDamage(Packet & packet)
{
{
Events::PlayerDamage e;
e.DamageAmount = packet.ReadPrimitive<double>();
e.PlayerDamagedID = packet.ReadPrimitive<EntityID>();
@@ -264,15 +245,16 @@ void Server::parseConnect(Packet& packet)
LOG_INFO("Player \"%s\" connected on IP: %s", m_PlayerDefinitions[i].Name.c_str(), m_PlayerDefinitions[i].Endpoint.address().to_string().c_str());
// Send a message to the player that connected
Packet packet(MessageType::Connect, m_SendPacketID);
packet.WritePrimitive<int>(i); // Player ID
packet.WritePrimitive<EntityID>(m_PlayerDefinitions[i].EntityID); // Entity ID
send(packet, i);
// Send notification that a player has connected
std::string str = m_PacketID + "Player " + m_PlayerDefinitions[i].Name + " connected on: "
+ m_PlayerDefinitions[i].Endpoint.address().to_string();
broadcast(str);
Packet notificationPacket(MessageType::PlayerConnected, m_PacketID);
broadcast(notificationPacket);
break;
}
}