Gulum/DarkRP2DServer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update Dependencies & Yojimbo hello world & Bone server

Browse Source
This commit is contained in:
Julian Nießner
2019-04-24 09:21:17 +02:00
parent fc2e3e801c
commit e024ef3f0c
15 changed files with 541 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/Constants.h
View File

@@ -1,9 +0,0 @@
#pragma once
namespace constants {
const int CLIENT_PORT = 9999;
const int MAX_CLIENTS = 128;
}

98
src/DarkRP2DDedicatedServer.cpp
View File

@@ -1,85 +1,35 @@
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <signal.h>
#include <iostream>
#include <SDL_net.h>
#include <yojimbo.h>
#include "GameServer.h"
using namespace yojimbo;
static GameServer *serv;
void interrupt_handler( int /*dummy*/ )
{
serv->m_running = false;
}
int main(int argc, char *argv[])
{
TCPsocket sd, csd; /* Socket descriptor, Client socket descriptor */
IPaddress ip, *remoteIP;
int quit, quit2;
char buffer[512];
std::cout << "Starting DarkRP2D Server..." << std::endl;
if (SDLNet_Init() < 0)
if ( !InitializeYojimbo() )
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
printf( "error: failed to initialize Yojimbo!\n" );
return 1;
}
yojimbo_log_level( YOJIMBO_LOG_LEVEL_INFO );
/* Resolving the host using NULL make network interface to listen */
if (SDLNet_ResolveHost(&ip, NULL, 9999) < 0)
{
fprintf(stderr, "SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
std::cout << "Yojimbo lives!" << std::endl;
signal( SIGINT, interrupt_handler );
/* Open a connection with the IP provided (listen on the host's port) */
if (!(sd = SDLNet_TCP_Open(&ip)))
{
fprintf(stderr, "SDLNet_TCP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
std::cout << "DarkRP2D Server started." << std::endl;
std::cout << "Waiting for a Connection!" << std::endl;
/* Wait for a connection, send data and term */ quit = 0;
while (!quit)
{ /* This check the sd if there is a pending connection. * If there is one, accept that, and open a new socket for communicating */
if ((csd = SDLNet_TCP_Accept(sd)))
{ /* Now we can communicate with the client using csd socket * sd will remain opened waiting other connections */
/* Get the remote address */
if ((remoteIP = SDLNet_TCP_GetPeerAddress(csd))) /* Print the address, converting in the host format */
printf("Host connected: %x %d\n", SDLNet_Read32(&remoteIP->host), SDLNet_Read16(&remoteIP->port));
else
fprintf(stderr, "SDLNet_TCP_GetPeerAddress: %s\n", SDLNet_GetError());
quit2 = 0;
while (!quit2)
{
if (SDLNet_TCP_Recv(csd, buffer, 512) > 0)
{
printf("Client say: %s\n", buffer);
if (strcmp(buffer, "exit") == 0) /* Terminate this connection */
{
quit2 = 1;
printf("Terminate connection\n");
}
if (strcmp(buffer, "quit") == 0) /* Quit the program */
{
quit2 = 1;
quit = 1;
printf("Quit program\n");
}
}
}
/* Close the client socket */ SDLNet_TCP_Close(csd);
}
}
std::cout << "Server is closing..." << std::endl;
SDLNet_TCP_Close(sd);
SDLNet_Quit();
std::cout << "Server closed!" << std::endl;
yojimbo::Address addr(127,0,0,1,9999);
GameServer server(addr);
serv = &server; //For interrupt
server.Run();
ShutdownYojimbo();
return EXIT_SUCCESS;
return 0;
}
}

137
src/GameServer.cpp Normal file
View File

@@ -0,0 +1,137 @@
#include "Gameserver.h"
#include <iostream>
using namespace yojimbo;
yojimbo::MessageFactory *GameAdapter::CreateMessageFactory(yojimbo::Allocator &allocator)
{
return YOJIMBO_NEW(allocator, GameMessageFactory, allocator);
}
void GameAdapter::OnServerClientConnected(int clientIndex)
{
if (m_server != NULL)
{
m_server->ClientConnected(clientIndex);
}
}
void GameAdapter::OnServerClientDisconnected(int clientIndex)
{
if (m_server != NULL)
{
m_server->ClientDisconnected(clientIndex);
}
}
GameServer::GameServer(const yojimbo::Address &address) : m_adapter(this),
m_server(yojimbo::GetDefaultAllocator(),
DEFAULT_PRIVATE_KEY,
address,
m_connectionConfig,
m_adapter, 0.0),
m_running(false)
{
// start the server
m_server.Start(MAX_PLAYERS);
if (!m_server.IsRunning())
{
throw std::runtime_error("Could not start server at port " + std::to_string(address.GetPort()));
}
// print the port we got in case we used port 0
char buffer[256];
m_server.GetAddress().ToString(buffer, sizeof(buffer));
// ... load game ...
}
void GameServer::ClientConnected(int clientIndex)
{
std::cout << "client " << clientIndex << " connected" << std::endl;
}
void GameServer::ClientDisconnected(int clientIndex)
{
std::cout << "client " << clientIndex << " disconnected" << std::endl;
}
void GameServer::Run()
{
float fixedDt = 1.0f / 60.0f;
m_running = true;
while (m_running)
{
double currentTime = yojimbo_time();
if (m_time <= currentTime)
{
Update(fixedDt);
m_time += fixedDt;
}
else
{
yojimbo_sleep(m_time - currentTime);
}
}
if (m_server.IsRunning())
m_server.Stop();
}
void GameServer::Update(float dt)
{
// stop if server is not running
if (!m_server.IsRunning())
{
m_running = false;
return;
}
// update server and process messages
m_server.AdvanceTime(m_time);
m_server.ReceivePackets();
ProcessMessages();
// ... process client inputs ...
// ... update game ...
// ... send game state to clients ...
m_server.SendPackets();
}
void GameServer::ProcessMessages()
{
for (int i = 0; i < MAX_PLAYERS; i++)
{
if (m_server.IsClientConnected(i))
{
for (int j = 0; j < m_connectionConfig.numChannels; j++)
{
yojimbo::Message *message = m_server.ReceiveMessage(i, j);
while (message != NULL)
{
ProcessMessage(i, message);
m_server.ReleaseMessage(i, message);
message = m_server.ReceiveMessage(i, j);
}
}
}
}
}
void GameServer::ProcessMessage(int clientIndex, yojimbo::Message *message)
{
switch (message->GetType())
{
case (int)GameMessageType::TEST:
ProcessTestMessage(clientIndex, (TestMessage *)message);
break;
default:
break;
}
}
void GameServer::ProcessTestMessage(int clientIndex, TestMessage *message)
{
// ... process test message ...
}

98
src/GameServer.h Normal file
View File

@@ -0,0 +1,98 @@
#pragma once
#include <yojimbo.h>
#include <string>
class GameServer;
// a simple test message
enum class GameMessageType
{
TEST,
COUNT
};
// two channels, one for each type that Yojimbo supports
enum class GameChannel
{
RELIABLE,
UNRELIABLE,
COUNT
};
// the client and server config
struct GameConnectionConfig : yojimbo::ClientServerConfig
{
GameConnectionConfig()
{
numChannels = 2;
channel[(int)GameChannel::RELIABLE].type = yojimbo::CHANNEL_TYPE_RELIABLE_ORDERED;
channel[(int)GameChannel::UNRELIABLE].type = yojimbo::CHANNEL_TYPE_UNRELIABLE_UNORDERED;
}
};
class TestMessage : public yojimbo::Message
{
public:
int m_data;
TestMessage() : m_data(0) {}
template <typename Stream>
bool Serialize(Stream &stream)
{
serialize_int(stream, m_data, 0, 512);
return true;
}
YOJIMBO_VIRTUAL_SERIALIZE_FUNCTIONS();
};
// the adapter
class GameAdapter : public yojimbo::Adapter
{
public:
explicit GameAdapter(GameServer *server = NULL) : m_server(server) {}
void OnServerClientConnected(int clientIndex) override;
void OnServerClientDisconnected(int clientIndex) override;
yojimbo::MessageFactory* CreateMessageFactory(yojimbo::Allocator& allocator) override;
private:
GameServer *m_server;
};
// the message factory
YOJIMBO_MESSAGE_FACTORY_START(GameMessageFactory, (int)GameMessageType::COUNT);
YOJIMBO_DECLARE_MESSAGE_TYPE((int)GameMessageType::TEST, TestMessage);
YOJIMBO_MESSAGE_FACTORY_FINISH();
static const uint8_t DEFAULT_PRIVATE_KEY[yojimbo::KeyBytes] = {0};
static const int MAX_PLAYERS = 64;
class GameServer
{
public:
GameServer(const yojimbo::Address &address);
void ClientConnected(int clientIndex);
void ClientDisconnected(int clientIndex);
void ProcessMessages();
void ProcessMessage(int clientIndex, yojimbo::Message *message);
void ProcessTestMessage(int clientIndex, TestMessage *message);
void Run();
void Update(float dt);
bool m_running;
private:
GameConnectionConfig m_connectionConfig;
yojimbo::Server m_server;
GameAdapter m_adapter;
double m_time;
};

22
src/Protocoll.h
View File

@@ -1,22 +0,0 @@
#pragma once
#define CONNECTION_REQUEST 0x01
#define CONNECTION_ACCEPTED 0x02
#define CONNECTION_DENIED 0x03
struct ConnectionRequest {
ConnectionRequest() : type(CONNECTION_REQUEST) {}
char type = CONNECTION_REQUEST;
};
struct ConnectionAccepted {
ConnectionAccepted() : type(CONNECTION_ACCEPTED) {}
char type;
int index;
};
struct ConnectionDenied {
ConnectionDenied() : type(CONNECTION_DENIED) {}
char type;
};

164
src/Server.cpp
View File

@@ -1,164 +0,0 @@
#include "Server.h"
#include "Protocoll.h"
#include <string>
#include <iostream>
#include <thread>
Server::Server(int port) : m_maxClients(constants::MAX_CLIENTS), m_clientConnected{0}
{
udpSocket = SDLNet_UDP_Open(port);
if (udpSocket == nullptr)
{
std::cout << "\tSDLNet_UDP_Open failed : " << SDLNet_GetError() << std::endl;
}
std::cout << "Server was started and is listening on port: " << port << std::endl;
//Creating ConnectionAccepted packet!
// Allocate udp packet with 512 byte size
connectionAccepted = SDLNet_AllocPacket(512);
if (connectionAccepted == nullptr)
{
std::cout << "\tSDLNet_AllocPacket failed : " << SDLNet_GetError() << std::endl;
}
ConnectionAccepted conAcc = ConnectionAccepted();
memcpy(connectionAccepted->data, &conAcc, sizeof(ConnectionAccepted));
connectionAccepted->len = sizeof(ConnectionAccepted);
connectionDenied = SDLNet_AllocPacket(512);
if (connectionDenied == nullptr)
{
std::cout << "\tSDLNet_AllocPacket failed : " << SDLNet_GetError() << std::endl;
}
ConnectionDenied conDen = ConnectionDenied();
memcpy(connectionDenied->data, &conDen, sizeof(ConnectionDenied));
connectionDenied->len = sizeof(ConnectionDenied);
//Creating receiver packet!
receivedPacket = SDLNet_AllocPacket(512);
if (receivedPacket == nullptr)
{
std::cout << "\tSDLNet_AllocPacket failed : " << SDLNet_GetError() << std::endl;
}
}
int Server::FindFreeClientIndex() const
{
for (int i = 0; i < m_maxClients; ++i)
{
if (!m_clientConnected[i])
return i;
}
return -1;
}
int Server::FindExistingClientIndex(const IPaddress &ip) const
{
for (int i = 0; i < m_maxClients; ++i)
{
if (m_clientConnected[i] && m_clients[i].host == ip.host && m_clients[i].port == ip.port)
return i;
}
return -1;
}
bool Server::IsClientConnected(int clientIndex) const
{
return m_clientConnected[clientIndex];
}
const IPaddress &Server::GetClientAddress(int clientIndex) const
{
return m_clients[clientIndex];
}
void Server::update(unsigned int delta)
{
//Receive packages
if (SDLNet_UDP_Recv(udpSocket, receivedPacket))
{
switch (*(receivedPacket->data))
{
case CONNECTION_REQUEST:
std::cout << "Connection request package received\n";
int freeIndex;
if ((freeIndex = this->FindFreeClientIndex()) == -1)
{
std::cout << "Connection denied because server full" << std::endl;
//Send Connection denied
this->sendConnectionDenied(receivedPacket->address);
break;
}
std::cout << "Free index found: " << freeIndex << std::endl;
int indexOfExistingClient;
if ((indexOfExistingClient = FindExistingClientIndex(receivedPacket->address)) == -1)
{
std::cout << "Client doesent exist create new" << std::endl;
m_clients[freeIndex] = receivedPacket->address;
m_clientConnected[freeIndex] = true;
//Send connection accepted with index
this->sendConnectionAccepted(receivedPacket->address, freeIndex);
m_numConnectedClients++;
break;
}
else
{
std::cout << "Client exist sending accepted" << std::endl;
//Send connection accepted with index
this->sendConnectionAccepted(receivedPacket->address, indexOfExistingClient);
}
break;
default:
break;
}
}
//Wait 10 sec
using namespace std::chrono_literals;
std::this_thread::sleep_for(1s);
//Send data
/*for(auto &value: clients) {
value.send(this->udpSocket,*helloWorldPacket);
}
std::cout << "Data was send!!" << std::endl;*/
}
bool Server::sendPacket(UDPpacket &packet)
{
// Send
// SDLNet_UDP_Send returns number of packets sent. 0 means error
if (SDLNet_UDP_Send(this->udpSocket, -1, &packet) == 0)
{
std::cout << "\tSDLNet_UDP_Send failed : " << SDLNet_GetError() << "\n"
<< "==========================================================================================================\n";
return false;
}
return true;
}
bool Server::sendConnectionDenied(IPaddress dest)
{
this->connectionDenied->address.host = dest.host;
this->connectionDenied->address.port = dest.port;
return this->sendPacket(*connectionDenied);
}
bool Server::sendConnectionAccepted(IPaddress dest, int index)
{
this->connectionAccepted->address.host = dest.host;
this->connectionAccepted->address.port = dest.port;
((ConnectionAccepted *) connectionAccepted->data)->index = index;
return this->sendPacket(*connectionAccepted);
}
Server::~Server()
{
SDLNet_FreePacket(receivedPacket);
SDLNet_FreePacket(connectionAccepted);
SDLNet_UDP_Close(udpSocket);
}

36
src/Server.h
View File

@@ -1,36 +0,0 @@
#pragma once
#include <SDL_net.h>
#include "Constants.h"
class Server {
public:
Server(int port);
~Server();
int FindFreeClientIndex() const;
int FindExistingClientIndex( const IPaddress &ip ) const;
bool IsClientConnected( int clientIndex ) const;
const IPaddress & GetClientAddress( int clientIndex ) const;
void update(unsigned int delta);
void gameTick();
private:
UDPsocket udpSocket;
UDPpacket *connectionDenied;
UDPpacket *connectionAccepted;
UDPpacket *receivedPacket;
int m_maxClients;
int m_numConnectedClients;
bool m_clientConnected[constants::MAX_CLIENTS];
IPaddress m_clients[constants::MAX_CLIENTS];
bool sendPacket(UDPpacket &packet);
bool sendConnectionDenied(IPaddress dest);
bool sendConnectionAccepted(IPaddress dest, int index);
};