MultiplayerManager

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;
using System;

public class MultiplayerManager : MonoBehaviour {

    public static int connectionID;//El identificador de mi instancia dentro de la red.
    public ConnectionType connectionType;//Tipo de conección.
    public static NetworkClient myClient;//Información de conección a un Servidor.
    public static MultiplayerManager instance;//Singleton


    public enum ConnectionType
    {
        None,
        Server,
        Client,
        Both
    }

    public enum PacketIDs : short
    {
        ShootCommand,
        CreateBullet,
        Count,
        Move,
        ConnectToServer,
        SpawnPlayer,

    }

    //interno
    Dictionary<PacketIDs, Action<PacketBase>> PacketActions = new Dictionary<PacketIDs, Action<PacketBase>>();

    //de acceso publico
    public Dictionary<string, Action<string>> OldSchoolCommand = new Dictionary<string, Action<string>>();

    private void Awake()
    {
        instance = this;
    }

    private void OnGUI()
    {

        if (!NetworkServer.active && !NetworkClient.active)
        {
            if (GUILayout.Button("Start Server"))//Inicializamos una red como Servidor.
                SetupServer();

            if (GUILayout.Button("Start Client"))//Inicializamos la conección a una red como Cliente.
                SetupClient();

            if (GUILayout.Button("Start Host Client"))//Inicializamos una red como Servidor y lanzamos el juego.
                SetupServer(true);
        }

        if (NetworkClient.active)//Si mi cliente está activo...
            if (GUILayout.Button("Disconnect"))//Añadimos un botón en pantalla, para desconectarnos.
                myClient.Disconnect();//Nos desconectamos.
    }

    public void SetupServer(bool launchClient = false)
    {
        connectionType = launchClient ? ConnectionType.Both : ConnectionType.Server;
        AddPacketActions();//Inicializo mis diccionarios.
        NetworkServer.Listen(8080);//Se prepara para recibir paquetes en el puerto específicado.
        myClient = ClientScene.ConnectLocalServer();//Crea y connecta a una instancia local de cliente al servidor local. Esto combierte al cliente en un "Host" - Un cliente y un servidor en el mismo proceso.
                                                    // --> ClientScene: https://docs.unity3d.com/ScriptReference/Networking.ClientScene.html
    }

    public void SetupClient()
    {
        connectionType = ConnectionType.Client;
        myClient = new NetworkClient();//Creo una nueva instancia de la clase NetWorkClient.
        AddPacketActions();//Inicializo mis diccionarios.
        connectionID = UnityEngine.Random.Range(0, 1000);
        myClient.Connect("127.0.0.1", 8080);//Me conecto a la ip del servidor "root" de la red, en el puerto específicado.
    }

    void AddPacketActions()
    {
        /*
         * En Esta sección, lo que vamos a hacer es crear en nuestro sistema las acciones que se van a realizar en el
         * momento en el que un paquete llegue al puerto de nuestra conección.
         * Debemos registrar por separado la acción a realizar para cada tipo de paquete.
        */

        //Registramos en la red las acciones para cada paquete.
        if (connectionType == ConnectionType.Server)//Si somos el servidor.
            for (short i = 1000; i < 1000 + (short)PacketIDs.Count; i++)
                NetworkServer.RegisterHandler(i, OnPacketReceived);

        else if (connectionType == ConnectionType.Client)//Si somos el cliente.
            for (short i = 1000; i < 1000 + (short)PacketIDs.Count; i++)
                myClient.RegisterHandler(i, OnPacketReceived);

        else if (connectionType == ConnectionType.Both)//Si somos las 2 cosas.
            for (short i = 1000; i < 1000 + (short)PacketIDs.Count; i++)
            {
                if (myClient != null) Debug.Log("hay client");
                myClient.RegisterHandler(i, OnPacketReceived);
                NetworkServer.RegisterHandler(i, OnPacketReceived);
            }
        // --> RegisterHander: https://docs.unity3d.com/ScriptReference/Networking.NetworkServer.RegisterHandler.html

        //Registramos los paquetes en nuestro sistema. Poner Las acciones propias

        /*PacketActions.Add(PacketIDs.Move_Command, PacketExecution.Move_Command);
        PacketActions.Add(PacketIDs.Attack_Command, PacketExecution.Attack_Command);
        PacketActions.Add(PacketIDs.Select_Command, PacketExecution.Select_Command);
        PacketActions.Add(PacketIDs.Old_School_Command, PacketExecution.Old_School_Command);
        old_school_command.Add("Old_School_Move", x => Move(x));

        packetActions.Add(PacketIDs.ConnectToServer, PacketExecution.ConnectServer);
        */
        PacketActions.Add(PacketIDs.Move, PacketExecution.Move);
        PacketActions.Add(PacketIDs.SpawnPlayer, PacketExecution.SpawnPlayer);

    }

    void OnPacketReceived(NetworkMessage netMsg)
    {
        // NetworkMessage es usado para extraer un Mensaje Tipado del NetworkReader de un NetworkMessage object.
        var msg = netMsg.ReadMessage<PacketBase>();//Convierto el mensaje a un tipo PacketBase.
        msg.connectionID = netMsg.conn.connectionId;//Almaceno dentro del PacketBase la ID de la conección guardada en el Mensaje.

        if (PacketActions.ContainsKey((PacketIDs)msg.messageID))//Tomo el identificador del paquete y me fijo si existe en el diccionario correspondiente.
            PacketActions[(PacketIDs)msg.messageID](msg);//Si existe, lo ejecuto.
    }

    void ConnectToClient()
    {
        new PacketBase(PacketIDs.ConnectToServer).Add((float)connectionID).Send();
    }

    public void Move(int playerID, Vector3 pos)
    {

      //  charObj.transform.position = pos;
    }

    public void Shoot(Vector3 pos, Vector3 fwd, string parent)
    {

    }

    public void SpawnPlayer(int connID)
    {
        //GameManager.instancia.TheAutority.InstanciateBullet(pos, rot);
        SuperGameManager.mainPlayer.CreateTank(connID);
    }
}