Nice Child

GameNetworkManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using MLAPI;
using MLAPI.SceneManagement;
using UnityEngine.SceneManagement;
using RufflesTransport;

namespace TankWar
{
    public class TankWarNetworkManager : NetworkingManager
    {
        // Client Side Events
        public Action failedConnectionHandler = null;
        public Action OnDisconnectHandler = null; // Handler for when a client disconnects from server/host
        public Action OnConnectHandler = null; // Handler when a client connects to the server

        // Server Side Events
        public Action<ulong> clientConnectedHandler = null;
        public Action<ulong> clientDisconnectedHandler = null;


        public bool clientConnecting = false; // Set to True when we attempt to start connecting
        string clientCode = "";


        public void Start()
        {
            OnClientConnectedCallback += ClientConnectedListener;
            OnClientDisconnectCallback += ClientDisconnectListener;
            initializeHandlers();
        }

        public void initializeHandlers()
        {
            // Client Side Events
            failedConnectionHandler = failedConnection;
            OnConnectHandler = OnConnectedToServer;
            OnDisconnectHandler = OnDisconnectedFromServer;

            // Server Events
            clientDisconnectedHandler = ClientDisconnected;
            clientConnectedHandler = ClientConnected;
        }

        public void Awake()
        {
            NetworkSceneManager.OnSceneSwitched += OnSceneSwitched;
        }

        public void ClientConnectedListener(ulong clientId)
        {
            Debug.Log("Entered Connected Listener");
            if (!IsServer)
            {
                clientConnecting = false;
                OnConnectHandler?.Invoke(); // Client Side
            }
            else
            {
                clientConnectedHandler?.Invoke(clientId); // Server Side
            }
        }

        public void ClientDisconnectListener(ulong clientId)
        {
            if (!IsServer && !clientConnecting)
            {
                // Execute for client only
                OnDisconnectHandler?.Invoke(); // client side
            }
            else if (clientConnecting)
            {
                clientConnecting = false;
                failedConnectionHandler?.Invoke(); // client side
            }
            else
            {
                clientDisconnectedHandler?.Invoke(clientId); // Server Side Only
            }
        }


        public void MakeServer()
        {
            clientConnecting = false;
#if UNITY_SERVER
			base.StartServer();         
#else
            base.StartHost();
#endif
        }


        public void StartClient()
        {
            clientConnecting = true;
            NetworkConfig.ConnectionData = System.Text.Encoding.ASCII.GetBytes(clientCode.ToString());
            base.StartClient();
        }

        // Clear our Previous Scene Handlers
        void OnSceneSwitched()
        {
            initializeHandlers(); // Clean all the handlers from the previous scene and re-establish the base ones.
        }


        // Listeners for Client Side to Call
        public void AddClientConnectedListener(Action listener)
        {
            OnConnectHandler += listener;
        }

        public void AddClientDisconnectedListener(Action listener)
        {
            OnDisconnectHandler += listener;
        }


        public void AddClientConnectionFailListener(Action listener)
        {
            failedConnectionHandler += listener;
        }
        // Remove Client Connection Listener
        public void RemoveClientConnectedListener(Action listener)
        {
            OnConnectHandler -= listener;
        }
        // Remove Client Disconnection Listener
        public void RemoveClientDisconnectedListener(Action listener)
        {
            OnDisconnectHandler -= listener;
        }

        // Remove Client Failed Connection Listener
        public void RemoveClientConnectionFailListener(Action listener)
        {
            failedConnectionHandler -= listener;
        }

        // Server side calls
        public void AddServerClientConnectedListener(Action<ulong> listener)
        {
            clientConnectedHandler += listener;
        }

        public void AddServerClientDisconnectedListener(Action<ulong> listener)
        {
            clientDisconnectedHandler += listener;
        }

        public void RemoveServerClientConnectedListener(Action<ulong> listener)
        {
            clientConnectedHandler -= listener;
        }

        public void RemoveServerClientDisconnectedListener(Action<ulong> listener)
        {
            clientDisconnectedHandler -= listener;
        }


        // Default Listeners

        public void ClientConnected(ulong clientId)
        {
            Debug.Log($"Client connected {clientId}");
        }


        void ClientDisconnected(ulong clientId)
        {
            Debug.Log($"Client disconnected {clientId}");
        }

        private void OnConnectedToServer()
        {
            Debug.Log("Connected to server");
        }

        public void OnDisconnectedFromServer()
        {
            Debug.Log("Disconnected from Server");
        }

        public void failedConnection()
        {
            Debug.Log("Connection to server failed");
        }
    }
}