En este tutorial vamos a construir una demostración simple de aprender cómo utilizar las funciones de la unidad de multijugador. Nuestro juego tendrá una única escena en la que vamos a implementar un multijugador tirador del espacio. En nuestra demostración en múltiples jugadores podrán unirse al mismo juego de disparar enemigos que serán iniciados al azar.

Con el fin de seguir este tutorial, que se espera que esté familiarizado con los siguientes conceptos:


  • programación C #
  • Uso del Editor de la unidad, tales como la importación de bienes, la creación de casas prefabricadas y la adición de componentes

    Vamos a utilizar un activo conocido como espejo. Esta es una expansión en el sistema de red por defecto de la unidad, la adición de nuevas características y la fijación de una gran cantidad de errores y problemas.

    Tabla de contenidos

    Creación de proyectos e importación de recursos

    Antes de comenzar a leer el tutorial, es necesario crear un nuevo proyecto de la Unidad e importar todos los sprites disponibles a través del código fuente. Con el fin de hacer eso, cree una carpeta llamada Sprites y copiar todos los sprites a esta carpeta. Unidad inspector les importará automáticamente a su proyecto.

    Sin embargo, algunos de esos sprites están en spritesheets, tales como los spritesheets enemigos, y ellos tienen que ser cortado en lonchas. Con el fin de hacer eso, tenemos que establecer el modo de Sprite como múltiple y abrir el Editor de Sprite.

    Importación de recursos sprites

    En el Editor de Sprite (que se muestra más abajo), es necesario abrir el menú rebanada y haga clic en el botón de la rebanada, con el tipo de sector tan automático. Por último, el golpe se aplica antes del cierre.


    También necesita importar el activo espejo. Ir al almacén de activos ( Ventana> Activos tienda ) y la descarga “espejo”.

    Descarga de espejo del almacén de activos.

    Fuente archivos de código

    Puede descargar los archivos de código fuente tutorial aquí.
    No se pierda! extremos de la oferta en

    • Accede a los más de 200 cursos
    • Nuevos cursos añadió mensual
    • Cancelar en cualquier momento
    • Los certificados de terminación

      ACCESO ahora

      fondo de la lona

      Lo primero que vamos a hacer es crear un lienzo de fondo para mostrar una imagen de fondo.

      Podemos hacerlo mediante la creación de una nueva imagen en la jerarquía, y se creará automáticamente una nueva mano (cambiarle el nombre a BackgroundCanvas).

      En los BackgroundCanvas, tenemos que establecer su Render Mode ser espacio de pantalla – Cámara (recuerde que debe conectar la cámara principal a ella). A continuación, vamos a establecer su modo Escala de interfaz de usuario a escala con Tamaño de la pantalla. De esta manera el lienzo aparecerá en el fondo, y no delante de los otros objetos.

      Creación del objeto de fondo de la lona del juego.

      En el BackgroundImage sólo tenemos que establecer el origen de imagen, el cual será el espacio.

      Creación de la imagen de fondo con la interfaz de usuario de la unidad

      Trate de ejecutar el juego ahora y usted debe ver el fondo del espacio en el juego.

      imagen de la estrella de fondo.

      Gestor de Red

      Con el fin de tener un juego de varios jugadores, necesitamos un GameObject con los componentes NetworkManager y NetworkManagerHUD, así que vamos a crear uno.

      gestor de red mediante la creación de redes marco de la Unidad y el espejo.

      Este objeto será responsable de la gestión para la conexión de los diferentes clientes en un juego y la sincronización de los objetos del juego entre todos los clientes. El Administrador de Red HUD muestra un sencillo HUD para los jugadores conectarse a un juego.

      Por ejemplo, si usted juega el juego ahora, debería ver la siguiente pantalla:

      Lo que las miradas juego como en este momento.

      En este tutorial vamos a utilizar el host LAN y opciones de LAN del cliente. De la unidad de juegos multijugador funcionan de la siguiente manera: en primer lugar, un jugador comienza un juego de anfitrión (host mediante la selección de LAN). Un host funciona como un cliente y un servidor al mismo tiempo. Luego, otros jugadores pueden conectarse a este host como clientes (mediante la selección de LAN de cliente). Los comunica cliente con el servidor, pero no se ejecutan en cualquier servidor único código. Por lo tanto, con el fin de probar nuestro juego vamos a abrir dos instancias de ella, uno como el anfitrión y otro como el cliente.

      Sin embargo, no se puede abrir dos instancias del juego en el Editor de la Unidad. Con el fin de hacerlo, que necesita para construir su juego y ejecutar la primera instancia del archivo ejecutable generado. El segundo ejemplo se puede ejecutar desde el editor de Unity (en el modo de reproducción).

      Con el fin de construir su juego que necesita para añadir la escena del juego a la acumulación. Por lo tanto, ir a Archivo -> configuración de generación y añadir la escena del juego de construcción. A continuación, se puede generar y archivo ejecutable y ejecutarlo haciendo clic en Archivo -> Construir y Ejecutar. Esto abrirá una nueva ventana con el juego. Después de hacer eso, se puede acceder al modo de reproducción en el Editor de la Unidad para ejecutar la segunda instancia del juego. Esto es lo que vamos a hacer cada vez que necesitamos para probar un juego de varios jugadores.

      Configuración de construir la unidad.

      movimiento de embarcaciones

      Ahora que tenemos el NetworkManager, podemos empezar a crear los objetos del juego que será gestionado por la misma. El primero que vamos a crear es la nave del jugador.

      Por ahora, el barco sólo se mueven horizontalmente en la pantalla, con su posición siendo actualizado por el NetworkManager. Más tarde, vamos a añadir a ella la capacidad de disparar balas y recibir daños.

      Por lo tanto, en primer lugar, crear una nueva llamada GameObject nave y hacer que una casa prefabricada. La siguiente figura muestra los componentes prefabricados de la nave, lo que voy a explicar ahora.

      objeto buque Player con componentes de red Unidad de espejo

      Con el fin de un objeto de juego que será gestionado por el NetworkManager, tenemos que añadir el componente NetworkIdentity a ella. Además, dado que la nave será controlado por el jugador, vamos a establecer la casilla Entidad jugador local para ello.

      El componente NetworkTransform, por su parte, es responsable de actualizar la posición del barco en todo el servidor y todos los clientes. De lo contrario, si nos hemos movido el barco en una pantalla, su posición no sería actualizado en las otras pantallas. NetworkIdentity y NetworkTransform son los dos componentes necesarios para las características multijugador. Habilitar Autoridad de cliente en el componente NetworkTransform.

      Ahora, al movimiento mango y colisiones, tenemos que añadir una RigidBody2D y una BoxCollider2D. Además, el BoxCollider2D será un disparador (Is activación establecido en true), ya que no queremos que las colisiones a afectar a la física de la nave.

      Por último, vamos a añadir un guión MoveShip, que tendrá un parámetro de velocidad. Se añadirán otros guiones más tarde, pero eso es todo por ahora.

      El script MoveShip es muy simple, en el método FixedUpdate obtenemos el movimiento desde el eje horizontal y ajustar la sensibilidad del buque en consecuencia. Sin embargo, hay dos cosas muy importantes relacionados con la red que deben ser explicados.

      En primer lugar, por lo general todas las secuencias de comandos en un juego Unidad hereda MonoBehaviour utilizar su API. Sin embargo, con el fin de utilizar la API de red el guión debe heredar NetworkBehaviour en lugar de MonoBehaviour. Es necesario que inlcude el espacio de nombres de red (usando UnityEngine.Networking) con el fin de hacer eso.

      Además, en un juego de varios jugadores Unidad, el mismo código se ejecuta en todas las instancias del juego (anfitrión y los clientes). Para permitir que los jugadores controlar sólo sus barcos, y no todos los barcos en el juego, tenemos que añadir una condición Si en el comienzo de la comprobación método FixedUpdate si este es el jugador local (si tienes curiosidad sobre cómo el juego se Si el trabajo sin esta condición, trate de retirarlo. Cuando se mueve un barco en una pantalla, todos los buques deben moverse juntos).
      utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando Espejo; MoveShip clase pública: NetworkBehaviour {[SerializeField] Velocidad de flotación privado; void FixedUpdate () {if (this.isLocalPlayer) {movimiento del flotador = Input.GetAxis ( «horizontal»); . GetComponent () velocidad = nuevo Vector2 (movimiento * velocidad, 0.0f); }}} 12345678910111213141516171819usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingMirror; publicclassMoveShip: NetworkBehaviour {[SerializeField] privatefloatspeed; voidFixedUpdate () {if (this.isLocalPlayer) {floatmovement = Input.GetAxis ( «horizontal»); getComponent < . Rigidbody2D> () = velocidad newVector2 (movimiento * velocidad, 0.0f);}}}

      Antes de jugar el juego, todavía tenemos que decirle al NetworkManager que la nave prefabricada es el jugador prefabricada. Lo hacemos seleccionándolo en el atributo jugador prefabricada en el componente de NetworkManager. Al hacer esto, cada vez que un jugador inicia una nueva instancia del juego, el NetworkManager creará una instancia de un barco.

      Configuración del gestor de la red prefabricada jugador.

      Ahora usted puede intentar jugar el juego. El movimiento del barco debe sincronizarse entre las dos instancias del juego.

      escena del juego que muestra dos naves espaciales azules

      freza Las posiciones

      Hasta ahora todos los buques están siendo generaron en el centro de la pantalla. Sin embargo, sería más interesante para fijar algunas posiciones predefinidas de regeneración, que es realmente fácil de hacer con la Unidad API multijugador.

      En primer lugar, tenemos que crear un nuevo juego de objetos a ser nuestra posición de desove y colocarlo en la posición deseada desove. A continuación, añadimos el componente NetworkStartPosition a ella. Voy a crear dos puestos de regeneración, una en la coordenada (-4, -4) y el otro en la coordenada (4, -4).

      la posición del objeto freza con una posición de inicio de la red.
      posición de objeto de inicio con un componente NetworkStartPosition.

      Ahora tenemos que definir cómo el NetworkManager utilizará esas posiciones. Hacemos esto mediante la configuración del atributo jugador freza Método. Hay dos opciones: allí aleatoria y Round Robin. medios aleatorias que, para cada instancia del juego, el gerente elegir la posición de inicio jugador al azar entre las posiciones desovar. Round Robin significa que va a ir secuencialmente a través de todas las posiciones de regeneración hasta que todos ellos han sido utilizados (por ejemplo, primeros SpawnPosition1 entonces SpawnPosition2). A continuación, comienza de nuevo desde el principio de la lista. Vamos a recoger Round Robin.

      Establecer el método de reproductor de desove de round robin en el administrador de red.

      Por ahora se puede tratar de jugar el juego de nuevo y ver si los barcos están siendo generaron en las posiciones correctas.

      escena del juego con naves espaciales azules más separados

      Las balas de disparo

      Lo siguiente que vamos a añadir en nuestro juego es dar la capacidad de los barcos fo balas de tiro. Además, esas balas deben estar sincronizados entre todas las instancias del juego.

      En primer lugar, tenemos que crear el prefabricada bala. Por lo tanto, crear una nueva llamada GameObject bala y que sea una casa prefabricada. Con el fin de gestionar en la red, que necesita los componentes NetworkIdentiy y NetworkTransform, como en el prefabricada barco. Sin embargo, una vez que se crea una bala, el juego no necesita para propagar su posición a través de la red, ya que la posición es actualizada por el motor de física. Por lo tanto, vamos a cambiar la red Enviar Tarifa en la Red Transformar a 0, para evitar la sobrecarga de la red.

      Además, las balas tendrá una velocidad y debe chocar con los enemigos más tarde. Por lo tanto, vamos a añadir un RigidBody2D y una CircleCollider2D a la casa prefabricada. Una vez más, el aviso de que el CircleCollider2D es un disparador.

      objeto de la bala con los componentes de la física y de red.

      Ahora que tenemos el prefabricada bala, podemos añadir un guión ShootBullets a la nave. Esta secuencia de comandos tendrá como parámetros de la bala prefabricada y la velocidad de la bala.

      Colocación de la escritura de balas disparar a la nave prefabricada.

      El script ShootBullets es también un NetworkBehaviour, y se muestra a continuación. En el método de actualización, se va a comprobar si el jugador local se ha pulsado la tecla de espacio y, de ser así, se llamará a un método para disparar balas. Este método va a crear una instancia de una nueva bala, establece su velocidad y destruirlo después de un segundo (cuando la bala ya ha salido de la pantalla).

      Una vez más, hay algunos conceptos importantes de la red que deben ser explicados aquí. En primer lugar, hay una etiqueta [Comando] anteriormente, el método CmdShoot. Esta etiqueta y el “cmd” en el principio del nombre del método que sea un método especial llamado Comando. En la unidad, un comando es un método que se ejecuta en el servidor, aunque se ha llamado en el cliente. En este caso, cuando el jugador dispara una bala locales, en lugar de llamar al método en el cliente, el juego va a enviar una solicitud de comando al servidor, y el servidor se ejecute el método.

      Además, hay una llamada a NetworkServer.Spawn en el método CmdShoot. El método de la freza es responsable de la creación de la bala en todas las instancias del juego. Por lo tanto, lo que hace es crear CmdShoot una bala en el servidor y, a continuación, el servidor replica esta bala entre todos los clientes. Tenga en cuenta que esto sólo es posible porque CmdShoot es un comando, y no un método regular.
      utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando Espejo; ShootBullets clase pública: NetworkBehaviour {[SerializeField] privada GameObject bulletPrefab; [SerializeField] bulletSpeed ​​flotador privado; vacío Update () {if (this.isLocalPlayer && Input.GetKeyDown (KeyCode.Space)) {this.CmdShoot (); }} [Comando] void CmdShoot () {GameObject bullet = Instantiate (bulletPrefab, this.transform.position, Quaternion.identity); . Bullet.GetComponent () velocidad = Vector2.up * bulletSpeed; NetworkServer.Spawn (bala); Destruye (bala, 1.0f); }} 123456789101112131415161718192021222324252627282930usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingMirror; publicclassShootBullets: NetworkBehaviour {[SerializeField] privateGameObject bulletPrefab; [SerializeField] privatefloatbulletSpeed; voidUpdate () {if (this.isLocalPlayer && Input.GetKeyDown (KeyCode.Space)) { this.CmdShoot ();}} [Comando] voidCmdShoot () {GameObject bullet = Instantiate (bulletPrefab, this.transform.position, Quaternion.identity);. bullet.GetComponent () velocidad = Vector2.up * bulletSpeed; NetworkServer.Spawn (bala); Destruir (bala, 1.0f);}}

      Por último, tenemos que decirle al administrador de la red que puede generar balas. Hacemos esto mediante la adición de la casa prefabricada de bala en la lista registrada Spawnable Prefabs.

      La adición de la casa prefabricada de bala en casas prefabricadas spawnable registrados del gestor de red.

      Ahora, usted puede intentar jugar el juego y disparar balas. Las balas deben estar sincronizados entre todas las instancias del juego.

      escena del juego Unidad con dos naves espaciales azules y una bala

      El desove enemigos

      El siguiente paso en nuestro juego es la adición de enemigos.

      En primer lugar, necesitamos una casa prefabricada enemigo. Por lo tanto, crear una nueva llamada GameObject enemigo y que sea una casa prefabricada. Como barcos, los enemigos tendrán un Rigidbody2D y BoxCollider2D a los movimientos de la manija y colisiones. Además, se necesita un NetworkIdentity y NetworkTransform, para ser manejado por el NetworkManager. Más adelante vamos a agregar una secuencia de comandos para que así, pero eso es todo por ahora.

      Enemigo prefabricada con los componentes de red del espejo y de la unidad

      Ahora, vamos a crear un GameObject llamada EnemySpawner. El EnemySpawner también tendrá un NetworkIdentity, pero ahora vamos a seleccionar el campo Servidor Sólo en el componente. De esta manera, el desove existirá sólo en el servidor, ya que no queremos enemigos a crearse en cada cliente. Además, tendrá un guión SpawnEnemies, que permita hacer surgir enemigos en un intervalo regular (los parámetros son los prefabricada enemigo, el intervalo de desove y la velocidad del enemigo).

      Enemy objeto desovador que prefabs desova enemigas.

      El script SpawnEnemies se muestra a continuación. Tenga en cuenta que estamos utilizando un nuevo método Unidad aquí: OnStartServer. Este método es muy similar al OnStart, la única diferencia es que sólo se llama para el servidor. Cuando esto sucede, vamos a llamar a InovkeRepeating para llamar al método SpawnEnemy cada 1 segundo (según spawnInterval).

      El método SpawnEnemy va a crear una instancia de un nuevo enemigo en una posición aleatoria, y utilizar NetworkServer.Spawn replicarlo entre todas las instancias del juego. Por último, el enemigo será destruido después de 10 segundos.
      utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando Espejo; SpawnEnemies clase pública: NetworkBehaviour {[SerializeField] privada GameObject enemyPrefab; [SerializeField] flotador privado spawnInterval = 1.0f; [SerializeField] flotador privado enemySpeed ​​= 1.0f; override public void OnStartServer () {InvokeRepeating ( «SpawnEnemy», this.spawnInterval, this.spawnInterval); } Void SpawnEnemy () {Vector2 spawnPosition = new Vector2 (Random.Range (-4.0f, 4.0F), this.transform.position.y); GameObject enemigo = Instantiate (enemyPrefab, spawnPosition, Quaternion.identity) como GameObject; . Enemy.GetComponent () velocidad = nuevo Vector2 (0.0f, -this.enemySpeed); NetworkServer.Spawn (enemigo); Destruye (enemigo, 10); }} 123456789101112131415161718192021222324252627282930usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingMirror; publicclassSpawnEnemies: NetworkBehaviour {[SerializeField] privateGameObject enemyPrefab; [SerializeField] privatefloatspawnInterval = 1.0f; [SerializeField] privatefloatenemySpeed ​​= 1.0f; publicoverridevoidOnStartServer () {InvokeRepeating ( «SpawnEnemy «, this.spawnInterval, this.spawnInterval);} voidSpawnEnemy () {Vector2 spawnPosition = newVector2 (Random.Range (-4.0f, 4.0F), this.transform.position.y); GameObject enemigo = Instantiate (enemyPrefab, spawnPosition , Quaternion.identity) asGameObject; enemy.GetComponent () velocidad = newVector2 (0.0f, -this.enemySpeed);. NetworkServer.Spawn (enemigo); Destruye (enemigo, 10);}}

      Antes de jugar el juego, tenemos que añadir el prefabricada Enemigo a la lista registrada Spawnable Prefabs.

      Añadiendo el enemigo prefabricada a la lista de casas prefabricadas spawnable registrada del gestor de la red.

      Ahora usted puede intentar jugar el juego ahora con los enemigos. Tenga en cuenta que el juego todavía no tiene aún el manejo de cualquier colisión. Por lo que no será capaz de disparar a los enemigos. Este será nuestro siguiente paso.

      escena del juego Unidad con naves espaciales y los enemigos verdes

      recibir daño

      Lo último que vamos a añadir a nuestro juego es la capacidad de golpear a los enemigos y, por desgracia, a morir con ellos. A fin de mantener este sencillo tutorial, voy a utilizar el mismo guión de los dos enemigos y barcos.

      La secuencia de comandos que se va a utilizar se llama ReceiveDamage, y se muestra a continuación. Se tendrá como parámetros configurables maxHealth, enemyTag y destroyOnDeath. El primero se utiliza para definir la salud inicial del objeto. La segunda se utiliza para detectar colisiones. Por ejemplo, el enemyTag para los buques será “Enemigo”, mientras que el enemyTag para los enemigos será “bala”. De esta manera, podemos construir naves chocar solamente con los enemigos, y enemigos chocar únicamente con balas. El último parámetro (destroyOnDeath) se utiliza para determinar si un objeto se respawned o destruida después de morir.
      utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando Espejo; ReceiveDamage clase pública: NetworkBehaviour {[SerializeField] private int maxHealth = 10; [SyncVar] int currentHealth privado; [SerializeField] cadena privada enemyTag; [SerializeField] destroyOnDeath bool privado; initialPosition Vector2 privado; // Usar esto para la inicialización de inicio void () {this.currentHealth = this.maxHealth; this.initialPosition = this.transform.position; } Void OnTriggerEnter2D (Collider2D colisionador) {if (collider.tag == this.enemyTag) {this.TakeDamage (1); Destruye (collider.gameObject); }} Void TakeDamage (cantidad int) {if (this.isServer) {this.currentHealth – = cantidad; si (this.currentHealth <= 0) {if (this.destroyOnDeath) {Destruir (this.gameObject); } Else {this.currentHealth = this.maxHealth; RpcRespawn (); }}}} [ClientRpc] void RpcRespawn () {this.transform.position = this.initialPosition; }} 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingMirror; publicclassReceiveDamage: NetworkBehaviour {[SerializeField] privateintmaxHealth = 10; [SyncVar] privateintcurrentHealth; [SerializeField] privatestringenemyTag; [SerializeField] privatebooldestroyOnDeath; privateVector2 initialPosition; // utilizar esto para initializationvoidStart () {this.currentHealth = this.maxHealth; this.initialPosition = this.transform.position;} voidOnTriggerEnter2D (Collider2D colisionador) {if (collider.tag == this.enemyTag) {this.TakeDamage (1); Destruye ( collider.gameObject);}} voidTakeDamage (intamount) {if (this.isServer) {this.currentHealth- = cantidad; si (this.currentHealth <= 0) {if (this.destroyOnDeath) {Destruye (this.gameObject); } else {this.currentHealth = this.maxHealth; RpcRespawn ();}}}} [ClientRpc] voidRpcRespawn () {this.transform.position = this.initialPosition;}}

      Ahora, vamos a analizar los métodos. En el método de inicio, el script establece el currentHealth a ser el máximo, y guarda la posición inicial (la posición inicial se utilizará para barcos de reaparición después). Además, los avisos que hay una etiqueta [SyncVar] por encima de la definición de atributo currentHealth. Esto significa que este valor de atributo deben estar sincronizados entre los casos de juego. Por lo tanto, si un objeto recibe daños en un caso, que se propagará a todos ellos.

      El método OnTriggerEnter2D es el responsable del manejo de colisiones (ya que los colisionadores que hemos añadido se configuran como factores desencadenantes). En primer lugar, comprobamos si la etiqueta es el colisionador enemyTag que estamos buscando, para manejar las colisiones contra objetos solamente estamos buscando (enemigos contra los buques y balas contra los enemigos). Si es así, llamamos al método TakeDamage y destruir al otro colisionador.

      El método TakeDamage, por su parte, se llamará sólo en el servidor. Esto se debe a la currentHealth ya es un SyncVar, por lo que sólo tenemos que actualizarlo en el servidor y se sincronizará entre los clientes. Además de eso, el método TakeDamage es simple, disminuye la currentHealth y comprueba si es menor que o igual a 0. Si es así, el objeto será destruido, si destroyOnDeath es cierto, o la currentHealth se restablecerá y el objeto se se regeneran. En la práctica, vamos a hacer enemigos a ser destruidos en caso de muerte, mientras que se regeneran los barcos.

      El último método es la reaparición de uno. Aquí estamos utilizando otra característica multijugador llamado ClientRpc (observar la etiqueta [ClientRpc] por encima de la definición del método). Esto es como lo contrario de la etiqueta [Comando]. Mientras que los comandos se envían desde los clientes al servidor, un ClientRpc se ejecuta en el cliente, a pesar de que el método se llama desde el servidor. Así, cuando un objeto necesita ser respawned, el servidor enviará una solicitud al cliente para ejecutar el método RpcRespawn (el nombre del método debe comenzar con RPC), que se limitará a restablecer la posición a la inicial. Este método se debe ejecutar en el cliente, ya que queremos que sea llamado para los buques y barcos están controlados únicamente por los jugadores (que establece el atributo Autoridad jugador local tan cierto en el componente NetworkIdentity).

      Por último, tenemos que añadir este script para ambos los prefabricados de la nave y del enemigo. Tenga en cuenta que, para que la nave es necesario definir la etiqueta de enemigo como “enemigo”, mientras que para el enemigo este valor del atributo es “bala” (también es necesario definir adecuadamente las etiquetas prefabricadas). Además, en el enemigo prefabricados vamos a comprobar el atributo Destruye Sobre la muerte.

      Acabar con el objeto buque jugador

      Finalización del prefabricado enemigo.

      Ahora, usted puede intentar jugar el juego de disparos enemigos. Deje que algunos enemigos golpean sus barcos para ver si están siendo respawned correctamente también.

      Y con esto concluye este tutorial. Que me haga saber sus preguntas y opiniones en la sección de comentarios.

      Mensajes relacionados

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *