Tabla de contenidos

Introducción

Si alguna vez has tenido un vistazo a los juegos móviles que actualmente están clasificados en la parte superior de la tienda de aplicaciones, es posible encontrar uno llamado Smash Hit. La idea básica del juego es que la cámara está en constante movimiento hacia adelante en el espacio 3D y es el trabajo del jugador romper estos paneles de vidrio que se encuentran en el camino de la cámara. El jugador hace esto por el desove bolas de acero en el lugar donde se tocan la pantalla. Cuando la bola de acero choca con el panel de vidrio, los añicos de vidrio. Este es un juego muy divertido, pero en vez de ir y descargarlo, vamos a crear nuestra propia versión (porque eso es lo que los verdaderos desarrolladores de juegos lo hacen).

Configuración del proyecto * supercrítico! *

Abre la unidad y haga clic en “crear”. El siguiente paso es muy importante, si no lo hace puede terminar a mitad de camino a través de este tutorial y descubrir que usted tiene que empezar de nuevo (como lo hice cuando fue la creación de este proyecto). El nombre de su proyecto y luego cambie la Plantilla para “RP Ligera”.


Esto significa que se pueden utilizar secuencias de comandos de la Unidad Render Pipeline para hacer shaders personalizados para los objetos (que va a hacer en este tutorial). Si usted nunca ha oído hablar de SRP (scripts Render Pipeline), usted puede sacar de este tutorial que entra en mucho más detalle. Ahora que ha realizado el paso muy importante, vamos a ir a la creación de la mecánica básica.

descargar el código fuente

Aquí está el enlace a los archivos de código fuente o los activos que van a ser utilizados. Usted puede hacer éstos a sí mismo en cualquier programa que eligió (he usado Blender por razones obvias).

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

    Crear el primer mecánico: Bola desove

    Antes de empezar a destruir cosas, hay que crear primero la cosa que se va a destruir la otra cosa. Si la frase no tiene sentido, he utilizado mis habilidades como artista gráfico para ilustrar lo que vamos a hacer:


    Lo que significa que, en esta sección, vamos a estar haciendo este tipo:


    get Vamos inició por primera explicación de lo que se ve en el panel del proyecto.


    Esto puede parecer desordenado pero necesitamos que sea aquí cuando empezamos añadiendo shaders y tal. Seguir adelante y crear una nueva carpeta llamada “casas prefabricadas”.


    En la carpeta de secuencias de comandos, cree un nuevo guión C # llamado “CameraCharacter”.


    Con el fin de evitar la creación de más secuencias de comandos que es necesario, vamos a crear un script para nuestra cámara (la cámara es donde estaremos de desove bolas de todos modos) ya partir de ese guión, que incorporará todas las cosas que queríamos (como bola desove, el movimiento hacia adelante continua, etc.). Ir a la carpeta de escenas y crear un nuevo escenario llamado “Escena1”.


    Arrastra el guión “CameraCharacter” en su cámara y vamos a empezar la codificación.


    El desove un balón en el lugar donde el jugador toca es probablemente la parte más difícil de este proyecto. Hay un poco de ajuste fino involucrados con el fin de conseguir que funcione a la perfección. La primera cosa que necesitamos es un objeto de juego para desovar y una variable de tipo float que determina la fuerza a la que se genera el objeto:
    CameraCharacter clase pública: MonoBehaviour {bola GameObject pública; ballForce flotación pública; vacío Inicio () {123456publicclassCameraCharacter: MonoBehaviour {bola publicGameObject; publicfloatballForce; voidStart () {

    A continuación, en la función de actualización, encontramos en primer lugar cuando se toca el ratón / pantalla (este juego va a trabajar en el móvil) y luego generar la pelota, como un objeto local de juego, en la posición de la cámara. Y por último, esta parte añade un poco de fuerza al cuerpo rígido unido a la pelota:
    si (Input.GetMouseButtonDown (0)) {GameObject ballRigid; ballRigid = Instantiate (balón, transform.position, transform.rotation) como GameObject; . BallRigid.GetComponent () AddForce (Vector3.forward * ballForce); } 123456if (Input.GetMouseButtonDown (0)) {GameObject ballRigid; ballRigid = Instantiate (balón, transform.position, transform.rotation) asGameObject; ballRigid.GetComponent () AddForce (Vector3.forward * ballForce);.} < p> conjunto de Let esto mediante la creación de una esfera con un cuerpo rígido. Escala esta esfera de manera que es la mitad de su tamaño original. Y a continuación, crear una casa prefabricada de este arrastrándolo a nuestra carpeta de casas prefabricadas.


    Asignar el prefabricada al nuevo campo “bola” en el guión CameraCharacter y la exitosa obra.


    Se dará cuenta de que puede hacer clic y generar una nueva pelota.


    El único problema es que no se puede generar en la posición del ratón. Para ello, se trata de (lo que pienso) es la parte sólo un poco confuso del guión. Creamos un nuevo Vector3 que utiliza un par de flotadores locales que registran la posición del ratón. A continuación, utilizamos un método en la clase de cámara que convierte las coordenadas de pantalla a coordenadas mundo. Y luego, finalmente, establecemos el valor del eje Z para que el método sea un atributo de la clase de cámara, llamado “nearClipPlane”, además de un valor flotante que desplazamientos hacia delante ligeramente. Esto es lo que se ve todo el código como:
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; CameraCharacter clase pública: MonoBehaviour {float pública spawnHelper = 4.5fy; pública GameObject pelota; flotador ballForce pública = 700; _cam cámara privada; // Usar esto para la inicialización de inicio void () {_cam = getComponent (); } // actualización se llama una vez por cuadro vacío Update () {// flotadores locales flotan mousePosx = Input.mousePosition.x; flotar mousePosy = Input.mousePosition.y; // Confusing parte 🙂 Vector3 BallInstantiatePoint = _cam.ScreenToWorldPoint (nuevo Vector3 (mousePosx, mousePosy, _cam.nearClipPlane + spawnHelper)); si (Input.GetMouseButtonDown (0)) {GameObject ballRigid; ballRigid = Instantiate (balón, BallInstantiatePoint, transform.rotation) como GameObject; . BallRigid.GetComponent () AddForce (Vector3.forward * ballForce); }}} 123456789101112131415161718192021222324252627282930313233343536373839usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; publicclassCameraCharacter: MonoBehaviour {publicfloatspawnHelper = 4.5fy; bola publicGameObject; publicfloatballForce = 700; _cam privateCamera; // Usar esto para initializationvoidStart () {_ leva = getComponent ( );} // actualización se llama una vez por framevoidUpdate () {// local floatsfloatmousePosx = Input.mousePosition.x; floatmousePosy = Input.mousePosition.y; // parte confusa 🙂 Vector3 BallInstantiatePoint = _cam.ScreenToWorldPoint (newVector3 (mousePosx , mousePosy, _cam.nearClipPlane + spawnHelper)); si (Input.GetMouseButtonDown (0)) {GameObject ballRigid; ballRigid = Instantiate (balón, BallInstantiatePoint, transform.rotation) asGameObject;. ballRigid.GetComponent () AddForce (Vector3 .forward * ballForce);}}}

    espero que algo de lo que está pasando tiene sentido. Si no es así, sólo pensar en ello, vas a entender, lo prometo.

    Dicho esto, sin embargo, ahora va a ver que va a generar una bola en la posición del ratón.


    Se pueden ajustar el “ballForce” y “spawnHelper” para ayudarle a entender lo que está pasando aquí.


    Crear el segundo mecánico: Breaking Glass

    Ahora es el momento para la parte divertida, DESTRUYENDO LA MATERIA !! En serio, usted no es un desarrollador de juegos reales hasta que tome un cierto placer en ver las cosas se rompen y se dispersan por todo el lugar. Dicho esto, hay un par de maneras en que puede ir sobre romper cosas: tomar un objeto de juego y tener un script crear fracturas, o crear las fracturas de sí mismo en un programa de terceros (es decir Blender ya que usted es un desarrollador independiente). Elegí la segunda y he hecho todo el trabajo duro para usted en esta parte. Si nos fijamos en el paquete de activos, se verá que hay tres cubos.


    Cada uno de estos cubos se ha fracturado y vuelto a unir para que se vea como un objeto completo, cuando en realidad se trata de un montón de pequeñas piezas. La forma en que esto se va a trabajar es que tan pronto como la pelota golpea un pedazo de vidrio, que desovan uno de estos. Bastante simple. Crear una nueva carpeta llamada “modelos” e importar el cristal fracturado.


    Si uno abierto de los objetos, se encuentra un cubo completo.


    Esto es importante porque este cubo tiene las dimensiones exactas del cristal fracturado. Arrastre el modelo en el proyecto y elimina todo excepto este cubo.



    Crea una casilla Colisionador, lo convierten en un disparador, y que sea una casa prefabricada llamado “cristal”.


    A continuación, vamos a crear un nuevo guión (en nuestras Scripts, por supuesto) llamado “GlassShatter” y asignarlo a la casa prefabricada de vidrio.


    Ahora tenemos que arrastrar en cada modelo de vidrio fracturado (esta parte es tedioso), elimine el cubo completo, asignar una malla Colisionador (si no tiene ya uno, y un cuerpo rígido a cada pieza de vidrio fracturado, y luego hacer una casa prefabricada con esta convención de etiquetado: “cristal1 (roto)”



    Ahora debería tener tres casas prefabricadas etiqueta “cristal1 (roto)”, “Glass2 (roto)”, etc.


    Con el editor de cosas fuera del camino (al menos la mayoría de ella), pasamos a Visual Studio para empezar a construir nuestro script. Abrir “GlassShatter” y crear una nueva matriz de juego de objetos llamado “shatteredObject”. A continuación, utilizamos OnTriggerEnter para determinar si es o no la pelota ha superpuesto, si es así, que una instancia de un objeto de juego de azar de la matriz “shatteredObject” y al mismo tiempo eliminar a nosotros mismos.
    public class GlassShatter: {MonoBehaviour pública GameObject [] shatteredObject; // Usar esto para la inicialización de inicio void () {} // actualización se llama una vez por cuadro de actualización de vacío () {} OnTriggerEnter private void (Colisionador de otra) {if (other.CompareTag ( «destructiva»)) {// recoge una GameObject al azar en la matriz int objectIndex = Random.RandomRange (0, shatteredObject.Length); Instantiate (shatteredObject [objectIndex], transform.position, shatteredObject [objectIndex] .transform.rotation); Destruye (GameObject); }}} 12345678910111213141516171819202122publicclassGlassShatter: MonoBehaviour {publicGameObject [] shatteredObject; // Usar esto para initializationvoidStart () {} // actualización se llama una vez por framevoidUpdate () {} privatevoidOnTriggerEnter (Colisionador de otra) {if (other.CompareTag ( «destructiva») ) {// escoge un GameObject aleatorio en el arrayintobjectIndex = Random.RandomRange (0, shatteredObject.Length); Instantiate (shatteredObject [objectIndex], transform.position, shatteredObject [objectIndex] .transform.rotation); Destruye (GameObject);} }}

    Este script requiere que la bola posee una etiqueta con la etiqueta “destructiva”. Vamos a seguir adelante y seleccionar nuestra pelota,


    crear una etiqueta llamada “destructiva” (asegúrese de que es exactamente la forma en que aparece en el guión),


    y después asignarlo a la pelota.


    También es necesario para rellenar la matriz “shatteredObject” en el editor. Ajuste el rango de 3 y arrastre en cada “Glass (roto)” prefabricada.


    Si usted no tiene ya uno, arrastre en la jerarquía de un “cristal” prefabricada y fuego una bola en ella.


    Si todo se hace correctamente, se debe romper en mil pedazos. ¡Felicidades! Ahora tome un momento y simplemente apreciar la destrucción que ha causado.

    Creación de la tercera mecánico: Movimiento de la cámara

    La tercera, y probablemente lo más sencillo, parte de este tutorial es la cámara en movimiento. La forma de hacer esto es mediante el uso de algo que se llama un carácter controlador. La razón es que podemos mover el objeto en el código (literalmente, sólo una línea) y tiene interacciones físicas. Así que ir a la cámara y crear un componente controlador de caracteres.


    A continuación, volver a su script CameraCharacter y vamos a hacer que esto se mueva!


    Yo sólo voy a darle el guión final (lo que significa que no tendremos que volver a ella en esta serie de tutoriales) para que podamos conseguir más allá del diseño y la codificación a.
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando UnityEngine.SceneManagement; usando UnityEngine.UI; CameraCharacter clase pública: {MonoBehaviour velocidad de flotación pública = 1; flotador incrementFactor pública = 0.02f; flotación pública spawnHelper = 4.5fy; pública GameObject pelota; flotador ballForce pública = 700; botón pública GameObject; // Utilizamos esto cuando ponemos en práctica interfaz de usuario bool camMoving public static = false; cameraChar CharacterController privado; // Un booleano cuyo valor será determinado por OnTriggerEnter colisión bool privado = false; _cam cámara privada; // Usar esto para la inicialización de inicio void () {cameraChar = gameObject.GetComponent (); _cam = getComponent (); } // actualización se llama una vez por cuadro de actualización de vacío () {debug.log ( «La velocidad es» más velocidad); flotar mousePosx = Input.mousePosition.x; flotar mousePosy = Input.mousePosition.y; Vector3 BallInstantiatePoint = _cam.ScreenToWorldPoint (nuevo Vector3 (mousePosx, mousePosy, _cam.nearClipPlane + spawnHelper)); // Esto comprueba si hemos chocado si (colisión && camMoving!) {CameraChar.Move (Vector3.forward * * Time.deltaTime velocidad); // Esto es para que el movimiento de la cámara se acelerará la velocidad = Velocidad + incrementFactor; } Else if (colisión || camMoving!) {CameraChar.Move (Vector3.zero); } If (Input.GetMouseButtonDown (0) && camMoving) {GameObject ballRigid; ballRigid = Instantiate (balón, BallInstantiatePoint, transform.rotation) como GameObject; . BallRigid.GetComponent () AddForce (Vector3.forward * ballForce); }} OnTriggerEnter private void (Colisionador de otra) {if (other.CompareTag ( «cristal»)) {colisión = true; Debug.log ( «chocó contra el vidrio !! Man down !!»); camMoving = false; button.SetActive (true); }} Public void StartCam () {camMoving = camMoving!; } Public void Reset () {SceneManager.LoadScene ( «Escena1»); }} 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingUnityEngine.SceneManagement; usingUnityEngine.UI; publicclassCameraCharacter: MonoBehaviour {publicfloatspeed = 1; publicfloatincrementFactor = 0.02f; publicfloatspawnHelper = 4.5fy; publicGameObject bola; publicfloatballForce = 700; botón publicGameObject; // utilizamos esto cuando ponemos en práctica UIpublicstaticboolcamMoving = false; privateCharacterController cameraChar; // Un booleano cuyo valor será determinado por OnTriggerEnterprivateboolcollision = false; _cam privateCamera; // Usar esto para initializationvoidStart () {cameraChar = gameObject.GetComponent ( ); _ leva = getComponent ();} // actualización se llama una vez por framevoidUpdate () {debug.log ( «La velocidad es» más velocidad); floatmousePosx = Input.mousePosition.x; floatmousePosy = Input.mousePosition.y ; Vector3 BallInstantiatePoint = _cam.Scre enToWorldPoint (newVector3 (mousePosx, mousePosy, _cam.nearClipPlane + spawnHelper)); // Esto comprueba si tenemos collidedif (colisión && camMoving!) {cameraChar.Move (Vector3.forward * * Time.deltaTime velocidad); // Esto es así que el movimiento de la cámara acelerará la velocidad UPSPEED = + incrementFactor;} elseif (colisión || camMoving!) {cameraChar.Move (Vector3.zero);} if (Input.GetMouseButtonDown (0) && camMoving) {GameObject ballRigid; ballRigid = Instantiate (bola, BallInstantiatePoint, transform.rotation) asGameObject; ballRigid.GetComponent () AddForce (Vector3.forward * ballForce);.}} privatevoidOnTriggerEnter (Colisionador de otra) {if (other.CompareTag ( «cristal»)) {colisión = true; debug.log ( «chocado con vidrio !! Man down !! «); camMoving = false; button.SetActive (true);}} publicvoidStartCam () {camMoving = camMoving;!} PublicvoidReset () {SceneManager.LoadScene (» Escena1″ );}}

    Hay mucho aquí que no vamos a utilizar en este tutorial. Pero, el método de notificación “OnTriggerEnter” comprobará si el objeto del juego solapado posee la etiqueta “cristal”. probablemente sepa qué hacer, vamos a tu casa prefabricada vidrio, < / p>


    crear una nueva etiqueta llamada “cristal”,


    y después asignarlo a su casa prefabricada de vidrio.


    La idea del colisionador de la cámara es que si el jugador no romper el vidrio delante de él, el juego se debe reiniciar o algo así. Ahora, aquí es donde, el diseñador del juego, llega a tomar una decisión: qué se asigna esta etiqueta a su “Glass (roto)” casas prefabricadas (a sabiendas de que si la cámara toca las piezas destrozadas que deje de moverse) o hace ejercicio merced en sus jugadores y hacerles golpear las piezas rotas todo lo que quieren? Tu decides. Además, la cámara tiene que tener un Colisionador de cápsula que es un disparador y un tamaño apropiado (también su decisión sobre el tamaño correcto). Recomiendo hacer el carácter de valores “radio” cerca de cero “altura” del controlador y, en caso contrario, es posible conseguirlo “montar en off” de la parte superior de las piezas rotas.


    Con todas esas cosas, y todo lo ajustado de la manera que les guste, vamos a arrastrar en algunas casas prefabricadas de vidrio y disfrutar de nuestra cámara en movimiento, mientras rompiendo a través de algún vaso!


    Conclusión

    ¡Menos mal! Felicitaciones por el tutorial Sé que no parece como mucho de un juego, pero en la Parte 2 y Parte 3, vamos a añadir shaders a impulsar el potencial de nuestros objetos del juego, un sistema de interfaz de usuario, y otras cosas que, básicamente, hacer que se sienta más como un juego. Hemos hecho la mayor parte del trabajo duro, por lo que no debería tener que hacer mucho más codificación de aquí en adelante. Espero que lo que hemos hecho con la creación de la mecánica en primer lugar, y ver lo que los mecánicos pueden hacer, hará que desea continuar en esta serie de tutoriales. Al final, tendrá un juego completo equipado con un menú y un nivel, todo lo cual le animo a modificar y cambiar a cualquier partido ver que va después. Con esto en mente, te veo en el siguiente tutorial. Como siempre:

    seguir haciendo grande juegos!

    Mensajes relacionados

Deja una respuesta

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