En el último tutorial de terminar la adición de la cuenta de un jugador de nuestro juego Bomberman. Ahora, vamos a hacer un juego de varios jugadores, utilizando soporte multijugador de la Unidad.

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


  • programación C #
  • conceptos unidad básica, como la importación de bienes, la creación de casas prefabricadas y la adición de componentes
  • Básico baldosa creación de mapas, tales como la adición de un juego de fichas y la creación de capas de mosaicos

    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

      Indice

      Activos de derechos de autor

      Los activos utilizados en este tutorial fueron creados por Cem Kalyoncu / cemkalyoncu y Matt Hackett / richtaur y puestos a disposición por “usr_share” a través de los campos comunes creativos licencia, cosa que permite el uso comercial bajo la atribución. Puede descargarlos en http://opengameart.org/content/bomb-party-the-complete-set o descargando el código fuente.

      archivos de código fuente

      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

        Gestor de la Red

        Con el fin de construir un juego de varios jugadores en unidad que necesitamos un objeto con el componente Network Manager. Por lo tanto, crear un objeto vacío en la escena Título y agregar el componente de red de administrador a él.

        También puede añadir el componente Gestor de Red de HUD. Esto mostrará un simple HUD en el juego que se puede usar para iniciar juegos multijugador. Más adelante vamos a crear nuestros propios botones de HUD, pero por ahora el Director de HUD red será suficiente.


        A estas alturas, se puede tratar de jugar el juego y se debe mostrar el Administrador de Red de HUD en la pantalla del título. El siguiente paso es hacer este NetworkManager para crear las múltiples jugadores en el juego.


        Creación de los jugadores

        El componente NetworkManager nos permite definir lo que es el jugador prefabricada en nuestro juego. Este prefabricada jugador será creado automáticamente por el administrador cada vez que un partido comienza. Pero antes de nuestra prefabricada jugador en el NetworkManager, necesitamos actualizar algunas cosas en el jugador prefabricadas en sí.

        A prefabricada puede ser instanciado por un NetworkManager sólo si tiene un componente NetworkIdentity unido a él. Por lo tanto, vamos a añadir una a nuestro jugador prefabricada. Además, el objeto del jugador debe ser controlado por los actores locales y no por el servidor, por lo que necesitamos para marcar la casilla Autoridad jugador local.


        Ahora, vamos a probar nuestro juego y ver si se están creando varias instancias del jugador. Pero primero, voy a explicar cómo funciona multijugador en la Unidad.

        En la Unidad, no hay un servidor dedicado para los partidos. Esto se debe a uno de los jugadores en un partido actúa como el servidor (además de ser un cliente en sí). El jugador que actúa como servidor y el cliente recibe el nombre de anfitrión en la Unidad. Para poder jugar una partida multijugador, uno de los jugadores tiene que comenzar el partido como el anfitrión, mientras que los otros se unen al partido como clientes. Todos los objetos del juego se replican en todos los casos de juego (servidores y clientes), y todos los scripts se ejecutan en todos los casos.

        Sin embargo, no podemos abrir dos instancias de nuestro juego en el editor de Unity. Por lo tanto, lo que tenemos que hacer es construir un ejecutable de nuestro juego y abrir por separado. Puede hacerlo seleccionando Archivo -> Construir y Ejecutar en el editor. Entonces, podemos empezar la otra instancia del editor de Unity.

        Trate de abrir dos instancias del juego. En uno de ellos, haga clic en el botón de host LAN del Gestor de Red de HUD. En el otro clic en el botón de LAN del cliente. Esto debería iniciar el juego en ambos casos, con dos objetos jugador.

        Sin embargo, hay un par de problemas que todavía tenemos que dirección:


        • Ambos jugadores se están creando en el centro de la pantalla. Queremos que se pueden crear en posiciones predefinidas.
        • Si tratamos de mover el reproductor en un cliente, ambos jugadores se mueven, y el movimiento no se propaga a los otros clientes.
        • Los jugadores no deben chocan entre cada otros.

          Lo que vamos a hacer ahora se dirige a todas esas cuestiones.

          Sincronizar el movimiento del jugador

          Empecemos haciendo que los jugadores a desovar en las posiciones predefinidas. Podemos hacer eso mediante la creación de objetos con el NetworkStartPosition en la escena de batalla. Por lo tanto, vamos a crear dos de ellos (queremos una batalla con dos jugadores). Ponerlos en las posiciones en las que desee a los jugadores para desovar.


          Ahora, el atributo jugador freza Método del NetworkManager define cómo se va a elegir las posiciones de los jugadores desovar. Hay dos políticas:


          1. Al azar:. La posición inicial de cada jugador será determinado al azar sobre la base de los que están disponibles
          2. Round-robin: dada una orden de las posiciones de partida, el primer jugador será creado en la primera posición. A continuación, el segundo jugador se creará en el segundo y así sucesivamente en forma circular.

            En nuestro caso, vamos a utilizar la política de operación por turnos.


            Ahora, usted puede intentar jugar el juego de nuevo, y los jugadores deben ser creados en las posiciones deseadas.

            Lo que vamos a hacer ahora es asegurarse de que cada cliente sólo puede mover su propio reproductor, y que el movimiento se propaga a través de todos los clientes.

            Podemos hacer que cada cliente se mueve su propio reproductor, cambiando el guión PlayerMovement. En primer lugar, vamos a hacer algo que será necesario que cada script que va a utilizar multijugador Características:. Tenemos que utilizar el espacio de nombres UnityEngine.Networking y tenemos que hacer que el script hereda NetworkBehaviour, en lugar de MonoBehaviour

            A continuación, vamos a cambiar el guión para que se vea como a continuación. En el principio del método FixedUpdate (que controla el movimiento de los jugadores), vamos a añadir una cláusula if que comprueba si este es el jugador local. Esta condición será verdadera sólo para uno de los clientes (el que controla el jugador) y falsa para todos los demás. De esta manera podemos asegurarnos de que sólo un cliente controlará cada jugador.

            Otra cosa que vamos a añadir es la realización del procedimiento OnStartLocalPlayer. Este método es similar al de la OnStart MonoBehaviour, pero va a ser llamado sólo para el jugador local. En este método vamos a definir el color del sprite del jugador a ser de color rojo, por lo que cada cliente puede identificar su propio reproductor.
            utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando UnityEngine.Networking; PlayerMovement clase pública: NetworkBehaviour {[SerializeField] Velocidad de flotación privado; [SerializeField] animador animador privado; override public void OnStartLocalPlayer () {getComponent () .color = Color.red; } Void FixedUpdate () {if (this.isLocalPlayer) {float moveHorizontal = Input.GetAxis ( «horizontal»); flotar moveVertical = Input.GetAxis ( «vertical»); Vector2 currentVelocity = gameObject.GetComponent () .velocity; flotar newVelocityX = 0f; si (moveHorizontal <0 && currentVelocity.x <= 0) {newVelocityX = -Velocidad; animator.SetInteger ( "DirectionX", -1); } Else if (moveHorizontal> 0 && currentVelocity.x> = 0) {newVelocityX = velocidad; animator.SetInteger ( «DirectionX», 1); } Else {animator.SetInteger ( «DirectionX», 0); } Flotar newVelocityY = 0f; si (moveVertical <0 && currentVelocity.y <= 0) {newVelocityY = -Velocidad; animator.SetInteger ( "DirectionY", -1); } Else if (moveVertical> 0 && currentVelocity.y> = 0) {= velocidad newVelocityY; animator.SetInteger ( «DirectionY», 1); } Else {animator.SetInteger ( «DirectionY», 0); } GameObject.GetComponent () .velocity = new Vector2 (newVelocityX, newVelocityY); }}} 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingUnityEngine.Networking; publicclassPlayerMovement: NetworkBehaviour {[SerializeField] privatefloatspeed; [SerializeField] privateAnimator animador; publicoverridevoidOnStartLocalPlayer () {getComponent () color = Color.red. ;} voidFixedUpdate () {if (this.isLocalPlayer) {floatmoveHorizontal = Input.GetAxis ( «horizontal»); floatmoveVertical = Input.GetAxis ( «vertical»);. Vector2 currentVelocity = gameObject.GetComponent () velocidad; floatnewVelocityX = 0f; si (moveHorizontal <0 && currentVelocity.x <= 0) {newVelocityX = -Velocidad; animator.SetInteger ( "DirectionX", - 1);} elseif (moveHorizontal> 0 && currentVelocity.x> = 0) {newVelocityX = velocidad ; animator.SetInteger ( «DirectionX», 1);} else {animator.SetInteger ( «DirectionX», 0);} floatnewVelocityY = 0f; si (moveVertical <0 && currentVelocity.y <= 0) {newVelocityY = -Velocidad; animador .SetInteger ( "Dir ectionY", - 1);} elseif (moveVertical> 0 && currentVelocity.y> = 0) {newVelocityY = velocidad; animator.SetInteger ( «DirectionY», 1);} else {animator.SetInteger ( «DirectionY», 0); .} gameObject.GetComponent () = velocidad newVector2 (newVelocityX, newVelocityY);}}}

            puede intentar jugar el juego ahora, y cada cliente podrá mover solamente un jugador. Sin embargo, el movimiento todavía no está siendo propagado a otro cliente. Podemos hacer eso mediante la adición de dos componentes en el jugador prefabricada: NetworkTransform y NetworkAnimator. El primer componente enviará la posición del jugador todos los clientes de acuerdo con la Tasa Enviar atributo de red. El segundo se sincronizará las animaciones entre todos los clientes (que solo necesita ajustar el animador del objeto). Ahora, si se intenta jugar el juego, el movimiento debe ser sincronizado correctamente.

            Por último, lo que vamos a hacer que los jugadores a no chocan entre sí. Podemos hacer eso mediante el establecimiento de una capa a la prefabricada jugador y cambiar la configuración física para desactivar las colisiones entre objetos de esta capa. Puede crear una nueva capa haciendo clic en Añadir capa en el inspector de objetos. Puede editar la configuración física haciendo clic en Editar -> Ajustes del proyecto -.> Configuración 2D física


            Con esto hemos terminado de hacer frente a los problemas de movimiento del jugador. Ahora vamos a sincronizar la creación de otros objetos, tales como bombas y explosiones.


            Sincronización bombas

            Lo primero que tenemos que hacer con el fin de crear bombas y explosiones es la adición de los componentes NetworkIdentity y NetworkTransform a sus casas prefabricadas, como lo hicimos con el jugador. Sin embargo, después se crean los objetos, que no se mueven por la pantalla. Por lo tanto, podemos establecer la red Enviar Tasa de ambos a 0, con el fin de reducir el tráfico de la red.


            Ahora, tenemos que cambiar los guiones BombDropping y BombExplosion a trabajar en un escenario multijugador.

            Empecemos por el script BombDropping. Queremos clientes para lanzar bombas sólo de sus propios palyers, por lo que vamos a comprobar de nuevo si es el jugador local antes de lanzar la bomba.

            Además, aquí vamos a hacer uso de un nuevo concepto multijugador Unidad, denominado Comando. Un Comando de la Unidad es un método que siempre se ejecuta en el servidor. Si se llama desde un cliente, el cliente enviará un mensaje al servidor pidiéndole que ejecute el método. Con el fin de convertir a un método en un comando que hay que añadir una etiqueta [Comando] antes del método, y el nombre del método debe comenzar con Cmd.

            La última cosa que necesitamos cambiar aquí, está generando la bomba en todos los clientes después de que instanciamos. Podemos hacer que el uso del método NetworkServer.Spawn. Este método recibe como parámetro un objeto y crea una copia de este objeto en todos los clientes. Tenga en cuenta que este método sólo puede ser llamado desde el servidor (que está bien porque estamos llamando dentro de un comando). Sin embargo, todavía tenemos que comprobar si el NetworkServer está activo antes de hacerlo. Por último, el guión BombDropping debe ser similar a continuación.
            BombDropping clase pública: NetworkBehaviour {[SerializeField] privada GameObject bombPrefab; // actualización se llama una vez por cuadro de actualización de vacío () {if (this.isLocalPlayer && Input.GetKeyDown ( «espacio»)) {CmdDropBomb (); }} [Comando] vacío CmdDropBomb () {if (NetworkServer.active) {GameObject bomba = Instantiate (bombPrefab, this.gameObject.transform.position, Quaternion.identity) como GameObject; NetworkServer.Spawn (bomba); }}} 1234567891011121314151617181920publicclassBombDropping: NetworkBehaviour {[SerializeField] privateGameObject bombPrefab; // actualización se llama una vez por framevoidUpdate () {if (this.isLocalPlayer && Input.GetKeyDown ( «espacio»)) {CmdDropBomb ();}} [Comando] voidCmdDropBomb ( ) {if (NetworkServer.active) {GameObject bomba = Instantiate (bombPrefab, this.gameObject.transform.position, Quaternion.identity) asGameObject; NetworkServer.Spawn (bomba);}}}

            Ahora, vamos a actualizar el guión BombExplosion . Aquí, las únicas cosas que tenemos que cambiar es recurriendo a los métodos en los comandos y la propagación de la creación y destrucción de objetos. Así que, a su vez los métodos de explotar y CreateExplosions en comandos (añadiendo la etiqueta [Comando] y cambiando sus nombres). Después de una instancia de cada objeto explosión tenemos que llamar al método NetworkServer.Spawn, como lo hicimos con las bombas. Además, cuando la destrucción de bloques (cuando una explosión golpea un bloque), tenemos que llamar al método NetworkServer.Destroy, con el fin de propagar la destrucción de objetos entre todos los clientes.
            BombExplosion clase pública: NetworkBehaviour {[SerializeField] privada BoxCollider2D collider2D; [SerializeField] privada GameObject explosionPrefab; [SerializeField] int explosionRange privado; [SerializeField] explosionDuration flotador privado; void OnTriggerExit2D (Collider2D otra) {this.collider2D.isTrigger = false; } [Comando] pública CmdExplode void () {if (NetworkServer.active) {GameObject explosión = Instantiate (explosionPrefab, this.gameObject.transform.position, Quaternion.identity) como GameObject; NetworkServer.Spawn (explosión); Destruye (explosión, this.explosionDuration); CmdCreateExplosions (Vector2.left); CmdCreateExplosions (Vector2.right); CmdCreateExplosions (Vector2.up); CmdCreateExplosions (Vector2.down); NetworkServer.Destroy (this.gameObject); }} [Comando] CmdCreateExplosions private void (dirección Vector2) {ContactFilter2D contactFilter = new ContactFilter2D (); Vector2 explosionDimensions = explosionPrefab.GetComponent () .bounds.size; Vector2 explosionPosition = (Vector2) this.gameObject.transform.position + (explosionDimensions.x * dirección); para (explosionIndex = 1 int; explosionIndex () bounds.size;. Vector2 explosionPosition = (Vector2) this.gameObject.transform.position + (explosionDimensions.x * dirección); para (intexplosionIndex = 1; explosionIndex Finalmente, ya que volvió el método de explotar en un comando, es necesario actualizar el guión ExplosionDamage en consecuencia.
            ExplosionDamage clase pública: MonoBehaviour {void OnTriggerEnter2D (Collider2D colisionador) {if (collider.tag == «carácter») {collider.gameObject.GetComponent () .LoseLife (); } Else if (collider.tag == «bomba») {collider.gameObject.GetComponent () .CmdExplode (); }}} 12345678910publicclassExplosionDamage:. MonoBehaviour {voidOnTriggerEnter2D (Collider2D colisionador) {if (collider.tag == «carácter») {collider.gameObject.GetComponent () LoseLife ();} elseif (collider.tag == «Bomba «) {collider.gameObject.GetComponent () CmdExplode ();.}}}

            la última cosa que necesitamos hacer es fijar la bomba y las casas prefabricadas de explosión como Spawnable casas prefabricadas en el NetworkManager. Podemos hacer eso mediante su inclusión en la lista Spawnable Prefabs del componente.


            A estas alturas, se puede tratar de jugar el juego y la creación de bombas. Las bombas deben estar sincronizados entre todos los clientes, así como sus explosiones.


            Control de la vida reproductor

            Hasta ahora, la vida de ambos jugadores ya se incrementan en ambos clientes. Queremos que cada cliente para mostrar sólo sus vidas. Podemos hacer que cambiando el guión PlayerLife de la siguiente manera. Tenemos que añadir una cláusula if en el principio del método de inicio para comprobar si este es el jugador local.

            Desde la Lista lifeImages es local para cada cliente, necesitamos el método LoseLife para ejecutar sólo para los jugadores locales. Además, cuando el número de vidas llegar a 0, no vamos a mostrar un juego sobre la pantalla más, simplemente vamos a reaparecer el jugador a su posición inicial. El método de reaparición también reconstruirá la Lista lifeImages. Tenga en cuenta que, con el fin de reaparecer el jugador, que necesitamos para salvar a su posición inicial y el número inicial de vidas en el método de inicio.
            PlayerLife clase pública: NetworkBehaviour {[SerializeField] int numberOfLives privadas = 3; [SerializeField] flotador invulnerabilityDuration privado = 2; private bool isInvulnerable = false; [SerializeField] privada GameObject playerLifeImage; Lista privada lifeImages; gameOverPanel GameObject privado; initialPosition Vector2 privado; initialNumberOfLives int privadas; vacío Inicio () {if (this.isLocalPlayer) {this.initialPosition = this.transform.position; this.initialNumberOfLives = this.numberOfLives; this.gameOverPanel = GameObject.Find ( «GameOverPanel»); this.gameOverPanel.SetActive (false); GameObject playerLivesGrid = GameObject.Find ( «PlayerLivesGrid»); this.lifeImages = new List (); for (int lifeIndex = 0; lifeIndex (); for (int lifeIndex = 0; lifeIndex lifeImages; privateGameObject gameOverPanel; privateVector2 initialPosition; privateintinitialNumberOfLives; voidStart () {if ( this.isLocalPlayer) {this.initialPosition = this.transform.position; this.initialNumberOfLives = this.numberOfLives; this.gameOverPanel = GameObject.Find ( «GameOverPanel»); this.gameOverPanel.SetActive (false); GameObject playerLivesGrid = GameObject. Encuentra ( «PlayerLivesGrid»); this.lifeImages = newList (); for (intlifeIndex = 0; lifeIndex (); para (intlifeIndex = 0; lifeIndex Si intenta reproducir ahora, cada cliente debe mostrar sólo el número de la vida de su jugador local. Como un desafío, puede intentar mostrar un mensaje con el jugador ganador cuando un jugador muere.


            Creación de partidos

            Hasta ahora estamos utilizando el Gestor de Red de HUD para protagonizar el anfitrión y el partido. Lo que vamos a hacer ahora es la eliminación de este HUD y la creación de nuestros propios botones para crear y unirse a los partidos.

            En primer lugar, eliminar el componente NetworkManagerHUD del NetworkManager. Además, quitar el StartGameText, ya que vamos a reemplazarlo por los botones.

            Ahora, crear un nuevo botón. (UI -> Botón) llamada CreateMatchButton como hijo de los TitleCanvas


            Ahora, vamos a crear un nuevo script llamado MultiplayerMatch y agregarlo al objeto de NetworkManager. Este script se utiliza para crear y unirse a partidos, lo que vamos a hacer ahora.


            En primer lugar, vamos a crear los métodos para crear un partido. El guión MultiplayerMatch tendrá como atributo del NetworkManager, con el fin de acceder a su método. Luego, en el inicio vamos a llamar al método StartMatchMaker del NetworkManager. Este método permitirá a los métodos Match Maker, que se utiliza para crear y unirse a los partidos.

            A continuación, vamos a añadir un método CreateMatch que será llamado por el CreateMatchButton cuando se hace clic. Este método se llama al método CreateMatch del fabricante de partido. Los parámetros son: el nombre de partido, el número máximo de jugadores por partido, un valor lógico que hace que el partido en la lista, y otros parámetros como la contraseña de un elo mínimo, que no vamos a utilizar. El último parámetro es la devolución de llamada, que se llamará una vez que se ha creado el partido. En nuestro caso vamos a llamar a un método OnCreateMatch.

            El método OnCreateMatch simplemente fijará el cliente como el host y cargar la escena de batalla. Todavía tenemos que iniciar el juego como un anfitrión, pero vamos a hacer eso después de crear el botón de unirse a partidos.
            public class MultiplayerMatch: MonoBehaviour {[SerializeField] privada NetworkManager NetworkManager; public bool isHost = false; // Usar esto para la inicialización de inicio void () {networkManager.StartMatchMaker (); } Public void CreateMatch () {networkManager.matchMaker.CreateMatch ( «igualar», 2, verdadera, String.Empty, String.Empty, String.Empty, 0, 0, OnMatchCreate); } Void OnMatchCreate (éxito bool, string extendedInfo, Matchinfo MatchInfo) {this.isHost = true; SceneManager.LoadScene ( «Batalla»); }} 12345678910111213141516171819202122publicclassMultiplayerMatch: MonoBehaviour {[SerializeField] privateNetworkManager networkmanager; publicboolisHost = false; // Usar esto para initializationvoidStart () {networkManager.StartMatchMaker ();} publicvoidCreateMatch () {networkManager.matchMaker.CreateMatch ( «partido», 2, es cierto, String.Empty, String.Empty, String.Empty, 0,0, OnMatchCreate);} voidOnMatchCreate (boolsuccess, stringextendedInfo, MatchInfo MatchInfo) {this.isHost = true; SceneManager.LoadScene ( «Battle»);}}

            Por último, establecer el método de CreateMatch como la devolución de llamada de la CreateMatchButton.


            partidos Unir

            Lo primero que tenemos que hacer para que los jugadores se unan a partidos es la creación de un botón para eso. Por lo tanto, de manera similar a lo que hicimos para la creación de partidos, crear un botón llamado JoinMatchButton.


            Ahora, vamos a crear los métodos necesarios en el guión MultiplayerMatch. En primer lugar, crear una función JoinMatch, que será llamado por el JoinMatchButton. Este método se llama al método ListMatches del fabricante de partido. Los parámetros de este método son: la página partidos (en nuestro caso se trata de la primera página), el número de partidos (sólo necesitamos un partido), algunos filtros y el último parámetro es la devolución de llamada (similar al método CreateMatch).

            Ahora la devolución de llamada será el método OnMatchList. Este método en realidad va a llamar a otro método en el Match Maker: JoinMatch. Los parámetros sólo importantes aquí son la primera y la última. El primero de ellos es el id partido, que podemos obtener a partir de los resultados mencionados. El último parámetro es la devolución de llamada de nuevo.

            Finalmente, el último de devolución de llamada (OnMatchJoined) simplemente cargar la escena de batalla. Ahora, para iniciar el anfitrión y el cliente cuando se inicia la escena de batalla, necesitamos dos cosas:


            1. Hacer el NetworkManager persistente, lo que significa que no será destruido cuando se carga una nueva escena.
            2. Adición de una devolución de llamada cuando se carga una nueva escena, de modo que podamos iniciar el servidor y el cliente cuando esto sucede.

              Lo primero que se hace ya por la secuencia de comandos de NetworkManager, por lo que no hay que preocuparse por eso. La segunda cosa que se va a hacer en el método Start. Esto se hace mediante la adición de una devolución de llamada al evento sceneLoaded. La devolución de llamada (OnSceneLoaded) sólo se va a hacer algo cuando se carga la escena de batalla. En este caso, se elimina la devolución de llamada y comprueba si este es el anfitrión. Si es así, se inicia un nuevo juego como el anfitrión. De lo contrario, se inicia un nuevo juego que el cliente.
              vacío Inicio () {SceneManager.sceneLoaded + = OnSceneLoaded; networkManager.StartMatchMaker (); } Private void OnSceneLoaded (escena de la escena, el modo LoadSceneMode) {if (scene.name == «Batalla») {SceneManager.sceneLoaded – = OnSceneLoaded; si (this.isHost) {networkManager.StartHost (); } Else {networkManager.StartClient (); }}} Public void JoinMatch () {networkManager.matchMaker.ListMatches (0, 1, String.Empty, es cierto, 0, 0, OnMatchList); } OnMatchList vacío (éxito bool, string extendedInfo, List partidos) {networkManager.matchMaker.JoinMatch (coincidencias [0] .networkId, String.Empty, String.Empty, String.Empty, 0, 0, OnMatchJoined); } Void OnMatchJoined (éxito bool, string extendedInfo, Matchinfo MatchInfo) {SceneManager.LoadScene ( «Batalla»); } 12345678910111213141516171819202122232425262728voidStart () {SceneManager.sceneLoaded + = OnSceneLoaded; networkManager.StartMatchMaker ();} privatevoidOnSceneLoaded (escena de la escena, el modo LoadSceneMode) {if (scene.name == «Batalla») {SceneManager.sceneLoaded- = OnSceneLoaded; si (esto. isHost) {networkManager.StartHost ();} else {networkManager.StartClient ();}}} publicvoidJoinMatch () {networkManager.matchMaker.ListMatches (0,1, String.Empty, es cierto, 0,0, OnMatchList);} voidOnMatchList (boolsuccess, stringextendedInfo, List partidos) {networkManager.matchMaker.JoinMatch (coincidencias [0] .networkId, String.Empty, String.Empty, String.Empty, 0,0, OnMatchJoined);} voidOnMatchJoined (boolsuccess, stringextendedInfo , MatchInfo MatchInfo) {SceneManager.LoadScene ( «Battle»);}.

              Finalmente, establecer el método de JoinMatch como la devolución de llamada de la JoinMatchButton


              A estas alturas, se puede tratar de jugar el juego con los botones de título de la pantalla, y que todavía debe trabajar como con el Gestor de Red de HUD. También puede tratar de usar los otros parámetros de la máquina de juego, tales como la creación de partidos con contraseña, utilizando un sistema de elo o lista más partidos por lo que el jugador puede elegir uno.


              Y esto concluye esta multijugador Bomberman tutorial. Por favor, dígame su opinión y preguntas en la sección de comentarios.

              Mensajes relacionados
               unidad escena del juego de multijugador espacio de juego de disparos

Deja una respuesta

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