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

Merge remote-tracking branch 'origin/Networking' into Networking

Browse Source 
# Conflicts:
#	include/Engine/Network/Packet.h
#	src/Engine/Network/Packet.cpp
This commit is contained in:
Jocke
2015-12-18 10:16:31 +01:00
parent db5b6ad519 076030a252
commit 0eb51a0fea
12 changed files with 211 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Network/Client.h
+20 -21
View File
@@ -25,7 +25,7 @@ public:
void Update();
void Close();
private:
// UDP logic
// Assio UDP logic
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
boost::asio::io_service m_IOService;
boost::asio::ip::udp::socket m_Socket;
@@ -52,30 +52,29 @@ private:
// if game is turned of by closing window.
bool m_WasStarted = false;
// Private member functions
void readFromServer();
void sendSnapshotToServer();
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 parseConnect(Packet& packet);
void parsePing();
void parseServerPing();
void parseSnapshot(Packet& packet);
void createNewPlayer(int i);
void identifyPacketLoss();
bool isConnected();
// Events
EventBroker* m_EventBroker;
EventRelay<Client, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(const Events::InputCommand &e);
void ReadFromServer();
void SendSnapshotToServer();
int Receive(char* data, size_t length);
void Send(Package& message);
void Connect();
void Disconnect();
void Ping();
void MoveMessageHead(char*& data, size_t& length, size_t stepSize);
void ParseMessageType(Package& package);
void ParseEventMessage(Package& package);
void ParseConnect(Package& package);
void ParsePing();
void ParseServerPing();
void ParseSnapshot(Package& package);
void CreateNewPlayer(int i);
void IdentifyPacketLoss();
bool IsConnected();
};
#endif
include/Engine/Network/Network.h
+1 -1
View File
@@ -3,7 +3,7 @@
#include "Core/World.h"
#include "Core/EventBroker.h"
#include "Network/Package.h"
#include "Network/Packet.h"
class Network
{
include/Engine/Network/NetworkDefinitions.h
+1 -1
View File
@@ -3,7 +3,7 @@
#include <boost/asio/ip/udp.hpp>
#include <queue>
#include "Network/Package.h"
#include "Network/Packet.h"
#define BOARDSIZE 16
include/Engine/Network/Package.h → include/Engine/Network/Packet.h
+15 -15
View File
@@ -1,24 +1,24 @@
#ifndef Package_h__
#define Package_h__
#ifndef Packet_h__
#define Packet_h__
#include <string>
#include "Network/MessageType.h"
#include "Core/Util/Logging.h"
// Defines the
class Package
class Packet
{
public:
// arg1: Type of message (Connect, Disconnect...)
// arg2: PackageID for identifying packet loss.
Package(MessageType type, unsigned int& packageID);
// Used to create package from already existing data buffer.
Package(char* data, const int sizeOfPackage);
// arg2: PacketID for identifying packet loss.
Packet(MessageType type, unsigned int& packetID);
// Used to create packet from already existing data buffer.
Packet(char* data, const int sizeOfPacket);
~Package();
~Packet();
// Add primitive types like int, float, char...
template<typename T>
void AddPrimitive(T val)
void WritePrimitive(T val)
{
// Check if we are trying to add more than the package can fit.
if (m_MaxPacketSize < m_Offset + sizeof(T)) {
@@ -29,10 +29,10 @@ public:
}
// Pops the first element as if it was a primitive.
template<typename T>
T PopFrontPrimitive()
T ReadPrimitive()
{
if (m_Offset < m_ReturnDataOffset + sizeof(T)) {
LOG_WARNING("Packet PopFrontPrimitive(): You are trying to remove more than what exists in this package!");
LOG_WARNING("Packet PopFrontPrimitive(): You are trying to remove more than what exists in this packet!");
return -1;
}
T returnValue;
@@ -41,12 +41,12 @@ public:
return returnValue;
}
// Add a string to the message
void AddString(std::string str);
void WriteString(std::string str);
// Add data to the message
void AddData(char* data, int sizeOfData);
void WriteData(char* data, int sizeOfData);
// Pops the first element as if it was a string.
std::string PopFrontString();
char* PopData(int SizeOfData);
std::string ReadString();
char* ReadData(int SizeOfData);
int Size() { return m_Offset; };
char* Data() { return m_Data; };
include/Engine/Network/Server.h
+20 -20
View File
@@ -47,26 +47,26 @@ private:
// Close logic
bool m_ThreadIsRunning = true;
// Network functions
int Receive(char* data, size_t length);
void ReadFromClients();
void Send(Package& package, int playerID);
void Send(Package& package);
void MoveMessageHead(char*& data, size_t& length, size_t stepSize);
void Broadcast(std::string message);
void Broadcast(Package& package);
void SendSnapshot();
void SendPing();
void CheckForTimeOuts();
void Disconnect(int i);
void ParseMessageType(Package& package);
void ParseEvent(Package& package);
void ParseConnect(Package& package);
void ParseDisconnect();
void ParseClientPing();
void ParseServerPing();
void ParseSnapshot(Package& package);
void IdentifyPacketLoss();
// Private member functions
int receive(char* data, size_t length);
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();
void checkForTimeOuts();
void disconnect(int i);
void parseMessageType(Packet& packet);
void parseEvent(Packet& packet);
void parseConnect(Packet& packet);
void parseDisconnect();
void parseClientPing();
void parseServerPing();
void parseSnapshot(Packet& packet);
void identifyPacketLoss();
};
#endif
include/Game/Game.h
+1 -1
View File
@@ -50,7 +50,7 @@ private:
boost::thread m_NetworkThread;
// Network methods
void NetworkFunction();
void networkFunction();
Network* m_ClientOrServer;
bool m_IsClientOrServer = false;
resources/DefaultConfig.ini
+3 -5
View File
@@ -6,14 +6,12 @@ EditorEnabled=false
[Video]
Fullscreen=false
VSYNC=false
Width=1280
Height=720
FOV=45
[Networking]
StartNetwork=false
StartNetwork=false
Address=0.0.0.0
Port=0
src/Engine/Input/InputProxy.cpp
+2 -2
View File
@@ -62,7 +62,7 @@ void InputProxy::Process()
e.Command = command;
e.Value = currentValue;
m_EventBroker->Publish(e);
//LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
m_LastCommandValues[command] = currentValue;
}
}
@@ -78,7 +78,7 @@ void InputProxy::Process()
}
//e.Value = std::max(-1.f, std::min(e.Value, 1.f));
m_EventBroker->Publish(e);
//LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
}
m_CommandQueue.clear();
}
src/Engine/Network/Client.cpp
+65 -65
View File
@@ -35,7 +35,7 @@ void Client::Start(World* world, EventBroker* eventBroker)
}
m_Socket.connect(m_ReceiverEndpoint);
LOG_INFO("I am client. BIP BOP");
ReadFromServer();
readFromServer();
}
void Client::Update()
@@ -55,13 +55,13 @@ void Client::Update()
void Client::Close()
{
if (m_WasStarted) {
Disconnect();
disconnect();
m_ThreadIsRunning = false;
m_EventBroker->Unsubscribe(m_EInputCommand);
}
}
void Client::ReadFromServer()
void Client::readFromServer()
{
int bytesRead = -1;
char readBuf[1024] = { 0 };
@@ -71,23 +71,23 @@ void Client::ReadFromServer()
while (m_ThreadIsRunning) {
if (m_Socket.available()) {
bytesRead = Receive(readBuf, INPUTSIZE);
bytesRead = receive(readBuf, INPUTSIZE);
if (bytesRead > 0) {
Package package(readBuf, bytesRead);
ParseMessageType(package);
Packet packet(readBuf, bytesRead);
parseMessageType(packet);
}
}
std::clock_t currentTime = std::clock();
if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
if (IsConnected()) {
SendSnapshotToServer();
if (isConnected()) {
sendSnapshotToServer();
}
previousSnapshotMessage = currentTime;
}
}
}
void Client::SendSnapshotToServer()
void Client::sendSnapshotToServer()
{
// Reset previouse key state in snapshot.
m_NextSnapshot.InputForward = "";
@@ -113,86 +113,86 @@ void Client::SendSnapshotToServer()
}
if (m_NextSnapshot.InputForward != "") {
Package package(MessageType::Event, m_SendPacketID);
package.AddString(m_NextSnapshot.InputForward);
Send(package);
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString(m_NextSnapshot.InputForward);
send(packet);
} else {
Package package(MessageType::Event, m_SendPacketID);
package.AddString("0Forward");
Send(package);
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString("0Forward");
send(packet);
}
if (m_NextSnapshot.InputRight != "") {
Package package(MessageType::Event, m_SendPacketID);
package.AddString(m_NextSnapshot.InputRight);
Send(package);
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString(m_NextSnapshot.InputRight);
send(packet);
} else {
Package package(MessageType::Event, m_SendPacketID);
package.AddString("0Right");
Send(package);
Packet packet(MessageType::Event, m_SendPacketID);
packet.WriteString("0Right");
send(packet);
}
}
void Client::ParseMessageType(Package& package)
void Client::parseMessageType(Packet& packet)
{
int messageType = package.PopFrontPrimitive<int>();
int messageType = packet.ReadPrimitive<int>();
if (messageType == -1)
return;
// Read packet ID
m_PreviousPacketID = m_PacketID; // Set previous packet id
m_PacketID = package.PopFrontPrimitive<int>(); //Read new packet id
m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
//IdentifyPacketLoss();
switch (static_cast<MessageType>(messageType)) {
case MessageType::Connect:
ParseConnect(package);
parseConnect(packet);
break;
case MessageType::ClientPing:
ParsePing();
parsePing();
break;
case MessageType::ServerPing:
ParseServerPing();
parseServerPing();
break;
case MessageType::Message:
break;
case MessageType::Snapshot:
ParseSnapshot(package);
parseSnapshot(packet);
break;
case MessageType::Disconnect:
break;
case MessageType::Event:
ParseEventMessage(package);
parseEventMessage(packet);
break;
default:
break;
}
}
void Client::ParseConnect(Package& package)
void Client::parseConnect(Packet& packet)
{
m_PlayerID = package.PopFrontPrimitive<int>();
m_PlayerID = packet.ReadPrimitive<int>();
LOG_INFO("%i: I am player: %i", m_PacketID, m_PlayerID);
}
void Client::ParsePing()
void Client::parsePing()
{
m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
LOG_INFO("%i: response time with ctime(ms): %f", m_PacketID, m_DurationOfPingTime);
}
void Client::ParseServerPing()
void Client::parseServerPing()
{
Package message(MessageType::ServerPing, m_SendPacketID);
message.AddString("Ping recieved");
Send(message);
Packet message(MessageType::ServerPing, m_SendPacketID);
message.WriteString("Ping recieved");
send(message);
}
void Client::ParseEventMessage(Package& package)
void Client::parseEventMessage(Packet& packet)
{
int Id = -1;
std::string command = package.PopFrontString();
std::string command = packet.ReadString();
if (command.find("+Player") != std::string::npos) {
Id = package.PopFrontPrimitive<int>();
Id = packet.ReadPrimitive<int>();
// Sett Player name
m_PlayerDefinitions[Id].Name = command.erase(0, 7);
} else {
@@ -200,13 +200,13 @@ void Client::ParseEventMessage(Package& package)
}
}
void Client::ParseSnapshot(Package& package)
void Client::parseSnapshot(Packet& packet)
{
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.
tempName = package.PopFrontString();
tempName = packet.ReadString();
// Apply the position data read to the player entity
@@ -226,12 +226,12 @@ void Client::ParseSnapshot(Package& package)
// Move player to server position
int dataSize = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Info.Meta.Stride;
memcpy(m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Data, package.PopData(dataSize), dataSize);
memcpy(m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Data, packet.ReadData(dataSize), dataSize);
}
}
}
int Client::Receive(char* data, size_t length)
int Client::receive(char* data, size_t length)
{
boost::system::error_code error;
@@ -241,44 +241,44 @@ 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;
}
void Client::Send(Package& package)
void Client::send(Packet& packet)
{
m_Socket.send_to(boost::asio::buffer(
package.Data(),
package.Size()),
packet.Data(),
packet.Size()),
m_ReceiverEndpoint, 0);
}
void Client::Connect()
void Client::connect()
{
Package message(MessageType::Connect, m_SendPacketID);
message.AddString(m_PlayerName);
Packet message(MessageType::Connect, m_SendPacketID);
message.WriteString(m_PlayerName);
m_StartPingTime = std::clock();
Send(message);
send(message);
}
void Client::Disconnect()
void Client::disconnect()
{
Package message(MessageType::Connect, m_SendPacketID);
message.AddString("+Disconnect");
Send(message);
Packet message(MessageType::Connect, m_SendPacketID);
message.WriteString("+Disconnect");
send(message);
}
void Client::Ping()
void Client::ping()
{
Package message(MessageType::Connect, m_SendPacketID);
message.AddString("Ping");
Packet message(MessageType::Connect, m_SendPacketID);
message.WriteString("Ping");
m_StartPingTime = std::clock();
Send(message);
send(message);
}
void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize)
void Client::moveMessageHead(char*& data, size_t& length, size_t stepSize)
{
data += stepSize;
length -= stepSize;
@@ -286,7 +286,7 @@ void Client::MoveMessageHead(char*& data, size_t& length, size_t stepSize)
bool Client::OnInputCommand(const Events::InputCommand & e)
{
if (IsConnected()) {
if (isConnected()) {
ComponentWrapper& player = m_World->GetComponent(m_PlayerDefinitions[m_PlayerID].EntityID, "Player");
if (e.Command == "Forward") {
if (e.Value > 0) {
@@ -314,12 +314,12 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
}
}
if (e.Command == "ConnectToServer") { // Connect for now
Connect();
connect();
}
return false;
}
void Client::CreateNewPlayer(int i)
void Client::createNewPlayer(int i)
{
m_PlayerDefinitions[i].EntityID = m_World->CreateEntity();
ComponentWrapper transform = m_World->AttachComponent(m_PlayerDefinitions[i].EntityID, "Transform");
@@ -327,7 +327,7 @@ void Client::CreateNewPlayer(int i)
model["Resource"] = "Models/Core/UnitSphere.obj";
}
void Client::IdentifyPacketLoss()
void Client::identifyPacketLoss()
{
// if no packets lost, difference should be equal to 1
int difference = m_PacketID - m_PreviousPacketID;
@@ -336,7 +336,7 @@ void Client::IdentifyPacketLoss()
}
}
bool Client::IsConnected()
bool Client::isConnected()
{
if (m_PlayerID != -1) {
if (m_PlayerDefinitions[m_PlayerID].EntityID != -1) {
src/Engine/Network/Package.cpp → src/Engine/Network/Packet.cpp
+16 -19
View File
@@ -1,60 +1,57 @@
#include "Network/Package.h"
#include "Network/Packet.h"
Package::Package(MessageType type, unsigned int& packageID)
Packet::Packet(MessageType type, unsigned int& packetID)
{
m_Data = new char[128];
// Create message header
// Add message type
int messageType = static_cast<int>(type);
Package::AddPrimitive<int>(messageType);
packageID = packageID % 1000; // Packet id modulos
Package::AddPrimitive<int>(packageID);
packageID++;
Packet::WritePrimitive<int>(messageType);
packetID = packetID % 1000; // Packet id modulos
Packet::WritePrimitive<int>(packetID);
packetID++;
}
Package::Package(char* data, const int sizeOfPackage)
Packet::Packet(char* data, const int sizeOfPacket)
{
// Create message
// Resize message
m_MaxPacketSize = sizeOfPackage;
m_Data = new char[sizeOfPackage];
// Copy data newly allocated memory
memcpy(m_Data, data, sizeOfPackage);
m_Offset = sizeOfPackage;
}
Package::~Package()
Packet::~Packet()
{
delete[] m_Data;
}
void Package::AddString(std::string str)
void Packet::WriteString(std::string str)
{
// Message, add one extra byte for null terminator
int sizeOfString = str.size() + 1;
if (m_Offset + sizeOfString > m_MaxPacketSize) {
LOG_WARNING("Package::AddString(): Data size in packet exceeded maximum package size.\n");
LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size.\n");
}
memcpy(m_Data + m_Offset, str.data(), sizeOfString * sizeof(char));
m_Offset += sizeOfString * sizeof(char);
}
void Package::AddData(char * data, int sizeOfData)
void Packet::WriteData(char * data, int sizeOfData)
{
if (m_Offset + sizeOfData > m_MaxPacketSize) {
LOG_WARNING("Package::AddData(): Data size in packet exceeded maximum package size.\n");
LOG_WARNING("Packet::WriteData(): Data size in packet exceeded maximum packet size.\n");
}
memcpy(m_Data + m_Offset, data, sizeOfData);
m_Offset += sizeOfData;
}
std::string Package::PopFrontString()
std::string Packet::ReadString()
{
std::string returnValue(m_Data + m_ReturnDataOffset);
if (m_Offset < m_ReturnDataOffset + returnValue.size()){
LOG_WARNING("packet PopFrontString(): Oh no! You are trying to remove things outside my memory kingdom");
LOG_WARNING("packet ReadString(): Oh no! You are trying to remove things outside my memory kingdom");
return "PopFrontString Failed";
}
// +1 for null terminator.
@@ -62,10 +59,10 @@ std::string Package::PopFrontString()
return returnValue;
}
char * Package::PopData(int SizeOfData)
char * Packet::ReadData(int SizeOfData)
{
if (m_Offset < m_ReturnDataOffset + SizeOfData) {
LOG_WARNING("packet PopData(): Oh no! You are trying to remove things outside my memory kingdom");
LOG_WARNING("packet ReadData(): Oh no! You are trying to remove things outside my memory kingdom");
return nullptr;
}
unsigned int oldReturnDataOffset = m_ReturnDataOffset;
src/Engine/Network/Server.cpp
+61 -61
View File
@@ -16,7 +16,7 @@ void Server::Start(World* world, EventBroker* eventBroker)
}
LOG_INFO("I am Server. BIP BOP\n");
ReadFromClients();
readFromClients();
}
void Server::Update()
@@ -40,7 +40,7 @@ void Server::Close()
m_ThreadIsRunning = false;
}
void Server::ReadFromClients()
void Server::readFromClients()
{
char readBuffer[1024] = { 0 };
int bytesRead = 0;
@@ -60,9 +60,9 @@ void Server::ReadFromClients()
if (m_ThreadIsRunning && m_Socket.available()) {
try {
bytesRead = Receive(readBuffer, INPUTSIZE);
Package package(readBuffer, bytesRead);
ParseMessageType(package);
bytesRead = receive(readBuffer, INPUTSIZE);
Packet packet(readBuffer, bytesRead);
parseMessageType(packet);
} catch (const std::exception& err) {
//LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
}
@@ -71,59 +71,59 @@ void Server::ReadFromClients()
std::clock_t currentTime = std::clock();
// Send snapshot
if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
SendSnapshot();
sendSnapshot();
previousSnapshotMessage = currentTime;
}
// Send pings each
if (intervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
SendPing();
sendPing();
previousePingMessage = currentTime;
}
// Time out logic
if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
CheckForTimeOuts();
checkForTimeOuts();
timOutTimer = currentTime;
}
}
}
void Server::ParseMessageType(Package& package)
void Server::parseMessageType(Packet& packet)
{
int messageType = package.PopFrontPrimitive<int>(); // Read what type off message was sent from server
int messageType = packet.ReadPrimitive<int>(); // Read what type off message was sent from server
// Read packet ID
m_PreviousPacketID = m_PacketID; // Set previous packet id
m_PacketID = package.PopFrontPrimitive<int>(); //Read new packet id
m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
//IdentifyPacketLoss();
switch (static_cast<MessageType>(messageType)) {
case MessageType::Connect:
ParseConnect(package);
parseConnect(packet);
break;
case MessageType::ClientPing:
//ParseClientPing();
//parseClientPing();
break;
case MessageType::ServerPing:
ParseServerPing();
parseServerPing();
break;
case MessageType::Message:
break;
case MessageType::Snapshot:
ParseSnapshot(package);
parseSnapshot(packet);
break;
case MessageType::Disconnect:
ParseDisconnect();
parseDisconnect();
break;
case MessageType::Event:
ParseEvent(package);
parseEvent(packet);
break;
default:
break;
}
}
int Server::Receive(char * data, size_t length)
int Server::receive(char * data, size_t length)
{
length = m_Socket.receive_from(
boost::asio::buffer((void*)data
@@ -132,69 +132,69 @@ int Server::Receive(char * data, size_t length)
return length;
}
void Server::Send(Package& message, int playerID)
void Server::send(Packet& packet, int playerID)
{
m_Socket.send_to(
boost::asio::buffer(message.Data(), message.Size()),
boost::asio::buffer(packet.Data(), packet.Size()),
m_PlayerDefinitions[playerID].Endpoint,
0);
}
void Server::Send(Package & package)
void Server::send(Packet & packet)
{
m_Socket.send_to(
boost::asio::buffer(
package.Data(),
package.Size()),
packet.Data(),
packet.Size()),
m_ReceiverEndpoint,
0);
}
void Server::MoveMessageHead(char *& data, size_t & length, size_t stepSize)
void Server::moveMessageHead(char *& data, size_t & length, size_t stepSize)
{
data += stepSize;
length -= stepSize;
}
void Server::Broadcast(std::string message)
void Server::broadcast(std::string message)
{
Package package(MessageType::Event, m_SendPacketID);
package.AddString(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(package, i);
send(packet, i);
}
}
}
void Server::Broadcast(Package& package)
void Server::broadcast(Packet& packet)
{
for (int i = 0; i < MAXCONNECTIONS; ++i) {
if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
Send(package, i);
send(packet, i);
}
}
}
void Server::SendSnapshot()
void Server::sendSnapshot()
{
Package package(MessageType::Snapshot, m_SendPacketID);
Packet packet(MessageType::Snapshot, m_SendPacketID);
for (size_t i = 0; i < MAXCONNECTIONS; i++) {
// Send an empty name if there is no player connected on this position.
package.AddString(m_PlayerDefinitions[i].Name);
packet.WriteString(m_PlayerDefinitions[i].Name);
if (m_PlayerDefinitions[i].EntityID == -1) {
continue;
}
// Pack transfrom component into data package
// Pack transfrom component into data packet
auto transform = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform");
package.AddData(transform.Data, transform.Info.Meta.Stride);
packet.WriteData(transform.Data, transform.Info.Meta.Stride);
}
Broadcast(package);
broadcast(packet);
}
void Server::SendPing()
void Server::sendPing()
{
// Prints connected players ping
for (size_t i = 0; i < MAXCONNECTIONS; i++) {
@@ -205,15 +205,15 @@ void Server::SendPing()
}
// Create ping message
Package package(MessageType::ServerPing, m_SendPacketID);
package.AddString("Ping from server");
Packet packet(MessageType::ServerPing, m_SendPacketID);
packet.WriteString("Ping from server");
// Time message
m_StartPingTime = std::clock();
// Send message
Broadcast(package);
broadcast(packet);
}
void Server::CheckForTimeOuts()
void Server::checkForTimeOuts()
{
int timeOutTimeMs = 5000;
int startPing = 1000 * m_StartPingTime
@@ -225,15 +225,15 @@ void Server::CheckForTimeOuts()
/ static_cast<double>(CLOCKS_PER_SEC);
if (startPing > stopPing + timeOutTimeMs) {
LOG_INFO("Player %i timed out!", i);
Disconnect(i);
disconnect(i);
}
}
}
}
void Server::Disconnect(int i)
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
@@ -242,7 +242,7 @@ void Server::Disconnect(int i)
m_PlayerDefinitions[i].Name = "";
}
void Server::ParseEvent(Package& package)
void Server::parseEvent(Packet& packet)
{
size_t i;
for (i = 0; i < MAXCONNECTIONS; i++) {
@@ -255,7 +255,7 @@ void Server::ParseEvent(Package& package)
return;
unsigned int entityId = m_PlayerDefinitions[i].EntityID;
std::string eventString = package.PopFrontString();
std::string eventString = packet.ReadString();
if ("+Forward" == eventString) {
m_World->GetComponent(entityId, "Player")["Forward"] = true;
m_World->GetComponent(entityId, "Player")["Back"] = false;
@@ -278,7 +278,7 @@ void Server::ParseEvent(Package& package)
}
}
void Server::ParseConnect(Package& package)
void Server::parseConnect(Packet& packet)
{
LOG_INFO("Parsing connections");
// Check if player is already connected
@@ -294,48 +294,48 @@ void Server::ParseConnect(Package& package)
m_PlayersToCreate.push_back(i);
m_PlayerDefinitions[i].Endpoint = m_ReceiverEndpoint;
m_PlayerDefinitions[i].Name = package.PopFrontString();
m_PlayerDefinitions[i].Name = packet.ReadString();
m_StopTimes[i] = std::clock();
LOG_INFO("Player \"%s\" connected on IP: %s", m_PlayerDefinitions[i].Name, m_PlayerDefinitions[i].Endpoint.address().to_string());
Package package(MessageType::Connect, m_SendPacketID);
package.AddPrimitive<int>(i); // Player ID
Packet packet(MessageType::Connect, m_SendPacketID);
packet.WritePrimitive<int>(i); // Player ID
Send(package, i);
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);
broadcast(str);
break;
}
}
}
void Server::ParseDisconnect()
void Server::parseDisconnect()
{
LOG_INFO("%i: Parsing disconnect", m_PacketID);
for (int i = 0; i < MAXCONNECTIONS; i++) {
if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
Disconnect(i);
disconnect(i);
break;
}
}
}
void Server::ParseClientPing()
void Server::parseClientPing()
{
LOG_INFO("%i: Parsing ping", m_PacketID);
// Return ping
Package package(MessageType::ClientPing, m_SendPacketID);
package.AddString("Ping received");
Send(package); // This dosen't work for multiple users
Packet packet(MessageType::ClientPing, m_SendPacketID);
packet.WriteString("Ping received");
send(packet); // This dosen't work for multiple users
}
void Server::ParseServerPing()
void Server::parseServerPing()
{
for (int i = 0; i < MAXCONNECTIONS; i++) {
if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
@@ -346,7 +346,7 @@ void Server::ParseServerPing()
}
// NOT USED
void Server::ParseSnapshot(Package& package)
void Server::parseSnapshot(Packet& packet)
{
// Does no logic. Returns snapshot if client request one
// The snapshot is not a real snapshot tho...
@@ -360,7 +360,7 @@ void Server::ParseSnapshot(Package& package)
}
}
void Server::IdentifyPacketLoss()
void Server::identifyPacketLoss()
{
// if no packets lost, difference should be equal to 1
int difference = m_PacketID - m_PreviousPacketID;
src/Game/Game.cpp
+6 -4
View File
@@ -54,8 +54,9 @@ Game::Game(int argc, char* argv[])
m_SystemPipeline->AddSystem<PlayerSystem>();
m_SystemPipeline->AddSystem<EditorSystem>(m_Renderer);
// Invoke network
if (m_Config->Get<bool>("Networking.StartNetwork", false) == true)
boost::thread workerThread(&Game::NetworkFunction, this);
if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
boost::thread workerThread(&Game::networkFunction, this);
}
m_LastTime = glfwGetTime();
debugInitialize();
@@ -90,8 +91,9 @@ void Game::Tick()
m_EventBroker->Swap();
// Update network
if (m_IsClientOrServer)
if (m_IsClientOrServer) {
m_ClientOrServer->Update();
}
// Iterate through systems and update world!
@@ -134,7 +136,7 @@ void Game::debugTick(double dt)
m_EventBroker->Process<Game>();
}
void Game::NetworkFunction()
void Game::networkFunction()
{
std::string inputMessage;
LOG_INFO("Start client or server? (c/s)");