ServerLogic Class Reference

Main server logic class, responsible for all server-managing actions. More...

Static Public Member Functions
static void	StartServer (int CCU, int port, DefaultNetworkSettings defaultSettings, ServerSettings serverSettings)
	Initializes and starts the server, including TCP/UDP listeners and packet handlers.
static void	StopServer ()
	Stops the server and closes all TCP and UDP connections.
static void	PacketAction (int packetId, Packet packet, int fromClient)
	Method responsible for managing received Packet.ClientPackets actions that are written in ServerReceiveHandler class. Can be easily extended for new packet types.
static void	SendUDPData (IPEndPoint clientEndPoint, Packet sendPacket)
	Sends a UDP packet to the specified client endpoint.
static DefaultNetworkSettings	GetSettings ()
static ServerSettings	GetServerSettings ()
static void	ConsoleLog (string message)
	Logs a message to the console with a newline.

Static Public Attributes
static Dictionary< int, ServerSideClient >	clientsList = new Dictionary<int, ServerSideClient>()
	A dictionary holding all connected clients, indexed by their client ID.
static int	maxCCU
	Maximum number of concurrent users allowed on the server.
static int	listeningPort
	Port number the server listens on for incoming connections.
static X509Certificate2	serverCertificate
	TLS certificate used for secure communication, if enabled.

Static Private Member Functions
static void	InitializeClientsList ()
	Initializes the client list.
static void	TcpConnectCallback (IAsyncResult result)
	Callback for handling new TCP client connections asynchronously. Assigns the client to the first available slot.
static void	UdpReceiveCallback (IAsyncResult result)
	Callback for processing incoming UDP data packets from clients.

Static Private Attributes
static TcpListener	tcpListener
	TCP listener for handling incoming TCP connections.
static UdpClient	udpListener
	UDP listener for handling incoming UDP packets.
static DefaultNetworkSettings	DefaultSettings
	Default network configuration settings for the server.
static ServerSettings	ServerSettings
	Advanced server-side settings used during initialization.

Detailed Description

Main server logic class, responsible for all server-managing actions.

Definition at line 12 of file ServerLogic.cs.

Member Function Documentation

ConsoleLog()

void ServerLogic.ConsoleLog ( string message )

static

Logs a message to the console with a newline.

Definition at line 250 of file ServerLogic.cs.

    {
        Console.WriteLine(message + "\n");
    }

GetServerSettings()

ServerSettings ServerLogic.GetServerSettings ( )

static

Definition at line 243 of file ServerLogic.cs.

    {
        return ServerSettings;
    }

GetSettings()

DefaultNetworkSettings ServerLogic.GetSettings ( )

static

Definition at line 238 of file ServerLogic.cs.

    {
        return DefaultSettings;
    }

InitializeClientsList()

void ServerLogic.InitializeClientsList ( )

staticprivate

Initializes the client list.

Definition at line 104 of file ServerLogic.cs.

    {
        for (int i = 1; i <= maxCCU; i++)
        {
            clientsList.Add(i, new ServerSideClient(i));
        }
    }

PacketAction()

void ServerLogic.PacketAction ( int packetId, Packet packet, int fromClient )

static

Method responsible for managing received Packet.ClientPackets actions that are written in ServerReceiveHandler class. Can be easily extended for new packet types.

Definition at line 114 of file ServerLogic.cs.

    {
        if (!Enum.IsDefined(typeof(Packet.ClientPackets), packetId))
        {
            Debug.LogWarning($"Unknown packet ID: {packetId}");
            return;
        }
 
        Packet.ClientPackets packetType = (Packet.ClientPackets)packetId;
 
        switch (packetType)
        {
            case Packet.ClientPackets.welcomeReceived:
                ServerReceiveHandler.WelcomeReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.MeassureRequest:
                ServerReceiveHandler.LatencyRequestReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.DisconnectRequest:
                ServerReceiveHandler.DisconnectRequestReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.MessageToUserRequest:
                ServerReceiveHandler.MessageToUserRequestReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.MessageToAllRequest:
                ServerReceiveHandler.MessageToAllRequestReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.TransformChange:
                ServerReceiveHandler.TransformChangeReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.AnimationChange:
                ServerReceiveHandler.AnimationChangeReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.BandwidthRequest:
                ServerReceiveHandler.BandwidthRequestReceived(fromClient, packet);
                break;
 
            case Packet.ClientPackets.ThroughputRequest:
                ServerReceiveHandler.ThroughputRequestReceived(fromClient, packet);
                break;
 
            default:
                Debug.LogWarning($"Unhandled client packet type: {packetType}");
                break;
        }
    }

SendUDPData()

void ServerLogic.SendUDPData ( IPEndPoint clientEndPoint, Packet sendPacket )

static

Sends a UDP packet to the specified client endpoint.

Definition at line 223 of file ServerLogic.cs.

    {
        try
        {
            if (clientEndPoint != null)
            {
                udpListener.BeginSend(sendPacket.ConvertToArray(), sendPacket.DataLength(), clientEndPoint, null, null);
            }
        }
        catch (Exception ex)
        {
            ConsoleLog($"Error sending via UDP {ex}");
        }
    }

StartServer()

void ServerLogic.StartServer ( int CCU, int port, DefaultNetworkSettings defaultSettings, ServerSettings serverSettings )

static

Initializes and starts the server, including TCP/UDP listeners and packet handlers.

Ability to use tunelling alternative to webserver (for example playit.gg service)

Definition at line 50 of file ServerLogic.cs.

    {
        DefaultSettings = defaultSettings;
        ServerSettings = serverSettings;
 
        if (DefaultSettings.useTLS == true)
        {
            try
            {
                serverCertificate = new X509Certificate2(DefaultSettings.certificatePath, DefaultSettings.certificatePassword);
                Debug.Log($"Certificate loaded successfully");
                Console.WriteLine($"Certificate loaded successfully");
            }
            catch (Exception ex)
            {
                Debug.LogError($"Problem with certificate: {ex.Message}");
                Console.WriteLine($"Problem with certificate: {ex.Message}");
            }
        }
 
        ConsoleLog("Starting Server");
        listeningPort = port;
        if (defaultSettings.useTunneling == true)
        {
            listeningPort = defaultSettings.TunnelPort;
        }
        maxCCU = CCU;
        InitializeClientsList();
        tcpListener = new TcpListener(IPAddress.Any, listeningPort); 
        tcpListener.Start(); 
        tcpListener.BeginAcceptTcpClient(new AsyncCallback(TcpConnectCallback), null); 
 
        udpListener = new UdpClient(listeningPort);
        udpListener.BeginReceive(UdpReceiveCallback, null);
 
        ConsoleLog($"Server started on Port {listeningPort}");
    }

StopServer()

void ServerLogic.StopServer ( )

static

Stops the server and closes all TCP and UDP connections.

Definition at line 94 of file ServerLogic.cs.

    {
        tcpListener.Stop();
        udpListener.Close();
        ConsoleLog("TCP and UDP sockets closed, server is down");
    }

TcpConnectCallback()

void ServerLogic.TcpConnectCallback ( IAsyncResult result )

staticprivate

Callback for handling new TCP client connections asynchronously. Assigns the client to the first available slot.

Definition at line 171 of file ServerLogic.cs.

    {
        TcpClient Client = tcpListener.EndAcceptTcpClient(result);
       tcpListener.BeginAcceptTcpClient(new AsyncCallback(TcpConnectCallback), null); 
        ConsoleLog($"Client on {Client.Client.RemoteEndPoint} is connecting");
        for (int i = 1; i <= maxCCU; i++)
        {
            if (clientsList[i].tcp.Socket == null)
            {
                clientsList[i].tcp.Connect(Client);
                ConsoleLog($"Client {clientsList[i].tcp.Socket.Client.RemoteEndPoint} has connected");            
                return;
            }
        }
        ConsoleLog("Max server CCU exceeded!");
    }

UdpReceiveCallback()

void ServerLogic.UdpReceiveCallback ( IAsyncResult result )

staticprivate

Callback for processing incoming UDP data packets from clients.

Definition at line 191 of file ServerLogic.cs.

    {
        try
        {
            IPEndPoint clientEndPoint = new IPEndPoint(IPAddress.Any, 0);
            byte[] data = udpListener.EndReceive(result, ref clientEndPoint);
            udpListener.BeginReceive(UdpReceiveCallback, null);
            if (data.Length < 4)
            {
                return;
            }
            Packet packet = new Packet(data);
            int clientId = packet.ReadInt();
            if (clientId == 0) return;
            if (clientsList[clientId].udp.EndPoint == null)
            {
                clientsList[clientId].udp.ConnectUDP(clientEndPoint);
                return;
            }
            if (clientsList[clientId].udp.EndPoint.ToString() == clientEndPoint.ToString())
            {
                clientsList[clientId].udp.UdpDataHandler(packet);
            }
        }
        catch (Exception ex)
        {
            ConsoleLog($"Error receiving UDP {ex}");
        }
    }

Member Data Documentation

clientsList

Dictionary<int, ServerSideClient> ServerLogic.clientsList = new Dictionary<int, ServerSideClient>()

static

A dictionary holding all connected clients, indexed by their client ID.

Definition at line 17 of file ServerLogic.cs.

DefaultSettings

DefaultNetworkSettings ServerLogic.DefaultSettings

staticprivate

Default network configuration settings for the server.

Definition at line 41 of file ServerLogic.cs.

listeningPort

int ServerLogic.listeningPort

static

Port number the server listens on for incoming connections.

Definition at line 25 of file ServerLogic.cs.

maxCCU

int ServerLogic.maxCCU

static

Maximum number of concurrent users allowed on the server.

Definition at line 21 of file ServerLogic.cs.

serverCertificate

X509Certificate2 ServerLogic.serverCertificate

static

TLS certificate used for secure communication, if enabled.

Definition at line 37 of file ServerLogic.cs.

ServerSettings

ServerSettings ServerLogic.ServerSettings

staticprivate

Advanced server-side settings used during initialization.

Definition at line 45 of file ServerLogic.cs.

tcpListener

TcpListener ServerLogic.tcpListener

staticprivate

TCP listener for handling incoming TCP connections.

Definition at line 29 of file ServerLogic.cs.

udpListener

UdpClient ServerLogic.udpListener

staticprivate

UDP listener for handling incoming UDP packets.

Definition at line 33 of file ServerLogic.cs.