DarkRP2D/dedicated_server/src/Server.cpp

#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);
}