descarga Project se encuentra aquí.

Esta semana, vamos a hablar de nuevo con algoritmos Unity3D. El objetivo principal será llevar una idea principal y construirlo. Comenzaremos con romper el concepto hacia abajo en secciones más pequeñas y manejables y se acumulan a la idea principal. Por lo tanto, la idea que queremos tener al final es un cubo que tiene los colores al azar que podemos guardar y cargar. También queremos generar dinámicamente estos desde un sencillo a múltiples prefabricadas cubo. Espero que ustedes están preparados, porque esto va a ser un tutorial muy emocionante.
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
    Sección 1: Aumento de la interfaz de usuario

    En esta sección, vamos a utilizar el editor de la Unidad para crear el prefabricada básica que tiene nuestro cubo y materiales. Por lo tanto, vamos a empezar por la creación de un nuevo proyecto que se establece para estar en modo 3D y calificó de “Cubos Galore”.

    Sección 1 SCN 1

    El siguiente, necesitamos un par de carpetas. Casas prefabricadas, guiones y materiales son los nombres de las carpetas.

    Sección 1 SCN 2

    Vamos a hacer unos 5 materiales diferentes colores. Puede seguir junto con los colores que he utilizado, o crear su propia cuenta.

    Sección 1 SCN 3

    Ahora que hemos creado nuestros materiales, vamos a añadir un cubo a la escena.

    Sección 1 SCN 4

    Duplicar el cubo 4 veces y aplicar un material a cada uno.

    Sección 1 SCN 5

    Ahora, arrastrar los 5 cubos en las casas prefabricadas carpeta y eliminarlas del panel de jerarquías.

    Sección 1 SCN 6

    Crear un objeto de juego vacío y llamarlo controlador.

    Sección 1 SCN 7

    Ahora, tenemos que hacer un script en la carpeta scripts y lo llaman “CubeController”.



    La última cosa que hacer para esta sección es seguir adelante y añadir el guión CubeController sobre el objeto controlador.

    Sección 1 SCN 9

    Sección 1 se ha completado; no parece mucho, pero esto es con toda seguridad los conceptos básicos de lo que esperamos accomplish.Section 2: El primer algoritmo

    En esta sección, vamos a tener un solo cubo prefabricada y tienen que duplicarse a sí mismo varias veces para formar un cuadrado. Para ello, necesitamos un poco de información. Esa información sería en términos de posiciones. ¿Cuál es el vector de posición 3 de los lados izquierdo y derecho de la plaza, así como el avance y retroceso posición más? Para responder a esto, necesitamos un poco de geometría para responder a la pregunta. Un cuadrado, por definición, tiene 4 lados iguales.

    Sección 2 SCN 1

    Ahora, queremos y la posición de nuestra plaza para estar en 0. La razón de esto es porque no queremos ninguna diferencia de altura de esta primera plaza.

    La posición x comenzará a -3 y traslado a 2. Así, esto hará que el cuadrado básico sea 5 de largo. Por lo tanto, tenemos que hacer lo mismo con la profundidad. Lo que nos lleva a la posición Z. La posición z será de 0 a 5. Ahora que tenemos la idea básica de lo que necesitamos, vamos a escribir el algoritmo.
    utilizando UnityEngine; utilizando System.Collections; CubeController clase pública: {MonoBehaviour pública GameObject CubePrefab; generateCubeSquare public void () {for (float x = -3; x <2; x ++) {for (float z = 0; z <5; z ++) {Instantiate (CubePrefab, nuevo Vector3 (x, 0, z), Quaternion.identity); }}} Public void start () {generateCubeSquare (); }} 1234567891011121314151617181920212223usingUnityEngine; usingSystem.Collections; publicclassCubeController: MonoBehaviour {publicGameObject CubePrefab; publicvoidgenerateCubeSquare () {for (floatx = -3; x <2; x ++) {for (floatz = 0; z <5; z ++) {Instantiate (CubePrefab, newVector3 (x, 0, z), Quaternion.identity);}}} publicvoidStart () {generateCubeSquare ();}}

    con el algoritmo, que escribió el algoritmo para coincidir con los valores de X y Z para que sea más fácil leer. Ahora, tenemos que añadir una casa prefabricada cubo para el controlador.

    Sección 2 SCN 2

    Vamos a echar un vistazo a los resultados.

    Sección 2 SCN 3

    Hmm, vamos a cambiar el ángulo de visión de la cámara para que podamos ver los resultados completos. Vamos a cambiar la posición Y de la cámara para ser 6. Ahora, vamos a cambiar la rotación X a ser 30.

    Sección 2 SCN 4

    Vamos a hacer una pequeña modificación para añadir una ligera modificación a esto, la modificación consiste en añadir un pequeño espacio entre cada cube.using UnityEngine; usando System.Collections; CubeController clase pública: {MonoBehaviour pública GameObject CubePrefab; generateCubeSquare public void () {for (float x = -3; x <2; x + = 1.08f) {for (float z = 0; z <5; z + = 1.08f) {Instantiate (CubePrefab, nuevo Vector3 ( x, 0, z), Quaternion.identity); }}} Public void start () {generateCubeSquare (); }} 1234567891011121314151617181920212223usingUnityEngine; usingSystem.Collections; publicclassCubeController: MonoBehaviour {publicGameObject CubePrefab; publicvoidgenerateCubeSquare () {for (floatx = -3; x <2; x + = 1.08f) {for (floatz = 0; z <5; z + = 1.08f ) {Instantiate (CubePrefab, newVector3 (x, 0, z), Quaternion.identity);}}} publicvoidStart () {generateCubeSquare ();}}

    lo que hicimos fue cambiado la parte de incremento del bucle. En lugar de añadir 1 con cada bucle, añadimos 1,08 al número z actual.

    Sección 2 SCN 5

    Como se puede ver, se ve un poco más como una rejilla cuadrada; Que a su vez se ve un poco más uniforme y limpio.

    Sección 3: Algoritmo con una lista de casas prefabricadas

    En esta sección, vamos a cambiar aleatoriamente los colores de los cubos en la plaza. Esto es más seguro que va a causar algunas frustraciones para el desarrollador principio. Por lo tanto, el camino he de hacer esto es mostrar la manera incorrecta de hacerlo primero y explicar por qué no funciona como se pretende y luego mostrar la forma correcta de hacerlo con una explicación.
    El camino equivocado: el uso de UnityEngine; usando System.Collections; usando System.Collections.Generic; CubeController clase pública: MonoBehaviour {public List CubePrefabList; generateColoredCubeSquare public void () {var index = CubePrefabList.Count; para (float x = -3; x <2; x + = 1.08f) {for (float z = 0; z <5; z + = 1.08f) {foreach (artículo var en CubePrefabList) {Instantiate (tema, nuevo Vector3 (x, 0, z), Quaternion.identity); }}}} Public void start () {generateColoredCubeSquare (); }}} 12345678910111213141516171819202122232425262728293031usingUnityEngine; usingSystem.Collections; usingSystem.Collections.Generic; publicclassCubeController: MonoBehaviour {publicList CubePrefabList; publicvoidgenerateColoredCubeSquare () {varindex = CubePrefabList.Count; for (floatx = -3; x <2; x + = 1.08f ) {for (floatz = 0; z <5; z + = 1.08f) {foreach (varItem inCubePrefabList) {Instantiate (artículo, newVector3 (x, 0, z), Quaternion.identity);}}}} publicvoidStart () { generateColoredCubeSquare ();}}}

    Vamos a echar un vistazo a los resultados


    La razón por la que esto no funciona según lo previsto se debe a la forma en que el código está escrito, se le indica al compilador para poner un cubo en el mismo lugar que los que ya están colocados. Hay bastantes maneras de hacer este error, así como para rectificar el problema.
    La forma correcta: el uso de UnityEngine; usando System.Collections; usando System.Collections.Generic; CubeController clase pública: MonoBehaviour {public List CubePrefabList; generateColoredCubeSquare public void () {for (float x = -3; x <2; x + = 1.08f) {for (float z = 0; z <5; z + = 1.08f) {Instantiate (CubePrefabList [Random.Range (0, CubePrefabList.Count)], nuevo Vector3 (x, 0, z), Quaternion.identity); }}} Public void start () {generateColoredCubeSquare (); } 123456789101112131415161718192021222324usingUnityEngine; usingSystem.Collections; usingSystem.Collections.Generic; publicclassCubeController: MonoBehaviour {publicList CubePrefabList; publicvoidgenerateColoredCubeSquare () {for (floatx = -3; x <2; x + = 1.08f) {for (floatz = 0; z <5; z + = 1.08f) {Instantiate (CubePrefabList [Random.Range (0, CubePrefabList.Count)], newVector3 (x, 0, z), Quaternion.identity);}}} publicvoidStart () {generateColoredCubeSquare () ;}

    Vamos a echar un vistazo a los resultados

    02.08.2016 (1)

    Como dije en la forma en la subsección mal, hay muchas formas de escribir esto correctamente. Elegí una manera que es fácil de usar y fácil de leer. Con este método, le decimos al compilador para poner un cubo en cada posición abierta y randomize la que el cubo está en cada posición.

    Sección 4: Realización de un cubo 3D

    En esta sección vamos a tomar el código existente y modificarlo un poco con el fin de crear un cubo. Para ello, todo lo que tenemos que hacer es aplicar un poco más de la geometría a la geometría existente que ya hemos creado. Tenemos nuestras x y z valores ya hecho, ahora tenemos que hacer los valores de Y. Ya que sabemos que queremos empezar a 0, lo que significa que necesitamos tener que termina en 5. Esto debería permitir que tengamos un 5 x 5 x 5 cubo, en otras palabras, una longitud de 5, una anchura de 5, y una profundidad de 5.
    utilizando UnityEngine; usando System.Collections; usando System.Collections.Generic; CubeController clase pública: MonoBehaviour {public List CubePrefabList; generateColoredCubeSquare public void () {for (float x = -3; x <2; x + = 1.08f) {for (float z = 0; z <5; z + = 1.08f) {for (float y = 0; y <5; y + = 1.08f) {Instantiate (CubePrefabList [Random.Range (0, CubePrefabList.Count)], nuevo Vector3 (x, y, z), Quaternion.identity); }}}} Public void start () {generateColoredCubeSquare (); }} 12345678910111213141516171819202122232425262728usingUnityEngine; usingSystem.Collections; usingSystem.Collections.Generic; publicclassCubeController: MonoBehaviour {publicList CubePrefabList; publicvoidgenerateColoredCubeSquare () {for (floatx = -3; x <2; x + = 1.08f) {for (floatz = 0 ; z <5; z + = 1.08f) {for (floaty = 0; y <5; y + = 1.08f) {Instantiate (CubePrefabList [Random.Range (0, CubePrefabList.Count)], newVector3 (x, y, z ), Quaternion.identity);}}}} publicvoidStart () {generateColoredCubeSquare ();}}

    Estos son los resultados

    Sección 4 SCN 1

    Lo que hicimos para lograr esto era que anidado un bucle 3 veces para manejar cada valor que queríamos para manipular. X, Y, Z y los valores para ser exactos, y el código en sí no ha cambiado mucho a todos. Lo que hay que recordar siempre es que sea tan simple como sea posible cuando se desea añadir un nuevo código de característica o cambio existente. Y siempre se debe tratar de tener el código para ser lo más legible posible.

    Sección 5: La aleatorización de los cubos variante

    En esta sección, será la reconstrucción de la clase del controlador de hacer varias cosas diferentes que la anterior. En lugar de difícil codificación de la posición x, y, y z del vector de 3, lo haremos así que podemos cambiar en el editor. La razón de esto es para permitir más estrechamente controlada pruebas, así como ser capaz de ver los resultados en tiempo de ejecución sin necesidad de modificar nuestro código. El siguiente cambio será la creación de los valores RGB y aleatorizar los prefabricadas en lugar de utilizar materiales. Por lo tanto, vamos a ver el código todo el camino hasta el método de inicio.
    utilizando UnityEngine; usando System.Collections; usando System.Collections.Generic; using System.IO; public class controlador: {MonoBehaviour pública GameObject CubePrefab; Vector3 gridSize pública; 123456789usingUnityEngine; usingSystem.Collections; usingSystem.Collections.Generic; usingSystem.IO; publicclassController: MonoBehaviour {publicGameObject CubePrefab; publicVector3 gridSize;

    Tenemos nuestra prefabricada cubo de público que hemos traído de vuelta de nuestro primer algoritmo y tenemos un público Vector 3 llamado gridSize. El CubePrefab fue devuelto porque no queremos usar una lista de casas prefabricadas ya que podemos utilizar una sola y modificar los colores de que uno. El gridSize Vector 3 está aquí porque queremos ser capaces de modificar la x y y z valores en el editor.
    Inicio public void () {CreateCubeGrid (); } 1234publicvoidStart () {CreateCubeGrid ();}

    El método de arranque tiene 1 item dentro de ella. Estamos llamando a un método llamado CreateCubeGrid. En este punto, hay que ver el compilador quejarse porque no tenemos un método para CreateCubeGrid todavía.
    ///

    Crea una nueva rejilla cubo si uno no existe pública CreateCubeGrid void () {for (var a = 0; a (); var rojo = Random.Range (0F, 1f); var verde = Random.Range (0F, 1f); azul var = Random.Range (0F, 1f); var color = nuevo color (rojo, verde, azul); renderer.material.color = color; }}}}} 123456789101112131415161718192021 ///

    Crea una nueva rejilla cubo si no existe uno publicvoidCreateCubeGrid () {for (vara = 0; a (); varred = Random.Range (0F, 1f); vargreen = Random.Range (0F, 1f); varblue = Random.Range (0F, 1f); varcolor = Newcolor (rojo, verde , azul); renderer.material.color = color;.}}}}}

    Ahora tenemos el método CreateCubeGrid y es bastante largo, así que vamos a ir sobre ella en pequeñas secciones
    ///

    Crea una nueva rejilla cubo si uno no existe pública CreateCubeGrid void () {for (var a = 0; a Crea una nueva rejilla cubo si no existe uno publicvoidCreateCubeGrid () {for (vara = 0; a El bucles de aquí debería ser bastante sencillo. Var a, b, y c son marcadores de posición para x de la gridSize, y, y las variables z y que incrementan en 1 con cada bucle.
    cubo var = (GameObject) Instantiate (CubePrefab, nuevo Vector3 (a, b, c), Quaternion.identity); var renderer = cube.GetComponent (); var rojo = Random.Range (0F, 1f); var verde = Random.Range (0F, 1f); azul var = Random.Range (0F, 1f); var color = nuevo color (rojo, verde, azul); renderer.material.color = color; 1234567varcube = (GameObject) Instantiate (CubePrefab, newVector3 (a, b, c), Quaternion.identity); varrenderer = cube.GetComponent (); varred = Random.Range (0F, 1f); vargreen = Random.Range (0f, 1f); varblue = Random.Range (0f, 1f); varcolor = Newcolor (rojo, verde, azul); renderer.material.color = color;

    creamos una variable llamada cubo para instanciar el cubePrefab con el vector de 3 posiciones de a, b, y c. Hemos establecido el Quaterion a la identidad, porque no queremos que cualquier rotación en los cubos. Con el fin de manipular los colores del cubo, necesitamos una referencia a la MeshRender que es lo que hace que nuestra variable de render. Rojo, verde y azul tienen un rango aleatorio de 0 a 1, esto nos permite especificar qué color queremos recoger. Por último, tenemos una variable color que crea la instancia de la clase de color, que se especifica como el rojo, verde y azul.

    02/06/2016

    Sección 7: Al girar el cubo en un pasillo y escaleras

    En esta sección, vamos a ir sobre tomar todo lo que hemos aprendido de las otras secciones y crear un poco de pasarela y una escalera que conduce hacia arriba a otra pasarela. Siguiendo con el motivo, todavía estaremos usando un cubo para esto.

    Las otras secciones eran realmente bueno para un comienzo básico, pero realmente no se podía utilizar para demasiado más allá de una idea para un juego de puzzle. Por lo tanto, creo que es hora de tomar lo que hemos aprendido y aplicarlo a crear algo más útil para el desarrollo del juego. Hagamos una amplia 1, 5 por largo pasillo que conduce a las escaleras que son los 5 niveles de altura.

    theidea

    El uso de mis habilidades de súper arte increíble para dibujar lo que tipo de ¿Quieres ser el resultado final, podemos ver exactamente lo que tenemos que hacer. Pero ¿cómo debemos ir sobre esto? ¿Hay que poner todo en un solo método o tener 3 métodos separados? Si seguimos el método de KISS (Keep It Estúpidamente simple), deberíamos tener 3 métodos que se ocupan de una sola tarea. Echemos un vistazo a los resultados finales de los algoritmos.
    utilizando UnityEngine; utilizando System.Collections; StairWayToWalkWay clase pública: {MonoBehaviour pública GameObject CubePrefab; Inicio public void () {CreateStairs (); CreateWalkWay (); CreateUppderWalkWay (); CreateStairs} public void () {int y = 0; int z = 5; for (int x = 5; x> 0; x–) {if (x == 5) {y = 0; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 4) {y = 1; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 3) {y = 2; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 2) {y = 3; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 1) {y = 4; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 0) {y = 5; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); }}} Public CreateWalkWay void () {for (int x = 5; x <10; x ++) {GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, 0, 5), Quaternion.identity); }} CreateUppderWalkWay public void () {for (int x = -5; x <1; x ++) {GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, 5, 5), Quaternion.identity); }}} 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374usingUnityEngine; usingSystem.Collections; publicclassStairWayToWalkWay: MonoBehaviour {publicGameObject CubePrefab; publicvoidStart () {CreateStairs (); CreateWalkWay (); CreateUppderWalkWay ();} publicvoidCreateStairs () {inty = 0; intz = 5; para (inTX = 5 ; x> 0; x -) {if (x == 5) {y = 0; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 4) {y = 1; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 3) {y = 2; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 2) {y = 3; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 1) { y = 4; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 0) {y = 5; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z ), Quaternion.identity);}}} publicvoidCreateWalkWay () {for (inTX = 5; x <10; x ++) {GameObject.Instantiate (CubePrefab, newVector 3 (x, 0,5), Quaternion.identity);}} publicvoidCreateUppderWalkWay () {for (inTX = -5; x <1; x ++) {GameObject.Instantiate (CubePrefab, newVector3 (x, 5,5), Quaternion .identity);}}}

    Ahora, debe ir en cada uno de los métodos a la vez. Para iniciar este lugar, tenemos nuestro método CreateWalkWay.
    público CreateWalkWay void () {for (int x = 5; x <10; x ++) {GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, 0, 5), Quaternion.identity); }} 1234567publicvoidCreateWalkWay () {for (inTX = 5; x <10; x ++) {GameObject.Instantiate (CubePrefab, newVector3 (x, 0,5), Quaternion.identity);}}

    Somos iterar sobre la x la variable a partir de x estar en 5 y terminando en 10. a continuación, crear un cubo en el vector de 3 posiciones de x (5 – 10)., y estando siempre a 0, y z estar siempre a 5. bastante sencillo y simple < br />
    Vamos a echar un vistazo más profundo a lo que está pasando con el método CreateStairs.
    CreateStairs public void () {int y = 0; int z = 5; for (int x = 5; x> 0; x–) {if (x == 5) {y = 0; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 4) {y = 1; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 3) {y = 2; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 2) {y = 3; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 1) {y = 4; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 0) {y = 5; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); }}} 12345678910111213141516171819202122232425262728293031323334353637383940414243publicvoidCreateStairs () {inty = 0; intz = 5; para (inTX = 5; x> 0; x -) {if (x == 5) {y = 0; GameObject.Instantiate (CubePrefab, newVector3 ( x, y, z), Quaternion.identity);} if (x == 4) {y = 1; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x = = 3) {y = 2; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 2) {y = 3; GameObject.Instantiate (CubePrefab, newVector3 (x , y, z), Quaternion.identity);} if (x == 1) {y = 4; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 0) {y = 5; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);}}}

    Este método es muy diferente de la forma en que manejamos cosas antes. Por lo tanto, vamos a descomponerlo en trozos más pequeños y más manejables.
    int y = 0; int z = 5; for (int x = 5; x> 0; x–) {} 12345inty = 0; intz = 5; para (inTX = 5; x> 0; x -) {}

    Nos empezó a nuestra inicializando y y las variables z en 0 y 5 respectivamente. Y estamos bucle con un bucle que comienza en 5 y termina en 0. En lugar de la subasta por 1, que disminuye en 1 (palabras de lujo para contar hacia arriba y abajo respectivamente).
    si (x == 5) {y = 0; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 4) {y = 1; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 3) {y = 2; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 2) {y = 3; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 1) {y = 4; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } If (x == 0) {y = 5; GameObject.Instantiate (CubePrefab, nuevo Vector3 (x, y, z), Quaternion.identity); } 1234567891011121314151617181920212223242526272829303132333435if (x == 5) {y = 0; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 4) {y = 1; GameObject.Instantiate ( CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 3) {y = 2; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} si (x == 2) {y = 3; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} if (x == 1) {y = 4; GameObject.Instantiate (CubePrefab , newVector3 (x, y, z), Quaternion.identity);} if (x == 0) {y = 5; GameObject.Instantiate (CubePrefab, newVector3 (x, y, z), Quaternion.identity);} < p> Tenemos una gran cantidad de declaraciones si es aquí, que simplemente está señalando a la ubicación de la variable x. Dentro de cada sentencia if estamos especificando la posición y. Por último, hemos creado esos lugares en la porción Vector 3 de la cláusula Instantiate.

    02.06.2016 (1)

    Como se puede ver, la conversión de los algoritmos de 2D a 3D es extremadamente simple y más divertido de hacer. Espero que hayan aprendido mucho de este tutorial,

    Mensajes relacionados

Deja una respuesta

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