Buscar..
Observaciones
Modo sin cabeza en la unidad
Si está construyendo un servidor para implementar en Linux, la configuración de compilación tiene una opción de "Modo sin cabeza". Una compilación de la aplicación con esta opción no muestra nada y no lee la entrada del usuario, que generalmente es lo que queremos para un servidor.
Creando un servidor, un cliente, y enviando un mensaje.
Unity networking proporciona la API de alto nivel (HLA) para manejar las comunicaciones de red que se abstraen de las implementaciones de bajo nivel.
En este ejemplo, veremos cómo crear un servidor que pueda comunicarse con uno o varios clientes.
El HLA nos permite serializar fácilmente una clase y enviar objetos de esta clase a través de la red.
La Clase que estamos utilizando para serializar.
Esta clase tiene que heredarse de MessageBase, en este ejemplo solo enviaremos una cadena dentro de esta clase.
using System;
using UnityEngine.Networking;
public class MyNetworkMessage : MessageBase
{
public string message;
}
Creando un servidor
Creamos un servidor que escucha el puerto 9999, permite un máximo de 10 conexiones y lee objetos de la red de nuestra clase personalizada.
El HLA asocia diferentes tipos de mensajes a una identificación. Hay tipos de mensajes predeterminados definidos en la clase MsgType de Unity Networking. Por ejemplo, el tipo de conexión tiene id 32 y se llama en el servidor cuando un cliente se conecta a él, o en el cliente cuando se conecta a un servidor. Puede registrar manejadores para gestionar los diferentes tipos de mensajes.
Cuando está enviando una clase personalizada, como nuestro caso, definimos un controlador con una nueva identificación asociada a la clase que estamos enviando a través de la red.
using UnityEngine;
using System.Collections;
using UnityEngine.Networking;
public class Server : MonoBehaviour {
int port = 9999;
int maxConnections = 10;
// The id we use to identify our messages and register the handler
short messageID = 1000;
// Use this for initialization
void Start () {
// Usually the server doesn't need to draw anything on the screen
Application.runInBackground = true;
CreateServer();
}
void CreateServer() {
// Register handlers for the types of messages we can receive
RegisterHandlers ();
var config = new ConnectionConfig ();
// There are different types of channels you can use, check the official documentation
config.AddChannel (QosType.ReliableFragmented);
config.AddChannel (QosType.UnreliableFragmented);
var ht = new HostTopology (config, maxConnections);
if (!NetworkServer.Configure (ht)) {
Debug.Log ("No server created, error on the configuration definition");
return;
} else {
// Start listening on the defined port
if(NetworkServer.Listen (port))
Debug.Log ("Server created, listening on port: " + port);
else
Debug.Log ("No server created, could not listen to the port: " + port);
}
}
void OnApplicationQuit() {
NetworkServer.Shutdown ();
}
private void RegisterHandlers () {
// Unity have different Messages types defined in MsgType
NetworkServer.RegisterHandler (MsgType.Connect, OnClientConnected);
NetworkServer.RegisterHandler (MsgType.Disconnect, OnClientDisconnected);
// Our message use his own message type.
NetworkServer.RegisterHandler (messageID, OnMessageReceived);
}
private void RegisterHandler(short t, NetworkMessageDelegate handler) {
NetworkServer.RegisterHandler (t, handler);
}
void OnClientConnected(NetworkMessage netMessage)
{
// Do stuff when a client connects to this server
// Send a thank you message to the client that just connected
MyNetworkMessage messageContainer = new MyNetworkMessage();
messageContainer.message = "Thanks for joining!";
// This sends a message to a specific client, using the connectionId
NetworkServer.SendToClient(netMessage.conn.connectionId,messageID,messageContainer);
// Send a message to all the clients connected
messageContainer = new MyNetworkMessage();
messageContainer.message = "A new player has conencted to the server";
// Broadcast a message a to everyone connected
NetworkServer.SendToAll(messageID,messageContainer);
}
void OnClientDisconnected(NetworkMessage netMessage)
{
// Do stuff when a client dissconnects
}
void OnMessageReceived(NetworkMessage netMessage)
{
// You can send any object that inherence from MessageBase
// The client and server can be on different projects, as long as the MyNetworkMessage or the class you are using have the same implementation on both projects
// The first thing we do is deserialize the message to our custom type
var objectMessage = netMessage.ReadMessage<MyNetworkMessage>();
Debug.Log("Message received: " + objectMessage.message);
}
}
El cliente
Ahora creamos un cliente
using System;
using UnityEngine;
using UnityEngine.Networking;
public class Client : MonoBehaviour
{
int port = 9999;
string ip = "localhost";
// The id we use to identify our messages and register the handler
short messageID = 1000;
// The network client
NetworkClient client;
public Client ()
{
CreateClient();
}
void CreateClient()
{
var config = new ConnectionConfig ();
// Config the Channels we will use
config.AddChannel (QosType.ReliableFragmented);
config.AddChannel (QosType.UnreliableFragmented);
// Create the client ant attach the configuration
client = new NetworkClient ();
client.Configure (config,1);
// Register the handlers for the different network messages
RegisterHandlers();
// Connect to the server
client.Connect (ip, port);
}
// Register the handlers for the different message types
void RegisterHandlers () {
// Unity have different Messages types defined in MsgType
client.RegisterHandler (messageID, OnMessageReceived);
client.RegisterHandler(MsgType.Connect, OnConnected);
client.RegisterHandler(MsgType.Disconnect, OnDisconnected);
}
void OnConnected(NetworkMessage message) {
// Do stuff when connected to the server
MyNetworkMessage messageContainer = new MyNetworkMessage();
messageContainer.message = "Hello server!";
// Say hi to the server when connected
client.Send(messageID,messageContainer);
}
void OnDisconnected(NetworkMessage message) {
// Do stuff when disconnected to the server
}
// Message received from the server
void OnMessageReceived(NetworkMessage netMessage)
{
// You can send any object that inherence from MessageBase
// The client and server can be on different projects, as long as the MyNetworkMessage or the class you are using have the same implementation on both projects
// The first thing we do is deserialize the message to our custom type
var objectMessage = netMessage.ReadMessage<MyNetworkMessage>();
Debug.Log("Message received: " + objectMessage.message);
}
}