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
oldsrc/Constants.h Normal file
View File

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

22
oldsrc/Protocoll.h Normal file
View File

@@ -0,0 +1,22 @@
// #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
oldsrc/Server.cpp Normal file
View File

@@ -0,0 +1,164 @@
// #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
oldsrc/Server.h Normal file
View File

@@ -0,0 +1,36 @@
// #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);
// };