NetworkBehaviour

Los NetworkBehaviour son scripts especiales que funcionan con objetos con el componente NetworkIdentity. Estos scripts son capaces de realizar funciones HLAPI como lo son Commands, ClientRPCs, SyncEvents y SyncVars.

Con el sistema de autoridad servidor del sistema de red de Unity, los objetos en red con NetworkIdentities deben estar “generadas” por el servidor utilizando el NetworkServer.Spawn(). Esto causa que ellos estén asignados al NetworkInstanceId y se creen en clientes que estén conectadas al servidor.

Propiedades

*Propiedad:*		*Función:*
isLocalPlayer		True si el objeto es el objeto jugador para el cliente local.
isServer		True, si este objeto está corriendo en el servidor, y ha sido generado.
isClient		True, si el objeto está corriendo en un cliente.
hasAuthority		True si este objeto es la version de autoridad del objeto. Así que en el servidor, o en el cliente con localPlayerAuthority.
assetId		Este es el assetID del NetworkIdentity del objeto.
netId		Este es el netID del NetworkIdentity del objeto.
playerControllerId		Este es el playerControllerId del NetworkIdentity del objeto.
connectionToServer		El objeto NetworkConnection a utilizar para enviar al servidor.
connectionToClient		El objeto NetworkConnection a utilizar para enviar al cliente.

NetworkBehaviours tienen las siguientes características que están descritas abajo.

Variables Synchronized (sincronizadas)
Callbacks de network
Funciones del Servidor y Cliente
Enviando Commands (comandos)
Llamadas Client RPC
Eventos en red

Variables Synchronized (sincronizadas)

Las variables miembro del NetworkBehaviours se pueden sincronizar del servidor a clientes. Debido a que el servidor es de autoridad en este sistema, la sincronización solamente está en la dirección servidor a cliente. Las solicitudes para que los clientes hagan cosas se manejan por Commands, no por variables sincronizadas de clientes.

El atributo SyncVar es utilizado para etiqueta variables miembro como si estuvieran sincronizadas. Las SyncVars pueden ser cualquier tipo básico, no clases, listas, u otras colecciones.

public class SpaceShip : NetworkBehaviour
{
    [SyncVar]
    public int health;

    [SyncVar]
    public string playerName;
}

Cuando el valor de una SyncVar cambia en el servidor, esta será enviada a todos los clientes ya listos en el juego. Cuando los objetos son generados, estos son creados en el cliente con el último estado de todas las SyncVars del servidor.

Callbacks de red

Hay funciones callback que son invocadas en scripts NetworkBehaviour para varios eventos en red. Estas son funciones virtuales en la clase base, por lo que pueden ser anuladas en código utilizado así:

public class SpaceShip : NetworkBehaviour
{
    public override void OnStartServer()
    {
        // disable client stuff
    }

    public override void OnStartClient()
    {
        // register client events, enable effects
    }
}

La función OnStartServer se llama cuando un objeto es generado en el servidor, o cuando el servidor empieza para objetos en la escena. La función OnStartClient se llama cuando el objeto es generado en el cliente, o cuando el cliente se conecta a un servidor para objetos en la escena. Estas funciones son útiles para hacer cosas que son específicas a ya sea el cliente o el servidor, tal como eliminar efectos en el servidor, o configurar eventos por el lado del cliente.

Tenga en cuenta que cuando un cliente local es utilizados, ambas funciones serán llamada en el mismo objeto.

Otros callbacks incluyen:

OnSerialize - llamado a recopilar el estado para enviar desde el servidor a los clientes
OnDeSerialize - llamado para aplicar un estado a los objetos en los clientes
OnNetworkDestroy - llamado en clientes cuando el servidor le dice al objeto que se destruya
OnStartLocalPlayer - llamado en clientes para objetos jugador para el cliente local (solamente)
OnRebuildObservers - llamado en el servidor cuando el conjunto de observadores para un objeto se re-construye
OnSetLocalVisibility - llamado en un anfitrión cuando la visibilidad de un objeto cambia para el cliente local
OnCheckObserver - llamado en el servidor para revisar el estado de visibilidad para un nuevo cliente

Funciones del Servidor y del Cliente

Funciones miembro en los NetworkBehaviours se pueden etiquetar con atributos personalizados para designarlos como funciones solamente para el servidor o solamente para el cliente. Por ejemplo:

using UnityEngine;
using UnityEngine.Networking;

public class SimpleSpaceShip : NetworkBehaviour
{
    int health;

    [Server]
    public void TakeDamage( int amount)
    {
        // will only work on server
        health -= amount;
    }

    [Client]
    void ShowExplosion()
    {
        // will only run on client
    }

    [ClientCallback]
    void Update()
    {
        // engine invoked callback - will only run on client
    }
}

Estos atributos hacen que la función devuelva inmediatamente si son llamados cuando el cliente o el servidor no estén activos. Estos no generan errores en el tiempo de compilación, pero emitirán un mensaje log de advertencia si se llama en el alcance (scope) equivocado. Los atributos ServerCallback y ClientCallback se pueden utilizar para funciones callback del motor que el código de usuario no controla su llamado. Estos atributos no causan que una advertencia se genere.

Enviando Commands (comandos)

Los Commands son maneras de que los clientes soliciten hacer algo en el servidor. Ya que la HLAPI es un sistema de autoridad del servidor, los clientes SOLAMENTE pueden hacer cosas a través de commands. Los commands son ejecutados en el objeto jugador en el servidor que corresponde al cliente que envió el command. Este en-rutamiento sucede automáticamente, por lo que es imposible para que un cliente envíe un commando para un jugador diferente.

Los Commands deben empezar con un prefijo “Cmd” y tener el atributo personalizado [Command] en ellos, como abajo:

using UnityEngine;
using UnityEngine.Networking;

public class SpaceShip : NetworkBehaviour
{
    bool alive;
    float thrusting;
    int spin;

    [Command]
    public void CmdThrust(float thrusting, int spin)
    {   
        if (!alive)
        {
            this.thrusting = 0;
            this.spin = 0;
            return;
        }
            
        this.thrusting = thrusting;
        this.spin = spin;
    }

    [ClientCallback]
    void Update()
    {
        int spin = 0;
        if (Input.GetKey(KeyCode.LeftArrow))
        {
            spin += 1;
        }
        if (Input.GetKey(KeyCode.RightArrow))
        {
            spin -= 1;
        }
        // this will be called on the server
        CmdThrust(Input.GetAxis("Vertical"), spin);
    }
}

Los commands son llamados simplemente al invocar la función normalmente en el cliente. Pero en vez de que la función command se ejecute en el cliente, será invocada en el objeto jugador del cliente en el servidor. Por lo que los commands son typesafe, tienen una seguridad integrada y un enrutamiento al jugador, y utilizar un mecanismo de serialización efectivo para que los argumentos hagan sus llamados más rápido.

Llamadas Client RPC

Las llamadas Client RPC son una manera para que los objetos en el servidor causen cosas que sucedan en objetos cliente. Esta es la dirección inversa de cómo los commands envían mensaje, pero los conceptos son lo mismo. Las llamas Client RPC sin embargo no solamente son invocadas en objetos jugador, estas son invocadas en cualquier objeto NetworkIdentity. Estas deben empezar con el prefijo “Rpc” y tienen el atributo personalizado [ClientRPC], como abajo:

using UnityEngine;
using UnityEngine.Networking;

public class SpaceShipRpc : NetworkBehaviour
{
    [ClientRpc]
    public void RpcDoOnClient(int foo)
    {
        Debug.Log("OnClient " + foo);
    }

    [ServerCallback]
    void Update()
    {
        int value = UnityEngine.Random.Range(0,100);
        if (value < 10)
        {
            // this will be invoked on all clients
            RpcDoOnClient(value);
        }
    }
}

Eventos en Red

Los eventos en red son como llamadas Client RPC, pero en vez de simplemente llamar una función en el objeto cliente, un Event en el objeto cliente se activa. Otros scripts que son registrados para el evento luego son invocados - con argumentos del servidor, por lo que esto permite interacciones en red inter-script en el cliente. Los eventos deben empezar con el prefijo “Event” y tener un atributo personalizado SyncEvent.

Los eventos pueden ser utilizados para construir sistemas de juego en red poderosos que pueden ser extendidos por otros scripts. Este ejemplo muestra cómo un script de efecto en el cliente puede responder a eventos generados por un script de combate en el servidor.

using UnityEngine;
using UnityEngine.Networking;

// Server script
public class MyCombat : NetworkBehaviour
{
    public delegate void TakeDamageDelegate(int amount);
    public delegate void DieDelegate();
    public delegate void RespawnDelegate();
    
    float deathTimer;
    bool alive;
    int health;

    [SyncEvent(channel=1)]
    public event TakeDamageDelegate EventTakeDamage;
    
    [SyncEvent]
    public event DieDelegate EventDie;
    
    [SyncEvent]
    public event RespawnDelegate EventRespawn;

    [Server]
    void EventTakeDamage(int amount)
    {
        if (!alive)
            return;
            
        if (health > amount) {
            health -= amount;
        }
        else
        {
            health = 0;
            alive = false;
            // send die event to all clients
            EventDie();
            deathTimer = Time.time + 5.0f;
        }
    }

    [ServerCallback]
    void Update()
    {
        if (!alive)
        {
            if (Time.time > deathTimer)
            {
                Respawn();
            }
            return;
        }
    }

    [Server]
    void Respawn()
    {
        alive = true;
        // send respawn event to all clients
        EventRespawn();
    }
}

Consejos

This is a base class that provides Commands and ClientRpc calls.

NetworkAnimator

NetworkClient

Manual